weapp-vite 5.2.1 → 5.2.2

package/dist/{chunk-LUDOMADB.cjs → chunk-RHQGM7EB.cjs}

@@ -2863,7 +2863,7 @@ var ReaddirpStream = class extends _stream.Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? _promises.lstat : _promises.stat;
     if (wantBigintFsStats) {
-      this._stat = (path23) => statMethod(path23, { bigint: true });
+      this._stat = (path25) => statMethod(path25, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -2888,8 +2888,8 @@ var ReaddirpStream = class extends _stream.Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path23, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path23));
+          const { path: path25, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path25));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -2929,20 +2929,20 @@ var ReaddirpStream = class extends _stream.Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path23, depth) {
+  async _exploreDir(path25, depth) {
     let files;
     try {
-      files = await _promises.readdir.call(void 0, path23, this._rdOptions);
+      files = await _promises.readdir.call(void 0, path25, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path23 };
+    return { files, depth, path: path25 };
   }
-  async _formatEntry(dirent, path23) {
+  async _formatEntry(dirent, path25) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = _path.resolve.call(void 0, _path.join.call(void 0, path23, basename4));
+      const fullPath = _path.resolve.call(void 0, _path.join.call(void 0, path25, basename4));
       entry = { path: _path.relative.call(void 0, this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -3343,16 +3343,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path23, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path25, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path23);
-    emitRaw(rawEvent, evPath, { watchedPath: path23 });
-    if (evPath && path23 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path23, evPath), KEY_LISTENERS, sysPath.join(path23, evPath));
+    listener(path25);
+    emitRaw(rawEvent, evPath, { watchedPath: path25 });
+    if (evPath && path25 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path25, evPath), KEY_LISTENERS, sysPath.join(path25, evPath));
     }
   };
   try {
-    return _fs.watch.call(void 0, path23, {
+    return _fs.watch.call(void 0, path25, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -3368,12 +3368,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path23, fullPath, options, handlers) => {
+var setFsWatchListener = (path25, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path23, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path25, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -3384,7 +3384,7 @@ var setFsWatchListener = (path23, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path23,
+      path25,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -3399,7 +3399,7 @@ var setFsWatchListener = (path23, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await _promises.open.call(void 0, path23, "r");
+          const fd = await _promises.open.call(void 0, path25, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -3430,7 +3430,7 @@ var setFsWatchListener = (path23, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path23, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path25, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -3452,7 +3452,7 @@ var setFsWatchFileListener = (path23, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path23, curr));
+          foreach(cont.listeners, (listener2) => listener2(path25, curr));
         }
       })
     };
@@ -3480,13 +3480,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path23, listener) {
+  _watchWithNodeFs(path25, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path23);
-    const basename4 = sysPath.basename(path23);
+    const directory = sysPath.dirname(path25);
+    const basename4 = sysPath.basename(path25);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename4);
-    const absolutePath = sysPath.resolve(path23);
+    const absolutePath = sysPath.resolve(path25);
     const options = {
       persistent: opts.persistent
     };
@@ -3496,12 +3496,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path23, absolutePath, options, {
+      closer = setFsWatchFileListener(path25, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path23, absolutePath, options, {
+      closer = setFsWatchListener(path25, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -3523,7 +3523,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename4))
       return;
-    const listener = async (path23, newStats) => {
+    const listener = async (path25, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -3537,11 +3537,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path23);
+            this.fsw._closeFile(path25);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path23, closer2);
+              this.fsw._addPathCloser(path25, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -3573,7 +3573,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path23, item) {
+  async _handleSymlink(entry, directory, path25, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -3583,7 +3583,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await _promises.realpath.call(void 0, path23);
+        linkPath = await _promises.realpath.call(void 0, path25);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -3593,12 +3593,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path23, entry.stats);
+          this.fsw._emit(EV.CHANGE, path25, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path23, entry.stats);
+        this.fsw._emit(EV.ADD, path25, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -3627,9 +3627,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path23 = sysPath.join(directory, item);
+      let path25 = sysPath.join(directory, item);
       current2.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path23, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path25, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -3638,8 +3638,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path23 = sysPath.join(dir, sysPath.relative(dir, path23));
-        this._addToNodeFs(path23, initialAdd, wh, depth + 1);
+        path25 = sysPath.join(dir, sysPath.relative(dir, path25));
+        this._addToNodeFs(path25, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve8, reject) => {
@@ -3708,13 +3708,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path23, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path25, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path23) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path25) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path23);
+    const wh = this.fsw._getWatchHelpers(path25);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -3730,8 +3730,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path23);
-        const targetPath = follow ? await _promises.realpath.call(void 0, path23) : path23;
+        const absPath = sysPath.resolve(path25);
+        const targetPath = follow ? await _promises.realpath.call(void 0, path25) : path25;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -3741,29 +3741,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await _promises.realpath.call(void 0, path23) : path23;
+        const targetPath = follow ? await _promises.realpath.call(void 0, path25) : path25;
         if (this.fsw.closed)
           return;
         const parent = sysPath.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path23, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path25, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path23), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path25), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path23, closer);
+        this.fsw._addPathCloser(path25, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path23;
+        return path25;
       }
     }
   }
@@ -3806,26 +3806,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path23) {
-  if (typeof path23 !== "string")
+function normalizePath(path25) {
+  if (typeof path25 !== "string")
     throw new Error("string expected");
-  path23 = sysPath2.normalize(path23);
-  path23 = path23.replace(/\\/g, "/");
+  path25 = sysPath2.normalize(path25);
+  path25 = path25.replace(/\\/g, "/");
   let prepend = false;
-  if (path23.startsWith("//"))
+  if (path25.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path23.match(DOUBLE_SLASH_RE2))
-    path23 = path23.replace(DOUBLE_SLASH_RE2, "/");
+  while (path25.match(DOUBLE_SLASH_RE2))
+    path25 = path25.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path23 = "/" + path23;
-  return path23;
+    path25 = "/" + path25;
+  return path25;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path23 = normalizePath(testString);
+  const path25 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path23, stats)) {
+    if (pattern(path25, stats)) {
       return true;
     }
   }
@@ -3865,19 +3865,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path23) => toUnix(sysPath2.normalize(toUnix(path23)));
-var normalizeIgnored = (cwd = "") => (path23) => {
-  if (typeof path23 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path23) ? path23 : sysPath2.join(cwd, path23));
+var normalizePathToUnix = (path25) => toUnix(sysPath2.normalize(toUnix(path25)));
+var normalizeIgnored = (cwd = "") => (path25) => {
+  if (typeof path25 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path25) ? path25 : sysPath2.join(cwd, path25));
   } else {
-    return path23;
+    return path25;
   }
 };
