weapp-vite 5.2.1 → 5.2.3

package/dist/{chunk-LUDOMADB.cjs → chunk-GMCAZZQY.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;
@@ -19444,11 +19444,51 @@ function transformWxsCode(code, options) {
 }
 
 // src/wxml/handle.ts
+var handleCache = /* @__PURE__ */ new WeakMap();
+var inlineWxsTransformCache = /* @__PURE__ */ new Map();
+var INLINE_WXS_CACHE_LIMIT = 256;
+function createCacheKey(options) {
+  return `${options.removeComment ? 1 : 0}|${options.transformEvent ? 1 : 0}`;
+}
+function getCachedResult(data2, cacheKey) {
+  return _optionalChain([handleCache, 'access', _259 => _259.get, 'call', _260 => _260(data2), 'optionalAccess', _261 => _261.get, 'call', _262 => _262(cacheKey)]);
+}
+function setCachedResult(data2, cacheKey, result) {
+  let cacheForToken = handleCache.get(data2);
+  if (!cacheForToken) {
+    cacheForToken = /* @__PURE__ */ new Map();
+    handleCache.set(data2, cacheForToken);
+  }
+  cacheForToken.set(cacheKey, result);
+  return result;
+}
+function getCachedInlineWxsTransform(code) {
+  const cached = inlineWxsTransformCache.get(code);
+  if (cached) {
+    inlineWxsTransformCache.delete(code);
+    inlineWxsTransformCache.set(code, cached);
+    return cached;
+  }
+  const transformed = transformWxsCode(code);
+  inlineWxsTransformCache.set(code, transformed);
+  if (inlineWxsTransformCache.size > INLINE_WXS_CACHE_LIMIT) {
+    const firstKey = inlineWxsTransformCache.keys().next().value;
+    if (firstKey) {
+      inlineWxsTransformCache.delete(firstKey);
+    }
+  }
+  return transformed;
+}
 function handleWxml(data2, options) {
   const opts = _shared.defu.call(void 0, options, {
     removeComment: true,
     transformEvent: true
   });
+  const cacheKey = createCacheKey(opts);
+  const cached = getCachedResult(data2, cacheKey);
+  if (cached) {
+    return cached;
+  }
   const {
     code,
     removalRanges,
@@ -19467,11 +19507,11 @@ function handleWxml(data2, options) {
   const shouldRemoveConditionals = removalRanges.length > 0;
   const shouldRemoveComments = opts.removeComment && commentTokens.length > 0;
   if (!shouldNormalizeImports && !shouldRemoveLang && !shouldTransformInlineWxs && !shouldTransformEvents && !shouldRemoveConditionals && !shouldRemoveComments) {
-    return {
+    return setCachedResult(data2, cacheKey, {
       code,
       components: components2,
       deps
-    };
+    });
   }
   const ms = new MagicString(code);
   if (shouldNormalizeImports) {
@@ -19486,8 +19526,8 @@ function handleWxml(data2, options) {
   }
   if (shouldTransformInlineWxs) {
     for (const { end, start, value } of inlineWxsTokens) {
-      const { result } = transformWxsCode(value);
-      if (_optionalChain([result, 'optionalAccess', _259 => _259.code])) {
+      const { result } = getCachedInlineWxsTransform(value);
+      if (_optionalChain([result, 'optionalAccess', _263 => _263.code])) {
         ms.update(start, end, `
 ${result.code}`);
       }
@@ -19499,7 +19539,7 @@ ${result.code}`);
     }
   }
   if (shouldRemoveConditionals) {
-    for (const { start, end } of [...removalRanges].sort((a, b) => b.start - a.start)) {
+    for (const { start, end } of removalRanges) {
       if (end > start) {
         ms.remove(start, end);
       }
@@ -19510,11 +19550,11 @@ ${result.code}`);
       ms.remove(start, end);
     }
   }
-  return {
+  return setCachedResult(data2, cacheKey, {
     code: ms.toString(),
     components: components2,
     deps
-  };
+  });
 }
 
 // src/plugins/hooks/useLoadEntry/index.ts
@@ -19567,7 +19607,7 @@ function createChunkEmitter(configService, loadedEntrySet, debug4) {
         // @ts-ignore
         preserveSignature: "exports-only"
       });
-      _optionalChain([debug4, 'optionalCall', _260 => _260(`load ${fileName} \u8017\u65F6 ${(_perf_hooks.performance.now() - start).toFixed(2)}ms`)]);
+      _optionalChain([debug4, 'optionalCall', _264 => _264(`load ${fileName} \u8017\u65F6 ${(_perf_hooks.performance.now() - start).toFixed(2)}ms`)]);
     });
   };
 }
@@ -19660,6 +19700,86 @@ function analyzeCommonJson(json) {
 }
 
 // src/plugins/hooks/useLoadEntry/loadEntry.ts
