weapp-vite 5.2.3 → 5.3.0

package/dist/{chunk-GMCAZZQY.cjs → chunk-N2SUN4MX.cjs}

@@ -916,13 +916,55 @@ function checkRuntime(minVersions) {
   }
 }
 
+// src/utils/weappConfig.ts
+_chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var _pathe = require('pathe'); var _pathe2 = _interopRequireDefault(_pathe);
+var WEAPP_VITE_CONFIG_CANDIDATES = [
+  "weapp-vite.config.ts",
+  "weapp-vite.config.mts",
+  "weapp-vite.config.cts",
+  "weapp-vite.config.js",
+  "weapp-vite.config.mjs",
+  "weapp-vite.config.cjs",
+  "weapp-vite.config.json"
+];
+var WEAPP_VITE_CONFIG_SET = new Set(WEAPP_VITE_CONFIG_CANDIDATES);
+async function findWeappConfigInDirectory(directory) {
+  for (const filename of WEAPP_VITE_CONFIG_CANDIDATES) {
+    const candidatePath = _pathe2.default.resolve(directory, filename);
+    if (await _fsextra2.default.pathExists(candidatePath)) {
+      return candidatePath;
+    }
+  }
+  return void 0;
+}
+async function resolveWeappConfigFile(options) {
+  const { root, specified } = options;
+  if (specified) {
+    const resolvedSpecified = _pathe2.default.isAbsolute(specified) ? specified : _pathe2.default.resolve(root, specified);
+    const specifiedBaseName = _pathe2.default.basename(resolvedSpecified);
+    if (WEAPP_VITE_CONFIG_SET.has(specifiedBaseName)) {
+      if (await _fsextra2.default.pathExists(resolvedSpecified)) {
+        return resolvedSpecified;
+      }
+      return void 0;
+    }
+    const fromSpecifiedDirectory = await findWeappConfigInDirectory(_pathe2.default.dirname(resolvedSpecified));
+    if (fromSpecifiedDirectory) {
+      return fromSpecifiedDirectory;
+    }
+  }
+  return findWeappConfigInDirectory(root);
+}
+
 // src/utils/index.ts
 _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
 
 // src/utils/file.ts
 _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
