weapp-vite 5.7.0 → 5.7.2

package/dist/{chunk-AKJEW44F.mjs → chunk-FSDX3XLK.mjs}

@@ -3,7 +3,7 @@ import {
   __require,
   __toESM,
   init_esm_shims
-} from "./chunk-SSQGJIB5.mjs";
+} from "./chunk-TZWATIK3.mjs";
 
 // ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/debug.js
 var require_debug = __commonJS({
@@ -11922,8 +11922,39 @@ import { Buffer as Buffer2 } from "buffer";
 import { posix as path10 } from "pathe";
 var SHARED_CHUNK_VIRTUAL_PREFIX = "weapp_shared_virtual";
 var SUB_PACKAGE_SHARED_DIR = "weapp-shared";
-var DEFAULT_SHARED_CHUNK_STRATEGY = "duplicate";
+var DEFAULT_SHARED_CHUNK_STRATEGY = "hoist";
+function markTakeModuleImporter(moduleId, importerId) {
+  if (!moduleId || !importerId) {
+    return;
+  }
+  const importers = takeImportersMap.get(moduleId);
+  if (importers) {
+    importers.add(importerId);
+  } else {
+    takeImportersMap.set(moduleId, /* @__PURE__ */ new Set([importerId]));
+  }
+}
+function resetTakeImportRegistry() {
+  takeImportersMap.clear();
+  forceDuplicateSharedChunks.clear();
+  sharedChunkDiagnostics.clear();
+}
+function getTakeImporters(moduleId) {
+  return takeImportersMap.get(moduleId);
+}
+function markForceDuplicateSharedChunk(sharedName) {
+  if (!sharedName) {
+    return;
+  }
+  forceDuplicateSharedChunks.add(sharedName);
+  forceDuplicateSharedChunks.add(`${sharedName}.js`);
+}
+function isForceDuplicateSharedChunk(fileName) {
+  return forceDuplicateSharedChunks.has(fileName);
+}
 var sharedChunkDiagnostics = /* @__PURE__ */ new Map();
+var takeImportersMap = /* @__PURE__ */ new Map();
+var forceDuplicateSharedChunks = /* @__PURE__ */ new Set();
 function resolveSharedChunkName(options) {
   const {
     id,
@@ -11933,7 +11964,42 @@ function resolveSharedChunkName(options) {
     strategy,
     forceDuplicateTester
   } = options;
+  const subPackageRootList = Array.from(subPackageRoots);
   const moduleInfo = ctx.getModuleInfo(id);
+  const takeImporters = getTakeImporters(id);
+  if (takeImporters?.size) {
+    const takeSharedName = resolveTakeSharedChunkName({
+      id,
+      ctx,
+      relativeAbsoluteSrcRoot,
+      subPackageRoots: subPackageRootList,
+      importers: Array.from(takeImporters)
+    });
+    if (takeSharedName) {
+      return takeSharedName;
+    }
+  }
+  if (strategy === "hoist") {
+    const relativeId = relativeAbsoluteSrcRoot(id);
+    const moduleRoot = resolveSubPackagePrefix(relativeId, subPackageRootList);
+    if (moduleRoot) {
+      assertModuleScopedToRoot({
+        moduleInfo,
+        moduleRoot,
+        relativeAbsoluteSrcRoot,
+        subPackageRoots: subPackageRootList,
+        moduleId: id
+      });
+      if (!moduleInfo?.importers || moduleInfo.importers.length <= 1) {
+        return void 0;
+      }
+      return path10.join(moduleRoot, "common");
+    }
+    if (!moduleInfo?.importers || moduleInfo.importers.length <= 1) {
+      return void 0;
+    }
+    return "common";
+  }
   if (!moduleInfo?.importers || moduleInfo.importers.length <= 1) {
     return void 0;
   }
@@ -11941,7 +12007,7 @@ function resolveSharedChunkName(options) {
     ctx,
     importers: moduleInfo.importers,
     relativeAbsoluteSrcRoot,
-    subPackageRoots: Array.from(subPackageRoots),
+    subPackageRoots: subPackageRootList,
     forceDuplicateTester
   });
   const keys = Object.keys(summary);
@@ -11954,9 +12020,7 @@ function resolveSharedChunkName(options) {
   }
   const hasMainImporter = keys.includes("");
   if (strategy === "duplicate" && !hasMainImporter) {
-    const combination = keys.filter(Boolean).sort().join("+");
-    const combinationSegment = combination ? `${combination}/` : "";
-    const sharedName = `${SHARED_CHUNK_VIRTUAL_PREFIX}/${combinationSegment}common`;
+    const sharedName = createSharedChunkNameFromKeys(keys);
     if (ignoredMainImporters.length) {
       sharedChunkDiagnostics.set(sharedName, {
         ignoredMainImporters: Array.from(new Set(ignoredMainImporters))
@@ -12107,8 +12171,60 @@ function resolveSubPackagePrefix(fileName, subPackageRoots) {
   }
   return "";
 }
+function resolveTakeSharedChunkName(options) {
+  const {
+    ctx,
+    relativeAbsoluteSrcRoot,
+    subPackageRoots,
+    importers
+  } = options;
+  if (!importers.length) {
+    return void 0;
+  }
+  const { summary } = summarizeImportPrefixes({
+    ctx,
+    importers,
+    relativeAbsoluteSrcRoot,
+    subPackageRoots
+  });
+  const keys = Object.keys(summary).filter(Boolean);
+  if (!keys.length) {
+    return void 0;
+  }
+  const sharedName = createSharedChunkNameFromKeys(keys);
+  markForceDuplicateSharedChunk(sharedName);
+  return sharedName;
+}
+function createSharedChunkNameFromKeys(keys) {
+  const sanitize = (value) => value.replace(/[\\/]+/g, "_");
+  const combination = keys.filter(Boolean).map(sanitize).sort().join("+");
+  const combinationSegment = combination ? `${combination}/` : "";
+  return `${SHARED_CHUNK_VIRTUAL_PREFIX}/${combinationSegment}common`;
+}
+function assertModuleScopedToRoot(options) {
+  const {
+    moduleInfo,
+    moduleRoot,
+    relativeAbsoluteSrcRoot,
+    subPackageRoots,
+    moduleId
+  } = options;
+  if (!moduleRoot || !moduleInfo?.importers?.length) {
+    return;
+  }
+  for (const importer of moduleInfo.importers) {
+    const importerRoot = resolveSubPackagePrefix(relativeAbsoluteSrcRoot(importer), subPackageRoots);
+    if (importerRoot !== moduleRoot) {
+      const moduleLabel = relativeAbsoluteSrcRoot(moduleId);
+      const importerLabel = relativeAbsoluteSrcRoot(importer);
+      throw new Error(
+        `[subpackages] \u6A21\u5757 "${moduleLabel}" \u4F4D\u4E8E\u5206\u5305 "${moduleRoot}"\uFF0C\u4F46\u88AB "${importerLabel}" \u5F15\u7528\uFF0C\u8BF7\u5C06\u8BE5\u6A21\u5757\u79FB\u52A8\u5230\u4E3B\u5305\u6216\u516C\u5171\u76EE\u5F55\u4EE5\u8FDB\u884C\u8DE8\u5206\u5305\u5171\u4EAB\u3002`
+      );
+    }
+  }
+}
 function applySharedChunkStrategy(bundle, options) {
-  if (options.strategy !== "duplicate") {
+  if (options.strategy !== "duplicate" && forceDuplicateSharedChunks.size === 0) {
     return;
   }
   if (!this) {
@@ -12128,13 +12244,17 @@ function applySharedChunkStrategy(bundle, options) {
     if (importers.length === 0) {
       continue;
     }
+    const sourceMapKeys = collectSourceMapKeys(fileName, chunk);
+    const sourceMapAssetInfo = findSourceMapAsset(bundle, sourceMapKeys);
+    const resolvedSourceMap = resolveSourceMapSource(originalMap, sourceMapAssetInfo?.asset.source);
     const importerMap = /* @__PURE__ */ new Map();
     let hasMainImporter = false;
+    const shouldForceDuplicate = isForceDuplicateSharedChunk(originalSharedFileName);
     for (const importerFile of importers) {
       const root = resolveSubPackagePrefix(importerFile, subPackageRoots);
       if (!root) {
         hasMainImporter = true;
-        break;
+        continue;
       }
       const duplicateBaseName = path10.basename(fileName);
       const intendedFileName = path10.join(root, SUB_PACKAGE_SHARED_DIR, duplicateBaseName);
@@ -12149,12 +12269,28 @@ function applySharedChunkStrategy(bundle, options) {
         });
       }
     }
-    if (hasMainImporter || importerMap.size === 0) {
-      consumeSharedChunkDiagnostics(originalSharedFileName);
+    const importerToChunk = /* @__PURE__ */ new Map();
+    const duplicates = [];
+    const diagnostics = consumeSharedChunkDiagnostics(originalSharedFileName);
+    const shouldRetainOriginalChunk = shouldForceDuplicate && hasMainImporter;
+    if ((hasMainImporter || importerMap.size === 0) && (!shouldForceDuplicate || importerMap.size === 0)) {
       let finalFileName = chunk.fileName;
       if (fileName.startsWith(`${SHARED_CHUNK_VIRTUAL_PREFIX}/`)) {
         const newFileName = fileName.slice(SHARED_CHUNK_VIRTUAL_PREFIX.length + 1);
         chunk.fileName = newFileName;
+        if (typeof chunk.sourcemapFileName === "string" && chunk.sourcemapFileName) {
+          chunk.sourcemapFileName = `${newFileName}.map`;
+        }
+        const targetKey = `${newFileName}.map`;
+        emitSourceMapAsset(this, targetKey, sourceMapAssetInfo, resolvedSourceMap);
+        for (const mapKey of sourceMapKeys) {
+          if (!mapKey || mapKey === targetKey) {
+            continue;
+          }
+          if (bundle[mapKey]) {
+            delete bundle[mapKey];
+          }
+        }
         finalFileName = newFileName;
       }
       options.onFallback?.({
@@ -12165,20 +12301,40 @@ function applySharedChunkStrategy(bundle, options) {
       });
       continue;
     }
-    const importerToChunk = /* @__PURE__ */ new Map();
-    const duplicates = [];
-    const diagnostics = consumeSharedChunkDiagnostics(originalSharedFileName);
+    if (shouldRetainOriginalChunk && fileName.startsWith(`${SHARED_CHUNK_VIRTUAL_PREFIX}/`)) {
+      const newFileName = fileName.slice(SHARED_CHUNK_VIRTUAL_PREFIX.length + 1);
+      chunk.fileName = newFileName;
+      if (typeof chunk.sourcemapFileName === "string" && chunk.sourcemapFileName) {
+        chunk.sourcemapFileName = `${newFileName}.map`;
+      }
+      const targetKey = `${newFileName}.map`;
+      emitSourceMapAsset(this, targetKey, sourceMapAssetInfo, resolvedSourceMap);
+      for (const mapKey of sourceMapKeys) {
+        if (!mapKey || mapKey === targetKey) {
+          continue;
+        }
+        if (bundle[mapKey]) {
+          delete bundle[mapKey];
+        }
+      }
+      options.onFallback?.({
+        sharedFileName: originalSharedFileName,
+        finalFileName: newFileName,
+        reason: "main-package",
+        importers: [...importers]
+      });
+    }
     for (const { newFileName, importers: importerFiles } of importerMap.values()) {
       this.emitFile({
         type: "asset",
         fileName: newFileName,
         source: originalCode
       });
-      if (originalMap) {
+      if (resolvedSourceMap) {
         this.emitFile({
           type: "asset",
           fileName: `${newFileName}.map`,
-          source: typeof originalMap === "string" ? originalMap : JSON.stringify(originalMap)
+          source: cloneSourceLike(resolvedSourceMap)
         });
       }
       for (const importerFile of importerFiles) {
@@ -12190,10 +12346,13 @@ function applySharedChunkStrategy(bundle, options) {
       });
     }
     updateImporters(bundle, importerToChunk, fileName);
-    delete bundle[fileName];
-    const mapKey = `${fileName}.map`;
-    if (bundle[mapKey]) {
-      delete bundle[mapKey];
+    if (!shouldRetainOriginalChunk) {
+      delete bundle[fileName];
+      for (const mapKey of sourceMapKeys) {
+        if (mapKey && bundle[mapKey]) {
+          delete bundle[mapKey];
+        }
+      }
     }
     const chunkBytes = typeof originalCode === "string" ? Buffer2.byteLength(originalCode, "utf8") : void 0;
     const redundantBytes = typeof chunkBytes === "number" ? chunkBytes * Math.max(duplicates.length - 1, 0) : void 0;
@@ -12202,7 +12361,8 @@ function applySharedChunkStrategy(bundle, options) {
       duplicates,
       ignoredMainImporters: diagnostics?.ignoredMainImporters,
       chunkBytes,
-      redundantBytes
+      redundantBytes,
+      retainedInMain: shouldRetainOriginalChunk
     });
   }
 }
@@ -12220,6 +12380,27 @@ function consumeSharedChunkDiagnostics(fileName) {
   }
   return void 0;
 }
+function emitSourceMapAsset(ctx, targetFileName, sourceMapAssetInfo, fallbackSource) {
+  if (!targetFileName) {
+    return;
+  }
+  if (sourceMapAssetInfo?.asset && isSourceLike(sourceMapAssetInfo.asset.source)) {
+    ctx.emitFile({
+      type: "asset",
+      fileName: targetFileName,
+      source: cloneSourceLike(sourceMapAssetInfo.asset.source),
+      name: sourceMapAssetInfo.asset.name
+    });
+    return;
+  }
+  if (fallbackSource) {
+    ctx.emitFile({
+      type: "asset",
+      fileName: targetFileName,
+      source: cloneSourceLike(fallbackSource)
+    });
+  }
+}
 function isSharedVirtualChunk(fileName, output) {
   return output?.type === "chunk" && fileName.startsWith(`${SHARED_CHUNK_VIRTUAL_PREFIX}/`);
 }
@@ -12232,6 +12413,24 @@ function findChunkImporters(bundle, target) {
     const chunk = output;
     if (chunk.imports.includes(target) || chunk.dynamicImports.includes(target)) {
       importers.add(fileName);
+      continue;
+    }
+    const metadata = chunk.viteMetadata;
+    if (metadata) {
+      const importedChunks = metadata.importedChunks;
+      if (hasInCollection(importedChunks, target)) {
+        importers.add(fileName);
+        continue;
+      }
+      const importedScripts = metadata.importedScripts ?? metadata.importedScriptsByUrl;
+      if (hasInCollection(importedScripts, target)) {
+        importers.add(fileName);
+        continue;
+      }
+    }
+    const potentialImport = createRelativeImport(fileName, target);
+    if (potentialImport && containsImportSpecifier(chunk.code ?? "", potentialImport)) {
+      importers.add(fileName);
     }
   }
   return Array.from(importers);
@@ -12259,11 +12458,35 @@ function updateImporters(bundle, importerToChunk, originalFileName) {
     const importerChunk = importer;
     const originalImportPath = createRelativeImport(importerFile, originalFileName);
     const newImportPath = createRelativeImport(importerFile, newChunkFile);
+    let codeUpdated = false;
     if (originalImportPath !== newImportPath) {
-      importerChunk.code = replaceAll(importerChunk.code, originalImportPath, newImportPath);
+      const updated = replaceAll(importerChunk.code, originalImportPath, newImportPath);
+      if (updated !== importerChunk.code) {
+        importerChunk.code = updated;
+        codeUpdated = true;
+      }
+    }
+    importerChunk.imports = replaceInArray(importerChunk.imports, originalFileName, newChunkFile, codeUpdated);
+    importerChunk.dynamicImports = replaceInArray(importerChunk.dynamicImports, originalFileName, newChunkFile, codeUpdated);
+    const implicitlyLoadedBefore = importerChunk.implicitlyLoadedBefore;
+    if (Array.isArray(implicitlyLoadedBefore)) {
+      importerChunk.implicitlyLoadedBefore = replaceInArray(
+        implicitlyLoadedBefore,
+        originalFileName,
+        newChunkFile,
+        codeUpdated
+      );
     }
-    importerChunk.imports = replaceInArray(importerChunk.imports, originalFileName, newChunkFile);
-    importerChunk.dynamicImports = replaceInArray(importerChunk.dynamicImports, originalFileName, newChunkFile);
+    const referencedFiles = importerChunk.referencedFiles;
+    if (Array.isArray(referencedFiles)) {
+      importerChunk.referencedFiles = replaceInArray(
+        referencedFiles,
+        originalFileName,
+        newChunkFile,
+        codeUpdated
+      );
+    }
+    updateViteMetadata(importerChunk, originalFileName, newChunkFile, codeUpdated);
   }
 }
 function replaceAll(source, searchValue, replaceValue) {
@@ -12282,10 +12505,74 @@ function replaceAll(source, searchValue, replaceValue) {
   }
   return source;
 }
-function replaceInArray(list, searchValue, replaceValue) {
-  return list.map((value) => {
-    return value === searchValue ? replaceValue : value;
-  });
+function containsImportSpecifier(source, specifier) {
+  if (!specifier) {
+    return false;
+  }
+  if (source.includes(specifier)) {
+    return true;
+  }
+  if (specifier.startsWith("./")) {
+    const trimmed = specifier.slice(2);
+    if (trimmed && source.includes(trimmed)) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasInCollection(collection, value) {
+  if (!collection || !value) {
+    return false;
+  }
+  if (collection instanceof Set) {
+    return collection.has(value);
+  }
+  if (Array.isArray(collection)) {
+    return collection.includes(value);
+  }
+  if (collection instanceof Map) {
+    return collection.has(value);
+  }
+  return false;
+}
+function replaceInArray(list, searchValue, replaceValue, shouldInsert) {
+  const values = Array.isArray(list) ? [...list] : [];
+  let replaced = false;
+  for (let index = 0; index < values.length; index++) {
+    const current2 = values[index];
+    if (current2 === searchValue) {
+      values[index] = replaceValue;
+      replaced = true;
+    }
+  }
+  if ((replaced || shouldInsert) && replaceValue && !values.includes(replaceValue)) {
+    values.push(replaceValue);
+  }
+  return values;
+}
+function updateViteMetadata(importerChunk, originalFileName, newChunkFile, shouldInsert) {
+  const metadata = importerChunk.viteMetadata;
+  if (!metadata || typeof metadata !== "object") {
+    return;
+  }
+  const candidateKeys = ["importedChunks", "importedScripts"];
+  for (const key of candidateKeys) {
+    const collection = metadata[key];
+    if (collection instanceof Set) {
+      const hadOriginal = collection.delete(originalFileName);
+      if (hadOriginal || shouldInsert) {
+        collection.add(newChunkFile);
+      }
+    } else if (Array.isArray(collection)) {
+      metadata[key] = replaceInArray(collection, originalFileName, newChunkFile, shouldInsert);
+    } else if (collection instanceof Map) {
+      if (collection.has(originalFileName)) {
+        const originalValue = collection.get(originalFileName);
+        collection.delete(originalFileName);
+        collection.set(newChunkFile, originalValue);
+      }
+    }
+  }
 }
 function createRelativeImport(fromFile, toFile) {
   const relative3 = path10.relative(path10.dirname(fromFile), toFile);
@@ -12294,6 +12581,55 @@ function createRelativeImport(fromFile, toFile) {
   }
   return `./${relative3}`;
 }
+function collectSourceMapKeys(fileName, chunk) {
+  const keys = /* @__PURE__ */ new Set();
+  if (fileName) {
+    keys.add(`${fileName}.map`);
+  }
+  if (typeof chunk.sourcemapFileName === "string" && chunk.sourcemapFileName) {
+    keys.add(chunk.sourcemapFileName);
+  }
+  return keys;
+}
+function findSourceMapAsset(bundle, candidateKeys) {
+  for (const key of candidateKeys) {
+    if (!key) {
+      continue;
+    }
+    const entry = bundle[key];
+    if (entry?.type === "asset") {
+      return {
+        asset: entry,
+        key
+      };
+    }
+  }
+  return void 0;
+}
+function resolveSourceMapSource(originalMap, assetSource) {
+  if (originalMap) {
+    if (typeof originalMap === "string") {
+      return originalMap;
+    }
+    if (originalMap instanceof Uint8Array || Buffer2.isBuffer(originalMap)) {
+      return Buffer2.from(originalMap);
+    }
+    return JSON.stringify(originalMap);
+  }
+  if (isSourceLike(assetSource)) {
+    return cloneSourceLike(assetSource);
+  }
+  return void 0;
+}
+function isSourceLike(source) {
+  return typeof source === "string" || source instanceof Uint8Array || Buffer2.isBuffer(source);
+}
+function cloneSourceLike(source) {
+  if (typeof source === "string") {
+    return source;
+  }
+  return Buffer2.from(source);
+}
 
 // src/runtime/advancedChunks.ts
 function testByReg2DExpList(reg2DExpList) {
@@ -12334,6 +12670,35 @@ function createAdvancedChunkNameResolver(options) {
 // src/runtime/sharedBuildConfig.ts
 var REG_NODE_MODULES_DIR = /[\\/]node_modules[\\/]/gi;
 var REG_COMMONJS_HELPERS = /commonjsHelpers\.js$/;
+function createForceDuplicateTester(patterns) {
+  if (!patterns || patterns.length === 0) {
+    return void 0;
+  }
+  const matchers = patterns.map((pattern) => {
+    if (typeof pattern === "string") {
+      const matcher = picomatch(pattern, { dot: true });
+      return (value) => matcher(value);
+    }
+    if (isRegexp(pattern)) {
+      return (value) => {
+        pattern.lastIndex = 0;
+        return pattern.test(value);
+      };
+    }
+    return void 0;
+  }).filter((matcher) => typeof matcher === "function");
+  if (!matchers.length) {
+    return void 0;
+  }
+  return (relativeId, absoluteId) => {
+    for (const matcher of matchers) {
+      if (matcher(relativeId) || matcher(absoluteId)) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
 function createSharedBuildConfig(configService, scanService) {
   const nodeModulesDeps = [REG_NODE_MODULES_DIR];
   const commonjsHelpersDeps = [REG_COMMONJS_HELPERS];
@@ -12364,35 +12729,6 @@ function createSharedBuildConfig(configService, scanService) {
     }
   };
 }
-function createForceDuplicateTester(patterns) {
-  if (!patterns || patterns.length === 0) {
-    return void 0;
-  }
-  const matchers = patterns.map((pattern) => {
-    if (typeof pattern === "string") {
-      const matcher = picomatch(pattern, { dot: true });
-      return (value) => matcher(value);
-    }
-    if (isRegexp(pattern)) {
-      return (value) => {
-        pattern.lastIndex = 0;
-        return pattern.test(value);
-      };
-    }
-    return void 0;
-  }).filter((matcher) => typeof matcher === "function");
-  if (!matchers.length) {
-    return void 0;
-  }
-  return (relativeId, absoluteId) => {
-    for (const matcher of matchers) {
-      if (matcher(relativeId) || matcher(absoluteId)) {
-        return true;
-      }
-    }
-    return false;
-  };
-}
 
 // src/runtime/buildPlugin.ts
 function createBuildService(ctx) {
@@ -23779,11 +24115,69 @@ function weappVite(ctx, subPackageMeta) {
     watchFilesSnapshot: []
   };
   return [
+    createTakeQueryPlugin(state),
     createWxssResolverPlugin(state),
     createCoreLifecyclePlugin(state),
     createRequireAnalysisPlugin(state)
   ];
 }
+var TAKE_DIRECTIVE_PREFIX = "take:";
+function normalizeTakeRequest(source) {
+  if (!source) {
+    return null;
+  }
+  if (source.startsWith(TAKE_DIRECTIVE_PREFIX)) {
+    const id = source.slice(TAKE_DIRECTIVE_PREFIX.length);
+    if (!id) {
+      return null;
+    }
+    return {
+      id,
+      legacy: false
+    };
+  }
+  if (!source.includes("?")) {
+    return null;
+  }
+  const [filename, rawQuery] = source.split("?", 2);
+  if (!rawQuery) {
+    return null;
+  }
+  const params = new URLSearchParams(rawQuery);
+  if (!params.has("take")) {
+    return null;
+  }
+  return {
+    id: filename,
+    legacy: true
+  };
+}
+function createTakeQueryPlugin(_state) {
+  return {
+    name: "weapp-vite:pre:take-query",
+    enforce: "pre",
+    buildStart() {
+      resetTakeImportRegistry();
+    },
+    async resolveId(source, importer) {
+      const takeRequest = normalizeTakeRequest(source);
+      if (!takeRequest) {
+        return null;
+      }
+      const resolved = await this.resolve(takeRequest.id, importer, { skipSelf: true });
+      if (resolved?.id) {
+        markTakeModuleImporter(resolved.id, importer);
+        if (takeRequest.legacy) {
+          logger_default.warn(
+            `"${source}" detected: the ?take query is deprecated, please migrate to the "take:" prefix (e.g. "take:${takeRequest.id}")`
+          );
+        }
+        return resolved;
+      }
+      return null;
+    }
+  };
+}
 function createWxssResolverPlugin(_state) {
   return {
     name: "weapp-vite:pre:wxss",
@@ -23933,7 +24327,7 @@ function createCoreLifecyclePlugin(state) {
         const duplicateWarningBytes = Number(configService.weappViteConfig?.chunks?.duplicateWarningBytes ?? 0);
         const shouldWarnOnDuplicate = Number.isFinite(duplicateWarningBytes) && duplicateWarningBytes > 0;
         let redundantBytesTotal = 0;
-        const handleDuplicate = shouldLogChunks || shouldWarnOnDuplicate ? ({ duplicates, ignoredMainImporters, chunkBytes, redundantBytes }) => {
+        const handleDuplicate = shouldLogChunks || shouldWarnOnDuplicate ? ({ duplicates, ignoredMainImporters, chunkBytes, redundantBytes, retainedInMain, sharedFileName }) => {
           if (shouldWarnOnDuplicate) {
             const duplicateCount = duplicates.length;
             const computedRedundant = typeof redundantBytes === "number" ? redundantBytes : typeof chunkBytes === "number" ? chunkBytes * Math.max(duplicateCount - 1, 0) : 0;
@@ -23952,6 +24346,9 @@ function createCoreLifecyclePlugin(state) {
             const subPackageList = Array.from(subPackageSet).join("\u3001") || "\u76F8\u5173\u5206\u5305";
             const ignoredHint = ignoredMainImporters?.length ? `\uFF0C\u5FFD\u7565\u4E3B\u5305\u5F15\u7528\uFF1A${ignoredMainImporters.join("\u3001")}` : "";
             logger_default.info(`[subpackages] \u5206\u5305 ${subPackageList} \u5171\u4EAB\u6A21\u5757\u5DF2\u590D\u5236\u5230\u5404\u81EA weapp-shared/common.js\uFF08${totalReferences} \u5904\u5F15\u7528${ignoredHint}\uFF09`);
+            if (retainedInMain) {
+              logger_default.warn(`[subpackages] \u6A21\u5757 ${sharedFileName} \u540C\u65F6\u88AB\u4E3B\u5305\u5F15\u7528\uFF0C\u56E0\u6B64\u4ECD\u4FDD\u7559\u5728\u4E3B\u5305 common.js\uFF0C\u5E76\u590D\u5236\u5230 ${subPackageList}\uFF0C\u8BF7\u786E\u8BA4\u662F\u5426\u9700\u8981\u5C06\u6E90\u4EE3\u7801\u79FB\u52A8\u5230\u4E3B\u5305\u6216\u516C\u5171\u76EE\u5F55\u3002`);
+            }
           }
         } : void 0;
         applySharedChunkStrategy.call(this, bundle, {