-var getAbsolutePath = (path23, cwd) => {
-  if (sysPath2.isAbsolute(path23)) {
-    return path23;
+var getAbsolutePath = (path25, cwd) => {
+  if (sysPath2.isAbsolute(path25)) {
+    return path25;
   }
-  return sysPath2.join(cwd, path23);
+  return sysPath2.join(cwd, path25);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -3932,10 +3932,10 @@ var DirEntry = class {
 var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 var WatchHelper = class {
-  constructor(path23, follow, fsw) {
+  constructor(path25, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path23;
-    this.path = path23 = path23.replace(REPLACER_RE, "");
+    const watchPath = path25;
+    this.path = path25 = path25.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -4057,20 +4057,20 @@ var FSWatcher = class extends _events2.EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path23) => {
-        const absPath = getAbsolutePath(path23, cwd);
+      paths = paths.map((path25) => {
+        const absPath = getAbsolutePath(path25, cwd);
         return absPath;
       });
     }
-    paths.forEach((path23) => {
-      this._removeIgnoredPath(path23);
+    paths.forEach((path25) => {
+      this._removeIgnoredPath(path25);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path23) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path23, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path25) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path25, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -4092,17 +4092,17 @@ var FSWatcher = class extends _events2.EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path23) => {
-      if (!sysPath2.isAbsolute(path23) && !this._closers.has(path23)) {
+    paths.forEach((path25) => {
+      if (!sysPath2.isAbsolute(path25) && !this._closers.has(path25)) {
         if (cwd)
-          path23 = sysPath2.join(cwd, path23);
-        path23 = sysPath2.resolve(path23);
+          path25 = sysPath2.join(cwd, path25);
+        path25 = sysPath2.resolve(path25);
       }
-      this._closePath(path23);
-      this._addIgnoredPath(path23);
-      if (this._watched.has(path23)) {
+      this._closePath(path25);
+      this._addIgnoredPath(path25);
+      if (this._watched.has(path25)) {
         this._addIgnoredPath({
-          path: path23,
+          path: path25,
           recursive: true
         });
       }
@@ -4166,38 +4166,38 @@ var FSWatcher = class extends _events2.EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path23, stats) {
+  async _emit(event, path25, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path23 = sysPath2.normalize(path23);
+      path25 = sysPath2.normalize(path25);
     if (opts.cwd)
-      path23 = sysPath2.relative(opts.cwd, path23);
-    const args = [path23];
+      path25 = sysPath2.relative(opts.cwd, path25);
+    const args = [path25];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path23))) {
+    if (awf && (pw = this._pendingWrites.get(path25))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path23, [event, ...args]);
+        this._pendingUnlinks.set(path25, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path24) => {
+          this._pendingUnlinks.forEach((entry, path26) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path24);
+            this._pendingUnlinks.delete(path26);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path23)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path25)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path23);
+        this._pendingUnlinks.delete(path25);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -4215,16 +4215,16 @@ var FSWatcher = class extends _events2.EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path23, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path25, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path23, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path25, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path23) : path23;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path25) : path25;
       let stats2;
       try {
         stats2 = await _promises.stat.call(void 0, fullPath);
@@ -4255,23 +4255,23 @@ var FSWatcher = class extends _events2.EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path23, timeout) {
+  _throttle(actionType, path25, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path23);
+    const actionPath = action.get(path25);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path23);
+      const item = action.get(path25);
       const count = item ? item.count : 0;
-      action.delete(path23);
+      action.delete(path25);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -4279,7 +4279,7 @@ var FSWatcher = class extends _events2.EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path23, thr);
+    action.set(path25, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -4293,44 +4293,44 @@ var FSWatcher = class extends _events2.EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path23, threshold, event, awfEmit) {
+  _awaitWriteFinish(path25, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path23;
-    if (this.options.cwd && !sysPath2.isAbsolute(path23)) {
-      fullPath = sysPath2.join(this.options.cwd, path23);
+    let fullPath = path25;
+    if (this.options.cwd && !sysPath2.isAbsolute(path25)) {
+      fullPath = sysPath2.join(this.options.cwd, path25);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       _fs.stat.call(void 0, fullPath, (err, curStat) => {
-        if (err || !writes.has(path23)) {
+        if (err || !writes.has(path25)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path23).lastChange = now2;
+          writes.get(path25).lastChange = now2;
         }
-        const pw = writes.get(path23);
+        const pw = writes.get(path25);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path23);
+          writes.delete(path25);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path23)) {
-      writes.set(path23, {
+    if (!writes.has(path25)) {
+      writes.set(path25, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path23);
+          writes.delete(path25);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -4341,8 +4341,8 @@ var FSWatcher = class extends _events2.EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path23, stats) {
-    if (this.options.atomic && DOT_RE.test(path23))
+  _isIgnored(path25, stats) {
+    if (this.options.atomic && DOT_RE.test(path25))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -4352,17 +4352,17 @@ var FSWatcher = class extends _events2.EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path23, stats);
+    return this._userIgnored(path25, stats);
   }
-  _isntIgnored(path23, stat6) {
-    return !this._isIgnored(path23, stat6);
+  _isntIgnored(path25, stat6) {
+    return !this._isIgnored(path25, stat6);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path23) {
-    return new WatchHelper(path23, this.options.followSymlinks, this);
+  _getWatchHelpers(path25) {
+    return new WatchHelper(path25, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -4394,63 +4394,63 @@ var FSWatcher = class extends _events2.EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path23 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path23);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path23) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path23, 100))
+    const path25 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path25);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path25) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path25, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path23);
+    const wp = this._getWatchedDir(path25);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path23, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path25, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path23;
+    let relPath = path25;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path23);
+      relPath = sysPath2.relative(this.options.cwd, path25);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path23);
+    this._watched.delete(path25);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path23))
-      this._emit(eventName, path23);
-    this._closePath(path23);
+    if (wasTracked && !this._isIgnored(path25))
+      this._emit(eventName, path25);
+    this._closePath(path25);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path23) {
-    this._closeFile(path23);
-    const dir = sysPath2.dirname(path23);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path23));
+  _closePath(path25) {
+    this._closeFile(path25);
+    const dir = sysPath2.dirname(path25);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path25));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path23) {
-    const closers = this._closers.get(path23);
+  _closeFile(path25) {
+    const closers = this._closers.get(path25);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path23);
+    this._closers.delete(path25);
   }
-  _addPathCloser(path23, closer) {
+  _addPathCloser(path25, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path23);
+    let list = this._closers.get(path25);
     if (!list) {
       list = [];
-      this._closers.set(path23, list);
+      this._closers.set(path25, list);
     }
     list.push(closer);
   }
@@ -6982,12 +6982,12 @@ var PathBase = (_class6 = class {
   /**
    * Get the Path object referenced by the string path, resolved from this Path
    */
-  resolve(path23) {
-    if (!path23) {
+  resolve(path25) {
+    if (!path25) {
       return this;
     }
-    const rootPath = this.getRootString(path23);
-    const dir = path23.substring(rootPath.length);
+    const rootPath = this.getRootString(path25);
+    const dir = path25.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -7739,8 +7739,8 @@ var PathWin32 = (_class7 = class _PathWin32 extends PathBase {
   /**
    * @internal
    */
-  getRootString(path23) {
-    return _path.win32.parse(path23).root;
+  getRootString(path25) {
+    return _path.win32.parse(path25).root;
   }
   /**
    * @internal
@@ -7786,8 +7786,8 @@ var PathPosix = (_class8 = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path23) {
-    return path23.startsWith("/") ? "/" : "";
+  getRootString(path25) {
+    return path25.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -7836,8 +7836,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs18 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs18);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs19 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs19);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = _url.fileURLToPath.call(void 0, cwd);
     }
@@ -7876,11 +7876,11 @@ var PathScurryBase = class {
   /**
    * Get the depth of a provided path, string, or the cwd
    */
-  depth(path23 = this.cwd) {
-    if (typeof path23 === "string") {
-      path23 = this.cwd.resolve(path23);
+  depth(path25 = this.cwd) {
+    if (typeof path25 === "string") {
+      path25 = this.cwd.resolve(path25);
     }
-    return path23.depth();
+    return path25.depth();
   }
   /**
    * Return the cache of child entries.  Exposed so subclasses can create
@@ -8367,9 +8367,9 @@ var PathScurryBase = class {
     process9();
     return results;
   }
-  chdir(path23 = this.cwd) {
+  chdir(path25 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path23 === "string" ? this.cwd.resolve(path23) : path23;
+    this.cwd = typeof path25 === "string" ? this.cwd.resolve(path25) : path25;
     this.cwd[setAsCwd](oldCwd);
   }
 };
@@ -8395,8 +8395,8 @@ var PathScurryWin32 = (_class9 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs18) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs18 });
+  newRoot(fs19) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs19 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -8424,8 +8424,8 @@ var PathScurryPosix = (_class10 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs18) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs18 });
+  newRoot(fs19) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs19 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -8731,8 +8731,8 @@ var MatchRecord = (_class11 = class {constructor() { _class11.prototype.__init28
   }
   // match, absolute, ifdir
   entries() {
-    return [...this.store.entries()].map(([path23, n2]) => [
-      path23,
+    return [...this.store.entries()].map(([path25, n2]) => [
+      path25,
       !!(n2 & 2),
       !!(n2 & 1)
     ]);
@@ -8937,9 +8937,9 @@ var GlobUtil = (_class14 = class {
   
   
   
-  constructor(patterns, path23, opts) {;_class14.prototype.__init32.call(this);_class14.prototype.__init33.call(this);_class14.prototype.__init34.call(this);
+  constructor(patterns, path25, opts) {;_class14.prototype.__init32.call(this);_class14.prototype.__init33.call(this);_class14.prototype.__init34.call(this);
     this.patterns = patterns;
-    this.path = path23;
+    this.path = path25;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -8958,11 +8958,11 @@ var GlobUtil = (_class14 = class {
       });
     }
   }
-  #ignored(path23) {
-    return this.seen.has(path23) || !!_optionalChain([this, 'access', _125 => _125.#ignore, 'optionalAccess', _126 => _126.ignored, 'optionalCall', _127 => _127(path23)]);
+  #ignored(path25) {
+    return this.seen.has(path25) || !!_optionalChain([this, 'access', _125 => _125.#ignore, 'optionalAccess', _126 => _126.ignored, 'optionalCall', _127 => _127(path25)]);
   }
-  #childrenIgnored(path23) {
-    return !!_optionalChain([this, 'access', _128 => _128.#ignore, 'optionalAccess', _129 => _129.childrenIgnored, 'optionalCall', _130 => _130(path23)]);
+  #childrenIgnored(path25) {
+    return !!_optionalChain([this, 'access', _128 => _128.#ignore, 'optionalAccess', _129 => _129.childrenIgnored, 'optionalCall', _130 => _130(path25)]);
   }
   // backpressure mechanism
   pause() {
@@ -9177,8 +9177,8 @@ var GlobUtil = (_class14 = class {
 }, _class14);
 var GlobWalker = (_class15 = class extends GlobUtil {
   __init35() {this.matches = /* @__PURE__ */ new Set()}
-  constructor(patterns, path23, opts) {
-    super(patterns, path23, opts);_class15.prototype.__init35.call(this);;
+  constructor(patterns, path25, opts) {
+    super(patterns, path25, opts);_class15.prototype.__init35.call(this);;
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -9215,8 +9215,8 @@ var GlobWalker = (_class15 = class extends GlobUtil {
 }, _class15);
 var GlobStream = class extends GlobUtil {
   
-  constructor(patterns, path23, opts) {
-    super(patterns, path23, opts);
+  constructor(patterns, path25, opts) {
+    super(patterns, path25, opts);
     this.results = new Minipass({
       signal: this.signal,
       objectMode: true
@@ -9553,44 +9553,44 @@ _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
 var platform_default = process.env.__TESTING_RIMRAF_PLATFORM__ || process.platform;
 
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/path-arg.js
-var pathArg = (path23, opt = {}) => {
-  const type = typeof path23;
+var pathArg = (path25, opt = {}) => {
+  const type = typeof path25;
   if (type !== "string") {
-    const ctor = path23 && type === "object" && path23.constructor;
-    const received = ctor && ctor.name ? `an instance of ${ctor.name}` : type === "object" ? _util.inspect.call(void 0, path23) : `type ${type} ${path23}`;
+    const ctor = path25 && type === "object" && path25.constructor;
+    const received = ctor && ctor.name ? `an instance of ${ctor.name}` : type === "object" ? _util.inspect.call(void 0, path25) : `type ${type} ${path25}`;
     const msg = `The "path" argument must be of type string. Received ${received}`;
     throw Object.assign(new TypeError(msg), {
-      path: path23,
+      path: path25,
       code: "ERR_INVALID_ARG_TYPE"
     });
   }
-  if (/\0/.test(path23)) {
+  if (/\0/.test(path25)) {
     const msg = "path must be a string without null bytes";
     throw Object.assign(new TypeError(msg), {
-      path: path23,
+      path: path25,
       code: "ERR_INVALID_ARG_VALUE"
     });
   }
-  path23 = _path.resolve.call(void 0, path23);
-  const { root } = _path.parse.call(void 0, path23);
-  if (path23 === root && opt.preserveRoot !== false) {
+  path25 = _path.resolve.call(void 0, path25);
+  const { root } = _path.parse.call(void 0, path25);
+  if (path25 === root && opt.preserveRoot !== false) {
     const msg = "refusing to remove root directory without preserveRoot:false";
     throw Object.assign(new Error(msg), {
-      path: path23,
+      path: path25,
       code: "ERR_PRESERVE_ROOT"
     });
   }
   if (platform_default === "win32") {
     const badWinChars = /[*|"<>?:]/;
-    const { root: root2 } = _path.parse.call(void 0, path23);
-    if (badWinChars.test(path23.substring(root2.length))) {
+    const { root: root2 } = _path.parse.call(void 0, path25);
+    if (badWinChars.test(path25.substring(root2.length))) {
       throw Object.assign(new Error("Illegal characters in path."), {
-        path: path23,
+        path: path25,
         code: "EINVAL"
       });
     }
   }
-  return path23;
+  return path25;
 };
 var path_arg_default = pathArg;
 
@@ -9605,16 +9605,16 @@ _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
 
 
 
-var readdirSync2 = (path23) => _fs.readdirSync.call(void 0, path23, { withFileTypes: true });
-var chmod = (path23, mode) => new Promise((res, rej) => actualFS.default.chmod(path23, mode, (er, ...d) => er ? rej(er) : res(...d)));
-var mkdir = (path23, options) => new Promise((res, rej) => actualFS.default.mkdir(path23, options, (er, made) => er ? rej(er) : res(made)));
-var readdir4 = (path23) => new Promise((res, rej) => actualFS.default.readdir(path23, { withFileTypes: true }, (er, data2) => er ? rej(er) : res(data2)));
+var readdirSync2 = (path25) => _fs.readdirSync.call(void 0, path25, { withFileTypes: true });
+var chmod = (path25, mode) => new Promise((res, rej) => actualFS.default.chmod(path25, mode, (er, ...d) => er ? rej(er) : res(...d)));
+var mkdir = (path25, options) => new Promise((res, rej) => actualFS.default.mkdir(path25, options, (er, made) => er ? rej(er) : res(made)));
+var readdir4 = (path25) => new Promise((res, rej) => actualFS.default.readdir(path25, { withFileTypes: true }, (er, data2) => er ? rej(er) : res(data2)));
 var rename = (oldPath, newPath) => new Promise((res, rej) => actualFS.default.rename(oldPath, newPath, (er, ...d) => er ? rej(er) : res(...d)));
-var rm = (path23, options) => new Promise((res, rej) => actualFS.default.rm(path23, options, (er, ...d) => er ? rej(er) : res(...d)));
-var rmdir = (path23) => new Promise((res, rej) => actualFS.default.rmdir(path23, (er, ...d) => er ? rej(er) : res(...d)));
-var stat4 = (path23) => new Promise((res, rej) => actualFS.default.stat(path23, (er, data2) => er ? rej(er) : res(data2)));
-var lstat4 = (path23) => new Promise((res, rej) => actualFS.default.lstat(path23, (er, data2) => er ? rej(er) : res(data2)));
-var unlink = (path23) => new Promise((res, rej) => actualFS.default.unlink(path23, (er, ...d) => er ? rej(er) : res(...d)));
+var rm = (path25, options) => new Promise((res, rej) => actualFS.default.rm(path25, options, (er, ...d) => er ? rej(er) : res(...d)));
+var rmdir = (path25) => new Promise((res, rej) => actualFS.default.rmdir(path25, (er, ...d) => er ? rej(er) : res(...d)));
+var stat4 = (path25) => new Promise((res, rej) => actualFS.default.stat(path25, (er, data2) => er ? rej(er) : res(data2)));
+var lstat4 = (path25) => new Promise((res, rej) => actualFS.default.lstat(path25, (er, data2) => er ? rej(er) : res(data2)));
+var unlink = (path25) => new Promise((res, rej) => actualFS.default.unlink(path25, (er, ...d) => er ? rej(er) : res(...d)));
 var promises = {
   chmod,
   mkdir,
@@ -9633,10 +9633,10 @@ var promises = {
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/readdir-or-error.js
 _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
 var { readdir: readdir5 } = promises;
-var readdirOrError = (path23) => readdir5(path23).catch((er) => er);
-var readdirOrErrorSync = (path23) => {
+var readdirOrError = (path25) => readdir5(path25).catch((er) => er);
+var readdirOrErrorSync = (path25) => {
   try {
-    return readdirSync2(path23);
+    return readdirSync2(path25);
   } catch (er) {
     return er;
   }
@@ -9661,35 +9661,35 @@ var ignoreENOENTSync = (fn) => {
 
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/rimraf-posix.js
 var { lstat: lstat5, rmdir: rmdir2, unlink: unlink2 } = promises;
-var rimrafPosix = async (path23, opt) => {
+var rimrafPosix = async (path25, opt) => {
   if (_optionalChain([opt, 'optionalAccess', _164 => _164.signal, 'optionalAccess', _165 => _165.aborted])) {
     throw opt.signal.reason;
   }
   try {
-    return await rimrafPosixDir(path23, opt, await lstat5(path23));
+    return await rimrafPosixDir(path25, opt, await lstat5(path25));
   } catch (er) {
     if (_optionalChain([er, 'optionalAccess', _166 => _166.code]) === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafPosixSync = (path23, opt) => {
+var rimrafPosixSync = (path25, opt) => {
   if (_optionalChain([opt, 'optionalAccess', _167 => _167.signal, 'optionalAccess', _168 => _168.aborted])) {
     throw opt.signal.reason;
   }
   try {
-    return rimrafPosixDirSync(path23, opt, _fs.lstatSync.call(void 0, path23));
+    return rimrafPosixDirSync(path25, opt, _fs.lstatSync.call(void 0, path25));
   } catch (er) {
     if (_optionalChain([er, 'optionalAccess', _169 => _169.code]) === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafPosixDir = async (path23, opt, ent) => {
+var rimrafPosixDir = async (path25, opt, ent) => {
   if (_optionalChain([opt, 'optionalAccess', _170 => _170.signal, 'optionalAccess', _171 => _171.aborted])) {
     throw opt.signal.reason;
   }
-  const entries = ent.isDirectory() ? await readdirOrError(path23) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path25) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -9699,30 +9699,30 @@ var rimrafPosixDir = async (path23, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path23, ent)) {
+    if (opt.filter && !await opt.filter(path25, ent)) {
       return false;
     }
-    await ignoreENOENT(unlink2(path23));
+    await ignoreENOENT(unlink2(path25));
     return true;
   }
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafPosixDir(_path.resolve.call(void 0, path23, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafPosixDir(_path.resolve.call(void 0, path25, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path23 === _path.parse.call(void 0, path23).root) {
+  if (opt.preserveRoot === false && path25 === _path.parse.call(void 0, path25).root) {
     return false;
   }
-  if (opt.filter && !await opt.filter(path23, ent)) {
+  if (opt.filter && !await opt.filter(path25, ent)) {
     return false;
   }
-  await ignoreENOENT(rmdir2(path23));
+  await ignoreENOENT(rmdir2(path25));
   return true;
 };
-var rimrafPosixDirSync = (path23, opt, ent) => {
+var rimrafPosixDirSync = (path25, opt, ent) => {
   if (_optionalChain([opt, 'optionalAccess', _172 => _172.signal, 'optionalAccess', _173 => _173.aborted])) {
     throw opt.signal.reason;
   }
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path23) : null;
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path25) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -9732,27 +9732,27 @@ var rimrafPosixDirSync = (path23, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path23, ent)) {
+    if (opt.filter && !opt.filter(path25, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => _fs.unlinkSync.call(void 0, path23));
+    ignoreENOENTSync(() => _fs.unlinkSync.call(void 0, path25));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
-    const p = _path.resolve.call(void 0, path23, ent2.name);
+    const p = _path.resolve.call(void 0, path25, ent2.name);
     removedAll = rimrafPosixDirSync(p, opt, ent2) && removedAll;
   }
-  if (opt.preserveRoot === false && path23 === _path.parse.call(void 0, path23).root) {
+  if (opt.preserveRoot === false && path25 === _path.parse.call(void 0, path25).root) {
     return false;
   }
   if (!removedAll) {
     return false;
   }
-  if (opt.filter && !opt.filter(path23, ent)) {
+  if (opt.filter && !opt.filter(path25, ent)) {
     return false;
   }
-  ignoreENOENTSync(() => _fs.rmdirSync.call(void 0, path23));
+  ignoreENOENTSync(() => _fs.rmdirSync.call(void 0, path25));
   return true;
 };
 
@@ -9763,9 +9763,9 @@ _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/fix-eperm.js
 _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
 var { chmod: chmod2 } = promises;
-var fixEPERM = (fn) => async (path23) => {
+var fixEPERM = (fn) => async (path25) => {
   try {
-    return await fn(path23);
+    return await fn(path25);
   } catch (er) {
     const fer = er;
     if (_optionalChain([fer, 'optionalAccess', _174 => _174.code]) === "ENOENT") {
@@ -9773,7 +9773,7 @@ var fixEPERM = (fn) => async (path23) => {
     }
     if (_optionalChain([fer, 'optionalAccess', _175 => _175.code]) === "EPERM") {
       try {
-        await chmod2(path23, 438);
+        await chmod2(path25, 438);
       } catch (er2) {
         const fer2 = er2;
         if (_optionalChain([fer2, 'optionalAccess', _176 => _176.code]) === "ENOENT") {
@@ -9781,14 +9781,14 @@ var fixEPERM = (fn) => async (path23) => {
         }
         throw er;
       }
-      return await fn(path23);
+      return await fn(path25);
     }
     throw er;
   }
 };
-var fixEPERMSync = (fn) => (path23) => {
+var fixEPERMSync = (fn) => (path25) => {
   try {
-    return fn(path23);
+    return fn(path25);
   } catch (er) {
     const fer = er;
     if (_optionalChain([fer, 'optionalAccess', _177 => _177.code]) === "ENOENT") {
@@ -9796,7 +9796,7 @@ var fixEPERMSync = (fn) => (path23) => {
     }
     if (_optionalChain([fer, 'optionalAccess', _178 => _178.code]) === "EPERM") {
       try {
-        _fs.chmodSync.call(void 0, path23, 438);
+        _fs.chmodSync.call(void 0, path25, 438);
       } catch (er2) {
         const fer2 = er2;
         if (_optionalChain([fer2, 'optionalAccess', _179 => _179.code]) === "ENOENT") {
@@ -9804,7 +9804,7 @@ var fixEPERMSync = (fn) => (path23) => {
         }
         throw er;
       }
-      return fn(path23);
+      return fn(path25);
     }
     throw er;
   }
@@ -9817,23 +9817,23 @@ var RATE = 1.2;
 var MAXRETRIES = 10;
 var codes = /* @__PURE__ */ new Set(["EMFILE", "ENFILE", "EBUSY"]);
 var retryBusy = (fn) => {
-  const method = async (path23, opt, backoff = 1, total = 0) => {
+  const method = async (path25, opt, backoff = 1, total = 0) => {
     const mbo = opt.maxBackoff || MAXBACKOFF;
     const rate = opt.backoff || RATE;
     const max = opt.maxRetries || MAXRETRIES;
     let retries = 0;
     while (true) {
       try {
-        return await fn(path23);
+        return await fn(path25);
       } catch (er) {
         const fer = er;
-        if (_optionalChain([fer, 'optionalAccess', _180 => _180.path]) === path23 && _optionalChain([fer, 'optionalAccess', _181 => _181.code]) && codes.has(fer.code)) {
+        if (_optionalChain([fer, 'optionalAccess', _180 => _180.path]) === path25 && _optionalChain([fer, 'optionalAccess', _181 => _181.code]) && codes.has(fer.code)) {
           backoff = Math.ceil(backoff * rate);
           total = backoff + total;
           if (total < mbo) {
             return new Promise((res, rej) => {
               setTimeout(() => {
-                method(path23, opt, backoff, total).then(res, rej);
+                method(path25, opt, backoff, total).then(res, rej);
               }, backoff);
             });
           }
@@ -9849,15 +9849,15 @@ var retryBusy = (fn) => {
   return method;
 };
 var retryBusySync = (fn) => {
-  const method = (path23, opt) => {
+  const method = (path25, opt) => {
     const max = opt.maxRetries || MAXRETRIES;
     let retries = 0;
     while (true) {
       try {
-        return fn(path23);
+        return fn(path25);
       } catch (er) {
         const fer = er;
-        if (_optionalChain([fer, 'optionalAccess', _182 => _182.path]) === path23 && _optionalChain([fer, 'optionalAccess', _183 => _183.code]) && codes.has(fer.code) && retries < max) {
+        if (_optionalChain([fer, 'optionalAccess', _182 => _182.path]) === path25 && _optionalChain([fer, 'optionalAccess', _183 => _183.code]) && codes.has(fer.code) && retries < max) {
           retries++;
           continue;
         }
@@ -9877,16 +9877,16 @@ _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
 
 
 var { stat: stat5 } = promises;
-var isDirSync = (path23) => {
+var isDirSync = (path25) => {
   try {
-    return _fs.statSync.call(void 0, path23).isDirectory();
+    return _fs.statSync.call(void 0, path25).isDirectory();
   } catch (er) {
     return false;
   }
 };
-var isDir = (path23) => stat5(path23).then((st) => st.isDirectory(), () => false);
-var win32DefaultTmp = async (path23) => {
-  const { root } = _path.parse.call(void 0, path23);
+var isDir = (path25) => stat5(path25).then((st) => st.isDirectory(), () => false);
+var win32DefaultTmp = async (path25) => {
+  const { root } = _path.parse.call(void 0, path25);
   const tmp = _os.tmpdir.call(void 0, );
   const { root: tmpRoot } = _path.parse.call(void 0, tmp);
   if (root.toLowerCase() === tmpRoot.toLowerCase()) {
@@ -9898,8 +9898,8 @@ var win32DefaultTmp = async (path23) => {
   }
   return root;
 };
-var win32DefaultTmpSync = (path23) => {
-  const { root } = _path.parse.call(void 0, path23);
+var win32DefaultTmpSync = (path25) => {
+  const { root } = _path.parse.call(void 0, path25);
   const tmp = _os.tmpdir.call(void 0, );
   const { root: tmpRoot } = _path.parse.call(void 0, tmp);
   if (root.toLowerCase() === tmpRoot.toLowerCase()) {
@@ -9918,10 +9918,10 @@ var defaultTmpSync = platform_default === "win32" ? win32DefaultTmpSync : posixD
 
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/rimraf-move-remove.js
 var { lstat: lstat6, rename: rename2, unlink: unlink3, rmdir: rmdir3, chmod: chmod3 } = promises;
-var uniqueFilename = (path23) => `.${_path.basename.call(void 0, path23)}.${Math.random()}`;
-var unlinkFixEPERM = async (path23) => unlink3(path23).catch((er) => {
+var uniqueFilename = (path25) => `.${_path.basename.call(void 0, path25)}.${Math.random()}`;
+var unlinkFixEPERM = async (path25) => unlink3(path25).catch((er) => {
   if (er.code === "EPERM") {
-    return chmod3(path23, 438).then(() => unlink3(path23), (er2) => {
+    return chmod3(path25, 438).then(() => unlink3(path25), (er2) => {
       if (er2.code === "ENOENT") {
         return;
       }
@@ -9932,13 +9932,13 @@ var unlinkFixEPERM = async (path23) => unlink3(path23).catch((er) => {
   }
   throw er;
 });
-var unlinkFixEPERMSync = (path23) => {
+var unlinkFixEPERMSync = (path25) => {
   try {
-    _fs.unlinkSync.call(void 0, path23);
+    _fs.unlinkSync.call(void 0, path25);
   } catch (er) {
     if (_optionalChain([er, 'optionalAccess', _184 => _184.code]) === "EPERM") {
       try {
-        return _fs.chmodSync.call(void 0, path23, 438);
+        return _fs.chmodSync.call(void 0, path25, 438);
       } catch (er2) {
         if (_optionalChain([er2, 'optionalAccess', _185 => _185.code]) === "ENOENT") {
           return;
@@ -9951,29 +9951,29 @@ var unlinkFixEPERMSync = (path23) => {
     throw er;
   }
 };
-var rimrafMoveRemove = async (path23, opt) => {
+var rimrafMoveRemove = async (path25, opt) => {
   if (_optionalChain([opt, 'optionalAccess', _187 => _187.signal, 'optionalAccess', _188 => _188.aborted])) {
     throw opt.signal.reason;
   }
   try {
-    return await rimrafMoveRemoveDir(path23, opt, await lstat6(path23));
+    return await rimrafMoveRemoveDir(path25, opt, await lstat6(path25));
   } catch (er) {
     if (_optionalChain([er, 'optionalAccess', _189 => _189.code]) === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafMoveRemoveDir = async (path23, opt, ent) => {
+var rimrafMoveRemoveDir = async (path25, opt, ent) => {
   if (_optionalChain([opt, 'optionalAccess', _190 => _190.signal, 'optionalAccess', _191 => _191.aborted])) {
     throw opt.signal.reason;
   }
   if (!opt.tmp) {
-    return rimrafMoveRemoveDir(path23, { ...opt, tmp: await defaultTmp(path23) }, ent);
+    return rimrafMoveRemoveDir(path25, { ...opt, tmp: await defaultTmp(path25) }, ent);
   }
-  if (path23 === opt.tmp && _path.parse.call(void 0, path23).root !== path23) {
+  if (path25 === opt.tmp && _path.parse.call(void 0, path25).root !== path25) {
     throw new Error("cannot delete temp directory used for deletion");
   }
-  const entries = ent.isDirectory() ? await readdirOrError(path23) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path25) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -9983,54 +9983,54 @@ var rimrafMoveRemoveDir = async (path23, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path23, ent)) {
+    if (opt.filter && !await opt.filter(path25, ent)) {
       return false;
     }
-    await ignoreENOENT(tmpUnlink(path23, opt.tmp, unlinkFixEPERM));
+    await ignoreENOENT(tmpUnlink(path25, opt.tmp, unlinkFixEPERM));
     return true;
   }
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafMoveRemoveDir(_path.resolve.call(void 0, path23, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafMoveRemoveDir(_path.resolve.call(void 0, path25, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path23 === _path.parse.call(void 0, path23).root) {
+  if (opt.preserveRoot === false && path25 === _path.parse.call(void 0, path25).root) {
     return false;
   }
-  if (opt.filter && !await opt.filter(path23, ent)) {
+  if (opt.filter && !await opt.filter(path25, ent)) {
     return false;
   }
-  await ignoreENOENT(tmpUnlink(path23, opt.tmp, rmdir3));
+  await ignoreENOENT(tmpUnlink(path25, opt.tmp, rmdir3));
   return true;
 };
-var tmpUnlink = async (path23, tmp, rm3) => {
-  const tmpFile = _path.resolve.call(void 0, tmp, uniqueFilename(path23));
-  await rename2(path23, tmpFile);
+var tmpUnlink = async (path25, tmp, rm3) => {
+  const tmpFile = _path.resolve.call(void 0, tmp, uniqueFilename(path25));
+  await rename2(path25, tmpFile);
   return await rm3(tmpFile);
 };
-var rimrafMoveRemoveSync = (path23, opt) => {
+var rimrafMoveRemoveSync = (path25, opt) => {
   if (_optionalChain([opt, 'optionalAccess', _192 => _192.signal, 'optionalAccess', _193 => _193.aborted])) {
     throw opt.signal.reason;
   }
   try {
-    return rimrafMoveRemoveDirSync(path23, opt, _fs.lstatSync.call(void 0, path23));
+    return rimrafMoveRemoveDirSync(path25, opt, _fs.lstatSync.call(void 0, path25));
   } catch (er) {
     if (_optionalChain([er, 'optionalAccess', _194 => _194.code]) === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafMoveRemoveDirSync = (path23, opt, ent) => {
+var rimrafMoveRemoveDirSync = (path25, opt, ent) => {
   if (_optionalChain([opt, 'optionalAccess', _195 => _195.signal, 'optionalAccess', _196 => _196.aborted])) {
     throw opt.signal.reason;
   }
   if (!opt.tmp) {
-    return rimrafMoveRemoveDirSync(path23, { ...opt, tmp: defaultTmpSync(path23) }, ent);
+    return rimrafMoveRemoveDirSync(path25, { ...opt, tmp: defaultTmpSync(path25) }, ent);
   }
   const tmp = opt.tmp;
-  if (path23 === opt.tmp && _path.parse.call(void 0, path23).root !== path23) {
+  if (path25 === opt.tmp && _path.parse.call(void 0, path25).root !== path25) {
     throw new Error("cannot delete temp directory used for deletion");
   }
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path23) : null;
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path25) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -10040,32 +10040,32 @@ var rimrafMoveRemoveDirSync = (path23, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path23, ent)) {
+    if (opt.filter && !opt.filter(path25, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => tmpUnlinkSync(path23, tmp, unlinkFixEPERMSync));
+    ignoreENOENTSync(() => tmpUnlinkSync(path25, tmp, unlinkFixEPERMSync));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
-    const p = _path.resolve.call(void 0, path23, ent2.name);
+    const p = _path.resolve.call(void 0, path25, ent2.name);
     removedAll = rimrafMoveRemoveDirSync(p, opt, ent2) && removedAll;
   }
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path23 === _path.parse.call(void 0, path23).root) {
+  if (opt.preserveRoot === false && path25 === _path.parse.call(void 0, path25).root) {
     return false;
   }
-  if (opt.filter && !opt.filter(path23, ent)) {
+  if (opt.filter && !opt.filter(path25, ent)) {
     return false;
   }
-  ignoreENOENTSync(() => tmpUnlinkSync(path23, tmp, _fs.rmdirSync));
+  ignoreENOENTSync(() => tmpUnlinkSync(path25, tmp, _fs.rmdirSync));
   return true;
 };
-var tmpUnlinkSync = (path23, tmp, rmSync2) => {
-  const tmpFile = _path.resolve.call(void 0, tmp, uniqueFilename(path23));
-  _fs.renameSync.call(void 0, path23, tmpFile);
+var tmpUnlinkSync = (path25, tmp, rmSync2) => {
+  const tmpFile = _path.resolve.call(void 0, tmp, uniqueFilename(path25));
+  _fs.renameSync.call(void 0, path25, tmpFile);
   return rmSync2(tmpFile);
 };
 
@@ -10075,31 +10075,31 @@ var rimrafWindowsFile = retryBusy(fixEPERM(unlink4));
 var rimrafWindowsFileSync = retryBusySync(fixEPERMSync(_fs.unlinkSync));
 var rimrafWindowsDirRetry = retryBusy(fixEPERM(rmdir4));
 var rimrafWindowsDirRetrySync = retryBusySync(fixEPERMSync(_fs.rmdirSync));
-var rimrafWindowsDirMoveRemoveFallback = async (path23, opt) => {
+var rimrafWindowsDirMoveRemoveFallback = async (path25, opt) => {
   if (_optionalChain([opt, 'optionalAccess', _197 => _197.signal, 'optionalAccess', _198 => _198.aborted])) {
     throw opt.signal.reason;
   }
   const { filter: filter3, ...options } = opt;
   try {
-    return await rimrafWindowsDirRetry(path23, options);
+    return await rimrafWindowsDirRetry(path25, options);
   } catch (er) {
     if (_optionalChain([er, 'optionalAccess', _199 => _199.code]) === "ENOTEMPTY") {
-      return await rimrafMoveRemove(path23, options);
+      return await rimrafMoveRemove(path25, options);
     }
     throw er;
   }
 };
-var rimrafWindowsDirMoveRemoveFallbackSync = (path23, opt) => {
+var rimrafWindowsDirMoveRemoveFallbackSync = (path25, opt) => {
   if (_optionalChain([opt, 'optionalAccess', _200 => _200.signal, 'optionalAccess', _201 => _201.aborted])) {
     throw opt.signal.reason;
   }
   const { filter: filter3, ...options } = opt;
   try {
-    return rimrafWindowsDirRetrySync(path23, options);
+    return rimrafWindowsDirRetrySync(path25, options);
   } catch (er) {
     const fer = er;
     if (_optionalChain([fer, 'optionalAccess', _202 => _202.code]) === "ENOTEMPTY") {
-      return rimrafMoveRemoveSync(path23, options);
+      return rimrafMoveRemoveSync(path25, options);
     }
     throw er;
   }
@@ -10107,35 +10107,35 @@ var rimrafWindowsDirMoveRemoveFallbackSync = (path23, opt) => {
 var START = Symbol("start");
 var CHILD = Symbol("child");
 var FINISH = Symbol("finish");
-var rimrafWindows = async (path23, opt) => {
+var rimrafWindows = async (path25, opt) => {
   if (_optionalChain([opt, 'optionalAccess', _203 => _203.signal, 'optionalAccess', _204 => _204.aborted])) {
     throw opt.signal.reason;
   }
   try {
-    return await rimrafWindowsDir(path23, opt, await lstat7(path23), START);
+    return await rimrafWindowsDir(path25, opt, await lstat7(path25), START);
   } catch (er) {
     if (_optionalChain([er, 'optionalAccess', _205 => _205.code]) === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafWindowsSync = (path23, opt) => {
+var rimrafWindowsSync = (path25, opt) => {
   if (_optionalChain([opt, 'optionalAccess', _206 => _206.signal, 'optionalAccess', _207 => _207.aborted])) {
     throw opt.signal.reason;
   }
   try {
-    return rimrafWindowsDirSync(path23, opt, _fs.lstatSync.call(void 0, path23), START);
+    return rimrafWindowsDirSync(path25, opt, _fs.lstatSync.call(void 0, path25), START);
   } catch (er) {
     if (_optionalChain([er, 'optionalAccess', _208 => _208.code]) === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafWindowsDir = async (path23, opt, ent, state = START) => {
+var rimrafWindowsDir = async (path25, opt, ent, state = START) => {
   if (_optionalChain([opt, 'optionalAccess', _209 => _209.signal, 'optionalAccess', _210 => _210.aborted])) {
     throw opt.signal.reason;
   }
-  const entries = ent.isDirectory() ? await readdirOrError(path23) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path25) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -10145,32 +10145,32 @@ var rimrafWindowsDir = async (path23, opt, ent, state = START) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path23, ent)) {
+    if (opt.filter && !await opt.filter(path25, ent)) {
       return false;
     }
-    await ignoreENOENT(rimrafWindowsFile(path23, opt));
+    await ignoreENOENT(rimrafWindowsFile(path25, opt));
     return true;
   }
   const s = state === START ? CHILD : state;
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafWindowsDir(_path.resolve.call(void 0, path23, ent2.name), opt, ent2, s)))).reduce((a, b) => a && b, true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafWindowsDir(_path.resolve.call(void 0, path25, ent2.name), opt, ent2, s)))).reduce((a, b) => a && b, true);
   if (state === START) {
-    return rimrafWindowsDir(path23, opt, ent, FINISH);
+    return rimrafWindowsDir(path25, opt, ent, FINISH);
   } else if (state === FINISH) {
-    if (opt.preserveRoot === false && path23 === _path.parse.call(void 0, path23).root) {
+    if (opt.preserveRoot === false && path25 === _path.parse.call(void 0, path25).root) {
       return false;
     }
     if (!removedAll) {
       return false;
     }
-    if (opt.filter && !await opt.filter(path23, ent)) {
+    if (opt.filter && !await opt.filter(path25, ent)) {
       return false;
     }
-    await ignoreENOENT(rimrafWindowsDirMoveRemoveFallback(path23, opt));
+    await ignoreENOENT(rimrafWindowsDirMoveRemoveFallback(path25, opt));
   }
   return true;
 };
-var rimrafWindowsDirSync = (path23, opt, ent, state = START) => {
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path23) : null;
+var rimrafWindowsDirSync = (path25, opt, ent, state = START) => {
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path25) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -10180,32 +10180,32 @@ var rimrafWindowsDirSync = (path23, opt, ent, state = START) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path23, ent)) {
+    if (opt.filter && !opt.filter(path25, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => rimrafWindowsFileSync(path23, opt));
+    ignoreENOENTSync(() => rimrafWindowsFileSync(path25, opt));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
     const s = state === START ? CHILD : state;
-    const p = _path.resolve.call(void 0, path23, ent2.name);
+    const p = _path.resolve.call(void 0, path25, ent2.name);
     removedAll = rimrafWindowsDirSync(p, opt, ent2, s) && removedAll;
   }
   if (state === START) {
-    return rimrafWindowsDirSync(path23, opt, ent, FINISH);
+    return rimrafWindowsDirSync(path25, opt, ent, FINISH);
   } else if (state === FINISH) {
-    if (opt.preserveRoot === false && path23 === _path.parse.call(void 0, path23).root) {
+    if (opt.preserveRoot === false && path25 === _path.parse.call(void 0, path25).root) {
       return false;
     }
     if (!removedAll) {
       return false;
     }
-    if (opt.filter && !opt.filter(path23, ent)) {
+    if (opt.filter && !opt.filter(path25, ent)) {
       return false;
     }
     ignoreENOENTSync(() => {
-      rimrafWindowsDirMoveRemoveFallbackSync(path23, opt);
+      rimrafWindowsDirMoveRemoveFallbackSync(path25, opt);
     });
   }
   return true;
@@ -10218,16 +10218,16 @@ var rimrafManualSync = platform_default === "win32" ? rimrafWindowsSync : rimraf
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/rimraf-native.js
 _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
 var { rm: rm2 } = promises;
-var rimrafNative = async (path23, opt) => {
-  await rm2(path23, {
+var rimrafNative = async (path25, opt) => {
+  await rm2(path25, {
     ...opt,
     force: true,
     recursive: true
   });
   return true;
 };
-var rimrafNativeSync = (path23, opt) => {
-  _fs.rmSync.call(void 0, path23, {
+var rimrafNativeSync = (path25, opt) => {
+  _fs.rmSync.call(void 0, path25, {
     ...opt,
     force: true,
     recursive: true
@@ -10245,26 +10245,26 @@ var useNative = !hasNative || platform_default === "win32" ? () => false : (opt)
 var useNativeSync = !hasNative || platform_default === "win32" ? () => false : (opt) => !_optionalChain([opt, 'optionalAccess', _213 => _213.signal]) && !_optionalChain([opt, 'optionalAccess', _214 => _214.filter]);
 
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/index.js
-var wrap = (fn) => async (path23, opt) => {
+var wrap = (fn) => async (path25, opt) => {
   const options = optArg(opt);
   if (options.glob) {
-    path23 = await glob(path23, options.glob);
+    path25 = await glob(path25, options.glob);
   }
-  if (Array.isArray(path23)) {
-    return !!(await Promise.all(path23.map((p) => fn(path_arg_default(p, options), options)))).reduce((a, b) => a && b, true);
+  if (Array.isArray(path25)) {
+    return !!(await Promise.all(path25.map((p) => fn(path_arg_default(p, options), options)))).reduce((a, b) => a && b, true);
   } else {
-    return !!await fn(path_arg_default(path23, options), options);
+    return !!await fn(path_arg_default(path25, options), options);
   }
 };
-var wrapSync = (fn) => (path23, opt) => {
+var wrapSync = (fn) => (path25, opt) => {
   const options = optArgSync(opt);
   if (options.glob) {
-    path23 = globSync(path23, options.glob);
+    path25 = globSync(path25, options.glob);
   }
-  if (Array.isArray(path23)) {
-    return !!path23.map((p) => fn(path_arg_default(p, options), options)).reduce((a, b) => a && b, true);
+  if (Array.isArray(path25)) {
+    return !!path25.map((p) => fn(path_arg_default(p, options), options)).reduce((a, b) => a && b, true);
   } else {
-    return !!fn(path_arg_default(path23, options), options);
+    return !!fn(path_arg_default(path25, options), options);
   }
 };
 var nativeSync = wrapSync(rimrafNativeSync);
@@ -10279,8 +10279,8 @@ var moveRemoveSync = wrapSync(rimrafMoveRemoveSync);
 var moveRemove = Object.assign(wrap(rimrafMoveRemove), {
   sync: moveRemoveSync
 });
-var rimrafSync = wrapSync((path23, opt) => useNativeSync(opt) ? rimrafNativeSync(path23, opt) : rimrafManualSync(path23, opt));
-var rimraf_ = wrap((path23, opt) => useNative(opt) ? rimrafNative(path23, opt) : rimrafManual(path23, opt));
+var rimrafSync = wrapSync((path25, opt) => useNativeSync(opt) ? rimrafNativeSync(path25, opt) : rimrafManualSync(path25, opt));
+var rimraf_ = wrap((path25, opt) => useNative(opt) ? rimrafNative(path25, opt) : rimrafManual(path25, opt));
 var rimraf = Object.assign(rimraf_, {
   rimraf: rimraf_,
   sync: rimrafSync,
@@ -16154,17 +16154,17 @@ function withTrailingSlash(input = "", respectQueryAndFragment) {
   if (hasTrailingSlash(input, true)) {
     return input || "/";
   }
-  let path23 = input;
+  let path25 = input;
   let fragment = "";
   const fragmentIndex = input.indexOf("#");
   if (fragmentIndex !== -1) {
-    path23 = input.slice(0, fragmentIndex);
+    path25 = input.slice(0, fragmentIndex);
     fragment = input.slice(fragmentIndex);
-    if (!path23) {
+    if (!path25) {
       return fragment;
     }
   }
-  const [s0, ...s] = path23.split("?");
+  const [s0, ...s] = path25.split("?");
   return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
 }
 function isNonEmptyURL(url) {
@@ -16193,8 +16193,8 @@ var _assert = require('assert'); var _assert2 = _interopRequireDefault(_assert);
 var _v8 = require('v8'); var _v82 = _interopRequireDefault(_v8);
 
 var BUILTIN_MODULES = new Set(_module.builtinModules);
-function normalizeSlash(path23) {
-  return path23.replace(/\\/g, "/");
+function normalizeSlash(path25) {
+  return path25.replace(/\\/g, "/");
 }
 var own$1 = {}.hasOwnProperty;
 var classRegExp = /^([A-Z][a-z\d]*)+$/;
@@ -16307,8 +16307,8 @@ codes2.ERR_INVALID_PACKAGE_CONFIG = createError(
    * @param {string} [base]
    * @param {string} [message]
    */
-  (path23, base, message) => {
-    return `Invalid package config ${path23}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+  (path25, base, message) => {
+    return `Invalid package config ${path25}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
   },
   Error
 );
@@ -16340,8 +16340,8 @@ codes2.ERR_MODULE_NOT_FOUND = createError(
    * @param {string} base
    * @param {boolean} [exactUrl]
    */
-  (path23, base, exactUrl = false) => {
-    return `Cannot find ${exactUrl ? "module" : "package"} '${path23}' imported from ${base}`;
+  (path25, base, exactUrl = false) => {
+    return `Cannot find ${exactUrl ? "module" : "package"} '${path25}' imported from ${base}`;
   },
   Error
 );
@@ -16392,8 +16392,8 @@ codes2.ERR_UNKNOWN_FILE_EXTENSION = createError(
    * @param {string} extension
    * @param {string} path
    */
-  (extension, path23) => {
-    return `Unknown file extension "${extension}" for ${path23}`;
+  (extension, path25) => {
+    return `Unknown file extension "${extension}" for ${path25}`;
   },
   TypeError
 );
@@ -16764,9 +16764,9 @@ Default "index" lookups for the main are deprecated for ES modules.`,
     );
   }
 }
-function tryStatSync(path23) {
+function tryStatSync(path25) {
   try {
-    return _fs.statSync.call(void 0, path23);
+    return _fs.statSync.call(void 0, path25);
   } catch (e6) {
   }
 }
@@ -17685,7 +17685,7 @@ function findUpSync(name, {
     directory = sysPath2.default.dirname(directory);
   }
 }
-function _resolve2(path23, options = {}) {
+function _resolve2(path25, options = {}) {
   if (options.platform === "auto" || !options.platform)
     options.platform = _process2.default.platform === "win32" ? "win32" : "posix";
   if (_process2.default.versions.pnp) {
@@ -17694,11 +17694,11 @@ function _resolve2(path23, options = {}) {
       paths.push(_process2.default.cwd());
     const targetRequire = _module.createRequire.call(void 0, _chunkOS76JPG2cjs.importMetaUrl);
     try {
-      return targetRequire.resolve(path23, { paths });
+      return targetRequire.resolve(path25, { paths });
     } catch (e10) {
     }
   }
-  const modulePath = resolvePathSync(path23, {
+  const modulePath = resolvePathSync(path25, {
     url: options.paths
   });
   if (options.platform === "win32")
@@ -17769,10 +17769,10 @@ var findUp = quansync2({
   async: findUp$1
 });
 var loadPackageJSON = quansync2(function* (cwd = _process2.default.cwd()) {
-  const path23 = yield findUp("package.json", { cwd });
-  if (!path23 || !actualFS.default.existsSync(path23))
+  const path25 = yield findUp("package.json", { cwd });
+  if (!path25 || !actualFS.default.existsSync(path25))
     return null;
-  return JSON.parse(yield readFile(path23));
+  return JSON.parse(yield readFile(path25));
 });
 var loadPackageJSONSync = loadPackageJSON.sync;
 var isPackageListed = quansync2(function* (name, cwd) {
@@ -17825,9 +17825,9 @@ var INSTALL_METADATA = {
 };
 
 // ../../node_modules/.pnpm/package-manager-detector@1.4.0/node_modules/package-manager-detector/dist/detect.mjs
-async function pathExists(path23, type) {
+async function pathExists(path25, type) {
   try {
-    const stat6 = await _promises2.default.stat(path23);
+    const stat6 = await _promises2.default.stat(path25);
     return type === "file" ? stat6.isFile() : stat6.isDirectory();
   } catch (e13) {
     return false;
@@ -20790,20 +20790,15 @@ function flatten(groups) {
   }, []);
 }
 
-// src/runtime/configPlugin.ts
-function createConfigService(ctx) {
-  const configState = ctx.runtimeState.config;
-  configState.packageInfo = getPackageInfoSync("weapp-vite");
-  const defineEnv = configState.defineEnv;
-  let packageManager = configState.packageManager;
-  let options = configState.options;
-  const oxcRuntimeInfo = getPackageInfoSync("@oxc-project/runtime");
-  const oxcRuntimeHelpersRoot = oxcRuntimeInfo ? _pathe2.default.resolve(oxcRuntimeInfo.rootPath, "src/helpers/esm") : void 0;
-  const NULL_BYTE = "\0";
-  const OXC_RUNTIME_HELPER_ALIAS = new RegExp(`^(?:${NULL_BYTE})?@oxc-project(?:/|\\+)runtime(?:@[^/]+)?/helpers/(.+)\\.js$`);
-  const FALLBACK_HELPER_PREFIX = `${NULL_BYTE}weapp-vite:oxc-helper:`;
-  const fallbackHelpers = {
-    objectWithoutProperties: `export default function _objectWithoutProperties(source, excluded) {
+// src/runtime/oxcRuntime.ts
+_chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
+
+
+var NULL_BYTE = "\0";
+var OXC_RUNTIME_HELPER_ALIAS = new RegExp(`^(?:${NULL_BYTE})?@oxc-project(?:/|\\+)runtime(?:@[^/]+)?/helpers/(.+)\\.js$`);
+var FALLBACK_HELPER_PREFIX = `${NULL_BYTE}weapp-vite:oxc-helper:`;
+var fallbackHelpers = {
+  objectWithoutProperties: `export default function _objectWithoutProperties(source, excluded) {
   if (source == null) return {};
   var target = {};
   var sourceKeys = Object.keys(source);
@@ -20825,7 +20820,7 @@ function createConfigService(ctx) {
   }
   return target;
 }`,
-    objectSpread2: `function ownKeys(object, enumerableOnly) {
+  objectSpread2: `function ownKeys(object, enumerableOnly) {
   var keys = Object.keys(object);
   if (Object.getOwnPropertySymbols) {
     var symbols = Object.getOwnPropertySymbols(object);
@@ -20858,13 +20853,25 @@ function _objectSpread2(target) {
   return target;
 }
 export default _objectSpread2;`
+};
+function getOxcHelperName(id) {
+  OXC_RUNTIME_HELPER_ALIAS.lastIndex = 0;
+  const match2 = OXC_RUNTIME_HELPER_ALIAS.exec(id);
+  return _optionalChain([match2, 'optionalAccess', _293 => _293[1]]);
+}
+function createOxcRuntimeSupport() {
+  const oxcRuntimeInfo = getPackageInfoSync("@oxc-project/runtime");
+  const oxcRuntimeHelpersRoot = oxcRuntimeInfo ? _pathe2.default.resolve(oxcRuntimeInfo.rootPath, "src/helpers/esm") : void 0;
+  const alias = {
+    find: OXC_RUNTIME_HELPER_ALIAS,
+    replacement: "@oxc-project/runtime/src/helpers/esm/$1.js"
   };
-  function getOxcHelperName(id) {
-    OXC_RUNTIME_HELPER_ALIAS.lastIndex = 0;
-    const match2 = OXC_RUNTIME_HELPER_ALIAS.exec(id);
-    return _optionalChain([match2, 'optionalAccess', _293 => _293[1]]);
+  if (!oxcRuntimeHelpersRoot) {
+    return {
+      alias
+    };
   }
-  const rolldownOxcRuntimePlugin = oxcRuntimeHelpersRoot ? {
+  const rolldownPlugin = {
     name: "weapp-vite:rolldown-oxc-runtime",
     resolveId(source) {
       if (source.startsWith(NULL_BYTE)) {
@@ -20874,13 +20881,14 @@ export default _objectSpread2;`
       if (!helperName) {
         return null;
       }
-      if (!oxcRuntimeHelpersRoot) {
+      const helpersRoot = oxcRuntimeHelpersRoot;
+      if (!helpersRoot) {
         if (helperName in fallbackHelpers) {
           return `${FALLBACK_HELPER_PREFIX}${helperName}`;
         }
         return null;
       }
-      return _pathe2.default.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
+      return _pathe2.default.resolve(helpersRoot, `${helperName}.js`);
     },
     async load(id) {
       if (id.startsWith(FALLBACK_HELPER_PREFIX)) {
@@ -20893,12 +20901,10 @@ export default _objectSpread2;`
       }
       const helperName = getOxcHelperName(id);
       if (helperName) {
-        if (oxcRuntimeHelpersRoot) {
-          const helperPath = id.startsWith(NULL_BYTE) ? _pathe2.default.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`) : id;
-          if (await _fsextra2.default.pathExists(helperPath)) {
-            console.warn("[weapp-vite] resolving oxc helper via Rolldown plugin:", helperName);
-            return _fsextra2.default.readFile(helperPath, "utf8");
-          }
+        const helperPath = id.startsWith(NULL_BYTE) ? _pathe2.default.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`) : id;
+        if (await _fsextra2.default.pathExists(helperPath)) {
+          console.warn("[weapp-vite] resolving oxc helper via Rolldown plugin:", helperName);
+          return _fsextra2.default.readFile(helperPath, "utf8");
         }
         const fallback = fallbackHelpers[helperName];
         if (fallback) {
@@ -20907,7 +20913,81 @@ export default _objectSpread2;`
       }
       return null;
     }
-  } : void 0;
+  };
+  const vitePlugin = {
+    name: "weapp-vite:oxc-runtime-helpers",
+    enforce: "pre",
+    resolveId(source) {
+      if (source.startsWith(NULL_BYTE)) {
+        return null;
+      }
+      if (source.includes("@oxc-project/runtime/helpers")) {
+        console.warn("[weapp-vite] resolveId intercepted:", source);
+      }
+      const helperName = getOxcHelperName(source);
+      if (helperName) {
+        return _pathe2.default.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
+      }
+      return null;
+    },
+    async load(id) {
+      if (!id.startsWith(NULL_BYTE)) {
+        return null;
+      }
+      const helperName = getOxcHelperName(id);
+      if (!helperName) {
+        return null;
+      }
+      const helperPath = _pathe2.default.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
+      console.warn("[weapp-vite] resolving oxc helper via Vite plugin:", helperName);
+      return _fsextra2.default.readFile(helperPath, "utf8");
+    }
+  };
+  return {
+    alias,
+    rolldownPlugin,
+    vitePlugin
+  };
+}
+
+// src/runtime/packageAliases.ts
+_chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
+
+
+var SPECIAL_PACKAGE_ALIASES = [
+  {
+    packageName: "class-variance-authority",
+    distEntry: "dist/index.js"
+  }
+];
+function resolveBuiltinPackageAliases() {
+  const aliases = [];
+  for (const { packageName, distEntry } of SPECIAL_PACKAGE_ALIASES) {
+    const info = getPackageInfoSync(packageName);
+    if (!info) {
+      continue;
+    }
+    const resolvedEntry = _pathe2.default.resolve(info.rootPath, distEntry);
+    if (!_fs.existsSync.call(void 0, resolvedEntry)) {
+      continue;
+    }
+    aliases.push({
+      find: packageName,
+      replacement: resolvedEntry
+    });
+  }
+  return aliases;
+}
+
+// src/runtime/configPlugin.ts
+function createConfigService(ctx) {
+  const configState = ctx.runtimeState.config;
+  configState.packageInfo = getPackageInfoSync("weapp-vite");
+  const defineEnv = configState.defineEnv;
+  let packageManager = configState.packageManager;
+  let options = configState.options;
+  const builtinPackageAliases = resolveBuiltinPackageAliases();
+  const oxcRuntimeSupport = createOxcRuntimeSupport();
   function normalizeAliasOptions(alias) {
     if (!alias) {
       return [];
@@ -20921,16 +21001,9 @@ export default _objectSpread2;`
       return { find, replacement };
     });
   }
-  function injectOxcRuntimeAlias(config) {
+  function injectBuiltinAliases(config) {
     const resolve8 = _nullishCoalesce(config.resolve, () => ( (config.resolve = {})));
-    const aliasEntry = {
-      find: OXC_RUNTIME_HELPER_ALIAS,
-      replacement: "@oxc-project/runtime/src/helpers/esm/$1.js"
-    };
-    const cvaAliasEntry = {
-      find: "class-variance-authority",
-      replacement: "class-variance-authority/dist/index.js"
-    };
+    const aliasEntry = oxcRuntimeSupport.alias;
     const aliasArray = normalizeAliasOptions(resolve8.alias);
     const hasAlias = aliasArray.some((entry) => {
       return entry.find instanceof RegExp && entry.find.source === aliasEntry.find.source;
@@ -20938,9 +21011,11 @@ export default _objectSpread2;`
     if (!hasAlias) {
       aliasArray.unshift(aliasEntry);
     }
-    const hasCvaAlias = aliasArray.some((entry) => typeof entry.find === "string" && entry.find === cvaAliasEntry.find);
-    if (!hasCvaAlias) {
-      aliasArray.unshift(cvaAliasEntry);
+    for (const builtinAlias of builtinPackageAliases) {
+      const hasAliasEntry = aliasArray.some((entry) => typeof entry.find === "string" && entry.find === builtinAlias.find);
+      if (!hasAliasEntry) {
+        aliasArray.unshift(builtinAlias);
+      }
     }
     resolve8.alias = aliasArray;
   }
@@ -21014,55 +21089,23 @@ export default _objectSpread2;`
         weapp: getWeappViteConfig()
       }
     );
-    if (rolldownOxcRuntimePlugin) {
+    const rolldownPlugin = oxcRuntimeSupport.rolldownPlugin;
+    if (rolldownPlugin) {
       const build3 = _nullishCoalesce(config.build, () => ( (config.build = {})));
       const rdOptions = _nullishCoalesce(build3.rolldownOptions, () => ( (build3.rolldownOptions = {})));
       const rawPlugins = rdOptions.plugins;
       const pluginArray = rawPlugins == null ? [] : Array.isArray(rawPlugins) ? [...rawPlugins] : [rawPlugins];
-      const hasPlugin = pluginArray.some((plugin) => {
-        if (!plugin || typeof plugin !== "object") {
-          return false;
-        }
-        return "name" in plugin && plugin.name === rolldownOxcRuntimePlugin.name;
-      });
+      const hasPlugin = pluginArray.includes(rolldownPlugin);
       if (!hasPlugin) {
-        rdOptions.plugins = [rolldownOxcRuntimePlugin, ...pluginArray];
+        rdOptions.plugins = [rolldownPlugin, ...pluginArray];
       } else if (!Array.isArray(rawPlugins)) {
         rdOptions.plugins = pluginArray;
       }
     }
-    injectOxcRuntimeAlias(config);
-    if (oxcRuntimeHelpersRoot) {
+    injectBuiltinAliases(config);
+    if (oxcRuntimeSupport.vitePlugin) {
       config.plugins ??= [];
-      config.plugins.unshift({
-        name: "weapp-vite:oxc-runtime-helpers",
-        enforce: "pre",
-        resolveId(source) {
-          if (source.startsWith(NULL_BYTE)) {
-            return null;
-          }
-          if (source.includes("@oxc-project/runtime/helpers")) {
-            console.warn("[weapp-vite] resolveId intercepted:", source);
-          }
-          const helperName = getOxcHelperName(source);
-          if (helperName) {
-            return _pathe2.default.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
-          }
-          return null;
-        },
-        async load(id) {
-          if (!id.startsWith(NULL_BYTE)) {
-            return null;
-          }
-          const helperName = getOxcHelperName(id);
-          if (!helperName) {
-            return null;
-          }
-          const helperPath = _pathe2.default.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
-          console.warn("[weapp-vite] resolving oxc helper via Vite plugin:", helperName);
-          return _fsextra2.default.readFile(helperPath, "utf8");
-        }
-      });
+      config.plugins.unshift(oxcRuntimeSupport.vitePlugin);
     }
     const platform = _nullishCoalesce(_optionalChain([config, 'access', _297 => _297.weapp, 'optionalAccess', _298 => _298.platform]), () => ( "weapp"));
     const resolvedOutputExtensions = getOutputExtensions(platform);
@@ -21135,7 +21178,7 @@ export default _objectSpread2;`
           }
         }
       );
-      injectOxcRuntimeAlias(inline);
+      injectBuiltinAliases(inline);
       return inline;
     }
     const inlineConfig = _shared.defu.call(void 0, 
@@ -21152,7 +21195,7 @@ export default _objectSpread2;`
       }
     );
     inlineConfig.logLevel = "info";
-    injectOxcRuntimeAlias(inlineConfig);
+    injectBuiltinAliases(inlineConfig);
     return inlineConfig;
   }
   function merge(subPackageMeta, ...configs) {
@@ -21166,9 +21209,10 @@ export default _objectSpread2;`
         return new RegExp(`^${pkg.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&")}(\\/|$)`);
       }));
     }
+    const rolldownPlugin = oxcRuntimeSupport.rolldownPlugin;
     const rolldownOptions = {
       external,
-      plugins: rolldownOxcRuntimePlugin ? [rolldownOxcRuntimePlugin] : void 0
+      plugins: rolldownPlugin ? [rolldownPlugin] : void 0
     };
     if (options.isDev) {
       const inline = _shared.defu.call(void 0, 
@@ -21196,7 +21240,7 @@ export default _objectSpread2;`
           }
         }
       );
-      injectOxcRuntimeAlias(inline);
+      injectBuiltinAliases(inline);
       return inline;
     }
     const inlineConfig = _shared.defu.call(void 0, 
@@ -21221,7 +21265,7 @@ export default _objectSpread2;`
       }
     );
     inlineConfig.logLevel = "info";
-    injectOxcRuntimeAlias(inlineConfig);
+    injectBuiltinAliases(inlineConfig);
     const currentRoot = _optionalChain([subPackageMeta, 'optionalAccess', _306 => _306.subPackage, 'access', _307 => _307.root]);
     options = {
       ...options,