webpack 5.5.1 → 5.9.0

package/bin/webpack.js

@@ -82,10 +82,17 @@ if (!cli.installed) {
 
 	console.error(notify);
 
-	const isYarn = fs.existsSync(path.resolve(process.cwd(), "yarn.lock"));
+	let packageManager;
+
+	if (fs.existsSync(path.resolve(process.cwd(), "yarn.lock"))) {
+		packageManager = "yarn";
+	} else if (fs.existsSync(path.resolve(process.cwd(), "pnpm-lock.yaml"))) {
+		packageManager = "pnpm";
+	} else {
+		packageManager = "npm";
+	}
 
-	const packageManager = isYarn ? "yarn" : "npm";
-	const installOptions = [isYarn ? "add" : "install", "-D"];
+	const installOptions = [packageManager === "yarn" ? "add" : "install", "-D"];
 
 	console.error(
 		`We will use "${packageManager}" to install the CLI via "${packageManager} ${installOptions.join(

package/lib/Compilation.js

@@ -76,6 +76,8 @@ const { getRuntimeKey } = require("./util/runtime");
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
 /** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
+/** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
+/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("./Cache")} Cache */
 /** @typedef {import("./CacheFacade")} CacheFacade */
@@ -87,15 +89,11 @@ const { getRuntimeKey } = require("./util/runtime");
 /** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("./DependencyTemplate")} DependencyTemplate */
 /** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
-/** @typedef {import("./Module")} Module */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./ModuleFactory")} ModuleFactory */
 /** @typedef {import("./RuntimeModule")} RuntimeModule */
 /** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry */
 /** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./stats/StatsFactory")} StatsFactory */
-/** @typedef {import("./stats/StatsPrinter")} StatsPrinter */
 /** @typedef {import("./util/Hash")} Hash */
 /** @template T @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T> */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
@@ -119,11 +117,6 @@ const { getRuntimeKey } = require("./util/runtime");
  * @returns {any}
  */
 
-/**
- * @typedef {Object} Plugin
- * @property {() => void} apply
- */
-
 /** @typedef {new (...args: any[]) => Dependency} DepConstructor */
 /** @typedef {Record<string, Source>} CompilationAssets */
 
@@ -296,10 +289,122 @@ class Compilation {
 	 */
 	constructor(compiler) {
 		const getNormalModuleLoader = () => deprecatedNormalModuleLoaderHook(this);
-		/** @type {AsyncSeriesHook<[CompilationAssets]>} */
+		/** @typedef {{ additionalAssets?: true | Function }} ProcessAssetsAdditionalOptions */
+		/** @type {AsyncSeriesHook<[CompilationAssets], ProcessAssetsAdditionalOptions>} */
 		const processAssetsHook = new AsyncSeriesHook(["assets"]);
+
+		let savedAssets = new Set();
+		const popNewAssets = assets => {
+			let newAssets = undefined;
+			for (const file of Object.keys(assets)) {
+				if (savedAssets.has(file)) continue;
+				if (newAssets === undefined) {
+					newAssets = Object.create(null);
+				}
+				newAssets[file] = assets[file];
+				savedAssets.add(file);
+			}
+			return newAssets;
+		};
+		processAssetsHook.intercept({
+			name: "Compilation",
+			call: () => {
+				savedAssets.clear();
+			},
+			register: tap => {
+				const { type, name } = tap;
+				const { fn, additionalAssets, ...remainingTap } = tap;
+				const additionalAssetsFn =
+					additionalAssets === true ? fn : additionalAssets;
+				let processedAssets = undefined;
+				switch (type) {
+					case "sync":
+						if (additionalAssetsFn) {
+							this.hooks.processAdditionalAssets.tap(name, assets => {
+								if (processedAssets === this.assets) additionalAssetsFn(assets);
+							});
+						}
+						return {
+							...remainingTap,
+							type: "async",
+							fn: (assets, callback) => {
+								try {
+									fn(assets);
+								} catch (e) {
+									return callback(e);
+								}
+								processedAssets = this.assets;
+								const newAssets = popNewAssets(assets);
+								if (newAssets !== undefined) {
+									this.hooks.processAdditionalAssets.callAsync(
+										newAssets,
+										callback
+									);
+									return;
+								}
+								callback();
+							}
+						};
+					case "async":
+						if (additionalAssetsFn) {
+							this.hooks.processAdditionalAssets.tapAsync(
+								name,
+								(assets, callback) => {
+									if (processedAssets === this.assets)
+										return additionalAssetsFn(assets, callback);
+									callback();
+								}
+							);
+						}
+						return {
+							...remainingTap,
+							fn: (assets, callback) => {
+								fn(assets, err => {
+									if (err) return callback(err);
+									processedAssets = this.assets;
+									const newAssets = popNewAssets(assets);
+									if (newAssets !== undefined) {
+										this.hooks.processAdditionalAssets.callAsync(
+											newAssets,
+											callback
+										);
+										return;
+									}
+									callback();
+								});
+							}
+						};
+					case "promise":
+						if (additionalAssetsFn) {
+							this.hooks.processAdditionalAssets.tapPromise(name, assets => {
+								if (processedAssets === this.assets)
+									return additionalAssetsFn(assets);
+								return Promise.resolve();
+							});
+						}
+						return {
+							...remainingTap,
+							fn: assets => {
+								const p = fn(assets);
+								if (!p || !p.then) return p;
+								return p.then(() => {
+									processedAssets = this.assets;
+									const newAssets = popNewAssets(assets);
+									if (newAssets !== undefined) {
+										return this.hooks.processAdditionalAssets.promise(
+											newAssets
+										);
+									}
+								});
+							}
+						};
+				}
+			}
+		});
+
 		/** @type {SyncHook<[CompilationAssets]>} */
 		const afterProcessAssetsHook = new SyncHook(["assets"]);
+
 		/**
 		 * @template T
 		 * @param {string} name name of the hook
@@ -551,6 +656,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 			processAssets: processAssetsHook,
 			afterProcessAssets: afterProcessAssetsHook,
+			/** @type {AsyncSeriesHook<[CompilationAssets]>} */
+			processAdditionalAssets: new AsyncSeriesHook(["assets"]),
 
 			/** @type {SyncBailHook<[], boolean>} */
 			needAdditionalSeal: new SyncBailHook([]),
@@ -3325,7 +3432,7 @@ This prevents using hashes of each other and should be avoided.`
 	 *
 	 * @param {string} name name of the child compiler
 	 * @param {OutputOptions} outputOptions // Need to convert config schema to types for this
-	 * @param {Plugin[]} plugins webpack plugins that will be applied
+	 * @param {Array<WebpackPluginInstance | WebpackPluginFunction>} plugins webpack plugins that will be applied
 	 * @returns {Compiler} creates a child Compiler instance
 	 */
 	createChildCompiler(name, outputOptions, plugins) {
@@ -3446,6 +3553,8 @@ Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE = 100;
 
 /**
  * Optimize the count of existing assets, e. g. by merging them.
+ * Only assets of the same type should be merged.
+ * For assets of different types see PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE.
  */
 Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT = 200;
 
@@ -3460,16 +3569,22 @@ Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY = 300;
 Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE = 400;
 
 /**
- * Summarize the list of existing assets.
- * When creating new assets from this they should be fully optimized.
- * e. g. creating an assets manifest of Service Workers.
+ * Add development tooling to assets, e. g. by extracting a SourceMap.
  */
-Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE = 1000;
+Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING = 500;
 
 /**
- * Add development tooling to assets, e. g. by extracting a SourceMap.
+ * Optimize the count of existing assets, e. g. by inlining assets of into other assets.
+ * Only assets of different types should be inlined.
+ * For assets of the same type see PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT.
  */
-Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING = 2000;
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE = 700;
+
+/**
+ * Summarize the list of existing assets
+ * e. g. creating an assets manifest of Service Workers.
+ */
+Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE = 1000;
 
 /**
  * Optimize the hashes of the assets, e. g. by generating real hashes of the asset content.

package/lib/Compiler.js

@@ -152,9 +152,9 @@ class Compiler {
 			beforeCompile: new AsyncSeriesHook(["params"]),
 			/** @type {SyncHook<[CompilationParams]>} */
 			compile: new SyncHook(["params"]),
-			/** @type {AsyncParallelHook<[Compilation], Module>} */
+			/** @type {AsyncParallelHook<[Compilation]>} */
 			make: new AsyncParallelHook(["compilation"]),
-			/** @type {AsyncParallelHook<[Compilation], Module>} */
+			/** @type {AsyncParallelHook<[Compilation]>} */
 			finishMake: new AsyncSeriesHook(["compilation"]),
 			/** @type {AsyncSeriesHook<[Compilation]>} */
 			afterCompile: new AsyncSeriesHook(["compilation"]),

package/lib/ExportsInfo.js

@@ -1085,7 +1085,7 @@ class ExportInfo {
 
 	/**
 	 * get used name
-	 * @param {string=} fallbackName fallback name for used exports with no name
+	 * @param {string | undefined} fallbackName fallback name for used exports with no name
 	 * @param {RuntimeSpec} runtime check usage for this runtime only
 	 * @returns {string | false} used name
 	 */

package/lib/FlagDependencyUsagePlugin.js

@@ -16,7 +16,6 @@ const { getEntryRuntime, mergeRuntimeOwned } = require("./util/runtime");
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("./ExportsInfo")} ExportsInfo */
 /** @typedef {import("./Module")} Module */
@@ -207,7 +206,10 @@ class FlagDependencyUsagePlugin {
 									referencedExports === EXPORTS_OBJECT_REFERENCED
 								) {
 									map.set(module, referencedExports);
-								} else if (oldReferencedExports === NO_EXPORTS_REFERENCED) {
+								} else if (
+									oldReferencedExports !== undefined &&
+									referencedExports === NO_EXPORTS_REFERENCED
+								) {
 									continue;
 								} else {
 									let exportsMap;

package/lib/HotModuleReplacementPlugin.js

@@ -12,6 +12,7 @@ const Compilation = require("./Compilation");
 const HotUpdateChunk = require("./HotUpdateChunk");
 const NormalModule = require("./NormalModule");
 const RuntimeGlobals = require("./RuntimeGlobals");
+const WebpackError = require("./WebpackError");
 const ConstDependency = require("./dependencies/ConstDependency");
 const ImportMetaHotAcceptDependency = require("./dependencies/ImportMetaHotAcceptDependency");
 const ImportMetaHotDeclineDependency = require("./dependencies/ImportMetaHotDeclineDependency");
@@ -22,15 +23,22 @@ const JavascriptParser = require("./javascript/JavascriptParser");
 const {
 	evaluateToIdentifier
 } = require("./javascript/JavascriptParserHelpers");
-const { find } = require("./util/SetHelpers");
+const { find, isSubset } = require("./util/SetHelpers");
 const TupleSet = require("./util/TupleSet");
 const { compareModulesById } = require("./util/comparators");
-const { getRuntimeKey, keyToRuntime } = require("./util/runtime");
+const {
+	getRuntimeKey,
+	keyToRuntime,
+	forEachRuntime,
+	mergeRuntimeOwned,
+	subtractRuntime
+} = require("./util/runtime");
 
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./RuntimeModule")} RuntimeModule */
 
 /**
  * @typedef {Object} HMRJavascriptParserHooks
@@ -388,27 +396,58 @@ class HotModuleReplacementPlugin {
 							}
 							chunkModuleHashes[key] = hash;
 						}
-						const hotUpdateMainContent = {
-							c: [],
-							r: [],
-							m: undefined
-						};
+
+						/** @type {Map<string, { updatedChunkIds: Set<string|number>, removedChunkIds: Set<string|number>, removedModules: Set<Module>, filename: string, assetInfo: AssetInfo }>} */
+						const hotUpdateMainContentByRuntime = new Map();
+						let allOldRuntime;
+						for (const key of Object.keys(records.chunkRuntime)) {
+							const runtime = keyToRuntime(records.chunkRuntime[key]);
+							allOldRuntime = mergeRuntimeOwned(allOldRuntime, runtime);
+						}
+						forEachRuntime(allOldRuntime, runtime => {
+							const {
+								path: filename,
+								info: assetInfo
+							} = compilation.getPathWithInfo(
+								compilation.outputOptions.hotUpdateMainFilename,
+								{
+									hash: records.hash,
+									runtime
+								}
+							);
+							hotUpdateMainContentByRuntime.set(runtime, {
+								updatedChunkIds: new Set(),
+								removedChunkIds: new Set(),
+								removedModules: new Set(),
+								filename,
+								assetInfo
+							});
+						});
+						if (hotUpdateMainContentByRuntime.size === 0) return;
 
 						// Create a list of all active modules to verify which modules are removed completely
 						/** @type {Map<number|string, Module>} */
 						const allModules = new Map();
 						for (const module of compilation.modules) {
-							allModules.set(chunkGraph.getModuleId(module), module);
+							const id = chunkGraph.getModuleId(module);
+							allModules.set(id, module);
 						}
 
 						// List of completely removed modules
-						const allRemovedModules = new Set();
+						/** @type {Set<string | number>} */
+						const completelyRemovedModules = new Set();
 
 						for (const key of Object.keys(records.chunkHashs)) {
-							// Check which modules are completely removed
+							const oldRuntime = keyToRuntime(records.chunkRuntime[key]);
+							/** @type {Module[]} */
+							const remainingModules = [];
+							// Check which modules are removed
 							for (const id of records.chunkModuleIds[key]) {
-								if (!allModules.has(id)) {
-									allRemovedModules.add(id);
+								const module = allModules.get(id);
+								if (module === undefined) {
+									completelyRemovedModules.add(id);
+								} else {
+									remainingModules.push(module);
 								}
 							}
 
@@ -417,6 +456,7 @@ class HotModuleReplacementPlugin {
 							let newRuntimeModules;
 							let newFullHashModules;
 							let newRuntime;
+							let removedFromRuntime;
 							const currentChunk = find(
 								compilation.chunks,
 								chunk => `${chunk.id}` === key
@@ -438,18 +478,61 @@ class HotModuleReplacementPlugin {
 									Array.from(fullHashModules).filter(module =>
 										updatedModules.has(module, currentChunk)
 									);
+								removedFromRuntime = subtractRuntime(oldRuntime, newRuntime);
 							} else {
+								// chunk has completely removed
 								chunkId = `${+key}` === key ? +key : key;
-								hotUpdateMainContent.r.push(chunkId);
-								const runtime = keyToRuntime(records.chunkRuntime[key]);
-								for (const id of records.chunkModuleIds[key]) {
-									const module = allModules.get(id);
-									if (!module) continue;
-									const hash = chunkGraph.getModuleHash(module, runtime);
+								removedFromRuntime = oldRuntime;
+								newRuntime = oldRuntime;
+							}
+							if (removedFromRuntime) {
+								// chunk was removed from some runtimes
+								forEachRuntime(removedFromRuntime, runtime => {
+									hotUpdateMainContentByRuntime
+										.get(runtime)
+										.removedChunkIds.add(chunkId);
+								});
+								// dispose modules from the chunk in these runtimes
+								// where they are no longer in this runtime
+								for (const module of remainingModules) {
 									const moduleKey = `${key}|${module.identifier()}`;
-									if (hash !== records.chunkModuleHashes[moduleKey]) {
-										newModules = newModules || [];
-										newModules.push(module);
+									const oldHash = records.chunkModuleHashes[moduleKey];
+									const runtimes = chunkGraph.getModuleRuntimes(module);
+									if (oldRuntime === newRuntime && runtimes.has(newRuntime)) {
+										// Module is still in the same runtime combination
+										const hash = chunkGraph.getModuleHash(module, newRuntime);
+										if (hash !== oldHash) {
+											if (module.type === "runtime") {
+												newRuntimeModules = newRuntimeModules || [];
+												newRuntimeModules.push(
+													/** @type {RuntimeModule} */ (module)
+												);
+											} else {
+												newModules = newModules || [];
+												newModules.push(module);
+											}
+										}
+									} else {
+										// module is no longer in this runtime combination
+										// We (incorrectly) assume that it's not in an overlapping runtime combination
+										// and dispose it from the main runtimes the chunk was removed from
+										forEachRuntime(removedFromRuntime, runtime => {
+											// If the module is still used in this runtime, do not dispose it
+											// This could create a bad runtime state where the module is still loaded,
+											// but no chunk which contains it. This means we don't receive further HMR updates
+											// to this module and that's bad.
+											// TODO force load one of the chunks which contains the module
+											for (const moduleRuntime of runtimes) {
+												if (typeof moduleRuntime === "string") {
+													if (moduleRuntime === runtime) return;
+												} else if (moduleRuntime !== undefined) {
+													if (moduleRuntime.has(runtime)) return;
+												}
+											}
+											hotUpdateMainContentByRuntime
+												.get(runtime)
+												.removedModules.add(module);
+										});
 									}
 								}
 							}
@@ -516,24 +599,75 @@ class HotModuleReplacementPlugin {
 										compilation.hooks.chunkAsset.call(currentChunk, filename);
 									}
 								}
-								hotUpdateMainContent.c.push(chunkId);
+								forEachRuntime(newRuntime, runtime => {
+									hotUpdateMainContentByRuntime
+										.get(runtime)
+										.updatedChunkIds.add(chunkId);
+								});
 							}
 						}
-						hotUpdateMainContent.m = Array.from(allRemovedModules);
-						const source = new RawSource(JSON.stringify(hotUpdateMainContent));
-						const {
-							path: filename,
-							info: assetInfo
-						} = compilation.getPathWithInfo(
-							compilation.outputOptions.hotUpdateMainFilename,
-							{
-								hash: records.hash
-							}
+						const completelyRemovedModulesArray = Array.from(
+							completelyRemovedModules
 						);
-						compilation.emitAsset(filename, source, {
-							hotModuleReplacement: true,
-							...assetInfo
-						});
+						const hotUpdateMainContentByFilename = new Map();
+						for (const {
+							removedChunkIds,
+							removedModules,
+							updatedChunkIds,
+							filename,
+							assetInfo
+						} of hotUpdateMainContentByRuntime.values()) {
+							const old = hotUpdateMainContentByFilename.get(filename);
+							if (
+								old &&
+								(!isSubset(old.removedChunkIds, removedChunkIds) ||
+									!isSubset(old.removedModules, removedModules) ||
+									!isSubset(old.updatedChunkIds, updatedChunkIds))
+							) {
+								compilation.warnings.push(
+									new WebpackError(`HotModuleReplacementPlugin
+The configured output.hotUpdateMainFilename doesn't lead to unique filenames per runtime and HMR update differs between runtimes.
+This might lead to incorrect runtime behavior of the applied update.
+To fix this, make sure to include [runtime] in the output.hotUpdateMainFilename option, or use the default config.`)
+								);
+								for (const chunkId of removedChunkIds)
+									old.removedChunkIds.add(chunkId);
+								for (const chunkId of removedModules)
+									old.removedModules.add(chunkId);
+								for (const chunkId of updatedChunkIds)
+									old.updatedChunkIds.add(chunkId);
+								continue;
+							}
+							hotUpdateMainContentByFilename.set(filename, {
+								removedChunkIds,
+								removedModules,
+								updatedChunkIds,
+								assetInfo
+							});
+						}
+						for (const [
+							filename,
+							{ removedChunkIds, removedModules, updatedChunkIds, assetInfo }
+						] of hotUpdateMainContentByFilename) {
+							const hotUpdateMainJson = {
+								c: Array.from(updatedChunkIds),
+								r: Array.from(removedChunkIds),
+								m:
+									removedModules.size === 0
+										? completelyRemovedModulesArray
+										: completelyRemovedModulesArray.concat(
+												Array.from(removedModules, m =>
+													chunkGraph.getModuleId(m)
+												)
+										  )
+							};
+
+							const source = new RawSource(JSON.stringify(hotUpdateMainJson));
+							compilation.emitAsset(filename, source, {
+								hotModuleReplacement: true,
+								...assetInfo
+							});
+						}
 					}
 				);
 

package/lib/NormalModule.js

@@ -26,6 +26,7 @@ const ModuleWarning = require("./ModuleWarning");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const UnhandledSchemeError = require("./UnhandledSchemeError");
 const WebpackError = require("./WebpackError");
+const formatLocation = require("./formatLocation");
 const LazySet = require("./util/LazySet");
 const { getScheme } = require("./util/URLAbsoluteSpecifier");
 const {
@@ -42,7 +43,6 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./Generator")} Generator */
@@ -249,6 +249,7 @@ class NormalModule extends Module {
 		this._lastSuccessfulBuildMeta = {};
 		this._forceBuild = true;
 		this._isEvaluatingSideEffects = false;
+		this._addedSideEffectsBailout = new WeakSet();
 	}
 
 	/**
@@ -878,6 +879,17 @@ class NormalModule extends Module {
 			for (const dep of this.dependencies) {
 				const state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
 				if (state === true) {
+					if (!this._addedSideEffectsBailout.has(moduleGraph)) {
+						this._addedSideEffectsBailout.add(moduleGraph);
+						moduleGraph
+							.getOptimizationBailout(this)
+							.push(
+								() =>
+									`Dependency (${
+										dep.type
+									}) with side effects at ${formatLocation(dep.loc)}`
+							);
+					}
 					this._isEvaluatingSideEffects = false;
 					return true;
 				} else if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {

package/lib/RuntimeTemplate.js

@@ -17,7 +17,6 @@ const { forEachRuntime, subtractRuntime } = require("./util/runtime");
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./InitFragment")} InitFragment */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./RequestShortener")} RequestShortener */
@@ -607,8 +606,6 @@ class RuntimeTemplate {
 	 * @param {string} options.importVar name of the import variable
 	 * @param {Module} options.originModule module in which the statement is emitted
 	 * @param {boolean=} options.weak true, if this is a weak dependency
-	 * @param {RuntimeSpec=} options.runtime runtime for which this code will be generated
-	 * @param {RuntimeSpec | boolean=} options.runtimeCondition only execute the statement in some runtimes
 	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
 	 * @returns {[string, string]} the import statement and the compat statement
 	 */

package/lib/SourceMapDevToolPlugin.js

@@ -162,7 +162,8 @@ class SourceMapDevToolPlugin {
 			compilation.hooks.processAssets.tapAsync(
 				{
 					name: "SourceMapDevToolPlugin",
-					stage: Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING
+					stage: Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING,
+					additionalAssets: true
 				},
 				(assets, callback) => {
 					const chunkGraph = compilation.chunkGraph;

package/lib/Template.js

@@ -7,7 +7,6 @@
 
 const { ConcatSource, PrefixSource } = require("webpack-sources");
 
-/** @typedef {import("webpack-sources").ConcatSource} ConcatSource */
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
 /** @typedef {import("./Chunk")} Chunk */

package/lib/TemplatedPathPlugin.js

@@ -274,6 +274,14 @@ const replacePathVariables = (path, data, assetInfo) => {
 	if (data.url) {
 		replacements.set("url", replacer(data.url));
 	}
+	if (typeof data.runtime === "string") {
+		replacements.set(
+			"runtime",
+			replacer(() => prepareId(data.runtime))
+		);
+	} else {
+		replacements.set("runtime", replacer("_"));
+	}
 
 	if (typeof path === "function") {
 		path = path(data, assetInfo);

package/lib/Watching.js

@@ -10,7 +10,6 @@ const Stats = require("./Stats");
 /** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Stats")} Stats */
 
 /**
  * @template T

package/lib/cache/ResolverCachePlugin.js

@@ -13,7 +13,6 @@ const makeSerializable = require("../util/makeSerializable");
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../FileSystemInfo")} FileSystemInfo */
 /** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
-/** @template T @typedef {import("../util/LazySet")<T>} LazySet<T> */
 
 class CacheEntry {
 	constructor(result, snapshot) {