webpack 5.104.1 → 5.105.1

package/lib/optimize/RemoveParentModulesPlugin.js

@@ -33,7 +33,7 @@ const THIRTY_TWO_BIGINT = BigInt(32);
  * Parses the module mask and returns the modules represented by it
  * @param {bigint} mask the module mask
  * @param {Module[]} ordinalModules the modules in the order they were added to the mask (LSB is index 0)
- * @returns {Generator<Module>} the modules represented by the mask
+ * @returns {Generator<Module, undefined, undefined>} the modules represented by the mask
  */
 function* getModulesFromMask(mask, ordinalModules) {
 	let offset = 31;
@@ -74,10 +74,13 @@ class RemoveParentModulesPlugin {
 			 */
 			const handler = (chunks, chunkGroups) => {
 				const chunkGraph = compilation.chunkGraph;
+				/** @type {Set<ChunkGroup>} */
 				const queue = new Set();
+				/** @type {WeakMap<ChunkGroup, bigint | undefined>} */
 				const availableModulesMap = new WeakMap();
 
 				let nextModuleMask = ONE_BIGINT;
+				/** @type {WeakMap<Module, bigint>} */
 				const maskByModule = new WeakMap();
 				/** @type {Module[]} */
 				const ordinalModules = [];
@@ -99,6 +102,7 @@ class RemoveParentModulesPlugin {
 				};
 
 				// Initialize masks by chunk and by chunk group for quicker comparisons
+				/** @type {WeakMap<Chunk, bigint>} */
 				const chunkMasks = new WeakMap();
 				for (const chunk of chunks) {
 					let mask = ZERO_BIGINT;
@@ -109,6 +113,7 @@ class RemoveParentModulesPlugin {
 					chunkMasks.set(chunk, mask);
 				}
 
+				/** @type {WeakMap<ChunkGroup, bigint>} */
 				const chunkGroupMasks = new WeakMap();
 				for (const chunkGroup of chunkGroups) {
 					let mask = ZERO_BIGINT;
@@ -143,7 +148,8 @@ class RemoveParentModulesPlugin {
 						const availableModulesInParent = availableModulesMap.get(parent);
 						if (availableModulesInParent !== undefined) {
 							const parentMask =
-								availableModulesInParent | chunkGroupMasks.get(parent);
+								availableModulesInParent |
+								/** @type {bigint} */ (chunkGroupMasks.get(parent));
 							// If we know the available modules in parent: process these
 							if (availableModulesMask === undefined) {
 								// if we have not own info yet: create new entry
@@ -181,7 +187,10 @@ class RemoveParentModulesPlugin {
 					);
 					if (availableModulesSets.includes(undefined)) continue; // No info about this chunk group
 
-					const availableModulesMask = intersectMasks(availableModulesSets);
+					const availableModulesMask = intersectMasks(
+						/** @type {bigint[]} */
+						(availableModulesSets)
+					);
 					const toRemoveMask = chunkMask & availableModulesMask;
 					if (toRemoveMask !== ZERO_BIGINT) {
 						for (const module of getModulesFromMask(

package/lib/optimize/RuntimeChunkPlugin.js

@@ -16,9 +16,9 @@ class RuntimeChunkPlugin {
 	/**
 	 * @param {{ name?: RuntimeChunkFunction }=} options options
 	 */
-	constructor(options) {
+	constructor(options = {}) {
+		/** @type {{ name: string | RuntimeChunkFunction }} */
 		this.options = {
-			/** @type {RuntimeChunkFunction} */
 			name: (entrypoint) => `runtime~${entrypoint.name}`,
 			...options
 		};
@@ -38,9 +38,7 @@ class RuntimeChunkPlugin {
 					(compilation.entries.get(entryName));
 				if (data.options.runtime === undefined && !data.options.dependOn) {
 					// Determine runtime chunk name
-					let name =
-						/** @type {string | RuntimeChunkFunction} */
-						(this.options.name);
+					let name = this.options.name;
 					if (typeof name === "function") {
 						name = name({ name: entryName });
 					}

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -68,6 +68,7 @@ class SideEffectsFlagPlugin {
 	 * @param {boolean} analyseSource analyse source code for side effects
 	 */
 	constructor(analyseSource = true) {
+		/** @type {boolean} */
 		this._analyseSource = analyseSource;
 	}
 
@@ -277,6 +278,7 @@ class SideEffectsFlagPlugin {
 
 						logger.time("update dependencies");
 
+						/** @type {Set<Module>} */
 						const optimizedModules = new Set();
 
 						/**
@@ -291,6 +293,7 @@ class SideEffectsFlagPlugin {
 									module
 								)) {
 									const dep = connection.dependency;
+									/** @type {boolean} */
 									let isReexport;
 									if (
 										(isReexport =

package/lib/optimize/SplitChunksPlugin.js

@@ -22,7 +22,6 @@ const memoize = require("../util/memoize");
 const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksCacheGroup} OptimizationSplitChunksCacheGroup */
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksGetCacheGroups} OptimizationSplitChunksGetCacheGroups */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksOptions} OptimizationSplitChunksOptions */
 /** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksSizes} OptimizationSplitChunksSizes */
 /** @typedef {import("../config/defaults").OutputNormalizedWithDefaults} OutputOptions */
@@ -36,6 +35,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
 /** @typedef {import("../util/deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
 /** @typedef {import("../util/deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
+/** @typedef {import("../util/deterministicGrouping").Sizes} Sizes */
 
 /**
  * @callback ChunkFilterFn
@@ -123,6 +123,8 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {ChunkGraph} chunkGraph
  */
 
+/** @typedef {(module: Module) => OptimizationSplitChunksCacheGroup | OptimizationSplitChunksCacheGroup[] | void} RawGetCacheGroups */
+
 /**
  * @callback GetCacheGroups
  * @param {Module} module
@@ -220,9 +222,10 @@ const getRequests = (chunk) => {
  * @returns {T} result
  */
 const mapObject = (obj, fn) => {
+	/** @type {T} */
 	const newObj = Object.create(null);
 	for (const key of Object.keys(obj)) {
-		newObj[key] = fn(
+		newObj[/** @type {keyof T} */ (key)] = fn(
 			obj[/** @type {keyof T} */ (key)],
 			/** @type {keyof T} */
 			(key)
@@ -454,7 +457,7 @@ const normalizeChunksFilter = (chunks) => {
 };
 
 /**
- * @param {undefined | GetCacheGroups | Record<string, false | string | RegExp | OptimizationSplitChunksGetCacheGroups | OptimizationSplitChunksCacheGroup>} cacheGroups the cache group options
+ * @param {undefined | GetCacheGroups | Record<string, false | string | RegExp | RawGetCacheGroups | OptimizationSplitChunksCacheGroup>} cacheGroups the cache group options
  * @param {DefaultSizeTypes} defaultSizeTypes the default size types
  * @returns {GetCacheGroups} a function to get the cache groups
  */
@@ -478,6 +481,7 @@ const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
 					}
 				});
 			} else if (typeof option === "function") {
+				/** @type {WeakMap<OptimizationSplitChunksCacheGroup, CacheGroupSource>} */
 				const cache = new WeakMap();
 				handlers.push((module, context, results) => {
 					const result = option(module);
@@ -530,6 +534,8 @@ const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
 	return () => null;
 };
 
+/** @typedef {(module: Module, context: CacheGroupsContext) => boolean} CheckTestFn */
+
 /**
  * @param {OptimizationSplitChunksCacheGroup["test"]} test test option
  * @param {Module} module the module
@@ -553,6 +559,8 @@ const checkTest = (test, module, context) => {
 	return false;
 };
 
+/** @typedef {(type: string) => boolean} CheckModuleTypeFn */
+
 /**
  * @param {OptimizationSplitChunksCacheGroup["type"]} test type option
  * @param {Module} module the module
@@ -574,6 +582,8 @@ const checkModuleType = (test, module) => {
 	return false;
 };
 
+/** @typedef {(layer: string | null) => boolean} CheckModuleLayerFn */
+
 /**
  * @param {OptimizationSplitChunksCacheGroup["layer"]} test type option
  * @param {Module} module the module
@@ -868,7 +878,7 @@ module.exports = class SplitChunksPlugin {
 						index <<= ONE;
 					}
 					/**
-					 * @param {Iterable<Chunk>} chunks list of chunks
+					 * @param {Iterable<Chunk, undefined, undefined>} chunks list of chunks
 					 * @returns {bigint | Chunk} key of the chunks
 					 */
 					const getKey = (chunks) => {
@@ -921,6 +931,7 @@ module.exports = class SplitChunksPlugin {
 					 */
 					const groupChunksByExports = (module) => {
 						const exportsInfo = moduleGraph.getExportsInfo(module);
+						/** @type {Map<string, Chunk[]>} */
 						const groupedByUsedExports = new Map();
 						for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
 							const key = exportsInfo.getUsageKey(chunk.runtime);
@@ -1082,7 +1093,8 @@ module.exports = class SplitChunksPlugin {
 					 * @property {bigint | Chunk} key a key of the list
 					 */
 
-					/** @type {WeakMap<ChunkSet | Chunk, WeakMap<ChunkFilterFn, SelectedChunksResult>>} */
+					/** @typedef {WeakMap<ChunkFilterFn, SelectedChunksResult>} ChunkMap */
+					/** @type {WeakMap<ChunkSet | Chunk, ChunkMap>} */
 					const selectedChunksCacheByChunksSet = new WeakMap();
 
 					/**
@@ -1095,6 +1107,7 @@ module.exports = class SplitChunksPlugin {
 					const getSelectedChunks = (chunks, chunkFilter) => {
 						let entry = selectedChunksCacheByChunksSet.get(chunks);
 						if (entry === undefined) {
+							/** @type {ChunkMap} */
 							entry = new WeakMap();
 							selectedChunksCacheByChunksSet.set(chunks, entry);
 						}
@@ -1392,7 +1405,9 @@ module.exports = class SplitChunksPlugin {
 
 					while (chunksInfoMap.size > 0) {
 						// Find best matching entry
+						/** @type {undefined | string} */
 						let bestEntryKey;
+						/** @type {undefined | ChunksInfoItem} */
 						let bestEntry;
 						for (const pair of chunksInfoMap) {
 							const key = pair[0];
@@ -1471,6 +1486,7 @@ module.exports = class SplitChunksPlugin {
 							item.cacheGroup._conditionalEnforce &&
 							checkMinSize(item.sizes, item.cacheGroup.enforceSizeThreshold);
 
+						/** @type {Set<Chunk>} */
 						const usedChunks = new Set(item.chunks);
 
 						// Check if maxRequests condition can be fulfilled
@@ -1533,6 +1549,7 @@ module.exports = class SplitChunksPlugin {
 							usedChunks.size === 1
 						) {
 							const [chunk] = usedChunks;
+							/** @type {SplitChunksSizes} */
 							const chunkSizes = Object.create(null);
 							for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
 								if (!item.modules.has(module)) {
@@ -1763,6 +1780,7 @@ module.exports = class SplitChunksPlugin {
 								return key;
 							},
 							getSize(module) {
+								/** @type {Sizes} */
 								const size = Object.create(null);
 								for (const key of module.getSourceTypes()) {
 									size[key] = module.size(key);

package/lib/performance/AssetsOverSizeLimitWarning.js

@@ -10,7 +10,7 @@ const WebpackError = require("../WebpackError");
 
 /** @typedef {import("./SizeLimitsPlugin").AssetDetails} AssetDetails */
 
-module.exports = class AssetsOverSizeLimitWarning extends WebpackError {
+class AssetsOverSizeLimitWarning extends WebpackError {
 	/**
 	 * @param {AssetDetails[]} assetsOverSizeLimit the assets
 	 * @param {number} assetLimit the size limit
@@ -26,7 +26,11 @@ module.exports = class AssetsOverSizeLimitWarning extends WebpackError {
 This can impact web performance.
 Assets: ${assetLists}`);
 
+		/** @type {string} */
 		this.name = "AssetsOverSizeLimitWarning";
 		this.assets = assetsOverSizeLimit;
 	}
-};
+}
+
+/** @type {typeof AssetsOverSizeLimitWarning} */
+module.exports = AssetsOverSizeLimitWarning;

package/lib/performance/EntrypointsOverSizeLimitWarning.js

@@ -10,7 +10,7 @@ const WebpackError = require("../WebpackError");
 
 /** @typedef {import("./SizeLimitsPlugin").EntrypointDetails} EntrypointDetails */
 
-module.exports = class EntrypointsOverSizeLimitWarning extends WebpackError {
+class EntrypointsOverSizeLimitWarning extends WebpackError {
 	/**
 	 * @param {EntrypointDetails[]} entrypoints the entrypoints
 	 * @param {number} entrypointLimit the size limit
@@ -29,7 +29,11 @@ module.exports = class EntrypointsOverSizeLimitWarning extends WebpackError {
 		)}). This can impact web performance.
 Entrypoints:${entrypointList}\n`);
 
+		/** @type {string} */
 		this.name = "EntrypointsOverSizeLimitWarning";
 		this.entrypoints = entrypoints;
 	}
-};
+}
+
+/** @type {typeof EntrypointsOverSizeLimitWarning} */
+module.exports = EntrypointsOverSizeLimitWarning;

package/lib/performance/NoAsyncChunksWarning.js

@@ -15,6 +15,7 @@ module.exports = class NoAsyncChunksWarning extends WebpackError {
 				"For more info visit https://webpack.js.org/guides/code-splitting/"
 		);
 
+		/** @type {string} */
 		this.name = "NoAsyncChunksWarning";
 	}
 };

package/lib/performance/SizeLimitsPlugin.js

@@ -34,12 +34,9 @@ const NoAsyncChunksWarning = require("./NoAsyncChunksWarning");
 /** @type {WeakSet<Entrypoint | ChunkGroup | Source>} */
 const isOverSizeLimitSet = new WeakSet();
 
-/**
- * @param {Asset["name"]} name the name
- * @param {Asset["source"]} source the source
- * @param {Asset["info"]} info the info
- * @returns {boolean} result
- */
+/** @typedef {(name: Asset["name"], source: Asset["source"], assetInfo: Asset["info"]) => boolean} AssetFilter */
+
+/** @type {AssetFilter} */
 const excludeSourceMap = (name, source, info) => !info.development;
 
 const PLUGIN_NAME = "SizeLimitsPlugin";
@@ -50,8 +47,11 @@ module.exports = class SizeLimitsPlugin {
 	 */
 	constructor(options) {
 		this.hints = options.hints;
+		/** @type {number | undefined} */
 		this.maxAssetSize = options.maxAssetSize;
+		/** @type {number | undefined} */
 		this.maxEntrypointSize = options.maxEntrypointSize;
+		/** @type {AssetFilter | undefined} */
 		this.assetFilter = options.assetFilter;
 	}
 

package/lib/prefetch/ChunkPrefetchFunctionRuntimeModule.js

@@ -17,7 +17,9 @@ class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
 	 */
 	constructor(type, runtimeFunction, runtimeHandlers) {
 		super(`chunk ${type} function`);
+		/** @type {string} */
 		this.runtimeFunction = runtimeFunction;
+		/** @type {string} */
 		this.runtimeHandlers = runtimeHandlers;
 	}
 

package/lib/prefetch/ChunkPrefetchStartupRuntimeModule.js

@@ -9,14 +9,16 @@ const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Chunk").ChunkChildOfTypeInOrder} ChunkChildOfTypeInOrder */
 /** @typedef {import("../Compilation")} Compilation */
 
 class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {{ onChunks: Chunk[], chunks: Set<Chunk> }[]} startupChunks chunk ids to trigger when chunks are loaded
+	 * @param {ChunkChildOfTypeInOrder[]} startupChunks chunk ids to trigger when chunks are loaded
 	 */
 	constructor(startupChunks) {
 		super("startup prefetch", RuntimeModule.STAGE_TRIGGER);
+		/** @type {ChunkChildOfTypeInOrder[]} */
 		this.startupChunks = startupChunks;
 	}
 

package/lib/prefetch/ChunkPrefetchTriggerRuntimeModule.js

@@ -17,6 +17,7 @@ class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
 	 */
 	constructor(chunkMap) {
 		super("chunk prefetch trigger", RuntimeModule.STAGE_TRIGGER);
+		/** @type {ChunkChildIdsByOrdersMap} */
 		this.chunkMap = chunkMap;
 	}
 

package/lib/prefetch/ChunkPreloadTriggerRuntimeModule.js

@@ -17,6 +17,7 @@ class ChunkPreloadTriggerRuntimeModule extends RuntimeModule {
 	 */
 	constructor(chunkMap) {
 		super("chunk preload trigger", RuntimeModule.STAGE_TRIGGER);
+		/** @type {ChunkChildIdsByOrdersMap} */
 		this.chunkMap = chunkMap;
 	}
 

package/lib/rules/BasicEffectRulePlugin.js

@@ -24,7 +24,9 @@ class BasicEffectRulePlugin {
 	 * @param {string=} effectType the effect type
 	 */
 	constructor(ruleProperty, effectType) {
+		/** @type {BasicEffectRuleKeys} */
 		this.ruleProperty = ruleProperty;
+		/** @type {string | BasicEffectRuleKeys} */
 		this.effectType = effectType || ruleProperty;
 	}
 

package/lib/rules/BasicMatcherRulePlugin.js

@@ -27,8 +27,11 @@ class BasicMatcherRulePlugin {
 	 * @param {boolean=} invert if true, inverts the condition
 	 */
 	constructor(ruleProperty, dataProperty, invert) {
+		/** @type {BasicMatcherRuleKeys} */
 		this.ruleProperty = ruleProperty;
+		/** @type {string | BasicMatcherRuleKeys} */
 		this.dataProperty = dataProperty || ruleProperty;
+		/** @type {boolean} */
 		this.invert = invert || false;
 	}
 

package/lib/rules/ObjectMatcherRulePlugin.js

@@ -18,18 +18,22 @@
  */
 
 /** @typedef {KeysOfTypes<RuleSetRule, { [k: string]: RuleSetConditionOrConditions }>} ObjectMatcherRuleKeys */
+/** @typedef {keyof EffectData} DataProperty */
 
 const PLUGIN_NAME = "ObjectMatcherRulePlugin";
 
 class ObjectMatcherRulePlugin {
 	/**
 	 * @param {ObjectMatcherRuleKeys} ruleProperty the rule property
-	 * @param {keyof EffectData=} dataProperty the data property
+	 * @param {DataProperty=} dataProperty the data property
 	 * @param {RuleConditionFunction=} additionalConditionFunction need to check
 	 */
 	constructor(ruleProperty, dataProperty, additionalConditionFunction) {
+		/** @type {ObjectMatcherRuleKeys} */
 		this.ruleProperty = ruleProperty;
+		/** @type {DataProperty | ObjectMatcherRuleKeys} */
 		this.dataProperty = dataProperty || ruleProperty;
+		/** @type {RuleConditionFunction | undefined} */
 		this.additionalConditionFunction = additionalConditionFunction;
 	}
 

package/lib/rules/RuleSetCompiler.js

@@ -9,6 +9,7 @@ const { SyncHook } = require("tapable");
 
 /** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
 /** @typedef {import("../../declarations/WebpackOptions").Falsy} Falsy */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetLoaderOptions} RuleSetLoaderOptions */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 
@@ -87,6 +88,9 @@ const { SyncHook } = require("tapable");
 
 /** @typedef {Set<string>} UnhandledProperties */
 
+/** @typedef {(data: EffectData) => (RuleSetUseItem | (Falsy | RuleSetUseItem)[])} RuleSetUseFn */
+/** @typedef {(value: string) => boolean} RuleSetConditionFn */
+
 /** @typedef {{ apply: (ruleSetCompiler: RuleSetCompiler) => void }} RuleSetPlugin */
 
 class RuleSetCompiler {
@@ -116,6 +120,7 @@ class RuleSetCompiler {
 	 * @returns {RuleSet} compiled RuleSet
 	 */
 	compile(ruleSet) {
+		/** @type {References} */
 		const refs = new Map();
 		const rules = this.compileRules("ruleSet", ruleSet, refs);
 
@@ -327,6 +332,7 @@ class RuleSetCompiler {
 			);
 		}
 
+		/** @type {Condition[]} */
 		const conditions = [];
 		for (const key of Object.keys(condition)) {
 			const value = condition[key];

package/lib/runtime/AsyncModuleRuntimeModule.js

@@ -16,6 +16,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 	 */
 	constructor(deferInterop = false) {
 		super("async module");
+		/** @type {boolean} */
 		this._deferInterop = deferInterop;
 	}
 

package/lib/runtime/ChunkNameRuntimeModule.js

@@ -13,6 +13,7 @@ class ChunkNameRuntimeModule extends RuntimeModule {
 	 */
 	constructor(chunkName) {
 		super("chunkName");
+		/** @type {string} */
 		this.chunkName = chunkName;
 	}
 

package/lib/runtime/CompatRuntimeModule.js

@@ -14,6 +14,7 @@ const RuntimeModule = require("../RuntimeModule");
 class CompatRuntimeModule extends RuntimeModule {
 	constructor() {
 		super("compat", RuntimeModule.STAGE_ATTACH);
+		/** @type {boolean} */
 		this.fullHash = true;
 	}
 

package/lib/runtime/EnsureChunkRuntimeModule.js

@@ -17,6 +17,7 @@ class EnsureChunkRuntimeModule extends RuntimeModule {
 	 */
 	constructor(runtimeRequirements) {
 		super("ensure chunk");
+		/** @type {ReadOnlyRuntimeRequirements} */
 		this.runtimeRequirements = runtimeRequirements;
 	}
 

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -26,10 +26,15 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 	 */
 	constructor(contentType, name, global, getFilenameForChunk, allChunks) {
 		super(`get ${name} chunk filename`);
+		/** @type {string} */
 		this.contentType = contentType;
+		/** @type {string} */
 		this.global = global;
+		/** @type {(chunk: Chunk) => TemplatePath | false} */
 		this.getFilenameForChunk = getFilenameForChunk;
+		/** @type {boolean} */
 		this.allChunks = allChunks;
+		/** @type {boolean} */
 		this.dependentHash = true;
 	}
 

package/lib/runtime/GetFullHashRuntimeModule.js

@@ -12,6 +12,7 @@ const RuntimeModule = require("../RuntimeModule");
 class GetFullHashRuntimeModule extends RuntimeModule {
 	constructor() {
 		super("getFullHash");
+		/** @type {boolean} */
 		this.fullHash = true;
 	}
 

package/lib/runtime/GetMainFilenameRuntimeModule.js

@@ -19,7 +19,9 @@ class GetMainFilenameRuntimeModule extends RuntimeModule {
 	 */
 	constructor(name, global, filename) {
 		super(`get ${name} filename`);
+		/** @type {string} */
 		this.global = global;
+		/** @type {string} */
 		this.filename = filename;
 	}
 

package/lib/runtime/GetTrustedTypesPolicyRuntimeModule.js

@@ -17,6 +17,7 @@ class GetTrustedTypesPolicyRuntimeModule extends HelperRuntimeModule {
 	 */
 	constructor(runtimeRequirements) {
 		super("trusted types policy");
+		/** @type {ReadOnlyRuntimeRequirements} */
 		this.runtimeRequirements = runtimeRequirements;
 	}
 

package/lib/runtime/LoadScriptRuntimeModule.js

@@ -47,7 +47,9 @@ class LoadScriptRuntimeModule extends HelperRuntimeModule {
 	 */
 	constructor(withCreateScriptUrl, withFetchPriority) {
 		super("load script");
+		/** @type {boolean | undefined} */
 		this._withCreateScriptUrl = withCreateScriptUrl;
+		/** @type {boolean | undefined} */
 		this._withFetchPriority = withFetchPriority;
 	}