@depup/webpack 5.109.2-depup.0 → 5.110.3-depup.0

package/lib/errors/deriveStackFromNestedError.js

@@ -0,0 +1,90 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/** @import { ErrorWithHideStack } from "./ModuleBuildError" */
+/** @import WebpackError from "./WebpackError" */
+
+/**
+ * Returns the nested error's stack without its leading "Name: message" line.
+ * @param {ErrorWithHideStack} nestedError the wrapped error
+ * @returns {string | undefined} frames of the nested stack
+ */
+const getNestedFrames = (nestedError) => {
+	const stack = nestedError.stack;
+	if (!stack) return undefined;
+	const firstLineEnd = stack.indexOf("\n");
+	return firstLineEnd === -1 ? "" : stack.slice(firstLineEnd + 1);
+};
+
+/**
+ * Derives `details` — or, for a `hideStack` error, `stack` — of a diagnostic
+ * that wraps `nestedError`. V8 formats a stack trace only when it is read, and
+ * a diagnostic is normally printed without one (stats needs `errorDetails` or
+ * `errorStack` for that), so the derived string is materialized on first
+ * access: a build with thousands of dependency warnings would otherwise spend a
+ * large share of its time formatting stacks that nothing ever reads.
+ * @param {WebpackError} error the wrapping diagnostic
+ * @param {ErrorWithHideStack | undefined} nestedError the wrapped error
+ * @returns {void}
+ */
+const deriveStackFromNestedError = (error, nestedError) => {
+	if (!nestedError) return;
+	if (nestedError.hideStack) {
+		// the frames are hidden, but they are still prepended to the own stack
+		const ownStack =
+			/** @type {PropertyDescriptor} */
+			(Object.getOwnPropertyDescriptor(error, "stack"));
+		/** @type {string | undefined} */
+		let stack;
+		let computed = false;
+		Object.defineProperty(error, "stack", {
+			configurable: true,
+			enumerable: false,
+			get() {
+				if (!computed) {
+					computed = true;
+					const own = ownStack.get ? ownStack.get.call(error) : ownStack.value;
+					const frames = getNestedFrames(nestedError);
+					stack = frames === undefined ? own : `${frames}\n\n${own}`;
+					// older V8 replaces the own `stack` accessor when it is first read
+					Object.defineProperty(error, "stack", {
+						configurable: true,
+						enumerable: false,
+						writable: true,
+						value: stack
+					});
+				}
+				return stack;
+			},
+			set(value) {
+				computed = true;
+				stack = value;
+			}
+		});
+		return;
+	}
+	/** @type {string | undefined} */
+	let details;
+	let computed = false;
+	Object.defineProperty(error, "details", {
+		configurable: true,
+		enumerable: true,
+		get() {
+			if (!computed) {
+				computed = true;
+				details = getNestedFrames(nestedError);
+			}
+			return details;
+		},
+		set(value) {
+			computed = true;
+			details = value;
+		}
+	});
+};
+
+module.exports = deriveStackFromNestedError;

package/lib/esm/ExportWebpackRequireRuntimeModule.js

@@ -14,6 +14,8 @@ class ExportWebpackRequireRuntimeModule extends RuntimeModule {
 
 	/**
 	 * Returns true, if the runtime module should get it's own scope.
+	 * When false, `generate()` must emit complete statements ending with `;`
+	 * so a following runtime IIFE is not parsed as a call (ASI).
 	 * @returns {boolean} true, if the runtime module should get it's own scope
 	 */
 	shouldIsolate() {

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -19,16 +19,20 @@ const {
 	getChunkFilenameTemplate,
 	getCompilationHooks
 } = require("../javascript/JavascriptModulesPlugin");
+const { entryModuleIdExpression } = require("../javascript/StartupHelpers");
 const { getUndoPath } = require("../util/identifier");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Entrypoint")} Entrypoint */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @import { Source } from "webpack-sources" */
+/** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
+/** @import Compilation from "../Compilation" */
+/** @import Compiler from "../Compiler" */
+/** @import Entrypoint from "../Entrypoint" */
+/**
+ * @import {
+ * 	ChunkRenderContext
+ * } from "../javascript/JavascriptModulesPlugin"
+ */
 
 /**
  * Gets relative path.
@@ -185,22 +189,18 @@ class ModuleChunkFormatPlugin {
 				const { chunk, chunkGraph, runtimeTemplate } = renderContext;
 				const hotUpdateChunk = chunk instanceof HotUpdateChunk ? chunk : null;
 				const source = new ConcatSource();
+				const cst = runtimeTemplate.renderConst();
 				source.add(
-					`export const ${RuntimeGlobals.esmId} = ${JSON.stringify(
-						chunk.id
-					)};\n`
-				);
-				source.add(
-					`export const ${RuntimeGlobals.esmIds} = ${JSON.stringify(
+					`export ${cst} ${RuntimeGlobals.esmIds} = ${JSON.stringify(
 						chunk.ids
 					)};\n`
 				);
-				source.add(`export const ${RuntimeGlobals.esmModules} = `);
+				source.add(`export ${cst} ${RuntimeGlobals.esmModules} = `);
 				source.add(modules);
 				source.add(";\n");
 				const runtimeModules = chunkGraph.getChunkRuntimeModulesInOrder(chunk);
 				if (runtimeModules.length > 0) {
-					source.add(`export const ${RuntimeGlobals.esmRuntime} =\n`);
+					source.add(`export ${cst} ${RuntimeGlobals.esmRuntime} =\n`);
 					source.add(
 						Template.renderChunkRuntimeModules(runtimeModules, renderContext)
 					);
@@ -229,7 +229,11 @@ class ModuleChunkFormatPlugin {
 					if (needExec) {
 						startupSource.add(
 							`var __webpack_exec__ = ${runtimeTemplate.returningFunction(
-								`${RuntimeGlobals.require}(${RuntimeGlobals.entryModuleId} = moduleId)`,
+								`${RuntimeGlobals.require}(${entryModuleIdExpression(
+									chunkGraph,
+									chunk,
+									"moduleId"
+								)})`,
 								"moduleId"
 							)}\n`
 						);
@@ -237,6 +241,7 @@ class ModuleChunkFormatPlugin {
 
 					/** @type {Set<Chunk>} */
 					const loadedChunks = new Set();
+					let ownInstalled = false;
 					for (let i = 0; i < entries.length; i++) {
 						const [module, entrypoint] = entries[i];
 						if (!chunkGraph.getModuleSourceTypes(module).has(JAVASCRIPT_TYPE)) {
@@ -246,8 +251,8 @@ class ModuleChunkFormatPlugin {
 						const moduleId = chunkGraph.getModuleId(module);
 						const chunks = getAllChunks(
 							/** @type {Entrypoint} */ (entrypoint),
-							/** @type {Chunk} */ (runtimeChunk),
-							undefined
+							chunk,
+							/** @type {Chunk} */ (runtimeChunk)
 						);
 						/** @type {Set<Chunk>} */
 						const processChunks = new Set();
@@ -267,6 +272,19 @@ class ModuleChunkFormatPlugin {
 							startupSource.add("\n");
 							startupSource.add(sourceWithDependentChunks);
 						}
+						if (!ownInstalled) {
+							ownInstalled = true;
+							// Own chunk data comes from the `export const` bindings above.
+							startupSource.add(
+								`${RuntimeGlobals.externalInstallChunk}({ ${
+									RuntimeGlobals.esmIds
+								}, ${RuntimeGlobals.esmModules}${
+									runtimeModules.length > 0
+										? `, ${RuntimeGlobals.esmRuntime}`
+										: ""
+								} });\n`
+							);
+						}
 						if (module === inlinedEntryModule && inlinedEntrySource) {
 							// Inline the entry at the top level so its declarations stay
 							// live ESM bindings (exports appended by `renderStartup`).

package/lib/esm/ModuleChunkLoadingPlugin.js

@@ -6,12 +6,19 @@
 "use strict";
 
 const RuntimeGlobals = require("../RuntimeGlobals");
-const ExportWebpackRequireRuntimeModule = require("./ExportWebpackRequireRuntimeModule");
-const ModuleChunkLoadingRuntimeModule = require("./ModuleChunkLoadingRuntimeModule");
+const lazyModule = require("../util/lazyModule");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
+/** @import Chunk from "../Chunk" */
+/** @import Compiler from "../Compiler" */
+/** @import { RuntimeRequirements } from "../Module" */
+
+// only a chunk that loads other chunks at runtime emits these
+const getExportWebpackRequireRuntimeModule = lazyModule(() =>
+	require("./ExportWebpackRequireRuntimeModule")
+);
+const getModuleChunkLoadingRuntimeModule = lazyModule(() =>
+	require("./ModuleChunkLoadingRuntimeModule")
+);
 
 const PLUGIN_NAME = "ModuleChunkLoadingPlugin";
 
@@ -48,65 +55,86 @@ class ModuleChunkLoadingPlugin {
 				if (onceForChunkSet.has(chunk)) return;
 				onceForChunkSet.add(chunk);
 				if (!isEnabledForChunk(chunk)) return;
-				set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-				set.add(RuntimeGlobals.hasOwnProperty);
-				compilation.addRuntimeModule(
+				compilation.addLazyRuntimeModule(
 					chunk,
-					new ModuleChunkLoadingRuntimeModule(set)
+					getModuleChunkLoadingRuntimeModule,
+					(Ctor) => new Ctor(set)
 				);
 			};
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.ensureChunkHandlers)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.baseURI)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.externalInstallChunk)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.analyzableChunkImport)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.onChunksLoaded)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.hmrDownloadManifest)
-				.tap(PLUGIN_NAME, handler);
+			/**
+			 * Installing a chunk is the only part that writes the module factories and
+			 * looks a chunk id up; a base uri, `onChunksLoaded` or the hot manifest come
+			 * without either. Kept off `handler`, which runs once per chunk and so cannot
+			 * see which of the requirements below the chunk ends up with.
+			 * @param {Chunk} chunk chunk to check
+			 * @param {RuntimeRequirements} set runtime requirements
+			 */
+			const installHandler = (chunk, set) => {
+				if (!isEnabledForChunk(chunk)) return;
+				set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+				set.add(RuntimeGlobals.hasOwnProperty);
+			};
+			for (const requirement of [
+				RuntimeGlobals.ensureChunkHandlers,
+				RuntimeGlobals.baseURI,
+				RuntimeGlobals.externalInstallChunk,
+				RuntimeGlobals.analyzableChunkImport,
+				RuntimeGlobals.onChunksLoaded,
+				RuntimeGlobals.hmrDownloadUpdateHandlers,
+				RuntimeGlobals.hmrDownloadManifest
+			]) {
+				compilation.hooks.runtimeRequirementInTree
+					.for(requirement)
+					.tap(PLUGIN_NAME, handler);
+			}
+			for (const requirement of [
+				RuntimeGlobals.ensureChunkHandlers,
+				RuntimeGlobals.externalInstallChunk,
+				RuntimeGlobals.analyzableChunkImport,
+				RuntimeGlobals.hmrDownloadUpdateHandlers
+			]) {
+				compilation.hooks.runtimeRequirementInTree
+					.for(requirement)
+					.tap(PLUGIN_NAME, installHandler);
+			}
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.externalInstallChunk)
 				.tap(PLUGIN_NAME, (chunk) => {
 					if (!isEnabledForChunk(chunk)) return;
-					compilation.addRuntimeModule(
+					compilation.addLazyRuntimeModule(
 						chunk,
-						new ExportWebpackRequireRuntimeModule()
+						getExportWebpackRequireRuntimeModule,
+						(Ctor) => new Ctor()
 					);
 				});
 
-			// The prefetch/preload handlers build the chunk URL themselves, so they need
-			// the public path and script filename directly — without relying on
-			// `ensureChunkHandlers` to pull them in (an analyzable `import()` may replace it).
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.prefetchChunkHandlers)
-				.tap(PLUGIN_NAME, (chunk, set) => {
-					if (!isEnabledForChunk(chunk)) return;
-					set.add(RuntimeGlobals.publicPath);
-					set.add(RuntimeGlobals.getChunkScriptFilename);
-				});
-
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.preloadChunkHandlers)
-				.tap(PLUGIN_NAME, (chunk, set) => {
-					if (!isEnabledForChunk(chunk)) return;
-					set.add(RuntimeGlobals.publicPath);
-					set.add(RuntimeGlobals.getChunkScriptFilename);
-				});
+			// A handler that builds its url asks for both directly: an analyzable
+			// `import()` may replace `ensureChunkHandlers`, which otherwise pulls them in.
+			for (const requirement of [
+				RuntimeGlobals.prefetchChunkHandlers,
+				RuntimeGlobals.preloadChunkHandlers
+			]) {
+				compilation.hooks.runtimeRequirementInTree
+					.for(requirement)
+					.tap(PLUGIN_NAME, (chunk, set, { chunkGraph }) => {
+						if (!isEnabledForChunk(chunk)) return;
+						// A baked url carries where the chunk is, so neither is read for it.
+						// Asked as the runtime module asks, so the two always agree.
+						const baked = compilation.runtimeTemplate.analyzableChunkScriptUrls(
+							chunk,
+							chunkGraph,
+							set
+						);
+						if (baked !== null && baked.complete) return;
+						set.add(RuntimeGlobals.publicPath);
+						set.add(RuntimeGlobals.getChunkScriptFilename);
+					});
+			}
 
+			// Keyed on `ensureChunk`, not on the handler map: only the runtime chunk loader
+			// builds a URL from a chunk id, and an analyzable `import()` carries its own.
 			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.ensureChunkHandlers)
+				.for(RuntimeGlobals.ensureChunk)
 				.tap(PLUGIN_NAME, (chunk, set) => {
 					if (!isEnabledForChunk(chunk)) return;
 
@@ -123,6 +151,13 @@ class ModuleChunkLoadingPlugin {
 					if (!isEnabledForChunk(chunk)) return;
 					set.add(RuntimeGlobals.publicPath);
 					set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
+					// The hot runtime force-loads through the handler map by bare chunk id, so
+					// the map and loader stay however analyzable — but only where there are
+					// async chunks to force-load.
+					if (chunk.hasAsyncChunks()) {
+						set.add(RuntimeGlobals.ensureChunkHandlers);
+						set.add(RuntimeGlobals.getChunkScriptFilename);
+					}
 					set.add(RuntimeGlobals.moduleCache);
 					set.add(RuntimeGlobals.hmrModuleData);
 					set.add(RuntimeGlobals.moduleFactoriesAddOnly);