webpack 5.107.2 → 5.108.0

package/lib/dependencies/StaticExportsDependency.js

@@ -10,11 +10,11 @@ const NullDependency = require("./NullDependency");
 
 /** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-
 /** @typedef {string[] | true} Exports */
 
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Exports, boolean]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Exports, boolean]>} ObjectSerializerContext */
+
 class StaticExportsDependency extends NullDependency {
 	/**
 	 * Creates an instance of StaticExportsDependency.
@@ -23,7 +23,9 @@ class StaticExportsDependency extends NullDependency {
 	 */
 	constructor(exports, canMangle) {
 		super();
+		/** @type {Exports} */
 		this.exports = exports;
+		/** @type {boolean} */
 		this.canMangle = canMangle;
 	}
 
@@ -49,9 +51,7 @@ class StaticExportsDependency extends NullDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-		write(this.exports);
-		write(this.canMangle);
+		context.write(this.exports).write(this.canMangle);
 		super.serialize(context);
 	}
 
@@ -60,10 +60,10 @@ class StaticExportsDependency extends NullDependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-		this.exports = read();
-		this.canMangle = read();
-		super.deserialize(context);
+		this.exports = context.read();
+		const c1 = context.rest;
+		this.canMangle = c1.read();
+		super.deserialize(c1.rest);
 	}
 }
 

package/lib/dependencies/SystemPlugin.js

@@ -155,8 +155,10 @@ class SystemImportDeprecationWarning extends WebpackError {
 				"For more info visit https://webpack.js.org/guides/code-splitting/"
 		);
 
+		/** @type {string} */
 		this.name = "SystemImportDeprecationWarning";
 
+		/** @type {DependencyLocation} */
 		this.loc = loc;
 	}
 }

package/lib/dependencies/URLContextDependency.js

@@ -11,8 +11,8 @@ const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTempl
 
 /** @typedef {import("../ContextModule").ContextOptions} ContextOptions */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range]>} ObjectSerializerContext */
 
 /** @typedef {ContextOptions & { request: string }} ContextDependencyOptions */
 
@@ -42,8 +42,7 @@ class URLContextDependency extends ContextDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-		write(this.valueRange);
+		context.write(this.valueRange);
 		super.serialize(context);
 	}
 
@@ -52,9 +51,8 @@ class URLContextDependency extends ContextDependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-		this.valueRange = read();
-		super.deserialize(context);
+		this.valueRange = context.read();
+		super.deserialize(context.rest);
 	}
 }
 

package/lib/dependencies/URLDependency.js

@@ -22,8 +22,8 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../optimize/InnerGraph").UsedByExports} UsedByExports */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range, boolean, UsedByExports | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range, boolean, UsedByExports | undefined]>} ObjectSerializerContext */
 
 const getIgnoredRawDataUrlModule = memoize(
 	() => new RawDataUrlModule("data:,", "ignored-asset", "(ignored asset)")
@@ -41,6 +41,7 @@ class URLDependency extends ModuleDependency {
 		super(request);
 		this.range = range;
 		this.outerRange = outerRange;
+		/** @type {boolean} */
 		this.relative = relative || false;
 		/** @type {UsedByExports | undefined} */
 		this.usedByExports = undefined;
@@ -60,11 +61,7 @@ class URLDependency extends ModuleDependency {
 	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
 	 */
 	getCondition(moduleGraph) {
-		return getDependencyUsedByExportsCondition(
-			this,
-			this.usedByExports,
-			moduleGraph
-		);
+		return getDependencyUsedByExportsCondition(this, moduleGraph);
 	}
 
 	/**
@@ -81,10 +78,10 @@ class URLDependency extends ModuleDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-		write(this.outerRange);
-		write(this.relative);
-		write(this.usedByExports);
+		context
+			.write(this.outerRange)
+			.write(this.relative)
+			.write(this.usedByExports);
 		super.serialize(context);
 	}
 
@@ -93,11 +90,12 @@ class URLDependency extends ModuleDependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-		this.outerRange = read();
-		this.relative = read();
-		this.usedByExports = read();
-		super.deserialize(context);
+		this.outerRange = context.read();
+		const c1 = context.rest;
+		this.relative = c1.read();
+		const c2 = c1.rest;
+		this.usedByExports = c2.read();
+		super.deserialize(c2.rest);
 	}
 }
 

package/lib/dependencies/UnsupportedDependency.js

@@ -12,8 +12,8 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, Range]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string, Range]>} ObjectSerializerContext */
 
 class UnsupportedDependency extends NullDependency {
 	/**
@@ -24,6 +24,7 @@ class UnsupportedDependency extends NullDependency {
 	constructor(request, range) {
 		super();
 
+		/** @type {string} */
 		this.request = request;
 		this.range = range;
 	}
@@ -33,11 +34,7 @@ class UnsupportedDependency extends NullDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-
-		write(this.request);
-		write(this.range);
-
+		context.write(this.request).write(this.range);
 		super.serialize(context);
 	}
 
@@ -46,12 +43,10 @@ class UnsupportedDependency extends NullDependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-
-		this.request = read();
-		this.range = read();
-
-		super.deserialize(context);
+		this.request = context.read();
+		const c1 = context.rest;
+		this.range = c1.read();
+		super.deserialize(c1.rest);
 	}
 }
 

package/lib/dependencies/WebAssemblyExportImportedDependency.js

@@ -12,8 +12,8 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, string, string]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string, string, string]>} ObjectSerializerContext */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 class WebAssemblyExportImportedDependency extends ModuleDependency {
@@ -49,7 +49,8 @@ class WebAssemblyExportImportedDependency extends ModuleDependency {
 	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
-		return [[this.name]];
+		// re-exporting wasm glue needs the real binding, never an inlined literal
+		return [{ name: [this.name], canInline: false }];
 	}
 
 	get type() {
@@ -65,12 +66,7 @@ class WebAssemblyExportImportedDependency extends ModuleDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-
-		write(this.exportName);
-		write(this.name);
-		write(this.valueType);
-
+		context.write(this.exportName).write(this.name).write(this.valueType);
 		super.serialize(context);
 	}
 
@@ -79,13 +75,12 @@ class WebAssemblyExportImportedDependency extends ModuleDependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-
-		this.exportName = read();
-		this.name = read();
-		this.valueType = read();
-
-		super.deserialize(context);
+		this.exportName = context.read();
+		const c1 = context.rest;
+		this.name = c1.read();
+		const c2 = c1.rest;
+		this.valueType = c2.read();
+		super.deserialize(c2.rest);
 	}
 }
 

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;
 						}
@@ -412,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);
@@ -454,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);
@@ -559,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;
 	}