weapp-vite 5.4.0 → 5.5.0

package/dist/{chunk-UT7K35VH.mjs → chunk-T4MUKDMP.mjs}

@@ -2951,13 +2951,13 @@ function extractComponentProps(code) {
   });
   let props = /* @__PURE__ */ new Map();
   traverse(ast, {
-    CallExpression(path30) {
+    CallExpression(path31) {
       if (props.size > 0) {
         return;
       }
-      const callee = path30.node.callee;
+      const callee = path31.node.callee;
       if (callee.type === "Identifier" && callee.name === "Component") {
-        const [options] = path30.node.arguments;
+        const [options] = path31.node.arguments;
         if (options && options.type === "ObjectExpression") {
           props = extractComponentProperties(options);
         }
@@ -4385,7 +4385,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path30) => statMethod(path30, { bigint: true });
+      this._stat = (path31) => statMethod(path31, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -4410,8 +4410,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path30, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path30));
+          const { path: path31, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path31));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -4451,20 +4451,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path30, depth) {
+  async _exploreDir(path31, depth) {
     let files;
     try {
-      files = await readdir(path30, this._rdOptions);
+      files = await readdir(path31, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path30 };
+    return { files, depth, path: path31 };
   }
-  async _formatEntry(dirent, path30) {
+  async _formatEntry(dirent, path31) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path30, basename4));
+      const fullPath = presolve(pjoin(path31, basename4));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -4865,16 +4865,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path30, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path31, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path30);
-    emitRaw(rawEvent, evPath, { watchedPath: path30 });
-    if (evPath && path30 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path30, evPath), KEY_LISTENERS, sysPath.join(path30, evPath));
+    listener(path31);
+    emitRaw(rawEvent, evPath, { watchedPath: path31 });
+    if (evPath && path31 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path31, evPath), KEY_LISTENERS, sysPath.join(path31, evPath));
     }
   };
   try {
-    return fs_watch(path30, {
+    return fs_watch(path31, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -4890,12 +4890,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path30, fullPath, options, handlers) => {
+var setFsWatchListener = (path31, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path30, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path31, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -4906,7 +4906,7 @@ var setFsWatchListener = (path30, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path30,
+      path31,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -4921,7 +4921,7 @@ var setFsWatchListener = (path30, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path30, "r");
+          const fd = await open(path31, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -4952,7 +4952,7 @@ var setFsWatchListener = (path30, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path30, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path31, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -4974,7 +4974,7 @@ var setFsWatchFileListener = (path30, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path30, curr));
+          foreach(cont.listeners, (listener2) => listener2(path31, curr));
         }
       })
     };
@@ -5002,13 +5002,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path30, listener) {
+  _watchWithNodeFs(path31, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path30);
-    const basename4 = sysPath.basename(path30);
+    const directory = sysPath.dirname(path31);
+    const basename4 = sysPath.basename(path31);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename4);
-    const absolutePath = sysPath.resolve(path30);
+    const absolutePath = sysPath.resolve(path31);
     const options = {
       persistent: opts.persistent
     };
@@ -5018,12 +5018,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path30, absolutePath, options, {
+      closer = setFsWatchFileListener(path31, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path30, absolutePath, options, {
+      closer = setFsWatchListener(path31, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -5045,7 +5045,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename4))
       return;
-    const listener = async (path30, newStats) => {
+    const listener = async (path31, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -5059,11 +5059,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path30);
+            this.fsw._closeFile(path31);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path30, closer2);
+              this.fsw._addPathCloser(path31, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -5095,7 +5095,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path30, item) {
+  async _handleSymlink(entry, directory, path31, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -5105,7 +5105,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path30);
+        linkPath = await fsrealpath(path31);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -5115,12 +5115,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path30, entry.stats);
+          this.fsw._emit(EV.CHANGE, path31, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path30, entry.stats);
+        this.fsw._emit(EV.ADD, path31, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -5149,9 +5149,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path30 = sysPath.join(directory, item);
+      let path31 = sysPath.join(directory, item);
       current2.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path30, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path31, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -5160,8 +5160,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path30 = sysPath.join(dir, sysPath.relative(dir, path30));
-        this._addToNodeFs(path30, initialAdd, wh, depth + 1);
+        path31 = sysPath.join(dir, sysPath.relative(dir, path31));
+        this._addToNodeFs(path31, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve8, reject) => {
@@ -5230,13 +5230,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path30, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path31, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path30) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path31) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path30);
+    const wh = this.fsw._getWatchHelpers(path31);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -5252,8 +5252,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path30);
-        const targetPath = follow ? await fsrealpath(path30) : path30;
+        const absPath = sysPath.resolve(path31);
+        const targetPath = follow ? await fsrealpath(path31) : path31;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -5263,29 +5263,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path30) : path30;
+        const targetPath = follow ? await fsrealpath(path31) : path31;
         if (this.fsw.closed)
           return;
         const parent = sysPath.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path30, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path31, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path30), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path31), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path30, closer);
+        this.fsw._addPathCloser(path31, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path30;
+        return path31;
       }
     }
   }
@@ -5328,26 +5328,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path30) {
-  if (typeof path30 !== "string")
+function normalizePath(path31) {
+  if (typeof path31 !== "string")
     throw new Error("string expected");
-  path30 = sysPath2.normalize(path30);
-  path30 = path30.replace(/\\/g, "/");
+  path31 = sysPath2.normalize(path31);
+  path31 = path31.replace(/\\/g, "/");
   let prepend = false;
-  if (path30.startsWith("//"))
+  if (path31.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path30.match(DOUBLE_SLASH_RE2))
-    path30 = path30.replace(DOUBLE_SLASH_RE2, "/");
+  while (path31.match(DOUBLE_SLASH_RE2))
+    path31 = path31.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path30 = "/" + path30;
-  return path30;
+    path31 = "/" + path31;
+  return path31;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path30 = normalizePath(testString);
+  const path31 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path30, stats)) {
+    if (pattern(path31, stats)) {
       return true;
     }
   }
@@ -5387,19 +5387,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path30) => toUnix(sysPath2.normalize(toUnix(path30)));
-var normalizeIgnored = (cwd = "") => (path30) => {
-  if (typeof path30 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path30) ? path30 : sysPath2.join(cwd, path30));
+var normalizePathToUnix = (path31) => toUnix(sysPath2.normalize(toUnix(path31)));
+var normalizeIgnored = (cwd = "") => (path31) => {
+  if (typeof path31 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path31) ? path31 : sysPath2.join(cwd, path31));
   } else {
-    return path30;
+    return path31;
   }
 };
-var getAbsolutePath = (path30, cwd) => {
-  if (sysPath2.isAbsolute(path30)) {
-    return path30;
+var getAbsolutePath = (path31, cwd) => {
+  if (sysPath2.isAbsolute(path31)) {
+    return path31;
   }
-  return sysPath2.join(cwd, path30);
+  return sysPath2.join(cwd, path31);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -5454,10 +5454,10 @@ var DirEntry = class {
 var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 var WatchHelper = class {
-  constructor(path30, follow, fsw) {
+  constructor(path31, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path30;
-    this.path = path30 = path30.replace(REPLACER_RE, "");
+    const watchPath = path31;
+    this.path = path31 = path31.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -5579,20 +5579,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path30) => {
-        const absPath = getAbsolutePath(path30, cwd);
+      paths = paths.map((path31) => {
+        const absPath = getAbsolutePath(path31, cwd);
         return absPath;
       });
     }
-    paths.forEach((path30) => {
-      this._removeIgnoredPath(path30);
+    paths.forEach((path31) => {
+      this._removeIgnoredPath(path31);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path30) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path30, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path31) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path31, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -5614,17 +5614,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path30) => {
-      if (!sysPath2.isAbsolute(path30) && !this._closers.has(path30)) {
+    paths.forEach((path31) => {
+      if (!sysPath2.isAbsolute(path31) && !this._closers.has(path31)) {
         if (cwd)
-          path30 = sysPath2.join(cwd, path30);
-        path30 = sysPath2.resolve(path30);
+          path31 = sysPath2.join(cwd, path31);
+        path31 = sysPath2.resolve(path31);
       }
-      this._closePath(path30);
-      this._addIgnoredPath(path30);
-      if (this._watched.has(path30)) {
+      this._closePath(path31);
+      this._addIgnoredPath(path31);
+      if (this._watched.has(path31)) {
         this._addIgnoredPath({
-          path: path30,
+          path: path31,
           recursive: true
         });
       }
@@ -5688,38 +5688,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, path30, stats) {
+  async _emit(event, path31, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path30 = sysPath2.normalize(path30);
+      path31 = sysPath2.normalize(path31);
     if (opts.cwd)
-      path30 = sysPath2.relative(opts.cwd, path30);
-    const args = [path30];
+      path31 = sysPath2.relative(opts.cwd, path31);
+    const args = [path31];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path30))) {
+    if (awf && (pw = this._pendingWrites.get(path31))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path30, [event, ...args]);
+        this._pendingUnlinks.set(path31, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path31) => {
+          this._pendingUnlinks.forEach((entry, path32) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path31);
+            this._pendingUnlinks.delete(path32);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path30)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path31)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path30);
+        this._pendingUnlinks.delete(path31);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -5737,16 +5737,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path30, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path31, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path30, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path31, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path30) : path30;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path31) : path31;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -5777,23 +5777,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, path30, timeout) {
+  _throttle(actionType, path31, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path30);
+    const actionPath = action.get(path31);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path30);
+      const item = action.get(path31);
       const count = item ? item.count : 0;
-      action.delete(path30);
+      action.delete(path31);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -5801,7 +5801,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path30, thr);
+    action.set(path31, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -5815,44 +5815,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path30, threshold, event, awfEmit) {
+  _awaitWriteFinish(path31, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path30;
-    if (this.options.cwd && !sysPath2.isAbsolute(path30)) {
-      fullPath = sysPath2.join(this.options.cwd, path30);
+    let fullPath = path31;
+    if (this.options.cwd && !sysPath2.isAbsolute(path31)) {
+      fullPath = sysPath2.join(this.options.cwd, path31);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path30)) {
+        if (err || !writes.has(path31)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path30).lastChange = now2;
+          writes.get(path31).lastChange = now2;
         }
-        const pw = writes.get(path30);
+        const pw = writes.get(path31);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path30);
+          writes.delete(path31);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path30)) {
-      writes.set(path30, {
+    if (!writes.has(path31)) {
+      writes.set(path31, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path30);
+          writes.delete(path31);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -5863,8 +5863,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path30, stats) {
-    if (this.options.atomic && DOT_RE.test(path30))
+  _isIgnored(path31, stats) {
+    if (this.options.atomic && DOT_RE.test(path31))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -5874,17 +5874,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path30, stats);
+    return this._userIgnored(path31, stats);
   }
-  _isntIgnored(path30, stat6) {
-    return !this._isIgnored(path30, stat6);
+  _isntIgnored(path31, stat6) {
+    return !this._isIgnored(path31, stat6);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path30) {
-    return new WatchHelper(path30, this.options.followSymlinks, this);
+  _getWatchHelpers(path31) {
+    return new WatchHelper(path31, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -5916,63 +5916,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path30 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path30);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path30) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path30, 100))
+    const path31 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path31);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path31) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path31, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path30);
+    const wp = this._getWatchedDir(path31);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path30, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path31, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path30;
+    let relPath = path31;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path30);
+      relPath = sysPath2.relative(this.options.cwd, path31);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path30);
+    this._watched.delete(path31);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path30))
-      this._emit(eventName, path30);
-    this._closePath(path30);
+    if (wasTracked && !this._isIgnored(path31))
+      this._emit(eventName, path31);
+    this._closePath(path31);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path30) {
-    this._closeFile(path30);
-    const dir = sysPath2.dirname(path30);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path30));
+  _closePath(path31) {
+    this._closeFile(path31);
+    const dir = sysPath2.dirname(path31);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path31));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path30) {
-    const closers = this._closers.get(path30);
+  _closeFile(path31) {
+    const closers = this._closers.get(path31);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path30);
+    this._closers.delete(path31);
   }
-  _addPathCloser(path30, closer) {
+  _addPathCloser(path31, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path30);
+    let list = this._closers.get(path31);
     if (!list) {
       list = [];
-      this._closers.set(path30, list);
+      this._closers.set(path31, list);
     }
     list.push(closer);
   }
