webpack 5.90.3 → 5.92.0

package/lib/util/mergeScope.js

@@ -0,0 +1,79 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("eslint-scope").Reference} Reference */
+/** @typedef {import("eslint-scope").Variable} Variable */
+/** @typedef {import("../javascript/JavascriptParser").AnyNode} AnyNode */
+/** @typedef {import("../javascript/JavascriptParser").Program} Program */
+
+/**
+ * @param {Variable} variable variable
+ * @returns {Reference[]} references
+ */
+const getAllReferences = variable => {
+	let set = variable.references;
+	// Look for inner scope variables too (like in class Foo { t() { Foo } })
+	const identifiers = new Set(variable.identifiers);
+	for (const scope of variable.scope.childScopes) {
+		for (const innerVar of scope.variables) {
+			if (innerVar.identifiers.some(id => identifiers.has(id))) {
+				set = set.concat(innerVar.references);
+				break;
+			}
+		}
+	}
+	return set;
+};
+
+/**
+ * @param {Program | Program[]} ast ast
+ * @param {AnyNode} node node
+ * @returns {undefined | AnyNode[]} result
+ */
+const getPathInAst = (ast, node) => {
+	if (ast === node) {
+		return [];
+	}
+
+	const nr = node.range;
+
+	const enterNode = n => {
+		if (!n) return undefined;
+		const r = n.range;
+		if (r) {
+			if (r[0] <= nr[0] && r[1] >= nr[1]) {
+				const path = getPathInAst(n, node);
+				if (path) {
+					path.push(n);
+					return path;
+				}
+			}
+		}
+		return undefined;
+	};
+
+	if (Array.isArray(ast)) {
+		for (let i = 0; i < ast.length; i++) {
+			const enterResult = enterNode(ast[i]);
+			if (enterResult !== undefined) return enterResult;
+		}
+	} else if (ast && typeof ast === "object") {
+		const keys = Object.keys(ast);
+		for (let i = 0; i < keys.length; i++) {
+			const value = ast[keys[i]];
+			if (Array.isArray(value)) {
+				const pathResult = getPathInAst(value, node);
+				if (pathResult !== undefined) return pathResult;
+			} else if (value && typeof value === "object") {
+				const enterResult = enterNode(value);
+				if (enterResult !== undefined) return enterResult;
+			}
+		}
+	}
+};
+
+module.exports = { getAllReferences, getPathInAst };

package/lib/util/runtime.js

@@ -229,22 +229,6 @@ const mergeRuntime = (a, b) => {
 };
 exports.mergeRuntime = mergeRuntime;
 
-/**
- * @param {RuntimeSpec[]} runtimes first
- * @param {RuntimeSpec} runtime second
- * @returns {RuntimeSpec} merged
- */
-exports.deepMergeRuntime = (runtimes, runtime) => {
-	if (!Array.isArray(runtimes)) {
-		return runtime;
-	}
-	let merged = runtime;
-	for (const r of runtimes) {
-		merged = mergeRuntime(runtime, r);
-	}
-	return merged;
-};
-
 /**
  * @param {RuntimeCondition} a first
  * @param {RuntimeCondition} b second
@@ -390,6 +374,7 @@ const subtractRuntime = (a, b) => {
 			}
 			const set = new SortableSet(a);
 			set.delete(b);
+			return set;
 		} else {
 			const set = new SortableSet();
 			for (const item of a) {
@@ -445,7 +430,7 @@ exports.filterRuntime = (runtime, filter) => {
 /**
  * @template T
  * @typedef {Map<string, T>} RuntimeSpecMapInnerMap
- * */
+ */
 
 /**
  * @template T

package/lib/util/semver.js

@@ -153,6 +153,9 @@ exports.parseRange = str => {
 				}
 				return [1, ...remainder.slice(1)];
 			case "~":
+				if (remainder.length === 2 && remainder[0] === 0) {
+					return [1, ...remainder.slice(1)];
+				}
 				return [2, ...remainder.slice(1)];
 			case ">=":
 				return remainder;

package/lib/util/smartGrouping.js

@@ -6,7 +6,7 @@
 "use strict";
 
 /**
- * @typedef {Object} GroupOptions
+ * @typedef {object} GroupOptions
  * @property {boolean=} groupChildren
  * @property {boolean=} force
  * @property {number=} targetGroupCount
@@ -15,7 +15,7 @@
 /**
  * @template T
  * @template R
- * @typedef {Object} GroupConfig
+ * @typedef {object} GroupConfig
  * @property {function(T): string[]} getKeys
  * @property {function(string, (R | T)[], T[]): R} createGroup
  * @property {function(string, T[]): GroupOptions=} getOptions
@@ -24,7 +24,7 @@
 /**
  * @template T
  * @template R
- * @typedef {Object} ItemWithGroups
+ * @typedef {object} ItemWithGroups
  * @property {T} item
  * @property {Set<Group<T, R>>} groups
  */

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -13,7 +13,7 @@ const Template = require("../Template");
 /** @typedef {import("../Compilation")} Compilation */
 
 /**
- * @typedef {Object} AsyncWasmLoadingRuntimeModuleOptions
+ * @typedef {object} AsyncWasmLoadingRuntimeModuleOptions
  * @property {function(string): string} generateLoadBinaryCode
  * @property {boolean} supportsStreaming
  */
