rollup 2.7.2 → 2.7.6

package/dist/shared/index.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.7.2
-	Wed, 22 Apr 2020 19:00:15 GMT - commit 97e6fa89d2ad14603094af77bad461a1aa81df3b
+	Rollup.js v2.7.6
+	Thu, 30 Apr 2020 18:55:10 GMT - commit 468010ba801b1e59573b6aa7319461a449aa43df
 
 
 	https://github.com/rollup/rollup
@@ -11,7 +11,8 @@
 'use strict';
 
 var rollup_js = require('./rollup.js');
-var _util_commonjsExternal = require('./_util_commonjs-external.js');
+var path = require('path');
+var util = require('util');
 var fs = require('fs');
 var events = require('events');
 var stream = require('stream');
@@ -556,7 +557,7 @@ const toRegex = (start, end, options) => {
 };
 
 const rangeError = (...args) => {
-  return new RangeError('Invalid range arguments: ' + _util_commonjsExternal.require$$1.inspect(...args));
+  return new RangeError('Invalid range arguments: ' + util.inspect(...args));
 };
 
 const invalidRange = (start, end, options) => {
@@ -1552,7 +1553,7 @@ var constants$1 = {
   CHAR_VERTICAL_LINE: 124, /* | */
   CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
 
-  SEP: _util_commonjsExternal.sysPath.sep,
+  SEP: path.sep,
 
   /**
    * Create EXTGLOB_CHARS
@@ -1612,7 +1613,7 @@ exports.isWindows = options => {
   if (options && typeof options.windows === 'boolean') {
     return options.windows;
   }
-  return win32 === true || _util_commonjsExternal.sysPath.sep === '\\';
+  return win32 === true || path.sep === '\\';
 };
 
 exports.escapeLast = (input, char, lastIdx) => {
@@ -3246,7 +3247,7 @@ picomatch.test = (input, regex, options, { glob, posix } = {}) => {
 
 picomatch.matchBase = (input, glob, options, posix = utils$1.isWindows(options)) => {
   const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
-  return regex.test(_util_commonjsExternal.sysPath.basename(input));
+  return regex.test(path.basename(input));
 };
 
 /**
@@ -3428,12 +3429,13 @@ var picomatch$1 = picomatch_1;
 
 const { Readable } = stream;
 
-const { promisify } = _util_commonjsExternal.require$$1;
+const { promisify } = util;
 
 
 const readdir = promisify(fs.readdir);
 const stat = promisify(fs.stat);
 const lstat = promisify(fs.lstat);
+const realpath = promisify(fs.realpath);
 
 /**
  * @typedef {Object} EntryInfo
@@ -3525,17 +3527,13 @@ class ReaddirpStream extends Readable {
     this._wantsDir = [DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
     this._wantsFile = [FILE_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
     this._wantsEverything = type === EVERYTHING_TYPE;
-    this._root = _util_commonjsExternal.sysPath.resolve(root);
+    this._root = path.resolve(root);
     this._isDirent = ('Dirent' in fs) && !opts.alwaysStat;
     this._statsProp = this._isDirent ? 'dirent' : 'stats';
     this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };
 
     // Launch stream with one parent, the root dir.
-    try {
-      this.parents = [this._exploreDir(root, 1)];
-    } catch (error) {
-      this.destroy(error);
-    }
+    this.parents = [this._exploreDir(root, 1)];
     this.reading = false;
     this.parent = undefined;
   }
@@ -3551,7 +3549,10 @@ class ReaddirpStream extends Readable {
         if (files.length > 0) {
           const slice = files.splice(0, batch).map(dirent => this._formatEntry(dirent, path));
           for (const entry of await Promise.all(slice)) {
-            if (this._isDirAndMatchesFilter(entry)) {
+            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));
               }
@@ -3560,7 +3561,7 @@ class ReaddirpStream extends Readable {
                 this.push(entry);
                 batch--;
               }
-            } else if (this._isFileAndMatchesFilter(entry)) {
+            } else if ((entryType === 'file' || this._includeAsFile(entry)) && this._fileFilter(entry)) {
               if (this._wantsFile) {
                 this.push(entry);
                 batch--;
@@ -3574,6 +3575,7 @@ class ReaddirpStream extends Readable {
             break;
           }
           this.parent = await parent;
+          if (this.destroyed) return;
         }
       }
     } catch (error) {
@@ -3593,11 +3595,12 @@ class ReaddirpStream extends Readable {
     return {files, depth, path};
   }
 
-  async _formatEntry(dirent, path) {
-    const basename = this._isDirent ? dirent.name : dirent;
-    const fullPath = _util_commonjsExternal.sysPath.resolve(_util_commonjsExternal.sysPath.join(path, basename));
-    const entry = {path: _util_commonjsExternal.sysPath.relative(this._root, fullPath), fullPath, basename};
+  async _formatEntry(dirent, path$1) {
+    let entry;
     try {
+      const basename = this._isDirent ? dirent.name : dirent;
+      const fullPath = path.resolve(path.join(path$1, basename));
+      entry = {path: path.relative(this._root, fullPath), fullPath, basename};
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -3609,24 +3612,43 @@ class ReaddirpStream extends Readable {
     if (isNormalFlowError(err) && !this.destroyed) {
       this.emit('warn', err);
     } else {
-      throw err;
+      this.destroy(err);
     }
   }
 
-  _isDirAndMatchesFilter(entry) {
+  async _getEntryType(entry) {
     // entry may be undefined, because a warning or an error were emitted
     // and the statsProp is undefined
     const stats = entry && entry[this._statsProp];
-    return stats && stats.isDirectory() && this._directoryFilter(entry);
+    if (!stats) {
+      return;
+    }
+    if (stats.isFile()) {
+      return 'file';
+    }
+    if (stats.isDirectory()) {
+      return 'directory';
+    }
+    if (stats && stats.isSymbolicLink()) {
+      try {
+        const entryRealPath = await realpath(entry.fullPath);
+        const entryRealPathStats = await lstat(entryRealPath);
+        if (entryRealPathStats.isFile()) {
+          return 'file';
+        }
+        if (entryRealPathStats.isDirectory()) {
+          return 'directory';
+        }
+      } catch (error) {
+        this._onError(error);
+      }
+    }
   }
 
-  _isFileAndMatchesFilter(entry) {
+  _includeAsFile(entry) {
     const stats = entry && entry[this._statsProp];
-    const isFileType = stats && (
-      (this._wantsEverything && !stats.isDirectory()) ||
-      (stats.isFile() || stats.isSymbolicLink())
-    );
-    return isFileType && this._fileFilter(entry);
+
+    return stats && this._wantsEverything && !stats.isDirectory();
   }
 }
 
@@ -3890,7 +3912,7 @@ var isGlob = function isGlob(str, options) {
   return false;
 };
 
-var pathPosixDirname = _util_commonjsExternal.sysPath.posix.dirname;
+var pathPosixDirname = path.posix.dirname;
 var isWin32 = os.platform() === 'win32';
 
 var slash = '/';
@@ -4193,11 +4215,11 @@ var binaryExtensions$2 = require$$0;
 
 const extensions = new Set(binaryExtensions$2);
 
-var isBinaryPath = filePath => extensions.has(_util_commonjsExternal.sysPath.extname(filePath).slice(1).toLowerCase());
+var isBinaryPath = filePath => extensions.has(path.extname(filePath).slice(1).toLowerCase());
 
 var constants$2 = rollup_js.createCommonjsModule(function (module, exports) {
 
-const {sep} = _util_commonjsExternal.sysPath;
+const {sep} = path;
 const {platform} = process;
 
 exports.EV_ALL = 'all';
@@ -4220,6 +4242,7 @@ exports.FSEVENT_DELETED = 'deleted';
 exports.FSEVENT_MOVED = 'moved';
 exports.FSEVENT_CLONED = 'cloned';
 exports.FSEVENT_UNKNOWN = 'unknown';
+exports.FSEVENT_TYPE_FILE = 'file';
 exports.FSEVENT_TYPE_DIRECTORY = 'directory';
 exports.FSEVENT_TYPE_SYMLINK = 'symlink';
 
@@ -4257,7 +4280,7 @@ exports.isWindows = platform === 'win32';
 exports.isMacos = platform === 'darwin';
 });
 
-const { promisify: promisify$1 } = _util_commonjsExternal.require$$1;
+const { promisify: promisify$1 } = util;
 
 const {
   isWindows,
@@ -4356,21 +4379,21 @@ const FsWatchInstances = new Map();
  * @param {Function} emitRaw emits raw event data
  * @returns {fs.FSWatcher} new fsevents instance
  */
-function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path$1, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path);
-    emitRaw(rawEvent, evPath, {watchedPath: path});
+    listener(path$1);
+    emitRaw(rawEvent, evPath, {watchedPath: path$1});
 
     // emit based on events occurring for files from a directory's watcher in
     // case the file's watcher misses it (and rely on throttling to de-dupe)
-    if (evPath && path !== evPath) {
+    if (evPath && path$1 !== evPath) {
       fsWatchBroadcast(
-        _util_commonjsExternal.sysPath.resolve(path, evPath), KEY_LISTENERS, _util_commonjsExternal.sysPath.join(path, evPath)
+        path.resolve(path$1, evPath), KEY_LISTENERS, path.join(path$1, evPath)
       );
     }
   };
   try {
-    return fs.watch(path, options, handleEvent);
+    return fs.watch(path$1, options, handleEvent);
   } catch (error) {
     errHandler(error);
   }
@@ -4553,13 +4576,13 @@ constructor(fsW) {
  * @param {Function} listener on fs change
  * @returns {Function} closer for the watcher instance
  */
-_watchWithNodeFs(path, listener) {
+_watchWithNodeFs(path$1, listener) {
   const opts = this.fsw.options;
-  const directory = _util_commonjsExternal.sysPath.dirname(path);
-  const basename = _util_commonjsExternal.sysPath.basename(path);
+  const directory = path.dirname(path$1);
+  const basename = path.basename(path$1);
   const parent = this.fsw._getWatchedDir(directory);
   parent.add(basename);
-  const absolutePath = _util_commonjsExternal.sysPath.resolve(path);
+  const absolutePath = path.resolve(path$1);
   const options = {persistent: opts.persistent};
   if (!listener) listener = EMPTY_FN;
 
@@ -4567,12 +4590,12 @@ _watchWithNodeFs(path, listener) {
   if (opts.usePolling) {
     options.interval = opts.enableBinaryInterval && isBinaryPath(basename) ?
       opts.binaryInterval : opts.interval;
-    closer = setFsWatchFileListener(path, absolutePath, options, {
+    closer = setFsWatchFileListener(path$1, absolutePath, options, {
       listener,
       rawEmitter: this.fsw._emitRaw
     });
   } else {
-    closer = setFsWatchListener(path, absolutePath, options, {
+    closer = setFsWatchListener(path$1, absolutePath, options, {
       listener,
       errHandler: this._boundHandleError,
       rawEmitter: this.fsw._emitRaw
@@ -4592,8 +4615,8 @@ _handleFile(file, stats, initialAdd) {
   if (this.fsw.closed) {
     return;
   }
-  const dirname = _util_commonjsExternal.sysPath.dirname(file);
-  const basename = _util_commonjsExternal.sysPath.basename(file);
+  const dirname = path.dirname(file);
+  const basename = path.basename(file);
   const parent = this.fsw._getWatchedDir(dirname);
   // stats is always present
   let prevStats = stats;
@@ -4684,7 +4707,7 @@ async _handleSymlink(entry, directory, path, item) {
 
 _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
   // Normalize the directory name on Windows
-  directory = _util_commonjsExternal.sysPath.join(directory, EMPTY_STR);
+  directory = path.join(directory, EMPTY_STR);
 
   if (!wh.hasGlob) {
     throttler = this.fsw._throttle('readdir', directory, 1000);
@@ -4704,10 +4727,10 @@ _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
       return;
     }
     const item = entry.path;
-    let path = _util_commonjsExternal.sysPath.join(directory, item);
+    let path$1 = path.join(directory, item);
     current.add(item);
 
-    if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
+    if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path$1, item)) {
       return;
     }
 
@@ -4722,9 +4745,9 @@ _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
       this.fsw._incrReadyCount();
 
       // ensure relativeness of path is preserved in case of watcher reuse
-      path = _util_commonjsExternal.sysPath.join(dir, _util_commonjsExternal.sysPath.relative(dir, path));
+      path$1 = path.join(dir, path.relative(dir, path$1));
 
-      this._addToNodeFs(path, initialAdd, wh, depth + 1);
+      this._addToNodeFs(path$1, initialAdd, wh, depth + 1);
     }
   }).on(EV_ERROR, this._boundHandleError);
 
@@ -4748,7 +4771,7 @@ _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
           // a path may have been filtered out of this readdir, but
           // shouldn't be removed because it matches a different glob
           (!wh.hasGlob || wh.filterPath({
-            fullPath: _util_commonjsExternal.sysPath.resolve(directory, item)
+            fullPath: path.resolve(directory, item)
           }));
       }).forEach((item) => {
         this.fsw._remove(directory, item);
@@ -4774,14 +4797,14 @@ _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
  * @returns {Promise<Function>} closer for the watcher instance.
  */
 async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
-  const parentDir = this.fsw._getWatchedDir(_util_commonjsExternal.sysPath.dirname(dir));
-  const tracked = parentDir.has(_util_commonjsExternal.sysPath.basename(dir));
+  const parentDir = this.fsw._getWatchedDir(path.dirname(dir));
+  const tracked = parentDir.has(path.basename(dir));
   if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
     if (!wh.hasGlob || wh.globFilter(dir)) this.fsw._emit(EV_ADD_DIR, dir, stats);
   }
 
   // ensure dir is tracked (harmless if redundant)
-  parentDir.add(_util_commonjsExternal.sysPath.basename(dir));
+  parentDir.add(path.basename(dir));
   this.fsw._getWatchedDir(dir);
   let throttler;
   let closer;
@@ -4813,14 +4836,14 @@ async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
  * @param {String=} target Child path actually targeted for watch
  * @returns {Promise}
  */
-async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+async _addToNodeFs(path$1, initialAdd, priorWh, depth, target) {
   const ready = this.fsw._emitReady;
-  if (this.fsw._isIgnored(path) || this.fsw.closed) {
+  if (this.fsw._isIgnored(path$1) || this.fsw.closed) {
     ready();
     return false;
   }
 
-  const wh = this.fsw._getWatchHelpers(path, depth);
+  const wh = this.fsw._getWatchHelpers(path$1, depth);
   if (!wh.hasGlob && priorWh) {
     wh.hasGlob = priorWh.hasGlob;
     wh.globFilter = priorWh.globFilter;
@@ -4837,42 +4860,42 @@ async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
       return false;
     }
 
-    const follow = this.fsw.options.followSymlinks && !path.includes(STAR$1) && !path.includes(BRACE_START);
+    const follow = this.fsw.options.followSymlinks && !path$1.includes(STAR$1) && !path$1.includes(BRACE_START);
     let closer;
     if (stats.isDirectory()) {
-      const targetPath = follow ? await fsrealpath(path) : path;
+      const targetPath = follow ? await fsrealpath(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;
       // preserve this symlink's target path
-      if (path !== targetPath && targetPath !== undefined) {
+      if (path$1 !== targetPath && targetPath !== undefined) {
         this.fsw._symlinkPaths.set(targetPath, true);
       }
     } else if (stats.isSymbolicLink()) {
-      const targetPath = follow ? await fsrealpath(path) : path;
+      const targetPath = follow ? await fsrealpath(path$1) : path$1;
       if (this.fsw.closed) return;
-      const parent = _util_commonjsExternal.sysPath.dirname(wh.watchPath);
+      const parent = path.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, wh, targetPath);
+      closer = await this._handleDir(parent, stats, initialAdd, depth, path$1, wh, targetPath);
       if (this.fsw.closed) return;
 
       // preserve this symlink's target path
       if (targetPath !== undefined) {
-        this.fsw._symlinkPaths.set(_util_commonjsExternal.sysPath.resolve(path), targetPath);
+        this.fsw._symlinkPaths.set(path.resolve(path$1), targetPath);
       }
     } else {
       closer = this._handleFile(wh.watchPath, stats, initialAdd);
     }
     ready();
 
-    this.fsw._addPathCloser(path, closer);
+    this.fsw._addPathCloser(path$1, closer);
     return false;
 
   } catch (error) {
     if (this.fsw._handleError(error)) {
       ready();
-      return path;
+      return path$1;
     }
   }
 }
@@ -4883,7 +4906,7 @@ var nodefsHandler = NodeFsHandler;
 
 var require$$1 = rollup_js.getCjsExportFromNamespace(rollup_js.fseventsImporter);
 
-const { promisify: promisify$2 } = _util_commonjsExternal.require$$1;
+const { promisify: promisify$2 } = util;
 
 let fsevents;
 try {
@@ -4918,6 +4941,7 @@ const {
   FSEVENT_MOVED,
   // FSEVENT_CLONED,
   FSEVENT_UNKNOWN,
+  FSEVENT_TYPE_FILE,
   FSEVENT_TYPE_DIRECTORY,
   FSEVENT_TYPE_SYMLINK,
 
@@ -4928,15 +4952,12 @@ const {
   EMPTY_FN: EMPTY_FN$1,
   IDENTITY_FN
 } = constants$2;
-const FS_MODE_READ = 'r';
 
 const Depth = (value) => isNaN(value) ? {} : {depth: value};
 
 const stat$2 = promisify$2(fs.stat);
-const open$1 = promisify$2(fs.open);
-const close$1 = promisify$2(fs.close);
 const lstat$2 = promisify$2(fs.lstat);
-const realpath = promisify$2(fs.realpath);
+const realpath$1 = promisify$2(fs.realpath);
 
 const statMethods$1 = { stat: stat$2, lstat: lstat$2 };
 
@@ -4986,9 +5007,9 @@ const createFSEventsInstance = (path, callback) => {
  * @param {Function} rawEmitter - passes data to listeners of the 'raw' event
  * @returns {Function} closer
  */
-function setFSEventsListener(path, realPath, listener, rawEmitter, fsw) {
-  let watchPath = _util_commonjsExternal.sysPath.extname(path) ? _util_commonjsExternal.sysPath.dirname(path) : path;
-  const parentPath = _util_commonjsExternal.sysPath.dirname(watchPath);
+function setFSEventsListener(path$1, realPath, listener, rawEmitter, fsw) {
+  let watchPath = path.extname(path$1) ? path.dirname(path$1) : path$1;
+  const parentPath = path.dirname(watchPath);
   let cont = FSEventsWatchers.get(watchPath);
 
   // If we've accumulated a substantial number of paths that
@@ -4999,14 +5020,14 @@ function setFSEventsListener(path, realPath, listener, rawEmitter, fsw) {
     watchPath = parentPath;
   }
 
-  const resolvedPath = _util_commonjsExternal.sysPath.resolve(path);
+  const resolvedPath = path.resolve(path$1);
   const hasSymlink = resolvedPath !== realPath;
 
   const filteredListener = (fullPath, flags, info) => {
     if (hasSymlink) fullPath = fullPath.replace(realPath, resolvedPath);
     if (
       fullPath === resolvedPath ||
-      !fullPath.indexOf(resolvedPath + _util_commonjsExternal.sysPath.sep)
+      !fullPath.indexOf(resolvedPath + path.sep)
     ) listener(fullPath, flags, info);
   };
 
@@ -5014,7 +5035,7 @@ function setFSEventsListener(path, realPath, listener, rawEmitter, fsw) {
   // modifies `watchPath` to the parent path when it finds a match
   let watchedParent = false;
   for (const watchedPath of FSEventsWatchers.keys()) {
-    if (realPath.indexOf(_util_commonjsExternal.sysPath.resolve(watchedPath) + _util_commonjsExternal.sysPath.sep) === 0) {
+    if (realPath.indexOf(path.resolve(watchedPath) + path.sep) === 0) {
       watchPath = watchedPath;
       cont = FSEventsWatchers.get(watchPath);
       watchedParent = true;
@@ -5077,12 +5098,20 @@ const couldConsolidate = (path) => {
 const canUse = () => fsevents && FSEventsWatchers.size < 128;
 
 // determines subdirectory traversal levels from root to path
-const calcDepth = (path, root) => {
+const calcDepth = (path$1, root) => {
   let i = 0;
-  while (!path.indexOf(root) && (path = _util_commonjsExternal.sysPath.dirname(path)) !== root) i++;
+  while (!path$1.indexOf(root) && (path$1 = path.dirname(path$1)) !== root) i++;
   return i;
 };
 
+// returns boolean indicating whether the fsevents' event info has the same type
+// as the one returned by fs.stat
+const sameTypes = (info, stats) => (
+  info.type === FSEVENT_TYPE_DIRECTORY && stats.isDirectory() ||
+  info.type === FSEVENT_TYPE_SYMLINK && stats.isSymbolicLink() ||
+  info.type === FSEVENT_TYPE_FILE && stats.isFile()
+);
+
 /**
  * @mixin
  */
@@ -5113,13 +5142,16 @@ addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
   this.handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts);
 }
 
-async checkFd(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
+async checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
   try {
-    const fd = await open$1(path, FS_MODE_READ);
+    const stats = await stat$2(path);
     if (this.fsw.closed) return;
-    await close$1(fd);
     if (this.fsw.closed) return;
-    this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+    if (sameTypes(info, stats)) {
+      this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+    } else {
+      this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+    }
   } catch (error) {
     if (error.code === 'EACCES') {
       this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
@@ -5133,9 +5165,10 @@ handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opt
   if (this.fsw.closed || this.checkIgnored(path)) return;
 
   if (event === EV_UNLINK) {
+    const isDirectory = info.type === FSEVENT_TYPE_DIRECTORY;
     // suppress unlink events on never before seen files
-    if (info.type === FSEVENT_TYPE_DIRECTORY || watchedDir.has(item)) {
-      this.fsw._remove(parent, item);
+    if (isDirectory || watchedDir.has(item)) {
+      this.fsw._remove(parent, item, isDirectory);
     }
   } else {
     if (event === EV_ADD$1) {
@@ -5180,15 +5213,15 @@ _watchWithFsEvents(watchPath, realPath, transform, globFilter) {
       opts.depth !== undefined &&
       calcDepth(fullPath, realPath) > opts.depth
     ) return;
-    const path = transform(_util_commonjsExternal.sysPath.join(
-      watchPath, _util_commonjsExternal.sysPath.relative(watchPath, fullPath)
+    const path$1 = transform(path.join(
+      watchPath, path.relative(watchPath, fullPath)
     ));
-    if (globFilter && !globFilter(path)) return;
+    if (globFilter && !globFilter(path$1)) return;
     // ensure directories are tracked
-    const parent = _util_commonjsExternal.sysPath.dirname(path);
-    const item = _util_commonjsExternal.sysPath.basename(path);
+    const parent = path.dirname(path$1);
+    const item = path.basename(path$1);
     const watchedDir = this.fsw._getWatchedDir(
-      info.type === FSEVENT_TYPE_DIRECTORY ? path : parent
+      info.type === FSEVENT_TYPE_DIRECTORY ? path$1 : parent
     );
 
     // correct for wrong events emitted
@@ -5196,26 +5229,26 @@ _watchWithFsEvents(watchPath, realPath, transform, globFilter) {
       if (typeof opts.ignored === FUNCTION_TYPE) {
         let stats;
         try {
-          stats = await stat$2(path);
+          stats = await stat$2(path$1);
         } catch (error) {}
         if (this.fsw.closed) return;
-        if (this.checkIgnored(path, stats)) return;
-        if (stats) {
-          this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+        if (this.checkIgnored(path$1, stats)) return;
+        if (sameTypes(info, stats)) {
+          this.addOrChange(path$1, fullPath, realPath, parent, watchedDir, item, info, opts);
         } else {
-          this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+          this.handleEvent(EV_UNLINK, path$1, fullPath, realPath, parent, watchedDir, item, info, opts);
         }
       } else {
-        this.checkFd(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+        this.checkExists(path$1, fullPath, realPath, parent, watchedDir, item, info, opts);
       }
     } else {
       switch (info.event) {
       case FSEVENT_CREATED:
       case FSEVENT_MODIFIED:
-        return this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+        return this.addOrChange(path$1, fullPath, realPath, parent, watchedDir, item, info, opts);
       case FSEVENT_DELETED:
       case FSEVENT_MOVED:
-        return this.checkFd(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+        return this.checkExists(path$1, fullPath, realPath, parent, watchedDir, item, info, opts);
       }
     }
   };
@@ -5248,7 +5281,7 @@ async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
   this.fsw._incrReadyCount();
 
   try {
-    const linkTarget = await realpath(linkPath);
+    const linkTarget = await realpath$1(linkPath);
     if (this.fsw.closed) return;
     if (this.fsw._isIgnored(linkTarget)) {
       return this.fsw._emitReady();
@@ -5258,12 +5291,12 @@ async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
 
     // add the linkTarget for watching with a wrapper for transform
     // that causes emitted paths to incorporate the link's path
-    this._addToFsEvents(linkTarget || linkPath, (path) => {
+    this._addToFsEvents(linkTarget || linkPath, (path$1) => {
       let aliasedPath = linkPath;
       if (linkTarget && linkTarget !== DOT_SLASH) {
-        aliasedPath = path.replace(linkTarget, linkPath);
-      } else if (path !== DOT_SLASH) {
-        aliasedPath = _util_commonjsExternal.sysPath.join(linkPath, path);
+        aliasedPath = path$1.replace(linkTarget, linkPath);
+      } else if (path$1 !== DOT_SLASH) {
+        aliasedPath = path.join(linkPath, path$1);
       }
       return transform(aliasedPath);
     }, false, curDepth);
@@ -5282,8 +5315,8 @@ async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
 emitAdd(newPath, stats, processPath, opts, forceAdd) {
   const pp = processPath(newPath);
   const isDir = stats.isDirectory();
-  const dirObj = this.fsw._getWatchedDir(_util_commonjsExternal.sysPath.dirname(pp));
-  const base = _util_commonjsExternal.sysPath.basename(pp);
+  const dirObj = this.fsw._getWatchedDir(path.dirname(pp));
+  const base = path.basename(pp);
 
   // ensure empty dirs get tracked
   if (isDir) this.fsw._getWatchedDir(pp);
@@ -5295,15 +5328,15 @@ emitAdd(newPath, stats, processPath, opts, forceAdd) {
   }
 }
 
-initWatch(realPath, path, wh, processPath) {
+initWatch(realPath, path$1, wh, processPath) {
   if (this.fsw.closed) return;
   const closer = this._watchWithFsEvents(
     wh.watchPath,
-    _util_commonjsExternal.sysPath.resolve(realPath || wh.watchPath),
+    path.resolve(realPath || wh.watchPath),
     processPath,
     wh.globFilter
   );
-  this.fsw._addPathCloser(path, closer);
+  this.fsw._addPathCloser(path$1, closer);
 }
 
 /**
@@ -5314,14 +5347,14 @@ initWatch(realPath, path, wh, processPath) {
  * @param {Number=} priorDepth Level of subdirectories already traversed.
  * @returns {Promise<void>}
  */
-async _addToFsEvents(path, transform, forceAdd, priorDepth) {
+async _addToFsEvents(path$1, transform, forceAdd, priorDepth) {
   if (this.fsw.closed) {
     return;
   }
   const opts = this.fsw.options;
   const processPath = typeof transform === FUNCTION_TYPE ? transform : IDENTITY_FN;
 
-  const wh = this.fsw._getWatchHelpers(path);
+  const wh = this.fsw._getWatchHelpers(path$1);
 
   // evaluate what is at the path we're being asked to watch
   try {
@@ -5332,7 +5365,7 @@ async _addToFsEvents(path, transform, forceAdd, priorDepth) {
     }
     if (stats.isDirectory()) {
       // emit addDir unless this is a glob parent
-      if (!wh.globFilter) this.emitAdd(processPath(path), stats, processPath, opts, forceAdd);
+      if (!wh.globFilter) this.emitAdd(processPath(path$1), stats, processPath, opts, forceAdd);
 
       // don't recurse further if it would exceed depth setting
       if (priorDepth && priorDepth > opts.depth) return;
@@ -5349,14 +5382,14 @@ async _addToFsEvents(path, transform, forceAdd, priorDepth) {
         }
         if (entry.stats.isDirectory() && !wh.filterPath(entry)) return;
 
-        const joinedPath = _util_commonjsExternal.sysPath.join(wh.watchPath, entry.path);
+        const joinedPath = path.join(wh.watchPath, entry.path);
         const {fullPath} = entry;
 
         if (wh.followSymlinks && entry.stats.isSymbolicLink()) {
           // preserve the current depth here since it can't be derived from
           // real paths past the symlink
           const curDepth = opts.depth === undefined ?
-            undefined : calcDepth(joinedPath, _util_commonjsExternal.sysPath.resolve(wh.watchPath)) + 1;
+            undefined : calcDepth(joinedPath, path.resolve(wh.watchPath)) + 1;
 
           this._handleFsEventsSymlink(joinedPath, fullPath, processPath, curDepth);
         } else {
@@ -5380,13 +5413,13 @@ async _addToFsEvents(path, transform, forceAdd, priorDepth) {
   if (opts.persistent && forceAdd !== true) {
     if (typeof transform === FUNCTION_TYPE) {
       // realpath has already been resolved
-      this.initWatch(undefined, path, wh, processPath);
+      this.initWatch(undefined, path$1, wh, processPath);
     } else {
       let realPath;
       try {
-        realPath = await realpath(wh.watchPath);
+        realPath = await realpath$1(wh.watchPath);
       } catch (e) {}
-      this.initWatch(realPath, path, wh, processPath);
+      this.initWatch(realPath, path$1, wh, processPath);
     }
   }
 }
@@ -5400,7 +5433,7 @@ fseventsHandler.canUse = canUse_1;
 const { EventEmitter } = events;
 
 
-const { promisify: promisify$3 } = _util_commonjsExternal.require$$1;
+const { promisify: promisify$3 } = util;
 
 const anymatch = anymatch_1.default;
 
@@ -5503,21 +5536,21 @@ const toUnix = (string) => {
 
 // Our version of upath.normalize
 // TODO: this is not equal to path-normalize module - investigate why
-const normalizePathToUnix = (path) => toUnix(_util_commonjsExternal.sysPath.normalize(toUnix(path)));
+const normalizePathToUnix = (path$1) => toUnix(path.normalize(toUnix(path$1)));
 
-const normalizeIgnored = (cwd = EMPTY_STR$1) => (path) => {
-  if (typeof path !== STRING_TYPE) return path;
-  return normalizePathToUnix(_util_commonjsExternal.sysPath.isAbsolute(path) ? path : _util_commonjsExternal.sysPath.join(cwd, path));
+const normalizeIgnored = (cwd = EMPTY_STR$1) => (path$1) => {
+  if (typeof path$1 !== STRING_TYPE) return path$1;
+  return normalizePathToUnix(path.isAbsolute(path$1) ? path$1 : path.join(cwd, path$1));
 };
 
-const getAbsolutePath = (path, cwd) => {
-  if (_util_commonjsExternal.sysPath.isAbsolute(path)) {
-    return path;
+const getAbsolutePath = (path$1, cwd) => {
+  if (path.isAbsolute(path$1)) {
+    return path$1;
   }
-  if (path.startsWith(BANG$1)) {
-    return BANG$1 + _util_commonjsExternal.sysPath.join(cwd, path.slice(1));
+  if (path$1.startsWith(BANG$1)) {
+    return BANG$1 + path.join(cwd, path$1.slice(1));
   }
-  return _util_commonjsExternal.sysPath.join(cwd, path);
+  return path.join(cwd, path$1);
 };
 
 const undef = (opts, key) => opts[key] === undefined;
@@ -5549,13 +5582,14 @@ class DirEntry {
     const {items} = this;
     if (!items) return;
     items.delete(item);
+    if (items.size > 0) return;
 
-    if (!items.size) {
-      const dir = this.path;
-      try {
-        await readdir$1(dir);
-      } catch (err) {
-        this._removeWatcher(_util_commonjsExternal.sysPath.dirname(dir), _util_commonjsExternal.sysPath.basename(dir));
+    const dir = this.path;
+    try {
+      await readdir$1(dir);
+    } catch (err) {
+      if (this._removeWatcher) {
+        this._removeWatcher(path.dirname(dir), path.basename(dir));
       }
     }
   }
@@ -5587,17 +5621,17 @@ class DirEntry {
 const STAT_METHOD_F = 'stat';
 const STAT_METHOD_L = 'lstat';
 class WatchHelper {
-  constructor(path, watchPath, follow, fsw) {
+  constructor(path$1, watchPath, follow, fsw) {
     this.fsw = fsw;
-    this.path = path = path.replace(REPLACER_RE, EMPTY_STR$1);
+    this.path = path$1 = path$1.replace(REPLACER_RE, EMPTY_STR$1);
     this.watchPath = watchPath;
-    this.fullWatchPath = _util_commonjsExternal.sysPath.resolve(watchPath);
-    this.hasGlob = watchPath !== path;
+    this.fullWatchPath = path.resolve(watchPath);
+    this.hasGlob = watchPath !== path$1;
     /** @type {object|boolean} */
-    if (path === EMPTY_STR$1) this.hasGlob = false;
+    if (path$1 === EMPTY_STR$1) this.hasGlob = false;
     this.globSymlink = this.hasGlob && follow ? undefined : false;
-    this.globFilter = this.hasGlob ? anymatch(path, undefined, ANYMATCH_OPTS) : false;
-    this.dirParts = this.getDirParts(path);
+    this.globFilter = this.hasGlob ? anymatch(path$1, undefined, ANYMATCH_OPTS) : false;
+    this.dirParts = this.getDirParts(path$1);
     this.dirParts.forEach((parts) => {
       if (parts.length > 1) parts.pop();
     });
@@ -5621,8 +5655,8 @@ class WatchHelper {
   }
 
   entryPath(entry) {
-    return _util_commonjsExternal.sysPath.join(this.watchPath,
-      _util_commonjsExternal.sysPath.relative(this.watchPath, this.checkGlobSymlink(entry))
+    return path.join(this.watchPath,
+      path.relative(this.watchPath, this.checkGlobSymlink(entry))
     );
   }
 
@@ -5637,12 +5671,12 @@ class WatchHelper {
       this.fsw._hasReadPermissions(stats);
   }
 
-  getDirParts(path) {
+  getDirParts(path$1) {
     if (!this.hasGlob) return [];
     const parts = [];
-    const expandedPath = path.includes(BRACE_START$1) ? braces_1.expand(path) : [path];
-    expandedPath.forEach((path) => {
-      parts.push(_util_commonjsExternal.sysPath.relative(this.watchPath, path).split(SLASH_OR_BACK_SLASH_RE));
+    const expandedPath = path$1.includes(BRACE_START$1) ? braces_1.expand(path$1) : [path$1];
+    expandedPath.forEach((path$1) => {
+      parts.push(path.relative(this.watchPath, path$1).split(SLASH_OR_BACK_SLASH_RE));
     });
     return parts;
   }
@@ -5835,7 +5869,7 @@ add(paths_, _origAdd, _internal) {
     ).then(results => {
       if (this.closed) return;
       results.filter(item => item).forEach(item => {
-        this.add(_util_commonjsExternal.sysPath.dirname(item), _util_commonjsExternal.sysPath.basename(_origAdd || item));
+        this.add(path.dirname(item), path.basename(_origAdd || item));
       });
     });
   }
@@ -5853,18 +5887,18 @@ unwatch(paths_) {
   const paths = unifyPaths(paths_);
   const {cwd} = this.options;
 
-  paths.forEach((path) => {
+  paths.forEach((path$1) => {
     // convert to absolute path unless relative path already matches
-    if (!_util_commonjsExternal.sysPath.isAbsolute(path) && !this._closers.has(path)) {
-      if (cwd) path = _util_commonjsExternal.sysPath.join(cwd, path);
-      path = _util_commonjsExternal.sysPath.resolve(path);
+    if (!path.isAbsolute(path$1) && !this._closers.has(path$1)) {
+      if (cwd) path$1 = path.join(cwd, path$1);
+      path$1 = path.resolve(path$1);
     }
 
-    this._closePath(path);
+    this._closePath(path$1);
 
-    this._ignoredPaths.add(path);
-    if (this._watched.has(path)) {
-      this._ignoredPaths.add(path + SLASH_GLOBSTAR);
+    this._ignoredPaths.add(path$1);
+    if (this._watched.has(path$1)) {
+      this._ignoredPaths.add(path$1 + SLASH_GLOBSTAR);
     }
 
     // reset the cached userIgnored anymatch fn
@@ -5880,7 +5914,7 @@ unwatch(paths_) {
  * @returns {Promise<void>}.
 */
 close() {
-  if (this.closed) return this;
+  if (this.closed) return this._closePromise;
   this.closed = true;
 
   // Memory management.
@@ -5898,7 +5932,9 @@ close() {
   ['closers', 'watched', 'streams', 'symlinkPaths', 'throttled'].forEach(key => {
     this[`_${key}`].clear();
   });
-  return closers.length ? Promise.all(closers).then(() => undefined) : Promise.resolve();
+
+  this._closePromise = closers.length ? Promise.all(closers).then(() => undefined) : Promise.resolve();
+  return this._closePromise;
 }
 
 /**
@@ -5908,7 +5944,7 @@ close() {
 getWatched() {
   const watchList = {};
   this._watched.forEach((entry, dir) => {
-    const key = this.options.cwd ? _util_commonjsExternal.sysPath.relative(this.options.cwd, dir) : dir;
+    const key = this.options.cwd ? path.relative(this.options.cwd, dir) : dir;
     watchList[key || ONE_DOT] = entry.getChildren().sort();
   });
   return watchList;
@@ -5932,28 +5968,28 @@ emitWithAll(event, args) {
  * @param {*=} val3
  * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
  */
-async _emit(event, path, val1, val2, val3) {
+async _emit(event, path$1, val1, val2, val3) {
   if (this.closed) return;
 
   const opts = this.options;
-  if (isWindows$1) path = _util_commonjsExternal.sysPath.normalize(path);
-  if (opts.cwd) path = _util_commonjsExternal.sysPath.relative(opts.cwd, path);
+  if (isWindows$1) path$1 = path.normalize(path$1);
+  if (opts.cwd) path$1 = path.relative(opts.cwd, path$1);
   /** @type Array<any> */
-  const args = [event, path];
+  const args = [event, path$1];
   if (val3 !== undefined) args.push(val1, val2, val3);
   else if (val2 !== undefined) args.push(val1, val2);
   else if (val1 !== undefined) args.push(val1);
 
   const awf = opts.awaitWriteFinish;
   let pw;
-  if (awf && (pw = this._pendingWrites.get(path))) {
+  if (awf && (pw = this._pendingWrites.get(path$1))) {
     pw.lastChange = new Date();
     return this;
   }
 
   if (opts.atomic) {
     if (event === EV_UNLINK$1) {
-      this._pendingUnlinks.set(path, args);
+      this._pendingUnlinks.set(path$1, args);
       setTimeout(() => {
         this._pendingUnlinks.forEach((entry, path) => {
           this.emit(...entry);
@@ -5963,9 +5999,9 @@ async _emit(event, path, val1, val2, val3) {
       }, typeof opts.atomic === 'number' ? opts.atomic : 100);
       return this;
     }
-    if (event === EV_ADD$2 && this._pendingUnlinks.has(path)) {
+    if (event === EV_ADD$2 && this._pendingUnlinks.has(path$1)) {
       event = args[0] = EV_CHANGE$2;
-      this._pendingUnlinks.delete(path);
+      this._pendingUnlinks.delete(path$1);
     }
   }
 
@@ -5986,29 +6022,28 @@ async _emit(event, path, val1, val2, val3) {
       }
     };
 
-    this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+    this._awaitWriteFinish(path$1, awf.stabilityThreshold, event, awfEmit);
     return this;
   }
 
   if (event === EV_CHANGE$2) {
-    const isThrottled = !this._throttle(EV_CHANGE$2, path, 50);
+    const isThrottled = !this._throttle(EV_CHANGE$2, path$1, 50);
     if (isThrottled) return this;
   }
 
   if (opts.alwaysStat && val1 === undefined &&
     (event === EV_ADD$2 || event === EV_ADD_DIR$2 || event === EV_CHANGE$2)
   ) {
-    const fullPath = opts.cwd ? _util_commonjsExternal.sysPath.join(opts.cwd, path) : path;
+    const fullPath = opts.cwd ? path.join(opts.cwd, path$1) : path$1;
+    let stats;
     try {
-      const stats = await stat$3(fullPath);
-      // Suppress event when fs_stat fails, to avoid sending undefined 'stat'
-      if (!stats) return;
-      args.push(stats);
-      this.emitWithAll(event, args);
+      stats = await stat$3(fullPath);
     } catch (err) {}
-  } else {
-    this.emitWithAll(event, args);
+    // Suppress event when fs_stat fails, to avoid sending undefined 'stat'
+    if (!stats || this.closed) return;
+    args.push(stats);
   }
+  this.emitWithAll(event, args);
 
   return this;
 }
@@ -6077,19 +6112,19 @@ _incrReadyCount() {
  * @param {EventName} event
  * @param {Function} awfEmit Callback to be called when ready for event to be emitted.
  */
-_awaitWriteFinish(path, threshold, event, awfEmit) {
+_awaitWriteFinish(path$1, threshold, event, awfEmit) {
   let timeoutHandler;
 
-  let fullPath = path;
-  if (this.options.cwd && !_util_commonjsExternal.sysPath.isAbsolute(path)) {
-    fullPath = _util_commonjsExternal.sysPath.join(this.options.cwd, path);
+  let fullPath = path$1;
+  if (this.options.cwd && !path.isAbsolute(path$1)) {
+    fullPath = path.join(this.options.cwd, path$1);
   }
 
   const now = new Date();
 
   const awaitWriteFinish = (prevStat) => {
     fs.stat(fullPath, (err, curStat) => {
-      if (err || !this._pendingWrites.has(path)) {
+      if (err || !this._pendingWrites.has(path$1)) {
         if (err && err.code !== 'ENOENT') awfEmit(err);
         return;
       }
@@ -6097,13 +6132,13 @@ _awaitWriteFinish(path, threshold, event, awfEmit) {
       const now = Number(new Date());
 
       if (prevStat && curStat.size !== prevStat.size) {
-        this._pendingWrites.get(path).lastChange = now;
+        this._pendingWrites.get(path$1).lastChange = now;
       }
-      const pw = this._pendingWrites.get(path);
+      const pw = this._pendingWrites.get(path$1);
       const df = now - pw.lastChange;
 
       if (df >= threshold) {
-        this._pendingWrites.delete(path);
+        this._pendingWrites.delete(path$1);
         awfEmit(undefined, curStat);
       } else {
         timeoutHandler = setTimeout(
@@ -6115,11 +6150,11 @@ _awaitWriteFinish(path, threshold, event, awfEmit) {
     });
   };
 
-  if (!this._pendingWrites.has(path)) {
-    this._pendingWrites.set(path, {
+  if (!this._pendingWrites.has(path$1)) {
+    this._pendingWrites.set(path$1, {
       lastChange: now,
       cancelWait: () => {
-        this._pendingWrites.delete(path);
+        this._pendingWrites.delete(path$1);
         clearTimeout(timeoutHandler);
         return event;
       }
@@ -6185,7 +6220,7 @@ _getWatchHelpers(path, depth) {
  */
 _getWatchedDir(directory) {
   if (!this._boundRemove) this._boundRemove = this._remove.bind(this);
-  const dir = _util_commonjsExternal.sysPath.resolve(directory);
+  const dir = path.resolve(directory);
   if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
   return this._watched.get(dir);
 }
@@ -6217,17 +6252,19 @@ _hasReadPermissions(stats) {
  * @param {String} item      base path of item/directory
  * @returns {void}
 */
-_remove(directory, item) {
+_remove(directory, item, isDirectory) {
   // if what is being deleted is a directory, get that directory's paths
   // for recursive deleting and cleaning of watched object
   // if it is not a directory, nestedDirectoryChildren will be empty array
-  const path = _util_commonjsExternal.sysPath.join(directory, item);
-  const fullPath = _util_commonjsExternal.sysPath.resolve(path);
-  const isDirectory = this._watched.has(path) || this._watched.has(fullPath);
+  const path$1 = path.join(directory, item);
+  const fullPath = path.resolve(path$1);
+  isDirectory = isDirectory != null
+    ? isDirectory
+    : this._watched.has(path$1) || this._watched.has(fullPath);
 
   // prevent duplicate handling in case of arriving here nearly simultaneously
   // via multiple paths (such as _handleFile and _handleDir)
-  if (!this._throttle('remove', path, 100)) return;
+  if (!this._throttle('remove', path$1, 100)) return;
 
   // if the only watched file is removed, watch for its return
   if (!isDirectory && !this.options.useFsEvents && this._watched.size === 1) {
@@ -6236,11 +6273,11 @@ _remove(directory, item) {
 
   // This will create a new entry in the watched object in either case
   // so we got to do the directory check beforehand
-  const wp = this._getWatchedDir(path);
+  const wp = this._getWatchedDir(path$1);
   const nestedDirectoryChildren = wp.getChildren();
 
   // Recursively remove children directories / files.
-  nestedDirectoryChildren.forEach(nested => this._remove(path, nested));
+  nestedDirectoryChildren.forEach(nested => this._remove(path$1, nested));
 
   // Check if item was on the watched list and remove it
   const parent = this._getWatchedDir(directory);
@@ -6248,8 +6285,8 @@ _remove(directory, item) {
   parent.remove(item);
 
   // If we wait for this file to be fully written, cancel the wait.
-  let relPath = path;
-  if (this.options.cwd) relPath = _util_commonjsExternal.sysPath.relative(this.options.cwd, path);
+  let relPath = path$1;
+  if (this.options.cwd) relPath = path.relative(this.options.cwd, path$1);
   if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
     const event = this._pendingWrites.get(relPath).cancelWait();
     if (event === EV_ADD$2) return;
@@ -6257,14 +6294,14 @@ _remove(directory, item) {
 
   // The Entry will either be a directory that just got removed
   // or a bogus entry to a file, in either case we have to remove it
-  this._watched.delete(path);
+  this._watched.delete(path$1);
   this._watched.delete(fullPath);
   const eventName = isDirectory ? EV_UNLINK_DIR : EV_UNLINK$1;
-  if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
+  if (wasTracked && !this._isIgnored(path$1)) this._emit(eventName, path$1);
 
   // Avoid conflicts if we later create another file with the same name
   if (!this.options.useFsEvents) {
-    this._closePath(path);
+    this._closePath(path$1);
   }
 }
 
@@ -6272,13 +6309,13 @@ _remove(directory, item) {
  *
  * @param {Path} path
  */
-_closePath(path) {
-  const closers = this._closers.get(path);
+_closePath(path$1) {
+  const closers = this._closers.get(path$1);
   if (!closers) return;
   closers.forEach(closer => closer());
-  this._closers.delete(path);
-  const dir = _util_commonjsExternal.sysPath.dirname(path);
-  this._getWatchedDir(dir).remove(_util_commonjsExternal.sysPath.basename(path));
+  this._closers.delete(path$1);
+  const dir = path.dirname(path$1);
+  this._getWatchedDir(dir).remove(path.basename(path$1));
 }
 
 /**
@@ -6337,9 +6374,8 @@ var chokidar = {
 	watch: watch_1
 };
 
-exports.braces = braces_1;
+exports.braces_1 = braces_1;
 exports.chokidar = chokidar;
 exports.picomatch = picomatch$1;
-exports.require$$1 = events;
 exports.utils = utils$1;
 //# sourceMappingURL=index.js.map