webpack 5.85.0 → 5.88.1

package/lib/dependencies/ImportEagerDependency.js

@@ -12,6 +12,8 @@ const ImportDependency = require("./ImportDependency");
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
@@ -19,7 +21,7 @@ class ImportEagerDependency extends ImportDependency {
 	/**
 	 * @param {string} request the request
 	 * @param {Range} range expression range
-	 * @param {string[][]=} referencedExports list of referenced exports
+	 * @param {(string[][] | null)=} referencedExports list of referenced exports
 	 */
 	constructor(request, range, referencedExports) {
 		super(request, range, referencedExports);
@@ -56,9 +58,9 @@ ImportEagerDependency.Template = class ImportEagerDependencyTemplate extends (
 		const dep = /** @type {ImportEagerDependency} */ (dependency);
 		const content = runtimeTemplate.moduleNamespacePromise({
 			chunkGraph,
-			module: moduleGraph.getModule(dep),
+			module: /** @type {Module} */ (moduleGraph.getModule(dep)),
 			request: dep.request,
-			strict: module.buildMeta.strictHarmonyModule,
+			strict: /** @type {BuildMeta} */ (module.buildMeta).strictHarmonyModule,
 			message: "import() eager",
 			runtimeRequirements
 		});

package/lib/dependencies/ImportMetaContextDependencyParserPlugin.js

@@ -219,6 +219,25 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 								}
 								break;
 							}
+							case "fetchPriority": {
+								const expr = parser.evaluateExpression(
+									/** @type {Expression} */ (prop.value)
+								);
+								if (
+									expr.isString() &&
+									["high", "low", "auto"].includes(expr.string)
+								) {
+									groupOptions.fetchPriority =
+										/** @type {RawChunkGroupOptions["fetchPriority"]} */ (
+											expr.string
+										);
+								} else {
+									errors.push(
+										createPropertyParseError(prop, '"high"|"low"|"auto"')
+									);
+								}
+								break;
+							}
 							case "recursive": {
 								const recursiveExpr = parser.evaluateExpression(
 									/** @type {Expression} */ (prop.value)

package/lib/dependencies/ImportMetaPlugin.js

@@ -26,8 +26,10 @@ const ConstDependency = require("./ConstDependency");
 /** @typedef {import("estree").MemberExpression} MemberExpression */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
 const getCriticalDependencyWarning = memoize(() =>
 	require("./CriticalDependencyWarning")
@@ -64,10 +66,10 @@ class ImportMetaPlugin {
 							.for("import.meta")
 							.tap(PLUGIN_NAME, metaProperty => {
 								const dep = new ConstDependency(
-									importMetaName,
-									metaProperty.range
+									/** @type {string} */ (importMetaName),
+									/** @type {Range} */ (metaProperty.range)
 								);
-								dep.loc = metaProperty.loc;
+								dep.loc = /** @type {DependencyLocation} */ (metaProperty.loc);
 								parser.state.module.addPresentationalDependency(dep);
 								return true;
 							});
@@ -82,6 +84,10 @@ class ImportMetaPlugin {
 					const importMetaUrl = () =>
 						JSON.stringify(getUrl(parser.state.module));
 					const importMetaWebpackVersion = () => JSON.stringify(webpackVersion);
+					/**
+					 * @param {string[]} members members
+					 * @returns {string} error message
+					 */
 					const importMetaUnknownProperty = members =>
 						`${Template.toNormalComment(
 							"unsupported import.meta." + members.join(".")
@@ -106,16 +112,20 @@ class ImportMetaPlugin {
 										new CriticalDependencyWarning(
 											"Accessing import.meta directly is unsupported (only property access or destructuring is supported)"
 										),
-										metaProperty.loc
+										/** @type {DependencyLocation} */ (metaProperty.loc)
 									)
 								);
 								const dep = new ConstDependency(
 									`${
-										parser.isAsiPosition(metaProperty.range[0]) ? ";" : ""
+										parser.isAsiPosition(
+											/** @type {Range} */ (metaProperty.range)[0]
+										)
+											? ";"
+											: ""
 									}({})`,
-									metaProperty.range
+									/** @type {Range} */ (metaProperty.range)
 								);
-								dep.loc = metaProperty.loc;
+								dep.loc = /** @type {DependencyLocation} */ (metaProperty.loc);
 								parser.state.module.addPresentationalDependency(dep);
 								return true;
 							}
@@ -136,8 +146,11 @@ class ImportMetaPlugin {
 										break;
 								}
 							}
-							const dep = new ConstDependency(`({${str}})`, metaProperty.range);
-							dep.loc = metaProperty.loc;
+							const dep = new ConstDependency(
+								`({${str}})`,
+								/** @type {Range} */ (metaProperty.range)
+							);
+							dep.loc = /** @type {DependencyLocation} */ (metaProperty.loc);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
@@ -159,8 +172,11 @@ class ImportMetaPlugin {
 					parser.hooks.expression
 						.for("import.meta.url")
 						.tap(PLUGIN_NAME, expr => {
-							const dep = new ConstDependency(importMetaUrl(), expr.range);
-							dep.loc = expr.loc;
+							const dep = new ConstDependency(
+								importMetaUrl(),
+								/** @type {Range} */ (expr.range)
+							);
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
@@ -172,7 +188,7 @@ class ImportMetaPlugin {
 						.tap(PLUGIN_NAME, expr => {
 							return new BasicEvaluatedExpression()
 								.setString(getUrl(parser.state.module))
-								.setRange(expr.range);
+								.setRange(/** @type {Range} */ (expr.range));
 						});
 
 					/// import.meta.webpack ///
@@ -201,9 +217,9 @@ class ImportMetaPlugin {
 						.tap(PLUGIN_NAME, (expr, members) => {
 							const dep = new ConstDependency(
 								importMetaUnknownProperty(members),
-								expr.range
+								/** @type {Range} */ (expr.range)
 							);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
@@ -220,7 +236,7 @@ class ImportMetaPlugin {
 							) {
 								return new BasicEvaluatedExpression()
 									.setUndefined()
-									.setRange(expr.range);
+									.setRange(/** @type {Range} */ (expr.range));
 							}
 						});
 				};

package/lib/dependencies/ImportParserPlugin.js

@@ -17,7 +17,10 @@ const ImportWeakDependency = require("./ImportWeakDependency");
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
 /** @typedef {import("../ContextModule").ContextMode} ContextMode */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
 class ImportParserPlugin {
 	/**
@@ -32,14 +35,18 @@ class ImportParserPlugin {
 	 * @returns {void}
 	 */
 	apply(parser) {
+		/**
+		 * @template T
+		 * @param {Iterable<T>} enumerable enumerable
+		 * @returns {T[][]} array of array
+		 */
 		const exportsFromEnumerable = enumerable =>
 			Array.from(enumerable, e => [e]);
 		parser.hooks.importCall.tap("ImportParserPlugin", expr => {
 			const param = parser.evaluateExpression(expr.source);
 
 			let chunkName = null;
-			/** @type {ContextMode} */
-			let mode = this.options.dynamicImportMode;
+			let mode = /** @type {ContextMode} */ (this.options.dynamicImportMode);
 			let include = null;
 			let exclude = null;
 			/** @type {string[][] | null} */
@@ -47,7 +54,11 @@ class ImportParserPlugin {
 			/** @type {RawChunkGroupOptions} */
 			const groupOptions = {};
 
-			const { dynamicImportPreload, dynamicImportPrefetch } = this.options;
+			const {
+				dynamicImportPreload,
+				dynamicImportPrefetch,
+				dynamicImportFetchPriority
+			} = this.options;
 			if (dynamicImportPreload !== undefined && dynamicImportPreload !== false)
 				groupOptions.preloadOrder =
 					dynamicImportPreload === true ? 0 : dynamicImportPreload;
@@ -57,9 +68,14 @@ class ImportParserPlugin {
 			)
 				groupOptions.prefetchOrder =
 					dynamicImportPrefetch === true ? 0 : dynamicImportPrefetch;
+			if (
+				dynamicImportFetchPriority !== undefined &&
+				dynamicImportFetchPriority !== false
+			)
+				groupOptions.fetchPriority = dynamicImportFetchPriority;
 
 			const { options: importOptions, errors: commentErrors } =
-				parser.parseCommentOptions(expr.range);
+				parser.parseCommentOptions(/** @type {Range} */ (expr.range));
 
 			if (commentErrors) {
 				for (const e of commentErrors) {
@@ -79,7 +95,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					} else {
@@ -94,7 +110,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					} else {
@@ -106,7 +122,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackMode\` expected a string, but received: ${importOptions.webpackMode}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					} else {
@@ -122,7 +138,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackPrefetch\` expected true or a number, but received: ${importOptions.webpackPrefetch}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					}
@@ -136,7 +152,22 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackPreload\` expected true or a number, but received: ${importOptions.webpackPreload}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					}
+				}
+				if (importOptions.webpackFetchPriority !== undefined) {
+					if (
+						typeof importOptions.webpackFetchPriority === "string" &&
+						["high", "low", "auto"].includes(importOptions.webpackFetchPriority)
+					) {
+						groupOptions.fetchPriority = importOptions.webpackFetchPriority;
+					} else {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackFetchPriority\` expected true or "low", "high" or "auto", but received: ${importOptions.webpackFetchPriority}.`,
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					}
@@ -149,7 +180,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackInclude\` expected a regular expression, but received: ${importOptions.webpackInclude}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					} else {
@@ -164,7 +195,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackExclude\` expected a regular expression, but received: ${importOptions.webpackExclude}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					} else {
@@ -176,7 +207,7 @@ class ImportParserPlugin {
 						!(
 							typeof importOptions.webpackExports === "string" ||
 							(Array.isArray(importOptions.webpackExports) &&
-								importOptions.webpackExports.every(
+								/** @type {string[]} */ (importOptions.webpackExports).every(
 									item => typeof item === "string"
 								))
 						)
@@ -184,7 +215,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackExports\` expected a string or an array of strings, but received: ${importOptions.webpackExports}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					} else {
@@ -206,7 +237,7 @@ class ImportParserPlugin {
 				parser.state.module.addWarning(
 					new UnsupportedFeatureWarning(
 						`\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`,
-						expr.loc
+						/** @type {DependencyLocation} */ (expr.loc)
 					)
 				);
 				mode = "lazy";
@@ -219,7 +250,7 @@ class ImportParserPlugin {
 					parser.state.module.addWarning(
 						new UnsupportedFeatureWarning(
 							`\`webpackExports\` could not be used with destructuring assignment.`,
-							expr.loc
+							/** @type {DependencyLocation} */ (expr.loc)
 						)
 					);
 				}
@@ -229,15 +260,15 @@ class ImportParserPlugin {
 			if (param.isString()) {
 				if (mode === "eager") {
 					const dep = new ImportEagerDependency(
-						param.string,
-						expr.range,
+						/** @type {string} */ (param.string),
+						/** @type {Range} */ (expr.range),
 						exports
 					);
 					parser.state.current.addDependency(dep);
 				} else if (mode === "weak") {
 					const dep = new ImportWeakDependency(
-						param.string,
-						expr.range,
+						/** @type {string} */ (param.string),
+						/** @type {Range} */ (expr.range),
 						exports
 					);
 					parser.state.current.addDependency(dep);
@@ -247,11 +278,15 @@ class ImportParserPlugin {
 							...groupOptions,
 							name: chunkName
 						},
-						expr.loc,
+						/** @type {DependencyLocation} */ (expr.loc),
 						param.string
 					);
-					const dep = new ImportDependency(param.string, expr.range, exports);
-					dep.loc = expr.loc;
+					const dep = new ImportDependency(
+						/** @type {string} */ (param.string),
+						/** @type {Range} */ (expr.range),
+						exports
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 					depBlock.addDependency(dep);
 					parser.state.current.addBlock(depBlock);
 				}
@@ -262,7 +297,7 @@ class ImportParserPlugin {
 				}
 				const dep = ContextDependencyHelpers.create(
 					ImportContextDependency,
-					expr.range,
+					/** @type {Range} */ (expr.range),
 					param,
 					expr,
 					this.options,
@@ -272,7 +307,9 @@ class ImportParserPlugin {
 						include,
 						exclude,
 						mode,
-						namespaceObject: parser.state.module.buildMeta.strictHarmonyModule
+						namespaceObject: /** @type {BuildMeta} */ (
+							parser.state.module.buildMeta
+						).strictHarmonyModule
 							? "strict"
 							: true,
 						typePrefix: "import()",
@@ -282,7 +319,7 @@ class ImportParserPlugin {
 					parser
 				);
 				if (!dep) return;
-				dep.loc = expr.loc;
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				dep.optional = !!parser.scope.inTry;
 				parser.state.current.addDependency(dep);
 				return true;

package/lib/dependencies/ImportWeakDependency.js

@@ -12,6 +12,8 @@ const ImportDependency = require("./ImportDependency");
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
@@ -19,7 +21,7 @@ class ImportWeakDependency extends ImportDependency {
 	/**
 	 * @param {string} request the request
 	 * @param {Range} range expression range
-	 * @param {string[][]=} referencedExports list of referenced exports
+	 * @param {(string[][] | null)=} referencedExports list of referenced exports
 	 */
 	constructor(request, range, referencedExports) {
 		super(request, range, referencedExports);
@@ -53,9 +55,9 @@ ImportWeakDependency.Template = class ImportDependencyTemplate extends (
 		const dep = /** @type {ImportWeakDependency} */ (dependency);
 		const content = runtimeTemplate.moduleNamespacePromise({
 			chunkGraph,
-			module: moduleGraph.getModule(dep),
+			module: /** @type {Module} */ (moduleGraph.getModule(dep)),
 			request: dep.request,
-			strict: module.buildMeta.strictHarmonyModule,
+			strict: /** @type {BuildMeta} */ (module.buildMeta).strictHarmonyModule,
 			message: "import() weak",
 			weak: true,
 			runtimeRequirements

package/lib/dependencies/JsonExportsDependency.js

@@ -47,7 +47,7 @@ const getExportsFromData = data => {
 
 class JsonExportsDependency extends NullDependency {
 	/**
-	 * @param {JsonData=} data json data
+	 * @param {JsonData} data json data
 	 */
 	constructor(data) {
 		super();

package/lib/dependencies/ModuleDependency.js

@@ -58,7 +58,7 @@ class ModuleDependency extends Dependency {
 
 	/**
 	 * @param {string} context context directory
-	 * @returns {Module} a module
+	 * @returns {Module | null} a module
 	 */
 	createIgnoredModule(context) {
 		const RawModule = getRawModule();

package/lib/dependencies/ModuleDependencyTemplateAsId.js

@@ -10,6 +10,7 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
 
 class ModuleDependencyTemplateAsId extends ModuleDependency.Template {
 	/**
@@ -22,7 +23,7 @@ class ModuleDependencyTemplateAsId extends ModuleDependency.Template {
 		const dep = /** @type {ModuleDependency} */ (dependency);
 		if (!dep.range) return;
 		const content = runtimeTemplate.moduleId({
-			module: moduleGraph.getModule(dep),
+			module: /** @type {Module} */ (moduleGraph.getModule(dep)),
 			chunkGraph,
 			request: dep.request,
 			weak: dep.weak

package/lib/dependencies/ProvidedDependency.js

@@ -17,6 +17,7 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
@@ -127,7 +128,9 @@ class ProvidedDependencyTemplate extends ModuleDependency.Template {
 		}
 	) {
 		const dep = /** @type {ProvidedDependency} */ (dependency);
-		const connection = moduleGraph.getConnection(dep);
+		const connection =
+			/** @type {ModuleGraphConnection} */
+			(moduleGraph.getConnection(dep));
 		const exportsInfo = moduleGraph.getExportsInfo(connection.module);
 		const usedName = exportsInfo.getUsedName(dep.ids, runtime);
 		initFragments.push(

package/lib/dependencies/RequireContextDependencyParserPlugin.js

@@ -7,7 +7,15 @@
 
 const RequireContextDependency = require("./RequireContextDependency");
 
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
 module.exports = class RequireContextDependencyParserPlugin {
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
 	apply(parser) {
 		parser.hooks.call
 			.for("require.context")
@@ -19,19 +27,19 @@ module.exports = class RequireContextDependencyParserPlugin {
 					case 4: {
 						const modeExpr = parser.evaluateExpression(expr.arguments[3]);
 						if (!modeExpr.isString()) return;
-						mode = modeExpr.string;
+						mode = /** @type {string} */ (modeExpr.string);
 					}
 					// falls through
 					case 3: {
 						const regExpExpr = parser.evaluateExpression(expr.arguments[2]);
 						if (!regExpExpr.isRegExp()) return;
-						regExp = regExpExpr.regExp;
+						regExp = /** @type {RegExp} */ (regExpExpr.regExp);
 					}
 					// falls through
 					case 2: {
 						const recursiveExpr = parser.evaluateExpression(expr.arguments[1]);
 						if (!recursiveExpr.isBoolean()) return;
-						recursive = recursiveExpr.bool;
+						recursive = /** @type {boolean} */ (recursiveExpr.bool);
 					}
 					// falls through
 					case 1: {
@@ -45,9 +53,9 @@ module.exports = class RequireContextDependencyParserPlugin {
 								mode,
 								category: "commonjs"
 							},
-							expr.range
+							/** @type {Range} */ (expr.range)
 						);
-						dep.loc = expr.loc;
+						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 						dep.optional = !!parser.scope.inTry;
 						parser.state.current.addDependency(dep);
 						return true;

package/lib/dependencies/RequireEnsureDependenciesBlock.js

@@ -8,10 +8,13 @@
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const makeSerializable = require("../util/makeSerializable");
 
+/** @typedef {import("../ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+
 class RequireEnsureDependenciesBlock extends AsyncDependenciesBlock {
 	/**
-	 * @param {TODO} chunkName chunk name
-	 * @param {TODO} loc location info
+	 * @param {ChunkGroupOptions & { entryOptions?: TODO }} chunkName chunk name
+	 * @param {DependencyLocation} loc location info
 	 */
 	constructor(chunkName, loc) {
 		super(chunkName, loc, null);

package/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js

@@ -10,6 +10,9 @@ const RequireEnsureDependency = require("./RequireEnsureDependency");
 const RequireEnsureItemDependency = require("./RequireEnsureItemDependency");
 const getFunctionExpression = require("./getFunctionExpression");
 
+/** @typedef {import("../ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+
 module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 	apply(parser) {
 		parser.hooks.call
@@ -57,7 +60,9 @@ module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 						}
 
 						const depBlock = new RequireEnsureDependenciesBlock(
-							chunkName,
+							/** @type {ChunkGroupOptions & { entryOptions?: TODO }} */ (
+								chunkName
+							),
 							expr.loc
 						);
 						const errorCallbackExists =

package/lib/dependencies/RequireHeaderDependency.js

@@ -35,6 +35,10 @@ class RequireHeaderDependency extends NullDependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {RequireHeaderDependency} RequireHeaderDependency
+	 */
 	static deserialize(context) {
 		const obj = new RequireHeaderDependency(context.read());
 		obj.deserialize(context);

package/lib/dependencies/RequireIncludeDependencyParserPlugin.js

@@ -13,6 +13,10 @@ const {
 const makeSerializable = require("../util/makeSerializable");
 const RequireIncludeDependency = require("./RequireIncludeDependency");
 
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
 module.exports = class RequireIncludeDependencyParserPlugin {
 	/**
 	 * @param {boolean} warn true: warn about deprecation, false: don't warn
@@ -20,6 +24,11 @@ module.exports = class RequireIncludeDependencyParserPlugin {
 	constructor(warn) {
 		this.warn = warn;
 	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
 	apply(parser) {
 		const { warn } = this;
 		parser.hooks.call
@@ -31,12 +40,17 @@ module.exports = class RequireIncludeDependencyParserPlugin {
 
 				if (warn) {
 					parser.state.module.addWarning(
-						new RequireIncludeDeprecationWarning(expr.loc)
+						new RequireIncludeDeprecationWarning(
+							/** @type {DependencyLocation} */ (expr.loc)
+						)
 					);
 				}
 
-				const dep = new RequireIncludeDependency(param.string, expr.range);
-				dep.loc = expr.loc;
+				const dep = new RequireIncludeDependency(
+					/** @type {string} */ (param.string),
+					/** @type {Range} */ (expr.range)
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.current.addDependency(dep);
 				return true;
 			});
@@ -45,7 +59,9 @@ module.exports = class RequireIncludeDependencyParserPlugin {
 			.tap("RequireIncludePlugin", expr => {
 				if (warn) {
 					parser.state.module.addWarning(
-						new RequireIncludeDeprecationWarning(expr.loc)
+						new RequireIncludeDeprecationWarning(
+							/** @type {DependencyLocation} */ (expr.loc)
+						)
 					);
 				}
 				return evaluateToString("function")(expr);
@@ -55,7 +71,9 @@ module.exports = class RequireIncludeDependencyParserPlugin {
 			.tap("RequireIncludePlugin", expr => {
 				if (warn) {
 					parser.state.module.addWarning(
-						new RequireIncludeDeprecationWarning(expr.loc)
+						new RequireIncludeDeprecationWarning(
+							/** @type {DependencyLocation} */ (expr.loc)
+						)
 					);
 				}
 				return toConstantDependency(parser, JSON.stringify("function"))(expr);
@@ -64,6 +82,9 @@ module.exports = class RequireIncludeDependencyParserPlugin {
 };
 
 class RequireIncludeDeprecationWarning extends WebpackError {
+	/**
+	 * @param {DependencyLocation} loc location
+	 */
 	constructor(loc) {
 		super("require.include() is deprecated and will be removed soon.");