@rspack/core 2.1.0-beta.0 → 2.1.0-rc.0

package/compiled/watchpack/index.js

@@ -1,143 +1,6 @@
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 428:
-/***/ ((module) => {
-
-module.exports = function (glob, opts) {
-  if (typeof glob !== 'string') {
-    throw new TypeError('Expected a string');
-  }
-
-  var str = String(glob);
-
-  // The regexp we are building, as a string.
-  var reStr = "";
-
-  // Whether we are matching so called "extended" globs (like bash) and should
-  // support single character matching, matching ranges of characters, group
-  // matching, etc.
-  var extended = opts ? !!opts.extended : false;
-
-  // When globstar is _false_ (default), '/foo/*' is translated a regexp like
-  // '^\/foo\/.*$' which will match any string beginning with '/foo/'
-  // When globstar is _true_, '/foo/*' is translated to regexp like
-  // '^\/foo\/[^/]*$' which will match any string beginning with '/foo/' BUT
-  // which does not have a '/' to the right of it.
-  // E.g. with '/foo/*' these will match: '/foo/bar', '/foo/bar.txt' but
-  // these will not '/foo/bar/baz', '/foo/bar/baz.txt'
-  // Lastely, when globstar is _true_, '/foo/**' is equivelant to '/foo/*' when
-  // globstar is _false_
-  var globstar = opts ? !!opts.globstar : false;
-
-  // If we are doing extended matching, this boolean is true when we are inside
-  // a group (eg {*.html,*.js}), and false otherwise.
-  var inGroup = false;
-
-  // RegExp flags (eg "i" ) to pass in to RegExp constructor.
-  var flags = opts && typeof( opts.flags ) === "string" ? opts.flags : "";
-
-  var c;
-  for (var i = 0, len = str.length; i < len; i++) {
-    c = str[i];
-
-    switch (c) {
-    case "/":
-    case "$":
-    case "^":
-    case "+":
-    case ".":
-    case "(":
-    case ")":
-    case "=":
-    case "!":
-    case "|":
-      reStr += "\\" + c;
-      break;
-
-    case "?":
-      if (extended) {
-        reStr += ".";
-	    break;
-      }
-
-    case "[":
-    case "]":
-      if (extended) {
-        reStr += c;
-	    break;
-      }
-
-    case "{":
-      if (extended) {
-        inGroup = true;
-	    reStr += "(";
-	    break;
-      }
-
-    case "}":
-      if (extended) {
-        inGroup = false;
-	    reStr += ")";
-	    break;
-      }
-
-    case ",":
-      if (inGroup) {
-        reStr += "|";
-	    break;
-      }
-      reStr += "\\" + c;
-      break;
-
-    case "*":
-      // Move over all consecutive "*"'s.
-      // Also store the previous and next characters
-      var prevChar = str[i - 1];
-      var starCount = 1;
-      while(str[i + 1] === "*") {
-        starCount++;
-        i++;
-      }
-      var nextChar = str[i + 1];
-
-      if (!globstar) {
-        // globstar is disabled, so treat any number of "*" as one
-        reStr += ".*";
-      } else {
-        // globstar is enabled, so determine if this is a globstar segment
-        var isGlobstar = starCount > 1                      // multiple "*"'s
-          && (prevChar === "/" || prevChar === undefined)   // from the start of the segment
-          && (nextChar === "/" || nextChar === undefined)   // to the end of the segment
-
-        if (isGlobstar) {
-          // it's a globstar, so match zero or more path segments
-          reStr += "((?:[^/]*(?:\/|$))*)";
-          i++; // move over the "/"
-        } else {
-          // it's not a globstar, so only match one path segment
-          reStr += "([^/]*)";
-        }
-      }
-      break;
-
-    default:
-      reStr += c;
-    }
-  }
-
-  // When regexp 'g' flag is specified don't
-  // constrain the regular expression with ^ & $
-  if (!flags || !~flags.indexOf('g')) {
-    reStr = "^" + reStr + "$";
-  }
-
-  return new RegExp(reStr, flags);
-};
-
-
-/***/ }),
-
 /***/ 648:
 /***/ ((module) => {
 
@@ -1111,7 +974,7 @@ function patch (fs) {
 
 /***/ }),
 
-/***/ 600:
+/***/ 409:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
@@ -1125,7 +988,7 @@ const { EventEmitter } = __nccwpck_require__(434);
 const path = __nccwpck_require__(928);
 const fs = __nccwpck_require__(692);
 
-const watchEventSource = __nccwpck_require__(313);
+const watchEventSource = __nccwpck_require__(92);
 
 /** @typedef {import("./index").IgnoredFunction} IgnoredFunction */
 /** @typedef {import("./index").EventType} EventType */
@@ -1145,13 +1008,28 @@ let FS_ACCURACY = 2000;
 const IS_OSX = (__nccwpck_require__(857).platform)() === "darwin";
 const IS_WIN = (__nccwpck_require__(857).platform)() === "win32";
 
-const { WATCHPACK_POLLING } = process.env;
+const { WATCHPACK_POLLING, WATCHPACK_RETRIES } = process.env;
 const FORCE_POLLING =
 	// @ts-expect-error avoid additional checks
 	`${+WATCHPACK_POLLING}` === WATCHPACK_POLLING
 		? +WATCHPACK_POLLING
 		: Boolean(WATCHPACK_POLLING) && WATCHPACK_POLLING !== "false";
 
+// Number of retries (and delay between retries, in ms) when an fs operation
+// returns EBUSY. EBUSY is transient on Windows when an AV scanner, indexer,
+// or another process briefly locks a file; retrying avoids incorrectly
+// reporting the file as removed (see webpack/watchpack#223, #44).
+//
+// Configurable via `WATCHPACK_RETRIES` env var: an integer >= 0, or "false"
+// to disable retries entirely. Unset / invalid values fall back to 3.
+const BUSY_RETRIES = (() => {
+	if (WATCHPACK_RETRIES === undefined) return 3;
+	if (WATCHPACK_RETRIES === "false") return 0;
+	const n = Number(WATCHPACK_RETRIES);
+	return Number.isFinite(n) && n >= 0 ? Math.floor(n) : 3;
+})();
+const BUSY_RETRY_DELAY = 100;
+
 /**
  * @param {string} str string
  * @returns {string} lower cased string
@@ -1194,6 +1072,38 @@ function ensureFsAccuracy(mtime) {
 	else if (FS_ACCURACY > 1000 && mtime % 1000 !== 0) FS_ACCURACY = 1000;
 }
 
+/**
+ * Call `fs.lstat` with retries on EBUSY. Transient EBUSY errors are common
+ * on Windows when another process (AV scanner, indexer, editor) holds an
+ * open handle on the file. See webpack/watchpack#223, #44.
+ *
+ * The retry count is taken from the `WATCHPACK_RETRIES` env var (default
+ * 3, set to "0" or "false" to disable retrying). The hot path is a single
+ * `fs.lstat` call with one inline callback; the timer and the recursive
+ * call are only scheduled when an EBUSY is actually observed.
+ * @param {string} target target path
+ * @param {{ closed: boolean }} watcher owning watcher (checked between retries)
+ * @param {(err: NodeJS.ErrnoException | null, stats: import("fs").Stats) => void} callback callback
+ * @param {number=} remaining retries remaining (defaults to `BUSY_RETRIES`)
+ */
+function lstatWithRetry(target, watcher, callback, remaining = BUSY_RETRIES) {
+	fs.lstat(target, (err, stats) => {
+		if (
+			err &&
+			/** @type {NodeJS.ErrnoException} */ (err).code === "EBUSY" &&
+			remaining > 0 &&
+			!watcher.closed
+		) {
+			setTimeout(
+				() => lstatWithRetry(target, watcher, callback, remaining - 1),
+				BUSY_RETRY_DELAY,
+			);
+			return;
+		}
+		callback(err, stats);
+	});
+}
+
 /**
  * @typedef {object} FileWatcherEvents
  * @property {(type: EventType) => void} initial-missing initial missing event
@@ -1284,6 +1194,8 @@ class DirectoryWatcher extends EventEmitter {
 		this.filesWithoutCase = new Map();
 		/** @type {Map<string, Watcher<DirectoryWatcherEvents> | boolean>} */
 		this.directories = new Map();
+		/** @type {Map<string, Watcher<FileWatcherEvents>>} */
+		this._symlinkTargetWatchers = new Map();
 		this.lastWatchEvent = 0;
 		this.initialScan = true;
 		this.ignored = options.ignored || (() => false);
@@ -1544,6 +1456,10 @@ class DirectoryWatcher extends EventEmitter {
 					(watcher).close();
 					this.directories.set(directory, true);
 				}
+				for (const w of this._symlinkTargetWatchers.values()) {
+					w.close();
+				}
+				this._symlinkTargetWatchers.clear();
 			}
 		}
 	}
