webpack 5.98.0 → 5.99.0

package/lib/dependencies/LoaderPlugin.js

@@ -12,6 +12,7 @@ const LoaderImportDependency = require("./LoaderImportDependency");
 
 /** @typedef {import("../../declarations/LoaderContext").LoaderPluginLoaderContext} LoaderPluginLoaderContext */
 /** @typedef {import("../Compilation").DepConstructor} DepConstructor */
+/** @typedef {import("../Compilation").ExecuteModuleExports} ExecuteModuleExports */
 /** @typedef {import("../Compilation").ExecuteModuleResult} ExecuteModuleResult */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
@@ -20,7 +21,7 @@ const LoaderImportDependency = require("./LoaderImportDependency");
 /**
  * @callback ImportModuleCallback
  * @param {(Error | null)=} err error object
- * @param {any=} exports exports of the evaluated module
+ * @param {ExecuteModuleExports=} exports exports of the evaluated module
  */
 
 /**
@@ -31,11 +32,6 @@ const LoaderImportDependency = require("./LoaderImportDependency");
  */
 
 class LoaderPlugin {
-	/**
-	 * @param {object} options options
-	 */
-	constructor(options = {}) {}
-
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -150,12 +146,7 @@ class LoaderPlugin {
 								for (const d of buildDependencies) {
 									loaderContext.addBuildDependency(d);
 								}
-								return callback(
-									null,
-									source,
-									/** @type {object | null} */ (map),
-									referencedModule
-								);
+								return callback(null, source, map, referencedModule);
 							}
 						);
 					};
@@ -271,8 +262,7 @@ class LoaderPlugin {
 						);
 					};
 
