webpack 5.99.5 → 5.99.7

package/lib/buildChunkGraph.js

@@ -256,6 +256,7 @@ const visitModules = (
 ) => {
 	const { moduleGraph, chunkGraph, moduleMemCaches } = compilation;
 
+	/** @type {Map<RuntimeSpec, BlockModulesMap>} */
 	const blockModulesRuntimeMap = new Map();
 
 	/** @type {BlockModulesMap | undefined} */
@@ -288,11 +289,12 @@ const visitModules = (
 	/**
 	 * @param {DependenciesBlock} block block
 	 * @param {RuntimeSpec} runtime runtime
-	 * @returns {BlockModulesInFlattenTuples} block modules in flatten tuples
+	 * @returns {BlockModulesInFlattenTuples | undefined} block modules in flatten tuples
 	 */
 	const getBlockModules = (block, runtime) => {
 		blockModulesMap = blockModulesRuntimeMap.get(runtime);
 		if (blockModulesMap === undefined) {
+			/** @type {BlockModulesMap} */
 			blockModulesMap = new Map();
 			blockModulesRuntimeMap.set(runtime, blockModulesMap);
 		}
@@ -301,6 +303,7 @@ const visitModules = (
 		const module = /** @type {Module} */ (block.getRootBlock());
 		const memCache = moduleMemCaches && moduleMemCaches.get(module);
 		if (memCache !== undefined) {
+			/** @type {BlockModulesMap} */
 			const map = memCache.provide(
 				"bundleChunkGraph.blockModules",
 				runtime,
@@ -1162,7 +1165,9 @@ const visitModules = (
 			 * @param {BlocksWithNestedBlocks} visited visited dependencies blocks
 			 */
 			const process = (current, visited) => {
-				const blockModules = getBlockModules(current, runtime);
+				const blockModules =
+					/** @type {BlockModulesInFlattenTuples} */
+					(getBlockModules(current, runtime));
 				for (let i = 0, len = blockModules.length; i < len; i += 3) {
 					const activeState = /** @type {ConnectionState} */ (
 						blockModules[i + 1]

package/lib/cache/IdleFileCachePlugin.js

@@ -12,6 +12,7 @@ const ProgressPlugin = require("../ProgressPlugin");
 /** @typedef {import("./PackFileCacheStrategy")} PackFileCacheStrategy */
 
 const BUILD_DEPENDENCIES_KEY = Symbol("build dependencies key");
+const PLUGIN_NAME = "IdleFileCachePlugin";
 
 class IdleFileCachePlugin {
 	/**
@@ -55,7 +56,7 @@ class IdleFileCachePlugin {
 		const pendingIdleTasks = new Map();
 
 		compiler.cache.hooks.store.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			(identifier, etag, data) => {
 				pendingIdleTasks.set(identifier, () =>
 					strategy.store(identifier, etag, data)
@@ -64,7 +65,7 @@ class IdleFileCachePlugin {
 		);
 
 		compiler.cache.hooks.get.tapPromise(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			(identifier, etag, gotHandlers) => {
 				const restore = () =>
 					strategy.restore(identifier, etag).then(cacheEntry => {
@@ -91,7 +92,7 @@ class IdleFileCachePlugin {
 		);
 
 		compiler.cache.hooks.storeBuildDependencies.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			dependencies => {
 				pendingIdleTasks.set(BUILD_DEPENDENCIES_KEY, () =>
 					Promise.resolve().then(() =>
@@ -102,7 +103,7 @@ class IdleFileCachePlugin {
 		);
 
 		compiler.cache.hooks.shutdown.tapPromise(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			() => {
 				if (idleTimer) {
 					clearTimeout(idleTimer);
@@ -129,7 +130,7 @@ class IdleFileCachePlugin {
 			}
 		);
 
-		/** @type {Promise<any>} */
+		/** @type {Promise<TODO>} */
 		let currentIdlePromise = resolvedPromise;
 		let isIdle = false;
 		let isInitialStore = true;
@@ -165,9 +166,7 @@ class IdleFileCachePlugin {
 						timeSpendInBuild = 0;
 					})
 					.catch(err => {
-						const logger = compiler.getInfrastructureLogger(
-							"IdleFileCachePlugin"
-						);
+						const logger = compiler.getInfrastructureLogger(PLUGIN_NAME);
 						logger.warn(`Background tasks during idle failed: ${err.message}`);
 						logger.debug(err.stack);
 					});
@@ -177,12 +176,12 @@ class IdleFileCachePlugin {
 		/** @type {ReturnType<typeof setTimeout> | undefined} */
 		let idleTimer;
 		compiler.cache.hooks.beginIdle.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			() => {
 				const isLargeChange = timeSpendInBuild > avgTimeSpendInStore * 2;
 				if (isInitialStore && idleTimeoutForInitialStore < idleTimeout) {
 					compiler
-						.getInfrastructureLogger("IdleFileCachePlugin")
+						.getInfrastructureLogger(PLUGIN_NAME)
 						.log(
 							`Initial cache was generated and cache will be persisted in ${
 								idleTimeoutForInitialStore / 1000
@@ -193,7 +192,7 @@ class IdleFileCachePlugin {
 					idleTimeoutAfterLargeChanges < idleTimeout
 				) {
 					compiler
-						.getInfrastructureLogger("IdleFileCachePlugin")
+						.getInfrastructureLogger(PLUGIN_NAME)
 						.log(
 							`Spend ${Math.round(timeSpendInBuild) / 1000}s in build and ${
 								Math.round(avgTimeSpendInStore) / 1000
@@ -218,7 +217,7 @@ class IdleFileCachePlugin {
 			}
 		);
 		compiler.cache.hooks.endIdle.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			() => {
 				if (idleTimer) {
 					clearTimeout(idleTimer);
@@ -227,7 +226,7 @@ class IdleFileCachePlugin {
 				isIdle = false;
 			}
 		);
-		compiler.hooks.done.tap("IdleFileCachePlugin", stats => {
+		compiler.hooks.done.tap(PLUGIN_NAME, stats => {
 			// 10% build overhead is ignored, as it's not cacheable
 			timeSpendInBuild *= 0.9;
 			timeSpendInBuild +=

package/lib/cache/MemoryCachePlugin.js

@@ -8,6 +8,7 @@
 const Cache = require("../Cache");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Cache").Data} Data */
 /** @typedef {import("../Cache").Etag} Etag */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
@@ -19,7 +20,7 @@ class MemoryCachePlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		/** @type {Map<string, { etag: Etag | null, data: any } | null>} */
+		/** @type {Map<string, { etag: Etag | null, data: Data } | null>} */
 		const cache = new Map();
 		compiler.cache.hooks.store.tap(
 			{ name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },

package/lib/cache/MemoryWithGcCachePlugin.js

@@ -8,6 +8,7 @@
 const Cache = require("../Cache");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Cache").Data} Data */
 /** @typedef {import("../Cache").Etag} Etag */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
@@ -17,6 +18,8 @@ const Cache = require("../Cache");
  * @property {number} maxGenerations max generations
  */
 
+const PLUGIN_NAME = "MemoryWithGcCachePlugin";
+
 class MemoryWithGcCachePlugin {
 	/**
 	 * @param {MemoryWithGcCachePluginOptions} options options
@@ -32,14 +35,14 @@ class MemoryWithGcCachePlugin {
 	 */
 	apply(compiler) {
 		const maxGenerations = this._maxGenerations;
-		/** @type {Map<string, { etag: Etag | null, data: any } | undefined | null>} */
+		/** @type {Map<string, { etag: Etag | null, data: Data } | undefined | null>} */
 		const cache = new Map();
-		/** @type {Map<string, { entry: { etag: Etag | null, data: any } | null, until: number }>} */
+		/** @type {Map<string, { entry: { etag: Etag | null, data: Data } | null, until: number }>} */
 		const oldCache = new Map();
 		let generation = 0;
 		let cachePosition = 0;
-		const logger = compiler.getInfrastructureLogger("MemoryWithGcCachePlugin");
-		compiler.hooks.afterDone.tap("MemoryWithGcCachePlugin", () => {
+		const logger = compiler.getInfrastructureLogger(PLUGIN_NAME);
+		compiler.hooks.afterDone.tap(PLUGIN_NAME, () => {
 			generation++;
 			let clearedEntries = 0;
 			let lastClearedIdentifier;
@@ -90,13 +93,13 @@ class MemoryWithGcCachePlugin {
 			}
 		});
 		compiler.cache.hooks.store.tap(
-			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_MEMORY },
 			(identifier, etag, data) => {
 				cache.set(identifier, { etag, data });
 			}
 		);
 		compiler.cache.hooks.get.tap(
-			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_MEMORY },
 			(identifier, etag, gotHandlers) => {
 				const cacheEntry = cache.get(identifier);
 				if (cacheEntry === null) {
@@ -128,7 +131,7 @@ class MemoryWithGcCachePlugin {
 			}
 		);
 		compiler.cache.hooks.shutdown.tap(
-			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_MEMORY },
 			() => {
 				cache.clear();
 				oldCache.clear();

package/lib/cache/PackFileCacheStrategy.js

@@ -18,6 +18,7 @@ const {
 } = require("../util/serialization");
 
 /** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
+/** @typedef {import("../Cache").Data} Data */
 /** @typedef {import("../Cache").Etag} Etag */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../FileSystemInfo").ResolveBuildDependenciesResult} ResolveBuildDependenciesResult */
@@ -96,14 +97,11 @@ const MIN_ITEMS_IN_FRESH_PACK = 100;
 const MAX_ITEMS_IN_FRESH_PACK = 50000;
 const MAX_TIME_IN_FRESH_PACK = 1 * 60 * 1000; // 1 min
 
-/** @typedef {TODO | undefined} Value */
-/** @typedef {TODO | undefined} LazyValue */
-
 class PackItemInfo {
 	/**
 	 * @param {string} identifier identifier of item
 	 * @param {string | null | undefined} etag etag of item
-	 * @param {Value} value fresh value of item
+	 * @param {Data} value fresh value of item
 	 */
 	constructor(identifier, etag, value) {
 		this.identifier = identifier;
@@ -158,7 +156,7 @@ class Pack {
 	/**
 	 * @param {string} identifier unique name for the resource
 	 * @param {string | null} etag etag of the resource
-	 * @returns {Value} cached content
+	 * @returns {Data} cached content
 	 */
 	get(identifier, etag) {
 		const info = this.itemInfo.get(identifier);
@@ -181,7 +179,7 @@ class Pack {
 	/**
 	 * @param {string} identifier unique name for the resource
 	 * @param {string | null} etag etag of the resource
-	 * @param {Value} data cached content
+	 * @param {Data} data cached content
 	 * @returns {void}
 	 */
 	set(identifier, etag, data) {
@@ -667,7 +665,7 @@ class Pack {
 
 makeSerializable(Pack, "webpack/lib/cache/PackFileCacheStrategy", "Pack");
 
-/** @typedef {Map<string, Value>} Content */
+/** @typedef {Map<string, Data>} Content */
 
 class PackContentItems {
 	/**
@@ -799,7 +797,7 @@ makeSerializable(
 	"PackContentItems"
 );
 
-/** @typedef {(() => Promise<PackContentItems> | PackContentItems)} LazyFunction */
+/** @typedef {(() => Promise<PackContentItems> | PackContentItems) & Partial<{ options: { size?: number }}>} LazyFunction */
 
 class PackContent {
 	/*
@@ -830,7 +828,7 @@ class PackContent {
 	 */
 	constructor(items, usedItems, dataOrFn, logger, lazyName) {
 		this.items = items;
-		/** @type {LazyValue} */
+		/** @type {LazyFunction | undefined} */
 		this.lazy = typeof dataOrFn === "function" ? dataOrFn : undefined;
 		/** @type {Content | undefined} */
 		this.content = typeof dataOrFn === "function" ? undefined : dataOrFn.map;
@@ -877,10 +875,7 @@ class PackContent {
 				}
 				// Move to state C
 				this.content = map;
-				this.lazy = SerializerMiddleware.unMemoizeLazy(
-					/** @type {LazyFunction} */
-					(this.lazy)
-				);
+				this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
 				return map.get(identifier);
 			});
 		}
@@ -891,10 +886,7 @@ class PackContent {
 		}
 		// Move to state C
 		this.content = map;
-		this.lazy = SerializerMiddleware.unMemoizeLazy(
-			/** @type {LazyFunction} */
-			(this.lazy)
-		);
+		this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
 		return map.get(identifier);
 	}
 
@@ -966,8 +958,7 @@ class PackContent {
 	}
 
 	/**
-	 * @template T
-	 * @param {(item?: LazyValue) => (() => Promise<PackContentItems> | PackContentItems)} write write function
+	 * @param {(lazy: LazyFunction) => (() => PackContentItems | Promise<PackContentItems>)} write write function
 	 * @returns {void}
 	 */
 	writeLazy(write) {
@@ -1100,6 +1091,7 @@ class PackFileCacheStrategy {
 		compression,
 		readonly
 	}) {
+		/** @type {import("../serialization/Serializer")<PackContainer, null, {}>} */
 		this.fileSerializer = createFileSerializer(
 			fs,
 			/** @type {string | Hash} */
@@ -1319,7 +1311,7 @@ class PackFileCacheStrategy {
 	/**
 	 * @param {string} identifier unique name for the resource
 	 * @param {Etag | null} etag etag of the resource
-	 * @param {Value} data cached content
+	 * @param {Data} data cached content
 	 * @returns {Promise<void>} promise
 	 */
 	store(identifier, etag, data) {
@@ -1333,7 +1325,7 @@ class PackFileCacheStrategy {
 	/**
 	 * @param {string} identifier unique name for the resource
 	 * @param {Etag | null} etag etag of the resource
-	 * @returns {Promise<Value>} promise to the cached content
+	 * @returns {Promise<Data>} promise to the cached content
 	 */
 	restore(identifier, etag) {
 		return this._getPack()

package/lib/cache/ResolverCachePlugin.js

@@ -95,6 +95,10 @@ const objectToString = (object, excludeContext) => {
 	return str;
 };
 
+/** @typedef {NonNullable<ResolveContext["yield"]>} Yield */
+
+const PLUGIN_NAME = "ResolverCachePlugin";
+
 class ResolverCachePlugin {
 	/**
 	 * Apply the plugin
@@ -102,7 +106,7 @@ class ResolverCachePlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const cache = compiler.getCache("ResolverCachePlugin");
+		const cache = compiler.getCache(PLUGIN_NAME);
 		/** @type {FileSystemInfo} */
 		let fileSystemInfo;
 		/** @type {SnapshotOptions | undefined} */
@@ -111,12 +115,12 @@ class ResolverCachePlugin {
 		let cachedResolves = 0;
 		let cacheInvalidResolves = 0;
 		let concurrentResolves = 0;
-		compiler.hooks.thisCompilation.tap("ResolverCachePlugin", compilation => {
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
 			snapshotOptions = compilation.options.snapshot.resolve;
 			fileSystemInfo = compilation.fileSystemInfo;
-			compilation.hooks.finishModules.tap("ResolverCachePlugin", () => {
+			compilation.hooks.finishModules.tap(PLUGIN_NAME, () => {
 				if (realResolves + cachedResolves > 0) {
-					const logger = compilation.getLogger("webpack.ResolverCachePlugin");
+					const logger = compilation.getLogger(`webpack.${PLUGIN_NAME}`);
 					logger.log(
 						`${Math.round(
 							(100 * realResolves) / (realResolves + cachedResolves)
@@ -253,13 +257,17 @@ class ResolverCachePlugin {
 				/** @typedef {(err?: Error, resolveRequest?: ResolveRequest) => void} ActiveRequest */
 				/** @type {Map<string, ActiveRequest[]>} */
 				const activeRequests = new Map();
-				/** @type {Map<string, [ActiveRequest, NonNullable<ResolveContext["yield"]>][]>} */
+				/** @type {Map<string, [ActiveRequest[], Yield[]]>} */
 				const activeRequestsWithYield = new Map();
 				const hook =
 					/** @type {SyncHook<[Resolver, ResolveOptions, ResolveOptionsWithDependencyType]>} */
 					(_hook);
-				hook.tap("ResolverCachePlugin", (resolver, options, userOptions) => {
-					if (/** @type {TODO} */ (options).cache !== true) return;
+				hook.tap(PLUGIN_NAME, (resolver, options, userOptions) => {
+					if (
+						/** @type {ResolveOptions & { cache: boolean }} */
+						(options).cache !== true
+					)
+						return;
 					const optionsIdent = objectToString(userOptions, false);
 					const cacheWithContext =
 						options.cacheWithContext !== undefined
@@ -267,7 +275,7 @@ class ResolverCachePlugin {
 							: false;
 					resolver.hooks.resolve.tapAsync(
 						{
-							name: "ResolverCachePlugin",
+							name: PLUGIN_NAME,
 							stage: -100
 						},
 						(request, resolveContext, callback) => {
@@ -288,7 +296,7 @@ class ResolverCachePlugin {
 								if (activeRequest) {
 									activeRequest[0].push(callback);
 									activeRequest[1].push(
-										/** @type {NonNullable<ResolveContext["yield"]>} */
+										/** @type {Yield} */
 										(resolveContext.yield)
 									);
 									return;
@@ -303,7 +311,7 @@ class ResolverCachePlugin {
 							const itemCache = cache.getItemCache(identifier, null);
 							/** @type {Callback[] | false | undefined} */
 							let callbacks;
-							/** @type {NonNullable<ResolveContext["yield"]>[] | undefined} */
+							/** @type {Yield[] | undefined} */
 							let yields;
 
 							/**
@@ -319,7 +327,7 @@ class ResolverCachePlugin {
 													for (const r of /** @type {ResolveRequest[]} */ (
 														result
 													)) {
-														/** @type {NonNullable<ResolveContext["yield"]>} */
+														/** @type {Yield} */
 														(resolveContext.yield)(r);
 													}
 												callback(null, null);
@@ -336,9 +344,7 @@ class ResolverCachePlugin {
 											} else {
 												for (let i = 0; i < definedCallbacks.length; i++) {
 													const cb = definedCallbacks[i];
-													const yield_ =
-														/** @type {NonNullable<ResolveContext["yield"]>[]} */
-														(yields)[i];
+													const yield_ = /** @type {Yield[]} */ (yields)[i];
 													if (result)
 														for (const r of /** @type {ResolveRequest[]} */ (
 															result
@@ -424,14 +430,8 @@ class ResolverCachePlugin {
 							itemCache.get(processCacheResult);
 							if (withYield && callbacks === undefined) {
 								callbacks = [callback];
-								yields = [
-									/** @type {NonNullable<ResolveContext["yield"]>} */
-									(resolveContext.yield)
-								];
-								activeRequestsWithYield.set(
-									identifier,
-									/** @type {[any, any]} */ ([callbacks, yields])
-								);
+								yields = [/** @type {Yield} */ (resolveContext.yield)];
+								activeRequestsWithYield.set(identifier, [callbacks, yields]);
 							} else if (callbacks === undefined) {
 								callbacks = [callback];
 								activeRequests.set(identifier, callbacks);

package/lib/cli.js

@@ -8,7 +8,11 @@
 const path = require("path");
 const webpackSchema = require("../schemas/WebpackOptions.json");
 
-/** @typedef {Parameters<import("schema-utils").validate>[0] & { absolutePath: boolean, instanceof: string, cli: { helper?: boolean, exclude?: boolean, description?: string, negatedDescription?: string, resetDescription?: string } }} Schema */
+/** @typedef {import("json-schema").JSONSchema4} JSONSchema4 */
+/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */
+/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */
+/** @typedef {JSONSchema4 | JSONSchema6 | JSONSchema7} JSONSchema */
+/** @typedef {JSONSchema & { absolutePath: boolean, instanceof: string, cli: { helper?: boolean, exclude?: boolean, description?: string, negatedDescription?: string, resetDescription?: string } }} Schema */
 
 // TODO add originPath to PathItem for better errors
 /**
@@ -44,11 +48,11 @@ const webpackSchema = require("../schemas/WebpackOptions.json");
 
 /**
  * @typedef {object} ArgumentConfig
- * @property {string | undefined} description
- * @property {string} [negatedDescription]
+ * @property {string=} description
+ * @property {string=} negatedDescription
  * @property {string} path
  * @property {boolean} multiple
- * @property {"enum"|"string"|"path"|"number"|"boolean"|"RegExp"|"reset"} type
+ * @property {"enum" | "string" | "path" | "number" | "boolean" | "RegExp" | "reset"} type
  * @property {EnumValue[]=} values
  */
 

package/lib/config/defaults.js

@@ -166,7 +166,7 @@ const applyWebpackOptionsBaseDefaults = options => {
 
 /**
  * @param {WebpackOptionsNormalized} options options to be modified
- * @param {number} [compilerIndex] index of compiler
+ * @param {number=} compilerIndex index of compiler
  * @returns {ResolvedOptions} Resolved options after apply defaults
  */
 const applyWebpackOptionsDefaults = (options, compilerIndex) => {
@@ -405,7 +405,7 @@ const applyExperimentsDefaults = (
  * @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 {number=} options.compilerIndex index of compiler
  * @param {Experiments["cacheUnaffected"]} options.cacheUnaffected the cacheUnaffected experiment is enabled
  * @returns {void}
  */

package/lib/config/normalization.js

@@ -22,6 +22,7 @@ const util = require("util");
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
 /** @typedef {import("../Entrypoint")} Entrypoint */
+/** @typedef {import("../WebpackError")} WebpackError */
 
 const handledDeprecatedNoEmitOnErrors = util.deprecate(
 	/**
@@ -210,14 +211,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;

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
  */
 
 /**

package/lib/container/ContainerReferencePlugin.js

@@ -31,6 +31,7 @@ const validate = createSchemaValidation(
 );
 
 const slashCode = "/".charCodeAt(0);
+const PLUGIN_NAME = "ContainerReferencePlugin";
 
 class ContainerReferencePlugin {
 	/**
@@ -79,7 +80,7 @@ class ContainerReferencePlugin {
 		new ExternalsPlugin(remoteType, remoteExternals).apply(compiler);
 
 		compiler.hooks.compilation.tap(
-			"ContainerReferencePlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					RemoteToExternalDependency,
@@ -96,37 +97,34 @@ class ContainerReferencePlugin {
 					new FallbackModuleFactory()
 				);
 
-				normalModuleFactory.hooks.factorize.tap(
-					"ContainerReferencePlugin",
-					data => {
-						if (!data.request.includes("!")) {
-							for (const [key, config] of remotes) {
-								if (
-									data.request.startsWith(`${key}`) &&
-									(data.request.length === key.length ||
-										data.request.charCodeAt(key.length) === slashCode)
-								) {
-									return new RemoteModule(
-										data.request,
-										config.external.map((external, i) =>
-											external.startsWith("internal ")
-												? external.slice(9)
-												: `webpack/container/reference/${key}${
-														i ? `/fallback-${i}` : ""
-													}`
-										),
-										`.${data.request.slice(key.length)}`,
-										config.shareScope
-									);
-								}
+				normalModuleFactory.hooks.factorize.tap(PLUGIN_NAME, data => {
+					if (!data.request.includes("!")) {
+						for (const [key, config] of remotes) {
+							if (
+								data.request.startsWith(`${key}`) &&
+								(data.request.length === key.length ||
+									data.request.charCodeAt(key.length) === slashCode)
+							) {
+								return new RemoteModule(
+									data.request,
+									config.external.map((external, i) =>
+										external.startsWith("internal ")
+											? external.slice(9)
+											: `webpack/container/reference/${key}${
+													i ? `/fallback-${i}` : ""
+												}`
+									),
+									`.${data.request.slice(key.length)}`,
+									config.shareScope
+								);
 							}
 						}
 					}
-				);
+				});
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("ContainerReferencePlugin", (chunk, set) => {
+					.tap(PLUGIN_NAME, (chunk, set) => {
 						set.add(RuntimeGlobals.module);
 						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
 						set.add(RuntimeGlobals.hasOwnProperty);

package/lib/container/ModuleFederationPlugin.js

@@ -37,6 +37,7 @@ const validate = createSchemaValidation(
 
 /** @type {WeakMap<Compilation, CompilationHooks>} */
 const compilationHooksMap = new WeakMap();
+const PLUGIN_NAME = "ModuleFederationPlugin";
 
 class ModuleFederationPlugin {
 	/**
@@ -89,7 +90,7 @@ class ModuleFederationPlugin {
 		) {
 			compiler.options.output.enabledLibraryTypes.push(library.type);
 		}
-		compiler.hooks.afterPlugins.tap("ModuleFederationPlugin", () => {
+		compiler.hooks.afterPlugins.tap(PLUGIN_NAME, () => {
 			if (
 				options.exposes &&
 				(Array.isArray(options.exposes)

package/lib/css/CssGenerator.js

@@ -292,7 +292,7 @@ class CssGenerator extends Generator {
 					Array.from(exports).reduce((obj, [key, value]) => {
 						obj[key] = value;
 						return obj;
-					}, {})
+					}, /** @type {Record<string, string>} */ ({}))
 				);
 
 				return stringifiedExports.length + 42;