webpack 5.93.0 → 5.95.0

package/lib/dependencies/LocalModulesHelpers.js

@@ -17,8 +17,8 @@ const LocalModule = require("./LocalModule");
 const lookup = (parent, mod) => {
 	if (mod.charAt(0) !== ".") return mod;
 
-	var path = parent.split("/");
-	var segments = mod.split("/");
+	const path = parent.split("/");
+	const segments = mod.split("/");
 	path.pop();
 
 	for (let i = 0; i < segments.length; i++) {
@@ -38,7 +38,7 @@ const lookup = (parent, mod) => {
  * @param {string} name name
  * @returns {LocalModule} local module
  */
-exports.addLocalModule = (state, name) => {
+module.exports.addLocalModule = (state, name) => {
 	if (!state.localModules) {
 		state.localModules = [];
 	}
@@ -53,7 +53,7 @@ exports.addLocalModule = (state, name) => {
  * @param {string} [namedModule] named module
  * @returns {LocalModule | null} local module or null
  */
-exports.getLocalModule = (state, name, namedModule) => {
+module.exports.getLocalModule = (state, name, namedModule) => {
 	if (!state.localModules) return null;
 	if (namedModule) {
 		// resolve dependency name relative to the defining named module

package/lib/dependencies/ModuleDecoratorDependency.js

@@ -50,7 +50,7 @@ class ModuleDecoratorDependency extends NullDependency {
 	 * @returns {string | null} an identifier to merge equal requests
 	 */
 	getResourceIdentifier() {
-		return `self`;
+		return "self";
 	}
 
 	/**

package/lib/dependencies/ProvidedDependency.js

@@ -64,7 +64,7 @@ class ProvidedDependency extends ModuleDependency {
 	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
-		let ids = this.ids;
+		const ids = this.ids;
 		if (ids.length === 0) return Dependency.EXPORTS_OBJECT_REFERENCED;
 		return [ids];
 	}

package/lib/dependencies/PureExpressionDependency.js

@@ -77,12 +77,12 @@ class PureExpressionDependency extends NullDependency {
 			hash.update("null");
 		} else {
 			hash.update(
-				runtimeToString(runtimeCondition) +
-					"|" +
-					runtimeToString(context.runtime)
+				`${runtimeToString(runtimeCondition)}|${runtimeToString(
+					context.runtime
+				)}`
 			);
 		}
-		hash.update(this.range + "");
+		hash.update(String(this.range));
 	}
 
 	/**
@@ -136,11 +136,11 @@ PureExpressionDependency.Template = class PureExpressionDependencyTemplate exten
 		const dep = /** @type {PureExpressionDependency} */ (dependency);
 		const runtimeCondition = dep._getRuntimeCondition(moduleGraph, runtime);
 		if (runtimeCondition === true) {
-			return;
+			// Do nothing
 		} else if (runtimeCondition === false) {
 			source.insert(
 				dep.range[0],
-				`(/* unused pure expression or super */ null && (`
+				"(/* unused pure expression or super */ null && ("
 			);
 			source.insert(dep.range[1], "))");
 		} else {

package/lib/dependencies/RequireContextDependencyParserPlugin.js

@@ -56,7 +56,7 @@ module.exports = class RequireContextDependencyParserPlugin {
 							/** @type {Range} */ (expr.range)
 						);
 						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-						dep.optional = !!parser.scope.inTry;
+						dep.optional = Boolean(parser.scope.inTry);
 						parser.state.current.addDependency(dep);
 						return true;
 					}

package/lib/dependencies/RuntimeRequirementsDependency.js

@@ -36,7 +36,7 @@ class RuntimeRequirementsDependency extends NullDependency {
 	 */
 	updateHash(hash, context) {
 		if (this._hashUpdate === undefined) {
-			this._hashUpdate = Array.from(this.runtimeRequirements).join() + "";
+			this._hashUpdate = `${Array.from(this.runtimeRequirements).join()}`;
 		}
 		hash.update(this._hashUpdate);
 	}

package/lib/dependencies/SystemPlugin.js

@@ -73,7 +73,7 @@ class SystemPlugin {
 								PLUGIN_NAME,
 								expressionIsUnsupported(
 									parser,
-									name + " is not supported by webpack."
+									`${name} is not supported by webpack.`
 								)
 							);
 					};

package/lib/dependencies/URLDependency.js

@@ -30,9 +30,9 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-const getIgnoredRawDataUrlModule = memoize(() => {
-	return new RawDataUrlModule("data:,", `ignored-asset`, `(ignored asset)`);
-});
+const getIgnoredRawDataUrlModule = memoize(
+	() => new RawDataUrlModule("data:,", "ignored-asset", "(ignored asset)")
+);
 
 class URLDependency extends ModuleDependency {
 	/**

package/lib/dependencies/URLPlugin.js

@@ -6,13 +6,17 @@
 "use strict";
 
 const { pathToFileURL } = require("url");
+const CommentCompilationWarning = require("../CommentCompilationWarning");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
 const { approve } = require("../javascript/JavascriptParserHelpers");
 const InnerGraph = require("../optimize/InnerGraph");
+const ConstDependency = require("./ConstDependency");
 const URLDependency = require("./URLDependency");
 
 /** @typedef {import("estree").NewExpression} NewExpressionNode */
@@ -44,8 +48,21 @@ class URLPlugin {
 				 * @param {NormalModule} module module
 				 * @returns {URL} file url
 				 */
-				const getUrl = module => {
-					return pathToFileURL(module.resource);
+				const getUrl = module => pathToFileURL(module.resource);
+
+				const isMetaUrl = (parser, arg) => {
+					const chain = parser.extractMemberExpressionChain(arg);
+
+					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;
 				};
 
 				/**
@@ -72,16 +89,7 @@ class URLPlugin {
 						)
 							return;
 
-						const chain = parser.extractMemberExpressionChain(arg2);
-
-						if (
-							chain.members.length !== 1 ||
-							chain.object.type !== "MetaProperty" ||
-							chain.object.meta.name !== "import" ||
-							chain.object.property.name !== "meta" ||
-							chain.members[0] !== "url"
-						)
-							return;
+						if (!isMetaUrl(parser, arg2)) return;
 
 						return parser.evaluateExpression(arg1).asString();
 					};
@@ -100,6 +108,52 @@ class URLPlugin {
 						});
 					parser.hooks.new.for("URL").tap(PLUGIN_NAME, _expr => {
 						const expr = /** @type {NewExpressionNode} */ (_expr);
+						const { options: importOptions, errors: commentErrors } =
+							parser.parseCommentOptions(/** @type {Range} */ (expr.range));
+
+						if (commentErrors) {
+							for (const e of commentErrors) {
+								const { comment } = e;
+								parser.state.module.addWarning(
+									new CommentCompilationWarning(
+										`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+										comment.loc
+									)
+								);
+							}
+						}
+
+						if (importOptions && importOptions.webpackIgnore !== undefined) {
+							if (typeof importOptions.webpackIgnore !== "boolean") {
+								parser.state.module.addWarning(
+									new UnsupportedFeatureWarning(
+										`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
+										/** @type {DependencyLocation} */ (expr.loc)
+									)
+								);
+								return;
+							} else if (importOptions.webpackIgnore) {
+								if (expr.arguments.length !== 2) return;
+
+								const [, arg2] = expr.arguments;
+
+								if (
+									arg2.type !== "MemberExpression" ||
+									!isMetaUrl(parser, arg2)
+								)
+									return;
+
+								const dep = new ConstDependency(
+									RuntimeGlobals.baseURI,
+									/** @type {Range} */ (arg2.range),
+									[RuntimeGlobals.baseURI]
+								);
+								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+								parser.state.module.addPresentationalDependency(dep);
+
+								return true;
+							}
+						}
 
 						const request = getUrlRequest(expr);
 

package/lib/dependencies/WorkerPlugin.js

@@ -45,15 +45,14 @@ const WorkerDependency = require("./WorkerDependency");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../util/createHash").Algorithm} Algorithm */
 /** @typedef {import("./HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
 
 /**
  * @param {NormalModule} module module
  * @returns {string} url
  */
-const getUrl = module => {
-	return pathToFileURL(module.resource).toString();
-};
+const getUrl = module => pathToFileURL(module.resource).toString();
 
 const WorkerSpecifierTag = Symbol("worker specifier tag");
 
@@ -82,6 +81,7 @@ class WorkerPlugin {
 		this._module = module;
 		this._workerPublicPath = workerPublicPath;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -258,7 +258,7 @@ class WorkerPlugin {
 						}
 
 						/** @type {EntryOptions} */
-						let entryOptions = {};
+						const entryOptions = {};
 
 						if (importOptions) {
 							if (importOptions.webpackIgnore !== undefined) {
@@ -269,10 +269,8 @@ class WorkerPlugin {
 											/** @type {DependencyLocation} */ (expr.loc)
 										)
 									);
-								} else {
-									if (importOptions.webpackIgnore) {
-										return false;
-									}
+								} else if (importOptions.webpackIgnore) {
+									return false;
 								}
 							}
 							if (importOptions.webpackEntryOptions !== undefined) {
@@ -316,16 +314,19 @@ class WorkerPlugin {
 						}
 
 						if (entryOptions.runtime === undefined) {
-							let i = workerIndexMap.get(parser.state) || 0;
+							const i = workerIndexMap.get(parser.state) || 0;
 							workerIndexMap.set(parser.state, i + 1);
-							let name = `${cachedContextify(
+							const name = `${cachedContextify(
 								parser.state.module.identifier()
 							)}|${i}`;
-							const hash = createHash(compilation.outputOptions.hashFunction);
-							hash.update(name);
-							const digest = /** @type {string} */ (
-								hash.digest(compilation.outputOptions.hashDigest)
+							const hash = createHash(
+								/** @type {Algorithm} */
+								(compilation.outputOptions.hashFunction)
 							);
+							hash.update(name);
+							const digest =
+								/** @type {string} */
+								(hash.digest(compilation.outputOptions.hashDigest));
 							entryOptions.runtime = digest.slice(
 								0,
 								compilation.outputOptions.hashDigestLength
@@ -394,15 +395,13 @@ class WorkerPlugin {
 							dep2.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addPresentationalDependency(dep1);
 							parser.state.module.addPresentationalDependency(dep2);
-						} else if (insertType === "argument") {
-							if (this._module) {
-								const dep = new ConstDependency(
-									', { type: "module" }',
-									insertLocation
-								);
-								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-								parser.state.module.addPresentationalDependency(dep);
-							}
+						} else if (insertType === "argument" && this._module) {
+							const dep = new ConstDependency(
+								', { type: "module" }',
+								insertLocation
+							);
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+							parser.state.module.addPresentationalDependency(dep);
 						}
 
 						parser.walkExpression(expr.callee);
@@ -482,7 +481,9 @@ class WorkerPlugin {
 					};
 					for (const item of options) {
 						if (item === "...") {
-							DEFAULT_SYNTAX.forEach(processItem);
+							for (const itemFromDefault of DEFAULT_SYNTAX) {
+								processItem(itemFromDefault);
+							}
 						} else processItem(item);
 					}
 				};

package/lib/dependencies/processExportInfo.js

@@ -10,9 +10,11 @@ const { UsageState } = require("../ExportsInfo");
 /** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
+/** @typedef {string[][]} ReferencedExports */
+
 /**
  * @param {RuntimeSpec} runtime the runtime
- * @param {string[][]} referencedExports list of referenced exports, will be added to
+ * @param {ReferencedExports} referencedExports list of referenced exports, will be added to
  * @param {string[]} prefix export prefix
  * @param {ExportInfo=} exportInfo the export info
  * @param {boolean} defaultPointsToSelf when true, using default will reference itself

package/lib/electron/ElectronTargetPlugin.js

@@ -16,6 +16,7 @@ class ElectronTargetPlugin {
 	constructor(context) {
 		this._context = context;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -58,9 +58,9 @@ class ModuleChunkFormatPlugin {
 						} else {
 							source.add(`export const id = ${JSON.stringify(chunk.id)};\n`);
 							source.add(`export const ids = ${JSON.stringify(chunk.ids)};\n`);
-							source.add(`export const modules = `);
+							source.add("export const modules = ");
 							source.add(modules);
-							source.add(`;\n`);
+							source.add(";\n");
 							const runtimeModules =
 								chunkGraph.getChunkRuntimeModulesInOrder(chunk);
 							if (runtimeModules.length > 0) {
@@ -103,7 +103,7 @@ class ModuleChunkFormatPlugin {
 												compilation.outputOptions
 											),
 											{
-												chunk: chunk,
+												chunk,
 												contentHashType: "javascript"
 											}
 										)

package/lib/esm/ModuleChunkLoadingRuntimeModule.js

@@ -17,6 +17,7 @@ const { getInitialChunkIds } = require("../javascript/StartupHelpers");
 const compileBooleanMatcher = require("../util/compileBooleanMatcher");
 const { getUndoPath } = require("../util/identifier");
 
+/** @typedef {import("../../declarations/WebpackOptions").Environment} Environment */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
@@ -87,9 +88,12 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		const chunk = /** @type {Chunk} */ (this.chunk);
+		const environment =
+			/** @type {Environment} */
+			(compilation.outputOptions.environment);
 		const {
 			runtimeTemplate,
-			outputOptions: { environment, importFunctionName, crossOriginLoading }
+			outputOptions: { importFunctionName, crossOriginLoading }
 		} = compilation;
 		const fn = RuntimeGlobals.ensureChunkHandlers;
 		const withBaseURI = this._runtimeRequirements.has(RuntimeGlobals.baseURI);
@@ -219,10 +223,10 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 														]
 													)});`,
 													`var promise = Promise.race([promise, new Promise(${runtimeTemplate.expressionFunction(
-														`installedChunkData = installedChunks[chunkId] = [resolve]`,
+														"installedChunkData = installedChunks[chunkId] = [resolve]",
 														"resolve"
 													)})])`,
-													`promises.push(installedChunkData[1] = promise);`
+													"promises.push(installedChunkData[1] = promise);"
 												]),
 												hasJsMatcher === true
 													? "}"

package/lib/formatLocation.js

@@ -48,9 +48,8 @@ const formatLocation = loc => {
 				typeof loc.end.column !== "number"
 			) {
 				return `${loc.start.line}-${loc.end.line}`;
-			} else {
-				return `${formatPosition(loc.start)}-${formatPosition(loc.end)}`;
 			}
+			return `${formatPosition(loc.start)}-${formatPosition(loc.end)}`;
 		}
 		if ("start" in loc && loc.start) {
 			return formatPosition(loc.start);

package/lib/hmr/HotModuleReplacement.runtime.js

@@ -201,7 +201,7 @@ module.exports = function () {
 				if (idx >= 0) registeredStatusHandlers.splice(idx, 1);
 			},
 
-			//inherit from previous dispose call
+			// inherit from previous dispose call
 			data: currentModuleData[moduleId]
 		};
 		currentChildModule = undefined;
@@ -293,11 +293,10 @@ module.exports = function () {
 						return waitForBlockingPromises(function () {
 							if (applyOnUpdate) {
 								return internalApply(applyOnUpdate);
-							} else {
-								return setStatus("ready").then(function () {
-									return updatedModules;
-								});
 							}
+							return setStatus("ready").then(function () {
+								return updatedModules;
+							});
 						});
 					});
 				});

package/lib/hmr/HotModuleReplacementRuntimeModule.js

@@ -13,6 +13,7 @@ class HotModuleReplacementRuntimeModule extends RuntimeModule {
 	constructor() {
 		super("hot module replacement", RuntimeModule.STAGE_BASIC);
 	}
+
 	/**
 	 * @returns {string | null} runtime code
 	 */

package/lib/hmr/JavascriptHotModuleReplacement.runtime.js

@@ -117,15 +117,12 @@ module.exports = function () {
 			if ($hasOwnProperty$(currentUpdate, moduleId)) {
 				var newModuleFactory = currentUpdate[moduleId];
 				/** @type {TODO} */
-				var result;
-				if (newModuleFactory) {
-					result = getAffectedModuleEffects(moduleId);
-				} else {
-					result = {
-						type: "disposed",
-						moduleId: moduleId
-					};
-				}
+				var result = newModuleFactory
+					? getAffectedModuleEffects(moduleId)
+					: {
+							type: "disposed",
+							moduleId: moduleId
+						};
 				/** @type {Error|false} */
 				var abortError = false;
 				var doApply = false;
@@ -376,17 +373,17 @@ module.exports = function () {
 									moduleId: moduleId,
 									module: $moduleCache$[moduleId]
 								});
-							} catch (err2) {
+							} catch (err1) {
 								if (options.onErrored) {
 									options.onErrored({
 										type: "self-accept-error-handler-errored",
 										moduleId: moduleId,
-										error: err2,
+										error: err1,
 										originalError: err
 									});
 								}
 								if (!options.ignoreErrored) {
-									reportError(err2);
+									reportError(err1);
 									reportError(err);
 								}
 							}

package/lib/hmr/LazyCompilationPlugin.js

@@ -37,10 +37,12 @@ const { registerNotSerializable } = require("../util/serialization");
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
+/** @typedef {{ client: string, data: string, active: boolean }} ModuleResult */
+
 /**
  * @typedef {object} BackendApi
- * @property {function(Error=): void} dispose
- * @property {function(Module): { client: string, data: string, active: boolean }} module
+ * @property {function(function((Error | null)=) : void): void} dispose
+ * @property {function(Module): ModuleResult} module
  */
 
 const HMR_DEPENDENCY_TYPES = new Set([
@@ -53,7 +55,7 @@ const HMR_DEPENDENCY_TYPES = new Set([
 /**
  * @param {undefined|string|RegExp|Function} test test option
  * @param {Module} module the module
- * @returns {boolean} true, if the module should be selected
+ * @returns {boolean | null | string} true, if the module should be selected
  */
 const checkTest = (test, module) => {
 	if (test === undefined) return true;
@@ -74,6 +76,9 @@ const checkTest = (test, module) => {
 const TYPES = new Set(["javascript"]);
 
 class LazyCompilationDependency extends Dependency {
+	/**
+	 * @param {LazyCompilationProxyModule} proxyModule proxy module
+	 */
 	constructor(proxyModule) {
 		super();
 		this.proxyModule = proxyModule;
@@ -98,6 +103,14 @@ class LazyCompilationDependency extends Dependency {
 registerNotSerializable(LazyCompilationDependency);
 
 class LazyCompilationProxyModule extends Module {
+	/**
+	 * @param {string} context context
+	 * @param {Module} originalModule an original module
+	 * @param {string} request request
+	 * @param {ModuleResult["client"]} client client
+	 * @param {ModuleResult["data"]} data data
+	 * @param {ModuleResult["active"]} active true when active, otherwise false
+	 */
 	constructor(context, originalModule, request, client, data, active) {
 		super(
 			WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY,
@@ -229,13 +242,13 @@ class LazyCompilationProxyModule extends Module {
 		]);
 		const keepActive = Template.asString([
 			`var dispose = client.keepAlive({ data: data, active: ${JSON.stringify(
-				!!block
+				Boolean(block)
 			)}, module: module, onError: onError });`
 		]);
 		let source;
 		if (block) {
 			const dep = block.dependencies[0];
-			const module = moduleGraph.getModule(dep);
+			const module = /** @type {Module} */ (moduleGraph.getModule(dep));
 			source = Template.asString([
 				client,
 				`module.exports = ${runtimeTemplate.moduleNamespacePromise({
@@ -264,7 +277,7 @@ class LazyCompilationProxyModule extends Module {
 			source = Template.asString([
 				client,
 				"var resolveSelf, onError;",
-				`module.exports = new Promise(function(resolve, reject) { resolveSelf = resolve; onError = reject; });`,
+				"module.exports = new Promise(function(resolve, reject) { resolveSelf = resolve; onError = reject; });",
 				"if (module.hot) {",
 				Template.indent([
 					"module.hot.accept();",
@@ -297,9 +310,8 @@ class LazyCompilationProxyModule extends Module {
 registerNotSerializable(LazyCompilationProxyModule);
 
 class LazyCompilationDependencyFactory extends ModuleFactory {
-	constructor(factory) {
+	constructor() {
 		super();
-		this._factory = factory;
 	}
 
 	/**
@@ -320,10 +332,10 @@ class LazyCompilationDependencyFactory extends ModuleFactory {
 class LazyCompilationPlugin {
 	/**
 	 * @param {object} options options
-	 * @param {(function(Compiler, function(Error?, BackendApi?): void): void) | function(Compiler): Promise<BackendApi>} options.backend the backend
+	 * @param {(function(Compiler, function(Error=, BackendApi?): void): void) | function(Compiler): Promise<BackendApi>} 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)} options.test additional filter for lazy compiled entrypoint modules
+	 * @param {RegExp | string | (function(Module): boolean) | undefined} options.test additional filter for lazy compiled entrypoint modules
 	 */
 	constructor({ backend, entries, imports, test }) {
 		this.backend = backend;
@@ -331,12 +343,14 @@ class LazyCompilationPlugin {
 		this.imports = imports;
 		this.test = test;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
+		/** @type {BackendApi} */
 		let backend;
 		compiler.hooks.beforeCompile.tapAsync(
 			"LazyCompilationPlugin",
@@ -344,7 +358,7 @@ class LazyCompilationPlugin {
 				if (backend !== undefined) return callback();
 				const promise = this.backend(compiler, (err, result) => {
 					if (err) return callback(err);
-					backend = result;
+					backend = /** @type {BackendApi} */ (result);
 					callback();
 				});
 				if (promise && promise.then) {
@@ -370,7 +384,8 @@ class LazyCompilationPlugin {
 							// an import() or not
 							const hmrDep = resolveData.dependencies[0];
 							const originModule =
-								compilation.moduleGraph.getParentModule(hmrDep);
+								/** @type {Module} */
+								(compilation.moduleGraph.getParentModule(hmrDep));
 							const isReferringToDynamicImport = originModule.blocks.some(
 								block =>
 									block.dependencies.some(