-					// eslint-disable-next-line no-warning-comments
-					// @ts-ignore Overloading doesn't work
+					// @ts-expect-error overloading doesn't work
 					loaderContext.importModule = (request, options, callback) => {
 						if (!callback) {
 							return new Promise((resolve, reject) => {

package/lib/dependencies/RequireContextDependency.js

@@ -10,10 +10,11 @@ const ContextDependency = require("./ContextDependency");
 const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateAsRequireId");
 
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
 
 class RequireContextDependency extends ContextDependency {
 	/**
-	 * @param {TODO} options options
+	 * @param {ContextDependencyOptions} options options
 	 * @param {Range} range range
 	 */
 	constructor(options, range) {

package/lib/dependencies/RequireContextDependencyParserPlugin.js

@@ -7,6 +7,7 @@
 
 const RequireContextDependency = require("./RequireContextDependency");
 
+/** @typedef {import("../ContextModule").ContextMode} ContextMode */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
@@ -22,12 +23,13 @@ module.exports = class RequireContextDependencyParserPlugin {
 			.tap("RequireContextDependencyParserPlugin", expr => {
 				let regExp = /^\.\/.*$/;
 				let recursive = true;
+				/** @type {ContextMode} */
 				let mode = "sync";
 				switch (expr.arguments.length) {
 					case 4: {
 						const modeExpr = parser.evaluateExpression(expr.arguments[3]);
 						if (!modeExpr.isString()) return;
-						mode = /** @type {string} */ (modeExpr.string);
+						mode = /** @type {ContextMode} */ (modeExpr.string);
 					}
 					// falls through
 					case 3: {
@@ -47,13 +49,14 @@ module.exports = class RequireContextDependencyParserPlugin {
 						if (!requestExpr.isString()) return;
 						const dep = new RequireContextDependency(
 							{
-								request: requestExpr.string,
+								request: /** @type {string} */ (requestExpr.string),
 								recursive,
 								regExp,
 								mode,
 								category: "commonjs"
 							},
-							/** @type {Range} */ (expr.range)
+							/** @type {Range} */
+							(expr.range)
 						);
 						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 						dep.optional = Boolean(parser.scope.inTry);

package/lib/dependencies/RequireEnsureDependenciesBlock.js

@@ -8,13 +8,14 @@
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const makeSerializable = require("../util/makeSerializable");
 
+/** @typedef {import("../AsyncDependenciesBlock").GroupOptions} GroupOptions */
 /** @typedef {import("../ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 
 class RequireEnsureDependenciesBlock extends AsyncDependenciesBlock {
 	/**
-	 * @param {ChunkGroupOptions & { entryOptions?: TODO }} chunkName chunk name
-	 * @param {DependencyLocation} loc location info
+	 * @param {GroupOptions | null} chunkName chunk name
+	 * @param {(DependencyLocation | null)=} loc location info
 	 */
 	constructor(chunkName, loc) {
 		super(chunkName, loc, null);

package/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js

@@ -10,6 +10,7 @@ const RequireEnsureDependency = require("./RequireEnsureDependency");
 const RequireEnsureItemDependency = require("./RequireEnsureItemDependency");
 const getFunctionExpression = require("./getFunctionExpression");
 
+/** @typedef {import("../AsyncDependenciesBlock").GroupOptions} GroupOptions */
 /** @typedef {import("../ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
@@ -25,6 +26,7 @@ module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 		parser.hooks.call
 			.for("require.ensure")
 			.tap("RequireEnsureDependenciesBlockParserPlugin", expr => {
+				/** @type {string | GroupOptions | null} */
 				let chunkName = null;
 				let errorExpressionArg = null;
 				let errorExpression = null;
@@ -32,7 +34,9 @@ module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 					case 4: {
 						const chunkNameExpr = parser.evaluateExpression(expr.arguments[3]);
 						if (!chunkNameExpr.isString()) return;
-						chunkName = chunkNameExpr.string;
+						chunkName =
+							/** @type {string} */
+							(chunkNameExpr.string);
 					}
 					// falls through
 					case 3: {
@@ -44,7 +48,9 @@ module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 								expr.arguments[2]
 							);
 							if (!chunkNameExpr.isString()) return;
-							chunkName = chunkNameExpr.string;
+							chunkName =
+								/** @type {string} */
+								(chunkNameExpr.string);
 						}
 					}
 					// falls through
@@ -70,9 +76,9 @@ module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 						}
 
 						const depBlock = new RequireEnsureDependenciesBlock(
-							/** @type {ChunkGroupOptions & { entryOptions?: TODO }} */
-							(chunkName),
-							/** @type {DependencyLocation} */ (expr.loc)
+							chunkName,
+							/** @type {DependencyLocation} */
+							(expr.loc)
 						);
 						const errorCallbackExists =
 							expr.arguments.length === 4 ||

package/lib/dependencies/RequireResolveContextDependency.js

@@ -19,7 +19,7 @@ class RequireResolveContextDependency extends ContextDependency {
 	 * @param {ContextDependencyOptions} options options
 	 * @param {Range} range range
 	 * @param {Range} valueRange value range
-	 * @param {TODO} context context
+	 * @param {string=} context context
 	 */
 	constructor(options, range, valueRange, context) {
 		super(options, context);

package/lib/dependencies/WebAssemblyExportImportedDependency.js

@@ -21,7 +21,7 @@ class WebAssemblyExportImportedDependency extends ModuleDependency {
 	 * @param {string} exportName export name
 	 * @param {string} request request
 	 * @param {string} name name
-	 * @param {TODO} valueType value type
+	 * @param {string} valueType value type
 	 */
 	constructor(exportName, request, name, valueType) {
 		super(request);

package/lib/dependencies/WorkerDependency.js

@@ -30,6 +30,7 @@ class WorkerDependency extends ModuleDependency {
 	 * @param {Range} range range
 	 * @param {object} workerDependencyOptions options
 	 * @param {string=} workerDependencyOptions.publicPath public path for the worker
+	 * @param {boolean=} workerDependencyOptions.needNewUrl need generate `new URL(...)`
 	 */
 	constructor(request, range, workerDependencyOptions) {
 		super(request);
@@ -118,12 +119,14 @@ WorkerDependency.Template = class WorkerDependencyTemplate extends (
 		runtimeRequirements.add(RuntimeGlobals.baseURI);
 		runtimeRequirements.add(RuntimeGlobals.getChunkScriptFilename);
 
+		const workerImportStr = `/* worker import */ ${workerImportBaseUrl} + ${
+			RuntimeGlobals.getChunkScriptFilename
+		}(${JSON.stringify(chunk.id)}), ${RuntimeGlobals.baseURI}`;
+
 		source.replace(
 			dep.range[0],
 			dep.range[1] - 1,
-			`/* worker import */ ${workerImportBaseUrl} + ${
-				RuntimeGlobals.getChunkScriptFilename
-			}(${JSON.stringify(chunk.id)}), ${RuntimeGlobals.baseURI}`
+			dep.options.needNewUrl ? `new URL(${workerImportStr})` : workerImportStr
 		);
 	}
 };

package/lib/dependencies/WorkerPlugin.js

@@ -27,6 +27,8 @@ const WorkerDependency = require("./WorkerDependency");
 
 /** @typedef {import("estree").CallExpression} CallExpression */
 /** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").Identifier} Identifier */
+/** @typedef {import("estree").MemberExpression} MemberExpression */
 /** @typedef {import("estree").ObjectExpression} ObjectExpression */
 /** @typedef {import("estree").Pattern} Pattern */
 /** @typedef {import("estree").Property} Property */
@@ -117,45 +119,81 @@ class WorkerPlugin {
 				/**
 				 * @param {JavascriptParser} parser the parser
 				 * @param {Expression} expr expression
-				 * @returns {[BasicEvaluatedExpression, [number, number]] | void} parsed
+				 * @returns {[string, [number, number]] | void} parsed
 				 */
 				const parseModuleUrl = (parser, expr) => {
-					if (
-						expr.type !== "NewExpression" ||
-						expr.callee.type === "Super" ||
-						expr.arguments.length !== 2
-					)
+					if (expr.type !== "NewExpression" || expr.callee.type === "Super")
 						return;
-					const [arg1, arg2] = expr.arguments;
-					if (arg1.type === "SpreadElement") return;
-					if (arg2.type === "SpreadElement") return;
-					const callee = parser.evaluateExpression(expr.callee);
-					if (!callee.isIdentifier() || callee.identifier !== "URL") return;
-					const arg2Value = parser.evaluateExpression(arg2);
 					if (
-						!arg2Value.isString() ||
-						!(/** @type {string} */ (arg2Value.string).startsWith("file://")) ||
-						arg2Value.string !== getUrl(parser.state.module)
+						expr.arguments.length === 1 &&
+						expr.arguments[0].type === "MemberExpression" &&
+						isMetaUrl(parser, expr.arguments[0])
 					) {
-						return;
+						const arg1 = expr.arguments[0];
+						return [
+							getUrl(parser.state.module),
+							[
+								/** @type {Range} */ (arg1.range)[0],
+								/** @type {Range} */ (arg1.range)[1]
+							]
+						];
+					} else if (expr.arguments.length === 2) {
+						const [arg1, arg2] = expr.arguments;
+						if (arg1.type === "SpreadElement") return;
+						if (arg2.type === "SpreadElement") return;
+						const callee = parser.evaluateExpression(expr.callee);
+						if (!callee.isIdentifier() || callee.identifier !== "URL") return;
+						const arg2Value = parser.evaluateExpression(arg2);
+						if (
+							!arg2Value.isString() ||
+							!(
+								/** @type {string} */ (arg2Value.string).startsWith("file://")
+							) ||
+							arg2Value.string !== getUrl(parser.state.module)
+						) {
+							return;
+						}
+						const arg1Value = parser.evaluateExpression(arg1);
+						if (!arg1Value.isString()) return;
+						return [
+							/** @type {string} */ (arg1Value.string),
+							[
+								/** @type {Range} */ (arg1.range)[0],
+								/** @type {Range} */ (arg2.range)[1]
+							]
+						];
 					}
-					const arg1Value = parser.evaluateExpression(arg1);
-					return [
-						arg1Value,
-						[
-							/** @type {Range} */ (arg1.range)[0],
-							/** @type {Range} */ (arg2.range)[1]
-						]
-					];
 				};
 
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @param {MemberExpression} expr expression
+				 * @returns {boolean} is `import.meta.url`
+				 */
+				const isMetaUrl = (parser, expr) => {
+					const chain = parser.extractMemberExpressionChain(expr);
+
+					if (
+						chain.members.length !== 1 ||
+						chain.object.type !== "MetaProperty" ||
+						chain.object.meta.name !== "import" ||
+						chain.object.property.name !== "meta" ||
+						chain.members[0] !== "url"
+					)
+						return false;
+
+					return true;
+				};
+
+				/** @typedef {Record<string, EXPECTED_ANY>} Values */
+
 				/**
 				 * @param {JavascriptParser} parser the parser
 				 * @param {ObjectExpression} expr expression
-				 * @returns {{ expressions: Record<string, Expression | Pattern>, otherElements: (Property | SpreadElement)[], values: Record<string, any>, spread: boolean, insertType: "comma" | "single", insertLocation: number }} parsed object
+				 * @returns {{ expressions: Record<string, Expression | Pattern>, otherElements: (Property | SpreadElement)[], values: Values, spread: boolean, insertType: "comma" | "single", insertLocation: number }} parsed object
 				 */
 				const parseObjectExpression = (parser, expr) => {
-					/** @type {Record<string, any>} */
+					/** @type {Values} */
 					const values = {};
 					/** @type {Record<string, Expression | Pattern>} */
 					const expressions = {};
@@ -174,7 +212,8 @@ class WorkerPlugin {
 							expressions[prop.key.name] = prop.value;
 							if (!prop.shorthand && !prop.value.type.endsWith("Pattern")) {
 								const value = parser.evaluateExpression(
-									/** @type {Expression} */ (prop.value)
+									/** @type {Expression} */
+									(prop.value)
 								);
 								if (value.isCompileTimeValue())
 									values[prop.key.name] = value.asCompileTimeValue();
@@ -217,10 +256,27 @@ class WorkerPlugin {
 						const [arg1, arg2] = expr.arguments;
 						if (arg1.type === "SpreadElement") return;
 						if (arg2 && arg2.type === "SpreadElement") return;
-						const parsedUrl = parseModuleUrl(parser, arg1);
-						if (!parsedUrl) return;
-						const [url, range] = parsedUrl;
-						if (!url.isString()) return;
+
+						/** @type {string} */
+						let url;
+						/** @type {[number, number]} */
+						let range;
+						/** @type {boolean} */
+						let needNewUrl = false;
+
+						if (arg1.type === "MemberExpression" && isMetaUrl(parser, arg1)) {
+							url = getUrl(parser.state.module);
+							range = [
+								/** @type {Range} */ (arg1.range)[0],
+								/** @type {Range} */ (arg1.range)[1]
+							];
+							needNewUrl = true;
+						} else {
+							const parsedUrl = parseModuleUrl(parser, arg1);
+							if (!parsedUrl) return;
+							[url, range] = parsedUrl;
+						}
+
 						const {
 							expressions,
 							otherElements,
@@ -234,7 +290,7 @@ class WorkerPlugin {
 									/** @type {Record<string, Expression | Pattern>} */
 									expressions: {},
 									otherElements: [],
-									/** @type {Record<string, any>} */
+									/** @type {Values} */
 									values: {},
 									spread: false,
 									insertType: arg2 ? "spread" : "argument",
@@ -342,13 +398,10 @@ class WorkerPlugin {
 							}
 						});
 						block.loc = expr.loc;
-						const dep = new WorkerDependency(
-							/** @type {string} */ (url.string),
-							range,
-							{
-								publicPath: this._workerPublicPath
-							}
-						);
+						const dep = new WorkerDependency(url, range, {
+							publicPath: this._workerPublicPath,
+							needNewUrl
+						});
 						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 						block.addDependency(dep);
 						parser.state.module.addBlock(block);
@@ -370,7 +423,7 @@ class WorkerPlugin {
 								);
 								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 								parser.state.module.addPresentationalDependency(dep);
-								/** @type {TODO} */
+								/** @type {EXPECTED_ANY} */
 								(expressions).type = undefined;
 							}
 						} else if (insertType === "comma") {
@@ -406,7 +459,13 @@ class WorkerPlugin {
 
 						parser.walkExpression(expr.callee);
 						for (const key of Object.keys(expressions)) {
-							if (expressions[key]) parser.walkExpression(expressions[key]);
+							if (expressions[key]) {
+								if (expressions[key].type.endsWith("Pattern")) continue;
+								parser.walkExpression(
+									/** @type {Expression} */
+									(expressions[key])
+								);
+							}
 						}
 						for (const prop of otherElements) {
 							parser.walkProperty(prop);

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -151,6 +151,11 @@ class ModuleChunkFormatPlugin {
 								let index = 0;
 								for (let i = 0; i < entries.length; i++) {
 									const [module, entrypoint] = entries[i];
+									if (
+										!chunkGraph.getModuleSourceTypes(module).has("javascript")
+									) {
+										continue;
+									}
 									const final = i + 1 === entries.length;
 									const moduleId = chunkGraph.getModuleId(module);
 									const chunks = getAllChunks(

package/lib/hmr/HotModuleReplacement.runtime.js

@@ -69,6 +69,7 @@ module.exports = function () {
 					me.children.push(request);
 				}
 			} else {
+				// eslint-disable-next-line no-console
 				console.warn(
 					"[HMR] unexpected require(" +
 						request +

package/lib/hmr/JavascriptHotModuleReplacement.runtime.js

@@ -109,6 +109,7 @@ module.exports = function () {
 		var appliedUpdate = {};
 
 		var warnUnexpectedRequire = function warnUnexpectedRequire(module) {
+			// eslint-disable-next-line no-console
 			console.warn(
 				"[HMR] unexpected require(" + module.id + ") to disposed module"
 			);

package/lib/hmr/LazyCompilationPlugin.js

@@ -23,14 +23,16 @@ const { registerNotSerializable } = require("../util/serialization");
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Module").BuildCallback} BuildCallback */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
+/** @typedef {import("../ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
 /** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../WebpackError")} WebpackError */
@@ -42,8 +44,8 @@ const { registerNotSerializable } = require("../util/serialization");
 
 /**
  * @typedef {object} BackendApi
- * @property {function(function((Error | null)=) : void): void} dispose
- * @property {function(Module): ModuleResult} module
+ * @property {(callback: (err?: (Error | null)) => void) => void} dispose
+ * @property {(module: Module) => ModuleResult} module
  */
 
 const HMR_DEPENDENCY_TYPES = new Set([
@@ -54,7 +56,7 @@ const HMR_DEPENDENCY_TYPES = new Set([
 ]);
 
 /**
- * @param {undefined|string|RegExp|Function} test test option
+ * @param {Options["test"]} test test option
  * @param {Module} module the module
  * @returns {boolean | null | string} true, if the module should be selected
  */
@@ -169,7 +171,7 @@ class LazyCompilationProxyModule extends Module {
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {
@@ -181,7 +183,7 @@ class LazyCompilationProxyModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {BuildCallback} callback callback function
 	 * @returns {void}
 	 */
 	build(options, compilation, resolver, fs, callback) {
@@ -315,13 +317,13 @@ class LazyCompilationDependencyFactory extends ModuleFactory {
 
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
+	 * @param {ModuleFactoryCallback} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {
-		const dependency = /** @type {LazyCompilationDependency} */ (
-			data.dependencies[0]
-		);
+		const dependency =
+			/** @type {LazyCompilationDependency} */
+			(data.dependencies[0]);
 		callback(null, {
 			module: dependency.proxyModule.originalModule
 		});
@@ -331,7 +333,7 @@ class LazyCompilationDependencyFactory extends ModuleFactory {
 /**
  * @callback BackendHandler
  * @param {Compiler} compiler compiler
- * @param {function(Error | null, BackendApi=): void} callback callback
+ * @param {(err: Error | null, backendApi?: BackendApi) => void} callback callback
  * @returns {void}
  */
 
@@ -341,13 +343,19 @@ class LazyCompilationDependencyFactory extends ModuleFactory {
  * @returns {Promise<BackendApi>} backend
  */
 
+/** @typedef {BackendHandler | PromiseBackendHandler} BackEnd */
+
+/**
+ * @typedef {object} Options options
+ * @property {BackEnd} backend the backend
+ * @property {boolean=} entries
+ * @property {boolean=} imports
+ * @property {(RegExp | string | ((module: Module) => boolean))=} test additional filter for lazy compiled entrypoint modules
+ */
+
 class LazyCompilationPlugin {
 	/**
-	 * @param {object} options options
-	 * @param {BackendHandler | PromiseBackendHandler} options.backend the backend
-	 * @param {boolean} options.entries true, when entries are lazy compiled
-	 * @param {boolean} options.imports true, when import() modules are lazy compiled
-	 * @param {RegExp | string | (function(Module): boolean) | undefined} options.test additional filter for lazy compiled entrypoint modules
+	 * @param {Options} options options
 	 */
 	constructor({ backend, entries, imports, test }) {
 		this.backend = backend;
@@ -386,7 +394,7 @@ class LazyCompilationPlugin {
 			(compilation, { normalModuleFactory }) => {
 				normalModuleFactory.hooks.module.tap(
 					"LazyCompilationPlugin",
-					(originalModule, createData, resolveData) => {
+					(module, createData, resolveData) => {
 						if (
 							resolveData.dependencies.every(dep =>
 								HMR_DEPENDENCY_TYPES.has(dep.type)
@@ -407,7 +415,7 @@ class LazyCompilationPlugin {
 												hmrDep.request
 									)
 							);
-							if (!isReferringToDynamicImport) return;
+							if (!isReferringToDynamicImport) return module;
 						} else if (
 							!resolveData.dependencies.every(
 								dep =>
@@ -418,21 +426,21 @@ class LazyCompilationPlugin {
 									(this.entries && dep.type === "entry")
 							)
 						)
-							return;
+							return module;
 						if (
 							/webpack[/\\]hot[/\\]|webpack-dev-server[/\\]client|webpack-hot-middleware[/\\]client/.test(
 								resolveData.request
 							) ||
-							!checkTest(this.test, originalModule)
+							!checkTest(this.test, module)
 						)
-							return;
-						const moduleInfo = backend.module(originalModule);
-						if (!moduleInfo) return;
+							return module;
+						const moduleInfo = backend.module(module);
+						if (!moduleInfo) return module;
 						const { client, data, active } = moduleInfo;
 
 						return new LazyCompilationProxyModule(
 							compiler.context,
-							originalModule,
+							module,
 							resolveData.request,
 							client,
 							data,

package/lib/hmr/lazyCompilationBackend.js

@@ -43,7 +43,7 @@ module.exports = options => (compiler, callback) => {
 						(options.server)
 					);
 				})();
-	/** @type {function(Server): void} */
+	/** @type {(server: Server) => void} */
 	const listen =
 		typeof options.listen === "function"
 			? options.listen

package/lib/ids/DeterministicModuleIdsPlugin.js

@@ -20,7 +20,7 @@ const {
 /**
  * @typedef {object} DeterministicModuleIdsPluginOptions
  * @property {string=} context context relative to which module identifiers are computed
- * @property {function(Module): boolean=} test selector function for modules
+ * @property {((module: Module) => boolean)=} test selector function for modules
  * @property {number=} maxLength maximum id length in digits (used as starting point)
  * @property {number=} salt hash salt for ids
  * @property {boolean=} fixedLength do not increase the maxLength to find an optimal id space size

package/lib/ids/HashedModuleIdsPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const { DEFAULTS } = require("../config/defaults");
 const {
 	compareModulesByPreOrderIndexOrIdentifier
 } = require("../util/comparators");
@@ -37,7 +38,7 @@ class HashedModuleIdsPlugin {
 		/** @type {HashedModuleIdsPluginOptions} */
 		this.options = {
 			context: undefined,
-			hashFunction: "md4",
+			hashFunction: DEFAULTS.HASH_FUNCTION,
 			hashDigest: "base64",
 			hashDigestLength: 4,
 			...options