@rspack-debug/browser 2.0.1 → 2.0.2

package/dist/index.js

@@ -32022,18 +32022,18 @@ __webpack_require__.add({
             return copy;
         };
     },
-    "../../node_modules/.pnpm/watchpack@2.4.4/node_modules/watchpack/lib/DirectoryWatcher.js" (module, __unused_rspack_exports, __webpack_require__) {
+    "../../node_modules/.pnpm/watchpack@2.5.1/node_modules/watchpack/lib/DirectoryWatcher.js" (module, __unused_rspack_exports, __webpack_require__) {
         var process = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
-        const EventEmitter = __webpack_require__("../../node_modules/.pnpm/events@3.3.0/node_modules/events/events.js").EventEmitter;
-        const fs = __webpack_require__("../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js");
+        const { EventEmitter } = __webpack_require__("../../node_modules/.pnpm/events@3.3.0/node_modules/events/events.js");
         const path = __webpack_require__("../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js");
-        const watchEventSource = __webpack_require__("../../node_modules/.pnpm/watchpack@2.4.4/node_modules/watchpack/lib/watchEventSource.js");
+        const fs = __webpack_require__("../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js");
+        const watchEventSource = __webpack_require__("../../node_modules/.pnpm/watchpack@2.5.1/node_modules/watchpack/lib/watchEventSource.js");
         const EXISTANCE_ONLY_TIME_ENTRY = Object.freeze({});
         let FS_ACCURACY = 2000;
         const IS_OSX = "darwin" === __webpack_require__("../../node_modules/.pnpm/os-browserify@0.3.0/node_modules/os-browserify/browser.js").iD();
         const IS_WIN = "win32" === __webpack_require__("../../node_modules/.pnpm/os-browserify@0.3.0/node_modules/os-browserify/browser.js").iD();
-        const WATCHPACK_POLLING = process.env.WATCHPACK_POLLING;
-        const FORCE_POLLING = `${+WATCHPACK_POLLING}` === WATCHPACK_POLLING ? +WATCHPACK_POLLING : !!WATCHPACK_POLLING && "false" !== WATCHPACK_POLLING;
+        const { WATCHPACK_POLLING } = process.env;
+        const FORCE_POLLING = `${+WATCHPACK_POLLING}` === WATCHPACK_POLLING ? +WATCHPACK_POLLING : Boolean(WATCHPACK_POLLING) && "false" !== WATCHPACK_POLLING;
         function withoutCase(str) {
             return str.toLowerCase();
         }
@@ -32042,15 +32042,28 @@ __webpack_require__.add({
                 if (0 === --times) return callback();
             };
         }
+        function fixupEntryAccuracy(entry) {
+            if (entry.accuracy > FS_ACCURACY) {
+                entry.safeTime = entry.safeTime - entry.accuracy + FS_ACCURACY;
+                entry.accuracy = FS_ACCURACY;
+            }
+        }
+        function ensureFsAccuracy(mtime) {
+            if (!mtime) return;
+            if (FS_ACCURACY > 1 && mtime % 1 !== 0) FS_ACCURACY = 1;
+            else if (FS_ACCURACY > 10 && mtime % 10 !== 0) FS_ACCURACY = 10;
+            else if (FS_ACCURACY > 100 && mtime % 100 !== 0) FS_ACCURACY = 100;
+            else if (FS_ACCURACY > 1000 && mtime % 1000 !== 0) FS_ACCURACY = 1000;
+        }
         class Watcher extends EventEmitter {
-            constructor(directoryWatcher, filePath, startTime){
+            constructor(directoryWatcher, target, startTime){
                 super();
                 this.directoryWatcher = directoryWatcher;
-                this.path = filePath;
+                this.path = target;
                 this.startTime = startTime && +startTime;
             }
             checkStartTime(mtime, initial) {
-                const startTime = this.startTime;
+                const { startTime } = this;
                 if ("number" != typeof startTime) return !initial;
                 return startTime <= mtime;
             }
@@ -32059,7 +32072,7 @@ __webpack_require__.add({
             }
         }
         class DirectoryWatcher extends EventEmitter {
-            constructor(watcherManager, directoryPath, options){
+            constructor(watcherManager, directoryPath, options = {}){
                 super();
                 if (FORCE_POLLING) options.poll = FORCE_POLLING;
                 this.watcherManager = watcherManager;
@@ -32132,11 +32145,12 @@ __webpack_require__.add({
                     if (!initial) this.forEachWatcher(this.path, (w)=>w.emit("change", itemPath, null, type, initial));
                 }
             }
-            setFileTime(filePath, mtime, initial, ignoreWhenEqual, type) {
+            setFileTime(target, mtime, initial, ignoreWhenEqual, type) {
                 const now = Date.now();
-                if (this.ignored(filePath)) return;
-                const old = this.files.get(filePath);
-                let safeTime, accuracy;
+                if (this.ignored(target)) return;
+                const old = this.files.get(target);
+                let safeTime;
+                let accuracy;
                 if (initial) {
                     safeTime = Math.min(now, mtime) + FS_ACCURACY;
                     accuracy = FS_ACCURACY;
@@ -32146,24 +32160,24 @@ __webpack_require__.add({
                     if (old && old.timestamp === mtime && mtime + FS_ACCURACY < now) return;
                 }
                 if (ignoreWhenEqual && old && old.timestamp === mtime) return;
-                this.files.set(filePath, {
+                this.files.set(target, {
                     safeTime,
                     accuracy,
                     timestamp: mtime
                 });
                 if (old) {
-                    if (!initial) this.forEachWatcher(filePath, (w)=>w.emit("change", mtime, type));
+                    if (!initial) this.forEachWatcher(target, (w)=>w.emit("change", mtime, type));
                 } else {
-                    const key = withoutCase(filePath);
+                    const key = withoutCase(target);
                     const count = this.filesWithoutCase.get(key);
                     this.filesWithoutCase.set(key, (count || 0) + 1);
                     if (void 0 !== count) this.doScan(false);
-                    this.forEachWatcher(filePath, (w)=>{
+                    this.forEachWatcher(target, (w)=>{
                         if (!initial || w.checkStartTime(safeTime, initial)) w.emit("change", mtime, type);
                     });
                 }
                 this.forEachWatcher(this.path, (w)=>{
-                    if (!initial || w.checkStartTime(safeTime, initial)) w.emit("change", filePath, safeTime, type, initial);
+                    if (!initial || w.checkStartTime(safeTime, initial)) w.emit("change", target, safeTime, type, initial);
                 });
             }
             setDirectory(directoryPath, birthtime, initial, type) {
@@ -32176,8 +32190,7 @@ __webpack_require__.add({
                         const now = Date.now();
                         if (this.nestedWatching) this.createNestedWatcher(directoryPath);
                         else this.directories.set(directoryPath, true);
-                        let safeTime;
-                        safeTime = initial ? Math.min(now, birthtime) + FS_ACCURACY : now;
+                        const safeTime = initial ? Math.min(now, birthtime) + FS_ACCURACY : now;
                         this.forEachWatcher(directoryPath, (w)=>{
                             if (!initial || w.checkStartTime(safeTime, false)) w.emit("change", birthtime, type);
                         });
@@ -32189,16 +32202,16 @@ __webpack_require__.add({
             }
             createNestedWatcher(directoryPath) {
                 const watcher = this.watcherManager.watchDirectory(directoryPath, 1);
-                watcher.on("change", (filePath, mtime, type, initial)=>{
+                watcher.on("change", (target, mtime, type, initial)=>{
                     this.forEachWatcher(this.path, (w)=>{
-                        if (!initial || w.checkStartTime(mtime, initial)) w.emit("change", filePath, mtime, type, initial);
+                        if (!initial || w.checkStartTime(mtime, initial)) w.emit("change", target, mtime, type, initial);
                     });
                 });
                 this.directories.set(directoryPath, watcher);
             }
             setNestedWatching(flag) {
-                if (!!flag !== this.nestedWatching) {
-                    this.nestedWatching = !!flag;
+                if (this.nestedWatching !== Boolean(flag)) {
+                    this.nestedWatching = Boolean(flag);
                     if (this.nestedWatching) for (const directory of this.directories.keys())this.createNestedWatcher(directory);
                     else for (const [directory, watcher] of this.directories){
                         watcher.close();
@@ -32206,26 +32219,26 @@ __webpack_require__.add({
                     }
                 }
             }
-            watch(filePath, startTime) {
-                const key = withoutCase(filePath);
+            watch(target, startTime) {
+                const key = withoutCase(target);
                 let watchers = this.watchers.get(key);
                 if (void 0 === watchers) {
                     watchers = new Set();
                     this.watchers.set(key, watchers);
                 }
                 this.refs++;
-                const watcher = new Watcher(this, filePath, startTime);
+                const watcher = new Watcher(this, target, startTime);
                 watcher.on("closed", ()=>{
                     if (--this.refs <= 0) return void this.close();
                     watchers.delete(watcher);
                     if (0 === watchers.size) {
                         this.watchers.delete(key);
-                        if (this.path === filePath) this.setNestedWatching(false);
+                        if (this.path === target) this.setNestedWatching(false);
                     }
                 });
                 watchers.add(watcher);
                 let safeTime;
-                if (filePath === this.path) {
+                if (target === this.path) {
                     this.setNestedWatching(true);
                     safeTime = this.lastWatchEvent;
                     for (const entry of this.files.values()){
@@ -32233,24 +32246,24 @@ __webpack_require__.add({
                         safeTime = Math.max(safeTime, entry.safeTime);
                     }
                 } else {
-                    const entry = this.files.get(filePath);
+                    const entry = this.files.get(target);
                     if (entry) {
                         fixupEntryAccuracy(entry);
                         safeTime = entry.safeTime;
                     } else safeTime = 0;
                 }
                 if (safeTime) {
-                    if (safeTime >= startTime) process.nextTick(()=>{
+                    if (startTime && safeTime >= startTime) process.nextTick(()=>{
                         if (this.closed) return;
-                        if (filePath === this.path) watcher.emit("change", filePath, safeTime, "watch (outdated on attach)", true);
+                        if (target === this.path) watcher.emit("change", target, safeTime, "watch (outdated on attach)", true);
                         else watcher.emit("change", safeTime, "watch (outdated on attach)", true);
                     });
                 } else if (this.initialScan) {
-                    if (this.initialScanRemoved.has(filePath)) process.nextTick(()=>{
+                    if (this.initialScanRemoved.has(target)) process.nextTick(()=>{
                         if (this.closed) return;
                         watcher.emit("remove");
                     });
-                } else if (filePath !== this.path && !this.directories.has(filePath) && watcher.checkStartTime(this.initialScanFinished, false)) process.nextTick(()=>{
+                } else if (target !== this.path && !this.directories.has(target) && watcher.checkStartTime(this.initialScanFinished, false)) process.nextTick(()=>{
                     if (this.closed) return;
                     watcher.emit("initial-missing", "watch (missing on attach)");
                 });
@@ -32259,31 +32272,29 @@ __webpack_require__.add({
             onWatchEvent(eventType, filename) {
                 if (this.closed) return;
                 if (!filename) return void this.doScan(false);
-                const filePath = path.join(this.path, filename);
-                if (this.ignored(filePath)) return;
+                const target = path.join(this.path, filename);
+                if (this.ignored(target)) return;
                 if (void 0 === this._activeEvents.get(filename)) {
                     this._activeEvents.set(filename, false);
                     const checkStats = ()=>{
                         if (this.closed) return;
                         this._activeEvents.set(filename, false);
-                        fs.lstat(filePath, (err, stats)=>{
+                        fs.lstat(target, (err, stats)=>{
                             if (this.closed) return;
                             if (true === this._activeEvents.get(filename)) return void process.nextTick(checkStats);
                             this._activeEvents.delete(filename);
                             if (err) {
                                 if ("ENOENT" !== err.code && "EPERM" !== err.code && "EBUSY" !== err.code) this.onStatsError(err);
-                                else if (filename === path.basename(this.path)) {
-                                    if (!fs.existsSync(this.path)) this.onDirectoryRemoved("stat failed");
-                                }
+                                else if (filename === path.basename(this.path) && !fs.existsSync(this.path)) this.onDirectoryRemoved("stat failed");
                             }
                             this.lastWatchEvent = Date.now();
                             if (stats) {
-                                if (stats.isDirectory()) this.setDirectory(filePath, +stats.birthtime || 1, false, eventType);
+                                if (stats.isDirectory()) this.setDirectory(target, +stats.birthtime || 1, false, eventType);
                                 else if (stats.isFile() || stats.isSymbolicLink()) {
-                                    if (stats.mtime) ensureFsAccuracy(stats.mtime);
-                                    this.setFileTime(filePath, +stats.mtime || +stats.ctime || 1, false, false, eventType);
+                                    if (stats.mtime) ensureFsAccuracy(+stats.mtime);
+                                    this.setFileTime(target, +stats.mtime || +stats.ctime || 1, false, false, eventType);
                                 }
-                            } else this.setMissing(filePath, false, eventType);
+                            } else this.setMissing(target, false, eventType);
                         });
                     };
                     process.nextTick(checkStats);
@@ -32292,15 +32303,15 @@ __webpack_require__.add({
             onWatcherError(err) {
                 if (this.closed) return;
                 if (err) {
-                    if ("EPERM" !== err.code && "ENOENT" !== err.code) console.error("Watchpack Error (watcher): " + err);
+                    if ("EPERM" !== err.code && "ENOENT" !== err.code) console.error(`Watchpack Error (watcher): ${err}`);
                     this.onDirectoryRemoved("watch error");
                 }
             }
             onStatsError(err) {
-                if (err) console.error("Watchpack Error (stats): " + err);
+                if (err) console.error(`Watchpack Error (stats): ${err}`);
             }
             onScanError(err) {
-                if (err) console.error("Watchpack Error (initial scan): " + err);
+                if (err) console.error(`Watchpack Error (initial scan): ${err}`);
                 this.onScanFinished();
             }
             onScanFinished() {
@@ -32316,8 +32327,8 @@ __webpack_require__.add({
                 }
                 this.watchInParentDirectory();
                 const type = `directory-removed (${reason})`;
-                for (const directory of this.directories.keys())this.setMissing(directory, null, type);
-                for (const file of this.files.keys())this.setMissing(file, null, type);
+                for (const directory of this.directories.keys())this.setMissing(directory, false, type);
+                for (const file of this.files.keys())this.setMissing(file, false, type);
             }
             watchInParentDirectory() {
                 if (!this.parentWatcher) {
@@ -32404,17 +32415,15 @@ __webpack_require__.add({
                         for (const itemPath of itemPaths)fs.lstat(itemPath, (err2, stats)=>{
                             if (this.closed) return;
                             if (err2) {
-                                if ("ENOENT" === err2.code || "EPERM" === err2.code || "EACCES" === err2.code || "EBUSY" === err2.code || "EINVAL" === err2.code && IS_WIN) this.setMissing(itemPath, initial, "scan (" + err2.code + ")");
+                                if ("ENOENT" === err2.code || "EPERM" === err2.code || "EACCES" === err2.code || "EBUSY" === err2.code || "EINVAL" === err2.code && IS_WIN) this.setMissing(itemPath, initial, `scan (${err2.code})`);
                                 else this.onScanError(err2);
                                 itemFinished();
                                 return;
                             }
                             if (stats.isFile() || stats.isSymbolicLink()) {
-                                if (stats.mtime) ensureFsAccuracy(stats.mtime);
+                                if (stats.mtime) ensureFsAccuracy(+stats.mtime);
                                 this.setFileTime(itemPath, +stats.mtime || +stats.ctime || 1, initial, true, "scan (file)");
-                            } else if (stats.isDirectory()) {
-                                if (!initial || !this.directories.has(itemPath)) this.setDirectory(itemPath, +stats.birthtime || 1, initial, "scan (dir)");
-                            }
+                            } else if (stats.isDirectory() && (!initial || !this.directories.has(itemPath))) this.setDirectory(itemPath, +stats.birthtime || 1, initial, "scan (dir)");
                             itemFinished();
                         });
                         itemFinished();
@@ -32441,7 +32450,7 @@ __webpack_require__.add({
                     obj[this.path] = safeTime;
                 }
                 if (!this.initialScan) for (const watchers of this.watchers.values())for (const watcher of watchers){
-                    const path = watcher.path;
+                    const { path } = watcher;
                     if (!Object.prototype.hasOwnProperty.call(obj, path)) obj[path] = null;
                 }
                 return obj;
@@ -32468,7 +32477,7 @@ __webpack_require__.add({
                     directoryTimestamps.set(this.path, EXISTANCE_ONLY_TIME_ENTRY);
                 }
                 if (!this.initialScan) for (const watchers of this.watchers.values())for (const watcher of watchers){
-                    const path = watcher.path;
+                    const { path } = watcher;
                     if (!fileTimestamps.has(path)) fileTimestamps.set(path, null);
                 }
                 return safeTime;
@@ -32493,21 +32502,9 @@ __webpack_require__.add({
         }
         module.exports = DirectoryWatcher;
         module.exports.EXISTANCE_ONLY_TIME_ENTRY = EXISTANCE_ONLY_TIME_ENTRY;
-        function fixupEntryAccuracy(entry) {
-            if (entry.accuracy > FS_ACCURACY) {
-                entry.safeTime = entry.safeTime - entry.accuracy + FS_ACCURACY;
-                entry.accuracy = FS_ACCURACY;
-            }
-        }
-        function ensureFsAccuracy(mtime) {
-            if (!mtime) return;
-            if (FS_ACCURACY > 1 && mtime % 1 !== 0) FS_ACCURACY = 1;
-            else if (FS_ACCURACY > 10 && mtime % 10 !== 0) FS_ACCURACY = 10;
-            else if (FS_ACCURACY > 100 && mtime % 100 !== 0) FS_ACCURACY = 100;
-            else if (FS_ACCURACY > 1000 && mtime % 1000 !== 0) FS_ACCURACY = 1000;
-        }
+        module.exports.Watcher = Watcher;
     },
-    "../../node_modules/.pnpm/watchpack@2.4.4/node_modules/watchpack/lib/LinkResolver.js" (module, __unused_rspack_exports, __webpack_require__) {
+    "../../node_modules/.pnpm/watchpack@2.5.1/node_modules/watchpack/lib/LinkResolver.js" (module, __unused_rspack_exports, __webpack_require__) {
         var process = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
         const fs = __webpack_require__("./src/browser/fs.ts");
         const path = __webpack_require__("../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js");
@@ -32546,14 +32543,20 @@ __webpack_require__.add({
                         const resultSet = new Set(linkResolved);
                         resultSet.add(realFile);
                         for(let i = 1; i < parentResolved.length; i++)resultSet.add(parentResolved[i]);
-                        result = Object.freeze(Array.from(resultSet));
+                        result = Object.freeze([
+                            ...resultSet
+                        ]);
                     } else if (parentResolved.length > 1) {
-                        result = parentResolved.slice();
+                        result = [
+                            ...parentResolved
+                        ];
                         result[0] = linkResolved[0];
                         result.push(realFile);
                         Object.freeze(result);
                     } else if (linkResolved.length > 1) {
-                        result = linkResolved.slice();
+                        result = [
+                            ...linkResolved
+                        ];
                         result.push(realFile);
                         Object.freeze(result);
                     } else result = Object.freeze([
@@ -32562,9 +32565,11 @@ __webpack_require__.add({
                     ]);
                     this.cache.set(file, result);
                     return result;
-                } catch (e) {
-                    if (!EXPECTED_ERRORS.has(e.code)) throw e;
-                    const result = parentResolved.slice();
+                } catch (err) {
+                    if (err.code && !EXPECTED_ERRORS.has(err.code)) throw err;
+                    const result = [
+                        ...parentResolved
+                    ];
                     result[0] = realFile;
                     Object.freeze(result);
                     this.cache.set(file, result);
@@ -32574,11 +32579,11 @@ __webpack_require__.add({
         }
         module.exports = LinkResolver;
     },
-    "../../node_modules/.pnpm/watchpack@2.4.4/node_modules/watchpack/lib/getWatcherManager.js" (module, __unused_rspack_exports, __webpack_require__) {
+    "../../node_modules/.pnpm/watchpack@2.5.1/node_modules/watchpack/lib/getWatcherManager.js" (module, __unused_rspack_exports, __webpack_require__) {
         const path = __webpack_require__("../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js");
-        const DirectoryWatcher = __webpack_require__("../../node_modules/.pnpm/watchpack@2.4.4/node_modules/watchpack/lib/DirectoryWatcher.js");
+        const DirectoryWatcher = __webpack_require__("../../node_modules/.pnpm/watchpack@2.5.1/node_modules/watchpack/lib/DirectoryWatcher.js");
         class WatcherManager {
-            constructor(options){
+            constructor(options = {}){
                 this.options = options;
                 this.directoryWatchers = new Map();
             }
@@ -32594,10 +32599,10 @@ __webpack_require__.add({
                 }
                 return watcher;
             }
-            watchFile(p, startTime) {
-                const directory = path.dirname(p);
-                if (directory === p) return null;
-                return this.getDirectoryWatcher(directory).watch(p, startTime);
+            watchFile(file, startTime) {
+                const directory = path.dirname(file);
+                if (directory === file) return null;
+                return this.getDirectoryWatcher(directory).watch(file, startTime);
             }
             watchDirectory(directory, startTime) {
                 return this.getDirectoryWatcher(directory).watch(directory, startTime);
@@ -32613,12 +32618,300 @@ __webpack_require__.add({
         };
         module.exports.WatcherManager = WatcherManager;
     },
-    "../../node_modules/.pnpm/watchpack@2.4.4/node_modules/watchpack/lib/reducePlan.js" (module, __unused_rspack_exports, __webpack_require__) {
+    "../../node_modules/.pnpm/watchpack@2.5.1/node_modules/watchpack/lib/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const { EventEmitter } = __webpack_require__("../../node_modules/.pnpm/events@3.3.0/node_modules/events/events.js");
+        const globToRegExp = __webpack_require__("../../node_modules/.pnpm/glob-to-regexp@0.4.1/node_modules/glob-to-regexp/index.js");
+        const LinkResolver = __webpack_require__("../../node_modules/.pnpm/watchpack@2.5.1/node_modules/watchpack/lib/LinkResolver.js");
+        const getWatcherManager = __webpack_require__("../../node_modules/.pnpm/watchpack@2.5.1/node_modules/watchpack/lib/getWatcherManager.js");
+        const watchEventSource = __webpack_require__("../../node_modules/.pnpm/watchpack@2.5.1/node_modules/watchpack/lib/watchEventSource.js");
+        function addWatchersToSet(watchers, set) {
+            for (const ww of watchers){
+                const w = ww.watcher;
+                if (!set.has(w.directoryWatcher)) set.add(w.directoryWatcher);
+            }
+        }
+        const stringToRegexp = (ignored)=>{
+            if (0 === ignored.length) return;
+            const { source } = globToRegExp(ignored, {
+                globstar: true,
+                extended: true
+            });
+            return `${source.slice(0, -1)}(?:$|\\/)`;
+        };
+        const ignoredToFunction = (ignored)=>{
+            if (Array.isArray(ignored)) {
+                const stringRegexps = ignored.map((i)=>stringToRegexp(i)).filter(Boolean);
+                if (0 === stringRegexps.length) return ()=>false;
+                const regexp = new RegExp(stringRegexps.join("|"));
+                return (item)=>regexp.test(item.replace(/\\/g, "/"));
+            }
+            if ("string" == typeof ignored) {
+                const stringRegexp = stringToRegexp(ignored);
+                if (!stringRegexp) return ()=>false;
+                const regexp = new RegExp(stringRegexp);
+                return (item)=>regexp.test(item.replace(/\\/g, "/"));
+            }
+            if (ignored instanceof RegExp) return (item)=>ignored.test(item.replace(/\\/g, "/"));
+            if ("function" == typeof ignored) return ignored;
+            if (!ignored) return ()=>false;
+            else throw new Error(`Invalid option for 'ignored': ${ignored}`);
+        };
+        const normalizeOptions = (options)=>({
+                followSymlinks: Boolean(options.followSymlinks),
+                ignored: ignoredToFunction(options.ignored),
+                poll: options.poll
+            });
+        const normalizeCache = new WeakMap();
+        const cachedNormalizeOptions = (options)=>{
+            const cacheEntry = normalizeCache.get(options);
+            if (void 0 !== cacheEntry) return cacheEntry;
+            const normalized = normalizeOptions(options);
+            normalizeCache.set(options, normalized);
+            return normalized;
+        };
+        class WatchpackFileWatcher {
+            constructor(watchpack, watcher, files){
+                this.files = Array.isArray(files) ? files : [
+                    files
+                ];
+                this.watcher = watcher;
+                watcher.on("initial-missing", (type)=>{
+                    for (const file of this.files)if (!watchpack._missing.has(file)) watchpack._onRemove(file, file, type);
+                });
+                watcher.on("change", (mtime, type, _initial)=>{
+                    for (const file of this.files)watchpack._onChange(file, mtime, file, type);
+                });
+                watcher.on("remove", (type)=>{
+                    for (const file of this.files)watchpack._onRemove(file, file, type);
+                });
+            }
+            update(files) {
+                if (Array.isArray(files)) this.files = files;
+                else if (1 !== this.files.length) this.files = [
+                    files
+                ];
+                else if (this.files[0] !== files) this.files[0] = files;
+            }
+            close() {
+                this.watcher.close();
+            }
+        }
+        class WatchpackDirectoryWatcher {
+            constructor(watchpack, watcher, directories){
+                this.directories = Array.isArray(directories) ? directories : [
+                    directories
+                ];
+                this.watcher = watcher;
+                watcher.on("initial-missing", (type)=>{
+                    for (const item of this.directories)watchpack._onRemove(item, item, type);
+                });
+                watcher.on("change", (file, mtime, type, _initial)=>{
+                    for (const item of this.directories)watchpack._onChange(item, mtime, file, type);
+                });
+                watcher.on("remove", (type)=>{
+                    for (const item of this.directories)watchpack._onRemove(item, item, type);
+                });
+            }
+            update(directories) {
+                if (Array.isArray(directories)) this.directories = directories;
+                else if (1 !== this.directories.length) this.directories = [
+                    directories
+                ];
+                else if (this.directories[0] !== directories) this.directories[0] = directories;
+            }
+            close() {
+                this.watcher.close();
+            }
+        }
+        class Watchpack extends EventEmitter {
+            constructor(options = {}){
+                super();
+                if (!options) options = {};
+                this.options = options;
+                this.aggregateTimeout = "number" == typeof options.aggregateTimeout ? options.aggregateTimeout : 200;
+                this.watcherOptions = cachedNormalizeOptions(options);
+                this.watcherManager = getWatcherManager(this.watcherOptions);
+                this.fileWatchers = new Map();
+                this.directoryWatchers = new Map();
+                this._missing = new Set();
+                this.startTime = void 0;
+                this.paused = false;
+                this.aggregatedChanges = new Set();
+                this.aggregatedRemovals = new Set();
+                this.aggregateTimer = void 0;
+                this._onTimeout = this._onTimeout.bind(this);
+            }
+            watch(arg1, arg2, arg3) {
+                let files;
+                let directories;
+                let missing;
+                let startTime;
+                if (arg2) {
+                    files = arg1;
+                    directories = arg2;
+                    missing = [];
+                    startTime = arg3;
+                } else ({ files = [], directories = [], missing = [], startTime } = arg1);
+                this.paused = false;
+                const { fileWatchers, directoryWatchers } = this;
+                const { ignored } = this.watcherOptions;
+                const filter = (path)=>!ignored(path);
+                const addToMap = (map, key, item)=>{
+                    const list = map.get(key);
+                    if (void 0 === list) map.set(key, item);
+                    else if (Array.isArray(list)) list.push(item);
+                    else map.set(key, [
+                        list,
+                        item
+                    ]);
+                };
+                const fileWatchersNeeded = new Map();
+                const directoryWatchersNeeded = new Map();
+                const missingFiles = new Set();
+                if (this.watcherOptions.followSymlinks) {
+                    const resolver = new LinkResolver();
+                    for (const file of files)if (filter(file)) {
+                        for (const innerFile of resolver.resolve(file))if (file === innerFile || filter(innerFile)) addToMap(fileWatchersNeeded, innerFile, file);
+                    }
+                    for (const file of missing)if (filter(file)) {
+                        for (const innerFile of resolver.resolve(file))if (file === innerFile || filter(innerFile)) {
+                            missingFiles.add(file);
+                            addToMap(fileWatchersNeeded, innerFile, file);
+                        }
+                    }
+                    for (const dir of directories)if (filter(dir)) {
+                        let first = true;
+                        for (const innerItem of resolver.resolve(dir)){
+                            if (filter(innerItem)) addToMap(first ? directoryWatchersNeeded : fileWatchersNeeded, innerItem, dir);
+                            first = false;
+                        }
+                    }
+                } else {
+                    for (const file of files)if (filter(file)) addToMap(fileWatchersNeeded, file, file);
+                    for (const file of missing)if (filter(file)) {
+                        missingFiles.add(file);
+                        addToMap(fileWatchersNeeded, file, file);
+                    }
+                    for (const dir of directories)if (filter(dir)) addToMap(directoryWatchersNeeded, dir, dir);
+                }
+                for (const [key, w] of fileWatchers){
+                    const needed = fileWatchersNeeded.get(key);
+                    if (void 0 === needed) {
+                        w.close();
+                        fileWatchers.delete(key);
+                    } else {
+                        w.update(needed);
+                        fileWatchersNeeded.delete(key);
+                    }
+                }
+                for (const [key, w] of directoryWatchers){
+                    const needed = directoryWatchersNeeded.get(key);
+                    if (void 0 === needed) {
+                        w.close();
+                        directoryWatchers.delete(key);
+                    } else {
+                        w.update(needed);
+                        directoryWatchersNeeded.delete(key);
+                    }
+                }
+                watchEventSource.batch(()=>{
+                    for (const [key, files] of fileWatchersNeeded){
+                        const watcher = this.watcherManager.watchFile(key, startTime);
+                        if (watcher) fileWatchers.set(key, new WatchpackFileWatcher(this, watcher, files));
+                    }
+                    for (const [key, directories] of directoryWatchersNeeded){
+                        const watcher = this.watcherManager.watchDirectory(key, startTime);
+                        if (watcher) directoryWatchers.set(key, new WatchpackDirectoryWatcher(this, watcher, directories));
+                    }
+                });
+                this._missing = missingFiles;
+                this.startTime = startTime;
+            }
+            close() {
+                this.paused = true;
+                if (this.aggregateTimer) clearTimeout(this.aggregateTimer);
+                for (const w of this.fileWatchers.values())w.close();
+                for (const w of this.directoryWatchers.values())w.close();
+                this.fileWatchers.clear();
+                this.directoryWatchers.clear();
+            }
+            pause() {
+                this.paused = true;
+                if (this.aggregateTimer) clearTimeout(this.aggregateTimer);
+            }
+            getTimes() {
+                const directoryWatchers = new Set();
+                addWatchersToSet(this.fileWatchers.values(), directoryWatchers);
+                addWatchersToSet(this.directoryWatchers.values(), directoryWatchers);
+                const obj = Object.create(null);
+                for (const w of directoryWatchers){
+                    const times = w.getTimes();
+                    for (const file of Object.keys(times))obj[file] = times[file];
+                }
+                return obj;
+            }
+            getTimeInfoEntries() {
+                const map = new Map();
+                this.collectTimeInfoEntries(map, map);
+                return map;
+            }
+            collectTimeInfoEntries(fileTimestamps, directoryTimestamps) {
+                const allWatchers = new Set();
+                addWatchersToSet(this.fileWatchers.values(), allWatchers);
+                addWatchersToSet(this.directoryWatchers.values(), allWatchers);
+                for (const w of allWatchers)w.collectTimeInfoEntries(fileTimestamps, directoryTimestamps);
+            }
+            getAggregated() {
+                if (this.aggregateTimer) {
+                    clearTimeout(this.aggregateTimer);
+                    this.aggregateTimer = void 0;
+                }
+                const changes = this.aggregatedChanges;
+                const removals = this.aggregatedRemovals;
+                this.aggregatedChanges = new Set();
+                this.aggregatedRemovals = new Set();
+                return {
+                    changes,
+                    removals
+                };
+            }
+            _onChange(item, mtime, file, type) {
+                file = file || item;
+                if (!this.paused) {
+                    this.emit("change", file, mtime, type);
+                    if (this.aggregateTimer) clearTimeout(this.aggregateTimer);
+                    this.aggregateTimer = setTimeout(this._onTimeout, this.aggregateTimeout);
+                }
+                this.aggregatedRemovals.delete(item);
+                this.aggregatedChanges.add(item);
+            }
+            _onRemove(item, file, type) {
+                file = file || item;
+                if (!this.paused) {
+                    this.emit("remove", file, type);
+                    if (this.aggregateTimer) clearTimeout(this.aggregateTimer);
+                    this.aggregateTimer = setTimeout(this._onTimeout, this.aggregateTimeout);
+                }
+                this.aggregatedChanges.delete(item);
+                this.aggregatedRemovals.add(item);
+            }
+            _onTimeout() {
+                this.aggregateTimer = void 0;
+                const changes = this.aggregatedChanges;
+                const removals = this.aggregatedRemovals;
+                this.aggregatedChanges = new Set();
+                this.aggregatedRemovals = new Set();
+                this.emit("aggregated", changes, removals);
+            }
+        }
+        module.exports = Watchpack;
+    },
+    "../../node_modules/.pnpm/watchpack@2.5.1/node_modules/watchpack/lib/reducePlan.js" (module, __unused_rspack_exports, __webpack_require__) {
         const path = __webpack_require__("../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js");
         module.exports = (plan, limit)=>{
             const treeMap = new Map();
-            for (const [filePath, value] of plan)treeMap.set(filePath, {
-                filePath,
+            for (const [target, value] of plan)treeMap.set(target, {
+                target,
                 parent: void 0,
                 children: void 0,
                 entries: 1,
@@ -32627,12 +32920,12 @@ __webpack_require__.add({
             });
             let currentCount = treeMap.size;
             for (const node of treeMap.values()){
-                const parentPath = path.dirname(node.filePath);
-                if (parentPath !== node.filePath) {
+                const parentPath = path.dirname(node.target);
+                if (parentPath !== node.target) {
                     let parent = treeMap.get(parentPath);
                     if (void 0 === parent) {
                         parent = {
-                            filePath: parentPath,
+                            target: parentPath,
                             parent: void 0,
                             children: [
                                 node
@@ -32675,7 +32968,7 @@ __webpack_require__.add({
                 bestNode.active = true;
                 bestNode.entries = 1;
                 currentCount -= reduction;
-                let parent = bestNode.parent;
+                let { parent } = bestNode;
                 while(parent){
                     parent.entries -= reduction;
                     parent = parent.parent;
@@ -32695,26 +32988,26 @@ __webpack_require__.add({
                     rootNode
                 ]);
                 for (const node of queue)if (!node.active || node === rootNode) {
-                    if (node.value) if (Array.isArray(node.value)) for (const item of node.value)map.set(item, node.filePath);
-                    else map.set(node.value, node.filePath);
+                    if (node.value) if (Array.isArray(node.value)) for (const item of node.value)map.set(item, node.target);
+                    else map.set(node.value, node.target);
                     if (node.children) for (const child of node.children)queue.add(child);
                 }
-                newPlan.set(rootNode.filePath, map);
+                newPlan.set(rootNode.target, map);
             }
             return newPlan;
         };
     },
-    "../../node_modules/.pnpm/watchpack@2.4.4/node_modules/watchpack/lib/watchEventSource.js" (__unused_rspack_module, exports, __webpack_require__) {
+    "../../node_modules/.pnpm/watchpack@2.5.1/node_modules/watchpack/lib/watchEventSource.js" (module, __unused_rspack_exports, __webpack_require__) {
         var process = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
+        const { EventEmitter } = __webpack_require__("../../node_modules/.pnpm/events@3.3.0/node_modules/events/events.js");
         const fs = __webpack_require__("./src/browser/fs.ts");
         const path = __webpack_require__("../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js");
-        const { EventEmitter } = __webpack_require__("../../node_modules/.pnpm/events@3.3.0/node_modules/events/events.js");
-        const reducePlan = __webpack_require__("../../node_modules/.pnpm/watchpack@2.4.4/node_modules/watchpack/lib/reducePlan.js");
+        const reducePlan = __webpack_require__("../../node_modules/.pnpm/watchpack@2.5.1/node_modules/watchpack/lib/reducePlan.js");
         const IS_OSX = "darwin" === __webpack_require__("../../node_modules/.pnpm/os-browserify@0.3.0/node_modules/os-browserify/browser.js").iD();
         const IS_WIN = "win32" === __webpack_require__("../../node_modules/.pnpm/os-browserify@0.3.0/node_modules/os-browserify/browser.js").iD();
         const SUPPORTS_RECURSIVE_WATCHING = IS_OSX || IS_WIN;
         const watcherLimit = +process.env.WATCHPACK_WATCHER_LIMIT || (IS_OSX ? 20 : 10000);
-        const recursiveWatcherLogging = !!process.env.WATCHPACK_RECURSIVE_WATCHER_LOGGING;
+        const recursiveWatcherLogging = Boolean(process.env.WATCHPACK_RECURSIVE_WATCHER_LOGGING);
         let isBatch = false;
         let watcherCount = 0;
         const pendingWatchers = new Map();
@@ -32837,6 +33130,9 @@ __webpack_require__.add({
             }
         }
         class Watcher extends EventEmitter {
+            constructor(){
+                super();
+            }
             close() {
                 if (pendingWatchers.has(this)) return void pendingWatchers.delete(this);
                 const watcher = underlyingWatcher.get(this);
@@ -32913,7 +33209,16 @@ __webpack_require__.add({
                 }
             }
         };
-        exports.watch = (filePath)=>{
+        module.exports.batch = (fn)=>{
+            isBatch = true;
+            try {
+                fn();
+            } finally{
+                isBatch = false;
+                execute();
+            }
+        };
+        module.exports.watch = (filePath)=>{
             const watcher = new Watcher();
             const directWatcher = directWatchers.get(filePath);
             if (void 0 !== directWatcher) {
@@ -32935,306 +33240,6 @@ __webpack_require__.add({
             if (!isBatch) execute();
             return watcher;
         };
-        exports.batch = (fn)=>{
-            isBatch = true;
-            try {
-                fn();
-            } finally{
-                isBatch = false;
-                execute();
-            }
-        };
-    },
-    "../../node_modules/.pnpm/watchpack@2.4.4/node_modules/watchpack/lib/watchpack.js" (module, __unused_rspack_exports, __webpack_require__) {
-        const getWatcherManager = __webpack_require__("../../node_modules/.pnpm/watchpack@2.4.4/node_modules/watchpack/lib/getWatcherManager.js");
-        const LinkResolver = __webpack_require__("../../node_modules/.pnpm/watchpack@2.4.4/node_modules/watchpack/lib/LinkResolver.js");
-        const EventEmitter = __webpack_require__("../../node_modules/.pnpm/events@3.3.0/node_modules/events/events.js").EventEmitter;
-        const globToRegExp = __webpack_require__("../../node_modules/.pnpm/glob-to-regexp@0.4.1/node_modules/glob-to-regexp/index.js");
-        const watchEventSource = __webpack_require__("../../node_modules/.pnpm/watchpack@2.4.4/node_modules/watchpack/lib/watchEventSource.js");
-        const EMPTY_ARRAY = [];
-        const EMPTY_OPTIONS = {};
-        function addWatchersToSet(watchers, set) {
-            for (const ww of watchers){
-                const w = ww.watcher;
-                if (!set.has(w.directoryWatcher)) set.add(w.directoryWatcher);
-            }
-        }
-        const stringToRegexp = (ignored)=>{
-            if (0 === ignored.length) return;
-            const source = globToRegExp(ignored, {
-                globstar: true,
-                extended: true
-            }).source;
-            return source.slice(0, source.length - 1) + "(?:$|\\/)";
-        };
-        const ignoredToFunction = (ignored)=>{
-            if (Array.isArray(ignored)) {
-                const stringRegexps = ignored.map((i)=>stringToRegexp(i)).filter(Boolean);
-                if (0 === stringRegexps.length) return ()=>false;
-                const regexp = new RegExp(stringRegexps.join("|"));
-                return (x)=>regexp.test(x.replace(/\\/g, "/"));
-            }
-            if ("string" == typeof ignored) {
-                const stringRegexp = stringToRegexp(ignored);
-                if (!stringRegexp) return ()=>false;
-                const regexp = new RegExp(stringRegexp);
-                return (x)=>regexp.test(x.replace(/\\/g, "/"));
-            }
-            if (ignored instanceof RegExp) return (x)=>ignored.test(x.replace(/\\/g, "/"));
-            if (ignored instanceof Function) return ignored;
-            if (!ignored) return ()=>false;
-            else throw new Error(`Invalid option for 'ignored': ${ignored}`);
-        };
-        const normalizeOptions = (options)=>({
-                followSymlinks: !!options.followSymlinks,
-                ignored: ignoredToFunction(options.ignored),
-                poll: options.poll
-            });
-        const normalizeCache = new WeakMap();
-        const cachedNormalizeOptions = (options)=>{
-            const cacheEntry = normalizeCache.get(options);
-            if (void 0 !== cacheEntry) return cacheEntry;
-            const normalized = normalizeOptions(options);
-            normalizeCache.set(options, normalized);
-            return normalized;
-        };
-        class WatchpackFileWatcher {
-            constructor(watchpack, watcher, files){
-                this.files = Array.isArray(files) ? files : [
-                    files
-                ];
-                this.watcher = watcher;
-                watcher.on("initial-missing", (type)=>{
-                    for (const file of this.files)if (!watchpack._missing.has(file)) watchpack._onRemove(file, file, type);
-                });
-                watcher.on("change", (mtime, type)=>{
-                    for (const file of this.files)watchpack._onChange(file, mtime, file, type);
-                });
-                watcher.on("remove", (type)=>{
-                    for (const file of this.files)watchpack._onRemove(file, file, type);
-                });
-            }
-            update(files) {
-                if (Array.isArray(files)) this.files = files;
-                else if (1 !== this.files.length) this.files = [
-                    files
-                ];
-                else if (this.files[0] !== files) this.files[0] = files;
-            }
-            close() {
-                this.watcher.close();
-            }
-        }
-        class WatchpackDirectoryWatcher {
-            constructor(watchpack, watcher, directories){
-                this.directories = Array.isArray(directories) ? directories : [
-                    directories
-                ];
-                this.watcher = watcher;
-                watcher.on("initial-missing", (type)=>{
-                    for (const item of this.directories)watchpack._onRemove(item, item, type);
-                });
-                watcher.on("change", (file, mtime, type)=>{
-                    for (const item of this.directories)watchpack._onChange(item, mtime, file, type);
-                });
-                watcher.on("remove", (type)=>{
-                    for (const item of this.directories)watchpack._onRemove(item, item, type);
-                });
-            }
-            update(directories) {
-                if (Array.isArray(directories)) this.directories = directories;
-                else if (1 !== this.directories.length) this.directories = [
-                    directories
-                ];
-                else if (this.directories[0] !== directories) this.directories[0] = directories;
-            }
-            close() {
-                this.watcher.close();
-            }
-        }
-        class Watchpack extends EventEmitter {
-            constructor(options){
-                super();
-                if (!options) options = EMPTY_OPTIONS;
-                this.options = options;
-                this.aggregateTimeout = "number" == typeof options.aggregateTimeout ? options.aggregateTimeout : 200;
-                this.watcherOptions = cachedNormalizeOptions(options);
-                this.watcherManager = getWatcherManager(this.watcherOptions);
-                this.fileWatchers = new Map();
-                this.directoryWatchers = new Map();
-                this._missing = new Set();
-                this.startTime = void 0;
-                this.paused = false;
-                this.aggregatedChanges = new Set();
-                this.aggregatedRemovals = new Set();
-                this.aggregateTimer = void 0;
-                this._onTimeout = this._onTimeout.bind(this);
-            }
-            watch(arg1, arg2, arg3) {
-                let files, directories, missing, startTime;
-                if (arg2) {
-                    files = arg1;
-                    directories = arg2;
-                    missing = EMPTY_ARRAY;
-                    startTime = arg3;
-                } else ({ files = EMPTY_ARRAY, directories = EMPTY_ARRAY, missing = EMPTY_ARRAY, startTime } = arg1);
-                this.paused = false;
-                const fileWatchers = this.fileWatchers;
-                const directoryWatchers = this.directoryWatchers;
-                const ignored = this.watcherOptions.ignored;
-                const filter = (path)=>!ignored(path);
-                const addToMap = (map, key, item)=>{
-                    const list = map.get(key);
-                    if (void 0 === list) map.set(key, item);
-                    else if (Array.isArray(list)) list.push(item);
-                    else map.set(key, [
-                        list,
-                        item
-                    ]);
-                };
-                const fileWatchersNeeded = new Map();
-                const directoryWatchersNeeded = new Map();
-                const missingFiles = new Set();
-                if (this.watcherOptions.followSymlinks) {
-                    const resolver = new LinkResolver();
-                    for (const file of files)if (filter(file)) {
-                        for (const innerFile of resolver.resolve(file))if (file === innerFile || filter(innerFile)) addToMap(fileWatchersNeeded, innerFile, file);
-                    }
-                    for (const file of missing)if (filter(file)) {
-                        for (const innerFile of resolver.resolve(file))if (file === innerFile || filter(innerFile)) {
-                            missingFiles.add(file);
-                            addToMap(fileWatchersNeeded, innerFile, file);
-                        }
-                    }
-                    for (const dir of directories)if (filter(dir)) {
-                        let first = true;
-                        for (const innerItem of resolver.resolve(dir)){
-                            if (filter(innerItem)) addToMap(first ? directoryWatchersNeeded : fileWatchersNeeded, innerItem, dir);
-                            first = false;
-                        }
-                    }
-                } else {
-                    for (const file of files)if (filter(file)) addToMap(fileWatchersNeeded, file, file);
-                    for (const file of missing)if (filter(file)) {
-                        missingFiles.add(file);
-                        addToMap(fileWatchersNeeded, file, file);
-                    }
-                    for (const dir of directories)if (filter(dir)) addToMap(directoryWatchersNeeded, dir, dir);
-                }
-                for (const [key, w] of fileWatchers){
-                    const needed = fileWatchersNeeded.get(key);
-                    if (void 0 === needed) {
-                        w.close();
-                        fileWatchers.delete(key);
-                    } else {
-                        w.update(needed);
-                        fileWatchersNeeded.delete(key);
-                    }
-                }
-                for (const [key, w] of directoryWatchers){
-                    const needed = directoryWatchersNeeded.get(key);
-                    if (void 0 === needed) {
-                        w.close();
-                        directoryWatchers.delete(key);
-                    } else {
-                        w.update(needed);
-                        directoryWatchersNeeded.delete(key);
-                    }
-                }
-                watchEventSource.batch(()=>{
-                    for (const [key, files] of fileWatchersNeeded){
-                        const watcher = this.watcherManager.watchFile(key, startTime);
-                        if (watcher) fileWatchers.set(key, new WatchpackFileWatcher(this, watcher, files));
-                    }
-                    for (const [key, directories] of directoryWatchersNeeded){
-                        const watcher = this.watcherManager.watchDirectory(key, startTime);
-                        if (watcher) directoryWatchers.set(key, new WatchpackDirectoryWatcher(this, watcher, directories));
-                    }
-                });
-                this._missing = missingFiles;
-                this.startTime = startTime;
-            }
-            close() {
-                this.paused = true;
-                if (this.aggregateTimer) clearTimeout(this.aggregateTimer);
-                for (const w of this.fileWatchers.values())w.close();
-                for (const w of this.directoryWatchers.values())w.close();
-                this.fileWatchers.clear();
-                this.directoryWatchers.clear();
-            }
-            pause() {
-                this.paused = true;
-                if (this.aggregateTimer) clearTimeout(this.aggregateTimer);
-            }
-            getTimes() {
-                const directoryWatchers = new Set();
-                addWatchersToSet(this.fileWatchers.values(), directoryWatchers);
-                addWatchersToSet(this.directoryWatchers.values(), directoryWatchers);
-                const obj = Object.create(null);
-                for (const w of directoryWatchers){
-                    const times = w.getTimes();
-                    for (const file of Object.keys(times))obj[file] = times[file];
-                }
-                return obj;
-            }
-            getTimeInfoEntries() {
-                const map = new Map();
-                this.collectTimeInfoEntries(map, map);
-                return map;
-            }
-            collectTimeInfoEntries(fileTimestamps, directoryTimestamps) {
-                const allWatchers = new Set();
-                addWatchersToSet(this.fileWatchers.values(), allWatchers);
-                addWatchersToSet(this.directoryWatchers.values(), allWatchers);
-                const safeTime = {
-                    value: 0
-                };
-                for (const w of allWatchers)w.collectTimeInfoEntries(fileTimestamps, directoryTimestamps, safeTime);
-            }
-            getAggregated() {
-                if (this.aggregateTimer) {
-                    clearTimeout(this.aggregateTimer);
-                    this.aggregateTimer = void 0;
-                }
-                const changes = this.aggregatedChanges;
-                const removals = this.aggregatedRemovals;
-                this.aggregatedChanges = new Set();
-                this.aggregatedRemovals = new Set();
-                return {
-                    changes,
-                    removals
-                };
-            }
-            _onChange(item, mtime, file, type) {
-                file = file || item;
-                if (!this.paused) {
-                    this.emit("change", file, mtime, type);
-                    if (this.aggregateTimer) clearTimeout(this.aggregateTimer);
-                    this.aggregateTimer = setTimeout(this._onTimeout, this.aggregateTimeout);
-                }
-                this.aggregatedRemovals.delete(item);
-                this.aggregatedChanges.add(item);
-            }
-            _onRemove(item, file, type) {
-                file = file || item;
-                if (!this.paused) {
-                    this.emit("remove", file, type);
-                    if (this.aggregateTimer) clearTimeout(this.aggregateTimer);
-                    this.aggregateTimer = setTimeout(this._onTimeout, this.aggregateTimeout);
-                }
-                this.aggregatedChanges.delete(item);
-                this.aggregatedRemovals.add(item);
-            }
-            _onTimeout() {
-                this.aggregateTimer = void 0;
-                const changes = this.aggregatedChanges;
-                const removals = this.aggregatedRemovals;
-                this.aggregatedChanges = new Set();
-                this.aggregatedRemovals = new Set();
-                this.emit("aggregated", changes, removals);
-            }
-        }
-        module.exports = Watchpack;
     },
     "../../node_modules/.pnpm/webpack-sources@3.3.4_patch_hash=0d62122aa5f9ac77d9ad3b4959c3c0492778a5948c0b00b45a673f3facfca327/node_modules/webpack-sources/lib/CachedSource.js" (module, __unused_rspack_exports, __webpack_require__) {
         var Buffer = __webpack_require__("./src/browser/buffer.ts")["Buffer"];
@@ -55160,7 +55165,7 @@ Object.defineProperty(Chunk.prototype, 'getChunkMaps', {
         const chunkNameMap = {};
         for (const chunk of this.getAllAsyncChunks()){
             const id = chunk.id;
-            if (!id) continue;
+            if (void 0 === id) continue;
             const chunkHash = realHash ? chunk.hash : chunk.renderedHash;
             if (chunkHash) chunkHashMap[id] = chunkHash;
             for (const key of Object.keys(chunk.contentHash)){
@@ -55409,6 +55414,22 @@ function _type_of(obj) {
     return obj && "u" > typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
 let _computedKey, _computedKey1, _computedKey2;
+function normalizePathData(data = {}) {
+    const pathData = {
+        filename: data.filename,
+        hash: data.hash,
+        contentHash: data.contentHash,
+        runtime: data.runtime,
+        url: data.url
+    };
+    if (void 0 !== data.id) pathData.id = String(data.id);
+    if (data.chunk) pathData.chunk = {
+        id: void 0 !== data.chunk.id ? String(data.chunk.id) : void 0,
+        name: data.chunk.name,
+        hash: data.chunk.hash
+    };
+    return pathData;
+}
 const checkCompilation = (compilation)=>{
     if (!(compilation instanceof Compilation)) throw new TypeError('The \'compilation\' argument must be an instance of Compilation. This usually occurs when multiple versions of "@rspack/core" are used, or when the code in "@rspack/core" is executed multiple times.');
 };
@@ -55777,30 +55798,22 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
         this.#warnings.splice(0, this.#warnings.length, ...warnings);
     }
     getPath(filename, data = {}) {
-        const pathData = {
-            ...data
-        };
+        const pathData = normalizePathData(data);
         if (data.contentHashType && data.chunk?.contentHash) pathData.contentHash = data.chunk.contentHash[data.contentHashType];
         return this.#inner.getPath(filename, pathData);
     }
     getPathWithInfo(filename, data = {}) {
-        const pathData = {
-            ...data
-        };
+        const pathData = normalizePathData(data);
         if (data.contentHashType && data.chunk?.contentHash) pathData.contentHash = data.chunk.contentHash[data.contentHashType];
         return this.#inner.getPathWithInfo(filename, pathData);
     }
     getAssetPath(filename, data = {}) {
-        const pathData = {
-            ...data
-        };
+        const pathData = normalizePathData(data);
         if (data.contentHashType && data.chunk?.contentHash) pathData.contentHash = data.chunk.contentHash[data.contentHashType];
         return this.#inner.getAssetPath(filename, pathData);
     }
     getAssetPathWithInfo(filename, data = {}) {
-        const pathData = {
-            ...data
-        };
+        const pathData = normalizePathData(data);
         if (data.contentHashType && data.chunk?.contentHash) pathData.contentHash = data.chunk.contentHash[data.contentHashType];
         return this.#inner.getAssetPathWithInfo(filename, pathData);
     }
@@ -61839,7 +61852,7 @@ const applyOutputDefaults = (options, { context, targetProperties: tp, isAffecte
     });
     D(output, 'bundlerInfo', {});
     if ('object' == typeof output.bundlerInfo) {
-        D(output.bundlerInfo, 'version', "2.0.1");
+        D(output.bundlerInfo, 'version', "2.0.2");
         D(output.bundlerInfo, 'bundler', 'rspack');
         D(output.bundlerInfo, 'force', false);
     }
@@ -63497,7 +63510,7 @@ class MultiStats {
             return obj;
         });
         if (childOptions.version) {
-            obj.rspackVersion = "2.0.1";
+            obj.rspackVersion = "2.0.2";
             obj.version = "5.75.0";
         }
         if (childOptions.hash) obj.hash = obj.children.map((j)=>j.hash).join('');
@@ -64162,7 +64175,7 @@ class NodeWatchFileSystem {
         if ('object' != typeof options) throw new Error("Invalid arguments: 'options'");
         if ('function' != typeof callbackUndelayed && callbackUndelayed) throw new Error("Invalid arguments: 'callbackUndelayed'");
         const oldWatcher = this.watcher;
-        const Watchpack = __webpack_require__("../../node_modules/.pnpm/watchpack@2.4.4/node_modules/watchpack/lib/watchpack.js");
+        const Watchpack = __webpack_require__("../../node_modules/.pnpm/watchpack@2.5.1/node_modules/watchpack/lib/index.js");
         this.watcher = new Watchpack(options);
         if (callbackUndelayed) this.watcher?.once('change', callbackUndelayed);
         const fetchTimeInfo = ()=>{
@@ -65012,7 +65025,7 @@ const MODULES_SORTER = {
 const SORTERS = {
     'compilation.chunks': {
         _: (comparators)=>{
-            comparators.push(compareSelect((c)=>c.id, DefaultStatsFactoryPlugin_compareIds));
+            comparators.push(compareSelect((c)=>void 0 === c.id ? void 0 : String(c.id), DefaultStatsFactoryPlugin_compareIds));
         }
     },
     'compilation.modules': MODULES_SORTER,
@@ -65133,7 +65146,10 @@ const SIMPLE_EXTRACTORS = {
                     LogType.error
                 ]) : getLogTypesBitFlag([]);
                 object.logging = {};
-                const compilationLogging = compilation.logging;
+                const compilationLogging = new Map();
+                for (const [origin, logEntries] of compilation.logging)compilationLogging.set(origin, [
+                    ...logEntries
+                ]);
                 for (const { name, ...rest } of context.getInner(compilation).getLogging(acceptedTypes)){
                     const value = compilationLogging.get(name);
                     const entry = {
@@ -65200,7 +65216,7 @@ const SIMPLE_EXTRACTORS = {
         },
         version: (object)=>{
             object.version = "5.75.0";
-            object.rspackVersion = "2.0.1";
+            object.rspackVersion = "2.0.2";
         },
         env: (object, _compilation, _context, { _env })=>{
             object.env = _env;
@@ -70029,7 +70045,7 @@ function transformSync(source, options) {
     const _options = JSON.stringify(options || {});
     return rspack_wasi_browser.transformSync(source, _options);
 }
-const exports_rspackVersion = "2.0.1";
+const exports_rspackVersion = "2.0.2";
 const exports_version = "5.75.0";
 const exports_WebpackError = Error;
 const exports_config = {