webpack 5.107.1 → 5.108.0

package/lib/hmr/JavascriptHotModuleReplacement.runtime.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
@@ -6,29 +5,127 @@
 
 "use strict";
 
-var $installedChunks$ = undefined;
-var $loadUpdateChunk$ = undefined;
-var $moduleCache$ = undefined;
-var $moduleFactories$ = undefined;
-var $ensureChunkHandlers$ = undefined;
-var $hasOwnProperty$ = undefined;
-var $hmrModuleData$ = undefined;
-var $hmrDownloadUpdateHandlers$ = undefined;
-var $hmrInvalidateModuleHandlers$ = undefined;
-var __webpack_require__ = undefined;
+/** @typedef {string | number} ModuleId */
+/** @typedef {Record<string, unknown>} HotData */
+/** @typedef {(data: HotData) => void} DisposeHandler */
+/** @typedef {(outdatedDependencies: ModuleId[]) => void} AcceptCallback */
+/** @typedef {(err: unknown, context: { moduleId: ModuleId, dependencyId: ModuleId }) => void} AcceptErrorHandler */
+/** @typedef {{ type: string, moduleId: ModuleId, dependencyId?: ModuleId, error: unknown, originalError?: unknown }} HotErrorEvent */
+/** @typedef {(reportError: (err: unknown) => void) => Promise<ModuleId[]>} ApplyFn */
+
+/**
+ * @typedef {object} ApplyOptions
+ * @property {boolean=} ignoreUnaccepted ignore unaccepted modules
+ * @property {boolean=} ignoreDeclined ignore declined modules
+ * @property {boolean=} ignoreErrored ignore errors thrown while applying
+ * @property {((event: ModuleEffect) => void)=} onDeclined called for declined modules
+ * @property {((event: ModuleEffect) => void)=} onUnaccepted called for unaccepted modules
+ * @property {((event: ModuleEffect) => void)=} onAccepted called for accepted modules
+ * @property {((event: ModuleEffect) => void)=} onDisposed called for disposed modules
+ * @property {((event: HotErrorEvent) => void)=} onErrored called on apply errors
+ */
+
+/**
+ * @typedef {object} ApplyResult
+ * @property {Error=} error fatal error that aborts the update
+ * @property {(() => void)=} dispose dispose phase of the update
+ * @property {ApplyFn=} apply apply phase of the update
+ */
+
+/** @typedef {(options: ApplyOptions) => ApplyResult} ApplyHandler */
+/** @typedef {(moduleId: ModuleId, applyHandlers: ApplyHandler[]) => void} InvalidateModuleHandler */
+/** @typedef {(chunkIds: ModuleId[], removedChunks: ModuleId[], removedModules: ModuleId[], promises: Promise<unknown>[], applyHandlers: ApplyHandler[], updatedModulesList: ModuleId[], css: ModuleId[] | undefined, forceLoadChunks: ModuleId[] | undefined) => void} DownloadUpdateHandler */
+/** @typedef {(chunkId: ModuleId, promises: Promise<unknown>[]) => void} EnsureChunkHandler */
+/** @typedef {(webpackRequire: (id: ModuleId) => unknown) => void} RuntimeModuleFn */
+
+/**
+ * @typedef {object} Hot
+ * @property {Record<ModuleId, AcceptCallback>} _acceptedDependencies accept callbacks by dependency id
+ * @property {Record<ModuleId, AcceptErrorHandler | undefined>} _acceptedErrorHandlers error handlers by dependency id
+ * @property {Record<ModuleId, boolean>} _declinedDependencies declined dependency ids
+ * @property {boolean | EXPECTED_FUNCTION} _selfAccepted true or the self-accept error handler
+ * @property {boolean} _selfDeclined module declined itself
+ * @property {boolean} _selfInvalidated module invalidated itself
+ * @property {DisposeHandler[]} _disposeHandlers registered dispose handlers
+ * @property {boolean} _main module is the entry of the update
+ * @property {() => void} _requireSelf re-require the module on apply
+ * @property {boolean} active module is not disposed
+ */
+
+/**
+ * @typedef {object} HotModule
+ * @property {ModuleId} id module id
+ * @property {Hot} hot hot API of the module
+ * @property {ModuleId[]} parents ids of modules requiring this module
+ * @property {ModuleId[]} children ids of modules required by this module
+ */
+
+/**
+ * @typedef {object} ModuleEffect
+ * @property {string} type effect type
+ * @property {ModuleId} moduleId affected module id
+ * @property {ModuleId[]=} chain update propagation chain
+ * @property {ModuleId=} parentId declining parent id
+ * @property {ModuleId[]=} outdatedModules outdated module ids
+ * @property {Record<ModuleId, ModuleId[]>=} outdatedDependencies outdated dependencies by module id
+ */
+
+/** @typedef {{ chain: ModuleId[], id: ModuleId }} QueueItem */
+/** @typedef {{ module: ModuleId, require: (id?: ModuleId) => void, errorHandler: boolean | EXPECTED_FUNCTION }} SelfAcceptedModule */
+
+// Globals injected by code generation; declared here only to type the template.
+/* eslint-disable no-unassigned-vars */
+/** @type {Record<ModuleId, unknown>} */
+var $installedChunks$;
+/** @type {(chunkId: ModuleId, updatedModulesList?: ModuleId[]) => Promise<unknown>} */
+var $loadUpdateChunk$;
+/** @type {Record<ModuleId, HotModule>} */
+var $moduleCache$;
+/** @type {Record<ModuleId, EXPECTED_FUNCTION>} */
+var $moduleFactories$;
+/** @type {Record<string, EnsureChunkHandler>} */
+var $ensureChunkHandlers$;
+/** @type {(obj: object, key: ModuleId) => boolean} */
+var $hasOwnProperty$;
+/** @type {Record<ModuleId, HotData>} */
+var $hmrModuleData$;
+/** @type {Record<string, DownloadUpdateHandler>} */
+var $hmrDownloadUpdateHandlers$;
+/** @type {Record<string, InvalidateModuleHandler>} */
+var $hmrInvalidateModuleHandlers$;
+/** @type {(id: ModuleId) => unknown} */
+var __webpack_require__;
+/* eslint-enable no-unassigned-vars */
 
 module.exports = function () {
+	/** @type {Record<ModuleId, boolean>} */
 	var currentUpdateChunks;
+	/** @type {Record<ModuleId, EXPECTED_FUNCTION | false>} */
 	var currentUpdate;
+	/** @type {ModuleId[]} */
 	var currentUpdateRemovedChunks;
+	/** @type {RuntimeModuleFn[]} */
 	var currentUpdateRuntime;
+	/**
+	 * @param {ApplyOptions} options apply options
+	 * @returns {ApplyResult} dispose/apply handlers or a fatal error
+	 */
 	function applyHandler(options) {
 		if ($ensureChunkHandlers$) delete $ensureChunkHandlers$.$key$Hmr;
-		currentUpdateChunks = undefined;
+		currentUpdateChunks = /** @type {Record<ModuleId, boolean>} */ (
+			/** @type {unknown} */ (undefined)
+		);
+		/**
+		 * @param {ModuleId} updateModuleId updated module id
+		 * @returns {ModuleEffect} effect of updating the module
+		 */
 		function getAffectedModuleEffects(updateModuleId) {
+			/** @type {ModuleId[]} */
 			var outdatedModules = [updateModuleId];
+			/** @type {Record<ModuleId, ModuleId[]>} */
 			var outdatedDependencies = {};
 
+			/** @type {QueueItem[]} */
 			var queue = outdatedModules.map(function (id) {
 				return {
 					chain: [id],
@@ -36,7 +133,7 @@ module.exports = function () {
 				};
 			});
 			while (queue.length > 0) {
-				var queueItem = queue.pop();
+				var queueItem = /** @type {QueueItem} */ (queue.pop());
 				var moduleId = queueItem.id;
 				var chain = queueItem.chain;
 				var module = $moduleCache$[moduleId];
@@ -95,6 +192,11 @@ module.exports = function () {
 			};
 		}
 
+		/**
+		 * @param {ModuleId[]} a target set
+		 * @param {ModuleId[]} b items to add
+		 * @returns {void}
+		 */
 		function addAllToSet(a, b) {
 			for (var i = 0; i < b.length; i++) {
 				var item = b[i];
@@ -104,10 +206,17 @@ module.exports = function () {
 
 		// at begin all updates modules are outdated
 		// the "outdated" status can propagate to parents if they don't accept the children
+		/** @type {Record<ModuleId, ModuleId[]>} */
 		var outdatedDependencies = {};
+		/** @type {ModuleId[]} */
 		var outdatedModules = [];
+		/** @type {Record<ModuleId, EXPECTED_FUNCTION>} */
 		var appliedUpdate = {};
 
+		/**
+		 * @param {HotModule} module disposed module
+		 * @returns {void}
+		 */
 		var warnUnexpectedRequire = function warnUnexpectedRequire(module) {
 			console.warn(
 				"[HMR] unexpected require(" + module.id + ") to disposed module"
@@ -117,6 +226,7 @@ module.exports = function () {
 		for (var moduleId in currentUpdate) {
 			if ($hasOwnProperty$(currentUpdate, moduleId)) {
 				var newModuleFactory = currentUpdate[moduleId];
+				/** @type {ModuleEffect} */
 				var result = newModuleFactory
 					? getAffectedModuleEffects(moduleId)
 					: {
@@ -176,15 +286,24 @@ module.exports = function () {
 					};
 				}
 				if (doApply) {
-					appliedUpdate[moduleId] = newModuleFactory;
-					addAllToSet(outdatedModules, result.outdatedModules);
-					for (moduleId in result.outdatedDependencies) {
-						if ($hasOwnProperty$(result.outdatedDependencies, moduleId)) {
+					appliedUpdate[moduleId] = /** @type {EXPECTED_FUNCTION} */ (
+						newModuleFactory
+					);
+					addAllToSet(
+						outdatedModules,
+						/** @type {ModuleId[]} */ (result.outdatedModules)
+					);
+					var resultOutdatedDependencies =
+						/** @type {Record<ModuleId, ModuleId[]>} */ (
+							result.outdatedDependencies
+						);
+					for (moduleId in resultOutdatedDependencies) {
+						if ($hasOwnProperty$(resultOutdatedDependencies, moduleId)) {
 							if (!outdatedDependencies[moduleId])
 								outdatedDependencies[moduleId] = [];
 							addAllToSet(
 								outdatedDependencies[moduleId],
-								result.outdatedDependencies[moduleId]
+								resultOutdatedDependencies[moduleId]
 							);
 						}
 					}
@@ -195,9 +314,12 @@ module.exports = function () {
 				}
 			}
 		}
-		currentUpdate = undefined;
+		currentUpdate = /** @type {Record<ModuleId, EXPECTED_FUNCTION | false>} */ (
+			/** @type {unknown} */ (undefined)
+		);
 
 		// Store self accepted outdated modules to require them later by the module system
+		/** @type {SelfAcceptedModule[]} */
 		var outdatedSelfAcceptedModules = [];
 		for (var j = 0; j < outdatedModules.length; j++) {
 			var outdatedModuleId = outdatedModules[j];
@@ -218,6 +340,7 @@ module.exports = function () {
 			}
 		}
 
+		/** @type {ModuleId[]} */
 		var moduleOutdatedDependencies;
 
 		return {
@@ -225,15 +348,18 @@ module.exports = function () {
 				currentUpdateRemovedChunks.forEach(function (chunkId) {
 					delete $installedChunks$[chunkId];
 				});
-				currentUpdateRemovedChunks = undefined;
+				currentUpdateRemovedChunks = /** @type {ModuleId[]} */ (
+					/** @type {unknown} */ (undefined)
+				);
 
 				var idx;
 				var queue = outdatedModules.slice();
 				while (queue.length > 0) {
-					var moduleId = queue.pop();
+					var moduleId = /** @type {ModuleId} */ (queue.pop());
 					var module = $moduleCache$[moduleId];
 					if (!module) continue;
 
+					/** @type {HotData} */
 					var data = {};
 
 					// Call dispose handlers
@@ -281,6 +407,7 @@ module.exports = function () {
 				}
 			},
 			apply: function (reportError) {
+				/** @type {Promise<unknown>[]} */
 				var acceptPromises = [];
 				// insert new code
 				for (var updateModuleId in appliedUpdate) {
@@ -301,8 +428,11 @@ module.exports = function () {
 						if (module) {
 							moduleOutdatedDependencies =
 								outdatedDependencies[outdatedModuleId];
+							/** @type {AcceptCallback[]} */
 							var callbacks = [];
+							/** @type {(AcceptErrorHandler | undefined)[]} */
 							var errorHandlers = [];
+							/** @type {ModuleId[]} */
 							var dependenciesForCallbacks = [];
 							for (var j = 0; j < moduleOutdatedDependencies.length; j++) {
 								var dependency = moduleOutdatedDependencies[j];
@@ -318,13 +448,15 @@ module.exports = function () {
 								}
 							}
 							for (var k = 0; k < callbacks.length; k++) {
+								/** @type {unknown} */
 								var result;
 								try {
 									result = callbacks[k].call(null, moduleOutdatedDependencies);
 								} catch (err) {
 									if (typeof errorHandlers[k] === "function") {
 										try {
-											errorHandlers[k](err, {
+											/** @type {AcceptErrorHandler} */
+											(errorHandlers[k])(err, {
 												moduleId: outdatedModuleId,
 												dependencyId: dependenciesForCallbacks[k]
 											});
@@ -357,8 +489,12 @@ module.exports = function () {
 										}
 									}
 								}
-								if (result && typeof result.then === "function") {
-									acceptPromises.push(result);
+								if (
+									result &&
+									typeof (/** @type {{ then?: unknown }} */ (result).then) ===
+										"function"
+								) {
+									acceptPromises.push(/** @type {Promise<unknown>} */ (result));
 								}
 							}
 						}
@@ -434,7 +570,9 @@ module.exports = function () {
 		removedModules,
 		promises,
 		applyHandlers,
-		updatedModulesList
+		updatedModulesList,
+		css,
+		forceLoadChunks
 	) {
 		applyHandlers.push(applyHandler);
 		currentUpdateChunks = {};
@@ -442,7 +580,7 @@ module.exports = function () {
 		currentUpdate = removedModules.reduce(function (obj, key) {
 			obj[key] = false;
 			return obj;
-		}, {});
+		}, /** @type {Record<ModuleId, EXPECTED_FUNCTION | false>} */ ({}));
 		currentUpdateRuntime = [];
 		chunkIds.forEach(function (chunkId) {
 			if (
@@ -466,6 +604,15 @@ module.exports = function () {
 					currentUpdateChunks[chunkId] = true;
 				}
 			};
+			// Force-load chunks that now own modules orphaned by a removed chunk;
+			// ensure handlers skip already-installed chunks, so no guard is needed.
+			if (forceLoadChunks) {
+				forceLoadChunks.forEach(function (chunkId) {
+					Object.keys($ensureChunkHandlers$).forEach(function (key) {
+						$ensureChunkHandlers$[key](chunkId, promises);
+					});
+				});
+			}
 		}
 	};
 };

package/lib/hmr/LazyCompilationPlugin.js

@@ -18,6 +18,7 @@ const {
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const CommonJsRequireDependency = require("../dependencies/CommonJsRequireDependency");
+const { resolveByProperty } = require("../util/cleverMerge");
 const { registerNotSerializable } = require("../util/serialization");
 
 /** @typedef {import("../config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
@@ -25,6 +26,7 @@ const { registerNotSerializable } = require("../util/serialization");
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../Module").BuildCallback} BuildCallback */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
@@ -45,6 +47,96 @@ const { registerNotSerializable } = require("../util/serialization");
 
 /** @typedef {{ client: string, data: string, active: boolean }} ModuleResult */
 
+/**
+ * Library wrappers of these types pass external modules as closure arguments
+ * (e.g. `__WEBPACK_EXTERNAL_MODULE_react__`) baked into the entry chunk at
+ * render time. When `lazyCompilation` activates a proxy for the first time,
+ * any external dependency the lazily-built module pulls in lands in a hot
+ * update chunk that lives outside the original wrapper closure, so the
+ * factory body can't resolve its closure identifier and throws at runtime.
+ * Reserving the externals up front (during the inactive build) folds them
+ * into the initial wrapper, so the closure identifiers are already defined
+ * when the activation update arrives.
+ */
+const CLOSURE_LIBRARY_TYPES = new Set([
+	"umd",
+	"umd2",
+	"amd",
+	"amd-require",
+	"system"
+]);
+
+/**
+ * `enabledLibraryTypes` covers both the global `output.library.type` and any
+ * per-entry `entry.<name>.library.type`, so a UMD/AMD/System wrapper attached
+ * to an individual entry is still detected.
+ * @param {import("../../declarations/WebpackOptions").OutputNormalized} output normalized output option
+ * @returns {boolean} true when at least one library wrapper passes externals as closure arguments
+ */
+const hasClosureLibrary = (output) => {
+	const enabled = output.enabledLibraryTypes;
+	if (enabled) {
+		for (const type of enabled) {
+			if (CLOSURE_LIBRARY_TYPES.has(type)) return true;
+		}
+	}
+	if (output.library && output.library.type) {
+		return CLOSURE_LIBRARY_TYPES.has(output.library.type);
+	}
+	return false;
+};
+
+/**
+ * Collects request strings from statically-enumerable externals (string,
+ * object, and arrays of those). Function and RegExp forms are skipped because
+ * their effective request set isn't knowable until something asks for it.
+ *
+ * Layer resolution mirrors `ExternalModuleFactoryPlugin.resolveLayer`: the
+ * effective map for the proxy's layer is computed via the same
+ * `resolveByProperty(..., "byLayer", layer)` helper that the externals system
+ * uses, so `byLayer.default` fallback and function-form `byLayer` entries are
+ * honored the same way.
+ *
+ * Entries whose effective value is `false` are skipped — `false` explicitly
+ * disables externalization for that request, and reserving it would force the
+ * real module into the entry chunk.
+ * @param {import("../../declarations/WebpackOptions").Externals | undefined} externals normalized externals option
+ * @param {string | null} layer issuer layer for which to resolve `byLayer`
+ * @returns {Set<string>} requests to reserve in the entry chunk
+ */
+const collectStaticExternalRequests = (externals, layer) => {
+	/** @type {Set<string>} */
+	const requests = new Set();
+	if (!externals) return requests;
+	/** @param {import("../../declarations/WebpackOptions").ExternalItem} item one item */
+	const visit = (item) => {
+		if (typeof item === "string") {
+			requests.add(item);
+			return;
+		}
+		if (!item || typeof item !== "object" || item instanceof RegExp) return;
+		const resolved = /** @type {Record<string, unknown>} */ (
+			resolveByProperty(
+				/** @type {Record<string, unknown>} */ (item),
+				"byLayer",
+				layer
+			)
+		);
+		for (const [request, value] of Object.entries(resolved)) {
+			// `false` explicitly opts the request out of externalization; reserving
+			// it would pull the actual module into the entry chunk.
+			if (value === false) continue;
+			requests.add(request);
+		}
+	};
+	if (Array.isArray(externals)) {
+		for (const item of externals) visit(item);
+	} else {
+		visit(externals);
+	}
+	return requests;
+};
+
 /**
  * Defines the backend api type used by this module.
  * @typedef {object} BackendApi
@@ -88,6 +180,7 @@ class LazyCompilationDependency extends Dependency {
 	 */
 	constructor(proxyModule) {
 		super();
+		/** @type {LazyCompilationProxyModule} */
 		this.proxyModule = proxyModule;
 	}
 
@@ -110,6 +203,14 @@ class LazyCompilationDependency extends Dependency {
 
 registerNotSerializable(LazyCompilationDependency);
 
+/**
+ * Defines the build info properties specific to lazy compilation proxy modules.
+ * @typedef {object} KnownLazyCompilationProxyModuleBuildInfo
+ * @property {boolean=} active whether the proxied module was active when built
+ */
+
+/** @typedef {BuildInfo & KnownLazyCompilationProxyModuleBuildInfo} LazyCompilationProxyModuleBuildInfo */
+
 class LazyCompilationProxyModule extends Module {
 	/**
 	 * Creates an instance of LazyCompilationProxyModule.
@@ -126,10 +227,18 @@ class LazyCompilationProxyModule extends Module {
 			context,
 			originalModule.layer
 		);
+		// Redeclared with the lazy compilation proxy specific shape
+		/** @type {LazyCompilationProxyModuleBuildInfo | undefined} */
+		this.buildInfo = undefined;
+		/** @type {Module} */
 		this.originalModule = originalModule;
+		/** @type {string} */
 		this.request = request;
+		/** @type {string} */
 		this.client = client;
+		/** @type {string} */
 		this.data = data;
+		/** @type {boolean} */
 		this.active = active;
 	}
 
@@ -213,6 +322,19 @@ class LazyCompilationProxyModule extends Module {
 			const block = new AsyncDependenciesBlock({});
 			block.addDependency(dep);
 			this.addBlock(block);
+		} else if (hasClosureLibrary(compilation.options.output)) {
+			// Reserve statically-declared externals as dependencies of the inactive
+			// proxy so the initial entry chunk's library wrapper already exposes
+			// their closure identifiers (e.g. `__WEBPACK_EXTERNAL_MODULE_react__`).
+			// Once the proxy activates and the lazily-built module references those
+			// externals, the identifiers resolve normally instead of throwing.
+			const requests = collectStaticExternalRequests(
+				options.externals,
+				this.layer
+			);
+			for (const request of requests) {
+				this.addDependency(new CommonJsRequireDependency(request));
+			}
 		}
 		callback();
 	}
@@ -250,17 +372,19 @@ class LazyCompilationProxyModule extends Module {
 		);
 		const clientModule = moduleGraph.getModule(clientDep);
 		const block = this.blocks[0];
+		const cst = runtimeTemplate.renderConst();
+		const lt = runtimeTemplate.renderLet();
 		const client = Template.asString([
-			`var client = ${runtimeTemplate.moduleExports({
+			`${cst} client = ${runtimeTemplate.moduleExports({
 				module: clientModule,
 				chunkGraph,
 				request: clientDep.userRequest,
 				runtimeRequirements
 			})}`,
-			`var data = ${JSON.stringify(this.data)};`
+			`${cst} data = ${JSON.stringify(this.data)};`
 		]);
 		const keepActive = Template.asString([
-			`var dispose = client.keepAlive({ data: data, active: ${JSON.stringify(
+			`${cst} dispose = client.keepAlive({ data: data, active: ${JSON.stringify(
 				Boolean(block)
 			)}, module: module, onError: onError });`
 		]);
@@ -288,7 +412,7 @@ class LazyCompilationProxyModule extends Module {
 						chunkGraph.getModuleId(module)
 					)}, function() { module.hot.invalidate(); });`,
 					"module.hot.dispose(function(data) { delete data.resolveSelf; dispose(data); });",
-					"if (module.hot.data && module.hot.data.resolveSelf) module.hot.data.resolveSelf(module.exports);"
+					`if (${runtimeTemplate.optionalChaining("module.hot.data", "resolveSelf")}) module.hot.data.resolveSelf(module.exports);`
 				]),
 				"}",
 				"function onError() { /* ignore */ }",
@@ -297,12 +421,12 @@ class LazyCompilationProxyModule extends Module {
 		} else {
 			source = Template.asString([
 				client,
-				"var resolveSelf, onError;",
+				`${lt} resolveSelf, onError;`,
 				"module.exports = new Promise(function(resolve, reject) { resolveSelf = resolve; onError = reject; });",
 				"if (module.hot) {",
 				Template.indent([
 					"module.hot.accept();",
-					"if (module.hot.data && module.hot.data.resolveSelf) module.hot.data.resolveSelf(module.exports);",
+					`if (${runtimeTemplate.optionalChaining("module.hot.data", "resolveSelf")}) module.hot.data.resolveSelf(module.exports);`,
 					"module.hot.dispose(function(data) { data.resolveSelf = resolveSelf; dispose(data); });"
 				]),
 				"}",
@@ -388,9 +512,13 @@ class LazyCompilationPlugin {
 	 * @param {Options} options options
 	 */
 	constructor({ backend, entries, imports, test }) {
+		/** @type {BackEnd} */
 		this.backend = backend;
+		/** @type {boolean | undefined} */
 		this.entries = entries;
+		/** @type {boolean | undefined} */
 		this.imports = imports;
+		/** @type {string | RegExp | TestFn | undefined} */
 		this.test = test;
 	}