webpack 5.76.1 → 5.88.0

package/lib/optimize/SplitChunksPlugin.js

@@ -41,7 +41,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /**
  * @callback ChunkFilterFunction
  * @param {Chunk} chunk
- * @returns {boolean}
+ * @returns {boolean | undefined}
  */
 
 /**
@@ -69,7 +69,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {number=} maxInitialRequests
  * @property {(string | function(PathData, AssetInfo=): string)=} filename
  * @property {string=} idHint
- * @property {string} automaticNameDelimiter
+ * @property {string=} automaticNameDelimiter
  * @property {boolean=} reuseExistingChunk
  * @property {boolean=} usedExports
  */
@@ -254,12 +254,24 @@ const compareEntries = (a, b) => {
 	return compareModuleIterables(modulesA, modulesB);
 };
 
+/**
+ * @param {Chunk} chunk the chunk
+ * @returns {boolean} true, if the chunk is an entry chunk
+ */
 const INITIAL_CHUNK_FILTER = chunk => chunk.canBeInitial();
+/**
+ * @param {Chunk} chunk the chunk
+ * @returns {boolean} true, if the chunk is an async chunk
+ */
 const ASYNC_CHUNK_FILTER = chunk => !chunk.canBeInitial();
+/**
+ * @param {Chunk} chunk the chunk
+ * @returns {boolean} always true
+ */
 const ALL_CHUNK_FILTER = chunk => true;
 
 /**
- * @param {OptimizationSplitChunksSizes} value the sizes
+ * @param {OptimizationSplitChunksSizes | undefined} value the sizes
  * @param {string[]} defaultSizeTypes the default size types
  * @returns {SplitChunksSizes} normalized representation
  */
