webpack 5.86.0 → 5.87.0

package/lib/util/deterministicGrouping.js

@@ -94,7 +94,8 @@ const subtractSizeFrom = (total, size) => {
 };
 
 /**
- * @param {Iterable<Node>} nodes some nodes
+ * @template T
+ * @param {Iterable<Node<T>>} nodes some nodes
  * @returns {Record<string, number>} total size
  */
 const sumSize = nodes => {
@@ -105,6 +106,11 @@ const sumSize = nodes => {
 	return sum;
 };
 
+/**
+ * @param {Record<string, number>} size size
+ * @param {Record<string, number>} maxSize minimum size
+ * @returns {boolean} true, when size is too big
+ */
 const isTooBig = (size, maxSize) => {
 	for (const key of Object.keys(size)) {
 		const s = size[key];
@@ -117,6 +123,11 @@ const isTooBig = (size, maxSize) => {
 	return false;
 };
 
+/**
+ * @param {Record<string, number>} size size
+ * @param {Record<string, number>} minSize minimum size
+ * @returns {boolean} true, when size is too small
+ */
 const isTooSmall = (size, minSize) => {
 	for (const key of Object.keys(size)) {
 		const s = size[key];
@@ -129,6 +140,11 @@ const isTooSmall = (size, minSize) => {
 	return false;
 };
 
+/**
+ * @param {Record<string, number>} size size
+ * @param {Record<string, number>} minSize minimum size
+ * @returns {Set<string>} set of types that are too small
+ */
 const getTooSmallTypes = (size, minSize) => {
 	const types = new Set();
 	for (const key of Object.keys(size)) {
@@ -142,6 +158,12 @@ const getTooSmallTypes = (size, minSize) => {
 	return types;
 };
 
+/**
+ * @template T
+ * @param {TODO} size size
+ * @param {Set<string>} types types
+ * @returns {number} number of matching size types
+ */
 const getNumberOfMatchingSizeTypes = (size, types) => {
 	let i = 0;
 	for (const key of Object.keys(size)) {
@@ -150,6 +172,11 @@ const getNumberOfMatchingSizeTypes = (size, types) => {
 	return i;
 };
 
+/**
+ * @param {Record<string, number>} size size
+ * @param {Set<string>} types types
+ * @returns {number} selective size sum
+ */
 const selectiveSizeSum = (size, types) => {
 	let sum = 0;
 	for (const key of Object.keys(size)) {
@@ -180,20 +207,20 @@ class Node {
 class Group {
 	/**
 	 * @param {Node<T>[]} nodes nodes
-	 * @param {number[]} similarities similarities between the nodes (length = nodes.length - 1)
+	 * @param {number[] | null} similarities similarities between the nodes (length = nodes.length - 1)
 	 * @param {Record<string, number>=} size size of the group
 	 */
 	constructor(nodes, similarities, size) {
 		this.nodes = nodes;
 		this.similarities = similarities;
 		this.size = size || sumSize(nodes);
-		/** @type {string} */
+		/** @type {string | undefined} */
 		this.key = undefined;
 	}
 
 	/**
-	 * @param {function(Node): boolean} filter filter function
-	 * @returns {Node[]} removed nodes
+	 * @param {function(Node<T>): boolean} filter filter function
+	 * @returns {Node<T>[] | undefined} removed nodes
 	 */
 	popNodes(filter) {
 		const newNodes = [];
@@ -208,7 +235,7 @@ class Group {
 				if (newNodes.length > 0) {
 					newSimilarities.push(
 						lastNode === this.nodes[i - 1]
-							? this.similarities[i - 1]
+							? /** @type {number[]} */ (this.similarities)[i - 1]
 							: similarity(lastNode.key, node.key)
 					);
 				}
@@ -225,7 +252,8 @@ class Group {
 }
 
 /**
- * @param {Iterable<Node>} nodes nodes
+ * @template T
+ * @param {Iterable<Node<T>>} nodes nodes
  * @returns {number[]} similarities
  */
 const getSimilarities = nodes => {
@@ -297,6 +325,11 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 	if (initialNodes.length > 0) {
 		const initialGroup = new Group(initialNodes, getSimilarities(initialNodes));
 
+		/**
+		 * @param {Group<T>} group group
+		 * @param {Record<string, number>} consideredSize size of the group to consider
+		 * @returns {boolean} true, if the group was modified
+		 */
 		const removeProblematicNodes = (group, consideredSize = group.size) => {
 			const problemTypes = getTooSmallTypes(consideredSize, minSize);
 			if (problemTypes.size > 0) {
@@ -347,7 +380,7 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 			const queue = [initialGroup];
 
 			while (queue.length) {
-				const group = queue.pop();
+				const group = /** @type {Group<T>} */ (queue.pop());
 				// only groups bigger than maxSize need to be splitted
 				if (!isTooBig(group.size, maxSize)) {
 					result.push(group);
@@ -428,7 +461,9 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 					// rightSize ^^^^^^^^^^^^^^^
 
 					while (pos <= right + 1) {
-						const similarity = group.similarities[pos - 1];
+						const similarity = /** @type {number[]} */ (group.similarities)[
+							pos - 1
+						];
 						if (
 							similarity < bestSimilarity &&
 							!isTooSmall(leftSize, minSize) &&
@@ -458,7 +493,9 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 				/** @type {number[]} */
 				const rightSimilarities = [];
 				for (let i = right + 2; i < group.nodes.length; i++) {
-					rightSimilarities.push(group.similarities[i - 1]);
+					rightSimilarities.push(
+						/** @type {number[]} */ (group.similarities)[i - 1]
+					);
 					rightNodes.push(group.nodes[i]);
 				}
 				queue.push(new Group(rightNodes, rightSimilarities));
@@ -467,7 +504,9 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 				/** @type {number[]} */
 				const leftSimilarities = [];
 				for (let i = 1; i < left; i++) {
-					leftSimilarities.push(group.similarities[i - 1]);
+					leftSimilarities.push(
+						/** @type {number[]} */ (group.similarities)[i - 1]
+					);
 					leftNodes.push(group.nodes[i]);
 				}
 				queue.push(new Group(leftNodes, leftSimilarities));

package/lib/util/findGraphRoots.js

@@ -109,7 +109,9 @@ module.exports = (items, getDependencies) => {
 				// Are there still edges unprocessed in the current node?
 				if (topOfStack.openEdges.length > 0) {
 					// Process one dependency
-					const dependency = topOfStack.openEdges.pop();
+					const dependency =
+						/** @type {Node<T>} */
+						(topOfStack.openEdges.pop());
 					switch (dependency.marker) {
 						case NO_MARKER:
 							// dependency has not be visited yet
@@ -169,7 +171,7 @@ module.exports = (items, getDependencies) => {
 							// so it's not really a root cycle
 							// remove the cycle from the root cycles
 							// and convert it to a normal node
-							rootCycles.delete(dependency.cycle);
+							rootCycles.delete(/** @type {Cycle<T>} */ (dependency.cycle));
 							dependency.marker = DONE_MARKER;
 							break;
 						// DONE_MARKER: nothing to do, don't recurse into dependencies

package/lib/util/memoize.js

@@ -13,18 +13,18 @@
  */
 const memoize = fn => {
 	let cache = false;
-	/** @type {T} */
+	/** @type {T | undefined} */
 	let result = undefined;
 	return () => {
 		if (cache) {
-			return result;
+			return /** @type {T} */ (result);
 		} else {
 			result = fn();
 			cache = true;
 			// Allow to clean up memory for fn
 			// and all dependent resources
 			fn = undefined;
-			return result;
+			return /** @type {T} */ (result);
 		}
 	};
 };

package/lib/util/processAsyncTree.js

@@ -21,6 +21,9 @@ const processAsyncTree = (items, concurrency, processor, callback) => {
 	let finished = false;
 	let processScheduled = true;
 
+	/**
+	 * @param {T} item item
+	 */
 	const push = item => {
 		queue.push(item);
 		if (!processScheduled && processing < concurrency) {
@@ -29,6 +32,9 @@ const processAsyncTree = (items, concurrency, processor, callback) => {
 		}
 	};
 
+	/**
+	 * @param {E | null | undefined} err error
+	 */
 	const processorCallback = err => {
 		processing--;
 		if (err && !finished) {
@@ -46,7 +52,7 @@ const processAsyncTree = (items, concurrency, processor, callback) => {
 		if (finished) return;
 		while (processing < concurrency && queue.length > 0) {
 			processing++;
-			const item = queue.pop();
+			const item = /** @type {T} */ (queue.pop());
 			processor(item, push, processorCallback);
 		}
 		processScheduled = false;

package/lib/util/registerExternalSerializer.js

@@ -26,7 +26,7 @@ const {
 /** @typedef {import("./serialization").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./serialization").ObjectSerializerContext} ObjectSerializerContext */
 
-/** @typedef {ObjectSerializerContext & { writeLazy?: (any) => void }} WebpackObjectSerializerContext */
+/** @typedef {ObjectSerializerContext & { writeLazy?: (value: any) => void }} WebpackObjectSerializerContext */
 
 const CURRENT_MODULE = "webpack/lib/util/registerExternalSerializer";
 

package/lib/util/runtime.js

@@ -434,7 +434,7 @@ class RuntimeSpecMap {
 
 	/**
 	 * @param {RuntimeSpec} runtime the runtimes
-	 * @returns {T} value
+	 * @returns {T | undefined} value
 	 */
 	get(runtime) {
 		switch (this._mode) {
@@ -517,6 +517,9 @@ class RuntimeSpecMap {
 		}
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime the runtimes
+	 */
 	delete(runtime) {
 		switch (this._mode) {
 			case 0:
@@ -593,6 +596,9 @@ class RuntimeSpecMap {
 exports.RuntimeSpecMap = RuntimeSpecMap;
 
 class RuntimeSpecSet {
+	/**
+	 * @param {Iterable<RuntimeSpec>=} iterable iterable
+	 */
 	constructor(iterable) {
 		/** @type {Map<string, RuntimeSpec>} */
 		this._map = new Map();
@@ -603,10 +609,17 @@ class RuntimeSpecSet {
 		}
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime runtime
+	 */
 	add(runtime) {
 		this._map.set(getRuntimeKey(runtime), runtime);
 	}
 
+	/**
+	 * @param {RuntimeSpec} runtime runtime
+	 * @returns {boolean} true, when the runtime exists
+	 */
 	has(runtime) {
 		return this._map.has(getRuntimeKey(runtime));
 	}

package/lib/util/smartGrouping.js

@@ -110,7 +110,7 @@ const smartGrouping = (items, groupConfigs) => {
 		/** @type {(T | R)[]} */
 		const results = [];
 		for (;;) {
-			/** @type {Group<T, R>} */
+			/** @type {Group<T, R> | undefined} */
 			let bestGroup = undefined;
 			let bestGroupSize = -1;
 			let bestGroupItems = undefined;

package/lib/validateSchema.js

@@ -119,7 +119,9 @@ const validateSchema = (schema, options, validationConfiguration) => {
 						)
 					) {
 						return `${formattedError}\nDid you mean ${
-							DID_YOU_MEAN[params.additionalProperty]
+							DID_YOU_MEAN[
+								/** @type {keyof DID_YOU_MEAN} */ (params.additionalProperty)
+							]
 						}?`;
 					}
 
@@ -129,7 +131,9 @@ const validateSchema = (schema, options, validationConfiguration) => {
 							params.additionalProperty
 						)
 					) {
-						return `${formattedError}\n${REMOVED[params.additionalProperty]}?`;
+						return `${formattedError}\n${
+							REMOVED[/** @type {keyof REMOVED} */ (params.additionalProperty)]
+						}?`;
 					}
 
 					if (!error.dataPath) {

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -9,6 +9,9 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
+
 /**
  * @typedef {Object} AsyncWasmLoadingRuntimeModuleOptions
  * @property {function(string): string} generateLoadBinaryCode
@@ -29,7 +32,8 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 	 * @returns {string} runtime code
 	 */
 	generate() {
-		const { compilation, chunk } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunk = /** @type {Chunk} */ (this.chunk);
 		const { outputOptions, runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.instantiateWasm;
 		const wasmModuleSrcPath = compilation.getPath(

package/lib/wasm-async/AsyncWebAssemblyParser.js

@@ -11,6 +11,8 @@ const Parser = require("../Parser");
 const StaticExportsDependency = require("../dependencies/StaticExportsDependency");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
@@ -43,9 +45,11 @@ class WebAssemblyParser extends Parser {
 		}
 
 		// flag it as async module
-		state.module.buildInfo.strict = true;
-		state.module.buildMeta.exportsType = "namespace";
-		state.module.buildMeta.async = true;
+		const buildInfo = /** @type {BuildInfo} */ (state.module.buildInfo);
+		buildInfo.strict = true;
+		const BuildMeta = /** @type {BuildMeta} */ (state.module.buildMeta);
+		BuildMeta.exportsType = "namespace";
+		BuildMeta.async = true;
 
 		// parse it
 		const program = decode(source, decoderOpts);

package/lib/wasm-sync/WasmChunkLoadingRuntimeModule.js

@@ -10,6 +10,7 @@ const Template = require("../Template");
 const { compareModulesByIdentifier } = require("../util/comparators");
 const WebAssemblyUtils = require("./WebAssemblyUtils");
 
+/** @typedef {import("@webassemblyjs/ast").Signature} Signature */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
@@ -91,9 +92,11 @@ const generateImportObject = (
 				value: `${instanceVar}[${JSON.stringify(usedName)}]`
 			});
 		} else {
-			const params = description.signature.params.map(
-				(param, k) => "p" + k + param.valtype
-			);
+			const params =
+				/** @type {Signature} */
+				(description.signature).params.map(
+					(param, k) => "p" + k + param.valtype
+				);
 
 			const mod = `${RuntimeGlobals.moduleCache}[${JSON.stringify(
 				chunkGraph.getModuleId(importedModule)
@@ -130,6 +133,7 @@ const generateImportObject = (
 			"};"
 		];
 	} else {
+		/** @type {Map<string, Array<{ name: string, value: string }>>} */
 		const propertiesByModule = new Map();
 		for (const p of properties) {
 			let list = propertiesByModule.get(p.module);
@@ -225,20 +229,23 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 	 * @returns {string} runtime code
 	 */
 	generate() {
-		const { chunkGraph, compilation, chunk, mangleImports } = this;
-		const { moduleGraph, outputOptions } = compilation;
 		const fn = RuntimeGlobals.ensureChunkHandlers;
 		const withHmr = this._runtimeRequirements.has(
 			RuntimeGlobals.hmrDownloadUpdateHandlers
 		);
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { moduleGraph, outputOptions } = compilation;
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
 		const wasmModules = getAllWasmModules(moduleGraph, chunkGraph, chunk);
+		const { mangleImports } = this;
 		/** @type {string[]} */
 		const declarations = [];
 		const importObjects = wasmModules.map(module => {
 			return generateImportObject(
 				chunkGraph,
 				module,
-				this.mangleImports,
+				mangleImports,
 				declarations,
 				chunk.runtime
 			);

package/lib/wasm-sync/WasmFinalizeExportsPlugin.js

@@ -11,6 +11,7 @@ const UnsupportedWebAssemblyFeatureError = require("./UnsupportedWebAssemblyFeat
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 
 class WasmFinalizeExportsPlugin {
 	/**
@@ -27,7 +28,8 @@ class WasmFinalizeExportsPlugin {
 						// 1. if a WebAssembly module
 						if (module.type.startsWith("webassembly") === true) {
 							const jsIncompatibleExports =
-								module.buildMeta.jsIncompatibleExports;
+								/** @type {BuildMeta} */
+								(module.buildMeta).jsIncompatibleExports;
 
 							if (jsIncompatibleExports === undefined) {
 								continue;

package/lib/wasm-sync/WebAssemblyGenerator.js

@@ -174,6 +174,7 @@ const createDefaultInitForGlobal = globalType => {
  */
 const rewriteImportedGlobals = state => bin => {
 	const additionalInitCode = state.additionalInitCode;
+	/** @type {Array<t.Global>} */
 	const newGlobals = [];
 
 	bin = editWithAST(state.ast, bin, {

package/lib/wasm-sync/WebAssemblyParser.js

@@ -14,6 +14,8 @@ const WebAssemblyExportImportedDependency = require("../dependencies/WebAssembly
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
@@ -81,8 +83,10 @@ class WebAssemblyParser extends Parser {
 		}
 
 		// flag it as ESM
-		state.module.buildInfo.strict = true;
-		state.module.buildMeta.exportsType = "namespace";
+		/** @type {BuildInfo} */
+		(state.module.buildInfo).strict = true;
+		/** @type {BuildMeta} */
+		(state.module.buildMeta).exportsType = "namespace";
 
 		// parse it
 		const program = decode(source, decoderOpts);

package/lib/web/JsonpChunkLoadingRuntimeModule.js

@@ -14,6 +14,7 @@ const { getInitialChunkIds } = require("../javascript/StartupHelpers");
 const compileBooleanMatcher = require("../util/compileBooleanMatcher");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
 
 /**
  * @typedef {Object} JsonpCompilationPluginHooks
@@ -72,7 +73,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 	 * @returns {string} runtime code
 	 */
 	generate() {
-		const { chunkGraph, compilation, chunk } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
 		const {
 			runtimeTemplate,
 			outputOptions: {
@@ -108,9 +109,14 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 		const withPreload = this._runtimeRequirements.has(
 			RuntimeGlobals.preloadChunkHandlers
 		);
+		const withFetchPriority = this._runtimeRequirements.has(
+			RuntimeGlobals.hasFetchPriority
+		);
 		const chunkLoadingGlobalExpr = `${globalObject}[${JSON.stringify(
 			chunkLoadingGlobal
 		)}]`;
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
 		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
 		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
@@ -138,7 +144,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 			withLoading
 				? Template.asString([
 						`${fn}.j = ${runtimeTemplate.basicFunction(
-							"chunkId, promises",
+							`chunkId, promises${withFetchPriority ? ", fetchPriority" : ""}`,
 							hasJsMatcher !== false
 								? Template.indent([
 										"// JSONP chunk loading for javascript",
@@ -190,7 +196,11 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 															"}"
 														]
 													)};`,
-													`${RuntimeGlobals.loadScript}(url, loadingEnded, "chunk-" + chunkId, chunkId);`
+													`${
+														RuntimeGlobals.loadScript
+													}(url, loadingEnded, "chunk-" + chunkId, chunkId${
+														withFetchPriority ? ", fetchPriority" : ""
+													});`
 												]),
 												hasJsMatcher === true
 													? "}"

package/lib/webpack.js

@@ -61,7 +61,10 @@ const createMultiCompiler = (childOptions, options) => {
 const createCompiler = rawOptions => {
 	const options = getNormalizedWebpackOptions(rawOptions);
 	applyWebpackOptionsBaseDefaults(options);
-	const compiler = new Compiler(options.context, options);
+	const compiler = new Compiler(
+		/** @type {string} */ (options.context),
+		options
+	);
 	new NodeEnvironmentPlugin({
 		infrastructureLogging: options.infrastructureLogging
 	}).apply(compiler);
@@ -69,7 +72,7 @@ const createCompiler = rawOptions => {
 		for (const plugin of options.plugins) {
 			if (typeof plugin === "function") {
 				plugin.call(compiler, compiler);
-			} else {
+			} else if (plugin) {
 				plugin.apply(compiler);
 			}
 		}
@@ -96,6 +99,11 @@ const createCompiler = rawOptions => {
  * @returns {MultiCompiler} the multi compiler object
  */
 
+/**
+ * @template T
+ * @param {Array<T> | T} options options
+ * @returns {Array<T>} array of options
+ */
 const asArray = options =>
 	Array.isArray(options) ? Array.from(options) : [options];
 
@@ -117,6 +125,7 @@ const webpack = /** @type {WebpackFunctionSingle & WebpackFunctionMulti} */ (
 			}
 			/** @type {MultiCompiler|Compiler} */
 			let compiler;
+			/** @type {boolean | undefined} */
 			let watch = false;
 			/** @type {WatchOptions|WatchOptions[]} */
 			let watchOptions;

package/lib/webworker/ImportScriptsChunkLoadingRuntimeModule.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 ImportScriptsChunkLoadingRuntimeModule extends RuntimeModule {
 	/**
@@ -38,8 +40,9 @@ class ImportScriptsChunkLoadingRuntimeModule extends RuntimeModule {
 		if (options && options.baseUri) {
 			return `${RuntimeGlobals.baseURI} = ${JSON.stringify(options.baseUri)};`;
 		}
-		const outputName = this.compilation.getPath(
-			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const outputName = compilation.getPath(
+			getChunkFilenameTemplate(chunk, compilation.outputOptions),
 			{
 				chunk,
 				contentHashType: "javascript"
@@ -47,7 +50,7 @@ class ImportScriptsChunkLoadingRuntimeModule extends RuntimeModule {
 		);
 		const rootOutputDir = getUndoPath(
 			outputName,
-			/** @type {string} */ (this.compilation.outputOptions.path),
+			/** @type {string} */ (compilation.outputOptions.path),
 			false
 		);
 		return `${RuntimeGlobals.baseURI} = self.location + ${JSON.stringify(
@@ -59,16 +62,7 @@ class ImportScriptsChunkLoadingRuntimeModule extends RuntimeModule {
 	 * @returns {string} runtime code
 	 */
 	generate() {
-		const {
-			chunk,
-			chunkGraph,
-			compilation: {
-				runtimeTemplate,
-				outputOptions: { chunkLoadingGlobal, hotUpdateGlobal }
-			},
-			_withCreateScriptUrl: withCreateScriptUrl
-		} = this;
-		const globalObject = runtimeTemplate.globalObject;
+		const compilation = /** @type {Compilation} */ (this.compilation);
 		const fn = RuntimeGlobals.ensureChunkHandlers;
 		const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
 		const withLoading = this.runtimeRequirements.has(
@@ -80,9 +74,12 @@ class ImportScriptsChunkLoadingRuntimeModule extends RuntimeModule {
 		const withHmrManifest = this.runtimeRequirements.has(
 			RuntimeGlobals.hmrDownloadManifest
 		);
+		const globalObject = compilation.runtimeTemplate.globalObject;
 		const chunkLoadingGlobalExpr = `${globalObject}[${JSON.stringify(
-			chunkLoadingGlobal
+			compilation.outputOptions.chunkLoadingGlobal
 		)}]`;
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
 		const hasJsMatcher = compileBooleanMatcher(
 			chunkGraph.getChunkConditionMap(chunk, chunkHasJs)
 		);
@@ -91,6 +88,8 @@ class ImportScriptsChunkLoadingRuntimeModule extends RuntimeModule {
 		const stateExpression = withHmr
 			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_importScripts`
 			: undefined;
+		const runtimeTemplate = compilation.runtimeTemplate;
+		const { _withCreateScriptUrl: withCreateScriptUrl } = this;
 
 		return Template.asString([
 			withBaseURI ? this._generateBaseUri(chunk) : "// no baseURI",
@@ -169,7 +168,7 @@ class ImportScriptsChunkLoadingRuntimeModule extends RuntimeModule {
 						Template.indent([
 							"var success = false;",
 							`${globalObject}[${JSON.stringify(
-								hotUpdateGlobal
+								compilation.outputOptions.hotUpdateGlobal
 							)}] = ${runtimeTemplate.basicFunction("_, moreModules, runtime", [
 								"for(var moduleId in moreModules) {",
 								Template.indent([

package/module.d.ts

@@ -174,6 +174,7 @@ interface ImportMeta {
 			exclude?: RegExp;
 			preload?: boolean | number;
 			prefetch?: boolean | number;
+			fetchPriority?: "low" | "high" | "auto";
 			chunkName?: string;
 			exports?: string | string[][];
 			mode?: "sync" | "eager" | "weak" | "lazy" | "lazy-once";