weapp-vite 5.9.5 → 5.11.0

package/dist/{chunk-O6FIJOUD.mjs → chunk-7JZ3SMTK.mjs}

@@ -3,7 +3,7 @@ import {
   __require,
   __toESM,
   init_esm_shims
-} from "./chunk-3V77QISZ.mjs";
+} from "./chunk-KYR4QU4G.mjs";
 
 // ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/debug.js
 var require_debug = __commonJS({
@@ -1030,7 +1030,7 @@ 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
+// ../../node_modules/.pnpm/lru-cache@11.2.4/node_modules/lru-cache/dist/esm/index.js
 init_esm_shims();
 var defaultPerf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
 var warned = /* @__PURE__ */ new Set();
@@ -1075,7 +1075,6 @@ if (typeof AC === "undefined") {
   };
 }
 var shouldWarn = (code) => !warned.has(code);
-var TYPE = Symbol("type");
 var isPosInt = (n2) => n2 && n2 === Math.floor(n2) && n2 > 0 && isFinite(n2);
 var getUintArray = (max) => !isPosInt(max) ? null : max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
 var ZeroArray = class extends Array {
@@ -1203,6 +1202,7 @@ var LRUCache = class _LRUCache {
   #sizes;
   #starts;
   #ttls;
+  #autopurgeTimers;
   #hasDispose;
   #hasFetchMethod;
   #hasDisposeAfter;
@@ -1221,6 +1221,7 @@ var LRUCache = class _LRUCache {
       // properties
       starts: c.#starts,
       ttls: c.#ttls,
+      autopurgeTimers: c.#autopurgeTimers,
       sizes: c.#sizes,
       keyMap: c.#keyMap,
       keyList: c.#keyList,
@@ -1411,10 +1412,16 @@ var LRUCache = class _LRUCache {
     const starts = new ZeroArray(this.#max);
     this.#ttls = ttls;
     this.#starts = starts;
+    const purgeTimers = this.ttlAutopurge ? new Array(this.#max) : void 0;
+    this.#autopurgeTimers = purgeTimers;
     this.#setItemTTL = (index, ttl, start = this.#perf.now()) => {
       starts[index] = ttl !== 0 ? start : 0;
       ttls[index] = ttl;
-      if (ttl !== 0 && this.ttlAutopurge) {
+      if (purgeTimers?.[index]) {
+        clearTimeout(purgeTimers[index]);
+        purgeTimers[index] = void 0;
+      }
+      if (ttl !== 0 && purgeTimers) {
         const t2 = setTimeout(() => {
           if (this.#isStale(index)) {
             this.#delete(this.#keyList[index], "expire");
@@ -1423,6 +1430,7 @@ var LRUCache = class _LRUCache {
         if (t2.unref) {
           t2.unref();
         }
+        purgeTimers[index] = t2;
       }
     };
     this.#updateItemAge = (index) => {
@@ -1972,6 +1980,10 @@ var LRUCache = class _LRUCache {
       }
     }
     this.#removeItemSize(head);
+    if (this.#autopurgeTimers?.[head]) {
+      clearTimeout(this.#autopurgeTimers[head]);
+      this.#autopurgeTimers[head] = void 0;
+    }
     if (free) {
       this.#keyList[head] = void 0;
       this.#valList[head] = void 0;
@@ -2343,6 +2355,10 @@ var LRUCache = class _LRUCache {
     if (this.#size !== 0) {
       const index = this.#keyMap.get(k);
       if (index !== void 0) {
+        if (this.#autopurgeTimers?.[index]) {
+          clearTimeout(this.#autopurgeTimers?.[index]);
+          this.#autopurgeTimers[index] = void 0;
+        }
         deleted = true;
         if (this.#size === 1) {
           this.#clear(reason);
@@ -2413,6 +2429,11 @@ var LRUCache = class _LRUCache {
     if (this.#ttls && this.#starts) {
       this.#ttls.fill(0);
       this.#starts.fill(0);
+      for (const t2 of this.#autopurgeTimers ?? []) {
+        if (t2 !== void 0)
+          clearTimeout(t2);
+      }
+      this.#autopurgeTimers?.fill(void 0);
     }
     if (this.#sizes) {
       this.#sizes.fill(0);
@@ -2650,13 +2671,13 @@ function extractComponentProps(code) {
   });
   let props = /* @__PURE__ */ new Map();
   traverse(ast, {
-    CallExpression(path36) {
+    CallExpression(path37) {
       if (props.size > 0) {
         return;
       }
-      const callee = path36.node.callee;
+      const callee = path37.node.callee;
       if (callee.type === "Identifier" && callee.name === "Component") {
-        const [options] = path36.node.arguments;
+        const [options] = path37.node.arguments;
         if (options && options.type === "ObjectExpression") {
           props = extractComponentProperties(options);
         }
@@ -4303,18 +4324,18 @@ init_esm_shims();
 import fs6 from "fs";
 import process3 from "process";
 
-// ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
+// ../../node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
 init_esm_shims();
-import { stat as statcb } from "fs";
-import { stat as stat3, readdir as readdir2 } from "fs/promises";
 import { EventEmitter } from "events";
-import * as sysPath2 from "path";
+import { stat as statcb, Stats } from "fs";
+import { readdir as readdir2, stat as stat3 } from "fs/promises";
+import * as sp2 from "path";
 
-// ../../node_modules/.pnpm/readdirp@4.1.2/node_modules/readdirp/esm/index.js
+// ../../node_modules/.pnpm/readdirp@5.0.0/node_modules/readdirp/index.js
 init_esm_shims();
-import { stat, lstat, readdir, realpath } from "fs/promises";
+import { lstat, readdir, realpath, stat } from "fs/promises";
+import { join as pjoin, relative as prelative, resolve as presolve, sep as psep } from "path";
 import { Readable } from "stream";
-import { resolve as presolve, relative as prelative, join as pjoin, sep as psep } from "path";
 var EntryTypes = {
   FILE_TYPE: "files",
   DIR_TYPE: "directories",
@@ -4369,6 +4390,20 @@ var normalizeFilter = (filter3) => {
   return emptyFn;
 };
 var ReaddirpStream = class extends Readable {
+  parents;
+  reading;
+  parent;
+  _stat;
+  _maxDepth;
+  _wantsDir;
+  _wantsFile;
+  _wantsEverything;
+  _root;
+  _isDirent;
+  _statsProp;
+  _rdOptions;
+  _fileFilter;
+  _directoryFilter;
   constructor(options = {}) {
     super({
       objectMode: true,
@@ -4381,11 +4416,11 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path36) => statMethod(path36, { bigint: true });
+      this._stat = (path37) => statMethod(path37, { bigint: true });
     } else {
       this._stat = statMethod;
     }
-    this._maxDepth = opts.depth ?? defaultOptions.depth;
+    this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
     this._wantsDir = type ? DIR_TYPES.has(type) : false;
     this._wantsFile = type ? FILE_TYPES.has(type) : false;
     this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
@@ -4406,8 +4441,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path36, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path36));
+          const { path: path37, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path37));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -4447,20 +4482,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path36, depth) {
+  async _exploreDir(path37, depth) {
     let files;
     try {
-      files = await readdir(path36, this._rdOptions);
+      files = await readdir(path37, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path36 };
+    return { files, depth, path: path37 };
   }
-  async _formatEntry(dirent, path36) {
+  async _formatEntry(dirent, path37) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path36, basename4));
+      const fullPath = presolve(pjoin(path37, basename4));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -4530,12 +4565,12 @@ function readdirp(root, options = {}) {
   return new ReaddirpStream(options);
 }
 
-// ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/handler.js
+// ../../node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/handler.js
 init_esm_shims();
-import { watchFile, unwatchFile, watch as fs_watch } from "fs";
-import { open, stat as stat2, lstat as lstat2, realpath as fsrealpath } from "fs/promises";
-import * as sysPath from "path";
+import { watch as fs_watch, unwatchFile, watchFile } from "fs";
+import { realpath as fsrealpath, lstat as lstat2, open, stat as stat2 } from "fs/promises";
 import { type as osType } from "os";
+import * as sp from "path";
 var STR_DATA = "data";
 var STR_END = "end";
 var STR_CLOSE = "close";
@@ -4828,7 +4863,7 @@ var binaryExtensions = /* @__PURE__ */ new Set([
   "zip",
   "zipx"
 ]);
-var isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+var isBinaryPath = (filePath) => binaryExtensions.has(sp.extname(filePath).slice(1).toLowerCase());
 var foreach = (val, fn) => {
   if (val instanceof Set) {
     val.forEach(fn);
@@ -4861,16 +4896,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path36, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path37, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path36);
-    emitRaw(rawEvent, evPath, { watchedPath: path36 });
-    if (evPath && path36 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path36, evPath), KEY_LISTENERS, sysPath.join(path36, evPath));
+    listener(path37);
+    emitRaw(rawEvent, evPath, { watchedPath: path37 });
+    if (evPath && path37 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path37, evPath), KEY_LISTENERS, sp.join(path37, evPath));
     }
   };
   try {
-    return fs_watch(path36, {
+    return fs_watch(path37, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -4886,12 +4921,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path36, fullPath, options, handlers) => {
+var setFsWatchListener = (path37, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path36, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path37, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -4902,7 +4937,7 @@ var setFsWatchListener = (path36, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path36,
+      path37,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -4917,7 +4952,7 @@ var setFsWatchListener = (path36, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path36, "r");
+          const fd = await open(path37, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -4948,7 +4983,7 @@ var setFsWatchListener = (path36, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path36, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path37, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -4970,7 +5005,7 @@ var setFsWatchFileListener = (path36, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path36, curr));
+          foreach(cont.listeners, (listener2) => listener2(path37, curr));
         }
       })
     };
@@ -4988,6 +5023,8 @@ var setFsWatchFileListener = (path36, fullPath, options, handlers) => {
   };
 };
 var NodeFsHandler = class {
+  fsw;
+  _boundHandleError;
   constructor(fsW) {
     this.fsw = fsW;
     this._boundHandleError = (error) => fsW._handleError(error);
@@ -4998,13 +5035,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path36, listener) {
+  _watchWithNodeFs(path37, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path36);
-    const basename4 = sysPath.basename(path36);
+    const directory = sp.dirname(path37);
+    const basename4 = sp.basename(path37);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename4);
-    const absolutePath = sysPath.resolve(path36);
+    const absolutePath = sp.resolve(path37);
     const options = {
       persistent: opts.persistent
     };
@@ -5014,12 +5051,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path36, absolutePath, options, {
+      closer = setFsWatchFileListener(path37, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path36, absolutePath, options, {
+      closer = setFsWatchListener(path37, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -5035,13 +5072,13 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname5 = sysPath.dirname(file);
-    const basename4 = sysPath.basename(file);
+    const dirname5 = sp.dirname(file);
+    const basename4 = sp.basename(file);
     const parent = this.fsw._getWatchedDir(dirname5);
     let prevStats = stats;
     if (parent.has(basename4))
       return;
-    const listener = async (path36, newStats) => {
+    const listener = async (path37, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -5055,11 +5092,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path36);
+            this.fsw._closeFile(path37);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path36, closer2);
+              this.fsw._addPathCloser(path37, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -5091,7 +5128,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, path36, item) {
+  async _handleSymlink(entry, directory, path37, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -5101,7 +5138,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path36);
+        linkPath = await fsrealpath(path37);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -5111,12 +5148,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, path36, entry.stats);
+          this.fsw._emit(EV.CHANGE, path37, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path36, entry.stats);
+        this.fsw._emit(EV.ADD, path37, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -5127,8 +5164,9 @@ var NodeFsHandler = class {
     this.fsw._symlinkPaths.set(full, true);
   }
   _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
-    directory = sysPath.join(directory, "");
-    throttler = this.fsw._throttle("readdir", directory, 1e3);
+    directory = sp.join(directory, "");
+    const throttleKey = target ? `${directory}:${target}` : directory;
+    throttler = this.fsw._throttle("readdir", throttleKey, 1e3);
     if (!throttler)
       return;
     const previous = this.fsw._getWatchedDir(wh.path);
@@ -5145,9 +5183,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path36 = sysPath.join(directory, item);
+      let path37 = sp.join(directory, item);
       current2.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path36, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path37, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -5156,8 +5194,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path36 = sysPath.join(dir, sysPath.relative(dir, path36));
-        this._addToNodeFs(path36, initialAdd, wh, depth + 1);
+        path37 = sp.join(dir, sp.relative(dir, path37));
+        this._addToNodeFs(path37, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve8, reject) => {
@@ -5193,12 +5231,12 @@ var NodeFsHandler = class {
    * @returns closer for the watcher instance.
    */
   async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath3) {
-    const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
-    const tracked = parentDir.has(sysPath.basename(dir));
+    const parentDir = this.fsw._getWatchedDir(sp.dirname(dir));
+    const tracked = parentDir.has(sp.basename(dir));
     if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
       this.fsw._emit(EV.ADD_DIR, dir, stats);
     }
-    parentDir.add(sysPath.basename(dir));
+    parentDir.add(sp.basename(dir));
     this.fsw._getWatchedDir(dir);
     let throttler;
     let closer;
@@ -5226,13 +5264,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path36, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path37, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path36) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path37) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path36);
+    const wh = this.fsw._getWatchHelpers(path37);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -5248,8 +5286,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path36);
-        const targetPath = follow ? await fsrealpath(path36) : path36;
+        const absPath = sp.resolve(path37);
+        const targetPath = follow ? await fsrealpath(path37) : path37;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -5259,42 +5297,42 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path36) : path36;
+        const targetPath = follow ? await fsrealpath(path37) : path37;
         if (this.fsw.closed)
           return;
-        const parent = sysPath.dirname(wh.watchPath);
+        const parent = sp.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, path36, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path37, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path36), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path37), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path36, closer);
+        this.fsw._addPathCloser(path37, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path36;
+        return path37;
       }
     }
   }
 };
 
-// ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
+// ../../node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
 var SLASH = "/";
 var SLASH_SLASH = "//";
 var ONE_DOT = ".";
 var TWO_DOTS = "..";
 var STRING_TYPE = "string";
 var BACK_SLASH_RE = /\\/g;
-var DOUBLE_SLASH_RE = /\/\//;
+var DOUBLE_SLASH_RE = /\/\//g;
 var DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
 var REPLACER_RE = /^\.[/\\]/;
 function arrify(item) {
@@ -5313,37 +5351,35 @@ function createPattern(matcher) {
       if (matcher.path === string)
         return true;
       if (matcher.recursive) {
-        const relative3 = sysPath2.relative(matcher.path, string);
+        const relative3 = sp2.relative(matcher.path, string);
         if (!relative3) {
           return false;
         }
-        return !relative3.startsWith("..") && !sysPath2.isAbsolute(relative3);
+        return !relative3.startsWith("..") && !sp2.isAbsolute(relative3);
       }
       return false;
     };
   }
   return () => false;
 }
-function normalizePath(path36) {
-  if (typeof path36 !== "string")
+function normalizePath(path37) {
+  if (typeof path37 !== "string")
     throw new Error("string expected");
-  path36 = sysPath2.normalize(path36);
-  path36 = path36.replace(/\\/g, "/");
+  path37 = sp2.normalize(path37);
+  path37 = path37.replace(/\\/g, "/");
   let prepend = false;
-  if (path36.startsWith("//"))
+  if (path37.startsWith("//"))
     prepend = true;
-  const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path36.match(DOUBLE_SLASH_RE2))
-    path36 = path36.replace(DOUBLE_SLASH_RE2, "/");
+  path37 = path37.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path36 = "/" + path36;
-  return path36;
+    path37 = "/" + path37;
+  return path37;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path36 = normalizePath(testString);
+  const path37 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path36, stats)) {
+    if (pattern(path37, stats)) {
       return true;
     }
   }
@@ -5375,30 +5411,31 @@ var toUnix = (string) => {
   if (str.startsWith(SLASH_SLASH)) {
     prepend = true;
   }
-  while (str.match(DOUBLE_SLASH_RE)) {
-    str = str.replace(DOUBLE_SLASH_RE, SLASH);
-  }
+  str = str.replace(DOUBLE_SLASH_RE, SLASH);
   if (prepend) {
     str = SLASH + str;
   }
   return str;
 };
-var normalizePathToUnix = (path36) => toUnix(sysPath2.normalize(toUnix(path36)));
-var normalizeIgnored = (cwd = "") => (path36) => {
-  if (typeof path36 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path36) ? path36 : sysPath2.join(cwd, path36));
+var normalizePathToUnix = (path37) => toUnix(sp2.normalize(toUnix(path37)));
+var normalizeIgnored = (cwd = "") => (path37) => {
+  if (typeof path37 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path37) ? path37 : sp2.join(cwd, path37));
   } else {
-    return path36;
+    return path37;
   }
 };
-var getAbsolutePath = (path36, cwd) => {
-  if (sysPath2.isAbsolute(path36)) {
-    return path36;
+var getAbsolutePath = (path37, cwd) => {
+  if (sp2.isAbsolute(path37)) {
+    return path37;
   }
-  return sysPath2.join(cwd, path36);
+  return sp2.join(cwd, path37);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
+  path;
+  _removeWatcher;
+  items;
   constructor(dir, removeWatcher) {
     this.path = dir;
     this._removeWatcher = removeWatcher;
@@ -5423,7 +5460,7 @@ var DirEntry = class {
       await readdir2(dir);
     } catch (err) {
       if (this._removeWatcher) {
-        this._removeWatcher(sysPath2.dirname(dir), sysPath2.basename(dir));
+        this._removeWatcher(sp2.dirname(dir), sp2.basename(dir));
       }
     }
   }
@@ -5450,12 +5487,19 @@ var DirEntry = class {
 var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 var WatchHelper = class {
-  constructor(path36, follow, fsw) {
+  fsw;
+  path;
+  watchPath;
+  fullWatchPath;
+  dirParts;
+  followSymlinks;
+  statMethod;
+  constructor(path37, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path36;
-    this.path = path36 = path36.replace(REPLACER_RE, "");
+    const watchPath = path37;
+    this.path = path37 = path37.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
-    this.fullWatchPath = sysPath2.resolve(watchPath);
+    this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
     this.dirParts.forEach((parts) => {
       if (parts.length > 1)
@@ -5465,7 +5509,7 @@ var WatchHelper = class {
     this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
   }
   entryPath(entry) {
-    return sysPath2.join(this.watchPath, sysPath2.relative(this.watchPath, entry.fullPath));
+    return sp2.join(this.watchPath, sp2.relative(this.watchPath, entry.fullPath));
   }
   filterPath(entry) {
     const { stats } = entry;
@@ -5479,6 +5523,24 @@ var WatchHelper = class {
   }
 };
 var FSWatcher = class extends EventEmitter {
+  closed;
+  options;
+  _closers;
+  _ignoredPaths;
+  _throttled;
+  _streams;
+  _symlinkPaths;
+  _watched;
+  _pendingWrites;
+  _pendingUnlinks;
+  _readyCount;
+  _emitReady;
+  _closePromise;
+  _userIgnored;
+  _readyEmitted;
+  _emitRaw;
+  _boundRemove;
+  _nodeFsHandler;
   // Not indenting methods for history sake; for now.
   constructor(_opts = {}) {
     super();
@@ -5575,20 +5637,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path36) => {
-        const absPath = getAbsolutePath(path36, cwd);
+      paths = paths.map((path37) => {
+        const absPath = getAbsolutePath(path37, cwd);
         return absPath;
       });
     }
-    paths.forEach((path36) => {
-      this._removeIgnoredPath(path36);
+    paths.forEach((path37) => {
+      this._removeIgnoredPath(path37);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path36) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path36, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path37) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path37, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -5597,7 +5659,7 @@ var FSWatcher = class extends EventEmitter {
         return;
       results.forEach((item) => {
         if (item)
-          this.add(sysPath2.dirname(item), sysPath2.basename(_origAdd || item));
+          this.add(sp2.dirname(item), sp2.basename(_origAdd || item));
       });
     });
     return this;
@@ -5610,17 +5672,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path36) => {
-      if (!sysPath2.isAbsolute(path36) && !this._closers.has(path36)) {
+    paths.forEach((path37) => {
+      if (!sp2.isAbsolute(path37) && !this._closers.has(path37)) {
         if (cwd)
-          path36 = sysPath2.join(cwd, path36);
-        path36 = sysPath2.resolve(path36);
+          path37 = sp2.join(cwd, path37);
+        path37 = sp2.resolve(path37);
       }
-      this._closePath(path36);
-      this._addIgnoredPath(path36);
-      if (this._watched.has(path36)) {
+      this._closePath(path37);
+      this._addIgnoredPath(path37);
+      if (this._watched.has(path37)) {
         this._addIgnoredPath({
-          path: path36,
+          path: path37,
           recursive: true
         });
       }
@@ -5663,7 +5725,7 @@ var FSWatcher = class extends EventEmitter {
   getWatched() {
     const watchList = {};
     this._watched.forEach((entry, dir) => {
-      const key = this.options.cwd ? sysPath2.relative(this.options.cwd, dir) : dir;
+      const key = this.options.cwd ? sp2.relative(this.options.cwd, dir) : dir;
       const index = key || ONE_DOT;
       watchList[index] = entry.getChildren().sort();
     });
@@ -5684,38 +5746,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, path36, stats) {
+  async _emit(event, path37, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path36 = sysPath2.normalize(path36);
+      path37 = sp2.normalize(path37);
     if (opts.cwd)
-      path36 = sysPath2.relative(opts.cwd, path36);
-    const args = [path36];
+      path37 = sp2.relative(opts.cwd, path37);
+    const args = [path37];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path36))) {
+    if (awf && (pw = this._pendingWrites.get(path37))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path36, [event, ...args]);
+        this._pendingUnlinks.set(path37, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path37) => {
+          this._pendingUnlinks.forEach((entry, path38) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path37);
+            this._pendingUnlinks.delete(path38);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path36)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path37)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path36);
+        this._pendingUnlinks.delete(path37);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -5733,16 +5795,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path36, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path37, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path36, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path37, 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, path36) : path36;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path37) : path37;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -5773,23 +5835,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, path36, timeout) {
+  _throttle(actionType, path37, 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(path36);
+    const actionPath = action.get(path37);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path36);
+      const item = action.get(path37);
       const count = item ? item.count : 0;
-      action.delete(path36);
+      action.delete(path37);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -5797,7 +5859,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path36, thr);
+    action.set(path37, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -5811,44 +5873,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path36, threshold, event, awfEmit) {
+  _awaitWriteFinish(path37, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path36;
-    if (this.options.cwd && !sysPath2.isAbsolute(path36)) {
-      fullPath = sysPath2.join(this.options.cwd, path36);
+    let fullPath = path37;
+    if (this.options.cwd && !sp2.isAbsolute(path37)) {
+      fullPath = sp2.join(this.options.cwd, path37);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path36)) {
+        if (err || !writes.has(path37)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path36).lastChange = now2;
+          writes.get(path37).lastChange = now2;
         }
-        const pw = writes.get(path36);
+        const pw = writes.get(path37);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path36);
+          writes.delete(path37);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path36)) {
-      writes.set(path36, {
+    if (!writes.has(path37)) {
+      writes.set(path37, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path36);
+          writes.delete(path37);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -5859,8 +5921,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path36, stats) {
-    if (this.options.atomic && DOT_RE.test(path36))
+  _isIgnored(path37, stats) {
+    if (this.options.atomic && DOT_RE.test(path37))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -5870,17 +5932,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path36, stats);
+    return this._userIgnored(path37, stats);
   }
-  _isntIgnored(path36, stat5) {
-    return !this._isIgnored(path36, stat5);
+  _isntIgnored(path37, stat5) {
+    return !this._isIgnored(path37, stat5);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path36) {
-    return new WatchHelper(path36, this.options.followSymlinks, this);
+  _getWatchHelpers(path37) {
+    return new WatchHelper(path37, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -5889,7 +5951,7 @@ var FSWatcher = class extends EventEmitter {
    * @param directory path of the directory
    */
   _getWatchedDir(directory) {
-    const dir = sysPath2.resolve(directory);
+    const dir = sp2.resolve(directory);
     if (!this._watched.has(dir))
       this._watched.set(dir, new DirEntry(dir, this._boundRemove));
     return this._watched.get(dir);
@@ -5912,63 +5974,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path36 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path36);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path36) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path36, 100))
+    const path37 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path37);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path37) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path37, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path36);
+    const wp = this._getWatchedDir(path37);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path36, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path37, 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 = path36;
+    let relPath = path37;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path36);
+      relPath = sp2.relative(this.options.cwd, path37);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path36);
+    this._watched.delete(path37);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path36))
-      this._emit(eventName, path36);
-    this._closePath(path36);
+    if (wasTracked && !this._isIgnored(path37))
+      this._emit(eventName, path37);
+    this._closePath(path37);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path36) {
-    this._closeFile(path36);
-    const dir = sysPath2.dirname(path36);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path36));
+  _closePath(path37) {
+    this._closeFile(path37);
+    const dir = sp2.dirname(path37);
+    this._getWatchedDir(dir).remove(sp2.basename(path37));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path36) {
-    const closers = this._closers.get(path36);
+  _closeFile(path37) {
+    const closers = this._closers.get(path37);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path36);
+    this._closers.delete(path37);
   }
-  _addPathCloser(path36, closer) {
+  _addPathCloser(path37, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path36);
+    let list = this._closers.get(path37);
     if (!list) {
       list = [];
-      this._closers.set(path36, list);
+      this._closers.set(path37, list);
     }
     list.push(closer);
   }
@@ -5995,15 +6057,15 @@ function watch(paths, options = {}) {
   watcher.add(paths);
   return watcher;
 }
-var esm_default = { watch, FSWatcher };
+var chokidar_default = { watch, FSWatcher };
 
 // src/runtime/buildPlugin.ts
 import path11 from "pathe";
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/index.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/index.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/glob@11.0.3/node_modules/glob/dist/esm/index.js
+// ../../node_modules/.pnpm/glob@13.0.0/node_modules/glob/dist/esm/index.js
 init_esm_shims();
 
 // ../../node_modules/.pnpm/minimatch@10.1.1/node_modules/minimatch/dist/esm/index.js
@@ -6908,7 +6970,7 @@ var path9 = {
 };
 var sep = defaultPlatform === "win32" ? path9.win32.sep : path9.posix.sep;
 minimatch.sep = sep;
-var GLOBSTAR = Symbol("globstar **");
+var GLOBSTAR = /* @__PURE__ */ Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
 var qmark2 = "[^/]";
 var star2 = qmark2 + "*?";
@@ -7572,11 +7634,11 @@ minimatch.Minimatch = Minimatch;
 minimatch.escape = escape;
 minimatch.unescape = unescape2;
 
-// ../../node_modules/.pnpm/glob@11.0.3/node_modules/glob/dist/esm/glob.js
+// ../../node_modules/.pnpm/glob@13.0.0/node_modules/glob/dist/esm/glob.js
 init_esm_shims();
 import { fileURLToPath as fileURLToPath2 } from "url";
 
-// ../../node_modules/.pnpm/path-scurry@2.0.0/node_modules/path-scurry/dist/esm/index.js
+// ../../node_modules/.pnpm/path-scurry@2.0.1/node_modules/path-scurry/dist/esm/index.js
 init_esm_shims();
 import { posix, win32 } from "path";
 import { fileURLToPath } from "url";
@@ -7597,37 +7659,37 @@ var isStream = (s) => !!s && typeof s === "object" && (s instanceof Minipass ||
 var isReadable = (s) => !!s && typeof s === "object" && s instanceof EventEmitter2 && typeof s.pipe === "function" && // node core Writable streams have a pipe() method, but it throws
 s.pipe !== Stream.Writable.prototype.pipe;
 var isWritable = (s) => !!s && typeof s === "object" && s instanceof EventEmitter2 && typeof s.write === "function" && typeof s.end === "function";
-var EOF = Symbol("EOF");
-var MAYBE_EMIT_END = Symbol("maybeEmitEnd");
-var EMITTED_END = Symbol("emittedEnd");
-var EMITTING_END = Symbol("emittingEnd");
-var EMITTED_ERROR = Symbol("emittedError");
-var CLOSED = Symbol("closed");
-var READ = Symbol("read");
-var FLUSH = Symbol("flush");
-var FLUSHCHUNK = Symbol("flushChunk");
-var ENCODING = Symbol("encoding");
-var DECODER = Symbol("decoder");
-var FLOWING = Symbol("flowing");
-var PAUSED = Symbol("paused");
-var RESUME = Symbol("resume");
-var BUFFER = Symbol("buffer");
-var PIPES = Symbol("pipes");
-var BUFFERLENGTH = Symbol("bufferLength");
-var BUFFERPUSH = Symbol("bufferPush");
-var BUFFERSHIFT = Symbol("bufferShift");
-var OBJECTMODE = Symbol("objectMode");
-var DESTROYED = Symbol("destroyed");
-var ERROR = Symbol("error");
-var EMITDATA = Symbol("emitData");
-var EMITEND = Symbol("emitEnd");
-var EMITEND2 = Symbol("emitEnd2");
-var ASYNC = Symbol("async");
-var ABORT = Symbol("abort");
-var ABORTED = Symbol("aborted");
-var SIGNAL = Symbol("signal");
-var DATALISTENERS = Symbol("dataListeners");
-var DISCARDED = Symbol("discarded");
+var EOF = /* @__PURE__ */ Symbol("EOF");
+var MAYBE_EMIT_END = /* @__PURE__ */ Symbol("maybeEmitEnd");
+var EMITTED_END = /* @__PURE__ */ Symbol("emittedEnd");
+var EMITTING_END = /* @__PURE__ */ Symbol("emittingEnd");
+var EMITTED_ERROR = /* @__PURE__ */ Symbol("emittedError");
+var CLOSED = /* @__PURE__ */ Symbol("closed");
+var READ = /* @__PURE__ */ Symbol("read");
+var FLUSH = /* @__PURE__ */ Symbol("flush");
+var FLUSHCHUNK = /* @__PURE__ */ Symbol("flushChunk");
+var ENCODING = /* @__PURE__ */ Symbol("encoding");
+var DECODER = /* @__PURE__ */ Symbol("decoder");
+var FLOWING = /* @__PURE__ */ Symbol("flowing");
+var PAUSED = /* @__PURE__ */ Symbol("paused");
+var RESUME = /* @__PURE__ */ Symbol("resume");
+var BUFFER = /* @__PURE__ */ Symbol("buffer");
+var PIPES = /* @__PURE__ */ Symbol("pipes");
+var BUFFERLENGTH = /* @__PURE__ */ Symbol("bufferLength");
+var BUFFERPUSH = /* @__PURE__ */ Symbol("bufferPush");
+var BUFFERSHIFT = /* @__PURE__ */ Symbol("bufferShift");
+var OBJECTMODE = /* @__PURE__ */ Symbol("objectMode");
+var DESTROYED = /* @__PURE__ */ Symbol("destroyed");
+var ERROR = /* @__PURE__ */ Symbol("error");
+var EMITDATA = /* @__PURE__ */ Symbol("emitData");
+var EMITEND = /* @__PURE__ */ Symbol("emitEnd");
+var EMITEND2 = /* @__PURE__ */ Symbol("emitEnd2");
+var ASYNC = /* @__PURE__ */ Symbol("async");
+var ABORT = /* @__PURE__ */ Symbol("abort");
+var ABORTED = /* @__PURE__ */ Symbol("aborted");
+var SIGNAL = /* @__PURE__ */ Symbol("signal");
+var DATALISTENERS = /* @__PURE__ */ Symbol("dataListeners");
+var DISCARDED = /* @__PURE__ */ Symbol("discarded");
 var defer = (fn) => Promise.resolve().then(fn);
 var nodefer = (fn) => fn();
 var isEndish = (ev) => ev === "end" || ev === "finish" || ev === "prefinish";
@@ -8463,7 +8525,7 @@ var Minipass = class extends EventEmitter2 {
   }
 };
 
-// ../../node_modules/.pnpm/path-scurry@2.0.0/node_modules/path-scurry/dist/esm/index.js
+// ../../node_modules/.pnpm/path-scurry@2.0.1/node_modules/path-scurry/dist/esm/index.js
 var realpathSync = rps.native;
 var defaultFS = {
   lstatSync,
@@ -8508,7 +8570,7 @@ var ENOREALPATH = 512;
 var ENOCHILD = ENOTDIR | ENOENT | ENOREALPATH;
 var TYPEMASK = 1023;
 var entToType = (s) => s.isFile() ? IFREG : s.isDirectory() ? IFDIR : s.isSymbolicLink() ? IFLNK : s.isCharacterDevice() ? IFCHR : s.isBlockDevice() ? IFBLK : s.isSocket() ? IFSOCK : s.isFIFO() ? IFIFO : UNKNOWN;
-var normalizeCache = /* @__PURE__ */ new Map();
+var normalizeCache = new LRUCache({ max: 2 ** 12 });
 var normalize2 = (s) => {
   const c = normalizeCache.get(s);
   if (c)
@@ -8517,7 +8579,7 @@ var normalize2 = (s) => {
   normalizeCache.set(s, n2);
   return n2;
 };
-var normalizeNocaseCache = /* @__PURE__ */ new Map();
+var normalizeNocaseCache = new LRUCache({ max: 2 ** 12 });
 var normalizeNocase = (s) => {
   const c = normalizeNocaseCache.get(s);
   if (c)
@@ -8540,7 +8602,7 @@ var ChildrenCache = class extends LRUCache {
     });
   }
 };
-var setAsCwd = Symbol("PathScurry setAsCwd");
+var setAsCwd = /* @__PURE__ */ Symbol("PathScurry setAsCwd");
 var PathBase = class {
   /**
    * the basename of this path
@@ -8674,6 +8736,7 @@ var PathBase = class {
   get parentPath() {
     return (this.parent || this).fullpath();
   }
+  /* c8 ignore start */
   /**
    * Deprecated alias for Dirent['parentPath'] Somewhat counterintuitively,
    * this property refers to the *parent* path, not the path object itself.
@@ -8683,6 +8746,7 @@ var PathBase = class {
   get path() {
     return this.parentPath;
   }
+  /* c8 ignore stop */
   /**
    * Do not create new Path objects directly.  They should always be accessed
    * via the PathScurry class or other methods on the Path class.
@@ -8728,12 +8792,12 @@ var PathBase = class {
   /**
    * Get the Path object referenced by the string path, resolved from this Path
    */
-  resolve(path36) {
-    if (!path36) {
+  resolve(path37) {
+    if (!path37) {
       return this;
     }
-    const rootPath = this.getRootString(path36);
-    const dir = path36.substring(rootPath.length);
+    const rootPath = this.getRootString(path37);
+    const dir = path37.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -9485,8 +9549,8 @@ var PathWin32 = class _PathWin32 extends PathBase {
   /**
    * @internal
    */
-  getRootString(path36) {
-    return win32.parse(path36).root;
+  getRootString(path37) {
+    return win32.parse(path37).root;
   }
   /**
    * @internal
@@ -9532,8 +9596,8 @@ var PathPosix = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path36) {
-    return path36.startsWith("/") ? "/" : "";
+  getRootString(path37) {
+    return path37.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -9622,11 +9686,11 @@ var PathScurryBase = class {
   /**
    * Get the depth of a provided path, string, or the cwd
    */
-  depth(path36 = this.cwd) {
-    if (typeof path36 === "string") {
-      path36 = this.cwd.resolve(path36);
+  depth(path37 = this.cwd) {
+    if (typeof path37 === "string") {
+      path37 = this.cwd.resolve(path37);
     }
-    return path36.depth();
+    return path37.depth();
   }
   /**
    * Return the cache of child entries.  Exposed so subclasses can create
@@ -10113,9 +10177,9 @@ var PathScurryBase = class {
     process10();
     return results;
   }
-  chdir(path36 = this.cwd) {
+  chdir(path37 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path36 === "string" ? this.cwd.resolve(path36) : path36;
+    this.cwd = typeof path37 === "string" ? this.cwd.resolve(path37) : path37;
     this.cwd[setAsCwd](oldCwd);
   }
 };
@@ -10189,7 +10253,7 @@ var PathScurryDarwin = class extends PathScurryPosix {
 var Path = process.platform === "win32" ? PathWin32 : PathPosix;
 var PathScurry = process.platform === "win32" ? PathScurryWin32 : process.platform === "darwin" ? PathScurryDarwin : PathScurryPosix;
 
-// ../../node_modules/.pnpm/glob@11.0.3/node_modules/glob/dist/esm/pattern.js
+// ../../node_modules/.pnpm/glob@13.0.0/node_modules/glob/dist/esm/pattern.js
 init_esm_shims();
 var isPatternList = (pl2) => pl2.length >= 1;
 var isGlobList = (gl) => gl.length >= 1;
@@ -10355,10 +10419,10 @@ var Pattern = class _Pattern {
   }
 };
 
-// ../../node_modules/.pnpm/glob@11.0.3/node_modules/glob/dist/esm/walker.js
+// ../../node_modules/.pnpm/glob@13.0.0/node_modules/glob/dist/esm/walker.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/glob@11.0.3/node_modules/glob/dist/esm/ignore.js
+// ../../node_modules/.pnpm/glob@13.0.0/node_modules/glob/dist/esm/ignore.js
 init_esm_shims();
 var defaultPlatform2 = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
 var Ignore = class {
@@ -10446,7 +10510,7 @@ var Ignore = class {
   }
 };
 
-// ../../node_modules/.pnpm/glob@11.0.3/node_modules/glob/dist/esm/processor.js
+// ../../node_modules/.pnpm/glob@13.0.0/node_modules/glob/dist/esm/processor.js
 init_esm_shims();
 var HasWalkedCache = class _HasWalkedCache {
   store;
@@ -10477,8 +10541,8 @@ var MatchRecord = class {
   }
   // match, absolute, ifdir
   entries() {
-    return [...this.store.entries()].map(([path36, n2]) => [
-      path36,
+    return [...this.store.entries()].map(([path37, n2]) => [
+      path37,
       !!(n2 & 2),
       !!(n2 & 1)
     ]);
@@ -10668,7 +10732,7 @@ var Processor = class _Processor {
   }
 };
 
-// ../../node_modules/.pnpm/glob@11.0.3/node_modules/glob/dist/esm/walker.js
+// ../../node_modules/.pnpm/glob@13.0.0/node_modules/glob/dist/esm/walker.js
 var makeIgnore = (ignore, opts) => typeof ignore === "string" ? new Ignore([ignore], opts) : Array.isArray(ignore) ? new Ignore(ignore, opts) : ignore;
 var GlobUtil = class {
   path;
@@ -10683,9 +10747,9 @@ var GlobUtil = class {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path36, opts) {
+  constructor(patterns, path37, opts) {
     this.patterns = patterns;
-    this.path = path36;
+    this.path = path37;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -10704,11 +10768,11 @@ var GlobUtil = class {
       });
     }
   }
-  #ignored(path36) {
-    return this.seen.has(path36) || !!this.#ignore?.ignored?.(path36);
+  #ignored(path37) {
+    return this.seen.has(path37) || !!this.#ignore?.ignored?.(path37);
   }
-  #childrenIgnored(path36) {
-    return !!this.#ignore?.childrenIgnored?.(path36);
+  #childrenIgnored(path37) {
+    return !!this.#ignore?.childrenIgnored?.(path37);
   }
   // backpressure mechanism
   pause() {
@@ -10923,8 +10987,8 @@ var GlobUtil = class {
 };
 var GlobWalker = class extends GlobUtil {
   matches = /* @__PURE__ */ new Set();
-  constructor(patterns, path36, opts) {
-    super(patterns, path36, opts);
+  constructor(patterns, path37, opts) {
+    super(patterns, path37, opts);
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -10961,8 +11025,8 @@ var GlobWalker = class extends GlobUtil {
 };
 var GlobStream = class extends GlobUtil {
   results;
-  constructor(patterns, path36, opts) {
-    super(patterns, path36, opts);
+  constructor(patterns, path37, opts) {
+    super(patterns, path37, opts);
     this.results = new Minipass({
       signal: this.signal,
       objectMode: true
@@ -10995,7 +11059,7 @@ var GlobStream = class extends GlobUtil {
   }
 };
 
-// ../../node_modules/.pnpm/glob@11.0.3/node_modules/glob/dist/esm/glob.js
+// ../../node_modules/.pnpm/glob@13.0.0/node_modules/glob/dist/esm/glob.js
 var defaultPlatform3 = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
 var Glob = class {
   absolute;
@@ -11195,7 +11259,7 @@ var Glob = class {
   }
 };
 
-// ../../node_modules/.pnpm/glob@11.0.3/node_modules/glob/dist/esm/has-magic.js
+// ../../node_modules/.pnpm/glob@13.0.0/node_modules/glob/dist/esm/has-magic.js
 init_esm_shims();
 var hasMagic = (pattern, options = {}) => {
   if (!Array.isArray(pattern)) {
@@ -11208,7 +11272,7 @@ var hasMagic = (pattern, options = {}) => {
   return false;
 };
 
-// ../../node_modules/.pnpm/glob@11.0.3/node_modules/glob/dist/esm/index.js
+// ../../node_modules/.pnpm/glob@13.0.0/node_modules/glob/dist/esm/index.js
 function globStreamSync(pattern, options = {}) {
   return new Glob(pattern, options).streamSync();
 }
@@ -11256,7 +11320,7 @@ var glob = Object.assign(glob_, {
 });
 glob.glob = glob;
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/opt-arg.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/opt-arg.js
 init_esm_shims();
 var typeOrUndef = (val, t2) => typeof val === "undefined" || typeof val === t2;
 var isRimrafOptions = (o) => !!o && typeof o === "object" && typeOrUndef(o.preserveRoot, "boolean") && typeOrUndef(o.tmp, "string") && typeOrUndef(o.maxRetries, "number") && typeOrUndef(o.retryDelay, "number") && typeOrUndef(o.backoff, "number") && typeOrUndef(o.maxBackoff, "number") && (typeOrUndef(o.glob, "boolean") || o.glob && typeof o.glob === "object") && typeOrUndef(o.filter, "function");
@@ -11289,67 +11353,67 @@ var optArgT = (opt) => {
 var optArg = (opt = {}) => optArgT(opt);
 var optArgSync = (opt = {}) => optArgT(opt);
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/path-arg.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/path-arg.js
 init_esm_shims();
 import { parse as parse2, resolve as resolve3 } from "path";
 import { inspect } from "util";
-var pathArg = (path36, opt = {}) => {
-  const type = typeof path36;
+var pathArg = (path37, opt = {}) => {
+  const type = typeof path37;
   if (type !== "string") {
-    const ctor = path36 && type === "object" && path36.constructor;
-    const received = ctor && ctor.name ? `an instance of ${ctor.name}` : type === "object" ? inspect(path36) : `type ${type} ${path36}`;
+    const ctor = path37 && type === "object" && path37.constructor;
+    const received = ctor && ctor.name ? `an instance of ${ctor.name}` : type === "object" ? inspect(path37) : `type ${type} ${path37}`;
     const msg = `The "path" argument must be of type string. Received ${received}`;
     throw Object.assign(new TypeError(msg), {
-      path: path36,
+      path: path37,
       code: "ERR_INVALID_ARG_TYPE"
     });
   }
-  if (/\0/.test(path36)) {
+  if (/\0/.test(path37)) {
     const msg = "path must be a string without null bytes";
     throw Object.assign(new TypeError(msg), {
-      path: path36,
+      path: path37,
       code: "ERR_INVALID_ARG_VALUE"
     });
   }
-  path36 = resolve3(path36);
-  const { root } = parse2(path36);
-  if (path36 === root && opt.preserveRoot !== false) {
+  path37 = resolve3(path37);
+  const { root } = parse2(path37);
+  if (path37 === root && opt.preserveRoot !== false) {
     const msg = "refusing to remove root directory without preserveRoot:false";
     throw Object.assign(new Error(msg), {
-      path: path36,
+      path: path37,
       code: "ERR_PRESERVE_ROOT"
     });
   }
   if (process.platform === "win32") {
     const badWinChars = /[*|"<>?:]/;
-    const { root: root2 } = parse2(path36);
-    if (badWinChars.test(path36.substring(root2.length))) {
+    const { root: root2 } = parse2(path37);
+    if (badWinChars.test(path37.substring(root2.length))) {
       throw Object.assign(new Error("Illegal characters in path."), {
-        path: path36,
+        path: path37,
         code: "EINVAL"
       });
     }
   }
-  return path36;
+  return path37;
 };
 var path_arg_default = pathArg;
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/rimraf-manual.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/rimraf-manual.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/rimraf-posix.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/rimraf-posix.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/fs.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/fs.js
 init_esm_shims();
 import { readdirSync as rdSync } from "fs";
 import fsPromises from "fs/promises";
 import { chmodSync, mkdirSync, renameSync, rmdirSync, rmSync, statSync, lstatSync as lstatSync2, unlinkSync } from "fs";
-var readdirSync2 = (path36) => rdSync(path36, { withFileTypes: true });
+var readdirSync2 = (path37) => rdSync(path37, { withFileTypes: true });
 var promises = {
   chmod: fsPromises.chmod,
   mkdir: fsPromises.mkdir,
-  readdir: (path36) => fsPromises.readdir(path36, { withFileTypes: true }),
+  readdir: (path37) => fsPromises.readdir(path37, { withFileTypes: true }),
   rename: fsPromises.rename,
   rm: fsPromises.rm,
   rmdir: fsPromises.rmdir,
@@ -11358,32 +11422,32 @@ var promises = {
   unlink: fsPromises.unlink
 };
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/rimraf-posix.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/rimraf-posix.js
 import { parse as parse3, resolve as resolve4 } from "path";
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/readdir-or-error.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/readdir-or-error.js
 init_esm_shims();
 var { readdir: readdir4 } = promises;
-var readdirOrError = (path36) => readdir4(path36).catch((er) => er);
-var readdirOrErrorSync = (path36) => {
+var readdirOrError = (path37) => readdir4(path37).catch((er) => er);
+var readdirOrErrorSync = (path37) => {
   try {
-    return readdirSync2(path36);
+    return readdirSync2(path37);
   } catch (er) {
     return er;
   }
 };
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/ignore-enoent.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/ignore-enoent.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/error.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/error.js
 init_esm_shims();
 var isRecord = (o) => !!o && typeof o === "object";
 var hasString = (o, key) => key in o && typeof o[key] === "string";
 var isFsError = (o) => isRecord(o) && hasString(o, "code") && hasString(o, "path");
 var errorCode = (er) => isRecord(er) && hasString(er, "code") ? er.code : null;
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/ignore-enoent.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/ignore-enoent.js
 var ignoreENOENT = async (p, rethrow) => p.catch((er) => {
   if (errorCode(er) === "ENOENT") {
     return;
@@ -11401,19 +11465,19 @@ var ignoreENOENTSync = (fn, rethrow) => {
   }
 };
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/rimraf-posix.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/rimraf-posix.js
 var { lstat: lstat4, rmdir, unlink } = promises;
-var rimrafPosix = async (path36, opt) => {
+var rimrafPosix = async (path37, opt) => {
   opt?.signal?.throwIfAborted();
-  return await ignoreENOENT(lstat4(path36).then((stat5) => rimrafPosixDir(path36, opt, stat5))) ?? true;
+  return await ignoreENOENT(lstat4(path37).then((stat5) => rimrafPosixDir(path37, opt, stat5))) ?? true;
 };
-var rimrafPosixSync = (path36, opt) => {
+var rimrafPosixSync = (path37, opt) => {
   opt?.signal?.throwIfAborted();
-  return ignoreENOENTSync(() => rimrafPosixDirSync(path36, opt, lstatSync2(path36))) ?? true;
+  return ignoreENOENTSync(() => rimrafPosixDirSync(path37, opt, lstatSync2(path37))) ?? true;
 };
-var rimrafPosixDir = async (path36, opt, ent) => {
+var rimrafPosixDir = async (path37, opt, ent) => {
   opt?.signal?.throwIfAborted();
-  const entries = ent.isDirectory() ? await readdirOrError(path36) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path37) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (errorCode(entries) === "ENOENT") {
@@ -11423,28 +11487,28 @@ var rimrafPosixDir = async (path36, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path36, ent)) {
+    if (opt.filter && !await opt.filter(path37, ent)) {
       return false;
     }
-    await ignoreENOENT(unlink(path36));
+    await ignoreENOENT(unlink(path37));
     return true;
   }
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafPosixDir(resolve4(path36, ent2.name), opt, ent2)))).every((v) => v === true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafPosixDir(resolve4(path37, ent2.name), opt, ent2)))).every((v) => v === true);
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path36 === parse3(path36).root) {
+  if (opt.preserveRoot === false && path37 === parse3(path37).root) {
     return false;
   }
-  if (opt.filter && !await opt.filter(path36, ent)) {
+  if (opt.filter && !await opt.filter(path37, ent)) {
     return false;
   }
-  await ignoreENOENT(rmdir(path36));
+  await ignoreENOENT(rmdir(path37));
   return true;
 };
-var rimrafPosixDirSync = (path36, opt, ent) => {
+var rimrafPosixDirSync = (path37, opt, ent) => {
   opt?.signal?.throwIfAborted();
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path36) : null;
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path37) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (errorCode(entries) === "ENOENT") {
@@ -11454,65 +11518,65 @@ var rimrafPosixDirSync = (path36, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path36, ent)) {
+    if (opt.filter && !opt.filter(path37, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => unlinkSync(path36));
+    ignoreENOENTSync(() => unlinkSync(path37));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
-    const p = resolve4(path36, ent2.name);
+    const p = resolve4(path37, ent2.name);
     removedAll = rimrafPosixDirSync(p, opt, ent2) && removedAll;
   }
-  if (opt.preserveRoot === false && path36 === parse3(path36).root) {
+  if (opt.preserveRoot === false && path37 === parse3(path37).root) {
     return false;
   }
   if (!removedAll) {
     return false;
   }
-  if (opt.filter && !opt.filter(path36, ent)) {
+  if (opt.filter && !opt.filter(path37, ent)) {
     return false;
   }
-  ignoreENOENTSync(() => rmdirSync(path36));
+  ignoreENOENTSync(() => rmdirSync(path37));
   return true;
 };
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/rimraf-windows.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/rimraf-windows.js
 init_esm_shims();
 import { parse as parse6, resolve as resolve7 } from "path";
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/fix-eperm.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/fix-eperm.js
 init_esm_shims();
 var { chmod } = promises;
-var fixEPERM = (fn) => async (path36) => {
+var fixEPERM = (fn) => async (path37) => {
   try {
-    return void await ignoreENOENT(fn(path36));
+    return void await ignoreENOENT(fn(path37));
   } catch (er) {
     if (errorCode(er) === "EPERM") {
-      if (!await ignoreENOENT(chmod(path36, 438).then(() => true), er)) {
+      if (!await ignoreENOENT(chmod(path37, 438).then(() => true), er)) {
         return;
       }
-      return void await fn(path36);
+      return void await fn(path37);
     }
     throw er;
   }
 };
-var fixEPERMSync = (fn) => (path36) => {
+var fixEPERMSync = (fn) => (path37) => {
   try {
-    return void ignoreENOENTSync(() => fn(path36));
+    return void ignoreENOENTSync(() => fn(path37));
   } catch (er) {
     if (errorCode(er) === "EPERM") {
-      if (!ignoreENOENTSync(() => (chmodSync(path36, 438), true), er)) {
+      if (!ignoreENOENTSync(() => (chmodSync(path37, 438), true), er)) {
         return;
       }
-      return void fn(path36);
+      return void fn(path37);
     }
     throw er;
   }
 };
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/retry-busy.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/retry-busy.js
 init_esm_shims();
 import { setTimeout as setTimeout2 } from "timers/promises";
 var MAXBACKOFF = 200;
@@ -11520,21 +11584,21 @@ var RATE = 1.2;
 var MAXRETRIES = 10;
 var codes = /* @__PURE__ */ new Set(["EMFILE", "ENFILE", "EBUSY"]);
 var retryBusy = (fn) => {
-  const method = async (path36, opt, backoff = 1, total = 0) => {
+  const method = async (path37, 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(path36);
+        return await fn(path37);
       } catch (er) {
-        if (isFsError(er) && er.path === path36 && codes.has(er.code)) {
+        if (isFsError(er) && er.path === path37 && codes.has(er.code)) {
           backoff = Math.ceil(backoff * rate);
           total = backoff + total;
           if (total < mbo) {
             await setTimeout2(backoff);
-            return method(path36, opt, backoff, total);
+            return method(path37, opt, backoff, total);
           }
           if (retries < max) {
             retries++;
@@ -11548,14 +11612,14 @@ var retryBusy = (fn) => {
   return method;
 };
 var retryBusySync = (fn) => {
-  const method = (path36, opt) => {
+  const method = (path37, opt) => {
     const max = opt.maxRetries || MAXRETRIES;
     let retries = 0;
     while (true) {
       try {
-        return fn(path36);
+        return fn(path37);
       } catch (er) {
-        if (isFsError(er) && er.path === path36 && codes.has(er.code) && retries < max) {
+        if (isFsError(er) && er.path === path37 && codes.has(er.code) && retries < max) {
           retries++;
           continue;
         }
@@ -11566,25 +11630,25 @@ var retryBusySync = (fn) => {
   return method;
 };
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/rimraf-move-remove.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/rimraf-move-remove.js
 init_esm_shims();
 import { basename as basename3, parse as parse5, resolve as resolve6 } from "path";
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/default-tmp.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/default-tmp.js
 init_esm_shims();
 import { tmpdir } from "os";
 import { parse as parse4, resolve as resolve5 } from "path";
 var { stat: stat4 } = promises;
-var isDirSync = (path36) => {
+var isDirSync = (path37) => {
   try {
-    return statSync(path36).isDirectory();
+    return statSync(path37).isDirectory();
   } catch {
     return false;
   }
 };
-var isDir = (path36) => stat4(path36).then((st) => st.isDirectory(), () => false);
-var win32DefaultTmp = async (path36) => {
-  const { root } = parse4(path36);
+var isDir = (path37) => stat4(path37).then((st) => st.isDirectory(), () => false);
+var win32DefaultTmp = async (path37) => {
+  const { root } = parse4(path37);
   const tmp = tmpdir();
   const { root: tmpRoot } = parse4(tmp);
   if (root.toLowerCase() === tmpRoot.toLowerCase()) {
@@ -11596,8 +11660,8 @@ var win32DefaultTmp = async (path36) => {
   }
   return root;
 };
-var win32DefaultTmpSync = (path36) => {
-  const { root } = parse4(path36);
+var win32DefaultTmpSync = (path37) => {
+  const { root } = parse4(path37);
   const tmp = tmpdir();
   const { root: tmpRoot } = parse4(tmp);
   if (root.toLowerCase() === tmpRoot.toLowerCase()) {
@@ -11614,24 +11678,24 @@ var posixDefaultTmpSync = () => tmpdir();
 var defaultTmp = process.platform === "win32" ? win32DefaultTmp : posixDefaultTmp;
 var defaultTmpSync = process.platform === "win32" ? win32DefaultTmpSync : posixDefaultTmpSync;
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/rimraf-move-remove.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/rimraf-move-remove.js
 var { lstat: lstat5, rename, unlink: unlink2, rmdir: rmdir2 } = promises;
-var uniqueFilename = (path36) => `.${basename3(path36)}.${Math.random()}`;
+var uniqueFilename = (path37) => `.${basename3(path37)}.${Math.random()}`;
 var unlinkFixEPERM = fixEPERM(unlink2);
 var unlinkFixEPERMSync = fixEPERMSync(unlinkSync);
-var rimrafMoveRemove = async (path36, opt) => {
+var rimrafMoveRemove = async (path37, opt) => {
   opt?.signal?.throwIfAborted();
-  return await ignoreENOENT(lstat5(path36).then((stat5) => rimrafMoveRemoveDir(path36, opt, stat5))) ?? true;
+  return await ignoreENOENT(lstat5(path37).then((stat5) => rimrafMoveRemoveDir(path37, opt, stat5))) ?? true;
 };
-var rimrafMoveRemoveDir = async (path36, opt, ent) => {
+var rimrafMoveRemoveDir = async (path37, opt, ent) => {
   opt?.signal?.throwIfAborted();
   if (!opt.tmp) {
-    return rimrafMoveRemoveDir(path36, { ...opt, tmp: await defaultTmp(path36) }, ent);
+    return rimrafMoveRemoveDir(path37, { ...opt, tmp: await defaultTmp(path37) }, ent);
   }
-  if (path36 === opt.tmp && parse5(path36).root !== path36) {
+  if (path37 === opt.tmp && parse5(path37).root !== path37) {
     throw new Error("cannot delete temp directory used for deletion");
   }
-  const entries = ent.isDirectory() ? await readdirOrError(path36) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path37) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (errorCode(entries) === "ENOENT") {
@@ -11641,44 +11705,44 @@ var rimrafMoveRemoveDir = async (path36, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path36, ent)) {
+    if (opt.filter && !await opt.filter(path37, ent)) {
       return false;
     }
-    await ignoreENOENT(tmpUnlink(path36, opt.tmp, unlinkFixEPERM));
+    await ignoreENOENT(tmpUnlink(path37, opt.tmp, unlinkFixEPERM));
     return true;
   }
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafMoveRemoveDir(resolve6(path36, ent2.name), opt, ent2)))).every((v) => v === true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafMoveRemoveDir(resolve6(path37, ent2.name), opt, ent2)))).every((v) => v === true);
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path36 === parse5(path36).root) {
+  if (opt.preserveRoot === false && path37 === parse5(path37).root) {
     return false;
   }
-  if (opt.filter && !await opt.filter(path36, ent)) {
+  if (opt.filter && !await opt.filter(path37, ent)) {
     return false;
   }
-  await ignoreENOENT(tmpUnlink(path36, opt.tmp, rmdir2));
+  await ignoreENOENT(tmpUnlink(path37, opt.tmp, rmdir2));
   return true;
 };
-var tmpUnlink = async (path36, tmp, rm2) => {
-  const tmpFile = resolve6(tmp, uniqueFilename(path36));
-  await rename(path36, tmpFile);
+var tmpUnlink = async (path37, tmp, rm2) => {
+  const tmpFile = resolve6(tmp, uniqueFilename(path37));
+  await rename(path37, tmpFile);
   return await rm2(tmpFile);
 };
-var rimrafMoveRemoveSync = (path36, opt) => {
+var rimrafMoveRemoveSync = (path37, opt) => {
   opt?.signal?.throwIfAborted();
-  return ignoreENOENTSync(() => rimrafMoveRemoveDirSync(path36, opt, lstatSync2(path36))) ?? true;
+  return ignoreENOENTSync(() => rimrafMoveRemoveDirSync(path37, opt, lstatSync2(path37))) ?? true;
 };
-var rimrafMoveRemoveDirSync = (path36, opt, ent) => {
+var rimrafMoveRemoveDirSync = (path37, opt, ent) => {
   opt?.signal?.throwIfAborted();
   if (!opt.tmp) {
-    return rimrafMoveRemoveDirSync(path36, { ...opt, tmp: defaultTmpSync(path36) }, ent);
+    return rimrafMoveRemoveDirSync(path37, { ...opt, tmp: defaultTmpSync(path37) }, ent);
   }
   const tmp = opt.tmp;
-  if (path36 === opt.tmp && parse5(path36).root !== path36) {
+  if (path37 === opt.tmp && parse5(path37).root !== path37) {
     throw new Error("cannot delete temp directory used for deletion");
   }
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path36) : null;
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path37) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (errorCode(entries) === "ENOENT") {
@@ -11688,79 +11752,79 @@ var rimrafMoveRemoveDirSync = (path36, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path36, ent)) {
+    if (opt.filter && !opt.filter(path37, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => tmpUnlinkSync(path36, tmp, unlinkFixEPERMSync));
+    ignoreENOENTSync(() => tmpUnlinkSync(path37, tmp, unlinkFixEPERMSync));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
-    const p = resolve6(path36, ent2.name);
+    const p = resolve6(path37, ent2.name);
     removedAll = rimrafMoveRemoveDirSync(p, opt, ent2) && removedAll;
   }
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path36 === parse5(path36).root) {
+  if (opt.preserveRoot === false && path37 === parse5(path37).root) {
     return false;
   }
-  if (opt.filter && !opt.filter(path36, ent)) {
+  if (opt.filter && !opt.filter(path37, ent)) {
     return false;
   }
-  ignoreENOENTSync(() => tmpUnlinkSync(path36, tmp, rmdirSync));
+  ignoreENOENTSync(() => tmpUnlinkSync(path37, tmp, rmdirSync));
   return true;
 };
-var tmpUnlinkSync = (path36, tmp, rmSync2) => {
-  const tmpFile = resolve6(tmp, uniqueFilename(path36));
-  renameSync(path36, tmpFile);
+var tmpUnlinkSync = (path37, tmp, rmSync2) => {
+  const tmpFile = resolve6(tmp, uniqueFilename(path37));
+  renameSync(path37, tmpFile);
   return rmSync2(tmpFile);
 };
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/rimraf-windows.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/rimraf-windows.js
 var { unlink: unlink3, rmdir: rmdir3, lstat: lstat6 } = promises;
 var rimrafWindowsFile = retryBusy(fixEPERM(unlink3));
 var rimrafWindowsFileSync = retryBusySync(fixEPERMSync(unlinkSync));
 var rimrafWindowsDirRetry = retryBusy(fixEPERM(rmdir3));
 var rimrafWindowsDirRetrySync = retryBusySync(fixEPERMSync(rmdirSync));
-var rimrafWindowsDirMoveRemoveFallback = async (path36, { filter: filter3, ...opt }) => {
+var rimrafWindowsDirMoveRemoveFallback = async (path37, { filter: filter3, ...opt }) => {
   opt?.signal?.throwIfAborted();
   try {
-    await rimrafWindowsDirRetry(path36, opt);
+    await rimrafWindowsDirRetry(path37, opt);
     return true;
   } catch (er) {
     if (errorCode(er) === "ENOTEMPTY") {
-      return rimrafMoveRemove(path36, opt);
+      return rimrafMoveRemove(path37, opt);
     }
     throw er;
   }
 };
-var rimrafWindowsDirMoveRemoveFallbackSync = (path36, { filter: filter3, ...opt }) => {
+var rimrafWindowsDirMoveRemoveFallbackSync = (path37, { filter: filter3, ...opt }) => {
   opt?.signal?.throwIfAborted();
   try {
-    rimrafWindowsDirRetrySync(path36, opt);
+    rimrafWindowsDirRetrySync(path37, opt);
     return true;
   } catch (er) {
     if (errorCode(er) === "ENOTEMPTY") {
-      return rimrafMoveRemoveSync(path36, opt);
+      return rimrafMoveRemoveSync(path37, opt);
     }
     throw er;
   }
 };
-var START = Symbol("start");
-var CHILD = Symbol("child");
-var FINISH = Symbol("finish");
-var rimrafWindows = async (path36, opt) => {
+var START = /* @__PURE__ */ Symbol("start");
+var CHILD = /* @__PURE__ */ Symbol("child");
+var FINISH = /* @__PURE__ */ Symbol("finish");
+var rimrafWindows = async (path37, opt) => {
   opt?.signal?.throwIfAborted();
-  return await ignoreENOENT(lstat6(path36).then((stat5) => rimrafWindowsDir(path36, opt, stat5, START))) ?? true;
+  return await ignoreENOENT(lstat6(path37).then((stat5) => rimrafWindowsDir(path37, opt, stat5, START))) ?? true;
 };
-var rimrafWindowsSync = (path36, opt) => {
+var rimrafWindowsSync = (path37, opt) => {
   opt?.signal?.throwIfAborted();
-  return ignoreENOENTSync(() => rimrafWindowsDirSync(path36, opt, lstatSync2(path36), START)) ?? true;
+  return ignoreENOENTSync(() => rimrafWindowsDirSync(path37, opt, lstatSync2(path37), START)) ?? true;
 };
-var rimrafWindowsDir = async (path36, opt, ent, state = START) => {
+var rimrafWindowsDir = async (path37, opt, ent, state = START) => {
   opt?.signal?.throwIfAborted();
-  const entries = ent.isDirectory() ? await readdirOrError(path36) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path37) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (errorCode(entries) === "ENOENT") {
@@ -11770,32 +11834,32 @@ var rimrafWindowsDir = async (path36, opt, ent, state = START) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path36, ent)) {
+    if (opt.filter && !await opt.filter(path37, ent)) {
       return false;
     }
-    await ignoreENOENT(rimrafWindowsFile(path36, opt));
+    await ignoreENOENT(rimrafWindowsFile(path37, opt));
     return true;
   }
   const s = state === START ? CHILD : state;
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafWindowsDir(resolve7(path36, ent2.name), opt, ent2, s)))).every((v) => v === true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafWindowsDir(resolve7(path37, ent2.name), opt, ent2, s)))).every((v) => v === true);
   if (state === START) {
-    return rimrafWindowsDir(path36, opt, ent, FINISH);
+    return rimrafWindowsDir(path37, opt, ent, FINISH);
   } else if (state === FINISH) {
-    if (opt.preserveRoot === false && path36 === parse6(path36).root) {
+    if (opt.preserveRoot === false && path37 === parse6(path37).root) {
       return false;
     }
     if (!removedAll) {
       return false;
     }
-    if (opt.filter && !await opt.filter(path36, ent)) {
+    if (opt.filter && !await opt.filter(path37, ent)) {
       return false;
     }
-    await ignoreENOENT(rimrafWindowsDirMoveRemoveFallback(path36, opt));
+    await ignoreENOENT(rimrafWindowsDirMoveRemoveFallback(path37, opt));
   }
   return true;
 };
-var rimrafWindowsDirSync = (path36, opt, ent, state = START) => {
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path36) : null;
+var rimrafWindowsDirSync = (path37, opt, ent, state = START) => {
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path37) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (errorCode(entries) === "ENOENT") {
@@ -11805,52 +11869,52 @@ var rimrafWindowsDirSync = (path36, opt, ent, state = START) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path36, ent)) {
+    if (opt.filter && !opt.filter(path37, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => rimrafWindowsFileSync(path36, opt));
+    ignoreENOENTSync(() => rimrafWindowsFileSync(path37, opt));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
     const s = state === START ? CHILD : state;
-    const p = resolve7(path36, ent2.name);
+    const p = resolve7(path37, ent2.name);
     removedAll = rimrafWindowsDirSync(p, opt, ent2, s) && removedAll;
   }
   if (state === START) {
-    return rimrafWindowsDirSync(path36, opt, ent, FINISH);
+    return rimrafWindowsDirSync(path37, opt, ent, FINISH);
   } else if (state === FINISH) {
-    if (opt.preserveRoot === false && path36 === parse6(path36).root) {
+    if (opt.preserveRoot === false && path37 === parse6(path37).root) {
       return false;
     }
     if (!removedAll) {
       return false;
     }
-    if (opt.filter && !opt.filter(path36, ent)) {
+    if (opt.filter && !opt.filter(path37, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => rimrafWindowsDirMoveRemoveFallbackSync(path36, opt));
+    ignoreENOENTSync(() => rimrafWindowsDirMoveRemoveFallbackSync(path37, opt));
   }
   return true;
 };
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/rimraf-manual.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/rimraf-manual.js
 var rimrafManual = process.platform === "win32" ? rimrafWindows : rimrafPosix;
 var rimrafManualSync = process.platform === "win32" ? rimrafWindowsSync : rimrafPosixSync;
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/rimraf-native.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/rimraf-native.js
 init_esm_shims();
 var { rm } = promises;
-var rimrafNative = async (path36, opt) => {
-  await rm(path36, {
+var rimrafNative = async (path37, opt) => {
+  await rm(path37, {
     ...opt,
     force: true,
     recursive: true
   });
   return true;
 };
-var rimrafNativeSync = (path36, opt) => {
-  rmSync(path36, {
+var rimrafNativeSync = (path37, opt) => {
+  rmSync(path37, {
     ...opt,
     force: true,
     recursive: true
@@ -11858,34 +11922,34 @@ var rimrafNativeSync = (path36, opt) => {
   return true;
 };
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/use-native.js
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/use-native.js
 init_esm_shims();
 var [major = 0, minor = 0] = process.version.replace(/^v/, "").split(".").map((v) => parseInt(v, 10));
 var hasNative = major > 14 || major === 14 && minor >= 14;
 var useNative = !hasNative || process.platform === "win32" ? () => false : (opt) => !opt?.signal && !opt?.filter;
 var useNativeSync = !hasNative || process.platform === "win32" ? () => false : (opt) => !opt?.signal && !opt?.filter;
 
-// ../../node_modules/.pnpm/rimraf@6.1.0/node_modules/rimraf/dist/esm/index.js
-var wrap = (fn) => async (path36, opt) => {
+// ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/index.js
+var wrap = (fn) => async (path37, opt) => {
   const options = optArg(opt);
   if (options.glob) {
-    path36 = await glob(path36, options.glob);
+    path37 = await glob(path37, options.glob);
   }
-  if (Array.isArray(path36)) {
-    return !!(await Promise.all(path36.map((p) => fn(path_arg_default(p, options), options)))).reduce((a, b) => a && b, true);
+  if (Array.isArray(path37)) {
+    return !!(await Promise.all(path37.map((p) => fn(path_arg_default(p, options), options)))).reduce((a, b) => a && b, true);
   } else {
-    return !!await fn(path_arg_default(path36, options), options);
+    return !!await fn(path_arg_default(path37, options), options);
   }
 };
-var wrapSync = (fn) => (path36, opt) => {
+var wrapSync = (fn) => (path37, opt) => {
   const options = optArgSync(opt);
   if (options.glob) {
-    path36 = globSync(path36, options.glob);
+    path37 = globSync(path37, options.glob);
   }
-  if (Array.isArray(path36)) {
-    return !!path36.map((p) => fn(path_arg_default(p, options), options)).reduce((a, b) => a && b, true);
+  if (Array.isArray(path37)) {
+    return !!path37.map((p) => fn(path_arg_default(p, options), options)).reduce((a, b) => a && b, true);
   } else {
-    return !!fn(path_arg_default(path36, options), options);
+    return !!fn(path_arg_default(path37, options), options);
   }
 };
 var nativeSync = wrapSync(rimrafNativeSync);
@@ -11900,8 +11964,8 @@ var moveRemoveSync = wrapSync(rimrafMoveRemoveSync);
 var moveRemove = Object.assign(wrap(rimrafMoveRemove), {
   sync: moveRemoveSync
 });
-var rimrafSync = wrapSync((path36, opt) => useNativeSync(opt) ? rimrafNativeSync(path36, opt) : rimrafManualSync(path36, opt));
-var rimraf_ = wrap((path36, opt) => useNative(opt) ? rimrafNative(path36, opt) : rimrafManual(path36, opt));
+var rimrafSync = wrapSync((path37, opt) => useNativeSync(opt) ? rimrafNativeSync(path37, opt) : rimrafManualSync(path37, opt));
+var rimraf_ = wrap((path37, opt) => useNative(opt) ? rimrafNative(path37, opt) : rimrafManual(path37, opt));
 var rimraf = Object.assign(rimraf_, {
   rimraf: rimraf_,
   sync: rimrafSync,
@@ -12953,7 +13017,13 @@ function createBuildService(ctx) {
     independentBuildTasks.set(root, task);
     return task;
   }
-  function checkWorkersOptions() {
+  function checkWorkersOptions(target = "app") {
+    if (target === "plugin") {
+      return {
+        hasWorkersDir: false,
+        workersDir: void 0
+      };
+    }
     const workersDir = scanService.workersDir;
     const hasWorkersDir = Boolean(workersDir);
     if (hasWorkersDir && configService.weappViteConfig?.worker?.entry === void 0) {
@@ -12977,12 +13047,12 @@ function createBuildService(ctx) {
       configService.mergeWorkers()
     );
   }
-  async function runDev() {
+  async function runDev(target) {
     if (process3.env.NODE_ENV === void 0) {
       process3.env.NODE_ENV = "development";
     }
-    debug?.("dev build watcher start");
-    const { hasWorkersDir, workersDir } = checkWorkersOptions();
+    debug?.(`[${target}] dev build watcher start`);
+    const { hasWorkersDir, workersDir } = checkWorkersOptions(target);
     const buildOptions = configService.merge(
       void 0,
       createSharedBuildConfig(configService, scanService)
@@ -12990,63 +13060,57 @@ function createBuildService(ctx) {
     const watcherPromise = build(
       buildOptions
     );
-    const workerPromise = hasWorkersDir && workersDir ? devWorkers(workersDir) : Promise.resolve();
+    const workerPromise = target === "app" && hasWorkersDir && workersDir ? devWorkers(workersDir) : Promise.resolve();
     const [watcher] = await Promise.all([watcherPromise, workerPromise]);
     const isTestEnv = process3.env.VITEST === "true" || process3.env.NODE_ENV === "test";
-    if (hasWorkersDir && workersDir) {
-      if (!isTestEnv) {
-        const absWorkerRoot = path11.resolve(configService.absoluteSrcRoot, workersDir);
-        const watcher2 = esm_default.watch(
-          absWorkerRoot,
-          {
-            persistent: true,
-            ignoreInitial: true
-          }
-        );
-        const logWorkerEvent = (type, target, level = "info") => {
-          if (!target) {
-            return;
-          }
-          const relative3 = configService.relativeCwd(target);
-          const message = `[workers:${type}] ${relative3}`;
-          if (level === "success") {
-            logger_default.success(message);
-          } else {
-            logger_default.info(message);
-          }
-        };
-        watcher2.on("all", (event, id) => {
-          if (!id) {
-            return;
-          }
-          if (event === "add") {
-            logWorkerEvent(event, id, "success");
-            void devWorkers(workersDir);
-            return;
-          }
-          logWorkerEvent(event, id);
-        });
-        watcher2.on("raw", (eventName, rawPath, details) => {
-          if (eventName !== "rename") {
-            return;
-          }
-          const candidate = typeof rawPath === "string" ? rawPath : rawPath && typeof rawPath.toString === "function" ? rawPath.toString() : "";
-          if (!candidate) {
-            return;
-          }
-          const baseDir = typeof details === "object" && details && "watchedPath" in details ? details.watchedPath ?? absWorkerRoot : absWorkerRoot;
-          const resolved = path11.isAbsolute(candidate) ? candidate : path11.resolve(baseDir, candidate);
-          const exists = fs6.existsSync(resolved);
-          if (exists) {
-            logWorkerEvent("rename->add", resolved);
-            return;
-          }
-          logWorkerEvent("rename->unlink", resolved);
-        });
-        watcherService.sidecarWatcherMap.set(absWorkerRoot, {
-          close: () => watcher2.close()
-        });
-      }
+    if (target === "app" && hasWorkersDir && workersDir && !isTestEnv) {
+      const absWorkerRoot = path11.resolve(configService.absoluteSrcRoot, workersDir);
+      const workerWatcher = chokidar_default.watch(
+        absWorkerRoot,
+        {
+          persistent: true,
+          ignoreInitial: true
+        }
+      );
+      const logWorkerEvent = (type, targetPath, level = "info") => {
+        if (!targetPath) {
+          return;
+        }
+        const relative3 = configService.relativeCwd(targetPath);
+        const message = `[workers:${type}] ${relative3}`;
+        if (level === "success") {
+          logger_default.success(message);
+        } else {
+          logger_default.info(message);
+        }
+      };
+      workerWatcher.on("all", (event, id) => {
+        if (!id) {
+          return;
+        }
+        if (event === "add") {
+          logWorkerEvent(event, id, "success");
+          void devWorkers(workersDir);
+          return;
+        }
+        logWorkerEvent(event, id);
+      });
+      workerWatcher.on("raw", (eventName, rawPath, details) => {
+        if (eventName !== "rename") {
+          return;
+        }
+        const candidate = typeof rawPath === "string" ? rawPath : rawPath && typeof rawPath.toString === "function" ? rawPath.toString() : "";
+        if (!candidate) {
+          return;
+        }
+        const baseDir = typeof details === "object" && details && "watchedPath" in details ? details.watchedPath ?? absWorkerRoot : absWorkerRoot;
+        const resolved = path11.isAbsolute(candidate) ? candidate : path11.resolve(baseDir, candidate);
+        const exists = fs6.existsSync(resolved);
+        logWorkerEvent(exists ? "rename->add" : "rename->unlink", resolved, exists ? "success" : "info");
+      });
+      watcherService.sidecarWatcherMap.set(absWorkerRoot, {
+        close: () => workerWatcher.close()
+      });
     }
     debug?.("dev build watcher end");
     debug?.("dev watcher listen start");
@@ -13068,24 +13132,25 @@ function createBuildService(ctx) {
       }
     });
     await promise;
-    watcherService.setRollupWatcher(watcher);
+    const watcherRoot = target === "plugin" ? configService.absolutePluginRoot ?? configService.absoluteSrcRoot : "/";
+    watcherService.setRollupWatcher(watcher, watcherRoot);
     return watcher;
   }
-  async function runProd() {
-    debug?.("prod build start");
-    const { hasWorkersDir } = checkWorkersOptions();
+  async function runProd(target) {
+    debug?.(`[${target}] prod build start`);
+    const { hasWorkersDir } = checkWorkersOptions(target);
     const bundlerPromise = build(
       configService.merge(
         void 0,
         createSharedBuildConfig(configService, scanService)
       )
     );
-    const workerPromise = hasWorkersDir ? buildWorkers() : Promise.resolve();
+    const workerPromise = target === "app" && hasWorkersDir ? buildWorkers() : Promise.resolve();
     const [output] = await Promise.all([bundlerPromise, workerPromise]);
-    debug?.("prod build end");
+    debug?.(`[${target}] prod build end`);
     return output;
   }
-  async function buildEntry(options) {
+  async function cleanOutputs() {
     if (configService.mpDistRoot) {
       const deletedFilePaths = await rimraf(
         [
@@ -13105,35 +13170,66 @@ function createBuildService(ctx) {
       debug?.("deletedFilePaths", deletedFilePaths);
       logger_default.success(`\u5DF2\u6E05\u7A7A ${configService.mpDistRoot} \u76EE\u5F55`);
     }
-    debug?.("build start");
-    let npmBuildTask = Promise.resolve();
-    if (!options?.skipNpm) {
-      let shouldBuildNpm = true;
+    const pluginOutputRoot = configService.absolutePluginOutputRoot;
+    if (pluginOutputRoot) {
+      const relativeToOutDir = path11.relative(configService.outDir, pluginOutputRoot);
+      const isInsideOutDir = relativeToOutDir === "" || !relativeToOutDir.startsWith("..") && !path11.isAbsolute(relativeToOutDir);
+      if (!isInsideOutDir) {
+        const deletedPluginFiles = await rimraf([
+          path11.resolve(pluginOutputRoot, "*"),
+          path11.resolve(pluginOutputRoot, ".*")
+        ], {
+          glob: true
+        });
+        debug?.("deletedPluginOutput", deletedPluginFiles);
+        logger_default.success(`\u5DF2\u6E05\u7A7A ${configService.relativeCwd(pluginOutputRoot)} \u76EE\u5F55`);
+      }
+    }
+  }
+  function scheduleNpmBuild(options) {
+    if (options?.skipNpm) {
+      return Promise.resolve();
+    }
+    const runTask = () => queue.add(async () => {
+      await npmService.build();
       if (configService.isDev) {
+        buildState.npmBuilt = true;
+      }
+    });
+    if (configService.isDev) {
+      return (async () => {
         const isDependenciesOutdated = await npmService.checkDependenciesCacheOutdate();
         if (!isDependenciesOutdated && buildState.npmBuilt) {
-          shouldBuildNpm = false;
-        } else if (isDependenciesOutdated) {
+          return;
+        }
+        if (isDependenciesOutdated) {
           buildState.npmBuilt = false;
         }
-      }
-      if (shouldBuildNpm) {
-        npmBuildTask = queue.add(async () => {
-          await npmService.build();
-          if (configService.isDev) {
-            buildState.npmBuilt = true;
-          }
-        });
+        const task2 = runTask();
         queue.start();
-      }
+        await task2;
+      })();
     }
-    let result;
+    const task = runTask();
+    queue.start();
+    return task;
+  }
+  async function runBuildTarget(target) {
+    ctx.currentBuildTarget = target;
     if (configService.isDev) {
-      result = await runDev();
-    } else {
-      result = await runProd();
+      return await runDev(target);
     }
+    return await runProd(target);
+  }
+  async function buildEntry(options) {
+    await cleanOutputs();
+    debug?.("build start");
+    const npmBuildTask = scheduleNpmBuild(options);
+    const result = await runBuildTarget("app");
     await npmBuildTask;
+    if (configService.absolutePluginRoot) {
+      await runBuildTarget("plugin");
+    }
     debug?.("build end");
     return result;
   }
@@ -18805,17 +18901,17 @@ function withTrailingSlash(input = "", respectQueryAndFragment) {
   if (hasTrailingSlash(input, true)) {
     return input || "/";
   }
-  let path36 = input;
+  let path37 = input;
   let fragment = "";
   const fragmentIndex = input.indexOf("#");
   if (fragmentIndex !== -1) {
-    path36 = input.slice(0, fragmentIndex);
+    path37 = input.slice(0, fragmentIndex);
     fragment = input.slice(fragmentIndex);
-    if (!path36) {
+    if (!path37) {
       return fragment;
     }
   }
-  const [s0, ...s] = path36.split("?");
+  const [s0, ...s] = path37.split("?");
   return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
 }
 function isNonEmptyURL(url) {
@@ -18833,7 +18929,6 @@ function joinURL(base, ...input) {
   }
   return url;
 }
-var protocolRelative = Symbol.for("ufo:protocolRelative");
 
 // ../../node_modules/.pnpm/mlly@1.8.0/node_modules/mlly/dist/index.mjs
 import { normalize as normalize3, isAbsolute as isAbsolute2, extname as extname$1 } from "pathe";
@@ -18844,8 +18939,8 @@ import path12, { dirname as dirname3 } from "path";
 import v8 from "v8";
 import { format, inspect as inspect2 } from "util";
 var BUILTIN_MODULES = new Set(builtinModules);
-function normalizeSlash(path36) {
-  return path36.replace(/\\/g, "/");
+function normalizeSlash(path37) {
+  return path37.replace(/\\/g, "/");
 }
 var own$1 = {}.hasOwnProperty;
 var classRegExp = /^([A-Z][a-z\d]*)+$/;
@@ -18958,8 +19053,8 @@ codes2.ERR_INVALID_PACKAGE_CONFIG = createError(
    * @param {string} [base]
    * @param {string} [message]
    */
-  (path36, base, message) => {
-    return `Invalid package config ${path36}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+  (path37, base, message) => {
+    return `Invalid package config ${path37}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
   },
   Error
 );
@@ -18991,8 +19086,8 @@ codes2.ERR_MODULE_NOT_FOUND = createError(
    * @param {string} base
    * @param {boolean} [exactUrl]
    */
-  (path36, base, exactUrl = false) => {
-    return `Cannot find ${exactUrl ? "module" : "package"} '${path36}' imported from ${base}`;
+  (path37, base, exactUrl = false) => {
+    return `Cannot find ${exactUrl ? "module" : "package"} '${path37}' imported from ${base}`;
   },
   Error
 );
@@ -19043,8 +19138,8 @@ codes2.ERR_UNKNOWN_FILE_EXTENSION = createError(
    * @param {string} extension
    * @param {string} path
    */
-  (extension, path36) => {
-    return `Unknown file extension "${extension}" for ${path36}`;
+  (extension, path37) => {
+    return `Unknown file extension "${extension}" for ${path37}`;
   },
   TypeError
 );
@@ -19415,9 +19510,9 @@ Default "index" lookups for the main are deprecated for ES modules.`,
     );
   }
 }
-function tryStatSync(path36) {
+function tryStatSync(path37) {
   try {
-    return statSync2(path36);
+    return statSync2(path37);
   } catch {
   }
 }
@@ -20187,7 +20282,7 @@ init_esm_shims();
 
 // ../../node_modules/.pnpm/quansync@0.2.11/node_modules/quansync/dist/index.mjs
 init_esm_shims();
-var GET_IS_ASYNC = Symbol.for("quansync.getIsAsync");
+var GET_IS_ASYNC = /* @__PURE__ */ Symbol.for("quansync.getIsAsync");
 var QuansyncError = class extends Error {
   constructor(message = "Unexpected promise in sync context") {
     super(message);
@@ -20336,7 +20431,7 @@ function findUpSync(name, {
     directory = path13.dirname(directory);
   }
 }
-function _resolve2(path36, options = {}) {
+function _resolve2(path37, options = {}) {
   if (options.platform === "auto" || !options.platform)
     options.platform = process4.platform === "win32" ? "win32" : "posix";
   if (process4.versions.pnp) {
@@ -20345,11 +20440,11 @@ function _resolve2(path36, options = {}) {
       paths.push(process4.cwd());
     const targetRequire = createRequire2(import.meta.url);
     try {
-      return targetRequire.resolve(path36, { paths });
+      return targetRequire.resolve(path37, { paths });
     } catch {
     }
   }
-  const modulePath = resolvePathSync(path36, {
+  const modulePath = resolvePathSync(path37, {
     url: options.paths
   });
   if (options.platform === "win32")
@@ -20420,10 +20515,10 @@ var findUp = quansync2({
   async: findUp$1
 });
 var loadPackageJSON = quansync2(function* (cwd = process4.cwd()) {
-  const path36 = yield findUp("package.json", { cwd });
-  if (!path36 || !fs8.existsSync(path36))
+  const path37 = yield findUp("package.json", { cwd });
+  if (!path37 || !fs8.existsSync(path37))
     return null;
-  return JSON.parse(yield readFile(path36));
+  return JSON.parse(yield readFile(path37));
 });
 var loadPackageJSONSync = loadPackageJSON.sync;
 var isPackageListed = quansync2(function* (name, cwd) {
@@ -20432,13 +20527,13 @@ var isPackageListed = quansync2(function* (name, cwd) {
 });
 var isPackageListedSync = isPackageListed.sync;
 
-// ../../node_modules/.pnpm/package-manager-detector@1.5.0/node_modules/package-manager-detector/dist/detect.mjs
+// ../../node_modules/.pnpm/package-manager-detector@1.6.0/node_modules/package-manager-detector/dist/detect.mjs
 init_esm_shims();
 import fs9 from "fs/promises";
 import path14 from "path";
 import process5 from "process";
 
-// ../../node_modules/.pnpm/package-manager-detector@1.5.0/node_modules/package-manager-detector/dist/constants.mjs
+// ../../node_modules/.pnpm/package-manager-detector@1.6.0/node_modules/package-manager-detector/dist/constants.mjs
 init_esm_shims();
 var AGENTS = [
   "npm",
@@ -20475,7 +20570,7 @@ var INSTALL_METADATA = {
   "bun.lockb": "bun"
 };
 
-// ../../node_modules/.pnpm/package-manager-detector@1.5.0/node_modules/package-manager-detector/dist/detect.mjs
+// ../../node_modules/.pnpm/package-manager-detector@1.6.0/node_modules/package-manager-detector/dist/detect.mjs
 async function pathExists(path210, type) {
   try {
     const stat5 = await fs9.stat(path210);
@@ -20492,14 +20587,15 @@ function* lookup(cwd = process5.cwd()) {
     directory = path14.dirname(directory);
   }
 }
-async function parsePackageJson(filepath, onUnknown) {
-  return !filepath || !pathExists(filepath, "file") ? null : await handlePackageManager(filepath, onUnknown);
+async function parsePackageJson(filepath, options) {
+  if (!filepath || !await pathExists(filepath, "file"))
+    return null;
+  return await handlePackageManager(filepath, options);
 }
 async function detect(options = {}) {
   const {
     cwd,
-    strategies = ["lockfile", "packageManager-field", "devEngines-field"],
-    onUnknown
+    strategies = ["lockfile", "packageManager-field", "devEngines-field"]
   } = options;
   let stopDir;
   if (typeof options.stopDir === "string") {
@@ -20515,7 +20611,7 @@ async function detect(options = {}) {
           for (const lock of Object.keys(LOCKS)) {
             if (await pathExists(path14.join(directory, lock), "file")) {
               const name = LOCKS[lock];
-              const result = await parsePackageJson(path14.join(directory, "package.json"), onUnknown);
+              const result = await parsePackageJson(path14.join(directory, "package.json"), options);
               if (result)
                 return result;
               else
@@ -20526,7 +20622,7 @@ async function detect(options = {}) {
         }
         case "packageManager-field":
         case "devEngines-field": {
-          const result = await parsePackageJson(path14.join(directory, "package.json"), onUnknown);
+          const result = await parsePackageJson(path14.join(directory, "package.json"), options);
           if (result)
             return result;
           break;
@@ -20563,9 +20659,10 @@ function getNameAndVer(pkg) {
   }
   return void 0;
 }
-async function handlePackageManager(filepath, onUnknown) {
+async function handlePackageManager(filepath, options) {
   try {
-    const pkg = JSON.parse(await fs9.readFile(filepath, "utf8"));
+    const content = await fs9.readFile(filepath, "utf8");
+    const pkg = options.packageJsonParser ? await options.packageJsonParser(content, filepath) : JSON.parse(content);
     let agent;
     const nameAndVer = getNameAndVer(pkg);
     if (nameAndVer) {
@@ -20583,7 +20680,7 @@ async function handlePackageManager(filepath, onUnknown) {
         agent = name;
         return { name, agent, version: version2 };
       } else {
-        return onUnknown?.(pkg.packageManager) ?? null;
+        return options.onUnknown?.(pkg.packageManager) ?? null;
       }
     }
   } catch {
@@ -20595,7 +20692,7 @@ function isMetadataYarnClassic(metadataPath) {
 }
 
 // src/runtime/config/createConfigService.ts
-import path32 from "pathe";
+import path33 from "pathe";
 
 // src/platform.ts
 init_esm_shims();
@@ -21447,7 +21544,7 @@ function createLoadConfig(options) {
 init_esm_shims();
 import { defu as defu4 } from "@weapp-core/shared";
 import { weappWebPlugin } from "@weapp-vite/web";
-import path31 from "pathe";
+import path32 from "pathe";
 
 // src/plugins/index.ts
 init_esm_shims();
@@ -21461,7 +21558,7 @@ import path19 from "pathe";
 function normalizeCopyGlobs(globs) {
   return Array.isArray(globs) ? globs : [];
 }
-function scanAssetFiles(configService, config) {
+function scanAssetFiles(configService, config, buildTarget) {
   const weappViteConfig = configService.weappViteConfig;
   const include = normalizeCopyGlobs(weappViteConfig?.copy?.include);
   const exclude = normalizeCopyGlobs(weappViteConfig?.copy?.exclude);
@@ -21475,10 +21572,16 @@ function scanAssetFiles(configService, config) {
     `**/*.{${defaultAssetExtensions.join(",")}}`,
     ...include
   ];
-  const roots = /* @__PURE__ */ new Set([configService.absoluteSrcRoot]);
-  if (configService.absolutePluginRoot) {
+  const roots = /* @__PURE__ */ new Set();
+  if (buildTarget !== "plugin") {
+    roots.add(configService.absoluteSrcRoot);
+  }
+  if (configService.absolutePluginRoot && buildTarget === "plugin") {
     roots.add(configService.absolutePluginRoot);
   }
+  if (!roots.size) {
+    return Promise.resolve([]);
+  }
   const crawlPromises = Array.from(roots).map((root) => {
     return new Fdir2({
       includeDirs: false,
@@ -21519,7 +21622,7 @@ function createAssetCollector(state) {
         state.pendingAssets = Promise.resolve([]);
         return;
       }
-      state.pendingAssets = scanAssetFiles(configService, state.resolvedConfig);
+      state.pendingAssets = scanAssetFiles(configService, state.resolvedConfig, state.buildTarget);
     },
     async buildEnd() {
       const assets = await state.pendingAssets;
@@ -21529,7 +21632,7 @@ function createAssetCollector(state) {
       for (const candidate of assets) {
         this.emitFile({
           type: "asset",
-          fileName: configService.relativeAbsoluteSrcRoot(candidate.file),
+          fileName: configService.relativeOutputPath(candidate.file),
           source: candidate.buffer
         });
       }
@@ -21537,7 +21640,7 @@ function createAssetCollector(state) {
   };
 }
 function asset(ctx) {
-  const state = { ctx };
+  const state = { ctx, buildTarget: ctx.currentBuildTarget ?? "app" };
   return [createAssetCollector(state)];
 }
 
@@ -22827,7 +22930,7 @@ var MagicString = class _MagicString {
 };
 
 // src/plugins/core.ts
-import path26 from "pathe";
+import path27 from "pathe";
 
 // src/plugins/css/shared/preprocessor.ts
 init_esm_shims();
@@ -23121,7 +23224,7 @@ function createChunkEmitter(configService, loadedEntrySet, debug4) {
       const start = performance2.now();
       loadedEntrySet.add(resolvedId.id);
       await this.load(resolvedId);
-      const fileName = configService.relativeAbsoluteSrcRoot(
+      const fileName = configService.relativeOutputPath(
         changeFileExtension(resolvedId.id, ".js")
       );
       this.emitFile({
@@ -23191,7 +23294,7 @@ function createJsonEmitManager(configService) {
     if (!entry.jsonPath) {
       return;
     }
-    const fileName = configService.relativeAbsoluteSrcRoot(
+    const fileName = configService.relativeOutputPath(
       jsonFileRemoveJsExtension(entry.jsonPath)
     );
     map.set(fileName, {
@@ -23370,8 +23473,10 @@ function createEntryLoader(options) {
     emitEntriesChunks,
     applyAutoImports,
     extendedLibManager,
+    buildTarget,
     debug: debug4
   } = options;
+  const isPluginBuild = buildTarget === "plugin";
   const { jsonService, configService, scanService } = ctx;
   const existsCache = /* @__PURE__ */ new Map();
   return async function loadEntry(id, type) {
@@ -23398,16 +23503,18 @@ function createEntryLoader(options) {
     let pluginJsonPathForRegistration;
     let pluginJsonForRegistration;
     if (type === "app") {
-      extendedLibManager.syncFromAppJson(json);
-      entries.push(...analyzeAppJson(json));
-      await collectAppSideFiles(
-        this,
-        id,
-        json,
-        jsonService,
-        registerJsonAsset,
-        existsCache
-      );
+      if (!isPluginBuild) {
+        extendedLibManager.syncFromAppJson(json);
+        entries.push(...analyzeAppJson(json));
+        await collectAppSideFiles(
+          this,
+          id,
+          json,
+          jsonService,
+          registerJsonAsset,
+          existsCache
+        );
+      }
       const pluginJsonPath = scanService?.pluginJsonPath;
       if (configService.absolutePluginRoot && pluginJsonPath) {
         this.addWatchFile(pluginJsonPath);
@@ -23441,25 +23548,27 @@ function createEntryLoader(options) {
       applyAutoImports(baseName, json);
       entries.push(...analyzeCommonJson(json));
     }
-    const filteredEntries = entries.filter((entry) => !extendedLibManager.shouldIgnoreEntry(entry));
-    const normalizedEntries = filteredEntries.map((entry) => normalizeEntry(entry, jsonPath));
-    for (const normalizedEntry of normalizedEntries) {
-      entriesMap.set(normalizedEntry, {
-        type: json.component ? "component" : "page",
-        templatePath,
-        jsonPath,
-        json,
-        path: id
-      });
+    const filteredEntries = isPluginBuild ? [] : entries.filter((entry) => !extendedLibManager.shouldIgnoreEntry(entry));
+    const normalizedEntries = isPluginBuild ? [] : filteredEntries.map((entry) => normalizeEntry(entry, jsonPath));
+    if (!isPluginBuild) {
+      for (const normalizedEntry of normalizedEntries) {
+        entriesMap.set(normalizedEntry, {
+          type: json.component ? "component" : "page",
+          templatePath,
+          jsonPath,
+          json,
+          path: id
+        });
+      }
     }
-    const resolvedIds = await resolveEntries.call(
+    const resolvedIds = normalizedEntries.length ? await resolveEntries.call(
       this,
       normalizedEntries,
       configService.absoluteSrcRoot
-    );
+    ) : [];
     debug4?.(`resolvedIds ${relativeCwdId} \u8017\u65F6 ${getTime()}`);
     const pendingResolvedIds = [];
-    const combinedResolved = pluginResolvedRecords ? [...resolvedIds, ...pluginResolvedRecords] : resolvedIds;
+    const combinedResolved = pluginResolvedRecords ? isPluginBuild ? pluginResolvedRecords : [...resolvedIds, ...pluginResolvedRecords] : resolvedIds;
     const pluginEntrySet = pluginResolvedRecords ? new Set(pluginResolvedRecords.map((record) => record.entry)) : void 0;
     for (const { entry, resolvedId } of combinedResolved) {
       if (!resolvedId) {
@@ -23479,11 +23588,13 @@ function createEntryLoader(options) {
       await Promise.all(emitEntriesChunks.call(this, pendingResolvedIds));
     }
     debug4?.(`emitEntriesChunks ${relativeCwdId} \u8017\u65F6 ${getTime()}`);
-    registerJsonAsset({
-      jsonPath,
-      json,
-      type
-    });
+    if (!isPluginBuild) {
+      registerJsonAsset({
+        jsonPath,
+        json,
+        type
+      });
+    }
     if (pluginJsonPathForRegistration && pluginJsonForRegistration) {
       registerJsonAsset({
         jsonPath: pluginJsonPathForRegistration,
@@ -23569,8 +23680,9 @@ function createTemplateScanner(wxmlService, debug4) {
 }
 
 // src/plugins/hooks/useLoadEntry/index.ts
-function useLoadEntry(ctx) {
+function useLoadEntry(ctx, options) {
   const debug4 = createDebugger("weapp-vite:load-entry");
+  const buildTarget = options?.buildTarget ?? "app";
   const entriesMap = /* @__PURE__ */ new Map();
   const loadedEntrySet = /* @__PURE__ */ new Set();
   const jsonEmitManager = createJsonEmitManager(ctx.configService);
@@ -23590,6 +23702,7 @@ function useLoadEntry(ctx) {
     emitEntriesChunks,
     applyAutoImports,
     extendedLibManager,
+    buildTarget,
     debug: debug4
   });
   return {
@@ -23947,7 +24060,7 @@ function ensureSidecarWatcher(ctx, rootDir) {
     ...templateExtensions.map((ext2) => path25.join(absRoot, `**/*.${ext2}`))
   ];
   const ignoredMatcher = createSidecarIgnoredMatcher(ctx, absRoot);
-  const watcher = esm_default.watch(patterns, {
+  const watcher = chokidar_default.watch(patterns, {
     ignoreInitial: false,
     persistent: true,
     awaitWriteFinish: {
@@ -23966,9 +24079,9 @@ function ensureSidecarWatcher(ctx, rootDir) {
     }
     handleSidecarChange(event, normalizedPath, isReady);
   };
-  watcher.on("add", (path36) => forwardChange("create", path36));
-  watcher.on("change", (path36) => forwardChange("update", path36));
-  watcher.on("unlink", (path36) => forwardChange("delete", path36));
+  watcher.on("add", (path37) => forwardChange("create", path37));
+  watcher.on("change", (path37) => forwardChange("update", path37));
+  watcher.on("unlink", (path37) => forwardChange("delete", path37));
   watcher.on("raw", (eventName, rawPath, details) => {
     if (eventName !== "rename") {
       return;
@@ -24048,6 +24161,7 @@ function getCssRealPath(res) {
 
 // src/plugins/utils/wxmlEmit.ts
 init_esm_shims();
+import path26 from "pathe";
 
 // src/wxml/handle.ts
 init_esm_shims();
@@ -24290,7 +24404,7 @@ ${result.code}`);
 
 // src/plugins/utils/wxmlEmit.ts
 function emitWxmlAssetsWithCache(options) {
-  const { runtime, compiler, subPackageMeta, emittedCodeCache } = options;
+  const { runtime, compiler, subPackageMeta, emittedCodeCache, buildTarget = "app" } = options;
   const { wxmlService, configService, scanService } = compiler;
   if (!wxmlService || !configService || !scanService) {
     throw new Error("emitWxmlAssets requires wxmlService, configService and scanService to be initialized");
@@ -24299,12 +24413,20 @@ function emitWxmlAssetsWithCache(options) {
     return {
       id,
       token,
-      fileName: configService.relativeAbsoluteSrcRoot(id)
+      fileName: configService.relativeOutputPath(id)
     };
   }).filter(({ fileName }) => {
     if (subPackageMeta) {
       return fileName.startsWith(subPackageMeta.subPackage.root);
     }
+    if (buildTarget === "plugin") {
+      const pluginRoot = configService.absolutePluginRoot;
+      if (!pluginRoot) {
+        return false;
+      }
+      const pluginBase = path26.basename(pluginRoot);
+      return fileName.startsWith(pluginBase);
+    }
     return scanService.isMainPackageFileName(fileName);
   });
   const emittedFiles = [];
@@ -24342,7 +24464,8 @@ function emitJsonAsset(runtime, fileName, source) {
 // src/plugins/core.ts
 var debug2 = createDebugger("weapp-vite:core");
 function weappVite(ctx, subPackageMeta) {
-  const { loadEntry, loadedEntrySet, jsonEmitFilesMap, entriesMap } = useLoadEntry(ctx);
+  const buildTarget = ctx.currentBuildTarget ?? "app";
+  const { loadEntry, loadedEntrySet, jsonEmitFilesMap, entriesMap } = useLoadEntry(ctx, { buildTarget });
   const state = {
     ctx,
     subPackageMeta,
@@ -24352,7 +24475,8 @@ function weappVite(ctx, subPackageMeta) {
     jsonEmitFilesMap,
     requireAsyncEmittedChunks: /* @__PURE__ */ new Set(),
     pendingIndependentBuilds: [],
-    watchFilesSnapshot: []
+    watchFilesSnapshot: [],
+    buildTarget
   };
   return [
     createTakeQueryPlugin(state),
@@ -24433,18 +24557,25 @@ function createWxssResolverPlugin(_state) {
   };
 }
 function createCoreLifecyclePlugin(state) {
-  const { ctx, subPackageMeta, loadEntry, loadedEntrySet } = state;
+  const { ctx, subPackageMeta, loadEntry, loadedEntrySet, buildTarget } = state;
   const { scanService, configService, buildService } = ctx;
+  const isPluginBuild = buildTarget === "plugin";
   return {
     name: "weapp-vite:pre",
     enforce: "pre",
     buildStart() {
       loadedEntrySet.clear();
       if (configService.isDev) {
-        const rootDir = subPackageMeta ? path26.resolve(configService.absoluteSrcRoot, subPackageMeta.subPackage.root) : configService.absoluteSrcRoot;
-        ensureSidecarWatcher(ctx, rootDir);
-        if (!subPackageMeta && configService.absolutePluginRoot) {
-          ensureSidecarWatcher(ctx, configService.absolutePluginRoot);
+        if (isPluginBuild) {
+          if (configService.absolutePluginRoot) {
+            ensureSidecarWatcher(ctx, configService.absolutePluginRoot);
+          }
+        } else {
+          const rootDir = subPackageMeta ? path27.resolve(configService.absoluteSrcRoot, subPackageMeta.subPackage.root) : configService.absoluteSrcRoot;
+          ensureSidecarWatcher(ctx, rootDir);
+          if (!subPackageMeta && configService.absolutePluginRoot) {
+            ensureSidecarWatcher(ctx, configService.absolutePluginRoot);
+          }
         }
       }
     },
@@ -24487,7 +24618,7 @@ function createCoreLifecyclePlugin(state) {
       let scannedInput;
       if (subPackageMeta) {
         scannedInput = subPackageMeta.entries.reduce((acc, entry) => {
-          acc[entry] = path26.resolve(configService.absoluteSrcRoot, entry);
+          acc[entry] = path27.resolve(configService.absoluteSrcRoot, entry);
           return acc;
         }, {});
       } else {
@@ -24551,11 +24682,16 @@ function createCoreLifecyclePlugin(state) {
         runtime,
         compiler: ctx,
         subPackageMeta,
-        emittedCodeCache: ctx.runtimeState.wxml.emittedCode
+        emittedCodeCache: ctx.runtimeState.wxml.emittedCode,
+        buildTarget
       });
     },
     async generateBundle(_options, bundle) {
       await flushIndependentBuilds.call(this, state);
+      if (isPluginBuild) {
+        filterPluginBundleOutputs(bundle, configService);
+        return;
+      }
       if (!subPackageMeta) {
         let matchSubPackage2 = function(filePath) {
           return subPackageRoots.find((root) => filePath === root || filePath.startsWith(`${root}/`));
@@ -24681,7 +24817,7 @@ function createRequireAnalysisPlugin(state) {
         return;
       }
       for (const requireModule of requireTokens) {
-        const absPath = path26.resolve(path26.dirname(moduleInfo.id), requireModule.value);
+        const absPath = path27.resolve(path27.dirname(moduleInfo.id), requireModule.value);
         const resolved = await this.resolve(absPath, moduleInfo.id);
         if (!resolved) {
           continue;
@@ -24694,7 +24830,7 @@ function createRequireAnalysisPlugin(state) {
         this.emitFile({
           type: "chunk",
           id: resolved.id,
-          fileName: configService.relativeAbsoluteSrcRoot(
+          fileName: configService.relativeOutputPath(
             changeFileExtension(resolved.id, ".js")
           ),
           preserveSignature: "exports-only"
@@ -24718,6 +24854,17 @@ function formatBytes(bytes) {
   const formatted = value.toFixed(precision).replace(/\.0+$/, "");
   return `${formatted} ${units[index]}`;
 }
+function filterPluginBundleOutputs(bundle, configService) {
+  const pluginOutputRoot = configService.absolutePluginOutputRoot;
+  for (const [fileName] of Object.entries(bundle)) {
+    const absolute = path27.resolve(configService.outDir, fileName);
+    const relative3 = pluginOutputRoot ? path27.relative(pluginOutputRoot, absolute) : "";
+    const isPluginFile = pluginOutputRoot ? !relative3.startsWith("..") && !path27.isAbsolute(relative3) : fileName.startsWith(path27.basename(configService.absolutePluginRoot ?? "plugin"));
+    if (!isPluginFile) {
+      delete bundle[fileName];
+    }
+  }
+}
 function emitJsonAssets(state) {
   const { ctx } = state;
   const { jsonService } = ctx;
@@ -24827,8 +24974,8 @@ function resolveRelativeImport(fromFile, specifier) {
   if (!specifier) {
     return "";
   }
-  const dir = path26.posix.dirname(fromFile);
-  const absolute = path26.posix.resolve("/", dir, specifier);
+  const dir = path27.posix.dirname(fromFile);
+  const absolute = path27.posix.resolve("/", dir, specifier);
   return absolute.startsWith("/") ? absolute.slice(1) : absolute;
 }
 async function flushIndependentBuilds(state) {
@@ -24862,11 +25009,11 @@ async function flushIndependentBuilds(state) {
 // src/plugins/css.ts
 init_esm_shims();
 import fs17 from "fs-extra";
-import path28 from "pathe";
+import path29 from "pathe";
 
 // src/plugins/css/shared/sharedStyles.ts
 init_esm_shims();
-import path27 from "pathe";
+import path28 from "pathe";
 import picomatch2 from "picomatch";
 var SLASH_RE = /\\/g;
 function toPosixPath(value) {
@@ -24982,7 +25129,7 @@ function findSharedStylesForModule(modulePath, fileName, sharedStyles) {
 }
 function resolveImportSpecifiers(fileName, entries) {
   const posixFileName = toPosixPath(fileName);
-  const dir = path27.posix.dirname(posixFileName);
+  const dir = path28.posix.dirname(posixFileName);
   const seen = /* @__PURE__ */ new Set();
   const specifiers = [];
   for (const entry of entries) {
@@ -24990,8 +25137,8 @@ function resolveImportSpecifiers(fileName, entries) {
     if (target === posixFileName) {
       continue;
     }
-    const relative3 = path27.posix.relative(dir, target);
-    let specifier = relative3 || path27.posix.basename(target);
+    const relative3 = path28.posix.relative(dir, target);
+    let specifier = relative3 || path28.posix.basename(target);
     if (!specifier || specifier === ".") {
       continue;
     }
@@ -25068,12 +25215,12 @@ async function handleBundleEntry(bundle, bundleKey, asset2, configService, share
     return;
   }
   const toAbsolute = (id) => {
-    return path28.isAbsolute(id) ? id : path28.resolve(configService.cwd, id);
+    return path29.isAbsolute(id) ? id : path29.resolve(configService.cwd, id);
   };
   if (bundleKey.endsWith(".wxss")) {
     const [rawOriginal] = asset2.originalFileNames ?? [];
-    const absOriginal = rawOriginal ? toAbsolute(rawOriginal) : path28.resolve(configService.absoluteSrcRoot, bundleKey);
-    const fileName = configService.relativeAbsoluteSrcRoot(absOriginal);
+    const absOriginal = rawOriginal ? toAbsolute(rawOriginal) : path29.resolve(configService.absoluteSrcRoot, bundleKey);
+    const fileName = configService.relativeOutputPath(absOriginal);
     if (fileName) {
       emitted.add(toPosixPath(fileName));
     }
@@ -25102,7 +25249,7 @@ async function handleBundleEntry(bundle, bundleKey, asset2, configService, share
       }
       const modulePath = toAbsolute(originalFileName);
       const converted = changeFileExtension(modulePath, configService.outputExtensions.wxss);
-      const fileName = configService.relativeAbsoluteSrcRoot(converted);
+      const fileName = configService.relativeOutputPath(converted);
       if (!fileName) {
         return;
       }
@@ -25183,7 +25330,7 @@ async function emitSharedStyleImportsForChunks(sharedStyles, emitted, configServ
         return;
       }
       const converted = changeFileExtension(moduleId, outputExtensions.wxss);
-      const fileName = configService.relativeAbsoluteSrcRoot(converted);
+      const fileName = configService.relativeOutputPath(converted);
       if (!fileName) {
         return;
       }
@@ -25284,12 +25431,12 @@ init_esm_shims();
 import { createHash as createHash2 } from "crypto";
 import { removeExtension as removeExtension2 } from "@weapp-core/shared";
 import fs18 from "fs-extra";
-import path29 from "pathe";
+import path30 from "pathe";
 async function resolveWorkerEntry(ctx, entry) {
   const { configService, scanService } = ctx;
-  const relativeEntryPath = path29.join(scanService.workersDir, entry);
+  const relativeEntryPath = path30.join(scanService.workersDir, entry);
   const key = removeExtension2(relativeEntryPath);
-  const absoluteEntry = path29.resolve(configService.absoluteSrcRoot, relativeEntryPath);
+  const absoluteEntry = path30.resolve(configService.absoluteSrcRoot, relativeEntryPath);
   if (isJsOrTs(entry)) {
     const exists = await fs18.exists(absoluteEntry);
     if (!exists) {
@@ -25326,12 +25473,12 @@ function createWorkerBuildPlugin(ctx) {
       options.chunkFileNames = (chunkInfo) => {
         const workersDir = scanService.workersDir ?? "";
         if (chunkInfo.isDynamicEntry) {
-          return path29.join(workersDir, "[name].js");
+          return path30.join(workersDir, "[name].js");
         }
         const sourceId = chunkInfo.facadeModuleId ?? chunkInfo.moduleIds[0];
         const hashBase = typeof sourceId === "string" ? configService.relativeCwd(sourceId) : chunkInfo.name;
         const stableHash = createHash2("sha256").update(hashBase).digest("base64url").slice(0, 8);
-        return path29.join(workersDir, `${chunkInfo.name}-${stableHash}.js`);
+        return path30.join(workersDir, `${chunkInfo.name}-${stableHash}.js`);
       };
     }
   };
@@ -25347,7 +25494,7 @@ function workers(ctx) {
 init_esm_shims();
 import { removeExtension as removeExtension3 } from "@weapp-core/shared";
 import fs19 from "fs-extra";
-import path30 from "pathe";
+import path31 from "pathe";
 var wxsCodeCache = new LRUCache({
   max: 512
 });
@@ -25372,13 +25519,13 @@ async function transformWxsFile(state, wxsPath) {
     if (typeof result?.code === "string") {
       code = result.code;
     }
-    const dirname5 = path30.dirname(wxsPath);
+    const dirname5 = path31.dirname(wxsPath);
     await Promise.all(
       importees.map(({ source }) => {
         return transformWxsFile.call(
           this,
           state,
-          path30.resolve(dirname5, source)
+          path31.resolve(dirname5, source)
         );
       })
     );
@@ -25389,7 +25536,7 @@ async function transformWxsFile(state, wxsPath) {
   state.wxsMap.set(wxsPath, {
     emittedFile: {
       type: "asset",
-      fileName: configService.relativeAbsoluteSrcRoot(
+      fileName: configService.relativeOutputPath(
         isRaw ? wxsPath : removeExtension3(wxsPath)
       ),
       source: code
@@ -25404,7 +25551,7 @@ async function handleWxsDeps(state, deps, absPath) {
       if (!jsExtensions.includes(dep.attrs.lang) && !arr) {
         return;
       }
-      const wxsPath = path30.resolve(path30.dirname(absPath), dep.value);
+      const wxsPath = path31.resolve(path31.dirname(absPath), dep.value);
       await transformWxsFile.call(this, state, wxsPath);
     })
   );
@@ -25445,7 +25592,7 @@ function wxs(ctx) {
 }
 
 // src/plugins/index.ts
-var RUNTIME_PLUGINS_SYMBOL = Symbol.for("weapp-runtime:plugins");
+var RUNTIME_PLUGINS_SYMBOL = /* @__PURE__ */ Symbol.for("weapp-runtime:plugins");
 var WEAPP_VITE_CONTEXT_PLUGIN_NAME = "weapp-vite:context";
 function createContextPlugin(ctx) {
   return {
@@ -25608,17 +25755,17 @@ function createMergeFactories(options) {
     };
     if (currentOptions.isDev) {
       const watchInclude = [
-        path31.join(currentOptions.cwd, currentOptions.srcRoot, "**")
+        path32.join(currentOptions.cwd, currentOptions.srcRoot, "**")
       ];
       const pluginRootConfig = currentOptions.config.weapp?.pluginRoot;
       if (pluginRootConfig) {
-        const absolutePluginRoot = path31.resolve(currentOptions.cwd, pluginRootConfig);
-        const relativeToSrc = path31.relative(
-          path31.resolve(currentOptions.cwd, currentOptions.srcRoot),
+        const absolutePluginRoot = path32.resolve(currentOptions.cwd, pluginRootConfig);
+        const relativeToSrc = path32.relative(
+          path32.resolve(currentOptions.cwd, currentOptions.srcRoot),
           absolutePluginRoot
         );
-        const pluginPatternBase = relativeToSrc.startsWith("..") ? absolutePluginRoot : path31.join(currentOptions.cwd, currentOptions.srcRoot, relativeToSrc);
-        watchInclude.push(path31.join(pluginPatternBase, "**"));
+        const pluginPatternBase = relativeToSrc.startsWith("..") ? absolutePluginRoot : path32.join(currentOptions.cwd, currentOptions.srcRoot, relativeToSrc);
+        watchInclude.push(path32.join(pluginPatternBase, "**"));
       }
       const inline = defu4(
         currentOptions.config,
@@ -25631,7 +25778,7 @@ function createMergeFactories(options) {
             watch: {
               exclude: [
                 ...defaultExcluded,
-                currentOptions.mpDistRoot ? path31.join(currentOptions.cwd, currentOptions.mpDistRoot, "**") : path31.join(currentOptions.cwd, "dist", "**")
+                currentOptions.mpDistRoot ? path32.join(currentOptions.cwd, currentOptions.mpDistRoot, "**") : path32.join(currentOptions.cwd, "dist", "**")
               ],
               include: watchInclude
             },
@@ -25761,6 +25908,62 @@ function createConfigService(ctx) {
   const builtinAliases = resolveBuiltinPackageAliases();
   const oxcRuntimeSupport = createOxcRuntimeSupport();
   const aliasManager = createAliasManager(oxcRuntimeSupport.alias, builtinAliases);
+  const toPosix3 = (value) => value.replace(/\\/g, "/");
+  const fromPosix = (value) => path33.sep === "/" ? value : value.split("/").join(path33.sep);
+  const resolveAbsolutePluginRoot = () => {
+    const pluginRootConfig = options.config.weapp?.pluginRoot;
+    if (!pluginRootConfig) {
+      return void 0;
+    }
+    return path33.resolve(options.cwd, pluginRootConfig);
+  };
+  const resolvePluginSourceBase = () => {
+    const absolutePluginRoot = resolveAbsolutePluginRoot();
+    if (!absolutePluginRoot) {
+      return void 0;
+    }
+    return toPosix3(path33.basename(absolutePluginRoot));
+  };
+  const resolveAbsolutePluginOutputRoot = () => {
+    const absolutePluginRoot = resolveAbsolutePluginRoot();
+    if (!absolutePluginRoot) {
+      return void 0;
+    }
+    const configured = options.projectConfig?.pluginRoot;
+    if (configured) {
+      return path33.resolve(options.cwd, configured);
+    }
+    const outDir = path33.resolve(options.cwd, options.mpDistRoot ?? "");
+    const pluginBase = path33.basename(absolutePluginRoot);
+    return path33.resolve(outDir, pluginBase);
+  };
+  const resolvePluginOutputBasePosix = () => {
+    const absoluteOutputRoot = resolveAbsolutePluginOutputRoot();
+    if (!absoluteOutputRoot) {
+      return void 0;
+    }
+    const outDir = path33.resolve(options.cwd, options.mpDistRoot ?? "");
+    const relative3 = path33.relative(outDir, absoluteOutputRoot);
+    const normalized = toPosix3(relative3);
+    if (!normalized || normalized === ".") {
+      return resolvePluginSourceBase();
+    }
+    return normalized;
+  };
+  const remapPluginRelativePath = (relativePath) => {
+    const pluginBase = resolvePluginSourceBase();
+    if (!pluginBase) {
+      return relativePath;
+    }
+    const normalizedRelative = toPosix3(relativePath);
+    if (normalizedRelative === pluginBase || normalizedRelative.startsWith(`${pluginBase}/`)) {
+      const pluginRelative = normalizedRelative === pluginBase ? "" : normalizedRelative.slice(pluginBase.length + 1);
+      const outputBase = resolvePluginOutputBasePosix() ?? pluginBase;
+      const mapped = pluginRelative ? `${outputBase}/${pluginRelative}` : outputBase;
+      return fromPosix(mapped);
+    }
+    return relativePath;
+  };
   function setOptions(value) {
     options = value;
     configState.options = value;
@@ -25876,7 +26079,7 @@ function createConfigService(ctx) {
       return options.mpDistRoot;
     },
     get outDir() {
-      return path32.resolve(options.cwd, options.mpDistRoot ?? "");
+      return path33.resolve(options.cwd, options.mpDistRoot ?? "");
     },
     get currentSubPackageRoot() {
       return options.currentSubPackageRoot;
@@ -25900,12 +26103,13 @@ function createConfigService(ctx) {
       return options.config.weapp?.pluginRoot;
     },
     get absolutePluginRoot() {
-      if (options.config.weapp?.pluginRoot) {
-        return path32.resolve(options.cwd, options.config.weapp.pluginRoot);
-      }
+      return resolveAbsolutePluginRoot();
+    },
+    get absolutePluginOutputRoot() {
+      return resolveAbsolutePluginOutputRoot();
     },
     get absoluteSrcRoot() {
-      return path32.resolve(options.cwd, options.srcRoot);
+      return path33.resolve(options.cwd, options.srcRoot);
     },
     get mode() {
       return options.mode;
@@ -25923,28 +26127,34 @@ function createConfigService(ctx) {
       return options.weappWeb;
     },
     relativeCwd(p) {
-      return path32.relative(options.cwd, p);
+      return path33.relative(options.cwd, p);
     },
     relativeSrcRoot(p) {
       return options.relativeSrcRoot(p);
     },
     relativeAbsoluteSrcRoot(p) {
-      const absoluteSrcRoot = path32.resolve(options.cwd, options.srcRoot);
-      const pluginRootConfig = options.config.weapp?.pluginRoot;
-      if (pluginRootConfig) {
-        const absolutePluginRoot = path32.resolve(options.cwd, pluginRootConfig);
-        const relativeToPlugin = path32.relative(absolutePluginRoot, p);
+      const absoluteSrcRoot = path33.resolve(options.cwd, options.srcRoot);
+      const absolutePluginRoot = resolveAbsolutePluginRoot();
+      if (absolutePluginRoot) {
+        const relativeToPlugin = path33.relative(absolutePluginRoot, p);
         if (!relativeToPlugin.startsWith("..")) {
-          const pluginBase = path32.basename(absolutePluginRoot);
-          return relativeToPlugin ? path32.join(pluginBase, relativeToPlugin) : pluginBase;
+          const pluginBase = path33.basename(absolutePluginRoot);
+          return relativeToPlugin ? path33.join(pluginBase, relativeToPlugin) : pluginBase;
         }
       }
-      const relativeFromSrc = path32.relative(absoluteSrcRoot, p);
+      const relativeFromSrc = path33.relative(absoluteSrcRoot, p);
       if (!relativeFromSrc.startsWith("..")) {
         return relativeFromSrc;
       }
-      const relativeFromCwd = path32.relative(options.cwd, p);
+      const relativeFromCwd = path33.relative(options.cwd, p);
       return relativeFromCwd;
+    },
+    relativeOutputPath(p) {
+      const relative3 = this.relativeAbsoluteSrcRoot(p);
+      if (!relative3) {
+        return relative3;
+      }
+      return remapPluginRelativePath(relative3);
     }
   };
 }
@@ -26019,6 +26229,7 @@ function createJsonService(ctx) {
           require: customRequire,
           rolldownOptions: {
             input: {
+              // @ts-ignore
               define: ctx.configService.defineImportMetaEnv
             },
             output: {
@@ -26062,7 +26273,7 @@ init_esm_shims();
 import { isBuiltin } from "module";
 import { defu as defu6, isObject as isObject9, objectHash } from "@weapp-core/shared";
 import fs21 from "fs-extra";
-import path33 from "pathe";
+import path34 from "pathe";
 import { build as tsdownBuild } from "tsdown";
 function createNpmService(ctx) {
   const oxcRuntimeSupport = createOxcRuntimeSupport();
@@ -26071,7 +26282,7 @@ function createNpmService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before generating npm cache path");
     }
-    return path33.resolve(ctx.configService.cwd, `node_modules/weapp-vite/.cache/${key.replaceAll("/", "-")}.json`);
+    return path34.resolve(ctx.configService.cwd, `node_modules/weapp-vite/.cache/${key.replaceAll("/", "-")}.json`);
   }
   function dependenciesCacheHash() {
     if (!ctx.configService) {
@@ -26175,14 +26386,14 @@ function createNpmService(ctx) {
     const { packageJson: targetJson, rootPath } = packageInfo;
     const dependencies = targetJson.dependencies ?? {};
     const keys = Object.keys(dependencies);
-    const destOutDir = path33.resolve(outDir, dep);
+    const destOutDir = path34.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: path33.resolve(
+        from: path34.resolve(
           rootPath,
           targetJson.miniprogram
         ),
@@ -26254,10 +26465,10 @@ function createNpmService(ctx) {
     debug?.("buildNpm start");
     const packNpmRelationList = getPackNpmRelationList();
     const [mainRelation, ...subRelations] = packNpmRelationList;
-    const packageJsonPath = path33.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
+    const packageJsonPath = path34.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
     if (await fs21.exists(packageJsonPath)) {
       const pkgJson = await fs21.readJson(packageJsonPath);
-      const outDir = path33.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, "miniprogram_npm");
+      const outDir = path34.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, "miniprogram_npm");
       if (pkgJson.dependencies) {
         const dependencies = Object.keys(pkgJson.dependencies);
         if (dependencies.length > 0) {
@@ -26276,7 +26487,7 @@ function createNpmService(ctx) {
           const targetDirs = [
             ...subRelations.map((x) => {
               return {
-                npmDistDir: path33.resolve(ctx.configService.cwd, x.miniprogramNpmDistDir, "miniprogram_npm")
+                npmDistDir: path34.resolve(ctx.configService.cwd, x.miniprogramNpmDistDir, "miniprogram_npm")
               };
             }),
             ...[...ctx.scanService.independentSubPackageMap.values()].map((x) => {
@@ -26284,7 +26495,7 @@ function createNpmService(ctx) {
               return {
                 root: x.subPackage.root,
                 dependencies: dependencies2,
-                npmDistDir: path33.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, x.subPackage.root, "miniprogram_npm")
+                npmDistDir: path34.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, x.subPackage.root, "miniprogram_npm")
               };
             })
           ];
@@ -26296,7 +26507,7 @@ function createNpmService(ctx) {
                   overwrite: true,
                   filter: (src) => {
                     if (Array.isArray(x.dependencies)) {
-                      const relPath = path33.relative(outDir, src);
+                      const relPath = path34.relative(outDir, src);
                       if (relPath === "") {
                         return true;
                       }
@@ -26312,7 +26523,7 @@ function createNpmService(ctx) {
                 overwrite: true,
                 filter: (src) => {
                   if (Array.isArray(x.dependencies)) {
-                    const relPath = path33.relative(outDir, src);
+                    const relPath = path34.relative(outDir, src);
                     if (relPath === "") {
                       return true;
                     }
@@ -26738,7 +26949,7 @@ var PQueue = class extends import_index2.default {
       ...options
     };
     return new Promise((resolve8, reject) => {
-      const taskSymbol = Symbol(`task-${options.id}`);
+      const taskSymbol = /* @__PURE__ */ Symbol(`task-${options.id}`);
       this.#queue.enqueue(async () => {
         this.#pending++;
         this.#runningTasks.set(taskSymbol, {
@@ -27281,7 +27492,7 @@ function createRuntimeState() {
 init_esm_shims();
 import { isObject as isObject10, removeExtensionDeep as removeExtensionDeep6 } from "@weapp-core/shared";
 import fs23 from "fs-extra";
-import path34 from "pathe";
+import path35 from "pathe";
 var SUPPORTED_SHARED_STYLE_EXTENSIONS = [
   ".wxss",
   ".css",
@@ -27300,8 +27511,8 @@ function toPosix2(value) {
   return value.replace(BACKSLASH_RE, "/");
 }
 function isPathInside(parent, target) {
-  const relative3 = path34.relative(parent, target);
-  return relative3 === "" || !relative3.startsWith("..") && !path34.isAbsolute(relative3);
+  const relative3 = path35.relative(parent, target);
+  return relative3 === "" || !relative3.startsWith("..") && !path35.isAbsolute(relative3);
 }
 function resolveSubPackageEntries(subPackage) {
   const entries = [];
@@ -27325,17 +27536,17 @@ function resolveStyleEntryAbsolutePath(source, subPackageRoot, configService) {
     return void 0;
   }
   const srcRoot = service.absoluteSrcRoot;
-  const absoluteSubRoot = path34.resolve(srcRoot, subPackageRoot);
+  const absoluteSubRoot = path35.resolve(srcRoot, subPackageRoot);
   const normalizedEntry = toPosix2(trimmed);
   const normalizedRoot = toPosix2(subPackageRoot);
   const candidates = [];
-  if (path34.isAbsolute(trimmed)) {
+  if (path35.isAbsolute(trimmed)) {
     candidates.push(trimmed);
   } else if (normalizedEntry === normalizedRoot || normalizedEntry.startsWith(`${normalizedRoot}/`)) {
-    candidates.push(path34.resolve(srcRoot, trimmed));
+    candidates.push(path35.resolve(srcRoot, trimmed));
   } else {
-    candidates.push(path34.resolve(absoluteSubRoot, trimmed));
-    candidates.push(path34.resolve(srcRoot, trimmed));
+    candidates.push(path35.resolve(absoluteSubRoot, trimmed));
+    candidates.push(path35.resolve(srcRoot, trimmed));
   }
   for (const candidate of candidates) {
     if (isPathInside(srcRoot, candidate)) {
@@ -27443,7 +27654,7 @@ function inferScopeFromRelativePath(relativePath) {
   if (cleaned.includes("/")) {
     return void 0;
   }
-  const base = path34.posix.basename(cleaned, path34.posix.extname(cleaned));
+  const base = path35.posix.basename(cleaned, path35.posix.extname(cleaned));
   if (base === "pages") {
     return "pages";
   }
@@ -27506,18 +27717,18 @@ function addStyleEntry(descriptor, absolutePath, posixOutput, root, normalizedRo
     source: descriptor.source,
     absolutePath,
     outputRelativePath: posixOutput,
-    inputExtension: path34.extname(absolutePath).toLowerCase(),
+    inputExtension: path35.extname(absolutePath).toLowerCase(),
     scope: descriptor.scope,
     include,
     exclude
   });
 }
 function appendDefaultScopedStyleEntries(root, normalizedRoot, service, dedupe, normalized) {
-  const absoluteSubRoot = path34.resolve(service.absoluteSrcRoot, root);
+  const absoluteSubRoot = path35.resolve(service.absoluteSrcRoot, root);
   for (const { base, scope } of DEFAULT_SCOPED_FILES) {
     for (const ext2 of DEFAULT_SCOPED_EXTENSIONS) {
       const filename = `${base}${ext2}`;
-      const absolutePath = path34.resolve(absoluteSubRoot, filename);
+      const absolutePath = path35.resolve(absoluteSubRoot, filename);
       if (!fs23.existsSync(absolutePath)) {
         continue;
       }
@@ -27529,7 +27740,7 @@ function appendDefaultScopedStyleEntries(root, normalizedRoot, service, dedupe,
         explicitScope: true
       };
       const outputAbsolutePath = changeFileExtension(absolutePath, service.outputExtensions.wxss);
-      const outputRelativePath = service.relativeAbsoluteSrcRoot(outputAbsolutePath);
+      const outputRelativePath = service.relativeOutputPath(outputAbsolutePath);
       if (!outputRelativePath) {
         continue;
       }
@@ -27567,13 +27778,13 @@ function normalizeSubPackageStyleEntries(styles, subPackage, configService) {
       logger_default.warn(`[subpackages] \u5206\u5305 ${root} \u6837\u5F0F\u5165\u53E3 \`${descriptor.source}\` \u5BF9\u5E94\u6587\u4EF6\u4E0D\u5B58\u5728\uFF0C\u5DF2\u5FFD\u7565\u3002`);
       continue;
     }
-    const ext2 = path34.extname(absolutePath).toLowerCase();
+    const ext2 = path35.extname(absolutePath).toLowerCase();
     if (!SUPPORTED_SHARED_STYLE_EXTS.has(ext2)) {
       logger_default.warn(`[subpackages] \u5206\u5305 ${root} \u6837\u5F0F\u5165\u53E3 \`${descriptor.source}\` \u5F53\u524D\u4EC5\u652F\u6301\u4EE5\u4E0B\u683C\u5F0F\uFF1A${SUPPORTED_SHARED_STYLE_EXTENSIONS.join(", ")}\uFF0C\u5DF2\u5FFD\u7565\u3002`);
       continue;
     }
     const outputAbsolutePath = changeFileExtension(absolutePath, service.outputExtensions.wxss);
-    const outputRelativePath = service.relativeAbsoluteSrcRoot(outputAbsolutePath);
+    const outputRelativePath = service.relativeOutputPath(outputAbsolutePath);
     if (!outputRelativePath) {
       logger_default.warn(`[subpackages] \u5206\u5305 ${root} \u6837\u5F0F\u5165\u53E3 \`${descriptor.source}\` \u4E0D\u5728\u9879\u76EE\u6E90\u7801\u76EE\u5F55\u5185\uFF0C\u5DF2\u5FFD\u7565\u3002`);
       continue;
@@ -27601,11 +27812,11 @@ function createScanService(ctx) {
       return scanState.appEntry;
     }
     const appDirname = ctx.configService.absoluteSrcRoot;
-    const appBasename = path34.resolve(appDirname, "app");
+    const appBasename = path35.resolve(appDirname, "app");
     const { path: appConfigFile } = await findJsonEntry(appBasename);
     const { path: appEntryPath } = await findJsEntry(appBasename);
     if (ctx.configService.absolutePluginRoot) {
-      const pluginBasename = path34.resolve(ctx.configService.absolutePluginRoot, "plugin");
+      const pluginBasename = path35.resolve(ctx.configService.absolutePluginRoot, "plugin");
       const { path: pluginConfigFile } = await findJsonEntry(pluginBasename);
       if (pluginConfigFile) {
         const pluginConfig = await ctx.jsonService.read(pluginConfigFile);
@@ -27628,14 +27839,14 @@ function createScanService(ctx) {
         scanState.appEntry = resolvedAppEntry;
         const { sitemapLocation = "sitemap.json", themeLocation = "theme.json" } = config;
         if (sitemapLocation) {
-          const { path: sitemapJsonPath } = await findJsonEntry(path34.resolve(appDirname, sitemapLocation));
+          const { path: sitemapJsonPath } = await findJsonEntry(path35.resolve(appDirname, sitemapLocation));
           if (sitemapJsonPath) {
             resolvedAppEntry.sitemapJsonPath = sitemapJsonPath;
             resolvedAppEntry.sitemapJson = await ctx.jsonService.read(sitemapJsonPath);
           }
         }
         if (themeLocation) {
-          const { path: themeJsonPath } = await findJsonEntry(path34.resolve(appDirname, themeLocation));
+          const { path: themeJsonPath } = await findJsonEntry(path35.resolve(appDirname, themeLocation));
           if (themeJsonPath) {
             resolvedAppEntry.themeJsonPath = themeJsonPath;
             resolvedAppEntry.themeJson = await ctx.jsonService.read(themeJsonPath);
@@ -27911,7 +28122,7 @@ function createWebServicePlugin(ctx) {
 init_esm_shims();
 import { removeExtensionDeep as removeExtensionDeep7 } from "@weapp-core/shared";
 import fs24 from "fs-extra";
-import path35 from "pathe";
+import path36 from "pathe";
 
 // src/wxml/index.ts
 init_esm_shims();
@@ -30621,7 +30832,7 @@ function createWxmlService(ctx) {
       throw new Error("configService must be initialized before scanning wxml");
     }
     if (await fs24.exists(filepath)) {
-      const dirname5 = path35.dirname(filepath);
+      const dirname5 = path36.dirname(filepath);
       const wxml = await fs24.readFile(filepath, "utf8");
       const shouldRescan = await cache2.isInvalidate(filepath, { content: wxml });
       if (!shouldRescan) {
@@ -30638,9 +30849,9 @@ function createWxmlService(ctx) {
         filepath,
         res.deps.filter((x) => isImportTag(x.tagName) && isTemplate(x.value)).map((x) => {
           if (x.value.startsWith("/")) {
-            return path35.resolve(ctx.configService.absoluteSrcRoot, x.value.slice(1));
+            return path36.resolve(ctx.configService.absoluteSrcRoot, x.value.slice(1));
           } else {
-            return path35.resolve(dirname5, x.value);
+            return path36.resolve(dirname5, x.value);
           }
         })
       );
@@ -30694,7 +30905,7 @@ function createCompilerContextInstance() {
     createBuildServicePlugin(context),
     createWebServicePlugin(context)
   ];
-  Object.defineProperty(context, Symbol.for("weapp-runtime:plugins"), {
+  Object.defineProperty(context, /* @__PURE__ */ Symbol.for("weapp-runtime:plugins"), {
     configurable: false,
     enumerable: false,
     writable: false,
@@ -30747,6 +30958,6 @@ export {
 };
 /*! Bundled license information:
 
-chokidar/esm/index.js:
+chokidar/index.js:
   (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
 */