webpack 5.107.1 → 5.108.0

package/lib/dependencies/WebAssemblyImportDependency.js

@@ -13,8 +13,8 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../errors/WebpackError")} WebpackError */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, ModuleImportDescription, false | string]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string, ModuleImportDescription, false | string]>} ObjectSerializerContext */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 class WebAssemblyImportDependency extends ModuleDependency {
@@ -50,7 +50,8 @@ class WebAssemblyImportDependency extends ModuleDependency {
 	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
-		return [[this.name]];
+		// wasm import glue needs the real binding, never an inlined literal
+		return [{ name: [this.name], canInline: false }];
 	}
 
 	/**
@@ -79,12 +80,10 @@ class WebAssemblyImportDependency extends ModuleDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-
-		write(this.name);
-		write(this.description);
-		write(this.onlyDirectImport);
-
+		context
+			.write(this.name)
+			.write(this.description)
+			.write(this.onlyDirectImport);
 		super.serialize(context);
 	}
 
@@ -93,13 +92,12 @@ class WebAssemblyImportDependency extends ModuleDependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-
-		this.name = read();
-		this.description = read();
-		this.onlyDirectImport = read();
-
-		super.deserialize(context);
+		this.name = context.read();
+		const c1 = context.rest;
+		this.description = c1.read();
+		const c2 = c1.rest;
+		this.onlyDirectImport = c2.read();
+		super.deserialize(c2.rest);
 	}
 }
 

package/lib/dependencies/WebpackIsIncludedDependency.js

@@ -26,6 +26,7 @@ class WebpackIsIncludedDependency extends ModuleDependency {
 	constructor(request, range) {
 		super(request);
 
+		/** @type {boolean} */
 		this.weak = true;
 		this.range = range;
 	}

package/lib/dependencies/WorkerDependency.js

@@ -18,8 +18,8 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../Entrypoint")} Entrypoint */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[WorkerDependencyOptions]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[WorkerDependencyOptions]>} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
@@ -28,6 +28,7 @@ const ModuleDependency = require("./ModuleDependency");
  * @typedef {object} WorkerDependencyOptions
  * @property {string=} publicPath public path for the worker
  * @property {boolean=} needNewUrl true when need generate `new URL(...)`, otherwise false
+ * @property {Range=} workerConstructorRange range of the global `Worker` constructor, set only for the `new Worker()` global syntax that needs a node-target rewrite
  */
 
 class WorkerDependency extends ModuleDependency {
@@ -84,8 +85,7 @@ class WorkerDependency extends ModuleDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-		write(this.options);
+		context.write(this.options);
 		super.serialize(context);
 	}
 
@@ -94,9 +94,8 @@ class WorkerDependency extends ModuleDependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-		this.options = read();
-		super.deserialize(context);
+		this.options = context.read();
+		super.deserialize(context.rest);
 	}
 }
 
