weapp-vite 5.6.0 → 5.6.1

package/dist/{chunk-KE6RSOKX.cjs → chunk-6JB3ELRA.cjs}

@@ -22964,6 +22964,8 @@ var watchedCssExts = new Set(supportedCssLangs.map((ext2) => `.${ext2}`));
 var configSuffixes = configExtensions.map((ext2) => `.${ext2}`);
 var sidecarSuffixes = [...configSuffixes, ...watchedCssExts];
 var watchLimitErrorCodes = /* @__PURE__ */ new Set(["EMFILE", "ENOSPC"]);
+var importProtocols = /^(?:https?:|data:|blob:|\/)/i;
+var cssImportRE = /@(import|wv-keep-import)\s+(?:url\()?['"]?([^'")\s]+)['"]?\)?/gi;
 function isWatchLimitError(error) {
   if (!error || typeof error !== "object") {
     return false;
@@ -22974,9 +22976,198 @@ function isWatchLimitError(error) {
   }
   return watchLimitErrorCodes.has(maybeError.code);
 }
-async function invalidateEntryForSidecar(filePath) {
+function normalizePath2(p) {
+  return _pathe2.default.normalize(p);
+}
+function ensureCssGraph(ctx) {
+  return ctx.runtimeState.css;
+}
+function cleanupImporterGraph(ctx, importer) {
+  const graph = ensureCssGraph(ctx);
+  const normalizedImporter = normalizePath2(importer);
+  const existingDeps = graph.importerToDependencies.get(normalizedImporter);
+  if (!existingDeps) {
+    return;
+  }
+  graph.importerToDependencies.delete(normalizedImporter);
+  for (const dep of existingDeps) {
+    const importers = graph.dependencyToImporters.get(dep);
+    if (!importers) {
+      continue;
+    }
+    importers.delete(normalizedImporter);
+    if (importers.size === 0) {
+      graph.dependencyToImporters.delete(dep);
+    }
+  }
+}
+function registerCssImports(ctx, importer, dependencies) {
+  const graph = ensureCssGraph(ctx);
+  const normalizedImporter = normalizePath2(importer);
+  const normalizedDeps = /* @__PURE__ */ new Set();
+  for (const dependency of dependencies) {
+    if (!dependency) {
+      continue;
+    }
+    normalizedDeps.add(normalizePath2(dependency));
+  }
+  const previousDeps = _nullishCoalesce(graph.importerToDependencies.get(normalizedImporter), () => ( /* @__PURE__ */ new Set()));
+  if (previousDeps.size) {
+    for (const previous of previousDeps) {
+      if (normalizedDeps.has(previous)) {
+        continue;
+      }
+      const importers = graph.dependencyToImporters.get(previous);
+      if (!importers) {
+        continue;
+      }
+      importers.delete(normalizedImporter);
+      if (importers.size === 0) {
+        graph.dependencyToImporters.delete(previous);
+      }
+    }
+  }
+  graph.importerToDependencies.set(normalizedImporter, normalizedDeps);
+  for (const dependency of normalizedDeps) {
+    let importers = graph.dependencyToImporters.get(dependency);
+    if (!importers) {
+      importers = /* @__PURE__ */ new Set();
+      graph.dependencyToImporters.set(dependency, importers);
+    }
+    importers.add(normalizedImporter);
+  }
+}
+async function extractCssImportDependencies(ctx, importer) {
+  try {
+    const stats = await actualFS.default.promises.stat(importer);
+    if (!stats.isFile()) {
+      cleanupImporterGraph(ctx, importer);
+      return;
+    }
+  } catch (e27) {
+    cleanupImporterGraph(ctx, importer);
+    return;
+  }
+  let cssContent;
+  try {
+    cssContent = await actualFS.default.promises.readFile(importer, "utf8");
+  } catch (e28) {
+    cleanupImporterGraph(ctx, importer);
+    return;
+  }
+  cssImportRE.lastIndex = 0;
+  const dependencies = /* @__PURE__ */ new Set();
+  const dir = _pathe2.default.dirname(importer);
+  while (true) {
+    const match2 = cssImportRE.exec(cssContent);
+    if (!match2) {
+      break;
+    }
+    const rawSpecifier = _optionalChain([match2, 'access', _362 => _362[2], 'optionalAccess', _363 => _363.trim, 'call', _364 => _364()]);
+    if (!rawSpecifier) {
+      continue;
+    }
+    if (importProtocols.test(rawSpecifier)) {
+      if (rawSpecifier.startsWith("/")) {
+        const absolute = _pathe2.default.resolve(ctx.configService.absoluteSrcRoot, rawSpecifier.slice(1));
+        dependencies.add(absolute);
+        const ext3 = _pathe2.default.extname(absolute);
+        if (ext3) {
+          dependencies.add(absolute.slice(0, -ext3.length));
+        }
+      }
+      continue;
+    }
+    let specifier = rawSpecifier;
+    if (specifier.startsWith("@/")) {
+      specifier = _pathe2.default.join(ctx.configService.absoluteSrcRoot, specifier.slice(2));
+    } else if (specifier === "@") {
+      specifier = ctx.configService.absoluteSrcRoot;
+    }
+    if (specifier.startsWith("~")) {
+      specifier = specifier.slice(1);
+    }
+    const cleaned = specifier.replace(/[?#].*$/, "");
+    const resolved = _pathe2.default.resolve(dir, cleaned);
+    dependencies.add(resolved);
+    const ext2 = _pathe2.default.extname(resolved);
+    if (!ext2) {
+      dependencies.add(resolved);
+    } else {
+      dependencies.add(resolved.slice(0, -ext2.length));
+    }
+  }
+  registerCssImports(ctx, importer, dependencies);
+}
+function collectCssImporters(ctx, dependency) {
+  const graph = ensureCssGraph(ctx);
+  const normalizedDependency = normalizePath2(dependency);
+  const matches2 = /* @__PURE__ */ new Set();
+  const direct = graph.dependencyToImporters.get(normalizedDependency);
+  if (direct) {
+    for (const importer of direct) {
+      matches2.add(importer);
+    }
+  }
+  const ext2 = _pathe2.default.extname(normalizedDependency);
+  if (ext2) {
+    const base = normalizedDependency.slice(0, -ext2.length);
+    const baseMatches = graph.dependencyToImporters.get(base);
+    if (baseMatches) {
+      for (const importer of baseMatches) {
+        matches2.add(importer);
+      }
+    }
+  }
+  return matches2;
+}
+async function resolveScriptForCss(cache2, basePath) {
+  const cached = cache2.get(basePath);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const result = await findJsEntry(basePath);
+  const scriptPath = result.path;
+  cache2.set(basePath, scriptPath);
+  return scriptPath;
+}
+async function collectAffectedScriptsAndImporters(ctx, startCssFile) {
+  const queue = [normalizePath2(startCssFile)];
+  const visitedCss = /* @__PURE__ */ new Set();
+  const affectedImporters = /* @__PURE__ */ new Set();
+  const affectedScripts = /* @__PURE__ */ new Set();
+  const scriptCache = /* @__PURE__ */ new Map();
+  while (queue.length) {
+    const current2 = queue.shift();
+    if (visitedCss.has(current2)) {
+      continue;
+    }
+    visitedCss.add(current2);
+    const ext2 = _pathe2.default.extname(current2);
+    if (ext2) {
+      const base = current2.slice(0, -ext2.length);
+      const script = await resolveScriptForCss(scriptCache, base);
+      if (script) {
+        affectedScripts.add(script);
+      }
+    }
+    const importers = collectCssImporters(ctx, current2);
+    for (const importer of importers) {
+      if (!visitedCss.has(importer)) {
+        queue.push(importer);
+      }
+      affectedImporters.add(importer);
+    }
+  }
+  return {
+    importers: affectedImporters,
+    scripts: affectedScripts
+  };
+}
+async function invalidateEntryForSidecar(ctx, filePath, event = "update") {
   const configSuffix = configSuffixes.find((suffix) => filePath.endsWith(suffix));
   const ext2 = _pathe2.default.extname(filePath);
+  const normalizedPath = normalizePath2(filePath);
   let scriptBasePath;
   if (configSuffix) {
     scriptBasePath = filePath.slice(0, -configSuffix.length);
@@ -22986,11 +23177,51 @@ async function invalidateEntryForSidecar(filePath) {
   if (!scriptBasePath) {
     return;
   }
-  const { path: scriptPath } = await findJsEntry(scriptBasePath);
-  if (!scriptPath) {
+  const touchedTargets = /* @__PURE__ */ new Set();
+  const touchedScripts = /* @__PURE__ */ new Set();
+  const primaryScript = await findJsEntry(scriptBasePath);
+  if (primaryScript.path) {
+    touchedScripts.add(primaryScript.path);
+  }
+  if (!primaryScript.path && ext2 && watchedCssExts.has(ext2)) {
+    const { importers, scripts } = await collectAffectedScriptsAndImporters(ctx, normalizedPath);
+    for (const importer of importers) {
+      touchedTargets.add(importer);
+    }
+    for (const script of scripts) {
+      touchedScripts.add(script);
+    }
+  }
+  const isCssSidecar = Boolean(ext2 && watchedCssExts.has(ext2));
+  const configService = ctx.configService;
+  const relativeSource = configService.relativeCwd(normalizedPath);
+  for (const target of touchedTargets) {
+    try {
+      await touch(target);
+    } catch (e29) {
+    }
+  }
+  for (const script of touchedScripts) {
+    try {
+      await touch(script);
+    } catch (e30) {
+    }
+  }
+  if (!touchedTargets.size && !touchedScripts.size) {
+    if (event === "create" && isCssSidecar) {
+      logger_default.info(`[sidecar:${event}] ${relativeSource} \u65B0\u589E\uFF0C\u4F46\u672A\u627E\u5230\u5F15\u7528\u65B9\uFF0C\u7B49\u5F85\u540E\u7EED\u5173\u8054`);
+    }
     return;
   }
-  await touch(scriptPath);
+  const touchedList = [];
+  for (const target of touchedTargets) {
+    touchedList.push(configService.relativeCwd(target));
+  }
+  for (const script of touchedScripts) {
+    touchedList.push(configService.relativeCwd(script));
+  }
+  const uniqueTouched = Array.from(new Set(touchedList));
+  logger_default.success(`[sidecar:${event}] ${relativeSource} -> \u5237\u65B0 ${uniqueTouched.join(", ")}`);
 }
 function ensureSidecarWatcher(ctx, rootDir) {
   if (!ctx.configService.isDev || !rootDir || _process2.default.env.VITEST === "true" || _process2.default.env.NODE_ENV === "test") {
@@ -23004,32 +23235,51 @@ function ensureSidecarWatcher(ctx, rootDir) {
   if (sidecarWatcherMap.has(absRoot)) {
     return;
   }
-  const handleSidecarChange = (filePath) => {
+  let isReady = false;
+  const handleSidecarChange = (event, filePath, ready) => {
     if (!isSidecarFile(filePath)) {
       return;
     }
-    void invalidateEntryForSidecar(filePath);
+    const ext2 = _pathe2.default.extname(filePath);
+    const isCssFile = Boolean(ext2 && watchedCssExts.has(ext2));
+    if (isCssFile && (event === "create" || event === "update")) {
+      void extractCssImportDependencies(ctx, filePath);
+    }
+    const shouldInvalidate = event === "create" && ready || event === "delete";
+    if (shouldInvalidate) {
+      void (async () => {
+        await invalidateEntryForSidecar(ctx, filePath, event);
+        if (isCssFile && event === "delete") {
+          cleanupImporterGraph(ctx, filePath);
+        }
+      })();
+      return;
+    }
+    if (isCssFile && event === "delete") {
+      cleanupImporterGraph(ctx, filePath);
+    }
   };
   const patterns = [
     ...configExtensions.map((ext2) => _pathe2.default.join(absRoot, `**/*.${ext2}`)),
     ...supportedCssLangs.map((ext2) => _pathe2.default.join(absRoot, `**/*.${ext2}`))
   ];
   const watcher = esm_default.watch(patterns, {
-    ignoreInitial: true,
+    ignoreInitial: false,
     persistent: true,
     awaitWriteFinish: {
       stabilityThreshold: 100,
       pollInterval: 20
     }
   });
-  const forwardChange = (input) => {
+  const forwardChange = (event, input) => {
     if (!input) {
       return;
     }
-    handleSidecarChange(_pathe2.default.normalize(input));
+    handleSidecarChange(event, _pathe2.default.normalize(input), isReady);
   };
-  watcher.on("add", forwardChange);
-  watcher.on("unlink", forwardChange);
+  watcher.on("add", (path36) => forwardChange("create", path36));
+  watcher.on("change", (path36) => forwardChange("update", path36));
+  watcher.on("unlink", (path36) => forwardChange("delete", path36));
   watcher.on("raw", (eventName, rawPath, details) => {
     if (eventName !== "rename") {
       return;
@@ -23040,14 +23290,17 @@ function ensureSidecarWatcher(ctx, rootDir) {
     }
     const baseDir = typeof details === "object" && details && "watchedPath" in details ? _nullishCoalesce(details.watchedPath, () => ( absRoot)) : absRoot;
     const resolved = _pathe2.default.isAbsolute(candidate) ? candidate : _pathe2.default.resolve(baseDir, candidate);
-    forwardChange(resolved);
+    forwardChange("create", resolved);
+  });
+  watcher.on("ready", () => {
+    isReady = true;
   });
   watcher.on("error", (error) => {
     if (!isWatchLimitError(error)) {
       return;
     }
     const relativeRoot = ctx.configService.relativeCwd(absRoot);
-    const code = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _362 => _362.code]), () => ( "UNKNOWN"));
+    const code = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _365 => _365.code]), () => ( "UNKNOWN"));
     logger_default.warn(`[watch] ${relativeRoot} \u76D1\u542C\u6570\u91CF\u8FBE\u5230\u4E0A\u9650 (${code})\uFF0C\u4FA7\u8F66\u6587\u4EF6\u76D1\u542C\u5DF2\u505C\u7528`);
   });
   sidecarWatcherMap.set(absRoot, {
@@ -23214,7 +23467,7 @@ function createCacheKey(options) {
   return `${options.removeComment ? 1 : 0}|${options.transformEvent ? 1 : 0}`;
 }
 function getCachedResult(data2, cacheKey) {
-  return _optionalChain([handleCache, 'access', _363 => _363.get, 'call', _364 => _364(data2), 'optionalAccess', _365 => _365.get, 'call', _366 => _366(cacheKey)]);
+  return _optionalChain([handleCache, 'access', _366 => _366.get, 'call', _367 => _367(data2), 'optionalAccess', _368 => _368.get, 'call', _369 => _369(cacheKey)]);
 }
 function setCachedResult(data2, cacheKey, result) {
   let cacheForToken = handleCache.get(data2);
@@ -23290,7 +23543,7 @@ function handleWxml(data2, options) {
   if (shouldTransformInlineWxs) {
     for (const { end, start, value } of inlineWxsTokens) {
       const { result } = getCachedInlineWxsTransform(value);
-      if (_optionalChain([result, 'optionalAccess', _367 => _367.code])) {
+      if (_optionalChain([result, 'optionalAccess', _370 => _370.code])) {
         ms.update(start, end, `
 ${result.code}`);
       }
@@ -23341,11 +23594,11 @@ function emitWxmlAssetsWithCache(options) {
   });
   const emittedFiles = [];
   for (const { id, fileName, token } of currentPackageWxmls) {
-    _optionalChain([runtime, 'access', _368 => _368.addWatchFile, 'optionalCall', _369 => _369(id)]);
+    _optionalChain([runtime, 'access', _371 => _371.addWatchFile, 'optionalCall', _372 => _372(id)]);
     const deps = wxmlService.depsMap.get(id);
     if (deps) {
       for (const dep of deps) {
-        _optionalChain([runtime, 'access', _370 => _370.addWatchFile, 'optionalCall', _371 => _371(dep)]);
+        _optionalChain([runtime, 'access', _373 => _373.addWatchFile, 'optionalCall', _374 => _374(dep)]);
       }
     }
     emittedFiles.push(fileName);
@@ -23427,7 +23680,7 @@ function createCoreLifecyclePlugin(state) {
       let handledByIndependentWatcher = false;
       let independentMeta;
       if (change.event === "create" || change.event === "delete") {
-        await invalidateEntryForSidecar(id);
+        await invalidateEntryForSidecar(ctx, id, change.event);
       }
       if (!subPackageMeta) {
         if (relativeSrc === "app.json" || relativeCwd === "project.config.json" || relativeCwd === "project.private.config.json") {
@@ -23441,7 +23694,7 @@ function createCoreLifecyclePlugin(state) {
           buildService.invalidateIndependentOutput(independentRoot);
           scanService.markIndependentDirty(independentRoot);
           handledByIndependentWatcher = true;
-          if (_optionalChain([independentMeta, 'optionalAccess', _372 => _372.watchSharedStyles]) !== false) {
+          if (_optionalChain([independentMeta, 'optionalAccess', _375 => _375.watchSharedStyles]) !== false) {
             invalidateSharedStyleCache();
           }
         }
@@ -23489,7 +23742,7 @@ function createCoreLifecyclePlugin(state) {
       options.input = scannedInput;
     },
     async load(id) {
-      _optionalChain([configService, 'access', _373 => _373.weappViteConfig, 'optionalAccess', _374 => _374.debug, 'optionalAccess', _375 => _375.load, 'optionalCall', _376 => _376(id, subPackageMeta)]);
+      _optionalChain([configService, 'access', _376 => _376.weappViteConfig, 'optionalAccess', _377 => _377.debug, 'optionalAccess', _378 => _378.load, 'optionalCall', _379 => _379(id, subPackageMeta)]);
       const relativeBasename = _shared.removeExtensionDeep.call(void 0, configService.relativeAbsoluteSrcRoot(id));
       if (isCSSRequest(id)) {
         const parsed = parseRequest(id);
@@ -23503,7 +23756,7 @@ function createCoreLifecyclePlugin(state) {
         }
         return null;
       }
-      if (loadedEntrySet.has(id) || _optionalChain([subPackageMeta, 'optionalAccess', _377 => _377.entries, 'access', _378 => _378.includes, 'call', _379 => _379(relativeBasename)])) {
+      if (loadedEntrySet.has(id) || _optionalChain([subPackageMeta, 'optionalAccess', _380 => _380.entries, 'access', _381 => _381.includes, 'call', _382 => _382(relativeBasename)])) {
         return await loadEntry.call(this, id, "component");
       }
       if (relativeBasename === "app") {
@@ -23534,8 +23787,8 @@ function createCoreLifecyclePlugin(state) {
           return subPackageRoots.find((root) => filePath === root || filePath.startsWith(`${root}/`));
         };
         var matchSubPackage = matchSubPackage2;
-        const sharedStrategy = _nullishCoalesce(_optionalChain([configService, 'access', _380 => _380.weappViteConfig, 'optionalAccess', _381 => _381.chunks, 'optionalAccess', _382 => _382.sharedStrategy]), () => ( DEFAULT_SHARED_CHUNK_STRATEGY));
-        const shouldLogChunks = _nullishCoalesce(_optionalChain([configService, 'access', _383 => _383.weappViteConfig, 'optionalAccess', _384 => _384.chunks, 'optionalAccess', _385 => _385.logOptimization]), () => ( true));
+        const sharedStrategy = _nullishCoalesce(_optionalChain([configService, 'access', _383 => _383.weappViteConfig, 'optionalAccess', _384 => _384.chunks, 'optionalAccess', _385 => _385.sharedStrategy]), () => ( DEFAULT_SHARED_CHUNK_STRATEGY));
+        const shouldLogChunks = _nullishCoalesce(_optionalChain([configService, 'access', _386 => _386.weappViteConfig, 'optionalAccess', _387 => _387.chunks, 'optionalAccess', _388 => _388.logOptimization]), () => ( true));
         const subPackageRoots = Array.from(scanService.subPackageMap.keys()).filter(Boolean);
         applySharedChunkStrategy.call(this, bundle, {
           strategy: sharedStrategy,
@@ -23580,10 +23833,10 @@ function createCoreLifecyclePlugin(state) {
           } : void 0
         });
       }
-      if (_optionalChain([configService, 'access', _386 => _386.weappViteConfig, 'optionalAccess', _387 => _387.debug, 'optionalAccess', _388 => _388.watchFiles])) {
+      if (_optionalChain([configService, 'access', _389 => _389.weappViteConfig, 'optionalAccess', _390 => _390.debug, 'optionalAccess', _391 => _391.watchFiles])) {
         const watcherService = ctx.watcherService;
-        const watcherRoot = _nullishCoalesce(_optionalChain([subPackageMeta, 'optionalAccess', _389 => _389.subPackage, 'access', _390 => _390.root]), () => ( "/"));
-        const watcher = _optionalChain([watcherService, 'optionalAccess', _391 => _391.getRollupWatcher, 'call', _392 => _392(watcherRoot)]);
+        const watcherRoot = _nullishCoalesce(_optionalChain([subPackageMeta, 'optionalAccess', _392 => _392.subPackage, 'access', _393 => _393.root]), () => ( "/"));
+        const watcher = _optionalChain([watcherService, 'optionalAccess', _394 => _394.getRollupWatcher, 'call', _395 => _395(watcherRoot)]);
         let watchFiles;
         if (watcher && typeof watcher.getWatchFiles === "function") {
           watchFiles = await watcher.getWatchFiles();
@@ -23597,7 +23850,7 @@ function createCoreLifecyclePlugin(state) {
       }
     },
     buildEnd() {
-      _optionalChain([debug2, 'optionalCall', _393 => _393(`${subPackageMeta ? `\u72EC\u7ACB\u5206\u5305 ${subPackageMeta.subPackage.root}` : "\u4E3B\u5305"} ${Array.from(this.getModuleIds()).length} \u4E2A\u6A21\u5757\u88AB\u7F16\u8BD1`)]);
+      _optionalChain([debug2, 'optionalCall', _396 => _396(`${subPackageMeta ? `\u72EC\u7ACB\u5206\u5305 ${subPackageMeta.subPackage.root}` : "\u4E3B\u5305"} ${Array.from(this.getModuleIds()).length} \u4E2A\u6A21\u5757\u88AB\u7F16\u8BD1`)]);
     }
   };
 }
@@ -23681,7 +23934,7 @@ async function flushIndependentBuilds(state) {
   }
   const outputs = await Promise.all(pendingIndependentBuilds);
   for (const { rollup } of outputs) {
-    const bundleOutputs = Array.isArray(_optionalChain([rollup, 'optionalAccess', _394 => _394.output])) ? rollup.output : [];
+    const bundleOutputs = Array.isArray(_optionalChain([rollup, 'optionalAccess', _397 => _397.output])) ? rollup.output : [];
     for (const output of bundleOutputs) {
       if (output.type === "chunk") {
         this.emitFile({
@@ -23718,13 +23971,13 @@ function toPosixPath(value) {
 var styleMatcherCache = /* @__PURE__ */ new WeakMap();
 function collectSharedStyleEntries(ctx, configService) {
   const map = /* @__PURE__ */ new Map();
-  const registry = _optionalChain([ctx, 'access', _395 => _395.scanService, 'optionalAccess', _396 => _396.subPackageMap]);
-  if (!_optionalChain([registry, 'optionalAccess', _397 => _397.size])) {
+  const registry = _optionalChain([ctx, 'access', _398 => _398.scanService, 'optionalAccess', _399 => _399.subPackageMap]);
+  if (!_optionalChain([registry, 'optionalAccess', _400 => _400.size])) {
     return map;
   }
   const currentRoot = configService.currentSubPackageRoot;
   for (const [root, meta] of registry.entries()) {
-    if (!_optionalChain([meta, 'access', _398 => _398.styleEntries, 'optionalAccess', _399 => _399.length])) {
+    if (!_optionalChain([meta, 'access', _401 => _401.styleEntries, 'optionalAccess', _402 => _402.length])) {
       continue;
     }
     if (currentRoot && root !== currentRoot) {
@@ -23769,12 +24022,12 @@ function getStyleMatcher(entry) {
   if (cached) {
     return cached;
   }
-  const includePatterns = _optionalChain([entry, 'access', _400 => _400.include, 'optionalAccess', _401 => _401.length]) ? entry.include : ["**/*"];
-  const excludePatterns = _optionalChain([entry, 'access', _402 => _402.exclude, 'optionalAccess', _403 => _403.length]) ? entry.exclude : void 0;
+  const includePatterns = _optionalChain([entry, 'access', _403 => _403.include, 'optionalAccess', _404 => _404.length]) ? entry.include : ["**/*"];
+  const excludePatterns = _optionalChain([entry, 'access', _405 => _405.exclude, 'optionalAccess', _406 => _406.length]) ? entry.exclude : void 0;
   const matcher = {
     include: _picomatch2.default.call(void 0, includePatterns, { dot: true })
   };
-  if (_optionalChain([excludePatterns, 'optionalAccess', _404 => _404.length])) {
+  if (_optionalChain([excludePatterns, 'optionalAccess', _407 => _407.length])) {
     matcher.exclude = _picomatch2.default.call(void 0, excludePatterns, { dot: true });
   }
   styleMatcherCache.set(entry, matcher);
@@ -23879,7 +24132,7 @@ function injectSharedStyleImports(css2, modulePath, fileName, sharedStyles, conf
   }
   const normalizedFileName = toPosixPath(fileName);
   const entries = findSharedStylesForModule(normalizedModule, normalizedFileName, sharedStyles);
-  if (!_optionalChain([entries, 'optionalAccess', _405 => _405.length])) {
+  if (!_optionalChain([entries, 'optionalAccess', _408 => _408.length])) {
     return css2;
   }
   const specifiers = resolveImportSpecifiers(fileName, entries);
@@ -24094,14 +24347,14 @@ function createPluginPruner() {
     name: "weapp-vite:preflight",
     enforce: "pre",
     configResolved(config) {
-      if (!_optionalChain([config, 'access', _406 => _406.plugins, 'optionalAccess', _407 => _407.length])) {
+      if (!_optionalChain([config, 'access', _409 => _409.plugins, 'optionalAccess', _410 => _410.length])) {
         return;
       }
       for (const removePlugin of removePlugins) {
         const idx = config.plugins.findIndex((plugin) => plugin.name === removePlugin);
         if (idx > -1) {
           const [plugin] = config.plugins.splice(idx, 1);
-          plugin && _optionalChain([debug3, 'optionalCall', _408 => _408("remove plugin", plugin.name)]);
+          plugin && _optionalChain([debug3, 'optionalCall', _411 => _411("remove plugin", plugin.name)]);
         }
       }
     }
@@ -24140,8 +24393,8 @@ function createWorkerBuildPlugin(ctx) {
     name: "weapp-vite:workers",
     enforce: "pre",
     async options(options) {
-      const workerConfig = _optionalChain([configService, 'access', _409 => _409.weappViteConfig, 'optionalAccess', _410 => _410.worker]);
-      const entries = Array.isArray(_optionalChain([workerConfig, 'optionalAccess', _411 => _411.entry])) ? workerConfig.entry : [_optionalChain([workerConfig, 'optionalAccess', _412 => _412.entry])];
+      const workerConfig = _optionalChain([configService, 'access', _412 => _412.weappViteConfig, 'optionalAccess', _413 => _413.worker]);
+      const entries = Array.isArray(_optionalChain([workerConfig, 'optionalAccess', _414 => _414.entry])) ? workerConfig.entry : [_optionalChain([workerConfig, 'optionalAccess', _415 => _415.entry])];
       const normalized = (await Promise.all(entries.filter(Boolean).map((entry) => resolveWorkerEntry(ctx, entry)))).filter((result) => Boolean(result.value)).reduce((acc, cur) => {
         acc[cur.key] = cur.value;
         return acc;
@@ -24258,7 +24511,7 @@ async function transformWxsFile(state, wxsPath) {
     const { result, importees } = transformWxsCode(rawCode, {
       filename: wxsPath
     });
-    if (typeof _optionalChain([result, 'optionalAccess', _413 => _413.code]) === "string") {
+    if (typeof _optionalChain([result, 'optionalAccess', _416 => _416.code]) === "string") {
       code = result.code;
     }
     const dirname5 = _pathe2.default.dirname(wxsPath);
@@ -24291,13 +24544,13 @@ async function transformWxsFile(state, wxsPath) {
 var RUNTIME_PLUGINS_SYMBOL = Symbol.for("weapp-runtime:plugins");
 function attachRuntimePlugins(ctx, plugins) {
   const runtimePlugins = ctx[RUNTIME_PLUGINS_SYMBOL];
-  if (!_optionalChain([runtimePlugins, 'optionalAccess', _414 => _414.length])) {
+  if (!_optionalChain([runtimePlugins, 'optionalAccess', _417 => _417.length])) {
     return plugins;
   }
   return [...runtimePlugins, ...plugins];
 }
 function applyInspect(ctx, plugins) {
-  const inspectOptions = _optionalChain([ctx, 'access', _415 => _415.configService, 'access', _416 => _416.weappViteConfig, 'optionalAccess', _417 => _417.debug, 'optionalAccess', _418 => _418.inspect]);
+  const inspectOptions = _optionalChain([ctx, 'access', _418 => _418.configService, 'access', _419 => _419.weappViteConfig, 'optionalAccess', _420 => _420.debug, 'optionalAccess', _421 => _421.inspect]);
   if (!inspectOptions) {
     return plugins;
   }
@@ -24388,7 +24641,7 @@ function createMergeFactories(options) {
     const currentOptions = getOptions2();
     applyRuntimePlatform("miniprogram");
     const external = [];
-    if (_optionalChain([currentOptions, 'access', _419 => _419.packageJson, 'optionalAccess', _420 => _420.dependencies])) {
+    if (_optionalChain([currentOptions, 'access', _422 => _422.packageJson, 'optionalAccess', _423 => _423.dependencies])) {
       external.push(
         ...Object.keys(currentOptions.packageJson.dependencies).map((pkg) => {
           return new RegExp(`^${pkg.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&")}(\\/|$)`);
@@ -24403,7 +24656,7 @@ function createMergeFactories(options) {
       const watchInclude = [
         _pathe2.default.join(currentOptions.cwd, currentOptions.srcRoot, "**")
       ];
-      const pluginRootConfig = _optionalChain([currentOptions, 'access', _421 => _421.config, 'access', _422 => _422.weapp, 'optionalAccess', _423 => _423.pluginRoot]);
+      const pluginRootConfig = _optionalChain([currentOptions, 'access', _424 => _424.config, 'access', _425 => _425.weapp, 'optionalAccess', _426 => _426.pluginRoot]);
       if (pluginRootConfig) {
         const absolutePluginRoot = _pathe2.default.resolve(currentOptions.cwd, pluginRootConfig);
         const relativeToSrc = _pathe2.default.relative(
@@ -24463,7 +24716,7 @@ function createMergeFactories(options) {
     );
     inlineConfig.logLevel = "info";
     injectBuiltinAliases(inlineConfig);
-    const currentRoot = _optionalChain([subPackageMeta, 'optionalAccess', _424 => _424.subPackage, 'access', _425 => _425.root]);
+    const currentRoot = _optionalChain([subPackageMeta, 'optionalAccess', _427 => _427.subPackage, 'access', _428 => _428.root]);
     setOptions({
       ...currentOptions,
       currentSubPackageRoot: currentRoot
@@ -24474,7 +24727,7 @@ function createMergeFactories(options) {
     ensureConfigService();
     const currentOptions = getOptions2();
     const web = currentOptions.weappWeb;
-    if (!_optionalChain([web, 'optionalAccess', _426 => _426.enabled])) {
+    if (!_optionalChain([web, 'optionalAccess', _429 => _429.enabled])) {
       return void 0;
     }
     applyRuntimePlatform("web");
@@ -24565,7 +24818,7 @@ function createConfigService(ctx) {
     defineEnv[key] = value;
   }
   function getDefineImportMetaEnv() {
-    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _427 => _427.platform]), () => ( DEFAULT_MP_PLATFORM));
+    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _430 => _430.platform]), () => ( DEFAULT_MP_PLATFORM));
     const resolvedPlatform = _nullishCoalesce(defineEnv.PLATFORM, () => ( mpPlatform));
     const env = {
       PLATFORM: resolvedPlatform,
@@ -24581,7 +24834,7 @@ function createConfigService(ctx) {
   }
   function applyRuntimePlatform(runtime) {
     const isWeb = runtime === "web";
-    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _428 => _428.platform]), () => ( DEFAULT_MP_PLATFORM));
+    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _431 => _431.platform]), () => ( DEFAULT_MP_PLATFORM));
     const resolvedPlatform = isWeb ? "web" : mpPlatform;
     setDefineEnv("PLATFORM", resolvedPlatform);
     setDefineEnv("IS_WEB", isWeb);
@@ -24692,10 +24945,10 @@ function createConfigService(ctx) {
       return options.srcRoot;
     },
     get pluginRoot() {
-      return _optionalChain([options, 'access', _429 => _429.config, 'access', _430 => _430.weapp, 'optionalAccess', _431 => _431.pluginRoot]);
+      return _optionalChain([options, 'access', _432 => _432.config, 'access', _433 => _433.weapp, 'optionalAccess', _434 => _434.pluginRoot]);
     },
     get absolutePluginRoot() {
-      if (_optionalChain([options, 'access', _432 => _432.config, 'access', _433 => _433.weapp, 'optionalAccess', _434 => _434.pluginRoot])) {
+      if (_optionalChain([options, 'access', _435 => _435.config, 'access', _436 => _436.weapp, 'optionalAccess', _437 => _437.pluginRoot])) {
         return _pathe2.default.resolve(options.cwd, options.config.weapp.pluginRoot);
       }
     },
@@ -24725,7 +24978,7 @@ function createConfigService(ctx) {
     },
     relativeAbsoluteSrcRoot(p) {
       const absoluteSrcRoot = _pathe2.default.resolve(options.cwd, options.srcRoot);
-      const pluginRootConfig = _optionalChain([options, 'access', _435 => _435.config, 'access', _436 => _436.weapp, 'optionalAccess', _437 => _437.pluginRoot]);
+      const pluginRootConfig = _optionalChain([options, 'access', _438 => _438.config, 'access', _439 => _439.weapp, 'optionalAccess', _440 => _440.pluginRoot]);
       if (pluginRootConfig) {
         const absolutePluginRoot = _pathe2.default.resolve(options.cwd, pluginRootConfig);
         const relativeToPlugin = _pathe2.default.relative(absolutePluginRoot, p);
@@ -24777,10 +25030,10 @@ function createJsonService(ctx) {
       }
       let resultJson;
       if (/app\.json(?:\.[jt]s)?$/.test(filepath)) {
-        await _optionalChain([ctx, 'access', _438 => _438.autoRoutesService, 'optionalAccess', _439 => _439.ensureFresh, 'call', _440 => _440()]);
+        await _optionalChain([ctx, 'access', _441 => _441.autoRoutesService, 'optionalAccess', _442 => _442.ensureFresh, 'call', _443 => _443()]);
       }
       if (/\.json\.[jt]s$/.test(filepath)) {
-        const routesReference = _optionalChain([ctx, 'access', _441 => _441.autoRoutesService, 'optionalAccess', _442 => _442.getReference, 'call', _443 => _443()]);
+        const routesReference = _optionalChain([ctx, 'access', _444 => _444.autoRoutesService, 'optionalAccess', _445 => _445.getReference, 'call', _446 => _446()]);
         const fallbackRoutes = _nullishCoalesce(routesReference, () => ( { pages: [], entries: [], subPackages: [] }));
         const routesModule = {
           routes: fallbackRoutes,
@@ -24829,7 +25082,7 @@ function createJsonService(ctx) {
       return resultJson;
     } catch (error) {
       logger_default.error(`\u6B8B\u7834\u7684JSON\u6587\u4EF6: ${filepath}`);
-      _optionalChain([debug, 'optionalCall', _444 => _444(error)]);
+      _optionalChain([debug, 'optionalCall', _447 => _447(error)]);
     }
   }
   function resolve8(entry) {
@@ -24884,7 +25137,7 @@ function createNpmService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before writing npm cache");
     }
-    if (_optionalChain([ctx, 'access', _445 => _445.configService, 'access', _446 => _446.weappViteConfig, 'optionalAccess', _447 => _447.npm, 'optionalAccess', _448 => _448.cache])) {
+    if (_optionalChain([ctx, 'access', _448 => _448.configService, 'access', _449 => _449.weappViteConfig, 'optionalAccess', _450 => _450.npm, 'optionalAccess', _451 => _451.cache])) {
       await _fsextra2.default.outputJSON(getDependenciesCacheFilePath(root), {
         hash: dependenciesCacheHash()
       });
@@ -24897,7 +25150,7 @@ function createNpmService(ctx) {
     }
   }
   async function checkDependenciesCacheOutdate(root) {
-    if (_optionalChain([ctx, 'access', _449 => _449.configService, 'optionalAccess', _450 => _450.weappViteConfig, 'optionalAccess', _451 => _451.npm, 'optionalAccess', _452 => _452.cache])) {
+    if (_optionalChain([ctx, 'access', _452 => _452.configService, 'optionalAccess', _453 => _453.weappViteConfig, 'optionalAccess', _454 => _454.npm, 'optionalAccess', _455 => _455.cache])) {
       const json = await readDependenciesCache(root);
       if (_shared.isObject.call(void 0, json)) {
         return dependenciesCacheHash() !== json.hash;
@@ -24930,7 +25183,7 @@ function createNpmService(ctx) {
       target: "es6",
       external: []
     });
-    const resolvedOptions = _optionalChain([ctx, 'access', _453 => _453.configService, 'optionalAccess', _454 => _454.weappViteConfig, 'optionalAccess', _455 => _455.npm, 'optionalAccess', _456 => _456.buildOptions, 'optionalCall', _457 => _457(
+    const resolvedOptions = _optionalChain([ctx, 'access', _456 => _456.configService, 'optionalAccess', _457 => _457.weappViteConfig, 'optionalAccess', _458 => _458.npm, 'optionalAccess', _459 => _459.buildOptions, 'optionalCall', _460 => _460(
       mergedOptions,
       { name, entry }
     )]);
@@ -25030,7 +25283,7 @@ function createNpmService(ctx) {
       throw new Error("configService must be initialized before resolving npm relation list");
     }
     let packNpmRelationList = [];
-    if (_optionalChain([ctx, 'access', _458 => _458.configService, 'access', _459 => _459.projectConfig, 'access', _460 => _460.setting, 'optionalAccess', _461 => _461.packNpmManually]) && Array.isArray(ctx.configService.projectConfig.setting.packNpmRelationList)) {
+    if (_optionalChain([ctx, 'access', _461 => _461.configService, 'access', _462 => _462.projectConfig, 'access', _463 => _463.setting, 'optionalAccess', _464 => _464.packNpmManually]) && Array.isArray(ctx.configService.projectConfig.setting.packNpmRelationList)) {
       packNpmRelationList = ctx.configService.projectConfig.setting.packNpmRelationList;
     } else {
       packNpmRelationList = [
@@ -25043,10 +25296,10 @@ function createNpmService(ctx) {
     return packNpmRelationList;
   }
   async function build3(options) {
-    if (!_optionalChain([ctx, 'access', _462 => _462.configService, 'optionalAccess', _463 => _463.weappViteConfig, 'optionalAccess', _464 => _464.npm, 'optionalAccess', _465 => _465.enable])) {
+    if (!_optionalChain([ctx, 'access', _465 => _465.configService, 'optionalAccess', _466 => _466.weappViteConfig, 'optionalAccess', _467 => _467.npm, 'optionalAccess', _468 => _468.enable])) {
       return;
     }
-    _optionalChain([debug, 'optionalCall', _466 => _466("buildNpm start")]);
+    _optionalChain([debug, 'optionalCall', _469 => _469("buildNpm start")]);
     const packNpmRelationList = getPackNpmRelationList();
     const [mainRelation, ...subRelations] = packNpmRelationList;
     const packageJsonPath = _pathe2.default.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
@@ -25121,7 +25374,7 @@ function createNpmService(ctx) {
         }
       }
     }
-    _optionalChain([debug, 'optionalCall', _467 => _467("buildNpm end")]);
+    _optionalChain([debug, 'optionalCall', _470 => _470("buildNpm end")]);
   }
   return {
     getDependenciesCacheFilePath,
@@ -25165,7 +25418,7 @@ var TimeoutError = (_class16 = class _TimeoutError extends Error {
   __init36() {this.name = "TimeoutError"}
   constructor(message, options) {
     super(message, options);_class16.prototype.__init36.call(this);;
-    _optionalChain([Error, 'access', _468 => _468.captureStackTrace, 'optionalCall', _469 => _469(this, _TimeoutError)]);
+    _optionalChain([Error, 'access', _471 => _471.captureStackTrace, 'optionalCall', _472 => _472(this, _TimeoutError)]);
   }
 }, _class16);
 var getAbortedReason = (signal) => _nullishCoalesce(signal.reason, () => ( new DOMException("This operation was aborted.", "AbortError")));
@@ -25183,7 +25436,7 @@ function pTimeout(promise, options) {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
-    if (_optionalChain([signal, 'optionalAccess', _470 => _470.aborted])) {
+    if (_optionalChain([signal, 'optionalAccess', _473 => _473.aborted])) {
       reject(getAbortedReason(signal));
       return;
     }
@@ -25281,7 +25534,7 @@ var PriorityQueue = class {
   }
   dequeue() {
     const item = this.#queue.shift();
-    return _optionalChain([item, 'optionalAccess', _471 => _471.run]);
+    return _optionalChain([item, 'optionalAccess', _474 => _474.run]);
   }
   filter(options) {
     return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
@@ -25342,10 +25595,10 @@ var PQueue = class extends import_index2.default {
       ...options
     };
     if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
-      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${_nullishCoalesce(_optionalChain([options, 'access', _472 => _472.intervalCap, 'optionalAccess', _473 => _473.toString, 'call', _474 => _474()]), () => ( ""))}\` (${typeof options.intervalCap})`);
+      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${_nullishCoalesce(_optionalChain([options, 'access', _475 => _475.intervalCap, 'optionalAccess', _476 => _476.toString, 'call', _477 => _477()]), () => ( ""))}\` (${typeof options.intervalCap})`);
     }
     if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) {
-      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${_nullishCoalesce(_optionalChain([options, 'access', _475 => _475.interval, 'optionalAccess', _476 => _476.toString, 'call', _477 => _477()]), () => ( ""))}\` (${typeof options.interval})`);
+      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${_nullishCoalesce(_optionalChain([options, 'access', _478 => _478.interval, 'optionalAccess', _479 => _479.toString, 'call', _480 => _480()]), () => ( ""))}\` (${typeof options.interval})`);
     }
     this.#carryoverIntervalCount = _nullishCoalesce(_nullishCoalesce(options.carryoverIntervalCount, () => ( options.carryoverConcurrencyCount)), () => ( false));
     this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
@@ -25552,7 +25805,7 @@ var PQueue = class extends import_index2.default {
         });
         try {
           try {
-            _optionalChain([options, 'access', _478 => _478.signal, 'optionalAccess', _479 => _479.throwIfAborted, 'call', _480 => _480()]);
+            _optionalChain([options, 'access', _481 => _481.signal, 'optionalAccess', _482 => _482.throwIfAborted, 'call', _483 => _483()]);
           } catch (error) {
             if (!this.#isIntervalIgnored) {
               this.#intervalCount--;
@@ -25925,7 +26178,7 @@ var FileCache = class {
       return true;
     }
     const cachedMtime = this.mtimeMap.get(id);
-    const nextSignature = _optionalChain([options, 'optionalAccess', _481 => _481.content]) !== void 0 ? createSignature(options.content) : void 0;
+    const nextSignature = _optionalChain([options, 'optionalAccess', _484 => _484.content]) !== void 0 ? createSignature(options.content) : void 0;
     const updateSignature = () => {
       if (nextSignature !== void 0) {
         this.signatureMap.set(id, nextSignature);
@@ -26038,6 +26291,10 @@ function createRuntimeState() {
     json: {
       cache: new FileCache()
     },
+    css: {
+      importerToDependencies: /* @__PURE__ */ new Map(),
+      dependencyToImporters: /* @__PURE__ */ new Map()
+    },
     watcher: {
       rollupWatcherMap: /* @__PURE__ */ new Map(),
       sidecarWatcherMap: /* @__PURE__ */ new Map()
@@ -26156,7 +26413,7 @@ function coerceStyleConfig(entry) {
   if (!entry || typeof entry !== "object") {
     return void 0;
   }
-  const source = _optionalChain([entry, 'access', _482 => _482.source, 'optionalAccess', _483 => _483.toString, 'call', _484 => _484(), 'access', _485 => _485.trim, 'call', _486 => _486()]);
+  const source = _optionalChain([entry, 'access', _485 => _485.source, 'optionalAccess', _486 => _486.toString, 'call', _487 => _487(), 'access', _488 => _488.trim, 'call', _489 => _489()]);
   if (!source) {
     return void 0;
   }
@@ -26332,7 +26589,7 @@ function normalizeSubPackageStyleEntries(styles, subPackage, configService) {
   if (!service) {
     return void 0;
   }
-  const root = _optionalChain([subPackage, 'access', _487 => _487.root, 'optionalAccess', _488 => _488.trim, 'call', _489 => _489()]);
+  const root = _optionalChain([subPackage, 'access', _490 => _490.root, 'optionalAccess', _491 => _491.trim, 'call', _492 => _492()]);
   if (!root) {
     return void 0;
   }
@@ -26440,7 +26697,7 @@ function createScanService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before scanning subpackages");
     }
-    const json = _optionalChain([scanState, 'access', _490 => _490.appEntry, 'optionalAccess', _491 => _491.json]);
+    const json = _optionalChain([scanState, 'access', _493 => _493.appEntry, 'optionalAccess', _494 => _494.json]);
     if (scanState.isDirty || subPackageMap.size === 0) {
       subPackageMap.clear();
       independentSubPackageMap.clear();
@@ -26458,15 +26715,15 @@ function createScanService(ctx) {
             subPackage,
             entries: resolveSubPackageEntries(subPackage)
           };
-          const subPackageConfig = _optionalChain([ctx, 'access', _492 => _492.configService, 'access', _493 => _493.weappViteConfig, 'optionalAccess', _494 => _494.subPackages, 'optionalAccess', _495 => _495[subPackage.root]]);
-          meta.subPackage.dependencies = _optionalChain([subPackageConfig, 'optionalAccess', _496 => _496.dependencies]);
-          meta.subPackage.inlineConfig = _optionalChain([subPackageConfig, 'optionalAccess', _497 => _497.inlineConfig]);
+          const subPackageConfig = _optionalChain([ctx, 'access', _495 => _495.configService, 'access', _496 => _496.weappViteConfig, 'optionalAccess', _497 => _497.subPackages, 'optionalAccess', _498 => _498[subPackage.root]]);
+          meta.subPackage.dependencies = _optionalChain([subPackageConfig, 'optionalAccess', _499 => _499.dependencies]);
+          meta.subPackage.inlineConfig = _optionalChain([subPackageConfig, 'optionalAccess', _500 => _500.inlineConfig]);
           meta.styleEntries = normalizeSubPackageStyleEntries(
-            _optionalChain([subPackageConfig, 'optionalAccess', _498 => _498.styles]),
+            _optionalChain([subPackageConfig, 'optionalAccess', _501 => _501.styles]),
             subPackage,
             ctx.configService
           );
-          meta.watchSharedStyles = _nullishCoalesce(_optionalChain([subPackageConfig, 'optionalAccess', _499 => _499.watchSharedStyles]), () => ( true));
+          meta.watchSharedStyles = _nullishCoalesce(_optionalChain([subPackageConfig, 'optionalAccess', _502 => _502.watchSharedStyles]), () => ( true));
           metas.push(meta);
           if (subPackage.root) {
             subPackageMap.set(subPackage.root, meta);
@@ -26522,11 +26779,11 @@ function createScanService(ctx) {
     loadSubPackages,
     isMainPackageFileName,
     get workersOptions() {
-      return _optionalChain([scanState, 'access', _500 => _500.appEntry, 'optionalAccess', _501 => _501.json, 'optionalAccess', _502 => _502.workers]);
+      return _optionalChain([scanState, 'access', _503 => _503.appEntry, 'optionalAccess', _504 => _504.json, 'optionalAccess', _505 => _505.workers]);
     },
     get workersDir() {
-      const workersOptions = _optionalChain([scanState, 'access', _503 => _503.appEntry, 'optionalAccess', _504 => _504.json, 'optionalAccess', _505 => _505.workers]);
-      return typeof workersOptions === "object" ? _optionalChain([workersOptions, 'optionalAccess', _506 => _506.path]) : workersOptions;
+      const workersOptions = _optionalChain([scanState, 'access', _506 => _506.appEntry, 'optionalAccess', _507 => _507.json, 'optionalAccess', _508 => _508.workers]);
+      return typeof workersOptions === "object" ? _optionalChain([workersOptions, 'optionalAccess', _509 => _509.path]) : workersOptions;
     },
     markDirty() {
       scanState.isDirty = true;
@@ -26573,7 +26830,7 @@ function createWatcherService(ctx) {
     },
     setRollupWatcher(watcher, root = "/") {
       const oldWatcher = rollupWatcherMap.get(root);
-      _optionalChain([oldWatcher, 'optionalAccess', _507 => _507.close, 'call', _508 => _508()]);
+      _optionalChain([oldWatcher, 'optionalAccess', _510 => _510.close, 'call', _511 => _511()]);
       rollupWatcherMap.set(root, watcher);
     },
     closeAll() {
@@ -26586,7 +26843,7 @@ function createWatcherService(ctx) {
         });
       });
       sidecarWatcherMap.clear();
-      void _optionalChain([ctx, 'access', _509 => _509.webService, 'optionalAccess', _510 => _510.close, 'call', _511 => _511(), 'access', _512 => _512.catch, 'call', _513 => _513(() => {
+      void _optionalChain([ctx, 'access', _512 => _512.webService, 'optionalAccess', _513 => _513.close, 'call', _514 => _514(), 'access', _515 => _515.catch, 'call', _516 => _516(() => {
       })]);
     },
     close(root = "/") {
@@ -26602,7 +26859,7 @@ function createWatcherService(ctx) {
         sidecarWatcherMap.delete(root);
       }
       if (rollupWatcherMap.size === 0 && sidecarWatcherMap.size === 0) {
-        void _optionalChain([ctx, 'access', _514 => _514.webService, 'optionalAccess', _515 => _515.close, 'call', _516 => _516(), 'access', _517 => _517.catch, 'call', _518 => _518(() => {
+        void _optionalChain([ctx, 'access', _517 => _517.webService, 'optionalAccess', _518 => _518.close, 'call', _519 => _519(), 'access', _520 => _520.catch, 'call', _521 => _521(() => {
         })]);
       }
     }
@@ -26615,7 +26872,7 @@ function createWatcherServicePlugin(ctx) {
     name: "weapp-runtime:watcher-service",
     closeBundle() {
       const configService = ctx.configService;
-      const isWatchMode = _optionalChain([configService, 'optionalAccess', _519 => _519.isDev]) || Boolean(_optionalChain([configService, 'optionalAccess', _520 => _520.inlineConfig, 'optionalAccess', _521 => _521.build, 'optionalAccess', _522 => _522.watch]));
+      const isWatchMode = _optionalChain([configService, 'optionalAccess', _522 => _522.isDev]) || Boolean(_optionalChain([configService, 'optionalAccess', _523 => _523.inlineConfig, 'optionalAccess', _524 => _524.build, 'optionalAccess', _525 => _525.watch]));
       if (!isWatchMode) {
         service.closeAll();
       }
@@ -26632,10 +26889,10 @@ function createWebService(ctx) {
   }
   let devServer;
   function isEnabled() {
-    return Boolean(_optionalChain([ctx, 'access', _523 => _523.configService, 'optionalAccess', _524 => _524.weappWebConfig, 'optionalAccess', _525 => _525.enabled]));
+    return Boolean(_optionalChain([ctx, 'access', _526 => _526.configService, 'optionalAccess', _527 => _527.weappWebConfig, 'optionalAccess', _528 => _528.enabled]));
   }
   async function startDevServer() {
-    if (!_optionalChain([ctx, 'access', _526 => _526.configService, 'optionalAccess', _527 => _527.isDev])) {
+    if (!_optionalChain([ctx, 'access', _529 => _529.configService, 'optionalAccess', _530 => _530.isDev])) {
       return void 0;
     }
     if (!isEnabled()) {
@@ -26644,7 +26901,7 @@ function createWebService(ctx) {
     if (devServer) {
       return devServer;
     }
-    const inlineConfig = _optionalChain([ctx, 'access', _528 => _528.configService, 'optionalAccess', _529 => _529.mergeWeb, 'call', _530 => _530()]);
+    const inlineConfig = _optionalChain([ctx, 'access', _531 => _531.configService, 'optionalAccess', _532 => _532.mergeWeb, 'call', _533 => _533()]);
     if (!inlineConfig) {
       return void 0;
     }
@@ -26657,7 +26914,7 @@ function createWebService(ctx) {
     if (!isEnabled()) {
       return void 0;
     }
-    const inlineConfig = _optionalChain([ctx, 'access', _531 => _531.configService, 'optionalAccess', _532 => _532.mergeWeb, 'call', _533 => _533()]);
+    const inlineConfig = _optionalChain([ctx, 'access', _534 => _534.configService, 'optionalAccess', _535 => _535.mergeWeb, 'call', _536 => _536()]);
     if (!inlineConfig) {
       return void 0;
     }
@@ -26687,7 +26944,7 @@ function createWebServicePlugin(ctx) {
   return {
     name: "weapp-runtime:web-service",
     async closeBundle() {
-      if (!_optionalChain([ctx, 'access', _534 => _534.configService, 'optionalAccess', _535 => _535.isDev])) {
+      if (!_optionalChain([ctx, 'access', _537 => _537.configService, 'optionalAccess', _538 => _538.isDev])) {
         await service.close();
       }
     }
@@ -29336,7 +29593,7 @@ function createWxmlService(ctx) {
     return set3;
   }
   function clearAll() {
-    const currentRoot = _optionalChain([ctx, 'access', _536 => _536.configService, 'optionalAccess', _537 => _537.currentSubPackageRoot]);
+    const currentRoot = _optionalChain([ctx, 'access', _539 => _539.configService, 'optionalAccess', _540 => _540.currentSubPackageRoot]);
     if (!currentRoot) {
       depsMap.clear();
       tokenMap.clear();
@@ -29395,7 +29652,7 @@ function createWxmlService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before scanning wxml");
     }
-    const wxmlConfig = _nullishCoalesce(_optionalChain([ctx, 'access', _538 => _538.configService, 'access', _539 => _539.weappViteConfig, 'optionalAccess', _540 => _540.wxml]), () => ( _optionalChain([ctx, 'access', _541 => _541.configService, 'access', _542 => _542.weappViteConfig, 'optionalAccess', _543 => _543.enhance, 'optionalAccess', _544 => _544.wxml])));
+    const wxmlConfig = _nullishCoalesce(_optionalChain([ctx, 'access', _541 => _541.configService, 'access', _542 => _542.weappViteConfig, 'optionalAccess', _543 => _543.wxml]), () => ( _optionalChain([ctx, 'access', _544 => _544.configService, 'access', _545 => _545.weappViteConfig, 'optionalAccess', _546 => _546.enhance, 'optionalAccess', _547 => _547.wxml])));
     return scanWxml(wxml, {
       platform: ctx.configService.platform,
       ...wxmlConfig === true ? {} : wxmlConfig