@unpackjs/core 1.5.4 → 1.6.0

package/compiled/chokidar/index.js

@@ -0,0 +1,1773 @@
+(() => {
+  "use strict";
+  var __webpack_modules__ = {
+    976: (__unused_webpack_module, exports, __nccwpck_require__) => {
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.NodeFsHandler =
+        exports.EVENTS =
+        exports.isIBMi =
+        exports.isLinux =
+        exports.isMacos =
+        exports.isWindows =
+        exports.IDENTITY_FN =
+        exports.EMPTY_FN =
+        exports.STR_CLOSE =
+        exports.STR_END =
+        exports.STR_DATA =
+          void 0;
+      const fs_1 = __nccwpck_require__(147);
+      const promises_1 = __nccwpck_require__(292);
+      const sysPath = __nccwpck_require__(17);
+      const os_1 = __nccwpck_require__(37);
+      exports.STR_DATA = "data";
+      exports.STR_END = "end";
+      exports.STR_CLOSE = "close";
+      const EMPTY_FN = () => {};
+      exports.EMPTY_FN = EMPTY_FN;
+      const IDENTITY_FN = (val) => val;
+      exports.IDENTITY_FN = IDENTITY_FN;
+      const pl = process.platform;
+      exports.isWindows = pl === "win32";
+      exports.isMacos = pl === "darwin";
+      exports.isLinux = pl === "linux";
+      exports.isIBMi = (0, os_1.type)() === "OS400";
+      exports.EVENTS = {
+        ALL: "all",
+        READY: "ready",
+        ADD: "add",
+        CHANGE: "change",
+        ADD_DIR: "addDir",
+        UNLINK: "unlink",
+        UNLINK_DIR: "unlinkDir",
+        RAW: "raw",
+        ERROR: "error",
+      };
+      const EV = exports.EVENTS;
+      const THROTTLE_MODE_WATCH = "watch";
+      const statMethods = { lstat: promises_1.lstat, stat: promises_1.stat };
+      const KEY_LISTENERS = "listeners";
+      const KEY_ERR = "errHandlers";
+      const KEY_RAW = "rawEmitters";
+      const HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+      const binaryExtensions = new Set([
+        "3dm",
+        "3ds",
+        "3g2",
+        "3gp",
+        "7z",
+        "a",
+        "aac",
+        "adp",
+        "afdesign",
+        "afphoto",
+        "afpub",
+        "ai",
+        "aif",
+        "aiff",
+        "alz",
+        "ape",
+        "apk",
+        "appimage",
+        "ar",
+        "arj",
+        "asf",
+        "au",
+        "avi",
+        "bak",
+        "baml",
+        "bh",
+        "bin",
+        "bk",
+        "bmp",
+        "btif",
+        "bz2",
+        "bzip2",
+        "cab",
+        "caf",
+        "cgm",
+        "class",
+        "cmx",
+        "cpio",
+        "cr2",
+        "cur",
+        "dat",
+        "dcm",
+        "deb",
+        "dex",
+        "djvu",
+        "dll",
+        "dmg",
+        "dng",
+        "doc",
+        "docm",
+        "docx",
+        "dot",
+        "dotm",
+        "dra",
+        "DS_Store",
+        "dsk",
+        "dts",
+        "dtshd",
+        "dvb",
+        "dwg",
+        "dxf",
+        "ecelp4800",
+        "ecelp7470",
+        "ecelp9600",
+        "egg",
+        "eol",
+        "eot",
+        "epub",
+        "exe",
+        "f4v",
+        "fbs",
+        "fh",
+        "fla",
+        "flac",
+        "flatpak",
+        "fli",
+        "flv",
+        "fpx",
+        "fst",
+        "fvt",
+        "g3",
+        "gh",
+        "gif",
+        "graffle",
+        "gz",
+        "gzip",
+        "h261",
+        "h263",
+        "h264",
+        "icns",
+        "ico",
+        "ief",
+        "img",
+        "ipa",
+        "iso",
+        "jar",
+        "jpeg",
+        "jpg",
+        "jpgv",
+        "jpm",
+        "jxr",
+        "key",
+        "ktx",
+        "lha",
+        "lib",
+        "lvp",
+        "lz",
+        "lzh",
+        "lzma",
+        "lzo",
+        "m3u",
+        "m4a",
+        "m4v",
+        "mar",
+        "mdi",
+        "mht",
+        "mid",
+        "midi",
+        "mj2",
+        "mka",
+        "mkv",
+        "mmr",
+        "mng",
+        "mobi",
+        "mov",
+        "movie",
+        "mp3",
+        "mp4",
+        "mp4a",
+        "mpeg",
+        "mpg",
+        "mpga",
+        "mxu",
+        "nef",
+        "npx",
+        "numbers",
+        "nupkg",
+        "o",
+        "odp",
+        "ods",
+        "odt",
+        "oga",
+        "ogg",
+        "ogv",
+        "otf",
+        "ott",
+        "pages",
+        "pbm",
+        "pcx",
+        "pdb",
+        "pdf",
+        "pea",
+        "pgm",
+        "pic",
+        "png",
+        "pnm",
+        "pot",
+        "potm",
+        "potx",
+        "ppa",
+        "ppam",
+        "ppm",
+        "pps",
+        "ppsm",
+        "ppsx",
+        "ppt",
+        "pptm",
+        "pptx",
+        "psd",
+        "pya",
+        "pyc",
+        "pyo",
+        "pyv",
+        "qt",
+        "rar",
+        "ras",
+        "raw",
+        "resources",
+        "rgb",
+        "rip",
+        "rlc",
+        "rmf",
+        "rmvb",
+        "rpm",
+        "rtf",
+        "rz",
+        "s3m",
+        "s7z",
+        "scpt",
+        "sgi",
+        "shar",
+        "snap",
+        "sil",
+        "sketch",
+        "slk",
+        "smv",
+        "snk",
+        "so",
+        "stl",
+        "suo",
+        "sub",
+        "swf",
+        "tar",
+        "tbz",
+        "tbz2",
+        "tga",
+        "tgz",
+        "thmx",
+        "tif",
+        "tiff",
+        "tlz",
+        "ttc",
+        "ttf",
+        "txz",
+        "udf",
+        "uvh",
+        "uvi",
+        "uvm",
+        "uvp",
+        "uvs",
+        "uvu",
+        "viv",
+        "vob",
+        "war",
+        "wav",
+        "wax",
+        "wbmp",
+        "wdp",
+        "weba",
+        "webm",
+        "webp",
+        "whl",
+        "wim",
+        "wm",
+        "wma",
+        "wmv",
+        "wmx",
+        "woff",
+        "woff2",
+        "wrm",
+        "wvx",
+        "xbm",
+        "xif",
+        "xla",
+        "xlam",
+        "xls",
+        "xlsb",
+        "xlsm",
+        "xlsx",
+        "xlt",
+        "xltm",
+        "xltx",
+        "xm",
+        "xmind",
+        "xpi",
+        "xpm",
+        "xwd",
+        "xz",
+        "z",
+        "zip",
+        "zipx",
+      ]);
+      const isBinaryPath = (filePath) =>
+        binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+      const foreach = (val, fn) => {
+        if (val instanceof Set) {
+          val.forEach(fn);
+        } else {
+          fn(val);
+        }
+      };
+      const addAndConvert = (main, prop, item) => {
+        let container = main[prop];
+        if (!(container instanceof Set)) {
+          main[prop] = container = new Set([container]);
+        }
+        container.add(item);
+      };
+      const clearItem = (cont) => (key) => {
+        const set = cont[key];
+        if (set instanceof Set) {
+          set.clear();
+        } else {
+          delete cont[key];
+        }
+      };
+      const delFromSet = (main, prop, item) => {
+        const container = main[prop];
+        if (container instanceof Set) {
+          container.delete(item);
+        } else if (container === item) {
+          delete main[prop];
+        }
+      };
+      const isEmptySet = (val) => (val instanceof Set ? val.size === 0 : !val);
+      const FsWatchInstances = new Map();
+      function createFsWatchInstance(
+        path,
+        options,
+        listener,
+        errHandler,
+        emitRaw,
+      ) {
+        const handleEvent = (rawEvent, evPath) => {
+          listener(path);
+          emitRaw(rawEvent, evPath, { watchedPath: path });
+          if (evPath && path !== evPath) {
+            fsWatchBroadcast(
+              sysPath.resolve(path, evPath),
+              KEY_LISTENERS,
+              sysPath.join(path, evPath),
+            );
+          }
+        };
+        try {
+          return (0, fs_1.watch)(
+            path,
+            { persistent: options.persistent },
+            handleEvent,
+          );
+        } catch (error) {
+          errHandler(error);
+          return undefined;
+        }
+      }
+      const fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+        const cont = FsWatchInstances.get(fullPath);
+        if (!cont) return;
+        foreach(cont[listenerType], (listener) => {
+          listener(val1, val2, val3);
+        });
+      };
+      const setFsWatchListener = (path, fullPath, options, handlers) => {
+        const { listener, errHandler, rawEmitter } = handlers;
+        let cont = FsWatchInstances.get(fullPath);
+        let watcher;
+        if (!options.persistent) {
+          watcher = createFsWatchInstance(
+            path,
+            options,
+            listener,
+            errHandler,
+            rawEmitter,
+          );
+          if (!watcher) return;
+          return watcher.close.bind(watcher);
+        }
+        if (cont) {
+          addAndConvert(cont, KEY_LISTENERS, listener);
+          addAndConvert(cont, KEY_ERR, errHandler);
+          addAndConvert(cont, KEY_RAW, rawEmitter);
+        } else {
+          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 (exports.isWindows && error.code === "EPERM") {
+              try {
+                const fd = await (0, promises_1.open)(path, "r");
+                await fd.close();
+                broadcastErr(error);
+              } catch (err) {}
+            } else {
+              broadcastErr(error);
+            }
+          });
+          cont = {
+            listeners: listener,
+            errHandlers: errHandler,
+            rawEmitters: rawEmitter,
+            watcher,
+          };
+          FsWatchInstances.set(fullPath, cont);
+        }
+        return () => {
+          delFromSet(cont, KEY_LISTENERS, listener);
+          delFromSet(cont, KEY_ERR, errHandler);
+          delFromSet(cont, KEY_RAW, rawEmitter);
+          if (isEmptySet(cont.listeners)) {
+            cont.watcher.close();
+            FsWatchInstances.delete(fullPath);
+            HANDLER_KEYS.forEach(clearItem(cont));
+            cont.watcher = undefined;
+            Object.freeze(cont);
+          }
+        };
+      };
+      const FsWatchFileInstances = new Map();
+      const setFsWatchFileListener = (path, fullPath, options, handlers) => {
+        const { listener, rawEmitter } = handlers;
+        let cont = FsWatchFileInstances.get(fullPath);
+        const copts = cont && cont.options;
+        if (
+          copts &&
+          (copts.persistent < options.persistent ||
+            copts.interval > options.interval)
+        ) {
+          (0, fs_1.unwatchFile)(fullPath);
+          cont = undefined;
+        }
+        if (cont) {
+          addAndConvert(cont, KEY_LISTENERS, listener);
+          addAndConvert(cont, KEY_RAW, rawEmitter);
+        } else {
+          cont = {
+            listeners: listener,
+            rawEmitters: rawEmitter,
+            options,
+            watcher: (0, fs_1.watchFile)(fullPath, options, (curr, prev) => {
+              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) => listener(path, curr));
+              }
+            }),
+          };
+          FsWatchFileInstances.set(fullPath, cont);
+        }
+        return () => {
+          delFromSet(cont, KEY_LISTENERS, listener);
+          delFromSet(cont, KEY_RAW, rawEmitter);
+          if (isEmptySet(cont.listeners)) {
+            FsWatchFileInstances.delete(fullPath);
+            (0, fs_1.unwatchFile)(fullPath);
+            cont.options = cont.watcher = undefined;
+            Object.freeze(cont);
+          }
+        };
+      };
+      class NodeFsHandler {
+        constructor(fsW) {
+          this.fsw = fsW;
+          this._boundHandleError = (error) => fsW._handleError(error);
+        }
+        _watchWithNodeFs(path, listener) {
+          const opts = this.fsw.options;
+          const directory = sysPath.dirname(path);
+          const basename = sysPath.basename(path);
+          const parent = this.fsw._getWatchedDir(directory);
+          parent.add(basename);
+          const absolutePath = sysPath.resolve(path);
+          const options = { persistent: opts.persistent };
+          if (!listener) listener = exports.EMPTY_FN;
+          let closer;
+          if (opts.usePolling) {
+            const enableBin = opts.interval !== opts.binaryInterval;
+            options.interval =
+              enableBin && isBinaryPath(basename)
+                ? opts.binaryInterval
+                : opts.interval;
+            closer = setFsWatchFileListener(path, absolutePath, options, {
+              listener,
+              rawEmitter: this.fsw._emitRaw,
+            });
+          } else {
+            closer = setFsWatchListener(path, absolutePath, options, {
+              listener,
+              errHandler: this._boundHandleError,
+              rawEmitter: this.fsw._emitRaw,
+            });
+          }
+          return closer;
+        }
+        _handleFile(file, stats, initialAdd) {
+          if (this.fsw.closed) {
+            return;
+          }
+          const dirname = sysPath.dirname(file);
+          const basename = sysPath.basename(file);
+          const parent = this.fsw._getWatchedDir(dirname);
+          let prevStats = stats;
+          if (parent.has(basename)) return;
+          const listener = async (path, newStats) => {
+            if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
+            if (!newStats || newStats.mtimeMs === 0) {
+              try {
+                const newStats = await (0, promises_1.stat)(file);
+                if (this.fsw.closed) return;
+                const at = newStats.atimeMs;
+                const mt = newStats.mtimeMs;
+                if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+                  this.fsw._emit(EV.CHANGE, file, newStats);
+                }
+                if (
+                  (exports.isMacos || exports.isLinux) &&
+                  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);
+              }
+            } else if (parent.has(basename)) {
+              const at = newStats.atimeMs;
+              const mt = newStats.mtimeMs;
+              if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+                this.fsw._emit(EV.CHANGE, file, newStats);
+              }
+              prevStats = newStats;
+            }
+          };
+          const closer = this._watchWithNodeFs(file, listener);
+          if (
+            !(initialAdd && this.fsw.options.ignoreInitial) &&
+            this.fsw._isntIgnored(file)
+          ) {
+            if (!this.fsw._throttle(EV.ADD, file, 0)) return;
+            this.fsw._emit(EV.ADD, file, stats);
+          }
+          return closer;
+        }
+        async _handleSymlink(entry, directory, path, item) {
+          if (this.fsw.closed) {
+            return;
+          }
+          const full = entry.fullPath;
+          const dir = this.fsw._getWatchedDir(directory);
+          if (!this.fsw.options.followSymlinks) {
+            this.fsw._incrReadyCount();
+            let linkPath;
+            try {
+              linkPath = await (0, promises_1.realpath)(path);
+            } catch (e) {
+              this.fsw._emitReady();
+              return true;
+            }
+            if (this.fsw.closed) return;
+            if (dir.has(item)) {
+              if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+                this.fsw._symlinkPaths.set(full, linkPath);
+                this.fsw._emit(EV.CHANGE, path, entry.stats);
+              }
+            } else {
+              dir.add(item);
+              this.fsw._symlinkPaths.set(full, linkPath);
+              this.fsw._emit(EV.ADD, path, entry.stats);
+            }
+            this.fsw._emitReady();
+            return true;
+          }
+          if (this.fsw._symlinkPaths.has(full)) {
+            return true;
+          }
+          this.fsw._symlinkPaths.set(full, true);
+        }
+        _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+          directory = sysPath.join(directory, "");
+          throttler = this.fsw._throttle("readdir", directory, 1e3);
+          if (!throttler) return;
+          const previous = this.fsw._getWatchedDir(wh.path);
+          const current = new Set();
+          let stream = this.fsw._readdirp(directory, {
+            fileFilter: (entry) => wh.filterPath(entry),
+            directoryFilter: (entry) => wh.filterDir(entry),
+          });
+          if (!stream) return;
+          stream
+            .on(exports.STR_DATA, async (entry) => {
+              if (this.fsw.closed) {
+                stream = undefined;
+                return;
+              }
+              const item = entry.path;
+              let path = sysPath.join(directory, item);
+              current.add(item);
+              if (
+                entry.stats.isSymbolicLink() &&
+                (await this._handleSymlink(entry, directory, path, item))
+              ) {
+                return;
+              }
+              if (this.fsw.closed) {
+                stream = undefined;
+                return;
+              }
+              if (item === target || (!target && !previous.has(item))) {
+                this.fsw._incrReadyCount();
+                path = sysPath.join(dir, sysPath.relative(dir, path));
+                this._addToNodeFs(path, initialAdd, wh, depth + 1);
+              }
+            })
+            .on(EV.ERROR, this._boundHandleError);
+          return new Promise((resolve, reject) => {
+            if (!stream) return reject();
+            stream.once(exports.STR_END, () => {
+              if (this.fsw.closed) {
+                stream = undefined;
+                return;
+              }
+              const wasThrottled = throttler ? throttler.clear() : false;
+              resolve(undefined);
+              previous
+                .getChildren()
+                .filter((item) => item !== directory && !current.has(item))
+                .forEach((item) => {
+                  this.fsw._remove(directory, item);
+                });
+              stream = undefined;
+              if (wasThrottled)
+                this._handleRead(
+                  directory,
+                  false,
+                  wh,
+                  target,
+                  dir,
+                  depth,
+                  throttler,
+                );
+            });
+          });
+        }
+        async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
+          const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
+          const tracked = parentDir.has(sysPath.basename(dir));
+          if (
+            !(initialAdd && this.fsw.options.ignoreInitial) &&
+            !target &&
+            !tracked
+          ) {
+            this.fsw._emit(EV.ADD_DIR, dir, stats);
+          }
+          parentDir.add(sysPath.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)
+          ) {
+            if (!target) {
+              await this._handleRead(
+                dir,
+                initialAdd,
+                wh,
+                target,
+                dir,
+                depth,
+                throttler,
+              );
+              if (this.fsw.closed) return;
+            }
+            closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
+              if (stats && stats.mtimeMs === 0) return;
+              this._handleRead(
+                dirPath,
+                false,
+                wh,
+                target,
+                dir,
+                depth,
+                throttler,
+              );
+            });
+          }
+          return closer;
+        }
+        async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+          const ready = this.fsw._emitReady;
+          if (this.fsw._isIgnored(path) || this.fsw.closed) {
+            ready();
+            return false;
+          }
+          const wh = this.fsw._getWatchHelpers(path);
+          if (priorWh) {
+            wh.filterPath = (entry) => priorWh.filterPath(entry);
+            wh.filterDir = (entry) => priorWh.filterDir(entry);
+          }
+          try {
+            const stats = await statMethods[wh.statMethod](wh.watchPath);
+            if (this.fsw.closed) return;
+            if (this.fsw._isIgnored(wh.watchPath, stats)) {
+              ready();
+              return false;
+            }
+            const follow = this.fsw.options.followSymlinks;
+            let closer;
+            if (stats.isDirectory()) {
+              const absPath = sysPath.resolve(path);
+              const targetPath = follow
+                ? await (0, promises_1.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 !== undefined) {
+                this.fsw._symlinkPaths.set(absPath, targetPath);
+              }
+            } else if (stats.isSymbolicLink()) {
+              const targetPath = follow
+                ? await (0, promises_1.realpath)(path)
+                : path;
+              if (this.fsw.closed) return;
+              const parent = sysPath.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,
+              );
+              if (this.fsw.closed) return;
+              if (targetPath !== undefined) {
+                this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
+              }
+            } else {
+              closer = this._handleFile(wh.watchPath, stats, initialAdd);
+            }
+            ready();
+            if (closer) this.fsw._addPathCloser(path, closer);
+            return false;
+          } catch (error) {
+            if (this.fsw._handleError(error)) {
+              ready();
+              return path;
+            }
+          }
+        }
+      }
+      exports.NodeFsHandler = NodeFsHandler;
+    },
+    861: (__unused_webpack_module, exports, __nccwpck_require__) => {
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.readdirpPromise =
+        exports.readdirp =
+        exports.ReaddirpStream =
+          void 0;
+      const fs_1 = __nccwpck_require__(147);
+      const promises_1 = __nccwpck_require__(292);
+      const stream_1 = __nccwpck_require__(781);
+      const path_1 = __nccwpck_require__(17);
+      function defaultOptions() {
+        return {
+          root: ".",
+          fileFilter: (_path) => true,
+          directoryFilter: (_path) => true,
+          type: FILE_TYPE,
+          lstat: false,
+          depth: 2147483648,
+          alwaysStat: false,
+          highWaterMark: 4096,
+        };
+      }
+      const RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+      const NORMAL_FLOW_ERRORS = new Set([
+        "ENOENT",
+        "EPERM",
+        "EACCES",
+        "ELOOP",
+        RECURSIVE_ERROR_CODE,
+      ]);
+      const FILE_TYPE = "files";
+      const DIR_TYPE = "directories";
+      const FILE_DIR_TYPE = "files_directories";
+      const EVERYTHING_TYPE = "all";
+      const ALL_TYPES = [FILE_TYPE, DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE];
+      const DIR_TYPES = new Set([DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE]);
+      const FILE_TYPES = new Set([FILE_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE]);
+      const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+      const wantBigintFsStats = process.platform === "win32";
+      const emptyFn = (_path) => true;
+      const normalizeFilter = (filter) => {
+        if (filter === undefined) return emptyFn;
+        if (typeof filter === "function") return filter;
+        if (typeof filter === "string") {
+          const fl = filter.trim();
+          return (entry) => entry.basename === fl;
+        }
+        if (Array.isArray(filter)) {
+          const trItems = filter.map((item) => item.trim());
+          return (entry) => trItems.some((f) => entry.basename === f);
+        }
+        return emptyFn;
+      };
+      class ReaddirpStream extends stream_1.Readable {
+        constructor(options = {}) {
+          super({
+            objectMode: true,
+            autoDestroy: true,
+            highWaterMark: options.highWaterMark,
+          });
+          const opts = { ...defaultOptions(), ...options };
+          const { root, type } = opts;
+          this._fileFilter = normalizeFilter(opts.fileFilter);
+          this._directoryFilter = normalizeFilter(opts.directoryFilter);
+          const statMethod = opts.lstat ? fs_1.lstatSync : fs_1.statSync;
+          if (wantBigintFsStats) {
+            this._stat = (path) => statMethod(path, { bigint: true });
+          } else {
+            this._stat = statMethod;
+          }
+          this._maxDepth = opts.depth;
+          this._wantsDir = DIR_TYPES.has(type);
+          this._wantsFile = FILE_TYPES.has(type);
+          this._wantsEverything = type === EVERYTHING_TYPE;
+          this._root = (0, path_1.resolve)(root);
+          this._isDirent = !opts.alwaysStat;
+          this._statsProp = this._isDirent ? "dirent" : "stats";
+          this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
+          this.parents = [this._exploreDir(root, 1)];
+          this.reading = false;
+          this.parent = undefined;
+        }
+        async _read(batch) {
+          if (this.reading) return;
+          this.reading = true;
+          try {
+            while (!this.destroyed && batch > 0) {
+              const par = this.parent;
+              const fil = par && par.files;
+              if (fil && fil.length > 0) {
+                const { path, depth } = par;
+                const slice = fil
+                  .splice(0, batch)
+                  .map((dirent) => this._formatEntry(dirent, path));
+                for (const entry of slice) {
+                  if (!entry) {
+                    batch--;
+                    return;
+                  }
+                  if (this.destroyed) return;
+                  const entryType = await this._getEntryType(entry);
+                  if (
+                    entryType === "directory" &&
+                    this._directoryFilter(entry)
+                  ) {
+                    if (depth <= this._maxDepth) {
+                      this.parents.push(
+                        this._exploreDir(entry.fullPath, depth + 1),
+                      );
+                    }
+                    if (this._wantsDir) {
+                      this.push(entry);
+                      batch--;
+                    }
+                  } else if (
+                    (entryType === "file" || this._includeAsFile(entry)) &&
+                    this._fileFilter(entry)
+                  ) {
+                    if (this._wantsFile) {
+                      this.push(entry);
+                      batch--;
+                    }
+                  }
+                }
+              } else {
+                const parent = this.parents.pop();
+                if (!parent) {
+                  this.push(null);
+                  break;
+                }
+                this.parent = await parent;
+                if (this.destroyed) return;
+              }
+            }
+          } catch (error) {
+            this.destroy(error);
+          } finally {
+            this.reading = false;
+          }
+        }
+        async _exploreDir(path, depth) {
+          let files;
+          try {
+            files = await (0, promises_1.readdir)(path, this._rdOptions);
+          } catch (error) {
+            this._onError(error);
+          }
+          return { files, depth, path };
+        }
+        _formatEntry(dirent, path) {
+          let entry;
+          const basename = this._isDirent ? dirent.name : dirent;
+          try {
+            const fullPath = (0, path_1.resolve)(
+              (0, path_1.join)(path, basename),
+            );
+            entry = {
+              path: (0, path_1.relative)(this._root, fullPath),
+              fullPath,
+              basename,
+            };
+            entry[this._statsProp] = this._isDirent
+              ? dirent
+              : this._stat(fullPath);
+          } catch (err) {
+            this._onError(err);
+            return;
+          }
+          return entry;
+        }
+        _onError(err) {
+          if (isNormalFlowError(err) && !this.destroyed) {
+            this.emit("warn", err);
+          } else {
+            this.destroy(err);
+          }
+        }
+        async _getEntryType(entry) {
+          if (!entry && this._statsProp in entry) {
+            return "";
+          }
+          const stats = entry[this._statsProp];
+          if (stats.isFile()) return "file";
+          if (stats.isDirectory()) return "directory";
+          if (stats && stats.isSymbolicLink()) {
+            const full = entry.fullPath;
+            try {
+              const entryRealPath = await (0, promises_1.realpath)(full);
+              const entryRealPathStats = (0, fs_1.lstatSync)(entryRealPath);
+              if (entryRealPathStats.isFile()) {
+                return "file";
+              }
+              if (entryRealPathStats.isDirectory()) {
+                const len = entryRealPath.length;
+                if (
+                  full.startsWith(entryRealPath) &&
+                  full.substr(len, 1) === path_1.sep
+                ) {
+                  const recursiveError = new Error(
+                    `Circular symlink detected: "${full}" points to "${entryRealPath}"`,
+                  );
+                  recursiveError.code = RECURSIVE_ERROR_CODE;
+                  return this._onError(recursiveError);
+                }
+                return "directory";
+              }
+            } catch (error) {
+              this._onError(error);
+              return "";
+            }
+          }
+        }
+        _includeAsFile(entry) {
+          const stats = entry && entry[this._statsProp];
+          return stats && this._wantsEverything && !stats.isDirectory();
+        }
+      }
+      exports.ReaddirpStream = ReaddirpStream;
+      const readdirp = (root, options = {}) => {
+        let type = options.entryType || options.type;
+        if (type === "both") type = 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 && !ALL_TYPES.includes(type)) {
+          throw new Error(
+            `readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`,
+          );
+        }
+        options.root = root;
+        return new ReaddirpStream(options);
+      };
+      exports.readdirp = readdirp;
+      const readdirpPromise = (root, options = {}) =>
+        new Promise((resolve, reject) => {
+          const files = [];
+          (0, exports.readdirp)(root, options)
+            .on("data", (entry) => files.push(entry))
+            .on("end", () => resolve(files))
+            .on("error", (error) => reject(error));
+        });
+      exports.readdirpPromise = readdirpPromise;
+      exports["default"] = exports.readdirp;
+    },
+    361: (module) => {
+      module.exports = require("events");
+    },
+    147: (module) => {
+      module.exports = require("fs");
+    },
+    292: (module) => {
+      module.exports = require("fs/promises");
+    },
+    37: (module) => {
+      module.exports = require("os");
+    },
+    17: (module) => {
+      module.exports = require("path");
+    },
+    781: (module) => {
+      module.exports = require("stream");
+    },
+  };
+  var __webpack_module_cache__ = {};
+  function __nccwpck_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (cachedModule !== undefined) {
+      return cachedModule.exports;
+    }
+    var module = (__webpack_module_cache__[moduleId] = { exports: {} });
+    var threw = true;
+    try {
+      __webpack_modules__[moduleId](
+        module,
+        module.exports,
+        __nccwpck_require__,
+      );
+      threw = false;
+    } finally {
+      if (threw) delete __webpack_module_cache__[moduleId];
+    }
+    return module.exports;
+  }
+  if (typeof __nccwpck_require__ !== "undefined")
+    __nccwpck_require__.ab = __dirname + "/";
+  var __webpack_exports__ = {};
+  (() => {
+    var exports = __webpack_exports__;
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.FSWatcher = exports.WatchHelper = void 0;
+    exports.watch = watch;
+    const fs_1 = __nccwpck_require__(147);
+    const promises_1 = __nccwpck_require__(292);
+    const events_1 = __nccwpck_require__(361);
+    const sysPath = __nccwpck_require__(17);
+    const readdirp_1 = __nccwpck_require__(861);
+    const handler_js_1 = __nccwpck_require__(976);
+    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 DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+    const REPLACER_RE = /^\.[/\\]/;
+    function arrify(item) {
+      return Array.isArray(item) ? item : [item];
+    }
+    const isMatcherObject = (matcher) =>
+      typeof matcher === "object" &&
+      matcher !== null &&
+      !(matcher instanceof RegExp);
+    function createPattern(matcher) {
+      if (typeof matcher === "function") return matcher;
+      if (typeof matcher === "string") return (string) => matcher === string;
+      if (matcher instanceof RegExp) return (string) => matcher.test(string);
+      if (typeof matcher === "object" && matcher !== null) {
+        return (string) => {
+          if (matcher.path === string) return true;
+          if (matcher.recursive) {
+            const relative = sysPath.relative(matcher.path, string);
+            if (!relative) {
+              return false;
+            }
+            return !relative.startsWith("..") && !sysPath.isAbsolute(relative);
+          }
+          return false;
+        };
+      }
+      return () => false;
+    }
+    function normalizePath(path) {
+      if (typeof path !== "string") throw new Error("string expected");
+      path = sysPath.normalize(path);
+      path = path.replace(/\\/g, "/");
+      let prepend = false;
+      if (path.startsWith("//")) prepend = true;
+      const DOUBLE_SLASH_RE = /\/\//;
+      while (path.match(DOUBLE_SLASH_RE))
+        path = path.replace(DOUBLE_SLASH_RE, "/");
+      if (prepend) path = "/" + path;
+      return path;
+    }
+    function matchPatterns(patterns, testString, stats) {
+      const path = normalizePath(testString);
+      for (let index = 0; index < patterns.length; index++) {
+        const pattern = patterns[index];
+        if (pattern(path, stats)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function anymatch(matchers, testString) {
+      if (matchers == null) {
+        throw new TypeError("anymatch: specify first argument");
+      }
+      const matchersArray = arrify(matchers);
+      const patterns = matchersArray.map((matcher) => createPattern(matcher));
+      if (testString == null) {
+        return (testString, stats) =>
+          matchPatterns(patterns, testString, stats);
+      }
+      return matchPatterns(patterns, testString);
+    }
+    const unifyPaths = (paths_) => {
+      const paths = arrify(paths_).flat();
+      if (!paths.every((p) => typeof p === STRING_TYPE)) {
+        throw new TypeError(`Non-string provided as watch path: ${paths}`);
+      }
+      return paths.map(normalizePathToUnix);
+    };
+    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);
+      }
+      if (prepend) {
+        str = SLASH + str;
+      }
+      return str;
+    };
+    const normalizePathToUnix = (path) =>
+      toUnix(sysPath.normalize(toUnix(path)));
+    const normalizeIgnored =
+      (cwd = "") =>
+      (path) => {
+        if (typeof path === "string") {
+          return normalizePathToUnix(
+            sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path),
+          );
+        } else {
+          return path;
+        }
+      };
+    const getAbsolutePath = (path, cwd) => {
+      if (sysPath.isAbsolute(path)) {
+        return path;
+      }
+      return sysPath.join(cwd, path);
+    };
+    const EMPTY_SET = Object.freeze(new Set());
+    class DirEntry {
+      constructor(dir, removeWatcher) {
+        this.path = dir;
+        this._removeWatcher = removeWatcher;
+        this.items = new Set();
+      }
+      add(item) {
+        const { items } = this;
+        if (!items) return;
+        if (item !== ONE_DOT && item !== TWO_DOTS) items.add(item);
+      }
+      async remove(item) {
+        const { items } = this;
+        if (!items) return;
+        items.delete(item);
+        if (items.size > 0) return;
+        const dir = this.path;
+        try {
+          await (0, promises_1.readdir)(dir);
+        } catch (err) {
+          if (this._removeWatcher) {
+            this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
+          }
+        }
+      }
+      has(item) {
+        const { items } = this;
+        if (!items) return;
+        return items.has(item);
+      }
+      getChildren() {
+        const { items } = this;
+        if (!items) return [];
+        return [...items.values()];
+      }
+      dispose() {
+        this.items.clear();
+        this.path = "";
+        this._removeWatcher = handler_js_1.EMPTY_FN;
+        this.items = EMPTY_SET;
+        Object.freeze(this);
+      }
+    }
+    const STAT_METHOD_F = "stat";
+    const STAT_METHOD_L = "lstat";
+    class WatchHelper {
+      constructor(path, follow, fsw) {
+        this.fsw = fsw;
+        const watchPath = path;
+        this.path = path = path.replace(REPLACER_RE, "");
+        this.watchPath = watchPath;
+        this.fullWatchPath = sysPath.resolve(watchPath);
+        this.dirParts = [];
+        this.dirParts.forEach((parts) => {
+          if (parts.length > 1) parts.pop();
+        });
+        this.followSymlinks = follow;
+        this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+      }
+      entryPath(entry) {
+        return sysPath.join(
+          this.watchPath,
+          sysPath.relative(this.watchPath, entry.fullPath),
+        );
+      }
+      filterPath(entry) {
+        const { stats } = entry;
+        if (stats && stats.isSymbolicLink()) return this.filterDir(entry);
+        const resolvedPath = this.entryPath(entry);
+        return (
+          this.fsw._isntIgnored(resolvedPath, stats) &&
+          this.fsw._hasReadPermissions(stats)
+        );
+      }
+      filterDir(entry) {
+        return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+      }
+    }
+    exports.WatchHelper = WatchHelper;
+    class FSWatcher extends events_1.EventEmitter {
+      constructor(_opts = {}) {
+        super();
+        this.closed = false;
+        this._closers = new Map();
+        this._ignoredPaths = new Set();
+        this._throttled = new Map();
+        this._streams = new Set();
+        this._symlinkPaths = new Map();
+        this._watched = new Map();
+        this._pendingWrites = new Map();
+        this._pendingUnlinks = new Map();
+        this._readyCount = 0;
+        this._readyEmitted = false;
+        const awf = _opts.awaitWriteFinish;
+        const DEF_AWF = { stabilityThreshold: 2e3, pollInterval: 100 };
+        const opts = {
+          persistent: true,
+          ignoreInitial: false,
+          ignorePermissionErrors: false,
+          interval: 100,
+          binaryInterval: 300,
+          followSymlinks: true,
+          usePolling: false,
+          atomic: true,
+          ..._opts,
+          ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+          awaitWriteFinish:
+            awf === true
+              ? DEF_AWF
+              : typeof awf === "object"
+                ? { ...DEF_AWF, ...awf }
+                : false,
+        };
+        if (handler_js_1.isIBMi) opts.usePolling = true;
+        if (opts.atomic === undefined) opts.atomic = !opts.usePolling;
+        const envPoll = process.env.CHOKIDAR_USEPOLLING;
+        if (envPoll !== undefined) {
+          const envLower = envPoll.toLowerCase();
+          if (envLower === "false" || envLower === "0") opts.usePolling = false;
+          else if (envLower === "true" || envLower === "1")
+            opts.usePolling = true;
+          else opts.usePolling = !!envLower;
+        }
+        const envInterval = process.env.CHOKIDAR_INTERVAL;
+        if (envInterval) opts.interval = Number.parseInt(envInterval, 10);
+        let readyCalls = 0;
+        this._emitReady = () => {
+          readyCalls++;
+          if (readyCalls >= this._readyCount) {
+            this._emitReady = handler_js_1.EMPTY_FN;
+            this._readyEmitted = true;
+            process.nextTick(() => this.emit(handler_js_1.EVENTS.READY));
+          }
+        };
+        this._emitRaw = (...args) =>
+          this.emit(handler_js_1.EVENTS.RAW, ...args);
+        this._boundRemove = this._remove.bind(this);
+        this.options = opts;
+        this._nodeFsHandler = new handler_js_1.NodeFsHandler(this);
+        Object.freeze(opts);
+      }
+      _addIgnoredPath(matcher) {
+        if (isMatcherObject(matcher)) {
+          for (const ignored of this._ignoredPaths) {
+            if (
+              isMatcherObject(ignored) &&
+              ignored.path === matcher.path &&
+              ignored.recursive === matcher.recursive
+            ) {
+              return;
+            }
+          }
+        }
+        this._ignoredPaths.add(matcher);
+      }
+      _removeIgnoredPath(matcher) {
+        this._ignoredPaths.delete(matcher);
+        if (typeof matcher === "string") {
+          for (const ignored of this._ignoredPaths) {
+            if (isMatcherObject(ignored) && ignored.path === matcher) {
+              this._ignoredPaths.delete(ignored);
+            }
+          }
+        }
+      }
+      add(paths_, _origAdd, _internal) {
+        const { cwd } = this.options;
+        this.closed = false;
+        this._closePromise = undefined;
+        let paths = unifyPaths(paths_);
+        if (cwd) {
+          paths = paths.map((path) => {
+            const absPath = getAbsolutePath(path, cwd);
+            return absPath;
+          });
+        }
+        paths.forEach((path) => {
+          this._removeIgnoredPath(path);
+        });
+        this._userIgnored = undefined;
+        if (!this._readyCount) this._readyCount = 0;
+        this._readyCount += paths.length;
+        Promise.all(
+          paths.map(async (path) => {
+            const res = await this._nodeFsHandler._addToNodeFs(
+              path,
+              !_internal,
+              undefined,
+              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),
+              );
+          });
+        });
+        return this;
+      }
+      unwatch(paths_) {
+        if (this.closed) return this;
+        const paths = unifyPaths(paths_);
+        const { cwd } = this.options;
+        paths.forEach((path) => {
+          if (!sysPath.isAbsolute(path) && !this._closers.has(path)) {
+            if (cwd) path = sysPath.join(cwd, path);
+            path = sysPath.resolve(path);
+          }
+          this._closePath(path);
+          this._addIgnoredPath(path);
+          if (this._watched.has(path)) {
+            this._addIgnoredPath({ path, recursive: true });
+          }
+          this._userIgnored = undefined;
+        });
+        return this;
+      }
+      close() {
+        if (this._closePromise) {
+          return this._closePromise;
+        }
+        this.closed = true;
+        this.removeAllListeners();
+        const closers = [];
+        this._closers.forEach((closerList) =>
+          closerList.forEach((closer) => {
+            const promise = closer();
+            if (promise instanceof Promise) closers.push(promise);
+          }),
+        );
+        this._streams.forEach((stream) => stream.destroy());
+        this._userIgnored = undefined;
+        this._readyCount = 0;
+        this._readyEmitted = false;
+        this._watched.forEach((dirent) => dirent.dispose());
+        this._closers.clear();
+        this._watched.clear();
+        this._streams.clear();
+        this._symlinkPaths.clear();
+        this._throttled.clear();
+        this._closePromise = closers.length
+          ? Promise.all(closers).then(() => undefined)
+          : Promise.resolve();
+        return this._closePromise;
+      }
+      getWatched() {
+        const watchList = {};
+        this._watched.forEach((entry, dir) => {
+          const key = this.options.cwd
+            ? sysPath.relative(this.options.cwd, dir)
+            : dir;
+          const index = key || ONE_DOT;
+          watchList[index] = entry.getChildren().sort();
+        });
+        return watchList;
+      }
+      emitWithAll(event, args) {
+        this.emit(...args);
+        if (event !== handler_js_1.EVENTS.ERROR)
+          this.emit(handler_js_1.EVENTS.ALL, ...args);
+      }
+      async _emit(event, path, stats) {
+        if (this.closed) return;
+        const opts = this.options;
+        if (handler_js_1.isWindows) path = sysPath.normalize(path);
+        if (opts.cwd) path = sysPath.relative(opts.cwd, path);
+        const args = [event, path];
+        if (stats != null) args.push(stats);
+        const awf = opts.awaitWriteFinish;
+        let pw;
+        if (awf && (pw = this._pendingWrites.get(path))) {
+          pw.lastChange = new Date();
+          return this;
+        }
+        if (opts.atomic) {
+          if (event === handler_js_1.EVENTS.UNLINK) {
+            this._pendingUnlinks.set(path, args);
+            setTimeout(
+              () => {
+                this._pendingUnlinks.forEach((entry, path) => {
+                  this.emit(...entry);
+                  this.emit(handler_js_1.EVENTS.ALL, ...entry);
+                  this._pendingUnlinks.delete(path);
+                });
+              },
+              typeof opts.atomic === "number" ? opts.atomic : 100,
+            );
+            return this;
+          }
+          if (
+            event === handler_js_1.EVENTS.ADD &&
+            this._pendingUnlinks.has(path)
+          ) {
+            event = args[0] = handler_js_1.EVENTS.CHANGE;
+            this._pendingUnlinks.delete(path);
+          }
+        }
+        if (
+          awf &&
+          (event === handler_js_1.EVENTS.ADD ||
+            event === handler_js_1.EVENTS.CHANGE) &&
+          this._readyEmitted
+        ) {
+          const awfEmit = (err, stats) => {
+            if (err) {
+              event = args[0] = handler_js_1.EVENTS.ERROR;
+              args[1] = err;
+              this.emitWithAll(event, args);
+            } else if (stats) {
+              if (args.length > 2) {
+                args[2] = stats;
+              } else {
+                args.push(stats);
+              }
+              this.emitWithAll(event, args);
+            }
+          };
+          this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+          return this;
+        }
+        if (event === handler_js_1.EVENTS.CHANGE) {
+          const isThrottled = !this._throttle(
+            handler_js_1.EVENTS.CHANGE,
+            path,
+            50,
+          );
+          if (isThrottled) return this;
+        }
+        if (
+          opts.alwaysStat &&
+          stats === undefined &&
+          (event === handler_js_1.EVENTS.ADD ||
+            event === handler_js_1.EVENTS.ADD_DIR ||
+            event === handler_js_1.EVENTS.CHANGE)
+        ) {
+          const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
+          let stats;
+          try {
+            stats = await (0, promises_1.stat)(fullPath);
+          } catch (err) {}
+          if (!stats || this.closed) return;
+          args.push(stats);
+        }
+        this.emitWithAll(event, args);
+        return this;
+      }
+      _handleError(error) {
+        const code = error && error.code;
+        if (
+          error &&
+          code !== "ENOENT" &&
+          code !== "ENOTDIR" &&
+          (!this.options.ignorePermissionErrors ||
+            (code !== "EPERM" && code !== "EACCES"))
+        ) {
+          this.emit(handler_js_1.EVENTS.ERROR, error);
+        }
+        return error || this.closed;
+      }
+      _throttle(actionType, path, timeout) {
+        if (!this._throttled.has(actionType)) {
+          this._throttled.set(actionType, new Map());
+        }
+        const action = this._throttled.get(actionType);
+        if (!action) throw new Error("invalid throttle");
+        const actionPath = action.get(path);
+        if (actionPath) {
+          actionPath.count++;
+          return false;
+        }
+        let timeoutObject;
+        const clear = () => {
+          const item = action.get(path);
+          const count = item ? item.count : 0;
+          action.delete(path);
+          clearTimeout(timeoutObject);
+          if (item) clearTimeout(item.timeoutObject);
+          return count;
+        };
+        timeoutObject = setTimeout(clear, timeout);
+        const thr = { timeoutObject, clear, count: 0 };
+        action.set(path, thr);
+        return thr;
+      }
+      _incrReadyCount() {
+        return this._readyCount++;
+      }
+      _awaitWriteFinish(path, threshold, event, awfEmit) {
+        const awf = this.options.awaitWriteFinish;
+        if (typeof awf !== "object") return;
+        const pollInterval = awf.pollInterval;
+        let timeoutHandler;
+        let fullPath = path;
+        if (this.options.cwd && !sysPath.isAbsolute(path)) {
+          fullPath = sysPath.join(this.options.cwd, path);
+        }
+        const now = new Date();
+        const writes = this._pendingWrites;
+        function awaitWriteFinishFn(prevStat) {
+          (0, fs_1.stat)(fullPath, (err, curStat) => {
+            if (err || !writes.has(path)) {
+              if (err && err.code !== "ENOENT") awfEmit(err);
+              return;
+            }
+            const now = Number(new Date());
+            if (prevStat && curStat.size !== prevStat.size) {
+              writes.get(path).lastChange = now;
+            }
+            const pw = writes.get(path);
+            const df = now - pw.lastChange;
+            if (df >= threshold) {
+              writes.delete(path);
+              awfEmit(undefined, curStat);
+            } else {
+              timeoutHandler = setTimeout(
+                awaitWriteFinishFn,
+                pollInterval,
+                curStat,
+              );
+            }
+          });
+        }
+        if (!writes.has(path)) {
+          writes.set(path, {
+            lastChange: now,
+            cancelWait: () => {
+              writes.delete(path);
+              clearTimeout(timeoutHandler);
+              return event;
+            },
+          });
+          timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+        }
+      }
+      _isIgnored(path, stats) {
+        if (this.options.atomic && DOT_RE.test(path)) return true;
+        if (!this._userIgnored) {
+          const { cwd } = this.options;
+          const ign = this.options.ignored;
+          const ignored = (ign || []).map(normalizeIgnored(cwd));
+          const ignoredPaths = [...this._ignoredPaths];
+          const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+          this._userIgnored = anymatch(list, undefined);
+        }
+        return this._userIgnored(path, stats);
+      }
+      _isntIgnored(path, stat) {
+        return !this._isIgnored(path, stat);
+      }
+      _getWatchHelpers(path) {
+        return new WatchHelper(path, this.options.followSymlinks, this);
+      }
+      _getWatchedDir(directory) {
+        const dir = sysPath.resolve(directory);
+        if (!this._watched.has(dir))
+          this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+        return this._watched.get(dir);
+      }
+      _hasReadPermissions(stats) {
+        if (this.options.ignorePermissionErrors) return true;
+        return Boolean(Number(stats.mode) & 256);
+      }
+      _remove(directory, item, isDirectory) {
+        const path = sysPath.join(directory, item);
+        const fullPath = sysPath.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);
+        }
+        const wp = this._getWatchedDir(path);
+        const nestedDirectoryChildren = wp.getChildren();
+        nestedDirectoryChildren.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;
+        if (this.options.cwd)
+          relPath = sysPath.relative(this.options.cwd, path);
+        if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+          const event = this._pendingWrites.get(relPath).cancelWait();
+          if (event === handler_js_1.EVENTS.ADD) return;
+        }
+        this._watched.delete(path);
+        this._watched.delete(fullPath);
+        const eventName = isDirectory
+          ? handler_js_1.EVENTS.UNLINK_DIR
+          : handler_js_1.EVENTS.UNLINK;
+        if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
+        this._closePath(path);
+      }
+      _closePath(path) {
+        this._closeFile(path);
+        const dir = sysPath.dirname(path);
+        this._getWatchedDir(dir).remove(sysPath.basename(path));
+      }
+      _closeFile(path) {
+        const closers = this._closers.get(path);
+        if (!closers) return;
+        closers.forEach((closer) => closer());
+        this._closers.delete(path);
+      }
+      _addPathCloser(path, closer) {
+        if (!closer) return;
+        let list = this._closers.get(path);
+        if (!list) {
+          list = [];
+          this._closers.set(path, list);
+        }
+        list.push(closer);
+      }
+      _readdirp(root, opts) {
+        if (this.closed) return;
+        const options = {
+          type: handler_js_1.EVENTS.ALL,
+          alwaysStat: true,
+          lstat: true,
+          ...opts,
+          depth: 0,
+        };
+        let stream = (0, readdirp_1.readdirp)(root, options);
+        this._streams.add(stream);
+        stream.once(handler_js_1.STR_CLOSE, () => {
+          stream = undefined;
+        });
+        stream.once(handler_js_1.STR_END, () => {
+          if (stream) {
+            this._streams.delete(stream);
+            stream = undefined;
+          }
+        });
+        return stream;
+      }
+    }
+    exports.FSWatcher = FSWatcher;
+    function watch(paths, options = {}) {
+      const watcher = new FSWatcher(options);
+      watcher.add(paths);
+      return watcher;
+    }
+    exports["default"] = { watch, FSWatcher };
+  })();
+  module.exports = __webpack_exports__;
+})();