weapp-vite 5.2.2 → 5.3.0

package/dist/{chunk-VWY5EX25.mjs → chunk-JGSE2EOU.mjs}

@@ -915,13 +915,55 @@ function checkRuntime(minVersions) {
   }
 }
 
+// src/utils/weappConfig.ts
+init_esm_shims();
+import fs from "fs-extra";
+import path from "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 = path.resolve(directory, filename);
+    if (await fs.pathExists(candidatePath)) {
+      return candidatePath;
+    }
+  }
+  return void 0;
+}
+async function resolveWeappConfigFile(options) {
+  const { root, specified } = options;
+  if (specified) {
+    const resolvedSpecified = path.isAbsolute(specified) ? specified : path.resolve(root, specified);
+    const specifiedBaseName = path.basename(resolvedSpecified);
+    if (WEAPP_VITE_CONFIG_SET.has(specifiedBaseName)) {
+      if (await fs.pathExists(resolvedSpecified)) {
+        return resolvedSpecified;
+      }
+      return void 0;
+    }
+    const fromSpecifiedDirectory = await findWeappConfigInDirectory(path.dirname(resolvedSpecified));
+    if (fromSpecifiedDirectory) {
+      return fromSpecifiedDirectory;
+    }
+  }
+  return findWeappConfigInDirectory(root);
+}
+
 // src/utils/index.ts
 init_esm_shims();
 
 // src/utils/file.ts
 init_esm_shims();
