weapp-vite 6.2.0 → 6.2.2

package/dist/{chunk-SGNL4SVW.mjs → chunk-R6PSILQG.mjs}

@@ -35,7 +35,7 @@ import {
   traverse,
   usingComponentFromResolvedFile,
   withTempDirLock
-} from "./chunk-2GIOG6RC.mjs";
+} from "./chunk-WH5NEVYM.mjs";
 import {
   changeFileExtension,
   configExtensions,
@@ -54,7 +54,7 @@ import {
   templateExtensions,
   touch,
   vueExtensions
-} from "./chunk-FC2MZYU3.mjs";
+} from "./chunk-NZGKD6UN.mjs";
 import {
   __commonJS,
   __toESM,
@@ -629,15 +629,15 @@ var LRUCache = class _LRUCache {
         purgeTimers[index] = void 0;
       }
       if (ttl !== 0 && purgeTimers) {
-        const t32 = setTimeout(() => {
+        const t33 = setTimeout(() => {
           if (this.#isStale(index)) {
             this.#delete(this.#keyList[index], "expire");
           }
         }, ttl + 1);
-        if (t32.unref) {
-          t32.unref();
+        if (t33.unref) {
+          t33.unref();
         }
-        purgeTimers[index] = t32;
+        purgeTimers[index] = t33;
       }
     };
     this.#updateItemAge = (index) => {
@@ -661,9 +661,9 @@ var LRUCache = class _LRUCache {
       const n = this.#perf.now();
       if (this.ttlResolution > 0) {
         cachedNow = n;
-        const t32 = setTimeout(() => cachedNow = 0, this.ttlResolution);
-        if (t32.unref) {
-          t32.unref();
+        const t33 = setTimeout(() => cachedNow = 0, this.ttlResolution);
+        if (t33.unref) {
+          t33.unref();
         }
       }
       return n;
@@ -683,8 +683,8 @@ var LRUCache = class _LRUCache {
     };
     this.#isStale = (index) => {
       const s = starts[index];
-      const t32 = ttls[index];
-      return !!t32 && !!s && (cachedNow || getNow()) - s > t32;
+      const t33 = ttls[index];
+      return !!t33 && !!s && (cachedNow || getNow()) - s > t33;
     };
   }
   // conditionally set private methods related to TTL
@@ -1636,9 +1636,9 @@ var LRUCache = class _LRUCache {
     if (this.#ttls && this.#starts) {
       this.#ttls.fill(0);
       this.#starts.fill(0);
-      for (const t32 of this.#autopurgeTimers ?? []) {
-        if (t32 !== void 0)
-          clearTimeout(t32);
+      for (const t33 of this.#autopurgeTimers ?? []) {
+        if (t33 !== void 0)
+          clearTimeout(t33);
       }
       this.#autopurgeTimers?.fill(void 0);
     }
@@ -2178,11 +2178,11 @@ function extractComponentProps(code) {
   const ast = parse(code, BABEL_TS_MODULE_PARSER_OPTIONS);
   let props = /* @__PURE__ */ new Map();
   traverse(ast, {
-    CallExpression(path70) {
+    CallExpression(path71) {
       if (props.size > 0) {
         return;
       }
-      const [options] = path70.node.arguments;
+      const [options] = path71.node.arguments;
       if (!options || options.type !== "ObjectExpression") {
         return;
       }
@@ -2353,12 +2353,12 @@ function extractComponentPropsFromDts(code) {
     errorRecovery: true
   });
   traverse(ast, {
-    TSInterfaceDeclaration(path70) {
+    TSInterfaceDeclaration(path71) {
       if (props.size > 0) {
-        path70.stop();
+        path71.stop();
         return;
       }
-      for (const member of path70.node.body.body) {
+      for (const member of path71.node.body.body) {
         if (member.type !== "TSPropertySignature") {
           continue;
         }
@@ -2369,22 +2369,22 @@ function extractComponentPropsFromDts(code) {
         const typeNode = unwrapTypeAnnotation(member.typeAnnotation);
         if (typeNode?.type === "TSTypeLiteral") {
           props = extractFromPropertiesTypeLiteral(typeNode);
-          path70.stop();
+          path71.stop();
           return;
         }
       }
-      const extracted = extractFromPropsInterfaceMembers(path70.node);
+      const extracted = extractFromPropsInterfaceMembers(path71.node);
       if (extracted.size > 0) {
         props = extracted;
-        path70.stop();
+        path71.stop();
       }
     },
-    ClassDeclaration(path70) {
+    ClassDeclaration(path71) {
       if (props.size > 0) {
-        path70.stop();
+        path71.stop();
         return;
       }
-      for (const member of path70.node.body.body) {
+      for (const member of path71.node.body.body) {
         if (member.type !== "ClassProperty" && member.type !== "ClassAccessorProperty") {
           continue;
         }
@@ -2395,7 +2395,7 @@ function extractComponentPropsFromDts(code) {
         const typeNode = unwrapTypeAnnotation(member.typeAnnotation);
         if (typeNode?.type === "TSTypeLiteral") {
           props = extractFromPropertiesTypeLiteral(typeNode);
-          path70.stop();
+          path71.stop();
           return;
         }
       }
@@ -8366,7 +8366,7 @@ function createSharedBuildConfig(configService, scanService) {
     build: {
       rolldownOptions: {
         output: {
-          advancedChunks: {
+          codeSplitting: {
             groups: [
               {
                 name: (id, ctx) => resolveAdvancedChunkName(id, ctx)
@@ -11310,12 +11310,12 @@ var PathBase = class {
   /**
    * Get the Path object referenced by the string path, resolved from this Path
    */
-  resolve(path70) {
-    if (!path70) {
+  resolve(path71) {
+    if (!path71) {
       return this;
     }
-    const rootPath = this.getRootString(path70);
-    const dir = path70.substring(rootPath.length);
+    const rootPath = this.getRootString(path71);
+    const dir = path71.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -11697,10 +11697,10 @@ var PathBase = class {
   #markENOTDIR() {
     if (this.#type & ENOTDIR)
       return;
-    let t32 = this.#type;
-    if ((t32 & IFMT) === IFDIR)
-      t32 &= IFMT_UNKNOWN;
-    this.#type = t32 | ENOTDIR;
+    let t33 = this.#type;
+    if ((t33 & IFMT) === IFDIR)
+      t33 &= IFMT_UNKNOWN;
+    this.#type = t33 | ENOTDIR;
     this.#markChildrenENOENT();
   }
   #readdirFail(code = "") {
@@ -12067,8 +12067,8 @@ var PathWin32 = class _PathWin32 extends PathBase {
   /**
    * @internal
    */
-  getRootString(path70) {
-    return win32.parse(path70).root;
+  getRootString(path71) {
+    return win32.parse(path71).root;
   }
   /**
    * @internal
@@ -12114,8 +12114,8 @@ var PathPosix = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path70) {
-    return path70.startsWith("/") ? "/" : "";
+  getRootString(path71) {
+    return path71.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -12204,11 +12204,11 @@ var PathScurryBase = class {
   /**
    * Get the depth of a provided path, string, or the cwd
    */
-  depth(path70 = this.cwd) {
-    if (typeof path70 === "string") {
-      path70 = this.cwd.resolve(path70);
+  depth(path71 = this.cwd) {
+    if (typeof path71 === "string") {
+      path71 = this.cwd.resolve(path71);
     }
-    return path70.depth();
+    return path71.depth();
   }
   /**
    * Return the cache of child entries.  Exposed so subclasses can create
@@ -12695,9 +12695,9 @@ var PathScurryBase = class {
     process11();
     return results;
   }
-  chdir(path70 = this.cwd) {
+  chdir(path71 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path70 === "string" ? this.cwd.resolve(path70) : path70;
+    this.cwd = typeof path71 === "string" ? this.cwd.resolve(path71) : path71;
     this.cwd[setAsCwd](oldCwd);
   }
 };
@@ -13059,8 +13059,8 @@ var MatchRecord = class {
   }
   // match, absolute, ifdir
   entries() {
-    return [...this.store.entries()].map(([path70, n]) => [
-      path70,
+    return [...this.store.entries()].map(([path71, n]) => [
+      path71,
       !!(n & 2),
       !!(n & 1)
     ]);
@@ -13091,7 +13091,7 @@ var SubWalks = class {
     return this.keys().map((k) => [k, this.store.get(k)]);
   }
   keys() {
-    return [...this.store.keys()].filter((t32) => t32.canReaddir());
+    return [...this.store.keys()].filter((t33) => t33.canReaddir());
   }
 };
 var Processor = class _Processor {
@@ -13111,53 +13111,53 @@ var Processor = class _Processor {
   processPatterns(target, patterns) {
     this.patterns = patterns;
     const processingSet = patterns.map((p) => [target, p]);
-    for (let [t32, pattern] of processingSet) {
-      this.hasWalkedCache.storeWalked(t32, pattern);
+    for (let [t33, pattern] of processingSet) {
+      this.hasWalkedCache.storeWalked(t33, pattern);
       const root = pattern.root();
       const absolute = pattern.isAbsolute() && this.opts.absolute !== false;
       if (root) {
-        t32 = t32.resolve(root === "/" && this.opts.root !== void 0 ? this.opts.root : root);
+        t33 = t33.resolve(root === "/" && this.opts.root !== void 0 ? this.opts.root : root);
         const rest2 = pattern.rest();
         if (!rest2) {
-          this.matches.add(t32, true, false);
+          this.matches.add(t33, true, false);
           continue;
         } else {
           pattern = rest2;
         }
       }
-      if (t32.isENOENT())
+      if (t33.isENOENT())
         continue;
       let p;
       let rest;
       let changed = false;
       while (typeof (p = pattern.pattern()) === "string" && (rest = pattern.rest())) {
-        const c = t32.resolve(p);
-        t32 = c;
+        const c = t33.resolve(p);
+        t33 = c;
         pattern = rest;
         changed = true;
       }
       p = pattern.pattern();
       rest = pattern.rest();
       if (changed) {
-        if (this.hasWalkedCache.hasWalked(t32, pattern))
+        if (this.hasWalkedCache.hasWalked(t33, pattern))
           continue;
-        this.hasWalkedCache.storeWalked(t32, pattern);
+        this.hasWalkedCache.storeWalked(t33, pattern);
       }
       if (typeof p === "string") {
         const ifDir = p === ".." || p === "" || p === ".";
-        this.matches.add(t32.resolve(p), absolute, ifDir);
+        this.matches.add(t33.resolve(p), absolute, ifDir);
         continue;
       } else if (p === GLOBSTAR) {
-        if (!t32.isSymbolicLink() || this.follow || pattern.checkFollowGlobstar()) {
-          this.subwalks.add(t32, pattern);
+        if (!t33.isSymbolicLink() || this.follow || pattern.checkFollowGlobstar()) {
+          this.subwalks.add(t33, pattern);
         }
         const rp = rest?.pattern();
         const rrest = rest?.rest();
         if (!rest || (rp === "" || rp === ".") && !rrest) {
-          this.matches.add(t32, absolute, rp === "" || rp === ".");
+          this.matches.add(t33, absolute, rp === "" || rp === ".");
         } else {
           if (rp === "..") {
-            const tp = t32.parent || t32;
+            const tp = t33.parent || t33;
             if (!rrest)
               this.matches.add(tp, absolute, true);
             else if (!this.hasWalkedCache.hasWalked(tp, rrest)) {
@@ -13166,7 +13166,7 @@ var Processor = class _Processor {
           }
         }
       } else if (p instanceof RegExp) {
-        this.subwalks.add(t32, pattern);
+        this.subwalks.add(t33, pattern);
       }
     }
     return this;
@@ -13265,9 +13265,9 @@ var GlobUtil = class {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path70, opts) {
+  constructor(patterns, path71, opts) {
     this.patterns = patterns;
-    this.path = path70;
+    this.path = path71;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -13286,11 +13286,11 @@ var GlobUtil = class {
       });
     }
   }
-  #ignored(path70) {
-    return this.seen.has(path70) || !!this.#ignore?.ignored?.(path70);
+  #ignored(path71) {
+    return this.seen.has(path71) || !!this.#ignore?.ignored?.(path71);
   }
-  #childrenIgnored(path70) {
-    return !!this.#ignore?.childrenIgnored?.(path70);
+  #childrenIgnored(path71) {
+    return !!this.#ignore?.childrenIgnored?.(path71);
   }
   // backpressure mechanism
   pause() {
@@ -13416,16 +13416,16 @@ var GlobUtil = class {
       tasks++;
       this.match(m, absolute, ifDir).then(() => next());
     }
-    for (const t32 of processor.subwalkTargets()) {
-      if (this.maxDepth !== Infinity && t32.depth() >= this.maxDepth) {
+    for (const t33 of processor.subwalkTargets()) {
+      if (this.maxDepth !== Infinity && t33.depth() >= this.maxDepth) {
         continue;
       }
       tasks++;
-      const childrenCached = t32.readdirCached();
-      if (t32.calledReaddir())
-        this.walkCB3(t32, childrenCached, processor, next);
+      const childrenCached = t33.readdirCached();
+      if (t33.calledReaddir())
+        this.walkCB3(t33, childrenCached, processor, next);
       else {
-        t32.readdirCB((_, entries) => this.walkCB3(t32, entries, processor, next), true);
+        t33.readdirCB((_, entries) => this.walkCB3(t33, entries, processor, next), true);
       }
     }
     next();
@@ -13474,13 +13474,13 @@ var GlobUtil = class {
         continue;
       this.matchSync(m, absolute, ifDir);
     }
-    for (const t32 of processor.subwalkTargets()) {
-      if (this.maxDepth !== Infinity && t32.depth() >= this.maxDepth) {
+    for (const t33 of processor.subwalkTargets()) {
+      if (this.maxDepth !== Infinity && t33.depth() >= this.maxDepth) {
         continue;
       }
       tasks++;
-      const children = t32.readdirSync();
-      this.walkCB3Sync(t32, children, processor, next);
+      const children = t33.readdirSync();
+      this.walkCB3Sync(t33, children, processor, next);
     }
     next();
   }
@@ -13505,8 +13505,8 @@ var GlobUtil = class {
 };
 var GlobWalker = class extends GlobUtil {
   matches = /* @__PURE__ */ new Set();
-  constructor(patterns, path70, opts) {
-    super(patterns, path70, opts);
+  constructor(patterns, path71, opts) {
+    super(patterns, path71, opts);
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -13543,8 +13543,8 @@ var GlobWalker = class extends GlobUtil {
 };
 var GlobStream = class extends GlobUtil {
   results;
-  constructor(patterns, path70, opts) {
-    super(patterns, path70, opts);
+  constructor(patterns, path71, opts) {
+    super(patterns, path71, opts);
     this.results = new Minipass({
       signal: this.signal,
       objectMode: true
@@ -13840,7 +13840,7 @@ glob.glob = glob;
 
 // ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/opt-arg.js
 init_esm_shims();
-var typeOrUndef = (val, t32) => typeof val === "undefined" || typeof val === t32;
+var typeOrUndef = (val, t33) => typeof val === "undefined" || typeof val === t33;
 var isRimrafOptions = (o) => !!o && typeof o === "object" && typeOrUndef(o.preserveRoot, "boolean") && typeOrUndef(o.tmp, "string") && typeOrUndef(o.maxRetries, "number") && typeOrUndef(o.retryDelay, "number") && typeOrUndef(o.backoff, "number") && typeOrUndef(o.maxBackoff, "number") && (typeOrUndef(o.glob, "boolean") || o.glob && typeof o.glob === "object") && typeOrUndef(o.filter, "function");
 var assertRimrafOptions = (o) => {
   if (!isRimrafOptions(o)) {
@@ -13875,44 +13875,44 @@ var optArgSync = (opt = {}) => optArgT(opt);
 init_esm_shims();
 import { parse as parse2, resolve } from "path";
 import { inspect } from "util";
-var pathArg = (path70, opt = {}) => {
-  const type = typeof path70;
+var pathArg = (path71, opt = {}) => {
+  const type = typeof path71;
   if (type !== "string") {
-    const ctor = path70 && type === "object" && path70.constructor;
-    const received = ctor && ctor.name ? `an instance of ${ctor.name}` : type === "object" ? inspect(path70) : `type ${type} ${path70}`;
+    const ctor = path71 && type === "object" && path71.constructor;
+    const received = ctor && ctor.name ? `an instance of ${ctor.name}` : type === "object" ? inspect(path71) : `type ${type} ${path71}`;
     const msg = `The "path" argument must be of type string. Received ${received}`;
     throw Object.assign(new TypeError(msg), {
-      path: path70,
+      path: path71,
       code: "ERR_INVALID_ARG_TYPE"
     });
   }
-  if (/\0/.test(path70)) {
+  if (/\0/.test(path71)) {
     const msg = "path must be a string without null bytes";
     throw Object.assign(new TypeError(msg), {
-      path: path70,
+      path: path71,
       code: "ERR_INVALID_ARG_VALUE"
     });
   }
-  path70 = resolve(path70);
-  const { root } = parse2(path70);
-  if (path70 === root && opt.preserveRoot !== false) {
+  path71 = resolve(path71);
+  const { root } = parse2(path71);
+  if (path71 === root && opt.preserveRoot !== false) {
     const msg = "refusing to remove root directory without preserveRoot:false";
     throw Object.assign(new Error(msg), {
-      path: path70,
+      path: path71,
       code: "ERR_PRESERVE_ROOT"
     });
   }
   if (process.platform === "win32") {
     const badWinChars = /[*|"<>?:]/;
-    const { root: root2 } = parse2(path70);
-    if (badWinChars.test(path70.substring(root2.length))) {
+    const { root: root2 } = parse2(path71);
+    if (badWinChars.test(path71.substring(root2.length))) {
       throw Object.assign(new Error("Illegal characters in path."), {
-        path: path70,
+        path: path71,
         code: "EINVAL"
       });
     }
   }
-  return path70;
+  return path71;
 };
 var path_arg_default = pathArg;
 
@@ -13927,11 +13927,11 @@ init_esm_shims();
 import { readdirSync as rdSync } from "fs";
 import fsPromises from "fs/promises";
 import { chmodSync, mkdirSync, renameSync, rmdirSync, rmSync, statSync, lstatSync as lstatSync2, unlinkSync } from "fs";
-var readdirSync2 = (path70) => rdSync(path70, { withFileTypes: true });
+var readdirSync2 = (path71) => rdSync(path71, { withFileTypes: true });
 var promises = {
   chmod: fsPromises.chmod,
   mkdir: fsPromises.mkdir,
-  readdir: (path70) => fsPromises.readdir(path70, { withFileTypes: true }),
+  readdir: (path71) => fsPromises.readdir(path71, { withFileTypes: true }),
   rename: fsPromises.rename,
   rm: fsPromises.rm,
   rmdir: fsPromises.rmdir,
@@ -13946,10 +13946,10 @@ import { parse as parse3, resolve as resolve2 } from "path";
 // ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/readdir-or-error.js
 init_esm_shims();
 var { readdir: readdir2 } = promises;
-var readdirOrError = (path70) => readdir2(path70).catch((er) => er);
-var readdirOrErrorSync = (path70) => {
+var readdirOrError = (path71) => readdir2(path71).catch((er) => er);
+var readdirOrErrorSync = (path71) => {
   try {
-    return readdirSync2(path70);
+    return readdirSync2(path71);
   } catch (er) {
     return er;
   }
@@ -13985,17 +13985,17 @@ var ignoreENOENTSync = (fn, rethrow) => {
 
 // ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/rimraf-posix.js
 var { lstat: lstat2, rmdir, unlink } = promises;
-var rimrafPosix = async (path70, opt) => {
+var rimrafPosix = async (path71, opt) => {
   opt?.signal?.throwIfAborted();
-  return await ignoreENOENT(lstat2(path70).then((stat5) => rimrafPosixDir(path70, opt, stat5))) ?? true;
+  return await ignoreENOENT(lstat2(path71).then((stat5) => rimrafPosixDir(path71, opt, stat5))) ?? true;
 };
-var rimrafPosixSync = (path70, opt) => {
+var rimrafPosixSync = (path71, opt) => {
   opt?.signal?.throwIfAborted();
-  return ignoreENOENTSync(() => rimrafPosixDirSync(path70, opt, lstatSync2(path70))) ?? true;
+  return ignoreENOENTSync(() => rimrafPosixDirSync(path71, opt, lstatSync2(path71))) ?? true;
 };
-var rimrafPosixDir = async (path70, opt, ent) => {
+var rimrafPosixDir = async (path71, opt, ent) => {
   opt?.signal?.throwIfAborted();
-  const entries = ent.isDirectory() ? await readdirOrError(path70) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path71) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (errorCode(entries) === "ENOENT") {
@@ -14005,28 +14005,28 @@ var rimrafPosixDir = async (path70, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path70, ent)) {
+    if (opt.filter && !await opt.filter(path71, ent)) {
       return false;
     }
-    await ignoreENOENT(unlink(path70));
+    await ignoreENOENT(unlink(path71));
     return true;
   }
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafPosixDir(resolve2(path70, ent2.name), opt, ent2)))).every((v) => v === true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafPosixDir(resolve2(path71, ent2.name), opt, ent2)))).every((v) => v === true);
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path70 === parse3(path70).root) {
+  if (opt.preserveRoot === false && path71 === parse3(path71).root) {
     return false;
   }
-  if (opt.filter && !await opt.filter(path70, ent)) {
+  if (opt.filter && !await opt.filter(path71, ent)) {
     return false;
   }
-  await ignoreENOENT(rmdir(path70));
+  await ignoreENOENT(rmdir(path71));
   return true;
 };
-var rimrafPosixDirSync = (path70, opt, ent) => {
+var rimrafPosixDirSync = (path71, opt, ent) => {
   opt?.signal?.throwIfAborted();
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path70) : null;
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path71) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (errorCode(entries) === "ENOENT") {
@@ -14036,27 +14036,27 @@ var rimrafPosixDirSync = (path70, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path70, ent)) {
+    if (opt.filter && !opt.filter(path71, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => unlinkSync(path70));
+    ignoreENOENTSync(() => unlinkSync(path71));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
-    const p = resolve2(path70, ent2.name);
+    const p = resolve2(path71, ent2.name);
     removedAll = rimrafPosixDirSync(p, opt, ent2) && removedAll;
   }
-  if (opt.preserveRoot === false && path70 === parse3(path70).root) {
+  if (opt.preserveRoot === false && path71 === parse3(path71).root) {
     return false;
   }
   if (!removedAll) {
     return false;
   }
-  if (opt.filter && !opt.filter(path70, ent)) {
+  if (opt.filter && !opt.filter(path71, ent)) {
     return false;
   }
-  ignoreENOENTSync(() => rmdirSync(path70));
+  ignoreENOENTSync(() => rmdirSync(path71));
   return true;
 };
 
@@ -14067,28 +14067,28 @@ import { parse as parse6, resolve as resolve5 } from "path";
 // ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/fix-eperm.js
 init_esm_shims();
 var { chmod } = promises;
-var fixEPERM = (fn) => async (path70) => {
+var fixEPERM = (fn) => async (path71) => {
   try {
-    return void await ignoreENOENT(fn(path70));
+    return void await ignoreENOENT(fn(path71));
   } catch (er) {
     if (errorCode(er) === "EPERM") {
-      if (!await ignoreENOENT(chmod(path70, 438).then(() => true), er)) {
+      if (!await ignoreENOENT(chmod(path71, 438).then(() => true), er)) {
         return;
       }
-      return void await fn(path70);
+      return void await fn(path71);
     }
     throw er;
   }
 };
-var fixEPERMSync = (fn) => (path70) => {
+var fixEPERMSync = (fn) => (path71) => {
   try {
-    return void ignoreENOENTSync(() => fn(path70));
+    return void ignoreENOENTSync(() => fn(path71));
   } catch (er) {
     if (errorCode(er) === "EPERM") {
-      if (!ignoreENOENTSync(() => (chmodSync(path70, 438), true), er)) {
+      if (!ignoreENOENTSync(() => (chmodSync(path71, 438), true), er)) {
         return;
       }
-      return void fn(path70);
+      return void fn(path71);
     }
     throw er;
   }
@@ -14102,21 +14102,21 @@ var RATE = 1.2;
 var MAXRETRIES = 10;
 var codes = /* @__PURE__ */ new Set(["EMFILE", "ENFILE", "EBUSY"]);
 var retryBusy = (fn) => {
-  const method = async (path70, opt, backoff = 1, total = 0) => {
+  const method = async (path71, 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(path70);
+        return await fn(path71);
       } catch (er) {
-        if (isFsError(er) && er.path === path70 && codes.has(er.code)) {
+        if (isFsError(er) && er.path === path71 && codes.has(er.code)) {
           backoff = Math.ceil(backoff * rate);
           total = backoff + total;
           if (total < mbo) {
             await setTimeout2(backoff);
-            return method(path70, opt, backoff, total);
+            return method(path71, opt, backoff, total);
           }
           if (retries < max) {
             retries++;
@@ -14130,14 +14130,14 @@ var retryBusy = (fn) => {
   return method;
 };
 var retryBusySync = (fn) => {
-  const method = (path70, opt) => {
+  const method = (path71, opt) => {
     const max = opt.maxRetries || MAXRETRIES;
     let retries = 0;
     while (true) {
       try {
-        return fn(path70);
+        return fn(path71);
       } catch (er) {
-        if (isFsError(er) && er.path === path70 && codes.has(er.code) && retries < max) {
+        if (isFsError(er) && er.path === path71 && codes.has(er.code) && retries < max) {
           retries++;
           continue;
         }
@@ -14157,16 +14157,16 @@ init_esm_shims();
 import { tmpdir } from "os";
 import { parse as parse4, resolve as resolve3 } from "path";
 var { stat } = promises;
-var isDirSync = (path70) => {
+var isDirSync = (path71) => {
   try {
-    return statSync(path70).isDirectory();
+    return statSync(path71).isDirectory();
   } catch {
     return false;
   }
 };
-var isDir = (path70) => stat(path70).then((st) => st.isDirectory(), () => false);
-var win32DefaultTmp = async (path70) => {
-  const { root } = parse4(path70);
+var isDir = (path71) => stat(path71).then((st) => st.isDirectory(), () => false);
+var win32DefaultTmp = async (path71) => {
+  const { root } = parse4(path71);
   const tmp = tmpdir();
   const { root: tmpRoot } = parse4(tmp);
   if (root.toLowerCase() === tmpRoot.toLowerCase()) {
@@ -14178,8 +14178,8 @@ var win32DefaultTmp = async (path70) => {
   }
   return root;
 };
-var win32DefaultTmpSync = (path70) => {
-  const { root } = parse4(path70);
+var win32DefaultTmpSync = (path71) => {
+  const { root } = parse4(path71);
   const tmp = tmpdir();
   const { root: tmpRoot } = parse4(tmp);
   if (root.toLowerCase() === tmpRoot.toLowerCase()) {
@@ -14198,22 +14198,22 @@ var defaultTmpSync = process.platform === "win32" ? win32DefaultTmpSync : posixD
 
 // ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/rimraf-move-remove.js
 var { lstat: lstat3, rename, unlink: unlink2, rmdir: rmdir2 } = promises;
-var uniqueFilename = (path70) => `.${basename(path70)}.${Math.random()}`;
+var uniqueFilename = (path71) => `.${basename(path71)}.${Math.random()}`;
 var unlinkFixEPERM = fixEPERM(unlink2);
 var unlinkFixEPERMSync = fixEPERMSync(unlinkSync);
-var rimrafMoveRemove = async (path70, opt) => {
+var rimrafMoveRemove = async (path71, opt) => {
   opt?.signal?.throwIfAborted();
-  return await ignoreENOENT(lstat3(path70).then((stat5) => rimrafMoveRemoveDir(path70, opt, stat5))) ?? true;
+  return await ignoreENOENT(lstat3(path71).then((stat5) => rimrafMoveRemoveDir(path71, opt, stat5))) ?? true;
 };
-var rimrafMoveRemoveDir = async (path70, opt, ent) => {
+var rimrafMoveRemoveDir = async (path71, opt, ent) => {
   opt?.signal?.throwIfAborted();
   if (!opt.tmp) {
-    return rimrafMoveRemoveDir(path70, { ...opt, tmp: await defaultTmp(path70) }, ent);
+    return rimrafMoveRemoveDir(path71, { ...opt, tmp: await defaultTmp(path71) }, ent);
   }
-  if (path70 === opt.tmp && parse5(path70).root !== path70) {
+  if (path71 === opt.tmp && parse5(path71).root !== path71) {
     throw new Error("cannot delete temp directory used for deletion");
   }
-  const entries = ent.isDirectory() ? await readdirOrError(path70) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path71) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (errorCode(entries) === "ENOENT") {
@@ -14223,44 +14223,44 @@ var rimrafMoveRemoveDir = async (path70, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path70, ent)) {
+    if (opt.filter && !await opt.filter(path71, ent)) {
       return false;
     }
-    await ignoreENOENT(tmpUnlink(path70, opt.tmp, unlinkFixEPERM));
+    await ignoreENOENT(tmpUnlink(path71, opt.tmp, unlinkFixEPERM));
     return true;
   }
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafMoveRemoveDir(resolve4(path70, ent2.name), opt, ent2)))).every((v) => v === true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafMoveRemoveDir(resolve4(path71, ent2.name), opt, ent2)))).every((v) => v === true);
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path70 === parse5(path70).root) {
+  if (opt.preserveRoot === false && path71 === parse5(path71).root) {
     return false;
   }
-  if (opt.filter && !await opt.filter(path70, ent)) {
+  if (opt.filter && !await opt.filter(path71, ent)) {
     return false;
   }
-  await ignoreENOENT(tmpUnlink(path70, opt.tmp, rmdir2));
+  await ignoreENOENT(tmpUnlink(path71, opt.tmp, rmdir2));
   return true;
 };
-var tmpUnlink = async (path70, tmp, rm2) => {
-  const tmpFile = resolve4(tmp, uniqueFilename(path70));
-  await rename(path70, tmpFile);
+var tmpUnlink = async (path71, tmp, rm2) => {
+  const tmpFile = resolve4(tmp, uniqueFilename(path71));
+  await rename(path71, tmpFile);
   return await rm2(tmpFile);
 };
-var rimrafMoveRemoveSync = (path70, opt) => {
+var rimrafMoveRemoveSync = (path71, opt) => {
   opt?.signal?.throwIfAborted();
-  return ignoreENOENTSync(() => rimrafMoveRemoveDirSync(path70, opt, lstatSync2(path70))) ?? true;
+  return ignoreENOENTSync(() => rimrafMoveRemoveDirSync(path71, opt, lstatSync2(path71))) ?? true;
 };
-var rimrafMoveRemoveDirSync = (path70, opt, ent) => {
+var rimrafMoveRemoveDirSync = (path71, opt, ent) => {
   opt?.signal?.throwIfAborted();
   if (!opt.tmp) {
-    return rimrafMoveRemoveDirSync(path70, { ...opt, tmp: defaultTmpSync(path70) }, ent);
+    return rimrafMoveRemoveDirSync(path71, { ...opt, tmp: defaultTmpSync(path71) }, ent);
   }
   const tmp = opt.tmp;
-  if (path70 === opt.tmp && parse5(path70).root !== path70) {
+  if (path71 === opt.tmp && parse5(path71).root !== path71) {
     throw new Error("cannot delete temp directory used for deletion");
   }
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path70) : null;
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path71) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (errorCode(entries) === "ENOENT") {
@@ -14270,32 +14270,32 @@ var rimrafMoveRemoveDirSync = (path70, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path70, ent)) {
+    if (opt.filter && !opt.filter(path71, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => tmpUnlinkSync(path70, tmp, unlinkFixEPERMSync));
+    ignoreENOENTSync(() => tmpUnlinkSync(path71, tmp, unlinkFixEPERMSync));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
-    const p = resolve4(path70, ent2.name);
+    const p = resolve4(path71, ent2.name);
     removedAll = rimrafMoveRemoveDirSync(p, opt, ent2) && removedAll;
   }
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path70 === parse5(path70).root) {
+  if (opt.preserveRoot === false && path71 === parse5(path71).root) {
     return false;
   }
-  if (opt.filter && !opt.filter(path70, ent)) {
+  if (opt.filter && !opt.filter(path71, ent)) {
     return false;
   }
-  ignoreENOENTSync(() => tmpUnlinkSync(path70, tmp, rmdirSync));
+  ignoreENOENTSync(() => tmpUnlinkSync(path71, tmp, rmdirSync));
   return true;
 };
-var tmpUnlinkSync = (path70, tmp, rmSync2) => {
-  const tmpFile = resolve4(tmp, uniqueFilename(path70));
-  renameSync(path70, tmpFile);
+var tmpUnlinkSync = (path71, tmp, rmSync2) => {
+  const tmpFile = resolve4(tmp, uniqueFilename(path71));
+  renameSync(path71, tmpFile);
   return rmSync2(tmpFile);
 };
 
@@ -14305,26 +14305,26 @@ var rimrafWindowsFile = retryBusy(fixEPERM(unlink3));
 var rimrafWindowsFileSync = retryBusySync(fixEPERMSync(unlinkSync));
 var rimrafWindowsDirRetry = retryBusy(fixEPERM(rmdir3));
 var rimrafWindowsDirRetrySync = retryBusySync(fixEPERMSync(rmdirSync));
-var rimrafWindowsDirMoveRemoveFallback = async (path70, { filter: filter3, ...opt }) => {
+var rimrafWindowsDirMoveRemoveFallback = async (path71, { filter: filter3, ...opt }) => {
   opt?.signal?.throwIfAborted();
   try {
-    await rimrafWindowsDirRetry(path70, opt);
+    await rimrafWindowsDirRetry(path71, opt);
     return true;
   } catch (er) {
     if (errorCode(er) === "ENOTEMPTY") {
-      return rimrafMoveRemove(path70, opt);
+      return rimrafMoveRemove(path71, opt);
     }
     throw er;
   }
 };
-var rimrafWindowsDirMoveRemoveFallbackSync = (path70, { filter: filter3, ...opt }) => {
+var rimrafWindowsDirMoveRemoveFallbackSync = (path71, { filter: filter3, ...opt }) => {
   opt?.signal?.throwIfAborted();
   try {
-    rimrafWindowsDirRetrySync(path70, opt);
+    rimrafWindowsDirRetrySync(path71, opt);
     return true;
   } catch (er) {
     if (errorCode(er) === "ENOTEMPTY") {
-      return rimrafMoveRemoveSync(path70, opt);
+      return rimrafMoveRemoveSync(path71, opt);
     }
     throw er;
   }
@@ -14332,17 +14332,17 @@ var rimrafWindowsDirMoveRemoveFallbackSync = (path70, { filter: filter3, ...opt
 var START = /* @__PURE__ */ Symbol("start");
 var CHILD = /* @__PURE__ */ Symbol("child");
 var FINISH = /* @__PURE__ */ Symbol("finish");
-var rimrafWindows = async (path70, opt) => {
+var rimrafWindows = async (path71, opt) => {
   opt?.signal?.throwIfAborted();
-  return await ignoreENOENT(lstat4(path70).then((stat5) => rimrafWindowsDir(path70, opt, stat5, START))) ?? true;
+  return await ignoreENOENT(lstat4(path71).then((stat5) => rimrafWindowsDir(path71, opt, stat5, START))) ?? true;
 };
-var rimrafWindowsSync = (path70, opt) => {
+var rimrafWindowsSync = (path71, opt) => {
   opt?.signal?.throwIfAborted();
-  return ignoreENOENTSync(() => rimrafWindowsDirSync(path70, opt, lstatSync2(path70), START)) ?? true;
+  return ignoreENOENTSync(() => rimrafWindowsDirSync(path71, opt, lstatSync2(path71), START)) ?? true;
 };
-var rimrafWindowsDir = async (path70, opt, ent, state = START) => {
+var rimrafWindowsDir = async (path71, opt, ent, state = START) => {
   opt?.signal?.throwIfAborted();
-  const entries = ent.isDirectory() ? await readdirOrError(path70) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path71) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (errorCode(entries) === "ENOENT") {
@@ -14352,32 +14352,32 @@ var rimrafWindowsDir = async (path70, opt, ent, state = START) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path70, ent)) {
+    if (opt.filter && !await opt.filter(path71, ent)) {
       return false;
     }
-    await ignoreENOENT(rimrafWindowsFile(path70, opt));
+    await ignoreENOENT(rimrafWindowsFile(path71, opt));
     return true;
   }
   const s = state === START ? CHILD : state;
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafWindowsDir(resolve5(path70, ent2.name), opt, ent2, s)))).every((v) => v === true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafWindowsDir(resolve5(path71, ent2.name), opt, ent2, s)))).every((v) => v === true);
   if (state === START) {
-    return rimrafWindowsDir(path70, opt, ent, FINISH);
+    return rimrafWindowsDir(path71, opt, ent, FINISH);
   } else if (state === FINISH) {
-    if (opt.preserveRoot === false && path70 === parse6(path70).root) {
+    if (opt.preserveRoot === false && path71 === parse6(path71).root) {
       return false;
     }
     if (!removedAll) {
       return false;
     }
-    if (opt.filter && !await opt.filter(path70, ent)) {
+    if (opt.filter && !await opt.filter(path71, ent)) {
       return false;
     }
-    await ignoreENOENT(rimrafWindowsDirMoveRemoveFallback(path70, opt));
+    await ignoreENOENT(rimrafWindowsDirMoveRemoveFallback(path71, opt));
   }
   return true;
 };
-var rimrafWindowsDirSync = (path70, opt, ent, state = START) => {
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path70) : null;
+var rimrafWindowsDirSync = (path71, opt, ent, state = START) => {
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path71) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (errorCode(entries) === "ENOENT") {
@@ -14387,31 +14387,31 @@ var rimrafWindowsDirSync = (path70, opt, ent, state = START) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path70, ent)) {
+    if (opt.filter && !opt.filter(path71, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => rimrafWindowsFileSync(path70, opt));
+    ignoreENOENTSync(() => rimrafWindowsFileSync(path71, opt));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
     const s = state === START ? CHILD : state;
-    const p = resolve5(path70, ent2.name);
+    const p = resolve5(path71, ent2.name);
     removedAll = rimrafWindowsDirSync(p, opt, ent2, s) && removedAll;
   }
   if (state === START) {
-    return rimrafWindowsDirSync(path70, opt, ent, FINISH);
+    return rimrafWindowsDirSync(path71, opt, ent, FINISH);
   } else if (state === FINISH) {
-    if (opt.preserveRoot === false && path70 === parse6(path70).root) {
+    if (opt.preserveRoot === false && path71 === parse6(path71).root) {
       return false;
     }
     if (!removedAll) {
       return false;
     }
-    if (opt.filter && !opt.filter(path70, ent)) {
+    if (opt.filter && !opt.filter(path71, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => rimrafWindowsDirMoveRemoveFallbackSync(path70, opt));
+    ignoreENOENTSync(() => rimrafWindowsDirMoveRemoveFallbackSync(path71, opt));
   }
   return true;
 };
@@ -14423,16 +14423,16 @@ var rimrafManualSync = process.platform === "win32" ? rimrafWindowsSync : rimraf
 // ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/rimraf-native.js
 init_esm_shims();
 var { rm } = promises;
-var rimrafNative = async (path70, opt) => {
-  await rm(path70, {
+var rimrafNative = async (path71, opt) => {
+  await rm(path71, {
     ...opt,
     force: true,
     recursive: true
   });
   return true;
 };
-var rimrafNativeSync = (path70, opt) => {
-  rmSync(path70, {
+var rimrafNativeSync = (path71, opt) => {
+  rmSync(path71, {
     ...opt,
     force: true,
     recursive: true
@@ -14448,26 +14448,26 @@ var useNative = !hasNative || process.platform === "win32" ? () => false : (opt)
 var useNativeSync = !hasNative || process.platform === "win32" ? () => false : (opt) => !opt?.signal && !opt?.filter;
 
 // ../../node_modules/.pnpm/rimraf@6.1.2/node_modules/rimraf/dist/esm/index.js
-var wrap = (fn) => async (path70, opt) => {
+var wrap = (fn) => async (path71, opt) => {
   const options = optArg(opt);
   if (options.glob) {
-    path70 = await glob(path70, options.glob);
+    path71 = await glob(path71, options.glob);
   }
-  if (Array.isArray(path70)) {
-    return !!(await Promise.all(path70.map((p) => fn(path_arg_default(p, options), options)))).reduce((a, b) => a && b, true);
+  if (Array.isArray(path71)) {
+    return !!(await Promise.all(path71.map((p) => fn(path_arg_default(p, options), options)))).reduce((a, b) => a && b, true);
   } else {
-    return !!await fn(path_arg_default(path70, options), options);
+    return !!await fn(path_arg_default(path71, options), options);
   }
 };
-var wrapSync = (fn) => (path70, opt) => {
+var wrapSync = (fn) => (path71, opt) => {
   const options = optArgSync(opt);
   if (options.glob) {
-    path70 = globSync(path70, options.glob);
+    path71 = globSync(path71, options.glob);
   }
-  if (Array.isArray(path70)) {
-    return !!path70.map((p) => fn(path_arg_default(p, options), options)).reduce((a, b) => a && b, true);
+  if (Array.isArray(path71)) {
+    return !!path71.map((p) => fn(path_arg_default(p, options), options)).reduce((a, b) => a && b, true);
   } else {
-    return !!fn(path_arg_default(path70, options), options);
+    return !!fn(path_arg_default(path71, options), options);
   }
 };
 var nativeSync = wrapSync(rimrafNativeSync);
@@ -14482,8 +14482,8 @@ var moveRemoveSync = wrapSync(rimrafMoveRemoveSync);
 var moveRemove = Object.assign(wrap(rimrafMoveRemove), {
   sync: moveRemoveSync
 });
-var rimrafSync = wrapSync((path70, opt) => useNativeSync(opt) ? rimrafNativeSync(path70, opt) : rimrafManualSync(path70, opt));
-var rimraf_ = wrap((path70, opt) => useNative(opt) ? rimrafNative(path70, opt) : rimrafManual(path70, opt));
+var rimrafSync = wrapSync((path71, opt) => useNativeSync(opt) ? rimrafNativeSync(path71, opt) : rimrafManualSync(path71, opt));
+var rimraf_ = wrap((path71, opt) => useNative(opt) ? rimrafNative(path71, opt) : rimrafManual(path71, opt));
 var rimraf = Object.assign(rimraf_, {
   rimraf: rimraf_,
   sync: rimrafSync,
@@ -14635,7 +14635,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat5 : stat2;
     if (wantBigintFsStats) {
-      this._stat = (path70) => statMethod(path70, { bigint: true });
+      this._stat = (path71) => statMethod(path71, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -14660,8 +14660,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path70, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path70));
+          const { path: path71, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path71));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -14701,20 +14701,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path70, depth) {
+  async _exploreDir(path71, depth) {
     let files;
     try {
-      files = await readdir3(path70, this._rdOptions);
+      files = await readdir3(path71, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path70 };
+    return { files, depth, path: path71 };
   }
-  async _formatEntry(dirent, path70) {
+  async _formatEntry(dirent, path71) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path70, basename4));
+      const fullPath = presolve(pjoin(path71, basename4));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -15115,16 +15115,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path70, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path71, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path70);
-    emitRaw(rawEvent, evPath, { watchedPath: path70 });
-    if (evPath && path70 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path70, evPath), KEY_LISTENERS, sp.join(path70, evPath));
+    listener(path71);
+    emitRaw(rawEvent, evPath, { watchedPath: path71 });
+    if (evPath && path71 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path71, evPath), KEY_LISTENERS, sp.join(path71, evPath));
     }
   };
   try {
-    return fs_watch(path70, {
+    return fs_watch(path71, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -15140,12 +15140,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path70, fullPath, options, handlers) => {
+var setFsWatchListener = (path71, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path70, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path71, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -15156,7 +15156,7 @@ var setFsWatchListener = (path70, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path70,
+      path71,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -15171,7 +15171,7 @@ var setFsWatchListener = (path70, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path70, "r");
+          const fd = await open(path71, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -15202,7 +15202,7 @@ var setFsWatchListener = (path70, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path70, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path71, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -15224,7 +15224,7 @@ var setFsWatchFileListener = (path70, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path70, curr));
+          foreach(cont.listeners, (listener2) => listener2(path71, curr));
         }
       })
     };
@@ -15254,13 +15254,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path70, listener) {
+  _watchWithNodeFs(path71, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path70);
-    const basename4 = sp.basename(path70);
+    const directory = sp.dirname(path71);
+    const basename4 = sp.basename(path71);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename4);
-    const absolutePath = sp.resolve(path70);
+    const absolutePath = sp.resolve(path71);
     const options = {
       persistent: opts.persistent
     };
@@ -15270,12 +15270,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path70, absolutePath, options, {
+      closer = setFsWatchFileListener(path71, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path70, absolutePath, options, {
+      closer = setFsWatchListener(path71, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -15297,7 +15297,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename4))
       return;
-    const listener = async (path70, newStats) => {
+    const listener = async (path71, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -15311,11 +15311,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path70);
+            this.fsw._closeFile(path71);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path70, closer2);
+              this.fsw._addPathCloser(path71, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -15347,7 +15347,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, path70, item) {
+  async _handleSymlink(entry, directory, path71, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -15357,7 +15357,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path70);
+        linkPath = await fsrealpath(path71);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -15367,12 +15367,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, path70, entry.stats);
+          this.fsw._emit(EV.CHANGE, path71, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path70, entry.stats);
+        this.fsw._emit(EV.ADD, path71, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -15402,9 +15402,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path70 = sp.join(directory, item);
+      let path71 = sp.join(directory, item);
       current2.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path70, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path71, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -15413,8 +15413,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path70 = sp.join(dir, sp.relative(dir, path70));
-        this._addToNodeFs(path70, initialAdd, wh, depth + 1);
+        path71 = sp.join(dir, sp.relative(dir, path71));
+        this._addToNodeFs(path71, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve8, reject) => {
@@ -15483,13 +15483,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path70, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path71, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path70) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path71) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path70);
+    const wh = this.fsw._getWatchHelpers(path71);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -15505,8 +15505,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path70);
-        const targetPath = follow ? await fsrealpath(path70) : path70;
+        const absPath = sp.resolve(path71);
+        const targetPath = follow ? await fsrealpath(path71) : path71;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -15516,29 +15516,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path70) : path70;
+        const targetPath = follow ? await fsrealpath(path71) : path71;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path70, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path71, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path70), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path71), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path70, closer);
+        this.fsw._addPathCloser(path71, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path70;
+        return path71;
       }
     }
   }
@@ -15581,24 +15581,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path70) {
-  if (typeof path70 !== "string")
+function normalizePath(path71) {
+  if (typeof path71 !== "string")
     throw new Error("string expected");
-  path70 = sp2.normalize(path70);
-  path70 = path70.replace(/\\/g, "/");
+  path71 = sp2.normalize(path71);
+  path71 = path71.replace(/\\/g, "/");
   let prepend = false;
-  if (path70.startsWith("//"))
+  if (path71.startsWith("//"))
     prepend = true;
-  path70 = path70.replace(DOUBLE_SLASH_RE, "/");
+  path71 = path71.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path70 = "/" + path70;
-  return path70;
+    path71 = "/" + path71;
+  return path71;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path70 = normalizePath(testString);
+  const path71 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path70, stats)) {
+    if (pattern(path71, stats)) {
       return true;
     }
   }
@@ -15636,19 +15636,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path70) => toUnix(sp2.normalize(toUnix(path70)));
-var normalizeIgnored = (cwd = "") => (path70) => {
-  if (typeof path70 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path70) ? path70 : sp2.join(cwd, path70));
+var normalizePathToUnix = (path71) => toUnix(sp2.normalize(toUnix(path71)));
+var normalizeIgnored = (cwd = "") => (path71) => {
+  if (typeof path71 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path71) ? path71 : sp2.join(cwd, path71));
   } else {
-    return path70;
+    return path71;
   }
 };
-var getAbsolutePath = (path70, cwd) => {
-  if (sp2.isAbsolute(path70)) {
-    return path70;
+var getAbsolutePath = (path71, cwd) => {
+  if (sp2.isAbsolute(path71)) {
+    return path71;
   }
-  return sp2.join(cwd, path70);
+  return sp2.join(cwd, path71);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -15713,10 +15713,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path70, follow, fsw) {
+  constructor(path71, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path70;
-    this.path = path70 = path70.replace(REPLACER_RE, "");
+    const watchPath = path71;
+    this.path = path71 = path71.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -15856,20 +15856,20 @@ var FSWatcher = class extends EventEmitter2 {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path70) => {
-        const absPath = getAbsolutePath(path70, cwd);
+      paths = paths.map((path71) => {
+        const absPath = getAbsolutePath(path71, cwd);
         return absPath;
       });
     }
-    paths.forEach((path70) => {
-      this._removeIgnoredPath(path70);
+    paths.forEach((path71) => {
+      this._removeIgnoredPath(path71);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path70) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path70, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path71) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path71, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -15891,17 +15891,17 @@ var FSWatcher = class extends EventEmitter2 {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path70) => {
-      if (!sp2.isAbsolute(path70) && !this._closers.has(path70)) {
+    paths.forEach((path71) => {
+      if (!sp2.isAbsolute(path71) && !this._closers.has(path71)) {
         if (cwd)
-          path70 = sp2.join(cwd, path70);
-        path70 = sp2.resolve(path70);
+          path71 = sp2.join(cwd, path71);
+        path71 = sp2.resolve(path71);
       }
-      this._closePath(path70);
-      this._addIgnoredPath(path70);
-      if (this._watched.has(path70)) {
+      this._closePath(path71);
+      this._addIgnoredPath(path71);
+      if (this._watched.has(path71)) {
         this._addIgnoredPath({
-          path: path70,
+          path: path71,
           recursive: true
         });
       }
@@ -15965,38 +15965,38 @@ var FSWatcher = class extends EventEmitter2 {
    * @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, path70, stats) {
+  async _emit(event, path71, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path70 = sp2.normalize(path70);
+      path71 = sp2.normalize(path71);
     if (opts.cwd)
-      path70 = sp2.relative(opts.cwd, path70);
-    const args = [path70];
+      path71 = sp2.relative(opts.cwd, path71);
+    const args = [path71];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path70))) {
+    if (awf && (pw = this._pendingWrites.get(path71))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path70, [event, ...args]);
+        this._pendingUnlinks.set(path71, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path71) => {
+          this._pendingUnlinks.forEach((entry, path72) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path71);
+            this._pendingUnlinks.delete(path72);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path70)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path71)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path70);
+        this._pendingUnlinks.delete(path71);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -16014,16 +16014,16 @@ var FSWatcher = class extends EventEmitter2 {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path70, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path71, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path70, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path71, 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 ? sp2.join(opts.cwd, path70) : path70;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path71) : path71;
       let stats2;
       try {
         stats2 = await stat4(fullPath);
@@ -16054,23 +16054,23 @@ var FSWatcher = class extends EventEmitter2 {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path70, timeout) {
+  _throttle(actionType, path71, 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(path70);
+    const actionPath = action.get(path71);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path70);
+      const item = action.get(path71);
       const count = item ? item.count : 0;
-      action.delete(path70);
+      action.delete(path71);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -16078,7 +16078,7 @@ var FSWatcher = class extends EventEmitter2 {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path70, thr);
+    action.set(path71, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -16092,44 +16092,44 @@ var FSWatcher = class extends EventEmitter2 {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path70, threshold, event, awfEmit) {
+  _awaitWriteFinish(path71, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path70;
-    if (this.options.cwd && !sp2.isAbsolute(path70)) {
-      fullPath = sp2.join(this.options.cwd, path70);
+    let fullPath = path71;
+    if (this.options.cwd && !sp2.isAbsolute(path71)) {
+      fullPath = sp2.join(this.options.cwd, path71);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path70)) {
+        if (err || !writes.has(path71)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path70).lastChange = now2;
+          writes.get(path71).lastChange = now2;
         }
-        const pw = writes.get(path70);
+        const pw = writes.get(path71);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path70);
+          writes.delete(path71);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path70)) {
-      writes.set(path70, {
+    if (!writes.has(path71)) {
+      writes.set(path71, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path70);
+          writes.delete(path71);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -16140,8 +16140,8 @@ var FSWatcher = class extends EventEmitter2 {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path70, stats) {
-    if (this.options.atomic && DOT_RE.test(path70))
+  _isIgnored(path71, stats) {
+    if (this.options.atomic && DOT_RE.test(path71))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -16151,17 +16151,17 @@ var FSWatcher = class extends EventEmitter2 {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path70, stats);
+    return this._userIgnored(path71, stats);
   }
-  _isntIgnored(path70, stat5) {
-    return !this._isIgnored(path70, stat5);
+  _isntIgnored(path71, stat5) {
+    return !this._isIgnored(path71, stat5);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path70) {
-    return new WatchHelper(path70, this.options.followSymlinks, this);
+  _getWatchHelpers(path71) {
+    return new WatchHelper(path71, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -16193,63 +16193,63 @@ var FSWatcher = class extends EventEmitter2 {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path70 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path70);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path70) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path70, 100))
+    const path71 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path71);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path71) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path71, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path70);
+    const wp = this._getWatchedDir(path71);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path70, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path71, 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 = path70;
+    let relPath = path71;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path70);
+      relPath = sp2.relative(this.options.cwd, path71);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path70);
+    this._watched.delete(path71);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path70))
-      this._emit(eventName, path70);
-    this._closePath(path70);
+    if (wasTracked && !this._isIgnored(path71))
+      this._emit(eventName, path71);
+    this._closePath(path71);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path70) {
-    this._closeFile(path70);
-    const dir = sp2.dirname(path70);
-    this._getWatchedDir(dir).remove(sp2.basename(path70));
+  _closePath(path71) {
+    this._closeFile(path71);
+    const dir = sp2.dirname(path71);
+    this._getWatchedDir(dir).remove(sp2.basename(path71));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path70) {
-    const closers = this._closers.get(path70);
+  _closeFile(path71) {
+    const closers = this._closers.get(path71);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path70);
+    this._closers.delete(path71);
   }
-  _addPathCloser(path70, closer) {
+  _addPathCloser(path71, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path70);
+    let list = this._closers.get(path71);
     if (!list) {
       list = [];
-      this._closers.set(path70, list);
+      this._closers.set(path71, list);
     }
     list.push(closer);
   }
@@ -18319,11 +18319,11 @@ pp$8.parseImportAttribute = function() {
 };
 pp$8.parseModuleExportName = function() {
   if (this.options.ecmaVersion >= 13 && this.type === types$1.string) {
-    var stringLiteral11 = this.parseLiteral(this.value);
-    if (loneSurrogate.test(stringLiteral11.value)) {
-      this.raise(stringLiteral11.start, "An export name cannot include a lone surrogate.");
+    var stringLiteral12 = this.parseLiteral(this.value);
+    if (loneSurrogate.test(stringLiteral12.value)) {
+      this.raise(stringLiteral12.start, "An export name cannot include a lone surrogate.");
     }
-    return stringLiteral11;
+    return stringLiteral12;
   }
   return this.parseIdent(true);
 };
@@ -22151,17 +22151,17 @@ function withTrailingSlash(input = "", respectQueryAndFragment) {
   if (hasTrailingSlash(input, true)) {
     return input || "/";
   }
-  let path70 = input;
+  let path71 = input;
   let fragment = "";
   const fragmentIndex = input.indexOf("#");
   if (fragmentIndex !== -1) {
-    path70 = input.slice(0, fragmentIndex);
+    path71 = input.slice(0, fragmentIndex);
     fragment = input.slice(fragmentIndex);
-    if (!path70) {
+    if (!path71) {
       return fragment;
     }
   }
-  const [s0, ...s] = path70.split("?");
+  const [s0, ...s] = path71.split("?");
   return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
 }
 function isNonEmptyURL(url) {
@@ -22189,8 +22189,8 @@ import path20, { dirname as dirname3 } from "path";
 import v8 from "v8";
 import { format, inspect as inspect2 } from "util";
 var BUILTIN_MODULES = new Set(builtinModules);
-function normalizeSlash(path70) {
-  return path70.replace(/\\/g, "/");
+function normalizeSlash(path71) {
+  return path71.replace(/\\/g, "/");
 }
 var own$1 = {}.hasOwnProperty;
 var classRegExp = /^([A-Z][a-z\d]*)+$/;
@@ -22303,8 +22303,8 @@ codes2.ERR_INVALID_PACKAGE_CONFIG = createError(
    * @param {string} [base]
    * @param {string} [message]
    */
-  (path70, base, message) => {
-    return `Invalid package config ${path70}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+  (path71, base, message) => {
+    return `Invalid package config ${path71}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
   },
   Error
 );
@@ -22336,8 +22336,8 @@ codes2.ERR_MODULE_NOT_FOUND = createError(
    * @param {string} base
    * @param {boolean} [exactUrl]
    */
-  (path70, base, exactUrl = false) => {
-    return `Cannot find ${exactUrl ? "module" : "package"} '${path70}' imported from ${base}`;
+  (path71, base, exactUrl = false) => {
+    return `Cannot find ${exactUrl ? "module" : "package"} '${path71}' imported from ${base}`;
   },
   Error
 );
@@ -22388,8 +22388,8 @@ codes2.ERR_UNKNOWN_FILE_EXTENSION = createError(
    * @param {string} extension
    * @param {string} path
    */
-  (extension, path70) => {
-    return `Unknown file extension "${extension}" for ${path70}`;
+  (extension, path71) => {
+    return `Unknown file extension "${extension}" for ${path71}`;
   },
   TypeError
 );
@@ -22760,9 +22760,9 @@ Default "index" lookups for the main are deprecated for ES modules.`,
     );
   }
 }
-function tryStatSync(path70) {
+function tryStatSync(path71) {
   try {
-    return statSync2(path70);
+    return statSync2(path71);
   } catch {
   }
 }
@@ -23681,7 +23681,7 @@ function findUpSync(name, {
     directory = path21.dirname(directory);
   }
 }
-function _resolve2(path70, options = {}) {
+function _resolve2(path71, options = {}) {
   if (options.platform === "auto" || !options.platform)
     options.platform = process3.platform === "win32" ? "win32" : "posix";
   if (process3.versions.pnp) {
@@ -23690,11 +23690,11 @@ function _resolve2(path70, options = {}) {
       paths.push(process3.cwd());
     const targetRequire = createRequire4(import.meta.url);
     try {
-      return targetRequire.resolve(path70, { paths });
+      return targetRequire.resolve(path71, { paths });
     } catch {
     }
   }
-  const modulePath = resolvePathSync(path70, {
+  const modulePath = resolvePathSync(path71, {
     url: options.paths
   });
   if (options.platform === "win32")
@@ -23765,10 +23765,10 @@ var findUp = quansync2({
   async: findUp$1
 });
 var loadPackageJSON = quansync2(function* (cwd = process3.cwd()) {
-  const path70 = yield findUp("package.json", { cwd });
-  if (!path70 || !fs11.existsSync(path70))
+  const path71 = yield findUp("package.json", { cwd });
+  if (!path71 || !fs11.existsSync(path71))
     return null;
-  return JSON.parse(yield readFile(path70));
+  return JSON.parse(yield readFile(path71));
 });
 var loadPackageJSONSync = loadPackageJSON.sync;
 var isPackageListed = quansync2(function* (name, cwd) {
@@ -23942,7 +23942,7 @@ function isMetadataYarnClassic(metadataPath) {
 }
 
 // src/runtime/config/createConfigService.ts
-import path61 from "pathe";
+import path62 from "pathe";
 
 // src/platform.ts
 init_esm_shims();
@@ -24950,7 +24950,7 @@ function mergeInlineConfig(config, injectBuiltinAliases, ...configs) {
 // src/runtime/config/internal/merge/miniprogram.ts
 init_esm_shims();
 import { defu as defu4 } from "@weapp-core/shared";
-import path60 from "pathe";
+import path61 from "pathe";
 
 // src/runtime/config/internal/merge/plugins.ts
 init_esm_shims();
@@ -25938,7 +25938,7 @@ function createEntryResolver() {
 init_esm_shims();
 import { removeExtensionDeep as removeExtensionDeep5 } from "@weapp-core/shared";
 import fs18 from "fs-extra";
-import path35 from "pathe";
+import path36 from "pathe";
 
 // src/utils/vueTemplateTags.ts
 init_esm_shims();
@@ -26107,13 +26107,184 @@ function collectVueTemplateTags(template, options) {
 
 // src/plugins/utils/vueSfc.ts
 init_esm_shims();
+import path35 from "pathe";
 import { parse as parseSfc } from "vue/compiler-sfc";
 var sfcParseCache = new LRUCache({
   max: 512
 });
+var SCRIPT_SETUP_SRC_ATTR = "data-weapp-vite-src";
+var SCRIPT_SRC_ATTR = "data-weapp-vite-script-src";
+var SCRIPT_SETUP_TAG_RE = /<script\b([^>]*)>/gi;
+var SCRIPT_LANG_EXT = /* @__PURE__ */ new Map([
+  [".ts", "ts"],
+  [".tsx", "tsx"],
+  [".js", "js"],
+  [".jsx", "jsx"],
+  [".mjs", "js"],
+  [".cjs", "js"]
+]);
+var STYLE_LANG_EXT = /* @__PURE__ */ new Map([
+  [".css", "css"],
+  [".scss", "scss"],
+  [".sass", "sass"],
+  [".less", "less"],
+  [".styl", "styl"],
+  [".stylus", "styl"]
+]);
+var TEMPLATE_LANG_EXT = /* @__PURE__ */ new Map([
+  [".html", "html"],
+  [".htm", "html"],
+  [".pug", "pug"],
+  [".jade", "pug"]
+]);
+function inferLangFromSrc(src, kind) {
+  const ext2 = path35.extname(src).toLowerCase();
+  if (!ext2) {
+    return void 0;
+  }
+  if (kind === "style") {
+    return STYLE_LANG_EXT.get(ext2);
+  }
+  if (kind === "template") {
+    return TEMPLATE_LANG_EXT.get(ext2);
+  }
+  return SCRIPT_LANG_EXT.get(ext2);
+}
+function getBlockLabel(kind) {
+  if (kind === "script setup") {
+    return "script setup";
+  }
+  return kind;
+}
+function preprocessScriptSetupSrc(source) {
+  if (!source.includes("<script") || !source.includes("setup") || !source.includes("src")) {
+    return source;
+  }
+  return source.replace(SCRIPT_SETUP_TAG_RE, (full, attrs) => {
+    if (!/\bsetup\b/i.test(attrs) || !/\bsrc\b/i.test(attrs)) {
+      return full;
+    }
+    const nextAttrs = attrs.replace(
+      /\bsrc(\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+))/i,
+      `${SCRIPT_SETUP_SRC_ATTR}$1`
+    );
+    return `<script${nextAttrs}>`;
+  });
+}
+function preprocessScriptSrc(source) {
+  if (!source.includes("<script") || !source.includes("src")) {
+    return source;
+  }
+  return source.replace(SCRIPT_SETUP_TAG_RE, (full, attrs) => {
+    if (/\bsetup\b/i.test(attrs) || !/\bsrc\b/i.test(attrs)) {
+      return full;
+    }
+    const nextAttrs = attrs.replace(
+      /\bsrc(\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+))/i,
+      `${SCRIPT_SRC_ATTR}$1`
+    );
+    return `<script${nextAttrs}>`;
+  });
+}
+function restoreScriptSetupSrc(descriptor) {
+  const scriptSetup = descriptor.scriptSetup;
+  if (!scriptSetup?.attrs || !(SCRIPT_SETUP_SRC_ATTR in scriptSetup.attrs)) {
+    return;
+  }
+  const raw = scriptSetup.attrs[SCRIPT_SETUP_SRC_ATTR];
+  if (typeof raw === "string") {
+    scriptSetup.src = raw;
+  }
+  delete scriptSetup.attrs[SCRIPT_SETUP_SRC_ATTR];
+}
+function restoreScriptSrc(descriptor) {
+  const script = descriptor.script;
+  if (!script?.attrs || !(SCRIPT_SRC_ATTR in script.attrs)) {
+    return;
+  }
+  const raw = script.attrs[SCRIPT_SRC_ATTR];
+  if (typeof raw === "string") {
+    script.src = raw;
+  }
+  delete script.attrs[SCRIPT_SRC_ATTR];
+}
+async function resolveBlockSrcPath(src, filename, options) {
+  const normalizedSrc = normalizeFsResolvedId(src);
+  if (normalizedSrc && isSkippableResolvedId(normalizedSrc)) {
+    throw new Error(`\u89E3\u6790 ${filename} \u5931\u8D25\uFF1A\u4E0D\u652F\u6301 <src> \u5F15\u7528\u865A\u62DF\u6A21\u5757 ${src}`);
+  }
+  let resolvedId;
+  if (options?.resolveId) {
+    const resolved = await options.resolveId(src, filename);
+    if (resolved) {
+      const normalized = normalizeFsResolvedId(resolved);
+      if (normalized && isSkippableResolvedId(normalized)) {
+        throw new Error(`\u89E3\u6790 ${filename} \u5931\u8D25\uFF1A\u4E0D\u652F\u6301 <src> \u5F15\u7528\u865A\u62DF\u6A21\u5757 ${src}`);
+      }
+      resolvedId = normalized || resolved;
+    }
+  }
+  if (resolvedId) {
+    if (!path35.isAbsolute(resolvedId)) {
+      resolvedId = path35.resolve(path35.dirname(filename), resolvedId);
+    }
+    return resolvedId;
+  }
+  if (normalizedSrc && path35.isAbsolute(normalizedSrc)) {
+    return normalizedSrc;
+  }
+  return path35.resolve(path35.dirname(filename), normalizedSrc || src);
+}
+async function readBlockContent(resolvedId, filename, options) {
+  const reader = options?.readFile ?? readFile2;
+  const checkMtime = options?.checkMtime;
+  try {
+    return await reader(resolvedId, { checkMtime });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`\u89E3\u6790 ${filename} \u5931\u8D25\uFF1A\u8BFB\u53D6 ${resolvedId} \u5931\u8D25\uFF1A${message}`);
+  }
+}
+async function resolveSfcBlockSrc(descriptor, filename, options) {
+  if (!options) {
+    return { descriptor, deps: [] };
+  }
+  const deps = /* @__PURE__ */ new Set();
+  const nextDescriptor = {
+    ...descriptor,
+    styles: descriptor.styles.slice()
+  };
+  const resolveBlock = async (block, kind) => {
+    if (!block || !block.src) {
+      return block;
+    }
+    if (block.content.trim().length > 0) {
+      throw new Error(`\u89E3\u6790 ${filename} \u5931\u8D25\uFF1A<${getBlockLabel(kind)}> \u540C\u65F6\u5B58\u5728 src \u4E0E\u5185\u8054\u5185\u5BB9`);
+    }
+    const resolvedId = await resolveBlockSrcPath(block.src, filename, options);
+    const content = await readBlockContent(resolvedId, filename, options);
+    deps.add(resolvedId);
+    const inferredLang = block.lang ?? inferLangFromSrc(resolvedId, kind);
+    return {
+      ...block,
+      content,
+      lang: inferredLang ?? block.lang
+    };
+  };
+  nextDescriptor.template = await resolveBlock(descriptor.template, "template");
+  nextDescriptor.script = await resolveBlock(descriptor.script, "script");
+  nextDescriptor.scriptSetup = await resolveBlock(descriptor.scriptSetup, "script setup");
+  if (nextDescriptor.styles.length) {
+    nextDescriptor.styles = await Promise.all(
+      nextDescriptor.styles.map((style) => resolveBlock(style, "style"))
+    );
+  }
+  return { descriptor: nextDescriptor, deps: Array.from(deps) };
+}
 async function readAndParseSfc(filename, options) {
   const checkMtime = options?.checkMtime ?? true;
   const source = options?.source ?? await readFile2(filename, { checkMtime });
+  const normalizedSource = preprocessScriptSrc(preprocessScriptSetupSrc(source));
   const signature = checkMtime ? (() => {
     const cached2 = mtimeCache.get(filename);
     if (!cached2) {
@@ -26125,6 +26296,14 @@ async function readAndParseSfc(filename, options) {
   if (cached) {
     const hit = signature ? cached.signature === signature : cached.source === source;
     if (hit) {
+      if (options?.resolveSrc) {
+        const resolved = await resolveSfcBlockSrc(cached.descriptor, filename, options.resolveSrc);
+        return {
+          source,
+          descriptor: resolved.descriptor,
+          errors: cached.errors
+        };
+      }
       return {
         source,
         descriptor: cached.descriptor,
@@ -26132,13 +26311,22 @@ async function readAndParseSfc(filename, options) {
       };
     }
   }
-  const parsed = parseSfc(source, { filename });
+  const parsed = parseSfc(normalizedSource, {
+    filename,
+    ignoreEmpty: normalizedSource === source
+  });
+  restoreScriptSetupSrc(parsed.descriptor);
+  restoreScriptSrc(parsed.descriptor);
   sfcParseCache.set(filename, {
     signature,
     source,
     descriptor: parsed.descriptor,
     errors: parsed.errors
   });
+  if (options?.resolveSrc) {
+    const resolved = await resolveSfcBlockSrc(parsed.descriptor, filename, options.resolveSrc);
+    return { source, descriptor: resolved.descriptor, errors: parsed.errors };
+  }
   return { source, descriptor: parsed.descriptor, errors: parsed.errors };
 }
 function getSfcCheckMtime(config) {
@@ -26205,7 +26393,19 @@ async function applyScriptSetupUsingComponents(options) {
     reExportResolutionCache
   } = options;
   try {
-    const { descriptor, errors } = await readAndParseSfc(vueEntryPath, { checkMtime: getSfcCheckMtime(configService) });
+    const { descriptor, errors } = await readAndParseSfc(vueEntryPath, {
+      checkMtime: getSfcCheckMtime(configService),
+      resolveSrc: {
+        resolveId: async (source, importer) => {
+          if (typeof pluginCtx.resolve !== "function") {
+            return void 0;
+          }
+          const resolved = await pluginCtx.resolve(source, importer);
+          return resolved?.id;
+        },
+        checkMtime: getSfcCheckMtime(configService)
+      }
+    });
     if (!errors?.length && descriptor?.template && !templatePath) {
       const tags = collectVueTemplateAutoImportTags(descriptor.template.content, vueEntryPath);
       if (tags.size) {
@@ -26224,12 +26424,12 @@ async function applyScriptSetupUsingComponents(options) {
           for (const { localName, importSource, importedName, kind } of imports) {
             const resolved = await pluginCtx.resolve(importSource, vueEntryPath);
             let resolvedId = resolved?.id ? normalizeFsResolvedId(resolved.id) : void 0;
-            if (!resolvedId || !path35.isAbsolute(resolvedId)) {
+            if (!resolvedId || !path36.isAbsolute(resolvedId)) {
               if (importSource.startsWith(".")) {
-                resolvedId = path35.resolve(path35.dirname(vueEntryPath), importSource);
+                resolvedId = path36.resolve(path36.dirname(vueEntryPath), importSource);
               }
             }
-            if (resolvedId && path35.isAbsolute(resolvedId) && !path35.extname(resolvedId)) {
+            if (resolvedId && path36.isAbsolute(resolvedId) && !path36.extname(resolvedId)) {
               const matched = await resolveEntryPath(resolvedId, {
                 kind,
                 exists: (p) => pathExists2(p, { ttlMs: getPathExistsTtlMs(configService) }),
@@ -26239,7 +26439,7 @@ async function applyScriptSetupUsingComponents(options) {
                 resolvedId = matched;
               }
             }
-            if (kind === "named" && importedName && resolvedId && path35.isAbsolute(resolvedId) && /\.(?:[cm]?ts|[cm]?js)$/.test(resolvedId)) {
+            if (kind === "named" && importedName && resolvedId && path36.isAbsolute(resolvedId) && /\.(?:[cm]?ts|[cm]?js)$/.test(resolvedId)) {
               const mapped = await resolveReExportedName(resolvedId, importedName, {
                 cache: reExportResolutionCache,
                 maxDepth: 4,
@@ -26447,7 +26647,7 @@ function createEntryLoader(options) {
 // src/plugins/hooks/useLoadEntry/normalizer.ts
 init_esm_shims();
 import { isObject as isObject4 } from "@weapp-core/shared";
-import path36 from "pathe";
+import path37 from "pathe";
 function resolveImportee(importee, jsonPath, configService) {
   let updated = importee;
   if (jsonPath && Array.isArray(configService.aliasEntries)) {
@@ -26456,8 +26656,8 @@ function resolveImportee(importee, jsonPath, configService) {
       updated = importee.replace(matchedEntry.find, matchedEntry.replacement);
     }
   }
-  const baseDir = jsonPath ? path36.dirname(jsonPath) : configService.absoluteSrcRoot;
-  return path36.resolve(baseDir, updated);
+  const baseDir = jsonPath ? path37.dirname(jsonPath) : configService.absoluteSrcRoot;
+  return path37.resolve(baseDir, updated);
 }
 function hasDependencyPrefix(dependencies, tokens) {
   return Object.keys(dependencies).some((dep) => {
@@ -26634,11 +26834,11 @@ init_esm_shims();
 init_esm_shims();
 import { isEmptyObject as isEmptyObject2, isObject as isObject5 } from "@weapp-core/shared";
 import MagicString3 from "magic-string";
-import path38 from "pathe";
+import path39 from "pathe";
 
 // src/plugins/utils/wxmlEmit.ts
 init_esm_shims();
-import path37 from "pathe";
+import path38 from "pathe";
 
 // src/wxml/handle.ts
 init_esm_shims();
@@ -26667,8 +26867,8 @@ function transformWxsCode(code, options) {
     }
     importees.push({ source: value });
   };
-  const tryCollectArgument = (path70) => {
-    const node = path70.node;
+  const tryCollectArgument = (path71) => {
+    const node = path71.node;
     if (t.isStringLiteral(node)) {
       maybePushImportee(node.value);
       return;
@@ -26679,7 +26879,7 @@ function transformWxsCode(code, options) {
       return;
     }
     try {
-      const evaluated = path70.evaluate();
+      const evaluated = path71.evaluate();
       if (evaluated.confident) {
         maybePushImportee(evaluated.value);
       }
@@ -26924,7 +27124,7 @@ function emitWxmlAssetsWithCache(options) {
       if (!pluginRoot) {
         return false;
       }
-      const pluginBase = path37.basename(pluginRoot);
+      const pluginBase = path38.basename(pluginRoot);
       return fileName.startsWith(pluginBase);
     }
     return scanService.isMainPackageFileName(fileName);
@@ -26965,9 +27165,9 @@ function emitJsonAsset(runtime, fileName, source) {
 function filterPluginBundleOutputs(bundle, configService) {
   const pluginOutputRoot = configService.absolutePluginOutputRoot;
   for (const [fileName] of Object.entries(bundle)) {
-    const absolute = path38.resolve(configService.outDir, fileName);
-    const relative3 = pluginOutputRoot ? path38.relative(pluginOutputRoot, absolute) : "";
-    const isPluginFile = pluginOutputRoot ? !relative3.startsWith("..") && !path38.isAbsolute(relative3) : fileName.startsWith(path38.basename(configService.absolutePluginRoot ?? "plugin"));
+    const absolute = path39.resolve(configService.outDir, fileName);
+    const relative3 = pluginOutputRoot ? path39.relative(pluginOutputRoot, absolute) : "";
+    const isPluginFile = pluginOutputRoot ? !relative3.startsWith("..") && !path39.isAbsolute(relative3) : fileName.startsWith(path39.basename(configService.absolutePluginRoot ?? "plugin"));
     if (!isPluginFile) {
       delete bundle[fileName];
     }
@@ -27082,8 +27282,8 @@ function resolveRelativeImport(fromFile, specifier) {
   if (!specifier) {
     return "";
   }
-  const dir = path38.posix.dirname(fromFile);
-  const absolute = path38.posix.resolve("/", dir, specifier);
+  const dir = path39.posix.dirname(fromFile);
+  const absolute = path39.posix.resolve("/", dir, specifier);
   return absolute.startsWith("/") ? absolute.slice(1) : absolute;
 }
 
@@ -27454,7 +27654,7 @@ function createBuildEndHook(state) {
 // src/plugins/core/lifecycle/load.ts
 init_esm_shims();
 import { removeExtensionDeep as removeExtensionDeep8 } from "@weapp-core/shared";
-import path39 from "pathe";
+import path40 from "pathe";
 
 // src/plugins/utils/parse.ts
 init_esm_shims();
@@ -27491,7 +27691,7 @@ function createOptionsHook(state) {
     let scannedInput;
     if (subPackageMeta) {
       scannedInput = subPackageMeta.entries.reduce((acc, entry) => {
-        acc[entry] = path39.resolve(configService.absoluteSrcRoot, entry);
+        acc[entry] = path40.resolve(configService.absoluteSrcRoot, entry);
         return acc;
       }, {});
     } else {
@@ -27565,14 +27765,14 @@ function createLoadHook(state) {
 
 // src/plugins/core/lifecycle/watch.ts
 init_esm_shims();
-import path45 from "pathe";
+import path46 from "pathe";
 
 // src/plugins/css/shared/preprocessor.ts
 init_esm_shims();
 import { createHash as createHash2 } from "crypto";
 import { createRequire as createRequire5 } from "module";
 import fs19 from "fs-extra";
-import path40 from "pathe";
+import path41 from "pathe";
 import { preprocessCSS } from "vite";
 
 // src/postcss/index.ts
@@ -27733,12 +27933,12 @@ async function processCssWithCache(code, configService) {
 }
 function dedupeAndNormalizeDependencies(base, dependencies) {
   const seen = /* @__PURE__ */ new Set();
-  const baseDir = path40.dirname(base);
+  const baseDir = path41.dirname(base);
   for (const dep of dependencies) {
     if (!dep) {
       continue;
     }
-    const normalized = path40.isAbsolute(dep) ? dep : path40.resolve(baseDir, dep);
+    const normalized = path41.isAbsolute(dep) ? dep : path41.resolve(baseDir, dep);
     seen.add(normalized);
   }
   return Array.from(seen);
@@ -27836,11 +28036,11 @@ init_esm_shims();
 // src/plugins/utils/invalidateEntry/cssGraph.ts
 init_esm_shims();
 import fs20 from "fs";
-import path42 from "pathe";
+import path43 from "pathe";
 
 // src/plugins/utils/invalidateEntry/shared.ts
 init_esm_shims();
-import path41 from "pathe";
+import path42 from "pathe";
 var watchedCssExts = new Set(supportedCssLangs.map((ext2) => `.${ext2}`));
 var watchedTemplateExts = new Set(templateExtensions.map((ext2) => `.${ext2}`));
 var configSuffixes = configExtensions.map((ext2) => `.${ext2}`);
@@ -27861,7 +28061,7 @@ function isWatchLimitError(error) {
   return watchLimitErrorCodes.has(maybeError.code);
 }
 function normalizePath2(p) {
-  return path41.normalize(p);
+  return path42.normalize(p);
 }
 
 // src/plugins/utils/invalidateEntry/cssGraph.ts
@@ -27945,7 +28145,7 @@ async function extractCssImportDependencies(ctx, importer) {
   }
   cssImportRE.lastIndex = 0;
   const dependencies = /* @__PURE__ */ new Set();
-  const dir = path42.dirname(importer);
+  const dir = path43.dirname(importer);
   while (true) {
     const match2 = cssImportRE.exec(cssContent);
     if (!match2) {
@@ -27957,9 +28157,9 @@ async function extractCssImportDependencies(ctx, importer) {
     }
     if (importProtocols.test(rawSpecifier)) {
       if (rawSpecifier.startsWith("/")) {
-        const absolute = path42.resolve(ctx.configService.absoluteSrcRoot, rawSpecifier.slice(1));
+        const absolute = path43.resolve(ctx.configService.absoluteSrcRoot, rawSpecifier.slice(1));
         dependencies.add(absolute);
-        const ext3 = path42.extname(absolute);
+        const ext3 = path43.extname(absolute);
         if (ext3) {
           dependencies.add(absolute.slice(0, -ext3.length));
         }
@@ -27968,7 +28168,7 @@ async function extractCssImportDependencies(ctx, importer) {
     }
     let specifier = rawSpecifier;
     if (specifier.startsWith("@/")) {
-      specifier = path42.join(ctx.configService.absoluteSrcRoot, specifier.slice(2));
+      specifier = path43.join(ctx.configService.absoluteSrcRoot, specifier.slice(2));
     } else if (specifier === "@") {
       specifier = ctx.configService.absoluteSrcRoot;
     }
@@ -27976,9 +28176,9 @@ async function extractCssImportDependencies(ctx, importer) {
       specifier = specifier.slice(1);
     }
     const cleaned = specifier.replace(/[?#].*$/, "");
-    const resolved = path42.resolve(dir, cleaned);
+    const resolved = path43.resolve(dir, cleaned);
     dependencies.add(resolved);
-    const ext2 = path42.extname(resolved);
+    const ext2 = path43.extname(resolved);
     if (!ext2) {
       dependencies.add(resolved);
     } else {
@@ -27997,7 +28197,7 @@ function collectCssImporters(ctx, dependency) {
       matches2.add(importer);
     }
   }
-  const ext2 = path42.extname(normalizedDependency);
+  const ext2 = path43.extname(normalizedDependency);
   if (ext2) {
     const base = normalizedDependency.slice(0, -ext2.length);
     const baseMatches = graph.dependencyToImporters.get(base);
@@ -28031,7 +28231,7 @@ async function collectAffectedScriptsAndImporters(ctx, startCssFile) {
       continue;
     }
     visitedCss.add(current2);
-    const ext2 = path42.extname(current2);
+    const ext2 = path43.extname(current2);
     if (ext2) {
       const base = current2.slice(0, -ext2.length);
       const script = await resolveScriptForCss(scriptCache, base);
@@ -28058,10 +28258,10 @@ function cleanupCssImporterGraph(ctx, importer) {
 
 // src/plugins/utils/invalidateEntry/sidecar.ts
 init_esm_shims();
-import path43 from "pathe";
+import path44 from "pathe";
 async function invalidateEntryForSidecar(ctx, filePath, event = "update") {
   const configSuffix = configSuffixes.find((suffix) => filePath.endsWith(suffix));
-  const ext2 = path43.extname(filePath);
+  const ext2 = path44.extname(filePath);
   const normalizedPath = normalizePath2(filePath);
   let scriptBasePath;
   if (configSuffix) {
@@ -28126,13 +28326,13 @@ async function invalidateEntryForSidecar(ctx, filePath, event = "update") {
 init_esm_shims();
 import fs21 from "fs";
 import process5 from "process";
-import path44 from "pathe";
+import path45 from "pathe";
 function ensureSidecarWatcher(ctx, rootDir) {
   if (!ctx.configService.isDev || !rootDir || process5.env.VITEST === "true" || process5.env.NODE_ENV === "test") {
     return;
   }
   const { sidecarWatcherMap } = ctx.runtimeState.watcher;
-  const absRoot = path44.normalize(rootDir);
+  const absRoot = path45.normalize(rootDir);
   if (!fs21.existsSync(absRoot)) {
     return;
   }
@@ -28144,7 +28344,7 @@ function ensureSidecarWatcher(ctx, rootDir) {
     if (!isSidecarFile(filePath)) {
       return;
     }
-    const ext2 = path44.extname(filePath);
+    const ext2 = path45.extname(filePath);
     const isCssFile = Boolean(ext2 && watchedCssExts.has(ext2));
     if (isCssFile && (event === "create" || event === "update")) {
       void extractCssImportDependencies(ctx, filePath);
@@ -28165,9 +28365,9 @@ function ensureSidecarWatcher(ctx, rootDir) {
     }
   };
   const patterns = [
-    ...configExtensions.map((ext2) => path44.join(absRoot, `**/*.${ext2}`)),
-    ...supportedCssLangs.map((ext2) => path44.join(absRoot, `**/*.${ext2}`)),
-    ...templateExtensions.map((ext2) => path44.join(absRoot, `**/*.${ext2}`))
+    ...configExtensions.map((ext2) => path45.join(absRoot, `**/*.${ext2}`)),
+    ...supportedCssLangs.map((ext2) => path45.join(absRoot, `**/*.${ext2}`)),
+    ...templateExtensions.map((ext2) => path45.join(absRoot, `**/*.${ext2}`))
   ];
   const ignoredMatcher = createSidecarIgnoredMatcher(ctx, absRoot);
   const watcher = chokidar_default.watch(patterns, {
@@ -28183,15 +28383,15 @@ function ensureSidecarWatcher(ctx, rootDir) {
     if (!input) {
       return;
     }
-    const normalizedPath = path44.normalize(input);
+    const normalizedPath = path45.normalize(input);
     if (!options?.silent) {
       logger_default.info(`[watch:${event}] ${ctx.configService.relativeCwd(normalizedPath)}`);
     }
     handleSidecarChange(event, normalizedPath, isReady);
   };
-  watcher.on("add", (path70) => forwardChange("create", path70));
-  watcher.on("change", (path70) => forwardChange("update", path70));
-  watcher.on("unlink", (path70) => forwardChange("delete", path70));
+  watcher.on("add", (path71) => forwardChange("create", path71));
+  watcher.on("change", (path71) => forwardChange("update", path71));
+  watcher.on("unlink", (path71) => forwardChange("delete", path71));
   watcher.on("raw", (eventName, rawPath, details) => {
     if (eventName !== "rename") {
       return;
@@ -28201,7 +28401,7 @@ function ensureSidecarWatcher(ctx, rootDir) {
       return;
     }
     const baseDir = typeof details === "object" && details && "watchedPath" in details ? details.watchedPath ?? absRoot : absRoot;
-    const resolved = path44.isAbsolute(candidate) ? candidate : path44.resolve(baseDir, candidate);
+    const resolved = path45.isAbsolute(candidate) ? candidate : path45.resolve(baseDir, candidate);
     if (ignoredMatcher(resolved)) {
       return;
     }
@@ -28229,22 +28429,22 @@ function ensureSidecarWatcher(ctx, rootDir) {
 function createSidecarIgnoredMatcher(ctx, rootDir) {
   const configService = ctx.configService;
   const ignoredRoots = /* @__PURE__ */ new Set();
-  const normalizedRoot = path44.normalize(rootDir);
+  const normalizedRoot = path45.normalize(rootDir);
   for (const dirName of defaultIgnoredDirNames) {
-    ignoredRoots.add(path44.join(normalizedRoot, dirName));
+    ignoredRoots.add(path45.join(normalizedRoot, dirName));
   }
   if (configService?.mpDistRoot) {
-    ignoredRoots.add(path44.resolve(configService.cwd, configService.mpDistRoot));
+    ignoredRoots.add(path45.resolve(configService.cwd, configService.mpDistRoot));
   } else {
-    ignoredRoots.add(path44.join(normalizedRoot, "dist"));
+    ignoredRoots.add(path45.join(normalizedRoot, "dist"));
   }
   if (configService?.outDir) {
-    ignoredRoots.add(path44.resolve(configService.cwd, configService.outDir));
+    ignoredRoots.add(path45.resolve(configService.cwd, configService.outDir));
   }
   return (candidate) => {
-    const normalized = path44.normalize(candidate);
+    const normalized = path45.normalize(candidate);
     for (const ignored of ignoredRoots) {
-      if (normalized === ignored || normalized.startsWith(`${ignored}${path44.sep}`)) {
+      if (normalized === ignored || normalized.startsWith(`${ignored}${path45.sep}`)) {
         return true;
       }
     }
@@ -28267,7 +28467,7 @@ function createBuildStartHook(state) {
           ensureSidecarWatcher(ctx, configService.absolutePluginRoot);
         }
       } else {
-        const rootDir = subPackageMeta ? path45.resolve(configService.absoluteSrcRoot, subPackageMeta.subPackage.root) : configService.absoluteSrcRoot;
+        const rootDir = subPackageMeta ? path46.resolve(configService.absoluteSrcRoot, subPackageMeta.subPackage.root) : configService.absoluteSrcRoot;
         ensureSidecarWatcher(ctx, rootDir);
         if (!subPackageMeta && configService.absolutePluginRoot) {
           ensureSidecarWatcher(ctx, configService.absolutePluginRoot);
@@ -28298,7 +28498,7 @@ function createWatchChangeHook(state) {
       }
       if (isTemplateFile2 || configSuffix || isStyleFile2) {
         const basePath = configSuffix ? normalizedId.slice(0, -configSuffix.length) : (() => {
-          const ext2 = path45.extname(normalizedId);
+          const ext2 = path46.extname(normalizedId);
           return ext2 ? normalizedId.slice(0, -ext2.length) : normalizedId;
         })();
         const primaryScript = await findJsEntry(basePath);
@@ -28372,7 +28572,7 @@ function createCoreLifecyclePlugin(state) {
 
 // src/plugins/core/requireAnalysis.ts
 init_esm_shims();
-import path46 from "pathe";
+import path47 from "pathe";
 
 // src/plugins/utils/ast.ts
 init_esm_shims();
@@ -28433,7 +28633,7 @@ function createRequireAnalysisPlugin(state) {
         return;
       }
       for (const requireModule of requireTokens) {
-        const absPath = path46.resolve(path46.dirname(moduleInfo.id), requireModule.value);
+        const absPath = path47.resolve(path47.dirname(moduleInfo.id), requireModule.value);
         const resolved = await this.resolve(absPath, moduleInfo.id);
         if (!resolved) {
           continue;
@@ -28527,11 +28727,11 @@ function weappVite(ctx, subPackageMeta) {
 // src/plugins/css.ts
 init_esm_shims();
 import fs22 from "fs-extra";
-import path48 from "pathe";
+import path49 from "pathe";
 
 // src/plugins/css/shared/sharedStyles.ts
 init_esm_shims();
-import path47 from "pathe";
+import path48 from "pathe";
 import picomatch2 from "picomatch";
 var styleMatcherCache = /* @__PURE__ */ new WeakMap();
 function collectSharedStyleEntries(ctx, configService) {
@@ -28640,7 +28840,7 @@ function findSharedStylesForModule(modulePath, fileName, sharedStyles) {
 }
 function resolveImportSpecifiers(fileName, entries) {
   const posixFileName = toPosixPath(fileName);
-  const dir = path47.posix.dirname(posixFileName);
+  const dir = path48.posix.dirname(posixFileName);
   const seen = /* @__PURE__ */ new Set();
   const specifiers = [];
   for (const entry of entries) {
@@ -28648,8 +28848,8 @@ function resolveImportSpecifiers(fileName, entries) {
     if (target === posixFileName) {
       continue;
     }
-    const relative3 = path47.posix.relative(dir, target);
-    let specifier = relative3 || path47.posix.basename(target);
+    const relative3 = path48.posix.relative(dir, target);
+    let specifier = relative3 || path48.posix.basename(target);
     if (!specifier || specifier === ".") {
       continue;
     }
@@ -28750,7 +28950,7 @@ async function handleBundleEntry(bundle, bundleKey, asset2, configService, share
   };
   if (bundleKey.endsWith(".wxss")) {
     const [rawOriginal] = asset2.originalFileNames ?? [];
-    const absOriginal = rawOriginal ? toAbsolute(rawOriginal) : path48.resolve(configService.absoluteSrcRoot, bundleKey);
+    const absOriginal = rawOriginal ? toAbsolute(rawOriginal) : path49.resolve(configService.absoluteSrcRoot, bundleKey);
     const fileName = configService.relativeOutputPath(absOriginal);
     if (fileName) {
       emitted.add(toPosixPath(fileName));
@@ -28965,7 +29165,7 @@ init_esm_shims();
 init_esm_shims();
 import { createRequire as createRequire6 } from "module";
 import process6 from "process";
-import path49 from "pathe";
+import path50 from "pathe";
 var VUE_VIRTUAL_MODULE_PREFIX = "\0vue:";
 var warnedMissingWevu = false;
 var wevuInstallState = "unknown";
@@ -28992,7 +29192,7 @@ function ensureWevuInstalled(ctx) {
   }
   const configService = ctx.configService;
   const cwd = configService?.cwd ?? process6.cwd();
-  const require3 = createRequire6(path49.join(cwd, "package.json"));
+  const require3 = createRequire6(path50.join(cwd, "package.json"));
   try {
     require3.resolve("wevu");
     wevuInstallState = "present";
@@ -29073,7 +29273,7 @@ init_esm_shims();
 var import_merge2 = __toESM(require_src(), 1);
 import { parse as parseJson2 } from "comment-json";
 import fs23 from "fs-extra";
-import path50 from "pathe";
+import path51 from "pathe";
 import { bundleRequire } from "rolldown-require";
 function normalizeConfigLang(lang) {
   if (!lang) {
@@ -29095,14 +29295,14 @@ function resolveJsLikeLang(lang) {
   return "js";
 }
 async function evaluateJsLikeConfig(source, filename, lang) {
-  const dir = path50.dirname(filename);
+  const dir = path51.dirname(filename);
   const extension = resolveJsLikeLang(lang) === "ts" ? "ts" : "js";
   const tempDir = resolveWevuConfigTempDir(dir);
   return await withTempDirLock(tempDir, async () => {
     await fs23.ensureDir(tempDir);
-    const basename4 = path50.basename(filename, path50.extname(filename));
+    const basename4 = path51.basename(filename, path51.extname(filename));
     const unique = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
-    const tempFile = path50.join(tempDir, `${basename4}.${unique}.${extension}`);
+    const tempFile = path51.join(tempDir, `${basename4}.${unique}.${extension}`);
     const rewritten = rewriteJsLikeImportsForTempDir(source, dir, tempDir);
     await fs23.writeFile(tempFile, rewritten, "utf8");
     try {
@@ -29346,16 +29546,16 @@ function extractDefineOptionsHash(content) {
   }
   const macroSources = [];
   traverse(ast, {
-    CallExpression(path70) {
-      const callee = path70.node.callee;
+    CallExpression(path71) {
+      const callee = path71.node.callee;
       if (!t2.isIdentifier(callee, { name: "defineOptions" })) {
         return;
       }
-      const isTopLevelStatement = path70.parentPath?.isExpressionStatement() && path70.parentPath.parentPath?.isProgram();
+      const isTopLevelStatement = path71.parentPath?.isExpressionStatement() && path71.parentPath.parentPath?.isProgram();
       if (!isTopLevelStatement) {
         return;
       }
-      const statement = path70.parentPath?.node;
+      const statement = path71.parentPath?.node;
       if (statement && typeof statement.start === "number" && typeof statement.end === "number") {
         macroSources.push(content.slice(statement.start, statement.end));
       }
@@ -29367,15 +29567,31 @@ function extractDefineOptionsHash(content) {
   return createHash3("sha256").update(macroSources.join("\n")).digest("hex").slice(0, 12);
 }
 async function parseVueFile(source, filename, options) {
-  const { descriptor, errors } = parse9(source, { filename });
+  const normalizedSource = preprocessScriptSrc(preprocessScriptSetupSrc(source));
+  const { descriptor, errors } = parse9(normalizedSource, {
+    filename,
+    ignoreEmpty: normalizedSource === source
+  });
+  restoreScriptSetupSrc(descriptor);
+  restoreScriptSrc(descriptor);
   if (errors.length > 0) {
     const error = errors[0];
     throw new Error(`\u89E3\u6790 ${filename} \u5931\u8D25\uFF1A${error.message}`);
   }
-  let descriptorForCompile = descriptor;
+  let resolvedDescriptor = descriptor;
+  let sfcSrcDeps;
+  if (options?.sfcSrc) {
+    const resolved = await resolveSfcBlockSrc(descriptor, filename, options.sfcSrc);
+    resolvedDescriptor = resolved.descriptor;
+    if (resolved.deps.length) {
+      sfcSrcDeps = resolved.deps;
+    }
+  }
+  let descriptorForCompile = resolvedDescriptor;
   const meta = {
-    hasScriptSetup: !!descriptor.scriptSetup,
-    hasSetupOption: !!descriptor.script && /\bsetup\s*\(/.test(descriptor.script.content)
+    hasScriptSetup: !!resolvedDescriptor.scriptSetup,
+    hasSetupOption: !!resolvedDescriptor.script && /\bsetup\s*\(/.test(resolvedDescriptor.script.content),
+    sfcSrcDeps
   };
   let scriptSetupMacroConfig;
   let scriptSetupMacroHash;
@@ -29383,7 +29599,7 @@ async function parseVueFile(source, filename, options) {
   const jsonKind = options?.json?.kind ?? (options?.isApp ? "app" : options?.isPage ? "page" : "component");
   const jsonDefaults = options?.json?.defaults?.[jsonKind];
   const mergeJson = createJsonMerger(options?.json?.mergeStrategy, { filename, kind: jsonKind });
-  const scriptSetup = descriptor.scriptSetup;
+  const scriptSetup = resolvedDescriptor.scriptSetup;
   if (scriptSetup?.content) {
     const extracted = await extractJsonMacroFromScriptSetup(
       scriptSetup.content,
@@ -29394,19 +29610,41 @@ async function parseVueFile(source, filename, options) {
       }
     );
     if (extracted.stripped !== scriptSetup.content) {
-      const setupLoc = scriptSetup.loc;
-      const startOffset = setupLoc.start.offset;
-      const endOffset = setupLoc.end.offset;
-      const nextSource = source.slice(0, startOffset) + extracted.stripped + source.slice(endOffset);
-      const { descriptor: nextDescriptor, errors: nextErrors } = parse9(nextSource, {
-        filename,
-        ignoreEmpty: false
-      });
-      if (nextErrors.length > 0) {
-        const error = nextErrors[0];
-        throw new Error(`\u89E3\u6790 ${filename} \u5931\u8D25\uFF1A${error.message}`);
+      if (scriptSetup.src) {
+        descriptorForCompile = {
+          ...descriptorForCompile,
+          scriptSetup: {
+            ...descriptorForCompile.scriptSetup,
+            content: extracted.stripped
+          }
+        };
+      } else {
+        const setupLoc = scriptSetup.loc;
+        const startOffset = setupLoc.start.offset;
+        const endOffset = setupLoc.end.offset;
+        const nextSource = normalizedSource.slice(0, startOffset) + extracted.stripped + normalizedSource.slice(endOffset);
+        const { descriptor: nextDescriptor, errors: nextErrors } = parse9(nextSource, {
+          filename,
+          ignoreEmpty: false
+        });
+        restoreScriptSetupSrc(nextDescriptor);
+        restoreScriptSrc(nextDescriptor);
+        if (nextErrors.length > 0) {
+          const error = nextErrors[0];
+          throw new Error(`\u89E3\u6790 ${filename} \u5931\u8D25\uFF1A${error.message}`);
+        }
+        if (options?.sfcSrc) {
+          const resolvedNext = await resolveSfcBlockSrc(nextDescriptor, filename, options.sfcSrc);
+          descriptorForCompile = resolvedNext.descriptor;
+          if (resolvedNext.deps.length) {
+            const deps = /* @__PURE__ */ new Set([...sfcSrcDeps ?? [], ...resolvedNext.deps]);
+            sfcSrcDeps = Array.from(deps);
+            meta.sfcSrcDeps = sfcSrcDeps;
+          }
+        } else {
+          descriptorForCompile = nextDescriptor;
+        }
       }
-      descriptorForCompile = nextDescriptor;
     }
     scriptSetupMacroConfig = extracted.config;
     scriptSetupMacroHash = extracted.macroHash;
@@ -29414,7 +29652,7 @@ async function parseVueFile(source, filename, options) {
   }
   const isAppFile = /[\\/]app\.vue$/.test(filename);
   return {
-    descriptor,
+    descriptor: resolvedDescriptor,
     descriptorForCompile,
     meta,
     scriptSetupMacroConfig,
@@ -29429,7 +29667,7 @@ async function parseVueFile(source, filename, options) {
 
 // src/plugins/vue/transform/compileVueFile/script.ts
 init_esm_shims();
-import * as t24 from "@babel/types";
+import * as t25 from "@babel/types";
 import { removeExtensionDeep as removeExtensionDeep10 } from "@weapp-core/shared";
 import { compileScript } from "vue/compiler-sfc";
 
@@ -29489,8 +29727,8 @@ function getObjectMemberIndexByKey(node, key) {
     return false;
   });
 }
-function isTopLevel(path70) {
-  return path70.getFunctionParent() == null;
+function isTopLevel(path71) {
+  return path71.getFunctionParent() == null;
 }
 
 // src/plugins/wevu/pageFeatures/flags.ts
@@ -29533,8 +29771,8 @@ function collectWevuPageFeatureFlags(ast) {
     }
   }
   traverse(ast, {
-    CallExpression(path70) {
-      const callee = path70.node.callee;
+    CallExpression(path71) {
+      const callee = path71.node.callee;
       if (t4.isIdentifier(callee)) {
         consumeHookCallByName(callee.name);
         return;
@@ -29546,8 +29784,8 @@ function collectWevuPageFeatureFlags(ast) {
         }
       }
     },
-    OptionalCallExpression(path70) {
-      const callee = path70.node.callee;
+    OptionalCallExpression(path71) {
+      const callee = path71.node.callee;
       if (t4.isIdentifier(callee)) {
         consumeHookCallByName(callee.name);
         return;
@@ -29797,23 +30035,23 @@ function collectTargetOptionsObjects(ast, moduleId) {
   const constObjectBindings = /* @__PURE__ */ new Map();
   const pendingConstObjectRefs = [];
   traverse(ast, {
-    VariableDeclarator(path70) {
-      if (!isTopLevel(path70)) {
+    VariableDeclarator(path71) {
+      if (!isTopLevel(path71)) {
         return;
       }
-      if (!t6.isIdentifier(path70.node.id)) {
+      if (!t6.isIdentifier(path71.node.id)) {
         return;
       }
-      const init = path70.node.init;
+      const init = path71.node.init;
       if (t6.isObjectExpression(init)) {
-        constObjectBindings.set(path70.node.id.name, init);
+        constObjectBindings.set(path71.node.id.name, init);
       }
     },
-    CallExpression(path70) {
-      if (!isTopLevel(path70)) {
+    CallExpression(path71) {
+      if (!isTopLevel(path71)) {
         return;
       }
-      const node = path70.node;
+      const node = path71.node;
       if (t6.isV8IntrinsicIdentifier(node.callee)) {
         return;
       }
@@ -29851,11 +30089,11 @@ function collectTargetOptionsObjects(ast, moduleId) {
         }
       }
     },
-    OptionalCallExpression(path70) {
-      if (!isTopLevel(path70)) {
+    OptionalCallExpression(path71) {
+      if (!isTopLevel(path71)) {
         return;
       }
-      const node = path70.node;
+      const node = path71.node;
       const callee = node.callee;
       if (t6.isV8IntrinsicIdentifier(callee)) {
         return;
@@ -30211,7 +30449,7 @@ async function injectWevuPageFeaturesInJsWithResolver(source, options) {
 // src/plugins/wevu/pageFeatures/matcher.ts
 init_esm_shims();
 import { removeExtensionDeep as removeExtensionDeep9 } from "@weapp-core/shared";
-import path51 from "pathe";
+import path52 from "pathe";
 function createPageEntryMatcher(ctx) {
   let cached;
   async function ensure() {
@@ -30229,7 +30467,7 @@ function createPageEntryMatcher(ctx) {
       if (!normalized) {
         continue;
       }
-      set2.add(path51.resolve(configService.absoluteSrcRoot, normalized));
+      set2.add(path52.resolve(configService.absoluteSrcRoot, normalized));
     }
     for (const meta of scanService.loadSubPackages()) {
       const root = meta.subPackage.root ?? "";
@@ -30238,7 +30476,7 @@ function createPageEntryMatcher(ctx) {
         if (!normalized) {
           continue;
         }
-        set2.add(path51.resolve(configService.absoluteSrcRoot, root, normalized));
+        set2.add(path52.resolve(configService.absoluteSrcRoot, root, normalized));
       }
     }
     if (scanService.pluginJson) {
@@ -30248,7 +30486,7 @@ function createPageEntryMatcher(ctx) {
         if (!normalized) {
           continue;
         }
-        set2.add(path51.resolve(configService.absoluteSrcRoot, removeExtensionDeep9(normalized)));
+        set2.add(path52.resolve(configService.absoluteSrcRoot, removeExtensionDeep9(normalized)));
       }
     }
     cached = set2;
@@ -30268,7 +30506,7 @@ function createPageEntryMatcher(ctx) {
 
 // src/plugins/wevu/pageFeatures/plugin.ts
 init_esm_shims();
-import path52 from "pathe";
+import path53 from "pathe";
 
 // src/plugins/utils/viteResolverAdapter.ts
 init_esm_shims();
@@ -30320,7 +30558,7 @@ function createWevuAutoPageFeaturesPlugin(ctx) {
         return null;
       }
       const filename = toAbsoluteId(sourceId, configService, void 0, { base: "cwd" });
-      if (!filename || !path52.isAbsolute(filename)) {
+      if (!filename || !path53.isAbsolute(filename)) {
         return null;
       }
       if (!await matcher.isPageFile(filename)) {
@@ -30361,24 +30599,24 @@ function injectTemplateComponentMeta(ast, templateComponentMeta) {
   const injectedNames = /* @__PURE__ */ new Set();
   let changed = false;
   traverse(ast, {
-    ImportDeclaration(path70) {
-      if (!path70.node.specifiers.length) {
+    ImportDeclaration(path71) {
+      if (!path71.node.specifiers.length) {
         return;
       }
-      const kept = path70.node.specifiers.filter((specifier) => {
+      const kept = path71.node.specifiers.filter((specifier) => {
         if (!("local" in specifier) || !t9.isIdentifier(specifier.local)) {
           return true;
         }
         const localName = specifier.local.name;
         return !candidateNames.has(localName);
       });
-      if (kept.length !== path70.node.specifiers.length) {
+      if (kept.length !== path71.node.specifiers.length) {
         changed = true;
         if (kept.length === 0) {
-          path70.remove();
+          path71.remove();
           return;
         }
-        path70.node.specifiers = kept;
+        path71.node.specifiers = kept;
       }
     }
   });
@@ -30421,10 +30659,10 @@ function vueSfcTransformPlugin() {
   return {
     name: "vue-sfc-transform",
     visitor: {
-      ImportDeclaration(path70) {
-        const source = path70.node.source.value;
+      ImportDeclaration(path71) {
+        const source = path71.node.source.value;
         if (source === "vue") {
-          const specifiers = path70.node.specifiers;
+          const specifiers = path71.node.specifiers;
           const filteredSpecifiers = specifiers.filter((s) => {
             if (s.type === "ImportSpecifier" && t10.isIdentifier(s.imported) && s.imported.name === WE_VU_RUNTIME_APIS3.defineComponent) {
               return false;
@@ -30432,14 +30670,14 @@ function vueSfcTransformPlugin() {
             return true;
           });
           if (filteredSpecifiers.length === 0) {
-            path70.remove();
+            path71.remove();
           } else if (filteredSpecifiers.length !== specifiers.length) {
-            path70.node.specifiers = filteredSpecifiers;
+            path71.node.specifiers = filteredSpecifiers;
           }
         }
       },
-      ObjectExpression(path70) {
-        const properties = path70.node.properties;
+      ObjectExpression(path71) {
+        const properties = path71.node.properties;
         const filtered = properties.filter((p) => {
           if (p.type === "ObjectProperty") {
             const key = p.key;
@@ -30449,11 +30687,11 @@ function vueSfcTransformPlugin() {
           }
           return true;
         });
-        path70.node.properties = filtered;
+        path71.node.properties = filtered;
       },
-      CallExpression(path70) {
-        if (t10.isIdentifier(path70.node.callee, { name: "__expose" }) && path70.parentPath?.isExpressionStatement() && path70.node.arguments.length === 0) {
-          path70.parentPath.remove();
+      CallExpression(path71) {
+        if (t10.isIdentifier(path71.node.callee, { name: "__expose" }) && path71.parentPath?.isExpressionStatement() && path71.node.arguments.length === 0) {
+          path71.parentPath.remove();
         }
       }
     }
@@ -30507,22 +30745,22 @@ function resolveComponentExpression(declaration, defineComponentDecls, aliases)
 // src/plugins/vue/transform/transformScript/collect.ts
 function createCollectVisitors(state) {
   return {
-    VariableDeclarator(path70) {
-      if (!t12.isIdentifier(path70.node.id) || !path70.node.init) {
+    VariableDeclarator(path71) {
+      if (!t12.isIdentifier(path71.node.id) || !path71.node.init) {
         return;
       }
-      if (t12.isObjectExpression(path70.node.init)) {
-        state.defineComponentDecls.set(path70.node.id.name, t12.cloneNode(path70.node.init, true));
+      if (t12.isObjectExpression(path71.node.init)) {
+        state.defineComponentDecls.set(path71.node.id.name, t12.cloneNode(path71.node.init, true));
       }
-      const unwrapped = unwrapDefineComponent(path70.node.init, state.defineComponentAliases);
+      const unwrapped = unwrapDefineComponent(path71.node.init, state.defineComponentAliases);
       if (unwrapped) {
-        state.defineComponentDecls.set(path70.node.id.name, t12.cloneNode(unwrapped, true));
-        path70.node.init = unwrapped;
+        state.defineComponentDecls.set(path71.node.id.name, t12.cloneNode(unwrapped, true));
+        path71.node.init = unwrapped;
         state.transformed = true;
       }
     },
-    ExportDefaultDeclaration(path70) {
-      state.defaultExportPath = path70;
+    ExportDefaultDeclaration(path71) {
+      state.defaultExportPath = path71;
     }
   };
 }
@@ -30568,16 +30806,17 @@ function ensureRuntimeImport(program, importedName, localName = importedName) {
 // src/plugins/vue/transform/transformScript/imports.ts
 function createImportVisitors(program, state) {
   return {
-    ImportDeclaration(path70) {
-      if (path70.node.source.value === "vue") {
+    ImportDeclaration(path71) {
+      if (path71.node.source.value === "vue") {
         const movedVueRuntimeAPIs = /* @__PURE__ */ new Set([
           "useAttrs",
           "useSlots",
           "useModel",
-          "mergeModels"
+          "mergeModels",
+          "useTemplateRef"
         ]);
         const movedSpecifiers = [];
-        const remaining = path70.node.specifiers.filter((specifier) => {
+        const remaining = path71.node.specifiers.filter((specifier) => {
           if (t14.isImportSpecifier(specifier) && specifier.imported.type === "Identifier" && specifier.imported.name === WE_VU_RUNTIME_APIS4.defineComponent) {
             state.defineComponentAliases.add(specifier.local.name);
             state.transformed = true;
@@ -30599,29 +30838,29 @@ function createImportVisitors(program, state) {
           }
         }
         if (remaining.length === 0) {
-          path70.remove();
+          path71.remove();
           return;
         }
-        path70.node.specifiers = remaining;
+        path71.node.specifiers = remaining;
       }
-      if (path70.node.importKind === "type") {
+      if (path71.node.importKind === "type") {
         state.transformed = true;
-        path70.remove();
+        path71.remove();
         return;
       }
-      const kept = path70.node.specifiers.filter((specifier) => {
+      const kept = path71.node.specifiers.filter((specifier) => {
         if ("importKind" in specifier && specifier.importKind === "type") {
           state.transformed = true;
           return false;
         }
         return true;
       });
-      if (kept.length !== path70.node.specifiers.length) {
+      if (kept.length !== path71.node.specifiers.length) {
         if (kept.length === 0) {
-          path70.remove();
+          path71.remove();
           return;
         }
-        path70.node.specifiers = kept;
+        path71.node.specifiers = kept;
       }
     }
   };
@@ -30635,11 +30874,11 @@ init_esm_shims();
 import * as t15 from "@babel/types";
 function createSetupExposeVisitors(state) {
   return {
-    ObjectMethod(path70) {
-      if (!t15.isIdentifier(path70.node.key, { name: "setup" }) && !t15.isStringLiteral(path70.node.key, { value: "setup" })) {
+    ObjectMethod(path71) {
+      if (!t15.isIdentifier(path71.node.key, { name: "setup" }) && !t15.isStringLiteral(path71.node.key, { value: "setup" })) {
         return;
       }
-      const params = path70.node.params;
+      const params = path71.node.params;
       if (params.length < 2 || !t15.isObjectPattern(params[1])) {
         return;
       }
@@ -30650,8 +30889,8 @@ function createSetupExposeVisitors(state) {
         }
         return t15.isIdentifier(property.key, { name: "expose" }) && t15.isIdentifier(property.value, { name: "__expose" });
       });
-      if (hasVueExposeAlias && path70.scope.hasBinding("__expose") && !path70.scope.hasBinding("expose")) {
-        path70.scope.rename("__expose", "expose");
+      if (hasVueExposeAlias && path71.scope.hasBinding("__expose") && !path71.scope.hasBinding("expose")) {
+        path71.scope.rename("__expose", "expose");
         state.transformed = true;
         for (const property of ctxParam.properties) {
           if (!t15.isObjectProperty(property)) {
@@ -30736,143 +30975,147 @@ function stripOptionalFromPattern(pattern) {
 // src/plugins/vue/transform/transformScript/macros/stripTypes.ts
 function createStripTypesVisitors(state) {
   return {
-    ExportNamedDeclaration(path70) {
-      if (path70.node.exportKind === "type") {
+    ExportNamedDeclaration(path71) {
+      if (path71.node.exportKind === "type") {
         state.transformed = true;
-        path70.remove();
+        path71.remove();
         return;
       }
-      if (path70.node.specifiers?.length) {
-        const remaining = path70.node.specifiers.filter((spec) => {
+      if (path71.node.specifiers?.length) {
+        const remaining = path71.node.specifiers.filter((spec) => {
           if (t17.isExportSpecifier(spec)) {
             return spec.exportKind !== "type";
           }
           return true;
         });
-        if (remaining.length !== path70.node.specifiers.length) {
+        if (remaining.length !== path71.node.specifiers.length) {
           state.transformed = true;
           if (remaining.length === 0) {
-            path70.remove();
+            path71.remove();
             return;
           }
-          path70.node.specifiers = remaining;
+          path71.node.specifiers = remaining;
         }
       }
     },
-    CallExpression(path70) {
-      if (t17.isIdentifier(path70.node.callee, { name: "__expose" }) && path70.parentPath?.isExpressionStatement()) {
-        if (path70.node.arguments.length === 0) {
-          path70.parentPath.remove();
+    CallExpression(path71) {
+      if (t17.isIdentifier(path71.node.callee, { name: "__expose" }) && path71.parentPath?.isExpressionStatement()) {
+        if (path71.node.arguments.length === 0) {
+          path71.parentPath.remove();
           state.transformed = true;
           return;
         }
       }
-      if (path70.node.typeParameters) {
-        path70.node.typeParameters = null;
+      if (path71.node.typeParameters) {
+        path71.node.typeParameters = null;
         state.transformed = true;
       }
     },
-    NewExpression(path70) {
-      if (path70.node.typeParameters) {
-        path70.node.typeParameters = null;
+    NewExpression(path71) {
+      if (path71.node.typeParameters) {
+        path71.node.typeParameters = null;
         state.transformed = true;
       }
     },
-    ObjectProperty(path70) {
-      if (t17.isIdentifier(path70.node.key, { name: "__name" }) || t17.isStringLiteral(path70.node.key, { value: "__name" })) {
-        path70.remove();
+    ObjectProperty(path71) {
+      if (t17.isIdentifier(path71.node.key, { name: "__name" }) || t17.isStringLiteral(path71.node.key, { value: "__name" })) {
+        path71.remove();
         state.transformed = true;
       }
     },
-    TSTypeAliasDeclaration(path70) {
-      path70.remove();
+    TSTypeAliasDeclaration(path71) {
+      path71.remove();
       state.transformed = true;
     },
-    TSInterfaceDeclaration(path70) {
-      path70.remove();
+    TSInterfaceDeclaration(path71) {
+      path71.remove();
       state.transformed = true;
     },
-    TSEnumDeclaration(path70) {
-      path70.remove();
+    TSEnumDeclaration(path71) {
+      path71.remove();
       state.transformed = true;
     },
-    TSModuleDeclaration(path70) {
-      path70.remove();
+    TSModuleDeclaration(path71) {
+      path71.remove();
       state.transformed = true;
     },
-    TSImportEqualsDeclaration(path70) {
-      path70.remove();
+    TSImportEqualsDeclaration(path71) {
+      path71.remove();
       state.transformed = true;
     },
-    TSAsExpression(path70) {
-      path70.replaceWith(path70.node.expression);
+    TSAsExpression(path71) {
+      path71.replaceWith(path71.node.expression);
       state.transformed = true;
     },
-    TSTypeAssertion(path70) {
-      path70.replaceWith(path70.node.expression);
+    TSSatisfiesExpression(path71) {
+      path71.replaceWith(path71.node.expression);
       state.transformed = true;
     },
-    TSNonNullExpression(path70) {
-      path70.replaceWith(path70.node.expression);
+    TSTypeAssertion(path71) {
+      path71.replaceWith(path71.node.expression);
       state.transformed = true;
     },
-    TSTypeAnnotation(path70) {
-      path70.remove();
+    TSNonNullExpression(path71) {
+      path71.replaceWith(path71.node.expression);
       state.transformed = true;
     },
-    TSParameterProperty(path70) {
-      path70.replaceWith(path70.node.parameter);
+    TSTypeAnnotation(path71) {
+      path71.remove();
       state.transformed = true;
     },
-    Function(path70) {
-      if (path70.node.returnType) {
-        path70.node.returnType = null;
+    TSParameterProperty(path71) {
+      path71.replaceWith(path71.node.parameter);
+      state.transformed = true;
+    },
+    Function(path71) {
+      if (path71.node.returnType) {
+        path71.node.returnType = null;
         state.transformed = true;
       }
-      if (path70.node.typeParameters) {
-        path70.node.typeParameters = null;
+      if (path71.node.typeParameters) {
+        path71.node.typeParameters = null;
         state.transformed = true;
       }
-      for (const param of path70.node.params) {
+      for (const param of path71.node.params) {
         if (stripOptionalFromPattern(param)) {
           state.transformed = true;
         }
       }
     },
-    ClassMethod(path70) {
-      if (stripOptionalFlag(path70.node)) {
+    ClassMethod(path71) {
+      if (stripOptionalFlag(path71.node)) {
         state.transformed = true;
       }
     },
-    ClassPrivateMethod(path70) {
-      if (stripOptionalFlag(path70.node)) {
+    ClassPrivateMethod(path71) {
+      if (stripOptionalFlag(path71.node)) {
         state.transformed = true;
       }
     },
-    ClassAccessorProperty(path70) {
-      if (path70.node.typeAnnotation) {
-        path70.node.typeAnnotation = null;
+    ClassAccessorProperty(path71) {
+      if (path71.node.typeAnnotation) {
+        path71.node.typeAnnotation = null;
         state.transformed = true;
       }
-      if (stripOptionalFlag(path70.node)) {
+      if (stripOptionalFlag(path71.node)) {
         state.transformed = true;
       }
     },
-    ClassProperty(path70) {
-      if (path70.node.typeAnnotation) {
-        path70.node.typeAnnotation = null;
+    ClassProperty(path71) {
+      if (path71.node.typeAnnotation) {
+        path71.node.typeAnnotation = null;
         state.transformed = true;
       }
-      if (stripOptionalFlag(path70.node)) {
+      if (stripOptionalFlag(path71.node)) {
         state.transformed = true;
       }
     },
-    ClassPrivateProperty(path70) {
-      if (path70.node.typeAnnotation) {
-        path70.node.typeAnnotation = null;
+    ClassPrivateProperty(path71) {
+      if (path71.node.typeAnnotation) {
+        path71.node.typeAnnotation = null;
         state.transformed = true;
       }
-      if (stripOptionalFlag(path70.node)) {
+      if (stripOptionalFlag(path71.node)) {
         state.transformed = true;
       }
     }
@@ -30889,7 +31132,7 @@ function createMacroVisitors(state) {
 
 // src/plugins/vue/transform/transformScript/rewrite/index.ts
 init_esm_shims();
-import * as t23 from "@babel/types";
+import * as t24 from "@babel/types";
 
 // src/plugins/vue/transform/transformScript/rewrite/classStyle.ts
 init_esm_shims();
@@ -31394,6 +31637,53 @@ function rewriteComponentExport(params) {
   return true;
 }
 
+// src/plugins/vue/transform/transformScript/rewrite/templateRefs.ts
+init_esm_shims();
+import * as t23 from "@babel/types";
+function buildTemplateRefEntry(binding) {
+  const props = [
+    t23.objectProperty(t23.identifier("selector"), t23.stringLiteral(binding.selector)),
+    t23.objectProperty(t23.identifier("inFor"), t23.booleanLiteral(binding.inFor))
+  ];
+  if (binding.name) {
+    props.push(t23.objectProperty(t23.identifier("name"), t23.stringLiteral(binding.name)));
+  }
+  if (binding.expAst) {
+    const body = t23.blockStatement([t23.returnStatement(t23.cloneNode(binding.expAst, true))]);
+    props.push(t23.objectProperty(t23.identifier("get"), t23.functionExpression(null, [], body)));
+  }
+  if (binding.kind) {
+    props.push(t23.objectProperty(t23.identifier("kind"), t23.stringLiteral(binding.kind)));
+  }
+  return t23.objectExpression(props);
+}
+function injectTemplateRefs(optionsObject, bindings) {
+  if (!bindings.length) {
+    return false;
+  }
+  const entries = bindings.map((binding) => buildTemplateRefEntry(binding));
+  const refsArray = t23.arrayExpression(entries);
+  const key = createStaticObjectKey2("__wevuTemplateRefs");
+  const existing = getObjectPropertyByKey2(optionsObject, "__wevuTemplateRefs");
+  if (!existing) {
+    optionsObject.properties.push(t23.objectProperty(key, refsArray));
+    return true;
+  }
+  if (t23.isArrayExpression(existing.value)) {
+    existing.value.elements.push(...entries);
+    return true;
+  }
+  if (t23.isIdentifier(existing.value) || t23.isMemberExpression(existing.value)) {
+    existing.value = t23.arrayExpression([
+      ...entries,
+      t23.spreadElement(t23.cloneNode(existing.value, true))
+    ]);
+    return true;
+  }
+  logger_default.warn("\u65E0\u6CD5\u81EA\u52A8\u6CE8\u5165 template ref \u5143\u6570\u636E\uFF0C\u8BF7\u624B\u52A8\u5408\u5E76 __wevuTemplateRefs\u3002");
+  return false;
+}
+
 // src/plugins/vue/transform/transformScript/rewrite/index.ts
 function rewriteDefaultExport(ast, state, options, enabledPageFeatures, serializedWevuDefaults, parsedWevuDefaults) {
   if (!state.defaultExportPath) {
@@ -31406,10 +31696,10 @@ function rewriteDefaultExport(ast, state, options, enabledPageFeatures, serializ
     state.defineComponentDecls,
     state.defineComponentAliases
   );
-  if (componentExpr && t23.isObjectExpression(componentExpr) && enabledPageFeatures.size) {
+  if (componentExpr && t24.isObjectExpression(componentExpr) && enabledPageFeatures.size) {
     transformed = injectWevuPageFeatureFlagsIntoOptionsObject(componentExpr, enabledPageFeatures) || transformed;
   }
-  if (componentExpr && t23.isObjectExpression(componentExpr) && parsedWevuDefaults) {
+  if (componentExpr && t24.isObjectExpression(componentExpr) && parsedWevuDefaults) {
     transformed = applyWevuDefaultsToComponentOptions({
       componentExpr,
       parsedWevuDefaults,
@@ -31418,13 +31708,21 @@ function rewriteDefaultExport(ast, state, options, enabledPageFeatures, serializ
   }
   const classStyleBindings = options?.classStyleRuntime === "js" ? options?.classStyleBindings ?? [] : [];
   if (classStyleBindings.length) {
-    if (componentExpr && t23.isObjectExpression(componentExpr)) {
+    if (componentExpr && t24.isObjectExpression(componentExpr)) {
       ensureClassStyleRuntimeImports(ast.program);
       transformed = injectClassStyleComputed(componentExpr, classStyleBindings) || transformed;
     } else {
       logger_default.warn("\u65E0\u6CD5\u81EA\u52A8\u6CE8\u5165 class/style \u8BA1\u7B97\u5C5E\u6027\uFF1A\u7EC4\u4EF6\u9009\u9879\u4E0D\u662F\u5BF9\u8C61\u5B57\u9762\u91CF\u3002");
     }
   }
+  const templateRefs = options?.templateRefs ?? [];
+  if (templateRefs.length) {
+    if (componentExpr && t24.isObjectExpression(componentExpr)) {
+      transformed = injectTemplateRefs(componentExpr, templateRefs) || transformed;
+    } else {
+      logger_default.warn("\u65E0\u6CD5\u81EA\u52A8\u6CE8\u5165 template ref \u5143\u6570\u636E\uFF1A\u7EC4\u4EF6\u9009\u9879\u4E0D\u662F\u5BF9\u8C61\u5B57\u9762\u91CF\u3002");
+    }
+  }
   if (componentExpr) {
     if (options?.isApp) {
       transformed = injectWevuDefaultsForApp({
@@ -31508,29 +31806,29 @@ async function compileScriptPhase(descriptor, descriptorForCompile, filename, op
         const setupAst = parse(descriptorForCompile.scriptSetup.content, BABEL_TS_MODULE_PARSER_OPTIONS);
         const pending = [];
         traverse(setupAst, {
-          ImportDeclaration(path70) {
-            if (path70.node.importKind === "type") {
+          ImportDeclaration(path71) {
+            if (path71.node.importKind === "type") {
               return;
             }
-            if (!t24.isStringLiteral(path70.node.source)) {
+            if (!t25.isStringLiteral(path71.node.source)) {
               return;
             }
-            const importSource = path70.node.source.value;
-            for (const specifier of path70.node.specifiers) {
+            const importSource = path71.node.source.value;
+            for (const specifier of path71.node.specifiers) {
               if ("importKind" in specifier && specifier.importKind === "type") {
                 continue;
               }
-              if (!("local" in specifier) || !t24.isIdentifier(specifier.local)) {
+              if (!("local" in specifier) || !t25.isIdentifier(specifier.local)) {
                 continue;
               }
               const localName = specifier.local.name;
               if (!templateComponentNames.has(localName)) {
                 continue;
               }
-              if (t24.isImportDefaultSpecifier(specifier)) {
+              if (t25.isImportDefaultSpecifier(specifier)) {
                 pending.push({ localName, importSource, importedName: "default", kind: "default" });
-              } else if (t24.isImportSpecifier(specifier)) {
-                const importedName = t24.isIdentifier(specifier.imported) ? specifier.imported.name : t24.isStringLiteral(specifier.imported) ? specifier.imported.value : void 0;
+              } else if (t25.isImportSpecifier(specifier)) {
+                const importedName = t25.isIdentifier(specifier.imported) ? specifier.imported.name : t25.isStringLiteral(specifier.imported) ? specifier.imported.value : void 0;
                 pending.push({ localName, importSource, importedName, kind: "named" });
               }
             }
@@ -31581,7 +31879,8 @@ async function compileScriptPhase(descriptor, descriptorForCompile, filename, op
       templateComponentMeta: Object.keys(autoComponentMeta).length ? autoComponentMeta : void 0,
       wevuDefaults: options?.wevuDefaults,
       classStyleRuntime: templateCompiled?.classStyleRuntime,
-      classStyleBindings: templateCompiled?.classStyleBindings
+      classStyleBindings: templateCompiled?.classStyleBindings,
+      templateRefs: templateCompiled?.templateRefs
     });
     return { script: transformed.code, autoUsingComponentsMap, autoComponentMeta };
   }
@@ -31636,7 +31935,7 @@ function transformScopedCss(source, id) {
 function transformCssModules(source, id) {
   const classes = {};
   const hash = generateHash(id);
-  const classRegex = /\.([a-z_][\w-]*)\s*\{/gi;
+  const classRegex = /\.([a-z_][\w-]*)(?:\[[^\]]+\])?\s*\{/gi;
   const foundClasses = [];
   let result = classRegex.exec(source);
   while (result !== null) {
@@ -31722,7 +32021,7 @@ import {
 
 // src/plugins/vue/compiler/template/classStyleRuntime.ts
 init_esm_shims();
-import path53 from "pathe";
+import path54 from "pathe";
 var CLASS_STYLE_WXS_MODULE = "__weapp_vite";
 var CLASS_STYLE_WXS_FILE = "__weapp_vite_class_style";
 function buildClassStyleWxsTag(extension, src) {
@@ -31734,11 +32033,11 @@ function resolveClassStyleWxsLocation(options) {
   const normalizedExt = options.extension.startsWith(".") ? options.extension.slice(1) : options.extension;
   const normalizedRoot = normalizeRoot(options.packageRoot ?? "");
   const fileName = normalizedRoot ? `${normalizedRoot}/${CLASS_STYLE_WXS_FILE}.${normalizedExt}` : `${CLASS_STYLE_WXS_FILE}.${normalizedExt}`;
-  const baseDir = path53.posix.dirname(toPosixPath(options.relativeBase));
+  const baseDir = path54.posix.dirname(toPosixPath(options.relativeBase));
   const fromDir = baseDir === "." ? "." : baseDir;
-  let src = path53.posix.relative(fromDir, fileName);
+  let src = path54.posix.relative(fromDir, fileName);
   if (!src || src === ".") {
-    src = path53.posix.basename(fileName);
+    src = path54.posix.basename(fileName);
   }
   if (!src.startsWith(".") && !src.startsWith("/")) {
     src = `./${src}`;
@@ -32093,11 +32392,11 @@ init_esm_shims();
 
 // src/plugins/vue/compiler/template/expression/bindings.ts
 init_esm_shims();
-import * as t28 from "@babel/types";
+import * as t29 from "@babel/types";
 
 // src/plugins/vue/compiler/template/expression/parse.ts
 init_esm_shims();
-import * as t25 from "@babel/types";
+import * as t26 from "@babel/types";
 var babelExpressionCache = new LRUCache({ max: 1024 });
 var inlineHandlerCache = new LRUCache({ max: 1024 });
 var BABEL_GENERATE_MINI_PROGRAM_OPTIONS = {
@@ -32163,17 +32462,17 @@ function parseInlineHandler(exp) {
       return null;
     }
     const expression = stmt.expression;
-    if (!t25.isCallExpression(expression) || !t25.isIdentifier(expression.callee)) {
+    if (!t26.isCallExpression(expression) || !t26.isIdentifier(expression.callee)) {
       return null;
     }
     const name = expression.callee.name;
     const args = [];
     for (const arg of expression.arguments) {
-      if (t25.isIdentifier(arg) && arg.name === "$event") {
+      if (t26.isIdentifier(arg) && arg.name === "$event") {
         args.push("$event");
-      } else if (t25.isStringLiteral(arg) || t25.isNumericLiteral(arg) || t25.isBooleanLiteral(arg)) {
+      } else if (t26.isStringLiteral(arg) || t26.isNumericLiteral(arg) || t26.isBooleanLiteral(arg)) {
         args.push(arg.value);
-      } else if (t25.isNullLiteral(arg)) {
+      } else if (t26.isNullLiteral(arg)) {
         args.push(null);
       } else {
         inlineHandlerCache.set(exp, false);
@@ -32191,33 +32490,33 @@ function parseInlineHandler(exp) {
 
 // src/plugins/vue/compiler/template/expression/scopedSlot.ts
 init_esm_shims();
-import * as t27 from "@babel/types";
+import * as t28 from "@babel/types";
 
 // src/plugins/vue/compiler/template/expression/wxml.ts
 init_esm_shims();
-import * as t26 from "@babel/types";
+import * as t27 from "@babel/types";
 function templateLiteralToConcat(node) {
   const segments = [];
   node.quasis.forEach((quasi, index) => {
     const cooked = quasi.value.cooked ?? quasi.value.raw ?? "";
     if (cooked) {
-      segments.push(t26.stringLiteral(cooked));
+      segments.push(t27.stringLiteral(cooked));
     }
     if (index < node.expressions.length) {
       let inner = node.expressions[index];
-      if (t26.isTemplateLiteral(inner)) {
+      if (t27.isTemplateLiteral(inner)) {
         inner = templateLiteralToConcat(inner);
       }
       segments.push(inner);
     }
   });
   if (segments.length === 0) {
-    return t26.stringLiteral("");
+    return t27.stringLiteral("");
   }
   if (segments.length === 1) {
     return segments[0];
   }
-  return segments.reduce((acc, cur) => t26.binaryExpression("+", acc, cur));
+  return segments.reduce((acc, cur) => t27.binaryExpression("+", acc, cur));
 }
 function normalizeWxmlExpression(exp) {
   if (!exp.includes("`") && !exp.includes("??")) {
@@ -32233,21 +32532,21 @@ function normalizeWxmlExpression(exp) {
       return exp;
     }
     traverse(ast, {
-      LogicalExpression(path70) {
-        if (path70.node.operator !== "??") {
+      LogicalExpression(path71) {
+        if (path71.node.operator !== "??") {
           return;
         }
-        const left = path70.node.left;
-        const right = path70.node.right;
-        const test = t26.binaryExpression("!=", t26.cloneNode(left), t26.nullLiteral());
-        path70.replaceWith(t26.conditionalExpression(test, t26.cloneNode(left), t26.cloneNode(right)));
-        path70.skip();
+        const left = path71.node.left;
+        const right = path71.node.right;
+        const test = t27.binaryExpression("!=", t27.cloneNode(left), t27.nullLiteral());
+        path71.replaceWith(t27.conditionalExpression(test, t27.cloneNode(left), t27.cloneNode(right)));
+        path71.skip();
       },
-      TemplateLiteral(path70) {
-        if (t26.isTaggedTemplateExpression(path70.parent)) {
+      TemplateLiteral(path71) {
+        if (t27.isTaggedTemplateExpression(path71.parent)) {
           return;
         }
-        path70.replaceWith(templateLiteralToConcat(path70.node));
+        path71.replaceWith(templateLiteralToConcat(path71.node));
       }
     });
     const normalized = stmt.expression;
@@ -32324,19 +32623,19 @@ function rewriteScopedSlotExpression(exp, context) {
   const slotProps = collectSlotPropMapping(context);
   const createMemberAccess2 = (target, prop) => {
     if (!prop) {
-      return t27.identifier(target);
+      return t28.identifier(target);
     }
     if (/^[A-Z_$][\w$]*$/i.test(prop)) {
-      return t27.memberExpression(t27.identifier(target), t27.identifier(prop));
+      return t28.memberExpression(t28.identifier(target), t28.identifier(prop));
     }
-    return t27.memberExpression(t27.identifier(target), t27.stringLiteral(prop), true);
+    return t28.memberExpression(t28.identifier(target), t28.stringLiteral(prop), true);
   };
   traverse(ast, {
-    Identifier(path70) {
-      if (!path70.isReferencedIdentifier()) {
+    Identifier(path71) {
+      if (!path71.isReferencedIdentifier()) {
         return;
       }
-      const name = path70.node.name;
+      const name = path71.node.name;
       if (SCOPED_SLOT_GLOBALS.has(name)) {
         return;
       }
@@ -32345,23 +32644,23 @@ function rewriteScopedSlotExpression(exp, context) {
       }
       if (Object.prototype.hasOwnProperty.call(slotProps, name)) {
         const member2 = createMemberAccess2("__wvSlotPropsData", slotProps[name]);
-        const parent2 = path70.parentPath;
-        if (parent2.isObjectProperty() && parent2.node.shorthand && parent2.node.key === path70.node) {
+        const parent2 = path71.parentPath;
+        if (parent2.isObjectProperty() && parent2.node.shorthand && parent2.node.key === path71.node) {
           parent2.node.shorthand = false;
           parent2.node.value = member2;
           return;
         }
-        path70.replaceWith(member2);
+        path71.replaceWith(member2);
         return;
       }
       const member = createMemberAccess2("__wvOwner", name);
-      const parent = path70.parentPath;
-      if (parent.isObjectProperty() && parent.node.shorthand && parent.node.key === path70.node) {
+      const parent = path71.parentPath;
+      if (parent.isObjectProperty() && parent.node.shorthand && parent.node.key === path71.node) {
         parent.node.shorthand = false;
         parent.node.value = member;
         return;
       }
-      path70.replaceWith(member);
+      path71.replaceWith(member);
     }
   });
   const stmt = ast.program.body[0];
@@ -32389,45 +32688,45 @@ function normalizeClassBindingExpression(exp, context) {
     if (!node) {
       return;
     }
-    if (t28.isArrayExpression(node)) {
+    if (t29.isArrayExpression(node)) {
       for (const el of node.elements) {
         if (!el) {
           continue;
         }
-        if (t28.isSpreadElement(el)) {
+        if (t29.isSpreadElement(el)) {
           context.warnings.push("\u5C0F\u7A0B\u5E8F\u4E0D\u652F\u6301 :class \u7684\u5C55\u5F00\u8BED\u6CD5\uFF0C\u5DF2\u5FFD\u7565\u3002");
           continue;
         }
-        if (t28.isExpression(el)) {
+        if (t29.isExpression(el)) {
           visit(el);
         }
       }
       return;
     }
-    if (t28.isObjectExpression(node)) {
+    if (t29.isObjectExpression(node)) {
       for (const prop of node.properties) {
-        if (t28.isSpreadElement(prop)) {
+        if (t29.isSpreadElement(prop)) {
           context.warnings.push("\u5C0F\u7A0B\u5E8F\u4E0D\u652F\u6301 :class \u5BF9\u8C61\u7684\u5C55\u5F00\u8BED\u6CD5\uFF0C\u5DF2\u5FFD\u7565\u3002");
           continue;
         }
-        if (!t28.isObjectProperty(prop)) {
+        if (!t29.isObjectProperty(prop)) {
           continue;
         }
         const value = prop.value;
-        if (!t28.isExpression(value)) {
+        if (!t29.isExpression(value)) {
           continue;
         }
         const test = value;
         if (prop.computed) {
           const keyExpr = prop.key;
-          if (!t28.isExpression(keyExpr)) {
+          if (!t29.isExpression(keyExpr)) {
             continue;
           }
-          pushExpr(t28.conditionalExpression(test, keyExpr, t28.stringLiteral("")));
-        } else if (t28.isIdentifier(prop.key)) {
-          pushExpr(t28.conditionalExpression(test, t28.stringLiteral(prop.key.name), t28.stringLiteral("")));
-        } else if (t28.isStringLiteral(prop.key)) {
-          pushExpr(t28.conditionalExpression(test, t28.stringLiteral(prop.key.value), t28.stringLiteral("")));
+          pushExpr(t29.conditionalExpression(test, keyExpr, t29.stringLiteral("")));
+        } else if (t29.isIdentifier(prop.key)) {
+          pushExpr(t29.conditionalExpression(test, t29.stringLiteral(prop.key.name), t29.stringLiteral("")));
+        } else if (t29.isStringLiteral(prop.key)) {
+          pushExpr(t29.conditionalExpression(test, t29.stringLiteral(prop.key.value), t29.stringLiteral("")));
         }
       }
       return;
@@ -32451,25 +32750,25 @@ function normalizeStyleBindingExpression(exp, context) {
   };
   const buildKeyExpression = (key, computed) => {
     if (computed) {
-      return t28.isExpression(key) ? key : null;
+      return t29.isExpression(key) ? key : null;
     }
-    if (t28.isIdentifier(key)) {
-      return t28.stringLiteral(key.name);
+    if (t29.isIdentifier(key)) {
+      return t29.stringLiteral(key.name);
     }
-    if (t28.isStringLiteral(key)) {
-      return t28.stringLiteral(key.value);
+    if (t29.isStringLiteral(key)) {
+      return t29.stringLiteral(key.value);
     }
-    if (t28.isNumericLiteral(key)) {
-      return t28.stringLiteral(String(key.value));
+    if (t29.isNumericLiteral(key)) {
+      return t29.stringLiteral(String(key.value));
     }
-    if (t28.isBooleanLiteral(key)) {
-      return t28.stringLiteral(String(key.value));
+    if (t29.isBooleanLiteral(key)) {
+      return t29.stringLiteral(String(key.value));
     }
     return null;
   };
   const buildStylePair = (keyExpr, valueExpr) => {
-    return t28.callExpression(
-      t28.memberExpression(t28.identifier("__weapp_vite"), t28.identifier("stylePair")),
+    return t29.callExpression(
+      t29.memberExpression(t29.identifier("__weapp_vite"), t29.identifier("stylePair")),
       [keyExpr, valueExpr]
     );
   };
@@ -32477,32 +32776,32 @@ function normalizeStyleBindingExpression(exp, context) {
     if (!node) {
       return;
     }
-    if (t28.isArrayExpression(node)) {
+    if (t29.isArrayExpression(node)) {
       for (const el of node.elements) {
         if (!el) {
           continue;
         }
-        if (t28.isSpreadElement(el)) {
+        if (t29.isSpreadElement(el)) {
           context.warnings.push("\u5C0F\u7A0B\u5E8F\u4E0D\u652F\u6301 :style \u7684\u5C55\u5F00\u8BED\u6CD5\uFF0C\u5DF2\u5FFD\u7565\u3002");
           continue;
         }
-        if (t28.isExpression(el)) {
+        if (t29.isExpression(el)) {
           visit(el);
         }
       }
       return;
     }
-    if (t28.isObjectExpression(node)) {
+    if (t29.isObjectExpression(node)) {
       for (const prop of node.properties) {
-        if (t28.isSpreadElement(prop)) {
+        if (t29.isSpreadElement(prop)) {
           context.warnings.push("\u5C0F\u7A0B\u5E8F\u4E0D\u652F\u6301 :style \u5BF9\u8C61\u7684\u5C55\u5F00\u8BED\u6CD5\uFF0C\u5DF2\u5FFD\u7565\u3002");
           continue;
         }
-        if (!t28.isObjectProperty(prop)) {
+        if (!t29.isObjectProperty(prop)) {
           continue;
         }
         const value = prop.value;
-        if (!t28.isExpression(value)) {
+        if (!t29.isExpression(value)) {
           continue;
         }
         const keyExpr = buildKeyExpression(prop.key, prop.computed);
@@ -32524,7 +32823,7 @@ function normalizeStyleBindingExpression(exp, context) {
 
 // src/plugins/vue/compiler/template/expression/js.ts
 init_esm_shims();
-import * as t29 from "@babel/types";
+import * as t30 from "@babel/types";
 var JS_RUNTIME_GLOBALS = /* @__PURE__ */ new Set([
   "Math",
   "Number",
@@ -32579,13 +32878,13 @@ function createMemberAccess(target, prop) {
   if (!prop) {
     return target;
   }
-  if (t29.isValidIdentifier(prop)) {
-    return t29.memberExpression(target, t29.identifier(prop));
+  if (t30.isValidIdentifier(prop)) {
+    return t30.memberExpression(target, t30.identifier(prop));
   }
-  return t29.memberExpression(target, t29.stringLiteral(prop), true);
+  return t30.memberExpression(target, t30.stringLiteral(prop), true);
 }
 function createThisMemberAccess(prop) {
-  return createMemberAccess(t29.thisExpression(), prop);
+  return createMemberAccess(t30.thisExpression(), prop);
 }
 function normalizeJsExpressionWithContext(exp, context, options) {
   const trimmed = exp.trim();
@@ -32603,15 +32902,15 @@ function normalizeJsExpressionWithContext(exp, context, options) {
   const locals = collectScopedSlotLocals(context);
   const slotProps = context.rewriteScopedSlot ? collectSlotPropMapping(context) : {};
   traverse(ast, {
-    Identifier(path70) {
-      if (!path70.isReferencedIdentifier()) {
+    Identifier(path71) {
+      if (!path71.isReferencedIdentifier()) {
         return;
       }
-      const name = path70.node.name;
+      const name = path71.node.name;
       if (JS_RUNTIME_GLOBALS.has(name)) {
         return;
       }
-      if (path70.scope.hasBinding(name)) {
+      if (path71.scope.hasBinding(name)) {
         return;
       }
       if (locals.has(name)) {
@@ -32632,13 +32931,13 @@ function normalizeJsExpressionWithContext(exp, context, options) {
       } else {
         replacement = createThisMemberAccess(name);
       }
-      const parent = path70.parentPath;
-      if (parent.isObjectProperty() && parent.node.shorthand && parent.node.key === path70.node) {
+      const parent = path71.parentPath;
+      if (parent.isObjectProperty() && parent.node.shorthand && parent.node.key === path71.node) {
         parent.node.shorthand = false;
         parent.node.value = replacement;
         return;
       }
-      path70.replaceWith(replacement);
+      path71.replaceWith(replacement);
     }
   });
   const stmt = ast.program.body[0];
@@ -32656,7 +32955,7 @@ import { NodeTypes as NodeTypes9 } from "@vue/compiler-core";
 
 // src/plugins/vue/compiler/template/attributes.ts
 init_esm_shims();
-import * as t30 from "@babel/types";
+import * as t31 from "@babel/types";
 import { NodeTypes as NodeTypes3 } from "@vue/compiler-core";
 function toWxmlStringLiteral2(value) {
   const escaped = value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\r/g, "\\r").replace(/\n/g, "\\n");
@@ -32677,12 +32976,12 @@ function generateExpressionCode(exp) {
 }
 function mergeJsExpressionParts(parts) {
   if (!parts.length) {
-    return t30.stringLiteral("");
+    return t31.stringLiteral("");
   }
   if (parts.length === 1) {
     return parts[0];
   }
-  return t30.arrayExpression(parts);
+  return t31.arrayExpression(parts);
 }
 function createClassStyleBinding(context, type, exp, expAst) {
   const index = context.classStyleBindings.length;
@@ -32715,7 +33014,7 @@ function renderClassAttribute(staticClass, dynamicClassExp, context) {
   }
   const jsParts = [];
   if (staticValue) {
-    jsParts.push(t30.stringLiteral(staticValue));
+    jsParts.push(t31.stringLiteral(staticValue));
   }
   const dynamicAst = normalizeJsExpressionWithContext(dynamicClassExp, context, { hint: "class \u7ED1\u5B9A" });
   if (dynamicAst) {
@@ -32755,7 +33054,7 @@ function renderStyleAttribute(staticStyle, dynamicStyleExp, vShowExp, context) {
   }
   const jsParts = [];
   if (staticValue) {
-    jsParts.push(t30.stringLiteral(staticValue));
+    jsParts.push(t31.stringLiteral(staticValue));
   }
   if (dynamicStyleExp) {
     const dynamicAst = normalizeJsExpressionWithContext(dynamicStyleExp, context, { hint: "style \u7ED1\u5B9A" });
@@ -32766,10 +33065,10 @@ function renderStyleAttribute(staticStyle, dynamicStyleExp, vShowExp, context) {
   if (vShowExp) {
     const showAst = normalizeJsExpressionWithContext(vShowExp, context, { hint: "v-show" });
     if (showAst) {
-      jsParts.push(t30.conditionalExpression(
+      jsParts.push(t31.conditionalExpression(
         showAst,
-        t30.stringLiteral(""),
-        t30.stringLiteral("display: none")
+        t31.stringLiteral(""),
+        t31.stringLiteral("display: none")
       ));
     }
   }
@@ -33058,6 +33357,10 @@ function transformDirective(node, context, elementNode, forInfo) {
 }
 
 // src/plugins/vue/compiler/template/elements/attrs.ts
+var builtinTagSet = new Set(components.map((tag) => tag.toLowerCase()));
+function isBuiltinTag(tag) {
+  return builtinTagSet.has(tag.toLowerCase());
+}
 function collectElementAttributes(node, context, options) {
   const { props } = node;
   const attrs = options?.extraAttrs ? [...options.extraAttrs] : [];
@@ -33067,8 +33370,19 @@ function collectElementAttributes(node, context, options) {
   let dynamicStyleExp;
   let vShowExp;
   let vTextExp;
+  let templateRef;
+  const inFor = Boolean(options?.forInfo || context.forStack.length);
   for (const prop of props) {
     if (prop.type === NodeTypes9.ATTRIBUTE) {
+      if (prop.name === "ref") {
+        if (prop.value?.type === NodeTypes9.TEXT) {
+          const name = prop.value.content.trim();
+          if (name) {
+            templateRef = { name };
+          }
+        }
+        continue;
+      }
       if (prop.name === "class" && prop.value?.type === NodeTypes9.TEXT) {
         staticClass = prop.value.content;
         continue;
@@ -33087,6 +33401,16 @@ function collectElementAttributes(node, context, options) {
       if (options?.skipSlotDirective && prop.name === "slot") {
         continue;
       }
+      if (prop.name === "bind" && prop.arg?.type === NodeTypes9.SIMPLE_EXPRESSION && prop.arg.content === "ref") {
+        const rawExp = prop.exp?.type === NodeTypes9.SIMPLE_EXPRESSION ? prop.exp.content : "";
+        if (rawExp) {
+          const expAst = normalizeJsExpressionWithContext(rawExp, context, { hint: "ref \u7ED1\u5B9A" });
+          if (expAst) {
+            templateRef = { expAst };
+          }
+        }
+        continue;
+      }
       if (prop.name === "bind" && prop.arg?.type === NodeTypes9.SIMPLE_EXPRESSION && prop.arg.content === "class" && prop.exp?.type === NodeTypes9.SIMPLE_EXPRESSION) {
         dynamicClassExp = prop.exp.content;
         continue;
@@ -33109,6 +33433,18 @@ function collectElementAttributes(node, context, options) {
       }
     }
   }
+  if (templateRef) {
+    const className = `__wv-ref-${context.templateRefIndexSeed++}`;
+    staticClass = staticClass ? `${staticClass} ${className}` : className;
+    const isComponentRef = options?.isComponent ?? !isBuiltinTag(node.tag);
+    context.templateRefs.push({
+      selector: `.${className}`,
+      inFor,
+      name: templateRef.name,
+      expAst: templateRef.expAst,
+      kind: isComponentRef ? "component" : "element"
+    });
+  }
   const classAttr = renderClassAttribute(staticClass, dynamicClassExp, context);
   if (classAttr) {
     attrs.unshift(classAttr);
@@ -33131,7 +33467,7 @@ import { NodeTypes as NodeTypes11 } from "@vue/compiler-core";
 
 // src/plugins/vue/compiler/template/elements/tag-slot.ts
 init_esm_shims();
-import * as t31 from "@babel/types";
+import * as t32 from "@babel/types";
 import { NodeTypes as NodeTypes10 } from "@vue/compiler-core";
 function renderSlotNameAttribute(info, context, attrName) {
   if (info.type === "static" && info.value !== "default") {
@@ -33205,38 +33541,38 @@ function parseSlotPropsExpression(exp, context) {
       return {};
     }
     const expression = stmt.expression;
-    if (!t31.isArrowFunctionExpression(expression)) {
+    if (!t32.isArrowFunctionExpression(expression)) {
       return {};
     }
     const param = expression.params[0];
     if (!param) {
       return {};
     }
-    if (t31.isIdentifier(param)) {
+    if (t32.isIdentifier(param)) {
       return { [param.name]: "" };
     }
-    if (t31.isObjectPattern(param)) {
+    if (t32.isObjectPattern(param)) {
       const mapping = {};
       for (const prop of param.properties) {
-        if (t31.isRestElement(prop)) {
+        if (t32.isRestElement(prop)) {
           context.warnings.push("\u5C0F\u7A0B\u5E8F\u4E0D\u652F\u6301\u4F5C\u7528\u57DF\u63D2\u69FD\u7684\u5269\u4F59\u89E3\u6784\u5143\u7D20\u3002");
           continue;
         }
-        if (!t31.isObjectProperty(prop)) {
+        if (!t32.isObjectProperty(prop)) {
           continue;
         }
         const key = prop.key;
-        const propName = t31.isIdentifier(key) ? key.name : t31.isStringLiteral(key) ? key.value : void 0;
+        const propName = t32.isIdentifier(key) ? key.name : t32.isStringLiteral(key) ? key.value : void 0;
         if (!propName) {
           context.warnings.push("\u5C0F\u7A0B\u5E8F\u4E0D\u652F\u6301\u4F5C\u7528\u57DF\u63D2\u69FD\u7684\u8BA1\u7B97\u5C5E\u6027\u952E\u3002");
           continue;
         }
         const value = prop.value;
-        if (t31.isIdentifier(value)) {
+        if (t32.isIdentifier(value)) {
           mapping[value.name] = propName;
           continue;
         }
-        if (t31.isAssignmentPattern(value) && t31.isIdentifier(value.left)) {
+        if (t32.isAssignmentPattern(value) && t32.isIdentifier(value.left)) {
           mapping[value.left.name] = propName;
           context.warnings.push("\u4E0D\u652F\u6301\u4F5C\u7528\u57DF\u63D2\u69FD\u53C2\u6570\u7684\u9ED8\u8BA4\u503C\uFF0C\u9ED8\u8BA4\u503C\u5C06\u88AB\u5FFD\u7565\u3002");
           continue;
@@ -33450,7 +33786,8 @@ function transformComponentWithSlots(node, context, transformNode2, options) {
   if (!slotDeclarations.length) {
     const { attrs: attrs2, vTextExp } = collectElementAttributes(node, context, {
       skipSlotDirective: true,
-      forInfo: options?.forInfo
+      forInfo: options?.forInfo,
+      isComponent: true
     });
     let children = node.children.map((child) => transformNode2(child, context)).join("");
     if (vTextExp !== void 0) {
@@ -33470,7 +33807,8 @@ function transformComponentWithSlots(node, context, transformNode2, options) {
   }
   const { attrs } = collectElementAttributes(node, context, {
     skipSlotDirective: true,
-    forInfo: options?.forInfo
+    forInfo: options?.forInfo,
+    isComponent: true
   });
   const mergedAttrs = [...extraAttrs, ...attrs, ...slotGenericAttrs];
   if (slotNames.length) {
@@ -33532,7 +33870,8 @@ function transformComponentWithSlotsFallback(node, context, transformNode2, opti
   if (!slotDeclarations.length) {
     const { attrs: attrs2, vTextExp } = collectElementAttributes(node, context, {
       skipSlotDirective: true,
-      forInfo: options?.forInfo
+      forInfo: options?.forInfo,
+      isComponent: true
     });
     let children = node.children.map((child) => transformNode2(child, context)).join("");
     if (vTextExp !== void 0) {
@@ -33548,7 +33887,8 @@ function transformComponentWithSlotsFallback(node, context, transformNode2, opti
   const renderedSlots = slotDeclarations.map((decl) => renderSlotFallback(decl, context, transformNode2)).join("");
   const { attrs } = collectElementAttributes(node, context, {
     skipSlotDirective: true,
-    forInfo: options?.forInfo
+    forInfo: options?.forInfo,
+    isComponent: true
   });
   const mergedAttrs = [...extraAttrs, ...attrs];
   const attrString = mergedAttrs.length ? ` ${mergedAttrs.join(" ")}` : "";
@@ -33924,7 +34264,9 @@ function compileVueTemplateToWxml(template, filename, options) {
       classStyleWxsExtension: wxsExtension,
       classStyleWxsSrc: options?.classStyleWxsSrc,
       forStack: [],
-      forIndexSeed: 0
+      forIndexSeed: 0,
+      templateRefs: [],
+      templateRefIndexSeed: 0
     };
     let wxml = ast.children.map((child) => transformNode(child, context)).join("");
     if (context.classStyleWxs) {
@@ -33950,6 +34292,9 @@ ${wxml}`;
       result.classStyleBindings = context.classStyleBindings;
       result.classStyleRuntime = context.classStyleRuntime;
     }
+    if (context.templateRefs.length) {
+      result.templateRefs = context.templateRefs;
+    }
     return result;
   } catch (error) {
     warnings.push(`\u6A21\u677F\u7F16\u8BD1\u5931\u8D25\uFF1A${error}`);
@@ -34029,7 +34374,7 @@ async function compileVueFile(source, filename, options) {
 // src/plugins/vue/transform/plugin/index.ts
 init_esm_shims();
 import fs28 from "fs-extra";
-import path57 from "pathe";
+import path58 from "pathe";
 
 // src/plugins/vue/transform/vitePlugin/injectPageFeatures.ts
 init_esm_shims();
@@ -34152,18 +34497,18 @@ function emitClassStyleWxsAssetIfMissing(ctx, bundle, fileName, source) {
 // src/plugins/vue/transform/vitePlugin/fallbackEntries.ts
 init_esm_shims();
 import fs25 from "fs-extra";
-import path55 from "pathe";
+import path56 from "pathe";
 
 // src/plugins/vue/transform/vitePlugin/collectVuePages.ts
 init_esm_shims();
 import fs24 from "fs-extra";
-import path54 from "pathe";
+import path55 from "pathe";
 async function collectVuePages(root) {
   const results = [];
   try {
     const entries = await fs24.readdir(root);
     for (const entry of entries) {
-      const full = path54.join(root, entry);
+      const full = path55.join(root, entry);
       const stat5 = await fs24.stat(full);
       if (stat5.isDirectory()) {
         const nested = await collectVuePages(full);
@@ -34183,7 +34528,7 @@ async function collectFallbackPageEntryIds(configService, scanService) {
   if (scanService?.appEntry?.json?.pages?.length) {
     pageList = scanService.appEntry.json.pages;
   } else {
-    const appJsonPath = path55.join(configService.cwd, "dist", "app.json");
+    const appJsonPath = path56.join(configService.cwd, "dist", "app.json");
     try {
       const appJsonContent = await fs25.readFile(appJsonPath, "utf-8");
       const appJson = JSON.parse(appJsonContent);
@@ -34192,15 +34537,15 @@ async function collectFallbackPageEntryIds(configService, scanService) {
     }
   }
   const collectedEntries = /* @__PURE__ */ new Set();
-  pageList.forEach((p) => collectedEntries.add(path55.join(configService.absoluteSrcRoot, p)));
-  const extraVueFiles = await collectVuePages(path55.join(configService.absoluteSrcRoot, "pages"));
+  pageList.forEach((p) => collectedEntries.add(path56.join(configService.absoluteSrcRoot, p)));
+  const extraVueFiles = await collectVuePages(path56.join(configService.absoluteSrcRoot, "pages"));
   extraVueFiles.forEach((f) => collectedEntries.add(f.slice(0, -4)));
   return collectedEntries;
 }
 
 // src/plugins/vue/transform/plugin/classStyle.ts
 init_esm_shims();
-import path56 from "pathe";
+import path57 from "pathe";
 function resolveClassStylePackageRoot(ctx, relativeBase, configService) {
   const currentRoot = normalizeRoot(configService.currentSubPackageRoot ?? "");
   if (currentRoot) {
@@ -34225,7 +34570,7 @@ function resolveClassStylePackageRoot(ctx, relativeBase, configService) {
 function resolveClassStyleWxsLocationForBase(ctx, relativeBase, extension, configService) {
   const classStyleWxsShared = configService.weappViteConfig?.vue?.template?.classStyleWxsShared ?? true;
   const packageRoot = classStyleWxsShared ? resolveClassStylePackageRoot(ctx, relativeBase, configService) : (() => {
-    const dir = path56.posix.dirname(toPosixPath(relativeBase));
+    const dir = path57.posix.dirname(toPosixPath(relativeBase));
     return dir === "." ? "" : dir;
   })();
   return resolveClassStyleWxsLocation({ relativeBase, extension, packageRoot });
@@ -34337,6 +34682,16 @@ function createCompileVueFileOptions(ctx, pluginCtx, vuePath, isPage, isApp, con
       defaults: jsonConfig?.defaults,
       mergeStrategy: jsonConfig?.mergeStrategy
     },
+    sfcSrc: {
+      resolveId: async (source, importer) => {
+        if (typeof pluginCtx.resolve !== "function") {
+          return void 0;
+        }
+        const resolved = await pluginCtx.resolve(source, importer);
+        return resolved?.id;
+      },
+      checkMtime: getSfcCheckMtime(configService)
+    },
     wevuDefaults
   };
 }
@@ -34686,6 +35041,13 @@ function createVueTransformPlugin(ctx) {
   const scopedSlotModules = /* @__PURE__ */ new Map();
   const emittedScopedSlotChunks = /* @__PURE__ */ new Set();
   const classStyleRuntimeWarned = { value: false };
+  const resolveSfcSrc = async (pluginCtx, source, importer) => {
+    if (typeof pluginCtx.resolve !== "function") {
+      return void 0;
+    }
+    const resolved = await pluginCtx.resolve(source, importer);
+    return resolved?.id;
+  };
   return {
     name: `${VUE_PLUGIN_NAME}:transform`,
     buildStart() {
@@ -34708,7 +35070,13 @@ function createVueTransformPlugin(ctx) {
       let styles = styleBlocksCache.get(filename);
       if (!styles) {
         try {
-          const parsedSfc = await readAndParseSfc(filename, { checkMtime: getSfcCheckMtime(ctx.configService) });
+          const parsedSfc = await readAndParseSfc(filename, {
+            checkMtime: getSfcCheckMtime(ctx.configService),
+            resolveSrc: {
+              resolveId: (src, importer) => resolveSfcSrc(this, src, importer),
+              checkMtime: getSfcCheckMtime(ctx.configService)
+            }
+          });
           styles = parsedSfc.descriptor.styles;
           styleBlocksCache.set(filename, styles);
         } catch {
@@ -34734,7 +35102,7 @@ function createVueTransformPlugin(ctx) {
       }
       const sourceId = getSourceFromVirtualId(id);
       const filename = toAbsoluteId(sourceId, configService, void 0, { base: "cwd" });
-      if (!filename || !path57.isAbsolute(filename)) {
+      if (!filename || !path58.isAbsolute(filename)) {
         return null;
       }
       if (typeof this.addWatchFile === "function") {
@@ -34744,7 +35112,14 @@ function createVueTransformPlugin(ctx) {
       try {
         const source = typeof code === "string" ? code : configService.isDev ? await readFile2(filename, { checkMtime: true, encoding: "utf8" }) : await fs28.readFile(filename, "utf-8");
         try {
-          const parsedSfc = await readAndParseSfc(filename, { source, checkMtime: false });
+          const parsedSfc = await readAndParseSfc(filename, {
+            source,
+            checkMtime: false,
+            resolveSrc: {
+              resolveId: (src, importer) => resolveSfcSrc(this, src, importer),
+              checkMtime: getSfcCheckMtime(ctx.configService)
+            }
+          });
           styleBlocksCache.set(filename, parsedSfc.descriptor.styles);
         } catch {
         }
@@ -34761,6 +35136,12 @@ function createVueTransformPlugin(ctx) {
             classStyleRuntimeWarned
           })
         );
+        if (Array.isArray(result.meta?.sfcSrcDeps) && typeof this.addWatchFile === "function") {
+          for (const dep of result.meta.sfcSrcDeps) {
+            ;
+            this.addWatchFile(dep);
+          }
+        }
         if (isPage && result.script) {
           const injected = await injectWevuPageFeaturesInJsWithViteResolver(this, result.script, filename, {
             checkMtime: configService.isDev
@@ -34904,12 +35285,12 @@ init_esm_shims();
 import { createHash as createHash4 } from "crypto";
 import { removeExtension as removeExtension2 } from "@weapp-core/shared";
 import fs29 from "fs-extra";
-import path58 from "pathe";
+import path59 from "pathe";
 async function resolveWorkerEntry(ctx, entry) {
   const { configService, scanService } = ctx;
-  const relativeEntryPath = path58.join(scanService.workersDir, entry);
+  const relativeEntryPath = path59.join(scanService.workersDir, entry);
   const key = removeExtension2(relativeEntryPath);
-  const absoluteEntry = path58.resolve(configService.absoluteSrcRoot, relativeEntryPath);
+  const absoluteEntry = path59.resolve(configService.absoluteSrcRoot, relativeEntryPath);
   if (isJsOrTs(entry)) {
     const exists = await fs29.pathExists(absoluteEntry);
     if (!exists) {
@@ -34946,12 +35327,12 @@ function createWorkerBuildPlugin(ctx) {
       options.chunkFileNames = (chunkInfo) => {
         const workersDir = scanService.workersDir ?? "";
         if (chunkInfo.isDynamicEntry) {
-          return path58.join(workersDir, "[name].js");
+          return path59.join(workersDir, "[name].js");
         }
         const sourceId = chunkInfo.facadeModuleId ?? chunkInfo.moduleIds[0];
         const hashBase = typeof sourceId === "string" ? configService.relativeCwd(sourceId) : chunkInfo.name;
         const stableHash = createHash4("sha256").update(hashBase).digest("base64url").slice(0, 8);
-        return path58.join(workersDir, `${chunkInfo.name}-${stableHash}.js`);
+        return path59.join(workersDir, `${chunkInfo.name}-${stableHash}.js`);
       };
     }
   };
@@ -34967,7 +35348,7 @@ function workers(ctx) {
 init_esm_shims();
 import { removeExtension as removeExtension3 } from "@weapp-core/shared";
 import fs30 from "fs-extra";
-import path59 from "pathe";
+import path60 from "pathe";
 var wxsCodeCache = new LRUCache({
   max: 512
 });
@@ -34992,13 +35373,13 @@ async function transformWxsFile(state, wxsPath) {
     if (typeof result?.code === "string") {
       code = result.code;
     }
-    const dirname5 = path59.dirname(wxsPath);
+    const dirname5 = path60.dirname(wxsPath);
     await Promise.all(
       importees.map(({ source }) => {
         return transformWxsFile.call(
           this,
           state,
-          path59.resolve(dirname5, source)
+          path60.resolve(dirname5, source)
         );
       })
     );
@@ -35024,7 +35405,7 @@ async function handleWxsDeps(state, deps, absPath) {
       if (!jsExtensions.includes(dep.attrs.lang) && !arr) {
         return;
       }
-      const wxsPath = path59.resolve(path59.dirname(absPath), dep.value);
+      const wxsPath = path60.resolve(path60.dirname(absPath), dep.value);
       await transformWxsFile.call(this, state, wxsPath);
     })
   );
@@ -35193,17 +35574,17 @@ function mergeMiniprogram(options, ...configs) {
   };
   if (isDev) {
     const watchInclude = [
-      path60.join(cwd, srcRoot, "**")
+      path61.join(cwd, srcRoot, "**")
     ];
     const pluginRootConfig = config.weapp?.pluginRoot;
     if (pluginRootConfig) {
-      const absolutePluginRoot = path60.resolve(cwd, pluginRootConfig);
-      const relativeToSrc = path60.relative(
-        path60.resolve(cwd, srcRoot),
+      const absolutePluginRoot = path61.resolve(cwd, pluginRootConfig);
+      const relativeToSrc = path61.relative(
+        path61.resolve(cwd, srcRoot),
         absolutePluginRoot
       );
-      const pluginPatternBase = relativeToSrc.startsWith("..") ? absolutePluginRoot : path60.join(cwd, srcRoot, relativeToSrc);
-      watchInclude.push(path60.join(pluginPatternBase, "**"));
+      const pluginPatternBase = relativeToSrc.startsWith("..") ? absolutePluginRoot : path61.join(cwd, srcRoot, relativeToSrc);
+      watchInclude.push(path61.join(pluginPatternBase, "**"));
     }
     const inline = defu4(
       config,
@@ -35216,7 +35597,7 @@ function mergeMiniprogram(options, ...configs) {
           watch: {
             exclude: [
               ...defaultExcluded,
-              mpDistRoot ? path60.join(cwd, mpDistRoot, "**") : path60.join(cwd, "dist", "**")
+              mpDistRoot ? path61.join(cwd, mpDistRoot, "**") : path61.join(cwd, "dist", "**")
             ],
             include: watchInclude
           },
@@ -35468,14 +35849,14 @@ function createConfigService(ctx) {
     if (!pluginRootConfig) {
       return void 0;
     }
-    return path61.resolve(options.cwd, pluginRootConfig);
+    return path62.resolve(options.cwd, pluginRootConfig);
   };
   const resolvePluginSourceBase = () => {
     const absolutePluginRoot = resolveAbsolutePluginRoot();
     if (!absolutePluginRoot) {
       return void 0;
     }
-    return toPosixPath(path61.basename(absolutePluginRoot));
+    return toPosixPath(path62.basename(absolutePluginRoot));
   };
   const resolveAbsolutePluginOutputRoot = () => {
     const absolutePluginRoot = resolveAbsolutePluginRoot();
@@ -35484,19 +35865,19 @@ function createConfigService(ctx) {
     }
     const configured = options.projectConfig?.pluginRoot;
     if (configured) {
-      return path61.resolve(options.cwd, configured);
+      return path62.resolve(options.cwd, configured);
     }
-    const outDir = path61.resolve(options.cwd, options.mpDistRoot ?? "");
-    const pluginBase = path61.basename(absolutePluginRoot);
-    return path61.resolve(outDir, pluginBase);
+    const outDir = path62.resolve(options.cwd, options.mpDistRoot ?? "");
+    const pluginBase = path62.basename(absolutePluginRoot);
+    return path62.resolve(outDir, pluginBase);
   };
   const resolvePluginOutputBasePosix = () => {
     const absoluteOutputRoot = resolveAbsolutePluginOutputRoot();
     if (!absoluteOutputRoot) {
       return void 0;
     }
-    const outDir = path61.resolve(options.cwd, options.mpDistRoot ?? "");
-    const relative3 = path61.relative(outDir, absoluteOutputRoot);
+    const outDir = path62.resolve(options.cwd, options.mpDistRoot ?? "");
+    const relative3 = path62.relative(outDir, absoluteOutputRoot);
     const normalized = toPosixPath(relative3);
     if (!normalized || normalized === ".") {
       return resolvePluginSourceBase();
@@ -35632,7 +36013,7 @@ function createConfigService(ctx) {
       return options.mpDistRoot;
     },
     get outDir() {
-      return path61.resolve(options.cwd, options.mpDistRoot ?? "");
+      return path62.resolve(options.cwd, options.mpDistRoot ?? "");
     },
     get currentSubPackageRoot() {
       return options.currentSubPackageRoot;
@@ -35662,7 +36043,7 @@ function createConfigService(ctx) {
       return resolveAbsolutePluginOutputRoot();
     },
     get absoluteSrcRoot() {
-      return path61.resolve(options.cwd, options.srcRoot);
+      return path62.resolve(options.cwd, options.srcRoot);
     },
     get mode() {
       return options.mode;
@@ -35680,26 +36061,26 @@ function createConfigService(ctx) {
       return options.weappWeb;
     },
     relativeCwd(p) {
-      return path61.relative(options.cwd, p);
+      return path62.relative(options.cwd, p);
     },
     relativeSrcRoot(p) {
       return options.relativeSrcRoot(p);
     },
     relativeAbsoluteSrcRoot(p) {
-      const absoluteSrcRoot = path61.resolve(options.cwd, options.srcRoot);
+      const absoluteSrcRoot = path62.resolve(options.cwd, options.srcRoot);
       const absolutePluginRoot = resolveAbsolutePluginRoot();
       if (absolutePluginRoot) {
-        const relativeToPlugin = path61.relative(absolutePluginRoot, p);
+        const relativeToPlugin = path62.relative(absolutePluginRoot, p);
         if (!relativeToPlugin.startsWith("..")) {
-          const pluginBase = path61.basename(absolutePluginRoot);
-          return relativeToPlugin ? path61.join(pluginBase, relativeToPlugin) : pluginBase;
+          const pluginBase = path62.basename(absolutePluginRoot);
+          return relativeToPlugin ? path62.join(pluginBase, relativeToPlugin) : pluginBase;
         }
       }
-      const relativeFromSrc = path61.relative(absoluteSrcRoot, p);
+      const relativeFromSrc = path62.relative(absoluteSrcRoot, p);
       if (!relativeFromSrc.startsWith("..")) {
         return relativeFromSrc;
       }
-      const relativeFromCwd = path61.relative(options.cwd, p);
+      const relativeFromCwd = path62.relative(options.cwd, p);
       return relativeFromCwd;
     },
     relativeOutputPath(p) {
@@ -35825,7 +36206,7 @@ init_esm_shims();
 // src/runtime/npmPlugin/service.ts
 init_esm_shims();
 import fs34 from "fs-extra";
-import path64 from "pathe";
+import path65 from "pathe";
 
 // src/runtime/npmPlugin/builder.ts
 init_esm_shims();
@@ -35833,7 +36214,7 @@ import { isBuiltin } from "module";
 import process9 from "process";
 import { defu as defu8, isObject as isObject7 } from "@weapp-core/shared";
 import fs32 from "fs-extra";
-import path62 from "pathe";
+import path63 from "pathe";
 import { build as viteBuild } from "vite";
 function createPackageBuilder(ctx, oxcVitePlugin) {
   function isMiniprogramPackage(pkg) {
@@ -35924,14 +36305,14 @@ function createPackageBuilder(ctx, oxcVitePlugin) {
     const { packageJson: targetJson, rootPath } = packageInfo;
     const dependencies = targetJson.dependencies ?? {};
     const keys = Object.keys(dependencies);
-    const destOutDir = path62.resolve(outDir, dep);
+    const destOutDir = path63.resolve(outDir, dep);
     if (isMiniprogramPackage(targetJson)) {
       if (await shouldSkipBuild(destOutDir, isDependenciesCacheOutdate)) {
         logger_default.info(`[npm] \u4F9D\u8D56 \`${dep}\` \u672A\u53D1\u751F\u53D8\u5316\uFF0C\u8DF3\u8FC7\u5904\u7406!`);
         return;
       }
       await copyBuild({
-        from: path62.resolve(
+        from: path63.resolve(
           rootPath,
           targetJson.miniprogram
         ),
@@ -35957,7 +36338,7 @@ function createPackageBuilder(ctx, oxcVitePlugin) {
         return;
       }
       if (!isDependenciesCacheOutdate && await fs32.pathExists(destOutDir)) {
-        const destEntry = path62.resolve(destOutDir, "index.js");
+        const destEntry = path63.resolve(destOutDir, "index.js");
         if (await fs32.pathExists(destEntry)) {
           const [srcStat, destStat] = await Promise.all([fs32.stat(index), fs32.stat(destEntry)]);
           if (srcStat.mtimeMs <= destStat.mtimeMs) {
@@ -36002,11 +36383,11 @@ function createPackageBuilder(ctx, oxcVitePlugin) {
 init_esm_shims();
 import { isObject as isObject8, objectHash } from "@weapp-core/shared";
 import fs33 from "fs-extra";
-import path63 from "pathe";
+import path64 from "pathe";
 function createDependenciesCache(ctx) {
   function getDependenciesCacheFilePath(key = "/") {
     const configService = requireConfigService(ctx, "\u751F\u6210 npm \u7F13\u5B58\u8DEF\u5F84\u524D\u5FC5\u987B\u521D\u59CB\u5316 configService\u3002");
-    return path63.resolve(configService.cwd, `node_modules/weapp-vite/.cache/${key.replaceAll("/", "-")}.json`);
+    return path64.resolve(configService.cwd, `node_modules/weapp-vite/.cache/${key.replaceAll("/", "-")}.json`);
   }
   function dependenciesCacheHash() {
     const configService = requireConfigService(ctx, "\u8BFB\u53D6\u4F9D\u8D56\u7F13\u5B58\u54C8\u5E0C\u524D\u5FC5\u987B\u521D\u59CB\u5316 configService\u3002");
@@ -36076,10 +36457,10 @@ function createNpmService(ctx) {
     debug?.("buildNpm start");
     const packNpmRelationList = getPackNpmRelationList(ctx);
     const [mainRelation, ...subRelations] = packNpmRelationList;
-    const packageJsonPath = path64.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
+    const packageJsonPath = path65.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
     if (await fs34.pathExists(packageJsonPath)) {
       const pkgJson = await fs34.readJson(packageJsonPath);
-      const outDir = path64.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, "miniprogram_npm");
+      const outDir = path65.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, "miniprogram_npm");
       if (pkgJson.dependencies) {
         const dependencies = Object.keys(pkgJson.dependencies);
         if (dependencies.length > 0) {
@@ -36098,7 +36479,7 @@ function createNpmService(ctx) {
           const targetDirs = [
             ...subRelations.map((x) => {
               return {
-                npmDistDir: path64.resolve(ctx.configService.cwd, x.miniprogramNpmDistDir, "miniprogram_npm")
+                npmDistDir: path65.resolve(ctx.configService.cwd, x.miniprogramNpmDistDir, "miniprogram_npm")
               };
             }),
             ...[...ctx.scanService.independentSubPackageMap.values()].map((x) => {
@@ -36106,7 +36487,7 @@ function createNpmService(ctx) {
               return {
                 root: x.subPackage.root,
                 dependencies: dependencies2,
-                npmDistDir: path64.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, x.subPackage.root, "miniprogram_npm")
+                npmDistDir: path65.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, x.subPackage.root, "miniprogram_npm")
               };
             })
           ];
@@ -36118,7 +36499,7 @@ function createNpmService(ctx) {
                   overwrite: true,
                   filter: (src) => {
                     if (Array.isArray(x.dependencies)) {
-                      const relPath = path64.relative(outDir, src);
+                      const relPath = path65.relative(outDir, src);
                       if (relPath === "") {
                         return true;
                       }
@@ -36134,7 +36515,7 @@ function createNpmService(ctx) {
                 overwrite: true,
                 filter: (src) => {
                   if (Array.isArray(x.dependencies)) {
-                    const relPath = path64.relative(outDir, src);
+                    const relPath = path65.relative(outDir, src);
                     if (relPath === "") {
                       return true;
                     }
@@ -37229,12 +37610,12 @@ init_esm_shims();
 // src/runtime/scanPlugin/service.ts
 init_esm_shims();
 import { isObject as isObject9 } from "@weapp-core/shared";
-import path68 from "pathe";
+import path69 from "pathe";
 
 // src/runtime/scanPlugin/styleEntries/index.ts
 init_esm_shims();
 import fs37 from "fs-extra";
-import path67 from "pathe";
+import path68 from "pathe";
 
 // src/runtime/scanPlugin/styleEntries/config.ts
 init_esm_shims();
@@ -37305,7 +37686,7 @@ function coerceStyleConfig(entry) {
 // src/runtime/scanPlugin/styleEntries/entries.ts
 init_esm_shims();
 import fs36 from "fs-extra";
-import path65 from "pathe";
+import path66 from "pathe";
 
 // src/runtime/scanPlugin/styleEntries/patterns.ts
 init_esm_shims();
@@ -37389,18 +37770,18 @@ function addStyleEntry(descriptor, absolutePath, posixOutput, root, normalizedRo
     source: descriptor.source,
     absolutePath,
     outputRelativePath: posixOutput,
-    inputExtension: path65.extname(absolutePath).toLowerCase(),
+    inputExtension: path66.extname(absolutePath).toLowerCase(),
     scope: descriptor.scope,
     include,
     exclude
   });
 }
 function appendDefaultScopedStyleEntries(root, normalizedRoot, service, dedupe, normalized) {
-  const absoluteSubRoot = path65.resolve(service.absoluteSrcRoot, root);
+  const absoluteSubRoot = path66.resolve(service.absoluteSrcRoot, root);
   for (const { base, scope } of DEFAULT_SCOPED_FILES) {
     for (const ext2 of DEFAULT_SCOPED_EXTENSIONS) {
       const filename = `${base}${ext2}`;
-      const absolutePath = path65.resolve(absoluteSubRoot, filename);
+      const absolutePath = path66.resolve(absoluteSubRoot, filename);
       if (!fs36.existsSync(absolutePath)) {
         continue;
       }
@@ -37425,7 +37806,7 @@ function appendDefaultScopedStyleEntries(root, normalizedRoot, service, dedupe,
 
 // src/runtime/scanPlugin/styleEntries/resolve.ts
 init_esm_shims();
-import path66 from "pathe";
+import path67 from "pathe";
 function resolveStyleEntryAbsolutePath(source, subPackageRoot, configService) {
   const service = configService;
   if (!service) {
@@ -37436,17 +37817,17 @@ function resolveStyleEntryAbsolutePath(source, subPackageRoot, configService) {
     return void 0;
   }
   const srcRoot = service.absoluteSrcRoot;
-  const absoluteSubRoot = path66.resolve(srcRoot, subPackageRoot);
+  const absoluteSubRoot = path67.resolve(srcRoot, subPackageRoot);
   const normalizedEntry = toPosixPath(trimmed);
   const normalizedRoot = toPosixPath(subPackageRoot);
   const candidates = [];
-  if (path66.isAbsolute(trimmed)) {
+  if (path67.isAbsolute(trimmed)) {
     candidates.push(trimmed);
   } else if (normalizedEntry === normalizedRoot || normalizedEntry.startsWith(`${normalizedRoot}/`)) {
-    candidates.push(path66.resolve(srcRoot, trimmed));
+    candidates.push(path67.resolve(srcRoot, trimmed));
   } else {
-    candidates.push(path66.resolve(absoluteSubRoot, trimmed));
-    candidates.push(path66.resolve(srcRoot, trimmed));
+    candidates.push(path67.resolve(absoluteSubRoot, trimmed));
+    candidates.push(path67.resolve(srcRoot, trimmed));
   }
   for (const candidate of candidates) {
     if (isPathInside(srcRoot, candidate)) {
@@ -37474,7 +37855,7 @@ function inferScopeFromRelativePath(relativePath) {
   if (cleaned.includes("/")) {
     return void 0;
   }
-  const base = path66.posix.basename(cleaned, path66.posix.extname(cleaned));
+  const base = path67.posix.basename(cleaned, path67.posix.extname(cleaned));
   if (base === "pages") {
     return "pages";
   }
@@ -37516,7 +37897,7 @@ function normalizeSubPackageStyleEntries(styles, subPackage, configService) {
       logger_default.warn(`[\u5206\u5305] \u5206\u5305 ${root} \u6837\u5F0F\u5165\u53E3 \`${descriptor.source}\` \u5BF9\u5E94\u6587\u4EF6\u4E0D\u5B58\u5728\uFF0C\u5DF2\u5FFD\u7565\u3002`);
       continue;
     }
-    const ext2 = path67.extname(absolutePath).toLowerCase();
+    const ext2 = path68.extname(absolutePath).toLowerCase();
     if (!SUPPORTED_SHARED_STYLE_EXTS.has(ext2)) {
       logger_default.warn(`[\u5206\u5305] \u5206\u5305 ${root} \u6837\u5F0F\u5165\u53E3 \`${descriptor.source}\` \u5F53\u524D\u4EC5\u652F\u6301\u4EE5\u4E0B\u683C\u5F0F\uFF1A${SUPPORTED_SHARED_STYLE_EXTENSIONS.join(", ")}\uFF0C\u5DF2\u5FFD\u7565\u3002`);
       continue;
@@ -37568,13 +37949,13 @@ function createScanService(ctx) {
       return scanState.appEntry;
     }
     const appDirname = ctx.configService.absoluteSrcRoot;
-    const appBasename = path68.resolve(appDirname, "app");
+    const appBasename = path69.resolve(appDirname, "app");
     let { path: appConfigFile } = await findJsonEntry(appBasename);
     const { path: appEntryPath } = await findJsEntry(appBasename);
     let configFromVue;
     let vueAppPath;
     if (!appConfigFile) {
-      const { extractConfigFromVue: extractConfigFromVue2 } = await import("./file-JVATZEJQ.mjs");
+      const { extractConfigFromVue: extractConfigFromVue2 } = await import("./file-XQ5KCZRI.mjs");
       vueAppPath = await findVueEntry(appBasename);
       if (vueAppPath) {
         configFromVue = await extractConfigFromVue2(vueAppPath);
@@ -37584,7 +37965,7 @@ function createScanService(ctx) {
       }
     }
     if (ctx.configService.absolutePluginRoot) {
-      const pluginBasename = path68.resolve(ctx.configService.absolutePluginRoot, "plugin");
+      const pluginBasename = path69.resolve(ctx.configService.absolutePluginRoot, "plugin");
       const { path: pluginConfigFile } = await findJsonEntry(pluginBasename);
       if (pluginConfigFile) {
         const pluginConfig = await ctx.jsonService.read(pluginConfigFile);
@@ -37613,14 +37994,14 @@ function createScanService(ctx) {
         scanState.appEntry = resolvedAppEntry;
         const { sitemapLocation = "sitemap.json", themeLocation = "theme.json" } = config;
         if (sitemapLocation) {
-          const { path: sitemapJsonPath } = await findJsonEntry(path68.resolve(appDirname, sitemapLocation));
+          const { path: sitemapJsonPath } = await findJsonEntry(path69.resolve(appDirname, sitemapLocation));
           if (sitemapJsonPath) {
             resolvedAppEntry.sitemapJsonPath = sitemapJsonPath;
             resolvedAppEntry.sitemapJson = await ctx.jsonService.read(sitemapJsonPath);
           }
         }
         if (themeLocation) {
-          const { path: themeJsonPath } = await findJsonEntry(path68.resolve(appDirname, themeLocation));
+          const { path: themeJsonPath } = await findJsonEntry(path69.resolve(appDirname, themeLocation));
           if (themeJsonPath) {
             resolvedAppEntry.themeJsonPath = themeJsonPath;
             resolvedAppEntry.themeJson = await ctx.jsonService.read(themeJsonPath);
@@ -37894,7 +38275,7 @@ function createWebServicePlugin(ctx) {
 init_esm_shims();
 import { removeExtensionDeep as removeExtensionDeep13 } from "@weapp-core/shared";
 import fs38 from "fs-extra";
-import path69 from "pathe";
+import path70 from "pathe";
 
 // src/wxml/index.ts
 init_esm_shims();
@@ -40537,7 +40918,7 @@ function createWxmlService(ctx) {
         return cached;
       }
     }
-    const dirname5 = path69.dirname(filepath);
+    const dirname5 = path70.dirname(filepath);
     const wxml = await fs38.readFile(filepath, "utf8");
     const res = analyze(wxml);
     tokenMap.set(filepath, res);
@@ -40546,9 +40927,9 @@ function createWxmlService(ctx) {
       filepath,
       res.deps.filter((x) => isImportTag(x.tagName) && isTemplate(x.value)).map((x) => {
         if (x.value.startsWith("/")) {
-          return path69.resolve(configService.absoluteSrcRoot, x.value.slice(1));
+          return path70.resolve(configService.absoluteSrcRoot, x.value.slice(1));
         } else {
-          return path69.resolve(dirname5, x.value);
+          return path70.resolve(dirname5, x.value);
         }
       })
     );