+function createStopwatch() {
+  const start = _perf_hooks.performance.now();
+  return () => `${(_perf_hooks.performance.now() - start).toFixed(2)}ms`;
+}
+async function addWatchTarget(pluginCtx, target, existsCache) {
+  if (!target || typeof pluginCtx.addWatchFile !== "function") {
+    return false;
+  }
+  if (existsCache.has(target)) {
+    const cached = existsCache.get(target);
+    if (cached) {
+      pluginCtx.addWatchFile(target);
+    }
+    return cached;
+  }
+  const exists = await _fsextra2.default.exists(target);
+  if (exists) {
+    pluginCtx.addWatchFile(target);
+  }
+  existsCache.set(target, exists);
+  return exists;
+}
+async function collectStyleImports(pluginCtx, id, existsCache) {
+  const styleImports = [];
+  for (const ext2 of supportedCssLangs) {
+    const mayBeCssPath = changeFileExtension(id, ext2);
+    const exists = await addWatchTarget(pluginCtx, mayBeCssPath, existsCache);
+    if (exists) {
+      styleImports.push(mayBeCssPath);
+    }
+  }
+  return styleImports;
+}
+async function collectAppSideFiles(pluginCtx, id, json, jsonService, registerJsonAsset, existsCache) {
+  const { sitemapLocation = "sitemap.json", themeLocation = "theme.json" } = json;
+  const processSideJson = async (location) => {
+    if (!location) {
+      return;
+    }
+    const { path: jsonPath, predictions } = await findJsonEntry(
+      _pathe2.default.resolve(_pathe2.default.dirname(id), location)
+    );
+    for (const prediction of predictions) {
+      await addWatchTarget(pluginCtx, prediction, existsCache);
+    }
+    if (!jsonPath) {
+      return;
+    }
+    const content = await jsonService.read(jsonPath);
+    registerJsonAsset({
+      json: content,
+      jsonPath,
+      type: "app"
+    });
+  };
+  await processSideJson(sitemapLocation);
+  await processSideJson(themeLocation);
+}
+async function ensureTemplateScanned(pluginCtx, id, scanTemplateEntry, existsCache) {
+  const { path: templateEntry, predictions } = await findTemplateEntry(id);
+  for (const prediction of predictions) {
+    await addWatchTarget(pluginCtx, prediction, existsCache);
+  }
+  if (!templateEntry) {
+    return "";
+  }
+  await scanTemplateEntry(templateEntry);
+  return templateEntry;
+}
+async function resolveEntries(entries, absoluteSrcRoot) {
+  return Promise.all(
+    entries.filter((entry) => !entry.includes(":")).map(async (entry) => {
+      const absPath = _pathe2.default.resolve(absoluteSrcRoot, entry);
+      return {
+        entry,
+        resolvedId: await this.resolve(absPath)
+      };
+    })
+  );
+}
 function createEntryLoader(options) {
   const {
     ctx,
@@ -19673,16 +19793,18 @@ function createEntryLoader(options) {
     debug: debug4
   } = options;
   const { jsonService, configService } = ctx;
+  const existsCache = /* @__PURE__ */ new Map();
   return async function loadEntry(id, type) {
-    const start = _perf_hooks.performance.now();
-    const getTime = () => `${(_perf_hooks.performance.now() - start).toFixed(2)}ms`;
+    existsCache.clear();
+    const stopwatch = debug4 ? createStopwatch() : void 0;
+    const getTime = () => stopwatch ? stopwatch() : "0.00ms";
     const relativeCwdId = configService.relativeCwd(id);
     this.addWatchFile(id);
     const baseName = _shared.removeExtensionDeep.call(void 0, id);
     const jsonEntry = await findJsonEntry(id);
     let jsonPath = jsonEntry.path;
     for (const prediction of jsonEntry.predictions) {
-      await addWatchTarget(this, prediction);
+      await addWatchTarget(this, prediction, existsCache);
     }
     let json = {};
     if (jsonPath) {
@@ -19699,10 +19821,11 @@ function createEntryLoader(options) {
         id,
         json,
         jsonService,
-        registerJsonAsset
+        registerJsonAsset,
+        existsCache
       );
     } else {
-      templatePath = await ensureTemplateScanned(this, id, scanTemplateEntry);
+      templatePath = await ensureTemplateScanned(this, id, scanTemplateEntry, existsCache);
       applyAutoImports(baseName, json);
       entries.push(...analyzeCommonJson(json));
     }
@@ -19721,104 +19844,45 @@ function createEntryLoader(options) {
       normalizedEntries,
       configService.absoluteSrcRoot
     );
-    _optionalChain([debug4, 'optionalCall', _261 => _261(`resolvedIds ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
-    await Promise.all(
-      emitEntriesChunks.call(
-        this,
-        resolvedIds.filter(({ entry, resolvedId }) => {
-          if (!resolvedId) {
-            logger_default.warn(`\u6CA1\u6709\u627E\u5230 \`${entry}\` \u7684\u5165\u53E3\u6587\u4EF6\uFF0C\u8BF7\u68C0\u67E5\u8DEF\u5F84\u662F\u5426\u6B63\u786E!`);
-            return false;
-          }
-          if (loadedEntrySet.has(resolvedId.id)) {
-            return false;
-          }
-          return true;
-        }).map((item) => item.resolvedId)
-      )
-    );
-    _optionalChain([debug4, 'optionalCall', _262 => _262(`emitEntriesChunks ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
+    _optionalChain([debug4, 'optionalCall', _265 => _265(`resolvedIds ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
+    const pendingResolvedIds = [];
+    for (const { entry, resolvedId } of resolvedIds) {
+      if (!resolvedId) {
+        logger_default.warn(`\u6CA1\u6709\u627E\u5230 \`${entry}\` \u7684\u5165\u53E3\u6587\u4EF6\uFF0C\u8BF7\u68C0\u67E5\u8DEF\u5F84\u662F\u5426\u6B63\u786E!`);
+        continue;
+      }
+      if (loadedEntrySet.has(resolvedId.id)) {
+        continue;
+      }
+      pendingResolvedIds.push(resolvedId);
+    }
+    if (pendingResolvedIds.length) {
+      await Promise.all(emitEntriesChunks.call(this, pendingResolvedIds));
+    }
+    _optionalChain([debug4, 'optionalCall', _266 => _266(`emitEntriesChunks ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
     registerJsonAsset({
       jsonPath,
       json,
       type
     });
     const code = await _fsextra2.default.readFile(id, "utf8");
+    const styleImports = await collectStyleImports(this, id, existsCache);
+    _optionalChain([debug4, 'optionalCall', _267 => _267(`loadEntry ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
+    if (styleImports.length === 0) {
+      return {
+        code
+      };
+    }
     const ms = new MagicString(code);
-    await prependStyleImports.call(this, id, ms);
-    _optionalChain([debug4, 'optionalCall', _263 => _263(`loadEntry ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
+    for (const styleImport of styleImports) {
+      ms.prepend(`import '${styleImport}';
+`);
+    }
     return {
       code: ms.toString()
     };
   };
 }
-async function collectAppSideFiles(pluginCtx, id, json, jsonService, registerJsonAsset) {
-  const { sitemapLocation = "sitemap.json", themeLocation = "theme.json" } = json;
-  const processSideJson = async (location) => {
-    if (!location) {
-      return;
-    }
-    const { path: jsonPath, predictions } = await findJsonEntry(
-      _pathe2.default.resolve(_pathe2.default.dirname(id), location)
-    );
-    for (const prediction of predictions) {
-      await addWatchTarget(pluginCtx, prediction);
-    }
-    if (!jsonPath) {
-      return;
-    }
-    const content = await jsonService.read(jsonPath);
-    registerJsonAsset({
-      json: content,
-      jsonPath,
-      type: "app"
-    });
-  };
-  await processSideJson(sitemapLocation);
-  await processSideJson(themeLocation);
-}
-async function ensureTemplateScanned(pluginCtx, id, scanTemplateEntry) {
-  const { path: templateEntry, predictions } = await findTemplateEntry(id);
-  for (const prediction of predictions) {
-    await addWatchTarget(pluginCtx, prediction);
-  }
-  if (!templateEntry) {
-    return "";
-  }
-  await scanTemplateEntry(templateEntry);
-  return templateEntry;
-}
-async function resolveEntries(entries, absoluteSrcRoot) {
-  return Promise.all(
-    entries.filter((entry) => !entry.includes(":")).map(async (entry) => {
-      const absPath = _pathe2.default.resolve(absoluteSrcRoot, entry);
-      return {
-        entry,
-        resolvedId: await this.resolve(absPath)
-      };
-    })
-  );
-}
-async function prependStyleImports(id, ms) {
-  for (const ext2 of supportedCssLangs) {
-    const mayBeCssPath = changeFileExtension(id, ext2);
-    const exists = await addWatchTarget(this, mayBeCssPath);
-    if (exists) {
-      ms.prepend(`import '${mayBeCssPath}';
-`);
-    }
-  }
-}
-async function addWatchTarget(pluginCtx, target) {
-  if (!target || typeof pluginCtx.addWatchFile !== "function") {
-    return false;
-  }
-  const exists = await _fsextra2.default.exists(target);
-  if (exists) {
-    pluginCtx.addWatchFile(target);
-  }
-  return exists;
-}
 
 // src/plugins/hooks/useLoadEntry/normalizer.ts
 _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
@@ -19874,7 +19938,7 @@ function createTemplateScanner(wxmlService, debug4) {
       const { components: components2 } = wxmlToken;
       wxmlService.setWxmlComponentsMap(templateEntry, components2);
     }
-    _optionalChain([debug4, 'optionalCall', _264 => _264(`scanTemplateEntry ${templateEntry} \u8017\u65F6 ${(_perf_hooks.performance.now() - start).toFixed(2)}ms`)]);
+    _optionalChain([debug4, 'optionalCall', _268 => _268(`scanTemplateEntry ${templateEntry} \u8017\u65F6 ${(_perf_hooks.performance.now() - start).toFixed(2)}ms`)]);
   };
 }
 
@@ -20157,7 +20221,7 @@ function createCoreLifecyclePlugin(state) {
       options.input = scannedInput;
     },
     async load(id) {
-      _optionalChain([configService, 'access', _265 => _265.weappViteConfig, 'optionalAccess', _266 => _266.debug, 'optionalAccess', _267 => _267.load, 'optionalCall', _268 => _268(id, subPackageMeta)]);
+      _optionalChain([configService, 'access', _269 => _269.weappViteConfig, 'optionalAccess', _270 => _270.debug, 'optionalAccess', _271 => _271.load, 'optionalCall', _272 => _272(id, subPackageMeta)]);
       const relativeBasename = _shared.removeExtensionDeep.call(void 0, configService.relativeAbsoluteSrcRoot(id));
       if (isCSSRequest(id)) {
         const parsed = parseRequest(id);
@@ -20171,7 +20235,7 @@ function createCoreLifecyclePlugin(state) {
         }
         return null;
       }
-      if (loadedEntrySet.has(id) || _optionalChain([subPackageMeta, 'optionalAccess', _269 => _269.entries, 'access', _270 => _270.includes, 'call', _271 => _271(relativeBasename)])) {
+      if (loadedEntrySet.has(id) || _optionalChain([subPackageMeta, 'optionalAccess', _273 => _273.entries, 'access', _274 => _274.includes, 'call', _275 => _275(relativeBasename)])) {
         return await loadEntry.call(this, id, "component");
       }
       if (relativeBasename === "app") {
@@ -20184,10 +20248,10 @@ function createCoreLifecyclePlugin(state) {
     },
     async generateBundle() {
       await flushIndependentBuilds.call(this, state, watcherService);
-      if (_optionalChain([configService, 'access', _272 => _272.weappViteConfig, 'optionalAccess', _273 => _273.debug, 'optionalAccess', _274 => _274.watchFiles])) {
+      if (_optionalChain([configService, 'access', _276 => _276.weappViteConfig, 'optionalAccess', _277 => _277.debug, 'optionalAccess', _278 => _278.watchFiles])) {
         const watcherService2 = ctx.watcherService;
-        const watcherRoot = _nullishCoalesce(_optionalChain([subPackageMeta, 'optionalAccess', _275 => _275.subPackage, 'access', _276 => _276.root]), () => ( "/"));
-        const watcher = _optionalChain([watcherService2, 'optionalAccess', _277 => _277.getRollupWatcher, 'call', _278 => _278(watcherRoot)]);
+        const watcherRoot = _nullishCoalesce(_optionalChain([subPackageMeta, 'optionalAccess', _279 => _279.subPackage, 'access', _280 => _280.root]), () => ( "/"));
+        const watcher = _optionalChain([watcherService2, 'optionalAccess', _281 => _281.getRollupWatcher, 'call', _282 => _282(watcherRoot)]);
         let watchFiles;
         if (watcher && typeof watcher.getWatchFiles === "function") {
           watchFiles = await watcher.getWatchFiles();
@@ -20201,7 +20265,7 @@ function createCoreLifecyclePlugin(state) {
       }
     },
     buildEnd() {
-      _optionalChain([debug2, 'optionalCall', _279 => _279(`${subPackageMeta ? `\u72EC\u7ACB\u5206\u5305 ${subPackageMeta.subPackage.root}` : "\u4E3B\u5305"} ${Array.from(this.getModuleIds()).length} \u4E2A\u6A21\u5757\u88AB\u7F16\u8BD1`)]);
+      _optionalChain([debug2, 'optionalCall', _283 => _283(`${subPackageMeta ? `\u72EC\u7ACB\u5206\u5305 ${subPackageMeta.subPackage.root}` : "\u4E3B\u5305"} ${Array.from(this.getModuleIds()).length} \u4E2A\u6A21\u5757\u88AB\u7F16\u8BD1`)]);
     }
   };
 }
@@ -20557,14 +20621,14 @@ function createPluginPruner() {
     name: "weapp-vite:preflight",
     enforce: "pre",
     configResolved(config) {
-      if (!_optionalChain([config, 'access', _280 => _280.plugins, 'optionalAccess', _281 => _281.length])) {
+      if (!_optionalChain([config, 'access', _284 => _284.plugins, 'optionalAccess', _285 => _285.length])) {
         return;
       }
       for (const removePlugin of removePlugins) {
         const idx = config.plugins.findIndex((plugin) => plugin.name === removePlugin);
         if (idx > -1) {
           const [plugin] = config.plugins.splice(idx, 1);
-          plugin && _optionalChain([debug3, 'optionalCall', _282 => _282("remove plugin", plugin.name)]);
+          plugin && _optionalChain([debug3, 'optionalCall', _286 => _286("remove plugin", plugin.name)]);
         }
       }
     }
@@ -20603,8 +20667,8 @@ function createWorkerBuildPlugin(ctx) {
     name: "weapp-vite:workers",
     enforce: "pre",
     async options(options) {
-      const workerConfig = _optionalChain([configService, 'access', _283 => _283.weappViteConfig, 'optionalAccess', _284 => _284.worker]);
-      const entries = Array.isArray(_optionalChain([workerConfig, 'optionalAccess', _285 => _285.entry])) ? workerConfig.entry : [_optionalChain([workerConfig, 'optionalAccess', _286 => _286.entry])];
+      const workerConfig = _optionalChain([configService, 'access', _287 => _287.weappViteConfig, 'optionalAccess', _288 => _288.worker]);
+      const entries = Array.isArray(_optionalChain([workerConfig, 'optionalAccess', _289 => _289.entry])) ? workerConfig.entry : [_optionalChain([workerConfig, 'optionalAccess', _290 => _290.entry])];
       const normalized = (await Promise.all(entries.filter(Boolean).map((entry) => resolveWorkerEntry(ctx, entry)))).filter((result) => Boolean(result.value)).reduce((acc, cur) => {
         acc[cur.key] = cur.value;
         return acc;
@@ -20721,7 +20785,7 @@ async function transformWxsFile(state, wxsPath) {
     const { result, importees } = transformWxsCode(rawCode, {
       filename: wxsPath
     });
-    if (typeof _optionalChain([result, 'optionalAccess', _287 => _287.code]) === "string") {
+    if (typeof _optionalChain([result, 'optionalAccess', _291 => _291.code]) === "string") {
       code = result.code;
     }
     const dirname5 = _pathe2.default.dirname(wxsPath);
@@ -20771,13 +20835,13 @@ function vitePluginWeappWorkers(ctx) {
 }
 function attachRuntimePlugins(ctx, plugins) {
   const runtimePlugins = ctx[RUNTIME_PLUGINS_SYMBOL];
-  if (!_optionalChain([runtimePlugins, 'optionalAccess', _288 => _288.length])) {
+  if (!_optionalChain([runtimePlugins, 'optionalAccess', _292 => _292.length])) {
     return plugins;
   }
   return [...runtimePlugins, ...plugins];
 }
 function applyInspect(ctx, plugins) {
-  const inspectOptions = _optionalChain([ctx, 'access', _289 => _289.configService, 'access', _290 => _290.weappViteConfig, 'optionalAccess', _291 => _291.debug, 'optionalAccess', _292 => _292.inspect]);
+  const inspectOptions = _optionalChain([ctx, 'access', _293 => _293.configService, 'access', _294 => _294.weappViteConfig, 'optionalAccess', _295 => _295.debug, 'optionalAccess', _296 => _296.inspect]);
   if (!inspectOptions) {
     return plugins;
   }
@@ -20790,20 +20854,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 +20884,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 +20917,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', _297 => _297[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 +20945,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 +20965,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 +20977,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 +21065,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 +21075,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;
   }
@@ -20982,8 +21121,8 @@ export default _objectSpread2;`
       command: isDev ? "serve" : "build",
       mode
     }, resolvedConfigFile, cwd);
-    const loadedConfig = _optionalChain([loaded, 'optionalAccess', _294 => _294.config]);
-    const srcRoot = _nullishCoalesce(_optionalChain([loadedConfig, 'optionalAccess', _295 => _295.weapp, 'optionalAccess', _296 => _296.srcRoot]), () => ( ""));
+    const loadedConfig = _optionalChain([loaded, 'optionalAccess', _298 => _298.config]);
+    const srcRoot = _nullishCoalesce(_optionalChain([loadedConfig, 'optionalAccess', _299 => _299.weapp, 'optionalAccess', _300 => _300.srcRoot]), () => ( ""));
     function relativeSrcRoot(p) {
       if (srcRoot) {
         return _pathe2.default.relative(srcRoot, p);
@@ -21014,61 +21153,29 @@ 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 platform = _nullishCoalesce(_optionalChain([config, 'access', _301 => _301.weapp, 'optionalAccess', _302 => _302.platform]), () => ( "weapp"));
     const resolvedOutputExtensions = getOutputExtensions(platform);
     config.plugins ??= [];
-    _optionalChain([config, 'access', _299 => _299.plugins, 'optionalAccess', _300 => _300.push, 'call', _301 => _301(_vitetsconfigpaths2.default.call(void 0, _optionalChain([config, 'access', _302 => _302.weapp, 'optionalAccess', _303 => _303.tsconfigPaths])))]);
-    const aliasEntries = getAliasEntries(_optionalChain([config, 'access', _304 => _304.weapp, 'optionalAccess', _305 => _305.jsonAlias]));
+    _optionalChain([config, 'access', _303 => _303.plugins, 'optionalAccess', _304 => _304.push, 'call', _305 => _305(_vitetsconfigpaths2.default.call(void 0, _optionalChain([config, 'access', _306 => _306.weapp, 'optionalAccess', _307 => _307.tsconfigPaths])))]);
+    const aliasEntries = getAliasEntries(_optionalChain([config, 'access', _308 => _308.weapp, 'optionalAccess', _309 => _309.jsonAlias]));
     return {
       config,
       aliasEntries,
@@ -21135,7 +21242,7 @@ export default _objectSpread2;`
           }
         }
       );
-      injectOxcRuntimeAlias(inline);
+      injectBuiltinAliases(inline);
       return inline;
     }
     const inlineConfig = _shared.defu.call(void 0, 
@@ -21152,7 +21259,7 @@ export default _objectSpread2;`
       }
     );
     inlineConfig.logLevel = "info";
-    injectOxcRuntimeAlias(inlineConfig);
+    injectBuiltinAliases(inlineConfig);
     return inlineConfig;
   }
   function merge(subPackageMeta, ...configs) {
@@ -21166,9 +21273,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 +21304,7 @@ export default _objectSpread2;`
           }
         }
       );
-      injectOxcRuntimeAlias(inline);
+      injectBuiltinAliases(inline);
       return inline;
     }
     const inlineConfig = _shared.defu.call(void 0, 
@@ -21221,8 +21329,8 @@ export default _objectSpread2;`
       }
     );
     inlineConfig.logLevel = "info";
-    injectOxcRuntimeAlias(inlineConfig);
-    const currentRoot = _optionalChain([subPackageMeta, 'optionalAccess', _306 => _306.subPackage, 'access', _307 => _307.root]);
+    injectBuiltinAliases(inlineConfig);
+    const currentRoot = _optionalChain([subPackageMeta, 'optionalAccess', _310 => _310.subPackage, 'access', _311 => _311.root]);
     options = {
       ...options,
       currentSubPackageRoot: currentRoot
@@ -21293,10 +21401,10 @@ export default _objectSpread2;`
       return options.srcRoot;
     },
     get pluginRoot() {
-      return _optionalChain([options, 'access', _308 => _308.config, 'access', _309 => _309.weapp, 'optionalAccess', _310 => _310.pluginRoot]);
+      return _optionalChain([options, 'access', _312 => _312.config, 'access', _313 => _313.weapp, 'optionalAccess', _314 => _314.pluginRoot]);
     },
     get absolutePluginRoot() {
-      if (_optionalChain([options, 'access', _311 => _311.config, 'access', _312 => _312.weapp, 'optionalAccess', _313 => _313.pluginRoot])) {
+      if (_optionalChain([options, 'access', _315 => _315.config, 'access', _316 => _316.weapp, 'optionalAccess', _317 => _317.pluginRoot])) {
         return _pathe2.default.resolve(options.cwd, options.config.weapp.pluginRoot);
       }
     },
@@ -21372,7 +21480,7 @@ function createJsonService(ctx) {
       return resultJson;
     } catch (error) {
       logger_default.error(`\u6B8B\u7834\u7684JSON\u6587\u4EF6: ${filepath}`);
-      _optionalChain([debug, 'optionalCall', _314 => _314(error)]);
+      _optionalChain([debug, 'optionalCall', _318 => _318(error)]);
     }
   }
   function resolve8(entry) {
@@ -21424,7 +21532,7 @@ function createNpmService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before writing npm cache");
     }
-    if (_optionalChain([ctx, 'access', _315 => _315.configService, 'access', _316 => _316.weappViteConfig, 'optionalAccess', _317 => _317.npm, 'optionalAccess', _318 => _318.cache])) {
+    if (_optionalChain([ctx, 'access', _319 => _319.configService, 'access', _320 => _320.weappViteConfig, 'optionalAccess', _321 => _321.npm, 'optionalAccess', _322 => _322.cache])) {
       await _fsextra2.default.outputJSON(getDependenciesCacheFilePath(root), {
         hash: dependenciesCacheHash()
       });
@@ -21437,7 +21545,7 @@ function createNpmService(ctx) {
     }
   }
   async function checkDependenciesCacheOutdate(root) {
-    if (_optionalChain([ctx, 'access', _319 => _319.configService, 'optionalAccess', _320 => _320.weappViteConfig, 'optionalAccess', _321 => _321.npm, 'optionalAccess', _322 => _322.cache])) {
+    if (_optionalChain([ctx, 'access', _323 => _323.configService, 'optionalAccess', _324 => _324.weappViteConfig, 'optionalAccess', _325 => _325.npm, 'optionalAccess', _326 => _326.cache])) {
       const json = await readDependenciesCache(root);
       if (_shared.isObject.call(void 0, json)) {
         return dependenciesCacheHash() !== json.hash;
@@ -21471,7 +21579,7 @@ function createNpmService(ctx) {
       target: "es6",
       external: []
     });
-    const resolvedOptions = _optionalChain([ctx, 'access', _323 => _323.configService, 'optionalAccess', _324 => _324.weappViteConfig, 'optionalAccess', _325 => _325.npm, 'optionalAccess', _326 => _326.buildOptions, 'optionalCall', _327 => _327(
+    const resolvedOptions = _optionalChain([ctx, 'access', _327 => _327.configService, 'optionalAccess', _328 => _328.weappViteConfig, 'optionalAccess', _329 => _329.npm, 'optionalAccess', _330 => _330.buildOptions, 'optionalCall', _331 => _331(
       mergedOptions,
       { name, entry }
     )]);
@@ -21559,7 +21667,7 @@ function createNpmService(ctx) {
       throw new Error("configService must be initialized before resolving npm relation list");
     }
     let packNpmRelationList = [];
-    if (_optionalChain([ctx, 'access', _328 => _328.configService, 'access', _329 => _329.projectConfig, 'access', _330 => _330.setting, 'optionalAccess', _331 => _331.packNpmManually]) && Array.isArray(ctx.configService.projectConfig.setting.packNpmRelationList)) {
+    if (_optionalChain([ctx, 'access', _332 => _332.configService, 'access', _333 => _333.projectConfig, 'access', _334 => _334.setting, 'optionalAccess', _335 => _335.packNpmManually]) && Array.isArray(ctx.configService.projectConfig.setting.packNpmRelationList)) {
       packNpmRelationList = ctx.configService.projectConfig.setting.packNpmRelationList;
     } else {
       packNpmRelationList = [
@@ -21572,10 +21680,10 @@ function createNpmService(ctx) {
     return packNpmRelationList;
   }
   async function build3(options) {
-    if (!_optionalChain([ctx, 'access', _332 => _332.configService, 'optionalAccess', _333 => _333.weappViteConfig, 'optionalAccess', _334 => _334.npm, 'optionalAccess', _335 => _335.enable])) {
+    if (!_optionalChain([ctx, 'access', _336 => _336.configService, 'optionalAccess', _337 => _337.weappViteConfig, 'optionalAccess', _338 => _338.npm, 'optionalAccess', _339 => _339.enable])) {
       return;
     }
-    _optionalChain([debug, 'optionalCall', _336 => _336("buildNpm start")]);
+    _optionalChain([debug, 'optionalCall', _340 => _340("buildNpm start")]);
     const packNpmRelationList = getPackNpmRelationList();
     const [mainRelation, ...subRelations] = packNpmRelationList;
     const packageJsonPath = _pathe2.default.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
@@ -21650,7 +21758,7 @@ function createNpmService(ctx) {
         }
       }
     }
-    _optionalChain([debug, 'optionalCall', _337 => _337("buildNpm end")]);
+    _optionalChain([debug, 'optionalCall', _341 => _341("buildNpm end")]);
   }
   return {
     getDependenciesCacheFilePath,
@@ -21694,7 +21802,7 @@ var TimeoutError = (_class16 = class _TimeoutError extends Error {
   __init36() {this.name = "TimeoutError"}
   constructor(message, options) {
     super(message, options);_class16.prototype.__init36.call(this);;
-    _optionalChain([Error, 'access', _338 => _338.captureStackTrace, 'optionalCall', _339 => _339(this, _TimeoutError)]);
+    _optionalChain([Error, 'access', _342 => _342.captureStackTrace, 'optionalCall', _343 => _343(this, _TimeoutError)]);
   }
 }, _class16);
 var getAbortedReason = (signal) => _nullishCoalesce(signal.reason, () => ( new DOMException("This operation was aborted.", "AbortError")));
@@ -21712,7 +21820,7 @@ function pTimeout(promise, options) {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
-    if (_optionalChain([signal, 'optionalAccess', _340 => _340.aborted])) {
+    if (_optionalChain([signal, 'optionalAccess', _344 => _344.aborted])) {
       reject(getAbortedReason(signal));
       return;
     }
@@ -21810,7 +21918,7 @@ var PriorityQueue = class {
   }
   dequeue() {
     const item = this.#queue.shift();
-    return _optionalChain([item, 'optionalAccess', _341 => _341.run]);
+    return _optionalChain([item, 'optionalAccess', _345 => _345.run]);
   }
   filter(options) {
     return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
@@ -21871,10 +21979,10 @@ var PQueue = class extends import_index2.default {
       ...options
     };
     if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
-      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${_nullishCoalesce(_optionalChain([options, 'access', _342 => _342.intervalCap, 'optionalAccess', _343 => _343.toString, 'call', _344 => _344()]), () => ( ""))}\` (${typeof options.intervalCap})`);
+      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${_nullishCoalesce(_optionalChain([options, 'access', _346 => _346.intervalCap, 'optionalAccess', _347 => _347.toString, 'call', _348 => _348()]), () => ( ""))}\` (${typeof options.intervalCap})`);
     }
     if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) {
-      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${_nullishCoalesce(_optionalChain([options, 'access', _345 => _345.interval, 'optionalAccess', _346 => _346.toString, 'call', _347 => _347()]), () => ( ""))}\` (${typeof options.interval})`);
+      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${_nullishCoalesce(_optionalChain([options, 'access', _349 => _349.interval, 'optionalAccess', _350 => _350.toString, 'call', _351 => _351()]), () => ( ""))}\` (${typeof options.interval})`);
     }
     this.#carryoverIntervalCount = _nullishCoalesce(_nullishCoalesce(options.carryoverIntervalCount, () => ( options.carryoverConcurrencyCount)), () => ( false));
     this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
@@ -22081,7 +22189,7 @@ var PQueue = class extends import_index2.default {
         });
         try {
           try {
-            _optionalChain([options, 'access', _348 => _348.signal, 'optionalAccess', _349 => _349.throwIfAborted, 'call', _350 => _350()]);
+            _optionalChain([options, 'access', _352 => _352.signal, 'optionalAccess', _353 => _353.throwIfAborted, 'call', _354 => _354()]);
           } catch (error) {
             if (!this.#isIntervalIgnored) {
               this.#intervalCount--;
@@ -22390,9 +22498,30 @@ _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
 // src/cache/file.ts
 _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
 
-
+var FNV_OFFSET_BASIS = 0xCBF29CE484222325n;
+var FNV_PRIME = 0x100000001B3n;
+var FNV_MASK = 0xFFFFFFFFFFFFFFFFn;
+function fnv1aStep(hash, byte) {
+  hash ^= BigInt(byte & 255);
+  return hash * FNV_PRIME & FNV_MASK;
+}
 function createSignature(content) {
-  return _crypto.createHash.call(void 0, "sha1").update(content).digest("hex");
+  let hash = FNV_OFFSET_BASIS;
+  if (typeof content === "string") {
+    for (let i = 0; i < content.length; i++) {
+      const code = content.charCodeAt(i);
+      hash = fnv1aStep(hash, code & 255);
+      const high = code >>> 8;
+      if (high > 0) {
+        hash = fnv1aStep(hash, high);
+      }
+    }
+  } else {
+    for (const byte of content) {
+      hash = fnv1aStep(hash, byte);
+    }
+  }
+  return hash.toString(36);
 }
 var FileCache = class {
   
@@ -22433,7 +22562,7 @@ var FileCache = class {
       return true;
     }
     const cachedMtime = this.mtimeMap.get(id);
-    const nextSignature = _optionalChain([options, 'optionalAccess', _351 => _351.content]) !== void 0 ? createSignature(options.content) : void 0;
+    const nextSignature = _optionalChain([options, 'optionalAccess', _355 => _355.content]) !== void 0 ? createSignature(options.content) : void 0;
     const updateSignature = () => {
       if (nextSignature !== void 0) {
         this.signatureMap.set(id, nextSignature);
@@ -22609,7 +22738,7 @@ function createScanService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before scanning subpackages");
     }
-    const json = _optionalChain([scanState, 'access', _352 => _352.appEntry, 'optionalAccess', _353 => _353.json]);
+    const json = _optionalChain([scanState, 'access', _356 => _356.appEntry, 'optionalAccess', _357 => _357.json]);
     if (scanState.isDirty || subPackageMap.size === 0) {
       subPackageMap.clear();
       independentSubPackageMap.clear();
@@ -22627,9 +22756,9 @@ function createScanService(ctx) {
             subPackage,
             entries: resolveSubPackageEntries(subPackage)
           };
-          const subPackageConfig = _optionalChain([ctx, 'access', _354 => _354.configService, 'access', _355 => _355.weappViteConfig, 'optionalAccess', _356 => _356.subPackages, 'optionalAccess', _357 => _357[subPackage.root]]);
-          meta.subPackage.dependencies = _optionalChain([subPackageConfig, 'optionalAccess', _358 => _358.dependencies]);
-          meta.subPackage.inlineConfig = _optionalChain([subPackageConfig, 'optionalAccess', _359 => _359.inlineConfig]);
+          const subPackageConfig = _optionalChain([ctx, 'access', _358 => _358.configService, 'access', _359 => _359.weappViteConfig, 'optionalAccess', _360 => _360.subPackages, 'optionalAccess', _361 => _361[subPackage.root]]);
+          meta.subPackage.dependencies = _optionalChain([subPackageConfig, 'optionalAccess', _362 => _362.dependencies]);
+          meta.subPackage.inlineConfig = _optionalChain([subPackageConfig, 'optionalAccess', _363 => _363.inlineConfig]);
           metas.push(meta);
           if (subPackage.root) {
             subPackageMap.set(subPackage.root, meta);
@@ -22679,11 +22808,11 @@ function createScanService(ctx) {
     loadSubPackages,
     isMainPackageFileName,
     get workersOptions() {
-      return _optionalChain([scanState, 'access', _360 => _360.appEntry, 'optionalAccess', _361 => _361.json, 'optionalAccess', _362 => _362.workers]);
+      return _optionalChain([scanState, 'access', _364 => _364.appEntry, 'optionalAccess', _365 => _365.json, 'optionalAccess', _366 => _366.workers]);
     },
     get workersDir() {
-      const workersOptions = _optionalChain([scanState, 'access', _363 => _363.appEntry, 'optionalAccess', _364 => _364.json, 'optionalAccess', _365 => _365.workers]);
-      return typeof workersOptions === "object" ? _optionalChain([workersOptions, 'optionalAccess', _366 => _366.path]) : workersOptions;
+      const workersOptions = _optionalChain([scanState, 'access', _367 => _367.appEntry, 'optionalAccess', _368 => _368.json, 'optionalAccess', _369 => _369.workers]);
+      return typeof workersOptions === "object" ? _optionalChain([workersOptions, 'optionalAccess', _370 => _370.path]) : workersOptions;
     },
     markDirty() {
       scanState.isDirty = true;
@@ -22729,7 +22858,7 @@ function createWatcherService(ctx) {
     },
     setRollupWatcher(watcher, root = "/") {
       const oldWatcher = rollupWatcherMap.get(root);
-      _optionalChain([oldWatcher, 'optionalAccess', _367 => _367.close, 'call', _368 => _368()]);
+      _optionalChain([oldWatcher, 'optionalAccess', _371 => _371.close, 'call', _372 => _372()]);
       rollupWatcherMap.set(root, watcher);
     },
     closeAll() {
@@ -22765,7 +22894,7 @@ function createWatcherServicePlugin(ctx) {
     name: "weapp-runtime:watcher-service",
     closeBundle() {
       const configService = ctx.configService;
-      const isWatchMode = _optionalChain([configService, 'optionalAccess', _369 => _369.isDev]) || Boolean(_optionalChain([configService, 'optionalAccess', _370 => _370.inlineConfig, 'optionalAccess', _371 => _371.build, 'optionalAccess', _372 => _372.watch]));
+      const isWatchMode = _optionalChain([configService, 'optionalAccess', _373 => _373.isDev]) || Boolean(_optionalChain([configService, 'optionalAccess', _374 => _374.inlineConfig, 'optionalAccess', _375 => _375.build, 'optionalAccess', _376 => _376.watch]));
       if (!isWatchMode) {
         service.closeAll();
       }
@@ -25159,7 +25288,7 @@ function fnv1aHash(input) {
   }
   return (hash >>> 0).toString(36);
 }
-function createCacheKey(source, platform) {
+function createCacheKey2(source, platform) {
   return `${platform}:${source.length.toString(36)}:${fnv1aHash(source)}`;
 }
 function resolveEventDirective(raw) {
@@ -25222,7 +25351,7 @@ function scanWxml(wxml, options) {
     platform: "weapp"
   });
   const canUseCache = opts.excludeComponent === defaultExcludeComponent;
-  const cacheKey = canUseCache ? createCacheKey(source, opts.platform) : void 0;
+  const cacheKey = canUseCache ? createCacheKey2(source, opts.platform) : void 0;
   if (cacheKey) {
     const cached = scanWxmlCache.get(cacheKey);
     if (cached) {
@@ -25364,6 +25493,9 @@ function scanWxml(wxml, options) {
     source
   );
   parser.end();
+  if (removalRanges.length > 1) {
+    removalRanges.sort((a, b) => b.start - a.start);
+  }
   const token = {
     components: components2,
     deps,
@@ -25412,7 +25544,7 @@ function createWxmlService(ctx) {
     return set3;
   }
   function clearAll() {
-    const currentRoot = _optionalChain([ctx, 'access', _373 => _373.configService, 'optionalAccess', _374 => _374.currentSubPackageRoot]);
+    const currentRoot = _optionalChain([ctx, 'access', _377 => _377.configService, 'optionalAccess', _378 => _378.currentSubPackageRoot]);
     if (!currentRoot) {
       depsMap.clear();
       tokenMap.clear();
@@ -25467,7 +25599,7 @@ function createWxmlService(ctx) {
     }
     return scanWxml(wxml, {
       platform: ctx.configService.platform,
-      ..._optionalChain([ctx, 'access', _375 => _375.configService, 'access', _376 => _376.weappViteConfig, 'optionalAccess', _377 => _377.enhance, 'optionalAccess', _378 => _378.wxml]) === true ? {} : _optionalChain([ctx, 'access', _379 => _379.configService, 'access', _380 => _380.weappViteConfig, 'optionalAccess', _381 => _381.enhance, 'optionalAccess', _382 => _382.wxml])
+      ..._optionalChain([ctx, 'access', _379 => _379.configService, 'access', _380 => _380.weappViteConfig, 'optionalAccess', _381 => _381.enhance, 'optionalAccess', _382 => _382.wxml]) === true ? {} : _optionalChain([ctx, 'access', _383 => _383.configService, 'access', _384 => _384.weappViteConfig, 'optionalAccess', _385 => _385.enhance, 'optionalAccess', _386 => _386.wxml])
     });
   }
   async function scan(filepath) {
@@ -25576,8 +25708,8 @@ function resetCompilerContext(key) {
 
 // src/createContext.ts
 async function createCompilerContext(options) {
-  const key = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _383 => _383.key]), () => ( "default"));
-  if (!_optionalChain([options, 'optionalAccess', _384 => _384.key])) {
+  const key = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _387 => _387.key]), () => ( "default"));
+  if (!_optionalChain([options, 'optionalAccess', _388 => _388.key])) {
     resetCompilerContext(key);
   }
   const ctx = getCompilerContext(key);