-import fs from "fs-extra";
-import path from "pathe";
+import fs2 from "fs-extra";
+import path2 from "pathe";
 function isJsOrTs(name) {
   if (typeof name === "string") {
     return /\.[jt]s$/.test(name);
@@ -942,15 +984,15 @@ function changeFileExtension(filePath, extension) {
     return "";
   }
   extension = extension ? extension.startsWith(".") ? extension : `.${extension}` : "";
-  const basename4 = path.basename(filePath, path.extname(filePath));
-  return path.join(path.dirname(filePath), basename4 + extension);
+  const basename4 = path2.basename(filePath, path2.extname(filePath));
+  return path2.join(path2.dirname(filePath), basename4 + extension);
 }
 async function findJsEntry(filepath) {
   const predictions = jsExtensions.map((ext2) => {
     return changeFileExtension(filepath, ext2);
   });
   for (const p of predictions) {
-    if (await fs.exists(p)) {
+    if (await fs2.exists(p)) {
       return {
         path: p,
         predictions
@@ -966,7 +1008,7 @@ async function findJsonEntry(filepath) {
     return changeFileExtension(filepath, ext2);
   });
   for (const p of predictions) {
-    if (await fs.exists(p)) {
+    if (await fs2.exists(p)) {
       return {
         predictions,
         path: p
@@ -982,7 +1024,7 @@ async function findTemplateEntry(filepath) {
     return changeFileExtension(filepath, ext2);
   });
   for (const p of predictions) {
-    if (await fs.exists(p)) {
+    if (await fs2.exists(p)) {
       return {
         predictions,
         path: p
@@ -999,9 +1041,9 @@ function isTemplate(filepath) {
 async function touch(filename) {
   const time = /* @__PURE__ */ new Date();
   try {
-    await fs.utimes(filename, time, time);
+    await fs2.utimes(filename, time, time);
   } catch {
-    await fs.close(await fs.open(filename, "w"));
+    await fs2.close(await fs2.open(filename, "w"));
   }
 }
 
@@ -1009,7 +1051,7 @@ async function touch(filename) {
 init_esm_shims();
 import { get, isObject, set } from "@weapp-core/shared";
 import { parse as parseJson, stringify } from "comment-json";
-import path2 from "pathe";
+import path3 from "pathe";
 function jsonFileRemoveJsExtension(fileName) {
   return fileName.replace(/\.[jt]s$/, "");
 }
@@ -1054,7 +1096,7 @@ function resolveImportee(importee, jsonPath, aliasEntries) {
       return importee;
     }
     const updatedId = importee.replace(matchedEntry.find, matchedEntry.replacement);
-    return path2.relative(path2.dirname(jsonPath), updatedId);
+    return path3.relative(path3.dirname(jsonPath), updatedId);
   }
   return importee;
 }
@@ -1097,16 +1139,16 @@ import crypto from "crypto";
 
 // src/utils/projectConfig.ts
 init_esm_shims();
-import fs2 from "fs-extra";
-import path3 from "pathe";
+import fs3 from "fs-extra";
+import path4 from "pathe";
 async function getProjectConfig(root, options) {
-  const baseJsonPath = path3.resolve(root, "project.config.json");
-  const privateJsonPath = path3.resolve(root, "project.private.config.json");
+  const baseJsonPath = path4.resolve(root, "project.config.json");
+  const privateJsonPath = path4.resolve(root, "project.private.config.json");
   let baseJson = {};
   let privateJson = {};
-  if (await fs2.exists(baseJsonPath)) {
+  if (await fs3.exists(baseJsonPath)) {
     try {
-      baseJson = await fs2.readJson(baseJsonPath) || {};
+      baseJson = await fs3.readJson(baseJsonPath) || {};
     } catch {
       throw new Error(`\u89E3\u6790 json \u683C\u5F0F\u5931\u8D25, project.config.json \u4E3A\u975E\u6CD5\u7684 json \u683C\u5F0F`);
     }
@@ -1114,9 +1156,9 @@ async function getProjectConfig(root, options) {
     throw new Error(`\u5728 ${root} \u76EE\u5F55\u4E0B\u627E\u4E0D\u5230 project.config.json`);
   }
   if (!options?.ignorePrivate) {
-    if (await fs2.exists(privateJsonPath)) {
+    if (await fs3.exists(privateJsonPath)) {
       try {
-        privateJson = await fs2.readJson(privateJsonPath) || {};
+        privateJson = await fs3.readJson(privateJsonPath) || {};
       } catch {
         throw new Error(`\u89E3\u6790 json \u683C\u5F0F\u5931\u8D25, project.private.config.json \u4E3A\u975E\u6CD5\u7684 json \u683C\u5F0F`);
       }
@@ -1169,6 +1211,7 @@ init_esm_shims();
 // src/runtime/autoImportPlugin.ts
 init_esm_shims();
 import { removeExtensionDeep } from "@weapp-core/shared";
+import fs4 from "fs-extra";
 
 // ../../node_modules/.pnpm/lru-cache@11.2.2/node_modules/lru-cache/dist/esm/index.js
 init_esm_shims();
@@ -2573,11 +2616,12 @@ var LRUCache = class _LRUCache {
 };
 
 // src/runtime/autoImportPlugin.ts
+import path6 from "pathe";
 import pm from "picomatch";
 
 // src/context/shared.ts
 init_esm_shims();
-import path4 from "pathe";
+import path5 from "pathe";
 
 // src/debugger.ts
 init_esm_shims();
@@ -2592,16 +2636,16 @@ function createDebugger(namespace) {
 // src/context/shared.ts
 var debug = createDebugger("weapp-vite:context");
 function resolvedComponentName(entry) {
-  const base = path4.basename(entry);
+  const base = path5.basename(entry);
   if (base === "index") {
-    const dirName = path4.dirname(entry);
+    const dirName = path5.dirname(entry);
     if (dirName === ".") {
       return {
         base
       };
     }
     return {
-      componentName: path4.basename(dirName),
+      componentName: path5.basename(dirName),
       base
       // isIndex: true,
     };
@@ -2635,6 +2679,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 = configService.weappViteConfig?.enhance?.autoImportComponents;
+    if (!autoImportConfig) {
+      return void 0;
+    }
+    const baseDir = (() => {
+      const configFilePath = configService.configFilePath;
+      if (configFilePath) {
+        return path6.dirname(configFilePath);
+      }
+      return configService.cwd;
+    })();
+    const outputOption = autoImportConfig.output;
+    if (outputOption === false) {
+      return void 0;
+    }
+    if (typeof outputOption === "string" && outputOption.length > 0) {
+      return path6.isAbsolute(outputOption) ? outputOption : path6.resolve(baseDir, outputOption);
+    }
+    return path6.resolve(baseDir, manifestFileName);
+  }
+  function collectResolverComponents() {
+    const resolvers = ctx.configService?.weappViteConfig?.enhance?.autoImportComponents?.resolvers;
+    if (!Array.isArray(resolvers)) {
+      return {};
+    }
+    const entries = [];
+    for (const resolver of resolvers) {
+      const map = resolver?.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 fs4.outputJson(outputPath, manifest, { spaces: 2 });
+  }
+  function scheduleManifestWrite(shouldWrite) {
+    if (!shouldWrite) {
+      return;
+    }
+    const configService = ctx.configService;
+    if (!configService?.weappViteConfig?.enhance?.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");
@@ -2645,26 +2779,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 (!json?.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 = removeExtensionDeep(jsonPath);
@@ -2685,9 +2823,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;
@@ -2697,9 +2837,10 @@ function createAutoImportService(ctx) {
         templatePath && entry.templatePath === templatePath || jsonPath && entry.jsonPath === jsonPath || jsEntry && entry.path === jsEntry || baseName && removeExtensionDeep(entry.templatePath) === baseName || baseName && removeExtensionDeep(entry.path) === baseName || baseName && removeExtensionDeep(entry.jsonPath ?? "") === baseName
       );
       if (matches2) {
-        registry.delete(key);
+        removed = registry.delete(key) || removed;
       }
     }
+    return removed;
   }
   function ensureMatcher() {
     if (!ctx.configService) {
@@ -2743,15 +2884,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: removeExtensionDeep(filePath),
         templatePath: filePath
       });
+      scheduleManifestWrite(removed);
     },
     resolve(componentName, importerBaseName) {
       const local = registry.get(componentName);
@@ -2769,6 +2912,9 @@ function createAutoImportService(ctx) {
     },
     getRegisteredLocalComponents() {
       return Array.from(registry.values());
+    },
+    awaitManifestWrites() {
+      return pendingWrite ?? Promise.resolve();
     }
   };
 }
@@ -2862,7 +3008,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path25) => statMethod(path25, { bigint: true });
+      this._stat = (path27) => statMethod(path27, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -2887,8 +3033,8 @@ var ReaddirpStream = class extends 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)
@@ -2928,20 +3074,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path25, depth) {
+  async _exploreDir(path27, depth) {
     let files;
     try {
-      files = await readdir(path25, this._rdOptions);
+      files = await readdir(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 = presolve(pjoin(path25, basename4));
+      const fullPath = presolve(pjoin(path27, basename4));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -3342,16 +3488,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(path25, {
+    return fs_watch(path27, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -3367,12 +3513,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);
@@ -3383,7 +3529,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,
@@ -3398,7 +3544,7 @@ var setFsWatchListener = (path25, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path25, "r");
+          const fd = await open(path27, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -3429,7 +3575,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;
@@ -3451,7 +3597,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));
         }
       })
     };
@@ -3479,13 +3625,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
     };
@@ -3495,12 +3641,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
@@ -3522,7 +3668,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) {
@@ -3536,11 +3682,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;
           }
@@ -3572,7 +3718,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;
     }
@@ -3582,7 +3728,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path25);
+        linkPath = await fsrealpath(path27);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -3592,12 +3738,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;
@@ -3626,9 +3772,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) {
@@ -3637,8 +3783,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) => {
@@ -3707,13 +3853,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);
@@ -3729,8 +3875,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path25);
-        const targetPath = follow ? await fsrealpath(path25) : path25;
+        const absPath = sysPath.resolve(path27);
+        const targetPath = follow ? await fsrealpath(path27) : path27;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -3740,29 +3886,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path25) : path25;
+        const targetPath = follow ? await fsrealpath(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;
       }
     }
   }
@@ -3805,26 +3951,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;
     }
   }
@@ -3864,19 +4010,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 {
@@ -3931,10 +4077,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 = [];
@@ -4056,20 +4202,20 @@ var FSWatcher = class extends 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;
@@ -4091,17 +4237,17 @@ var FSWatcher = class extends 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
         });
       }
@@ -4165,38 +4311,38 @@ var FSWatcher = class extends 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) {
@@ -4214,16 +4360,16 @@ var FSWatcher = class extends 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 stat3(fullPath);
@@ -4254,23 +4400,23 @@ var FSWatcher = class extends 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);
@@ -4278,7 +4424,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path25, thr);
+    action.set(path27, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -4292,44 +4438,44 @@ var FSWatcher = class extends 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) {
       statcb(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;
         }
@@ -4340,8 +4486,8 @@ var FSWatcher = class extends 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;
@@ -4351,17 +4497,17 @@ var FSWatcher = class extends 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
   // -----------------
@@ -4393,63 +4539,63 @@ var FSWatcher = class extends 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);
   }
@@ -4479,7 +4625,7 @@ function watch(paths, options = {}) {
 var esm_default = { watch, FSWatcher };
 
 // src/runtime/buildPlugin.ts
-import path6 from "pathe";
+import path8 from "pathe";
 
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/index.js
 init_esm_shims();
@@ -5166,11 +5312,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;
@@ -6981,12 +7127,12 @@ var PathBase = 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;
@@ -7738,8 +7884,8 @@ var PathWin32 = class _PathWin32 extends PathBase {
   /**
    * @internal
    */
-  getRootString(path25) {
-    return win32.parse(path25).root;
+  getRootString(path27) {
+    return win32.parse(path27).root;
   }
   /**
    * @internal
@@ -7785,8 +7931,8 @@ var PathPosix = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path25) {
-    return path25.startsWith("/") ? "/" : "";
+  getRootString(path27) {
+    return path27.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -7835,8 +7981,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 = fileURLToPath(cwd);
     }
@@ -7875,11 +8021,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
@@ -8366,9 +8512,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);
   }
 };
@@ -8394,8 +8540,8 @@ var PathScurryWin32 = 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
@@ -8423,8 +8569,8 @@ var PathScurryPosix = 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
@@ -8730,8 +8876,8 @@ var MatchRecord = class {
   }
   // match, absolute, ifdir
   entries() {
-    return [...this.store.entries()].map(([path25, n2]) => [
-      path25,
+    return [...this.store.entries()].map(([path27, n2]) => [
+      path27,
       !!(n2 & 2),
       !!(n2 & 1)
     ]);
@@ -8936,9 +9082,9 @@ var GlobUtil = class {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path25, opts) {
+  constructor(patterns, path27, opts) {
     this.patterns = patterns;
-    this.path = path25;
+    this.path = path27;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -8957,11 +9103,11 @@ var GlobUtil = class {
       });
     }
   }
-  #ignored(path25) {
-    return this.seen.has(path25) || !!this.#ignore?.ignored?.(path25);
+  #ignored(path27) {
+    return this.seen.has(path27) || !!this.#ignore?.ignored?.(path27);
   }
-  #childrenIgnored(path25) {
-    return !!this.#ignore?.childrenIgnored?.(path25);
+  #childrenIgnored(path27) {
+    return !!this.#ignore?.childrenIgnored?.(path27);
   }
   // backpressure mechanism
   pause() {
@@ -9176,8 +9322,8 @@ var GlobUtil = class {
 };
 var GlobWalker = class extends GlobUtil {
   matches = /* @__PURE__ */ new Set();
-  constructor(patterns, path25, opts) {
-    super(patterns, path25, opts);
+  constructor(patterns, path27, opts) {
+    super(patterns, path27, opts);
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -9214,8 +9360,8 @@ var GlobWalker = class extends GlobUtil {
 };
 var GlobStream = class extends GlobUtil {
   results;
-  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
@@ -9552,44 +9698,44 @@ init_esm_shims();
 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" ? inspect(path25) : `type ${type} ${path25}`;
+    const ctor = path27 && type === "object" && path27.constructor;
+    const received = ctor && ctor.name ? `an instance of ${ctor.name}` : type === "object" ? inspect(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 = resolve3(path25);
-  const { root } = parse(path25);
-  if (path25 === root && opt.preserveRoot !== false) {
+  path27 = resolve3(path27);
+  const { root } = parse(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 } = parse(path25);
-    if (badWinChars.test(path25.substring(root2.length))) {
+    const { root: root2 } = parse(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;
 
@@ -9601,19 +9747,19 @@ init_esm_shims();
 
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/fs.js
 init_esm_shims();
-import fs3 from "fs";
+import fs5 from "fs";
 import { chmodSync, mkdirSync, renameSync, rmdirSync, rmSync, statSync, lstatSync as lstatSync2, unlinkSync } from "fs";
 import { readdirSync as rdSync } from "fs";
-var readdirSync2 = (path25) => rdSync(path25, { withFileTypes: true });
-var chmod = (path25, mode) => new Promise((res, rej) => fs3.chmod(path25, mode, (er, ...d) => er ? rej(er) : res(...d)));
-var mkdir = (path25, options) => new Promise((res, rej) => fs3.mkdir(path25, options, (er, made) => er ? rej(er) : res(made)));
-var readdir4 = (path25) => new Promise((res, rej) => fs3.readdir(path25, { withFileTypes: true }, (er, data2) => er ? rej(er) : res(data2)));
-var rename = (oldPath, newPath) => new Promise((res, rej) => fs3.rename(oldPath, newPath, (er, ...d) => er ? rej(er) : res(...d)));
-var rm = (path25, options) => new Promise((res, rej) => fs3.rm(path25, options, (er, ...d) => er ? rej(er) : res(...d)));
-var rmdir = (path25) => new Promise((res, rej) => fs3.rmdir(path25, (er, ...d) => er ? rej(er) : res(...d)));
-var stat4 = (path25) => new Promise((res, rej) => fs3.stat(path25, (er, data2) => er ? rej(er) : res(data2)));
-var lstat4 = (path25) => new Promise((res, rej) => fs3.lstat(path25, (er, data2) => er ? rej(er) : res(data2)));
-var unlink = (path25) => new Promise((res, rej) => fs3.unlink(path25, (er, ...d) => er ? rej(er) : res(...d)));
+var readdirSync2 = (path27) => rdSync(path27, { withFileTypes: true });
+var chmod = (path27, mode) => new Promise((res, rej) => fs5.chmod(path27, mode, (er, ...d) => er ? rej(er) : res(...d)));
+var mkdir = (path27, options) => new Promise((res, rej) => fs5.mkdir(path27, options, (er, made) => er ? rej(er) : res(made)));
+var readdir4 = (path27) => new Promise((res, rej) => fs5.readdir(path27, { withFileTypes: true }, (er, data2) => er ? rej(er) : res(data2)));
+var rename = (oldPath, newPath) => new Promise((res, rej) => fs5.rename(oldPath, newPath, (er, ...d) => er ? rej(er) : res(...d)));
+var rm = (path27, options) => new Promise((res, rej) => fs5.rm(path27, options, (er, ...d) => er ? rej(er) : res(...d)));
+var rmdir = (path27) => new Promise((res, rej) => fs5.rmdir(path27, (er, ...d) => er ? rej(er) : res(...d)));
+var stat4 = (path27) => new Promise((res, rej) => fs5.stat(path27, (er, data2) => er ? rej(er) : res(data2)));
+var lstat4 = (path27) => new Promise((res, rej) => fs5.lstat(path27, (er, data2) => er ? rej(er) : res(data2)));
+var unlink = (path27) => new Promise((res, rej) => fs5.unlink(path27, (er, ...d) => er ? rej(er) : res(...d)));
 var promises = {
   chmod,
   mkdir,
@@ -9632,10 +9778,10 @@ import { parse as parse2, resolve as resolve4 } from "path";
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/readdir-or-error.js
 init_esm_shims();
 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;
   }
@@ -9660,35 +9806,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) => {
+var rimrafPosix = async (path27, opt) => {
   if (opt?.signal?.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 (er?.code === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafPosixSync = (path25, opt) => {
+var rimrafPosixSync = (path27, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   try {
-    return rimrafPosixDirSync(path25, opt, lstatSync2(path25));
+    return rimrafPosixDirSync(path27, opt, lstatSync2(path27));
   } catch (er) {
     if (er?.code === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafPosixDir = async (path25, opt, ent) => {
+var rimrafPosixDir = async (path27, opt, ent) => {
   if (opt?.signal?.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") {
@@ -9698,30 +9844,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(resolve4(path25, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafPosixDir(resolve4(path27, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path25 === parse2(path25).root) {
+  if (opt.preserveRoot === false && path27 === parse2(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) => {
+var rimrafPosixDirSync = (path27, opt, ent) => {
   if (opt?.signal?.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") {
@@ -9731,27 +9877,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(() => unlinkSync(path25));
+    ignoreENOENTSync(() => unlinkSync(path27));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
-    const p = resolve4(path25, ent2.name);
+    const p = resolve4(path27, ent2.name);
     removedAll = rimrafPosixDirSync(p, opt, ent2) && removedAll;
   }
-  if (opt.preserveRoot === false && path25 === parse2(path25).root) {
+  if (opt.preserveRoot === false && path27 === parse2(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(() => rmdirSync(path25));
+  ignoreENOENTSync(() => rmdirSync(path27));
   return true;
 };
 
@@ -9762,9 +9908,9 @@ import { parse as parse5, resolve as resolve7 } from "path";
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/fix-eperm.js
 init_esm_shims();
 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 (fer?.code === "ENOENT") {
@@ -9772,7 +9918,7 @@ var fixEPERM = (fn) => async (path25) => {
     }
     if (fer?.code === "EPERM") {
       try {
-        await chmod2(path25, 438);
+        await chmod2(path27, 438);
       } catch (er2) {
         const fer2 = er2;
         if (fer2?.code === "ENOENT") {
@@ -9780,14 +9926,14 @@ var fixEPERM = (fn) => async (path25) => {
         }
         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 (fer?.code === "ENOENT") {
@@ -9795,7 +9941,7 @@ var fixEPERMSync = (fn) => (path25) => {
     }
     if (fer?.code === "EPERM") {
       try {
-        chmodSync(path25, 438);
+        chmodSync(path27, 438);
       } catch (er2) {
         const fer2 = er2;
         if (fer2?.code === "ENOENT") {
@@ -9803,7 +9949,7 @@ var fixEPERMSync = (fn) => (path25) => {
         }
         throw er;
       }
-      return fn(path25);
+      return fn(path27);
     }
     throw er;
   }
@@ -9816,23 +9962,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 (fer?.path === path25 && fer?.code && codes.has(fer.code)) {
+        if (fer?.path === path27 && fer?.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);
             });
           }
@@ -9848,15 +9994,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 (fer?.path === path25 && fer?.code && codes.has(fer.code) && retries < max) {
+        if (fer?.path === path27 && fer?.code && codes.has(fer.code) && retries < max) {
           retries++;
           continue;
         }
@@ -9876,16 +10022,16 @@ init_esm_shims();
 import { tmpdir } from "os";
 import { parse as parse3, resolve as resolve5 } from "path";
 var { stat: stat5 } = promises;
-var isDirSync = (path25) => {
+var isDirSync = (path27) => {
   try {
-    return statSync(path25).isDirectory();
+    return statSync(path27).isDirectory();
   } catch (er) {
     return false;
   }
 };
-var isDir = (path25) => stat5(path25).then((st) => st.isDirectory(), () => false);
-var win32DefaultTmp = async (path25) => {
-  const { root } = parse3(path25);
+var isDir = (path27) => stat5(path27).then((st) => st.isDirectory(), () => false);
+var win32DefaultTmp = async (path27) => {
+  const { root } = parse3(path27);
   const tmp = tmpdir();
   const { root: tmpRoot } = parse3(tmp);
   if (root.toLowerCase() === tmpRoot.toLowerCase()) {
@@ -9897,8 +10043,8 @@ var win32DefaultTmp = async (path25) => {
   }
   return root;
 };
-var win32DefaultTmpSync = (path25) => {
-  const { root } = parse3(path25);
+var win32DefaultTmpSync = (path27) => {
+  const { root } = parse3(path27);
   const tmp = tmpdir();
   const { root: tmpRoot } = parse3(tmp);
   if (root.toLowerCase() === tmpRoot.toLowerCase()) {
@@ -9917,10 +10063,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) => `.${basename3(path25)}.${Math.random()}`;
-var unlinkFixEPERM = async (path25) => unlink3(path25).catch((er) => {
+var uniqueFilename = (path27) => `.${basename3(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;
       }
@@ -9931,13 +10077,13 @@ var unlinkFixEPERM = async (path25) => unlink3(path25).catch((er) => {
   }
   throw er;
 });
-var unlinkFixEPERMSync = (path25) => {
+var unlinkFixEPERMSync = (path27) => {
   try {
-    unlinkSync(path25);
+    unlinkSync(path27);
   } catch (er) {
     if (er?.code === "EPERM") {
       try {
-        return chmodSync(path25, 438);
+        return chmodSync(path27, 438);
       } catch (er2) {
         if (er2?.code === "ENOENT") {
           return;
@@ -9950,29 +10096,29 @@ var unlinkFixEPERMSync = (path25) => {
     throw er;
   }
 };
-var rimrafMoveRemove = async (path25, opt) => {
+var rimrafMoveRemove = async (path27, opt) => {
   if (opt?.signal?.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 (er?.code === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafMoveRemoveDir = async (path25, opt, ent) => {
+var rimrafMoveRemoveDir = async (path27, opt, ent) => {
   if (opt?.signal?.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 && parse4(path25).root !== path25) {
+  if (path27 === opt.tmp && parse4(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") {
@@ -9982,54 +10128,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(resolve6(path25, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafMoveRemoveDir(resolve6(path27, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path25 === parse4(path25).root) {
+  if (opt.preserveRoot === false && path27 === parse4(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 = resolve6(tmp, uniqueFilename(path25));
-  await rename2(path25, tmpFile);
+var tmpUnlink = async (path27, tmp, rm3) => {
+  const tmpFile = resolve6(tmp, uniqueFilename(path27));
+  await rename2(path27, tmpFile);
   return await rm3(tmpFile);
 };
-var rimrafMoveRemoveSync = (path25, opt) => {
+var rimrafMoveRemoveSync = (path27, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   try {
-    return rimrafMoveRemoveDirSync(path25, opt, lstatSync2(path25));
+    return rimrafMoveRemoveDirSync(path27, opt, lstatSync2(path27));
   } catch (er) {
     if (er?.code === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafMoveRemoveDirSync = (path25, opt, ent) => {
+var rimrafMoveRemoveDirSync = (path27, opt, ent) => {
   if (opt?.signal?.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 && parse4(path25).root !== path25) {
+  if (path27 === opt.tmp && parse4(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") {
@@ -10039,32 +10185,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 = resolve6(path25, ent2.name);
+    const p = resolve6(path27, ent2.name);
     removedAll = rimrafMoveRemoveDirSync(p, opt, ent2) && removedAll;
   }
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path25 === parse4(path25).root) {
+  if (opt.preserveRoot === false && path27 === parse4(path27).root) {
     return false;
   }
-  if (opt.filter && !opt.filter(path25, ent)) {
+  if (opt.filter && !opt.filter(path27, ent)) {
     return false;
   }
-  ignoreENOENTSync(() => tmpUnlinkSync(path25, tmp, rmdirSync));
+  ignoreENOENTSync(() => tmpUnlinkSync(path27, tmp, rmdirSync));
   return true;
 };
-var tmpUnlinkSync = (path25, tmp, rmSync2) => {
-  const tmpFile = resolve6(tmp, uniqueFilename(path25));
-  renameSync(path25, tmpFile);
+var tmpUnlinkSync = (path27, tmp, rmSync2) => {
+  const tmpFile = resolve6(tmp, uniqueFilename(path27));
+  renameSync(path27, tmpFile);
   return rmSync2(tmpFile);
 };
 
@@ -10074,31 +10220,31 @@ var rimrafWindowsFile = retryBusy(fixEPERM(unlink4));
 var rimrafWindowsFileSync = retryBusySync(fixEPERMSync(unlinkSync));
 var rimrafWindowsDirRetry = retryBusy(fixEPERM(rmdir4));
 var rimrafWindowsDirRetrySync = retryBusySync(fixEPERMSync(rmdirSync));
-var rimrafWindowsDirMoveRemoveFallback = async (path25, opt) => {
+var rimrafWindowsDirMoveRemoveFallback = async (path27, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   const { filter: filter3, ...options } = opt;
   try {
-    return await rimrafWindowsDirRetry(path25, options);
+    return await rimrafWindowsDirRetry(path27, options);
   } catch (er) {
     if (er?.code === "ENOTEMPTY") {
-      return await rimrafMoveRemove(path25, options);
+      return await rimrafMoveRemove(path27, options);
     }
     throw er;
   }
 };
-var rimrafWindowsDirMoveRemoveFallbackSync = (path25, opt) => {
+var rimrafWindowsDirMoveRemoveFallbackSync = (path27, opt) => {
   if (opt?.signal?.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 (fer?.code === "ENOTEMPTY") {
-      return rimrafMoveRemoveSync(path25, options);
+      return rimrafMoveRemoveSync(path27, options);
     }
     throw er;
   }
@@ -10106,35 +10252,35 @@ var rimrafWindowsDirMoveRemoveFallbackSync = (path25, opt) => {
 var START = Symbol("start");
 var CHILD = Symbol("child");
 var FINISH = Symbol("finish");
-var rimrafWindows = async (path25, opt) => {
+var rimrafWindows = async (path27, opt) => {
   if (opt?.signal?.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 (er?.code === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafWindowsSync = (path25, opt) => {
+var rimrafWindowsSync = (path27, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   try {
-    return rimrafWindowsDirSync(path25, opt, lstatSync2(path25), START);
+    return rimrafWindowsDirSync(path27, opt, lstatSync2(path27), START);
   } catch (er) {
     if (er?.code === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafWindowsDir = async (path25, opt, ent, state = START) => {
+var rimrafWindowsDir = async (path27, opt, ent, state = START) => {
   if (opt?.signal?.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") {
@@ -10144,32 +10290,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(resolve7(path25, ent2.name), opt, ent2, s)))).reduce((a, b) => a && b, true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafWindowsDir(resolve7(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 === parse5(path25).root) {
+    if (opt.preserveRoot === false && path27 === parse5(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") {
@@ -10179,32 +10325,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 = resolve7(path25, ent2.name);
+    const p = resolve7(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 === parse5(path25).root) {
+    if (opt.preserveRoot === false && path27 === parse5(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;
@@ -10217,16 +10363,16 @@ var rimrafManualSync = platform_default === "win32" ? rimrafWindowsSync : rimraf
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/rimraf-native.js
 init_esm_shims();
 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) => {
-  rmSync(path25, {
+var rimrafNativeSync = (path27, opt) => {
+  rmSync(path27, {
     ...opt,
     force: true,
     recursive: true
@@ -10244,26 +10390,26 @@ var useNative = !hasNative || platform_default === "win32" ? () => false : (opt)
 var useNativeSync = !hasNative || platform_default === "win32" ? () => false : (opt) => !opt?.signal && !opt?.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);
@@ -10278,8 +10424,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,
@@ -10366,7 +10512,7 @@ function createBuildService(ctx) {
                       }, {});
                       const summaryKeys = Object.keys(summary);
                       const prefix = summaryKeys.length === 1 ? summaryKeys[0] : "";
-                      return path6.join(prefix, "common");
+                      return path8.join(prefix, "common");
                     }
                   }
                 }
@@ -10391,7 +10537,7 @@ function createBuildService(ctx) {
     if (hasWorkersDir && workersDir) {
       devWorkers(workersDir);
       esm_default.watch(
-        path6.resolve(configService.absoluteSrcRoot, workersDir),
+        path8.resolve(configService.absoluteSrcRoot, workersDir),
         {
           persistent: true,
           ignoreInitial: true
@@ -10442,8 +10588,8 @@ function createBuildService(ctx) {
     if (configService.mpDistRoot) {
       const deletedFilePaths = await rimraf(
         [
-          path6.resolve(configService.outDir, "*"),
-          path6.resolve(configService.outDir, ".*")
+          path8.resolve(configService.outDir, "*"),
+          path8.resolve(configService.outDir, ".*")
         ],
         {
           glob: true,
@@ -10507,13 +10653,13 @@ function createBuildServicePlugin(ctx) {
 init_esm_shims();
 import process7 from "process";
 import { defu as defu3 } from "@weapp-core/shared";
-import fs14 from "fs-extra";
+import fs16 from "fs-extra";
 
 // ../../node_modules/.pnpm/local-pkg@1.1.2/node_modules/local-pkg/dist/index.mjs
 init_esm_shims();
-import fs5 from "fs";
+import fs7 from "fs";
 import { createRequire as createRequire2 } from "module";
-import path8, { dirname as dirname4, join as join3, win32 as win322 } from "path";
+import path10, { dirname as dirname4, join as join3, win32 as win322 } from "path";
 import process4 from "process";
 import fsPromises from "fs/promises";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -16133,7 +16279,7 @@ Parser.acorn = {
 
 // ../../node_modules/.pnpm/mlly@1.8.0/node_modules/mlly/dist/index.mjs
 import { builtinModules, createRequire } from "module";
-import fs4, { realpathSync as realpathSync2, statSync as statSync2, promises as promises2 } from "fs";
+import fs6, { realpathSync as realpathSync2, statSync as statSync2, promises as promises2 } from "fs";
 
 // ../../node_modules/.pnpm/ufo@1.6.1/node_modules/ufo/dist/index.mjs
 init_esm_shims();
@@ -16153,17 +16299,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) {
@@ -16188,12 +16334,12 @@ import { normalize as normalize3, isAbsolute as isAbsolute2, extname as extname$
 import { fileURLToPath as fileURLToPath$1, URL as URL$1, pathToFileURL as pathToFileURL$1 } from "url";
 import assert from "assert";
 import process$1 from "process";
-import path7, { dirname as dirname3 } from "path";
+import path9, { dirname as dirname3 } from "path";
 import v8 from "v8";
 import { format, inspect as inspect2 } from "util";
 var BUILTIN_MODULES = new Set(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]*)+$/;
@@ -16306,8 +16452,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
 );
@@ -16339,8 +16485,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
 );
@@ -16391,8 +16537,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
 );
@@ -16537,7 +16683,7 @@ function read(jsonPath, { base, specifier }) {
   }
   let string;
   try {
-    string = fs4.readFileSync(path7.toNamespacedPath(jsonPath), "utf8");
+    string = fs6.readFileSync(path9.toNamespacedPath(jsonPath), "utf8");
   } catch (error) {
     const exception = (
       /** @type {ErrnoException} */
@@ -16752,7 +16898,7 @@ Default "index" lookups for the main are deprecated for ES modules.`,
       "DeprecationWarning",
       "DEP0151"
     );
-  } else if (path7.resolve(packagePath, main) !== urlPath) {
+  } else if (path9.resolve(packagePath, main) !== urlPath) {
     process$1.emitWarning(
       `Package ${packagePath} has a "main" field set to "${main}", excluding the full filename and extension to the resolved file at "${urlPath.slice(
         packagePath.length
@@ -16763,9 +16909,9 @@ Default "index" lookups for the main are deprecated for ES modules.`,
     );
   }
 }
-function tryStatSync(path25) {
+function tryStatSync(path27) {
   try {
-    return statSync2(path25);
+    return statSync2(path27);
   } catch {
   }
 }
@@ -16859,7 +17005,7 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
   {
     const real = realpathSync2(filePath);
     const { search, hash } = resolved;
-    resolved = pathToFileURL$1(real + (filePath.endsWith(path7.sep) ? "/" : ""));
+    resolved = pathToFileURL$1(real + (filePath.endsWith(path9.sep) ? "/" : ""));
     resolved.search = search;
     resolved.hash = hash;
   }
@@ -17641,12 +17787,12 @@ async function findUp$1(name, {
   type = "file",
   stopAt
 } = {}) {
-  let directory = path8.resolve(toPath(cwd) ?? "");
-  const { root } = path8.parse(directory);
-  stopAt = path8.resolve(directory, toPath(stopAt ?? root));
-  const isAbsoluteName = path8.isAbsolute(name);
+  let directory = path10.resolve(toPath(cwd) ?? "");
+  const { root } = path10.parse(directory);
+  stopAt = path10.resolve(directory, toPath(stopAt ?? root));
+  const isAbsoluteName = path10.isAbsolute(name);
   while (directory) {
-    const filePath = isAbsoluteName ? name : path8.join(directory, name);
+    const filePath = isAbsoluteName ? name : path10.join(directory, name);
     try {
       const stats = await fsPromises.stat(filePath);
       if (type === "file" && stats.isFile() || type === "directory" && stats.isDirectory()) {
@@ -17657,7 +17803,7 @@ async function findUp$1(name, {
     if (directory === stopAt || directory === root) {
       break;
     }
-    directory = path8.dirname(directory);
+    directory = path10.dirname(directory);
   }
 }
 function findUpSync(name, {
@@ -17665,14 +17811,14 @@ function findUpSync(name, {
   type = "file",
   stopAt
 } = {}) {
-  let directory = path8.resolve(toPath(cwd) ?? "");
-  const { root } = path8.parse(directory);
-  stopAt = path8.resolve(directory, toPath(stopAt) ?? root);
-  const isAbsoluteName = path8.isAbsolute(name);
+  let directory = path10.resolve(toPath(cwd) ?? "");
+  const { root } = path10.parse(directory);
+  stopAt = path10.resolve(directory, toPath(stopAt) ?? root);
+  const isAbsoluteName = path10.isAbsolute(name);
   while (directory) {
-    const filePath = isAbsoluteName ? name : path8.join(directory, name);
+    const filePath = isAbsoluteName ? name : path10.join(directory, name);
     try {
-      const stats = fs5.statSync(filePath, { throwIfNoEntry: false });
+      const stats = fs7.statSync(filePath, { throwIfNoEntry: false });
       if (type === "file" && stats?.isFile() || type === "directory" && stats?.isDirectory()) {
         return filePath;
       }
@@ -17681,10 +17827,10 @@ function findUpSync(name, {
     if (directory === stopAt || directory === root) {
       break;
     }
-    directory = path8.dirname(directory);
+    directory = path10.dirname(directory);
   }
 }
-function _resolve2(path25, options = {}) {
+function _resolve2(path27, options = {}) {
   if (options.platform === "auto" || !options.platform)
     options.platform = process4.platform === "win32" ? "win32" : "posix";
   if (process4.versions.pnp) {
@@ -17693,11 +17839,11 @@ function _resolve2(path25, options = {}) {
       paths.push(process4.cwd());
     const targetRequire = createRequire2(import.meta.url);
     try {
-      return targetRequire.resolve(path25, { paths });
+      return targetRequire.resolve(path27, { paths });
     } catch {
     }
   }
-  const modulePath = resolvePathSync(path25, {
+  const modulePath = resolvePathSync(path27, {
     url: options.paths
   });
   if (options.platform === "win32")
@@ -17718,8 +17864,8 @@ function getPackageJsonPath(name, options = {}) {
   return searchPackageJSON(entry);
 }
 var readFile = quansync2({
-  async: (id) => fs5.promises.readFile(id, "utf8"),
-  sync: (id) => fs5.readFileSync(id, "utf8")
+  async: (id) => fs7.promises.readFile(id, "utf8"),
+  sync: (id) => fs7.readFileSync(id, "utf8")
 });
 var getPackageInfo = quansync2(function* (name, options = {}) {
   const packageJsonPath = getPackageJsonPath(name, options);
@@ -17758,7 +17904,7 @@ function searchPackageJSON(dir) {
       return;
     dir = newDir;
     packageJsonPath = join3(dir, "package.json");
-    if (fs5.existsSync(packageJsonPath))
+    if (fs7.existsSync(packageJsonPath))
       break;
   }
   return packageJsonPath;
@@ -17768,10 +17914,10 @@ var findUp = quansync2({
   async: findUp$1
 });
 var loadPackageJSON = quansync2(function* (cwd = process4.cwd()) {
-  const path25 = yield findUp("package.json", { cwd });
-  if (!path25 || !fs5.existsSync(path25))
+  const path27 = yield findUp("package.json", { cwd });
+  if (!path27 || !fs7.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) {
@@ -17782,8 +17928,8 @@ var isPackageListedSync = isPackageListed.sync;
 
 // ../../node_modules/.pnpm/package-manager-detector@1.4.0/node_modules/package-manager-detector/dist/detect.mjs
 init_esm_shims();
-import fs6 from "fs/promises";
-import path9 from "path";
+import fs8 from "fs/promises";
+import path11 from "path";
 import process5 from "process";
 
 // ../../node_modules/.pnpm/package-manager-detector@1.4.0/node_modules/package-manager-detector/dist/constants.mjs
@@ -17824,20 +17970,20 @@ 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 fs6.stat(path25);
+    const stat6 = await fs8.stat(path27);
     return type === "file" ? stat6.isFile() : stat6.isDirectory();
   } catch {
     return false;
   }
 }
 function* lookup(cwd = process5.cwd()) {
-  let directory = path9.resolve(cwd);
-  const { root } = path9.parse(directory);
+  let directory = path11.resolve(cwd);
+  const { root } = path11.parse(directory);
   while (directory && directory !== root) {
     yield directory;
-    directory = path9.dirname(directory);
+    directory = path11.dirname(directory);
   }
 }
 async function parsePackageJson(filepath, onUnknown) {
@@ -17851,7 +17997,7 @@ async function detect(options = {}) {
   } = options;
   let stopDir;
   if (typeof options.stopDir === "string") {
-    const resolved = path9.resolve(options.stopDir);
+    const resolved = path11.resolve(options.stopDir);
     stopDir = (dir) => dir === resolved;
   } else {
     stopDir = options.stopDir;
@@ -17861,9 +18007,9 @@ async function detect(options = {}) {
       switch (strategy) {
         case "lockfile": {
           for (const lock of Object.keys(LOCKS)) {
-            if (await pathExists(path9.join(directory, lock), "file")) {
+            if (await pathExists(path11.join(directory, lock), "file")) {
               const name = LOCKS[lock];
-              const result = await parsePackageJson(path9.join(directory, "package.json"), onUnknown);
+              const result = await parsePackageJson(path11.join(directory, "package.json"), onUnknown);
               if (result)
                 return result;
               else
@@ -17874,7 +18020,7 @@ async function detect(options = {}) {
         }
         case "packageManager-field":
         case "devEngines-field": {
-          const result = await parsePackageJson(path9.join(directory, "package.json"), onUnknown);
+          const result = await parsePackageJson(path11.join(directory, "package.json"), onUnknown);
           if (result)
             return result;
           break;
@@ -17882,7 +18028,7 @@ async function detect(options = {}) {
         case "install-metadata": {
           for (const metadata of Object.keys(INSTALL_METADATA)) {
             const fileOrDir = metadata.endsWith("/") ? "dir" : "file";
-            if (await pathExists(path9.join(directory, metadata), fileOrDir)) {
+            if (await pathExists(path11.join(directory, metadata), fileOrDir)) {
               const name = INSTALL_METADATA[metadata];
               const agent = name === "yarn" ? isMetadataYarnClassic(metadata) ? "yarn" : "yarn@berry" : name;
               return { name, agent };
@@ -17913,7 +18059,7 @@ function getNameAndVer(pkg) {
 }
 async function handlePackageManager(filepath, onUnknown) {
   try {
-    const pkg = JSON.parse(await fs6.readFile(filepath, "utf8"));
+    const pkg = JSON.parse(await fs8.readFile(filepath, "utf8"));
     let agent;
     const nameAndVer = getNameAndVer(pkg);
     if (nameAndVer) {
@@ -17943,7 +18089,7 @@ function isMetadataYarnClassic(metadataPath) {
 }
 
 // src/runtime/configPlugin.ts
-import path21 from "pathe";
+import path23 from "pathe";
 import { loadConfigFromFile } from "vite";
 import tsconfigPaths from "vite-tsconfig-paths";
 
@@ -18032,8 +18178,8 @@ import { wrapPlugin } from "vite-plugin-performance";
 // src/plugins/asset.ts
 init_esm_shims();
 import { fdir as Fdir } from "fdir";
-import fs7 from "fs-extra";
-import path10 from "pathe";
+import fs9 from "fs-extra";
+import path12 from "pathe";
 function asset(ctx) {
   const state = { ctx };
   return [createAssetCollector(state)];
@@ -18076,7 +18222,7 @@ function scanAssetFiles(configService, config) {
   const filter3 = weappViteConfig?.copy?.filter ?? (() => true);
   const ignore = [
     ...defaultExcluded,
-    path10.resolve(configService.cwd, `${config.build.outDir}/**/*`),
+    path12.resolve(configService.cwd, `${config.build.outDir}/**/*`),
     ...exclude
   ];
   const fdir = new Fdir({
@@ -18095,7 +18241,7 @@ function scanAssetFiles(configService, config) {
       files.filter(filter3).map(async (file) => {
         return {
           file,
-          buffer: await fs7.readFile(file)
+          buffer: await fs9.readFile(file)
         };
       })
     );
@@ -18108,7 +18254,7 @@ function normalizeCopyGlobs(globs) {
 // src/plugins/autoImport.ts
 init_esm_shims();
 import { fdir as Fdir2 } from "fdir";
-import path11 from "pathe";
+import path13 from "pathe";
 function autoImport(ctx) {
   const state = { ctx };
   return [createAutoImportPlugin(state)];
@@ -18185,7 +18331,7 @@ async function findTemplateCandidates(state, globs) {
     ],
     pathSeparator: "/"
   });
-  return await fdir.withFullPaths().globWithOptions(globs.map((pattern) => path11.resolve(configService.absoluteSrcRoot, pattern)), {
+  return await fdir.withFullPaths().globWithOptions(globs.map((pattern) => path13.resolve(configService.absoluteSrcRoot, pattern)), {
     ignore
   }).crawl(configService.absoluteSrcRoot).withPromise();
 }
@@ -18201,14 +18347,14 @@ function resolveAbsolutePath(ctx, candidate) {
   if (!configService) {
     return void 0;
   }
-  if (path11.isAbsolute(candidate)) {
+  if (path13.isAbsolute(candidate)) {
     return candidate;
   }
-  const resolvedFromSrc = path11.resolve(configService.absoluteSrcRoot, candidate);
+  const resolvedFromSrc = path13.resolve(configService.absoluteSrcRoot, candidate);
   if (resolvedFromSrc.startsWith(configService.absoluteSrcRoot)) {
     return resolvedFromSrc;
   }
-  return path11.resolve(configService.cwd, candidate);
+  return path13.resolve(configService.cwd, candidate);
 }
 function matchesAutoImportGlobs(ctx, candidate) {
   const { autoImportService, configService } = ctx;
@@ -18236,8 +18382,8 @@ function matchesAutoImportGlobs(ctx, candidate) {
 // src/plugins/core.ts
 init_esm_shims();
 import { isEmptyObject as isEmptyObject2, isObject as isObject6, removeExtensionDeep as removeExtensionDeep4 } from "@weapp-core/shared";
-import fs10 from "fs-extra";
-import path16 from "pathe";
+import fs12 from "fs-extra";
+import path18 from "pathe";
 import { build as build2 } from "vite";
 
 // src/wxml/handle.ts
@@ -19443,11 +19589,51 @@ function transformWxsCode(code, options) {
 }
 
 // src/wxml/handle.ts
+var handleCache = /* @__PURE__ */ new WeakMap();
+var inlineWxsTransformCache = /* @__PURE__ */ new Map();
+var INLINE_WXS_CACHE_LIMIT = 256;
+function createCacheKey(options) {
+  return `${options.removeComment ? 1 : 0}|${options.transformEvent ? 1 : 0}`;
+}
+function getCachedResult(data2, cacheKey) {
+  return handleCache.get(data2)?.get(cacheKey);
+}
+function setCachedResult(data2, cacheKey, result) {
+  let cacheForToken = handleCache.get(data2);
+  if (!cacheForToken) {
+    cacheForToken = /* @__PURE__ */ new Map();
+    handleCache.set(data2, cacheForToken);
+  }
+  cacheForToken.set(cacheKey, result);
+  return result;
+}
+function getCachedInlineWxsTransform(code) {
+  const cached = inlineWxsTransformCache.get(code);
+  if (cached) {
+    inlineWxsTransformCache.delete(code);
+    inlineWxsTransformCache.set(code, cached);
+    return cached;
+  }
+  const transformed = transformWxsCode(code);
+  inlineWxsTransformCache.set(code, transformed);
+  if (inlineWxsTransformCache.size > INLINE_WXS_CACHE_LIMIT) {
+    const firstKey = inlineWxsTransformCache.keys().next().value;
+    if (firstKey) {
+      inlineWxsTransformCache.delete(firstKey);
+    }
+  }
+  return transformed;
+}
 function handleWxml(data2, options) {
   const opts = defu2(options, {
     removeComment: true,
     transformEvent: true
   });
+  const cacheKey = createCacheKey(opts);
+  const cached = getCachedResult(data2, cacheKey);
+  if (cached) {
+    return cached;
+  }
   const {
     code,
     removalRanges,
@@ -19466,11 +19652,11 @@ function handleWxml(data2, options) {
   const shouldRemoveConditionals = removalRanges.length > 0;
   const shouldRemoveComments = opts.removeComment && commentTokens.length > 0;
   if (!shouldNormalizeImports && !shouldRemoveLang && !shouldTransformInlineWxs && !shouldTransformEvents && !shouldRemoveConditionals && !shouldRemoveComments) {
-    return {
+    return setCachedResult(data2, cacheKey, {
       code,
       components: components2,
       deps
-    };
+    });
   }
   const ms = new MagicString(code);
   if (shouldNormalizeImports) {
@@ -19485,7 +19671,7 @@ function handleWxml(data2, options) {
   }
   if (shouldTransformInlineWxs) {
     for (const { end, start, value } of inlineWxsTokens) {
-      const { result } = transformWxsCode(value);
+      const { result } = getCachedInlineWxsTransform(value);
       if (result?.code) {
         ms.update(start, end, `
 ${result.code}`);
@@ -19498,7 +19684,7 @@ ${result.code}`);
     }
   }
   if (shouldRemoveConditionals) {
-    for (const { start, end } of [...removalRanges].sort((a, b) => b.start - a.start)) {
+    for (const { start, end } of removalRanges) {
       if (end > start) {
         ms.remove(start, end);
       }
@@ -19509,11 +19695,11 @@ ${result.code}`);
       ms.remove(start, end);
     }
   }
-  return {
+  return setCachedResult(data2, cacheKey, {
     code: ms.toString(),
     components: components2,
     deps
-  };
+  });
 }
 
 // src/plugins/hooks/useLoadEntry/index.ts
@@ -19597,13 +19783,13 @@ function createJsonEmitManager(configService) {
 init_esm_shims();
 import { performance as performance3 } from "perf_hooks";
 import { removeExtensionDeep as removeExtensionDeep3 } from "@weapp-core/shared";
-import fs8 from "fs-extra";
-import path13 from "pathe";
+import fs10 from "fs-extra";
+import path15 from "pathe";
 
 // src/plugins/utils/analyze.ts
 init_esm_shims();
 import { get as get3, isObject as isObject4, removeExtension } from "@weapp-core/shared";
-import path12 from "pathe";
+import path14 from "pathe";
 function collectPluginExportEntries(plugins, root) {
   if (!isObject4(plugins)) {
     return [];
@@ -19618,7 +19804,7 @@ function collectPluginExportEntries(plugins, root) {
       continue;
     }
     const normalized = removeExtension(exportPath);
-    entries.push(root ? path12.join(root, normalized) : normalized);
+    entries.push(root ? path14.join(root, normalized) : normalized);
   }
   return entries;
 }
@@ -19659,6 +19845,86 @@ function analyzeCommonJson(json) {
 }
 
 // src/plugins/hooks/useLoadEntry/loadEntry.ts
+function createStopwatch() {
+  const start = performance3.now();
+  return () => `${(performance3.now() - start).toFixed(2)}ms`;
+}
+async function addWatchTarget(pluginCtx, target, existsCache) {
+  if (!target || typeof pluginCtx.addWatchFile !== "function") {
+    return false;
+  }
+  if (existsCache.has(target)) {
+    const cached = existsCache.get(target);
+    if (cached) {
+      pluginCtx.addWatchFile(target);
+    }
+    return cached;
+  }
+  const exists = await fs10.exists(target);
+  if (exists) {
+    pluginCtx.addWatchFile(target);
+  }
+  existsCache.set(target, exists);
+  return exists;
+}
+async function collectStyleImports(pluginCtx, id, existsCache) {
+  const styleImports = [];
+  for (const ext2 of supportedCssLangs) {
+    const mayBeCssPath = changeFileExtension(id, ext2);
+    const exists = await addWatchTarget(pluginCtx, mayBeCssPath, existsCache);
+    if (exists) {
+      styleImports.push(mayBeCssPath);
+    }
+  }
+  return styleImports;
+}
+async function collectAppSideFiles(pluginCtx, id, json, jsonService, registerJsonAsset, existsCache) {
+  const { sitemapLocation = "sitemap.json", themeLocation = "theme.json" } = json;
+  const processSideJson = async (location) => {
+    if (!location) {
+      return;
+    }
+    const { path: jsonPath, predictions } = await findJsonEntry(
+      path15.resolve(path15.dirname(id), location)
+    );
+    for (const prediction of predictions) {
+      await addWatchTarget(pluginCtx, prediction, existsCache);
+    }
+    if (!jsonPath) {
+      return;
+    }
+    const content = await jsonService.read(jsonPath);
+    registerJsonAsset({
+      json: content,
+      jsonPath,
+      type: "app"
+    });
+  };
+  await processSideJson(sitemapLocation);
+  await processSideJson(themeLocation);
+}
+async function ensureTemplateScanned(pluginCtx, id, scanTemplateEntry, existsCache) {
+  const { path: templateEntry, predictions } = await findTemplateEntry(id);
+  for (const prediction of predictions) {
+    await addWatchTarget(pluginCtx, prediction, existsCache);
+  }
+  if (!templateEntry) {
+    return "";
+  }
+  await scanTemplateEntry(templateEntry);
+  return templateEntry;
+}
+async function resolveEntries(entries, absoluteSrcRoot) {
+  return Promise.all(
+    entries.filter((entry) => !entry.includes(":")).map(async (entry) => {
+      const absPath = path15.resolve(absoluteSrcRoot, entry);
+      return {
+        entry,
+        resolvedId: await this.resolve(absPath)
+      };
+    })
+  );
+}
 function createEntryLoader(options) {
   const {
     ctx,
@@ -19672,16 +19938,18 @@ function createEntryLoader(options) {
     debug: debug4
   } = options;
   const { jsonService, configService } = ctx;
+  const existsCache = /* @__PURE__ */ new Map();
   return async function loadEntry(id, type) {
-    const start = performance3.now();
-    const getTime = () => `${(performance3.now() - start).toFixed(2)}ms`;
+    existsCache.clear();
+    const stopwatch = debug4 ? createStopwatch() : void 0;
+    const getTime = () => stopwatch ? stopwatch() : "0.00ms";
     const relativeCwdId = configService.relativeCwd(id);
     this.addWatchFile(id);
     const baseName = removeExtensionDeep3(id);
     const jsonEntry = await findJsonEntry(id);
     let jsonPath = jsonEntry.path;
     for (const prediction of jsonEntry.predictions) {
-      await addWatchTarget(this, prediction);
+      await addWatchTarget(this, prediction, existsCache);
     }
     let json = {};
     if (jsonPath) {
@@ -19698,10 +19966,11 @@ function createEntryLoader(options) {
         id,
         json,
         jsonService,
-        registerJsonAsset
+        registerJsonAsset,
+        existsCache
       );
     } else {
-      templatePath = await ensureTemplateScanned(this, id, scanTemplateEntry);
+      templatePath = await ensureTemplateScanned(this, id, scanTemplateEntry, existsCache);
       applyAutoImports(baseName, json);
       entries.push(...analyzeCommonJson(json));
     }
@@ -19721,108 +19990,49 @@ function createEntryLoader(options) {
       configService.absoluteSrcRoot
     );
     debug4?.(`resolvedIds ${relativeCwdId} \u8017\u65F6 ${getTime()}`);
-    await Promise.all(
-      emitEntriesChunks.call(
-        this,
-        resolvedIds.filter(({ entry, resolvedId }) => {
-          if (!resolvedId) {
-            logger_default.warn(`\u6CA1\u6709\u627E\u5230 \`${entry}\` \u7684\u5165\u53E3\u6587\u4EF6\uFF0C\u8BF7\u68C0\u67E5\u8DEF\u5F84\u662F\u5426\u6B63\u786E!`);
-            return false;
-          }
-          if (loadedEntrySet.has(resolvedId.id)) {
-            return false;
-          }
-          return true;
-        }).map((item) => item.resolvedId)
-      )
-    );
+    const pendingResolvedIds = [];
+    for (const { entry, resolvedId } of resolvedIds) {
+      if (!resolvedId) {
+        logger_default.warn(`\u6CA1\u6709\u627E\u5230 \`${entry}\` \u7684\u5165\u53E3\u6587\u4EF6\uFF0C\u8BF7\u68C0\u67E5\u8DEF\u5F84\u662F\u5426\u6B63\u786E!`);
+        continue;
+      }
+      if (loadedEntrySet.has(resolvedId.id)) {
+        continue;
+      }
+      pendingResolvedIds.push(resolvedId);
+    }
+    if (pendingResolvedIds.length) {
+      await Promise.all(emitEntriesChunks.call(this, pendingResolvedIds));
+    }
     debug4?.(`emitEntriesChunks ${relativeCwdId} \u8017\u65F6 ${getTime()}`);
     registerJsonAsset({
       jsonPath,
       json,
       type
     });
-    const code = await fs8.readFile(id, "utf8");
-    const ms = new MagicString(code);
-    await prependStyleImports.call(this, id, ms);
+    const code = await fs10.readFile(id, "utf8");
+    const styleImports = await collectStyleImports(this, id, existsCache);
     debug4?.(`loadEntry ${relativeCwdId} \u8017\u65F6 ${getTime()}`);
-    return {
-      code: ms.toString()
-    };
-  };
-}
-async function collectAppSideFiles(pluginCtx, id, json, jsonService, registerJsonAsset) {
-  const { sitemapLocation = "sitemap.json", themeLocation = "theme.json" } = json;
-  const processSideJson = async (location) => {
-    if (!location) {
-      return;
-    }
-    const { path: jsonPath, predictions } = await findJsonEntry(
-      path13.resolve(path13.dirname(id), location)
-    );
-    for (const prediction of predictions) {
-      await addWatchTarget(pluginCtx, prediction);
-    }
-    if (!jsonPath) {
-      return;
-    }
-    const content = await jsonService.read(jsonPath);
-    registerJsonAsset({
-      json: content,
-      jsonPath,
-      type: "app"
-    });
-  };
-  await processSideJson(sitemapLocation);
-  await processSideJson(themeLocation);
-}
-async function ensureTemplateScanned(pluginCtx, id, scanTemplateEntry) {
-  const { path: templateEntry, predictions } = await findTemplateEntry(id);
-  for (const prediction of predictions) {
-    await addWatchTarget(pluginCtx, prediction);
-  }
-  if (!templateEntry) {
-    return "";
-  }
-  await scanTemplateEntry(templateEntry);
-  return templateEntry;
-}
-async function resolveEntries(entries, absoluteSrcRoot) {
-  return Promise.all(
-    entries.filter((entry) => !entry.includes(":")).map(async (entry) => {
-      const absPath = path13.resolve(absoluteSrcRoot, entry);
+    if (styleImports.length === 0) {
       return {
-        entry,
-        resolvedId: await this.resolve(absPath)
+        code
       };
-    })
-  );
-}
-async function prependStyleImports(id, ms) {
-  for (const ext2 of supportedCssLangs) {
-    const mayBeCssPath = changeFileExtension(id, ext2);
-    const exists = await addWatchTarget(this, mayBeCssPath);
-    if (exists) {
-      ms.prepend(`import '${mayBeCssPath}';
+    }
+    const ms = new MagicString(code);
+    for (const styleImport of styleImports) {
+      ms.prepend(`import '${styleImport}';
 `);
     }
-  }
-}
-async function addWatchTarget(pluginCtx, target) {
-  if (!target || typeof pluginCtx.addWatchFile !== "function") {
-    return false;
-  }
-  const exists = await fs8.exists(target);
-  if (exists) {
-    pluginCtx.addWatchFile(target);
-  }
-  return exists;
+    return {
+      code: ms.toString()
+    };
+  };
 }
 
 // src/plugins/hooks/useLoadEntry/normalizer.ts
 init_esm_shims();
 import { isObject as isObject5 } from "@weapp-core/shared";
-import path14 from "pathe";
+import path16 from "pathe";
 function createEntryNormalizer(configService) {
   return function normalizeEntry(entry, jsonPath) {
     if (/plugin:\/\//.test(entry)) {
@@ -19847,8 +20057,8 @@ function resolveImportee2(importee, jsonPath, configService) {
       updated = importee.replace(matchedEntry.find, matchedEntry.replacement);
     }
   }
-  const baseDir = jsonPath ? path14.dirname(jsonPath) : configService.absoluteSrcRoot;
-  return path14.resolve(baseDir, updated);
+  const baseDir = jsonPath ? path16.dirname(jsonPath) : configService.absoluteSrcRoot;
+  return path16.resolve(baseDir, updated);
 }
 function hasDependencyPrefix(dependencies, tokens) {
   return Object.keys(dependencies).some((dep) => {
@@ -19937,16 +20147,16 @@ function collectRequireTokens(ast) {
 
 // src/plugins/utils/invalidateEntry.ts
 init_esm_shims();
-import fs9 from "fs";
+import fs11 from "fs";
 import process6 from "process";
-import path15 from "pathe";
+import path17 from "pathe";
 var watchedCssExts = new Set(supportedCssLangs.map((ext2) => `.${ext2}`));
 var configSuffixes = configExtensions.map((ext2) => `.${ext2}`);
 var sidecarSuffixes = [...configSuffixes, ...watchedCssExts];
 var supportsRecursiveWatch = process6.platform === "darwin" || process6.platform === "win32";
 async function invalidateEntryForSidecar(filePath) {
   const configSuffix = configSuffixes.find((suffix) => filePath.endsWith(suffix));
-  const ext2 = path15.extname(filePath);
+  const ext2 = path17.extname(filePath);
   let scriptBasePath;
   if (configSuffix) {
     scriptBasePath = filePath.slice(0, -configSuffix.length);
@@ -19967,8 +20177,8 @@ function ensureSidecarWatcher(ctx, rootDir) {
     return;
   }
   const { sidecarWatcherMap } = ctx.runtimeState.watcher;
-  const absRoot = path15.normalize(rootDir);
-  if (!fs9.existsSync(absRoot)) {
+  const absRoot = path17.normalize(rootDir);
+  if (!fs11.existsSync(absRoot)) {
     return;
   }
   if (sidecarWatcherMap.has(absRoot)) {
@@ -19981,11 +20191,11 @@ function ensureSidecarWatcher(ctx, rootDir) {
     void invalidateEntryForSidecar(filePath);
   };
   if (supportsRecursiveWatch) {
-    const watcher2 = fs9.watch(absRoot, { recursive: true }, (_event, filename) => {
+    const watcher2 = fs11.watch(absRoot, { recursive: true }, (_event, filename) => {
       if (!filename) {
         return;
       }
-      const resolved = path15.join(absRoot, filename.toString());
+      const resolved = path17.join(absRoot, filename.toString());
       handleSidecarChange(resolved);
     });
     sidecarWatcherMap.set(absRoot, {
@@ -19996,8 +20206,8 @@ function ensureSidecarWatcher(ctx, rootDir) {
     return;
   }
   const patterns = [
-    ...configExtensions.map((ext2) => path15.join(absRoot, `**/*.${ext2}`)),
-    ...supportedCssLangs.map((ext2) => path15.join(absRoot, `**/*.${ext2}`))
+    ...configExtensions.map((ext2) => path17.join(absRoot, `**/*.${ext2}`)),
+    ...supportedCssLangs.map((ext2) => path17.join(absRoot, `**/*.${ext2}`))
   ];
   const watcher = esm_default.watch(patterns, {
     ignoreInitial: true,
@@ -20080,7 +20290,7 @@ function createCoreLifecyclePlugin(state) {
     buildStart() {
       loadedEntrySet.clear();
       if (configService.isDev) {
-        const rootDir = subPackageMeta ? path16.resolve(configService.absoluteSrcRoot, subPackageMeta.subPackage.root) : configService.absoluteSrcRoot;
+        const rootDir = subPackageMeta ? path18.resolve(configService.absoluteSrcRoot, subPackageMeta.subPackage.root) : configService.absoluteSrcRoot;
         ensureSidecarWatcher(ctx, rootDir);
       }
     },
@@ -20112,7 +20322,7 @@ function createCoreLifecyclePlugin(state) {
       let scannedInput;
       if (subPackageMeta) {
         scannedInput = subPackageMeta.entries.reduce((acc, entry) => {
-          acc[entry] = path16.resolve(configService.absoluteSrcRoot, entry);
+          acc[entry] = path18.resolve(configService.absoluteSrcRoot, entry);
           return acc;
         }, {});
       } else {
@@ -20163,8 +20373,8 @@ function createCoreLifecyclePlugin(state) {
         if (parsed.query.wxss) {
           const realPath = getCssRealPath(parsed);
           this.addWatchFile(realPath);
-          if (await fs10.exists(realPath)) {
-            const css2 = await fs10.readFile(realPath, "utf8");
+          if (await fs12.exists(realPath)) {
+            const css2 = await fs12.readFile(realPath, "utf8");
             return { code: css2 };
           }
         }
@@ -20235,7 +20445,7 @@ function createRequireAnalysisPlugin(state) {
         return;
       }
       for (const requireModule of requireTokens) {
-        const absPath = path16.resolve(path16.dirname(moduleInfo.id), requireModule.value);
+        const absPath = path18.resolve(path18.dirname(moduleInfo.id), requireModule.value);
         const resolved = await this.resolve(absPath, moduleInfo.id);
         if (!resolved) {
           continue;
@@ -20588,8 +20798,8 @@ function createEnvSynchronizer({ configService }) {
 init_esm_shims();
 import { createHash } from "crypto";
 import { removeExtension as removeExtension2 } from "@weapp-core/shared";
-import fs11 from "fs-extra";
-import path17 from "pathe";
+import fs13 from "fs-extra";
+import path19 from "pathe";
 function workers(ctx) {
   if (!ctx.scanService.workersDir) {
     return [];
@@ -20617,23 +20827,23 @@ function createWorkerBuildPlugin(ctx) {
       options.chunkFileNames = (chunkInfo) => {
         const workersDir = scanService.workersDir ?? "";
         if (chunkInfo.isDynamicEntry) {
-          return path17.join(workersDir, "[name].js");
+          return path19.join(workersDir, "[name].js");
         }
         const sourceId = chunkInfo.facadeModuleId ?? chunkInfo.moduleIds[0];
         const hashBase = typeof sourceId === "string" ? configService.relativeCwd(sourceId) : chunkInfo.name;
         const stableHash = createHash("sha256").update(hashBase).digest("base64url").slice(0, 8);
-        return path17.join(workersDir, `${chunkInfo.name}-${stableHash}.js`);
+        return path19.join(workersDir, `${chunkInfo.name}-${stableHash}.js`);
       };
     }
   };
 }
 async function resolveWorkerEntry(ctx, entry) {
   const { configService, scanService } = ctx;
-  const relativeEntryPath = path17.join(scanService.workersDir, entry);
+  const relativeEntryPath = path19.join(scanService.workersDir, entry);
   const key = removeExtension2(relativeEntryPath);
-  const absoluteEntry = path17.resolve(configService.absoluteSrcRoot, relativeEntryPath);
+  const absoluteEntry = path19.resolve(configService.absoluteSrcRoot, relativeEntryPath);
   if (isJsOrTs(entry)) {
-    const exists = await fs11.exists(absoluteEntry);
+    const exists = await fs13.exists(absoluteEntry);
     if (!exists) {
       logger_default.warn(`\u5F15\u7528 worker: \`${configService.relativeCwd(relativeEntryPath)}\` \u4E0D\u5B58\u5728!`);
       return { key };
@@ -20651,8 +20861,8 @@ async function resolveWorkerEntry(ctx, entry) {
 // src/plugins/wxs.ts
 init_esm_shims();
 import { removeExtension as removeExtension3 } from "@weapp-core/shared";
-import fs12 from "fs-extra";
-import path18 from "pathe";
+import fs14 from "fs-extra";
+import path20 from "pathe";
 var wxsCodeCache = new LRUCache({
   max: 512
 });
@@ -20697,7 +20907,7 @@ async function handleWxsDeps(state, deps, absPath) {
       if (!jsExtensions.includes(dep.attrs.lang) && !arr) {
         return;
       }
-      const wxsPath = path18.resolve(path18.dirname(absPath), dep.value);
+      const wxsPath = path20.resolve(path20.dirname(absPath), dep.value);
       await transformWxsFile.call(this, state, wxsPath);
     })
   );
@@ -20706,7 +20916,7 @@ async function transformWxsFile(state, wxsPath) {
   const { ctx } = state;
   const { configService } = ctx;
   this.addWatchFile(wxsPath);
-  if (!await fs12.exists(wxsPath)) {
+  if (!await fs14.exists(wxsPath)) {
     return;
   }
   const suffixMatch = wxsPath.match(/\.wxs(\.[jt]s)?$/);
@@ -20714,7 +20924,7 @@ async function transformWxsFile(state, wxsPath) {
   if (suffixMatch) {
     isRaw = !suffixMatch[1];
   }
-  const rawCode = await fs12.readFile(wxsPath, "utf8");
+  const rawCode = await fs14.readFile(wxsPath, "utf8");
   let code = wxsCodeCache.get(rawCode);
   if (code === void 0) {
     const { result, importees } = transformWxsCode(rawCode, {
@@ -20723,13 +20933,13 @@ async function transformWxsFile(state, wxsPath) {
     if (typeof result?.code === "string") {
       code = result.code;
     }
-    const dirname5 = path18.dirname(wxsPath);
+    const dirname5 = path20.dirname(wxsPath);
     await Promise.all(
       importees.map(({ source }) => {
         return transformWxsFile.call(
           this,
           state,
-          path18.resolve(dirname5, source)
+          path20.resolve(dirname5, source)
         );
       })
     );
@@ -20791,8 +21001,8 @@ function flatten(groups) {
 
 // src/runtime/oxcRuntime.ts
 init_esm_shims();
-import fs13 from "fs-extra";
-import path19 from "pathe";
+import fs15 from "fs-extra";
+import path21 from "pathe";
 var NULL_BYTE = "\0";
 var OXC_RUNTIME_HELPER_ALIAS = new RegExp(`^(?:${NULL_BYTE})?@oxc-project(?:/|\\+)runtime(?:@[^/]+)?/helpers/(.+)\\.js$`);
 var FALLBACK_HELPER_PREFIX = `${NULL_BYTE}weapp-vite:oxc-helper:`;
@@ -20860,7 +21070,7 @@ function getOxcHelperName(id) {
 }
 function createOxcRuntimeSupport() {
   const oxcRuntimeInfo = getPackageInfoSync("@oxc-project/runtime");
-  const oxcRuntimeHelpersRoot = oxcRuntimeInfo ? path19.resolve(oxcRuntimeInfo.rootPath, "src/helpers/esm") : void 0;
+  const oxcRuntimeHelpersRoot = oxcRuntimeInfo ? path21.resolve(oxcRuntimeInfo.rootPath, "src/helpers/esm") : void 0;
   const alias = {
     find: OXC_RUNTIME_HELPER_ALIAS,
     replacement: "@oxc-project/runtime/src/helpers/esm/$1.js"
@@ -20887,7 +21097,7 @@ function createOxcRuntimeSupport() {
         }
         return null;
       }
-      return path19.resolve(helpersRoot, `${helperName}.js`);
+      return path21.resolve(helpersRoot, `${helperName}.js`);
     },
     async load(id) {
       if (id.startsWith(FALLBACK_HELPER_PREFIX)) {
@@ -20900,10 +21110,10 @@ function createOxcRuntimeSupport() {
       }
       const helperName = getOxcHelperName(id);
       if (helperName) {
-        const helperPath = id.startsWith(NULL_BYTE) ? path19.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`) : id;
-        if (await fs13.pathExists(helperPath)) {
+        const helperPath = id.startsWith(NULL_BYTE) ? path21.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`) : id;
+        if (await fs15.pathExists(helperPath)) {
           console.warn("[weapp-vite] resolving oxc helper via Rolldown plugin:", helperName);
-          return fs13.readFile(helperPath, "utf8");
+          return fs15.readFile(helperPath, "utf8");
         }
         const fallback = fallbackHelpers[helperName];
         if (fallback) {
@@ -20925,7 +21135,7 @@ function createOxcRuntimeSupport() {
       }
       const helperName = getOxcHelperName(source);
       if (helperName) {
-        return path19.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
+        return path21.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
       }
       return null;
     },
@@ -20937,9 +21147,9 @@ function createOxcRuntimeSupport() {
       if (!helperName) {
         return null;
       }
-      const helperPath = path19.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
+      const helperPath = path21.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
       console.warn("[weapp-vite] resolving oxc helper via Vite plugin:", helperName);
-      return fs13.readFile(helperPath, "utf8");
+      return fs15.readFile(helperPath, "utf8");
     }
   };
   return {
@@ -20952,7 +21162,7 @@ function createOxcRuntimeSupport() {
 // src/runtime/packageAliases.ts
 init_esm_shims();
 import { existsSync } from "fs";
-import path20 from "pathe";
+import path22 from "pathe";
 var SPECIAL_PACKAGE_ALIASES = [
   {
     packageName: "class-variance-authority",
@@ -20966,7 +21176,7 @@ function resolveBuiltinPackageAliases() {
     if (!info) {
       continue;
     }
-    const resolvedEntry = path20.resolve(info.rootPath, distEntry);
+    const resolvedEntry = path22.resolve(info.rootPath, distEntry);
     if (!existsSync(resolvedEntry)) {
       continue;
     }
@@ -21040,29 +21250,39 @@ function createConfigService(ctx) {
     if (!mpDistRoot) {
       throw new Error("\u8BF7\u5728 `project.config.json` \u91CC\u8BBE\u7F6E `miniprogramRoot`, \u6BD4\u5982\u53EF\u4EE5\u8BBE\u7F6E\u4E3A `dist/` ");
     }
-    const packageJsonPath = path21.resolve(cwd, "package.json");
+    const packageJsonPath = path23.resolve(cwd, "package.json");
     let packageJson = {};
-    if (await fs14.exists(packageJsonPath)) {
-      const localPackageJson = await fs14.readJson(packageJsonPath, {
+    if (await fs16.exists(packageJsonPath)) {
+      const localPackageJson = await fs16.readJson(packageJsonPath, {
         throws: false
       }) || {};
       packageJson = localPackageJson;
     }
     let resolvedConfigFile = configFile;
-    if (resolvedConfigFile && !path21.isAbsolute(resolvedConfigFile)) {
-      resolvedConfigFile = path21.resolve(cwd, resolvedConfigFile);
+    if (resolvedConfigFile && !path23.isAbsolute(resolvedConfigFile)) {
+      resolvedConfigFile = path23.resolve(cwd, resolvedConfigFile);
     }
+    const weappConfigFilePath = await resolveWeappConfigFile({
+      root: cwd,
+      specified: resolvedConfigFile
+    });
     const loaded = await loadConfigFromFile({
       command: isDev ? "serve" : "build",
       mode
     }, resolvedConfigFile, cwd);
     const loadedConfig = loaded?.config;
-    const srcRoot = loadedConfig?.weapp?.srcRoot ?? "";
-    function relativeSrcRoot(p) {
-      if (srcRoot) {
-        return path21.relative(srcRoot, p);
+    let weappLoaded;
+    if (weappConfigFilePath) {
+      const normalizedWeappPath = path23.resolve(weappConfigFilePath);
+      const normalizedLoadedPath = loaded?.path ? path23.resolve(loaded.path) : void 0;
+      if (normalizedLoadedPath && normalizedLoadedPath === normalizedWeappPath) {
+        weappLoaded = loaded;
+      } else {
+        weappLoaded = await loadConfigFromFile({
+          command: isDev ? "serve" : "build",
+          mode
+        }, weappConfigFilePath, cwd);
       }
-      return p;
     }
     const config = defu3(
       inlineConfig,
@@ -21088,6 +21308,19 @@ function createConfigService(ctx) {
         weapp: getWeappViteConfig()
       }
     );
+    if (weappLoaded?.config?.weapp) {
+      config.weapp = defu3(
+        weappLoaded.config.weapp,
+        config.weapp ?? {}
+      );
+    }
+    const srcRoot = config.weapp?.srcRoot ?? "";
+    function relativeSrcRoot(p) {
+      if (srcRoot) {
+        return path23.relative(srcRoot, p);
+      }
+      return p;
+    }
     const rolldownPlugin = oxcRuntimeSupport.rolldownPlugin;
     if (rolldownPlugin) {
       const build3 = config.build ?? (config.build = {});
@@ -21111,6 +21344,7 @@ function createConfigService(ctx) {
     config.plugins ??= [];
     config.plugins?.push(tsconfigPaths(config.weapp?.tsconfigPaths));
     const aliasEntries = getAliasEntries(config.weapp?.jsonAlias);
+    const configFilePath = weappLoaded?.path ?? loaded?.path ?? resolvedConfigFile;
     return {
       config,
       aliasEntries,
@@ -21125,6 +21359,7 @@ function createConfigService(ctx) {
       packageJsonPath,
       platform,
       srcRoot,
+      configFilePath,
       currentSubPackageRoot: void 0
     };
   }
@@ -21143,6 +21378,7 @@ function createConfigService(ctx) {
       config: {},
       packageJson: {},
       platform: "weapp",
+      configFilePath: void 0,
       currentSubPackageRoot: void 0
     });
     options = resolvedConfig;
@@ -21226,9 +21462,9 @@ function createConfigService(ctx) {
             watch: {
               exclude: [
                 ...defaultExcluded,
-                options.mpDistRoot ? path21.join(options.cwd, options.mpDistRoot, "**") : path21.join(options.cwd, "dist", "**")
+                options.mpDistRoot ? path23.join(options.cwd, options.mpDistRoot, "**") : path23.join(options.cwd, "dist", "**")
               ],
-              include: [path21.join(options.cwd, options.srcRoot, "**")]
+              include: [path23.join(options.cwd, options.srcRoot, "**")]
             },
             minify: false,
             emptyOutDir: false,
@@ -21315,7 +21551,7 @@ function createConfigService(ctx) {
       return options.mpDistRoot;
     },
     get outDir() {
-      return path21.resolve(options.cwd, options.mpDistRoot ?? "");
+      return path23.resolve(options.cwd, options.mpDistRoot ?? "");
     },
     get currentSubPackageRoot() {
       return options.currentSubPackageRoot;
@@ -21340,11 +21576,11 @@ function createConfigService(ctx) {
     },
     get absolutePluginRoot() {
       if (options.config.weapp?.pluginRoot) {
-        return path21.resolve(options.cwd, options.config.weapp.pluginRoot);
+        return path23.resolve(options.cwd, options.config.weapp.pluginRoot);
       }
     },
     get absoluteSrcRoot() {
-      return path21.resolve(options.cwd, options.srcRoot);
+      return path23.resolve(options.cwd, options.srcRoot);
     },
     get mode() {
       return options.mode;
@@ -21355,14 +21591,17 @@ function createConfigService(ctx) {
     get platform() {
       return options.platform;
     },
+    get configFilePath() {
+      return options.configFilePath;
+    },
     relativeCwd(p) {
-      return path21.relative(options.cwd, p);
+      return path23.relative(options.cwd, p);
     },
     relativeSrcRoot(p) {
       return options.relativeSrcRoot(p);
     },
     relativeAbsoluteSrcRoot(p) {
-      return path21.relative(path21.resolve(options.cwd, options.srcRoot), p);
+      return path23.relative(path23.resolve(options.cwd, options.srcRoot), p);
     }
   };
 }
@@ -21377,7 +21616,7 @@ function createConfigServicePlugin(ctx) {
 // src/runtime/jsonPlugin.ts
 init_esm_shims();
 import { parse as parseJson2 } from "comment-json";
-import fs15 from "fs-extra";
+import fs17 from "fs-extra";
 import { bundleRequire } from "rolldown-require";
 function parseCommentJson(json) {
   return parseJson2(json, void 0, true);
@@ -21409,7 +21648,7 @@ function createJsonService(ctx) {
         });
         resultJson = typeof mod.default === "function" ? await mod.default(ctx) : mod.default;
       } else {
-        resultJson = parseCommentJson(await fs15.readFile(filepath, "utf8"));
+        resultJson = parseCommentJson(await fs17.readFile(filepath, "utf8"));
       }
       cache2.set(filepath, resultJson);
       return resultJson;
@@ -21442,14 +21681,14 @@ function createJsonServicePlugin(ctx) {
 init_esm_shims();
 import { isBuiltin } from "module";
 import { defu as defu4, isObject as isObject8, objectHash as objectHash2 } from "@weapp-core/shared";
-import fs16 from "fs-extra";
-import path22 from "pathe";
+import fs18 from "fs-extra";
+import path24 from "pathe";
 function createNpmService(ctx) {
   function getDependenciesCacheFilePath(key = "/") {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before generating npm cache path");
     }
-    return path22.resolve(ctx.configService.cwd, `node_modules/weapp-vite/.cache/${key.replaceAll("/", "-")}.json`);
+    return path24.resolve(ctx.configService.cwd, `node_modules/weapp-vite/.cache/${key.replaceAll("/", "-")}.json`);
   }
   function dependenciesCacheHash() {
     if (!ctx.configService) {
@@ -21461,22 +21700,22 @@ function createNpmService(ctx) {
     return Reflect.has(pkg, "miniprogram") && typeof pkg.miniprogram === "string";
   }
   async function shouldSkipBuild(outDir, isOutdated) {
-    return !isOutdated && await fs16.exists(outDir);
+    return !isOutdated && await fs18.exists(outDir);
   }
   async function writeDependenciesCache(root) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before writing npm cache");
     }
     if (ctx.configService.weappViteConfig?.npm?.cache) {
-      await fs16.outputJSON(getDependenciesCacheFilePath(root), {
+      await fs18.outputJSON(getDependenciesCacheFilePath(root), {
         hash: dependenciesCacheHash()
       });
     }
   }
   async function readDependenciesCache(root) {
     const cachePath = getDependenciesCacheFilePath(root);
-    if (await fs16.exists(cachePath)) {
-      return await fs16.readJson(cachePath, { throws: false });
+    if (await fs18.exists(cachePath)) {
+      return await fs18.readJson(cachePath, { throws: false });
     }
   }
   async function checkDependenciesCacheOutdate(root) {
@@ -21529,7 +21768,7 @@ function createNpmService(ctx) {
     }
   }
   async function copyBuild({ from, to }) {
-    await fs16.copy(
+    await fs18.copy(
       from,
       to
     );
@@ -21542,14 +21781,14 @@ function createNpmService(ctx) {
     const { packageJson: targetJson, rootPath } = packageInfo;
     const dependencies = targetJson.dependencies ?? {};
     const keys = Object.keys(dependencies);
-    const destOutDir = path22.resolve(outDir, dep);
+    const destOutDir = path24.resolve(outDir, dep);
     if (await shouldSkipBuild(destOutDir, isDependenciesCacheOutdate)) {
       logger_default.info(`[npm] \u4F9D\u8D56 \`${dep}\` \u672A\u53D1\u751F\u53D8\u5316\uFF0C\u8DF3\u8FC7\u5904\u7406!`);
       return;
     }
     if (isMiniprogramPackage(targetJson)) {
       await copyBuild({
-        from: path22.resolve(
+        from: path24.resolve(
           rootPath,
           targetJson.miniprogram
         ),
@@ -21621,10 +21860,10 @@ function createNpmService(ctx) {
     debug?.("buildNpm start");
     const packNpmRelationList = getPackNpmRelationList();
     const [mainRelation, ...subRelations] = packNpmRelationList;
-    const packageJsonPath = path22.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
-    if (await fs16.exists(packageJsonPath)) {
-      const pkgJson = await fs16.readJson(packageJsonPath);
-      const outDir = path22.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, "miniprogram_npm");
+    const packageJsonPath = path24.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
+    if (await fs18.exists(packageJsonPath)) {
+      const pkgJson = await fs18.readJson(packageJsonPath);
+      const outDir = path24.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, "miniprogram_npm");
       if (pkgJson.dependencies) {
         const dependencies = Object.keys(pkgJson.dependencies);
         if (dependencies.length > 0) {
@@ -21643,7 +21882,7 @@ function createNpmService(ctx) {
           const targetDirs = [
             ...subRelations.map((x) => {
               return {
-                npmDistDir: path22.resolve(ctx.configService.cwd, x.miniprogramNpmDistDir, "miniprogram_npm")
+                npmDistDir: path24.resolve(ctx.configService.cwd, x.miniprogramNpmDistDir, "miniprogram_npm")
               };
             }),
             ...[...ctx.scanService.independentSubPackageMap.values()].map((x) => {
@@ -21651,19 +21890,19 @@ function createNpmService(ctx) {
               return {
                 root: x.subPackage.root,
                 dependencies: dependencies2,
-                npmDistDir: path22.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, x.subPackage.root, "miniprogram_npm")
+                npmDistDir: path24.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, x.subPackage.root, "miniprogram_npm")
               };
             })
           ];
           await Promise.all(targetDirs.map(async (x) => {
             if (x.root) {
               const isDependenciesCacheOutdate2 = await checkDependenciesCacheOutdate(x.root);
-              if (isDependenciesCacheOutdate2 || !await fs16.exists(x.npmDistDir)) {
-                await fs16.copy(outDir, x.npmDistDir, {
+              if (isDependenciesCacheOutdate2 || !await fs18.exists(x.npmDistDir)) {
+                await fs18.copy(outDir, x.npmDistDir, {
                   overwrite: true,
                   filter: (src) => {
                     if (Array.isArray(x.dependencies)) {
-                      const relPath = path22.relative(outDir, src);
+                      const relPath = path24.relative(outDir, src);
                       if (relPath === "") {
                         return true;
                       }
@@ -21675,11 +21914,11 @@ function createNpmService(ctx) {
               }
               await writeDependenciesCache(x.root);
             } else {
-              await fs16.copy(outDir, x.npmDistDir, {
+              await fs18.copy(outDir, x.npmDistDir, {
                 overwrite: true,
                 filter: (src) => {
                   if (Array.isArray(x.dependencies)) {
-                    const relPath = path22.relative(outDir, src);
+                    const relPath = path24.relative(outDir, src);
                     if (relPath === "") {
                       return true;
                     }
@@ -22432,10 +22671,31 @@ init_esm_shims();
 
 // src/cache/file.ts
 init_esm_shims();
-import { createHash as createHash2 } from "crypto";
-import fs17 from "fs-extra";
+import fs19 from "fs-extra";
+var FNV_OFFSET_BASIS = 0xCBF29CE484222325n;
+var FNV_PRIME = 0x100000001B3n;
+var FNV_MASK = 0xFFFFFFFFFFFFFFFFn;
+function fnv1aStep(hash, byte) {
+  hash ^= BigInt(byte & 255);
+  return hash * FNV_PRIME & FNV_MASK;
+}
 function createSignature(content) {
-  return createHash2("sha1").update(content).digest("hex");
+  let hash = FNV_OFFSET_BASIS;
+  if (typeof content === "string") {
+    for (let i = 0; i < content.length; i++) {
+      const code = content.charCodeAt(i);
+      hash = fnv1aStep(hash, code & 255);
+      const high = code >>> 8;
+      if (high > 0) {
+        hash = fnv1aStep(hash, high);
+      }
+    }
+  } else {
+    for (const byte of content) {
+      hash = fnv1aStep(hash, byte);
+    }
+  }
+  return hash.toString(36);
 }
 var FileCache = class {
   cache;
@@ -22461,7 +22721,7 @@ var FileCache = class {
   async isInvalidate(id, options) {
     let mtimeMs;
     try {
-      const stat6 = await fs17.stat(id);
+      const stat6 = await fs19.stat(id);
       mtimeMs = stat6.mtimeMs;
     } catch (error) {
       if (error && error.code === "ENOENT") {
@@ -22522,7 +22782,8 @@ function createDefaultLoadConfigResult() {
     mpDistRoot: "",
     packageJsonPath: "",
     platform: "weapp",
-    srcRoot: ""
+    srcRoot: "",
+    configFilePath: void 0
   };
 }
 function createDefaultPackageInfo() {
@@ -22581,7 +22842,7 @@ function createRuntimeState() {
 // src/runtime/scanPlugin.ts
 init_esm_shims();
 import { isObject as isObject9, removeExtensionDeep as removeExtensionDeep5 } from "@weapp-core/shared";
-import path23 from "pathe";
+import path25 from "pathe";
 function resolveSubPackageEntries(subPackage) {
   const entries = [];
   const root = subPackage.root ?? "";
@@ -22605,11 +22866,11 @@ function createScanService(ctx) {
       return scanState.appEntry;
     }
     const appDirname = ctx.configService.absoluteSrcRoot;
-    const appBasename = path23.resolve(appDirname, "app");
+    const appBasename = path25.resolve(appDirname, "app");
     const { path: appConfigFile } = await findJsonEntry(appBasename);
     const { path: appEntryPath } = await findJsEntry(appBasename);
     if (ctx.configService.absolutePluginRoot) {
-      const pluginBasename = path23.resolve(ctx.configService.absolutePluginRoot, "plugin");
+      const pluginBasename = path25.resolve(ctx.configService.absolutePluginRoot, "plugin");
       const { path: pluginConfigFile } = await findJsonEntry(pluginBasename);
       if (pluginConfigFile) {
         const pluginConfig = await ctx.jsonService.read(pluginConfigFile);
@@ -22628,14 +22889,14 @@ function createScanService(ctx) {
         scanState.appEntry = resolvedAppEntry;
         const { sitemapLocation = "sitemap.json", themeLocation = "theme.json" } = config;
         if (sitemapLocation) {
-          const { path: sitemapJsonPath } = await findJsonEntry(path23.resolve(appDirname, sitemapLocation));
+          const { path: sitemapJsonPath } = await findJsonEntry(path25.resolve(appDirname, sitemapLocation));
           if (sitemapJsonPath) {
             resolvedAppEntry.sitemapJsonPath = sitemapJsonPath;
             resolvedAppEntry.sitemapJson = await ctx.jsonService.read(sitemapJsonPath);
           }
         }
         if (themeLocation) {
-          const { path: themeJsonPath } = await findJsonEntry(path23.resolve(appDirname, themeLocation));
+          const { path: themeJsonPath } = await findJsonEntry(path25.resolve(appDirname, themeLocation));
           if (themeJsonPath) {
             resolvedAppEntry.themeJsonPath = themeJsonPath;
             resolvedAppEntry.themeJson = await ctx.jsonService.read(themeJsonPath);
@@ -22819,8 +23080,8 @@ function createWatcherServicePlugin(ctx) {
 // src/runtime/wxmlPlugin.ts
 init_esm_shims();
 import { removeExtensionDeep as removeExtensionDeep6 } from "@weapp-core/shared";
-import fs18 from "fs-extra";
-import path24 from "pathe";
+import fs20 from "fs-extra";
+import path26 from "pathe";
 
 // src/wxml/index.ts
 init_esm_shims();
@@ -25202,7 +25463,7 @@ function fnv1aHash(input) {
   }
   return (hash >>> 0).toString(36);
 }
-function createCacheKey(source, platform) {
+function createCacheKey2(source, platform) {
   return `${platform}:${source.length.toString(36)}:${fnv1aHash(source)}`;
 }
 function resolveEventDirective(raw) {
@@ -25265,7 +25526,7 @@ function scanWxml(wxml, options) {
     platform: "weapp"
   });
   const canUseCache = opts.excludeComponent === defaultExcludeComponent;
-  const cacheKey = canUseCache ? createCacheKey(source, opts.platform) : void 0;
+  const cacheKey = canUseCache ? createCacheKey2(source, opts.platform) : void 0;
   if (cacheKey) {
     const cached = scanWxmlCache.get(cacheKey);
     if (cached) {
@@ -25407,6 +25668,9 @@ function scanWxml(wxml, options) {
     source
   );
   parser.end();
+  if (removalRanges.length > 1) {
+    removalRanges.sort((a, b) => b.start - a.start);
+  }
   const token = {
     components: components2,
     deps,
@@ -25517,9 +25781,9 @@ function createWxmlService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before scanning wxml");
     }
-    if (await fs18.exists(filepath)) {
-      const dirname5 = path24.dirname(filepath);
-      const wxml = await fs18.readFile(filepath, "utf8");
+    if (await fs20.exists(filepath)) {
+      const dirname5 = path26.dirname(filepath);
+      const wxml = await fs20.readFile(filepath, "utf8");
       const shouldRescan = await cache2.isInvalidate(filepath, { content: wxml });
       if (!shouldRescan) {
         const cached = cache2.get(filepath);
@@ -25535,9 +25799,9 @@ function createWxmlService(ctx) {
         filepath,
         res.deps.filter((x) => isImportTag(x.tagName) && isTemplate(x.value)).map((x) => {
           if (x.value.startsWith("/")) {
-            return path24.resolve(ctx.configService.absoluteSrcRoot, x.value.slice(1));
+            return path26.resolve(ctx.configService.absoluteSrcRoot, x.value.slice(1));
           } else {
-            return path24.resolve(dirname5, x.value);
+            return path26.resolve(dirname5, x.value);
           }
         })
       );
@@ -25637,6 +25901,7 @@ export {
   logger_default,
   VERSION,
   checkRuntime,
+  resolveWeappConfigFile,
   createCompilerContext
 };
 /*! Bundled license information: