weapp-vite 5.4.0 → 5.5.0

package/dist/{chunk-XEHEGODS.cjs → chunk-5GG5TEGR.cjs}

@@ -2952,13 +2952,13 @@ function extractComponentProps(code) {
   });
   let props = /* @__PURE__ */ new Map();
   _traverse2.default.call(void 0, ast, {
-    CallExpression(path30) {
+    CallExpression(path31) {
       if (props.size > 0) {
         return;
       }
-      const callee = path30.node.callee;
+      const callee = path31.node.callee;
       if (callee.type === "Identifier" && callee.name === "Component") {
-        const [options] = path30.node.arguments;
+        const [options] = path31.node.arguments;
         if (options && options.type === "ObjectExpression") {
           props = extractComponentProperties(options);
         }
@@ -4386,7 +4386,7 @@ var ReaddirpStream = class extends _stream.Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? _promises.lstat : _promises.stat;
     if (wantBigintFsStats) {
-      this._stat = (path30) => statMethod(path30, { bigint: true });
+      this._stat = (path31) => statMethod(path31, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -4411,8 +4411,8 @@ var ReaddirpStream = class extends _stream.Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path30, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path30));
+          const { path: path31, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path31));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -4452,20 +4452,20 @@ var ReaddirpStream = class extends _stream.Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path30, depth) {
+  async _exploreDir(path31, depth) {
     let files;
     try {
-      files = await _promises.readdir.call(void 0, path30, this._rdOptions);
+      files = await _promises.readdir.call(void 0, path31, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path30 };
+    return { files, depth, path: path31 };
   }
-  async _formatEntry(dirent, path30) {
+  async _formatEntry(dirent, path31) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = _path.resolve.call(void 0, _path.join.call(void 0, path30, basename4));
+      const fullPath = _path.resolve.call(void 0, _path.join.call(void 0, path31, 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) {
@@ -4866,16 +4866,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path30, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path31, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path30);
-    emitRaw(rawEvent, evPath, { watchedPath: path30 });
-    if (evPath && path30 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path30, evPath), KEY_LISTENERS, sysPath.join(path30, evPath));
+    listener(path31);
+    emitRaw(rawEvent, evPath, { watchedPath: path31 });
+    if (evPath && path31 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path31, evPath), KEY_LISTENERS, sysPath.join(path31, evPath));
     }
   };
   try {
-    return _fs.watch.call(void 0, path30, {
+    return _fs.watch.call(void 0, path31, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -4891,12 +4891,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path30, fullPath, options, handlers) => {
+var setFsWatchListener = (path31, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path30, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path31, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -4907,7 +4907,7 @@ var setFsWatchListener = (path30, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path30,
+      path31,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -4922,7 +4922,7 @@ var setFsWatchListener = (path30, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await _promises.open.call(void 0, path30, "r");
+          const fd = await _promises.open.call(void 0, path31, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -4953,7 +4953,7 @@ var setFsWatchListener = (path30, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path30, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path31, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -4975,7 +4975,7 @@ var setFsWatchFileListener = (path30, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path30, curr));
+          foreach(cont.listeners, (listener2) => listener2(path31, curr));
         }
       })
     };
@@ -5003,13 +5003,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path30, listener) {
+  _watchWithNodeFs(path31, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path30);
-    const basename4 = sysPath.basename(path30);
+    const directory = sysPath.dirname(path31);
+    const basename4 = sysPath.basename(path31);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename4);
-    const absolutePath = sysPath.resolve(path30);
+    const absolutePath = sysPath.resolve(path31);
     const options = {
       persistent: opts.persistent
     };
@@ -5019,12 +5019,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path30, absolutePath, options, {
+      closer = setFsWatchFileListener(path31, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path30, absolutePath, options, {
+      closer = setFsWatchListener(path31, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -5046,7 +5046,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename4))
       return;
-    const listener = async (path30, newStats) => {
+    const listener = async (path31, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -5060,11 +5060,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path30);
+            this.fsw._closeFile(path31);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path30, closer2);
+              this.fsw._addPathCloser(path31, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -5096,7 +5096,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, path30, item) {
+  async _handleSymlink(entry, directory, path31, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -5106,7 +5106,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await _promises.realpath.call(void 0, path30);
+        linkPath = await _promises.realpath.call(void 0, path31);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -5116,12 +5116,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, path30, entry.stats);
+          this.fsw._emit(EV.CHANGE, path31, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path30, entry.stats);
+        this.fsw._emit(EV.ADD, path31, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -5150,9 +5150,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path30 = sysPath.join(directory, item);
+      let path31 = sysPath.join(directory, item);
       current2.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path30, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path31, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -5161,8 +5161,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path30 = sysPath.join(dir, sysPath.relative(dir, path30));
-        this._addToNodeFs(path30, initialAdd, wh, depth + 1);
+        path31 = sysPath.join(dir, sysPath.relative(dir, path31));
+        this._addToNodeFs(path31, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve8, reject) => {
@@ -5231,13 +5231,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path30, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path31, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path30) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path31) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path30);
+    const wh = this.fsw._getWatchHelpers(path31);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -5253,8 +5253,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path30);
-        const targetPath = follow ? await _promises.realpath.call(void 0, path30) : path30;
+        const absPath = sysPath.resolve(path31);
+        const targetPath = follow ? await _promises.realpath.call(void 0, path31) : path31;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -5264,29 +5264,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await _promises.realpath.call(void 0, path30) : path30;
+        const targetPath = follow ? await _promises.realpath.call(void 0, path31) : path31;
         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, path30, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path31, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path30), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path31), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path30, closer);
+        this.fsw._addPathCloser(path31, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path30;
+        return path31;
       }
     }
   }
@@ -5329,26 +5329,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path30) {
-  if (typeof path30 !== "string")
+function normalizePath(path31) {
+  if (typeof path31 !== "string")
     throw new Error("string expected");
-  path30 = sysPath2.normalize(path30);
-  path30 = path30.replace(/\\/g, "/");
+  path31 = sysPath2.normalize(path31);
+  path31 = path31.replace(/\\/g, "/");
   let prepend = false;
-  if (path30.startsWith("//"))
+  if (path31.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path30.match(DOUBLE_SLASH_RE2))
-    path30 = path30.replace(DOUBLE_SLASH_RE2, "/");
+  while (path31.match(DOUBLE_SLASH_RE2))
+    path31 = path31.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path30 = "/" + path30;
-  return path30;
+    path31 = "/" + path31;
+  return path31;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path30 = normalizePath(testString);
+  const path31 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path30, stats)) {
+    if (pattern(path31, stats)) {
       return true;
     }
   }
@@ -5388,19 +5388,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path30) => toUnix(sysPath2.normalize(toUnix(path30)));
-var normalizeIgnored = (cwd = "") => (path30) => {
-  if (typeof path30 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path30) ? path30 : sysPath2.join(cwd, path30));
+var normalizePathToUnix = (path31) => toUnix(sysPath2.normalize(toUnix(path31)));
+var normalizeIgnored = (cwd = "") => (path31) => {
+  if (typeof path31 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path31) ? path31 : sysPath2.join(cwd, path31));
   } else {
-    return path30;
+    return path31;
   }
 };
