webpack 5.97.1 → 5.99.0

package/lib/cli.js

@@ -8,23 +8,25 @@
 const path = require("path");
 const webpackSchema = require("../schemas/WebpackOptions.json");
 
-/** @typedef {TODO & { absolutePath: boolean, instanceof: string, cli: { helper?: boolean, exclude?: boolean } }} Schema */
+/** @typedef {Parameters<import("schema-utils").validate>[0] & { absolutePath: boolean, instanceof: string, cli: { helper?: boolean, exclude?: boolean, description?: string, negatedDescription?: string, resetDescription?: string } }} Schema */
 
 // TODO add originPath to PathItem for better errors
 /**
  * @typedef {object} PathItem
- * @property {any} schema the part of the schema
+ * @property {Schema} schema the part of the schema
  * @property {string} path the path in the config
  */
 
 /** @typedef {"unknown-argument" | "unexpected-non-array-in-path" | "unexpected-non-object-in-path" | "multiple-values-unexpected" | "invalid-value"} ProblemType */
 
+/** @typedef {string | number | boolean | RegExp} Value */
+
 /**
  * @typedef {object} Problem
  * @property {ProblemType} type
  * @property {string} path
  * @property {string} argument
- * @property {any=} value
+ * @property {Value=} value
  * @property {number=} index
  * @property {string=} expected
  */
@@ -36,6 +38,10 @@ const webpackSchema = require("../schemas/WebpackOptions.json");
  * @property {string=} expected
  */
 
+/** @typedef {{ [key: string]: EnumValue }} EnumValueObject */
+/** @typedef {EnumValue[]} EnumValueArray */
+/** @typedef {string | number | boolean | EnumValueObject | EnumValueArray | null} EnumValue */
+
 /**
  * @typedef {object} ArgumentConfig
  * @property {string | undefined} description
@@ -43,7 +49,7 @@ const webpackSchema = require("../schemas/WebpackOptions.json");
  * @property {string} path
  * @property {boolean} multiple
  * @property {"enum"|"string"|"path"|"number"|"boolean"|"RegExp"|"reset"} type
- * @property {any[]=} values
+ * @property {EnumValue[]=} values
  */
 
 /** @typedef {"string" | "number" | "boolean"} SimpleType */
@@ -56,8 +62,6 @@ const webpackSchema = require("../schemas/WebpackOptions.json");
  * @property {ArgumentConfig[]} configs
  */
 
-/** @typedef {string | number | boolean | RegExp | (string | number | boolean | RegExp)} Value */
-
 /** @typedef {Record<string, Argument>} Flags */
 
 /**
@@ -93,7 +97,7 @@ const getArguments = (schema = webpackSchema) => {
 		let schemaPart = schema;
 
 		for (let i = 1; i < newPath.length; i++) {
-			const inner = schemaPart[newPath[i]];
+			const inner = schemaPart[/** @type {keyof Schema} */ (newPath[i])];
 
 			if (!inner) {
 				break;
@@ -147,7 +151,7 @@ const getArguments = (schema = webpackSchema) => {
 
 	/**
 	 * @param {Schema} schemaPart schema
-	 * @returns {Pick<ArgumentConfig, "type"|"values"> | undefined} partial argument config
+	 * @returns {Pick<ArgumentConfig, "type" | "values"> | undefined} partial argument config
 	 */
 	const schemaToArgumentConfig = schemaPart => {
 		if (schemaPart.enum) {
@@ -272,7 +276,7 @@ const getArguments = (schema = webpackSchema) => {
 	/**
 	 * @param {Schema} schemaPart the current schema
 	 * @param {string} schemaPath the current path in the schema
-	 * @param {{schema: object, path: string}[]} path all previous visited schemaParts
+	 * @param {PathItem[]} path all previous visited schemaParts
 	 * @param {string | null} inArray if inside of an array, the path to the array
 	 * @returns {number} added arguments
 	 */
@@ -291,6 +295,7 @@ const getArguments = (schema = webpackSchema) => {
 
 		if (schemaPart.cli && schemaPart.cli.exclude) return 0;
 
+		/** @type {PathItem[]} */
 		const fullPath = [{ schema: schemaPart, path: schemaPath }, ...path];
 
 		let addedArguments = 0;
@@ -423,7 +428,7 @@ const cliAddedItems = new WeakMap();
  * @param {Configuration} config configuration
  * @param {string} schemaPath path in the config
  * @param {number | undefined} index index of value when multiple values are provided, otherwise undefined
- * @returns {{ problem?: LocalProblem, object?: any, property?: Property, value?: any }} problem or object with property and value
+ * @returns {{ problem?: LocalProblem, object?: TODO, property?: Property, value?: EXPECTED_OBJECT | EXPECTED_ANY[] }} problem or object with property and value
  */
 const getObjectAndProperty = (config, schemaPath, index = 0) => {
 	if (!schemaPath) return { value: config };
@@ -522,7 +527,7 @@ const getObjectAndProperty = (config, schemaPath, index = 0) => {
 /**
  * @param {Configuration} config configuration
  * @param {string} schemaPath path in the config
- * @param {any} value parsed value
+ * @param {ParsedValue} value parsed value
  * @param {number | undefined} index index of value when multiple values are provided, otherwise undefined
  * @returns {LocalProblem | null} problem or null for success
  */
@@ -587,10 +592,12 @@ const getExpectedValue = argConfig => {
 	}
 };
 
+/** @typedef {null | string | number | boolean | RegExp | EnumValue | []} ParsedValue */
+
 /**
  * @param {ArgumentConfig} argConfig processing instructions
  * @param {Value} value the value
- * @returns {any | undefined} parsed value
+ * @returns {ParsedValue | undefined} parsed value
  */
 const parseValueForArgumentConfig = (argConfig, value) => {
 	switch (argConfig.type) {
@@ -627,9 +634,10 @@ const parseValueForArgumentConfig = (argConfig, value) => {
 			break;
 		case "enum": {
 			const values =
-				/** @type {NonNullable<ArgumentConfig["values"]>} */
+				/** @type {EnumValue[]} */
 				(argConfig.values);
-			if (values.includes(value)) return value;
+			if (values.includes(/** @type {Exclude<Value, RegExp>} */ (value)))
+				return value;
 			for (const item of values) {
 				if (`${item}` === value) return item;
 			}
@@ -641,7 +649,7 @@ const parseValueForArgumentConfig = (argConfig, value) => {
 	}
 };
 
-/** @typedef {any} Configuration */
+/** @typedef {TODO} Configuration */
 
 /**
  * @param {Flags} args object of arguments

package/lib/config/defaults.js

@@ -47,6 +47,7 @@ const {
 /** @typedef {import("../../declarations/WebpackOptions").GeneratorOptionsByModuleTypeKnown} GeneratorOptionsByModuleTypeKnown */
 /** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../../declarations/WebpackOptions").JsonGeneratorOptions} JsonGeneratorOptions */
 /** @typedef {import("../../declarations/WebpackOptions").Library} Library */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
@@ -78,6 +79,10 @@ const {
 
 const NODE_MODULES_REGEXP = /[\\/]node_modules[\\/]/i;
 const DEFAULT_CACHE_NAME = "default";
+const DEFAULTS = {
+	// TODO webpack 6 - use xxhash64
+	HASH_FUNCTION: "md4"
+};
 
 /**
  * Sets a constant default value when undefined
@@ -100,7 +105,7 @@ const D = (obj, prop, value) => {
  * @template {keyof T} P
  * @param {T} obj an object
  * @param {P} prop a property of this object
- * @param {function(): T[P]} factory a default value factory for the property
+ * @param {() => T[P]} factory a default value factory for the property
  * @returns {void}
  */
 const F = (obj, prop, factory) => {
@@ -118,7 +123,7 @@ const F = (obj, prop, factory) => {
  * @template {keyof T} P
  * @param {T} obj an object
  * @param {P} prop a property of this object
- * @param {function(): T[P]} factory a default value factory for the property
+ * @param {() => T[P]} factory a default value factory for the property
  * @returns {void}
  */
 const A = (obj, prop, factory) => {
@@ -220,6 +225,7 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		mode: mode || "production",
 		development,
 		cacheUnaffected: options.experiments.cacheUnaffected,
+		futureDefaults,
 		compilerIndex
 	});
 	const cache = Boolean(options.cache);
@@ -261,8 +267,9 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 			(options.experiments.css),
 		futureDefaults,
 		isNode: targetProperties && targetProperties.node === true,
-		uniqueName: options.output.uniqueName,
-		targetProperties
+		uniqueName: /** @type {string} */ (options.output.uniqueName),
+		targetProperties,
+		mode: options.mode
 	});
 
 	applyExternalsPresetsDefaults(options.externalsPresets, {
@@ -396,6 +403,7 @@ const applyExperimentsDefaults = (
  * @param {object} options options
  * @param {string} options.name name
  * @param {Mode} options.mode mode
+ * @param {boolean} options.futureDefaults is future defaults enabled
  * @param {boolean} options.development is development mode
  * @param {number} [options.compilerIndex] index of compiler
  * @param {Experiments["cacheUnaffected"]} options.cacheUnaffected the cacheUnaffected experiment is enabled
@@ -403,7 +411,7 @@ const applyExperimentsDefaults = (
  */
 const applyCacheDefaults = (
 	cache,
-	{ name, mode, development, cacheUnaffected, compilerIndex }
+	{ name, mode, development, cacheUnaffected, compilerIndex, futureDefaults }
 ) => {
 	if (cache === false) return;
 	switch (cache.type) {
@@ -446,7 +454,7 @@ const applyCacheDefaults = (
 					/** @type {NonNullable<FileCacheOptions["name"]>} */ (cache.name)
 				)
 			);
-			D(cache, "hashAlgorithm", "md4");
+			D(cache, "hashAlgorithm", futureDefaults ? "xxhash64" : "md4");
 			D(cache, "store", "pack");
 			D(cache, "compression", false);
 			D(cache, "profile", false);
@@ -580,6 +588,14 @@ const applyJavascriptParserOptionsDefaults = (
 	if (futureDefaults) D(parserOptions, "exportsPresence", "error");
 };
 
+/**
+ * @param {JsonGeneratorOptions} generatorOptions generator options
+ * @returns {void}
+ */
+const applyJsonGeneratorOptionsDefaults = generatorOptions => {
+	D(generatorOptions, "JSONParse", true);
+};
+
 /**
  * @param {CssGeneratorOptions} generatorOptions generator options
  * @param {object} options options
@@ -609,6 +625,7 @@ const applyCssGeneratorOptionsDefaults = (
  * @param {string} options.uniqueName the unique name
  * @param {boolean} options.isNode is node target platform
  * @param {TargetProperties | false} options.targetProperties target properties
+ * @param {Mode | undefined} options.mode mode
  * @returns {void}
  */
 const applyModuleDefaults = (
@@ -621,7 +638,8 @@ const applyModuleDefaults = (
 		futureDefaults,
 		isNode,
 		uniqueName,
-		targetProperties
+		targetProperties,
+		mode
 	}
 ) => {
 	if (cache) {
@@ -643,19 +661,19 @@ const applyModuleDefaults = (
 
 	F(module.parser, ASSET_MODULE_TYPE, () => ({}));
 	F(
-		/** @type {NonNullable<ParserOptionsByModuleTypeKnown["asset"]>} */
+		/** @type {NonNullable<ParserOptionsByModuleTypeKnown[ASSET_MODULE_TYPE]>} */
 		(module.parser[ASSET_MODULE_TYPE]),
 		"dataUrlCondition",
 		() => ({})
 	);
 	if (
 		typeof (
-			/** @type {NonNullable<ParserOptionsByModuleTypeKnown["asset"]>} */
+			/** @type {NonNullable<ParserOptionsByModuleTypeKnown[ASSET_MODULE_TYPE]>} */
 			(module.parser[ASSET_MODULE_TYPE]).dataUrlCondition
 		) === "object"
 	) {
 		D(
-			/** @type {NonNullable<ParserOptionsByModuleTypeKnown["asset"]>} */
+			/** @type {NonNullable<ParserOptionsByModuleTypeKnown[ASSET_MODULE_TYPE]>} */
 			(module.parser[ASSET_MODULE_TYPE]).dataUrlCondition,
 			"maxSize",
 			8096
@@ -663,6 +681,12 @@ const applyModuleDefaults = (
 	}
 
 	F(module.parser, "javascript", () => ({}));
+	F(module.parser, JSON_MODULE_TYPE, () => ({}));
+	D(
+		module.parser[JSON_MODULE_TYPE],
+		"exportsDepth",
+		mode === "development" ? 1 : Infinity
+	);
 
 	applyJavascriptParserOptionsDefaults(
 		/** @type {NonNullable<ParserOptionsByModuleTypeKnown["javascript"]>} */
@@ -673,17 +697,38 @@ const applyModuleDefaults = (
 		}
 	);
 
+	F(module.generator, "json", () => ({}));
+	applyJsonGeneratorOptionsDefaults(
+		/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown["json"]>} */
+		(module.generator.json)
+	);
+
 	if (css) {
 		F(module.parser, CSS_MODULE_TYPE, () => ({}));
 
-		D(module.parser[CSS_MODULE_TYPE], "import", true);
-		D(module.parser[CSS_MODULE_TYPE], "url", true);
-		D(module.parser[CSS_MODULE_TYPE], "namedExports", true);
+		D(
+			/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE]>} */
+			(module.parser[CSS_MODULE_TYPE]),
+			"import",
+			true
+		);
+		D(
+			/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE]>} */
+			(module.parser[CSS_MODULE_TYPE]),
+			"url",
+			true
+		);
+		D(
+			/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE]>} */
+			(module.parser[CSS_MODULE_TYPE]),
+			"namedExports",
+			true
+		);
 
 		F(module.generator, CSS_MODULE_TYPE, () => ({}));
 
 		applyCssGeneratorOptionsDefaults(
-			/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown["css"]>} */
+			/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE]>} */
 			(module.generator[CSS_MODULE_TYPE]),
 			{ targetProperties }
 		);
@@ -692,24 +737,46 @@ const applyModuleDefaults = (
 			uniqueName.length > 0 ? "[uniqueName]-[id]-[local]" : "[id]-[local]";
 
 		F(module.generator, CSS_MODULE_TYPE_AUTO, () => ({}));
-		D(module.generator[CSS_MODULE_TYPE_AUTO], "localIdentName", localIdentName);
-		D(module.generator[CSS_MODULE_TYPE_AUTO], "exportsConvention", "as-is");
+		D(
+			/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]>} */
+			(module.generator[CSS_MODULE_TYPE_AUTO]),
+			"localIdentName",
+			localIdentName
+		);
+		D(
+			/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]>} */
+			(module.generator[CSS_MODULE_TYPE_AUTO]),
+			"exportsConvention",
+			"as-is"
+		);
 
 		F(module.generator, CSS_MODULE_TYPE_MODULE, () => ({}));
 		D(
-			module.generator[CSS_MODULE_TYPE_MODULE],
+			/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]>} */
+			(module.generator[CSS_MODULE_TYPE_MODULE]),
 			"localIdentName",
 			localIdentName
 		);
-		D(module.generator[CSS_MODULE_TYPE_MODULE], "exportsConvention", "as-is");
+		D(
+			/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]>} */
+			(module.generator[CSS_MODULE_TYPE_MODULE]),
+			"exportsConvention",
+			"as-is"
+		);
 
 		F(module.generator, CSS_MODULE_TYPE_GLOBAL, () => ({}));
 		D(
-			module.generator[CSS_MODULE_TYPE_GLOBAL],
+			/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
+			(module.generator[CSS_MODULE_TYPE_GLOBAL]),
 			"localIdentName",
 			localIdentName
 		);
-		D(module.generator[CSS_MODULE_TYPE_GLOBAL], "exportsConvention", "as-is");
+		D(
+			/** @type {NonNullable<GeneratorOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
+			(module.generator[CSS_MODULE_TYPE_GLOBAL]),
+			"exportsConvention",
+			"as-is"
+		);
 	}
 
 	A(module, "defaultRules", () => {
@@ -1075,7 +1142,7 @@ const applyOutputDefaults = (
 	D(output, "assetModuleFilename", "[hash][ext][query]");
 	D(output, "webassemblyModuleFilename", "[hash].module.wasm");
 	D(output, "compareBeforeEmit", true);
-	D(output, "charset", true);
+	D(output, "charset", !futureDefaults);
 	const uniqueNameId = Template.toIdentifier(
 		/** @type {NonNullable<Output["uniqueName"]>} */ (output.uniqueName)
 	);
@@ -1216,7 +1283,14 @@ const applyOutputDefaults = (
 	);
 	D(output, "workerPublicPath", "");
 	D(output, "chunkLoadTimeout", 120000);
-	D(output, "hashFunction", futureDefaults ? "xxhash64" : "md4");
+	F(output, "hashFunction", () => {
+		if (futureDefaults) {
+			DEFAULTS.HASH_FUNCTION = "xxhash64";
+			return "xxhash64";
+		}
+
+		return "md4";
+	});
 	D(output, "hashDigest", "hex");
 	D(output, "hashDigestLength", futureDefaults ? 16 : 20);
 	D(output, "strictModuleErrorHandling", false);
@@ -1235,7 +1309,7 @@ const applyOutputDefaults = (
 	}
 
 	/**
-	 * @param {function(EntryDescription): void} fn iterator
+	 * @param {(entryDescription: EntryDescription) => void} fn iterator
 	 * @returns {void}
 	 */
 	const forEachEntry = fn => {
@@ -1477,7 +1551,7 @@ const applyOptimizationDefaults = (
 							passes: 2
 						}
 					}
-				}).apply(compiler);
+				}).apply(/** @type {TODO} */ (compiler));
 			}
 		}
 	]);
@@ -1554,14 +1628,14 @@ const getResolveDefaults = ({
 	const browserField =
 		tp && tp.web && (!tp.node || (tp.electron && tp.electronRenderer));
 
-	/** @type {function(): ResolveOptions} */
+	/** @type {() => ResolveOptions} */
 	const cjsDeps = () => ({
 		aliasFields: browserField ? ["browser"] : [],
 		mainFields: browserField ? ["browser", "module", "..."] : ["module", "..."],
 		conditionNames: ["require", "module", "..."],
 		extensions: [...jsExtensions]
 	});
-	/** @type {function(): ResolveOptions} */
+	/** @type {() => ResolveOptions} */
 	const esmDeps = () => ({
 		aliasFields: browserField ? ["browser"] : [],
 		mainFields: browserField ? ["browser", "module", "..."] : ["module", "..."],
@@ -1610,7 +1684,8 @@ const getResolveDefaults = ({
 		styleConditions.push(mode === "development" ? "development" : "production");
 		styleConditions.push("style");
 
-		resolveOptions.byDependency["css-import"] = {
+		/** @type {NonNullable<ResolveOptions["byDependency"]>} */
+		(resolveOptions.byDependency)["css-import"] = {
 			// We avoid using any main files because we have to be consistent with CSS `@import`
 			// and CSS `@import` does not handle `main` files in directories,
 			// you should always specify the full URL for styles
@@ -1651,7 +1726,7 @@ const getResolveLoaderDefaults = ({ cache }) => {
 const applyInfrastructureLoggingDefaults = infrastructureLogging => {
 	F(infrastructureLogging, "stream", () => process.stderr);
 	const tty =
-		/** @type {any} */ (infrastructureLogging.stream).isTTY &&
+		/** @type {EXPECTED_ANY} */ (infrastructureLogging.stream).isTTY &&
 		process.env.TERM !== "dumb";
 	D(infrastructureLogging, "level", "info");
 	D(infrastructureLogging, "debug", false);
@@ -1662,3 +1737,4 @@ const applyInfrastructureLoggingDefaults = infrastructureLogging => {
 module.exports.applyWebpackOptionsBaseDefaults =
 	applyWebpackOptionsBaseDefaults;
 module.exports.applyWebpackOptionsDefaults = applyWebpackOptionsDefaults;
+module.exports.DEFAULTS = DEFAULTS;

package/lib/config/normalization.js

@@ -44,8 +44,8 @@ const handledDeprecatedNoEmitOnErrors = util.deprecate(
 /**
  * @template T
  * @template R
- * @param {T|undefined} value value or not
- * @param {function(T): R} fn nested handler
+ * @param {T | undefined} value value or not
+ * @param {(value: T) => R} fn nested handler
  * @returns {R} result value
  */
 const nestedConfig = (value, fn) =>
@@ -60,9 +60,9 @@ const cloneObject = value => /** @type {T} */ ({ ...value });
 /**
  * @template T
  * @template R
- * @param {T|undefined} value value or not
- * @param {function(T): R} fn nested handler
- * @returns {R|undefined} result value
+ * @param {T | undefined} value value or not
+ * @param {(value: T) => R} fn nested handler
+ * @returns {R | undefined} result value
  */
 const optionalNestedConfig = (value, fn) =>
 	value === undefined ? undefined : fn(value);
@@ -70,18 +70,18 @@ const optionalNestedConfig = (value, fn) =>
 /**
  * @template T
  * @template R
- * @param {T[]|undefined} value array or not
- * @param {function(T[]): R[]} fn nested handler
- * @returns {R[]|undefined} cloned value
+ * @param {T[] | undefined} value array or not
+ * @param {(value: T[]) => R[]} fn nested handler
+ * @returns {R[] | undefined} cloned value
  */
 const nestedArray = (value, fn) => (Array.isArray(value) ? fn(value) : fn([]));
 
 /**
  * @template T
  * @template R
- * @param {T[]|undefined} value array or not
- * @param {function(T[]): R[]} fn nested handler
- * @returns {R[]|undefined} cloned value
+ * @param {T[] | undefined} value array or not
+ * @param {(value: T[]) => R[]} fn nested handler
+ * @returns {R[] | undefined} cloned value
  */
 const optionalNestedArray = (value, fn) =>
 	Array.isArray(value) ? fn(value) : undefined;
@@ -90,8 +90,8 @@ const optionalNestedArray = (value, fn) =>
  * @template T
  * @template R
  * @param {Record<string, T>|undefined} value value or not
- * @param {function(T): R} fn nested handler
- * @param {Record<string, function(T): R>=} customKeys custom nested handler for some keys
+ * @param {(value: T) => R} fn nested handler
+ * @param {Record<string, (value: T) => R>=} customKeys custom nested handler for some keys
  * @returns {Record<string, R>} result value
  */
 const keyedNestedConfig = (value, fn, customKeys) => {
@@ -346,6 +346,7 @@ const getNormalizedWebpackOptions = config => ({
 			importFunctionName: output.importFunctionName,
 			importMetaName: output.importMetaName,
 			scriptType: output.scriptType,
+			// TODO webpack6 remove `libraryTarget`/`auxiliaryComment`/`amdContainer`/etc in favor of the `library` option
 			library: libraryBase && {
 				type:
 					output.libraryTarget !== undefined

package/lib/config/target.js

@@ -22,12 +22,12 @@ const getDefaultTarget = context => {
 
 /**
  * @typedef {object} PlatformTargetProperties
- * @property {boolean | null} web web platform, importing of http(s) and std: is available
- * @property {boolean | null} browser browser platform, running in a normal web browser
- * @property {boolean | null} webworker (Web)Worker platform, running in a web/shared/service worker
- * @property {boolean | null} node node platform, require of node built-in modules is available
- * @property {boolean | null} nwjs nwjs platform, require of legacy nw.gui is available
- * @property {boolean | null} electron electron platform, require of some electron built-in modules is available
+ * @property {boolean | null} [web] web platform, importing of http(s) and std: is available
+ * @property {boolean | null} [browser] browser platform, running in a normal web browser
+ * @property {boolean | null} [webworker] (Web)Worker platform, running in a web/shared/service worker
+ * @property {boolean | null} [node] node platform, require of node built-in modules is available
+ * @property {boolean | null} [nwjs] nwjs platform, require of legacy nw.gui is available
+ * @property {boolean | null} [electron] electron platform, require of some electron built-in modules is available
  */
 
 /**
@@ -341,7 +341,7 @@ const mergeTargetProperties = targetProperties => {
 			keys.add(/** @type {keyof TargetProperties} */ (key));
 		}
 	}
-	/** @type {object} */
+	/** @type {TargetProperties} */
 	const result = {};
 	for (const key of keys) {
 		let hasTrue = false;
@@ -361,7 +361,7 @@ const mergeTargetProperties = targetProperties => {
 			/** @type {TargetProperties} */
 			(result)[key] = hasFalse && hasTrue ? null : Boolean(hasTrue);
 	}
-	return /** @type {TargetProperties} */ (result);
+	return result;
 };
 
 /**

package/lib/container/ContainerEntryModule.js

@@ -20,9 +20,11 @@ const ContainerExposedDependency = require("./ContainerExposedDependency");
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").BuildCallback} BuildCallback */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../RequestShortener")} RequestShortener */
@@ -91,7 +93,7 @@ class ContainerEntryModule extends Module {
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {
@@ -103,7 +105,7 @@ class ContainerEntryModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {BuildCallback} callback callback function
 	 * @returns {void}
 	 */
 	build(options, compilation, resolver, fs, callback) {

package/lib/container/ContainerEntryModuleFactory.js

@@ -8,14 +8,14 @@
 const ModuleFactory = require("../ModuleFactory");
 const ContainerEntryModule = require("./ContainerEntryModule");
 
+/** @typedef {import("../ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
 /** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 /** @typedef {import("./ContainerEntryDependency")} ContainerEntryDependency */
 
 module.exports = class ContainerEntryModuleFactory extends ModuleFactory {
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
+	 * @param {ModuleFactoryCallback} callback callback
 	 * @returns {void}
 	 */
 	create({ dependencies: [dependency] }, callback) {

package/lib/container/FallbackModule.js

@@ -19,9 +19,11 @@ const FallbackItemDependency = require("./FallbackItemDependency");
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").BuildCallback} BuildCallback */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../RequestShortener")} RequestShortener */
@@ -80,7 +82,7 @@ class FallbackModule extends Module {
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {
@@ -92,7 +94,7 @@ class FallbackModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {BuildCallback} callback callback function
 	 * @returns {void}
 	 */
 	build(options, compilation, resolver, fs, callback) {

package/lib/container/FallbackModuleFactory.js

@@ -8,14 +8,14 @@
 const ModuleFactory = require("../ModuleFactory");
 const FallbackModule = require("./FallbackModule");
 
+/** @typedef {import("../ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
 /** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 /** @typedef {import("./FallbackDependency")} FallbackDependency */
 
 module.exports = class FallbackModuleFactory extends ModuleFactory {
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
+	 * @param {ModuleFactoryCallback} callback callback
 	 * @returns {void}
 	 */
 	create({ dependencies: [dependency] }, callback) {