@@ -6002,7 +6002,7 @@ function watch(paths, options = {}) {
 var esm_default = { watch, FSWatcher };
 
 // src/runtime/buildPlugin.ts
-import path10 from "pathe";
+import path11 from "pathe";
 
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/index.js
 init_esm_shims();
@@ -8504,12 +8504,12 @@ var PathBase = class {
   /**
    * Get the Path object referenced by the string path, resolved from this Path
    */
-  resolve(path30) {
-    if (!path30) {
+  resolve(path31) {
+    if (!path31) {
       return this;
     }
-    const rootPath = this.getRootString(path30);
-    const dir = path30.substring(rootPath.length);
+    const rootPath = this.getRootString(path31);
+    const dir = path31.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -9261,8 +9261,8 @@ var PathWin32 = class _PathWin32 extends PathBase {
   /**
    * @internal
    */
-  getRootString(path30) {
-    return win32.parse(path30).root;
+  getRootString(path31) {
+    return win32.parse(path31).root;
   }
   /**
    * @internal
@@ -9308,8 +9308,8 @@ var PathPosix = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path30) {
-    return path30.startsWith("/") ? "/" : "";
+  getRootString(path31) {
+    return path31.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -9398,11 +9398,11 @@ var PathScurryBase = class {
   /**
    * Get the depth of a provided path, string, or the cwd
    */
-  depth(path30 = this.cwd) {
-    if (typeof path30 === "string") {
-      path30 = this.cwd.resolve(path30);
+  depth(path31 = this.cwd) {
+    if (typeof path31 === "string") {
+      path31 = this.cwd.resolve(path31);
     }
-    return path30.depth();
+    return path31.depth();
   }
   /**
    * Return the cache of child entries.  Exposed so subclasses can create
@@ -9889,9 +9889,9 @@ var PathScurryBase = class {
     process10();
     return results;
   }
-  chdir(path30 = this.cwd) {
+  chdir(path31 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path30 === "string" ? this.cwd.resolve(path30) : path30;
+    this.cwd = typeof path31 === "string" ? this.cwd.resolve(path31) : path31;
     this.cwd[setAsCwd](oldCwd);
   }
 };
@@ -10253,8 +10253,8 @@ var MatchRecord = class {
   }
   // match, absolute, ifdir
   entries() {
-    return [...this.store.entries()].map(([path30, n2]) => [
-      path30,
+    return [...this.store.entries()].map(([path31, n2]) => [
+      path31,
       !!(n2 & 2),
       !!(n2 & 1)
     ]);
@@ -10459,9 +10459,9 @@ var GlobUtil = class {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path30, opts) {
+  constructor(patterns, path31, opts) {
     this.patterns = patterns;
-    this.path = path30;
+    this.path = path31;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -10480,11 +10480,11 @@ var GlobUtil = class {
       });
     }
   }
-  #ignored(path30) {
-    return this.seen.has(path30) || !!this.#ignore?.ignored?.(path30);
+  #ignored(path31) {
+    return this.seen.has(path31) || !!this.#ignore?.ignored?.(path31);
   }
-  #childrenIgnored(path30) {
-    return !!this.#ignore?.childrenIgnored?.(path30);
+  #childrenIgnored(path31) {
+    return !!this.#ignore?.childrenIgnored?.(path31);
   }
   // backpressure mechanism
   pause() {
@@ -10699,8 +10699,8 @@ var GlobUtil = class {
 };
 var GlobWalker = class extends GlobUtil {
   matches = /* @__PURE__ */ new Set();
-  constructor(patterns, path30, opts) {
-    super(patterns, path30, opts);
+  constructor(patterns, path31, opts) {
+    super(patterns, path31, opts);
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -10737,8 +10737,8 @@ var GlobWalker = class extends GlobUtil {
 };
 var GlobStream = class extends GlobUtil {
   results;
-  constructor(patterns, path30, opts) {
-    super(patterns, path30, opts);
+  constructor(patterns, path31, opts) {
+    super(patterns, path31, opts);
     this.results = new Minipass({
       signal: this.signal,
       objectMode: true
@@ -11075,44 +11075,44 @@ init_esm_shims();
 var platform_default = process.env.__TESTING_RIMRAF_PLATFORM__ || process.platform;
 
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/path-arg.js
-var pathArg = (path30, opt = {}) => {
-  const type = typeof path30;
+var pathArg = (path31, opt = {}) => {
+  const type = typeof path31;
   if (type !== "string") {
-    const ctor = path30 && type === "object" && path30.constructor;
-    const received = ctor && ctor.name ? `an instance of ${ctor.name}` : type === "object" ? inspect(path30) : `type ${type} ${path30}`;
+    const ctor = path31 && type === "object" && path31.constructor;
+    const received = ctor && ctor.name ? `an instance of ${ctor.name}` : type === "object" ? inspect(path31) : `type ${type} ${path31}`;
     const msg = `The "path" argument must be of type string. Received ${received}`;
     throw Object.assign(new TypeError(msg), {
-      path: path30,
+      path: path31,
       code: "ERR_INVALID_ARG_TYPE"
     });
   }
-  if (/\0/.test(path30)) {
+  if (/\0/.test(path31)) {
     const msg = "path must be a string without null bytes";
     throw Object.assign(new TypeError(msg), {
-      path: path30,
+      path: path31,
       code: "ERR_INVALID_ARG_VALUE"
     });
   }
-  path30 = resolve3(path30);
-  const { root } = parse2(path30);
-  if (path30 === root && opt.preserveRoot !== false) {
+  path31 = resolve3(path31);
+  const { root } = parse2(path31);
+  if (path31 === root && opt.preserveRoot !== false) {
     const msg = "refusing to remove root directory without preserveRoot:false";
     throw Object.assign(new Error(msg), {
-      path: path30,
+      path: path31,
       code: "ERR_PRESERVE_ROOT"
     });
   }
   if (platform_default === "win32") {
     const badWinChars = /[*|"<>?:]/;
-    const { root: root2 } = parse2(path30);
-    if (badWinChars.test(path30.substring(root2.length))) {
+    const { root: root2 } = parse2(path31);
+    if (badWinChars.test(path31.substring(root2.length))) {
       throw Object.assign(new Error("Illegal characters in path."), {
-        path: path30,
+        path: path31,
         code: "EINVAL"
       });
     }
   }
-  return path30;
+  return path31;
 };
 var path_arg_default = pathArg;
 
@@ -11127,16 +11127,16 @@ init_esm_shims();
 import fs6 from "fs";
 import { chmodSync, mkdirSync, renameSync, rmdirSync, rmSync, statSync, lstatSync as lstatSync2, unlinkSync } from "fs";
 import { readdirSync as rdSync } from "fs";
-var readdirSync2 = (path30) => rdSync(path30, { withFileTypes: true });
-var chmod = (path30, mode) => new Promise((res, rej) => fs6.chmod(path30, mode, (er, ...d) => er ? rej(er) : res(...d)));
-var mkdir = (path30, options) => new Promise((res, rej) => fs6.mkdir(path30, options, (er, made) => er ? rej(er) : res(made)));
-var readdir4 = (path30) => new Promise((res, rej) => fs6.readdir(path30, { withFileTypes: true }, (er, data2) => er ? rej(er) : res(data2)));
+var readdirSync2 = (path31) => rdSync(path31, { withFileTypes: true });
+var chmod = (path31, mode) => new Promise((res, rej) => fs6.chmod(path31, mode, (er, ...d) => er ? rej(er) : res(...d)));
+var mkdir = (path31, options) => new Promise((res, rej) => fs6.mkdir(path31, options, (er, made) => er ? rej(er) : res(made)));
+var readdir4 = (path31) => new Promise((res, rej) => fs6.readdir(path31, { withFileTypes: true }, (er, data2) => er ? rej(er) : res(data2)));
 var rename = (oldPath, newPath) => new Promise((res, rej) => fs6.rename(oldPath, newPath, (er, ...d) => er ? rej(er) : res(...d)));
-var rm = (path30, options) => new Promise((res, rej) => fs6.rm(path30, options, (er, ...d) => er ? rej(er) : res(...d)));
-var rmdir = (path30) => new Promise((res, rej) => fs6.rmdir(path30, (er, ...d) => er ? rej(er) : res(...d)));
-var stat4 = (path30) => new Promise((res, rej) => fs6.stat(path30, (er, data2) => er ? rej(er) : res(data2)));
-var lstat4 = (path30) => new Promise((res, rej) => fs6.lstat(path30, (er, data2) => er ? rej(er) : res(data2)));
-var unlink = (path30) => new Promise((res, rej) => fs6.unlink(path30, (er, ...d) => er ? rej(er) : res(...d)));
+var rm = (path31, options) => new Promise((res, rej) => fs6.rm(path31, options, (er, ...d) => er ? rej(er) : res(...d)));
+var rmdir = (path31) => new Promise((res, rej) => fs6.rmdir(path31, (er, ...d) => er ? rej(er) : res(...d)));
+var stat4 = (path31) => new Promise((res, rej) => fs6.stat(path31, (er, data2) => er ? rej(er) : res(data2)));
+var lstat4 = (path31) => new Promise((res, rej) => fs6.lstat(path31, (er, data2) => er ? rej(er) : res(data2)));
+var unlink = (path31) => new Promise((res, rej) => fs6.unlink(path31, (er, ...d) => er ? rej(er) : res(...d)));
 var promises = {
   chmod,
   mkdir,
@@ -11155,10 +11155,10 @@ import { parse as parse3, resolve as resolve4 } from "path";
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/readdir-or-error.js
 init_esm_shims();
 var { readdir: readdir5 } = promises;
-var readdirOrError = (path30) => readdir5(path30).catch((er) => er);
-var readdirOrErrorSync = (path30) => {
+var readdirOrError = (path31) => readdir5(path31).catch((er) => er);
+var readdirOrErrorSync = (path31) => {
   try {
-    return readdirSync2(path30);
+    return readdirSync2(path31);
   } catch (er) {
     return er;
   }
@@ -11183,35 +11183,35 @@ var ignoreENOENTSync = (fn) => {
 
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/rimraf-posix.js
 var { lstat: lstat5, rmdir: rmdir2, unlink: unlink2 } = promises;
-var rimrafPosix = async (path30, opt) => {
+var rimrafPosix = async (path31, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   try {
-    return await rimrafPosixDir(path30, opt, await lstat5(path30));
+    return await rimrafPosixDir(path31, opt, await lstat5(path31));
   } catch (er) {
     if (er?.code === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafPosixSync = (path30, opt) => {
+var rimrafPosixSync = (path31, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   try {
-    return rimrafPosixDirSync(path30, opt, lstatSync2(path30));
+    return rimrafPosixDirSync(path31, opt, lstatSync2(path31));
   } catch (er) {
     if (er?.code === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafPosixDir = async (path30, opt, ent) => {
+var rimrafPosixDir = async (path31, opt, ent) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
-  const entries = ent.isDirectory() ? await readdirOrError(path30) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path31) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -11221,30 +11221,30 @@ var rimrafPosixDir = async (path30, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path30, ent)) {
+    if (opt.filter && !await opt.filter(path31, ent)) {
       return false;
     }
-    await ignoreENOENT(unlink2(path30));
+    await ignoreENOENT(unlink2(path31));
     return true;
   }
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafPosixDir(resolve4(path30, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafPosixDir(resolve4(path31, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path30 === parse3(path30).root) {
+  if (opt.preserveRoot === false && path31 === parse3(path31).root) {
     return false;
   }
-  if (opt.filter && !await opt.filter(path30, ent)) {
+  if (opt.filter && !await opt.filter(path31, ent)) {
     return false;
   }
-  await ignoreENOENT(rmdir2(path30));
+  await ignoreENOENT(rmdir2(path31));
   return true;
 };
-var rimrafPosixDirSync = (path30, opt, ent) => {
+var rimrafPosixDirSync = (path31, opt, ent) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path30) : null;
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path31) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -11254,27 +11254,27 @@ var rimrafPosixDirSync = (path30, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path30, ent)) {
+    if (opt.filter && !opt.filter(path31, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => unlinkSync(path30));
+    ignoreENOENTSync(() => unlinkSync(path31));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
-    const p = resolve4(path30, ent2.name);
+    const p = resolve4(path31, ent2.name);
     removedAll = rimrafPosixDirSync(p, opt, ent2) && removedAll;
   }
-  if (opt.preserveRoot === false && path30 === parse3(path30).root) {
+  if (opt.preserveRoot === false && path31 === parse3(path31).root) {
     return false;
   }
   if (!removedAll) {
     return false;
   }
-  if (opt.filter && !opt.filter(path30, ent)) {
+  if (opt.filter && !opt.filter(path31, ent)) {
     return false;
   }
-  ignoreENOENTSync(() => rmdirSync(path30));
+  ignoreENOENTSync(() => rmdirSync(path31));
   return true;
 };
 
@@ -11285,9 +11285,9 @@ import { parse as parse6, resolve as resolve7 } from "path";
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/fix-eperm.js
 init_esm_shims();
 var { chmod: chmod2 } = promises;
-var fixEPERM = (fn) => async (path30) => {
+var fixEPERM = (fn) => async (path31) => {
   try {
-    return await fn(path30);
+    return await fn(path31);
   } catch (er) {
     const fer = er;
     if (fer?.code === "ENOENT") {
@@ -11295,7 +11295,7 @@ var fixEPERM = (fn) => async (path30) => {
     }
     if (fer?.code === "EPERM") {
       try {
-        await chmod2(path30, 438);
+        await chmod2(path31, 438);
       } catch (er2) {
         const fer2 = er2;
         if (fer2?.code === "ENOENT") {
@@ -11303,14 +11303,14 @@ var fixEPERM = (fn) => async (path30) => {
         }
         throw er;
       }
-      return await fn(path30);
+      return await fn(path31);
     }
     throw er;
   }
 };
-var fixEPERMSync = (fn) => (path30) => {
+var fixEPERMSync = (fn) => (path31) => {
   try {
-    return fn(path30);
+    return fn(path31);
   } catch (er) {
     const fer = er;
     if (fer?.code === "ENOENT") {
@@ -11318,7 +11318,7 @@ var fixEPERMSync = (fn) => (path30) => {
     }
     if (fer?.code === "EPERM") {
       try {
-        chmodSync(path30, 438);
+        chmodSync(path31, 438);
       } catch (er2) {
         const fer2 = er2;
         if (fer2?.code === "ENOENT") {
@@ -11326,7 +11326,7 @@ var fixEPERMSync = (fn) => (path30) => {
         }
         throw er;
       }
-      return fn(path30);
+      return fn(path31);
     }
     throw er;
   }
@@ -11339,23 +11339,23 @@ var RATE = 1.2;
 var MAXRETRIES = 10;
 var codes = /* @__PURE__ */ new Set(["EMFILE", "ENFILE", "EBUSY"]);
 var retryBusy = (fn) => {
-  const method = async (path30, opt, backoff = 1, total = 0) => {
+  const method = async (path31, opt, backoff = 1, total = 0) => {
     const mbo = opt.maxBackoff || MAXBACKOFF;
     const rate = opt.backoff || RATE;
     const max = opt.maxRetries || MAXRETRIES;
     let retries = 0;
     while (true) {
       try {
-        return await fn(path30);
+        return await fn(path31);
       } catch (er) {
         const fer = er;
-        if (fer?.path === path30 && fer?.code && codes.has(fer.code)) {
+        if (fer?.path === path31 && fer?.code && codes.has(fer.code)) {
           backoff = Math.ceil(backoff * rate);
           total = backoff + total;
           if (total < mbo) {
             return new Promise((res, rej) => {
               setTimeout(() => {
-                method(path30, opt, backoff, total).then(res, rej);
+                method(path31, opt, backoff, total).then(res, rej);
               }, backoff);
             });
           }
@@ -11371,15 +11371,15 @@ var retryBusy = (fn) => {
   return method;
 };
 var retryBusySync = (fn) => {
-  const method = (path30, opt) => {
+  const method = (path31, opt) => {
     const max = opt.maxRetries || MAXRETRIES;
     let retries = 0;
     while (true) {
       try {
-        return fn(path30);
+        return fn(path31);
       } catch (er) {
         const fer = er;
-        if (fer?.path === path30 && fer?.code && codes.has(fer.code) && retries < max) {
+        if (fer?.path === path31 && fer?.code && codes.has(fer.code) && retries < max) {
           retries++;
           continue;
         }
@@ -11399,16 +11399,16 @@ init_esm_shims();
 import { tmpdir } from "os";
 import { parse as parse4, resolve as resolve5 } from "path";
 var { stat: stat5 } = promises;
-var isDirSync = (path30) => {
+var isDirSync = (path31) => {
   try {
-    return statSync(path30).isDirectory();
+    return statSync(path31).isDirectory();
   } catch (er) {
     return false;
   }
 };
-var isDir = (path30) => stat5(path30).then((st) => st.isDirectory(), () => false);
-var win32DefaultTmp = async (path30) => {
-  const { root } = parse4(path30);
+var isDir = (path31) => stat5(path31).then((st) => st.isDirectory(), () => false);
+var win32DefaultTmp = async (path31) => {
+  const { root } = parse4(path31);
   const tmp = tmpdir();
   const { root: tmpRoot } = parse4(tmp);
   if (root.toLowerCase() === tmpRoot.toLowerCase()) {
@@ -11420,8 +11420,8 @@ var win32DefaultTmp = async (path30) => {
   }
   return root;
 };
-var win32DefaultTmpSync = (path30) => {
-  const { root } = parse4(path30);
+var win32DefaultTmpSync = (path31) => {
+  const { root } = parse4(path31);
   const tmp = tmpdir();
   const { root: tmpRoot } = parse4(tmp);
   if (root.toLowerCase() === tmpRoot.toLowerCase()) {
@@ -11440,10 +11440,10 @@ var defaultTmpSync = platform_default === "win32" ? win32DefaultTmpSync : posixD
 
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/rimraf-move-remove.js
 var { lstat: lstat6, rename: rename2, unlink: unlink3, rmdir: rmdir3, chmod: chmod3 } = promises;
-var uniqueFilename = (path30) => `.${basename3(path30)}.${Math.random()}`;
-var unlinkFixEPERM = async (path30) => unlink3(path30).catch((er) => {
+var uniqueFilename = (path31) => `.${basename3(path31)}.${Math.random()}`;
+var unlinkFixEPERM = async (path31) => unlink3(path31).catch((er) => {
   if (er.code === "EPERM") {
-    return chmod3(path30, 438).then(() => unlink3(path30), (er2) => {
+    return chmod3(path31, 438).then(() => unlink3(path31), (er2) => {
       if (er2.code === "ENOENT") {
         return;
       }
@@ -11454,13 +11454,13 @@ var unlinkFixEPERM = async (path30) => unlink3(path30).catch((er) => {
   }
   throw er;
 });
-var unlinkFixEPERMSync = (path30) => {
+var unlinkFixEPERMSync = (path31) => {
   try {
-    unlinkSync(path30);
+    unlinkSync(path31);
   } catch (er) {
     if (er?.code === "EPERM") {
       try {
-        return chmodSync(path30, 438);
+        return chmodSync(path31, 438);
       } catch (er2) {
         if (er2?.code === "ENOENT") {
           return;
@@ -11473,29 +11473,29 @@ var unlinkFixEPERMSync = (path30) => {
     throw er;
   }
 };
-var rimrafMoveRemove = async (path30, opt) => {
+var rimrafMoveRemove = async (path31, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   try {
-    return await rimrafMoveRemoveDir(path30, opt, await lstat6(path30));
+    return await rimrafMoveRemoveDir(path31, opt, await lstat6(path31));
   } catch (er) {
     if (er?.code === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafMoveRemoveDir = async (path30, opt, ent) => {
+var rimrafMoveRemoveDir = async (path31, opt, ent) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   if (!opt.tmp) {
-    return rimrafMoveRemoveDir(path30, { ...opt, tmp: await defaultTmp(path30) }, ent);
+    return rimrafMoveRemoveDir(path31, { ...opt, tmp: await defaultTmp(path31) }, ent);
   }
-  if (path30 === opt.tmp && parse5(path30).root !== path30) {
+  if (path31 === opt.tmp && parse5(path31).root !== path31) {
     throw new Error("cannot delete temp directory used for deletion");
   }
-  const entries = ent.isDirectory() ? await readdirOrError(path30) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path31) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -11505,54 +11505,54 @@ var rimrafMoveRemoveDir = async (path30, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path30, ent)) {
+    if (opt.filter && !await opt.filter(path31, ent)) {
       return false;
     }
-    await ignoreENOENT(tmpUnlink(path30, opt.tmp, unlinkFixEPERM));
+    await ignoreENOENT(tmpUnlink(path31, opt.tmp, unlinkFixEPERM));
     return true;
   }
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafMoveRemoveDir(resolve6(path30, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafMoveRemoveDir(resolve6(path31, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path30 === parse5(path30).root) {
+  if (opt.preserveRoot === false && path31 === parse5(path31).root) {
     return false;
   }
-  if (opt.filter && !await opt.filter(path30, ent)) {
+  if (opt.filter && !await opt.filter(path31, ent)) {
     return false;
   }
-  await ignoreENOENT(tmpUnlink(path30, opt.tmp, rmdir3));
+  await ignoreENOENT(tmpUnlink(path31, opt.tmp, rmdir3));
   return true;
 };
-var tmpUnlink = async (path30, tmp, rm3) => {
-  const tmpFile = resolve6(tmp, uniqueFilename(path30));
-  await rename2(path30, tmpFile);
+var tmpUnlink = async (path31, tmp, rm3) => {
+  const tmpFile = resolve6(tmp, uniqueFilename(path31));
+  await rename2(path31, tmpFile);
   return await rm3(tmpFile);
 };
-var rimrafMoveRemoveSync = (path30, opt) => {
+var rimrafMoveRemoveSync = (path31, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   try {
-    return rimrafMoveRemoveDirSync(path30, opt, lstatSync2(path30));
+    return rimrafMoveRemoveDirSync(path31, opt, lstatSync2(path31));
   } catch (er) {
     if (er?.code === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafMoveRemoveDirSync = (path30, opt, ent) => {
+var rimrafMoveRemoveDirSync = (path31, opt, ent) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   if (!opt.tmp) {
-    return rimrafMoveRemoveDirSync(path30, { ...opt, tmp: defaultTmpSync(path30) }, ent);
+    return rimrafMoveRemoveDirSync(path31, { ...opt, tmp: defaultTmpSync(path31) }, ent);
   }
   const tmp = opt.tmp;
-  if (path30 === opt.tmp && parse5(path30).root !== path30) {
+  if (path31 === opt.tmp && parse5(path31).root !== path31) {
     throw new Error("cannot delete temp directory used for deletion");
   }
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path30) : null;
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path31) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -11562,32 +11562,32 @@ var rimrafMoveRemoveDirSync = (path30, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path30, ent)) {
+    if (opt.filter && !opt.filter(path31, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => tmpUnlinkSync(path30, tmp, unlinkFixEPERMSync));
+    ignoreENOENTSync(() => tmpUnlinkSync(path31, tmp, unlinkFixEPERMSync));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
-    const p = resolve6(path30, ent2.name);
+    const p = resolve6(path31, ent2.name);
     removedAll = rimrafMoveRemoveDirSync(p, opt, ent2) && removedAll;
   }
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path30 === parse5(path30).root) {
+  if (opt.preserveRoot === false && path31 === parse5(path31).root) {
     return false;
   }
-  if (opt.filter && !opt.filter(path30, ent)) {
+  if (opt.filter && !opt.filter(path31, ent)) {
     return false;
   }
-  ignoreENOENTSync(() => tmpUnlinkSync(path30, tmp, rmdirSync));
+  ignoreENOENTSync(() => tmpUnlinkSync(path31, tmp, rmdirSync));
   return true;
 };
-var tmpUnlinkSync = (path30, tmp, rmSync2) => {
-  const tmpFile = resolve6(tmp, uniqueFilename(path30));
-  renameSync(path30, tmpFile);
+var tmpUnlinkSync = (path31, tmp, rmSync2) => {
+  const tmpFile = resolve6(tmp, uniqueFilename(path31));
+  renameSync(path31, tmpFile);
   return rmSync2(tmpFile);
 };
 
@@ -11597,31 +11597,31 @@ var rimrafWindowsFile = retryBusy(fixEPERM(unlink4));
 var rimrafWindowsFileSync = retryBusySync(fixEPERMSync(unlinkSync));
 var rimrafWindowsDirRetry = retryBusy(fixEPERM(rmdir4));
 var rimrafWindowsDirRetrySync = retryBusySync(fixEPERMSync(rmdirSync));
-var rimrafWindowsDirMoveRemoveFallback = async (path30, opt) => {
+var rimrafWindowsDirMoveRemoveFallback = async (path31, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   const { filter: filter3, ...options } = opt;
   try {
-    return await rimrafWindowsDirRetry(path30, options);
+    return await rimrafWindowsDirRetry(path31, options);
   } catch (er) {
     if (er?.code === "ENOTEMPTY") {
-      return await rimrafMoveRemove(path30, options);
+      return await rimrafMoveRemove(path31, options);
     }
     throw er;
   }
 };
-var rimrafWindowsDirMoveRemoveFallbackSync = (path30, opt) => {
+var rimrafWindowsDirMoveRemoveFallbackSync = (path31, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   const { filter: filter3, ...options } = opt;
   try {
-    return rimrafWindowsDirRetrySync(path30, options);
+    return rimrafWindowsDirRetrySync(path31, options);
   } catch (er) {
     const fer = er;
     if (fer?.code === "ENOTEMPTY") {
-      return rimrafMoveRemoveSync(path30, options);
+      return rimrafMoveRemoveSync(path31, options);
     }
     throw er;
   }
@@ -11629,35 +11629,35 @@ var rimrafWindowsDirMoveRemoveFallbackSync = (path30, opt) => {
 var START = Symbol("start");
 var CHILD = Symbol("child");
 var FINISH = Symbol("finish");
-var rimrafWindows = async (path30, opt) => {
+var rimrafWindows = async (path31, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   try {
-    return await rimrafWindowsDir(path30, opt, await lstat7(path30), START);
+    return await rimrafWindowsDir(path31, opt, await lstat7(path31), START);
   } catch (er) {
     if (er?.code === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafWindowsSync = (path30, opt) => {
+var rimrafWindowsSync = (path31, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   try {
-    return rimrafWindowsDirSync(path30, opt, lstatSync2(path30), START);
+    return rimrafWindowsDirSync(path31, opt, lstatSync2(path31), START);
   } catch (er) {
     if (er?.code === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafWindowsDir = async (path30, opt, ent, state = START) => {
+var rimrafWindowsDir = async (path31, opt, ent, state = START) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
-  const entries = ent.isDirectory() ? await readdirOrError(path30) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path31) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -11667,32 +11667,32 @@ var rimrafWindowsDir = async (path30, opt, ent, state = START) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path30, ent)) {
+    if (opt.filter && !await opt.filter(path31, ent)) {
       return false;
     }
-    await ignoreENOENT(rimrafWindowsFile(path30, opt));
+    await ignoreENOENT(rimrafWindowsFile(path31, opt));
     return true;
   }
   const s = state === START ? CHILD : state;
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafWindowsDir(resolve7(path30, ent2.name), opt, ent2, s)))).reduce((a, b) => a && b, true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafWindowsDir(resolve7(path31, ent2.name), opt, ent2, s)))).reduce((a, b) => a && b, true);
   if (state === START) {
-    return rimrafWindowsDir(path30, opt, ent, FINISH);
+    return rimrafWindowsDir(path31, opt, ent, FINISH);
   } else if (state === FINISH) {
-    if (opt.preserveRoot === false && path30 === parse6(path30).root) {
+    if (opt.preserveRoot === false && path31 === parse6(path31).root) {
       return false;
     }
     if (!removedAll) {
       return false;
     }
-    if (opt.filter && !await opt.filter(path30, ent)) {
+    if (opt.filter && !await opt.filter(path31, ent)) {
       return false;
     }
-    await ignoreENOENT(rimrafWindowsDirMoveRemoveFallback(path30, opt));
+    await ignoreENOENT(rimrafWindowsDirMoveRemoveFallback(path31, opt));
   }
   return true;
 };
-var rimrafWindowsDirSync = (path30, opt, ent, state = START) => {
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path30) : null;
+var rimrafWindowsDirSync = (path31, opt, ent, state = START) => {
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path31) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -11702,32 +11702,32 @@ var rimrafWindowsDirSync = (path30, opt, ent, state = START) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path30, ent)) {
+    if (opt.filter && !opt.filter(path31, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => rimrafWindowsFileSync(path30, opt));
+    ignoreENOENTSync(() => rimrafWindowsFileSync(path31, opt));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
     const s = state === START ? CHILD : state;
-    const p = resolve7(path30, ent2.name);
+    const p = resolve7(path31, ent2.name);
     removedAll = rimrafWindowsDirSync(p, opt, ent2, s) && removedAll;
   }
   if (state === START) {
-    return rimrafWindowsDirSync(path30, opt, ent, FINISH);
+    return rimrafWindowsDirSync(path31, opt, ent, FINISH);
   } else if (state === FINISH) {
-    if (opt.preserveRoot === false && path30 === parse6(path30).root) {
+    if (opt.preserveRoot === false && path31 === parse6(path31).root) {
       return false;
     }
     if (!removedAll) {
       return false;
     }
-    if (opt.filter && !opt.filter(path30, ent)) {
+    if (opt.filter && !opt.filter(path31, ent)) {
       return false;
     }
     ignoreENOENTSync(() => {
-      rimrafWindowsDirMoveRemoveFallbackSync(path30, opt);
+      rimrafWindowsDirMoveRemoveFallbackSync(path31, opt);
     });
   }
   return true;
@@ -11740,16 +11740,16 @@ var rimrafManualSync = platform_default === "win32" ? rimrafWindowsSync : rimraf
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/rimraf-native.js
 init_esm_shims();
 var { rm: rm2 } = promises;
-var rimrafNative = async (path30, opt) => {
-  await rm2(path30, {
+var rimrafNative = async (path31, opt) => {
+  await rm2(path31, {
     ...opt,
     force: true,
     recursive: true
   });
   return true;
 };
-var rimrafNativeSync = (path30, opt) => {
-  rmSync(path30, {
+var rimrafNativeSync = (path31, opt) => {
+  rmSync(path31, {
     ...opt,
     force: true,
     recursive: true
@@ -11767,26 +11767,26 @@ var useNative = !hasNative || platform_default === "win32" ? () => false : (opt)
 var useNativeSync = !hasNative || platform_default === "win32" ? () => false : (opt) => !opt?.signal && !opt?.filter;
 
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/index.js
-var wrap = (fn) => async (path30, opt) => {
+var wrap = (fn) => async (path31, opt) => {
   const options = optArg(opt);
   if (options.glob) {
-    path30 = await glob(path30, options.glob);
+    path31 = await glob(path31, options.glob);
   }
-  if (Array.isArray(path30)) {
-    return !!(await Promise.all(path30.map((p) => fn(path_arg_default(p, options), options)))).reduce((a, b) => a && b, true);
+  if (Array.isArray(path31)) {
+    return !!(await Promise.all(path31.map((p) => fn(path_arg_default(p, options), options)))).reduce((a, b) => a && b, true);
   } else {
-    return !!await fn(path_arg_default(path30, options), options);
+    return !!await fn(path_arg_default(path31, options), options);
   }
 };
-var wrapSync = (fn) => (path30, opt) => {
+var wrapSync = (fn) => (path31, opt) => {
   const options = optArgSync(opt);
   if (options.glob) {
-    path30 = globSync(path30, options.glob);
+    path31 = globSync(path31, options.glob);
   }
-  if (Array.isArray(path30)) {
-    return !!path30.map((p) => fn(path_arg_default(p, options), options)).reduce((a, b) => a && b, true);
+  if (Array.isArray(path31)) {
+    return !!path31.map((p) => fn(path_arg_default(p, options), options)).reduce((a, b) => a && b, true);
   } else {
-    return !!fn(path_arg_default(path30, options), options);
+    return !!fn(path_arg_default(path31, options), options);
   }
 };
 var nativeSync = wrapSync(rimrafNativeSync);
@@ -11801,8 +11801,8 @@ var moveRemoveSync = wrapSync(rimrafMoveRemoveSync);
 var moveRemove = Object.assign(wrap(rimrafMoveRemove), {
   sync: moveRemoveSync
 });
-var rimrafSync = wrapSync((path30, opt) => useNativeSync(opt) ? rimrafNativeSync(path30, opt) : rimrafManualSync(path30, opt));
-var rimraf_ = wrap((path30, opt) => useNative(opt) ? rimrafNative(path30, opt) : rimrafManual(path30, opt));
+var rimrafSync = wrapSync((path31, opt) => useNativeSync(opt) ? rimrafNativeSync(path31, opt) : rimrafManualSync(path31, opt));
+var rimraf_ = wrap((path31, opt) => useNative(opt) ? rimrafNative(path31, opt) : rimrafManual(path31, opt));
 var rimraf = Object.assign(rimraf_, {
   rimraf: rimraf_,
   sync: rimrafSync,
@@ -11822,10 +11822,258 @@ rimraf.rimraf = rimraf;
 
 // src/runtime/buildPlugin.ts
 import { build } from "vite";
-var REG_NODE_MODULES_DIR = /[\\/]node_modules[\\/]/gi;
+
+// src/runtime/advancedChunks.ts
+init_esm_shims();
+
+// src/runtime/chunkStrategy.ts
+init_esm_shims();
+import { posix as path10 } from "pathe";
+var SHARED_CHUNK_VIRTUAL_PREFIX = "__weapp_shared__";
+var SUB_PACKAGE_SHARED_DIR = "__shared__";
+var DEFAULT_SHARED_CHUNK_STRATEGY = "duplicate";
+function resolveSharedChunkName(options) {
+  const {
+    id,
+    ctx,
+    relativeAbsoluteSrcRoot,
+    subPackageRoots,
+    strategy
+  } = options;
+  const moduleInfo = ctx.getModuleInfo(id);
+  if (!moduleInfo?.importers || moduleInfo.importers.length <= 1) {
+    return void 0;
+  }
+  const summary = summarizeImportPrefixes({
+    importers: moduleInfo.importers,
+    relativeAbsoluteSrcRoot,
+    subPackageRoots: Array.from(subPackageRoots)
+  });
+  const keys = Object.keys(summary);
+  if (keys.length === 0) {
+    return void 0;
+  }
+  if (keys.length === 1) {
+    const prefix = keys[0];
+    return prefix ? path10.join(prefix, "common") : "common";
+  }
+  const hasMainImporter = keys.includes("");
+  if (strategy === "duplicate" && !hasMainImporter) {
+    const combination = keys.filter(Boolean).sort().join("+");
+    const combinationSegment = combination ? `${combination}/` : "";
+    return `${SHARED_CHUNK_VIRTUAL_PREFIX}/${combinationSegment}common`;
+  }
+  return "common";
+}
+function summarizeImportPrefixes(options) {
+  const { importers, relativeAbsoluteSrcRoot, subPackageRoots } = options;
+  const summary = {};
+  for (const importer of importers) {
+    const relPath = relativeAbsoluteSrcRoot(importer);
+    const prefix = resolveSubPackagePrefix(relPath, subPackageRoots);
+    summary[prefix] = (summary[prefix] || 0) + 1;
+  }
+  return summary;
+}
+function resolveSubPackagePrefix(fileName, subPackageRoots) {
+  for (const root of subPackageRoots) {
+    if (!root) {
+      continue;
+    }
+    if (fileName === root || fileName.startsWith(`${root}/`)) {
+      return root;
+    }
+  }
+  return "";
+}
+function applySharedChunkStrategy(bundle, options) {
+  if (options.strategy !== "duplicate") {
+    return;
+  }
+  if (!this) {
+    throw new Error("applySharedChunkStrategy requires plugin context");
+  }
+  const subPackageRoots = Array.from(options.subPackageRoots).filter(Boolean);
+  const entries = Object.entries(bundle);
+  for (const [fileName, output] of entries) {
+    if (!isSharedVirtualChunk(fileName, output)) {
+      continue;
+    }
+    const chunk = output;
+    const originalCode = chunk.code;
+    const originalMap = chunk.map;
+    const importers = findChunkImporters(bundle, fileName);
+    if (importers.length === 0) {
+      continue;
+    }
+    const importerMap = /* @__PURE__ */ new Map();
+    let hasMainImporter = false;
+    for (const importerFile of importers) {
+      const root = resolveSubPackagePrefix(importerFile, subPackageRoots);
+      if (!root) {
+        hasMainImporter = true;
+        break;
+      }
+      const duplicateBaseName = path10.basename(fileName);
+      const intendedFileName = path10.join(root, SUB_PACKAGE_SHARED_DIR, duplicateBaseName);
+      const uniqueFileName = ensureUniqueFileName(bundle, intendedFileName);
+      const existing = importerMap.get(root);
+      if (existing) {
+        existing.importers.push(importerFile);
+      } else {
+        importerMap.set(root, {
+          newFileName: uniqueFileName,
+          importers: [importerFile]
+        });
+      }
+    }
+    if (hasMainImporter || importerMap.size === 0) {
+      if (fileName.startsWith(`${SHARED_CHUNK_VIRTUAL_PREFIX}/`)) {
+        const newFileName = fileName.slice(SHARED_CHUNK_VIRTUAL_PREFIX.length + 1);
+        chunk.fileName = newFileName;
+      }
+      continue;
+    }
+    const importerToChunk = /* @__PURE__ */ new Map();
+    for (const { newFileName, importers: importerFiles } of importerMap.values()) {
+      this.emitFile({
+        type: "asset",
+        fileName: newFileName,
+        source: originalCode
+      });
+      if (originalMap) {
+        this.emitFile({
+          type: "asset",
+          fileName: `${newFileName}.map`,
+          source: typeof originalMap === "string" ? originalMap : JSON.stringify(originalMap)
+        });
+      }
+      for (const importerFile of importerFiles) {
+        importerToChunk.set(importerFile, newFileName);
+      }
+    }
+    updateImporters(bundle, importerToChunk, fileName);
+    chunk.code = "// duplicated into sub-packages via weapp-vite chunk strategy\n";
+    chunk.map = null;
+    chunk.sourcemapFileName = null;
+    chunk.imports = [];
+    chunk.dynamicImports = [];
+    chunk.exports = [];
+    chunk.moduleIds = [];
+    chunk.modules = {};
+  }
+}
+function isSharedVirtualChunk(fileName, output) {
+  return output?.type === "chunk" && fileName.startsWith(`${SHARED_CHUNK_VIRTUAL_PREFIX}/`);
+}
+function findChunkImporters(bundle, target) {
+  const importers = /* @__PURE__ */ new Set();
+  for (const [fileName, output] of Object.entries(bundle)) {
+    if (output?.type !== "chunk") {
+      continue;
+    }
+    const chunk = output;
+    if (chunk.imports.includes(target) || chunk.dynamicImports.includes(target)) {
+      importers.add(fileName);
+    }
+  }
+  return Array.from(importers);
+}
+function ensureUniqueFileName(bundle, fileName) {
+  if (!bundle[fileName]) {
+    return fileName;
+  }
+  const { dir, name, ext: ext2 } = path10.parse(fileName);
+  let index = 1;
+  let candidate = fileName;
+  while (bundle[candidate]) {
+    const nextName = `${name}.${index}`;
+    candidate = dir ? path10.join(dir, `${nextName}${ext2}`) : `${nextName}${ext2}`;
+    index++;
+  }
+  return candidate;
+}
+function updateImporters(bundle, importerToChunk, originalFileName) {
+  for (const [importerFile, newChunkFile] of importerToChunk.entries()) {
+    const importer = bundle[importerFile];
+    if (!importer || importer.type !== "chunk") {
+      continue;
+    }
+    const importerChunk = importer;
+    const originalImportPath = createRelativeImport(importerFile, originalFileName);
+    const newImportPath = createRelativeImport(importerFile, newChunkFile);
+    if (originalImportPath !== newImportPath) {
+      importerChunk.code = replaceAll(importerChunk.code, originalImportPath, newImportPath);
+    }
+    importerChunk.imports = replaceInArray(importerChunk.imports, originalFileName, newChunkFile);
+    importerChunk.dynamicImports = replaceInArray(importerChunk.dynamicImports, originalFileName, newChunkFile);
+  }
+}
+function replaceAll(source, searchValue, replaceValue) {
+  if (!searchValue) {
+    return source;
+  }
+  if (source.includes(searchValue)) {
+    return source.split(searchValue).join(replaceValue);
+  }
+  if (searchValue.startsWith("./") && replaceValue.startsWith("./")) {
+    const trimmedSearch = searchValue.slice(2);
+    const trimmedReplace = replaceValue.slice(2);
+    if (trimmedSearch && source.includes(trimmedSearch)) {
+      return source.split(trimmedSearch).join(trimmedReplace);
+    }
+  }
+  return source;
+}
+function replaceInArray(list, searchValue, replaceValue) {
+  return list.map((value) => {
+    return value === searchValue ? replaceValue : value;
+  });
+}
+function createRelativeImport(fromFile, toFile) {
+  const relative3 = path10.relative(path10.dirname(fromFile), toFile);
+  if (!relative3 || relative3.startsWith(".")) {
+    return relative3 || "./";
+  }
+  return `./${relative3}`;
+}
+
+// src/runtime/advancedChunks.ts
 function testByReg2DExpList(reg2DExpList) {
-  return (id) => reg2DExpList.some((regExpList) => regExpList.some((regExp) => regExp.test(id)));
+  return (id) => reg2DExpList.some((regExpList) => regExpList.some((regExp) => {
+    regExp.lastIndex = 0;
+    return regExp.test(id);
+  }));
 }
+function createAdvancedChunkNameResolver(options) {
+  const {
+    relativeAbsoluteSrcRoot,
+    getSubPackageRoots,
+    strategy,
+    vendorsMatchers
+  } = options;
+  const isVendor = testByReg2DExpList(vendorsMatchers);
+  return (id, ctx) => {
+    const subPackageRoots = Array.from(getSubPackageRoots());
+    const sharedName = resolveSharedChunkName({
+      id,
+      ctx,
+      relativeAbsoluteSrcRoot,
+      subPackageRoots,
+      strategy
+    });
+    if (!isVendor(id)) {
+      return sharedName;
+    }
+    if (strategy === "hoist") {
+      return "vendors";
+    }
+    return sharedName;
+  };
+}
+
+// src/runtime/buildPlugin.ts
+var REG_NODE_MODULES_DIR = /[\\/]node_modules[\\/]/gi;
 function createBuildService(ctx) {
   function assertRuntimeServices(target) {
     if (!target.configService || !target.watcherService || !target.npmService || !target.scanService) {
@@ -11863,6 +12111,13 @@ function createBuildService(ctx) {
   function sharedBuildConfig() {
     const nodeModulesDeps = [REG_NODE_MODULES_DIR];
     const commonjsHelpersDeps = [/commonjsHelpers\.js$/];
+    const sharedStrategy = configService.weappViteConfig?.chunks?.sharedStrategy ?? DEFAULT_SHARED_CHUNK_STRATEGY;
+    const resolveAdvancedChunkName = createAdvancedChunkNameResolver({
+      vendorsMatchers: [nodeModulesDeps, commonjsHelpersDeps],
+      relativeAbsoluteSrcRoot: configService.relativeAbsoluteSrcRoot,
+      getSubPackageRoots: () => scanService.subPackageMap.keys(),
+      strategy: sharedStrategy
+    });
     return {
       build: {
         rolldownOptions: {
@@ -11870,28 +12125,7 @@ function createBuildService(ctx) {
             advancedChunks: {
               groups: [
                 {
-                  name: (id, ctxPlugin) => {
-                    REG_NODE_MODULES_DIR.lastIndex = 0;
-                    if (testByReg2DExpList([nodeModulesDeps, commonjsHelpersDeps])(id)) {
-                      return "vendors";
-                    }
-                    const moduleInfo = ctxPlugin.getModuleInfo(id);
-                    if (moduleInfo?.importers?.length && moduleInfo.importers.length > 1) {
-                      const summary = moduleInfo.importers.reduce((acc, cur) => {
-                        const relPath = configService.relativeAbsoluteSrcRoot(cur);
-                        const prefix2 = [
-                          ...scanService.subPackageMap.keys()
-                        ].find(
-                          (x) => relPath.startsWith(x)
-                        ) ?? "";
-                        acc[prefix2] = (acc[prefix2] || 0) + 1;
-                        return acc;
-                      }, {});
-                      const summaryKeys = Object.keys(summary);
-                      const prefix = summaryKeys.length === 1 ? summaryKeys[0] : "";
-                      return path10.join(prefix, "common");
-                    }
-                  }
+                  name: (id, ctxPlugin) => resolveAdvancedChunkName(id, ctxPlugin)
                 }
               ]
             },
@@ -11915,7 +12149,7 @@ function createBuildService(ctx) {
     if (hasWorkersDir && workersDir) {
       devWorkers(workersDir);
       if (!isTestEnv) {
-        const absWorkerRoot = path10.resolve(configService.absoluteSrcRoot, workersDir);
+        const absWorkerRoot = path11.resolve(configService.absoluteSrcRoot, workersDir);
         const watcher2 = esm_default.watch(
           absWorkerRoot,
           {
@@ -11973,8 +12207,8 @@ function createBuildService(ctx) {
     if (configService.mpDistRoot) {
       const deletedFilePaths = await rimraf(
         [
-          path10.resolve(configService.outDir, "*"),
-          path10.resolve(configService.outDir, ".*")
+          path11.resolve(configService.outDir, "*"),
+          path11.resolve(configService.outDir, ".*")
         ],
         {
           glob: true,
@@ -12045,7 +12279,7 @@ import fs17 from "fs-extra";
 init_esm_shims();
 import fs8 from "fs";
 import { createRequire as createRequire2 } from "module";
-import path12, { dirname as dirname4, join as join3, win32 as win322 } from "path";
+import path13, { dirname as dirname4, join as join3, win32 as win322 } from "path";
 import process4 from "process";
 import fsPromises from "fs/promises";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -17685,17 +17919,17 @@ function withTrailingSlash(input = "", respectQueryAndFragment) {
   if (hasTrailingSlash(input, true)) {
     return input || "/";
   }
-  let path30 = input;
+  let path31 = input;
   let fragment = "";
   const fragmentIndex = input.indexOf("#");
   if (fragmentIndex !== -1) {
-    path30 = input.slice(0, fragmentIndex);
+    path31 = input.slice(0, fragmentIndex);
     fragment = input.slice(fragmentIndex);
-    if (!path30) {
+    if (!path31) {
       return fragment;
     }
   }
-  const [s0, ...s] = path30.split("?");
+  const [s0, ...s] = path31.split("?");
   return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
 }
 function isNonEmptyURL(url) {
@@ -17720,12 +17954,12 @@ import { normalize as normalize3, isAbsolute as isAbsolute2, extname as extname$
 import { fileURLToPath as fileURLToPath$1, URL as URL$1, pathToFileURL as pathToFileURL$1 } from "url";
 import assert from "assert";
 import process$1 from "process";
-import path11, { dirname as dirname3 } from "path";
+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(path30) {
-  return path30.replace(/\\/g, "/");
+function normalizeSlash(path31) {
+  return path31.replace(/\\/g, "/");
 }
 var own$1 = {}.hasOwnProperty;
 var classRegExp = /^([A-Z][a-z\d]*)+$/;
@@ -17838,8 +18072,8 @@ codes2.ERR_INVALID_PACKAGE_CONFIG = createError(
    * @param {string} [base]
    * @param {string} [message]
    */
-  (path30, base, message) => {
-    return `Invalid package config ${path30}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+  (path31, base, message) => {
+    return `Invalid package config ${path31}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
   },
   Error
 );
@@ -17871,8 +18105,8 @@ codes2.ERR_MODULE_NOT_FOUND = createError(
    * @param {string} base
    * @param {boolean} [exactUrl]
    */
-  (path30, base, exactUrl = false) => {
-    return `Cannot find ${exactUrl ? "module" : "package"} '${path30}' imported from ${base}`;
+  (path31, base, exactUrl = false) => {
+    return `Cannot find ${exactUrl ? "module" : "package"} '${path31}' imported from ${base}`;
   },
   Error
 );
@@ -17923,8 +18157,8 @@ codes2.ERR_UNKNOWN_FILE_EXTENSION = createError(
    * @param {string} extension
    * @param {string} path
    */
-  (extension, path30) => {
-    return `Unknown file extension "${extension}" for ${path30}`;
+  (extension, path31) => {
+    return `Unknown file extension "${extension}" for ${path31}`;
   },
   TypeError
 );
@@ -18069,7 +18303,7 @@ function read(jsonPath, { base, specifier }) {
   }
   let string;
   try {
-    string = fs7.readFileSync(path11.toNamespacedPath(jsonPath), "utf8");
+    string = fs7.readFileSync(path12.toNamespacedPath(jsonPath), "utf8");
   } catch (error) {
     const exception = (
       /** @type {ErrnoException} */
@@ -18284,7 +18518,7 @@ Default "index" lookups for the main are deprecated for ES modules.`,
       "DeprecationWarning",
       "DEP0151"
     );
-  } else if (path11.resolve(packagePath, main) !== urlPath) {
+  } else if (path12.resolve(packagePath, main) !== urlPath) {
     process$1.emitWarning(
       `Package ${packagePath} has a "main" field set to "${main}", excluding the full filename and extension to the resolved file at "${urlPath.slice(
         packagePath.length
@@ -18295,9 +18529,9 @@ Default "index" lookups for the main are deprecated for ES modules.`,
     );
   }
 }
-function tryStatSync(path30) {
+function tryStatSync(path31) {
   try {
-    return statSync2(path30);
+    return statSync2(path31);
   } catch {
   }
 }
@@ -18391,7 +18625,7 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
   {
     const real = realpathSync2(filePath);
     const { search, hash } = resolved;
-    resolved = pathToFileURL$1(real + (filePath.endsWith(path11.sep) ? "/" : ""));
+    resolved = pathToFileURL$1(real + (filePath.endsWith(path12.sep) ? "/" : ""));
     resolved.search = search;
     resolved.hash = hash;
   }
@@ -19173,12 +19407,12 @@ async function findUp$1(name, {
   type = "file",
   stopAt
 } = {}) {
-  let directory = path12.resolve(toPath(cwd) ?? "");
-  const { root } = path12.parse(directory);
-  stopAt = path12.resolve(directory, toPath(stopAt ?? root));
-  const isAbsoluteName = path12.isAbsolute(name);
+  let directory = path13.resolve(toPath(cwd) ?? "");
+  const { root } = path13.parse(directory);
+  stopAt = path13.resolve(directory, toPath(stopAt ?? root));
+  const isAbsoluteName = path13.isAbsolute(name);
   while (directory) {
-    const filePath = isAbsoluteName ? name : path12.join(directory, name);
+    const filePath = isAbsoluteName ? name : path13.join(directory, name);
     try {
       const stats = await fsPromises.stat(filePath);
       if (type === "file" && stats.isFile() || type === "directory" && stats.isDirectory()) {
@@ -19189,7 +19423,7 @@ async function findUp$1(name, {
     if (directory === stopAt || directory === root) {
       break;
     }
-    directory = path12.dirname(directory);
+    directory = path13.dirname(directory);
   }
 }
 function findUpSync(name, {
@@ -19197,12 +19431,12 @@ function findUpSync(name, {
   type = "file",
   stopAt
 } = {}) {
-  let directory = path12.resolve(toPath(cwd) ?? "");
-  const { root } = path12.parse(directory);
-  stopAt = path12.resolve(directory, toPath(stopAt) ?? root);
-  const isAbsoluteName = path12.isAbsolute(name);
+  let directory = path13.resolve(toPath(cwd) ?? "");
+  const { root } = path13.parse(directory);
+  stopAt = path13.resolve(directory, toPath(stopAt) ?? root);
+  const isAbsoluteName = path13.isAbsolute(name);
   while (directory) {
-    const filePath = isAbsoluteName ? name : path12.join(directory, name);
+    const filePath = isAbsoluteName ? name : path13.join(directory, name);
     try {
       const stats = fs8.statSync(filePath, { throwIfNoEntry: false });
       if (type === "file" && stats?.isFile() || type === "directory" && stats?.isDirectory()) {
@@ -19213,10 +19447,10 @@ function findUpSync(name, {
     if (directory === stopAt || directory === root) {
       break;
     }
-    directory = path12.dirname(directory);
+    directory = path13.dirname(directory);
   }
 }
-function _resolve2(path30, options = {}) {
+function _resolve2(path31, options = {}) {
   if (options.platform === "auto" || !options.platform)
     options.platform = process4.platform === "win32" ? "win32" : "posix";
   if (process4.versions.pnp) {
@@ -19225,11 +19459,11 @@ function _resolve2(path30, options = {}) {
       paths.push(process4.cwd());
     const targetRequire = createRequire2(import.meta.url);
     try {
-      return targetRequire.resolve(path30, { paths });
+      return targetRequire.resolve(path31, { paths });
     } catch {
     }
   }
-  const modulePath = resolvePathSync(path30, {
+  const modulePath = resolvePathSync(path31, {
     url: options.paths
   });
   if (options.platform === "win32")
@@ -19300,10 +19534,10 @@ var findUp = quansync2({
   async: findUp$1
 });
 var loadPackageJSON = quansync2(function* (cwd = process4.cwd()) {
-  const path30 = yield findUp("package.json", { cwd });
-  if (!path30 || !fs8.existsSync(path30))
+  const path31 = yield findUp("package.json", { cwd });
+  if (!path31 || !fs8.existsSync(path31))
     return null;
-  return JSON.parse(yield readFile(path30));
+  return JSON.parse(yield readFile(path31));
 });
 var loadPackageJSONSync = loadPackageJSON.sync;
 var isPackageListed = quansync2(function* (name, cwd) {
@@ -19312,13 +19546,13 @@ var isPackageListed = quansync2(function* (name, cwd) {
 });
 var isPackageListedSync = isPackageListed.sync;
 
-// ../../node_modules/.pnpm/package-manager-detector@1.4.1/node_modules/package-manager-detector/dist/detect.mjs
+// ../../node_modules/.pnpm/package-manager-detector@1.5.0/node_modules/package-manager-detector/dist/detect.mjs
 init_esm_shims();
 import fs9 from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 import process5 from "process";
 
-// ../../node_modules/.pnpm/package-manager-detector@1.4.1/node_modules/package-manager-detector/dist/constants.mjs
+// ../../node_modules/.pnpm/package-manager-detector@1.5.0/node_modules/package-manager-detector/dist/constants.mjs
 init_esm_shims();
 var AGENTS = [
   "npm",
@@ -19355,7 +19589,7 @@ var INSTALL_METADATA = {
   "bun.lockb": "bun"
 };
 
-// ../../node_modules/.pnpm/package-manager-detector@1.4.1/node_modules/package-manager-detector/dist/detect.mjs
+// ../../node_modules/.pnpm/package-manager-detector@1.5.0/node_modules/package-manager-detector/dist/detect.mjs
 async function pathExists(path210, type) {
   try {
     const stat6 = await fs9.stat(path210);
@@ -19365,11 +19599,11 @@ async function pathExists(path210, type) {
   }
 }
 function* lookup(cwd = process5.cwd()) {
-  let directory = path13.resolve(cwd);
-  const { root } = path13.parse(directory);
+  let directory = path14.resolve(cwd);
+  const { root } = path14.parse(directory);
   while (directory && directory !== root) {
     yield directory;
-    directory = path13.dirname(directory);
+    directory = path14.dirname(directory);
   }
 }
 async function parsePackageJson(filepath, onUnknown) {
@@ -19383,7 +19617,7 @@ async function detect(options = {}) {
   } = options;
   let stopDir;
   if (typeof options.stopDir === "string") {
-    const resolved = path13.resolve(options.stopDir);
+    const resolved = path14.resolve(options.stopDir);
     stopDir = (dir) => dir === resolved;
   } else {
     stopDir = options.stopDir;
@@ -19393,9 +19627,9 @@ async function detect(options = {}) {
       switch (strategy) {
         case "lockfile": {
           for (const lock of Object.keys(LOCKS)) {
-            if (await pathExists(path13.join(directory, lock), "file")) {
+            if (await pathExists(path14.join(directory, lock), "file")) {
               const name = LOCKS[lock];
-              const result = await parsePackageJson(path13.join(directory, "package.json"), onUnknown);
+              const result = await parsePackageJson(path14.join(directory, "package.json"), onUnknown);
               if (result)
                 return result;
               else
@@ -19406,7 +19640,7 @@ async function detect(options = {}) {
         }
         case "packageManager-field":
         case "devEngines-field": {
-          const result = await parsePackageJson(path13.join(directory, "package.json"), onUnknown);
+          const result = await parsePackageJson(path14.join(directory, "package.json"), onUnknown);
           if (result)
             return result;
           break;
@@ -19414,7 +19648,7 @@ async function detect(options = {}) {
         case "install-metadata": {
           for (const metadata of Object.keys(INSTALL_METADATA)) {
             const fileOrDir = metadata.endsWith("/") ? "dir" : "file";
-            if (await pathExists(path13.join(directory, metadata), fileOrDir)) {
+            if (await pathExists(path14.join(directory, metadata), fileOrDir)) {
               const name = INSTALL_METADATA[metadata];
               const agent = name === "yarn" ? isMetadataYarnClassic(metadata) ? "yarn" : "yarn@berry" : name;
               return { name, agent };
@@ -19475,7 +19709,7 @@ function isMetadataYarnClassic(metadataPath) {
 }
 
 // src/runtime/configPlugin.ts
-import path26 from "pathe";
+import path27 from "pathe";
 import { loadConfigFromFile } from "vite";
 import tsconfigPaths from "vite-tsconfig-paths";
 
@@ -19510,6 +19744,9 @@ function getWeappViteConfig() {
     npm: {
       enable: true,
       cache: true
+    },
+    chunks: {
+      sharedStrategy: "duplicate"
     }
   };
 }
@@ -19542,7 +19779,7 @@ import { wrapPlugin } from "vite-plugin-performance";
 init_esm_shims();
 import { fdir as Fdir } from "fdir";
 import fs10 from "fs-extra";
-import path14 from "pathe";
+import path15 from "pathe";
 function asset(ctx) {
   const state = { ctx };
   return [createAssetCollector(state)];
@@ -19585,7 +19822,7 @@ function scanAssetFiles(configService, config) {
   const filter3 = weappViteConfig?.copy?.filter ?? (() => true);
   const ignore = [
     ...defaultExcluded,
-    path14.resolve(configService.cwd, `${config.build.outDir}/**/*`),
+    path15.resolve(configService.cwd, `${config.build.outDir}/**/*`),
     ...exclude
   ];
   const fdir = new Fdir({
@@ -19617,7 +19854,7 @@ function normalizeCopyGlobs(globs) {
 // src/plugins/autoImport.ts
 init_esm_shims();
 import { fdir as Fdir2 } from "fdir";
-import path15 from "pathe";
+import path16 from "pathe";
 function normalizeChangedPath(id) {
   if (!id || id.startsWith("\0")) {
     return void 0;
@@ -19630,14 +19867,14 @@ function resolveAbsolutePath(ctx, candidate) {
   if (!configService) {
     return void 0;
   }
-  if (path15.isAbsolute(candidate)) {
+  if (path16.isAbsolute(candidate)) {
     return candidate;
   }
-  const resolvedFromSrc = path15.resolve(configService.absoluteSrcRoot, candidate);
+  const resolvedFromSrc = path16.resolve(configService.absoluteSrcRoot, candidate);
   if (resolvedFromSrc.startsWith(configService.absoluteSrcRoot)) {
     return resolvedFromSrc;
   }
-  return path15.resolve(configService.cwd, candidate);
+  return path16.resolve(configService.cwd, candidate);
 }
 function matchesAutoImportGlobs(ctx, candidate) {
   const { autoImportService, configService } = ctx;
@@ -19680,7 +19917,7 @@ async function findTemplateCandidates(state, globs) {
     ],
     pathSeparator: "/"
   });
-  return await fdir.withFullPaths().globWithOptions(globs.map((pattern) => path15.resolve(configService.absoluteSrcRoot, pattern)), {
+  return await fdir.withFullPaths().globWithOptions(globs.map((pattern) => path16.resolve(configService.absoluteSrcRoot, pattern)), {
     ignore
   }).crawl(configService.absoluteSrcRoot).withPromise();
 }
@@ -19820,7 +20057,7 @@ function autoRoutes(ctx) {
 init_esm_shims();
 import { isEmptyObject as isEmptyObject2, isObject as isObject6, removeExtensionDeep as removeExtensionDeep5 } from "@weapp-core/shared";
 import fs13 from "fs-extra";
-import path20 from "pathe";
+import path21 from "pathe";
 import { build as build2 } from "vite";
 
 // src/wxml/handle.ts
@@ -21221,12 +21458,12 @@ init_esm_shims();
 import { performance as performance3 } from "perf_hooks";
 import { removeExtensionDeep as removeExtensionDeep4 } from "@weapp-core/shared";
 import fs11 from "fs-extra";
-import path17 from "pathe";
+import path18 from "pathe";
 
 // src/plugins/utils/analyze.ts
 init_esm_shims();
 import { get as get3, isObject as isObject4, removeExtension } from "@weapp-core/shared";
-import path16 from "pathe";
+import path17 from "pathe";
 function collectPluginExportEntries(plugins, root) {
   if (!isObject4(plugins)) {
     return [];
@@ -21241,7 +21478,7 @@ function collectPluginExportEntries(plugins, root) {
       continue;
     }
     const normalized = removeExtension(exportPath);
-    entries.push(root ? path16.join(root, normalized) : normalized);
+    entries.push(root ? path17.join(root, normalized) : normalized);
   }
   return entries;
 }
@@ -21322,7 +21559,7 @@ async function collectAppSideFiles(pluginCtx, id, json, jsonService, registerJso
       return;
     }
     const { path: jsonPath, predictions } = await findJsonEntry(
-      path17.resolve(path17.dirname(id), location)
+      path18.resolve(path18.dirname(id), location)
     );
     for (const prediction of predictions) {
       await addWatchTarget(pluginCtx, prediction, existsCache);
@@ -21354,7 +21591,7 @@ async function ensureTemplateScanned(pluginCtx, id, scanTemplateEntry, existsCac
 async function resolveEntries(entries, absoluteSrcRoot) {
   return Promise.all(
     entries.filter((entry) => !entry.includes(":")).map(async (entry) => {
-      const absPath = path17.resolve(absoluteSrcRoot, entry);
+      const absPath = path18.resolve(absoluteSrcRoot, entry);
       return {
         entry,
         resolvedId: await this.resolve(absPath)
@@ -21469,7 +21706,7 @@ function createEntryLoader(options) {
 // src/plugins/hooks/useLoadEntry/normalizer.ts
 init_esm_shims();
 import { isObject as isObject5 } from "@weapp-core/shared";
-import path18 from "pathe";
+import path19 from "pathe";
 function createEntryNormalizer(configService) {
   return function normalizeEntry(entry, jsonPath) {
     if (/plugin:\/\//.test(entry)) {
@@ -21494,8 +21731,8 @@ function resolveImportee2(importee, jsonPath, configService) {
       updated = importee.replace(matchedEntry.find, matchedEntry.replacement);
     }
   }
-  const baseDir = jsonPath ? path18.dirname(jsonPath) : configService.absoluteSrcRoot;
-  return path18.resolve(baseDir, updated);
+  const baseDir = jsonPath ? path19.dirname(jsonPath) : configService.absoluteSrcRoot;
+  return path19.resolve(baseDir, updated);
 }
 function hasDependencyPrefix(dependencies, tokens) {
   return Object.keys(dependencies).some((dep) => {
@@ -21586,7 +21823,7 @@ function collectRequireTokens(ast) {
 init_esm_shims();
 import fs12 from "fs";
 import process6 from "process";
-import path19 from "pathe";
+import path20 from "pathe";
 var watchedCssExts = new Set(supportedCssLangs.map((ext2) => `.${ext2}`));
 var configSuffixes = configExtensions.map((ext2) => `.${ext2}`);
 var sidecarSuffixes = [...configSuffixes, ...watchedCssExts];
@@ -21604,7 +21841,7 @@ function isWatchLimitError(error) {
 }
 async function invalidateEntryForSidecar(filePath) {
   const configSuffix = configSuffixes.find((suffix) => filePath.endsWith(suffix));
-  const ext2 = path19.extname(filePath);
+  const ext2 = path20.extname(filePath);
   let scriptBasePath;
   if (configSuffix) {
     scriptBasePath = filePath.slice(0, -configSuffix.length);
@@ -21625,7 +21862,7 @@ function ensureSidecarWatcher(ctx, rootDir) {
     return;
   }
   const { sidecarWatcherMap } = ctx.runtimeState.watcher;
-  const absRoot = path19.normalize(rootDir);
+  const absRoot = path20.normalize(rootDir);
   if (!fs12.existsSync(absRoot)) {
     return;
   }
@@ -21640,8 +21877,8 @@ function ensureSidecarWatcher(ctx, rootDir) {
   };
   const registerChokidarWatcher = () => {
     const patterns = [
-      ...configExtensions.map((ext2) => path19.join(absRoot, `**/*.${ext2}`)),
-      ...supportedCssLangs.map((ext2) => path19.join(absRoot, `**/*.${ext2}`))
+      ...configExtensions.map((ext2) => path20.join(absRoot, `**/*.${ext2}`)),
+      ...supportedCssLangs.map((ext2) => path20.join(absRoot, `**/*.${ext2}`))
     ];
     const watcher = esm_default.watch(patterns, {
       ignoreInitial: true,
@@ -21675,7 +21912,7 @@ function ensureSidecarWatcher(ctx, rootDir) {
         if (!filename) {
           return;
         }
-        const resolved = path19.join(absRoot, filename.toString());
+        const resolved = path20.join(absRoot, filename.toString());
         handleSidecarChange(resolved);
       });
       let handledWatchLimit = false;
@@ -21788,7 +22025,7 @@ function createCoreLifecyclePlugin(state) {
     buildStart() {
       loadedEntrySet.clear();
       if (configService.isDev) {
-        const rootDir = subPackageMeta ? path20.resolve(configService.absoluteSrcRoot, subPackageMeta.subPackage.root) : configService.absoluteSrcRoot;
+        const rootDir = subPackageMeta ? path21.resolve(configService.absoluteSrcRoot, subPackageMeta.subPackage.root) : configService.absoluteSrcRoot;
         ensureSidecarWatcher(ctx, rootDir);
       }
     },
@@ -21820,7 +22057,7 @@ function createCoreLifecyclePlugin(state) {
       let scannedInput;
       if (subPackageMeta) {
         scannedInput = subPackageMeta.entries.reduce((acc, entry) => {
-          acc[entry] = path20.resolve(configService.absoluteSrcRoot, entry);
+          acc[entry] = path21.resolve(configService.absoluteSrcRoot, entry);
           return acc;
         }, {});
       } else {
@@ -21889,8 +22126,15 @@ function createCoreLifecyclePlugin(state) {
       emitJsonAssets.call(this, state);
       state.watchFilesSnapshot = emitWxmlAssets.call(this, state);
     },
-    async generateBundle() {
+    async generateBundle(_options, bundle) {
       await flushIndependentBuilds.call(this, state, watcherService);
+      if (!subPackageMeta) {
+        const sharedStrategy = configService.weappViteConfig?.chunks?.sharedStrategy ?? DEFAULT_SHARED_CHUNK_STRATEGY;
+        applySharedChunkStrategy.call(this, bundle, {
+          strategy: sharedStrategy,
+          subPackageRoots: scanService.subPackageMap.keys()
+        });
+      }
       if (configService.weappViteConfig?.debug?.watchFiles) {
         const watcherService2 = ctx.watcherService;
         const watcherRoot = subPackageMeta?.subPackage.root ?? "/";
@@ -21943,7 +22187,7 @@ function createRequireAnalysisPlugin(state) {
         return;
       }
       for (const requireModule of requireTokens) {
-        const absPath = path20.resolve(path20.dirname(moduleInfo.id), requireModule.value);
+        const absPath = path21.resolve(path21.dirname(moduleInfo.id), requireModule.value);
         const resolved = await this.resolve(absPath, moduleInfo.id);
         if (!resolved) {
           continue;
@@ -22297,7 +22541,7 @@ init_esm_shims();
 import { createHash } from "crypto";
 import { removeExtension as removeExtension2 } from "@weapp-core/shared";
 import fs14 from "fs-extra";
-import path21 from "pathe";
+import path22 from "pathe";
 function workers(ctx) {
   if (!ctx.scanService.workersDir) {
     return [];
@@ -22325,21 +22569,21 @@ function createWorkerBuildPlugin(ctx) {
       options.chunkFileNames = (chunkInfo) => {
         const workersDir = scanService.workersDir ?? "";
         if (chunkInfo.isDynamicEntry) {
-          return path21.join(workersDir, "[name].js");
+          return path22.join(workersDir, "[name].js");
         }
         const sourceId = chunkInfo.facadeModuleId ?? chunkInfo.moduleIds[0];
         const hashBase = typeof sourceId === "string" ? configService.relativeCwd(sourceId) : chunkInfo.name;
         const stableHash = createHash("sha256").update(hashBase).digest("base64url").slice(0, 8);
-        return path21.join(workersDir, `${chunkInfo.name}-${stableHash}.js`);
+        return path22.join(workersDir, `${chunkInfo.name}-${stableHash}.js`);
       };
     }
   };
 }
 async function resolveWorkerEntry(ctx, entry) {
   const { configService, scanService } = ctx;
-  const relativeEntryPath = path21.join(scanService.workersDir, entry);
+  const relativeEntryPath = path22.join(scanService.workersDir, entry);
   const key = removeExtension2(relativeEntryPath);
-  const absoluteEntry = path21.resolve(configService.absoluteSrcRoot, relativeEntryPath);
+  const absoluteEntry = path22.resolve(configService.absoluteSrcRoot, relativeEntryPath);
   if (isJsOrTs(entry)) {
     const exists = await fs14.exists(absoluteEntry);
     if (!exists) {
@@ -22360,7 +22604,7 @@ async function resolveWorkerEntry(ctx, entry) {
 init_esm_shims();
 import { removeExtension as removeExtension3 } from "@weapp-core/shared";
 import fs15 from "fs-extra";
-import path22 from "pathe";
+import path23 from "pathe";
 var wxsCodeCache = new LRUCache({
   max: 512
 });
@@ -22405,7 +22649,7 @@ async function handleWxsDeps(state, deps, absPath) {
       if (!jsExtensions.includes(dep.attrs.lang) && !arr) {
         return;
       }
-      const wxsPath = path22.resolve(path22.dirname(absPath), dep.value);
+      const wxsPath = path23.resolve(path23.dirname(absPath), dep.value);
       await transformWxsFile.call(this, state, wxsPath);
     })
   );
@@ -22431,13 +22675,13 @@ async function transformWxsFile(state, wxsPath) {
     if (typeof result?.code === "string") {
       code = result.code;
     }
-    const dirname5 = path22.dirname(wxsPath);
+    const dirname5 = path23.dirname(wxsPath);
     await Promise.all(
       importees.map(({ source }) => {
         return transformWxsFile.call(
           this,
           state,
-          path22.resolve(dirname5, source)
+          path23.resolve(dirname5, source)
         );
       })
     );
@@ -22668,29 +22912,29 @@ function sanitizeBuildTarget(target, options) {
 
 // src/runtime/config/web.ts
 init_esm_shims();
-import path23 from "pathe";
+import path24 from "pathe";
 function normalizeSrcDir(root, cwd, srcRoot, config) {
   if (!config) {
-    const absoluteSrc2 = path23.resolve(cwd, srcRoot);
-    return path23.relative(root, absoluteSrc2) || "";
+    const absoluteSrc2 = path24.resolve(cwd, srcRoot);
+    return path24.relative(root, absoluteSrc2) || "";
   }
   if (config.srcDir) {
-    if (path23.isAbsolute(config.srcDir)) {
-      return path23.relative(root, config.srcDir);
+    if (path24.isAbsolute(config.srcDir)) {
+      return path24.relative(root, config.srcDir);
     }
     return config.srcDir;
   }
-  const absoluteSrc = path23.resolve(cwd, srcRoot);
-  return path23.relative(root, absoluteSrc) || "";
+  const absoluteSrc = path24.resolve(cwd, srcRoot);
+  return path24.relative(root, absoluteSrc) || "";
 }
 function normalizeOutDir(root, config) {
   if (!config?.outDir) {
-    return path23.resolve(root, "dist-web");
+    return path24.resolve(root, "dist-web");
   }
-  if (path23.isAbsolute(config.outDir)) {
+  if (path24.isAbsolute(config.outDir)) {
     return config.outDir;
   }
-  return path23.resolve(root, config.outDir);
+  return path24.resolve(root, config.outDir);
 }
 function resolveWeappWebConfig(options) {
   const { cwd, srcRoot, config } = options;
@@ -22701,7 +22945,7 @@ function resolveWeappWebConfig(options) {
   if (!enabled) {
     return void 0;
   }
-  const root = config.root ? path23.resolve(cwd, config.root) : cwd;
+  const root = config.root ? path24.resolve(cwd, config.root) : cwd;
   const srcDir = normalizeSrcDir(root, cwd, srcRoot, config);
   const outDir = normalizeOutDir(root, config);
   const pluginOptions = {
@@ -22723,7 +22967,7 @@ function resolveWeappWebConfig(options) {
 // src/runtime/oxcRuntime.ts
 init_esm_shims();
 import fs16 from "fs-extra";
-import path24 from "pathe";
+import path25 from "pathe";
 var NULL_BYTE = "\0";
 var OXC_RUNTIME_HELPER_ALIAS = new RegExp(`^(?:${NULL_BYTE})?@oxc-project(?:/|\\+)runtime(?:@[^/]+)?/helpers/(.+)\\.js$`);
 var FALLBACK_HELPER_PREFIX = `${NULL_BYTE}weapp-vite:oxc-helper:`;
@@ -22791,7 +23035,7 @@ function getOxcHelperName(id) {
 }
 function createOxcRuntimeSupport() {
   const oxcRuntimeInfo = getPackageInfoSync("@oxc-project/runtime");
-  const oxcRuntimeHelpersRoot = oxcRuntimeInfo ? path24.resolve(oxcRuntimeInfo.rootPath, "src/helpers/esm") : void 0;
+  const oxcRuntimeHelpersRoot = oxcRuntimeInfo ? path25.resolve(oxcRuntimeInfo.rootPath, "src/helpers/esm") : void 0;
   const alias = {
     find: OXC_RUNTIME_HELPER_ALIAS,
     replacement: "@oxc-project/runtime/src/helpers/esm/$1.js"
@@ -22818,7 +23062,7 @@ function createOxcRuntimeSupport() {
         }
         return null;
       }
-      return path24.resolve(helpersRoot, `${helperName}.js`);
+      return path25.resolve(helpersRoot, `${helperName}.js`);
     },
     async load(id) {
       if (id.startsWith(FALLBACK_HELPER_PREFIX)) {
@@ -22831,7 +23075,7 @@ function createOxcRuntimeSupport() {
       }
       const helperName = getOxcHelperName(id);
       if (helperName) {
-        const helperPath = id.startsWith(NULL_BYTE) ? path24.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`) : id;
+        const helperPath = id.startsWith(NULL_BYTE) ? path25.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`) : id;
         if (await fs16.pathExists(helperPath)) {
           console.warn("[weapp-vite] resolving oxc helper via Rolldown plugin:", helperName);
           return fs16.readFile(helperPath, "utf8");
@@ -22856,7 +23100,7 @@ function createOxcRuntimeSupport() {
       }
       const helperName = getOxcHelperName(source);
       if (helperName) {
-        return path24.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
+        return path25.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
       }
       return null;
     },
@@ -22868,7 +23112,7 @@ function createOxcRuntimeSupport() {
       if (!helperName) {
         return null;
       }
-      const helperPath = path24.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
+      const helperPath = path25.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
       console.warn("[weapp-vite] resolving oxc helper via Vite plugin:", helperName);
       return fs16.readFile(helperPath, "utf8");
     }
@@ -22883,7 +23127,7 @@ function createOxcRuntimeSupport() {
 // src/runtime/packageAliases.ts
 init_esm_shims();
 import { existsSync } from "fs";
-import path25 from "pathe";
+import path26 from "pathe";
 var SPECIAL_PACKAGE_ALIASES = [
   {
     packageName: "class-variance-authority",
@@ -22897,7 +23141,7 @@ function resolveBuiltinPackageAliases() {
     if (!info) {
       continue;
     }
-    const resolvedEntry = path25.resolve(info.rootPath, distEntry);
+    const resolvedEntry = path26.resolve(info.rootPath, distEntry);
     if (!existsSync(resolvedEntry)) {
       continue;
     }
@@ -22908,7 +23152,7 @@ function resolveBuiltinPackageAliases() {
   }
   const weappViteInfo = getPackageInfoSync("weapp-vite");
   if (weappViteInfo) {
-    const autoRoutesSource = path25.resolve(weappViteInfo.rootPath, "src/auto-routes.ts");
+    const autoRoutesSource = path26.resolve(weappViteInfo.rootPath, "src/auto-routes.ts");
     if (existsSync(autoRoutesSource)) {
       aliases.push({
         find: "weapp-vite/auto-routes",
@@ -22993,7 +23237,7 @@ function createConfigService(ctx) {
     if (!mpDistRoot) {
       throw new Error("\u8BF7\u5728 `project.config.json` \u91CC\u8BBE\u7F6E `miniprogramRoot`, \u6BD4\u5982\u53EF\u4EE5\u8BBE\u7F6E\u4E3A `dist/` ");
     }
-    const packageJsonPath = path26.resolve(cwd, "package.json");
+    const packageJsonPath = path27.resolve(cwd, "package.json");
     let packageJson = {};
     if (await fs17.exists(packageJsonPath)) {
       const localPackageJson = await fs17.readJson(packageJsonPath, {
@@ -23002,8 +23246,8 @@ function createConfigService(ctx) {
       packageJson = localPackageJson;
     }
     let resolvedConfigFile = configFile;
-    if (resolvedConfigFile && !path26.isAbsolute(resolvedConfigFile)) {
-      resolvedConfigFile = path26.resolve(cwd, resolvedConfigFile);
+    if (resolvedConfigFile && !path27.isAbsolute(resolvedConfigFile)) {
+      resolvedConfigFile = path27.resolve(cwd, resolvedConfigFile);
     }
     const weappConfigFilePath = await resolveWeappConfigFile({
       root: cwd,
@@ -23016,8 +23260,8 @@ function createConfigService(ctx) {
     const loadedConfig = loaded?.config;
     let weappLoaded;
     if (weappConfigFilePath) {
-      const normalizedWeappPath = path26.resolve(weappConfigFilePath);
-      const normalizedLoadedPath = loaded?.path ? path26.resolve(loaded.path) : void 0;
+      const normalizedWeappPath = path27.resolve(weappConfigFilePath);
+      const normalizedLoadedPath = loaded?.path ? path27.resolve(loaded.path) : void 0;
       if (normalizedLoadedPath && normalizedLoadedPath === normalizedWeappPath) {
         weappLoaded = loaded;
       } else {
@@ -23126,7 +23370,7 @@ function createConfigService(ctx) {
     }
     function relativeSrcRoot(p) {
       if (srcRoot) {
-        return path26.relative(srcRoot, p);
+        return path27.relative(srcRoot, p);
       }
       return p;
     }
@@ -23275,12 +23519,13 @@ function createConfigService(ctx) {
             watch: {
               exclude: [
                 ...defaultExcluded,
-                options.mpDistRoot ? path26.join(options.cwd, options.mpDistRoot, "**") : path26.join(options.cwd, "dist", "**")
+                options.mpDistRoot ? path27.join(options.cwd, options.mpDistRoot, "**") : path27.join(options.cwd, "dist", "**")
               ],
-              include: [path26.join(options.cwd, options.srcRoot, "**")]
+              include: [path27.join(options.cwd, options.srcRoot, "**")]
             },
             minify: false,
             emptyOutDir: false,
+            // @ts-ignore
             rolldownOptions: {
               ...rolldownOptions
             },
@@ -23306,6 +23551,7 @@ function createConfigService(ctx) {
         define: getDefineImportMetaEnv(),
         build: {
           emptyOutDir: false,
+          // @ts-ignore
           rolldownOptions: {
             ...rolldownOptions
           }
@@ -23426,7 +23672,7 @@ function createConfigService(ctx) {
       return options.mpDistRoot;
     },
     get outDir() {
-      return path26.resolve(options.cwd, options.mpDistRoot ?? "");
+      return path27.resolve(options.cwd, options.mpDistRoot ?? "");
     },
     get currentSubPackageRoot() {
       return options.currentSubPackageRoot;
@@ -23451,11 +23697,11 @@ function createConfigService(ctx) {
     },
     get absolutePluginRoot() {
       if (options.config.weapp?.pluginRoot) {
-        return path26.resolve(options.cwd, options.config.weapp.pluginRoot);
+        return path27.resolve(options.cwd, options.config.weapp.pluginRoot);
       }
     },
     get absoluteSrcRoot() {
-      return path26.resolve(options.cwd, options.srcRoot);
+      return path27.resolve(options.cwd, options.srcRoot);
     },
     get mode() {
       return options.mode;
@@ -23473,13 +23719,13 @@ function createConfigService(ctx) {
       return options.weappWeb;
     },
     relativeCwd(p) {
-      return path26.relative(options.cwd, p);
+      return path27.relative(options.cwd, p);
     },
     relativeSrcRoot(p) {
       return options.relativeSrcRoot(p);
     },
     relativeAbsoluteSrcRoot(p) {
-      return path26.relative(path26.resolve(options.cwd, options.srcRoot), p);
+      return path27.relative(path27.resolve(options.cwd, options.srcRoot), p);
     }
   };
 }
@@ -23595,13 +23841,13 @@ init_esm_shims();
 import { isBuiltin } from "module";
 import { defu as defu4, isObject as isObject8, objectHash as objectHash2 } from "@weapp-core/shared";
 import fs19 from "fs-extra";
-import path27 from "pathe";
+import path28 from "pathe";
 function createNpmService(ctx) {
   function getDependenciesCacheFilePath(key = "/") {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before generating npm cache path");
     }
-    return path27.resolve(ctx.configService.cwd, `node_modules/weapp-vite/.cache/${key.replaceAll("/", "-")}.json`);
+    return path28.resolve(ctx.configService.cwd, `node_modules/weapp-vite/.cache/${key.replaceAll("/", "-")}.json`);
   }
   function dependenciesCacheHash() {
     if (!ctx.configService) {
@@ -23694,14 +23940,14 @@ function createNpmService(ctx) {
     const { packageJson: targetJson, rootPath } = packageInfo;
     const dependencies = targetJson.dependencies ?? {};
     const keys = Object.keys(dependencies);
-    const destOutDir = path27.resolve(outDir, dep);
+    const destOutDir = path28.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: path27.resolve(
+        from: path28.resolve(
           rootPath,
           targetJson.miniprogram
         ),
@@ -23773,10 +24019,10 @@ function createNpmService(ctx) {
     debug?.("buildNpm start");
     const packNpmRelationList = getPackNpmRelationList();
     const [mainRelation, ...subRelations] = packNpmRelationList;
-    const packageJsonPath = path27.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
+    const packageJsonPath = path28.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
     if (await fs19.exists(packageJsonPath)) {
       const pkgJson = await fs19.readJson(packageJsonPath);
-      const outDir = path27.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, "miniprogram_npm");
+      const outDir = path28.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, "miniprogram_npm");
       if (pkgJson.dependencies) {
         const dependencies = Object.keys(pkgJson.dependencies);
         if (dependencies.length > 0) {
@@ -23795,7 +24041,7 @@ function createNpmService(ctx) {
           const targetDirs = [
             ...subRelations.map((x) => {
               return {
-                npmDistDir: path27.resolve(ctx.configService.cwd, x.miniprogramNpmDistDir, "miniprogram_npm")
+                npmDistDir: path28.resolve(ctx.configService.cwd, x.miniprogramNpmDistDir, "miniprogram_npm")
               };
             }),
             ...[...ctx.scanService.independentSubPackageMap.values()].map((x) => {
@@ -23803,7 +24049,7 @@ function createNpmService(ctx) {
               return {
                 root: x.subPackage.root,
                 dependencies: dependencies2,
-                npmDistDir: path27.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, x.subPackage.root, "miniprogram_npm")
+                npmDistDir: path28.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, x.subPackage.root, "miniprogram_npm")
               };
             })
           ];
@@ -23815,7 +24061,7 @@ function createNpmService(ctx) {
                   overwrite: true,
                   filter: (src) => {
                     if (Array.isArray(x.dependencies)) {
-                      const relPath = path27.relative(outDir, src);
+                      const relPath = path28.relative(outDir, src);
                       if (relPath === "") {
                         return true;
                       }
@@ -23831,7 +24077,7 @@ function createNpmService(ctx) {
                 overwrite: true,
                 filter: (src) => {
                   if (Array.isArray(x.dependencies)) {
-                    const relPath = path27.relative(outDir, src);
+                    const relPath = path28.relative(outDir, src);
                     if (relPath === "") {
                       return true;
                     }
@@ -24785,7 +25031,7 @@ function createRuntimeState() {
 // src/runtime/scanPlugin.ts
 init_esm_shims();
 import { isObject as isObject9, removeExtensionDeep as removeExtensionDeep6 } from "@weapp-core/shared";
-import path28 from "pathe";
+import path29 from "pathe";
 function resolveSubPackageEntries(subPackage) {
   const entries = [];
   const root = subPackage.root ?? "";
@@ -24809,11 +25055,11 @@ function createScanService(ctx) {
       return scanState.appEntry;
     }
     const appDirname = ctx.configService.absoluteSrcRoot;
-    const appBasename = path28.resolve(appDirname, "app");
+    const appBasename = path29.resolve(appDirname, "app");
     const { path: appConfigFile } = await findJsonEntry(appBasename);
     const { path: appEntryPath } = await findJsEntry(appBasename);
     if (ctx.configService.absolutePluginRoot) {
-      const pluginBasename = path28.resolve(ctx.configService.absolutePluginRoot, "plugin");
+      const pluginBasename = path29.resolve(ctx.configService.absolutePluginRoot, "plugin");
       const { path: pluginConfigFile } = await findJsonEntry(pluginBasename);
       if (pluginConfigFile) {
         const pluginConfig = await ctx.jsonService.read(pluginConfigFile);
@@ -24832,14 +25078,14 @@ function createScanService(ctx) {
         scanState.appEntry = resolvedAppEntry;
         const { sitemapLocation = "sitemap.json", themeLocation = "theme.json" } = config;
         if (sitemapLocation) {
-          const { path: sitemapJsonPath } = await findJsonEntry(path28.resolve(appDirname, sitemapLocation));
+          const { path: sitemapJsonPath } = await findJsonEntry(path29.resolve(appDirname, sitemapLocation));
           if (sitemapJsonPath) {
             resolvedAppEntry.sitemapJsonPath = sitemapJsonPath;
             resolvedAppEntry.sitemapJson = await ctx.jsonService.read(sitemapJsonPath);
           }
         }
         if (themeLocation) {
-          const { path: themeJsonPath } = await findJsonEntry(path28.resolve(appDirname, themeLocation));
+          const { path: themeJsonPath } = await findJsonEntry(path29.resolve(appDirname, themeLocation));
           if (themeJsonPath) {
             resolvedAppEntry.themeJsonPath = themeJsonPath;
             resolvedAppEntry.themeJson = await ctx.jsonService.read(themeJsonPath);
@@ -25101,7 +25347,7 @@ function createWebServicePlugin(ctx) {
 init_esm_shims();
 import { removeExtensionDeep as removeExtensionDeep7 } from "@weapp-core/shared";
 import fs21 from "fs-extra";
-import path29 from "pathe";
+import path30 from "pathe";
 
 // src/wxml/index.ts
 init_esm_shims();
@@ -27803,7 +28049,7 @@ function createWxmlService(ctx) {
       throw new Error("configService must be initialized before scanning wxml");
     }
     if (await fs21.exists(filepath)) {
-      const dirname5 = path29.dirname(filepath);
+      const dirname5 = path30.dirname(filepath);
       const wxml = await fs21.readFile(filepath, "utf8");
       const shouldRescan = await cache2.isInvalidate(filepath, { content: wxml });
       if (!shouldRescan) {
@@ -27820,9 +28066,9 @@ function createWxmlService(ctx) {
         filepath,
         res.deps.filter((x) => isImportTag(x.tagName) && isTemplate(x.value)).map((x) => {
           if (x.value.startsWith("/")) {
-            return path29.resolve(ctx.configService.absoluteSrcRoot, x.value.slice(1));
+            return path30.resolve(ctx.configService.absoluteSrcRoot, x.value.slice(1));
           } else {
-            return path29.resolve(dirname5, x.value);
+            return path30.resolve(dirname5, x.value);
           }
         })
       );