webpack 5.59.0 → 5.94.0

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -10,18 +10,17 @@ const Template = require("../Template");
 const { first } = require("../util/SetHelpers");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("../Compilation").PathData} PathData */
-
-/** @typedef {function(PathData, AssetInfo=): string} FilenameFunction */
+/** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
 
 class GetChunkFilenameRuntimeModule extends RuntimeModule {
 	/**
 	 * @param {string} contentType the contentType to use the content hash for
 	 * @param {string} name kind of filename
 	 * @param {string} global function name to be assigned
-	 * @param {function(Chunk): string | FilenameFunction} getFilenameForChunk functor to get the filename or function
+	 * @param {function(Chunk): TemplatePath} getFilenameForChunk functor to get the filename or function
 	 * @param {boolean} allChunks when false, only async chunks are included
 	 */
 	constructor(contentType, name, global, getFilenameForChunk, allChunks) {
@@ -34,24 +33,19 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const {
-			global,
-			chunk,
-			chunkGraph,
-			contentType,
-			getFilenameForChunk,
-			allChunks,
-			compilation
-		} = this;
+		const { global, contentType, getFilenameForChunk, allChunks } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
 		const { runtimeTemplate } = compilation;
 
-		/** @type {Map<string | FilenameFunction, Set<Chunk>>} */
+		/** @type {Map<string | TemplatePath, Set<Chunk>>} */
 		const chunkFilenames = new Map();
 		let maxChunks = 0;
-		/** @type {string} */
+		/** @type {string | undefined} */
 		let dynamicFilename;
 
 		/**
@@ -69,9 +63,19 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 				if (typeof chunkFilename === "string") {
 					if (set.size < maxChunks) return;
 					if (set.size === maxChunks) {
-						if (chunkFilename.length < dynamicFilename.length) return;
-						if (chunkFilename.length === dynamicFilename.length) {
-							if (chunkFilename < dynamicFilename) return;
+						if (
+							chunkFilename.length <
+							/** @type {string} */ (dynamicFilename).length
+						) {
+							return;
+						}
+
+						if (
+							chunkFilename.length ===
+								/** @type {string} */ (dynamicFilename).length &&
+							chunkFilename < /** @type {string} */ (dynamicFilename)
+						) {
+							return;
 						}
 					}
 					maxChunks = set.size;
@@ -108,14 +112,14 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 			addChunk(entrypoint.chunks[entrypoint.chunks.length - 1]);
 		}
 
-		/** @type {Map<string, Set<string | number>>} */
+		/** @type {Map<string, Set<string | number | null>>} */
 		const staticUrls = new Map();
 		/** @type {Set<Chunk>} */
 		const dynamicUrlChunks = new Set();
 
 		/**
 		 * @param {Chunk} c the chunk
-		 * @param {string | FilenameFunction} chunkFilename the filename template for the chunk
+		 * @param {string | TemplatePath} chunkFilename the filename template for the chunk
 		 * @returns {void}
 		 */
 		const addStaticUrl = (c, chunkFilename) => {
@@ -130,8 +134,12 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 					return '" + chunkId + "';
 				}
 				const s = JSON.stringify(str);
-				return s.slice(1, s.length - 1);
+				return s.slice(1, -1);
 			};
+			/**
+			 * @param {string} value string
+			 * @returns {function(number): string} string to put in quotes with length
+			 */
 			const unquotedStringifyWithLength = value => length =>
 				unquotedStringify(`${value}`.slice(0, length));
 			const chunkFilenameValue =
@@ -141,17 +149,21 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 								chunk: c,
 								contentHashType: contentType
 							})