-var getAbsolutePath = (path30, cwd) => {
-  if (sysPath2.isAbsolute(path30)) {
-    return path30;
+var getAbsolutePath = (path31, cwd) => {
+  if (sysPath2.isAbsolute(path31)) {
+    return path31;
   }
-  return sysPath2.join(cwd, path30);
+  return sysPath2.join(cwd, path31);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -5455,10 +5455,10 @@ var DirEntry = class {
 var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 var WatchHelper = class {
-  constructor(path30, follow, fsw) {
+  constructor(path31, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path30;
-    this.path = path30 = path30.replace(REPLACER_RE, "");
+    const watchPath = path31;
+    this.path = path31 = path31.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -5580,20 +5580,20 @@ var FSWatcher = class extends _events2.EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path30) => {
-        const absPath = getAbsolutePath(path30, cwd);
+      paths = paths.map((path31) => {
+        const absPath = getAbsolutePath(path31, cwd);
         return absPath;
       });
     }
-    paths.forEach((path30) => {
-      this._removeIgnoredPath(path30);
+    paths.forEach((path31) => {
+      this._removeIgnoredPath(path31);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path30) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path30, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path31) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path31, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -5615,17 +5615,17 @@ var FSWatcher = class extends _events2.EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path30) => {
-      if (!sysPath2.isAbsolute(path30) && !this._closers.has(path30)) {
+    paths.forEach((path31) => {
+      if (!sysPath2.isAbsolute(path31) && !this._closers.has(path31)) {
         if (cwd)
-          path30 = sysPath2.join(cwd, path30);
-        path30 = sysPath2.resolve(path30);
+          path31 = sysPath2.join(cwd, path31);
+        path31 = sysPath2.resolve(path31);
       }
-      this._closePath(path30);
-      this._addIgnoredPath(path30);
-      if (this._watched.has(path30)) {
+      this._closePath(path31);
+      this._addIgnoredPath(path31);
+      if (this._watched.has(path31)) {
         this._addIgnoredPath({
-          path: path30,
+          path: path31,
           recursive: true
         });
       }
@@ -5689,38 +5689,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, path30, stats) {
+  async _emit(event, path31, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path30 = sysPath2.normalize(path30);
+      path31 = sysPath2.normalize(path31);
     if (opts.cwd)
-      path30 = sysPath2.relative(opts.cwd, path30);
-    const args = [path30];
+      path31 = sysPath2.relative(opts.cwd, path31);
+    const args = [path31];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path30))) {
+    if (awf && (pw = this._pendingWrites.get(path31))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path30, [event, ...args]);
+        this._pendingUnlinks.set(path31, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path31) => {
+          this._pendingUnlinks.forEach((entry, path32) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path31);
+            this._pendingUnlinks.delete(path32);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path30)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path31)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path30);
+        this._pendingUnlinks.delete(path31);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -5738,16 +5738,16 @@ var FSWatcher = class extends _events2.EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path30, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path31, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path30, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path31, 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, path30) : path30;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path31) : path31;
       let stats2;
       try {
         stats2 = await _promises.stat.call(void 0, fullPath);
@@ -5778,23 +5778,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, path30, timeout) {
+  _throttle(actionType, path31, 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(path30);
+    const actionPath = action.get(path31);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path30);
+      const item = action.get(path31);
       const count = item ? item.count : 0;
-      action.delete(path30);
+      action.delete(path31);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -5802,7 +5802,7 @@ var FSWatcher = class extends _events2.EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path30, thr);
+    action.set(path31, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -5816,44 +5816,44 @@ var FSWatcher = class extends _events2.EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path30, threshold, event, awfEmit) {
+  _awaitWriteFinish(path31, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path30;
-    if (this.options.cwd && !sysPath2.isAbsolute(path30)) {
-      fullPath = sysPath2.join(this.options.cwd, path30);
+    let fullPath = path31;
+    if (this.options.cwd && !sysPath2.isAbsolute(path31)) {
+      fullPath = sysPath2.join(this.options.cwd, path31);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       _fs.stat.call(void 0, fullPath, (err, curStat) => {
-        if (err || !writes.has(path30)) {
+        if (err || !writes.has(path31)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path30).lastChange = now2;
+          writes.get(path31).lastChange = now2;
         }
-        const pw = writes.get(path30);
+        const pw = writes.get(path31);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path30);
+          writes.delete(path31);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path30)) {
-      writes.set(path30, {
+    if (!writes.has(path31)) {
+      writes.set(path31, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path30);
+          writes.delete(path31);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -5864,8 +5864,8 @@ var FSWatcher = class extends _events2.EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path30, stats) {
-    if (this.options.atomic && DOT_RE.test(path30))
+  _isIgnored(path31, stats) {
+    if (this.options.atomic && DOT_RE.test(path31))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -5875,17 +5875,17 @@ var FSWatcher = class extends _events2.EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path30, stats);
+    return this._userIgnored(path31, stats);
   }
-  _isntIgnored(path30, stat6) {
-    return !this._isIgnored(path30, stat6);
+  _isntIgnored(path31, stat6) {
+    return !this._isIgnored(path31, stat6);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path30) {
-    return new WatchHelper(path30, this.options.followSymlinks, this);
+  _getWatchHelpers(path31) {
+    return new WatchHelper(path31, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -5917,63 +5917,63 @@ var FSWatcher = class extends _events2.EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path30 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path30);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path30) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path30, 100))
+    const path31 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path31);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path31) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path31, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path30);
+    const wp = this._getWatchedDir(path31);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path30, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path31, 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 = path30;
+    let relPath = path31;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path30);
+      relPath = sysPath2.relative(this.options.cwd, path31);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path30);
+    this._watched.delete(path31);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path30))
-      this._emit(eventName, path30);
-    this._closePath(path30);
+    if (wasTracked && !this._isIgnored(path31))
+      this._emit(eventName, path31);
+    this._closePath(path31);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path30) {
-    this._closeFile(path30);
-    const dir = sysPath2.dirname(path30);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path30));
+  _closePath(path31) {
+    this._closeFile(path31);
+    const dir = sysPath2.dirname(path31);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path31));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path30) {
-    const closers = this._closers.get(path30);
+  _closeFile(path31) {
+    const closers = this._closers.get(path31);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path30);
+    this._closers.delete(path31);
   }
-  _addPathCloser(path30, closer) {
+  _addPathCloser(path31, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path30);
+    let list = this._closers.get(path31);
     if (!list) {
       list = [];
-      this._closers.set(path30, list);
+      this._closers.set(path31, list);
     }
     list.push(closer);
   }
@@ -8505,12 +8505,12 @@ var PathBase = (_class6 = class {
   /**
    * Get the Path object referenced by the string path, resolved from this Path
    */
-  resolve(path30) {
-    if (!path30) {
+  resolve(path31) {
+    if (!path31) {
       return this;
     }
-    const rootPath = this.getRootString(path30);
-    const dir = path30.substring(rootPath.length);
+    const rootPath = this.getRootString(path31);
+    const dir = path31.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -9262,8 +9262,8 @@ var PathWin32 = (_class7 = class _PathWin32 extends PathBase {
   /**
    * @internal
    */
-  getRootString(path30) {
-    return _path.win32.parse(path30).root;
+  getRootString(path31) {
+    return _path.win32.parse(path31).root;
   }
   /**
    * @internal
@@ -9309,8 +9309,8 @@ var PathPosix = (_class8 = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path30) {
-    return path30.startsWith("/") ? "/" : "";
+  getRootString(path31) {
+    return path31.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -9399,11 +9399,11 @@ var PathScurryBase = class {
   /**
    * Get the depth of a provided path, string, or the cwd
    */
-  depth(path30 = this.cwd) {
-    if (typeof path30 === "string") {
-      path30 = this.cwd.resolve(path30);
+  depth(path31 = this.cwd) {
+    if (typeof path31 === "string") {
+      path31 = this.cwd.resolve(path31);
     }
-    return path30.depth();
+    return path31.depth();
   }
   /**
    * Return the cache of child entries.  Exposed so subclasses can create
@@ -9890,9 +9890,9 @@ var PathScurryBase = class {
     process10();
     return results;
   }
-  chdir(path30 = this.cwd) {
+  chdir(path31 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path30 === "string" ? this.cwd.resolve(path30) : path30;
+    this.cwd = typeof path31 === "string" ? this.cwd.resolve(path31) : path31;
     this.cwd[setAsCwd](oldCwd);
   }
 };
@@ -10254,8 +10254,8 @@ var MatchRecord = (_class11 = class {constructor() { _class11.prototype.__init28
   }
   // match, absolute, ifdir
   entries() {
-    return [...this.store.entries()].map(([path30, n2]) => [
-      path30,
+    return [...this.store.entries()].map(([path31, n2]) => [
+      path31,
       !!(n2 & 2),
       !!(n2 & 1)
     ]);
@@ -10460,9 +10460,9 @@ var GlobUtil = (_class14 = class {
   
   
   
-  constructor(patterns, path30, opts) {;_class14.prototype.__init32.call(this);_class14.prototype.__init33.call(this);_class14.prototype.__init34.call(this);
+  constructor(patterns, path31, opts) {;_class14.prototype.__init32.call(this);_class14.prototype.__init33.call(this);_class14.prototype.__init34.call(this);
     this.patterns = patterns;
-    this.path = path30;
+    this.path = path31;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -10481,11 +10481,11 @@ var GlobUtil = (_class14 = class {
       });
     }
   }
-  #ignored(path30) {
-    return this.seen.has(path30) || !!_optionalChain([this, 'access', _143 => _143.#ignore, 'optionalAccess', _144 => _144.ignored, 'optionalCall', _145 => _145(path30)]);
+  #ignored(path31) {
+    return this.seen.has(path31) || !!_optionalChain([this, 'access', _143 => _143.#ignore, 'optionalAccess', _144 => _144.ignored, 'optionalCall', _145 => _145(path31)]);
   }
-  #childrenIgnored(path30) {
-    return !!_optionalChain([this, 'access', _146 => _146.#ignore, 'optionalAccess', _147 => _147.childrenIgnored, 'optionalCall', _148 => _148(path30)]);
+  #childrenIgnored(path31) {
+    return !!_optionalChain([this, 'access', _146 => _146.#ignore, 'optionalAccess', _147 => _147.childrenIgnored, 'optionalCall', _148 => _148(path31)]);
   }
   // backpressure mechanism
   pause() {
@@ -10700,8 +10700,8 @@ var GlobUtil = (_class14 = class {
 }, _class14);
 var GlobWalker = (_class15 = class extends GlobUtil {
   __init35() {this.matches = /* @__PURE__ */ new Set()}
-  constructor(patterns, path30, opts) {
-    super(patterns, path30, opts);_class15.prototype.__init35.call(this);;
+  constructor(patterns, path31, opts) {
+    super(patterns, path31, opts);_class15.prototype.__init35.call(this);;
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -10738,8 +10738,8 @@ var GlobWalker = (_class15 = class extends GlobUtil {
 }, _class15);
 var GlobStream = class extends GlobUtil {
   
-  constructor(patterns, path30, opts) {
-    super(patterns, path30, opts);
+  constructor(patterns, path31, opts) {
+    super(patterns, path31, opts);
     this.results = new Minipass({
       signal: this.signal,
       objectMode: true
@@ -11076,44 +11076,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 = (path30, opt = {}) => {
-  const type = typeof path30;
+var pathArg = (path31, opt = {}) => {
+  const type = typeof path31;
   if (type !== "string") {
-    const ctor = path30 && type === "object" && path30.constructor;
-    const received = ctor && ctor.name ? `an instance of ${ctor.name}` : type === "object" ? _util.inspect.call(void 0, path30) : `type ${type} ${path30}`;
+    const ctor = path31 && type === "object" && path31.constructor;
+    const received = ctor && ctor.name ? `an instance of ${ctor.name}` : type === "object" ? _util.inspect.call(void 0, path31) : `type ${type} ${path31}`;
     const msg = `The "path" argument must be of type string. Received ${received}`;
     throw Object.assign(new TypeError(msg), {
-      path: path30,
+      path: path31,
       code: "ERR_INVALID_ARG_TYPE"
     });
   }
-  if (/\0/.test(path30)) {
+  if (/\0/.test(path31)) {
     const msg = "path must be a string without null bytes";
     throw Object.assign(new TypeError(msg), {
-      path: path30,
+      path: path31,
       code: "ERR_INVALID_ARG_VALUE"
     });
   }
-  path30 = _path.resolve.call(void 0, path30);
-  const { root } = _path.parse.call(void 0, path30);
-  if (path30 === root && opt.preserveRoot !== false) {
+  path31 = _path.resolve.call(void 0, path31);
+  const { root } = _path.parse.call(void 0, path31);
+  if (path31 === root && opt.preserveRoot !== false) {
     const msg = "refusing to remove root directory without preserveRoot:false";
     throw Object.assign(new Error(msg), {
-      path: path30,
+      path: path31,
       code: "ERR_PRESERVE_ROOT"
     });
   }
   if (platform_default === "win32") {
     const badWinChars = /[*|"<>?:]/;
-    const { root: root2 } = _path.parse.call(void 0, path30);
-    if (badWinChars.test(path30.substring(root2.length))) {
+    const { root: root2 } = _path.parse.call(void 0, path31);
+    if (badWinChars.test(path31.substring(root2.length))) {
       throw Object.assign(new Error("Illegal characters in path."), {
-        path: path30,
+        path: path31,
         code: "EINVAL"
       });
     }
   }
-  return path30;
+  return path31;
 };
 var path_arg_default = pathArg;
 
@@ -11128,16 +11128,16 @@ _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
 
 
 
-var readdirSync2 = (path30) => _fs.readdirSync.call(void 0, path30, { withFileTypes: true });
-var chmod = (path30, mode) => new Promise((res, rej) => actualFS.default.chmod(path30, mode, (er, ...d) => er ? rej(er) : res(...d)));
-var mkdir = (path30, options) => new Promise((res, rej) => actualFS.default.mkdir(path30, options, (er, made) => er ? rej(er) : res(made)));
-var readdir4 = (path30) => new Promise((res, rej) => actualFS.default.readdir(path30, { withFileTypes: true }, (er, data2) => er ? rej(er) : res(data2)));
+var readdirSync2 = (path31) => _fs.readdirSync.call(void 0, path31, { withFileTypes: true });
+var chmod = (path31, mode) => new Promise((res, rej) => actualFS.default.chmod(path31, mode, (er, ...d) => er ? rej(er) : res(...d)));
+var mkdir = (path31, options) => new Promise((res, rej) => actualFS.default.mkdir(path31, options, (er, made) => er ? rej(er) : res(made)));
+var readdir4 = (path31) => new Promise((res, rej) => actualFS.default.readdir(path31, { 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 = (path30, options) => new Promise((res, rej) => actualFS.default.rm(path30, options, (er, ...d) => er ? rej(er) : res(...d)));
-var rmdir = (path30) => new Promise((res, rej) => actualFS.default.rmdir(path30, (er, ...d) => er ? rej(er) : res(...d)));
-var stat4 = (path30) => new Promise((res, rej) => actualFS.default.stat(path30, (er, data2) => er ? rej(er) : res(data2)));
-var lstat4 = (path30) => new Promise((res, rej) => actualFS.default.lstat(path30, (er, data2) => er ? rej(er) : res(data2)));
-var unlink = (path30) => new Promise((res, rej) => actualFS.default.unlink(path30, (er, ...d) => er ? rej(er) : res(...d)));
+var rm = (path31, options) => new Promise((res, rej) => actualFS.default.rm(path31, options, (er, ...d) => er ? rej(er) : res(...d)));
+var rmdir = (path31) => new Promise((res, rej) => actualFS.default.rmdir(path31, (er, ...d) => er ? rej(er) : res(...d)));
+var stat4 = (path31) => new Promise((res, rej) => actualFS.default.stat(path31, (er, data2) => er ? rej(er) : res(data2)));
+var lstat4 = (path31) => new Promise((res, rej) => actualFS.default.lstat(path31, (er, data2) => er ? rej(er) : res(data2)));
+var unlink = (path31) => new Promise((res, rej) => actualFS.default.unlink(path31, (er, ...d) => er ? rej(er) : res(...d)));
 var promises = {
   chmod,
   mkdir,
@@ -11156,10 +11156,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 = (path30) => readdir5(path30).catch((er) => er);
-var readdirOrErrorSync = (path30) => {
+var readdirOrError = (path31) => readdir5(path31).catch((er) => er);
+var readdirOrErrorSync = (path31) => {
   try {
-    return readdirSync2(path30);
+    return readdirSync2(path31);
   } catch (er) {
     return er;
   }
@@ -11184,35 +11184,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 (path30, opt) => {
+var rimrafPosix = async (path31, opt) => {
   if (_optionalChain([opt, 'optionalAccess', _182 => _182.signal, 'optionalAccess', _183 => _183.aborted])) {
     throw opt.signal.reason;
   }
   try {
-    return await rimrafPosixDir(path30, opt, await lstat5(path30));
+    return await rimrafPosixDir(path31, opt, await lstat5(path31));
   } catch (er) {
     if (_optionalChain([er, 'optionalAccess', _184 => _184.code]) === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafPosixSync = (path30, opt) => {
+var rimrafPosixSync = (path31, opt) => {
   if (_optionalChain([opt, 'optionalAccess', _185 => _185.signal, 'optionalAccess', _186 => _186.aborted])) {
     throw opt.signal.reason;
   }
   try {
-    return rimrafPosixDirSync(path30, opt, _fs.lstatSync.call(void 0, path30));
+    return rimrafPosixDirSync(path31, opt, _fs.lstatSync.call(void 0, path31));
   } catch (er) {
     if (_optionalChain([er, 'optionalAccess', _187 => _187.code]) === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafPosixDir = async (path30, opt, ent) => {
+var rimrafPosixDir = async (path31, opt, ent) => {
   if (_optionalChain([opt, 'optionalAccess', _188 => _188.signal, 'optionalAccess', _189 => _189.aborted])) {
     throw opt.signal.reason;
   }
-  const entries = ent.isDirectory() ? await readdirOrError(path30) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path31) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -11222,30 +11222,30 @@ var rimrafPosixDir = async (path30, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path30, ent)) {
+    if (opt.filter && !await opt.filter(path31, ent)) {
       return false;
     }
-    await ignoreENOENT(unlink2(path30));
+    await ignoreENOENT(unlink2(path31));
     return true;
   }
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafPosixDir(_path.resolve.call(void 0, path30, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafPosixDir(_path.resolve.call(void 0, path31, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path30 === _path.parse.call(void 0, path30).root) {
+  if (opt.preserveRoot === false && path31 === _path.parse.call(void 0, path31).root) {
     return false;
   }
-  if (opt.filter && !await opt.filter(path30, ent)) {
+  if (opt.filter && !await opt.filter(path31, ent)) {
     return false;
   }
-  await ignoreENOENT(rmdir2(path30));
+  await ignoreENOENT(rmdir2(path31));
   return true;
 };
-var rimrafPosixDirSync = (path30, opt, ent) => {
+var rimrafPosixDirSync = (path31, opt, ent) => {
   if (_optionalChain([opt, 'optionalAccess', _190 => _190.signal, 'optionalAccess', _191 => _191.aborted])) {
     throw opt.signal.reason;
   }
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path30) : null;
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path31) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -11255,27 +11255,27 @@ var rimrafPosixDirSync = (path30, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path30, ent)) {
+    if (opt.filter && !opt.filter(path31, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => _fs.unlinkSync.call(void 0, path30));
+    ignoreENOENTSync(() => _fs.unlinkSync.call(void 0, path31));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
-    const p = _path.resolve.call(void 0, path30, ent2.name);
+    const p = _path.resolve.call(void 0, path31, ent2.name);
     removedAll = rimrafPosixDirSync(p, opt, ent2) && removedAll;
   }
-  if (opt.preserveRoot === false && path30 === _path.parse.call(void 0, path30).root) {
+  if (opt.preserveRoot === false && path31 === _path.parse.call(void 0, path31).root) {
     return false;
   }
   if (!removedAll) {
     return false;
   }
-  if (opt.filter && !opt.filter(path30, ent)) {
+  if (opt.filter && !opt.filter(path31, ent)) {
     return false;
   }
-  ignoreENOENTSync(() => _fs.rmdirSync.call(void 0, path30));
+  ignoreENOENTSync(() => _fs.rmdirSync.call(void 0, path31));
   return true;
 };
 
@@ -11286,9 +11286,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 (path30) => {
+var fixEPERM = (fn) => async (path31) => {
   try {
-    return await fn(path30);
+    return await fn(path31);
   } catch (er) {
     const fer = er;
     if (_optionalChain([fer, 'optionalAccess', _192 => _192.code]) === "ENOENT") {
@@ -11296,7 +11296,7 @@ var fixEPERM = (fn) => async (path30) => {
     }
     if (_optionalChain([fer, 'optionalAccess', _193 => _193.code]) === "EPERM") {
       try {
-        await chmod2(path30, 438);
+        await chmod2(path31, 438);
       } catch (er2) {
         const fer2 = er2;
         if (_optionalChain([fer2, 'optionalAccess', _194 => _194.code]) === "ENOENT") {
@@ -11304,14 +11304,14 @@ var fixEPERM = (fn) => async (path30) => {
         }
         throw er;
       }
-      return await fn(path30);
+      return await fn(path31);
     }
     throw er;
   }
 };
-var fixEPERMSync = (fn) => (path30) => {
+var fixEPERMSync = (fn) => (path31) => {
   try {
-    return fn(path30);
+    return fn(path31);
   } catch (er) {
     const fer = er;
     if (_optionalChain([fer, 'optionalAccess', _195 => _195.code]) === "ENOENT") {
@@ -11319,7 +11319,7 @@ var fixEPERMSync = (fn) => (path30) => {
     }
     if (_optionalChain([fer, 'optionalAccess', _196 => _196.code]) === "EPERM") {
       try {
-        _fs.chmodSync.call(void 0, path30, 438);
+        _fs.chmodSync.call(void 0, path31, 438);
       } catch (er2) {
         const fer2 = er2;
         if (_optionalChain([fer2, 'optionalAccess', _197 => _197.code]) === "ENOENT") {
@@ -11327,7 +11327,7 @@ var fixEPERMSync = (fn) => (path30) => {
         }
         throw er;
       }
-      return fn(path30);
+      return fn(path31);
     }
     throw er;
   }
@@ -11340,23 +11340,23 @@ var RATE = 1.2;
 var MAXRETRIES = 10;
 var codes = /* @__PURE__ */ new Set(["EMFILE", "ENFILE", "EBUSY"]);
 var retryBusy = (fn) => {
-  const method = async (path30, opt, backoff = 1, total = 0) => {
+  const method = async (path31, 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(path30);
+        return await fn(path31);
       } catch (er) {
         const fer = er;
-        if (_optionalChain([fer, 'optionalAccess', _198 => _198.path]) === path30 && _optionalChain([fer, 'optionalAccess', _199 => _199.code]) && codes.has(fer.code)) {
+        if (_optionalChain([fer, 'optionalAccess', _198 => _198.path]) === path31 && _optionalChain([fer, 'optionalAccess', _199 => _199.code]) && codes.has(fer.code)) {
           backoff = Math.ceil(backoff * rate);
           total = backoff + total;
           if (total < mbo) {
             return new Promise((res, rej) => {
               setTimeout(() => {
-                method(path30, opt, backoff, total).then(res, rej);
+                method(path31, opt, backoff, total).then(res, rej);
               }, backoff);
             });
           }
@@ -11372,15 +11372,15 @@ var retryBusy = (fn) => {
   return method;
 };
 var retryBusySync = (fn) => {
-  const method = (path30, opt) => {
+  const method = (path31, opt) => {
     const max = opt.maxRetries || MAXRETRIES;
     let retries = 0;
     while (true) {
       try {
-        return fn(path30);
+        return fn(path31);
       } catch (er) {
         const fer = er;
-        if (_optionalChain([fer, 'optionalAccess', _200 => _200.path]) === path30 && _optionalChain([fer, 'optionalAccess', _201 => _201.code]) && codes.has(fer.code) && retries < max) {
+        if (_optionalChain([fer, 'optionalAccess', _200 => _200.path]) === path31 && _optionalChain([fer, 'optionalAccess', _201 => _201.code]) && codes.has(fer.code) && retries < max) {
           retries++;
           continue;
         }
@@ -11400,16 +11400,16 @@ _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
 
 
 var { stat: stat5 } = promises;
-var isDirSync = (path30) => {
+var isDirSync = (path31) => {
   try {
-    return _fs.statSync.call(void 0, path30).isDirectory();
+    return _fs.statSync.call(void 0, path31).isDirectory();
   } catch (er) {
     return false;
   }
 };
-var isDir = (path30) => stat5(path30).then((st) => st.isDirectory(), () => false);
-var win32DefaultTmp = async (path30) => {
-  const { root } = _path.parse.call(void 0, path30);
+var isDir = (path31) => stat5(path31).then((st) => st.isDirectory(), () => false);
+var win32DefaultTmp = async (path31) => {
+  const { root } = _path.parse.call(void 0, path31);
   const tmp = _os.tmpdir.call(void 0, );
   const { root: tmpRoot } = _path.parse.call(void 0, tmp);
   if (root.toLowerCase() === tmpRoot.toLowerCase()) {
@@ -11421,8 +11421,8 @@ var win32DefaultTmp = async (path30) => {
   }
   return root;
 };
-var win32DefaultTmpSync = (path30) => {
-  const { root } = _path.parse.call(void 0, path30);
+var win32DefaultTmpSync = (path31) => {
+  const { root } = _path.parse.call(void 0, path31);
   const tmp = _os.tmpdir.call(void 0, );
   const { root: tmpRoot } = _path.parse.call(void 0, tmp);
   if (root.toLowerCase() === tmpRoot.toLowerCase()) {
@@ -11441,10 +11441,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 = (path30) => `.${_path.basename.call(void 0, path30)}.${Math.random()}`;
-var unlinkFixEPERM = async (path30) => unlink3(path30).catch((er) => {
+var uniqueFilename = (path31) => `.${_path.basename.call(void 0, path31)}.${Math.random()}`;
+var unlinkFixEPERM = async (path31) => unlink3(path31).catch((er) => {
   if (er.code === "EPERM") {
-    return chmod3(path30, 438).then(() => unlink3(path30), (er2) => {
+    return chmod3(path31, 438).then(() => unlink3(path31), (er2) => {
       if (er2.code === "ENOENT") {
         return;
       }
@@ -11455,13 +11455,13 @@ var unlinkFixEPERM = async (path30) => unlink3(path30).catch((er) => {
   }
   throw er;
 });
-var unlinkFixEPERMSync = (path30) => {
+var unlinkFixEPERMSync = (path31) => {
   try {
-    _fs.unlinkSync.call(void 0, path30);
+    _fs.unlinkSync.call(void 0, path31);
   } catch (er) {
     if (_optionalChain([er, 'optionalAccess', _202 => _202.code]) === "EPERM") {
       try {
-        return _fs.chmodSync.call(void 0, path30, 438);
+        return _fs.chmodSync.call(void 0, path31, 438);
       } catch (er2) {
         if (_optionalChain([er2, 'optionalAccess', _203 => _203.code]) === "ENOENT") {
           return;
@@ -11474,29 +11474,29 @@ var unlinkFixEPERMSync = (path30) => {
     throw er;
   }
 };
-var rimrafMoveRemove = async (path30, opt) => {
+var rimrafMoveRemove = async (path31, opt) => {
   if (_optionalChain([opt, 'optionalAccess', _205 => _205.signal, 'optionalAccess', _206 => _206.aborted])) {
     throw opt.signal.reason;
   }
   try {
-    return await rimrafMoveRemoveDir(path30, opt, await lstat6(path30));
+    return await rimrafMoveRemoveDir(path31, opt, await lstat6(path31));
   } catch (er) {
     if (_optionalChain([er, 'optionalAccess', _207 => _207.code]) === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafMoveRemoveDir = async (path30, opt, ent) => {
+var rimrafMoveRemoveDir = async (path31, opt, ent) => {
   if (_optionalChain([opt, 'optionalAccess', _208 => _208.signal, 'optionalAccess', _209 => _209.aborted])) {
     throw opt.signal.reason;
   }
   if (!opt.tmp) {
-    return rimrafMoveRemoveDir(path30, { ...opt, tmp: await defaultTmp(path30) }, ent);
+    return rimrafMoveRemoveDir(path31, { ...opt, tmp: await defaultTmp(path31) }, ent);
   }
-  if (path30 === opt.tmp && _path.parse.call(void 0, path30).root !== path30) {
+  if (path31 === opt.tmp && _path.parse.call(void 0, path31).root !== path31) {
     throw new Error("cannot delete temp directory used for deletion");
   }
-  const entries = ent.isDirectory() ? await readdirOrError(path30) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path31) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -11506,54 +11506,54 @@ var rimrafMoveRemoveDir = async (path30, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path30, ent)) {
+    if (opt.filter && !await opt.filter(path31, ent)) {
       return false;
     }
-    await ignoreENOENT(tmpUnlink(path30, opt.tmp, unlinkFixEPERM));
+    await ignoreENOENT(tmpUnlink(path31, opt.tmp, unlinkFixEPERM));
     return true;
   }
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafMoveRemoveDir(_path.resolve.call(void 0, path30, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafMoveRemoveDir(_path.resolve.call(void 0, path31, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path30 === _path.parse.call(void 0, path30).root) {
+  if (opt.preserveRoot === false && path31 === _path.parse.call(void 0, path31).root) {
     return false;
   }
-  if (opt.filter && !await opt.filter(path30, ent)) {
+  if (opt.filter && !await opt.filter(path31, ent)) {
     return false;
   }
-  await ignoreENOENT(tmpUnlink(path30, opt.tmp, rmdir3));
+  await ignoreENOENT(tmpUnlink(path31, opt.tmp, rmdir3));
   return true;
 };
-var tmpUnlink = async (path30, tmp, rm3) => {
-  const tmpFile = _path.resolve.call(void 0, tmp, uniqueFilename(path30));
-  await rename2(path30, tmpFile);
+var tmpUnlink = async (path31, tmp, rm3) => {
+  const tmpFile = _path.resolve.call(void 0, tmp, uniqueFilename(path31));
+  await rename2(path31, tmpFile);
   return await rm3(tmpFile);
 };
-var rimrafMoveRemoveSync = (path30, opt) => {
+var rimrafMoveRemoveSync = (path31, opt) => {
   if (_optionalChain([opt, 'optionalAccess', _210 => _210.signal, 'optionalAccess', _211 => _211.aborted])) {
     throw opt.signal.reason;
   }
   try {
-    return rimrafMoveRemoveDirSync(path30, opt, _fs.lstatSync.call(void 0, path30));
+    return rimrafMoveRemoveDirSync(path31, opt, _fs.lstatSync.call(void 0, path31));
   } catch (er) {
     if (_optionalChain([er, 'optionalAccess', _212 => _212.code]) === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafMoveRemoveDirSync = (path30, opt, ent) => {
+var rimrafMoveRemoveDirSync = (path31, opt, ent) => {
   if (_optionalChain([opt, 'optionalAccess', _213 => _213.signal, 'optionalAccess', _214 => _214.aborted])) {
     throw opt.signal.reason;
   }
   if (!opt.tmp) {
-    return rimrafMoveRemoveDirSync(path30, { ...opt, tmp: defaultTmpSync(path30) }, ent);
+    return rimrafMoveRemoveDirSync(path31, { ...opt, tmp: defaultTmpSync(path31) }, ent);
   }
   const tmp = opt.tmp;
-  if (path30 === opt.tmp && _path.parse.call(void 0, path30).root !== path30) {
+  if (path31 === opt.tmp && _path.parse.call(void 0, path31).root !== path31) {
     throw new Error("cannot delete temp directory used for deletion");
   }
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path30) : null;
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path31) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -11563,32 +11563,32 @@ var rimrafMoveRemoveDirSync = (path30, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path30, ent)) {
+    if (opt.filter && !opt.filter(path31, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => tmpUnlinkSync(path30, tmp, unlinkFixEPERMSync));
+    ignoreENOENTSync(() => tmpUnlinkSync(path31, tmp, unlinkFixEPERMSync));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
-    const p = _path.resolve.call(void 0, path30, ent2.name);
+    const p = _path.resolve.call(void 0, path31, ent2.name);
     removedAll = rimrafMoveRemoveDirSync(p, opt, ent2) && removedAll;
   }
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path30 === _path.parse.call(void 0, path30).root) {
+  if (opt.preserveRoot === false && path31 === _path.parse.call(void 0, path31).root) {
     return false;
   }
-  if (opt.filter && !opt.filter(path30, ent)) {
+  if (opt.filter && !opt.filter(path31, ent)) {
     return false;
   }
-  ignoreENOENTSync(() => tmpUnlinkSync(path30, tmp, _fs.rmdirSync));
+  ignoreENOENTSync(() => tmpUnlinkSync(path31, tmp, _fs.rmdirSync));
   return true;
 };
-var tmpUnlinkSync = (path30, tmp, rmSync2) => {
-  const tmpFile = _path.resolve.call(void 0, tmp, uniqueFilename(path30));
-  _fs.renameSync.call(void 0, path30, tmpFile);
+var tmpUnlinkSync = (path31, tmp, rmSync2) => {
+  const tmpFile = _path.resolve.call(void 0, tmp, uniqueFilename(path31));
+  _fs.renameSync.call(void 0, path31, tmpFile);
   return rmSync2(tmpFile);
 };
 
@@ -11598,31 +11598,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 (path30, opt) => {
+var rimrafWindowsDirMoveRemoveFallback = async (path31, opt) => {
   if (_optionalChain([opt, 'optionalAccess', _215 => _215.signal, 'optionalAccess', _216 => _216.aborted])) {
     throw opt.signal.reason;
   }
   const { filter: filter3, ...options } = opt;
   try {
-    return await rimrafWindowsDirRetry(path30, options);
+    return await rimrafWindowsDirRetry(path31, options);
   } catch (er) {
     if (_optionalChain([er, 'optionalAccess', _217 => _217.code]) === "ENOTEMPTY") {
-      return await rimrafMoveRemove(path30, options);
+      return await rimrafMoveRemove(path31, options);
     }
     throw er;
   }
 };
-var rimrafWindowsDirMoveRemoveFallbackSync = (path30, opt) => {
+var rimrafWindowsDirMoveRemoveFallbackSync = (path31, opt) => {
   if (_optionalChain([opt, 'optionalAccess', _218 => _218.signal, 'optionalAccess', _219 => _219.aborted])) {
     throw opt.signal.reason;
   }
   const { filter: filter3, ...options } = opt;
   try {
-    return rimrafWindowsDirRetrySync(path30, options);
+    return rimrafWindowsDirRetrySync(path31, options);
   } catch (er) {
     const fer = er;
     if (_optionalChain([fer, 'optionalAccess', _220 => _220.code]) === "ENOTEMPTY") {
-      return rimrafMoveRemoveSync(path30, options);
+      return rimrafMoveRemoveSync(path31, options);
     }
     throw er;
   }
@@ -11630,35 +11630,35 @@ var rimrafWindowsDirMoveRemoveFallbackSync = (path30, opt) => {
 var START = Symbol("start");
 var CHILD = Symbol("child");
 var FINISH = Symbol("finish");
-var rimrafWindows = async (path30, opt) => {
+var rimrafWindows = async (path31, opt) => {
   if (_optionalChain([opt, 'optionalAccess', _221 => _221.signal, 'optionalAccess', _222 => _222.aborted])) {
     throw opt.signal.reason;
   }
   try {
-    return await rimrafWindowsDir(path30, opt, await lstat7(path30), START);
+    return await rimrafWindowsDir(path31, opt, await lstat7(path31), START);
   } catch (er) {
     if (_optionalChain([er, 'optionalAccess', _223 => _223.code]) === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafWindowsSync = (path30, opt) => {
+var rimrafWindowsSync = (path31, opt) => {
   if (_optionalChain([opt, 'optionalAccess', _224 => _224.signal, 'optionalAccess', _225 => _225.aborted])) {
     throw opt.signal.reason;
   }
   try {
-    return rimrafWindowsDirSync(path30, opt, _fs.lstatSync.call(void 0, path30), START);
+    return rimrafWindowsDirSync(path31, opt, _fs.lstatSync.call(void 0, path31), START);
   } catch (er) {
     if (_optionalChain([er, 'optionalAccess', _226 => _226.code]) === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafWindowsDir = async (path30, opt, ent, state = START) => {
+var rimrafWindowsDir = async (path31, opt, ent, state = START) => {
   if (_optionalChain([opt, 'optionalAccess', _227 => _227.signal, 'optionalAccess', _228 => _228.aborted])) {
     throw opt.signal.reason;
   }
-  const entries = ent.isDirectory() ? await readdirOrError(path30) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path31) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -11668,32 +11668,32 @@ var rimrafWindowsDir = async (path30, opt, ent, state = START) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path30, ent)) {
+    if (opt.filter && !await opt.filter(path31, ent)) {
       return false;
     }
-    await ignoreENOENT(rimrafWindowsFile(path30, opt));
+    await ignoreENOENT(rimrafWindowsFile(path31, opt));
     return true;
   }
   const s = state === START ? CHILD : state;
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafWindowsDir(_path.resolve.call(void 0, path30, 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, path31, ent2.name), opt, ent2, s)))).reduce((a, b) => a && b, true);
   if (state === START) {
-    return rimrafWindowsDir(path30, opt, ent, FINISH);
+    return rimrafWindowsDir(path31, opt, ent, FINISH);
   } else if (state === FINISH) {
-    if (opt.preserveRoot === false && path30 === _path.parse.call(void 0, path30).root) {
+    if (opt.preserveRoot === false && path31 === _path.parse.call(void 0, path31).root) {
       return false;
     }
     if (!removedAll) {
       return false;
     }
-    if (opt.filter && !await opt.filter(path30, ent)) {
+    if (opt.filter && !await opt.filter(path31, ent)) {
       return false;
     }
-    await ignoreENOENT(rimrafWindowsDirMoveRemoveFallback(path30, opt));
+    await ignoreENOENT(rimrafWindowsDirMoveRemoveFallback(path31, opt));
   }
   return true;
 };
-var rimrafWindowsDirSync = (path30, opt, ent, state = START) => {
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path30) : null;
+var rimrafWindowsDirSync = (path31, opt, ent, state = START) => {
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path31) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -11703,32 +11703,32 @@ var rimrafWindowsDirSync = (path30, opt, ent, state = START) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path30, ent)) {
+    if (opt.filter && !opt.filter(path31, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => rimrafWindowsFileSync(path30, opt));
+    ignoreENOENTSync(() => rimrafWindowsFileSync(path31, opt));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
     const s = state === START ? CHILD : state;
-    const p = _path.resolve.call(void 0, path30, ent2.name);
+    const p = _path.resolve.call(void 0, path31, ent2.name);
     removedAll = rimrafWindowsDirSync(p, opt, ent2, s) && removedAll;
   }
   if (state === START) {
-    return rimrafWindowsDirSync(path30, opt, ent, FINISH);
+    return rimrafWindowsDirSync(path31, opt, ent, FINISH);
   } else if (state === FINISH) {
-    if (opt.preserveRoot === false && path30 === _path.parse.call(void 0, path30).root) {
+    if (opt.preserveRoot === false && path31 === _path.parse.call(void 0, path31).root) {
       return false;
     }
     if (!removedAll) {
       return false;
     }
-    if (opt.filter && !opt.filter(path30, ent)) {
+    if (opt.filter && !opt.filter(path31, ent)) {
       return false;
     }
     ignoreENOENTSync(() => {
-      rimrafWindowsDirMoveRemoveFallbackSync(path30, opt);
+      rimrafWindowsDirMoveRemoveFallbackSync(path31, opt);
     });
   }
   return true;
@@ -11741,16 +11741,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 (path30, opt) => {
-  await rm2(path30, {
+var rimrafNative = async (path31, opt) => {
+  await rm2(path31, {
     ...opt,
     force: true,
     recursive: true
   });
   return true;
 };
-var rimrafNativeSync = (path30, opt) => {
-  _fs.rmSync.call(void 0, path30, {
+var rimrafNativeSync = (path31, opt) => {
+  _fs.rmSync.call(void 0, path31, {
     ...opt,
     force: true,
     recursive: true
@@ -11768,26 +11768,26 @@ var useNative = !hasNative || platform_default === "win32" ? () => false : (opt)
 var useNativeSync = !hasNative || platform_default === "win32" ? () => false : (opt) => !_optionalChain([opt, 'optionalAccess', _231 => _231.signal]) && !_optionalChain([opt, 'optionalAccess', _232 => _232.filter]);
 
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/index.js
-var wrap = (fn) => async (path30, opt) => {
+var wrap = (fn) => async (path31, opt) => {
   const options = optArg(opt);
   if (options.glob) {
-    path30 = await glob(path30, options.glob);
+    path31 = await glob(path31, options.glob);
   }
-  if (Array.isArray(path30)) {
-    return !!(await Promise.all(path30.map((p) => fn(path_arg_default(p, options), options)))).reduce((a, b) => a && b, true);
+  if (Array.isArray(path31)) {
+    return !!(await Promise.all(path31.map((p) => fn(path_arg_default(p, options), options)))).reduce((a, b) => a && b, true);
   } else {
-    return !!await fn(path_arg_default(path30, options), options);
+    return !!await fn(path_arg_default(path31, options), options);
   }
 };
-var wrapSync = (fn) => (path30, opt) => {
+var wrapSync = (fn) => (path31, opt) => {
   const options = optArgSync(opt);
   if (options.glob) {
-    path30 = globSync(path30, options.glob);
+    path31 = globSync(path31, options.glob);
   }
-  if (Array.isArray(path30)) {
-    return !!path30.map((p) => fn(path_arg_default(p, options), options)).reduce((a, b) => a && b, true);
+  if (Array.isArray(path31)) {
+    return !!path31.map((p) => fn(path_arg_default(p, options), options)).reduce((a, b) => a && b, true);
   } else {
-    return !!fn(path_arg_default(path30, options), options);
+    return !!fn(path_arg_default(path31, options), options);
   }
 };
 var nativeSync = wrapSync(rimrafNativeSync);
@@ -11802,8 +11802,8 @@ var moveRemoveSync = wrapSync(rimrafMoveRemoveSync);
 var moveRemove = Object.assign(wrap(rimrafMoveRemove), {
   sync: moveRemoveSync
 });
-var rimrafSync = wrapSync((path30, opt) => useNativeSync(opt) ? rimrafNativeSync(path30, opt) : rimrafManualSync(path30, opt));
-var rimraf_ = wrap((path30, opt) => useNative(opt) ? rimrafNative(path30, opt) : rimrafManual(path30, opt));
+var rimrafSync = wrapSync((path31, opt) => useNativeSync(opt) ? rimrafNativeSync(path31, opt) : rimrafManualSync(path31, opt));
+var rimraf_ = wrap((path31, opt) => useNative(opt) ? rimrafNative(path31, opt) : rimrafManual(path31, opt));
 var rimraf = Object.assign(rimraf_, {
   rimraf: rimraf_,
   sync: rimrafSync,
@@ -11823,10 +11823,258 @@ rimraf.rimraf = rimraf;
 
 // src/runtime/buildPlugin.ts
 var _vite = require('vite');
-var REG_NODE_MODULES_DIR = /[\\/]node_modules[\\/]/gi;
+
+// src/runtime/advancedChunks.ts
+_chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
+
+// src/runtime/chunkStrategy.ts
+_chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
+
+var SHARED_CHUNK_VIRTUAL_PREFIX = "__weapp_shared__";
+var SUB_PACKAGE_SHARED_DIR = "__shared__";
+var DEFAULT_SHARED_CHUNK_STRATEGY = "duplicate";
+function resolveSharedChunkName(options) {
+  const {
+    id,
+    ctx,
+    relativeAbsoluteSrcRoot,
+    subPackageRoots,
+    strategy
+  } = options;
+  const moduleInfo = ctx.getModuleInfo(id);
+  if (!_optionalChain([moduleInfo, 'optionalAccess', _233 => _233.importers]) || moduleInfo.importers.length <= 1) {
+    return void 0;
+  }
+  const summary = summarizeImportPrefixes({
+    importers: moduleInfo.importers,
+    relativeAbsoluteSrcRoot,
+    subPackageRoots: Array.from(subPackageRoots)
+  });
+  const keys = Object.keys(summary);
+  if (keys.length === 0) {
+    return void 0;
+  }
+  if (keys.length === 1) {
+    const prefix = keys[0];
+    return prefix ? _pathe.posix.join(prefix, "common") : "common";
+  }
+  const hasMainImporter = keys.includes("");
+  if (strategy === "duplicate" && !hasMainImporter) {
+    const combination = keys.filter(Boolean).sort().join("+");
+    const combinationSegment = combination ? `${combination}/` : "";
+    return `${SHARED_CHUNK_VIRTUAL_PREFIX}/${combinationSegment}common`;
+  }
+  return "common";
+}
+function summarizeImportPrefixes(options) {
+  const { importers, relativeAbsoluteSrcRoot, subPackageRoots } = options;
+  const summary = {};
+  for (const importer of importers) {
+    const relPath = relativeAbsoluteSrcRoot(importer);
+    const prefix = resolveSubPackagePrefix(relPath, subPackageRoots);
+    summary[prefix] = (summary[prefix] || 0) + 1;
+  }
+  return summary;
+}
+function resolveSubPackagePrefix(fileName, subPackageRoots) {
+  for (const root of subPackageRoots) {
+    if (!root) {
+      continue;
+    }
+    if (fileName === root || fileName.startsWith(`${root}/`)) {
+      return root;
+    }
+  }
+  return "";
+}
+function applySharedChunkStrategy(bundle, options) {
+  if (options.strategy !== "duplicate") {
+    return;
+  }
+  if (!this) {
+    throw new Error("applySharedChunkStrategy requires plugin context");
+  }
+  const subPackageRoots = Array.from(options.subPackageRoots).filter(Boolean);
+  const entries = Object.entries(bundle);
+  for (const [fileName, output] of entries) {
+    if (!isSharedVirtualChunk(fileName, output)) {
+      continue;
+    }
+    const chunk = output;
+    const originalCode = chunk.code;
+    const originalMap = chunk.map;
+    const importers = findChunkImporters(bundle, fileName);
+    if (importers.length === 0) {
+      continue;
+    }
+    const importerMap = /* @__PURE__ */ new Map();
+    let hasMainImporter = false;
+    for (const importerFile of importers) {
+      const root = resolveSubPackagePrefix(importerFile, subPackageRoots);
+      if (!root) {
+        hasMainImporter = true;
+        break;
+      }
+      const duplicateBaseName = _pathe.posix.basename(fileName);
+      const intendedFileName = _pathe.posix.join(root, SUB_PACKAGE_SHARED_DIR, duplicateBaseName);
+      const uniqueFileName = ensureUniqueFileName(bundle, intendedFileName);
+      const existing = importerMap.get(root);
+      if (existing) {
+        existing.importers.push(importerFile);
+      } else {
+        importerMap.set(root, {
+          newFileName: uniqueFileName,
+          importers: [importerFile]
+        });
+      }
+    }
+    if (hasMainImporter || importerMap.size === 0) {
+      if (fileName.startsWith(`${SHARED_CHUNK_VIRTUAL_PREFIX}/`)) {
+        const newFileName = fileName.slice(SHARED_CHUNK_VIRTUAL_PREFIX.length + 1);
+        chunk.fileName = newFileName;
+      }
+      continue;
+    }
+    const importerToChunk = /* @__PURE__ */ new Map();
+    for (const { newFileName, importers: importerFiles } of importerMap.values()) {
+      this.emitFile({
+        type: "asset",
+        fileName: newFileName,
+        source: originalCode
+      });
+      if (originalMap) {
+        this.emitFile({
+          type: "asset",
+          fileName: `${newFileName}.map`,
+          source: typeof originalMap === "string" ? originalMap : JSON.stringify(originalMap)
+        });
+      }
+      for (const importerFile of importerFiles) {
+        importerToChunk.set(importerFile, newFileName);
+      }
+    }
+    updateImporters(bundle, importerToChunk, fileName);
+    chunk.code = "// duplicated into sub-packages via weapp-vite chunk strategy\n";
+    chunk.map = null;
+    chunk.sourcemapFileName = null;
+    chunk.imports = [];
+    chunk.dynamicImports = [];
+    chunk.exports = [];
+    chunk.moduleIds = [];
+    chunk.modules = {};
+  }
+}
+function isSharedVirtualChunk(fileName, output) {
+  return _optionalChain([output, 'optionalAccess', _234 => _234.type]) === "chunk" && fileName.startsWith(`${SHARED_CHUNK_VIRTUAL_PREFIX}/`);
+}
+function findChunkImporters(bundle, target) {
+  const importers = /* @__PURE__ */ new Set();
+  for (const [fileName, output] of Object.entries(bundle)) {
+    if (_optionalChain([output, 'optionalAccess', _235 => _235.type]) !== "chunk") {
+      continue;
+    }
+    const chunk = output;
+    if (chunk.imports.includes(target) || chunk.dynamicImports.includes(target)) {
+      importers.add(fileName);
+    }
+  }
+  return Array.from(importers);
+}
+function ensureUniqueFileName(bundle, fileName) {
+  if (!bundle[fileName]) {
+    return fileName;
+  }
+  const { dir, name, ext: ext2 } = _pathe.posix.parse(fileName);
+  let index = 1;
+  let candidate = fileName;
+  while (bundle[candidate]) {
+    const nextName = `${name}.${index}`;
+    candidate = dir ? _pathe.posix.join(dir, `${nextName}${ext2}`) : `${nextName}${ext2}`;
+    index++;
+  }
+  return candidate;
+}
+function updateImporters(bundle, importerToChunk, originalFileName) {
+  for (const [importerFile, newChunkFile] of importerToChunk.entries()) {
+    const importer = bundle[importerFile];
+    if (!importer || importer.type !== "chunk") {
+      continue;
+    }
+    const importerChunk = importer;
+    const originalImportPath = createRelativeImport(importerFile, originalFileName);
+    const newImportPath = createRelativeImport(importerFile, newChunkFile);
+    if (originalImportPath !== newImportPath) {
+      importerChunk.code = replaceAll(importerChunk.code, originalImportPath, newImportPath);
+    }
+    importerChunk.imports = replaceInArray(importerChunk.imports, originalFileName, newChunkFile);
+    importerChunk.dynamicImports = replaceInArray(importerChunk.dynamicImports, originalFileName, newChunkFile);
+  }
+}
+function replaceAll(source, searchValue, replaceValue) {
+  if (!searchValue) {
+    return source;
+  }
+  if (source.includes(searchValue)) {
+    return source.split(searchValue).join(replaceValue);
+  }
+  if (searchValue.startsWith("./") && replaceValue.startsWith("./")) {
+    const trimmedSearch = searchValue.slice(2);
+    const trimmedReplace = replaceValue.slice(2);
+    if (trimmedSearch && source.includes(trimmedSearch)) {
+      return source.split(trimmedSearch).join(trimmedReplace);
+    }
+  }
+  return source;
+}
+function replaceInArray(list, searchValue, replaceValue) {
+  return list.map((value) => {
+    return value === searchValue ? replaceValue : value;
+  });
+}
+function createRelativeImport(fromFile, toFile) {
+  const relative3 = _pathe.posix.relative(_pathe.posix.dirname(fromFile), toFile);
+  if (!relative3 || relative3.startsWith(".")) {
+    return relative3 || "./";
+  }
+  return `./${relative3}`;
+}
+
+// src/runtime/advancedChunks.ts
 function testByReg2DExpList(reg2DExpList) {
-  return (id) => reg2DExpList.some((regExpList) => regExpList.some((regExp) => regExp.test(id)));
+  return (id) => reg2DExpList.some((regExpList) => regExpList.some((regExp) => {
+    regExp.lastIndex = 0;
+    return regExp.test(id);
+  }));
+}
+function createAdvancedChunkNameResolver(options) {
+  const {
+    relativeAbsoluteSrcRoot,
+    getSubPackageRoots,
+    strategy,
+    vendorsMatchers
+  } = options;
+  const isVendor = testByReg2DExpList(vendorsMatchers);
+  return (id, ctx) => {
+    const subPackageRoots = Array.from(getSubPackageRoots());
+    const sharedName = resolveSharedChunkName({
+      id,
+      ctx,
+      relativeAbsoluteSrcRoot,
+      subPackageRoots,
+      strategy
+    });
+    if (!isVendor(id)) {
+      return sharedName;
+    }
+    if (strategy === "hoist") {
+      return "vendors";
+    }
+    return sharedName;
+  };
 }
+
+// src/runtime/buildPlugin.ts
+var REG_NODE_MODULES_DIR = /[\\/]node_modules[\\/]/gi;
 function createBuildService(ctx) {
   function assertRuntimeServices(target) {
     if (!target.configService || !target.watcherService || !target.npmService || !target.scanService) {
@@ -11840,7 +12088,7 @@ function createBuildService(ctx) {
   function checkWorkersOptions() {
     const workersDir = scanService.workersDir;
     const hasWorkersDir = Boolean(workersDir);
-    if (hasWorkersDir && _optionalChain([configService, 'access', _233 => _233.weappViteConfig, 'optionalAccess', _234 => _234.worker, 'optionalAccess', _235 => _235.entry]) === void 0) {
+    if (hasWorkersDir && _optionalChain([configService, 'access', _236 => _236.weappViteConfig, 'optionalAccess', _237 => _237.worker, 'optionalAccess', _238 => _238.entry]) === void 0) {
       logger_default.error("\u68C0\u6D4B\u5230\u5DF2\u7ECF\u5F00\u542F\u4E86 `worker`\uFF0C\u8BF7\u5728 `vite.config.ts` \u4E2D\u8BBE\u7F6E `weapp.worker.entry` \u8DEF\u5F84");
       logger_default.error("\u6BD4\u5982\u5F15\u5165\u7684 `worker` \u8DEF\u5F84\u4E3A `workers/index`, \u6B64\u65F6 `weapp.worker.entry` \u8BBE\u7F6E\u4E3A `[index]` ");
       throw new Error("\u8BF7\u5728 `vite.config.ts` \u4E2D\u8BBE\u7F6E `weapp.worker.entry` \u8DEF\u5F84");
@@ -11864,6 +12112,13 @@ function createBuildService(ctx) {
   function sharedBuildConfig() {
     const nodeModulesDeps = [REG_NODE_MODULES_DIR];
     const commonjsHelpersDeps = [/commonjsHelpers\.js$/];
+    const sharedStrategy = _nullishCoalesce(_optionalChain([configService, 'access', _239 => _239.weappViteConfig, 'optionalAccess', _240 => _240.chunks, 'optionalAccess', _241 => _241.sharedStrategy]), () => ( DEFAULT_SHARED_CHUNK_STRATEGY));
+    const resolveAdvancedChunkName = createAdvancedChunkNameResolver({
+      vendorsMatchers: [nodeModulesDeps, commonjsHelpersDeps],
+      relativeAbsoluteSrcRoot: configService.relativeAbsoluteSrcRoot,
+      getSubPackageRoots: () => scanService.subPackageMap.keys(),
+      strategy: sharedStrategy
+    });
     return {
       build: {
         rolldownOptions: {
@@ -11871,28 +12126,7 @@ function createBuildService(ctx) {
             advancedChunks: {
               groups: [
                 {
-                  name: (id, ctxPlugin) => {
-                    REG_NODE_MODULES_DIR.lastIndex = 0;
-                    if (testByReg2DExpList([nodeModulesDeps, commonjsHelpersDeps])(id)) {
-                      return "vendors";
-                    }
-                    const moduleInfo = ctxPlugin.getModuleInfo(id);
-                    if (_optionalChain([moduleInfo, 'optionalAccess', _236 => _236.importers, 'optionalAccess', _237 => _237.length]) && moduleInfo.importers.length > 1) {
-                      const summary = moduleInfo.importers.reduce((acc, cur) => {
-                        const relPath = configService.relativeAbsoluteSrcRoot(cur);
-                        const prefix2 = _nullishCoalesce([
-                          ...scanService.subPackageMap.keys()
-                        ].find(
-                          (x) => relPath.startsWith(x)
-                        ), () => ( ""));
-                        acc[prefix2] = (acc[prefix2] || 0) + 1;
-                        return acc;
-                      }, {});
-                      const summaryKeys = Object.keys(summary);
-                      const prefix = summaryKeys.length === 1 ? summaryKeys[0] : "";
-                      return _pathe2.default.join(prefix, "common");
-                    }
-                  }
+                  name: (id, ctxPlugin) => resolveAdvancedChunkName(id, ctxPlugin)
                 }
               ]
             },
@@ -11906,7 +12140,7 @@ function createBuildService(ctx) {
     if (_process2.default.env.NODE_ENV === void 0) {
       _process2.default.env.NODE_ENV = "development";
     }
-    _optionalChain([debug, 'optionalCall', _238 => _238("dev build watcher start")]);
+    _optionalChain([debug, 'optionalCall', _242 => _242("dev build watcher start")]);
     const buildOptions = configService.merge(void 0, sharedBuildConfig());
     const watcher = await _vite.build.call(void 0, 
       buildOptions
@@ -11935,8 +12169,8 @@ function createBuildService(ctx) {
         });
       }
     }
-    _optionalChain([debug, 'optionalCall', _239 => _239("dev build watcher end")]);
-    _optionalChain([debug, 'optionalCall', _240 => _240("dev watcher listen start")]);
+    _optionalChain([debug, 'optionalCall', _243 => _243("dev build watcher end")]);
+    _optionalChain([debug, 'optionalCall', _244 => _244("dev watcher listen start")]);
     let startTime;
     let resolveWatcher;
     let rejectWatcher;
@@ -11959,7 +12193,7 @@ function createBuildService(ctx) {
     return watcher;
   }
   async function runProd() {
-    _optionalChain([debug, 'optionalCall', _241 => _241("prod build start")]);
+    _optionalChain([debug, 'optionalCall', _245 => _245("prod build start")]);
     const output = await _vite.build.call(void 0, 
       configService.merge(void 0, sharedBuildConfig())
     );
@@ -11967,7 +12201,7 @@ function createBuildService(ctx) {
     if (hasWorkersDir) {
       await buildWorkers();
     }
-    _optionalChain([debug, 'optionalCall', _242 => _242("prod build end")]);
+    _optionalChain([debug, 'optionalCall', _246 => _246("prod build end")]);
     return output;
   }
   async function buildEntry(options) {
@@ -11987,12 +12221,12 @@ function createBuildService(ctx) {
           }
         }
       );
-      _optionalChain([debug, 'optionalCall', _243 => _243("deletedFilePaths", deletedFilePaths)]);
+      _optionalChain([debug, 'optionalCall', _247 => _247("deletedFilePaths", deletedFilePaths)]);
       logger_default.success(`\u5DF2\u6E05\u7A7A ${configService.mpDistRoot} \u76EE\u5F55`);
     }
-    _optionalChain([debug, 'optionalCall', _244 => _244("build start")]);
+    _optionalChain([debug, 'optionalCall', _248 => _248("build start")]);
     let npmBuildTask = Promise.resolve();
-    if (!_optionalChain([options, 'optionalAccess', _245 => _245.skipNpm])) {
+    if (!_optionalChain([options, 'optionalAccess', _249 => _249.skipNpm])) {
       let shouldBuildNpm = true;
       if (configService.isDev) {
         const isDependenciesOutdated = await npmService.checkDependenciesCacheOutdate();
@@ -12019,7 +12253,7 @@ function createBuildService(ctx) {
       result = await runProd();
     }
     await npmBuildTask;
-    _optionalChain([debug, 'optionalCall', _246 => _246("build end")]);
+    _optionalChain([debug, 'optionalCall', _250 => _250("build end")]);
     return result;
   }
   return {
@@ -17686,17 +17920,17 @@ function withTrailingSlash(input = "", respectQueryAndFragment) {
   if (hasTrailingSlash(input, true)) {
     return input || "/";
   }
-  let path30 = input;
+  let path31 = input;
   let fragment = "";
   const fragmentIndex = input.indexOf("#");
   if (fragmentIndex !== -1) {
-    path30 = input.slice(0, fragmentIndex);
+    path31 = input.slice(0, fragmentIndex);
     fragment = input.slice(fragmentIndex);
-    if (!path30) {
+    if (!path31) {
       return fragment;
     }
   }
-  const [s0, ...s] = path30.split("?");
+  const [s0, ...s] = path31.split("?");
   return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
 }
 function isNonEmptyURL(url) {
@@ -17725,8 +17959,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(path30) {
-  return path30.replace(/\\/g, "/");
+function normalizeSlash(path31) {
+  return path31.replace(/\\/g, "/");
 }
 var own$1 = {}.hasOwnProperty;
 var classRegExp = /^([A-Z][a-z\d]*)+$/;
@@ -17839,8 +18073,8 @@ codes2.ERR_INVALID_PACKAGE_CONFIG = createError(
    * @param {string} [base]
    * @param {string} [message]
    */
-  (path30, base, message) => {
-    return `Invalid package config ${path30}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+  (path31, base, message) => {
+    return `Invalid package config ${path31}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
   },
   Error
 );
@@ -17872,8 +18106,8 @@ codes2.ERR_MODULE_NOT_FOUND = createError(
    * @param {string} base
    * @param {boolean} [exactUrl]
    */
-  (path30, base, exactUrl = false) => {
-    return `Cannot find ${exactUrl ? "module" : "package"} '${path30}' imported from ${base}`;
+  (path31, base, exactUrl = false) => {
+    return `Cannot find ${exactUrl ? "module" : "package"} '${path31}' imported from ${base}`;
   },
   Error
 );
@@ -17924,8 +18158,8 @@ codes2.ERR_UNKNOWN_FILE_EXTENSION = createError(
    * @param {string} extension
    * @param {string} path
    */
-  (extension, path30) => {
-    return `Unknown file extension "${extension}" for ${path30}`;
+  (extension, path31) => {
+    return `Unknown file extension "${extension}" for ${path31}`;
   },
   TypeError
 );
@@ -18296,9 +18530,9 @@ Default "index" lookups for the main are deprecated for ES modules.`,
     );
   }
 }
-function tryStatSync(path30) {
+function tryStatSync(path31) {
   try {
-    return _fs.statSync.call(void 0, path30);
+    return _fs.statSync.call(void 0, path31);
   } catch (e13) {
   }
 }
@@ -18971,7 +19205,7 @@ function _tryModuleResolve(id, url, conditions) {
   try {
     return moduleResolve(id, url, conditions);
   } catch (error) {
-    if (!NOT_FOUND_ERRORS.has(_optionalChain([error, 'optionalAccess', _247 => _247.code]))) {
+    if (!NOT_FOUND_ERRORS.has(_optionalChain([error, 'optionalAccess', _251 => _251.code]))) {
       throw error;
     }
   }
@@ -19000,7 +19234,7 @@ function _resolve(id, options = {}) {
         return pathToFileURL(id);
       }
     } catch (error) {
-      if (_optionalChain([error, 'optionalAccess', _248 => _248.code]) !== "ENOENT") {
+      if (_optionalChain([error, 'optionalAccess', _252 => _252.code]) !== "ENOENT") {
         throw error;
       }
     }
@@ -19144,10 +19378,10 @@ function fromGeneratorFn(generatorFn, options) {
   return fromObject({
     name: generatorFn.name,
     async(...args) {
-      return iterateAsync(generatorFn.apply(this, args), _optionalChain([options, 'optionalAccess', _249 => _249.onYield]));
+      return iterateAsync(generatorFn.apply(this, args), _optionalChain([options, 'optionalAccess', _253 => _253.onYield]));
     },
     sync(...args) {
-      return iterateSync2(generatorFn.apply(this, args), _optionalChain([options, 'optionalAccess', _250 => _250.onYield]));
+      return iterateSync2(generatorFn.apply(this, args), _optionalChain([options, 'optionalAccess', _254 => _254.onYield]));
     }
   });
 }
@@ -19206,7 +19440,7 @@ function findUpSync(name, {
     const filePath = isAbsoluteName ? name : sysPath2.default.join(directory, name);
     try {
       const stats = actualFS.default.statSync(filePath, { throwIfNoEntry: false });
-      if (type === "file" && _optionalChain([stats, 'optionalAccess', _251 => _251.isFile, 'call', _252 => _252()]) || type === "directory" && _optionalChain([stats, 'optionalAccess', _253 => _253.isDirectory, 'call', _254 => _254()])) {
+      if (type === "file" && _optionalChain([stats, 'optionalAccess', _255 => _255.isFile, 'call', _256 => _256()]) || type === "directory" && _optionalChain([stats, 'optionalAccess', _257 => _257.isDirectory, 'call', _258 => _258()])) {
         return filePath;
       }
     } catch (e16) {
@@ -19217,7 +19451,7 @@ function findUpSync(name, {
     directory = sysPath2.default.dirname(directory);
   }
 }
-function _resolve2(path30, options = {}) {
+function _resolve2(path31, options = {}) {
   if (options.platform === "auto" || !options.platform)
     options.platform = _process2.default.platform === "win32" ? "win32" : "posix";
   if (_process2.default.versions.pnp) {
@@ -19226,11 +19460,11 @@ function _resolve2(path30, options = {}) {
       paths.push(_process2.default.cwd());
     const targetRequire = _module.createRequire.call(void 0, _chunkOS76JPG2cjs.importMetaUrl);
     try {
-      return targetRequire.resolve(path30, { paths });
+      return targetRequire.resolve(path31, { paths });
     } catch (e17) {
     }
   }
-  const modulePath = resolvePathSync(path30, {
+  const modulePath = resolvePathSync(path31, {
     url: options.paths
   });
   if (options.platform === "win32")
@@ -19301,10 +19535,10 @@ var findUp = quansync2({
   async: findUp$1
 });
 var loadPackageJSON = quansync2(function* (cwd = _process2.default.cwd()) {
-  const path30 = yield findUp("package.json", { cwd });
-  if (!path30 || !actualFS.default.existsSync(path30))
+  const path31 = yield findUp("package.json", { cwd });
+  if (!path31 || !actualFS.default.existsSync(path31))
     return null;
-  return JSON.parse(yield readFile(path30));
+  return JSON.parse(yield readFile(path31));
 });
 var loadPackageJSONSync = loadPackageJSON.sync;
 var isPackageListed = quansync2(function* (name, cwd) {
@@ -19313,13 +19547,13 @@ var isPackageListed = quansync2(function* (name, cwd) {
 });
 var isPackageListedSync = isPackageListed.sync;
 
-// ../../node_modules/.pnpm/package-manager-detector@1.4.1/node_modules/package-manager-detector/dist/detect.mjs
+// ../../node_modules/.pnpm/package-manager-detector@1.5.0/node_modules/package-manager-detector/dist/detect.mjs
 _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
 
 
 
 
-// ../../node_modules/.pnpm/package-manager-detector@1.4.1/node_modules/package-manager-detector/dist/constants.mjs
+// ../../node_modules/.pnpm/package-manager-detector@1.5.0/node_modules/package-manager-detector/dist/constants.mjs
 _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
 var AGENTS = [
   "npm",
@@ -19356,7 +19590,7 @@ var INSTALL_METADATA = {
   "bun.lockb": "bun"
 };
 
-// ../../node_modules/.pnpm/package-manager-detector@1.4.1/node_modules/package-manager-detector/dist/detect.mjs
+// ../../node_modules/.pnpm/package-manager-detector@1.5.0/node_modules/package-manager-detector/dist/detect.mjs
 async function pathExists(path210, type) {
   try {
     const stat6 = await _promises2.default.stat(path210);
@@ -19425,18 +19659,18 @@ async function detect(options = {}) {
         }
       }
     }
-    if (_optionalChain([stopDir, 'optionalCall', _255 => _255(directory)]))
+    if (_optionalChain([stopDir, 'optionalCall', _259 => _259(directory)]))
       break;
   }
   return null;
 }
 function getNameAndVer(pkg) {
-  const handelVer = (version3) => _nullishCoalesce(_optionalChain([version3, 'optionalAccess', _256 => _256.match, 'call', _257 => _257(/\d+(\.\d+){0,2}/), 'optionalAccess', _258 => _258[0]]), () => ( version3));
+  const handelVer = (version3) => _nullishCoalesce(_optionalChain([version3, 'optionalAccess', _260 => _260.match, 'call', _261 => _261(/\d+(\.\d+){0,2}/), 'optionalAccess', _262 => _262[0]]), () => ( version3));
   if (typeof pkg.packageManager === "string") {
     const [name, ver] = pkg.packageManager.replace(/^\^/, "").split("@");
     return { name, ver: handelVer(ver) };
   }
-  if (typeof _optionalChain([pkg, 'access', _259 => _259.devEngines, 'optionalAccess', _260 => _260.packageManager, 'optionalAccess', _261 => _261.name]) === "string") {
+  if (typeof _optionalChain([pkg, 'access', _263 => _263.devEngines, 'optionalAccess', _264 => _264.packageManager, 'optionalAccess', _265 => _265.name]) === "string") {
     return {
       name: pkg.devEngines.packageManager.name,
       ver: handelVer(pkg.devEngines.packageManager.version)
@@ -19464,7 +19698,7 @@ async function handlePackageManager(filepath, onUnknown) {
         agent = name;
         return { name, agent, version: version3 };
       } else {
-        return _nullishCoalesce(_optionalChain([onUnknown, 'optionalCall', _262 => _262(pkg.packageManager)]), () => ( null));
+        return _nullishCoalesce(_optionalChain([onUnknown, 'optionalCall', _266 => _266(pkg.packageManager)]), () => ( null));
       }
     }
   } catch (e21) {
@@ -19511,6 +19745,9 @@ function getWeappViteConfig() {
     npm: {
       enable: true,
       cache: true
+    },
+    chunks: {
+      sharedStrategy: "duplicate"
     }
   };
 }
@@ -19566,7 +19803,7 @@ function createAssetCollector(state) {
     },
     async buildEnd() {
       const assets = await state.pendingAssets;
-      if (!_optionalChain([assets, 'optionalAccess', _263 => _263.length])) {
+      if (!_optionalChain([assets, 'optionalAccess', _267 => _267.length])) {
         return;
       }
       for (const candidate of assets) {
@@ -19581,9 +19818,9 @@ function createAssetCollector(state) {
 }
 function scanAssetFiles(configService, config) {
   const weappViteConfig = configService.weappViteConfig;
-  const include = normalizeCopyGlobs(_optionalChain([weappViteConfig, 'optionalAccess', _264 => _264.copy, 'optionalAccess', _265 => _265.include]));
-  const exclude = normalizeCopyGlobs(_optionalChain([weappViteConfig, 'optionalAccess', _266 => _266.copy, 'optionalAccess', _267 => _267.exclude]));
-  const filter3 = _nullishCoalesce(_optionalChain([weappViteConfig, 'optionalAccess', _268 => _268.copy, 'optionalAccess', _269 => _269.filter]), () => ( (() => true)));
+  const include = normalizeCopyGlobs(_optionalChain([weappViteConfig, 'optionalAccess', _268 => _268.copy, 'optionalAccess', _269 => _269.include]));
+  const exclude = normalizeCopyGlobs(_optionalChain([weappViteConfig, 'optionalAccess', _270 => _270.copy, 'optionalAccess', _271 => _271.exclude]));
+  const filter3 = _nullishCoalesce(_optionalChain([weappViteConfig, 'optionalAccess', _272 => _272.copy, 'optionalAccess', _273 => _273.filter]), () => ( (() => true)));
   const ignore = [
     ...defaultExcluded,
     _pathe2.default.resolve(configService.cwd, `${config.build.outDir}/**/*`),
@@ -19699,13 +19936,13 @@ function createAutoImportPlugin(state) {
         return;
       }
       const weappConfig = configService.weappViteConfig;
-      const globs = _nullishCoalesce(_optionalChain([weappConfig, 'optionalAccess', _270 => _270.autoImportComponents, 'optionalAccess', _271 => _271.globs]), () => ( _optionalChain([weappConfig, 'optionalAccess', _272 => _272.enhance, 'optionalAccess', _273 => _273.autoImportComponents, 'optionalAccess', _274 => _274.globs])));
-      const globsKey = _nullishCoalesce(_optionalChain([globs, 'optionalAccess', _275 => _275.join, 'call', _276 => _276("\0")]), () => ( ""));
+      const globs = _nullishCoalesce(_optionalChain([weappConfig, 'optionalAccess', _274 => _274.autoImportComponents, 'optionalAccess', _275 => _275.globs]), () => ( _optionalChain([weappConfig, 'optionalAccess', _276 => _276.enhance, 'optionalAccess', _277 => _277.autoImportComponents, 'optionalAccess', _278 => _278.globs])));
+      const globsKey = _nullishCoalesce(_optionalChain([globs, 'optionalAccess', _279 => _279.join, 'call', _280 => _280("\0")]), () => ( ""));
       if (globsKey !== state.lastGlobsKey) {
         state.initialScanDone = false;
         state.lastGlobsKey = globsKey;
       }
-      if (!_optionalChain([globs, 'optionalAccess', _277 => _277.length])) {
+      if (!_optionalChain([globs, 'optionalAccess', _281 => _281.length])) {
         return;
       }
       if (state.initialScanDone) {
@@ -19802,7 +20039,7 @@ function createAutoRoutesPlugin(ctx) {
       if (!service.isRouteFile(context.file)) {
         return;
       }
-      if (_optionalChain([resolvedConfig, 'optionalAccess', _278 => _278.command]) === "serve") {
+      if (_optionalChain([resolvedConfig, 'optionalAccess', _282 => _282.command]) === "serve") {
         await service.ensureFresh();
       }
       const virtualModule = context.server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_ID);
@@ -21034,7 +21271,7 @@ function createCacheKey(options) {
   return `${options.removeComment ? 1 : 0}|${options.transformEvent ? 1 : 0}`;
 }
 function getCachedResult(data2, cacheKey) {
-  return _optionalChain([handleCache, 'access', _279 => _279.get, 'call', _280 => _280(data2), 'optionalAccess', _281 => _281.get, 'call', _282 => _282(cacheKey)]);
+  return _optionalChain([handleCache, 'access', _283 => _283.get, 'call', _284 => _284(data2), 'optionalAccess', _285 => _285.get, 'call', _286 => _286(cacheKey)]);
 }
 function setCachedResult(data2, cacheKey, result) {
   let cacheForToken = handleCache.get(data2);
@@ -21110,7 +21347,7 @@ function handleWxml(data2, options) {
   if (shouldTransformInlineWxs) {
     for (const { end, start, value } of inlineWxsTokens) {
       const { result } = getCachedInlineWxsTransform(value);
-      if (_optionalChain([result, 'optionalAccess', _283 => _283.code])) {
+      if (_optionalChain([result, 'optionalAccess', _287 => _287.code])) {
         ms.update(start, end, `
 ${result.code}`);
       }
@@ -21190,7 +21427,7 @@ function createChunkEmitter(configService, loadedEntrySet, debug4) {
         // @ts-ignore
         preserveSignature: "exports-only"
       });
-      _optionalChain([debug4, 'optionalCall', _284 => _284(`load ${fileName} \u8017\u65F6 ${(_perf_hooks.performance.now() - start).toFixed(2)}ms`)]);
+      _optionalChain([debug4, 'optionalCall', _288 => _288(`load ${fileName} \u8017\u65F6 ${(_perf_hooks.performance.now() - start).toFixed(2)}ms`)]);
     });
   };
 }
@@ -21427,7 +21664,7 @@ function createEntryLoader(options) {
       normalizedEntries,
       configService.absoluteSrcRoot
     );
-    _optionalChain([debug4, 'optionalCall', _285 => _285(`resolvedIds ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
+    _optionalChain([debug4, 'optionalCall', _289 => _289(`resolvedIds ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
     const pendingResolvedIds = [];
     for (const { entry, resolvedId } of resolvedIds) {
       if (!resolvedId) {
@@ -21442,7 +21679,7 @@ function createEntryLoader(options) {
     if (pendingResolvedIds.length) {
       await Promise.all(emitEntriesChunks.call(this, pendingResolvedIds));
     }
-    _optionalChain([debug4, 'optionalCall', _286 => _286(`emitEntriesChunks ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
+    _optionalChain([debug4, 'optionalCall', _290 => _290(`emitEntriesChunks ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
     registerJsonAsset({
       jsonPath,
       json,
@@ -21450,7 +21687,7 @@ function createEntryLoader(options) {
     });
     const code = await _fsextra2.default.readFile(id, "utf8");
     const styleImports = await collectStyleImports(this, id, existsCache);
-    _optionalChain([debug4, 'optionalCall', _287 => _287(`loadEntry ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
+    _optionalChain([debug4, 'optionalCall', _291 => _291(`loadEntry ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
     if (styleImports.length === 0) {
       return {
         code
@@ -21521,7 +21758,7 @@ function createTemplateScanner(wxmlService, debug4) {
       const { components: components2 } = wxmlToken;
       wxmlService.setWxmlComponentsMap(templateEntry, components2);
     }
-    _optionalChain([debug4, 'optionalCall', _288 => _288(`scanTemplateEntry ${templateEntry} \u8017\u65F6 ${(_perf_hooks.performance.now() - start).toFixed(2)}ms`)]);
+    _optionalChain([debug4, 'optionalCall', _292 => _292(`scanTemplateEntry ${templateEntry} \u8017\u65F6 ${(_perf_hooks.performance.now() - start).toFixed(2)}ms`)]);
   };
 }
 
@@ -21666,7 +21903,7 @@ function ensureSidecarWatcher(ctx, rootDir) {
   };
   const warnWatchLimit = (error, action) => {
     const relativeRoot = ctx.configService.relativeCwd(absRoot);
-    const code = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _289 => _289.code]), () => ( "UNKNOWN"));
+    const code = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _293 => _293.code]), () => ( "UNKNOWN"));
     const message = action === "fallback" ? `[watch] ${relativeRoot} \u76D1\u542C\u6570\u91CF\u8FBE\u5230\u4E0A\u9650 (${code})\uFF0C\u6B63\u5728\u56DE\u9000\u5230 chokidar watcher` : `[watch] ${relativeRoot} \u76D1\u542C\u6570\u91CF\u8FBE\u5230\u4E0A\u9650 (${code})\uFF0C\u5DF2\u505C\u7528\u4FA7\u8F66\u6587\u4EF6\u76D1\u542C`;
     logger_default.warn(message);
   };
@@ -21686,7 +21923,7 @@ function ensureSidecarWatcher(ctx, rootDir) {
         }
         handledWatchLimit = true;
         try {
-          _optionalChain([watcher, 'optionalAccess', _290 => _290.close, 'call', _291 => _291()]);
+          _optionalChain([watcher, 'optionalAccess', _294 => _294.close, 'call', _295 => _295()]);
         } catch (e24) {
         }
         if (supportsRecursiveWatch) {
@@ -21703,7 +21940,7 @@ function ensureSidecarWatcher(ctx, rootDir) {
         }
       });
       sidecarWatcherMap.set(absRoot, {
-        close: () => _optionalChain([watcher, 'optionalAccess', _292 => _292.close, 'call', _293 => _293()])
+        close: () => _optionalChain([watcher, 'optionalAccess', _296 => _296.close, 'call', _297 => _297()])
       });
       return;
     } catch (error) {
@@ -21865,7 +22102,7 @@ function createCoreLifecyclePlugin(state) {
       options.input = scannedInput;
     },
     async load(id) {
-      _optionalChain([configService, 'access', _294 => _294.weappViteConfig, 'optionalAccess', _295 => _295.debug, 'optionalAccess', _296 => _296.load, 'optionalCall', _297 => _297(id, subPackageMeta)]);
+      _optionalChain([configService, 'access', _298 => _298.weappViteConfig, 'optionalAccess', _299 => _299.debug, 'optionalAccess', _300 => _300.load, 'optionalCall', _301 => _301(id, subPackageMeta)]);
       const relativeBasename = _shared.removeExtensionDeep.call(void 0, configService.relativeAbsoluteSrcRoot(id));
       if (isCSSRequest(id)) {
         const parsed = parseRequest(id);
@@ -21879,7 +22116,7 @@ function createCoreLifecyclePlugin(state) {
         }
         return null;
       }
-      if (loadedEntrySet.has(id) || _optionalChain([subPackageMeta, 'optionalAccess', _298 => _298.entries, 'access', _299 => _299.includes, 'call', _300 => _300(relativeBasename)])) {
+      if (loadedEntrySet.has(id) || _optionalChain([subPackageMeta, 'optionalAccess', _302 => _302.entries, 'access', _303 => _303.includes, 'call', _304 => _304(relativeBasename)])) {
         return await loadEntry.call(this, id, "component");
       }
       if (relativeBasename === "app") {
@@ -21890,12 +22127,19 @@ function createCoreLifecyclePlugin(state) {
       emitJsonAssets.call(this, state);
       state.watchFilesSnapshot = emitWxmlAssets.call(this, state);
     },
-    async generateBundle() {
+    async generateBundle(_options, bundle) {
       await flushIndependentBuilds.call(this, state, watcherService);
-      if (_optionalChain([configService, 'access', _301 => _301.weappViteConfig, 'optionalAccess', _302 => _302.debug, 'optionalAccess', _303 => _303.watchFiles])) {
+      if (!subPackageMeta) {
+        const sharedStrategy = _nullishCoalesce(_optionalChain([configService, 'access', _305 => _305.weappViteConfig, 'optionalAccess', _306 => _306.chunks, 'optionalAccess', _307 => _307.sharedStrategy]), () => ( DEFAULT_SHARED_CHUNK_STRATEGY));
+        applySharedChunkStrategy.call(this, bundle, {
+          strategy: sharedStrategy,
+          subPackageRoots: scanService.subPackageMap.keys()
+        });
+      }
+      if (_optionalChain([configService, 'access', _308 => _308.weappViteConfig, 'optionalAccess', _309 => _309.debug, 'optionalAccess', _310 => _310.watchFiles])) {
         const watcherService2 = ctx.watcherService;
-        const watcherRoot = _nullishCoalesce(_optionalChain([subPackageMeta, 'optionalAccess', _304 => _304.subPackage, 'access', _305 => _305.root]), () => ( "/"));
-        const watcher = _optionalChain([watcherService2, 'optionalAccess', _306 => _306.getRollupWatcher, 'call', _307 => _307(watcherRoot)]);
+        const watcherRoot = _nullishCoalesce(_optionalChain([subPackageMeta, 'optionalAccess', _311 => _311.subPackage, 'access', _312 => _312.root]), () => ( "/"));
+        const watcher = _optionalChain([watcherService2, 'optionalAccess', _313 => _313.getRollupWatcher, 'call', _314 => _314(watcherRoot)]);
         let watchFiles;
         if (watcher && typeof watcher.getWatchFiles === "function") {
           watchFiles = await watcher.getWatchFiles();
@@ -21909,7 +22153,7 @@ function createCoreLifecyclePlugin(state) {
       }
     },
     buildEnd() {
-      _optionalChain([debug2, 'optionalCall', _308 => _308(`${subPackageMeta ? `\u72EC\u7ACB\u5206\u5305 ${subPackageMeta.subPackage.root}` : "\u4E3B\u5305"} ${Array.from(this.getModuleIds()).length} \u4E2A\u6A21\u5757\u88AB\u7F16\u8BD1`)]);
+      _optionalChain([debug2, 'optionalCall', _315 => _315(`${subPackageMeta ? `\u72EC\u7ACB\u5206\u5305 ${subPackageMeta.subPackage.root}` : "\u4E3B\u5305"} ${Array.from(this.getModuleIds()).length} \u4E2A\u6A21\u5757\u88AB\u7F16\u8BD1`)]);
     }
   };
 }
@@ -22265,14 +22509,14 @@ function createPluginPruner() {
     name: "weapp-vite:preflight",
     enforce: "pre",
     configResolved(config) {
-      if (!_optionalChain([config, 'access', _309 => _309.plugins, 'optionalAccess', _310 => _310.length])) {
+      if (!_optionalChain([config, 'access', _316 => _316.plugins, 'optionalAccess', _317 => _317.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', _311 => _311("remove plugin", plugin.name)]);
+          plugin && _optionalChain([debug3, 'optionalCall', _318 => _318("remove plugin", plugin.name)]);
         }
       }
     }
@@ -22311,8 +22555,8 @@ function createWorkerBuildPlugin(ctx) {
     name: "weapp-vite:workers",
     enforce: "pre",
     async options(options) {
-      const workerConfig = _optionalChain([configService, 'access', _312 => _312.weappViteConfig, 'optionalAccess', _313 => _313.worker]);
-      const entries = Array.isArray(_optionalChain([workerConfig, 'optionalAccess', _314 => _314.entry])) ? workerConfig.entry : [_optionalChain([workerConfig, 'optionalAccess', _315 => _315.entry])];
+      const workerConfig = _optionalChain([configService, 'access', _319 => _319.weappViteConfig, 'optionalAccess', _320 => _320.worker]);
+      const entries = Array.isArray(_optionalChain([workerConfig, 'optionalAccess', _321 => _321.entry])) ? workerConfig.entry : [_optionalChain([workerConfig, 'optionalAccess', _322 => _322.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;
@@ -22429,7 +22673,7 @@ async function transformWxsFile(state, wxsPath) {
     const { result, importees } = transformWxsCode(rawCode, {
       filename: wxsPath
     });
-    if (typeof _optionalChain([result, 'optionalAccess', _316 => _316.code]) === "string") {
+    if (typeof _optionalChain([result, 'optionalAccess', _323 => _323.code]) === "string") {
       code = result.code;
     }
     const dirname5 = _pathe2.default.dirname(wxsPath);
@@ -22462,13 +22706,13 @@ async function transformWxsFile(state, wxsPath) {
 var RUNTIME_PLUGINS_SYMBOL = Symbol.for("weapp-runtime:plugins");
 function attachRuntimePlugins(ctx, plugins) {
   const runtimePlugins = ctx[RUNTIME_PLUGINS_SYMBOL];
-  if (!_optionalChain([runtimePlugins, 'optionalAccess', _317 => _317.length])) {
+  if (!_optionalChain([runtimePlugins, 'optionalAccess', _324 => _324.length])) {
     return plugins;
   }
   return [...runtimePlugins, ...plugins];
 }
 function applyInspect(ctx, plugins) {
-  const inspectOptions = _optionalChain([ctx, 'access', _318 => _318.configService, 'access', _319 => _319.weappViteConfig, 'optionalAccess', _320 => _320.debug, 'optionalAccess', _321 => _321.inspect]);
+  const inspectOptions = _optionalChain([ctx, 'access', _325 => _325.configService, 'access', _326 => _326.weappViteConfig, 'optionalAccess', _327 => _327.debug, 'optionalAccess', _328 => _328.inspect]);
   if (!inspectOptions) {
     return plugins;
   }
@@ -22514,13 +22758,13 @@ function migrateEnhanceOptions(target, options) {
   }
   const enhance = target.enhance;
   const userConfigured = _nullishCoalesce(options.userConfigured, () => ( {}));
-  if (!userConfigured.wxml && _optionalChain([enhance, 'optionalAccess', _322 => _322.wxml]) !== void 0) {
+  if (!userConfigured.wxml && _optionalChain([enhance, 'optionalAccess', _329 => _329.wxml]) !== void 0) {
     target.wxml = enhance.wxml;
   }
-  if (!userConfigured.wxs && _optionalChain([enhance, 'optionalAccess', _323 => _323.wxs]) !== void 0) {
+  if (!userConfigured.wxs && _optionalChain([enhance, 'optionalAccess', _330 => _330.wxs]) !== void 0) {
     target.wxs = enhance.wxs;
   }
-  if (!userConfigured.autoImportComponents && _optionalChain([enhance, 'optionalAccess', _324 => _324.autoImportComponents]) !== void 0) {
+  if (!userConfigured.autoImportComponents && _optionalChain([enhance, 'optionalAccess', _331 => _331.autoImportComponents]) !== void 0) {
     target.autoImportComponents = enhance.autoImportComponents;
   }
   if (options.warn && !hasLoggedEnhanceDeprecation) {
@@ -22685,7 +22929,7 @@ function normalizeSrcDir(root, cwd, srcRoot, config) {
   return _pathe2.default.relative(root, absoluteSrc) || "";
 }
 function normalizeOutDir(root, config) {
-  if (!_optionalChain([config, 'optionalAccess', _325 => _325.outDir])) {
+  if (!_optionalChain([config, 'optionalAccess', _332 => _332.outDir])) {
     return _pathe2.default.resolve(root, "dist-web");
   }
   if (_pathe2.default.isAbsolute(config.outDir)) {
@@ -22788,7 +23032,7 @@ export default _objectSpread2;`
 function getOxcHelperName(id) {
   OXC_RUNTIME_HELPER_ALIAS.lastIndex = 0;
   const match2 = OXC_RUNTIME_HELPER_ALIAS.exec(id);
-  return _optionalChain([match2, 'optionalAccess', _326 => _326[1]]);
+  return _optionalChain([match2, 'optionalAccess', _333 => _333[1]]);
 }
 function createOxcRuntimeSupport() {
   const oxcRuntimeInfo = getPackageInfoSync("@oxc-project/runtime");
@@ -22961,7 +23205,7 @@ function createConfigService(ctx) {
     resolve8.alias = aliasArray;
   }
   function getDefineImportMetaEnv() {
-    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _327 => _327.platform]), () => ( DEFAULT_MP_PLATFORM));
+    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _334 => _334.platform]), () => ( DEFAULT_MP_PLATFORM));
     const resolvedPlatform = _nullishCoalesce(defineEnv.PLATFORM, () => ( mpPlatform));
     const env = {
       PLATFORM: resolvedPlatform,
@@ -22980,7 +23224,7 @@ function createConfigService(ctx) {
   }
   function applyRuntimePlatform(runtime) {
     const isWeb = runtime === "web";
-    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _328 => _328.platform]), () => ( DEFAULT_MP_PLATFORM));
+    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _335 => _335.platform]), () => ( DEFAULT_MP_PLATFORM));
     const resolvedPlatform = isWeb ? "web" : mpPlatform;
     setDefineEnv("PLATFORM", resolvedPlatform);
     setDefineEnv("IS_WEB", isWeb);
@@ -23014,11 +23258,11 @@ function createConfigService(ctx) {
       command: isDev ? "serve" : "build",
       mode
     }, resolvedConfigFile, cwd);
-    const loadedConfig = _optionalChain([loaded, 'optionalAccess', _329 => _329.config]);
+    const loadedConfig = _optionalChain([loaded, 'optionalAccess', _336 => _336.config]);
     let weappLoaded;
     if (weappConfigFilePath) {
       const normalizedWeappPath = _pathe2.default.resolve(weappConfigFilePath);
-      const normalizedLoadedPath = _optionalChain([loaded, 'optionalAccess', _330 => _330.path]) ? _pathe2.default.resolve(loaded.path) : void 0;
+      const normalizedLoadedPath = _optionalChain([loaded, 'optionalAccess', _337 => _337.path]) ? _pathe2.default.resolve(loaded.path) : void 0;
       if (normalizedLoadedPath && normalizedLoadedPath === normalizedWeappPath) {
         weappLoaded = loaded;
       } else {
@@ -23051,47 +23295,47 @@ function createConfigService(ctx) {
         weapp: getWeappViteConfig()
       }
     );
-    if (_optionalChain([weappLoaded, 'optionalAccess', _331 => _331.config, 'optionalAccess', _332 => _332.weapp])) {
+    if (_optionalChain([weappLoaded, 'optionalAccess', _338 => _338.config, 'optionalAccess', _339 => _339.weapp])) {
       config.weapp = _shared.defu.call(void 0, 
         weappLoaded.config.weapp,
         _nullishCoalesce(config.weapp, () => ( {}))
       );
     }
     const shouldWarnEnhance = [
-      _optionalChain([inlineConfig, 'optionalAccess', _333 => _333.weapp, 'optionalAccess', _334 => _334.enhance]),
-      _optionalChain([loadedConfig, 'optionalAccess', _335 => _335.weapp, 'optionalAccess', _336 => _336.enhance]),
-      _optionalChain([weappLoaded, 'optionalAccess', _337 => _337.config, 'optionalAccess', _338 => _338.weapp, 'optionalAccess', _339 => _339.enhance])
+      _optionalChain([inlineConfig, 'optionalAccess', _340 => _340.weapp, 'optionalAccess', _341 => _341.enhance]),
+      _optionalChain([loadedConfig, 'optionalAccess', _342 => _342.weapp, 'optionalAccess', _343 => _343.enhance]),
+      _optionalChain([weappLoaded, 'optionalAccess', _344 => _344.config, 'optionalAccess', _345 => _345.weapp, 'optionalAccess', _346 => _346.enhance])
     ].some(hasDeprecatedEnhanceUsage);
     const userConfiguredTopLevel = {
       wxml: [
-        _optionalChain([inlineConfig, 'optionalAccess', _340 => _340.weapp, 'optionalAccess', _341 => _341.wxml]),
-        _optionalChain([loadedConfig, 'optionalAccess', _342 => _342.weapp, 'optionalAccess', _343 => _343.wxml]),
-        _optionalChain([weappLoaded, 'optionalAccess', _344 => _344.config, 'optionalAccess', _345 => _345.weapp, 'optionalAccess', _346 => _346.wxml])
+        _optionalChain([inlineConfig, 'optionalAccess', _347 => _347.weapp, 'optionalAccess', _348 => _348.wxml]),
+        _optionalChain([loadedConfig, 'optionalAccess', _349 => _349.weapp, 'optionalAccess', _350 => _350.wxml]),
+        _optionalChain([weappLoaded, 'optionalAccess', _351 => _351.config, 'optionalAccess', _352 => _352.weapp, 'optionalAccess', _353 => _353.wxml])
       ].some((value) => value !== void 0),
       wxs: [
-        _optionalChain([inlineConfig, 'optionalAccess', _347 => _347.weapp, 'optionalAccess', _348 => _348.wxs]),
-        _optionalChain([loadedConfig, 'optionalAccess', _349 => _349.weapp, 'optionalAccess', _350 => _350.wxs]),
-        _optionalChain([weappLoaded, 'optionalAccess', _351 => _351.config, 'optionalAccess', _352 => _352.weapp, 'optionalAccess', _353 => _353.wxs])
+        _optionalChain([inlineConfig, 'optionalAccess', _354 => _354.weapp, 'optionalAccess', _355 => _355.wxs]),
+        _optionalChain([loadedConfig, 'optionalAccess', _356 => _356.weapp, 'optionalAccess', _357 => _357.wxs]),
+        _optionalChain([weappLoaded, 'optionalAccess', _358 => _358.config, 'optionalAccess', _359 => _359.weapp, 'optionalAccess', _360 => _360.wxs])
       ].some((value) => value !== void 0),
       autoImportComponents: [
-        _optionalChain([inlineConfig, 'optionalAccess', _354 => _354.weapp, 'optionalAccess', _355 => _355.autoImportComponents]),
-        _optionalChain([loadedConfig, 'optionalAccess', _356 => _356.weapp, 'optionalAccess', _357 => _357.autoImportComponents]),
-        _optionalChain([weappLoaded, 'optionalAccess', _358 => _358.config, 'optionalAccess', _359 => _359.weapp, 'optionalAccess', _360 => _360.autoImportComponents])
+        _optionalChain([inlineConfig, 'optionalAccess', _361 => _361.weapp, 'optionalAccess', _362 => _362.autoImportComponents]),
+        _optionalChain([loadedConfig, 'optionalAccess', _363 => _363.weapp, 'optionalAccess', _364 => _364.autoImportComponents]),
+        _optionalChain([weappLoaded, 'optionalAccess', _365 => _365.config, 'optionalAccess', _366 => _366.weapp, 'optionalAccess', _367 => _367.autoImportComponents])
       ].some((value) => value !== void 0)
     };
     migrateEnhanceOptions(config.weapp, {
       warn: shouldWarnEnhance,
       userConfigured: userConfiguredTopLevel
     });
-    const srcRoot = _nullishCoalesce(_optionalChain([config, 'access', _361 => _361.weapp, 'optionalAccess', _362 => _362.srcRoot]), () => ( ""));
+    const srcRoot = _nullishCoalesce(_optionalChain([config, 'access', _368 => _368.weapp, 'optionalAccess', _369 => _369.srcRoot]), () => ( ""));
     const resolvedWebConfig = resolveWeappWebConfig({
       cwd,
       srcRoot,
-      config: _optionalChain([config, 'access', _363 => _363.weapp, 'optionalAccess', _364 => _364.web])
+      config: _optionalChain([config, 'access', _370 => _370.weapp, 'optionalAccess', _371 => _371.web])
     });
     const buildConfig = _nullishCoalesce(config.build, () => ( (config.build = {})));
-    const jsFormat = _nullishCoalesce(_optionalChain([config, 'access', _365 => _365.weapp, 'optionalAccess', _366 => _366.jsFormat]), () => ( "cjs"));
-    const enableLegacyEs5 = _optionalChain([config, 'access', _367 => _367.weapp, 'optionalAccess', _368 => _368.es5]) === true;
+    const jsFormat = _nullishCoalesce(_optionalChain([config, 'access', _372 => _372.weapp, 'optionalAccess', _373 => _373.jsFormat]), () => ( "cjs"));
+    const enableLegacyEs5 = _optionalChain([config, 'access', _374 => _374.weapp, 'optionalAccess', _375 => _375.es5]) === true;
     if (enableLegacyEs5 && jsFormat !== "cjs") {
       throw new Error('`weapp.es5` \u4EC5\u652F\u6301\u5728 `weapp.jsFormat` \u4E3A "cjs" \u65F6\u4F7F\u7528\uFF0C\u8BF7\u5207\u6362\u5230 CommonJS \u6216\u5173\u95ED\u8BE5\u9009\u9879\u3002');
     }
@@ -23117,7 +23361,7 @@ function createConfigService(ctx) {
     const pluginArray = rawPlugins == null ? [] : Array.isArray(rawPlugins) ? [...rawPlugins] : [rawPlugins];
     if (enableLegacyEs5) {
       const swcPluginName = "weapp-runtime:swc-es5-transform";
-      const hasSwcPlugin = pluginArray.some((plugin) => _optionalChain([plugin, 'optionalAccess', _369 => _369.name]) === swcPluginName);
+      const hasSwcPlugin = pluginArray.some((plugin) => _optionalChain([plugin, 'optionalAccess', _376 => _376.name]) === swcPluginName);
       if (!hasSwcPlugin) {
         pluginArray.push(createLegacyEs5Plugin());
       }
@@ -23149,12 +23393,12 @@ function createConfigService(ctx) {
       config.plugins ??= [];
       config.plugins.unshift(oxcRuntimeSupport.vitePlugin);
     }
-    const platform = _nullishCoalesce(_optionalChain([config, 'access', _370 => _370.weapp, 'optionalAccess', _371 => _371.platform]), () => ( "weapp"));
+    const platform = _nullishCoalesce(_optionalChain([config, 'access', _377 => _377.weapp, 'optionalAccess', _378 => _378.platform]), () => ( "weapp"));
     const resolvedOutputExtensions = getOutputExtensions(platform);
     config.plugins ??= [];
-    _optionalChain([config, 'access', _372 => _372.plugins, 'optionalAccess', _373 => _373.push, 'call', _374 => _374(_vitetsconfigpaths2.default.call(void 0, _optionalChain([config, 'access', _375 => _375.weapp, 'optionalAccess', _376 => _376.tsconfigPaths])))]);
-    const aliasEntries = getAliasEntries(_optionalChain([config, 'access', _377 => _377.weapp, 'optionalAccess', _378 => _378.jsonAlias]));
-    const configFilePath = _nullishCoalesce(_nullishCoalesce(_optionalChain([weappLoaded, 'optionalAccess', _379 => _379.path]), () => ( _optionalChain([loaded, 'optionalAccess', _380 => _380.path]))), () => ( resolvedConfigFile));
+    _optionalChain([config, 'access', _379 => _379.plugins, 'optionalAccess', _380 => _380.push, 'call', _381 => _381(_vitetsconfigpaths2.default.call(void 0, _optionalChain([config, 'access', _382 => _382.weapp, 'optionalAccess', _383 => _383.tsconfigPaths])))]);
+    const aliasEntries = getAliasEntries(_optionalChain([config, 'access', _384 => _384.weapp, 'optionalAccess', _385 => _385.jsonAlias]));
+    const configFilePath = _nullishCoalesce(_nullishCoalesce(_optionalChain([weappLoaded, 'optionalAccess', _386 => _386.path]), () => ( _optionalChain([loaded, 'optionalAccess', _387 => _387.path]))), () => ( resolvedConfigFile));
     return {
       config,
       aliasEntries,
@@ -23282,6 +23526,7 @@ function createConfigService(ctx) {
             },
             minify: false,
             emptyOutDir: false,
+            // @ts-ignore
             rolldownOptions: {
               ...rolldownOptions
             },
@@ -23307,6 +23552,7 @@ function createConfigService(ctx) {
         define: getDefineImportMetaEnv(),
         build: {
           emptyOutDir: false,
+          // @ts-ignore
           rolldownOptions: {
             ...rolldownOptions
           }
@@ -23315,7 +23561,7 @@ function createConfigService(ctx) {
     );
     inlineConfig.logLevel = "info";
     injectBuiltinAliases(inlineConfig);
-    const currentRoot = _optionalChain([subPackageMeta, 'optionalAccess', _381 => _381.subPackage, 'access', _382 => _382.root]);
+    const currentRoot = _optionalChain([subPackageMeta, 'optionalAccess', _388 => _388.subPackage, 'access', _389 => _389.root]);
     options = {
       ...options,
       currentSubPackageRoot: currentRoot
@@ -23329,7 +23575,7 @@ function createConfigService(ctx) {
     }
     options = configState.options;
     const web = options.weappWeb;
-    if (!_optionalChain([web, 'optionalAccess', _383 => _383.enabled])) {
+    if (!_optionalChain([web, 'optionalAccess', _390 => _390.enabled])) {
       return void 0;
     }
     applyRuntimePlatform("web");
@@ -23448,10 +23694,10 @@ function createConfigService(ctx) {
       return options.srcRoot;
     },
     get pluginRoot() {
-      return _optionalChain([options, 'access', _384 => _384.config, 'access', _385 => _385.weapp, 'optionalAccess', _386 => _386.pluginRoot]);
+      return _optionalChain([options, 'access', _391 => _391.config, 'access', _392 => _392.weapp, 'optionalAccess', _393 => _393.pluginRoot]);
     },
     get absolutePluginRoot() {
-      if (_optionalChain([options, 'access', _387 => _387.config, 'access', _388 => _388.weapp, 'optionalAccess', _389 => _389.pluginRoot])) {
+      if (_optionalChain([options, 'access', _394 => _394.config, 'access', _395 => _395.weapp, 'optionalAccess', _396 => _396.pluginRoot])) {
         return _pathe2.default.resolve(options.cwd, options.config.weapp.pluginRoot);
       }
     },
@@ -23516,10 +23762,10 @@ function createJsonService(ctx) {
       }
       let resultJson;
       if (/app\.json(?:\.[jt]s)?$/.test(filepath)) {
-        await _optionalChain([ctx, 'access', _390 => _390.autoRoutesService, 'optionalAccess', _391 => _391.ensureFresh, 'call', _392 => _392()]);
+        await _optionalChain([ctx, 'access', _397 => _397.autoRoutesService, 'optionalAccess', _398 => _398.ensureFresh, 'call', _399 => _399()]);
       }
       if (/\.json\.[jt]s$/.test(filepath)) {
-        const routesReference = _optionalChain([ctx, 'access', _393 => _393.autoRoutesService, 'optionalAccess', _394 => _394.getReference, 'call', _395 => _395()]);
+        const routesReference = _optionalChain([ctx, 'access', _400 => _400.autoRoutesService, 'optionalAccess', _401 => _401.getReference, 'call', _402 => _402()]);
         const fallbackRoutes = _nullishCoalesce(routesReference, () => ( { pages: [], entries: [], subPackages: [] }));
         const routesModule = {
           routes: fallbackRoutes,
@@ -23568,7 +23814,7 @@ function createJsonService(ctx) {
       return resultJson;
     } catch (error) {
       logger_default.error(`\u6B8B\u7834\u7684JSON\u6587\u4EF6: ${filepath}`);
-      _optionalChain([debug, 'optionalCall', _396 => _396(error)]);
+      _optionalChain([debug, 'optionalCall', _403 => _403(error)]);
     }
   }
   function resolve8(entry) {
@@ -23620,7 +23866,7 @@ function createNpmService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before writing npm cache");
     }
-    if (_optionalChain([ctx, 'access', _397 => _397.configService, 'access', _398 => _398.weappViteConfig, 'optionalAccess', _399 => _399.npm, 'optionalAccess', _400 => _400.cache])) {
+    if (_optionalChain([ctx, 'access', _404 => _404.configService, 'access', _405 => _405.weappViteConfig, 'optionalAccess', _406 => _406.npm, 'optionalAccess', _407 => _407.cache])) {
       await _fsextra2.default.outputJSON(getDependenciesCacheFilePath(root), {
         hash: dependenciesCacheHash()
       });
@@ -23633,7 +23879,7 @@ function createNpmService(ctx) {
     }
   }
   async function checkDependenciesCacheOutdate(root) {
-    if (_optionalChain([ctx, 'access', _401 => _401.configService, 'optionalAccess', _402 => _402.weappViteConfig, 'optionalAccess', _403 => _403.npm, 'optionalAccess', _404 => _404.cache])) {
+    if (_optionalChain([ctx, 'access', _408 => _408.configService, 'optionalAccess', _409 => _409.weappViteConfig, 'optionalAccess', _410 => _410.npm, 'optionalAccess', _411 => _411.cache])) {
       const json = await readDependenciesCache(root);
       if (_shared.isObject.call(void 0, json)) {
         return dependenciesCacheHash() !== json.hash;
@@ -23667,7 +23913,7 @@ function createNpmService(ctx) {
       target: "es6",
       external: []
     });
-    const resolvedOptions = _optionalChain([ctx, 'access', _405 => _405.configService, 'optionalAccess', _406 => _406.weappViteConfig, 'optionalAccess', _407 => _407.npm, 'optionalAccess', _408 => _408.buildOptions, 'optionalCall', _409 => _409(
+    const resolvedOptions = _optionalChain([ctx, 'access', _412 => _412.configService, 'optionalAccess', _413 => _413.weappViteConfig, 'optionalAccess', _414 => _414.npm, 'optionalAccess', _415 => _415.buildOptions, 'optionalCall', _416 => _416(
       mergedOptions,
       { name, entry }
     )]);
@@ -23755,7 +24001,7 @@ function createNpmService(ctx) {
       throw new Error("configService must be initialized before resolving npm relation list");
     }
     let packNpmRelationList = [];
-    if (_optionalChain([ctx, 'access', _410 => _410.configService, 'access', _411 => _411.projectConfig, 'access', _412 => _412.setting, 'optionalAccess', _413 => _413.packNpmManually]) && Array.isArray(ctx.configService.projectConfig.setting.packNpmRelationList)) {
+    if (_optionalChain([ctx, 'access', _417 => _417.configService, 'access', _418 => _418.projectConfig, 'access', _419 => _419.setting, 'optionalAccess', _420 => _420.packNpmManually]) && Array.isArray(ctx.configService.projectConfig.setting.packNpmRelationList)) {
       packNpmRelationList = ctx.configService.projectConfig.setting.packNpmRelationList;
     } else {
       packNpmRelationList = [
@@ -23768,10 +24014,10 @@ function createNpmService(ctx) {
     return packNpmRelationList;
   }
   async function build4(options) {
-    if (!_optionalChain([ctx, 'access', _414 => _414.configService, 'optionalAccess', _415 => _415.weappViteConfig, 'optionalAccess', _416 => _416.npm, 'optionalAccess', _417 => _417.enable])) {
+    if (!_optionalChain([ctx, 'access', _421 => _421.configService, 'optionalAccess', _422 => _422.weappViteConfig, 'optionalAccess', _423 => _423.npm, 'optionalAccess', _424 => _424.enable])) {
       return;
     }
-    _optionalChain([debug, 'optionalCall', _418 => _418("buildNpm start")]);
+    _optionalChain([debug, 'optionalCall', _425 => _425("buildNpm start")]);
     const packNpmRelationList = getPackNpmRelationList();
     const [mainRelation, ...subRelations] = packNpmRelationList;
     const packageJsonPath = _pathe2.default.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
@@ -23846,7 +24092,7 @@ function createNpmService(ctx) {
         }
       }
     }
-    _optionalChain([debug, 'optionalCall', _419 => _419("buildNpm end")]);
+    _optionalChain([debug, 'optionalCall', _426 => _426("buildNpm end")]);
   }
   return {
     getDependenciesCacheFilePath,
@@ -23890,7 +24136,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', _420 => _420.captureStackTrace, 'optionalCall', _421 => _421(this, _TimeoutError)]);
+    _optionalChain([Error, 'access', _427 => _427.captureStackTrace, 'optionalCall', _428 => _428(this, _TimeoutError)]);
   }
 }, _class16);
 var getAbortedReason = (signal) => _nullishCoalesce(signal.reason, () => ( new DOMException("This operation was aborted.", "AbortError")));
@@ -23908,7 +24154,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', _422 => _422.aborted])) {
+    if (_optionalChain([signal, 'optionalAccess', _429 => _429.aborted])) {
       reject(getAbortedReason(signal));
       return;
     }
@@ -24006,7 +24252,7 @@ var PriorityQueue = class {
   }
   dequeue() {
     const item = this.#queue.shift();
-    return _optionalChain([item, 'optionalAccess', _423 => _423.run]);
+    return _optionalChain([item, 'optionalAccess', _430 => _430.run]);
   }
   filter(options) {
     return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
@@ -24067,10 +24313,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', _424 => _424.intervalCap, 'optionalAccess', _425 => _425.toString, 'call', _426 => _426()]), () => ( ""))}\` (${typeof options.intervalCap})`);
+      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${_nullishCoalesce(_optionalChain([options, 'access', _431 => _431.intervalCap, 'optionalAccess', _432 => _432.toString, 'call', _433 => _433()]), () => ( ""))}\` (${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', _427 => _427.interval, 'optionalAccess', _428 => _428.toString, 'call', _429 => _429()]), () => ( ""))}\` (${typeof options.interval})`);
+      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${_nullishCoalesce(_optionalChain([options, 'access', _434 => _434.interval, 'optionalAccess', _435 => _435.toString, 'call', _436 => _436()]), () => ( ""))}\` (${typeof options.interval})`);
     }
     this.#carryoverIntervalCount = _nullishCoalesce(_nullishCoalesce(options.carryoverIntervalCount, () => ( options.carryoverConcurrencyCount)), () => ( false));
     this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
@@ -24277,7 +24523,7 @@ var PQueue = class extends import_index2.default {
         });
         try {
           try {
-            _optionalChain([options, 'access', _430 => _430.signal, 'optionalAccess', _431 => _431.throwIfAborted, 'call', _432 => _432()]);
+            _optionalChain([options, 'access', _437 => _437.signal, 'optionalAccess', _438 => _438.throwIfAborted, 'call', _439 => _439()]);
           } catch (error) {
             if (!this.#isIntervalIgnored) {
               this.#intervalCount--;
@@ -24650,7 +24896,7 @@ var FileCache = class {
       return true;
     }
     const cachedMtime = this.mtimeMap.get(id);
-    const nextSignature = _optionalChain([options, 'optionalAccess', _433 => _433.content]) !== void 0 ? createSignature(options.content) : void 0;
+    const nextSignature = _optionalChain([options, 'optionalAccess', _440 => _440.content]) !== void 0 ? createSignature(options.content) : void 0;
     const updateSignature = () => {
       if (nextSignature !== void 0) {
         this.signatureMap.set(id, nextSignature);
@@ -24857,7 +25103,7 @@ function createScanService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before scanning subpackages");
     }
-    const json = _optionalChain([scanState, 'access', _434 => _434.appEntry, 'optionalAccess', _435 => _435.json]);
+    const json = _optionalChain([scanState, 'access', _441 => _441.appEntry, 'optionalAccess', _442 => _442.json]);
     if (scanState.isDirty || subPackageMap.size === 0) {
       subPackageMap.clear();
       independentSubPackageMap.clear();
@@ -24875,9 +25121,9 @@ function createScanService(ctx) {
             subPackage,
             entries: resolveSubPackageEntries(subPackage)
           };
-          const subPackageConfig = _optionalChain([ctx, 'access', _436 => _436.configService, 'access', _437 => _437.weappViteConfig, 'optionalAccess', _438 => _438.subPackages, 'optionalAccess', _439 => _439[subPackage.root]]);
-          meta.subPackage.dependencies = _optionalChain([subPackageConfig, 'optionalAccess', _440 => _440.dependencies]);
-          meta.subPackage.inlineConfig = _optionalChain([subPackageConfig, 'optionalAccess', _441 => _441.inlineConfig]);
+          const subPackageConfig = _optionalChain([ctx, 'access', _443 => _443.configService, 'access', _444 => _444.weappViteConfig, 'optionalAccess', _445 => _445.subPackages, 'optionalAccess', _446 => _446[subPackage.root]]);
+          meta.subPackage.dependencies = _optionalChain([subPackageConfig, 'optionalAccess', _447 => _447.dependencies]);
+          meta.subPackage.inlineConfig = _optionalChain([subPackageConfig, 'optionalAccess', _448 => _448.inlineConfig]);
           metas.push(meta);
           if (subPackage.root) {
             subPackageMap.set(subPackage.root, meta);
@@ -24927,11 +25173,11 @@ function createScanService(ctx) {
     loadSubPackages,
     isMainPackageFileName,
     get workersOptions() {
-      return _optionalChain([scanState, 'access', _442 => _442.appEntry, 'optionalAccess', _443 => _443.json, 'optionalAccess', _444 => _444.workers]);
+      return _optionalChain([scanState, 'access', _449 => _449.appEntry, 'optionalAccess', _450 => _450.json, 'optionalAccess', _451 => _451.workers]);
     },
     get workersDir() {
-      const workersOptions = _optionalChain([scanState, 'access', _445 => _445.appEntry, 'optionalAccess', _446 => _446.json, 'optionalAccess', _447 => _447.workers]);
-      return typeof workersOptions === "object" ? _optionalChain([workersOptions, 'optionalAccess', _448 => _448.path]) : workersOptions;
+      const workersOptions = _optionalChain([scanState, 'access', _452 => _452.appEntry, 'optionalAccess', _453 => _453.json, 'optionalAccess', _454 => _454.workers]);
+      return typeof workersOptions === "object" ? _optionalChain([workersOptions, 'optionalAccess', _455 => _455.path]) : workersOptions;
     },
     markDirty() {
       scanState.isDirty = true;
@@ -24977,7 +25223,7 @@ function createWatcherService(ctx) {
     },
     setRollupWatcher(watcher, root = "/") {
       const oldWatcher = rollupWatcherMap.get(root);
-      _optionalChain([oldWatcher, 'optionalAccess', _449 => _449.close, 'call', _450 => _450()]);
+      _optionalChain([oldWatcher, 'optionalAccess', _456 => _456.close, 'call', _457 => _457()]);
       rollupWatcherMap.set(root, watcher);
     },
     closeAll() {
@@ -24990,7 +25236,7 @@ function createWatcherService(ctx) {
         });
       });
       sidecarWatcherMap.clear();
-      void _optionalChain([ctx, 'access', _451 => _451.webService, 'optionalAccess', _452 => _452.close, 'call', _453 => _453(), 'access', _454 => _454.catch, 'call', _455 => _455(() => {
+      void _optionalChain([ctx, 'access', _458 => _458.webService, 'optionalAccess', _459 => _459.close, 'call', _460 => _460(), 'access', _461 => _461.catch, 'call', _462 => _462(() => {
       })]);
     },
     close(root = "/") {
@@ -25006,7 +25252,7 @@ function createWatcherService(ctx) {
         sidecarWatcherMap.delete(root);
       }
       if (rollupWatcherMap.size === 0 && sidecarWatcherMap.size === 0) {
-        void _optionalChain([ctx, 'access', _456 => _456.webService, 'optionalAccess', _457 => _457.close, 'call', _458 => _458(), 'access', _459 => _459.catch, 'call', _460 => _460(() => {
+        void _optionalChain([ctx, 'access', _463 => _463.webService, 'optionalAccess', _464 => _464.close, 'call', _465 => _465(), 'access', _466 => _466.catch, 'call', _467 => _467(() => {
         })]);
       }
     }
@@ -25019,7 +25265,7 @@ function createWatcherServicePlugin(ctx) {
     name: "weapp-runtime:watcher-service",
     closeBundle() {
       const configService = ctx.configService;
-      const isWatchMode = _optionalChain([configService, 'optionalAccess', _461 => _461.isDev]) || Boolean(_optionalChain([configService, 'optionalAccess', _462 => _462.inlineConfig, 'optionalAccess', _463 => _463.build, 'optionalAccess', _464 => _464.watch]));
+      const isWatchMode = _optionalChain([configService, 'optionalAccess', _468 => _468.isDev]) || Boolean(_optionalChain([configService, 'optionalAccess', _469 => _469.inlineConfig, 'optionalAccess', _470 => _470.build, 'optionalAccess', _471 => _471.watch]));
       if (!isWatchMode) {
         service.closeAll();
       }
@@ -25036,10 +25282,10 @@ function createWebService(ctx) {
   }
   let devServer;
   function isEnabled() {
-    return Boolean(_optionalChain([ctx, 'access', _465 => _465.configService, 'optionalAccess', _466 => _466.weappWebConfig, 'optionalAccess', _467 => _467.enabled]));
+    return Boolean(_optionalChain([ctx, 'access', _472 => _472.configService, 'optionalAccess', _473 => _473.weappWebConfig, 'optionalAccess', _474 => _474.enabled]));
   }
   async function startDevServer() {
-    if (!_optionalChain([ctx, 'access', _468 => _468.configService, 'optionalAccess', _469 => _469.isDev])) {
+    if (!_optionalChain([ctx, 'access', _475 => _475.configService, 'optionalAccess', _476 => _476.isDev])) {
       return void 0;
     }
     if (!isEnabled()) {
@@ -25048,7 +25294,7 @@ function createWebService(ctx) {
     if (devServer) {
       return devServer;
     }
-    const inlineConfig = _optionalChain([ctx, 'access', _470 => _470.configService, 'optionalAccess', _471 => _471.mergeWeb, 'call', _472 => _472()]);
+    const inlineConfig = _optionalChain([ctx, 'access', _477 => _477.configService, 'optionalAccess', _478 => _478.mergeWeb, 'call', _479 => _479()]);
     if (!inlineConfig) {
       return void 0;
     }
@@ -25061,7 +25307,7 @@ function createWebService(ctx) {
     if (!isEnabled()) {
       return void 0;
     }
-    const inlineConfig = _optionalChain([ctx, 'access', _473 => _473.configService, 'optionalAccess', _474 => _474.mergeWeb, 'call', _475 => _475()]);
+    const inlineConfig = _optionalChain([ctx, 'access', _480 => _480.configService, 'optionalAccess', _481 => _481.mergeWeb, 'call', _482 => _482()]);
     if (!inlineConfig) {
       return void 0;
     }
@@ -25091,7 +25337,7 @@ function createWebServicePlugin(ctx) {
   return {
     name: "weapp-runtime:web-service",
     async closeBundle() {
-      if (!_optionalChain([ctx, 'access', _476 => _476.configService, 'optionalAccess', _477 => _477.isDev])) {
+      if (!_optionalChain([ctx, 'access', _483 => _483.configService, 'optionalAccess', _484 => _484.isDev])) {
         await service.close();
       }
     }
@@ -27740,7 +27986,7 @@ function createWxmlService(ctx) {
     return set3;
   }
   function clearAll() {
-    const currentRoot = _optionalChain([ctx, 'access', _478 => _478.configService, 'optionalAccess', _479 => _479.currentSubPackageRoot]);
+    const currentRoot = _optionalChain([ctx, 'access', _485 => _485.configService, 'optionalAccess', _486 => _486.currentSubPackageRoot]);
     if (!currentRoot) {
       depsMap.clear();
       tokenMap.clear();
@@ -27793,7 +28039,7 @@ function createWxmlService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before scanning wxml");
     }
-    const wxmlConfig = _nullishCoalesce(_optionalChain([ctx, 'access', _480 => _480.configService, 'access', _481 => _481.weappViteConfig, 'optionalAccess', _482 => _482.wxml]), () => ( _optionalChain([ctx, 'access', _483 => _483.configService, 'access', _484 => _484.weappViteConfig, 'optionalAccess', _485 => _485.enhance, 'optionalAccess', _486 => _486.wxml])));
+    const wxmlConfig = _nullishCoalesce(_optionalChain([ctx, 'access', _487 => _487.configService, 'access', _488 => _488.weappViteConfig, 'optionalAccess', _489 => _489.wxml]), () => ( _optionalChain([ctx, 'access', _490 => _490.configService, 'access', _491 => _491.weappViteConfig, 'optionalAccess', _492 => _492.enhance, 'optionalAccess', _493 => _493.wxml])));
     return scanWxml(wxml, {
       platform: ctx.configService.platform,
       ...wxmlConfig === true ? {} : wxmlConfig