@storm-software/git-tools 2.104.47 → 2.104.49

package/bin/{esm-IZHFRARS.js → esm-WLHP7RVO.js}

@@ -1,7 +1,6 @@
 import {
-  __name,
   init_esm_shims
-} from "./chunk-EJRTGQIY.js";
+} from "./chunk-W2TU25OT.js";
 
 // ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
 init_esm_shims();
@@ -23,8 +22,8 @@ var EntryTypes = {
 };
 var defaultOptions = {
   root: ".",
-  fileFilter: /* @__PURE__ */ __name((_entryInfo) => true, "fileFilter"),
-  directoryFilter: /* @__PURE__ */ __name((_entryInfo) => true, "directoryFilter"),
+  fileFilter: (_entryInfo) => true,
+  directoryFilter: (_entryInfo) => true,
   type: EntryTypes.FILE_TYPE,
   lstat: false,
   depth: 2147483648,
@@ -33,13 +32,7 @@ var defaultOptions = {
 };
 Object.freeze(defaultOptions);
 var RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
-var NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set([
-  "ENOENT",
-  "EPERM",
-  "EACCES",
-  "ELOOP",
-  RECURSIVE_ERROR_CODE
-]);
+var NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
 var ALL_TYPES = [
   EntryTypes.DIR_TYPE,
   EntryTypes.EVERYTHING_TYPE,
@@ -56,12 +49,14 @@ var FILE_TYPES = /* @__PURE__ */ new Set([
   EntryTypes.FILE_DIR_TYPE,
   EntryTypes.FILE_TYPE
 ]);
-var isNormalFlowError = /* @__PURE__ */ __name((error) => NORMAL_FLOW_ERRORS.has(error.code), "isNormalFlowError");
+var isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
 var wantBigintFsStats = process.platform === "win32";
-var emptyFn = /* @__PURE__ */ __name((_entryInfo) => true, "emptyFn");
-var normalizeFilter = /* @__PURE__ */ __name((filter) => {
-  if (filter === void 0) return emptyFn;
-  if (typeof filter === "function") return filter;
+var emptyFn = (_entryInfo) => true;
+var normalizeFilter = (filter) => {
+  if (filter === void 0)
+    return emptyFn;
+  if (typeof filter === "function")
+    return filter;
   if (typeof filter === "string") {
     const fl = filter.trim();
     return (entry) => entry.basename === fl;
@@ -71,29 +66,21 @@ var normalizeFilter = /* @__PURE__ */ __name((filter) => {
     return (entry) => trItems.some((f) => entry.basename === f);
   }
   return emptyFn;
-}, "normalizeFilter");
+};
 var ReaddirpStream = class extends Readable {
-  static {
-    __name(this, "ReaddirpStream");
-  }
   constructor(options = {}) {
     super({
       objectMode: true,
       autoDestroy: true,
       highWaterMark: options.highWaterMark
     });
-    const opts = {
-      ...defaultOptions,
-      ...options
-    };
+    const opts = { ...defaultOptions, ...options };
     const { root, type } = opts;
     this._fileFilter = normalizeFilter(opts.fileFilter);
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path) => statMethod(path, {
-        bigint: true
-      });
+      this._stat = (path) => statMethod(path, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -104,18 +91,14 @@ var ReaddirpStream = class extends Readable {
     this._root = presolve(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._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
+    this.parents = [this._exploreDir(root, 1)];
     this.reading = false;
     this.parent = void 0;
   }
   async _read(batch) {
-    if (this.reading) return;
+    if (this.reading)
+      return;
     this.reading = true;
     try {
       while (!this.destroyed && batch > 0) {
@@ -126,8 +109,10 @@ var ReaddirpStream = class extends Readable {
           const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
-            if (!entry) continue;
-            if (this.destroyed) return;
+            if (!entry)
+              continue;
+            if (this.destroyed)
+              return;
             const entryType = await this._getEntryType(entry);
             if (entryType === "directory" && this._directoryFilter(entry)) {
               if (depth <= this._maxDepth) {
@@ -151,7 +136,8 @@ var ReaddirpStream = class extends Readable {
             break;
           }
           this.parent = await parent;
-          if (this.destroyed) return;
+          if (this.destroyed)
+            return;
         }
       }
     } catch (error) {
@@ -167,22 +153,14 @@ var ReaddirpStream = class extends Readable {
     } catch (error) {
       this._onError(error);
     }
-    return {
-      files,
-      depth,
-      path
-    };
+    return { files, depth, path };
   }
   async _formatEntry(dirent, path) {
     let entry;
     const basename3 = this._isDirent ? dirent.name : dirent;
     try {
       const fullPath = presolve(pjoin(path, basename3));
-      entry = {
-        path: prelative(this._root, fullPath),
-        fullPath,
-        basename: basename3
-      };
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -202,8 +180,10 @@ var ReaddirpStream = class extends Readable {
       return "";
     }
     const stats = entry[this._statsProp];
-    if (stats.isFile()) return "file";
-    if (stats.isDirectory()) return "directory";
+    if (stats.isFile())
+      return "file";
+    if (stats.isDirectory())
+      return "directory";
     if (stats && stats.isSymbolicLink()) {
       const full = entry.fullPath;
       try {
@@ -234,8 +214,10 @@ var ReaddirpStream = class extends Readable {
 };
 function readdirp(root, options = {}) {
   let type = options.entryType || options.type;
-  if (type === "both") type = EntryTypes.FILE_DIR_TYPE;
-  if (type) options.type = type;
+  if (type === "both")
+    type = EntryTypes.FILE_DIR_TYPE;
+  if (type)
+    options.type = type;
   if (!root) {
     throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
   } else if (typeof root !== "string") {
@@ -246,7 +228,6 @@ function readdirp(root, options = {}) {
   options.root = root;
   return new ReaddirpStream(options);
 }
-__name(readdirp, "readdirp");
 
 // ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/handler.js
 init_esm_shims();
@@ -257,8 +238,8 @@ import { type as osType } from "os";
 var STR_DATA = "data";
 var STR_END = "end";
 var STR_CLOSE = "close";
-var EMPTY_FN = /* @__PURE__ */ __name(() => {
-}, "EMPTY_FN");
+var EMPTY_FN = () => {
+};
 var pl = process.platform;
 var isWindows = pl === "win32";
 var isMacos = pl === "darwin";
@@ -278,18 +259,11 @@ var EVENTS = {
 };
 var EV = EVENTS;
 var THROTTLE_MODE_WATCH = "watch";
-var statMethods = {
-  lstat: lstat2,
-  stat: stat2
-};
+var statMethods = { lstat: lstat2, stat: stat2 };
 var KEY_LISTENERS = "listeners";
 var KEY_ERR = "errHandlers";
 var KEY_RAW = "rawEmitters";
-var HANDLER_KEYS = [
-  KEY_LISTENERS,
-  KEY_ERR,
-  KEY_RAW
-];
+var HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
 var binaryExtensions = /* @__PURE__ */ new Set([
   "3dm",
   "3ds",
@@ -553,51 +527,47 @@ var binaryExtensions = /* @__PURE__ */ new Set([
   "zip",
   "zipx"
 ]);
-var isBinaryPath = /* @__PURE__ */ __name((filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase()), "isBinaryPath");
-var foreach = /* @__PURE__ */ __name((val, fn) => {
+var isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+var foreach = (val, fn) => {
   if (val instanceof Set) {
     val.forEach(fn);
   } else {
     fn(val);
   }
-}, "foreach");
-var addAndConvert = /* @__PURE__ */ __name((main, prop, item) => {
+};
+var addAndConvert = (main, prop, item) => {
   let container = main[prop];
   if (!(container instanceof Set)) {
-    main[prop] = container = /* @__PURE__ */ new Set([
-      container
-    ]);
+    main[prop] = container = /* @__PURE__ */ new Set([container]);
   }
   container.add(item);
-}, "addAndConvert");
-var clearItem = /* @__PURE__ */ __name((cont) => (key) => {
+};
+var clearItem = (cont) => (key) => {
   const set = cont[key];
   if (set instanceof Set) {
     set.clear();
   } else {
     delete cont[key];
   }
-}, "clearItem");
-var delFromSet = /* @__PURE__ */ __name((main, prop, item) => {
+};
+var delFromSet = (main, prop, item) => {
   const container = main[prop];
   if (container instanceof Set) {
     container.delete(item);
   } else if (container === item) {
     delete main[prop];
   }
-}, "delFromSet");
-var isEmptySet = /* @__PURE__ */ __name((val) => val instanceof Set ? val.size === 0 : !val, "isEmptySet");
+};
+var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
 function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
-  const handleEvent = /* @__PURE__ */ __name((rawEvent, evPath) => {
+  const handleEvent = (rawEvent, evPath) => {
     listener(path);
-    emitRaw(rawEvent, evPath, {
-      watchedPath: path
-    });
+    emitRaw(rawEvent, evPath, { watchedPath: path });
     if (evPath && path !== evPath) {
       fsWatchBroadcast(sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath));
     }
-  }, "handleEvent");
+  };
   try {
     return fs_watch(path, {
       persistent: options.persistent
@@ -607,21 +577,22 @@ function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
     return void 0;
   }
 }
-__name(createFsWatchInstance, "createFsWatchInstance");
-var fsWatchBroadcast = /* @__PURE__ */ __name((fullPath, listenerType, val1, val2, val3) => {
+var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
   const cont = FsWatchInstances.get(fullPath);
-  if (!cont) return;
+  if (!cont)
+    return;
   foreach(cont[listenerType], (listener) => {
     listener(val1, val2, val3);
   });
-}, "fsWatchBroadcast");
-var setFsWatchListener = /* @__PURE__ */ __name((path, fullPath, options, handlers) => {
+};
+var 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;
+    if (!watcher)
+      return;
     return watcher.close.bind(watcher);
   }
   if (cont) {
@@ -629,11 +600,20 @@ var setFsWatchListener = /* @__PURE__ */ __name((path, fullPath, options, handle
     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 = createFsWatchInstance(
+      path,
+      options,
+      fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
+      errHandler,
+      // no need to use broadcast here
+      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 (cont)
+        cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
           const fd = await open(path, "r");
@@ -665,9 +645,9 @@ var setFsWatchListener = /* @__PURE__ */ __name((path, fullPath, options, handle
       Object.freeze(cont);
     }
   };
-}, "setFsWatchListener");
+};
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = /* @__PURE__ */ __name((path, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -685,10 +665,7 @@ var setFsWatchFileListener = /* @__PURE__ */ __name((path, fullPath, options, ha
       options,
       watcher: watchFile(fullPath, options, (curr, prev) => {
         foreach(cont.rawEmitters, (rawEmitter2) => {
-          rawEmitter2(EV.CHANGE, fullPath, {
-            curr,
-            prev
-          });
+          rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
@@ -708,11 +685,8 @@ var setFsWatchFileListener = /* @__PURE__ */ __name((path, fullPath, options, ha
       Object.freeze(cont);
     }
   };
-}, "setFsWatchFileListener");
+};
 var NodeFsHandler = class {
-  static {
-    __name(this, "NodeFsHandler");
-  }
   constructor(fsW) {
     this.fsw = fsW;
     this._boundHandleError = (error) => fsW._handleError(error);
@@ -733,7 +707,8 @@ var NodeFsHandler = class {
     const options = {
       persistent: opts.persistent
     };
-    if (!listener) listener = EMPTY_FN;
+    if (!listener)
+      listener = EMPTY_FN;
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
@@ -763,13 +738,16 @@ var NodeFsHandler = class {
     const basename3 = sysPath.basename(file);
     const parent = this.fsw._getWatchedDir(dirname3);
     let prevStats = stats;
-    if (parent.has(basename3)) return;
-    const listener = /* @__PURE__ */ __name(async (path, newStats) => {
-      if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
+    if (parent.has(basename3))
+      return;
+    const listener = async (path, newStats) => {
+      if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
+        return;
       if (!newStats || newStats.mtimeMs === 0) {
         try {
           const newStats2 = await stat2(file);
-          if (this.fsw.closed) return;
+          if (this.fsw.closed)
+            return;
           const at = newStats2.atimeMs;
           const mt = newStats2.mtimeMs;
           if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -779,7 +757,8 @@ var NodeFsHandler = class {
             this.fsw._closeFile(path);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
-            if (closer2) this.fsw._addPathCloser(path, closer2);
+            if (closer2)
+              this.fsw._addPathCloser(path, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -794,10 +773,11 @@ var NodeFsHandler = class {
         }
         prevStats = newStats;
       }
-    }, "listener");
+    };
     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;
+      if (!this.fsw._throttle(EV.ADD, file, 0))
+        return;
       this.fsw._emit(EV.ADD, file, stats);
     }
     return closer;
@@ -825,7 +805,8 @@ var NodeFsHandler = class {
         this.fsw._emitReady();
         return true;
       }
-      if (this.fsw.closed) return;
+      if (this.fsw.closed)
+        return;
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
@@ -847,14 +828,16 @@ var NodeFsHandler = class {
   _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
     directory = sysPath.join(directory, "");
     throttler = this.fsw._throttle("readdir", directory, 1e3);
-    if (!throttler) return;
+    if (!throttler)
+      return;
     const previous = this.fsw._getWatchedDir(wh.path);
     const current = /* @__PURE__ */ new Set();
     let stream = this.fsw._readdirp(directory, {
-      fileFilter: /* @__PURE__ */ __name((entry) => wh.filterPath(entry), "fileFilter"),
-      directoryFilter: /* @__PURE__ */ __name((entry) => wh.filterDir(entry), "directoryFilter")
+      fileFilter: (entry) => wh.filterPath(entry),
+      directoryFilter: (entry) => wh.filterDir(entry)
     });
-    if (!stream) return;
+    if (!stream)
+      return;
     stream.on(STR_DATA, async (entry) => {
       if (this.fsw.closed) {
         stream = void 0;
@@ -877,7 +860,8 @@ var NodeFsHandler = class {
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve3, reject) => {
-      if (!stream) return reject();
+      if (!stream)
+        return reject();
       stream.once(STR_END, () => {
         if (this.fsw.closed) {
           stream = void 0;
@@ -891,7 +875,8 @@ var NodeFsHandler = class {
           this.fsw._remove(directory, item);
         });
         stream = void 0;
-        if (wasThrottled) this._handleRead(directory, false, wh, target, dir, depth, throttler);
+        if (wasThrottled)
+          this._handleRead(directory, false, wh, target, dir, depth, throttler);
       });
     });
   }
@@ -920,10 +905,12 @@ var NodeFsHandler = class {
     if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath2)) {
       if (!target) {
         await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
-        if (this.fsw.closed) return;
+        if (this.fsw.closed)
+          return;
       }
       closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
-        if (stats2 && stats2.mtimeMs === 0) return;
+        if (stats2 && stats2.mtimeMs === 0)
+          return;
         this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
       });
     }
@@ -951,7 +938,8 @@ var NodeFsHandler = class {
     }
     try {
       const stats = await statMethods[wh.statMethod](wh.watchPath);
-      if (this.fsw.closed) return;
+      if (this.fsw.closed)
+        return;
       if (this.fsw._isIgnored(wh.watchPath, stats)) {
         ready();
         return false;
@@ -961,20 +949,24 @@ var NodeFsHandler = class {
       if (stats.isDirectory()) {
         const absPath = sysPath.resolve(path);
         const targetPath = follow ? await fsrealpath(path) : path;
-        if (this.fsw.closed) return;
+        if (this.fsw.closed)
+          return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
-        if (this.fsw.closed) return;
+        if (this.fsw.closed)
+          return;
         if (absPath !== targetPath && targetPath !== void 0) {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
         const targetPath = follow ? await fsrealpath(path) : path;
-        if (this.fsw.closed) return;
+        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 (this.fsw.closed)
+          return;
         if (targetPath !== void 0) {
           this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
         }
@@ -982,7 +974,8 @@ var NodeFsHandler = class {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
-      if (closer) this.fsw._addPathCloser(path, closer);
+      if (closer)
+        this.fsw._addPathCloser(path, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
@@ -1004,19 +997,20 @@ var DOUBLE_SLASH_RE = /\/\//;
 var DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
 var REPLACER_RE = /^\.[/\\]/;
 function arrify(item) {
-  return Array.isArray(item) ? item : [
-    item
-  ];
+  return Array.isArray(item) ? item : [item];
 }
-__name(arrify, "arrify");
-var isMatcherObject = /* @__PURE__ */ __name((matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp), "isMatcherObject");
+var 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 === "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.path === string)
+        return true;
       if (matcher.recursive) {
         const relative3 = sysPath2.relative(matcher.path, string);
         if (!relative3) {
@@ -1029,19 +1023,21 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-__name(createPattern, "createPattern");
 function normalizePath(path) {
-  if (typeof path !== "string") throw new Error("string expected");
+  if (typeof path !== "string")
+    throw new Error("string expected");
   path = sysPath2.normalize(path);
   path = path.replace(/\\/g, "/");
   let prepend = false;
-  if (path.startsWith("//")) prepend = true;
+  if (path.startsWith("//"))
+    prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path.match(DOUBLE_SLASH_RE2)) path = path.replace(DOUBLE_SLASH_RE2, "/");
-  if (prepend) path = "/" + path;
+  while (path.match(DOUBLE_SLASH_RE2))
+    path = path.replace(DOUBLE_SLASH_RE2, "/");
+  if (prepend)
+    path = "/" + path;
   return path;
 }
-__name(normalizePath, "normalizePath");
 function matchPatterns(patterns, testString, stats) {
   const path = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
@@ -1052,7 +1048,6 @@ function matchPatterns(patterns, testString, stats) {
   }
   return false;
 }
-__name(matchPatterns, "matchPatterns");
 function anymatch(matchers, testString) {
   if (matchers == null) {
     throw new TypeError("anymatch: specify first argument");
@@ -1066,15 +1061,14 @@ function anymatch(matchers, testString) {
   }
   return matchPatterns(patterns, testString);
 }
-__name(anymatch, "anymatch");
-var unifyPaths = /* @__PURE__ */ __name((paths_) => {
+var 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);
-}, "unifyPaths");
-var toUnix = /* @__PURE__ */ __name((string) => {
+};
+var toUnix = (string) => {
   let str = string.replace(BACK_SLASH_RE, SLASH);
   let prepend = false;
   if (str.startsWith(SLASH_SLASH)) {
@@ -1087,26 +1081,23 @@ var toUnix = /* @__PURE__ */ __name((string) => {
     str = SLASH + str;
   }
   return str;
-}, "toUnix");
-var normalizePathToUnix = /* @__PURE__ */ __name((path) => toUnix(sysPath2.normalize(toUnix(path))), "normalizePathToUnix");
-var normalizeIgnored = /* @__PURE__ */ __name((cwd = "") => (path) => {
+};
+var normalizePathToUnix = (path) => toUnix(sysPath2.normalize(toUnix(path)));
+var normalizeIgnored = (cwd = "") => (path) => {
   if (typeof path === "string") {
     return normalizePathToUnix(sysPath2.isAbsolute(path) ? path : sysPath2.join(cwd, path));
   } else {
     return path;
   }
-}, "normalizeIgnored");
-var getAbsolutePath = /* @__PURE__ */ __name((path, cwd) => {
+};
+var getAbsolutePath = (path, cwd) => {
   if (sysPath2.isAbsolute(path)) {
     return path;
   }
   return sysPath2.join(cwd, path);
-}, "getAbsolutePath");
+};
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
-var DirEntry = class DirEntry2 {
-  static {
-    __name(this, "DirEntry");
-  }
+var DirEntry = class {
   constructor(dir, removeWatcher) {
     this.path = dir;
     this._removeWatcher = removeWatcher;
@@ -1114,14 +1105,18 @@ var DirEntry = class DirEntry2 {
   }
   add(item) {
     const { items } = this;
-    if (!items) return;
-    if (item !== ONE_DOT && item !== TWO_DOTS) items.add(item);
+    if (!items)
+      return;
+    if (item !== ONE_DOT && item !== TWO_DOTS)
+      items.add(item);
   }
   async remove(item) {
     const { items } = this;
-    if (!items) return;
+    if (!items)
+      return;
     items.delete(item);
-    if (items.size > 0) return;
+    if (items.size > 0)
+      return;
     const dir = this.path;
     try {
       await readdir2(dir);
@@ -1133,15 +1128,15 @@ var DirEntry = class DirEntry2 {
   }
   has(item) {
     const { items } = this;
-    if (!items) return;
+    if (!items)
+      return;
     return items.has(item);
   }
   getChildren() {
     const { items } = this;
-    if (!items) return [];
-    return [
-      ...items.values()
-    ];
+    if (!items)
+      return [];
+    return [...items.values()];
   }
   dispose() {
     this.items.clear();
@@ -1154,9 +1149,6 @@ var DirEntry = class DirEntry2 {
 var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 var WatchHelper = class {
-  static {
-    __name(this, "WatchHelper");
-  }
   constructor(path, follow, fsw) {
     this.fsw = fsw;
     const watchPath = path;
@@ -1165,7 +1157,8 @@ var WatchHelper = class {
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
     this.dirParts.forEach((parts) => {
-      if (parts.length > 1) parts.pop();
+      if (parts.length > 1)
+        parts.pop();
     });
     this.followSymlinks = follow;
     this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
@@ -1175,7 +1168,8 @@ var WatchHelper = class {
   }
   filterPath(entry) {
     const { stats } = entry;
-    if (stats && stats.isSymbolicLink()) return this.filterDir(entry);
+    if (stats && stats.isSymbolicLink())
+      return this.filterDir(entry);
     const resolvedPath = this.entryPath(entry);
     return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
   }
@@ -1184,9 +1178,6 @@ var WatchHelper = class {
   }
 };
 var FSWatcher = class extends EventEmitter {
-  static {
-    __name(this, "FSWatcher");
-  }
   // Not indenting methods for history sake; for now.
   constructor(_opts = {}) {
     super();
@@ -1202,10 +1193,7 @@ var FSWatcher = class extends EventEmitter {
     this._readyCount = 0;
     this._readyEmitted = false;
     const awf = _opts.awaitWriteFinish;
-    const DEF_AWF = {
-      stabilityThreshold: 2e3,
-      pollInterval: 100
-    };
+    const DEF_AWF = { stabilityThreshold: 2e3, pollInterval: 100 };
     const opts = {
       // Defaults
       persistent: true,
@@ -1217,25 +1205,29 @@ var FSWatcher = class extends EventEmitter {
       usePolling: false,
       // useAsync: false,
       atomic: true,
+      // NOTE: overwritten later (depends on usePolling)
       ..._opts,
       // Change format
       ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
-      awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? {
-        ...DEF_AWF,
-        ...awf
-      } : false
+      awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
     };
-    if (isIBMi) opts.usePolling = true;
-    if (opts.atomic === void 0) opts.atomic = !opts.usePolling;
+    if (isIBMi)
+      opts.usePolling = true;
+    if (opts.atomic === void 0)
+      opts.atomic = !opts.usePolling;
     const envPoll = process.env.CHOKIDAR_USEPOLLING;
     if (envPoll !== void 0) {
       const envLower = envPoll.toLowerCase();
-      if (envLower === "false" || envLower === "0") opts.usePolling = false;
-      else if (envLower === "true" || envLower === "1") opts.usePolling = true;
-      else opts.usePolling = !!envLower;
+      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);
+    if (envInterval)
+      opts.interval = Number.parseInt(envInterval, 10);
     let readyCalls = 0;
     this._emitReady = () => {
       readyCalls++;
@@ -1291,16 +1283,20 @@ var FSWatcher = class extends EventEmitter {
       this._removeIgnoredPath(path);
     });
     this._userIgnored = void 0;
-    if (!this._readyCount) this._readyCount = 0;
+    if (!this._readyCount)
+      this._readyCount = 0;
     this._readyCount += paths.length;
     Promise.all(paths.map(async (path) => {
       const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, void 0, 0, _origAdd);
-      if (res) this._emitReady();
+      if (res)
+        this._emitReady();
       return res;
     })).then((results) => {
-      if (this.closed) return;
+      if (this.closed)
+        return;
       results.forEach((item) => {
-        if (item) this.add(sysPath2.dirname(item), sysPath2.basename(_origAdd || item));
+        if (item)
+          this.add(sysPath2.dirname(item), sysPath2.basename(_origAdd || item));
       });
     });
     return this;
@@ -1309,12 +1305,14 @@ var FSWatcher = class extends EventEmitter {
    * Close watchers or start ignoring events from specified paths.
    */
   unwatch(paths_) {
-    if (this.closed) return this;
+    if (this.closed)
+      return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
     paths.forEach((path) => {
       if (!sysPath2.isAbsolute(path) && !this._closers.has(path)) {
-        if (cwd) path = sysPath2.join(cwd, path);
+        if (cwd)
+          path = sysPath2.join(cwd, path);
         path = sysPath2.resolve(path);
       }
       this._closePath(path);
@@ -1341,7 +1339,8 @@ var FSWatcher = class extends EventEmitter {
     const closers = [];
     this._closers.forEach((closerList) => closerList.forEach((closer) => {
       const promise = closer();
-      if (promise instanceof Promise) closers.push(promise);
+      if (promise instanceof Promise)
+        closers.push(promise);
     }));
     this._streams.forEach((stream) => stream.destroy());
     this._userIgnored = void 0;
@@ -1371,7 +1370,8 @@ var FSWatcher = class extends EventEmitter {
   }
   emitWithAll(event, args) {
     this.emit(event, ...args);
-    if (event !== EVENTS.ERROR) this.emit(EVENTS.ALL, event, ...args);
+    if (event !== EVENTS.ERROR)
+      this.emit(EVENTS.ALL, event, ...args);
   }
   // Common helpers
   // --------------
@@ -1384,14 +1384,16 @@ var FSWatcher = class extends EventEmitter {
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
   async _emit(event, path, stats) {
-    if (this.closed) return;
+    if (this.closed)
+      return;
     const opts = this.options;
-    if (isWindows) path = sysPath2.normalize(path);
-    if (opts.cwd) path = sysPath2.relative(opts.cwd, path);
-    const args = [
-      path
-    ];
-    if (stats != null) args.push(stats);
+    if (isWindows)
+      path = sysPath2.normalize(path);
+    if (opts.cwd)
+      path = sysPath2.relative(opts.cwd, path);
+    const args = [path];
+    if (stats != null)
+      args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
     if (awf && (pw = this._pendingWrites.get(path))) {
@@ -1400,10 +1402,7 @@ var FSWatcher = class extends EventEmitter {
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path, [
-          event,
-          ...args
-        ]);
+        this._pendingUnlinks.set(path, [event, ...args]);
         setTimeout(() => {
           this._pendingUnlinks.forEach((entry, path2) => {
             this.emit(...entry);
@@ -1419,7 +1418,7 @@ var FSWatcher = class extends EventEmitter {
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
-      const awfEmit = /* @__PURE__ */ __name((err, stats2) => {
+      const awfEmit = (err, stats2) => {
         if (err) {
           event = EVENTS.ERROR;
           args[0] = err;
@@ -1432,13 +1431,14 @@ var FSWatcher = class extends EventEmitter {
           }
           this.emitWithAll(event, args);
         }
-      }, "awfEmit");
+      };
       this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
       const isThrottled = !this._throttle(EVENTS.CHANGE, path, 50);
-      if (isThrottled) return this;
+      if (isThrottled)
+        return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
       const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path) : path;
@@ -1447,7 +1447,8 @@ var FSWatcher = class extends EventEmitter {
         stats2 = await stat3(fullPath);
       } catch (err) {
       }
-      if (!stats2 || this.closed) return;
+      if (!stats2 || this.closed)
+        return;
       args.push(stats2);
     }
     this.emitWithAll(event, args);
@@ -1476,27 +1477,25 @@ var FSWatcher = class extends EventEmitter {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
-    if (!action) throw new Error("invalid throttle");
+    if (!action)
+      throw new Error("invalid throttle");
     const actionPath = action.get(path);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
-    const clear = /* @__PURE__ */ __name(() => {
+    const clear = () => {
       const item = action.get(path);
       const count = item ? item.count : 0;
       action.delete(path);
       clearTimeout(timeoutObject);
-      if (item) clearTimeout(item.timeoutObject);
+      if (item)
+        clearTimeout(item.timeoutObject);
       return count;
-    }, "clear");
-    timeoutObject = setTimeout(clear, timeout);
-    const thr = {
-      timeoutObject,
-      clear,
-      count: 0
     };
+    timeoutObject = setTimeout(clear, timeout);
+    const thr = { timeoutObject, clear, count: 0 };
     action.set(path, thr);
     return thr;
   }
@@ -1513,7 +1512,8 @@ var FSWatcher = class extends EventEmitter {
    */
   _awaitWriteFinish(path, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
-    if (typeof awf !== "object") return;
+    if (typeof awf !== "object")
+      return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
     let fullPath = path;
@@ -1525,7 +1525,8 @@ var FSWatcher = class extends EventEmitter {
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
         if (err || !writes.has(path)) {
-          if (err && err.code !== "ENOENT") awfEmit(err);
+          if (err && err.code !== "ENOENT")
+            awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
@@ -1542,15 +1543,14 @@ var FSWatcher = class extends EventEmitter {
         }
       });
     }
-    __name(awaitWriteFinishFn, "awaitWriteFinishFn");
     if (!writes.has(path)) {
       writes.set(path, {
         lastChange: now,
-        cancelWait: /* @__PURE__ */ __name(() => {
+        cancelWait: () => {
           writes.delete(path);
           clearTimeout(timeoutHandler);
           return event;
-        }, "cancelWait")
+        }
       });
       timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
     }
@@ -1559,18 +1559,14 @@ var FSWatcher = class extends EventEmitter {
    * Determines whether user has asked to ignore this path.
    */
   _isIgnored(path, stats) {
-    if (this.options.atomic && DOT_RE.test(path)) return true;
+    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
-      ];
+      const ignoredPaths = [...this._ignoredPaths];
+      const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
     return this._userIgnored(path, stats);
@@ -1593,7 +1589,8 @@ var FSWatcher = class extends EventEmitter {
    */
   _getWatchedDir(directory) {
     const dir = sysPath2.resolve(directory);
-    if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+    if (!this._watched.has(dir))
+      this._watched.set(dir, new DirEntry(dir, this._boundRemove));
     return this._watched.get(dir);
   }
   // File helpers
@@ -1602,7 +1599,8 @@ var FSWatcher = class extends EventEmitter {
    * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
    */
   _hasReadPermissions(stats) {
-    if (this.options.ignorePermissionErrors) return true;
+    if (this.options.ignorePermissionErrors)
+      return true;
     return Boolean(Number(stats.mode) & 256);
   }
   /**
@@ -1616,7 +1614,8 @@ var FSWatcher = class extends EventEmitter {
     const path = sysPath2.join(directory, item);
     const fullPath = sysPath2.resolve(path);
     isDirectory = isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path, 100)) return;
+    if (!this._throttle("remove", path, 100))
+      return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
@@ -1630,15 +1629,18 @@ var FSWatcher = class extends EventEmitter {
       this._symlinkPaths.delete(fullPath);
     }
     let relPath = path;
-    if (this.options.cwd) relPath = sysPath2.relative(this.options.cwd, path);
+    if (this.options.cwd)
+      relPath = sysPath2.relative(this.options.cwd, path);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
-      if (event === EVENTS.ADD) return;
+      if (event === EVENTS.ADD)
+        return;
     }
     this._watched.delete(path);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
+    if (wasTracked && !this._isIgnored(path))
+      this._emit(eventName, path);
     this._closePath(path);
   }
   /**
@@ -1654,12 +1656,14 @@ var FSWatcher = class extends EventEmitter {
    */
   _closeFile(path) {
     const closers = this._closers.get(path);
-    if (!closers) return;
+    if (!closers)
+      return;
     closers.forEach((closer) => closer());
     this._closers.delete(path);
   }
   _addPathCloser(path, closer) {
-    if (!closer) return;
+    if (!closer)
+      return;
     let list = this._closers.get(path);
     if (!list) {
       list = [];
@@ -1668,14 +1672,9 @@ var FSWatcher = class extends EventEmitter {
     list.push(closer);
   }
   _readdirp(root, opts) {
-    if (this.closed) return;
-    const options = {
-      type: EVENTS.ALL,
-      alwaysStat: true,
-      lstat: true,
-      ...opts,
-      depth: 0
-    };
+    if (this.closed)
+      return;
+    const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
     let stream = readdirp(root, options);
     this._streams.add(stream);
     stream.once(STR_CLOSE, () => {
@@ -1695,11 +1694,7 @@ function watch(paths, options = {}) {
   watcher.add(paths);
   return watcher;
 }
-__name(watch, "watch");
-var esm_default = {
-  watch,
-  FSWatcher
-};
+var esm_default = { watch, FSWatcher };
 export {
   FSWatcher,
   WatchHelper,