-					  )
+						)
 					: JSON.stringify(chunkFilename);
 			const staticChunkFilename = compilation.getPath(chunkFilenameValue, {
 				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
 				hashWithLength: length =>
 					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
 				chunk: {
-					id: unquotedStringify(c.id),
-					hash: unquotedStringify(c.renderedHash),
-					hashWithLength: unquotedStringifyWithLength(c.renderedHash),
-					name: unquotedStringify(c.name || c.id),
+					id: unquotedStringify(/** @type {number | string} */ (c.id)),
+					hash: unquotedStringify(/** @type {string} */ (c.renderedHash)),
+					hashWithLength: unquotedStringifyWithLength(
+						/** @type {string} */ (c.renderedHash)
+					),
+					name: unquotedStringify(
+						c.name || /** @type {number | string} */ (c.id)
+					),
 					contentHash: {
 						[contentType]: unquotedStringify(c.contentHash[contentType])
 					},
@@ -183,8 +195,10 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		 * @returns {string} code with static mapping of results of fn
 		 */
 		const createMap = fn => {
+			/** @type {Record<number | string, number | string>} */
 			const obj = {};
 			let useId = false;
+			/** @type {number | string | undefined} */
 			let lastKey;
 			let entries = 0;
 			for (const c of dynamicUrlChunks) {
@@ -192,8 +206,8 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 				if (value === c.id) {
 					useId = true;
 				} else {
-					obj[c.id] = value;
-					lastKey = c.id;
+					obj[/** @type {number | string} */ (c.id)] = value;
+					lastKey = /** @type {number | string} */ (c.id);
 					entries++;
 				}
 			}
@@ -201,9 +215,9 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 			if (entries === 1) {
 				return useId
 					? `(chunkId === ${JSON.stringify(lastKey)} ? ${JSON.stringify(
-							obj[lastKey]
-					  )} : chunkId)`
-					: JSON.stringify(obj[lastKey]);
+							obj[/** @type {number | string} */ (lastKey)]
+						)} : chunkId)`
+					: JSON.stringify(obj[/** @type {number | string} */ (lastKey)]);
 			}
 			return useId
 				? `(${JSON.stringify(obj)}[chunkId] || chunkId)`
@@ -214,17 +228,14 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		 * @param {function(Chunk): string | number} fn function from chunk to value
 		 * @returns {string} code with static mapping of results of fn for including in quoted string
 		 */
-		const mapExpr = fn => {
-			return `" + ${createMap(fn)} + "`;
-		};
+		const mapExpr = fn => `" + ${createMap(fn)} + "`;
 
 		/**
 		 * @param {function(Chunk): string | number} fn function from chunk to value
 		 * @returns {function(number): string} function which generates code with static mapping of results of fn for including in quoted string for specific length
 		 */
-		const mapExprWithLength = fn => length => {
-			return `" + ${createMap(c => `${fn(c)}`.slice(0, length))} + "`;
-		};
+		const mapExprWithLength = fn => length =>
+			`" + ${createMap(c => `${fn(c)}`.slice(0, length))} + "`;
 
 		const url =
 			dynamicFilename &&
@@ -234,9 +245,11 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
 				chunk: {
 					id: `" + chunkId + "`,
-					hash: mapExpr(c => c.renderedHash),
-					hashWithLength: mapExprWithLength(c => c.renderedHash),
-					name: mapExpr(c => c.name || c.id),
+					hash: mapExpr(c => /** @type {string} */ (c.renderedHash)),
+					hashWithLength: mapExprWithLength(
+						c => /** @type {string} */ (c.renderedHash)
+					),
+					name: mapExpr(c => c.name || /** @type {number | string} */ (c.id)),
 					contentHash: {
 						[contentType]: mapExpr(c => c.contentHash[contentType])
 					},
@@ -266,13 +279,13 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 											: `{${Array.from(
 													ids,
 													id => `${JSON.stringify(id)}:1`
-											  ).join(",")}}[chunkId]`;
+												).join(",")}}[chunkId]`;
 									return `if (${condition}) return ${url};`;
 								})
 							),
 							"// return url for filenames based on template",
 							`return ${url};`
