webpack 5.97.1 → 5.104.1

package/lib/debug/ProfilingPlugin.js

@@ -6,28 +6,45 @@
 
 const { Tracer } = require("chrome-trace-event");
 const {
-	JAVASCRIPT_MODULE_TYPE_AUTO,
-	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
-	JAVASCRIPT_MODULE_TYPE_ESM,
-	WEBASSEMBLY_MODULE_TYPE_ASYNC,
-	WEBASSEMBLY_MODULE_TYPE_SYNC,
-	JSON_MODULE_TYPE
+	CSS_MODULES,
+	JAVASCRIPT_MODULES,
+	JSON_MODULE_TYPE,
+	WEBASSEMBLY_MODULES
 } = require("../ModuleTypeConstants");
 const createSchemaValidation = require("../util/create-schema-validation");
 const { dirname, mkdirpSync } = require("../util/fs");
 
+/** @typedef {import("inspector").Session} Session */
+/** @typedef {import("tapable").FullTap} FullTap */
 /** @typedef {import("../../declarations/plugins/debug/ProfilingPlugin").ProfilingPluginOptions} ProfilingPluginOptions */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../ContextModuleFactory")} ContextModuleFactory */
-/** @typedef {import("../ModuleFactory")} ModuleFactory */
 /** @typedef {import("../NormalModuleFactory")} NormalModuleFactory */