-var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
-var _pathe = require('pathe'); var _pathe2 = _interopRequireDefault(_pathe);
+
+
 function isJsOrTs(name) {
   if (typeof name === "string") {
     return /\.[jt]s$/.test(name);
@@ -1171,6 +1213,7 @@ _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
 _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
 
 
+
 // ../../node_modules/.pnpm/lru-cache@11.2.2/node_modules/lru-cache/dist/esm/index.js
 _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
 var defaultPerf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
@@ -2574,6 +2617,7 @@ var LRUCache = (_class4 = class _LRUCache {
 }, _class4);
 
 // src/runtime/autoImportPlugin.ts
+
 var _picomatch = require('picomatch'); var _picomatch2 = _interopRequireDefault(_picomatch);
 
 // src/context/shared.ts
@@ -2636,6 +2680,96 @@ function logWarnOnce(message) {
 function createAutoImportService(ctx) {
   const autoImportState = ctx.runtimeState.autoImport;
   const registry = autoImportState.registry;
+  const manifestFileName = "auto-import-components.json";
+  let pendingWrite;
+  let writeRequested = false;
+  function resolveManifestOutputPath() {
+    const configService = ctx.configService;
+    if (!configService) {
+      return void 0;
+    }
+    const autoImportConfig = _optionalChain([configService, 'access', _63 => _63.weappViteConfig, 'optionalAccess', _64 => _64.enhance, 'optionalAccess', _65 => _65.autoImportComponents]);
+    if (!autoImportConfig) {
+      return void 0;
+    }
+    const baseDir = (() => {
+      const configFilePath = configService.configFilePath;
+      if (configFilePath) {
+        return _pathe2.default.dirname(configFilePath);
+      }
+      return configService.cwd;
+    })();
+    const outputOption = autoImportConfig.output;
+    if (outputOption === false) {
+      return void 0;
+    }
+    if (typeof outputOption === "string" && outputOption.length > 0) {
+      return _pathe2.default.isAbsolute(outputOption) ? outputOption : _pathe2.default.resolve(baseDir, outputOption);
+    }
+    return _pathe2.default.resolve(baseDir, manifestFileName);
+  }
+  function collectResolverComponents() {
+    const resolvers = _optionalChain([ctx, 'access', _66 => _66.configService, 'optionalAccess', _67 => _67.weappViteConfig, 'optionalAccess', _68 => _68.enhance, 'optionalAccess', _69 => _69.autoImportComponents, 'optionalAccess', _70 => _70.resolvers]);
+    if (!Array.isArray(resolvers)) {
+      return {};
+    }
+    const entries = [];
+    for (const resolver of resolvers) {
+      const map = _optionalChain([resolver, 'optionalAccess', _71 => _71.components]);
+      if (!map) {
+        continue;
+      }
+      for (const [name, from] of Object.entries(map)) {
+        entries.push([name, from]);
+      }
+    }
+    return Object.fromEntries(entries);
+  }
+  async function writeManifestFile(outputPath) {
+    const resolverEntries = Object.entries(collectResolverComponents());
+    const localEntries = Array.from(registry.entries()).filter((entry) => entry[1].kind === "local");
+    const manifestMap = /* @__PURE__ */ new Map();
+    for (const [componentName, from] of resolverEntries) {
+      manifestMap.set(componentName, from);
+    }
+    for (const [componentName, match2] of localEntries) {
+      manifestMap.set(componentName, match2.value.from);
+    }
+    const manifest = Object.fromEntries(
+      Array.from(manifestMap.entries()).sort(([a], [b]) => a.localeCompare(b))
+    );
+    await _fsextra2.default.outputJson(outputPath, manifest, { spaces: 2 });
+  }
+  function scheduleManifestWrite(shouldWrite) {
+    if (!shouldWrite) {
+      return;
+    }
+    const configService = ctx.configService;
+    if (!_optionalChain([configService, 'optionalAccess', _72 => _72.weappViteConfig, 'optionalAccess', _73 => _73.enhance, 'optionalAccess', _74 => _74.autoImportComponents])) {
+      return;
+    }
+    writeRequested = true;
+    if (pendingWrite) {
+      return;
+    }
+    pendingWrite = Promise.resolve().then(async () => {
+      while (writeRequested) {
+        writeRequested = false;
+        const outputPath = resolveManifestOutputPath();
+        if (!outputPath) {
+          return;
+        }
+        try {
+          await writeManifestFile(outputPath);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          logger_default.error(`\u81EA\u52A8\u5BFC\u51FA\u7EC4\u4EF6\u6E05\u5355\u5931\u8D25: ${message}`);
+        }
+      }
+    }).finally(() => {
+      pendingWrite = void 0;
+    });
+  }
   async function registerLocalComponent(filePath) {
     if (!ctx.configService || !ctx.jsonService) {
       throw new Error("configService/jsonService must be initialized before scanning components");
@@ -2646,26 +2780,30 @@ function createAutoImportService(ctx) {
       findJsonEntry(baseName),
       findTemplateEntry(baseName)
     ]);
-    removeRegisteredComponent({
+    const removed = removeRegisteredComponent({
       baseName,
       templatePath,
       jsEntry,
       jsonPath
     });
     if (!jsEntry || !jsonPath || !templatePath) {
+      scheduleManifestWrite(removed);
       return;
     }
     const json = await ctx.jsonService.read(jsonPath);
-    if (!_optionalChain([json, 'optionalAccess', _63 => _63.component])) {
+    if (!_optionalChain([json, 'optionalAccess', _75 => _75.component])) {
+      scheduleManifestWrite(removed);
       return;
     }
     const { componentName, base } = resolvedComponentName(baseName);
     if (!componentName) {
+      scheduleManifestWrite(removed);
       return;
     }
     const hasComponent = registry.has(componentName);
     if (hasComponent && base !== "index") {
       logWarnOnce(`\u53D1\u73B0 \`${componentName}\` \u7EC4\u4EF6\u91CD\u540D! \u8DF3\u8FC7\u7EC4\u4EF6 \`${ctx.configService.relativeCwd(baseName)}\` \u7684\u81EA\u52A8\u5F15\u5165`);
+      scheduleManifestWrite(removed);
       return;
     }
     const sourceWithoutExt = _shared.removeExtensionDeep.call(void 0, jsonPath);
@@ -2686,9 +2824,11 @@ function createAutoImportService(ctx) {
         from
       }
     });
+    scheduleManifestWrite(true);
   }
   function removeRegisteredComponent(paths) {
     const { baseName, templatePath, jsEntry, jsonPath } = paths;
+    let removed = false;
     for (const [key, value] of registry) {
       if (value.kind !== "local") {
         continue;
@@ -2698,15 +2838,16 @@ function createAutoImportService(ctx) {
         templatePath && entry.templatePath === templatePath || jsonPath && entry.jsonPath === jsonPath || jsEntry && entry.path === jsEntry || baseName && _shared.removeExtensionDeep.call(void 0, entry.templatePath) === baseName || baseName && _shared.removeExtensionDeep.call(void 0, entry.path) === baseName || baseName && _shared.removeExtensionDeep.call(void 0, _nullishCoalesce(entry.jsonPath, () => ( ""))) === baseName
       );
       if (matches2) {
-        registry.delete(key);
+        removed = registry.delete(key) || removed;
       }
     }
+    return removed;
   }
   function ensureMatcher() {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before filtering components");
     }
-    const globs = _optionalChain([ctx, 'access', _64 => _64.configService, 'access', _65 => _65.weappViteConfig, 'optionalAccess', _66 => _66.enhance, 'optionalAccess', _67 => _67.autoImportComponents, 'optionalAccess', _68 => _68.globs]);
+    const globs = _optionalChain([ctx, 'access', _76 => _76.configService, 'access', _77 => _77.weappViteConfig, 'optionalAccess', _78 => _78.enhance, 'optionalAccess', _79 => _79.autoImportComponents, 'optionalAccess', _80 => _80.globs]);
     if (!globs || globs.length === 0) {
       autoImportState.matcher = void 0;
       autoImportState.matcherKey = "";
@@ -2724,7 +2865,7 @@ function createAutoImportService(ctx) {
     return autoImportState.matcher;
   }
   function resolveWithResolvers(componentName, importerBaseName) {
-    const resolvers = _optionalChain([ctx, 'access', _69 => _69.configService, 'optionalAccess', _70 => _70.weappViteConfig, 'optionalAccess', _71 => _71.enhance, 'optionalAccess', _72 => _72.autoImportComponents, 'optionalAccess', _73 => _73.resolvers]);
+    const resolvers = _optionalChain([ctx, 'access', _81 => _81.configService, 'optionalAccess', _82 => _82.weappViteConfig, 'optionalAccess', _83 => _83.enhance, 'optionalAccess', _84 => _84.autoImportComponents, 'optionalAccess', _85 => _85.resolvers]);
     if (!Array.isArray(resolvers)) {
       return void 0;
     }
@@ -2744,15 +2885,17 @@ function createAutoImportService(ctx) {
       registry.clear();
       autoImportState.matcher = void 0;
       autoImportState.matcherKey = "";
+      scheduleManifestWrite(true);
     },
     async registerPotentialComponent(filePath) {
       await registerLocalComponent(filePath);
     },
     removePotentialComponent(filePath) {
-      removeRegisteredComponent({
+      const removed = removeRegisteredComponent({
         baseName: _shared.removeExtensionDeep.call(void 0, filePath),
         templatePath: filePath
       });
+      scheduleManifestWrite(removed);
     },
     resolve(componentName, importerBaseName) {
       const local = registry.get(componentName);
@@ -2770,6 +2913,9 @@ function createAutoImportService(ctx) {
     },
     getRegisteredLocalComponents() {
       return Array.from(registry.values());
+    },
+    awaitManifestWrites() {
+      return _nullishCoalesce(pendingWrite, () => ( Promise.resolve()));
     }
   };
 }
@@ -2863,7 +3009,7 @@ var ReaddirpStream = class extends _stream.Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? _promises.lstat : _promises.stat;
     if (wantBigintFsStats) {
-      this._stat = (path25) => statMethod(path25, { bigint: true });
+      this._stat = (path27) => statMethod(path27, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -2888,8 +3034,8 @@ var ReaddirpStream = class extends _stream.Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path25, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path25));
+          const { path: path27, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path27));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -2929,20 +3075,20 @@ var ReaddirpStream = class extends _stream.Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path25, depth) {
+  async _exploreDir(path27, depth) {
     let files;
     try {
-      files = await _promises.readdir.call(void 0, path25, this._rdOptions);
+      files = await _promises.readdir.call(void 0, path27, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path25 };
+    return { files, depth, path: path27 };
   }
-  async _formatEntry(dirent, path25) {
+  async _formatEntry(dirent, path27) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = _path.resolve.call(void 0, _path.join.call(void 0, path25, basename4));
+      const fullPath = _path.resolve.call(void 0, _path.join.call(void 0, path27, basename4));
       entry = { path: _path.relative.call(void 0, this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -3343,16 +3489,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path25, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path27, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path25);
-    emitRaw(rawEvent, evPath, { watchedPath: path25 });
-    if (evPath && path25 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path25, evPath), KEY_LISTENERS, sysPath.join(path25, evPath));
+    listener(path27);
+    emitRaw(rawEvent, evPath, { watchedPath: path27 });
+    if (evPath && path27 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path27, evPath), KEY_LISTENERS, sysPath.join(path27, evPath));
     }
   };
   try {
-    return _fs.watch.call(void 0, path25, {
+    return _fs.watch.call(void 0, path27, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -3368,12 +3514,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path25, fullPath, options, handlers) => {
+var setFsWatchListener = (path27, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path25, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path27, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -3384,7 +3530,7 @@ var setFsWatchListener = (path25, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path25,
+      path27,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -3399,7 +3545,7 @@ var setFsWatchListener = (path25, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await _promises.open.call(void 0, path25, "r");
+          const fd = await _promises.open.call(void 0, path27, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -3430,7 +3576,7 @@ var setFsWatchListener = (path25, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path25, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path27, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -3452,7 +3598,7 @@ var setFsWatchFileListener = (path25, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path25, curr));
+          foreach(cont.listeners, (listener2) => listener2(path27, curr));
         }
       })
     };
@@ -3480,13 +3626,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path25, listener) {
+  _watchWithNodeFs(path27, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path25);
-    const basename4 = sysPath.basename(path25);
+    const directory = sysPath.dirname(path27);
+    const basename4 = sysPath.basename(path27);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename4);
-    const absolutePath = sysPath.resolve(path25);
+    const absolutePath = sysPath.resolve(path27);
     const options = {
       persistent: opts.persistent
     };
@@ -3496,12 +3642,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path25, absolutePath, options, {
+      closer = setFsWatchFileListener(path27, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path25, absolutePath, options, {
+      closer = setFsWatchListener(path27, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -3523,7 +3669,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename4))
       return;
-    const listener = async (path25, newStats) => {
+    const listener = async (path27, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -3537,11 +3683,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path25);
+            this.fsw._closeFile(path27);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path25, closer2);
+              this.fsw._addPathCloser(path27, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -3573,7 +3719,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, path25, item) {
+  async _handleSymlink(entry, directory, path27, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -3583,7 +3729,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await _promises.realpath.call(void 0, path25);
+        linkPath = await _promises.realpath.call(void 0, path27);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -3593,12 +3739,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, path25, entry.stats);
+          this.fsw._emit(EV.CHANGE, path27, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path25, entry.stats);
+        this.fsw._emit(EV.ADD, path27, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -3627,9 +3773,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path25 = sysPath.join(directory, item);
+      let path27 = sysPath.join(directory, item);
       current2.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path25, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path27, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -3638,8 +3784,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path25 = sysPath.join(dir, sysPath.relative(dir, path25));
-        this._addToNodeFs(path25, initialAdd, wh, depth + 1);
+        path27 = sysPath.join(dir, sysPath.relative(dir, path27));
+        this._addToNodeFs(path27, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve8, reject) => {
@@ -3708,13 +3854,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path25, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path27, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path25) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path27) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path25);
+    const wh = this.fsw._getWatchHelpers(path27);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -3730,8 +3876,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path25);
-        const targetPath = follow ? await _promises.realpath.call(void 0, path25) : path25;
+        const absPath = sysPath.resolve(path27);
+        const targetPath = follow ? await _promises.realpath.call(void 0, path27) : path27;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -3741,29 +3887,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await _promises.realpath.call(void 0, path25) : path25;
+        const targetPath = follow ? await _promises.realpath.call(void 0, path27) : path27;
         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, path25, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path27, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path25), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path27), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path25, closer);
+        this.fsw._addPathCloser(path27, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path25;
+        return path27;
       }
     }
   }
@@ -3806,26 +3952,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path25) {
-  if (typeof path25 !== "string")
+function normalizePath(path27) {
+  if (typeof path27 !== "string")
     throw new Error("string expected");
-  path25 = sysPath2.normalize(path25);
-  path25 = path25.replace(/\\/g, "/");
+  path27 = sysPath2.normalize(path27);
+  path27 = path27.replace(/\\/g, "/");
   let prepend = false;
-  if (path25.startsWith("//"))
+  if (path27.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path25.match(DOUBLE_SLASH_RE2))
-    path25 = path25.replace(DOUBLE_SLASH_RE2, "/");
+  while (path27.match(DOUBLE_SLASH_RE2))
+    path27 = path27.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path25 = "/" + path25;
-  return path25;
+    path27 = "/" + path27;
+  return path27;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path25 = normalizePath(testString);
+  const path27 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path25, stats)) {
+    if (pattern(path27, stats)) {
       return true;
     }
   }
@@ -3865,19 +4011,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path25) => toUnix(sysPath2.normalize(toUnix(path25)));
-var normalizeIgnored = (cwd = "") => (path25) => {
-  if (typeof path25 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path25) ? path25 : sysPath2.join(cwd, path25));
+var normalizePathToUnix = (path27) => toUnix(sysPath2.normalize(toUnix(path27)));
+var normalizeIgnored = (cwd = "") => (path27) => {
+  if (typeof path27 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path27) ? path27 : sysPath2.join(cwd, path27));
   } else {
-    return path25;
+    return path27;
   }
 };
-var getAbsolutePath = (path25, cwd) => {
-  if (sysPath2.isAbsolute(path25)) {
-    return path25;
+var getAbsolutePath = (path27, cwd) => {
+  if (sysPath2.isAbsolute(path27)) {
+    return path27;
   }
-  return sysPath2.join(cwd, path25);
+  return sysPath2.join(cwd, path27);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -3932,10 +4078,10 @@ var DirEntry = class {
 var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 var WatchHelper = class {
-  constructor(path25, follow, fsw) {
+  constructor(path27, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path25;
-    this.path = path25 = path25.replace(REPLACER_RE, "");
+    const watchPath = path27;
+    this.path = path27 = path27.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -4057,20 +4203,20 @@ var FSWatcher = class extends _events2.EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path25) => {
-        const absPath = getAbsolutePath(path25, cwd);
+      paths = paths.map((path27) => {
+        const absPath = getAbsolutePath(path27, cwd);
         return absPath;
       });
     }
-    paths.forEach((path25) => {
-      this._removeIgnoredPath(path25);
+    paths.forEach((path27) => {
+      this._removeIgnoredPath(path27);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path25) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path25, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path27) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path27, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -4092,17 +4238,17 @@ var FSWatcher = class extends _events2.EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path25) => {
-      if (!sysPath2.isAbsolute(path25) && !this._closers.has(path25)) {
+    paths.forEach((path27) => {
+      if (!sysPath2.isAbsolute(path27) && !this._closers.has(path27)) {
         if (cwd)
-          path25 = sysPath2.join(cwd, path25);
-        path25 = sysPath2.resolve(path25);
+          path27 = sysPath2.join(cwd, path27);
+        path27 = sysPath2.resolve(path27);
       }
-      this._closePath(path25);
-      this._addIgnoredPath(path25);
-      if (this._watched.has(path25)) {
+      this._closePath(path27);
+      this._addIgnoredPath(path27);
+      if (this._watched.has(path27)) {
         this._addIgnoredPath({
-          path: path25,
+          path: path27,
           recursive: true
         });
       }
@@ -4166,38 +4312,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, path25, stats) {
+  async _emit(event, path27, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path25 = sysPath2.normalize(path25);
+      path27 = sysPath2.normalize(path27);
     if (opts.cwd)
-      path25 = sysPath2.relative(opts.cwd, path25);
-    const args = [path25];
+      path27 = sysPath2.relative(opts.cwd, path27);
+    const args = [path27];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path25))) {
+    if (awf && (pw = this._pendingWrites.get(path27))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path25, [event, ...args]);
+        this._pendingUnlinks.set(path27, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path26) => {
+          this._pendingUnlinks.forEach((entry, path28) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path26);
+            this._pendingUnlinks.delete(path28);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path25)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path27)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path25);
+        this._pendingUnlinks.delete(path27);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -4215,16 +4361,16 @@ var FSWatcher = class extends _events2.EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path25, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path27, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path25, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path27, 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, path25) : path25;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path27) : path27;
       let stats2;
       try {
         stats2 = await _promises.stat.call(void 0, fullPath);
@@ -4255,23 +4401,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, path25, timeout) {
+  _throttle(actionType, path27, 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(path25);
+    const actionPath = action.get(path27);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path25);
+      const item = action.get(path27);
       const count = item ? item.count : 0;
-      action.delete(path25);
+      action.delete(path27);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -4279,7 +4425,7 @@ var FSWatcher = class extends _events2.EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path25, thr);
+    action.set(path27, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -4293,44 +4439,44 @@ var FSWatcher = class extends _events2.EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path25, threshold, event, awfEmit) {
+  _awaitWriteFinish(path27, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path25;
-    if (this.options.cwd && !sysPath2.isAbsolute(path25)) {
-      fullPath = sysPath2.join(this.options.cwd, path25);
+    let fullPath = path27;
+    if (this.options.cwd && !sysPath2.isAbsolute(path27)) {
+      fullPath = sysPath2.join(this.options.cwd, path27);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       _fs.stat.call(void 0, fullPath, (err, curStat) => {
-        if (err || !writes.has(path25)) {
+        if (err || !writes.has(path27)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path25).lastChange = now2;
+          writes.get(path27).lastChange = now2;
         }
-        const pw = writes.get(path25);
+        const pw = writes.get(path27);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path25);
+          writes.delete(path27);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path25)) {
-      writes.set(path25, {
+    if (!writes.has(path27)) {
+      writes.set(path27, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path25);
+          writes.delete(path27);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -4341,8 +4487,8 @@ var FSWatcher = class extends _events2.EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path25, stats) {
-    if (this.options.atomic && DOT_RE.test(path25))
+  _isIgnored(path27, stats) {
+    if (this.options.atomic && DOT_RE.test(path27))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -4352,17 +4498,17 @@ var FSWatcher = class extends _events2.EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path25, stats);
+    return this._userIgnored(path27, stats);
   }
-  _isntIgnored(path25, stat6) {
-    return !this._isIgnored(path25, stat6);
+  _isntIgnored(path27, stat6) {
+    return !this._isIgnored(path27, stat6);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path25) {
-    return new WatchHelper(path25, this.options.followSymlinks, this);
+  _getWatchHelpers(path27) {
+    return new WatchHelper(path27, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -4394,63 +4540,63 @@ var FSWatcher = class extends _events2.EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path25 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path25);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path25) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path25, 100))
+    const path27 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path27);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path27) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path27, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path25);
+    const wp = this._getWatchedDir(path27);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path25, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path27, 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 = path25;
+    let relPath = path27;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path25);
+      relPath = sysPath2.relative(this.options.cwd, path27);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path25);
+    this._watched.delete(path27);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path25))
-      this._emit(eventName, path25);
-    this._closePath(path25);
+    if (wasTracked && !this._isIgnored(path27))
+      this._emit(eventName, path27);
+    this._closePath(path27);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path25) {
-    this._closeFile(path25);
-    const dir = sysPath2.dirname(path25);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path25));
+  _closePath(path27) {
+    this._closeFile(path27);
+    const dir = sysPath2.dirname(path27);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path27));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path25) {
-    const closers = this._closers.get(path25);
+  _closeFile(path27) {
+    const closers = this._closers.get(path27);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path25);
+    this._closers.delete(path27);
   }
-  _addPathCloser(path25, closer) {
+  _addPathCloser(path27, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path25);
+    let list = this._closers.get(path27);
     if (!list) {
       list = [];
-      this._closers.set(path25, list);
+      this._closers.set(path27, list);
     }
     list.push(closer);
   }
@@ -4725,7 +4871,7 @@ var AST = class _AST {
     const ret = this.type === null ? this.#parts.slice().map((p) => typeof p === "string" ? p : p.toJSON()) : [this.type, ...this.#parts.map((p) => p.toJSON())];
     if (this.isStart() && !this.type)
       ret.unshift([]);
-    if (this.isEnd() && (this === this.#root || this.#root.#filledNegs && _optionalChain([this, 'access', _74 => _74.#parent, 'optionalAccess', _75 => _75.type]) === "!")) {
+    if (this.isEnd() && (this === this.#root || this.#root.#filledNegs && _optionalChain([this, 'access', _86 => _86.#parent, 'optionalAccess', _87 => _87.type]) === "!")) {
       ret.push({});
     }
     return ret;
@@ -4733,7 +4879,7 @@ var AST = class _AST {
   isStart() {
     if (this.#root === this)
       return true;
-    if (!_optionalChain([this, 'access', _76 => _76.#parent, 'optionalAccess', _77 => _77.isStart, 'call', _78 => _78()]))
+    if (!_optionalChain([this, 'access', _88 => _88.#parent, 'optionalAccess', _89 => _89.isStart, 'call', _90 => _90()]))
       return false;
     if (this.#parentIndex === 0)
       return true;
@@ -4749,12 +4895,12 @@ var AST = class _AST {
   isEnd() {
     if (this.#root === this)
       return true;
-    if (_optionalChain([this, 'access', _79 => _79.#parent, 'optionalAccess', _80 => _80.type]) === "!")
+    if (_optionalChain([this, 'access', _91 => _91.#parent, 'optionalAccess', _92 => _92.type]) === "!")
       return true;
-    if (!_optionalChain([this, 'access', _81 => _81.#parent, 'optionalAccess', _82 => _82.isEnd, 'call', _83 => _83()]))
+    if (!_optionalChain([this, 'access', _93 => _93.#parent, 'optionalAccess', _94 => _94.isEnd, 'call', _95 => _95()]))
       return false;
     if (!this.type)
-      return _optionalChain([this, 'access', _84 => _84.#parent, 'optionalAccess', _85 => _85.isEnd, 'call', _86 => _86()]);
+      return _optionalChain([this, 'access', _96 => _96.#parent, 'optionalAccess', _97 => _97.isEnd, 'call', _98 => _98()]);
     const pl2 = this.#parent ? this.#parent.#parts.length : 0;
     return this.#parentIndex === pl2 - 1;
   }
@@ -4999,7 +5145,7 @@ var AST = class _AST {
         }
       }
       let end = "";
-      if (this.isEnd() && this.#root.#filledNegs && _optionalChain([this, 'access', _87 => _87.#parent, 'optionalAccess', _88 => _88.type]) === "!") {
+      if (this.isEnd() && this.#root.#filledNegs && _optionalChain([this, 'access', _99 => _99.#parent, 'optionalAccess', _100 => _100.type]) === "!") {
         end = "(?:$|\\/)";
       }
       const final2 = start2 + src + end;
@@ -5167,11 +5313,11 @@ var qmarksTestNoExtDot = ([$0]) => {
   return (f) => f.length === len && f !== "." && f !== "..";
 };
 var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-var path5 = {
+var path7 = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep = defaultPlatform === "win32" ? path5.win32.sep : path5.posix.sep;
+var sep = defaultPlatform === "win32" ? path7.win32.sep : path7.posix.sep;
 minimatch.sep = sep;
 var GLOBSTAR = Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
@@ -6055,8 +6201,8 @@ var Minipass = (_class5 = class extends _events2.EventEmitter {
   // drop everything and get out of the flow completely
   [ABORT]() {
     this[ABORTED] = true;
-    this.emit("abort", _optionalChain([this, 'access', _89 => _89[SIGNAL], 'optionalAccess', _90 => _90.reason]));
-    this.destroy(_optionalChain([this, 'access', _91 => _91[SIGNAL], 'optionalAccess', _92 => _92.reason]));
+    this.emit("abort", _optionalChain([this, 'access', _101 => _101[SIGNAL], 'optionalAccess', _102 => _102.reason]));
+    this.destroy(_optionalChain([this, 'access', _103 => _103[SIGNAL], 'optionalAccess', _104 => _104.reason]));
   }
   /**
    * True if the stream has been aborted.
@@ -6116,7 +6262,7 @@ var Minipass = (_class5 = class extends _events2.EventEmitter {
       return this[FLOWING];
     }
     if (typeof chunk === "string" && // unless it is a string already ready for us to use
-    !(encoding === this[ENCODING] && !_optionalChain([this, 'access', _93 => _93[DECODER], 'optionalAccess', _94 => _94.lastNeed]))) {
+    !(encoding === this[ENCODING] && !_optionalChain([this, 'access', _105 => _105[DECODER], 'optionalAccess', _106 => _106.lastNeed]))) {
       chunk = Buffer.from(chunk, encoding);
     }
     if (Buffer.isBuffer(chunk) && this[ENCODING]) {
@@ -6982,12 +7128,12 @@ var PathBase = (_class6 = class {
   /**
    * Get the Path object referenced by the string path, resolved from this Path
    */
-  resolve(path25) {
-    if (!path25) {
+  resolve(path27) {
+    if (!path27) {
       return this;
     }
-    const rootPath = this.getRootString(path25);
-    const dir = path25.substring(rootPath.length);
+    const rootPath = this.getRootString(path27);
+    const dir = path27.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -7306,7 +7452,7 @@ var PathBase = (_class6 = class {
     }
     try {
       const read2 = await this.#fs.promises.readlink(this.fullpath());
-      const linkTarget = await _asyncOptionalChain([(await this.parent.realpath()), 'optionalAccess', async _95 => _95.resolve, 'call', async _96 => _96(read2)]);
+      const linkTarget = await _asyncOptionalChain([(await this.parent.realpath()), 'optionalAccess', async _107 => _107.resolve, 'call', async _108 => _108(read2)]);
       if (linkTarget) {
         return this.#linkTarget = linkTarget;
       }
@@ -7331,7 +7477,7 @@ var PathBase = (_class6 = class {
     }
     try {
       const read2 = this.#fs.readlinkSync(this.fullpath());
-      const linkTarget = _optionalChain([this, 'access', _97 => _97.parent, 'access', _98 => _98.realpathSync, 'call', _99 => _99(), 'optionalAccess', _100 => _100.resolve, 'call', _101 => _101(read2)]);
+      const linkTarget = _optionalChain([this, 'access', _109 => _109.parent, 'access', _110 => _110.realpathSync, 'call', _111 => _111(), 'optionalAccess', _112 => _112.resolve, 'call', _113 => _113(read2)]);
       if (linkTarget) {
         return this.#linkTarget = linkTarget;
       }
@@ -7739,8 +7885,8 @@ var PathWin32 = (_class7 = class _PathWin32 extends PathBase {
   /**
    * @internal
    */
-  getRootString(path25) {
-    return _path.win32.parse(path25).root;
+  getRootString(path27) {
+    return _path.win32.parse(path27).root;
   }
   /**
    * @internal
@@ -7786,8 +7932,8 @@ var PathPosix = (_class8 = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path25) {
-    return path25.startsWith("/") ? "/" : "";
+  getRootString(path27) {
+    return path27.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -7836,8 +7982,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs19 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs19);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs21 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs21);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = _url.fileURLToPath.call(void 0, cwd);
     }
@@ -7876,11 +8022,11 @@ var PathScurryBase = class {
   /**
    * Get the depth of a provided path, string, or the cwd
    */
-  depth(path25 = this.cwd) {
-    if (typeof path25 === "string") {
-      path25 = this.cwd.resolve(path25);
+  depth(path27 = this.cwd) {
+    if (typeof path27 === "string") {
+      path27 = this.cwd.resolve(path27);
     }
-    return path25.depth();
+    return path27.depth();
   }
   /**
    * Return the cache of child entries.  Exposed so subclasses can create
@@ -8061,7 +8207,7 @@ var PathScurryBase = class {
       entry = this.cwd;
     }
     const e = await entry.readlink();
-    return withFileTypes ? e : _optionalChain([e, 'optionalAccess', _102 => _102.fullpath, 'call', _103 => _103()]);
+    return withFileTypes ? e : _optionalChain([e, 'optionalAccess', _114 => _114.fullpath, 'call', _115 => _115()]);
   }
   readlinkSync(entry = this.cwd, { withFileTypes } = {
     withFileTypes: false
@@ -8073,7 +8219,7 @@ var PathScurryBase = class {
       entry = this.cwd;
     }
     const e = entry.readlinkSync();
-    return withFileTypes ? e : _optionalChain([e, 'optionalAccess', _104 => _104.fullpath, 'call', _105 => _105()]);
+    return withFileTypes ? e : _optionalChain([e, 'optionalAccess', _116 => _116.fullpath, 'call', _117 => _117()]);
   }
   async realpath(entry = this.cwd, { withFileTypes } = {
     withFileTypes: false
@@ -8085,7 +8231,7 @@ var PathScurryBase = class {
       entry = this.cwd;
     }
     const e = await entry.realpath();
-    return withFileTypes ? e : _optionalChain([e, 'optionalAccess', _106 => _106.fullpath, 'call', _107 => _107()]);
+    return withFileTypes ? e : _optionalChain([e, 'optionalAccess', _118 => _118.fullpath, 'call', _119 => _119()]);
   }
   realpathSync(entry = this.cwd, { withFileTypes } = {
     withFileTypes: false
@@ -8097,7 +8243,7 @@ var PathScurryBase = class {
       entry = this.cwd;
     }
     const e = entry.realpathSync();
-    return withFileTypes ? e : _optionalChain([e, 'optionalAccess', _108 => _108.fullpath, 'call', _109 => _109()]);
+    return withFileTypes ? e : _optionalChain([e, 'optionalAccess', _120 => _120.fullpath, 'call', _121 => _121()]);
   }
   async walk(entry = this.cwd, opts = {}) {
     if (typeof entry === "string") {
@@ -8131,7 +8277,7 @@ var PathScurryBase = class {
             results.push(withFileTypes ? e : e.fullpath());
           }
           if (follow && e.isSymbolicLink()) {
-            e.realpath().then((r2) => _optionalChain([r2, 'optionalAccess', _110 => _110.isUnknown, 'call', _111 => _111()]) ? r2.lstat() : r2).then((r2) => _optionalChain([r2, 'optionalAccess', _112 => _112.shouldWalk, 'call', _113 => _113(dirs, walkFilter)]) ? walk2(r2, next) : next());
+            e.realpath().then((r2) => _optionalChain([r2, 'optionalAccess', _122 => _122.isUnknown, 'call', _123 => _123()]) ? r2.lstat() : r2).then((r2) => _optionalChain([r2, 'optionalAccess', _124 => _124.shouldWalk, 'call', _125 => _125(dirs, walkFilter)]) ? walk2(r2, next) : next());
           } else {
             if (e.shouldWalk(dirs, walkFilter)) {
               walk2(e, next);
@@ -8277,7 +8423,7 @@ var PathScurryBase = class {
             const promises3 = [];
             for (const e of entries) {
               if (e.isSymbolicLink()) {
-                promises3.push(e.realpath().then((r2) => _optionalChain([r2, 'optionalAccess', _114 => _114.isUnknown, 'call', _115 => _115()]) ? r2.lstat() : r2));
+                promises3.push(e.realpath().then((r2) => _optionalChain([r2, 'optionalAccess', _126 => _126.isUnknown, 'call', _127 => _127()]) ? r2.lstat() : r2));
               }
             }
             if (promises3.length) {
@@ -8367,9 +8513,9 @@ var PathScurryBase = class {
     process9();
     return results;
   }
-  chdir(path25 = this.cwd) {
+  chdir(path27 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path25 === "string" ? this.cwd.resolve(path25) : path25;
+    this.cwd = typeof path27 === "string" ? this.cwd.resolve(path27) : path27;
     this.cwd[setAsCwd](oldCwd);
   }
 };
@@ -8395,8 +8541,8 @@ var PathScurryWin32 = (_class9 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs19) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs19 });
+  newRoot(fs21) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs21 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -8424,8 +8570,8 @@ var PathScurryPosix = (_class10 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs19) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs19 });
+  newRoot(fs21) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs21 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -8711,7 +8857,7 @@ var HasWalkedCache = class _HasWalkedCache {
     return new _HasWalkedCache(new Map(this.store));
   }
   hasWalked(target, pattern) {
-    return _optionalChain([this, 'access', _116 => _116.store, 'access', _117 => _117.get, 'call', _118 => _118(target.fullpath()), 'optionalAccess', _119 => _119.has, 'call', _120 => _120(pattern.globString())]);
+    return _optionalChain([this, 'access', _128 => _128.store, 'access', _129 => _129.get, 'call', _130 => _130(target.fullpath()), 'optionalAccess', _131 => _131.has, 'call', _132 => _132(pattern.globString())]);
   }
   storeWalked(target, pattern) {
     const fullpath = target.fullpath();
@@ -8731,8 +8877,8 @@ var MatchRecord = (_class11 = class {constructor() { _class11.prototype.__init28
   }
   // match, absolute, ifdir
   entries() {
-    return [...this.store.entries()].map(([path25, n2]) => [
-      path25,
+    return [...this.store.entries()].map(([path27, n2]) => [
+      path27,
       !!(n2 & 2),
       !!(n2 & 1)
     ]);
@@ -8823,8 +8969,8 @@ var Processor = (_class13 = class _Processor {
         if (!t2.isSymbolicLink() || this.follow || pattern.checkFollowGlobstar()) {
           this.subwalks.add(t2, pattern);
         }
-        const rp = _optionalChain([rest, 'optionalAccess', _121 => _121.pattern, 'call', _122 => _122()]);
-        const rrest = _optionalChain([rest, 'optionalAccess', _123 => _123.rest, 'call', _124 => _124()]);
+        const rp = _optionalChain([rest, 'optionalAccess', _133 => _133.pattern, 'call', _134 => _134()]);
+        const rrest = _optionalChain([rest, 'optionalAccess', _135 => _135.rest, 'call', _136 => _136()]);
         if (!rest || (rp === "" || rp === ".") && !rrest) {
           this.matches.add(t2, absolute, rp === "" || rp === ".");
         } else {
@@ -8937,9 +9083,9 @@ var GlobUtil = (_class14 = class {
   
   
   
-  constructor(patterns, path25, opts) {;_class14.prototype.__init32.call(this);_class14.prototype.__init33.call(this);_class14.prototype.__init34.call(this);
+  constructor(patterns, path27, opts) {;_class14.prototype.__init32.call(this);_class14.prototype.__init33.call(this);_class14.prototype.__init34.call(this);
     this.patterns = patterns;
-    this.path = path25;
+    this.path = path27;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -8958,18 +9104,18 @@ var GlobUtil = (_class14 = class {
       });
     }
   }
-  #ignored(path25) {
-    return this.seen.has(path25) || !!_optionalChain([this, 'access', _125 => _125.#ignore, 'optionalAccess', _126 => _126.ignored, 'optionalCall', _127 => _127(path25)]);
+  #ignored(path27) {
+    return this.seen.has(path27) || !!_optionalChain([this, 'access', _137 => _137.#ignore, 'optionalAccess', _138 => _138.ignored, 'optionalCall', _139 => _139(path27)]);
   }
-  #childrenIgnored(path25) {
-    return !!_optionalChain([this, 'access', _128 => _128.#ignore, 'optionalAccess', _129 => _129.childrenIgnored, 'optionalCall', _130 => _130(path25)]);
+  #childrenIgnored(path27) {
+    return !!_optionalChain([this, 'access', _140 => _140.#ignore, 'optionalAccess', _141 => _141.childrenIgnored, 'optionalCall', _142 => _142(path27)]);
   }
   // backpressure mechanism
   pause() {
     this.paused = true;
   }
   resume() {
-    if (_optionalChain([this, 'access', _131 => _131.signal, 'optionalAccess', _132 => _132.aborted]))
+    if (_optionalChain([this, 'access', _143 => _143.signal, 'optionalAccess', _144 => _144.aborted]))
       return;
     this.paused = false;
     let fn = void 0;
@@ -8978,7 +9124,7 @@ var GlobUtil = (_class14 = class {
     }
   }
   onResume(fn) {
-    if (_optionalChain([this, 'access', _133 => _133.signal, 'optionalAccess', _134 => _134.aborted]))
+    if (_optionalChain([this, 'access', _145 => _145.signal, 'optionalAccess', _146 => _146.aborted]))
       return;
     if (!this.paused) {
       fn();
@@ -9000,7 +9146,7 @@ var GlobUtil = (_class14 = class {
     }
     const needStat = e.isUnknown() || this.opts.stat;
     const s = needStat ? await e.lstat() : e;
-    if (this.opts.follow && this.opts.nodir && _optionalChain([s, 'optionalAccess', _135 => _135.isSymbolicLink, 'call', _136 => _136()])) {
+    if (this.opts.follow && this.opts.nodir && _optionalChain([s, 'optionalAccess', _147 => _147.isSymbolicLink, 'call', _148 => _148()])) {
       const target = await s.realpath();
       if (target && (target.isUnknown() || this.opts.stat)) {
         await target.lstat();
@@ -9009,7 +9155,7 @@ var GlobUtil = (_class14 = class {
     return this.matchCheckTest(s, ifDir);
   }
   matchCheckTest(e, ifDir) {
-    return e && (this.maxDepth === Infinity || e.depth() <= this.maxDepth) && (!ifDir || e.canReaddir()) && (!this.opts.nodir || !e.isDirectory()) && (!this.opts.nodir || !this.opts.follow || !e.isSymbolicLink() || !_optionalChain([e, 'access', _137 => _137.realpathCached, 'call', _138 => _138(), 'optionalAccess', _139 => _139.isDirectory, 'call', _140 => _140()])) && !this.#ignored(e) ? e : void 0;
+    return e && (this.maxDepth === Infinity || e.depth() <= this.maxDepth) && (!ifDir || e.canReaddir()) && (!this.opts.nodir || !e.isDirectory()) && (!this.opts.nodir || !this.opts.follow || !e.isSymbolicLink() || !_optionalChain([e, 'access', _149 => _149.realpathCached, 'call', _150 => _150(), 'optionalAccess', _151 => _151.isDirectory, 'call', _152 => _152()])) && !this.#ignored(e) ? e : void 0;
   }
   matchCheckSync(e, ifDir) {
     if (ifDir && this.opts.nodir)
@@ -9023,9 +9169,9 @@ var GlobUtil = (_class14 = class {
     }
     const needStat = e.isUnknown() || this.opts.stat;
     const s = needStat ? e.lstatSync() : e;
-    if (this.opts.follow && this.opts.nodir && _optionalChain([s, 'optionalAccess', _141 => _141.isSymbolicLink, 'call', _142 => _142()])) {
+    if (this.opts.follow && this.opts.nodir && _optionalChain([s, 'optionalAccess', _153 => _153.isSymbolicLink, 'call', _154 => _154()])) {
       const target = s.realpathSync();
-      if (target && (_optionalChain([target, 'optionalAccess', _143 => _143.isUnknown, 'call', _144 => _144()]) || this.opts.stat)) {
+      if (target && (_optionalChain([target, 'optionalAccess', _155 => _155.isUnknown, 'call', _156 => _156()]) || this.opts.stat)) {
         target.lstatSync();
       }
     }
@@ -9034,7 +9180,7 @@ var GlobUtil = (_class14 = class {
   matchFinish(e, absolute) {
     if (this.#ignored(e))
       return;
-    if (!this.includeChildMatches && _optionalChain([this, 'access', _145 => _145.#ignore, 'optionalAccess', _146 => _146.add])) {
+    if (!this.includeChildMatches && _optionalChain([this, 'access', _157 => _157.#ignore, 'optionalAccess', _158 => _158.add])) {
       const ign = `${e.relativePosix()}/**`;
       this.#ignore.add(ign);
     }
@@ -9063,14 +9209,14 @@ var GlobUtil = (_class14 = class {
       this.matchFinish(p, absolute);
   }
   walkCB(target, patterns, cb) {
-    if (_optionalChain([this, 'access', _147 => _147.signal, 'optionalAccess', _148 => _148.aborted]))
+    if (_optionalChain([this, 'access', _159 => _159.signal, 'optionalAccess', _160 => _160.aborted]))
       cb();
     this.walkCB2(target, patterns, new Processor(this.opts), cb);
   }
   walkCB2(target, patterns, processor, cb) {
     if (this.#childrenIgnored(target))
       return cb();
-    if (_optionalChain([this, 'access', _149 => _149.signal, 'optionalAccess', _150 => _150.aborted]))
+    if (_optionalChain([this, 'access', _161 => _161.signal, 'optionalAccess', _162 => _162.aborted]))
       cb();
     if (this.paused) {
       this.onResume(() => this.walkCB2(target, patterns, processor, cb));
@@ -9122,14 +9268,14 @@ var GlobUtil = (_class14 = class {
     next();
   }
   walkCBSync(target, patterns, cb) {
-    if (_optionalChain([this, 'access', _151 => _151.signal, 'optionalAccess', _152 => _152.aborted]))
+    if (_optionalChain([this, 'access', _163 => _163.signal, 'optionalAccess', _164 => _164.aborted]))
       cb();
     this.walkCB2Sync(target, patterns, new Processor(this.opts), cb);
   }
   walkCB2Sync(target, patterns, processor, cb) {
     if (this.#childrenIgnored(target))
       return cb();
-    if (_optionalChain([this, 'access', _153 => _153.signal, 'optionalAccess', _154 => _154.aborted]))
+    if (_optionalChain([this, 'access', _165 => _165.signal, 'optionalAccess', _166 => _166.aborted]))
       cb();
     if (this.paused) {
       this.onResume(() => this.walkCB2Sync(target, patterns, processor, cb));
@@ -9177,21 +9323,21 @@ var GlobUtil = (_class14 = class {
 }, _class14);
 var GlobWalker = (_class15 = class extends GlobUtil {
   __init35() {this.matches = /* @__PURE__ */ new Set()}
-  constructor(patterns, path25, opts) {
-    super(patterns, path25, opts);_class15.prototype.__init35.call(this);;
+  constructor(patterns, path27, opts) {
+    super(patterns, path27, opts);_class15.prototype.__init35.call(this);;
   }
   matchEmit(e) {
     this.matches.add(e);
   }
   async walk() {
-    if (_optionalChain([this, 'access', _155 => _155.signal, 'optionalAccess', _156 => _156.aborted]))
+    if (_optionalChain([this, 'access', _167 => _167.signal, 'optionalAccess', _168 => _168.aborted]))
       throw this.signal.reason;
     if (this.path.isUnknown()) {
       await this.path.lstat();
     }
     await new Promise((res, rej) => {
       this.walkCB(this.path, this.patterns, () => {
-        if (_optionalChain([this, 'access', _157 => _157.signal, 'optionalAccess', _158 => _158.aborted])) {
+        if (_optionalChain([this, 'access', _169 => _169.signal, 'optionalAccess', _170 => _170.aborted])) {
           rej(this.signal.reason);
         } else {
           res(this.matches);
@@ -9201,13 +9347,13 @@ var GlobWalker = (_class15 = class extends GlobUtil {
     return this.matches;
   }
   walkSync() {
-    if (_optionalChain([this, 'access', _159 => _159.signal, 'optionalAccess', _160 => _160.aborted]))
+    if (_optionalChain([this, 'access', _171 => _171.signal, 'optionalAccess', _172 => _172.aborted]))
       throw this.signal.reason;
     if (this.path.isUnknown()) {
       this.path.lstatSync();
     }
     this.walkCBSync(this.path, this.patterns, () => {
-      if (_optionalChain([this, 'access', _161 => _161.signal, 'optionalAccess', _162 => _162.aborted]))
+      if (_optionalChain([this, 'access', _173 => _173.signal, 'optionalAccess', _174 => _174.aborted]))
         throw this.signal.reason;
     });
     return this.matches;
@@ -9215,8 +9361,8 @@ var GlobWalker = (_class15 = class extends GlobUtil {
 }, _class15);
 var GlobStream = class extends GlobUtil {
   
-  constructor(patterns, path25, opts) {
-    super(patterns, path25, opts);
+  constructor(patterns, path27, opts) {
+    super(patterns, path27, opts);
     this.results = new Minipass({
       signal: this.signal,
       objectMode: true
@@ -9553,44 +9699,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 = (path25, opt = {}) => {
-  const type = typeof path25;
+var pathArg = (path27, opt = {}) => {
+  const type = typeof path27;
   if (type !== "string") {
-    const ctor = path25 && type === "object" && path25.constructor;
-    const received = ctor && ctor.name ? `an instance of ${ctor.name}` : type === "object" ? _util.inspect.call(void 0, path25) : `type ${type} ${path25}`;
+    const ctor = path27 && type === "object" && path27.constructor;
+    const received = ctor && ctor.name ? `an instance of ${ctor.name}` : type === "object" ? _util.inspect.call(void 0, path27) : `type ${type} ${path27}`;
     const msg = `The "path" argument must be of type string. Received ${received}`;
     throw Object.assign(new TypeError(msg), {
-      path: path25,
+      path: path27,
       code: "ERR_INVALID_ARG_TYPE"
     });
   }
-  if (/\0/.test(path25)) {
+  if (/\0/.test(path27)) {
     const msg = "path must be a string without null bytes";
     throw Object.assign(new TypeError(msg), {
-      path: path25,
+      path: path27,
       code: "ERR_INVALID_ARG_VALUE"
     });
   }
-  path25 = _path.resolve.call(void 0, path25);
-  const { root } = _path.parse.call(void 0, path25);
-  if (path25 === root && opt.preserveRoot !== false) {
+  path27 = _path.resolve.call(void 0, path27);
+  const { root } = _path.parse.call(void 0, path27);
+  if (path27 === root && opt.preserveRoot !== false) {
     const msg = "refusing to remove root directory without preserveRoot:false";
     throw Object.assign(new Error(msg), {
-      path: path25,
+      path: path27,
       code: "ERR_PRESERVE_ROOT"
     });
   }
   if (platform_default === "win32") {
     const badWinChars = /[*|"<>?:]/;
-    const { root: root2 } = _path.parse.call(void 0, path25);
-    if (badWinChars.test(path25.substring(root2.length))) {
+    const { root: root2 } = _path.parse.call(void 0, path27);
+    if (badWinChars.test(path27.substring(root2.length))) {
       throw Object.assign(new Error("Illegal characters in path."), {
-        path: path25,
+        path: path27,
         code: "EINVAL"
       });
     }
   }
-  return path25;
+  return path27;
 };
 var path_arg_default = pathArg;
 
@@ -9605,16 +9751,16 @@ _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
 
 
 
-var readdirSync2 = (path25) => _fs.readdirSync.call(void 0, path25, { withFileTypes: true });
-var chmod = (path25, mode) => new Promise((res, rej) => actualFS.default.chmod(path25, mode, (er, ...d) => er ? rej(er) : res(...d)));
-var mkdir = (path25, options) => new Promise((res, rej) => actualFS.default.mkdir(path25, options, (er, made) => er ? rej(er) : res(made)));
-var readdir4 = (path25) => new Promise((res, rej) => actualFS.default.readdir(path25, { withFileTypes: true }, (er, data2) => er ? rej(er) : res(data2)));
+var readdirSync2 = (path27) => _fs.readdirSync.call(void 0, path27, { withFileTypes: true });
+var chmod = (path27, mode) => new Promise((res, rej) => actualFS.default.chmod(path27, mode, (er, ...d) => er ? rej(er) : res(...d)));
+var mkdir = (path27, options) => new Promise((res, rej) => actualFS.default.mkdir(path27, options, (er, made) => er ? rej(er) : res(made)));
+var readdir4 = (path27) => new Promise((res, rej) => actualFS.default.readdir(path27, { 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 = (path25, options) => new Promise((res, rej) => actualFS.default.rm(path25, options, (er, ...d) => er ? rej(er) : res(...d)));
-var rmdir = (path25) => new Promise((res, rej) => actualFS.default.rmdir(path25, (er, ...d) => er ? rej(er) : res(...d)));
-var stat4 = (path25) => new Promise((res, rej) => actualFS.default.stat(path25, (er, data2) => er ? rej(er) : res(data2)));
-var lstat4 = (path25) => new Promise((res, rej) => actualFS.default.lstat(path25, (er, data2) => er ? rej(er) : res(data2)));
-var unlink = (path25) => new Promise((res, rej) => actualFS.default.unlink(path25, (er, ...d) => er ? rej(er) : res(...d)));
+var rm = (path27, options) => new Promise((res, rej) => actualFS.default.rm(path27, options, (er, ...d) => er ? rej(er) : res(...d)));
+var rmdir = (path27) => new Promise((res, rej) => actualFS.default.rmdir(path27, (er, ...d) => er ? rej(er) : res(...d)));
+var stat4 = (path27) => new Promise((res, rej) => actualFS.default.stat(path27, (er, data2) => er ? rej(er) : res(data2)));
+var lstat4 = (path27) => new Promise((res, rej) => actualFS.default.lstat(path27, (er, data2) => er ? rej(er) : res(data2)));
+var unlink = (path27) => new Promise((res, rej) => actualFS.default.unlink(path27, (er, ...d) => er ? rej(er) : res(...d)));
 var promises = {
   chmod,
   mkdir,
@@ -9633,10 +9779,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 = (path25) => readdir5(path25).catch((er) => er);
-var readdirOrErrorSync = (path25) => {
+var readdirOrError = (path27) => readdir5(path27).catch((er) => er);
+var readdirOrErrorSync = (path27) => {
   try {
-    return readdirSync2(path25);
+    return readdirSync2(path27);
   } catch (er) {
     return er;
   }
@@ -9653,7 +9799,7 @@ var ignoreENOENTSync = (fn) => {
   try {
     return fn();
   } catch (er) {
-    if (_optionalChain([er, 'optionalAccess', _163 => _163.code]) !== "ENOENT") {
+    if (_optionalChain([er, 'optionalAccess', _175 => _175.code]) !== "ENOENT") {
       throw er;
     }
   }
@@ -9661,35 +9807,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 (path25, opt) => {
-  if (_optionalChain([opt, 'optionalAccess', _164 => _164.signal, 'optionalAccess', _165 => _165.aborted])) {
+var rimrafPosix = async (path27, opt) => {
+  if (_optionalChain([opt, 'optionalAccess', _176 => _176.signal, 'optionalAccess', _177 => _177.aborted])) {
     throw opt.signal.reason;
   }
   try {
-    return await rimrafPosixDir(path25, opt, await lstat5(path25));
+    return await rimrafPosixDir(path27, opt, await lstat5(path27));
   } catch (er) {
-    if (_optionalChain([er, 'optionalAccess', _166 => _166.code]) === "ENOENT")
+    if (_optionalChain([er, 'optionalAccess', _178 => _178.code]) === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafPosixSync = (path25, opt) => {
-  if (_optionalChain([opt, 'optionalAccess', _167 => _167.signal, 'optionalAccess', _168 => _168.aborted])) {
+var rimrafPosixSync = (path27, opt) => {
+  if (_optionalChain([opt, 'optionalAccess', _179 => _179.signal, 'optionalAccess', _180 => _180.aborted])) {
     throw opt.signal.reason;
   }
   try {
-    return rimrafPosixDirSync(path25, opt, _fs.lstatSync.call(void 0, path25));
+    return rimrafPosixDirSync(path27, opt, _fs.lstatSync.call(void 0, path27));
   } catch (er) {
-    if (_optionalChain([er, 'optionalAccess', _169 => _169.code]) === "ENOENT")
+    if (_optionalChain([er, 'optionalAccess', _181 => _181.code]) === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafPosixDir = async (path25, opt, ent) => {
-  if (_optionalChain([opt, 'optionalAccess', _170 => _170.signal, 'optionalAccess', _171 => _171.aborted])) {
+var rimrafPosixDir = async (path27, opt, ent) => {
+  if (_optionalChain([opt, 'optionalAccess', _182 => _182.signal, 'optionalAccess', _183 => _183.aborted])) {
     throw opt.signal.reason;
   }
-  const entries = ent.isDirectory() ? await readdirOrError(path25) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path27) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -9699,30 +9845,30 @@ var rimrafPosixDir = async (path25, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path25, ent)) {
+    if (opt.filter && !await opt.filter(path27, ent)) {
       return false;
     }
-    await ignoreENOENT(unlink2(path25));
+    await ignoreENOENT(unlink2(path27));
     return true;
   }
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafPosixDir(_path.resolve.call(void 0, path25, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafPosixDir(_path.resolve.call(void 0, path27, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path25 === _path.parse.call(void 0, path25).root) {
+  if (opt.preserveRoot === false && path27 === _path.parse.call(void 0, path27).root) {
     return false;
   }
-  if (opt.filter && !await opt.filter(path25, ent)) {
+  if (opt.filter && !await opt.filter(path27, ent)) {
     return false;
   }
-  await ignoreENOENT(rmdir2(path25));
+  await ignoreENOENT(rmdir2(path27));
   return true;
 };
-var rimrafPosixDirSync = (path25, opt, ent) => {
-  if (_optionalChain([opt, 'optionalAccess', _172 => _172.signal, 'optionalAccess', _173 => _173.aborted])) {
+var rimrafPosixDirSync = (path27, opt, ent) => {
+  if (_optionalChain([opt, 'optionalAccess', _184 => _184.signal, 'optionalAccess', _185 => _185.aborted])) {
     throw opt.signal.reason;
   }
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path25) : null;
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path27) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -9732,27 +9878,27 @@ var rimrafPosixDirSync = (path25, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path25, ent)) {
+    if (opt.filter && !opt.filter(path27, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => _fs.unlinkSync.call(void 0, path25));
+    ignoreENOENTSync(() => _fs.unlinkSync.call(void 0, path27));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
-    const p = _path.resolve.call(void 0, path25, ent2.name);
+    const p = _path.resolve.call(void 0, path27, ent2.name);
     removedAll = rimrafPosixDirSync(p, opt, ent2) && removedAll;
   }
-  if (opt.preserveRoot === false && path25 === _path.parse.call(void 0, path25).root) {
+  if (opt.preserveRoot === false && path27 === _path.parse.call(void 0, path27).root) {
     return false;
   }
   if (!removedAll) {
     return false;
   }
-  if (opt.filter && !opt.filter(path25, ent)) {
+  if (opt.filter && !opt.filter(path27, ent)) {
     return false;
   }
-  ignoreENOENTSync(() => _fs.rmdirSync.call(void 0, path25));
+  ignoreENOENTSync(() => _fs.rmdirSync.call(void 0, path27));
   return true;
 };
 
@@ -9763,48 +9909,48 @@ _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 (path25) => {
+var fixEPERM = (fn) => async (path27) => {
   try {
-    return await fn(path25);
+    return await fn(path27);
   } catch (er) {
     const fer = er;
-    if (_optionalChain([fer, 'optionalAccess', _174 => _174.code]) === "ENOENT") {
+    if (_optionalChain([fer, 'optionalAccess', _186 => _186.code]) === "ENOENT") {
       return;
     }
-    if (_optionalChain([fer, 'optionalAccess', _175 => _175.code]) === "EPERM") {
+    if (_optionalChain([fer, 'optionalAccess', _187 => _187.code]) === "EPERM") {
       try {
-        await chmod2(path25, 438);
+        await chmod2(path27, 438);
       } catch (er2) {
         const fer2 = er2;
-        if (_optionalChain([fer2, 'optionalAccess', _176 => _176.code]) === "ENOENT") {
+        if (_optionalChain([fer2, 'optionalAccess', _188 => _188.code]) === "ENOENT") {
           return;
         }
         throw er;
       }
-      return await fn(path25);
+      return await fn(path27);
     }
     throw er;
   }
 };
-var fixEPERMSync = (fn) => (path25) => {
+var fixEPERMSync = (fn) => (path27) => {
   try {
-    return fn(path25);
+    return fn(path27);
   } catch (er) {
     const fer = er;
-    if (_optionalChain([fer, 'optionalAccess', _177 => _177.code]) === "ENOENT") {
+    if (_optionalChain([fer, 'optionalAccess', _189 => _189.code]) === "ENOENT") {
       return;
     }
-    if (_optionalChain([fer, 'optionalAccess', _178 => _178.code]) === "EPERM") {
+    if (_optionalChain([fer, 'optionalAccess', _190 => _190.code]) === "EPERM") {
       try {
-        _fs.chmodSync.call(void 0, path25, 438);
+        _fs.chmodSync.call(void 0, path27, 438);
       } catch (er2) {
         const fer2 = er2;
-        if (_optionalChain([fer2, 'optionalAccess', _179 => _179.code]) === "ENOENT") {
+        if (_optionalChain([fer2, 'optionalAccess', _191 => _191.code]) === "ENOENT") {
           return;
         }
         throw er;
       }
-      return fn(path25);
+      return fn(path27);
     }
     throw er;
   }
@@ -9817,23 +9963,23 @@ var RATE = 1.2;
 var MAXRETRIES = 10;
 var codes = /* @__PURE__ */ new Set(["EMFILE", "ENFILE", "EBUSY"]);
 var retryBusy = (fn) => {
-  const method = async (path25, opt, backoff = 1, total = 0) => {
+  const method = async (path27, 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(path25);
+        return await fn(path27);
       } catch (er) {
         const fer = er;
-        if (_optionalChain([fer, 'optionalAccess', _180 => _180.path]) === path25 && _optionalChain([fer, 'optionalAccess', _181 => _181.code]) && codes.has(fer.code)) {
+        if (_optionalChain([fer, 'optionalAccess', _192 => _192.path]) === path27 && _optionalChain([fer, 'optionalAccess', _193 => _193.code]) && codes.has(fer.code)) {
           backoff = Math.ceil(backoff * rate);
           total = backoff + total;
           if (total < mbo) {
             return new Promise((res, rej) => {
               setTimeout(() => {
-                method(path25, opt, backoff, total).then(res, rej);
+                method(path27, opt, backoff, total).then(res, rej);
               }, backoff);
             });
           }
@@ -9849,15 +9995,15 @@ var retryBusy = (fn) => {
   return method;
 };
 var retryBusySync = (fn) => {
-  const method = (path25, opt) => {
+  const method = (path27, opt) => {
     const max = opt.maxRetries || MAXRETRIES;
     let retries = 0;
     while (true) {
       try {
-        return fn(path25);
+        return fn(path27);
       } catch (er) {
         const fer = er;
-        if (_optionalChain([fer, 'optionalAccess', _182 => _182.path]) === path25 && _optionalChain([fer, 'optionalAccess', _183 => _183.code]) && codes.has(fer.code) && retries < max) {
+        if (_optionalChain([fer, 'optionalAccess', _194 => _194.path]) === path27 && _optionalChain([fer, 'optionalAccess', _195 => _195.code]) && codes.has(fer.code) && retries < max) {
           retries++;
           continue;
         }
@@ -9877,16 +10023,16 @@ _chunkOS76JPG2cjs.init_cjs_shims.call(void 0, );
 
 
 var { stat: stat5 } = promises;
-var isDirSync = (path25) => {
+var isDirSync = (path27) => {
   try {
-    return _fs.statSync.call(void 0, path25).isDirectory();
+    return _fs.statSync.call(void 0, path27).isDirectory();
   } catch (er) {
     return false;
   }
 };
-var isDir = (path25) => stat5(path25).then((st) => st.isDirectory(), () => false);
-var win32DefaultTmp = async (path25) => {
-  const { root } = _path.parse.call(void 0, path25);
+var isDir = (path27) => stat5(path27).then((st) => st.isDirectory(), () => false);
+var win32DefaultTmp = async (path27) => {
+  const { root } = _path.parse.call(void 0, path27);
   const tmp = _os.tmpdir.call(void 0, );
   const { root: tmpRoot } = _path.parse.call(void 0, tmp);
   if (root.toLowerCase() === tmpRoot.toLowerCase()) {
@@ -9898,8 +10044,8 @@ var win32DefaultTmp = async (path25) => {
   }
   return root;
 };
-var win32DefaultTmpSync = (path25) => {
-  const { root } = _path.parse.call(void 0, path25);
+var win32DefaultTmpSync = (path27) => {
+  const { root } = _path.parse.call(void 0, path27);
   const tmp = _os.tmpdir.call(void 0, );
   const { root: tmpRoot } = _path.parse.call(void 0, tmp);
   if (root.toLowerCase() === tmpRoot.toLowerCase()) {
@@ -9918,10 +10064,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 = (path25) => `.${_path.basename.call(void 0, path25)}.${Math.random()}`;
-var unlinkFixEPERM = async (path25) => unlink3(path25).catch((er) => {
+var uniqueFilename = (path27) => `.${_path.basename.call(void 0, path27)}.${Math.random()}`;
+var unlinkFixEPERM = async (path27) => unlink3(path27).catch((er) => {
   if (er.code === "EPERM") {
-    return chmod3(path25, 438).then(() => unlink3(path25), (er2) => {
+    return chmod3(path27, 438).then(() => unlink3(path27), (er2) => {
       if (er2.code === "ENOENT") {
         return;
       }
@@ -9932,48 +10078,48 @@ var unlinkFixEPERM = async (path25) => unlink3(path25).catch((er) => {
   }
   throw er;
 });
-var unlinkFixEPERMSync = (path25) => {
+var unlinkFixEPERMSync = (path27) => {
   try {
-    _fs.unlinkSync.call(void 0, path25);
+    _fs.unlinkSync.call(void 0, path27);
   } catch (er) {
-    if (_optionalChain([er, 'optionalAccess', _184 => _184.code]) === "EPERM") {
+    if (_optionalChain([er, 'optionalAccess', _196 => _196.code]) === "EPERM") {
       try {
-        return _fs.chmodSync.call(void 0, path25, 438);
+        return _fs.chmodSync.call(void 0, path27, 438);
       } catch (er2) {
-        if (_optionalChain([er2, 'optionalAccess', _185 => _185.code]) === "ENOENT") {
+        if (_optionalChain([er2, 'optionalAccess', _197 => _197.code]) === "ENOENT") {
           return;
         }
         throw er;
       }
-    } else if (_optionalChain([er, 'optionalAccess', _186 => _186.code]) === "ENOENT") {
+    } else if (_optionalChain([er, 'optionalAccess', _198 => _198.code]) === "ENOENT") {
       return;
     }
     throw er;
   }
 };
-var rimrafMoveRemove = async (path25, opt) => {
-  if (_optionalChain([opt, 'optionalAccess', _187 => _187.signal, 'optionalAccess', _188 => _188.aborted])) {
+var rimrafMoveRemove = async (path27, opt) => {
+  if (_optionalChain([opt, 'optionalAccess', _199 => _199.signal, 'optionalAccess', _200 => _200.aborted])) {
     throw opt.signal.reason;
   }
   try {
-    return await rimrafMoveRemoveDir(path25, opt, await lstat6(path25));
+    return await rimrafMoveRemoveDir(path27, opt, await lstat6(path27));
   } catch (er) {
-    if (_optionalChain([er, 'optionalAccess', _189 => _189.code]) === "ENOENT")
+    if (_optionalChain([er, 'optionalAccess', _201 => _201.code]) === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafMoveRemoveDir = async (path25, opt, ent) => {
-  if (_optionalChain([opt, 'optionalAccess', _190 => _190.signal, 'optionalAccess', _191 => _191.aborted])) {
+var rimrafMoveRemoveDir = async (path27, opt, ent) => {
+  if (_optionalChain([opt, 'optionalAccess', _202 => _202.signal, 'optionalAccess', _203 => _203.aborted])) {
     throw opt.signal.reason;
   }
   if (!opt.tmp) {
-    return rimrafMoveRemoveDir(path25, { ...opt, tmp: await defaultTmp(path25) }, ent);
+    return rimrafMoveRemoveDir(path27, { ...opt, tmp: await defaultTmp(path27) }, ent);
   }
-  if (path25 === opt.tmp && _path.parse.call(void 0, path25).root !== path25) {
+  if (path27 === opt.tmp && _path.parse.call(void 0, path27).root !== path27) {
     throw new Error("cannot delete temp directory used for deletion");
   }
-  const entries = ent.isDirectory() ? await readdirOrError(path25) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path27) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -9983,54 +10129,54 @@ var rimrafMoveRemoveDir = async (path25, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path25, ent)) {
+    if (opt.filter && !await opt.filter(path27, ent)) {
       return false;
     }
-    await ignoreENOENT(tmpUnlink(path25, opt.tmp, unlinkFixEPERM));
+    await ignoreENOENT(tmpUnlink(path27, opt.tmp, unlinkFixEPERM));
     return true;
   }
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafMoveRemoveDir(_path.resolve.call(void 0, path25, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafMoveRemoveDir(_path.resolve.call(void 0, path27, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path25 === _path.parse.call(void 0, path25).root) {
+  if (opt.preserveRoot === false && path27 === _path.parse.call(void 0, path27).root) {
     return false;
   }
-  if (opt.filter && !await opt.filter(path25, ent)) {
+  if (opt.filter && !await opt.filter(path27, ent)) {
     return false;
   }
-  await ignoreENOENT(tmpUnlink(path25, opt.tmp, rmdir3));
+  await ignoreENOENT(tmpUnlink(path27, opt.tmp, rmdir3));
   return true;
 };
-var tmpUnlink = async (path25, tmp, rm3) => {
-  const tmpFile = _path.resolve.call(void 0, tmp, uniqueFilename(path25));
-  await rename2(path25, tmpFile);
+var tmpUnlink = async (path27, tmp, rm3) => {
+  const tmpFile = _path.resolve.call(void 0, tmp, uniqueFilename(path27));
+  await rename2(path27, tmpFile);
   return await rm3(tmpFile);
 };
-var rimrafMoveRemoveSync = (path25, opt) => {
-  if (_optionalChain([opt, 'optionalAccess', _192 => _192.signal, 'optionalAccess', _193 => _193.aborted])) {
+var rimrafMoveRemoveSync = (path27, opt) => {
+  if (_optionalChain([opt, 'optionalAccess', _204 => _204.signal, 'optionalAccess', _205 => _205.aborted])) {
     throw opt.signal.reason;
   }
   try {
-    return rimrafMoveRemoveDirSync(path25, opt, _fs.lstatSync.call(void 0, path25));
+    return rimrafMoveRemoveDirSync(path27, opt, _fs.lstatSync.call(void 0, path27));
   } catch (er) {
-    if (_optionalChain([er, 'optionalAccess', _194 => _194.code]) === "ENOENT")
+    if (_optionalChain([er, 'optionalAccess', _206 => _206.code]) === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafMoveRemoveDirSync = (path25, opt, ent) => {
-  if (_optionalChain([opt, 'optionalAccess', _195 => _195.signal, 'optionalAccess', _196 => _196.aborted])) {
+var rimrafMoveRemoveDirSync = (path27, opt, ent) => {
+  if (_optionalChain([opt, 'optionalAccess', _207 => _207.signal, 'optionalAccess', _208 => _208.aborted])) {
     throw opt.signal.reason;
   }
   if (!opt.tmp) {
-    return rimrafMoveRemoveDirSync(path25, { ...opt, tmp: defaultTmpSync(path25) }, ent);
+    return rimrafMoveRemoveDirSync(path27, { ...opt, tmp: defaultTmpSync(path27) }, ent);
   }
   const tmp = opt.tmp;
-  if (path25 === opt.tmp && _path.parse.call(void 0, path25).root !== path25) {
+  if (path27 === opt.tmp && _path.parse.call(void 0, path27).root !== path27) {
     throw new Error("cannot delete temp directory used for deletion");
   }
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path25) : null;
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path27) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -10040,32 +10186,32 @@ var rimrafMoveRemoveDirSync = (path25, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path25, ent)) {
+    if (opt.filter && !opt.filter(path27, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => tmpUnlinkSync(path25, tmp, unlinkFixEPERMSync));
+    ignoreENOENTSync(() => tmpUnlinkSync(path27, tmp, unlinkFixEPERMSync));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
-    const p = _path.resolve.call(void 0, path25, ent2.name);
+    const p = _path.resolve.call(void 0, path27, ent2.name);
     removedAll = rimrafMoveRemoveDirSync(p, opt, ent2) && removedAll;
   }
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path25 === _path.parse.call(void 0, path25).root) {
+  if (opt.preserveRoot === false && path27 === _path.parse.call(void 0, path27).root) {
     return false;
   }
-  if (opt.filter && !opt.filter(path25, ent)) {
+  if (opt.filter && !opt.filter(path27, ent)) {
     return false;
   }
-  ignoreENOENTSync(() => tmpUnlinkSync(path25, tmp, _fs.rmdirSync));
+  ignoreENOENTSync(() => tmpUnlinkSync(path27, tmp, _fs.rmdirSync));
   return true;
 };
-var tmpUnlinkSync = (path25, tmp, rmSync2) => {
-  const tmpFile = _path.resolve.call(void 0, tmp, uniqueFilename(path25));
-  _fs.renameSync.call(void 0, path25, tmpFile);
+var tmpUnlinkSync = (path27, tmp, rmSync2) => {
+  const tmpFile = _path.resolve.call(void 0, tmp, uniqueFilename(path27));
+  _fs.renameSync.call(void 0, path27, tmpFile);
   return rmSync2(tmpFile);
 };
 
@@ -10075,31 +10221,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 (path25, opt) => {
-  if (_optionalChain([opt, 'optionalAccess', _197 => _197.signal, 'optionalAccess', _198 => _198.aborted])) {
+var rimrafWindowsDirMoveRemoveFallback = async (path27, opt) => {
+  if (_optionalChain([opt, 'optionalAccess', _209 => _209.signal, 'optionalAccess', _210 => _210.aborted])) {
     throw opt.signal.reason;
   }
   const { filter: filter3, ...options } = opt;
   try {
-    return await rimrafWindowsDirRetry(path25, options);
+    return await rimrafWindowsDirRetry(path27, options);
   } catch (er) {
-    if (_optionalChain([er, 'optionalAccess', _199 => _199.code]) === "ENOTEMPTY") {
-      return await rimrafMoveRemove(path25, options);
+    if (_optionalChain([er, 'optionalAccess', _211 => _211.code]) === "ENOTEMPTY") {
+      return await rimrafMoveRemove(path27, options);
     }
     throw er;
   }
 };
-var rimrafWindowsDirMoveRemoveFallbackSync = (path25, opt) => {
-  if (_optionalChain([opt, 'optionalAccess', _200 => _200.signal, 'optionalAccess', _201 => _201.aborted])) {
+var rimrafWindowsDirMoveRemoveFallbackSync = (path27, opt) => {
+  if (_optionalChain([opt, 'optionalAccess', _212 => _212.signal, 'optionalAccess', _213 => _213.aborted])) {
     throw opt.signal.reason;
   }
   const { filter: filter3, ...options } = opt;
   try {
-    return rimrafWindowsDirRetrySync(path25, options);
+    return rimrafWindowsDirRetrySync(path27, options);
   } catch (er) {
     const fer = er;
-    if (_optionalChain([fer, 'optionalAccess', _202 => _202.code]) === "ENOTEMPTY") {
-      return rimrafMoveRemoveSync(path25, options);
+    if (_optionalChain([fer, 'optionalAccess', _214 => _214.code]) === "ENOTEMPTY") {
+      return rimrafMoveRemoveSync(path27, options);
     }
     throw er;
   }
@@ -10107,35 +10253,35 @@ var rimrafWindowsDirMoveRemoveFallbackSync = (path25, opt) => {
 var START = Symbol("start");
 var CHILD = Symbol("child");
 var FINISH = Symbol("finish");
-var rimrafWindows = async (path25, opt) => {
-  if (_optionalChain([opt, 'optionalAccess', _203 => _203.signal, 'optionalAccess', _204 => _204.aborted])) {
+var rimrafWindows = async (path27, opt) => {
+  if (_optionalChain([opt, 'optionalAccess', _215 => _215.signal, 'optionalAccess', _216 => _216.aborted])) {
     throw opt.signal.reason;
   }
   try {
-    return await rimrafWindowsDir(path25, opt, await lstat7(path25), START);
+    return await rimrafWindowsDir(path27, opt, await lstat7(path27), START);
   } catch (er) {
-    if (_optionalChain([er, 'optionalAccess', _205 => _205.code]) === "ENOENT")
+    if (_optionalChain([er, 'optionalAccess', _217 => _217.code]) === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafWindowsSync = (path25, opt) => {
-  if (_optionalChain([opt, 'optionalAccess', _206 => _206.signal, 'optionalAccess', _207 => _207.aborted])) {
+var rimrafWindowsSync = (path27, opt) => {
+  if (_optionalChain([opt, 'optionalAccess', _218 => _218.signal, 'optionalAccess', _219 => _219.aborted])) {
     throw opt.signal.reason;
   }
   try {
-    return rimrafWindowsDirSync(path25, opt, _fs.lstatSync.call(void 0, path25), START);
+    return rimrafWindowsDirSync(path27, opt, _fs.lstatSync.call(void 0, path27), START);
   } catch (er) {
-    if (_optionalChain([er, 'optionalAccess', _208 => _208.code]) === "ENOENT")
+    if (_optionalChain([er, 'optionalAccess', _220 => _220.code]) === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafWindowsDir = async (path25, opt, ent, state = START) => {
-  if (_optionalChain([opt, 'optionalAccess', _209 => _209.signal, 'optionalAccess', _210 => _210.aborted])) {
+var rimrafWindowsDir = async (path27, opt, ent, state = START) => {
+  if (_optionalChain([opt, 'optionalAccess', _221 => _221.signal, 'optionalAccess', _222 => _222.aborted])) {
     throw opt.signal.reason;
   }
-  const entries = ent.isDirectory() ? await readdirOrError(path25) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path27) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -10145,32 +10291,32 @@ var rimrafWindowsDir = async (path25, opt, ent, state = START) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path25, ent)) {
+    if (opt.filter && !await opt.filter(path27, ent)) {
       return false;
     }
-    await ignoreENOENT(rimrafWindowsFile(path25, opt));
+    await ignoreENOENT(rimrafWindowsFile(path27, opt));
     return true;
   }
   const s = state === START ? CHILD : state;
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafWindowsDir(_path.resolve.call(void 0, path25, ent2.name), opt, ent2, s)))).reduce((a, b) => a && b, true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafWindowsDir(_path.resolve.call(void 0, path27, ent2.name), opt, ent2, s)))).reduce((a, b) => a && b, true);
   if (state === START) {
-    return rimrafWindowsDir(path25, opt, ent, FINISH);
+    return rimrafWindowsDir(path27, opt, ent, FINISH);
   } else if (state === FINISH) {
-    if (opt.preserveRoot === false && path25 === _path.parse.call(void 0, path25).root) {
+    if (opt.preserveRoot === false && path27 === _path.parse.call(void 0, path27).root) {
       return false;
     }
     if (!removedAll) {
       return false;
     }
-    if (opt.filter && !await opt.filter(path25, ent)) {
+    if (opt.filter && !await opt.filter(path27, ent)) {
       return false;
     }
-    await ignoreENOENT(rimrafWindowsDirMoveRemoveFallback(path25, opt));
+    await ignoreENOENT(rimrafWindowsDirMoveRemoveFallback(path27, opt));
   }
   return true;
 };
-var rimrafWindowsDirSync = (path25, opt, ent, state = START) => {
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path25) : null;
+var rimrafWindowsDirSync = (path27, opt, ent, state = START) => {
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path27) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -10180,32 +10326,32 @@ var rimrafWindowsDirSync = (path25, opt, ent, state = START) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path25, ent)) {
+    if (opt.filter && !opt.filter(path27, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => rimrafWindowsFileSync(path25, opt));
+    ignoreENOENTSync(() => rimrafWindowsFileSync(path27, opt));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
     const s = state === START ? CHILD : state;
-    const p = _path.resolve.call(void 0, path25, ent2.name);
+    const p = _path.resolve.call(void 0, path27, ent2.name);
     removedAll = rimrafWindowsDirSync(p, opt, ent2, s) && removedAll;
   }
   if (state === START) {
-    return rimrafWindowsDirSync(path25, opt, ent, FINISH);
+    return rimrafWindowsDirSync(path27, opt, ent, FINISH);
   } else if (state === FINISH) {
-    if (opt.preserveRoot === false && path25 === _path.parse.call(void 0, path25).root) {
+    if (opt.preserveRoot === false && path27 === _path.parse.call(void 0, path27).root) {
       return false;
     }
     if (!removedAll) {
       return false;
     }
-    if (opt.filter && !opt.filter(path25, ent)) {
+    if (opt.filter && !opt.filter(path27, ent)) {
       return false;
     }
     ignoreENOENTSync(() => {
-      rimrafWindowsDirMoveRemoveFallbackSync(path25, opt);
+      rimrafWindowsDirMoveRemoveFallbackSync(path27, opt);
     });
   }
   return true;
@@ -10218,16 +10364,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 (path25, opt) => {
-  await rm2(path25, {
+var rimrafNative = async (path27, opt) => {
+  await rm2(path27, {
     ...opt,
     force: true,
     recursive: true
   });
   return true;
 };
-var rimrafNativeSync = (path25, opt) => {
-  _fs.rmSync.call(void 0, path25, {
+var rimrafNativeSync = (path27, opt) => {
+  _fs.rmSync.call(void 0, path27, {
     ...opt,
     force: true,
     recursive: true
@@ -10241,30 +10387,30 @@ var version = process.env.__TESTING_RIMRAF_NODE_VERSION__ || process.version;
 var versArr = version.replace(/^v/, "").split(".");
 var [major = 0, minor = 0] = versArr.map((v) => parseInt(v, 10));
 var hasNative = major > 14 || major === 14 && minor >= 14;
-var useNative = !hasNative || platform_default === "win32" ? () => false : (opt) => !_optionalChain([opt, 'optionalAccess', _211 => _211.signal]) && !_optionalChain([opt, 'optionalAccess', _212 => _212.filter]);
-var useNativeSync = !hasNative || platform_default === "win32" ? () => false : (opt) => !_optionalChain([opt, 'optionalAccess', _213 => _213.signal]) && !_optionalChain([opt, 'optionalAccess', _214 => _214.filter]);
+var useNative = !hasNative || platform_default === "win32" ? () => false : (opt) => !_optionalChain([opt, 'optionalAccess', _223 => _223.signal]) && !_optionalChain([opt, 'optionalAccess', _224 => _224.filter]);
+var useNativeSync = !hasNative || platform_default === "win32" ? () => false : (opt) => !_optionalChain([opt, 'optionalAccess', _225 => _225.signal]) && !_optionalChain([opt, 'optionalAccess', _226 => _226.filter]);
 
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/index.js
-var wrap = (fn) => async (path25, opt) => {
+var wrap = (fn) => async (path27, opt) => {
   const options = optArg(opt);
   if (options.glob) {
-    path25 = await glob(path25, options.glob);
+    path27 = await glob(path27, options.glob);
   }
-  if (Array.isArray(path25)) {
-    return !!(await Promise.all(path25.map((p) => fn(path_arg_default(p, options), options)))).reduce((a, b) => a && b, true);
+  if (Array.isArray(path27)) {
+    return !!(await Promise.all(path27.map((p) => fn(path_arg_default(p, options), options)))).reduce((a, b) => a && b, true);
   } else {
-    return !!await fn(path_arg_default(path25, options), options);
+    return !!await fn(path_arg_default(path27, options), options);
   }
 };
-var wrapSync = (fn) => (path25, opt) => {
+var wrapSync = (fn) => (path27, opt) => {
   const options = optArgSync(opt);
   if (options.glob) {
-    path25 = globSync(path25, options.glob);
+    path27 = globSync(path27, options.glob);
   }
-  if (Array.isArray(path25)) {
-    return !!path25.map((p) => fn(path_arg_default(p, options), options)).reduce((a, b) => a && b, true);
+  if (Array.isArray(path27)) {
+    return !!path27.map((p) => fn(path_arg_default(p, options), options)).reduce((a, b) => a && b, true);
   } else {
-    return !!fn(path_arg_default(path25, options), options);
+    return !!fn(path_arg_default(path27, options), options);
   }
 };
 var nativeSync = wrapSync(rimrafNativeSync);
@@ -10279,8 +10425,8 @@ var moveRemoveSync = wrapSync(rimrafMoveRemoveSync);
 var moveRemove = Object.assign(wrap(rimrafMoveRemove), {
   sync: moveRemoveSync
 });
-var rimrafSync = wrapSync((path25, opt) => useNativeSync(opt) ? rimrafNativeSync(path25, opt) : rimrafManualSync(path25, opt));
-var rimraf_ = wrap((path25, opt) => useNative(opt) ? rimrafNative(path25, opt) : rimrafManual(path25, opt));
+var rimrafSync = wrapSync((path27, opt) => useNativeSync(opt) ? rimrafNativeSync(path27, opt) : rimrafManualSync(path27, opt));
+var rimraf_ = wrap((path27, opt) => useNative(opt) ? rimrafNative(path27, opt) : rimrafManual(path27, opt));
 var rimraf = Object.assign(rimraf_, {
   rimraf: rimraf_,
   sync: rimrafSync,
@@ -10317,7 +10463,7 @@ function createBuildService(ctx) {
   function checkWorkersOptions() {
     const workersDir = scanService.workersDir;
     const hasWorkersDir = Boolean(workersDir);
-    if (hasWorkersDir && _optionalChain([configService, 'access', _215 => _215.weappViteConfig, 'optionalAccess', _216 => _216.worker, 'optionalAccess', _217 => _217.entry]) === void 0) {
+    if (hasWorkersDir && _optionalChain([configService, 'access', _227 => _227.weappViteConfig, 'optionalAccess', _228 => _228.worker, 'optionalAccess', _229 => _229.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");
@@ -10354,7 +10500,7 @@ function createBuildService(ctx) {
                       return "vendors";
                     }
                     const moduleInfo = ctxPlugin.getModuleInfo(id);
-                    if (_optionalChain([moduleInfo, 'optionalAccess', _218 => _218.importers, 'optionalAccess', _219 => _219.length]) && moduleInfo.importers.length > 1) {
+                    if (_optionalChain([moduleInfo, 'optionalAccess', _230 => _230.importers, 'optionalAccess', _231 => _231.length]) && moduleInfo.importers.length > 1) {
                       const summary = moduleInfo.importers.reduce((acc, cur) => {
                         const relPath = configService.relativeAbsoluteSrcRoot(cur);
                         const prefix2 = _nullishCoalesce([
@@ -10383,7 +10529,7 @@ function createBuildService(ctx) {
     if (_process2.default.env.NODE_ENV === void 0) {
       _process2.default.env.NODE_ENV = "development";
     }
-    _optionalChain([debug, 'optionalCall', _220 => _220("dev build watcher start")]);
+    _optionalChain([debug, 'optionalCall', _232 => _232("dev build watcher start")]);
     const buildOptions = configService.merge(void 0, sharedBuildConfig());
     const watcher = await _vite.build.call(void 0, 
       buildOptions
@@ -10404,8 +10550,8 @@ function createBuildService(ctx) {
         }
       });
     }
-    _optionalChain([debug, 'optionalCall', _221 => _221("dev build watcher end")]);
-    _optionalChain([debug, 'optionalCall', _222 => _222("dev watcher listen start")]);
+    _optionalChain([debug, 'optionalCall', _233 => _233("dev build watcher end")]);
+    _optionalChain([debug, 'optionalCall', _234 => _234("dev watcher listen start")]);
     let startTime;
     let resolveWatcher;
     let rejectWatcher;
@@ -10428,7 +10574,7 @@ function createBuildService(ctx) {
     return watcher;
   }
   async function runProd() {
-    _optionalChain([debug, 'optionalCall', _223 => _223("prod build start")]);
+    _optionalChain([debug, 'optionalCall', _235 => _235("prod build start")]);
     const output = await _vite.build.call(void 0, 
       configService.merge(void 0, sharedBuildConfig())
     );
@@ -10436,7 +10582,7 @@ function createBuildService(ctx) {
     if (hasWorkersDir) {
       await buildWorkers();
     }
-    _optionalChain([debug, 'optionalCall', _224 => _224("prod build end")]);
+    _optionalChain([debug, 'optionalCall', _236 => _236("prod build end")]);
     return output;
   }
   async function buildEntry(options) {
@@ -10456,12 +10602,12 @@ function createBuildService(ctx) {
           }
         }
       );
-      _optionalChain([debug, 'optionalCall', _225 => _225("deletedFilePaths", deletedFilePaths)]);
+      _optionalChain([debug, 'optionalCall', _237 => _237("deletedFilePaths", deletedFilePaths)]);
       logger_default.success(`\u5DF2\u6E05\u7A7A ${configService.mpDistRoot} \u76EE\u5F55`);
     }
-    _optionalChain([debug, 'optionalCall', _226 => _226("build start")]);
+    _optionalChain([debug, 'optionalCall', _238 => _238("build start")]);
     let npmBuildTask = Promise.resolve();
-    if (!_optionalChain([options, 'optionalAccess', _227 => _227.skipNpm])) {
+    if (!_optionalChain([options, 'optionalAccess', _239 => _239.skipNpm])) {
       let shouldBuildNpm = true;
       if (configService.isDev) {
         const isDependenciesOutdated = await npmService.checkDependenciesCacheOutdate();
@@ -10488,7 +10634,7 @@ function createBuildService(ctx) {
       result = await runProd();
     }
     await npmBuildTask;
-    _optionalChain([debug, 'optionalCall', _228 => _228("build end")]);
+    _optionalChain([debug, 'optionalCall', _240 => _240("build end")]);
     return result;
   }
   return {
@@ -16154,17 +16300,17 @@ function withTrailingSlash(input = "", respectQueryAndFragment) {
   if (hasTrailingSlash(input, true)) {
     return input || "/";
   }
-  let path25 = input;
+  let path27 = input;
   let fragment = "";
   const fragmentIndex = input.indexOf("#");
   if (fragmentIndex !== -1) {
-    path25 = input.slice(0, fragmentIndex);
+    path27 = input.slice(0, fragmentIndex);
     fragment = input.slice(fragmentIndex);
-    if (!path25) {
+    if (!path27) {
       return fragment;
     }
   }
-  const [s0, ...s] = path25.split("?");
+  const [s0, ...s] = path27.split("?");
   return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
 }
 function isNonEmptyURL(url) {
@@ -16193,8 +16339,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(path25) {
-  return path25.replace(/\\/g, "/");
+function normalizeSlash(path27) {
+  return path27.replace(/\\/g, "/");
 }
 var own$1 = {}.hasOwnProperty;
 var classRegExp = /^([A-Z][a-z\d]*)+$/;
@@ -16307,8 +16453,8 @@ codes2.ERR_INVALID_PACKAGE_CONFIG = createError(
    * @param {string} [base]
    * @param {string} [message]
    */
-  (path25, base, message) => {
-    return `Invalid package config ${path25}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+  (path27, base, message) => {
+    return `Invalid package config ${path27}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
   },
   Error
 );
@@ -16340,8 +16486,8 @@ codes2.ERR_MODULE_NOT_FOUND = createError(
    * @param {string} base
    * @param {boolean} [exactUrl]
    */
-  (path25, base, exactUrl = false) => {
-    return `Cannot find ${exactUrl ? "module" : "package"} '${path25}' imported from ${base}`;
+  (path27, base, exactUrl = false) => {
+    return `Cannot find ${exactUrl ? "module" : "package"} '${path27}' imported from ${base}`;
   },
   Error
 );
@@ -16392,8 +16538,8 @@ codes2.ERR_UNKNOWN_FILE_EXTENSION = createError(
    * @param {string} extension
    * @param {string} path
    */
-  (extension, path25) => {
-    return `Unknown file extension "${extension}" for ${path25}`;
+  (extension, path27) => {
+    return `Unknown file extension "${extension}" for ${path27}`;
   },
   TypeError
 );
@@ -16764,9 +16910,9 @@ Default "index" lookups for the main are deprecated for ES modules.`,
     );
   }
 }
-function tryStatSync(path25) {
+function tryStatSync(path27) {
   try {
-    return _fs.statSync.call(void 0, path25);
+    return _fs.statSync.call(void 0, path27);
   } catch (e6) {
   }
 }
@@ -17439,7 +17585,7 @@ function _tryModuleResolve(id, url, conditions) {
   try {
     return moduleResolve(id, url, conditions);
   } catch (error) {
-    if (!NOT_FOUND_ERRORS.has(_optionalChain([error, 'optionalAccess', _229 => _229.code]))) {
+    if (!NOT_FOUND_ERRORS.has(_optionalChain([error, 'optionalAccess', _241 => _241.code]))) {
       throw error;
     }
   }
@@ -17468,7 +17614,7 @@ function _resolve(id, options = {}) {
         return pathToFileURL(id);
       }
     } catch (error) {
-      if (_optionalChain([error, 'optionalAccess', _230 => _230.code]) !== "ENOENT") {
+      if (_optionalChain([error, 'optionalAccess', _242 => _242.code]) !== "ENOENT") {
         throw error;
       }
     }
@@ -17612,10 +17758,10 @@ function fromGeneratorFn(generatorFn, options) {
   return fromObject({
     name: generatorFn.name,
     async(...args) {
-      return iterateAsync(generatorFn.apply(this, args), _optionalChain([options, 'optionalAccess', _231 => _231.onYield]));
+      return iterateAsync(generatorFn.apply(this, args), _optionalChain([options, 'optionalAccess', _243 => _243.onYield]));
     },
     sync(...args) {
-      return iterateSync2(generatorFn.apply(this, args), _optionalChain([options, 'optionalAccess', _232 => _232.onYield]));
+      return iterateSync2(generatorFn.apply(this, args), _optionalChain([options, 'optionalAccess', _244 => _244.onYield]));
     }
   });
 }
@@ -17674,7 +17820,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', _233 => _233.isFile, 'call', _234 => _234()]) || type === "directory" && _optionalChain([stats, 'optionalAccess', _235 => _235.isDirectory, 'call', _236 => _236()])) {
+      if (type === "file" && _optionalChain([stats, 'optionalAccess', _245 => _245.isFile, 'call', _246 => _246()]) || type === "directory" && _optionalChain([stats, 'optionalAccess', _247 => _247.isDirectory, 'call', _248 => _248()])) {
         return filePath;
       }
     } catch (e9) {
@@ -17685,7 +17831,7 @@ function findUpSync(name, {
     directory = sysPath2.default.dirname(directory);
   }
 }
-function _resolve2(path25, options = {}) {
+function _resolve2(path27, options = {}) {
   if (options.platform === "auto" || !options.platform)
     options.platform = _process2.default.platform === "win32" ? "win32" : "posix";
   if (_process2.default.versions.pnp) {
@@ -17694,11 +17840,11 @@ function _resolve2(path25, options = {}) {
       paths.push(_process2.default.cwd());
     const targetRequire = _module.createRequire.call(void 0, _chunkOS76JPG2cjs.importMetaUrl);
     try {
-      return targetRequire.resolve(path25, { paths });
+      return targetRequire.resolve(path27, { paths });
     } catch (e10) {
     }
   }
-  const modulePath = resolvePathSync(path25, {
+  const modulePath = resolvePathSync(path27, {
     url: options.paths
   });
   if (options.platform === "win32")
@@ -17769,10 +17915,10 @@ var findUp = quansync2({
   async: findUp$1
 });
 var loadPackageJSON = quansync2(function* (cwd = _process2.default.cwd()) {
-  const path25 = yield findUp("package.json", { cwd });
-  if (!path25 || !actualFS.default.existsSync(path25))
+  const path27 = yield findUp("package.json", { cwd });
+  if (!path27 || !actualFS.default.existsSync(path27))
     return null;
-  return JSON.parse(yield readFile(path25));
+  return JSON.parse(yield readFile(path27));
 });
 var loadPackageJSONSync = loadPackageJSON.sync;
 var isPackageListed = quansync2(function* (name, cwd) {
@@ -17825,9 +17971,9 @@ var INSTALL_METADATA = {
 };
 
 // ../../node_modules/.pnpm/package-manager-detector@1.4.0/node_modules/package-manager-detector/dist/detect.mjs
-async function pathExists(path25, type) {
+async function pathExists(path27, type) {
   try {
-    const stat6 = await _promises2.default.stat(path25);
+    const stat6 = await _promises2.default.stat(path27);
     return type === "file" ? stat6.isFile() : stat6.isDirectory();
   } catch (e13) {
     return false;
@@ -17893,18 +18039,18 @@ async function detect(options = {}) {
         }
       }
     }
-    if (_optionalChain([stopDir, 'optionalCall', _237 => _237(directory)]))
+    if (_optionalChain([stopDir, 'optionalCall', _249 => _249(directory)]))
       break;
   }
   return null;
 }
 function getNameAndVer(pkg) {
-  const handelVer = (version3) => _nullishCoalesce(_optionalChain([version3, 'optionalAccess', _238 => _238.match, 'call', _239 => _239(/\d+(\.\d+){0,2}/), 'optionalAccess', _240 => _240[0]]), () => ( version3));
+  const handelVer = (version3) => _nullishCoalesce(_optionalChain([version3, 'optionalAccess', _250 => _250.match, 'call', _251 => _251(/\d+(\.\d+){0,2}/), 'optionalAccess', _252 => _252[0]]), () => ( version3));
   if (typeof pkg.packageManager === "string") {
     const [name, ver] = pkg.packageManager.replace(/^\^/, "").split("@");
     return { name, ver: handelVer(ver) };
   }
-  if (typeof _optionalChain([pkg, 'access', _241 => _241.devEngines, 'optionalAccess', _242 => _242.packageManager, 'optionalAccess', _243 => _243.name]) === "string") {
+  if (typeof _optionalChain([pkg, 'access', _253 => _253.devEngines, 'optionalAccess', _254 => _254.packageManager, 'optionalAccess', _255 => _255.name]) === "string") {
     return {
       name: pkg.devEngines.packageManager.name,
       ver: handelVer(pkg.devEngines.packageManager.version)
@@ -17932,7 +18078,7 @@ async function handlePackageManager(filepath, onUnknown) {
         agent = name;
         return { name, agent, version: version3 };
       } else {
-        return _nullishCoalesce(_optionalChain([onUnknown, 'optionalCall', _244 => _244(pkg.packageManager)]), () => ( null));
+        return _nullishCoalesce(_optionalChain([onUnknown, 'optionalCall', _256 => _256(pkg.packageManager)]), () => ( null));
       }
     }
   } catch (e14) {
@@ -18057,7 +18203,7 @@ function createAssetCollector(state) {
     },
     async buildEnd() {
       const assets = await state.pendingAssets;
-      if (!_optionalChain([assets, 'optionalAccess', _245 => _245.length])) {
+      if (!_optionalChain([assets, 'optionalAccess', _257 => _257.length])) {
         return;
       }
       for (const candidate of assets) {
@@ -18072,9 +18218,9 @@ function createAssetCollector(state) {
 }
 function scanAssetFiles(configService, config) {
   const weappViteConfig = configService.weappViteConfig;
-  const include = normalizeCopyGlobs(_optionalChain([weappViteConfig, 'optionalAccess', _246 => _246.copy, 'optionalAccess', _247 => _247.include]));
-  const exclude = normalizeCopyGlobs(_optionalChain([weappViteConfig, 'optionalAccess', _248 => _248.copy, 'optionalAccess', _249 => _249.exclude]));
-  const filter3 = _nullishCoalesce(_optionalChain([weappViteConfig, 'optionalAccess', _250 => _250.copy, 'optionalAccess', _251 => _251.filter]), () => ( (() => true)));
+  const include = normalizeCopyGlobs(_optionalChain([weappViteConfig, 'optionalAccess', _258 => _258.copy, 'optionalAccess', _259 => _259.include]));
+  const exclude = normalizeCopyGlobs(_optionalChain([weappViteConfig, 'optionalAccess', _260 => _260.copy, 'optionalAccess', _261 => _261.exclude]));
+  const filter3 = _nullishCoalesce(_optionalChain([weappViteConfig, 'optionalAccess', _262 => _262.copy, 'optionalAccess', _263 => _263.filter]), () => ( (() => true)));
   const ignore = [
     ...defaultExcluded,
     _pathe2.default.resolve(configService.cwd, `${config.build.outDir}/**/*`),
@@ -18127,13 +18273,13 @@ function createAutoImportPlugin(state) {
       if (!state.resolvedConfig) {
         return;
       }
-      const globs = _optionalChain([configService, 'access', _252 => _252.weappViteConfig, 'optionalAccess', _253 => _253.enhance, 'optionalAccess', _254 => _254.autoImportComponents, 'optionalAccess', _255 => _255.globs]);
-      const globsKey = _nullishCoalesce(_optionalChain([globs, 'optionalAccess', _256 => _256.join, 'call', _257 => _257("\0")]), () => ( ""));
+      const globs = _optionalChain([configService, 'access', _264 => _264.weappViteConfig, 'optionalAccess', _265 => _265.enhance, 'optionalAccess', _266 => _266.autoImportComponents, 'optionalAccess', _267 => _267.globs]);
+      const globsKey = _nullishCoalesce(_optionalChain([globs, 'optionalAccess', _268 => _268.join, 'call', _269 => _269("\0")]), () => ( ""));
       if (globsKey !== state.lastGlobsKey) {
         state.initialScanDone = false;
         state.lastGlobsKey = globsKey;
       }
-      if (!_optionalChain([globs, 'optionalAccess', _258 => _258.length])) {
+      if (!_optionalChain([globs, 'optionalAccess', _270 => _270.length])) {
         return;
       }
       if (state.initialScanDone) {
@@ -19451,7 +19597,7 @@ function createCacheKey(options) {
   return `${options.removeComment ? 1 : 0}|${options.transformEvent ? 1 : 0}`;
 }
 function getCachedResult(data2, cacheKey) {
-  return _optionalChain([handleCache, 'access', _259 => _259.get, 'call', _260 => _260(data2), 'optionalAccess', _261 => _261.get, 'call', _262 => _262(cacheKey)]);
+  return _optionalChain([handleCache, 'access', _271 => _271.get, 'call', _272 => _272(data2), 'optionalAccess', _273 => _273.get, 'call', _274 => _274(cacheKey)]);
 }
 function setCachedResult(data2, cacheKey, result) {
   let cacheForToken = handleCache.get(data2);
@@ -19527,7 +19673,7 @@ function handleWxml(data2, options) {
   if (shouldTransformInlineWxs) {
     for (const { end, start, value } of inlineWxsTokens) {
       const { result } = getCachedInlineWxsTransform(value);
-      if (_optionalChain([result, 'optionalAccess', _263 => _263.code])) {
+      if (_optionalChain([result, 'optionalAccess', _275 => _275.code])) {
         ms.update(start, end, `
 ${result.code}`);
       }
@@ -19607,7 +19753,7 @@ function createChunkEmitter(configService, loadedEntrySet, debug4) {
         // @ts-ignore
         preserveSignature: "exports-only"
       });
-      _optionalChain([debug4, 'optionalCall', _264 => _264(`load ${fileName} \u8017\u65F6 ${(_perf_hooks.performance.now() - start).toFixed(2)}ms`)]);
+      _optionalChain([debug4, 'optionalCall', _276 => _276(`load ${fileName} \u8017\u65F6 ${(_perf_hooks.performance.now() - start).toFixed(2)}ms`)]);
     });
   };
 }
@@ -19844,7 +19990,7 @@ function createEntryLoader(options) {
       normalizedEntries,
       configService.absoluteSrcRoot
     );
-    _optionalChain([debug4, 'optionalCall', _265 => _265(`resolvedIds ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
+    _optionalChain([debug4, 'optionalCall', _277 => _277(`resolvedIds ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
     const pendingResolvedIds = [];
     for (const { entry, resolvedId } of resolvedIds) {
       if (!resolvedId) {
@@ -19859,7 +20005,7 @@ function createEntryLoader(options) {
     if (pendingResolvedIds.length) {
       await Promise.all(emitEntriesChunks.call(this, pendingResolvedIds));
     }
-    _optionalChain([debug4, 'optionalCall', _266 => _266(`emitEntriesChunks ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
+    _optionalChain([debug4, 'optionalCall', _278 => _278(`emitEntriesChunks ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
     registerJsonAsset({
       jsonPath,
       json,
@@ -19867,7 +20013,7 @@ function createEntryLoader(options) {
     });
     const code = await _fsextra2.default.readFile(id, "utf8");
     const styleImports = await collectStyleImports(this, id, existsCache);
-    _optionalChain([debug4, 'optionalCall', _267 => _267(`loadEntry ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
+    _optionalChain([debug4, 'optionalCall', _279 => _279(`loadEntry ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
     if (styleImports.length === 0) {
       return {
         code
@@ -19938,7 +20084,7 @@ function createTemplateScanner(wxmlService, debug4) {
       const { components: components2 } = wxmlToken;
       wxmlService.setWxmlComponentsMap(templateEntry, components2);
     }
-    _optionalChain([debug4, 'optionalCall', _268 => _268(`scanTemplateEntry ${templateEntry} \u8017\u65F6 ${(_perf_hooks.performance.now() - start).toFixed(2)}ms`)]);
+    _optionalChain([debug4, 'optionalCall', _280 => _280(`scanTemplateEntry ${templateEntry} \u8017\u65F6 ${(_perf_hooks.performance.now() - start).toFixed(2)}ms`)]);
   };
 }
 
@@ -20221,7 +20367,7 @@ function createCoreLifecyclePlugin(state) {
       options.input = scannedInput;
     },
     async load(id) {
-      _optionalChain([configService, 'access', _269 => _269.weappViteConfig, 'optionalAccess', _270 => _270.debug, 'optionalAccess', _271 => _271.load, 'optionalCall', _272 => _272(id, subPackageMeta)]);
+      _optionalChain([configService, 'access', _281 => _281.weappViteConfig, 'optionalAccess', _282 => _282.debug, 'optionalAccess', _283 => _283.load, 'optionalCall', _284 => _284(id, subPackageMeta)]);
       const relativeBasename = _shared.removeExtensionDeep.call(void 0, configService.relativeAbsoluteSrcRoot(id));
       if (isCSSRequest(id)) {
         const parsed = parseRequest(id);
@@ -20235,7 +20381,7 @@ function createCoreLifecyclePlugin(state) {
         }
         return null;
       }
-      if (loadedEntrySet.has(id) || _optionalChain([subPackageMeta, 'optionalAccess', _273 => _273.entries, 'access', _274 => _274.includes, 'call', _275 => _275(relativeBasename)])) {
+      if (loadedEntrySet.has(id) || _optionalChain([subPackageMeta, 'optionalAccess', _285 => _285.entries, 'access', _286 => _286.includes, 'call', _287 => _287(relativeBasename)])) {
         return await loadEntry.call(this, id, "component");
       }
       if (relativeBasename === "app") {
@@ -20248,10 +20394,10 @@ function createCoreLifecyclePlugin(state) {
     },
     async generateBundle() {
       await flushIndependentBuilds.call(this, state, watcherService);
-      if (_optionalChain([configService, 'access', _276 => _276.weappViteConfig, 'optionalAccess', _277 => _277.debug, 'optionalAccess', _278 => _278.watchFiles])) {
+      if (_optionalChain([configService, 'access', _288 => _288.weappViteConfig, 'optionalAccess', _289 => _289.debug, 'optionalAccess', _290 => _290.watchFiles])) {
         const watcherService2 = ctx.watcherService;
-        const watcherRoot = _nullishCoalesce(_optionalChain([subPackageMeta, 'optionalAccess', _279 => _279.subPackage, 'access', _280 => _280.root]), () => ( "/"));
-        const watcher = _optionalChain([watcherService2, 'optionalAccess', _281 => _281.getRollupWatcher, 'call', _282 => _282(watcherRoot)]);
+        const watcherRoot = _nullishCoalesce(_optionalChain([subPackageMeta, 'optionalAccess', _291 => _291.subPackage, 'access', _292 => _292.root]), () => ( "/"));
+        const watcher = _optionalChain([watcherService2, 'optionalAccess', _293 => _293.getRollupWatcher, 'call', _294 => _294(watcherRoot)]);
         let watchFiles;
         if (watcher && typeof watcher.getWatchFiles === "function") {
           watchFiles = await watcher.getWatchFiles();
@@ -20265,7 +20411,7 @@ function createCoreLifecyclePlugin(state) {
       }
     },
     buildEnd() {
-      _optionalChain([debug2, 'optionalCall', _283 => _283(`${subPackageMeta ? `\u72EC\u7ACB\u5206\u5305 ${subPackageMeta.subPackage.root}` : "\u4E3B\u5305"} ${Array.from(this.getModuleIds()).length} \u4E2A\u6A21\u5757\u88AB\u7F16\u8BD1`)]);
+      _optionalChain([debug2, 'optionalCall', _295 => _295(`${subPackageMeta ? `\u72EC\u7ACB\u5206\u5305 ${subPackageMeta.subPackage.root}` : "\u4E3B\u5305"} ${Array.from(this.getModuleIds()).length} \u4E2A\u6A21\u5757\u88AB\u7F16\u8BD1`)]);
     }
   };
 }
@@ -20621,14 +20767,14 @@ function createPluginPruner() {
     name: "weapp-vite:preflight",
     enforce: "pre",
     configResolved(config) {
-      if (!_optionalChain([config, 'access', _284 => _284.plugins, 'optionalAccess', _285 => _285.length])) {
+      if (!_optionalChain([config, 'access', _296 => _296.plugins, 'optionalAccess', _297 => _297.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', _286 => _286("remove plugin", plugin.name)]);
+          plugin && _optionalChain([debug3, 'optionalCall', _298 => _298("remove plugin", plugin.name)]);
         }
       }
     }
@@ -20667,8 +20813,8 @@ function createWorkerBuildPlugin(ctx) {
     name: "weapp-vite:workers",
     enforce: "pre",
     async options(options) {
-      const workerConfig = _optionalChain([configService, 'access', _287 => _287.weappViteConfig, 'optionalAccess', _288 => _288.worker]);
-      const entries = Array.isArray(_optionalChain([workerConfig, 'optionalAccess', _289 => _289.entry])) ? workerConfig.entry : [_optionalChain([workerConfig, 'optionalAccess', _290 => _290.entry])];
+      const workerConfig = _optionalChain([configService, 'access', _299 => _299.weappViteConfig, 'optionalAccess', _300 => _300.worker]);
+      const entries = Array.isArray(_optionalChain([workerConfig, 'optionalAccess', _301 => _301.entry])) ? workerConfig.entry : [_optionalChain([workerConfig, 'optionalAccess', _302 => _302.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;
@@ -20785,7 +20931,7 @@ async function transformWxsFile(state, wxsPath) {
     const { result, importees } = transformWxsCode(rawCode, {
       filename: wxsPath
     });
-    if (typeof _optionalChain([result, 'optionalAccess', _291 => _291.code]) === "string") {
+    if (typeof _optionalChain([result, 'optionalAccess', _303 => _303.code]) === "string") {
       code = result.code;
     }
     const dirname5 = _pathe2.default.dirname(wxsPath);
@@ -20835,13 +20981,13 @@ function vitePluginWeappWorkers(ctx) {
 }
 function attachRuntimePlugins(ctx, plugins) {
   const runtimePlugins = ctx[RUNTIME_PLUGINS_SYMBOL];
-  if (!_optionalChain([runtimePlugins, 'optionalAccess', _292 => _292.length])) {
+  if (!_optionalChain([runtimePlugins, 'optionalAccess', _304 => _304.length])) {
     return plugins;
   }
   return [...runtimePlugins, ...plugins];
 }
 function applyInspect(ctx, plugins) {
-  const inspectOptions = _optionalChain([ctx, 'access', _293 => _293.configService, 'access', _294 => _294.weappViteConfig, 'optionalAccess', _295 => _295.debug, 'optionalAccess', _296 => _296.inspect]);
+  const inspectOptions = _optionalChain([ctx, 'access', _305 => _305.configService, 'access', _306 => _306.weappViteConfig, 'optionalAccess', _307 => _307.debug, 'optionalAccess', _308 => _308.inspect]);
   if (!inspectOptions) {
     return plugins;
   }
@@ -20921,7 +21067,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', _297 => _297[1]]);
+  return _optionalChain([match2, 'optionalAccess', _309 => _309[1]]);
 }
 function createOxcRuntimeSupport() {
   const oxcRuntimeInfo = getPackageInfoSync("@oxc-project/runtime");
@@ -21117,17 +21263,27 @@ function createConfigService(ctx) {
     if (resolvedConfigFile && !_pathe2.default.isAbsolute(resolvedConfigFile)) {
       resolvedConfigFile = _pathe2.default.resolve(cwd, resolvedConfigFile);
     }
+    const weappConfigFilePath = await resolveWeappConfigFile({
+      root: cwd,
+      specified: resolvedConfigFile
+    });
     const loaded = await _vite.loadConfigFromFile.call(void 0, {
       command: isDev ? "serve" : "build",
       mode
     }, resolvedConfigFile, cwd);
-    const loadedConfig = _optionalChain([loaded, 'optionalAccess', _298 => _298.config]);
-    const srcRoot = _nullishCoalesce(_optionalChain([loadedConfig, 'optionalAccess', _299 => _299.weapp, 'optionalAccess', _300 => _300.srcRoot]), () => ( ""));
-    function relativeSrcRoot(p) {
-      if (srcRoot) {
-        return _pathe2.default.relative(srcRoot, p);
+    const loadedConfig = _optionalChain([loaded, 'optionalAccess', _310 => _310.config]);
+    let weappLoaded;
+    if (weappConfigFilePath) {
+      const normalizedWeappPath = _pathe2.default.resolve(weappConfigFilePath);
+      const normalizedLoadedPath = _optionalChain([loaded, 'optionalAccess', _311 => _311.path]) ? _pathe2.default.resolve(loaded.path) : void 0;
+      if (normalizedLoadedPath && normalizedLoadedPath === normalizedWeappPath) {
+        weappLoaded = loaded;
+      } else {
+        weappLoaded = await _vite.loadConfigFromFile.call(void 0, {
+          command: isDev ? "serve" : "build",
+          mode
+        }, weappConfigFilePath, cwd);
       }
-      return p;
     }
     const config = _shared.defu.call(void 0, 
       inlineConfig,
@@ -21153,6 +21309,19 @@ function createConfigService(ctx) {
         weapp: getWeappViteConfig()
       }
     );
+    if (_optionalChain([weappLoaded, 'optionalAccess', _312 => _312.config, 'optionalAccess', _313 => _313.weapp])) {
+      config.weapp = _shared.defu.call(void 0, 
+        weappLoaded.config.weapp,
+        _nullishCoalesce(config.weapp, () => ( {}))
+      );
+    }
+    const srcRoot = _nullishCoalesce(_optionalChain([config, 'access', _314 => _314.weapp, 'optionalAccess', _315 => _315.srcRoot]), () => ( ""));
+    function relativeSrcRoot(p) {
+      if (srcRoot) {
+        return _pathe2.default.relative(srcRoot, p);
+      }
+      return p;
+    }
     const rolldownPlugin = oxcRuntimeSupport.rolldownPlugin;
     if (rolldownPlugin) {
       const build3 = _nullishCoalesce(config.build, () => ( (config.build = {})));
@@ -21171,11 +21340,12 @@ function createConfigService(ctx) {
       config.plugins ??= [];
       config.plugins.unshift(oxcRuntimeSupport.vitePlugin);
     }
-    const platform = _nullishCoalesce(_optionalChain([config, 'access', _301 => _301.weapp, 'optionalAccess', _302 => _302.platform]), () => ( "weapp"));
+    const platform = _nullishCoalesce(_optionalChain([config, 'access', _316 => _316.weapp, 'optionalAccess', _317 => _317.platform]), () => ( "weapp"));
     const resolvedOutputExtensions = getOutputExtensions(platform);
     config.plugins ??= [];
-    _optionalChain([config, 'access', _303 => _303.plugins, 'optionalAccess', _304 => _304.push, 'call', _305 => _305(_vitetsconfigpaths2.default.call(void 0, _optionalChain([config, 'access', _306 => _306.weapp, 'optionalAccess', _307 => _307.tsconfigPaths])))]);
-    const aliasEntries = getAliasEntries(_optionalChain([config, 'access', _308 => _308.weapp, 'optionalAccess', _309 => _309.jsonAlias]));
+    _optionalChain([config, 'access', _318 => _318.plugins, 'optionalAccess', _319 => _319.push, 'call', _320 => _320(_vitetsconfigpaths2.default.call(void 0, _optionalChain([config, 'access', _321 => _321.weapp, 'optionalAccess', _322 => _322.tsconfigPaths])))]);
+    const aliasEntries = getAliasEntries(_optionalChain([config, 'access', _323 => _323.weapp, 'optionalAccess', _324 => _324.jsonAlias]));
+    const configFilePath = _nullishCoalesce(_nullishCoalesce(_optionalChain([weappLoaded, 'optionalAccess', _325 => _325.path]), () => ( _optionalChain([loaded, 'optionalAccess', _326 => _326.path]))), () => ( resolvedConfigFile));
     return {
       config,
       aliasEntries,
@@ -21190,6 +21360,7 @@ function createConfigService(ctx) {
       packageJsonPath,
       platform,
       srcRoot,
+      configFilePath,
       currentSubPackageRoot: void 0
     };
   }
@@ -21208,6 +21379,7 @@ function createConfigService(ctx) {
       config: {},
       packageJson: {},
       platform: "weapp",
+      configFilePath: void 0,
       currentSubPackageRoot: void 0
     });
     options = resolvedConfig;
@@ -21330,7 +21502,7 @@ function createConfigService(ctx) {
     );
     inlineConfig.logLevel = "info";
     injectBuiltinAliases(inlineConfig);
-    const currentRoot = _optionalChain([subPackageMeta, 'optionalAccess', _310 => _310.subPackage, 'access', _311 => _311.root]);
+    const currentRoot = _optionalChain([subPackageMeta, 'optionalAccess', _327 => _327.subPackage, 'access', _328 => _328.root]);
     options = {
       ...options,
       currentSubPackageRoot: currentRoot
@@ -21401,10 +21573,10 @@ function createConfigService(ctx) {
       return options.srcRoot;
     },
     get pluginRoot() {
-      return _optionalChain([options, 'access', _312 => _312.config, 'access', _313 => _313.weapp, 'optionalAccess', _314 => _314.pluginRoot]);
+      return _optionalChain([options, 'access', _329 => _329.config, 'access', _330 => _330.weapp, 'optionalAccess', _331 => _331.pluginRoot]);
     },
     get absolutePluginRoot() {
-      if (_optionalChain([options, 'access', _315 => _315.config, 'access', _316 => _316.weapp, 'optionalAccess', _317 => _317.pluginRoot])) {
+      if (_optionalChain([options, 'access', _332 => _332.config, 'access', _333 => _333.weapp, 'optionalAccess', _334 => _334.pluginRoot])) {
         return _pathe2.default.resolve(options.cwd, options.config.weapp.pluginRoot);
       }
     },
@@ -21420,6 +21592,9 @@ function createConfigService(ctx) {
     get platform() {
       return options.platform;
     },
+    get configFilePath() {
+      return options.configFilePath;
+    },
     relativeCwd(p) {
       return _pathe2.default.relative(options.cwd, p);
     },
@@ -21480,7 +21655,7 @@ function createJsonService(ctx) {
       return resultJson;
     } catch (error) {
       logger_default.error(`\u6B8B\u7834\u7684JSON\u6587\u4EF6: ${filepath}`);
-      _optionalChain([debug, 'optionalCall', _318 => _318(error)]);
+      _optionalChain([debug, 'optionalCall', _335 => _335(error)]);
     }
   }
   function resolve8(entry) {
@@ -21532,7 +21707,7 @@ function createNpmService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before writing npm cache");
     }
-    if (_optionalChain([ctx, 'access', _319 => _319.configService, 'access', _320 => _320.weappViteConfig, 'optionalAccess', _321 => _321.npm, 'optionalAccess', _322 => _322.cache])) {
+    if (_optionalChain([ctx, 'access', _336 => _336.configService, 'access', _337 => _337.weappViteConfig, 'optionalAccess', _338 => _338.npm, 'optionalAccess', _339 => _339.cache])) {
       await _fsextra2.default.outputJSON(getDependenciesCacheFilePath(root), {
         hash: dependenciesCacheHash()
       });
@@ -21545,7 +21720,7 @@ function createNpmService(ctx) {
     }
   }
   async function checkDependenciesCacheOutdate(root) {
-    if (_optionalChain([ctx, 'access', _323 => _323.configService, 'optionalAccess', _324 => _324.weappViteConfig, 'optionalAccess', _325 => _325.npm, 'optionalAccess', _326 => _326.cache])) {
+    if (_optionalChain([ctx, 'access', _340 => _340.configService, 'optionalAccess', _341 => _341.weappViteConfig, 'optionalAccess', _342 => _342.npm, 'optionalAccess', _343 => _343.cache])) {
       const json = await readDependenciesCache(root);
       if (_shared.isObject.call(void 0, json)) {
         return dependenciesCacheHash() !== json.hash;
@@ -21579,7 +21754,7 @@ function createNpmService(ctx) {
       target: "es6",
       external: []
     });
-    const resolvedOptions = _optionalChain([ctx, 'access', _327 => _327.configService, 'optionalAccess', _328 => _328.weappViteConfig, 'optionalAccess', _329 => _329.npm, 'optionalAccess', _330 => _330.buildOptions, 'optionalCall', _331 => _331(
+    const resolvedOptions = _optionalChain([ctx, 'access', _344 => _344.configService, 'optionalAccess', _345 => _345.weappViteConfig, 'optionalAccess', _346 => _346.npm, 'optionalAccess', _347 => _347.buildOptions, 'optionalCall', _348 => _348(
       mergedOptions,
       { name, entry }
     )]);
@@ -21667,7 +21842,7 @@ function createNpmService(ctx) {
       throw new Error("configService must be initialized before resolving npm relation list");
     }
     let packNpmRelationList = [];
-    if (_optionalChain([ctx, 'access', _332 => _332.configService, 'access', _333 => _333.projectConfig, 'access', _334 => _334.setting, 'optionalAccess', _335 => _335.packNpmManually]) && Array.isArray(ctx.configService.projectConfig.setting.packNpmRelationList)) {
+    if (_optionalChain([ctx, 'access', _349 => _349.configService, 'access', _350 => _350.projectConfig, 'access', _351 => _351.setting, 'optionalAccess', _352 => _352.packNpmManually]) && Array.isArray(ctx.configService.projectConfig.setting.packNpmRelationList)) {
       packNpmRelationList = ctx.configService.projectConfig.setting.packNpmRelationList;
     } else {
       packNpmRelationList = [
@@ -21680,10 +21855,10 @@ function createNpmService(ctx) {
     return packNpmRelationList;
   }
   async function build3(options) {
-    if (!_optionalChain([ctx, 'access', _336 => _336.configService, 'optionalAccess', _337 => _337.weappViteConfig, 'optionalAccess', _338 => _338.npm, 'optionalAccess', _339 => _339.enable])) {
+    if (!_optionalChain([ctx, 'access', _353 => _353.configService, 'optionalAccess', _354 => _354.weappViteConfig, 'optionalAccess', _355 => _355.npm, 'optionalAccess', _356 => _356.enable])) {
       return;
     }
-    _optionalChain([debug, 'optionalCall', _340 => _340("buildNpm start")]);
+    _optionalChain([debug, 'optionalCall', _357 => _357("buildNpm start")]);
     const packNpmRelationList = getPackNpmRelationList();
     const [mainRelation, ...subRelations] = packNpmRelationList;
     const packageJsonPath = _pathe2.default.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
@@ -21758,7 +21933,7 @@ function createNpmService(ctx) {
         }
       }
     }
-    _optionalChain([debug, 'optionalCall', _341 => _341("buildNpm end")]);
+    _optionalChain([debug, 'optionalCall', _358 => _358("buildNpm end")]);
   }
   return {
     getDependenciesCacheFilePath,
@@ -21802,7 +21977,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', _342 => _342.captureStackTrace, 'optionalCall', _343 => _343(this, _TimeoutError)]);
+    _optionalChain([Error, 'access', _359 => _359.captureStackTrace, 'optionalCall', _360 => _360(this, _TimeoutError)]);
   }
 }, _class16);
 var getAbortedReason = (signal) => _nullishCoalesce(signal.reason, () => ( new DOMException("This operation was aborted.", "AbortError")));
@@ -21820,7 +21995,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', _344 => _344.aborted])) {
+    if (_optionalChain([signal, 'optionalAccess', _361 => _361.aborted])) {
       reject(getAbortedReason(signal));
       return;
     }
@@ -21918,7 +22093,7 @@ var PriorityQueue = class {
   }
   dequeue() {
     const item = this.#queue.shift();
-    return _optionalChain([item, 'optionalAccess', _345 => _345.run]);
+    return _optionalChain([item, 'optionalAccess', _362 => _362.run]);
   }
   filter(options) {
     return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
@@ -21979,10 +22154,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', _346 => _346.intervalCap, 'optionalAccess', _347 => _347.toString, 'call', _348 => _348()]), () => ( ""))}\` (${typeof options.intervalCap})`);
+      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${_nullishCoalesce(_optionalChain([options, 'access', _363 => _363.intervalCap, 'optionalAccess', _364 => _364.toString, 'call', _365 => _365()]), () => ( ""))}\` (${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', _349 => _349.interval, 'optionalAccess', _350 => _350.toString, 'call', _351 => _351()]), () => ( ""))}\` (${typeof options.interval})`);
+      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${_nullishCoalesce(_optionalChain([options, 'access', _366 => _366.interval, 'optionalAccess', _367 => _367.toString, 'call', _368 => _368()]), () => ( ""))}\` (${typeof options.interval})`);
     }
     this.#carryoverIntervalCount = _nullishCoalesce(_nullishCoalesce(options.carryoverIntervalCount, () => ( options.carryoverConcurrencyCount)), () => ( false));
     this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
@@ -22189,7 +22364,7 @@ var PQueue = class extends import_index2.default {
         });
         try {
           try {
-            _optionalChain([options, 'access', _352 => _352.signal, 'optionalAccess', _353 => _353.throwIfAborted, 'call', _354 => _354()]);
+            _optionalChain([options, 'access', _369 => _369.signal, 'optionalAccess', _370 => _370.throwIfAborted, 'call', _371 => _371()]);
           } catch (error) {
             if (!this.#isIntervalIgnored) {
               this.#intervalCount--;
@@ -22562,7 +22737,7 @@ var FileCache = class {
       return true;
     }
     const cachedMtime = this.mtimeMap.get(id);
-    const nextSignature = _optionalChain([options, 'optionalAccess', _355 => _355.content]) !== void 0 ? createSignature(options.content) : void 0;
+    const nextSignature = _optionalChain([options, 'optionalAccess', _372 => _372.content]) !== void 0 ? createSignature(options.content) : void 0;
     const updateSignature = () => {
       if (nextSignature !== void 0) {
         this.signatureMap.set(id, nextSignature);
@@ -22608,7 +22783,8 @@ function createDefaultLoadConfigResult() {
     mpDistRoot: "",
     packageJsonPath: "",
     platform: "weapp",
-    srcRoot: ""
+    srcRoot: "",
+    configFilePath: void 0
   };
 }
 function createDefaultPackageInfo() {
@@ -22738,7 +22914,7 @@ function createScanService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before scanning subpackages");
     }
-    const json = _optionalChain([scanState, 'access', _356 => _356.appEntry, 'optionalAccess', _357 => _357.json]);
+    const json = _optionalChain([scanState, 'access', _373 => _373.appEntry, 'optionalAccess', _374 => _374.json]);
     if (scanState.isDirty || subPackageMap.size === 0) {
       subPackageMap.clear();
       independentSubPackageMap.clear();
@@ -22756,9 +22932,9 @@ function createScanService(ctx) {
             subPackage,
             entries: resolveSubPackageEntries(subPackage)
           };
-          const subPackageConfig = _optionalChain([ctx, 'access', _358 => _358.configService, 'access', _359 => _359.weappViteConfig, 'optionalAccess', _360 => _360.subPackages, 'optionalAccess', _361 => _361[subPackage.root]]);
-          meta.subPackage.dependencies = _optionalChain([subPackageConfig, 'optionalAccess', _362 => _362.dependencies]);
-          meta.subPackage.inlineConfig = _optionalChain([subPackageConfig, 'optionalAccess', _363 => _363.inlineConfig]);
+          const subPackageConfig = _optionalChain([ctx, 'access', _375 => _375.configService, 'access', _376 => _376.weappViteConfig, 'optionalAccess', _377 => _377.subPackages, 'optionalAccess', _378 => _378[subPackage.root]]);
+          meta.subPackage.dependencies = _optionalChain([subPackageConfig, 'optionalAccess', _379 => _379.dependencies]);
+          meta.subPackage.inlineConfig = _optionalChain([subPackageConfig, 'optionalAccess', _380 => _380.inlineConfig]);
           metas.push(meta);
           if (subPackage.root) {
             subPackageMap.set(subPackage.root, meta);
@@ -22808,11 +22984,11 @@ function createScanService(ctx) {
     loadSubPackages,
     isMainPackageFileName,
     get workersOptions() {
-      return _optionalChain([scanState, 'access', _364 => _364.appEntry, 'optionalAccess', _365 => _365.json, 'optionalAccess', _366 => _366.workers]);
+      return _optionalChain([scanState, 'access', _381 => _381.appEntry, 'optionalAccess', _382 => _382.json, 'optionalAccess', _383 => _383.workers]);
     },
     get workersDir() {
-      const workersOptions = _optionalChain([scanState, 'access', _367 => _367.appEntry, 'optionalAccess', _368 => _368.json, 'optionalAccess', _369 => _369.workers]);
-      return typeof workersOptions === "object" ? _optionalChain([workersOptions, 'optionalAccess', _370 => _370.path]) : workersOptions;
+      const workersOptions = _optionalChain([scanState, 'access', _384 => _384.appEntry, 'optionalAccess', _385 => _385.json, 'optionalAccess', _386 => _386.workers]);
+      return typeof workersOptions === "object" ? _optionalChain([workersOptions, 'optionalAccess', _387 => _387.path]) : workersOptions;
     },
     markDirty() {
       scanState.isDirty = true;
@@ -22858,7 +23034,7 @@ function createWatcherService(ctx) {
     },
     setRollupWatcher(watcher, root = "/") {
       const oldWatcher = rollupWatcherMap.get(root);
-      _optionalChain([oldWatcher, 'optionalAccess', _371 => _371.close, 'call', _372 => _372()]);
+      _optionalChain([oldWatcher, 'optionalAccess', _388 => _388.close, 'call', _389 => _389()]);
       rollupWatcherMap.set(root, watcher);
     },
     closeAll() {
@@ -22894,7 +23070,7 @@ function createWatcherServicePlugin(ctx) {
     name: "weapp-runtime:watcher-service",
     closeBundle() {
       const configService = ctx.configService;
-      const isWatchMode = _optionalChain([configService, 'optionalAccess', _373 => _373.isDev]) || Boolean(_optionalChain([configService, 'optionalAccess', _374 => _374.inlineConfig, 'optionalAccess', _375 => _375.build, 'optionalAccess', _376 => _376.watch]));
+      const isWatchMode = _optionalChain([configService, 'optionalAccess', _390 => _390.isDev]) || Boolean(_optionalChain([configService, 'optionalAccess', _391 => _391.inlineConfig, 'optionalAccess', _392 => _392.build, 'optionalAccess', _393 => _393.watch]));
       if (!isWatchMode) {
         service.closeAll();
       }
@@ -25544,7 +25720,7 @@ function createWxmlService(ctx) {
     return set3;
   }
   function clearAll() {
-    const currentRoot = _optionalChain([ctx, 'access', _377 => _377.configService, 'optionalAccess', _378 => _378.currentSubPackageRoot]);
+    const currentRoot = _optionalChain([ctx, 'access', _394 => _394.configService, 'optionalAccess', _395 => _395.currentSubPackageRoot]);
     if (!currentRoot) {
       depsMap.clear();
       tokenMap.clear();
@@ -25599,7 +25775,7 @@ function createWxmlService(ctx) {
     }
     return scanWxml(wxml, {
       platform: ctx.configService.platform,
-      ..._optionalChain([ctx, 'access', _379 => _379.configService, 'access', _380 => _380.weappViteConfig, 'optionalAccess', _381 => _381.enhance, 'optionalAccess', _382 => _382.wxml]) === true ? {} : _optionalChain([ctx, 'access', _383 => _383.configService, 'access', _384 => _384.weappViteConfig, 'optionalAccess', _385 => _385.enhance, 'optionalAccess', _386 => _386.wxml])
+      ..._optionalChain([ctx, 'access', _396 => _396.configService, 'access', _397 => _397.weappViteConfig, 'optionalAccess', _398 => _398.enhance, 'optionalAccess', _399 => _399.wxml]) === true ? {} : _optionalChain([ctx, 'access', _400 => _400.configService, 'access', _401 => _401.weappViteConfig, 'optionalAccess', _402 => _402.enhance, 'optionalAccess', _403 => _403.wxml])
     });
   }
   async function scan(filepath) {
@@ -25708,8 +25884,8 @@ function resetCompilerContext(key) {
 
 // src/createContext.ts
 async function createCompilerContext(options) {
-  const key = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _387 => _387.key]), () => ( "default"));
-  if (!_optionalChain([options, 'optionalAccess', _388 => _388.key])) {
+  const key = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _404 => _404.key]), () => ( "default"));
+  if (!_optionalChain([options, 'optionalAccess', _405 => _405.key])) {
     resetCompilerContext(key);
   }
   const ctx = getCompilerContext(key);
@@ -25727,7 +25903,8 @@ async function createCompilerContext(options) {
 
 
 
-exports.logger_default = logger_default; exports.VERSION = VERSION; exports.checkRuntime = checkRuntime; exports.createCompilerContext = createCompilerContext;
+
+exports.logger_default = logger_default; exports.VERSION = VERSION; exports.checkRuntime = checkRuntime; exports.resolveWeappConfigFile = resolveWeappConfigFile; exports.createCompilerContext = createCompilerContext;
 /*! Bundled license information:
 
 chokidar/esm/index.js: