webpack 5.97.1 → 5.104.1

package/lib/config/normalization.js

@@ -15,13 +15,14 @@ const util = require("util");
 /** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
 /** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptionsNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationNormalized} OptimizationNormalized */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationRuntimeChunk} OptimizationRuntimeChunk */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationRuntimeChunkNormalized} OptimizationRuntimeChunkNormalized */
 /** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputNormalized */
-/** @typedef {import("../../declarations/WebpackOptions").Plugins} Plugins */
+/** @typedef {import("../../declarations/WebpackOptions").PluginsNormalized} PluginsNormalized */
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
-/** @typedef {import("../Entrypoint")} Entrypoint */
+/** @typedef {import("../WebpackError")} WebpackError */
 
 const handledDeprecatedNoEmitOnErrors = util.deprecate(
 	/**
@@ -44,8 +45,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) =>
@@ -53,16 +54,16 @@ const nestedConfig = (value, fn) =>
 
 /**
  * @template T
- * @param {T|undefined} value value or not
+ * @param {T | undefined} value value or not
  * @returns {T} result value
  */
-const cloneObject = value => /** @type {T} */ ({ ...value });
+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 +71,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;
@@ -89,9 +90,9 @@ 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 {Record<string, T> | undefined} value value or not
+ * @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) => {
@@ -123,13 +124,13 @@ const keyedNestedConfig = (value, fn, customKeys) => {
  * @param {WebpackOptions} config input config
  * @returns {WebpackOptionsNormalized} normalized options
  */
-const getNormalizedWebpackOptions = config => ({
+const getNormalizedWebpackOptions = (config) => ({
 	amd: config.amd,
 	bail: config.bail,
 	cache:
 		/** @type {NonNullable<CacheOptions>} */
 		(
-			optionalNestedConfig(config.cache, cache => {
+			optionalNestedConfig(config.cache, (cache) => {
 				if (cache === false) return false;
 				if (cache === true) {
 					return {
@@ -172,35 +173,36 @@ const getNormalizedWebpackOptions = config => ({
 		),
 	context: config.context,
 	dependencies: config.dependencies,
-	devServer: optionalNestedConfig(config.devServer, devServer => {
+	devServer: optionalNestedConfig(config.devServer, (devServer) => {
 		if (devServer === false) return false;
 		return { ...devServer };
 	}),
 	devtool: config.devtool,
+	dotenv: config.dotenv,
 	entry:
 		config.entry === undefined
 			? { main: {} }
 			: typeof config.entry === "function"
 				? (
-						fn => () =>
+						(fn) => () =>
 							Promise.resolve().then(fn).then(getNormalizedEntryStatic)
 					)(config.entry)
 				: getNormalizedEntryStatic(config.entry),
-	experiments: nestedConfig(config.experiments, experiments => ({
+	experiments: nestedConfig(config.experiments, (experiments) => ({
 		...experiments,
-		buildHttp: optionalNestedConfig(experiments.buildHttp, options =>
+		buildHttp: optionalNestedConfig(experiments.buildHttp, (options) =>
 			Array.isArray(options) ? { allowedUris: options } : options
 		),
 		lazyCompilation: optionalNestedConfig(
 			experiments.lazyCompilation,
-			options => (options === true ? {} : options)
+			(options) => (options === true ? {} : options)
 		)
 	})),
 	externals: /** @type {NonNullable<Externals>} */ (config.externals),
 	externalsPresets: cloneObject(config.externalsPresets),
 	externalsType: config.externalsType,
 	ignoreWarnings: config.ignoreWarnings
-		? config.ignoreWarnings.map(ignore => {
+		? config.ignoreWarnings.map((ignore) => {
 				if (typeof ignore === "function") return ignore;
 				const i = ignore instanceof RegExp ? { message: ignore } : ignore;
 				return (warning, { requestShortener }) => {
@@ -210,14 +212,19 @@ const getNormalizedWebpackOptions = config => ({
 					}
 					if (
 						i.module &&
-						(!warning.module ||
+						(!(/** @type {WebpackError} */ (warning).module) ||
 							!i.module.test(
-								warning.module.readableIdentifier(requestShortener)
+								/** @type {WebpackError} */
+								(warning).module.readableIdentifier(requestShortener)
 							))
 					) {
 						return false;
 					}
-					if (i.file && (!warning.file || !i.file.test(warning.file))) {
+					if (
+						i.file &&
+						(!(/** @type {WebpackError} */ (warning).file) ||
+							!i.file.test(/** @type {WebpackError} */ (warning).file))
+					) {
 						return false;
 					}
 					return true;
@@ -230,11 +237,12 @@ const getNormalizedWebpackOptions = config => ({
 	module:
 		/** @type {ModuleOptionsNormalized} */
 		(
-			nestedConfig(config.module, module => ({
+			nestedConfig(config.module, (module) => ({
 				noParse: module.noParse,
 				unsafeCache: module.unsafeCache,
 				parser: keyedNestedConfig(module.parser, cloneObject, {
-					javascript: parserOptions => ({
+					javascript: (parserOptions) => ({
+						// TODO webpack 6 remove from `ModuleOptions`, keep only `*ByModuleType`
 						unknownContextRequest: module.unknownContextRequest,
 						unknownContextRegExp: module.unknownContextRegExp,
 						unknownContextRecursive: module.unknownContextRecursive,
@@ -246,33 +254,32 @@ const getNormalizedWebpackOptions = config => ({
 						wrappedContextRegExp: module.wrappedContextRegExp,
 						wrappedContextRecursive: module.wrappedContextRecursive,
 						wrappedContextCritical: module.wrappedContextCritical,
-						// TODO webpack 6 remove
 						strictExportPresence: module.strictExportPresence,
 						strictThisContextOnImports: module.strictThisContextOnImports,
 						...parserOptions
 					})
 				}),
 				generator: cloneObject(module.generator),
-				defaultRules: optionalNestedArray(module.defaultRules, r => [...r]),
-				rules: nestedArray(module.rules, r => [...r])
+				defaultRules: optionalNestedArray(module.defaultRules, (r) => [...r]),
+				rules: nestedArray(module.rules, (r) => [...r])
 			}))
 		),
 	name: config.name,
 	node: nestedConfig(
 		config.node,
-		node =>
+		(node) =>
 			node && {
 				...node
 			}
 	),
-	optimization: nestedConfig(config.optimization, optimization => ({
+	optimization: nestedConfig(config.optimization, (optimization) => ({
 		...optimization,
 		runtimeChunk: getNormalizedOptimizationRuntimeChunk(
 			optimization.runtimeChunk
 		),
 		splitChunks: nestedConfig(
 			optimization.splitChunks,
-			splitChunks =>
+			(splitChunks) =>
 				splitChunks && {
 					...splitChunks,
 					defaultSizeTypes: splitChunks.defaultSizeTypes
@@ -281,6 +288,12 @@ const getNormalizedWebpackOptions = config => ({
 					cacheGroups: cloneObject(splitChunks.cacheGroups)
 				}
 		),
+		minimizer:
+			optimization.minimizer !== undefined
+				? /** @type {OptimizationNormalized["minimizer"]} */ (
+						nestedArray(optimization.minimizer, (p) => p.filter(Boolean))
+					)
+				: optimization.minimizer,
 		emitOnErrors:
 			optimization.noEmitOnErrors !== undefined
 				? handledDeprecatedNoEmitOnErrors(
@@ -289,7 +302,7 @@ const getNormalizedWebpackOptions = config => ({
 					)
 				: optimization.emitOnErrors
 	})),
-	output: nestedConfig(config.output, output => {
+	output: nestedConfig(config.output, (output) => {
 		const { library } = output;
 		const libraryAsName = /** @type {LibraryName} */ (library);
 		const libraryBase =
@@ -346,6 +359,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
@@ -377,12 +391,16 @@ const getNormalizedWebpackOptions = config => ({
 			sourcePrefix: output.sourcePrefix,
 			strictModuleErrorHandling: output.strictModuleErrorHandling,
 			strictModuleExceptionHandling: output.strictModuleExceptionHandling,
-			trustedTypes: optionalNestedConfig(output.trustedTypes, trustedTypes => {
-				if (trustedTypes === true) return {};
-				if (typeof trustedTypes === "string")
-					return { policyName: trustedTypes };
-				return { ...trustedTypes };
-			}),
+			trustedTypes: optionalNestedConfig(
+				output.trustedTypes,
+				(trustedTypes) => {
+					if (trustedTypes === true) return {};
+					if (typeof trustedTypes === "string") {
+						return { policyName: trustedTypes };
+					}
+					return { ...trustedTypes };
+				}
+			),
 			uniqueName: output.uniqueName,
 			wasmLoading: output.wasmLoading,
 			webassemblyModuleFilename: output.webassemblyModuleFilename,
@@ -393,13 +411,15 @@ const getNormalizedWebpackOptions = config => ({
 		return result;
 	}),
 	parallelism: config.parallelism,
-	performance: optionalNestedConfig(config.performance, performance => {
+	performance: optionalNestedConfig(config.performance, (performance) => {
 		if (performance === false) return false;
 		return {
 			...performance
 		};
 	}),
-	plugins: /** @type {Plugins} */ (nestedArray(config.plugins, p => [...p])),
+	plugins: /** @type {PluginsNormalized} */ (
+		nestedArray(config.plugins, (p) => p.filter(Boolean))
+	),
 	profile: config.profile,
 	recordsInputPath:
 		config.recordsInputPath !== undefined
@@ -409,39 +429,46 @@ const getNormalizedWebpackOptions = config => ({
 		config.recordsOutputPath !== undefined
 			? config.recordsOutputPath
 			: config.recordsPath,
-	resolve: nestedConfig(config.resolve, resolve => ({
+	resolve: nestedConfig(config.resolve, (resolve) => ({
 		...resolve,
 		byDependency: keyedNestedConfig(resolve.byDependency, cloneObject)
 	})),
 	resolveLoader: cloneObject(config.resolveLoader),
-	snapshot: nestedConfig(config.snapshot, snapshot => ({
+	snapshot: nestedConfig(config.snapshot, (snapshot) => ({
 		resolveBuildDependencies: optionalNestedConfig(
 			snapshot.resolveBuildDependencies,
-			resolveBuildDependencies => ({
+			(resolveBuildDependencies) => ({
 				timestamp: resolveBuildDependencies.timestamp,
 				hash: resolveBuildDependencies.hash
 			})
 		),
 		buildDependencies: optionalNestedConfig(
 			snapshot.buildDependencies,
-			buildDependencies => ({
+			(buildDependencies) => ({
 				timestamp: buildDependencies.timestamp,
 				hash: buildDependencies.hash
 			})
 		),
-		resolve: optionalNestedConfig(snapshot.resolve, resolve => ({
+		resolve: optionalNestedConfig(snapshot.resolve, (resolve) => ({
 			timestamp: resolve.timestamp,
 			hash: resolve.hash
 		})),
-		module: optionalNestedConfig(snapshot.module, module => ({
+		module: optionalNestedConfig(snapshot.module, (module) => ({
 			timestamp: module.timestamp,
 			hash: module.hash
 		})),
-		immutablePaths: optionalNestedArray(snapshot.immutablePaths, p => [...p]),
-		managedPaths: optionalNestedArray(snapshot.managedPaths, p => [...p]),
-		unmanagedPaths: optionalNestedArray(snapshot.unmanagedPaths, p => [...p])
+		contextModule: optionalNestedConfig(
+			snapshot.contextModule,
+			(contextModule) => ({
+				timestamp: contextModule.timestamp,
+				hash: contextModule.hash
+			})
+		),
+		immutablePaths: optionalNestedArray(snapshot.immutablePaths, (p) => [...p]),
+		managedPaths: optionalNestedArray(snapshot.managedPaths, (p) => [...p]),
+		unmanagedPaths: optionalNestedArray(snapshot.unmanagedPaths, (p) => [...p])
 	})),
-	stats: nestedConfig(config.stats, stats => {
+	stats: nestedConfig(config.stats, (stats) => {
 		if (stats === false) {
 			return {
 				preset: "none"
@@ -470,7 +497,7 @@ const getNormalizedWebpackOptions = config => ({
  * @param {EntryStatic} entry static entry options
  * @returns {EntryStaticNormalized} normalized static entry options
  */
-const getNormalizedEntryStatic = entry => {
+const getNormalizedEntryStatic = (entry) => {
 	if (typeof entry === "string") {
 		return {
 			main: {
@@ -532,7 +559,7 @@ const getNormalizedEntryStatic = entry => {
  * @param {OptimizationRuntimeChunk=} runtimeChunk runtimeChunk option
  * @returns {OptimizationRuntimeChunkNormalized=} normalized runtimeChunk option
  */
-const getNormalizedOptimizationRuntimeChunk = runtimeChunk => {
+const getNormalizedOptimizationRuntimeChunk = (runtimeChunk) => {
 	if (runtimeChunk === undefined) return;
 	if (runtimeChunk === false) return false;
 	if (runtimeChunk === "single") {
@@ -542,16 +569,16 @@ const getNormalizedOptimizationRuntimeChunk = runtimeChunk => {
 	}
 	if (runtimeChunk === true || runtimeChunk === "multiple") {
 		return {
-			/**
-			 * @param {Entrypoint} entrypoint entrypoint
-			 * @returns {string} runtime chunk name
-			 */
-			name: entrypoint => `runtime~${entrypoint.name}`
+			name: (entrypoint) => `runtime~${entrypoint.name}`
 		};
 	}
 	const { name } = runtimeChunk;
 	return {
-		name: typeof name === "function" ? name : () => name
+		name:
+			typeof name === "function"
+				? /** @type {Exclude<OptimizationRuntimeChunkNormalized, false>["name"]} */
+					(name)
+				: () => /** @type {string} */ (name)
 	};
 };
 

package/lib/config/target.js

@@ -15,19 +15,19 @@ const getBrowserslistTargetHandler = memoize(() =>
  * @param {string} context the context directory
  * @returns {string} default target
  */
-const getDefaultTarget = context => {
-	const browsers = getBrowserslistTargetHandler().load(null, context);
+const getDefaultTarget = (context) => {
+	const browsers = getBrowserslistTargetHandler().load(undefined, context);
 	return browsers ? "browserslist" : "web";
 };
 
 /**
  * @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
  */
 
 /**
@@ -42,6 +42,7 @@ const getDefaultTarget = context => {
  * @property {boolean | null} require has require function available
  * @property {boolean | null} nodeBuiltins has node.js built-in modules available
  * @property {boolean | null} nodePrefixForCoreModules node.js allows to use `node:` prefix for core modules
+ * @property {boolean | null} importMetaDirnameAndFilename node.js allows to use `import.meta.dirname` and `import.meta.filename`
  * @property {boolean | null} document has document available (allows script tags)
  * @property {boolean | null} importScripts has importScripts available
  * @property {boolean | null} importScriptsInWorker has importScripts available when creating a worker
@@ -54,6 +55,7 @@ const getDefaultTarget = context => {
  * @property {boolean | null} globalThis has globalThis variable available
  * @property {boolean | null} bigIntLiteral big int literal syntax is available
  * @property {boolean | null} const const and let variable declarations are available
+ * @property {boolean | null} methodShorthand object method shorthand is available
  * @property {boolean | null} arrowFunction arrow functions are available
  * @property {boolean | null} forOf for of iteration is available
  * @property {boolean | null} destructuring destructuring is available
@@ -178,6 +180,9 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 				nodeBuiltins: true,
 				// v16.0.0, v14.18.0
 				nodePrefixForCoreModules: Number(major) < 15 ? v(14, 18) : v(16),
+				// Added in: v21.2.0, v20.11.0, but Node.js will output experimental warning, we don't want it
+				// v24.0.0, v22.16.0 - This property is no longer experimental.
+				importMetaDirnameAndFilename: v(22, 16),
 				global: true,
 				document: false,
 				fetchWasm: false,
@@ -188,13 +193,14 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 				const: v(6),
 				templateLiteral: v(4),
 				optionalChaining: v(14),
+				methodShorthand: v(4),
 				arrowFunction: v(6),
 				asyncFunction: v(7, 6),
 				forOf: v(5),
 				destructuring: v(6),
 				bigIntLiteral: v(10, 4),
 				dynamicImport: v(12, 17),
-				dynamicImportInWorker: major ? false : undefined,
+				dynamicImportInWorker: v(12, 17),
 				module: v(12, 17)
 			};
 		}
@@ -223,6 +229,8 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 				// 15.0.0	- Node.js	v16.5
 				// 14.0.0 - Mode.js v14.17, but prefixes only since v14.18
 				nodePrefixForCoreModules: v(15),
+				// 37.0.0 - Node.js v22.16
+				importMetaDirnameAndFilename: v(37),
 
 				require: true,
 				document: context === "renderer",
@@ -234,13 +242,14 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 				const: v(1, 1),
 				templateLiteral: v(1, 1),
 				optionalChaining: v(8),
+				methodShorthand: v(1, 1),
 				arrowFunction: v(1, 1),
 				asyncFunction: v(1, 7),
 				forOf: v(0, 36),
 				destructuring: v(1, 1),
 				bigIntLiteral: v(4),
 				dynamicImport: v(11),
-				dynamicImportInWorker: major ? false : undefined,
+				dynamicImportInWorker: v(11),
 				module: v(11)
 			};
 		}
@@ -272,13 +281,14 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 				const: v(0, 15),
 				templateLiteral: v(0, 13),
 				optionalChaining: v(0, 44),
+				methodShorthand: v(0, 15),
 				arrowFunction: v(0, 15),
 				asyncFunction: v(0, 21),
 				forOf: v(0, 13),
 				destructuring: v(0, 15),
 				bigIntLiteral: v(0, 32),
 				dynamicImport: v(0, 43),
-				dynamicImportInWorker: major ? false : undefined,
+				dynamicImportInWorker: v(0, 44),
 				module: v(0, 43)
 			};
 		}
@@ -287,13 +297,14 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 		"esX",
 		"EcmaScript in this version. Examples: es2020, es5.",
 		/^es(\d+)$/,
-		version => {
+		(version) => {
 			let v = Number(version);
-			if (v < 1000) v = v + 2009;
+			if (v < 1000) v += 2009;
 			return {
 				const: v >= 2015,
 				templateLiteral: v >= 2015,
 				optionalChaining: v >= 2020,
+				methodShorthand: v >= 2015,
 				arrowFunction: v >= 2015,
 				forOf: v >= 2015,
 				destructuring: v >= 2015,
@@ -333,7 +344,7 @@ const getTargetProperties = (target, context) => {
  * @param {TargetProperties[]} targetProperties array of target properties
  * @returns {TargetProperties} merged target properties
  */
-const mergeTargetProperties = targetProperties => {
+const mergeTargetProperties = (targetProperties) => {
 	/** @type {Set<keyof TargetProperties>} */
 	const keys = new Set();
 	for (const tp of targetProperties) {
@@ -341,7 +352,7 @@ const mergeTargetProperties = targetProperties => {
 			keys.add(/** @type {keyof TargetProperties} */ (key));
 		}
 	}
-	/** @type {object} */
+	/** @type {TargetProperties} */
 	const result = {};
 	for (const key of keys) {
 		let hasTrue = false;
@@ -357,11 +368,12 @@ const mergeTargetProperties = targetProperties => {
 					break;
 			}
 		}
-		if (hasTrue || hasFalse)
+		if (hasTrue || hasFalse) {
 			/** @type {TargetProperties} */
 			(result)[key] = hasFalse && hasTrue ? null : Boolean(hasTrue);
+		}
 	}
-	return /** @type {TargetProperties} */ (result);
+	return result;
 };
 
 /**
@@ -370,7 +382,7 @@ const mergeTargetProperties = targetProperties => {
  * @returns {TargetProperties} target properties
  */
 const getTargetsProperties = (targets, context) =>
-	mergeTargetProperties(targets.map(t => getTargetProperties(t, context)));
+	mergeTargetProperties(targets.map((t) => getTargetProperties(t, context)));
 
 module.exports.getDefaultTarget = getDefaultTarget;
 module.exports.getTargetProperties = getTargetProperties;

package/lib/container/ContainerEntryDependency.js

@@ -8,7 +8,6 @@
 const Dependency = require("../Dependency");
 const makeSerializable = require("../util/makeSerializable");
 
-/** @typedef {import("./ContainerEntryModule").ExposeOptions} ExposeOptions */
 /** @typedef {import("./ContainerEntryModule").ExposesList} ExposesList */
 
 class ContainerEntryDependency extends Dependency {

package/lib/container/ContainerEntryModule.js

@@ -8,7 +8,10 @@
 const { OriginalSource, RawSource } = require("webpack-sources");
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Module = require("../Module");
-const { JS_TYPES } = require("../ModuleSourceTypesConstants");
+const {
+	JAVASCRIPT_TYPE,
+	JAVASCRIPT_TYPES
+} = require("../ModuleSourceTypeConstants");
 const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
@@ -16,23 +19,21 @@ const StaticExportsDependency = require("../dependencies/StaticExportsDependency
 const makeSerializable = require("../util/makeSerializable");
 const ContainerExposedDependency = require("./ContainerExposedDependency");
 
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @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").LibIdent} LibIdent */
+/** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../WebpackError")} WebpackError */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./ContainerEntryDependency")} ContainerEntryDependency */
 
 /**
  * @typedef {object} ExposeOptions
@@ -59,7 +60,7 @@ class ContainerEntryModule extends Module {
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
-		return JS_TYPES;
+		return JAVASCRIPT_TYPES;
 	}
 
 	/**
@@ -81,7 +82,7 @@ class ContainerEntryModule extends Module {
 
 	/**
 	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @returns {LibIdent | null} an identifier for library inclusion
 	 */
 	libIdent(options) {
 		return `${this.layer ? `(${this.layer})/` : ""}webpack/container/entry/${
@@ -91,7 +92,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 +104,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) {
@@ -157,7 +158,7 @@ class ContainerEntryModule extends Module {
 		for (const block of this.blocks) {
 			const { dependencies } = block;
 
-			const modules = dependencies.map(dependency => {
+			const modules = dependencies.map((dependency) => {
 				const dep = /** @type {ContainerExposedDependency} */ (dependency);
 				return {
 					name: dep.exposedName,
@@ -168,9 +169,9 @@ class ContainerEntryModule extends Module {
 
 			let str;
 
-			if (modules.some(m => !m.module)) {
+			if (modules.some((m) => !m.module)) {
 				str = runtimeTemplate.throwMissingModuleErrorBlock({
-					request: modules.map(m => m.request).join(", ")
+					request: modules.map((m) => m.request).join(", ")
 				});
 			} else {
 				str = `return ${runtimeTemplate.blockPromise({
@@ -244,7 +245,7 @@ class ContainerEntryModule extends Module {
 		]);
 
 		sources.set(
-			"javascript",
+			JAVASCRIPT_TYPE,
 			this.useSourceMap || this.useSimpleSourceMap
 				? new OriginalSource(source, "webpack/container-entry")
 				: new RawSource(source)