@@ -111,7 +110,8 @@ WorkerDependency.Template = class WorkerDependencyTemplate extends (
 	 * @returns {void}
 	 */
 	apply(dependency, source, templateContext) {
-		const { chunkGraph, moduleGraph, runtimeRequirements } = templateContext;
+		const { chunkGraph, moduleGraph, runtimeRequirements, runtimeTemplate } =
+			templateContext;
 		const dep = /** @type {WorkerDependency} */ (dependency);
 		const block = /** @type {AsyncDependenciesBlock} */ (
 			moduleGraph.getParentBlock(dependency)
@@ -138,6 +138,17 @@ WorkerDependency.Template = class WorkerDependencyTemplate extends (
 			dep.range[1] - 1,
 			dep.options.needNewUrl ? `new URL(${workerImportStr})` : workerImportStr
 		);
+
+		// `Worker` is global only on the web, so route node (universal or node-only) through `worker_threads`
+		const { platform } = runtimeTemplate.compilation.compiler;
+		const ctorRange = dep.options.workerConstructorRange;
+		if (
+			ctorRange &&
+			(runtimeTemplate.isUniversalTarget() || (platform.node && !platform.web))
+		) {
+			runtimeRequirements.add(RuntimeGlobals.worker);
+			source.replace(ctorRange[0], ctorRange[1] - 1, RuntimeGlobals.worker);
+		}
 	}
 };
 

package/lib/dependencies/WorkerPlugin.js

@@ -77,9 +77,13 @@ class WorkerPlugin {
 	 * @param {WorkerPublicPath=} workerPublicPath worker public path
 	 */
 	constructor(chunkLoading, wasmLoading, module, workerPublicPath) {
+		/** @type {ChunkLoading | undefined} */
 		this._chunkLoading = chunkLoading;
+		/** @type {WasmLoading | undefined} */
 		this._wasmLoading = wasmLoading;
+		/** @type {boolean | undefined} */
 		this._module = module;
+		/** @type {string | undefined} */
 		this._workerPublicPath = workerPublicPath;
 	}
 
@@ -255,9 +259,10 @@ class WorkerPlugin {
 					/**
 					 * Returns true when handled.
 					 * @param {CallExpression} expr expression
+					 * @param {boolean=} isGlobalWorker matched the global `new Worker()` syntax (eligible for universal rewrite)
 					 * @returns {boolean | void} true when handled
 					 */
-					const handleNewWorker = (expr) => {
+					const handleNewWorker = (expr, isGlobalWorker = false) => {
 						if (expr.arguments.length === 0 || expr.arguments.length > 2) {
 							return;
 						}
@@ -349,10 +354,24 @@ class WorkerPlugin {
 										)
 									);
 								} else {
-									Object.assign(
-										entryOptions,
-										importOptions.webpackEntryOptions
-									);
+									// `webpackEntryOptions` is user input from a magic
+									// comment, so copy only safe own keys to avoid
+									// prototype pollution via `__proto__`/`constructor`/
+									// `prototype`.
+									const userEntryOptions = importOptions.webpackEntryOptions;
+									for (const key of Object.keys(userEntryOptions)) {
+										if (
+											key === "__proto__" ||
+											key === "constructor" ||
+											key === "prototype"
+										) {
+											continue;
+										}
+										/** @type {EXPECTED_ANY} */
+										(entryOptions)[key] = /** @type {EXPECTED_ANY} */ (
+											userEntryOptions
+										)[key];
+									}
 								}
 							}
 							if (importOptions.webpackChunkName !== undefined) {
@@ -398,13 +417,17 @@ class WorkerPlugin {
 							entryOptions: {
 								chunkLoading: this._chunkLoading,
 								wasmLoading: this._wasmLoading,
-								...entryOptions
+								...entryOptions,
+								worker: true
 							}
 						});
 						block.loc = expr.loc;
 						const dep = new WorkerDependency(url, range, {
 							publicPath: this._workerPublicPath,
-							needNewUrl
+							needNewUrl,
+							workerConstructorRange: isGlobalWorker
+								? /** @type {Range} */ (expr.callee.range)
+								: undefined
 						});
 						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 						block.addDependency(dep);
@@ -440,12 +463,15 @@ class WorkerPlugin {
 								parser.state.module.addPresentationalDependency(dep);
 							}
 						} else if (insertType === "spread") {
+							const type = this._module ? '"module"' : "undefined";
+							// `{ ...(opts), type }` is equivalent to `Object.assign({}, opts, { type })`
+							const useSpread = compilation.outputOptions.environment.spread;
 							const dep1 = new ConstDependency(
-								"Object.assign({}, ",
+								useSpread ? "{ ...(" : "Object.assign({}, ",
 								/** @type {Range} */ (insertLocation)[0]
 							);
 							const dep2 = new ConstDependency(
-								`, { type: ${this._module ? '"module"' : "undefined"} })`,
+								useSpread ? `), type: ${type} }` : `, { type: ${type} })`,
 								/** @type {Range} */ (insertLocation)[1]
 							);
 							dep1.loc = /** @type {DependencyLocation} */ (expr.loc);
@@ -545,7 +571,11 @@ class WorkerPlugin {
 										return handleNewWorker(expr);
 									});
 							} else {
-								parser.hooks.new.for(item).tap(PLUGIN_NAME, handleNewWorker);
+								parser.hooks.new
+									.for(item)
+									.tap(PLUGIN_NAME, (expr) =>
+										handleNewWorker(expr, item === "Worker")
+									);
 							}
 						}
 					};

package/lib/dependencies/processExportInfo.js

@@ -18,7 +18,7 @@ const { UsageState } = require("../ExportsInfo");
  * @param {string[]} prefix export prefix
  * @param {ExportInfo=} exportInfo the export info
  * @param {boolean} defaultPointsToSelf when true, using default will reference itself