+/** @typedef {import("../ResolverFactory")} ResolverFactory */
 /** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 
-/** @typedef {TODO} Inspector */
+/**
+ * @template T, R
+ * @typedef {import("tapable").Hook<T, R>} Hook
+ */
+
+/**
+ * @template T
+ * @typedef {import("../util/deprecation").FakeHook<T>} FakeHook
+ */
+
+/**
+ * @template T
+ * @typedef {import("tapable").HookMap<T>} HookMap
+ */
+
+/**
+ * @template T, R
+ * @typedef {import("tapable").HookInterceptor<T, R>} HookInterceptor
+ */
 
 const validate = createSchemaValidation(
-	require("../../schemas/plugins/debug/ProfilingPlugin.check.js"),
+	require("../../schemas/plugins/debug/ProfilingPlugin.check"),
 	() => require("../../schemas/plugins/debug/ProfilingPlugin.json"),
 	{
 		name: "Profiling Plugin",
@@ -35,6 +52,8 @@ const validate = createSchemaValidation(
 	}
 );
 
+/** @typedef {{ Session: typeof import("inspector").Session }} Inspector */
+
 /** @type {Inspector | undefined} */
 let inspector;
 
@@ -42,6 +61,7 @@ try {
 	// eslint-disable-next-line n/no-unsupported-features/node-builtins
 	inspector = require("inspector");
 } catch (_err) {
+	// eslint-disable-next-line no-console
 	console.log("Unable to CPU profile in < node 8.0");
 }
 
@@ -50,6 +70,7 @@ class Profiler {
 	 * @param {Inspector} inspector inspector
 	 */
 	constructor(inspector) {
+		/** @type {undefined | Session} */
 		this.session = undefined;
 		this.inspector = inspector;
 		this._startTime = 0;
@@ -65,8 +86,9 @@ class Profiler {
 		}
 
 		try {
-			this.session = new inspector.Session();
-			this.session.connect();
+			this.session = new /** @type {Inspector} */ (inspector).Session();
+			/** @type {Session} */
+			(this.session).connect();
 		} catch (_) {
 			this.session = undefined;
 			return Promise.resolve();
@@ -86,13 +108,14 @@ class Profiler {
 
 	/**
 	 * @param {string} method method name
-	 * @param {object} [params] params
-	 * @returns {Promise<TODO>} Promise for the result
+	 * @param {EXPECTED_OBJECT=} params params
+	 * @returns {Promise<EXPECTED_ANY | void>} Promise for the result
 	 */
 	sendCommand(method, params) {
 		if (this.hasSession()) {
 			return new Promise((res, rej) => {
-				this.session.post(method, params, (err, params) => {
+				/** @type {Session} */
+				(this.session).post(method, params, (err, params) => {
 					if (err !== null) {
 						rej(err);
 					} else {
@@ -106,12 +129,16 @@ class Profiler {
 
 	destroy() {
 		if (this.hasSession()) {
-			this.session.disconnect();
+			/** @type {Session} */
+			(this.session).disconnect();
 		}
 
 		return Promise.resolve();
 	}
 
+	/**
+	 * @returns {Promise<{ profile: { startTime: number, endTime: number } }>} profile result
+	 */
 	stopProfiling() {
 		return this.sendCommand("Profiler.stop").then(({ profile }) => {
 			const hrtime = process.hrtime();
@@ -140,7 +167,7 @@ class Profiler {
  * @property {Tracer} trace instance of Tracer
  * @property {number} counter Counter
  * @property {Profiler} profiler instance of Profiler
- * @property {Function} end the end function
+ * @property {(callback: (err?: null | Error) => void) => void} end the end function
  */
 
 /**
@@ -196,7 +223,7 @@ const createTrace = (fs, outputPath) => {
 		trace,
 		counter,
 		profiler,
-		end: callback => {
+		end: (callback) => {
 			trace.push("]");
 			// Wait until the write stream finishes.
 			fsStream.on("close", () => {
@@ -242,9 +269,16 @@ class ProfilingPlugin {
 		}
 
 		for (const hookName of Object.keys(compiler.resolverFactory.hooks)) {
-			const hook = compiler.resolverFactory.hooks[hookName];
+			const hook =
+				compiler.resolverFactory.hooks[
+					/** @type {keyof ResolverFactory["hooks"]} */
+					(hookName)
+				];
 			if (hook) {
-				hook.intercept(makeInterceptorFor("Resolver", tracer)(hookName));
+				hook.intercept(
+					/** @type {EXPECTED_ANY} */
+					(makeInterceptorFor("Resolver", tracer)(hookName))
+				);
 			}
 		}
 
@@ -263,7 +297,9 @@ class ProfilingPlugin {
 					"Context Module Factory"
 				);
 				interceptAllParserHooks(normalModuleFactory, tracer);
+				interceptAllGeneratorHooks(normalModuleFactory, tracer);
 				interceptAllJavascriptModulesPluginHooks(compilation, tracer);
+				interceptAllCssModulesPluginHooks(compilation, tracer);
 			}
 		);
 
@@ -275,7 +311,7 @@ class ProfilingPlugin {
 			},
 			(stats, callback) => {
 				if (compiler.watchMode) return callback();
-				tracer.profiler.stopProfiling().then(parsedResults => {
+				tracer.profiler.stopProfiling().then((parsedResults) => {
 					if (parsedResults === undefined) {
 						tracer.profiler.destroy();
 						tracer.end(callback);
@@ -334,15 +370,18 @@ class ProfilingPlugin {
 	}
 }
 
+/** @typedef {Record<string, Hook<EXPECTED_ANY, EXPECTED_ANY> | FakeHook<EXPECTED_ANY> | HookMap<EXPECTED_ANY>>} Hooks */
+
 /**
- * @param {any} instance instance
+ * @param {EXPECTED_OBJECT & { hooks?: Hooks }} instance instance
  * @param {Trace} tracer tracer
  * @param {string} logLabel log label
  */
 const interceptAllHooksFor = (instance, tracer, logLabel) => {
 	if (Reflect.has(instance, "hooks")) {
-		for (const hookName of Object.keys(instance.hooks)) {
-			const hook = instance.hooks[hookName];
+		const hooks = /** @type {Hooks} */ (instance.hooks);
+		for (const hookName of Object.keys(hooks)) {
+			const hook = hooks[hookName];
 			if (hook && !hook._fakeHook) {
 				hook.intercept(makeInterceptorFor(logLabel, tracer)(hookName));
 			}
@@ -356,23 +395,42 @@ const interceptAllHooksFor = (instance, tracer, logLabel) => {
  */
 const interceptAllParserHooks = (moduleFactory, tracer) => {
 	const moduleTypes = [
-		JAVASCRIPT_MODULE_TYPE_AUTO,
-		JAVASCRIPT_MODULE_TYPE_DYNAMIC,
-		JAVASCRIPT_MODULE_TYPE_ESM,
+		...JAVASCRIPT_MODULES,
 		JSON_MODULE_TYPE,
-		WEBASSEMBLY_MODULE_TYPE_ASYNC,
-		WEBASSEMBLY_MODULE_TYPE_SYNC
+		...WEBASSEMBLY_MODULES,
+		...CSS_MODULES
 	];
 
 	for (const moduleType of moduleTypes) {
 		moduleFactory.hooks.parser
 			.for(moduleType)
-			.tap(PLUGIN_NAME, (parser, parserOpts) => {
+			.tap(PLUGIN_NAME, (parser, _parserOpts) => {
 				interceptAllHooksFor(parser, tracer, "Parser");
 			});
 	}
 };
 
+/**
+ * @param {NormalModuleFactory} moduleFactory normal module factory
+ * @param {Trace} tracer tracer
+ */
+const interceptAllGeneratorHooks = (moduleFactory, tracer) => {
+	const moduleTypes = [
+		...JAVASCRIPT_MODULES,
+		JSON_MODULE_TYPE,
+		...WEBASSEMBLY_MODULES,
+		...CSS_MODULES
+	];
+
+	for (const moduleType of moduleTypes) {
+		moduleFactory.hooks.generator
+			.for(moduleType)
+			.tap(PLUGIN_NAME, (parser, _parserOpts) => {
+				interceptAllHooksFor(parser, tracer, "Generator");
+			});
+	}
+};
+
 /**
  * @param {Compilation} compilation compilation
  * @param {Trace} tracer tracer
@@ -391,35 +449,53 @@ const interceptAllJavascriptModulesPluginHooks = (compilation, tracer) => {
 };
 
 /**
+ * @param {Compilation} compilation compilation
+ * @param {Trace} tracer tracer
+ */
+const interceptAllCssModulesPluginHooks = (compilation, tracer) => {
+	interceptAllHooksFor(
+		{
+			hooks: require("../css/CssModulesPlugin").getCompilationHooks(compilation)
+		},
+		tracer,
+		"CssModulesPlugin"
+	);
+};
+
+/** @typedef {(...args: EXPECTED_ANY[]) => EXPECTED_ANY | Promise<(...args: EXPECTED_ANY[]) => EXPECTED_ANY>} PluginFunction */
+
+/**
+ * @template T
  * @param {string} instance instance
  * @param {Trace} tracer tracer
- * @returns {TODO} interceptor
+ * @returns {(hookName: string) => HookInterceptor<EXPECTED_ANY, EXPECTED_ANY>} interceptor
  */
-const makeInterceptorFor = (instance, tracer) => hookName => ({
-	register: tapInfo => {
-		const { name, type, fn } = tapInfo;
+const makeInterceptorFor = (instance, tracer) => (hookName) => ({
+	/**
+	 * @param {FullTap} tapInfo tap info
+	 * @returns {FullTap} modified full tap
+	 */
+	register: (tapInfo) => {
+		const { name, type, fn: internalFn } = tapInfo;
 		const newFn =
 			// Don't tap our own hooks to ensure stream can close cleanly
 			name === PLUGIN_NAME
-				? fn
+				? internalFn
 				: makeNewProfiledTapFn(hookName, tracer, {
 						name,
 						type,
-						fn
+						fn: /** @type {PluginFunction} */ (internalFn)
 					});
 		return { ...tapInfo, fn: newFn };
 	}
 });
 
-// TODO improve typing
-/** @typedef {(...args: TODO[]) => void | Promise<TODO>} PluginFunction */
-
 /**
  * @param {string} hookName Name of the hook to profile.
  * @param {Trace} tracer The trace object.
  * @param {object} options Options for the profiled fn.
  * @param {string} options.name Plugin name
- * @param {string} options.type Plugin type (sync | async | promise)
+ * @param {"sync" | "async" | "promise"} options.type Plugin type (sync | async | promise)
  * @param {PluginFunction} options.fn Plugin function
  * @returns {PluginFunction} Chainable hooked function.
  */
@@ -435,8 +511,10 @@ const makeNewProfiledTapFn = (hookName, tracer, { name, type, fn }) => {
 					id,
 					cat: defaultCategory
 				});
-				const promise = /** @type {Promise<*>} */ (fn(...args));
-				return promise.then(r => {
+				const promise =
+					/** @type {Promise<(...args: EXPECTED_ANY[]) => EXPECTED_ANY>} */
+					(fn(...args));
+				return promise.then((r) => {
 					tracer.trace.end({
 						name,
 						id,
@@ -454,14 +532,20 @@ const makeNewProfiledTapFn = (hookName, tracer, { name, type, fn }) => {
 					cat: defaultCategory
 				});
 				const callback = args.pop();
-				fn(...args, (...r) => {
-					tracer.trace.end({
-						name,
-						id,
-						cat: defaultCategory
-					});
-					callback(...r);
-				});
+				fn(
+					...args,
+					/**
+					 * @param {...EXPECTED_ANY[]} r result
+					 */
+					(...r) => {
+						tracer.trace.end({
+							name,
+							id,
+							cat: defaultCategory
+						});
+						callback(...r);
+					}
+				);
 			};
 		case "sync":
 			return (...args) => {
@@ -496,7 +580,7 @@ const makeNewProfiledTapFn = (hookName, tracer, { name, type, fn }) => {
 				return r;
 			};
 		default:
-			break;
+			return fn;
 	}
 };
 

package/lib/dependencies/AMDDefineDependencyParserPlugin.js

@@ -24,19 +24,19 @@ const { addLocalModule, getLocalModule } = require("./LocalModulesHelpers");
 /** @typedef {import("estree").Literal} Literal */
 /** @typedef {import("estree").MemberExpression} MemberExpression */
 /** @typedef {import("estree").ObjectExpression} ObjectExpression */
-/** @typedef {import("estree").SimpleCallExpression} SimpleCallExpression */
 /** @typedef {import("estree").SpreadElement} SpreadElement */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").ExportedVariableInfo} ExportedVariableInfo */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
 /**
  * @param {Expression | SpreadElement} expr expression
  * @returns {expr is CallExpression} true if it's a bound function expression
  */
-const isBoundFunctionExpression = expr => {
+const isBoundFunctionExpression = (expr) => {
 	if (expr.type !== "CallExpression") return false;
 	if (expr.callee.type !== "MemberExpression") return false;
 	if (expr.callee.computed) return false;
@@ -52,7 +52,7 @@ const isBoundFunctionExpression = expr => {
  * @param {Expression | SpreadElement} expr expression
  * @returns {expr is FunctionExpression | ArrowFunctionExpression} true when unbound function expression
  */
-const isUnboundFunctionExpression = expr => {
+const isUnboundFunctionExpression = (expr) => {
 	if (expr.type === "FunctionExpression") return true;
 	if (expr.type === "ArrowFunctionExpression") return true;
 	return false;
@@ -62,12 +62,16 @@ const isUnboundFunctionExpression = expr => {
  * @param {Expression | SpreadElement} expr expression
  * @returns {expr is FunctionExpression | ArrowFunctionExpression | CallExpression} true when callable
  */
-const isCallable = expr => {
+const isCallable = (expr) => {
 	if (isUnboundFunctionExpression(expr)) return true;
 	if (isBoundFunctionExpression(expr)) return true;
 	return false;
 };
 
+/** @typedef {Record<number, string>} Identifiers */
+
+const PLUGIN_NAME = "AMDDefineDependencyParserPlugin";
+
 class AMDDefineDependencyParserPlugin {
 	/**
 	 * @param {JavascriptParserOptions} options parserOptions
@@ -83,17 +87,14 @@ class AMDDefineDependencyParserPlugin {
 	apply(parser) {
 		parser.hooks.call
 			.for("define")
-			.tap(
-				"AMDDefineDependencyParserPlugin",
-				this.processCallDefine.bind(this, parser)
-			);
+			.tap(PLUGIN_NAME, this.processCallDefine.bind(this, parser));
 	}
 
 	/**
 	 * @param {JavascriptParser} parser the parser
 	 * @param {CallExpression} expr call expression
 	 * @param {BasicEvaluatedExpression} param param
-	 * @param {Record<number, string>} identifiers identifiers
+	 * @param {Identifiers} identifiers identifiers
 	 * @param {string=} namedModule named module
 	 * @returns {boolean | undefined} result
 	 */
@@ -106,10 +107,11 @@ class AMDDefineDependencyParserPlugin {
 					["require", "module", "exports"].includes(
 						/** @type {string} */ (item.string)
 					)
-				)
-					identifiers[/** @type {number} */ (idx)] = /** @type {string} */ (
-						item.string
-					);
+				) {
+					identifiers[idx] =
+						/** @type {string} */
+						(item.string);
+				}
 				const result = this.processItem(parser, expr, item, namedModule);
 				if (result === undefined) {
 					this.processContext(parser, expr, item);
@@ -248,7 +250,7 @@ class AMDDefineDependencyParserPlugin {
 	 * @returns {boolean | undefined} result
 	 */
 	processCallDefine(parser, expr) {
-		/** @type {TODO} */
+		/** @type {Expression | SpreadElement | undefined} */
 		let array;
 		/** @type {FunctionExpression | ArrowFunctionExpression | CallExpression | Identifier | undefined} */
 		let fn;
@@ -347,9 +349,10 @@ class AMDDefineDependencyParserPlugin {
 				}
 			}
 		}
+		/** @type {Map<string, ExportedVariableInfo>} */
 		const fnRenames = new Map();
 		if (array) {
-			/** @type {Record<number, string>} */
+			/** @type {Identifiers} */
 			const identifiers = {};
 			const param = parser.evaluateExpression(array);
 			const result = this.processArray(
@@ -385,7 +388,7 @@ class AMDDefineDependencyParserPlugin {
 		let inTry;
 		if (fn && isUnboundFunctionExpression(fn)) {
 			inTry = parser.scope.inTry;
-			parser.inScope(fnParams, () => {
+			parser.inScope(/** @type {Identifier[]} */ (fnParams), () => {
 				for (const [name, varInfo] of fnRenames) {
 					parser.setVariable(name, varInfo);
 				}
@@ -410,30 +413,28 @@ class AMDDefineDependencyParserPlugin {
 			parser.inScope(
 				/** @type {Identifier[]} */
 				(object.params).filter(
-					i => !["require", "module", "exports"].includes(i.name)
+					(i) => !["require", "module", "exports"].includes(i.name)
 				),
 				() => {
 					for (const [name, varInfo] of fnRenames) {
 						parser.setVariable(name, varInfo);
 					}
 					parser.scope.inTry = /** @type {boolean} */ (inTry);
-
-					if (object.body.type === "BlockStatement") {
-						parser.detectMode(object.body.body);
-						const prev = parser.prevStatement;
-						parser.preWalkStatement(object.body);
-						parser.prevStatement = prev;
-						parser.walkStatement(object.body);
-					} else {
-						parser.walkExpression(object.body);
-					}
+					parser.detectMode(object.body.body);
+					const prev = parser.prevStatement;
+					parser.preWalkStatement(object.body);
+					parser.prevStatement = prev;
+					parser.walkStatement(object.body);
 				}
 			);
 			if (fn.arguments) {
 				parser.walkExpressions(fn.arguments);
 			}
 		} else if (fn || obj) {
-			parser.walkExpression(fn || obj);
+			parser.walkExpression(
+				/** @type {FunctionExpression | ArrowFunctionExpression | CallExpression | ObjectExpression | Identifier} */
+				(fn || obj)
+			);
 		}
 
 		const dep = this.newDefineDependency(

package/lib/dependencies/AMDPlugin.js

@@ -32,18 +32,21 @@ const ConstDependency = require("./ConstDependency");
 const LocalModuleDependency = require("./LocalModuleDependency");
 const UnsupportedDependency = require("./UnsupportedDependency");
 
+/** @typedef {import("../../declarations/WebpackOptions").Amd} Amd */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../javascript/BasicEvaluatedExpression").GetMembers} GetMembers */
 
 const PLUGIN_NAME = "AMDPlugin";
 
+/** @typedef {Exclude<Amd, false>} AmdOptions */
+
 class AMDPlugin {
 	/**
-	 * @param {Record<string, any>} amdOptions the AMD options
+	 * @param {AmdOptions} amdOptions the AMD options
 	 */
 	constructor(amdOptions) {
 		this.amdOptions = amdOptions;
@@ -116,13 +119,13 @@ class AMDPlugin {
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.amdDefine)
-					.tap(PLUGIN_NAME, (chunk, set) => {
+					.tap(PLUGIN_NAME, (chunk, _set) => {
 						compilation.addRuntimeModule(chunk, new AMDDefineRuntimeModule());
 					});
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.amdOptions)
-					.tap(PLUGIN_NAME, (chunk, set) => {
+					.tap(PLUGIN_NAME, (chunk, _set) => {
 						compilation.addRuntimeModule(
 							chunk,
 							new AMDOptionsRuntimeModule(amdOptions)
@@ -140,7 +143,7 @@ class AMDPlugin {
 					/**
 					 * @param {string} optionExpr option expression
 					 * @param {string} rootName root name
-					 * @param {function(): TODO} getMembers callback
+					 * @param {GetMembers} getMembers callback
 					 */
 					const tapOptionsHooks = (optionExpr, rootName, getMembers) => {
 						parser.hooks.expression
@@ -153,9 +156,13 @@ class AMDPlugin {
 							);
 						parser.hooks.evaluateIdentifier
 							.for(optionExpr)
-							.tap(
-								PLUGIN_NAME,
-								evaluateToIdentifier(optionExpr, rootName, getMembers, true)
+							.tap(PLUGIN_NAME, (expr) =>
+								evaluateToIdentifier(
+									optionExpr,
+									rootName,
+									getMembers,
+									true
+								)(expr)
 							);
 						parser.hooks.evaluateTypeof
 							.for(optionExpr)
@@ -173,7 +180,7 @@ class AMDPlugin {
 					);
 					new AMDDefineDependencyParserPlugin(parserOptions).apply(parser);
 
-					tapOptionsHooks("define.amd", "define", () => "amd");
+					tapOptionsHooks("define.amd", "define", () => ["amd"]);
 					tapOptionsHooks("require.amd", "require", () => ["amd"]);
 					tapOptionsHooks(
 						"__webpack_amd_options__",
@@ -181,7 +188,7 @@ class AMDPlugin {
 						() => []
 					);
 
-					parser.hooks.expression.for("define").tap(PLUGIN_NAME, expr => {
+					parser.hooks.expression.for("define").tap(PLUGIN_NAME, (expr) => {
 						const dep = new ConstDependency(
 							RuntimeGlobals.amdDefine,
 							/** @type {Range} */ (expr.range),
@@ -201,7 +208,7 @@ class AMDPlugin {
 						.for("define")
 						.tap(PLUGIN_NAME, evaluateToString("function"));
 					parser.hooks.canRename.for("define").tap(PLUGIN_NAME, approve);
-					parser.hooks.rename.for("define").tap(PLUGIN_NAME, expr => {
+					parser.hooks.rename.for("define").tap(PLUGIN_NAME, (expr) => {
 						const dep = new ConstDependency(
 							RuntimeGlobals.amdDefine,
 							/** @type {Range} */ (expr.range),

package/lib/dependencies/AMDRequireArrayDependency.js

@@ -7,6 +7,7 @@
 
 const DependencyTemplate = require("../DependencyTemplate");
 const makeSerializable = require("../util/makeSerializable");
+const LocalModuleDependency = require("./LocalModuleDependency");
 const NullDependency = require("./NullDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
@@ -16,7 +17,6 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./AMDRequireItemDependency")} AMDRequireItemDependency */
-/** @typedef {import("./LocalModuleDependency")} LocalModuleDependency */
 
 class AMDRequireArrayDependency extends NullDependency {
 	/**
@@ -89,14 +89,14 @@ AMDRequireArrayDependency.Template = class AMDRequireArrayDependencyTemplate ext
 	 * @returns {string} content
 	 */
 	getContent(dep, templateContext) {
-		const requires = dep.depsArray.map(dependency =>
+		const requires = dep.depsArray.map((dependency) =>
 			this.contentForDependency(dependency, templateContext)
 		);
 		return `[${requires.join(", ")}]`;
 	}
 
 	/**
-	 * @param {TODO} dep the dependency for which the template should be applied
+	 * @param {string | LocalModuleDependency | AMDRequireItemDependency} dep the dependency for which the template should be applied
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {string} content
 	 */
@@ -108,9 +108,10 @@ AMDRequireArrayDependency.Template = class AMDRequireArrayDependencyTemplate ext
 			return dep;
 		}
 
-		if (dep.localModule) {
+		if (dep instanceof LocalModuleDependency) {
 			return dep.localModule.variableName();
 		}
+
 		return runtimeTemplate.moduleExports({
 			module: moduleGraph.getModule(dep),
 			chunkGraph,

package/lib/dependencies/AMDRequireContextDependency.js

@@ -11,10 +11,11 @@ const ContextDependency = require("./ContextDependency");
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
 
 class AMDRequireContextDependency extends ContextDependency {
 	/**
-	 * @param {TODO} options options
+	 * @param {ContextDependencyOptions} options options
 	 * @param {Range} range range
 	 * @param {Range} valueRange value range
 	 */