@depup/webpack 5.110.1-depup.0 → 5.111.1-depup.0

package/lib/util/hash/wasm-hash.js

@@ -7,10 +7,9 @@
 
 const Hash = require("../Hash");
 
-// 65536 is the size of a wasm memory page
-// 64 is the maximum chunk size for every possible wasm hash implementation
-// 4 is the maximum number of bytes per char for string encoding (max is utf-8)
-// ~3 makes sure that it's always a block of 4 chars, so avoid partially encoded bytes for base64
+// 65536 is a wasm memory page, 64 the largest chunk size any wasm hash
+// implementation takes, 4 the most bytes utf-8 spends on one char, and `& ~3`
+// keeps it a whole block of 4 chars so base64 never sees a partial encoding.
 const MAX_SHORT_STRING = Math.floor((65536 - 64) / 4) & ~3;
 
 /**

package/lib/util/identifier.js

@@ -5,6 +5,7 @@
 "use strict";
 
 const path = require("path");
+const { fileURLToPath } = require("url");
 
 // Any absolute path: POSIX (/foo) and every Windows form — drive-letter (C:\,
 // C:/), UNC (\\, //), rooted (\, /); equals posix||win32 isAbsolute.
@@ -15,6 +16,23 @@ const WINDOWS_ABS_PATH_REGEXP = /^[a-z]:[\\/]/i;
 const SEGMENTS_SPLIT_REGEXP = /([|!])/;
 const WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g;
 const NODE_MODULES_REGEXP = /[\\/]node_modules[\\/]/i;
+// A file URL, the form `import.meta.resolve()` returns a local module in.
+// One slash after the scheme is enough, as Node's own URL parser needs.
+const FILE_URL_REGEXP = /^file:\//i;
+// What `import()` resolves as a place rather than as a package name: relative,
+// rooted, or carrying a scheme.
+const RESOLVABLE_SPECIFIER_REGEXP = /^(?:\.{0,2}\/|[a-zA-Z][\w+.-]*:)/;
+
+/**
+ * Converts a file URL to the path it names. Any other value is returned
+ * unchanged, so this is safe to apply to an option that also takes a path.
+ * @param {string} pathOrUrl an absolute path or a file URL
+ * @returns {string} an absolute path
+ */
+const fileUrlToPath = (pathOrUrl) => {
+	if (!FILE_URL_REGEXP.test(pathOrUrl)) return pathOrUrl;
+	return fileURLToPath(pathOrUrl);
+};
 
 /**
  * Relative path to request.
@@ -568,12 +586,14 @@ const toJsStringLiteral = (str) =>
 
 module.exports.ABSOLUTE_PATH_REGEXP = ABSOLUTE_PATH_REGEXP;
 module.exports.NODE_MODULES_REGEXP = NODE_MODULES_REGEXP;
+module.exports.RESOLVABLE_SPECIFIER_REGEXP = RESOLVABLE_SPECIFIER_REGEXP;
 module.exports.WINDOWS_ABS_PATH_REGEXP = WINDOWS_ABS_PATH_REGEXP;
 module.exports.WINDOWS_PATH_SEPARATOR_REGEXP = WINDOWS_PATH_SEPARATOR_REGEXP;
 module.exports.absolutify = absolutify;
 module.exports.contextify = contextify;
 module.exports.contextifySourceUrl = contextifySourceUrl;
 module.exports.escapeHashInPathRequest = escapeHashInPathRequest;
+module.exports.fileUrlToPath = fileUrlToPath;
 module.exports.getUndoPath = getUndoPath;
 module.exports.makeCacheable = makeCacheable;
 module.exports.makePathsAbsolute = makeCacheableWithContext(_makePathsAbsolute);

package/lib/util/internalSerializables.js

@@ -31,6 +31,7 @@ module.exports = {
 	"container/RemoteModule": () => require("../container/RemoteModule"),
 	"container/RemoteToExternalDependency": () =>
 		require("../container/RemoteToExternalDependency"),
+	"context/ContextModule": () => require("../context/ContextModule"),
 	"dependencies/AMDDefineDependency": () =>
 		require("../dependencies/AMDDefineDependency"),
 	"dependencies/AMDRequireArrayDependency": () =>
@@ -113,6 +114,8 @@ module.exports = {
 		require("../dependencies/HarmonyExportImportedSpecifierDependency"),
 	"dependencies/HarmonyExportSpecifierDependency": () =>
 		require("../dependencies/HarmonyExportSpecifierDependency"),
+	"dependencies/HarmonyImportBareSideEffectDependency": () =>
+		require("../dependencies/HarmonyImportBareSideEffectDependency"),
 	"dependencies/HarmonyImportSideEffectDependency": () =>
 		require("../dependencies/HarmonyImportSideEffectDependency"),
 	"dependencies/HarmonyImportSpecifierDependency": () =>
@@ -141,6 +144,8 @@ module.exports = {
 		require("../dependencies/ImportMetaHotAcceptDependency"),
 	"dependencies/ImportMetaHotDeclineDependency": () =>
 		require("../dependencies/ImportMetaHotDeclineDependency"),
+	"dependencies/ImportMetaMainDependency": () =>
+		require("../dependencies/ImportMetaMainDependency"),
 	"dependencies/ImportMetaResolveDependency": () =>
 		require("../dependencies/ImportMetaResolveDependency"),
 	"dependencies/ImportWeakDependency": () =>
@@ -211,6 +216,8 @@ module.exports = {
 	"errors/EnvironmentNotSupportAsyncWarning": () =>
 		require("../errors/EnvironmentNotSupportAsyncWarning"),
 	"errors/HookWebpackError": () => require("../errors/HookWebpackError"),
+	"errors/ImportedBindingAssignmentError": () =>
+		require("../errors/ImportedBindingAssignmentError"),
 	"errors/InvalidDependenciesModuleWarning": () =>
 		require("../errors/InvalidDependenciesModuleWarning"),
 	"errors/JSONParseError": () => require("../errors/JSONParseError"),
@@ -255,7 +262,6 @@ module.exports = {
 	"wasm-async/AsyncWasmModule": () => require("../wasm-async/AsyncWasmModule"),
 	"wasm-sync/SyncWasmModule": () => require("../wasm-sync/SyncWasmModule"),
 	AsyncDependenciesBlock: () => require("../AsyncDependenciesBlock"),
-	ContextModule: () => require("../ContextModule"),
 	CssModule: () => require("../css/CssModule"),
 	DependenciesBlock: () => require("../DependenciesBlock"),
 	ExternalModule: () => require("../ExternalModule"),

package/lib/util/registerExternalSerializer.js

@@ -5,8 +5,6 @@
 
 "use strict";
 
-const Position = require("acorn").Position;
-const SourceLocation = require("acorn").SourceLocation;
 const ValidationError = require("schema-utils").ValidationError;
 const {
 	CachedSource,
@@ -17,9 +15,10 @@ const {
 	ReplaceSource,
 	SourceMapSource
 } = require("webpack-sources");
+const ParserPosition = require("../javascript/syntax").ParserPosition;
 const { register } = require("./serialization");
 
-/** @import { RealDependencyLocation, SourcePosition } from "../Dependency" */
+/** @import { SourcePosition } from "../Dependency" */
 /**
  * @import {
  * 	ObjectDeserializerContext,
@@ -229,51 +228,13 @@ register(
 );
 
 register(
-	SourceLocation,
+	ParserPosition,
 	CURRENT_MODULE,
-	"acorn/SourceLocation",
-	new (class SourceLocationSerializer {
+	"webpack/ParserPosition",
+	new (class ParserPositionSerializer {
 		/**
 		 * Serializes this instance into the provided serializer context.
-		 * @param {SourceLocation} loc the location to be serialized
-		 * @param {import("../serialization/ObjectMiddleware").ObjectSerializerContext<number[]>} context context
-		 * @returns {void}
-		 */
-		serialize(loc, { write }) {
-			write(loc.start.line);
-			write(loc.start.column);
-			write(loc.end.line);
-			write(loc.end.column);
-		}
-
-		/**
-		 * Restores this instance from the provided deserializer context.
-		 * @param {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<number[]>} context context
-		 * @returns {RealDependencyLocation} location
-		 */
-		deserialize({ read }) {
-			return {
-				start: {
-					line: read(),
-					column: read()
-				},
-				end: {
-					line: read(),
-					column: read()
-				}
-			};
-		}
-	})()
-);
-
-register(
-	Position,
-	CURRENT_MODULE,
-	"acorn/Position",
-	new (class PositionSerializer {
-		/**
-		 * Serializes this instance into the provided serializer context.
-		 * @param {Position} pos the position to be serialized
+		 * @param {ParserPosition} pos the position to be serialized
 		 * @param {import("../serialization/ObjectMiddleware").ObjectSerializerContext<number[]>} context context
 		 * @returns {void}
 		 */

package/lib/util/removeBOM.js

@@ -5,12 +5,17 @@
 
 "use strict";
 
+const { decodeVLQ, encodeVLQ } = require("./createMappings");
+
+/** @import { RawSourceMap } from "webpack-sources" */
+/** @import { Result } from "../NormalModule" */
+
 /**
  * Returns result without BOM.
  * @param {string | Buffer} strOrBuffer string or buffer
  * @returns {string | Buffer} result without BOM
  */
-module.exports = (strOrBuffer) => {
+const removeBOM = (strOrBuffer) => {
 	if (typeof strOrBuffer === "string" && strOrBuffer.charCodeAt(0) === 0xfeff) {
 		return strOrBuffer.slice(1);
 	} else if (
@@ -24,3 +29,79 @@ module.exports = (strOrBuffer) => {
 
 	return strOrBuffer;
 };
+
+/**
+ * A BOM occupies generated column 0 of the first line, so a map describing
+ * BOM-prefixed content starts that line at column 1 or later. Removing the BOM
+ * moves the line one column left; the segments after the first are encoded
+ * relative to it, so only the first is rewritten. A map already starting at
+ * column 0 describes the content without its BOM and is left alone.
+ * @param {string} mappings VLQ encoded `mappings` of a map for BOM-prefixed content
+ * @returns {string} `mappings` for the same content without its BOM
+ */
+const shiftMappings = (mappings) => {
+	const { value, end } = decodeVLQ(mappings, 0);
+	if (end === 0 || value <= 0) return mappings;
+	return encodeVLQ(value - 1) + mappings.slice(end);
+};
+
+/**
+ * Adjust a source map that accompanied BOM-prefixed content for the removal of
+ * that BOM. Anything without VLQ `mappings` is passed through untouched, as is
+ * a map declaring a version other than 3 — earlier versions spell `mappings`
+ * differently. A map that declares no version at all is taken as version 3.
+ * @param {(string | RawSourceMap)=} sourceMap the map, as an object or as JSON
+ * @returns {(string | RawSourceMap)=} the adjusted map
+ */
+const adjustSourceMapForRemovedBOM = (sourceMap) => {
+	if (!sourceMap) return sourceMap;
+
+	if (typeof sourceMap === "string") {
+		/** @type {RawSourceMap} */
+		let parsed;
+		try {
+			parsed = JSON.parse(sourceMap);
+		} catch (_err) {
+			return sourceMap;
+		}
+		const adjusted = adjustSourceMapForRemovedBOM(parsed);
+		return adjusted === parsed ? sourceMap : JSON.stringify(adjusted);
+	}
+
+	if (sourceMap.version !== undefined && sourceMap.version !== 3) {
+		return sourceMap;
+	}
+
+	if (typeof sourceMap.mappings !== "string") return sourceMap;
+
+	const mappings = shiftMappings(sourceMap.mappings);
+
+	return mappings === sourceMap.mappings
+		? sourceMap
+		: { ...sourceMap, mappings };
+};
+
+/**
+ * @param {Result} result a loader result: content, an optional source map, extra info
+ * @returns {Result} the result with a leading BOM removed from its content and its source map kept in sync
+ */
+const removeBOMFromResult = (result) => {
+	const content = result[0];
+	const withoutBOM = removeBOM(content);
+
+	if (withoutBOM === content) return result;
+
+	// Copied rather than rebuilt, so a result carrying no source map keeps its
+	// arity.
+	const adjusted = /** @type {Result} */ ([...result]);
+
+	adjusted[0] = withoutBOM;
+
+	if (adjusted[1]) adjusted[1] = adjustSourceMapForRemovedBOM(adjusted[1]);
+
+	return adjusted;
+};
+
+module.exports.adjustSourceMapForRemovedBOM = adjustSourceMapForRemovedBOM;
+module.exports.removeBOM = removeBOM;
+module.exports.removeBOMFromResult = removeBOMFromResult;

package/lib/util/semver.js

@@ -63,6 +63,7 @@ const versionLt = (a, b) => {
 	b = parseVersion(b);
 	var i = 0;
 	for (;;) {
+		// WHY: the ordering this loop implements, by the type of each side.
 		// a       b  EOA     object  undefined  number  string
 		// EOA        a == b  a < b   b < a      a < b   a < b
 		// object     b < a   (0)     b < a      a < b   a < b
@@ -185,6 +186,7 @@ module.exports.parseRange = (str) => {
 	 * @returns {SemVerRange}
 	 */
 	const parseSimple = (str) => {
+		// WHY: the grammar this parses.
 		// simple       ::= primitive | partial | tilde | caret
 		// primitive    ::= ( '<' | '>' | '>=' | '<=' | '=' | '!' ) ( ' ' ) * partial
 		// tilde        ::= '~' ( ' ' ) * partial
@@ -399,7 +401,7 @@ const satisfy = (range, version) => {
 		for (var i = 0, j = 1, isEqual = true; ; j++, i++) {
 			// cspell:word nequal nequ
 
-			// when isEqual = true:
+			// WHY: the decision table this loop implements, when isEqual = true:
 			// range         version: EOA/object  undefined  number    string
 			// EOA                    equal       block      big-ver   big-ver
 			// undefined              bigger      next       big-ver   big-ver
@@ -408,7 +410,7 @@ const satisfy = (range, version) => {
 			// string                 smaller     block      differ    cmp
 			// fixed string           smaller     block      small-cmp cmp-fix
 
-			// when isEqual = false:
+			// WHY: and when isEqual = false:
 			// range         version: EOA/object  undefined  number    string
 			// EOA                    nequal      block      next-ver  next-ver
 			// undefined              nequal      block      next-ver  next-ver
@@ -417,7 +419,7 @@ const satisfy = (range, version) => {
 			// string                 nequal      block      next      next
 			// fixed string           nequal      block      next      next   (this never happens)
 
-			// EOA end of array
+			// WHY: EOA is end of array; what each cell of the two tables means:
 			// equal (version is equal range):
 			//   when !negated: return true,
 			//   when negated: return false

package/lib/wasm-async/AsyncWasmCompileRuntimeModule.js

@@ -11,11 +11,12 @@ const Template = require("../Template");
 const { fullHashPathData } = require("../wasm/wasmModuleFilename");
 
 /** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
 /** @import Compilation from "../Compilation" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 
 /** @typedef {(wasmModuleSrcPath: string) => string} GenerateBeforeLoadBinaryCode */
-/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec) => string} GenerateLoadBinaryCode */
+/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec, analyzable: boolean) => string} GenerateLoadBinaryCode */
 /** @typedef {() => string} GenerateBeforeCompileStreaming */
 
 /**
@@ -55,6 +56,15 @@ class AsyncWasmCompileRuntimeModule extends RuntimeModule {
 		this.supportsStreaming = supportsStreaming;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
@@ -69,7 +79,7 @@ class AsyncWasmCompileRuntimeModule extends RuntimeModule {
 		// Analyzable output bakes the binary's URL into the call site instead.
 		const analyzable = runtimeTemplate.supportsAnalyzable(
 			"wasm",
-			undefined,
+			/** @type {ChunkGraph} */ (this.chunkGraph),
 			undefined,
 			chunk.runtime
 		);
@@ -92,7 +102,8 @@ class AsyncWasmCompileRuntimeModule extends RuntimeModule {
 
 		const loader = this.generateLoadBinaryCode(
 			wasmModuleSrcPath,
-			chunk.runtime
+			chunk.runtime,
+			analyzable
 		);
 
 		// Fallback path: fetch -> arrayBuffer -> WebAssembly.compile

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -11,11 +11,12 @@ const Template = require("../Template");
 const { fullHashPathData } = require("../wasm/wasmModuleFilename");
 
 /** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
 /** @import Compilation from "../Compilation" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 
 /** @typedef {(wasmModuleSrcPath: string) => string} GenerateBeforeLoadBinaryCode */
-/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec) => string} GenerateLoadBinaryCode */
+/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec, analyzable: boolean) => string} GenerateLoadBinaryCode */
 /** @typedef {() => string} GenerateBeforeInstantiateStreaming */
 
 /**
@@ -56,6 +57,15 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 		this.supportsStreaming = supportsStreaming;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
@@ -70,7 +80,7 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 		// Analyzable output bakes the binary's URL into the call site instead.
 		const analyzable = runtimeTemplate.supportsAnalyzable(
 			"wasm",
-			undefined,
+			/** @type {ChunkGraph} */ (this.chunkGraph),
 			undefined,
 			chunk.runtime
 		);
@@ -93,7 +103,8 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 
 		const loader = this.generateLoadBinaryCode(
 			wasmModuleSrcPath,
-			chunk.runtime
+			chunk.runtime,
+			analyzable
 		);
 		const fallback = [
 			`.then(${runtimeTemplate.returningFunction("x.arrayBuffer()", "x")})`,

package/lib/wasm-async/AsyncWebAssemblyGenerator.js

@@ -72,7 +72,12 @@ class AsyncWebAssemblyGenerator extends Generator {
 	 * @returns {Source | null} generated code
 	 */
 	generateError(error, module, generateContext) {
-		return new RawSource(error.message);
+		return new RawSource(
+			Generator.buildErrorMessage(
+				error,
+				generateContext.runtimeTemplate.requestShortener
+			)
+		);
 	}
 }
 

package/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js

@@ -303,7 +303,11 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 	 */
 	generateError(error, module, generateContext) {
 		return new RawSource(
-			Generator.throwBuildErrorCode(error, "WebAssembly.CompileError")
+			Generator.throwBuildErrorCode(
+				error,
+				"WebAssembly.CompileError",
+				generateContext.runtimeTemplate.requestShortener
+			)
 		);
 	}
 }

package/lib/wasm-async/UniversalCompileAsyncWasmPlugin.js

@@ -67,31 +67,26 @@ class UniversalCompileAsyncWasmPlugin {
 			// per call: it depends on parse results, so it is not settled while the plugin
 			// is being applied.
 			/**
-			 * @param {RuntimeSpec} runtime the runtime this loader serves
+			 * @param {boolean} analyzable whether the call site bakes a complete URL
 			 * @returns {string} the argument to hand the reader
 			 */
-			const wasmUrlArg = (runtime) =>
-				compilation.runtimeTemplate.supportsAnalyzable(
-					"wasm",
-					undefined,
-					undefined,
-					runtime
-				)
+			const wasmUrlArg = (analyzable) =>
+				analyzable
 					? "wasmUrl"
 					: compilation.runtimeTemplate.importMetaUrl("wasmUrl");
 			/**
 			 * Generates the runtime expression that fetches the binary in browsers
 			 * or reads it from the filesystem in Node.js.
-			 * @type {(path: string, runtime: RuntimeSpec) => string}
+			 * @type {(path: string, runtime: RuntimeSpec, analyzable: boolean) => string}
 			 */
-			const generateLoadBinaryCode = (path, runtime) =>
+			const generateLoadBinaryCode = (path, runtime, analyzable) =>
 				Template.asString([
 					"(useFetch",
-					Template.indent([`? fetch(${wasmUrlArg(runtime)})`]),
+					Template.indent([`? fetch(${wasmUrlArg(analyzable)})`]),
 					Template.indent([
 						": Promise.all([import('fs'), import('url')]).then(([{ readFile }, { URL }]) => new Promise((resolve, reject) => {",
 						Template.indent([
-							`readFile(${wasmUrlArg(runtime)}, (err, buffer) => {`,
+							`readFile(${wasmUrlArg(analyzable)}, (err, buffer) => {`,
 							Template.indent([
 								"if (err) return reject(err);",
 								"",

package/lib/wasm-sync/WasmChunkLoadingRuntimeModule.js

@@ -254,6 +254,15 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 		this._runtimeRequirements = runtimeRequirements;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return [[RuntimeGlobals.ensureChunkHandlers, "wasm"]];
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
@@ -330,10 +339,9 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 				stateExpression ? runtimeTemplate.assignOr(stateExpression, "{}") : "{}"
 			};`,
 			"",
-			// This function is used to delay reading the installed wasm module promises
-			// by a microtask. Sorting them doesn't help because there are edge cases where
-			// sorting is not possible (modules splitted into different chunks).
-			// So we not even trying and solve this by a microtask delay.
+			// Delays reading the installed wasm module promises by a microtask.
+			// Sorting them instead is not always possible — modules split across
+			// chunks have no order — so the delay is what is relied on.
 			"function promiseResolve() { return Promise.resolve(); }",
 			"",
 			Template.asString(declarations),

package/lib/wasm-sync/WebAssemblyGenerator.js

@@ -544,7 +544,12 @@ class WebAssemblyGenerator extends Generator {
 	 * @returns {Source | null} generated code
 	 */
 	generateError(error, module, generateContext) {
-		return new RawSource(error.message);
+		return new RawSource(
+			Generator.buildErrorMessage(
+				error,
+				generateContext.runtimeTemplate.requestShortener
+			)
+		);
 	}
 
 	/**

package/lib/wasm-sync/WebAssemblyJavascriptGenerator.js

@@ -232,7 +232,11 @@ class WebAssemblyJavascriptGenerator extends Generator {
 	 */
 	generateError(error, module, generateContext) {
 		return new RawSource(
-			Generator.throwBuildErrorCode(error, "WebAssembly.CompileError")
+			Generator.throwBuildErrorCode(
+				error,
+				"WebAssembly.CompileError",
+				generateContext.runtimeTemplate.requestShortener
+			)
 		);
 	}
 }

package/lib/wasm-sync/WebAssemblyUtils.js

@@ -42,10 +42,8 @@ const getUsedDependencies = (moduleGraph, module, mangle) => {
 			}
 
 			const exportName = dep.name;
-			// TODO add the following 3 lines when removing of ModuleExport is possible
-			// const importedModule = moduleGraph.getModule(dep);
-			// const usedName = importedModule && moduleGraph.getExportsInfo(importedModule).getUsedName(exportName, runtime);
-			// if (usedName !== false) {
+			// TODO once ModuleExport can be removed, skip a dependency whose
+			// imported module reports `getUsedName(exportName, runtime) === false`.
 			if (mangle) {
 				array.push({
 					dependency: dep,

package/lib/web/FetchCompileAsyncWasmPlugin.js

@@ -91,12 +91,14 @@ class FetchCompileAsyncWasmPlugin {
 					}
 					const baked = compilation.runtimeTemplate.supportsAnalyzable(
 						"wasm",
-						undefined,
+						chunkGraph,
 						undefined,
 						chunk.runtime
 					);
-					const analyzable =
-						compilation.runtimeTemplate.supportsAnalyzable("wasm-relative");
+					const analyzable = compilation.runtimeTemplate.supportsAnalyzable(
+						"wasm-relative",
+						chunkGraph
+					);
 					// A baked URL carries the public path already, and a settled one is written
 					// out below; only a path nothing but the global knows asks for it.
 					const constant =
@@ -151,12 +153,14 @@ class FetchCompileAsyncWasmPlugin {
 					}
 					const baked = compilation.runtimeTemplate.supportsAnalyzable(
 						"wasm",
-						undefined,
+						chunkGraph,
 						undefined,
 						chunk.runtime
 					);
-					const analyzable =
-						compilation.runtimeTemplate.supportsAnalyzable("wasm-relative");
+					const analyzable = compilation.runtimeTemplate.supportsAnalyzable(
+						"wasm-relative",
+						chunkGraph
+					);
 					// A baked URL carries the public path already, and a settled one is written
 					// out below; only a path nothing but the global knows asks for it.
 					const constant =

package/lib/web/FetchCompileWasmPlugin.js

@@ -99,8 +99,10 @@ class FetchCompileWasmPlugin {
 						return;
 					}
 					set.add(RuntimeGlobals.moduleCache);
-					const analyzable =
-						compilation.runtimeTemplate.supportsAnalyzable("wasm-relative");
+					const analyzable = compilation.runtimeTemplate.supportsAnalyzable(
+						"wasm-relative",
+						chunkGraph
+					);
 					const constant = analyzable
 						? undefined
 						: compilation.runtimeTemplate.constantPublicPath();

package/lib/web/JsonpChunkLoadingRuntimeModule.js

@@ -38,6 +38,42 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 		this._runtimeRequirements = runtimeRequirements;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const runtimeRequirements = this._runtimeRequirements;
+		/** @type {[string, string][]} */
+		const handlers = [];
+		if (runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)) {
+			handlers.push([RuntimeGlobals.ensureChunkHandlers, "j"]);
+		}
+		// The hot update flow installs this one onto the same map while it runs.
+		if (runtimeRequirements.has(RuntimeGlobals.hmrDownloadUpdateHandlers)) {
+			handlers.push([RuntimeGlobals.ensureChunkHandlers, "jsonpHmr"]);
+		}
+		if (
+			runtimeRequirements.has(RuntimeGlobals.prefetchChunkHandlers) &&
+			chunk.hasChildByOrder(chunkGraph, "prefetch", true, chunkHasJs)
+		) {
+			handlers.push([RuntimeGlobals.prefetchChunkHandlers, "j"]);
+		}
+		if (
+			runtimeRequirements.has(RuntimeGlobals.preloadChunkHandlers) &&
+			chunk.hasChildByOrder(chunkGraph, "preload", true, chunkHasJs)
+		) {
+			handlers.push([RuntimeGlobals.preloadChunkHandlers, "j"]);
+		}
+		if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
+			handlers.push([RuntimeGlobals.onChunksLoaded, "j"]);
+		}
+		return handlers;
+	}
+
 	/**
 	 * @private
 	 * @param {Chunk} chunk chunk