-					  ]
+						]
 					: ["// return url for filenames based on template", `return ${url};`]
 			)};`
 		]);

package/lib/runtime/GetFullHashRuntimeModule.js

@@ -16,12 +16,13 @@ class GetFullHashRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		return `${RuntimeGlobals.getFullHash} = ${runtimeTemplate.returningFunction(
-			JSON.stringify(this.compilation.hash || "XXXX")
+			JSON.stringify(compilation.hash || "XXXX")
 		)}`;
 	}
 }

package/lib/runtime/GetMainFilenameRuntimeModule.js

@@ -8,6 +8,7 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compilation")} Compilation */
 
 class GetMainFilenameRuntimeModule extends RuntimeModule {
@@ -23,10 +24,12 @@ class GetMainFilenameRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { global, filename, compilation, chunk } = this;
+		const { global, filename } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunk = /** @type {Chunk} */ (this.chunk);
 		const { runtimeTemplate } = compilation;
 		const url = compilation.getPath(JSON.stringify(filename), {
 			hash: `" + ${RuntimeGlobals.getFullHash}() + "`,

package/lib/runtime/GetTrustedTypesPolicyRuntimeModule.js

@@ -0,0 +1,98 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
+
+class GetTrustedTypesPolicyRuntimeModule extends HelperRuntimeModule {
+	/**
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
+	 */
+	constructor(runtimeRequirements) {
+		super("trusted types policy");
+		this.runtimeRequirements = runtimeRequirements;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate, outputOptions } = compilation;
+		const { trustedTypes } = outputOptions;
+		const fn = RuntimeGlobals.getTrustedTypesPolicy;
+		const wrapPolicyCreationInTryCatch = trustedTypes
+			? trustedTypes.onPolicyCreationFailure === "continue"
+			: false;
+
+		return Template.asString([
+			"var policy;",
+			`${fn} = ${runtimeTemplate.basicFunction("", [
+				"// Create Trusted Type policy if Trusted Types are available and the policy doesn't exist yet.",
+				"if (policy === undefined) {",
+				Template.indent([
+					"policy = {",
+					Template.indent(
+						[
+							...(this.runtimeRequirements.has(RuntimeGlobals.createScript)
+								? [
+										`createScript: ${runtimeTemplate.returningFunction(
+											"script",
+											"script"
+										)}`
+									]
+								: []),
+							...(this.runtimeRequirements.has(RuntimeGlobals.createScriptUrl)
+								? [
+										`createScriptURL: ${runtimeTemplate.returningFunction(
+											"url",
+											"url"
+										)}`
+									]
+								: [])
+						].join(",\n")
+					),
+					"};",
+					...(trustedTypes
+						? [
+								'if (typeof trustedTypes !== "undefined" && trustedTypes.createPolicy) {',
+								Template.indent([
+									...(wrapPolicyCreationInTryCatch ? ["try {"] : []),
+									...[
+										`policy = trustedTypes.createPolicy(${JSON.stringify(
+											trustedTypes.policyName
+										)}, policy);`
+									].map(line =>
+										wrapPolicyCreationInTryCatch ? Template.indent(line) : line
+									),
+									...(wrapPolicyCreationInTryCatch
+										? [
+												"} catch (e) {",
+												Template.indent([
+													`console.warn('Could not create trusted-types policy ${JSON.stringify(
+														trustedTypes.policyName
+													)}');`
+												]),
+												"}"
+											]
+										: [])
+								]),
+								"}"
+							]
+						: [])
+				]),
+				"}",
+				"return policy;"
+			])};`
+		]);
+	}
+}
+
+module.exports = GetTrustedTypesPolicyRuntimeModule;

package/lib/runtime/GlobalRuntimeModule.js

@@ -14,7 +14,7 @@ class GlobalRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
 		return Template.asString([

package/lib/runtime/HasOwnPropertyRuntimeModule.js

@@ -9,16 +9,19 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
+/** @typedef {import("../Compilation")} Compilation */
+
 class HasOwnPropertyRuntimeModule extends RuntimeModule {
 	constructor() {
 		super("hasOwnProperty shorthand");
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 
 		return Template.asString([
 			`${RuntimeGlobals.hasOwnProperty} = ${runtimeTemplate.returningFunction(

package/lib/runtime/LoadScriptRuntimeModule.js

@@ -14,7 +14,7 @@ const HelperRuntimeModule = require("./HelperRuntimeModule");
 /** @typedef {import("../Compiler")} Compiler */
 
 /**
- * @typedef {Object} LoadScriptCompilationHooks
+ * @typedef {object} LoadScriptCompilationHooks
  * @property {SyncWaterfallHook<[string, Chunk]>} createScript
  */
 
@@ -44,17 +44,19 @@ class LoadScriptRuntimeModule extends HelperRuntimeModule {
 
 	/**
 	 * @param {boolean=} withCreateScriptUrl use create script url for trusted types
+	 * @param {boolean=} withFetchPriority use `fetchPriority` attribute
 	 */
-	constructor(withCreateScriptUrl) {
+	constructor(withCreateScriptUrl, withFetchPriority) {
 		super("load script");
 		this._withCreateScriptUrl = withCreateScriptUrl;
+		this._withFetchPriority = withFetchPriority;
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { compilation } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate, outputOptions } = compilation;
 		const {
 			scriptType,
@@ -72,7 +74,7 @@ class LoadScriptRuntimeModule extends HelperRuntimeModule {
 			"script = document.createElement('script');",
 			scriptType ? `script.type = ${JSON.stringify(scriptType)};` : "",
 			charset ? "script.charset = 'utf-8';" : "",
-			`script.timeout = ${loadTimeout / 1000};`,
+			`script.timeout = ${/** @type {number} */ (loadTimeout) / 1000};`,
 			`if (${RuntimeGlobals.scriptNonce}) {`,
 			Template.indent(
 				`script.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`
@@ -81,55 +83,69 @@ class LoadScriptRuntimeModule extends HelperRuntimeModule {
 			uniqueName
 				? 'script.setAttribute("data-webpack", dataWebpackPrefix + key);'
 				: "",
+			this._withFetchPriority
+				? Template.asString([
+						"if(fetchPriority) {",
+						Template.indent(
+							'script.setAttribute("fetchpriority", fetchPriority);'
+						),
+						"}"
+					])
+				: "",
 			`script.src = ${
 				this._withCreateScriptUrl
 					? `${RuntimeGlobals.createScriptUrl}(url)`
 					: "url"
 			};`,
 			crossOriginLoading
-				? Template.asString([
-						"if (script.src.indexOf(window.location.origin + '/') !== 0) {",
-						Template.indent(
-							`script.crossOrigin = ${JSON.stringify(crossOriginLoading)};`
-						),
-						"}"
-				  ])
+				? crossOriginLoading === "use-credentials"
+					? 'script.crossOrigin = "use-credentials";'
+					: Template.asString([
+							"if (script.src.indexOf(window.location.origin + '/') !== 0) {",
+							Template.indent(
+								`script.crossOrigin = ${JSON.stringify(crossOriginLoading)};`
+							),
+							"}"
+						])
 				: ""
 		]);
 
 		return Template.asString([
 			"var inProgress = {};",
 			uniqueName
-				? `var dataWebpackPrefix = ${JSON.stringify(uniqueName + ":")};`
+				? `var dataWebpackPrefix = ${JSON.stringify(`${uniqueName}:`)};`
 				: "// data-webpack is not used as build has no uniqueName",
 			"// loadScript function to load a script via script tag",
-			`${fn} = ${runtimeTemplate.basicFunction("url, done, key, chunkId", [
-				"if(inProgress[url]) { inProgress[url].push(done); return; }",
-				"var script, needAttach;",
-				"if(key !== undefined) {",
-				Template.indent([
-					'var scripts = document.getElementsByTagName("script");',
-					"for(var i = 0; i < scripts.length; i++) {",
+			`${fn} = ${runtimeTemplate.basicFunction(
+				`url, done, key, chunkId${
+					this._withFetchPriority ? ", fetchPriority" : ""
+				}`,
+				[
+					"if(inProgress[url]) { inProgress[url].push(done); return; }",
+					"var script, needAttach;",
+					"if(key !== undefined) {",
+					Template.indent([
+						'var scripts = document.getElementsByTagName("script");',
+						"for(var i = 0; i < scripts.length; i++) {",
+						Template.indent([
+							"var s = scripts[i];",
+							`if(s.getAttribute("src") == url${
+								uniqueName
+									? ' || s.getAttribute("data-webpack") == dataWebpackPrefix + key'
+									: ""
+							}) { script = s; break; }`
+						]),
+						"}"
+					]),
+					"}",
+					"if(!script) {",
 					Template.indent([
-						"var s = scripts[i];",
-						`if(s.getAttribute("src") == url${
-							uniqueName
-								? ' || s.getAttribute("data-webpack") == dataWebpackPrefix + key'
-								: ""
-						}) { script = s; break; }`
+						"needAttach = true;",
+						createScript.call(code, /** @type {Chunk} */ (this.chunk))
 					]),
-					"}"
-				]),
-				"}",
-				"if(!script) {",
-				Template.indent([
-					"needAttach = true;",
-					createScript.call(code, this.chunk)
-				]),
-				"}",
-				"inProgress[url] = [done];",
-				"var onScriptComplete = " +
-					runtimeTemplate.basicFunction(
+					"}",
+					"inProgress[url] = [done];",
+					`var onScriptComplete = ${runtimeTemplate.basicFunction(
 						"prev, event",
 						Template.asString([
 							"// avoid mem leaks in IE.",
@@ -144,13 +160,13 @@ class LoadScriptRuntimeModule extends HelperRuntimeModule {
 							)});`,
 							"if(prev) return prev(event);"
 						])
-					),
-				";",
-				`var timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), ${loadTimeout});`,
-				"script.onerror = onScriptComplete.bind(null, script.onerror);",
-				"script.onload = onScriptComplete.bind(null, script.onload);",
-				"needAttach && document.head.appendChild(script);"
-			])};`
+					)}`,
+					`var timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), ${loadTimeout});`,
+					"script.onerror = onScriptComplete.bind(null, script.onerror);",
+					"script.onload = onScriptComplete.bind(null, script.onload);",
+					"needAttach && document.head.appendChild(script);"
+				]
+			)};`
 		]);
 	}
 }

package/lib/runtime/MakeNamespaceObjectRuntimeModule.js

@@ -8,16 +8,19 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
+/** @typedef {import("../Compilation")} Compilation */
+
 class MakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 	constructor() {
 		super("make 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.makeNamespaceObject;
 		return Template.asString([
 			"// define __esModule on exports",

package/lib/runtime/NonceRuntimeModule.js

@@ -0,0 +1,24 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+
+class NonceRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("nonce", RuntimeModule.STAGE_ATTACH);
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		return `${RuntimeGlobals.scriptNonce} = undefined;`;
+	}
+}
+
+module.exports = NonceRuntimeModule;

package/lib/runtime/OnChunksLoadedRuntimeModule.js

@@ -8,16 +8,18 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
+/** @typedef {import("../Compilation")} Compilation */
+
 class OnChunksLoadedRuntimeModule extends RuntimeModule {
 	constructor() {
 		super("chunk loaded");
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { compilation } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate } = compilation;
 		return Template.asString([
 			"var deferred = [];",

package/lib/runtime/PublicPathRuntimeModule.js

@@ -7,17 +7,24 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
+/** @typedef {import("../Compilation")} Compilation */
+
 class PublicPathRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {OutputOptions["publicPath"]} publicPath public path
+	 */
 	constructor(publicPath) {
 		super("publicPath", RuntimeModule.STAGE_BASIC);
 		this.publicPath = publicPath;
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { compilation, publicPath } = this;
+		const { publicPath } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
 
 		return `${RuntimeGlobals.publicPath} = ${JSON.stringify(
 			compilation.getPath(publicPath || "", {

package/lib/runtime/RelativeUrlRuntimeModule.js

@@ -8,16 +8,19 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
+/** @typedef {import("../Compilation")} Compilation */
+
 class RelativeUrlRuntimeModule extends HelperRuntimeModule {
 	constructor() {
 		super("relative url");
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		return Template.asString([
 			`${RuntimeGlobals.relativeUrl} = function RelativeURL(url) {`,
 			Template.indent([