@@ -386,8 +398,8 @@ const totalSize = sizes => {
 };
 
 /**
- * @param {false|string|Function} name the chunk name
- * @returns {GetName} a function to get the name of the chunk
+ * @param {false|string|Function|undefined} name the chunk name
+ * @returns {GetName | undefined} a function to get the name of the chunk
  */
 const normalizeName = name => {
 	if (typeof name === "string") {
@@ -412,6 +424,11 @@ const normalizeChunksFilter = chunks => {
 	if (chunks === "all") {
 		return ALL_CHUNK_FILTER;
 	}
+	if (chunks instanceof RegExp) {
+		return chunk => {
+			return chunk.name ? chunks.test(chunk.name) : false;
+		};
+	}
 	if (typeof chunks === "function") {
 		return chunks;
 	}
@@ -839,6 +856,10 @@ module.exports = class SplitChunksPlugin {
 						}
 						return key;
 					};
+					/**
+					 * @param {bigint | Chunk} key key of the chunks
+					 * @returns {string} stringified key
+					 */
 					const keyToString = key => {
 						if (typeof key === "bigint") return key.toString(16);
 						return chunkIndexMap.get(key).toString(16);
@@ -910,6 +931,10 @@ module.exports = class SplitChunksPlugin {
 					// group these set of chunks by count
 					// to allow to check less sets via isSubset
 					// (only smaller sets can be subset)
+					/**
+					 * @param {IterableIterator<Set<Chunk>>} chunkSets set of sets of chunks
+					 * @returns {Map<number, Array<Set<Chunk>>>} map of sets of chunks by count
+					 */
 					const groupChunkSetsByCount = chunkSets => {
 						/** @type {Map<number, Array<Set<Chunk>>>} */
 						const chunkSetsByCount = new Map();
@@ -1019,8 +1044,9 @@ module.exports = class SplitChunksPlugin {
 							entry = new WeakMap();
 							selectedChunksCacheByChunksSet.set(chunks, entry);
 						}
-						/** @type {SelectedChunksResult} */
-						let entry2 = entry.get(chunkFilter);
+						let entry2 =
+							/** @type {SelectedChunksResult} */
+							(entry.get(chunkFilter));
 						if (entry2 === undefined) {
 							/** @type {Chunk[]} */
 							const selectedChunks = [];
@@ -1068,11 +1094,9 @@ module.exports = class SplitChunksPlugin {
 						// Break if minimum number of chunks is not reached
 						if (selectedChunks.length < cacheGroup.minChunks) return;
 						// Determine name for split chunk
-						const name = cacheGroup.getName(
-							module,
-							selectedChunks,
-							cacheGroup.key
-						);
+						const name =
+							/** @type {string} */
+							(cacheGroup.getName(module, selectedChunks, cacheGroup.key));
 						// Check if the name is ok
 						const existingChunk = compilation.namedChunks.get(name);
 						if (existingChunk) {
@@ -1139,7 +1163,7 @@ module.exports = class SplitChunksPlugin {
 								? ` name:${name}`
 								: ` chunks:${keyToString(selectedChunksKey)}`);
 						// Add module to maps
-						let info = chunksInfoMap.get(key);
+						let info = /** @type {ChunksInfoItem} */ (chunksInfoMap.get(key));
 						if (info === undefined) {
 							chunksInfoMap.set(
 								key,
@@ -1204,7 +1228,9 @@ module.exports = class SplitChunksPlugin {
 							getExportsChunkSetsInGraph();
 							/** @type {Set<Set<Chunk> | Chunk>} */
 							const set = new Set();
-							const groupedByUsedExports = groupedByExportsMap.get(module);
+							const groupedByUsedExports =
+								/** @type {Iterable<Chunk[]>} */
+								(groupedByExportsMap.get(module));
 							for (const chunks of groupedByUsedExports) {
 								const chunksKey = getKey(chunks);
 								for (const comb of getExportsCombinations(chunksKey))
@@ -1228,7 +1254,10 @@ module.exports = class SplitChunksPlugin {
 								if (count < cacheGroup.minChunks) continue;
 								// Select chunks by configuration
 								const { chunks: selectedChunks, key: selectedChunksKey } =
-									getSelectedChunks(chunkCombination, cacheGroup.chunksFilter);
+									getSelectedChunks(
+										chunkCombination,
+										/** @type {ChunkFilterFunction} */ (cacheGroup.chunksFilter)
+									);
 
 								addModuleToChunksInfoMap(
 									cacheGroup,
@@ -1320,12 +1349,13 @@ module.exports = class SplitChunksPlugin {
 							}
 						}
 
-						const item = bestEntry;
-						chunksInfoMap.delete(bestEntryKey);
+						const item = /** @type {ChunksInfoItem} */ (bestEntry);
+						chunksInfoMap.delete(/** @type {string} */ (bestEntryKey));
 
+						/** @type {Chunk["name"] | undefined} */
 						let chunkName = item.name;
 						// Variable for the new chunk (lazy created)
-						/** @type {Chunk} */
+						/** @type {Chunk | undefined} */
 						let newChunk;
 						// When no chunk name, check if we can reuse a chunk instead of creating a new one
 						let isExistingChunk = false;
@@ -1394,14 +1424,18 @@ module.exports = class SplitChunksPlugin {
 						) {
 							for (const chunk of usedChunks) {
 								// respect max requests
-								const maxRequests = chunk.isOnlyInitial()
-									? item.cacheGroup.maxInitialRequests
-									: chunk.canBeInitial()
-									? Math.min(
-											item.cacheGroup.maxInitialRequests,
-											item.cacheGroup.maxAsyncRequests
-									  )
-									: item.cacheGroup.maxAsyncRequests;
+								const maxRequests = /** @type {number} */ (
+									chunk.isOnlyInitial()
+										? item.cacheGroup.maxInitialRequests
+										: chunk.canBeInitial()
+										? Math.min(
+												/** @type {number} */
+												(item.cacheGroup.maxInitialRequests),
+												/** @type {number} */
+												(item.cacheGroup.maxAsyncRequests)
+										  )
+										: item.cacheGroup.maxAsyncRequests
+								);
 								if (
 									isFinite(maxRequests) &&
 									getRequests(chunk) >= maxRequests
@@ -1421,8 +1455,12 @@ module.exports = class SplitChunksPlugin {
 						// Were some (invalid) chunks removed from usedChunks?
 						// => readd all modules to the queue, as things could have been changed
 						if (usedChunks.size < item.chunks.size) {
-							if (isExistingChunk) usedChunks.add(newChunk);
-							if (usedChunks.size >= item.cacheGroup.minChunks) {
+							if (isExistingChunk)
+								usedChunks.add(/** @type {Chunk} */ (newChunk));
+							if (
+								/** @type {number} */ (usedChunks.size) >=
+								/** @type {number} */ (item.cacheGroup.minChunks)
+							) {
 								const chunksArr = Array.from(usedChunks);
 								for (const module of item.modules) {
 									addModuleToChunksInfoMap(
@@ -1466,7 +1504,7 @@ module.exports = class SplitChunksPlugin {
 								) {
 									// queue this item again to be processed again
 									// without violating modules
-									chunksInfoMap.set(bestEntryKey, item);
+									chunksInfoMap.set(/** @type {string} */ (bestEntryKey), item);
 								}
 								continue;
 							}
@@ -1696,7 +1734,9 @@ module.exports = class SplitChunksPlugin {
 									hashFilename(name, outputOptions);
 							}
 							if (i !== results.length - 1) {
-								const newPart = compilation.addChunk(name);
+								const newPart = compilation.addChunk(
+									/** @type {Chunk["name"]} */ (name)
+								);
 								chunk.split(newPart);
 								newPart.chunkReason = chunk.chunkReason;
 								// Add all modules to the new chunk
@@ -1711,7 +1751,7 @@ module.exports = class SplitChunksPlugin {
 								}
 							} else {
 								// change the chunk to be a part
-								chunk.name = name;
+								chunk.name = /** @type {Chunk["name"]} */ (name);
 							}
 						}
 					}

package/lib/performance/SizeLimitsPlugin.js

@@ -95,7 +95,7 @@ module.exports = class SizeLimitsPlugin {
 				}
 
 				const size = info.size || source.size();
-				if (size > assetSizeLimit) {
+				if (size > /** @type {number} */ (assetSizeLimit)) {
 					assetsOverSizeLimit.push({
 						name,
 						size
@@ -114,7 +114,7 @@ module.exports = class SizeLimitsPlugin {
 			for (const [name, entry] of compilation.entrypoints) {
 				const size = getEntrypointSize(entry);
 
-				if (size > entrypointSizeLimit) {
+				if (size > /** @type {number} */ (entrypointSizeLimit)) {
 					entrypointsOverLimit.push({
 						name: name,
 						size: size,
@@ -131,14 +131,17 @@ module.exports = class SizeLimitsPlugin {
 				// if !1, then 2, if !2 return
 				if (assetsOverSizeLimit.length > 0) {
 					warnings.push(
-						new AssetsOverSizeLimitWarning(assetsOverSizeLimit, assetSizeLimit)
+						new AssetsOverSizeLimitWarning(
+							assetsOverSizeLimit,
+							/** @type {number} */ (assetSizeLimit)
+						)
 					);
 				}
 				if (entrypointsOverLimit.length > 0) {
 					warnings.push(
 						new EntrypointsOverSizeLimitWarning(
 							entrypointsOverLimit,
-							entrypointSizeLimit
+							/** @type {number} */ (entrypointSizeLimit)
 						)
 					);
 				}

package/lib/prefetch/ChunkPrefetchFunctionRuntimeModule.js

@@ -7,6 +7,7 @@
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
@@ -23,11 +24,12 @@ class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
 		const { runtimeFunction, runtimeHandlers } = this;
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		return Template.asString([
 			`${runtimeHandlers} = {};`,
 			`${runtimeFunction} = ${runtimeTemplate.basicFunction("chunkId", [

package/lib/prefetch/ChunkPrefetchPreloadPlugin.js

@@ -11,6 +11,8 @@ const ChunkPrefetchStartupRuntimeModule = require("./ChunkPrefetchStartupRuntime
 const ChunkPrefetchTriggerRuntimeModule = require("./ChunkPrefetchTriggerRuntimeModule");
 const ChunkPreloadTriggerRuntimeModule = require("./ChunkPreloadTriggerRuntimeModule");
 
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
 /** @typedef {import("../Compiler")} Compiler */
 
 class ChunkPrefetchPreloadPlugin {
@@ -43,7 +45,7 @@ class ChunkPrefetchPreloadPlugin {
 				compilation.hooks.additionalTreeRuntimeRequirements.tap(
 					"ChunkPrefetchPreloadPlugin",
 					(chunk, set, { chunkGraph }) => {
-						const chunkMap = chunk.getChildIdsByOrdersMap(chunkGraph, false);
+						const chunkMap = chunk.getChildIdsByOrdersMap(chunkGraph);
 
 						if (chunkMap.prefetch) {
 							set.add(RuntimeGlobals.prefetchChunk);

package/lib/prefetch/ChunkPrefetchStartupRuntimeModule.js

@@ -9,6 +9,7 @@ const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
@@ -21,11 +22,13 @@ class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { startupChunks, chunk } = this;
-		const { runtimeTemplate } = this.compilation;
+		const { startupChunks } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const { runtimeTemplate } = compilation;
 		return Template.asString(
 			startupChunks.map(
 				({ onChunks, chunks }) =>

package/lib/prefetch/ChunkPrefetchTriggerRuntimeModule.js

@@ -8,6 +8,7 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
@@ -20,11 +21,12 @@ class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
 		const { chunkMap } = this;
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		const body = [
 			"var chunks = chunkToChildrenMap[chunkId];",
 			`Array.isArray(chunks) && chunks.map(${RuntimeGlobals.prefetchChunk});`

package/lib/prefetch/ChunkPreloadTriggerRuntimeModule.js

@@ -8,6 +8,7 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 class ChunkPreloadTriggerRuntimeModule extends RuntimeModule {
@@ -20,11 +21,12 @@ class ChunkPreloadTriggerRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
 		const { chunkMap } = this;
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		const body = [
 			"var chunks = chunkToChildrenMap[chunkId];",
 			`Array.isArray(chunks) && chunks.map(${RuntimeGlobals.preloadChunk});`

package/lib/rules/BasicEffectRulePlugin.js

@@ -8,6 +8,10 @@
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 
 class BasicEffectRulePlugin {
+	/**
+	 * @param {string} ruleProperty the rule property
+	 * @param {string=} effectType the effect type
+	 */
 	constructor(ruleProperty, effectType) {
 		this.ruleProperty = ruleProperty;
 		this.effectType = effectType || ruleProperty;

package/lib/rules/BasicMatcherRulePlugin.js

@@ -9,6 +9,11 @@
 /** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
 
 class BasicMatcherRulePlugin {
+	/**
+	 * @param {string} ruleProperty the rule property
+	 * @param {string=} dataProperty the data property
+	 * @param {boolean=} invert if true, inverts the condition
+	 */
 	constructor(ruleProperty, dataProperty, invert) {
 		this.ruleProperty = ruleProperty;
 		this.dataProperty = dataProperty || ruleProperty;

package/lib/rules/RuleSetCompiler.js

@@ -150,9 +150,9 @@ class RuleSetCompiler {
 	 * @returns {CompiledRule[]} rules
 	 */
 	compileRules(path, rules, refs) {
-		return rules.map((rule, i) =>
-			this.compileRule(`${path}[${i}]`, rule, refs)
-		);
+		return rules
+			.filter(Boolean)
+			.map((rule, i) => this.compileRule(`${path}[${i}]`, rule, refs));
 	}
 
 	/**

package/lib/rules/UseEffectRulePlugin.js

@@ -106,9 +106,11 @@ class UseEffectRulePlugin {
 					 */
 					const useToEffectsWithoutIdent = (path, items) => {
 						if (Array.isArray(items)) {
-							return items.map((item, idx) =>
-								useToEffectRaw(`${path}[${idx}]`, "[[missing ident]]", item)
-							);
+							return items
+								.filter(Boolean)
+								.map((item, idx) =>
+									useToEffectRaw(`${path}[${idx}]`, "[[missing ident]]", item)
+								);
 						}
 						return [useToEffectRaw(path, "[[missing ident]]", items)];
 					};
@@ -120,7 +122,7 @@ class UseEffectRulePlugin {
 					 */
 					const useToEffects = (path, items) => {
 						if (Array.isArray(items)) {
-							return items.map((item, idx) => {
+							return items.filter(Boolean).map((item, idx) => {
 								const subPath = `${path}[${idx}]`;
 								return useToEffect(subPath, subPath, item);
 							});

package/lib/runtime/AsyncModuleRuntimeModule.js

@@ -8,23 +8,26 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
+/** @typedef {import("../Compilation")} Compilation */
+
 class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 	constructor() {
 		super("async module");
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.asyncModule;
 		return Template.asString([
 			'var webpackQueues = typeof Symbol === "function" ? Symbol("webpack queues") : "__webpack_queues__";',
-			'var webpackExports = typeof Symbol === "function" ? Symbol("webpack exports") : "__webpack_exports__";',
+			`var webpackExports = typeof Symbol === "function" ? Symbol("webpack exports") : "${RuntimeGlobals.exports}";`,
 			'var webpackError = typeof Symbol === "function" ? Symbol("webpack error") : "__webpack_error__";',
 			`var resolveQueue = ${runtimeTemplate.basicFunction("queue", [
-				"if(queue && !queue.d) {",
+				"if(queue && queue.d < 1) {",
 				Template.indent([
 					"queue.d = 1;",
 					`queue.forEach(${runtimeTemplate.expressionFunction(
@@ -73,7 +76,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 			)};`,
 			`${fn} = ${runtimeTemplate.basicFunction("module, body, hasAwait", [
 				"var queue;",
-				"hasAwait && ((queue = []).d = 1);",
+				"hasAwait && ((queue = []).d = -1);",
 				"var depQueues = new Set();",
 				"var exports = module.exports;",
 				"var currentDeps;",
@@ -121,7 +124,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 					"(err ? reject(promise[webpackError] = err) : outerResolve(exports)), resolveQueue(queue)",
 					"err"
 				)});`,
-				"queue && (queue.d = 0);"
+				"queue && queue.d < 0 && (queue.d = 0);"
 			])};`
 		]);
 	}

package/lib/runtime/AutoPublicPathRuntimeModule.js

@@ -10,16 +10,18 @@ const Template = require("../Template");
 const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
 const { getUndoPath } = require("../util/identifier");
 
+/** @typedef {import("../Compilation")} Compilation */
+
 class AutoPublicPathRuntimeModule extends RuntimeModule {
 	constructor() {
 		super("publicPath", RuntimeModule.STAGE_BASIC);
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { compilation } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { scriptType, importMetaName, path } = compilation.outputOptions;
 		const chunkName = compilation.getPath(
 			JavascriptModulesPlugin.getChunkFilenameTemplate(
@@ -31,7 +33,11 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 				contentHashType: "javascript"
 			}
 		);
-		const undoPath = getUndoPath(chunkName, path, false);
+		const undoPath = getUndoPath(
+			chunkName,
+			/** @type {string} */ (path),
+			false
+		);
 
 		return Template.asString([
 			"var scriptUrl;",
@@ -43,11 +49,16 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 						"if (!scriptUrl && document) {",
 						Template.indent([
 							`if (document.currentScript)`,
-							Template.indent(`scriptUrl = document.currentScript.src`),
+							Template.indent(`scriptUrl = document.currentScript.src;`),
 							"if (!scriptUrl) {",
 							Template.indent([
 								'var scripts = document.getElementsByTagName("script");',
-								"if(scripts.length) scriptUrl = scripts[scripts.length - 1].src"
+								"if(scripts.length) {",
+								Template.indent([
+									"var i = scripts.length - 1;",
+									"while (i > -1 && !scriptUrl) scriptUrl = scripts[i--].src;"
+								]),
+								"}"
 							]),
 							"}"
 						]),

package/lib/runtime/BaseUriRuntimeModule.js

@@ -8,18 +8,22 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
+/** @typedef {import("../../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescriptionNormalized */
+/** @typedef {import("../Chunk")} Chunk */
+
 class BaseUriRuntimeModule extends RuntimeModule {
 	constructor() {
 		super("base uri", RuntimeModule.STAGE_ATTACH);
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { chunk } = this;
-
-		const options = chunk.getEntryOptions();
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const options =
+			/** @type {EntryDescriptionNormalized} */
+			(chunk.getEntryOptions());
 		return `${RuntimeGlobals.baseURI} = ${
 			options.baseUri === undefined
 				? "undefined"

package/lib/runtime/ChunkNameRuntimeModule.js

@@ -17,7 +17,7 @@ class ChunkNameRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
 		return `${RuntimeGlobals.chunkName} = ${JSON.stringify(this.chunkName)};`;

package/lib/runtime/CompatGetDefaultExportRuntimeModule.js

@@ -8,16 +8,19 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
+/** @typedef {import("../Compilation")} Compilation */
+
 class CompatGetDefaultExportRuntimeModule extends HelperRuntimeModule {
 	constructor() {
 		super("compat get default export");
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.compatGetDefaultExport;
 		return Template.asString([
 			"// getDefaultExport function for compatibility with non-harmony modules",

package/lib/runtime/CompatRuntimeModule.js

@@ -7,6 +7,9 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../MainTemplate")} MainTemplate */
 
 class CompatRuntimeModule extends RuntimeModule {
@@ -16,10 +19,12 @@ class CompatRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { chunkGraph, chunk, compilation } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
 		const {
 			runtimeTemplate,
 			mainTemplate,

package/lib/runtime/CreateFakeNamespaceObjectRuntimeModule.js

@@ -8,16 +8,19 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
+/** @typedef {import("../Compilation")} Compilation */
+
 class CreateFakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 	constructor() {
 		super("create fake namespace object");
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.createFakeNamespaceObject;
 		return Template.asString([
 			`var getProto = Object.getPrototypeOf ? ${runtimeTemplate.returningFunction(