@@ -1667,7 +1583,7 @@ class DirectoryWatcher extends EventEmitter {
 			const checkStats = () => {
 				if (this.closed) return;
 				this._activeEvents.set(filename, false);
-				fs.lstat(target, (err, stats) => {
+				lstatWithRetry(target, this, (err, stats) => {
 					if (this.closed) return;
 					if (this._activeEvents.get(filename) === true) {
 						process.nextTick(checkStats);
@@ -1676,6 +1592,9 @@ class DirectoryWatcher extends EventEmitter {
 					this._activeEvents.delete(filename);
 					// ENOENT happens when the file/directory doesn't exist
 					// EPERM happens when the containing directory doesn't exist
+					// EBUSY happens when another process has the file locked (e.g.
+					// Windows AV scanner). lstatWithRetry already retried before
+					// giving up here.
 					if (err) {
 						if (
 							err.code !== "ENOENT" &&
@@ -1692,6 +1611,13 @@ class DirectoryWatcher extends EventEmitter {
 					}
 					this.lastWatchEvent = Date.now();
 					if (!stats) {
+						// On EBUSY we keep the tracked state: the file is likely still
+						// there and a later event or scan will reconcile. Emitting a
+						// remove here would make the watch appear to stop after a
+						// transient lock (webpack/watchpack#223, #44).
+						if (err && err.code === "EBUSY" && BUSY_RETRIES > 0) {
+							return;
+						}
 						this.setMissing(target, false, eventType);
 					} else if (stats.isDirectory()) {
 						this.setDirectory(target, +stats.birthtime || 1, false, eventType);
@@ -1841,7 +1767,20 @@ class DirectoryWatcher extends EventEmitter {
 			fs.readdir(this.path, (err, items) => {
 				if (this.closed) return;
 				if (err) {
-					if (err.code === "ENOENT" || err.code === "EPERM") {
+					// Mirror the lstat error handling below: treat permission /
+					// invalid-argument / no-device errors on the directory itself
+					// as removed rather than logging "Watchpack Error (initial
+					// scan)". These surface for unreadable mounts (WSL `/mnt/c`,
+					// fuse mounts), unmounted devices (`/efi`), and libuv's
+					// post-Node 22.17 `EINVAL` on protected Windows paths
+					// (see #187).
+					if (
+						err.code === "ENOENT" ||
+						err.code === "EPERM" ||
+						err.code === "EACCES" ||
+						err.code === "ENODEV" ||
+						(err.code === "EINVAL" && IS_WIN)
+					) {
 						this.onDirectoryRemoved("scan readdir failed");
 					} else {
 						this.onScanError(err);
@@ -1918,7 +1857,7 @@ class DirectoryWatcher extends EventEmitter {
 					}
 				});
 				for (const itemPath of itemPaths) {
-					fs.lstat(itemPath, (err2, stats) => {
+					lstatWithRetry(itemPath, this, (err2, stats) => {
 						if (this.closed) return;
 						if (err2) {
 							if (
@@ -1926,39 +1865,115 @@ class DirectoryWatcher extends EventEmitter {
 								err2.code === "EPERM" ||
 								err2.code === "EACCES" ||
 								err2.code === "EBUSY" ||
+								err2.code === "ENODEV" ||
 								// TODO https://github.com/libuv/libuv/pull/4566
 								(err2.code === "EINVAL" && IS_WIN)
 							) {
-								this.setMissing(itemPath, initial, `scan (${err2.code})`);
+								// readdir saw the entry but we can't stat it due to a
+								// transient lock — keep the previously-known entry instead
+								// of incorrectly flagging it as missing.
+								if (
+									!(
+										err2.code === "EBUSY" &&
+										BUSY_RETRIES > 0 &&
+										this.files.has(itemPath)
+									)
+								) {
+									this.setMissing(itemPath, initial, `scan (${err2.code})`);
+								}
 							} else {
 								this.onScanError(err2);
 							}
 							itemFinished();
 							return;
 						}
-						if (stats.isFile() || stats.isSymbolicLink()) {
-							if (stats.mtime) {
-								ensureFsAccuracy(+stats.mtime);
+						/**
+						 * @param {string | null} realPath resolved real path for an outside-dir symlink target
+						 */
+						const apply = (realPath) => {
+							if (stats.isFile() || stats.isSymbolicLink()) {
+								if (stats.mtime) ensureFsAccuracy(+stats.mtime);
+								this.setFileTime(
+									itemPath,
+									+stats.mtime || +stats.ctime || 1,
+									initial,
+									true,
+									"scan (file)",
+								);
+								if (realPath && !this._symlinkTargetWatchers.has(itemPath)) {
+									const w = this.watcherManager.watchFile(realPath, Date.now());
+									if (w) {
+										w.on("change", (mtime, type, wInitial) => {
+											if (wInitial) return;
+											this.setFileTime(itemPath, mtime, false, false, type);
+										});
+										this._symlinkTargetWatchers.set(itemPath, w);
+									}
+								}
+							} else if (
+								stats.isDirectory() &&
+								(!initial || !this.directories.has(itemPath))
+							) {
+								this.setDirectory(
+									itemPath,
+									+stats.birthtime || 1,
+									initial,
+									"scan (dir)",
+								);
 							}
-							this.setFileTime(
-								itemPath,
-								+stats.mtime || +stats.ctime || 1,
-								initial,
-								true,
-								"scan (file)",
-							);
-						} else if (
-							stats.isDirectory() &&
-							(!initial || !this.directories.has(itemPath))
+							itemFinished();
+						};
+						if (
+							this.options.followSymlinks &&
+							this.nestedWatching &&
+							stats.isSymbolicLink()
 						) {
-							this.setDirectory(
-								itemPath,
-								+stats.birthtime || 1,
-								initial,
-								"scan (dir)",
-							);
+							fs.realpath(itemPath, (err3, realPath) => {
+								if (this.closed) return;
+								if (
+									err3 ||
+									!realPath ||
+									withoutCase(path.dirname(realPath)) === withoutCase(this.path)
+								) {
+									apply(null);
+									return;
+								}
+								// Cycle protection: when the symlink's target is the symlink
+								// path itself or one of its ancestors, descending would
+								// create an unbounded chain of `DirectoryWatcher`s as we walk
+								// back into territory we are already watching. Treat the
+								// symlink as a plain entry instead so the symlink itself is
+								// still tracked but no recursion happens.
+								const rel = path.relative(realPath, itemPath);
+								if (!path.isAbsolute(rel) && !rel.startsWith("..")) {
+									apply(null);
+									return;
+								}
+								fs.stat(realPath, (err4, targetStats) => {
+									if (this.closed) return;
+									if (err4 || !targetStats) {
+										apply(null);
+									} else if (targetStats.isFile()) {
+										apply(realPath);
+									} else if (targetStats.isDirectory()) {
+										// Treat a symlink whose target is a directory as a
+										// nested watched directory so files inside the target
+										// propagate change events to the symlink path.
+										this.setDirectory(
+											itemPath,
+											+targetStats.birthtime || +stats.birthtime || 1,
+											initial,
+											"scan (dir)",
+										);
+										itemFinished();
+									} else {
+										apply(null);
+									}
+								});
+							});
+							return;
 						}
-						itemFinished();
+						apply(null);
 					});
 				}
 				itemFinished();
@@ -2056,6 +2071,7 @@ class DirectoryWatcher extends EventEmitter {
 	}
 
 	close() {
+		if (this.closed) return;
 		this.closed = true;
 		this.initialScan = false;
 		if (this.watcher) {
@@ -2069,6 +2085,10 @@ class DirectoryWatcher extends EventEmitter {
 			}
 			this.directories.clear();
 		}
+		for (const w of this._symlinkTargetWatchers.values()) {
+			w.close();
+		}
+		this._symlinkTargetWatchers.clear();
 		if (this.parentWatcher) {
 			this.parentWatcher.close();
 			this.parentWatcher = null;
@@ -2084,7 +2104,7 @@ module.exports.Watcher = Watcher;
 
 /***/ }),
 
-/***/ 703:
+/***/ 366:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
@@ -2206,7 +2226,7 @@ module.exports = LinkResolver;
 
 /***/ }),
 
-/***/ 254:
+/***/ 213:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
@@ -2217,7 +2237,7 @@ module.exports = LinkResolver;
 
 
 const path = __nccwpck_require__(928);
-const DirectoryWatcher = __nccwpck_require__(600);
+const DirectoryWatcher = __nccwpck_require__(409);
 
 /** @typedef {import("./index").EventMap} EventMap */
 /** @typedef {import("./DirectoryWatcher").DirectoryWatcherOptions} DirectoryWatcherOptions */
@@ -2294,7 +2314,7 @@ module.exports.WatcherManager = WatcherManager;
 
 /***/ }),
 
-/***/ 17:
+/***/ 934:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
@@ -2305,10 +2325,10 @@ module.exports.WatcherManager = WatcherManager;
 
 
 const { EventEmitter } = __nccwpck_require__(434);
-const globToRegExp = __nccwpck_require__(428);
-const LinkResolver = __nccwpck_require__(703);
-const getWatcherManager = __nccwpck_require__(254);
-const watchEventSource = __nccwpck_require__(313);
+const LinkResolver = __nccwpck_require__(366);
+const getWatcherManager = __nccwpck_require__(213);
+const globToRegExp = __nccwpck_require__(737);
+const watchEventSource = __nccwpck_require__(92);
 
 /** @typedef {import("./getWatcherManager").WatcherManager} WatcherManager */
 /** @typedef {import("./DirectoryWatcher")} DirectoryWatcher */
@@ -2345,8 +2365,9 @@ const watchEventSource = __nccwpck_require__(313);
 /** @typedef {`scan (${string})` | "change" | "rename" | `watch ${string}` | `directory-removed ${string}`} EventType */
 /** @typedef {{ safeTime: number, timestamp: number, accuracy: number }} Entry */
 /** @typedef {{ safeTime: number }} OnlySafeTimeEntry */
+
 // eslint-disable-next-line jsdoc/ts-no-empty-object-type
-/** @typedef {{}} ExistenceOnlyTimeEntry */
+/** @typedef {{  }} ExistenceOnlyTimeEntry */
 /** @typedef {Map<string, Entry | OnlySafeTimeEntry | ExistenceOnlyTimeEntry | null>} TimeInfoEntries */
 /** @typedef {Set<string>} Changes */
 /** @typedef {Set<string>} Removals */
@@ -2360,10 +2381,8 @@ const watchEventSource = __nccwpck_require__(313);
  */
 function addWatchersToSet(watchers, set) {
 	for (const ww of watchers) {
-		const w = ww.watcher;
-		if (!set.has(w.directoryWatcher)) {
-			set.add(w.directoryWatcher);
-		}
+		// Set.add is already idempotent, so skip the redundant has() probe.
+		set.add(ww.watcher.directoryWatcher);
 	}
 }
 
@@ -2375,31 +2394,47 @@ const stringToRegexp = (ignored) => {
 	if (ignored.length === 0) {
 		return;
 	}
-	const { source } = globToRegExp(ignored, { globstar: true, extended: true });
-	return `${source.slice(0, -1)}(?:$|\\/)`;
+	return `^${globToRegExp(ignored)}(?:$|\\/)`;
 };
 
+/**
+ * Normalizes path separators for regex testing. `String.prototype.replace`
+ * always allocates a new string, even when the pattern finds nothing; for
+ * POSIX paths (the common case) that allocation is pure overhead. Check for
+ * a backslash with `indexOf` first so we skip the copy on paths that are
+ * already normalized.
+ * @param {string} item item
+ * @returns {string} item with backslashes normalized to forward slashes
+ */
+const normalizeSeparators = (item) =>
+	item.includes("\\") ? item.replace(/\\/g, "/") : item;
+
 /**
  * @param {Ignored=} ignored ignored
  * @returns {(item: string) => boolean} ignored to function
  */
 const ignoredToFunction = (ignored) => {
 	if (Array.isArray(ignored)) {
-		const stringRegexps = ignored.map((i) => stringToRegexp(i)).filter(Boolean);
+		const stringRegexps =
+			/** @type {string[]} */
+			(ignored.map((i) => stringToRegexp(i)).filter(Boolean));
 		if (stringRegexps.length === 0) {
 			return () => false;
 		}
-		const regexp = new RegExp(stringRegexps.join("|"));
-		return (item) => regexp.test(item.replace(/\\/g, "/"));
+		const regexp =
+			stringRegexps.length === 1
+				? new RegExp(stringRegexps[0])
+				: new RegExp(stringRegexps.join("|"));
+		return (item) => regexp.test(normalizeSeparators(item));
 	} else if (typeof ignored === "string") {
 		const stringRegexp = stringToRegexp(ignored);
 		if (!stringRegexp) {
 			return () => false;
 		}
 		const regexp = new RegExp(stringRegexp);
-		return (item) => regexp.test(item.replace(/\\/g, "/"));
+		return (item) => regexp.test(normalizeSeparators(item));
 	} else if (ignored instanceof RegExp) {
-		return (item) => ignored.test(item.replace(/\\/g, "/"));
+		return (item) => ignored.test(normalizeSeparators(item));
 	} else if (typeof ignored === "function") {
 		return ignored;
 	} else if (ignored) {
@@ -2763,8 +2798,10 @@ class Watchpack extends EventEmitter {
 		/** @type {Record<string, number>} */
 		const obj = Object.create(null);
 		for (const w of directoryWatchers) {
+			// getTimes() returns a prototype-less object, so for...in is safe
+			// and avoids the throwaway array that Object.keys would allocate.
 			const times = w.getTimes();
-			for (const file of Object.keys(times)) obj[file] = times[file];
+			for (const file in times) obj[file] = times[file];
 		}
 		return obj;
 	}
@@ -2851,12 +2888,35 @@ class Watchpack extends EventEmitter {
 	}
 }
 
-module.exports = Watchpack;
+/**
+ * @template A
+ * @template B
+ * @param {A} obj input a
+ * @param {B} exports input b
+ * @returns {A & B} merged
+ */
+const mergeExports = (obj, exports) => {
+	const descriptors = Object.getOwnPropertyDescriptors(exports);
+	Object.defineProperties(obj, descriptors);
+	return /** @type {A & B} */ (Object.freeze(obj));
+};
+
+/** @typedef {typeof Watchpack & { util: { readonly globToRegExp: typeof globToRegExp } }} WatchpackExports */
+
+module.exports = /** @type {WatchpackExports} */ (
+	mergeExports(Watchpack, {
+		util: {
+			get globToRegExp() {
+				return globToRegExp;
+			},
+		},
+	})
+);
 
 
 /***/ }),
 
-/***/ 240:
+/***/ 817:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
@@ -2929,45 +2989,66 @@ module.exports = (plan, limit) => {
 			}
 		}
 	}
-	// Reduce until limit reached
-	while (currentCount > limit) {
-		// Select node that helps reaching the limit most effectively without overmerging
-		const overLimit = currentCount - limit;
-		let bestNode;
-		let bestCost = Infinity;
+	// Reduce until limit reached. When no reduction is needed at all, skip
+	// building the candidate set entirely to avoid paying for the setup on the
+	// common fast path.
+	if (currentCount > limit) {
+		// Pre-filter candidate nodes so the inner selection loop skips structural
+		// non-candidates entirely. `children` length and parent presence are
+		// fixed after tree construction; only `entries` can change (it can only
+		// decrease), so a node that fails the `entries` check in a later round
+		// is simply skipped via `continue`. When we merge a subtree we drop the
+		// descendants from the candidate set to keep it shrinking over
+		// iterations.
+		/** @type {Set<TreeNode<T>>} */
+		const candidates = new Set();
 		for (const node of treeMap.values()) {
-			if (node.entries <= 1 || !node.children || !node.parent) continue;
+			if (!node.parent || !node.children) continue;
 			if (node.children.length === 0) continue;
 			if (node.children.length === 1 && !node.value) continue;
-			// Try to select the node with has just a bit more entries than we need to reduce
-			// When just a bit more is over 30% over the limit,
-			// also consider just a bit less entries then we need to reduce
-			const cost =
-				node.entries - 1 >= overLimit
-					? node.entries - 1 - overLimit
-					: overLimit - node.entries + 1 + limit * 0.3;
-			if (cost < bestCost) {
-				bestNode = node;
-				bestCost = cost;
+			candidates.add(node);
+		}
+		const costBias = limit * 0.3;
+		while (currentCount > limit) {
+			// Select node that helps reaching the limit most effectively without overmerging
+			const overLimit = currentCount - limit;
+			let bestNode;
+			let bestCost = Infinity;
+			for (const node of candidates) {
+				if (node.entries <= 1) continue;
+				// Try to select the node with has just a bit more entries than we need to reduce
+				// When just a bit more is over 30% over the limit,
+				// also consider just a bit less entries then we need to reduce
+				const diff = node.entries - 1 - overLimit;
+				const cost = diff >= 0 ? diff : -diff + costBias;
+				if (cost < bestCost) {
+					bestNode = node;
+					bestCost = cost;
+					// A cost of 0 means the merge reduces exactly to the limit;
+					// no further candidate can improve on that, so stop scanning.
+					if (cost === 0) break;
+				}
 			}
-		}
-		if (!bestNode) break;
-		// Merge all children
-		const reduction = bestNode.entries - 1;
-		bestNode.active = true;
-		bestNode.entries = 1;
-		currentCount -= reduction;
-		let { parent } = bestNode;
-		while (parent) {
-			parent.entries -= reduction;
-			parent = parent.parent;
-		}
-		const queue = new Set(bestNode.children);
-		for (const node of queue) {
-			node.active = false;
-			node.entries = 0;
-			if (node.children) {
-				for (const child of node.children) queue.add(child);
+			if (!bestNode) break;
+			// Merge all children
+			const reduction = bestNode.entries - 1;
+			bestNode.active = true;
+			bestNode.entries = 1;
+			candidates.delete(bestNode);
+			currentCount -= reduction;
+			let { parent } = bestNode;
+			while (parent) {
+				parent.entries -= reduction;
+				parent = parent.parent;
+			}
+			const queue = new Set(bestNode.children);
+			for (const node of queue) {
+				node.active = false;
+				node.entries = 0;
+				candidates.delete(node);
+				if (node.children) {
+					for (const child of node.children) queue.add(child);
+				}
 			}
 		}
 	}
@@ -3002,7 +3083,157 @@ module.exports = (plan, limit) => {
 
 /***/ }),
 
-/***/ 313:
+/***/ 737:
+/***/ ((module) => {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Haijie Xie @hai-x
+*/
+
+
+
+// Based on https://github.com/fitzgen/glob-to-regexp (MIT)
+// Specialized for watchpack: `extended` and `globstar` always enabled.
+// Returns the regexp source without `^`/`$` anchors.
+
+const CC_EXCLAMATION = 33; // "!"
+const CC_DOLLAR = 36; // "$"
+const CC_LEFT_PARENTHESIS = 40; // "("
+const CC_RIGHT_PARENTHESIS = 41; // ")"
+const CC_ASTERISK = 42; // "*"
+const CC_PLUS = 43; // "+"
+const CC_COMMA = 44; // ","
+const CC_DOT = 46; // "."
+const CC_SLASH = 47; // "/"
+const CC_EQUAL = 61; // "="
+const CC_QUESTION_MARK = 63; // "?"
+const CC_LEFT_BRACKET = 91; // "["
+const CC_RIGHT_BRACKET = 93; // "]"
+const CC_CARET = 94; // "^"
+const CC_LEFT_BRACE = 123; // "{"
+const CC_PIPE = 124; // "|"
+const CC_RIGHT_BRACE = 125; // "}"
+
+/**
+ * @param {string} glob glob pattern
+ * @returns {string} regexp source without anchors
+ */
+module.exports = (glob) => {
+	if (typeof glob !== "string") {
+		throw new TypeError("Expected a string");
+	}
+
+	const len = glob.length;
+	let reStr = "";
+	let inGroup = false;
+	// Start of the current run of literal characters, copied with one slice
+	let literalStart = 0;
+
+	for (let i = 0; i < len; i++) {
+		const cc = glob.charCodeAt(i);
+		const tokenStart = i;
+		let mapped;
+
+		switch (cc) {
+			case CC_SLASH:
+				mapped = "\\/";
+				break;
+			case CC_DOLLAR:
+				mapped = "\\$";
+				break;
+			case CC_CARET:
+				mapped = "\\^";
+				break;
+			case CC_PLUS:
+				mapped = "\\+";
+				break;
+			case CC_DOT:
+				mapped = "\\.";
+				break;
+			case CC_LEFT_PARENTHESIS:
+				mapped = "\\(";
+				break;
+			case CC_RIGHT_PARENTHESIS:
+				mapped = "\\)";
+				break;
+			case CC_EQUAL:
+				mapped = "\\=";
+				break;
+			case CC_EXCLAMATION:
+				mapped = "\\!";
+				break;
+			case CC_PIPE:
+				mapped = "\\|";
+				break;
+			case CC_QUESTION_MARK:
+				mapped = ".";
+				break;
+			case CC_LEFT_BRACKET:
+				mapped = "[";
+				break;
+			case CC_RIGHT_BRACKET:
+				mapped = "]";
+				break;
+			case CC_LEFT_BRACE:
+				inGroup = true;
+				mapped = "(";
+				break;
+			case CC_RIGHT_BRACE:
+				inGroup = false;
+				mapped = ")";
+				break;
+			case CC_COMMA:
+				mapped = inGroup ? "|" : "\\,";
+				break;
+			case CC_ASTERISK: {
+				const atStart = i === 0;
+				const afterSlash = !atStart && glob.charCodeAt(i - 1) === CC_SLASH;
+				let starCount = 1;
+				while (i + 1 < len && glob.charCodeAt(i + 1) === CC_ASTERISK) {
+					starCount++;
+					i++;
+				}
+				const atEnd = i + 1 === len;
+				const beforeSlash = !atEnd && glob.charCodeAt(i + 1) === CC_SLASH;
+				if (
+					starCount > 1 &&
+					(atStart || afterSlash) &&
+					(atEnd || beforeSlash)
+				) {
+					// Globstar segment, matches zero or more path segments
+					mapped = "((?:[^/]*(?:\\/|$))*)";
+					i++; // Move over the "/"
+				} else {
+					// Not a globstar, matches one path segment
+					mapped = "([^/]*)";
+				}
+				break;
+			}
+			default:
+				// Literal character, extend the current run
+				continue;
+		}
+
+		if (literalStart < tokenStart) {
+			reStr += glob.slice(literalStart, tokenStart);
+		}
+		reStr += mapped;
+		literalStart = i + 1;
+	}
+
+	if (literalStart < len) {
+		reStr += literalStart === 0 ? glob : glob.slice(literalStart);
+	}
+
+	return reStr;
+};
+
+
+/***/ }),
+
+/***/ 92:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
@@ -3015,7 +3246,7 @@ module.exports = (plan, limit) => {
 const { EventEmitter } = __nccwpck_require__(434);
 const fs = __nccwpck_require__(896);
 const path = __nccwpck_require__(928);
-const reducePlan = __nccwpck_require__(240);
+const reducePlan = __nccwpck_require__(817);
 
 /** @typedef {import("fs").FSWatcher} FSWatcher */
 /** @typedef {import("./index").EventType} EventType */
@@ -3069,6 +3300,9 @@ function createEPERMError(filePath) {
  * @returns {(type: "rename" | "change", filename: string) => void} handler of change event
  */
 function createHandleChangeEvent(watcher, filePath, handleChangeEvent) {
+	// path.basename(filePath) is invariant for the lifetime of the watcher,
+	// so compute it once rather than on every dispatched event.
+	const ownBasename = path.basename(filePath);
 	return (type, filename) => {
 		// TODO: After Node.js v22, fs.watch(dir) and deleting a dir will trigger the rename change event.
 		// Here we just ignore it and keep the same behavior as before v22
@@ -3076,7 +3310,7 @@ function createHandleChangeEvent(watcher, filePath, handleChangeEvent) {
 		if (
 			type === "rename" &&
 			path.isAbsolute(filename) &&
-			path.basename(filename) === path.basename(filePath)
+			path.basename(filename) === ownBasename
 		) {
 			if (!IS_OSX) {
 				// Before v22, windows will throw EPERM error
@@ -3437,16 +3671,21 @@ module.exports.watch = (filePath) => {
 		directWatcher.add(watcher);
 		return watcher;
 	}
-	let current = filePath;
-	for (;;) {
-		const recursiveWatcher = recursiveWatchers.get(current);
-		if (recursiveWatcher !== undefined) {
-			recursiveWatcher.add(filePath, watcher);
-			return watcher;
+	// Only platforms with recursive fs.watch ever populate recursiveWatchers,
+	// so skip the entire parent walk when the map is empty (always the case
+	// on Linux and the common case before the watcher limit is reached).
+	if (recursiveWatchers.size !== 0) {
+		let current = filePath;
+		for (;;) {
+			const recursiveWatcher = recursiveWatchers.get(current);
+			if (recursiveWatcher !== undefined) {
+				recursiveWatcher.add(filePath, watcher);
+				return watcher;
+			}
+			const parent = path.dirname(current);
+			if (parent === current) break;
+			current = parent;
 		}
-		const parent = path.dirname(current);
-		if (parent === current) break;
-		current = parent;
 	}
 	// Queue up watcher for creation
 	pendingWatchers.set(watcher, filePath);
@@ -3565,7 +3804,7 @@ module.exports = require("util");
 /******/ 	// startup
 /******/ 	// Load entry module and return exports
 /******/ 	// This entry module is referenced by other modules so it can't be inlined
-/******/ 	var __webpack_exports__ = __nccwpck_require__(17);
+/******/ 	var __webpack_exports__ = __nccwpck_require__(934);
 /******/ 	module.exports = __webpack_exports__;
 /******/ 	
 /******/ })()