webpack 5.97.1 → 5.99.0

package/lib/debug/ProfilingPlugin.js

@@ -6,22 +6,23 @@
 
 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,
+	JAVASCRIPT_MODULES,
+	CSS_MODULES,
+	WEBASSEMBLY_MODULES,
 	JSON_MODULE_TYPE
 } = require("../ModuleTypeConstants");
 const createSchemaValidation = require("../util/create-schema-validation");
 const { dirname, mkdirpSync } = require("../util/fs");
 
+/** @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("../Parser")} Parser */
+/** @typedef {import("../ResolverFactory")} ResolverFactory */
 /** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 
 /** @typedef {TODO} Inspector */
@@ -42,6 +43,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");
 }
 
@@ -86,19 +88,27 @@ class Profiler {
 
 	/**
 	 * @param {string} method method name
-	 * @param {object} [params] params
+	 * @param {Record<string, EXPECTED_ANY>} [params] params
 	 * @returns {Promise<TODO>} Promise for the result
 	 */
 	sendCommand(method, params) {
 		if (this.hasSession()) {
 			return new Promise((res, rej) => {
-				this.session.post(method, params, (err, params) => {
-					if (err !== null) {
-						rej(err);
-					} else {
-						res(params);
+				this.session.post(
+					method,
+					params,
+					/**
+					 * @param {Error | null} err error
+					 * @param {object} params params
+					 */
+					(err, params) => {
+						if (err !== null) {
+							rej(err);
+						} else {
+							res(params);
+						}
 					}
-				});
+				);
 			});
 		}
 		return Promise.resolve();
@@ -140,7 +150,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
  */
 
 /**
@@ -242,7 +252,11 @@ 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));
 			}
@@ -263,7 +277,9 @@ class ProfilingPlugin {
 					"Context Module Factory"
 				);
 				interceptAllParserHooks(normalModuleFactory, tracer);
+				interceptAllGeneratorHooks(normalModuleFactory, tracer);
 				interceptAllJavascriptModulesPluginHooks(compilation, tracer);
+				interceptAllCssModulesPluginHooks(compilation, tracer);
 			}
 		);
 
@@ -335,7 +351,7 @@ class ProfilingPlugin {
 }
 
 /**
- * @param {any} instance instance
+ * @param {EXPECTED_ANY & { hooks: TODO }} instance instance
  * @param {Trace} tracer tracer
  * @param {string} logLabel log label
  */
@@ -356,12 +372,10 @@ 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) {
@@ -373,6 +387,27 @@ const interceptAllParserHooks = (moduleFactory, tracer) => {
 	}
 };
 
+/**
+ * @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
@@ -390,36 +425,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 */
+
 /**
  * @param {string} instance instance
  * @param {Trace} tracer tracer
- * @returns {TODO} interceptor
+ * @returns {(hookName: string) => TODO} interceptor
  */
 const makeInterceptorFor = (instance, tracer) => hookName => ({
+	/**
+	 * @param {FullTap} tapInfo tap info
+	 * @returns {FullTap} modified full tap
+	 */
 	register: tapInfo => {
-		const { name, type, fn } = 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,7 +487,9 @@ const makeNewProfiledTapFn = (hookName, tracer, { name, type, fn }) => {
 					id,
 					cat: defaultCategory
 				});
-				const promise = /** @type {Promise<*>} */ (fn(...args));
+				const promise =
+					/** @type {Promise<(...args: EXPECTED_ANY[]) => EXPECTED_ANY>} */
+					(fn(...args));
 				return promise.then(r => {
 					tracer.trace.end({
 						name,
@@ -454,14 +508,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 +556,7 @@ const makeNewProfiledTapFn = (hookName, tracer, { name, type, fn }) => {
 				return r;
 			};
 		default:
-			break;
+			return fn;
 	}
 };
 

package/lib/dependencies/AMDDefineDependencyParserPlugin.js

@@ -248,7 +248,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;
@@ -385,7 +385,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);
 				}
@@ -425,7 +425,10 @@ class AMDDefineDependencyParserPlugin {
 						parser.prevStatement = prev;
 						parser.walkStatement(object.body);
 					} else {
-						parser.walkExpression(object.body);
+						parser.walkExpression(
+							/** @type {TODO} */
+							(object.body)
+						);
 					}
 				}
 			);
@@ -433,7 +436,10 @@ class AMDDefineDependencyParserPlugin {
 				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,6 +32,7 @@ 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 */
@@ -41,9 +42,11 @@ const UnsupportedDependency = require("./UnsupportedDependency");
 
 const PLUGIN_NAME = "AMDPlugin";
 
+/** @typedef {Record<string, TODO>} AmdOptions */
+
 class AMDPlugin {
 	/**
-	 * @param {Record<string, any>} amdOptions the AMD options
+	 * @param {AmdOptions} amdOptions the AMD options
 	 */
 	constructor(amdOptions) {
 		this.amdOptions = amdOptions;
@@ -140,7 +143,7 @@ class AMDPlugin {
 					/**
 					 * @param {string} optionExpr option expression
 					 * @param {string} rootName root name
-					 * @param {function(): TODO} getMembers callback
+					 * @param {() => TODO} getMembers callback
 					 */
 					const tapOptionsHooks = (optionExpr, rootName, getMembers) => {
 						parser.hooks.expression

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 {
 	/**
@@ -96,7 +96,7 @@ AMDRequireArrayDependency.Template = class AMDRequireArrayDependencyTemplate ext
 	}
 
 	/**
-	 * @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
 	 */

package/lib/dependencies/AMDRequireDependenciesBlockParserPlugin.js

@@ -104,7 +104,7 @@ class AMDRequireDependenciesBlockParserPlugin {
 		} else if (param.isConstArray()) {
 			/** @type {(string | LocalModuleDependency | AMDRequireItemDependency)[]} */
 			const deps = [];
-			for (const request of /** @type {any[]} */ (param.array)) {
+			for (const request of /** @type {EXPECTED_ANY[]} */ (param.array)) {
 				let dep;
 				let localModule;
 				if (request === "require") {
@@ -158,20 +158,27 @@ class AMDRequireDependenciesBlockParserPlugin {
 			if (param.string === "require") {
 				dep = new ConstDependency(
 					RuntimeGlobals.require,
-					/** @type {TODO} */ (param.string),
+					/** @type {TODO} */
+					(param.string),
 					[RuntimeGlobals.require]
 				);
 			} else if (param.string === "module") {
 				dep = new ConstDependency(
-					/** @type {BuildInfo} */
-					(parser.state.module.buildInfo).moduleArgument,
+					/** @type {string} */
+					(
+						/** @type {BuildInfo} */
+						(parser.state.module.buildInfo).moduleArgument
+					),
 					/** @type {Range} */ (param.range),
 					[RuntimeGlobals.module]
 				);
 			} else if (param.string === "exports") {
 				dep = new ConstDependency(
-					/** @type {BuildInfo} */
-					(parser.state.module.buildInfo).exportsArgument,
+					/** @type {string} */
+					(
+						/** @type {BuildInfo} */
+						(parser.state.module.buildInfo).exportsArgument
+					),
 					/** @type {Range} */ (param.range),
 					[RuntimeGlobals.exports]
 				);
@@ -208,7 +215,8 @@ class AMDRequireDependenciesBlockParserPlugin {
 	processContext(parser, expr, param) {
 		const dep = ContextDependencyHelpers.create(
 			AMDRequireContextDependency,
-			/** @type {Range} */ (param.range),
+			/** @type {Range} */
+			(param.range),
 			param,
 			expr,
 			this.options,

package/lib/dependencies/AMDRuntimeModules.js

@@ -8,6 +8,8 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
+/** @typedef {import("./AMDPlugin").AmdOptions} AmdOptions */
+
 class AMDDefineRuntimeModule extends RuntimeModule {
 	constructor() {
 		super("amd define");
@@ -27,7 +29,7 @@ class AMDDefineRuntimeModule extends RuntimeModule {
 
 class AMDOptionsRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {Record<string, boolean | number | string>} options the AMD options
+	 * @param {AmdOptions} options the AMD options
 	 */
 	constructor(options) {
 		super("amd options");

package/lib/dependencies/CommonJsExportRequireDependency.js

@@ -71,9 +71,7 @@ class CommonJsExportRequireDependency extends ModuleDependency {
 	 * @returns {string[]} the imported id
 	 */
 	getIds(moduleGraph) {
-		return (
-			/** @type {TODO} */ (moduleGraph.getMeta(this))[idsSymbol] || this.ids
-		);
+		return moduleGraph.getMeta(this)[idsSymbol] || this.ids;
 	}
 
 	/**
@@ -82,7 +80,7 @@ class CommonJsExportRequireDependency extends ModuleDependency {
 	 * @returns {void}
 	 */
 	setIds(moduleGraph, ids) {
-		/** @type {TODO} */ (moduleGraph.getMeta(this))[idsSymbol] = ids;
+		moduleGraph.getMeta(this)[idsSymbol] = ids;
 	}
 
 	/**
@@ -190,7 +188,8 @@ class CommonJsExportRequireDependency extends ModuleDependency {
 		if (reexportInfo) {
 			return {
 				exports: Array.from(
-					/** @type {TODO} */ (reexportInfo).exports,
+					/** @type {Set<string>} */
+					(reexportInfo.exports),
 					name => ({
 						name,
 						from,

package/lib/dependencies/CommonJsExportsParserPlugin.js

@@ -44,16 +44,16 @@ const ModuleDecoratorDependency = require("./ModuleDecoratorDependency");
  * exports.foo = void 0;
  * exports.foo = "bar";
  * ```
- * @param {TODO} expr expression
+ * @param {Expression} expr expression
  * @returns {Expression | undefined} returns the value of property descriptor
  */
 const getValueOfPropertyDescription = expr => {
 	if (expr.type !== "ObjectExpression") return;
 	for (const property of expr.properties) {
-		if (property.computed) continue;
+		if (property.type === "SpreadElement" || property.computed) continue;
 		const key = property.key;
 		if (key.type !== "Identifier" || key.name !== "value") continue;
-		return property.value;
+		return /** @type {Expression} */ (property.value);
 	}
 };
 

package/lib/dependencies/CommonJsImportsParserPlugin.js

@@ -11,6 +11,7 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const WebpackError = require("../WebpackError");
 const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
+const { VariableInfo } = require("../javascript/JavascriptParser");
 const {
 	evaluateToIdentifier,
 	evaluateToString,
@@ -201,9 +202,9 @@ class CommonJsImportsParserPlugin {
 		const requireAsExpressionHandler = expr => {
 			const dep = new CommonJsRequireContextDependency(
 				{
-					request: options.unknownContextRequest,
-					recursive: options.unknownContextRecursive,
-					regExp: options.unknownContextRegExp,
+					request: /** @type {string} */ (options.unknownContextRequest),
+					recursive: /** @type {boolean} */ (options.unknownContextRecursive),
+					regExp: /** @type {TODO} */ (options.unknownContextRegExp),
 					mode: "sync"
 				},
 				/** @type {Range} */ (expr.range),
@@ -464,6 +465,36 @@ class CommonJsImportsParserPlugin {
 		 * @returns {boolean | void} true when handled
 		 */
 		const processResolve = (expr, weak) => {
+			if (!weak && options.commonjsMagicComments) {
+				const { options: requireOptions, errors: commentErrors } =
+					parser.parseCommentOptions(/** @type {Range} */ (expr.range));
+
+				if (commentErrors) {
+					for (const e of commentErrors) {
+						const { comment } = e;
+						parser.state.module.addWarning(
+							new CommentCompilationWarning(
+								`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+								/** @type {DependencyLocation} */ (comment.loc)
+							)
+						);
+					}
+				}
+				if (requireOptions && requireOptions.webpackIgnore !== undefined) {
+					if (typeof requireOptions.webpackIgnore !== "boolean") {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					} else if (requireOptions.webpackIgnore) {
+						// Do not instrument `require()` if `webpackIgnore` is `true`
+						return true;
+					}
+				}
+			}
+
 			if (expr.arguments.length !== 1) return;
 			const param = parser.evaluateExpression(expr.arguments[0]);
 			if (param.isConditional()) {
@@ -699,11 +730,11 @@ class CommonJsImportsParserPlugin {
 					declarator.init.callee.type !== "Identifier"
 				)
 					return;
-				const variableInfo =
-					/** @type {TODO} */
-					(parser.getVariableInfo(declarator.init.callee.name));
+				const variableInfo = parser.getVariableInfo(
+					declarator.init.callee.name
+				);
 				if (
-					variableInfo &&
+					variableInfo instanceof VariableInfo &&
 					variableInfo.tagInfo &&
 					variableInfo.tagInfo.tag === createRequireSpecifierTag
 				) {

package/lib/dependencies/CommonJsRequireContextDependency.js

@@ -12,10 +12,11 @@ const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTempl
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
 
 class CommonJsRequireContextDependency extends ContextDependency {
 	/**
-	 * @param {TODO} options options for the context module
+	 * @param {ContextDependencyOptions} options options for the context module
 	 * @param {Range} range location in source code
 	 * @param {Range | undefined} valueRange location of the require call
 	 * @param {boolean | string } inShorthand true or name

package/lib/dependencies/ContextDependencyHelpers.js

@@ -7,7 +7,7 @@
 
 const { parseResource } = require("../util/identifier");
 
-/** @typedef {import("estree").Node} EsTreeNode */
+/** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
@@ -48,11 +48,11 @@ const splitContextFromPrefix = prefix => {
  * @param {ContextDependencyConstructor} Dep the Dependency class
  * @param {Range} range source range
  * @param {BasicEvaluatedExpression} param context param
- * @param {EsTreeNode} expr expr
+ * @param {Expression} expr expr
  * @param {Pick<JavascriptParserOptions, `${"expr"|"wrapped"}Context${"Critical"|"Recursive"|"RegExp"}` | "exprContextRequest">} options options for context creation
  * @param {PartialContextDependencyOptions} contextOptions options for the ContextModule
  * @param {JavascriptParser} parser the parser
- * @param {...any} depArgs depArgs
+ * @param {...EXPECTED_ANY} depArgs depArgs
  * @returns {ContextDependency} the created Dependency
  */
 module.exports.create = (
@@ -164,7 +164,10 @@ module.exports.create = (
 				});
 			} else {
 				// Expression
-				parser.walkExpression(part.expression);
+				parser.walkExpression(
+					/** @type {Expression} */
+					(part.expression)
+				);
 			}
 		}
 
@@ -233,7 +236,11 @@ module.exports.create = (
 
 		if (parser && param.wrappedInnerExpressions) {
 			for (const part of param.wrappedInnerExpressions) {
-				if (part.expression) parser.walkExpression(part.expression);
+				if (part.expression)
+					parser.walkExpression(
+						/** @type {Expression} */
+						(part.expression)
+					);
 			}
 		}
 
@@ -256,7 +263,7 @@ module.exports.create = (
 		options.exprContextCritical &&
 		"the request of a dependency is an expression";
 
-	parser.walkExpression(param.expression);
+	parser.walkExpression(/** @type {Expression} */ (param.expression));
 
 	return dep;
 };