webpack 5.86.0 → 5.88.0

package/lib/javascript/JavascriptParserHelpers.js

@@ -9,20 +9,26 @@ const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const ConstDependency = require("../dependencies/ConstDependency");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 
-/** @typedef {import("estree").Expression} ExpressionNode */
+/** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("estree").Node} Node */
+/** @typedef {import("estree").SourceLocation} SourceLocation */
 /** @typedef {import("./JavascriptParser")} JavascriptParser */
+/** @typedef {import("./JavascriptParser").Range} Range */
 
 /**
  * @param {JavascriptParser} parser the parser
  * @param {string} value the const value
  * @param {string[]=} runtimeRequirements runtime requirements
- * @returns {function(ExpressionNode): true} plugin function
+ * @returns {function(Expression): true} plugin function
  */
 exports.toConstantDependency = (parser, value, runtimeRequirements) => {
 	return function constDependency(expr) {
-		const dep = new ConstDependency(value, expr.range, runtimeRequirements);
-		dep.loc = expr.loc;
+		const dep = new ConstDependency(
+			value,
+			/** @type {Range} */ (expr.range),
+			runtimeRequirements
+		);
+		dep.loc = /** @type {SourceLocation} */ (expr.loc);
 		parser.state.module.addPresentationalDependency(dep);
 		return true;
 	};
@@ -30,33 +36,37 @@ exports.toConstantDependency = (parser, value, runtimeRequirements) => {
 
 /**
  * @param {string} value the string value
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
+ * @returns {function(Expression): BasicEvaluatedExpression} plugin function
  */
 exports.evaluateToString = value => {
 	return function stringExpression(expr) {
-		return new BasicEvaluatedExpression().setString(value).setRange(expr.range);
+		return new BasicEvaluatedExpression()
+			.setString(value)
+			.setRange(/** @type {Range} */ (expr.range));
 	};
 };
 
 /**
  * @param {number} value the number value
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
+ * @returns {function(Expression): BasicEvaluatedExpression} plugin function
  */
 exports.evaluateToNumber = value => {
 	return function stringExpression(expr) {
-		return new BasicEvaluatedExpression().setNumber(value).setRange(expr.range);
+		return new BasicEvaluatedExpression()
+			.setNumber(value)
+			.setRange(/** @type {Range} */ (expr.range));
 	};
 };
 
 /**
  * @param {boolean} value the boolean value
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
+ * @returns {function(Expression): BasicEvaluatedExpression} plugin function
  */
 exports.evaluateToBoolean = value => {
 	return function booleanExpression(expr) {
 		return new BasicEvaluatedExpression()
 			.setBoolean(value)
-			.setRange(expr.range);
+			.setRange(/** @type {Range} */ (expr.range));
 	};
 };
 
@@ -65,14 +75,14 @@ exports.evaluateToBoolean = value => {
  * @param {string} rootInfo rootInfo
  * @param {function(): string[]} getMembers getMembers
  * @param {boolean|null=} truthy is truthy, null if nullish
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} callback
+ * @returns {function(Expression): BasicEvaluatedExpression} callback
  */
 exports.evaluateToIdentifier = (identifier, rootInfo, getMembers, truthy) => {
 	return function identifierExpression(expr) {
 		let evaluatedExpression = new BasicEvaluatedExpression()
 			.setIdentifier(identifier, rootInfo, getMembers)
 			.setSideEffects(false)
-			.setRange(expr.range);
+			.setRange(/** @type {Range} */ (expr.range));
 		switch (truthy) {
 			case true:
 				evaluatedExpression.setTruthy();
@@ -89,14 +99,26 @@ exports.evaluateToIdentifier = (identifier, rootInfo, getMembers, truthy) => {
 	};
 };
 
+/**
+ * @param {JavascriptParser} parser the parser
+ * @param {string} message the message
+ * @returns {function(Expression): boolean | undefined} callback to handle unsupported expression
+ */
 exports.expressionIsUnsupported = (parser, message) => {
 	return function unsupportedExpression(expr) {
-		const dep = new ConstDependency("(void 0)", expr.range, null);
-		dep.loc = expr.loc;
+		const dep = new ConstDependency(
+			"(void 0)",
+			/** @type {Range} */ (expr.range),
+			null
+		);
+		dep.loc = /** @type {SourceLocation} */ (expr.loc);
 		parser.state.module.addPresentationalDependency(dep);
 		if (!parser.state.module) return;
 		parser.state.module.addWarning(
-			new UnsupportedFeatureWarning(message, expr.loc)
+			new UnsupportedFeatureWarning(
+				message,
+				/** @type {SourceLocation} */ (expr.loc)
+			)
 		);
 		return true;
 	};

package/lib/logging/runtime.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const SyncBailHook = require("tapable/lib/SyncBailHook");
+const { SyncBailHook } = require("tapable");
 const { Logger } = require("./Logger");
 const createConsoleLogger = require("./createConsoleLogger");
 

package/lib/logging/truncateArgs.js

@@ -5,6 +5,10 @@
 
 "use strict";
 
+/**
+ * @param {Array<number>} array array of numbers
+ * @returns {number} sum of all numbers in array
+ */
 const arraySum = array => {
 	let sum = 0;
 	for (const item of array) sum += item;

package/lib/node/ReadFileChunkLoadingRuntimeModule.js

@@ -16,6 +16,8 @@ const compileBooleanMatcher = require("../util/compileBooleanMatcher");
 const { getUndoPath } = require("../util/identifier");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
 
 class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 	/**
@@ -46,11 +48,13 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { chunkGraph, chunk } = this;
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.ensureChunkHandlers;
 		const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
 		const withExternalInstallChunk = this.runtimeRequirements.has(
@@ -72,8 +76,8 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
 		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
-		const outputName = this.compilation.getPath(
-			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
+		const outputName = compilation.getPath(
+			getChunkFilenameTemplate(chunk, compilation.outputOptions),
 			{
 				chunk,
 				contentHashType: "javascript"
@@ -81,7 +85,7 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 		);
 		const rootOutputDir = getUndoPath(
 			outputName,
-			/** @type {string} */ (this.compilation.outputOptions.path),
+			/** @type {string} */ (compilation.outputOptions.path),
 			false
 		);
 

package/lib/node/RequireChunkLoadingRuntimeModule.js

@@ -16,6 +16,8 @@ const compileBooleanMatcher = require("../util/compileBooleanMatcher");
 const { getUndoPath } = require("../util/identifier");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
 
 class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 	/**
@@ -46,11 +48,13 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { chunkGraph, chunk } = this;
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.ensureChunkHandlers;
 		const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
 		const withExternalInstallChunk = this.runtimeRequirements.has(
@@ -72,8 +76,8 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
 		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
-		const outputName = this.compilation.getPath(
-			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
+		const outputName = compilation.getPath(
+			getChunkFilenameTemplate(chunk, compilation.outputOptions),
 			{
 				chunk,
 				contentHashType: "javascript"
@@ -81,7 +85,7 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 		);
 		const rootOutputDir = getUndoPath(
 			outputName,
-			/** @type {string} */ (this.compilation.outputOptions.path),
+			/** @type {string} */ (compilation.outputOptions.path),
 			true
 		);
 

package/lib/optimize/InnerGraph.js

@@ -309,7 +309,7 @@ exports.isDependencyUsedByExports = (
 
 /**
  * @param {Dependency} dependency the dependency
- * @param {Set<string> | boolean} usedByExports usedByExports info
+ * @param {Set<string> | boolean | undefined} usedByExports usedByExports info
  * @param {ModuleGraph} moduleGraph moduleGraph
  * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
  */

package/lib/optimize/InnerGraphPlugin.js

@@ -16,6 +16,7 @@ const InnerGraph = require("./InnerGraph");
 /** @typedef {import("estree").ClassExpression} ClassExpressionNode */
 /** @typedef {import("estree").Node} Node */
 /** @typedef {import("estree").VariableDeclarator} VariableDeclaratorNode */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
@@ -46,7 +47,7 @@ class InnerGraphPlugin {
 
 				/**
 				 * @param {JavascriptParser} parser the parser
-				 * @param {Object} parserOptions options
+				 * @param {JavascriptParserOptions} parserOptions options
 				 * @returns {void}
 				 */
 				const handler = (parser, parserOptions) => {

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") : "${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(

package/lib/runtime/BaseUriRuntimeModule.js

@@ -9,6 +9,7 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
 /** @typedef {import("../../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescriptionNormalized */
+/** @typedef {import("../Chunk")} Chunk */
 
 class BaseUriRuntimeModule extends RuntimeModule {
 	constructor() {
@@ -16,11 +17,10 @@ class BaseUriRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { chunk } = this;
-
+		const chunk = /** @type {Chunk} */ (this.chunk);
 		const options =
 			/** @type {EntryDescriptionNormalized} */
 			(chunk.getEntryOptions());

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(