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

package/lib/util/chainedImports.js

@@ -39,10 +39,9 @@ module.exports.getTrimmedIdsAndRange = (
 	);
 	let trimmedRange = untrimmedRange;
 	if (trimmedIds.length !== untrimmedIds.length) {
-		// The array returned from dep.idRanges is right-aligned with the array returned from dep.names.
-		// Meaning, the two arrays may not always have the same number of elements, but the last element of
-		// dep.idRanges corresponds to [the expression fragment to the left of] the last element of dep.names.
-		// Use this to find the correct replacement range based on the number of ids that were trimmed.
+		// `dep.idRanges` is right-aligned with `dep.names`: the two may differ in
+		// length, but their last elements correspond, which is what turns the count
+		// of trimmed ids into the replacement range.
 		const idx =
 			ranges === undefined
 				? -1 /* trigger failure case below */

package/lib/util/concatenate.js

@@ -324,10 +324,10 @@ const addScopeSymbols = (s, nameSet, scopeSet1, scopeSet2) => {
 	}
 };
 
-// Declared by the chunk bootstrap in the scope module code is hoisted into.
-// Hit when a webpack bundle is bundled again, since its output declares exactly
-// these: the `const` one then fails to parse, the `var` one silently clobbers
-// the module table. CompatibilityPlugin renames the other two runtime names.
+// WHY: Declared by the chunk bootstrap in the scope module code is hoisted
+// into, so re-bundling a webpack bundle collides with them: the `const` one
+// fails to parse and the `var` one silently clobbers the module table.
+// CompatibilityPlugin renames the other two runtime names.
 const CHUNK_RUNTIME_DECLARATIONS = new Set([
 	"__webpack_modules__",
 	"__webpack_module_cache__"

package/lib/util/createHooksRegistry.js

@@ -15,8 +15,7 @@ const createHooksRegistry = (createHooks) => {
 	return (compilation) => {
 		let hooks = map.get(compilation);
 		if (hooks === undefined) {
-			// validated once per compilation — this runs on every render and
-			// codegen. Matched by class name, not `instanceof`: a compilation from
+			// Matched by class name rather than `instanceof`: a compilation from
 			// another webpack copy has to pass too, and importing `Compilation`
 			// here cycles.
 			const candidate =

package/lib/util/dataURL.js

@@ -44,9 +44,8 @@ const decodeDataURI = (uri) => {
  */
 
 // `URIRegEx`'s `.` stops at a newline, which a raw `<svg>` payload carries, and
-// its `base64` group is optional in a way that reads `;charset=utf8` as one.
-// This one is the strict split a rewriter needs; that one stays as the matcher
-// module requests are recognized by.
+// its optional `base64` group reads `;charset=utf8` as one. This is the strict
+// split a rewriter needs; that one stays as the matcher for module requests.
 const STRICT_URI_REGEXP = /^data:([^,;]*)((?:;[^,;]*)*),([\s\S]*)$/i;
 
 const JSON_TYPE = "json";

package/lib/util/deterministicGrouping.js

@@ -450,12 +450,11 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 					right--;
 				}
 
+				// WHY: both sides already clear minSize here.
 				//      left v   v right
 				// [ O O O ] O O O [ O O O ]
 				// ^^^^^^^^^ leftSize
 				//       rightSize ^^^^^^^^^
-				// leftSize > minSize
-				// rightSize > minSize
 
 				// Perfect split: [ O O O ] [ O O O ]
 				//                right === left - 1
@@ -476,26 +475,22 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 						queue.push(group);
 						continue;
 					}
-					// can't split group while holding minSize
-					// because minSize is preferred of maxSize we return
-					// the problematic nodes as result here even while it's too big
-					// To avoid this make sure maxSize > minSize * 3
+					// No split holds minSize, which is preferred over maxSize, so these
+					// nodes are returned oversized. Keeping maxSize > minSize * 3
+					// avoids it.
 					result.push(group);
 					continue;
 				}
 				if (left <= right) {
-					// when there is a area between left and right
-					// we look for best split point
-					// we split at the minimum similarity
-					// here key space is separated the most
-					// But we also need to make sure to not create too small groups
+					// In the area between left and right, split at the minimum
+					// similarity, where the key space is separated the most — without
+					// creating groups that are too small.
 					let best = -1;
 					let bestSimilarity = Infinity;
 					let pos = left;
 					const rightSize = sumSize(group.nodes, pos);
 
-					//       pos v   v right
-					// [ O O O ] O O O [ O O O ]
+					// [ O O O ] O O O [ O O O ]   pos, then right
 					// ^^^^^^^^^ leftSize
 					// rightSize ^^^^^^^^^^^^^^^
 

package/lib/util/findGraphRoots.js

@@ -125,12 +125,9 @@ module.exports = (items, getDependencies) => {
 							depSCC.marker = IN_PROGRESS_MARKER;
 							break;
 						case IN_PROGRESS_MARKER: {
-							// Back-edge to an SCC that is still on the stack
-							// Example:
-							//   A -> B -> C -> D
-							//        ^         |
-							//        |_________|
-							// If we are at `D` and traverse `D` -> `B`, then `B/C/D` must be in one SCC
+							// A back-edge to an SCC still on the stack merges every SCC
+							// above it — in `A -> B -> C -> D` with `D -> B`, reaching `B`
+							// from `D` puts `B`, `C` and `D` into one SCC.
 							/** @type {Set<SCC<T>>} */
 							const sccsToMerge = new Set();
 							for (
@@ -162,13 +159,9 @@ module.exports = (items, getDependencies) => {
 					// All dependencies of the current node have been processed
 					// So we leave the node
 					stack.pop();
-					// Mark an SCC as DONE only when the popped node is the last
-					// node from that SCC remaining on the current stack.
-					//   A -> B -> C -> D
-					//        ^         |
-					//        |_________|
-					// If `B` is popped and the new stack top is `A`, they are in
-					// different SCCs, so B's SCC can be finalized.
+					// An SCC is DONE only once the popped node is its last one on
+					// the stack. In `A -> B -> C -> D` with `D -> B`, popping `B` onto a
+					// stack topped by `A` — a different SCC — finalizes B's.
 					if (
 						stack.length &&
 						topOfStack.node.scc !== stack[stack.length - 1].node.scc

package/lib/util/fs.js

@@ -167,7 +167,7 @@ const { ABSOLUTE_PATH_REGEXP } = require("./identifier");
  * @typedef {{
  * (path: PathOrFileDescriptor, options?: { encoding?: null | undefined, flag?: string | undefined } | null): Buffer,
  * (path: PathOrFileDescriptor, options: { encoding: BufferEncoding, flag?: string | undefined } | BufferEncoding): string,
- * (path: PathOrFileDescriptor, options?: (ObjectEncodingOptions & { flag?: string | undefined }) | BufferEncoding | null): string | Buffer,
+ * (path: PathOrFileDescriptor, options: ObjectEncodingOptions & { flag?: string | undefined }): string | Buffer,
  * }} ReadFileSync
  */
 
@@ -402,6 +402,21 @@ const { ABSOLUTE_PATH_REGEXP } = require("./identifier");
  * @typedef {(path: PathLike, options?: BufferEncoding | ReadStreamOptions) => NodeJS.ReadableStream} CreateReadStream
  */
 
+/**
+ * Defines the symlink type used by this module.
+ * @typedef {(target: PathLike, path: PathLike, type: "dir" | "file" | "junction" | null | undefined, callback: NoParamCallback) => void} Symlink
+ */
+
+/**
+ * Defines the chmod type used by this module.
+ * @typedef {(path: PathLike, mode: number | string, callback: NoParamCallback) => void} Chmod
+ */
+
+/**
+ * Defines the utimes type used by this module.
+ * @typedef {(path: PathLike, atime: number | string | Date, mtime: number | string | Date, callback: NoParamCallback) => void} Utimes
+ */
+
 /**
  * Defines the output file system type used by this module.
  * @typedef {object} OutputFileSystem
@@ -410,6 +425,10 @@ const { ABSOLUTE_PATH_REGEXP } = require("./identifier");
  * @property {Rmdir=} rmdir
  * @property {WriteFile} writeFile
  * @property {Unlink=} unlink
+ * @property {Symlink=} symlink
+ * @property {Readlink=} readlink
+ * @property {Chmod=} chmod
+ * @property {Utimes=} utimes
  * @property {Stat} stat
  * @property {LStat=} lstat
  * @property {ReadFile} readFile
@@ -755,6 +774,13 @@ const lstatReadlinkAbsolute = (fs, p, callback) => {
  */
 const isAbsolute = (pathname) => ABSOLUTE_PATH_REGEXP.test(pathname);
 
+/**
+ * What of a file's mode is its permissions — the type bits above them are not
+ * settable, and the set-user-id and sticky bits are not carried over a copy.
+ */
+const PERMISSIONS_MASK = 0o777;
+
+module.exports.PERMISSIONS_MASK = PERMISSIONS_MASK;
 module.exports.dirname = dirname;
 module.exports.isAbsolute = isAbsolute;
 module.exports.join = join;

package/lib/util/globUtils.js

@@ -558,7 +558,7 @@ const braceFreeGlobToPathRegExpSource = (glob) => {
  * pattern built with `path.resolve` works everywhere; use `[*]` to match a
  * literal `*`), and a relative pattern matches at any depth. Matching follows
  * `path.matchesGlob`, except where its minimatch shows through — see the
- * divergences listed above the corpus in `test/globUtils.unittest.js`.
+ * divergences listed above the corpus in `test/unitCases/globUtils.unittest.js`.
  * @param {string} pattern glob pattern
  * @param {GlobMatchOptions=} options options
  * @returns {((str: string) => boolean) | null} matcher, null for un-compilable patterns

package/lib/util/handlerKeys.js

@@ -0,0 +1,40 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+/** @import RuntimeModule from "../RuntimeModule" */
+
+/**
+ * The one key a chunk's runtime modules install on a handler map, or `null` when
+ * they install several, none, or one a module could not name. Every module states
+ * what it installs, so nothing has to be rendered to find out.
+ * @param {RuntimeModule} runtimeModule the runtime module rendering the dispatch
+ * @param {string} handlers the handler map global
+ * @returns {string | null} the sole handler key, or `null`
+ */
+const getOnlyHandlerKey = (runtimeModule, handlers) => {
+	const { chunkGraph, chunk } = runtimeModule;
+	if (chunkGraph === undefined || chunk === undefined) return null;
+	/** @type {string | null} */
+	let only = null;
+	for (const module of chunkGraph.getChunkRuntimeModulesIterable(chunk)) {
+		// TODO webpack 6: call it directly, every runtime module answers by then. A
+		// module built against an older webpack extends a base class without it.
+		const installed =
+			typeof module.getInstalledChunkHandlers === "function"
+				? module.getInstalledChunkHandlers()
+				: null;
+		// A module that cannot name what it installs leaves every map unknowable.
+		if (!Array.isArray(installed)) return null;
+		for (const [map, key] of installed) {
+			if (map !== handlers) continue;
+			if (only !== null && only !== key) return null;
+			only = key;
+		}
+	}
+	return only;
+};
+
+module.exports.getOnlyHandlerKey = getOnlyHandlerKey;

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": () =>
@@ -257,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/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

@@ -56,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

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -57,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

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-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/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