- * @param {Set<ExportInfo>} alreadyVisited already visited export info (to handle circular reexports)
+ * @param {Set<ExportInfo>=} alreadyVisited already visited export info (to handle circular reexports)
  */
 const processExportInfo = (
 	runtime,
@@ -26,7 +26,7 @@ const processExportInfo = (
 	prefix,
 	exportInfo,
 	defaultPointsToSelf = false,
-	alreadyVisited = new Set()
+	alreadyVisited = undefined
 ) => {
 	if (!exportInfo) {
 		referencedExports.push(prefix);
@@ -34,35 +34,37 @@ const processExportInfo = (
 	}
 	const used = exportInfo.getUsed(runtime);
 	if (used === UsageState.Unused) return;
-	if (alreadyVisited.has(exportInfo)) {
+	if (alreadyVisited !== undefined && alreadyVisited.has(exportInfo)) {
 		referencedExports.push(prefix);
 		return;
 	}
-	alreadyVisited.add(exportInfo);
+	// Terminal case: not recursing, so no need to track visited here
 	if (
 		used !== UsageState.OnlyPropertiesUsed ||
 		!exportInfo.exportsInfo ||
 		exportInfo.exportsInfo.otherExportsInfo.getUsed(runtime) !==
 			UsageState.Unused
 	) {
-		alreadyVisited.delete(exportInfo);
 		referencedExports.push(prefix);
 		return;
 	}
+	// Only the recursive path needs the visited set; allocate it lazily
+	const visited = alreadyVisited !== undefined ? alreadyVisited : new Set();
+	visited.add(exportInfo);
 	const exportsInfo = exportInfo.exportsInfo;
-	for (const exportInfo of exportsInfo.orderedExports) {
+	for (const childExportInfo of exportsInfo.orderedExports) {
 		processExportInfo(
 			runtime,
 			referencedExports,
-			defaultPointsToSelf && exportInfo.name === "default"
+			defaultPointsToSelf && childExportInfo.name === "default"
 				? prefix
-				: [...prefix, exportInfo.name],
-			exportInfo,
+				: [...prefix, childExportInfo.name],
+			childExportInfo,
 			false,
-			alreadyVisited
+			visited
 		);
 	}
-	alreadyVisited.delete(exportInfo);
+	visited.delete(exportInfo);
 };
 
 module.exports = processExportInfo;

package/lib/dll/DelegatedModule.js

@@ -36,8 +36,8 @@ const makeSerializable = require("../util/makeSerializable");
 /** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[DelegatedModuleSourceRequest, DelegatedModuleData, DelegatedModuleType, string, string | Module]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[DelegatedModuleSourceRequest, DelegatedModuleData, DelegatedModuleType, string, string | Module]>} ObjectSerializerContext */
 /** @typedef {import("../dependencies/StaticExportsDependency").Exports} Exports */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
@@ -72,11 +72,17 @@ class DelegatedModule extends Module {
 		super(JAVASCRIPT_MODULE_TYPE_DYNAMIC, null);
 
 		// Info from Factory
+		/** @type {string} */
 		this.sourceRequest = sourceRequest;
+		/** @type {ModuleId} */
 		this.request = data.id;
+		/** @type {DelegatedModuleType} */
 		this.delegationType = type;
+		/** @type {string} */
 		this.userRequest = userRequest;
+		/** @type {string | Module} */
 		this.originalRequest = originalRequest;
+		/** @type {DelegatedModuleData} */
 		this.delegateData = data;
 
 		// Build info
@@ -232,13 +238,13 @@ class DelegatedModule extends Module {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
 		// constructor
-		write(this.sourceRequest);
-		write(this.delegateData);
-		write(this.delegationType);
-		write(this.userRequest);
-		write(this.originalRequest);
+		context
+			.write(this.sourceRequest)
+			.write(this.delegateData)
+			.write(this.delegationType)
+			.write(this.userRequest)
+			.write(this.originalRequest);
 		super.serialize(context);
 	}
 
@@ -248,15 +254,23 @@ class DelegatedModule extends Module {
 	 * @returns {DelegatedModule} DelegatedModule
 	 */
 	static deserialize(context) {
-		const { read } = context;
+		const sourceRequest = context.read();
+		const c1 = context.rest;
+		const delegateData = c1.read();
+		const c2 = c1.rest;
+		const delegationType = c2.read();
+		const c3 = c2.rest;
+		const userRequest = c3.read();
+		const c4 = c3.rest;
+		const originalRequest = c4.read();
 		const obj = new DelegatedModule(
-			read(), // sourceRequest
-			read(), // delegateData
-			read(), // delegationType
-			read(), // userRequest
-			read() // originalRequest
+			sourceRequest,
+			delegateData,
+			delegationType,
+			userRequest,
+			originalRequest
 		);
-		obj.deserialize(context);
+		obj.deserialize(c4.rest);
 		return obj;
 	}
 

package/lib/dll/DelegatedModuleFactoryPlugin.js

@@ -35,6 +35,7 @@ class DelegatedModuleFactoryPlugin {
 	 * @param {Options} options options
 	 */
 	constructor(options) {
+		/** @type {Options} */
 		this.options = options;
 		options.type = options.type || "require";
 		options.extensions = options.extensions || ["", ".js", ".json", ".wasm"];

package/lib/dll/DelegatedPlugin.js

@@ -19,6 +19,7 @@ class DelegatedPlugin {
 	 * @param {Options} options options
 	 */
 	constructor(options) {
+		/** @type {Options} */
 		this.options = options;
 	}
 

package/lib/dll/DllEntryPlugin.js

@@ -25,8 +25,11 @@ class DllEntryPlugin {
 	 * @param {Options} options options
 	 */
 	constructor(context, entries, options) {
+		/** @type {string} */
 		this.context = context;
+		/** @type {Entries} */
 		this.entries = entries;
+		/** @type {Options} */
 		this.options = options;
 	}
 

package/lib/dll/DllModule.js

@@ -28,8 +28,8 @@ const makeSerializable = require("../util/makeSerializable");
 /** @typedef {import("../Module").Sources} Sources */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string]>} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
@@ -51,6 +51,7 @@ class DllModule extends Module {
 		// Info from Factory
 		/** @type {Dependency[]} */
 		this.dependencies = dependencies;
+		/** @type {string} */
 		this.name = name;
 	}
 

package/lib/dll/DllPlugin.js

@@ -11,6 +11,7 @@ const LibManifestPlugin = require("./LibManifestPlugin");
 
 /** @typedef {import("../../declarations/plugins/dll/DllPlugin").DllPluginOptions} DllPluginOptions */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module").FactoryMeta} FactoryMeta */
 /** @typedef {import("./DllEntryPlugin").Entries} Entries */
 /** @typedef {import("./DllEntryPlugin").Options} Options */
 
@@ -68,6 +69,21 @@ class DllPlugin {
 		new LibManifestPlugin({ ...this.options, entryOnly }).apply(compiler);
 		if (!entryOnly) {
 			new FlagAllModulesAsUsedPlugin(PLUGIN_NAME).apply(compiler);
+			compiler.hooks.compilation.tap(
+				PLUGIN_NAME,
+				(_compilation, { normalModuleFactory }) => {
+					normalModuleFactory.hooks.module.tap(
+						{ name: PLUGIN_NAME, stage: 10 },
+						(module) => {
+							if (module.factoryMeta === undefined) {
+								module.factoryMeta = {};
+							}
+							module.factoryMeta.sideEffectFree = false;
+							return module;
+						}
+					);
+				}
+			);
 		}
 	}
 }

package/lib/dll/DllReferencePlugin.js

@@ -30,6 +30,7 @@ class DllReferencePlugin {
 	 * @param {DllReferencePluginOptions} options options object
 	 */
 	constructor(options) {
+		/** @type {DllReferencePluginOptions} */
 		this.options = options;
 	}
 
@@ -188,7 +189,9 @@ class DllManifestError extends WebpackError {
 	constructor(filename, message) {
 		super();
 
+		/** @type {string} */
 		this.name = "DllManifestError";
+		/** @type {string} */
 		this.message = `Dll manifest ${filename}\n${message}`;
 	}
 }

package/lib/dll/LibManifestPlugin.js

@@ -44,6 +44,7 @@ class LibManifestPlugin {
 	 * @param {LibManifestPluginOptions} options the options
 	 */
 	constructor(options) {
+		/** @type {LibManifestPluginOptions} */
 		this.options = options;
 	}
 

package/lib/electron/ElectronTargetPlugin.js

@@ -7,17 +7,22 @@
 
 const ExternalsPlugin = require("../ExternalsPlugin");
 
+/** @typedef {import("../../declarations/WebpackOptions").ExternalsType} ExternalsType */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency")} Dependency */
 /** @typedef {"main" | "preload" | "renderer"} ElectronContext */
 
 class ElectronTargetPlugin {
 	/**
 	 * Creates an instance of ElectronTargetPlugin.
 	 * @param {ElectronContext=} context in main, preload or renderer context?
+	 * @param {ExternalsType=} type default external type
 	 */
-	constructor(context) {
+	constructor(context, type = "node-commonjs") {
 		/** @type {ElectronContext | undefined} */
 		this._context = context;
+		/** @type {ExternalsType} */
+		this.type = type;
 	}
 
 	/**
@@ -26,7 +31,20 @@ class ElectronTargetPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		new ExternalsPlugin("node-commonjs", [
+		/**
+		 * @param {Dependency} dependency the dependency
+		 * @returns {ExternalsType} the external type
+		 */
+		const externalType = (dependency) => {
+			// When `require` electron built-in modules with module output
+			// we should still emit `node-commonjs` for compatibility
+			if (dependency.category === "commonjs") {
+				return "node-commonjs";
+			}
+
+			return this.type;
+		};
+		new ExternalsPlugin(externalType, [
 			"clipboard",
 			"crash-reporter",
 			"electron",
@@ -38,7 +56,7 @@ class ElectronTargetPlugin {
 		]).apply(compiler);
 		switch (this._context) {
 			case "main":
-				new ExternalsPlugin("node-commonjs", [
+				new ExternalsPlugin(externalType, [
 					"app",
 					"auto-updater",
 					"browser-window",
@@ -58,7 +76,7 @@ class ElectronTargetPlugin {
 				break;
 			case "preload":
 			case "renderer":
-				new ExternalsPlugin("node-commonjs", [
+				new ExternalsPlugin(externalType, [
 					"desktop-capturer",
 					"ipc-renderer",
 					"remote",

package/lib/errors/ConcurrentCompilationError.js

@@ -13,6 +13,7 @@ class ConcurrentCompilationError extends WebpackError {
 			"You ran Webpack twice. Each instance only supports a single concurrent compilation at a time."
 		);
 
+		/** @type {string} */
 		this.name = "ConcurrentCompilationError";
 	}
 }

package/lib/errors/HookWebpackError.js

@@ -8,8 +8,8 @@
 const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
 
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Error, string]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Error, string]>} ObjectSerializerContext */
 
 /**
  * Defines the callback callback.
@@ -29,12 +29,16 @@ class HookWebpackError extends WebpackError {
 	constructor(error, hook) {
 		super(error ? error.message : undefined, error ? { cause: error } : {});
 
+		/** @type {string} */
 		this.hook = hook;
+		/** @type {Error} */
 		this.error = error;
 		/** @type {string} */
 		this.name = "HookWebpackError";
+		/** @type {boolean} */
 		this.hideStack = true;
 		this.stack += `\n-- inner error --\n${error ? error.stack : ""}`;
+		/** @type {string} */
 		this.details = `caused by plugins in ${hook}\n${error ? error.stack : ""}`;
 	}
 
@@ -43,11 +47,7 @@ class HookWebpackError extends WebpackError {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-
-		write(this.error);
-		write(this.hook);
-
+		context.write(this.error).write(this.hook);
 		super.serialize(context);
 	}
 
@@ -56,12 +56,10 @@ class HookWebpackError extends WebpackError {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-
-		this.error = read();
-		this.hook = read();
-
-		super.deserialize(context);
+		this.error = context.read();
+		const c1 = context.rest;
+		this.hook = c1.read();
+		super.deserialize(c1.rest);
 	}
 }
 

package/lib/errors/IgnoreErrorModuleFactory.js

@@ -22,6 +22,7 @@ class IgnoreErrorModuleFactory extends ModuleFactory {
 	constructor(normalModuleFactory) {
 		super();
 
+		/** @type {NormalModuleFactory} */
 		this.normalModuleFactory = normalModuleFactory;
 	}
 

package/lib/errors/InvalidDependenciesModuleWarning.js

@@ -32,7 +32,9 @@ ${depsList.slice(0, 3).join("\n")}${
 
 		/** @type {string} */
 		this.name = "InvalidDependenciesModuleWarning";
+		/** @type {string} */
 		this.details = depsList.slice(3).join("\n");
+		/** @type {Module} */
 		this.module = module;
 	}
 }