@@ -69,7 +69,9 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 			const concat = (/** @type {string[]} */ ...text) => text.join("");
 			return [
 				`var req = ${loader};`,
-				`var fallback = ${runtimeTemplate.returningFunction(Template.asString(["req", Template.indent(fallback)]))};`,
+				`var fallback = ${runtimeTemplate.returningFunction(
+					Template.asString(["req", Template.indent(fallback)])
+				)};`,
 				concat(
 					"return req.then(",
 					runtimeTemplate.basicFunction("res", [

package/lib/wasm-async/AsyncWebAssemblyGenerator.js

@@ -14,7 +14,7 @@ const Generator = require("../Generator");
 const TYPES = new Set(["webassembly"]);
 
 /**
- * @typedef {Object} AsyncWebAssemblyGeneratorOptions
+ * @typedef {object} AsyncWebAssemblyGeneratorOptions
  * @property {boolean} [mangleImports] mangle imports
  */
 

package/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js

@@ -77,7 +77,7 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 		const wasmDepsByRequest = new Map();
 		for (const dep of module.dependencies) {
 			if (dep instanceof WebAssemblyImportDependency) {
-				const module = moduleGraph.getModule(dep);
+				const module = /** @type {Module} */ (moduleGraph.getModule(dep));
 				if (!depModules.has(module)) {
 					depModules.set(module, {
 						request: dep.request,
@@ -120,7 +120,9 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 			wasmDepsByRequest,
 			([request, deps]) => {
 				const exportItems = deps.map(dep => {
-					const importedModule = moduleGraph.getModule(dep);
+					const importedModule =
+						/** @type {Module} */
+						(moduleGraph.getModule(dep));
 					const importVar =
 						/** @type {ImportObjRequestItem} */
 						(depModules.get(importedModule)).importVar;

package/lib/wasm-async/AsyncWebAssemblyModulesPlugin.js

@@ -39,7 +39,7 @@ const getAsyncWebAssemblyParser = memoize(() =>
 );
 
 /**
- * @typedef {Object} WebAssemblyRenderContext
+ * @typedef {object} WebAssemblyRenderContext
  * @property {Chunk} chunk the chunk
  * @property {DependencyTemplates} dependencyTemplates the dependency templates
  * @property {RuntimeTemplate} runtimeTemplate the runtime template
@@ -49,12 +49,12 @@ const getAsyncWebAssemblyParser = memoize(() =>
  */
 
 /**
- * @typedef {Object} CompilationHooks
+ * @typedef {object} CompilationHooks
  * @property {SyncWaterfallHook<[Source, Module, WebAssemblyRenderContext]>} renderModuleContent
  */
 
 /**
- * @typedef {Object} AsyncWebAssemblyModulesPluginOptions
+ * @typedef {object} AsyncWebAssemblyModulesPluginOptions
  * @property {boolean} [mangleImports] mangle imports
  */
 

package/lib/wasm-sync/WasmChunkLoadingRuntimeModule.js

@@ -15,6 +15,7 @@ const WebAssemblyUtils = require("./WebAssemblyUtils");
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
@@ -61,6 +62,7 @@ const generateImportObject = (
 	runtime
 ) => {
 	const moduleGraph = chunkGraph.moduleGraph;
+	/** @type {Map<string, string | number>} */
 	const waitForInstances = new Map();
 	const properties = [];
 	const usedWasmDependencies = WebAssemblyUtils.getUsedDependencies(
@@ -85,7 +87,10 @@ const generateImportObject = (
 
 		if (direct) {
 			const instanceVar = `m${waitForInstances.size}`;
-			waitForInstances.set(instanceVar, chunkGraph.getModuleId(importedModule));
+			waitForInstances.set(
+				instanceVar,
+				chunkGraph.getModuleId(/** @type {Module} */ (importedModule))
+			);
 			properties.push({
 				module,
 				name,
@@ -99,20 +104,24 @@ const generateImportObject = (
 				);
 
 			const mod = `${RuntimeGlobals.moduleCache}[${JSON.stringify(
-				chunkGraph.getModuleId(importedModule)
+				chunkGraph.getModuleId(/** @type {Module} */ (importedModule))
 			)}]`;
 			const modExports = `${mod}.exports`;
 
 			const cache = `wasmImportedFuncCache${declarations.length}`;
 			declarations.push(`var ${cache};`);
 
+			const modCode =
+				/** @type {Module} */
+				(importedModule).type.startsWith("webassembly")
+					? `${mod} ? ${modExports}[${JSON.stringify(usedName)}] : `
+					: "";
+
 			properties.push({
 				module,
 				name,
 				value: Template.asString([
-					(importedModule.type.startsWith("webassembly")
-						? `${mod} ? ${modExports}[${JSON.stringify(usedName)}] : `
-						: "") + `function(${params}) {`,
+					modCode + `function(${params}) {`,
 					Template.indent([
 						`if(${cache} === undefined) ${cache} = ${modExports};`,
 						`return ${cache}[${JSON.stringify(usedName)}](${params});`
@@ -201,11 +210,11 @@ const generateImportObject = (
 };
 
 /**
- * @typedef {Object} WasmChunkLoadingRuntimeModuleOptions
+ * @typedef {object} WasmChunkLoadingRuntimeModuleOptions
  * @property {(path: string) => string} generateLoadBinaryCode
  * @property {boolean} [supportsStreaming]
  * @property {boolean} [mangleImports]
- * @property {Set<string>} runtimeRequirements
+ * @property {ReadOnlyRuntimeRequirements} runtimeRequirements
  */
 
 class WasmChunkLoadingRuntimeModule extends RuntimeModule {

package/lib/wasm-sync/WebAssemblyGenerator.js

@@ -25,6 +25,14 @@ const WebAssemblyExportImportedDependency = require("../dependencies/WebAssembly
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("./WebAssemblyUtils").UsedWasmDependency} UsedWasmDependency */
+/** @typedef {import("@webassemblyjs/ast").Instruction} Instruction */
+/** @typedef {import("@webassemblyjs/ast").ModuleImport} ModuleImport */
+/** @typedef {import("@webassemblyjs/ast").ModuleExport} ModuleExport */
+/** @typedef {import("@webassemblyjs/ast").Global} Global */
+/**
+ * @template T
+ * @typedef {import("@webassemblyjs/ast").NodePath<T>} NodePath
+ */
 
 /**
  * @typedef {(buf: ArrayBuffer) => ArrayBuffer} ArrayBufferTransform
@@ -32,7 +40,7 @@ const WebAssemblyExportImportedDependency = require("../dependencies/WebAssembly
 
 /**
  * @template T
- * @param {Function[]} fns transforms
+ * @param {((prev: ArrayBuffer) => ArrayBuffer)[]} fns transforms
  * @returns {Function} composed transform
  */
 const compose = (...fns) => {
@@ -47,7 +55,8 @@ const compose = (...fns) => {
 /**
  * Removes the start instruction
  *
- * @param {Object} state unused state
+ * @param {object} state state
+ * @param {object} state.ast Module's ast
  * @returns {ArrayBufferTransform} transform
  */
 const removeStartFunc = state => bin => {
@@ -61,7 +70,7 @@ const removeStartFunc = state => bin => {
 /**
  * Get imported globals
  *
- * @param {Object} ast Module's AST
+ * @param {object} ast Module's AST
  * @returns {t.ModuleImport[]} - nodes
  */
 const getImportedGlobals = ast => {
@@ -82,8 +91,8 @@ const getImportedGlobals = ast => {
 /**
  * Get the count for imported func
  *
- * @param {Object} ast Module's AST
- * @returns {Number} - count
+ * @param {object} ast Module's AST
+ * @returns {number} - count
  */
 const getCountImportedFunc = ast => {
 	let count = 0;
@@ -102,7 +111,7 @@ const getCountImportedFunc = ast => {
 /**
  * Get next type index
  *
- * @param {Object} ast Module's AST
+ * @param {object} ast Module's AST
  * @returns {t.Index} - index
  */
 const getNextTypeIndex = ast => {
@@ -118,12 +127,12 @@ const getNextTypeIndex = ast => {
 /**
  * Get next func index
  *
- * The Func section metadata provide informations for implemented funcs
+ * The Func section metadata provide information for implemented funcs
  * in order to have the correct index we shift the index by number of external
  * functions.
  *
- * @param {Object} ast Module's AST
- * @param {Number} countImportedFunc number of imported funcs
+ * @param {object} ast Module's AST
+ * @param {number} countImportedFunc number of imported funcs
  * @returns {t.Index} - index
  */
 const getNextFuncIndex = (ast, countImportedFunc) => {
@@ -169,7 +178,9 @@ const createDefaultInitForGlobal = globalType => {
  *
  * Note that globals will become mutable.
  *
- * @param {Object} state unused state
+ * @param {object} state transformation state
+ * @param {object} state.ast Module's ast
+ * @param {t.Instruction[]} state.additionalInitCode list of addition instructions for the init function
  * @returns {ArrayBufferTransform} transform
  */
 const rewriteImportedGlobals = state => bin => {
@@ -180,7 +191,7 @@ const rewriteImportedGlobals = state => bin => {
 	bin = editWithAST(state.ast, bin, {
 		ModuleImport(path) {
 			if (t.isGlobalType(path.node.descr)) {
-				const globalType = path.node.descr;
+				const globalType = /** @type {TODO} */ (path.node.descr);
 
 				globalType.mutability = "var";
 
@@ -197,6 +208,9 @@ const rewriteImportedGlobals = state => bin => {
 
 		// in order to preserve non-imported global's order we need to re-inject
 		// those as well
+		/**
+		 * @param {NodePath<Global>} path path
+		 */
 		Global(path) {
 			const { node } = path;
 			const [init] = node.init;
@@ -234,8 +248,8 @@ const rewriteImportedGlobals = state => bin => {
 
 /**
  * Rewrite the export names
- * @param {Object} state state
- * @param {Object} state.ast Module's ast
+ * @param {object} state state
+ * @param {object} state.ast Module's ast
  * @param {Module} state.module Module
  * @param {ModuleGraph} state.moduleGraph module graph
  * @param {Set<string>} state.externalExports Module
@@ -246,6 +260,9 @@ const rewriteExportNames =
 	({ ast, moduleGraph, module, externalExports, runtime }) =>
 	bin => {
 		return editWithAST(ast, bin, {
+			/**
+			 * @param {NodePath<ModuleExport>} path path
+			 */
 			ModuleExport(path) {
 				const isExternal = externalExports.has(path.node.name);
 				if (isExternal) {
@@ -259,15 +276,15 @@ const rewriteExportNames =
 					path.remove();
 					return;
 				}
-				path.node.name = usedName;
+				path.node.name = /** @type {string} */ (usedName);
 			}
 		});
 	};
 
 /**
  * Mangle import names and modules
- * @param {Object} state state
- * @param {Object} state.ast Module's ast
+ * @param {object} state state
+ * @param {object} state.ast Module's ast
  * @param {Map<string, UsedWasmDependency>} state.usedDependencyMap mappings to mangle names
  * @returns {ArrayBufferTransform} transform
  */
@@ -275,6 +292,9 @@ const rewriteImports =
 	({ ast, usedDependencyMap }) =>
 	bin => {
 		return editWithAST(ast, bin, {
+			/**
+			 * @param {NodePath<ModuleImport>} path path
+			 */
 			ModuleImport(path) {
 				const result = usedDependencyMap.get(
 					path.node.module + ":" + path.node.name
@@ -293,8 +313,8 @@ const rewriteImports =
  *
  * The init function fills the globals given input arguments.
  *
- * @param {Object} state transformation state
- * @param {Object} state.ast Module's ast
+ * @param {object} state transformation state
+ * @param {object} state.ast Module's ast
  * @param {t.Identifier} state.initFuncId identifier of the init function
  * @param {t.Index} state.startAtFuncOffset index of the start function
  * @param {t.ModuleImport[]} state.importedGlobals list of imported globals
@@ -326,6 +346,7 @@ const addInitFunction =
 			);
 		});
 
+		/** @type {Instruction[]} */
 		const funcBody = [];
 		importedGlobals.forEach((importedGlobal, index) => {
 			const args = [t.indexLiteral(index)];
@@ -397,7 +418,7 @@ const getUsedDependencyMap = (moduleGraph, module, mangle) => {
 const TYPES = new Set(["webassembly"]);
 
 /**
- * @typedef {Object} WebAssemblyGeneratorOptions
+ * @typedef {object} WebAssemblyGeneratorOptions
  * @property {boolean} [mangleImports] mangle imports
  */
 

package/lib/wasm-sync/WebAssemblyModulesPlugin.js

@@ -31,7 +31,7 @@ const getWebAssemblyParser = memoize(() => require("./WebAssemblyParser"));
 const PLUGIN_NAME = "WebAssemblyModulesPlugin";
 
 /**
- * @typedef {Object} WebAssemblyModulesPluginOptions
+ * @typedef {object} WebAssemblyModulesPluginOptions
  * @property {boolean} [mangleImports] mangle imports
  */
 

package/lib/wasm-sync/WebAssemblyParser.js

@@ -97,8 +97,9 @@ class WebAssemblyParser extends Parser {
 		// extract imports and exports
 		/** @type {string[]} */
 		const exports = [];
-		let jsIncompatibleExports = (state.module.buildMeta.jsIncompatibleExports =
-			undefined);
+		const buildMeta = /** @type {BuildMeta} */ (state.module.buildMeta);
+		/** @type {Record<string, string> | undefined} */
+		let jsIncompatibleExports = (buildMeta.jsIncompatibleExports = undefined);
 
 		/** @type {TODO[]} */
 		const importedGlobals = [];
@@ -118,7 +119,8 @@ class WebAssemblyParser extends Parser {
 					if (incompatibleType) {
 						if (jsIncompatibleExports === undefined) {
 							jsIncompatibleExports =
-								state.module.buildMeta.jsIncompatibleExports = {};
+								/** @type {BuildMeta} */
+								(state.module.buildMeta).jsIncompatibleExports = {};
 						}
 						jsIncompatibleExports[node.name] = incompatibleType;
 					}
@@ -127,7 +129,8 @@ class WebAssemblyParser extends Parser {
 				exports.push(node.name);
 
 				if (node.descr && node.descr.exportType === "Global") {
-					const refNode = importedGlobals[node.descr.id.value];
+					const refNode =
+						importedGlobals[/** @type {TODO} */ (node.descr.id.value)];
 					if (refNode) {
 						const dep = new WebAssemblyExportImportedDependency(
 							node.name,

package/lib/wasm-sync/WebAssemblyUtils.js

@@ -11,7 +11,8 @@ const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDe
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 
-/** @typedef {Object} UsedWasmDependency
+/**
+ * @typedef {object} UsedWasmDependency
  * @property {WebAssemblyImportDependency} dependency the dependency
  * @property {string} name the export name
  * @property {string} module the module name

package/lib/web/FetchCompileWasmPlugin.js

@@ -17,7 +17,7 @@ const WasmChunkLoadingRuntimeModule = require("../wasm-sync/WasmChunkLoadingRunt
 const PLUGIN_NAME = "FetchCompileWasmPlugin";
 
 /**
- * @typedef {Object} FetchCompileWasmPluginOptions
+ * @typedef {object} FetchCompileWasmPluginOptions
  * @property {boolean} [mangleImports] mangle imports
  */
 

package/lib/web/JsonpChunkLoadingRuntimeModule.js

@@ -15,9 +15,10 @@ const compileBooleanMatcher = require("../util/compileBooleanMatcher");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 
 /**
- * @typedef {Object} JsonpCompilationPluginHooks
+ * @typedef {object} JsonpCompilationPluginHooks
  * @property {SyncWaterfallHook<[string, Chunk]>} linkPreload
  * @property {SyncWaterfallHook<[string, Chunk]>} linkPrefetch
  */
@@ -48,7 +49,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @param {Set<string>} runtimeRequirements runtime requirements
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
 	 */
 	constructor(runtimeRequirements) {
 		super("jsonp chunk loading", RuntimeModule.STAGE_ATTACH);

package/lib/webpack.js

@@ -31,7 +31,7 @@ const getValidateSchema = memoize(() => require("./validateSchema"));
 /**
  * @template T
  * @callback Callback
- * @param {(Error | null)=} err
+ * @param {Error | null} err
  * @param {T=} stats
  * @returns {void}
  */
@@ -42,7 +42,9 @@ const getValidateSchema = memoize(() => require("./validateSchema"));
  * @returns {MultiCompiler} a multi-compiler
  */
 const createMultiCompiler = (childOptions, options) => {
-	const compilers = childOptions.map(options => createCompiler(options));
+	const compilers = childOptions.map((options, index) =>
+		createCompiler(options, index)
+	);
 	const compiler = new MultiCompiler(compilers, options);
 	for (const childCompiler of compilers) {
 		if (childCompiler.options.dependencies) {
@@ -57,9 +59,10 @@ const createMultiCompiler = (childOptions, options) => {
 
 /**
  * @param {WebpackOptions} rawOptions options object
+ * @param {number} [compilerIndex] index of compiler
  * @returns {Compiler} a compiler
  */
-const createCompiler = rawOptions => {
+const createCompiler = (rawOptions, compilerIndex) => {
 	const options = getNormalizedWebpackOptions(rawOptions);
 	applyWebpackOptionsBaseDefaults(options);
 	const compiler = new Compiler(
@@ -79,7 +82,13 @@ const createCompiler = rawOptions => {
 			}
 		}
 	}
-	applyWebpackOptionsDefaults(options);
+	const resolvedDefaultOptions = applyWebpackOptionsDefaults(
+		options,
+		compilerIndex
+	);
+	if (resolvedDefaultOptions.platform) {
+		compiler.platform = resolvedDefaultOptions.platform;
+	}
 	compiler.hooks.environment.call();
 	compiler.hooks.afterEnvironment.call();
 	new WebpackOptionsApply().process(options, compiler);
@@ -113,7 +122,7 @@ const webpack = /** @type {WebpackFunctionSingle & WebpackFunctionMulti} */ (
 	/**
 	 * @param {WebpackOptions | (ReadonlyArray<WebpackOptions> & MultiCompilerOptions)} options options
 	 * @param {Callback<Stats> & Callback<MultiStats>=} callback callback
-	 * @returns {Compiler | MultiCompiler} Compiler or MultiCompiler
+	 * @returns {Compiler | MultiCompiler | null} Compiler or MultiCompiler
 	 */
 	(options, callback) => {
 		const create = () => {
@@ -156,7 +165,11 @@ const webpack = /** @type {WebpackFunctionSingle & WebpackFunctionMulti} */ (
 				} else {
 					compiler.run((err, stats) => {
 						compiler.close(err2 => {
-							callback(err || err2, stats);
+							callback(
+								err || err2,
+								/** @type {options extends WebpackOptions ? Stats : MultiStats} */
+								(stats)
+							);
 						});
 					});
 				}

package/lib/webworker/ImportScriptsChunkLoadingRuntimeModule.js

@@ -18,10 +18,11 @@ const { getUndoPath } = require("../util/identifier");
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 
 class ImportScriptsChunkLoadingRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {Set<string>} runtimeRequirements runtime requirements
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
 	 * @param {boolean} withCreateScriptUrl with createScriptUrl support
 	 */
 	constructor(runtimeRequirements, withCreateScriptUrl) {