webpack 5.97.1 → 5.104.1

package/lib/dependencies/JsonExportsDependency.js

@@ -8,52 +8,76 @@
 const makeSerializable = require("../util/makeSerializable");
 const NullDependency = require("./NullDependency");
 
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Dependency").ExportSpec} ExportSpec */
 /** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../json/JsonData")} JsonData */
-/** @typedef {import("../json/JsonData").RawJsonData} RawJsonData */
+/** @typedef {import("../json/JsonData").JsonValue} JsonValue */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 
 /**
- * @param {RawJsonData} data data
- * @returns {TODO} value
+ * @callback GetExportsFromDataFn
+ * @param {JsonValue} data raw json data
+ * @param {number=} curDepth current depth
+ * @returns {ExportSpec[] | null} export spec or nothing
  */
-const getExportsFromData = data => {
-	if (data && typeof data === "object") {
-		if (Array.isArray(data)) {
-			return data.length < 100
-				? data.map((item, idx) => ({
-						name: `${idx}`,
-						canMangle: true,
-						exports: getExportsFromData(item)
-					}))
-				: undefined;
+
+/**
+ * @param {number} exportsDepth exportsDepth
+ * @returns {GetExportsFromDataFn} value
+ */
+const getExportsWithDepth = (exportsDepth) =>
+	/** @type {GetExportsFromDataFn} */
+	function getExportsFromData(data, curDepth = 1) {
+		if (curDepth > exportsDepth) {
+			return null;
 		}
-		const exports = [];
-		for (const key of Object.keys(data)) {
-			exports.push({
-				name: key,
-				canMangle: true,
-				exports: getExportsFromData(data[key])
-			});
+
+		if (data && typeof data === "object") {
+			if (Array.isArray(data)) {
+				return data.length < 100
+					? data.map((item, idx) => ({
+							name: `${idx}`,
+							canMangle: true,
+							exports: getExportsFromData(item, curDepth + 1) || undefined
+						}))
+					: null;
+			}
+
+			/** @type {ExportSpec[]} */
+			const exports = [];
+
+			for (const key of Object.keys(data)) {
+				exports.push({
+					name: key,
+					canMangle: true,
+					exports:
+						getExportsFromData(
+							/** @type {JsonValue} */
+							(data[key]),
+							curDepth + 1
+						) || undefined
+				});
+			}
+
+			return exports;
 		}
-		return exports;
-	}
-	return undefined;
-};
+
+		return null;
+	};
 
 class JsonExportsDependency extends NullDependency {
 	/**
 	 * @param {JsonData} data json data
+	 * @param {number} exportsDepth the depth of json exports to analyze
 	 */
-	constructor(data) {
+	constructor(data, exportsDepth) {
 		super();
 		this.data = data;
+		this.exportsDepth = exportsDepth;
 	}
 
 	get type() {
@@ -67,8 +91,8 @@ class JsonExportsDependency extends NullDependency {
 	 */
 	getExports(moduleGraph) {
 		return {
-			exports: getExportsFromData(
-				this.data && /** @type {RawJsonData} */ (this.data.get())
+			exports: getExportsWithDepth(this.exportsDepth)(
+				this.data && /** @type {JsonValue} */ (this.data.get())
 			),
 			dependencies: undefined
 		};
@@ -90,6 +114,7 @@ class JsonExportsDependency extends NullDependency {
 	serialize(context) {
 		const { write } = context;
 		write(this.data);
+		write(this.exportsDepth);
 		super.serialize(context);
 	}
 
@@ -99,6 +124,7 @@ class JsonExportsDependency extends NullDependency {
 	deserialize(context) {
 		const { read } = context;
 		this.data = read();
+		this.exportsDepth = read();
 		super.deserialize(context);
 	}
 }

package/lib/dependencies/LoaderDependency.js

@@ -9,9 +9,6 @@ const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 class LoaderDependency extends ModuleDependency {
 	/**

package/lib/dependencies/LoaderImportDependency.js

@@ -9,9 +9,6 @@ const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 class LoaderImportDependency extends ModuleDependency {
 	/**

package/lib/dependencies/LoaderPlugin.js

@@ -10,17 +10,18 @@ const LazySet = require("../util/LazySet");
 const LoaderDependency = require("./LoaderDependency");
 const LoaderImportDependency = require("./LoaderImportDependency");
 
-/** @typedef {import("../../declarations/LoaderContext").LoaderPluginLoaderContext} LoaderPluginLoaderContext */
-/** @typedef {import("../Compilation").DepConstructor} DepConstructor */
+/** @typedef {import("../Compilation").DependencyConstructor} DependencyConstructor */
+/** @typedef {import("../Compilation").ExecuteModuleExports} ExecuteModuleExports */
 /** @typedef {import("../Compilation").ExecuteModuleResult} ExecuteModuleResult */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").FileSystemDependencies} FileSystemDependencies */
 
 /**
  * @callback ImportModuleCallback
  * @param {(Error | null)=} err error object
- * @param {any=} exports exports of the evaluated module
+ * @param {ExecuteModuleExports=} exports exports of the evaluated module
+ * @returns {void}
  */
 
 /**
@@ -30,12 +31,9 @@ const LoaderImportDependency = require("./LoaderImportDependency");
  * @property {string=} baseUri target base uri
  */
 
-class LoaderPlugin {
-	/**
-	 * @param {object} options options
-	 */
-	constructor(options = {}) {}
+const PLUGIN_NAME = "LoaderPlugin";
 
+class LoaderPlugin {
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -43,7 +41,7 @@ class LoaderPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"LoaderPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					LoaderDependency,
@@ -56,18 +54,19 @@ class LoaderPlugin {
 			}
 		);
 
-		compiler.hooks.compilation.tap("LoaderPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			const moduleGraph = compilation.moduleGraph;
 			NormalModule.getCompilationHooks(compilation).loader.tap(
-				"LoaderPlugin",
-				loaderContext => {
+				PLUGIN_NAME,
+				(loaderContext) => {
 					loaderContext.loadModule = (request, callback) => {
 						const dep = new LoaderDependency(request);
 						dep.loc = {
 							name: request
 						};
 						const factory = compilation.dependencyFactories.get(
-							/** @type {DepConstructor} */ (dep.constructor)
+							/** @type {DependencyConstructor} */
+							(dep.constructor)
 						);
 						if (factory === undefined) {
 							return callback(
@@ -93,7 +92,7 @@ class LoaderPlugin {
 								context: loaderContext.context,
 								recursive: false
 							},
-							err => {
+							(err) => {
 								compilation.factorizeQueue.setContext(oldFactorizeQueueContext);
 								compilation.addModuleQueue.setContext(oldAddModuleQueueContext);
 								compilation.buildQueue.decreaseParallelism();
@@ -127,9 +126,13 @@ class LoaderPlugin {
 									map = moduleSource.map();
 									source = moduleSource.source();
 								}
+								/** @type {FileSystemDependencies} */
 								const fileDependencies = new LazySet();
+								/** @type {FileSystemDependencies} */
 								const contextDependencies = new LazySet();
+								/** @type {FileSystemDependencies} */
 								const missingDependencies = new LazySet();
+								/** @type {FileSystemDependencies} */
 								const buildDependencies = new LazySet();
 								referencedModule.addCacheDependencies(
 									fileDependencies,
@@ -150,12 +153,7 @@ class LoaderPlugin {
 								for (const d of buildDependencies) {
 									loaderContext.addBuildDependency(d);
 								}
-								return callback(
-									null,
-									source,
-									/** @type {object | null} */ (map),
-									referencedModule
-								);
+								return callback(null, source, map, referencedModule);
 							}
 						);
 					};
@@ -172,7 +170,8 @@ class LoaderPlugin {
 							name: request
 						};
 						const factory = compilation.dependencyFactories.get(
-							/** @type {DepConstructor} */ (dep.constructor)
+							/** @type {DependencyConstructor} */
+							(dep.constructor)
 						);
 						if (factory === undefined) {
 							return callback(
@@ -203,7 +202,7 @@ class LoaderPlugin {
 								connectOrigin: false,
 								checkCycle: true
 							},
-							err => {
+							(err) => {
 								compilation.factorizeQueue.setContext(oldFactorizeQueueContext);
 								compilation.addModuleQueue.setContext(oldAddModuleQueueContext);
 								compilation.buildQueue.decreaseParallelism();
@@ -271,8 +270,7 @@ class LoaderPlugin {
 						);
 					};
 
-					// eslint-disable-next-line no-warning-comments
-					// @ts-ignore Overloading doesn't work
+					// @ts-expect-error overloading doesn't work
 					loaderContext.importModule = (request, options, callback) => {
 						if (!callback) {
 							return new Promise((resolve, reject) => {
@@ -289,4 +287,5 @@ class LoaderPlugin {
 		});
 	}
 }
+
 module.exports = LoaderPlugin;

package/lib/dependencies/LocalModulesHelpers.js

@@ -7,7 +7,7 @@
 
 const LocalModule = require("./LocalModule");
 
-/** @typedef {import("../javascript/JavascriptParser").ParserState} ParserState */
+/** @typedef {import("../javascript/JavascriptParser").JavascriptParserState} JavascriptParserState */
 
 /**
  * @param {string} parent parent module
@@ -34,7 +34,7 @@ const lookup = (parent, mod) => {
 };
 
 /**
- * @param {ParserState} state parser state
+ * @param {JavascriptParserState} state parser state
  * @param {string} name name
  * @returns {LocalModule} local module
  */
@@ -48,9 +48,9 @@ module.exports.addLocalModule = (state, name) => {
 };
 
 /**
- * @param {ParserState} state parser state
+ * @param {JavascriptParserState} state parser state
  * @param {string} name name
- * @param {string} [namedModule] named module
+ * @param {string=} namedModule named module
  * @returns {LocalModule | null} local module or null
  */
 module.exports.getLocalModule = (state, name, namedModule) => {

package/lib/dependencies/ModuleDecoratorDependency.js

@@ -12,11 +12,9 @@ const makeSerializable = require("../util/makeSerializable");
 const NullDependency = require("./NullDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
@@ -57,7 +55,7 @@ class ModuleDecoratorDependency extends NullDependency {
 	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
 		return this.allowExportsAccess

package/lib/dependencies/ModuleDependency.js

@@ -7,27 +7,26 @@
 
 const Dependency = require("../Dependency");
 const DependencyTemplate = require("../DependencyTemplate");
-const RawModule = require("../RawModule");
 
 /** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
 class ModuleDependency extends Dependency {
 	/**
 	 * @param {string} request request path which needs resolving
+	 * @param {number=} sourceOrder source order
 	 */
-	constructor(request) {
+	constructor(request, sourceOrder) {
 		super();
 		this.request = request;
 		this.userRequest = request;
+		this.sourceOrder = sourceOrder;
+		/** @type {Range | undefined} */
 		this.range = undefined;
-		// TODO move it to subclasses and rename
-		// assertions must be serialized by subclasses that use it
-		/** @type {ImportAttributes | undefined} */
-		this.assertions = undefined;
 		this._context = undefined;
 	}
 
@@ -42,11 +41,7 @@ class ModuleDependency extends Dependency {
 	 * @returns {string | null} an identifier to merge equal requests
 	 */
 	getResourceIdentifier() {
-		let str = `context${this._context || ""}|module${this.request}`;
-		if (this.assertions !== undefined) {
-			str += JSON.stringify(this.assertions);
-		}
-		return str;
+		return `context${this._context || ""}|module${this.request}`;
 	}
 
 	/**
@@ -58,14 +53,18 @@ class ModuleDependency extends Dependency {
 
 	/**
 	 * @param {string} context context directory
-	 * @returns {Module | null} a module
+	 * @returns {Module} ignored module
 	 */
 	createIgnoredModule(context) {
-		return new RawModule(
+		const RawModule = require("../RawModule");
+
+		const module = new RawModule(
 			"/* (ignored) */",
 			`ignored|${context}|${this.request}`,
 			`${this.request} (ignored)`
 		);
+		module.factoryMeta = { sideEffectFree: true };
+		return module;
 	}
 
 	/**
@@ -77,6 +76,7 @@ class ModuleDependency extends Dependency {
 		write(this.userRequest);
 		write(this._context);
 		write(this.range);
+		write(this.sourceOrder);
 		super.serialize(context);
 	}
 
@@ -89,6 +89,7 @@ class ModuleDependency extends Dependency {
 		this.userRequest = read();
 		this._context = read();
 		this.range = read();
+		this.sourceOrder = read();
 		super.deserialize(context);
 	}
 }

package/lib/dependencies/ModuleDependencyTemplateAsRequireId.js

@@ -35,4 +35,5 @@ class ModuleDependencyTemplateAsRequireId extends ModuleDependency.Template {
 		source.replace(dep.range[0], dep.range[1] - 1, content);
 	}
 }
+
 module.exports = ModuleDependencyTemplateAsRequireId;

package/lib/dependencies/ModuleHotAcceptDependency.js

@@ -17,7 +17,7 @@ class ModuleHotAcceptDependency extends ModuleDependency {
 	 * @param {Range} range location in source code
 	 */
 	constructor(request, range) {
-		super(request);
+		super(request, Infinity);
 		this.range = range;
 		this.weak = true;
 	}

package/lib/dependencies/NullDependency.js

@@ -12,6 +12,8 @@ const DependencyTemplate = require("../DependencyTemplate");
 /** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
+/** @typedef {string[]} RawRuntimeRequirements */
+
 class NullDependency extends Dependency {
 	get type() {
 		return "null";

package/lib/dependencies/ProvidedDependency.js

@@ -11,14 +11,12 @@ const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
@@ -26,19 +24,19 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
- * @param {string[]|null} path the property path array
+ * @param {string[] | null} path the property path array
  * @returns {string} the converted path
  */
-const pathToString = path =>
+const pathToString = (path) =>
 	path !== null && path.length > 0
-		? path.map(part => `[${JSON.stringify(part)}]`).join("")
+		? path.map((part) => `[${JSON.stringify(part)}]`).join("")
 		: "";
 
 class ProvidedDependency extends ModuleDependency {
 	/**
 	 * @param {string} request request
 	 * @param {string} identifier identifier
-	 * @param {string[]} ids ids
+	 * @param {ExportInfoName[]} ids ids
 	 * @param {Range} range range
 	 */
 	constructor(request, identifier, ids, range) {
@@ -61,7 +59,7 @@ class ProvidedDependency extends ModuleDependency {
 	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
 		const ids = this.ids;
@@ -142,7 +140,7 @@ class ProvidedDependencyTemplate extends ModuleDependency.Template {
 					chunkGraph,
 					request: dep.request,
 					runtimeRequirements
-				})}${pathToString(/** @type {string[]} */ (usedName))};\n`,
+				})}${pathToString(/** @type {string[] | null} */ (usedName))};\n`,
 				InitFragment.STAGE_PROVIDES,
 				1,
 				`provided ${dep.identifier}`

package/lib/dependencies/PureExpressionDependency.js

@@ -11,7 +11,6 @@ const { filterRuntime, runtimeToString } = require("../util/runtime");
 const NullDependency = require("./NullDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
@@ -47,7 +46,7 @@ class PureExpressionDependency extends NullDependency {
 				/** @type {Module} */
 				(moduleGraph.getParentModule(this));
 			const exportsInfo = moduleGraph.getExportsInfo(selfModule);
-			const runtimeCondition = filterRuntime(runtime, runtime => {
+			const runtimeCondition = filterRuntime(runtime, (runtime) => {
 				for (const exportName of usedByExports) {
 					if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused) {
 						return true;

package/lib/dependencies/RequireContextDependency.js

@@ -10,10 +10,11 @@ const ContextDependency = require("./ContextDependency");
 const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateAsRequireId");
 
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
 
 class RequireContextDependency extends ContextDependency {
 	/**
-	 * @param {TODO} options options
+	 * @param {ContextDependencyOptions} options options
 	 * @param {Range} range range
 	 */
 	constructor(options, range) {

package/lib/dependencies/RequireContextDependencyParserPlugin.js

@@ -7,60 +7,63 @@
 
 const RequireContextDependency = require("./RequireContextDependency");
 
+/** @typedef {import("../ContextModule").ContextMode} ContextMode */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
+const PLUGIN_NAME = "RequireContextDependencyParserPlugin";
+
 module.exports = class RequireContextDependencyParserPlugin {
 	/**
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
 	apply(parser) {
-		parser.hooks.call
-			.for("require.context")
-			.tap("RequireContextDependencyParserPlugin", expr => {
-				let regExp = /^\.\/.*$/;
-				let recursive = true;
-				let mode = "sync";
-				switch (expr.arguments.length) {
-					case 4: {
-						const modeExpr = parser.evaluateExpression(expr.arguments[3]);
-						if (!modeExpr.isString()) return;
-						mode = /** @type {string} */ (modeExpr.string);
-					}
-					// falls through
-					case 3: {
-						const regExpExpr = parser.evaluateExpression(expr.arguments[2]);
-						if (!regExpExpr.isRegExp()) return;
-						regExp = /** @type {RegExp} */ (regExpExpr.regExp);
-					}
-					// falls through
-					case 2: {
-						const recursiveExpr = parser.evaluateExpression(expr.arguments[1]);
-						if (!recursiveExpr.isBoolean()) return;
-						recursive = /** @type {boolean} */ (recursiveExpr.bool);
-					}
-					// falls through
-					case 1: {
-						const requestExpr = parser.evaluateExpression(expr.arguments[0]);
-						if (!requestExpr.isString()) return;
-						const dep = new RequireContextDependency(
-							{
-								request: requestExpr.string,
-								recursive,
-								regExp,
-								mode,
-								category: "commonjs"
-							},
-							/** @type {Range} */ (expr.range)
-						);
-						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-						dep.optional = Boolean(parser.scope.inTry);
-						parser.state.current.addDependency(dep);
-						return true;
-					}
+		parser.hooks.call.for("require.context").tap(PLUGIN_NAME, (expr) => {
+			let regExp = /^\.\/.*$/;
+			let recursive = true;
+			/** @type {ContextMode} */
+			let mode = "sync";
+			switch (expr.arguments.length) {
+				case 4: {
+					const modeExpr = parser.evaluateExpression(expr.arguments[3]);
+					if (!modeExpr.isString()) return;
+					mode = /** @type {ContextMode} */ (modeExpr.string);
+				}
+				// falls through
+				case 3: {
+					const regExpExpr = parser.evaluateExpression(expr.arguments[2]);
+					if (!regExpExpr.isRegExp()) return;
+					regExp = /** @type {RegExp} */ (regExpExpr.regExp);
+				}
+				// falls through
+				case 2: {
+					const recursiveExpr = parser.evaluateExpression(expr.arguments[1]);
+					if (!recursiveExpr.isBoolean()) return;
+					recursive = /** @type {boolean} */ (recursiveExpr.bool);
+				}
+				// falls through
+				case 1: {
+					const requestExpr = parser.evaluateExpression(expr.arguments[0]);
+					if (!requestExpr.isString()) return;
+					const dep = new RequireContextDependency(
+						{
+							request: /** @type {string} */ (requestExpr.string),
+							recursive,
+							regExp,
+							mode,
+							category: "commonjs"
+						},
+						/** @type {Range} */
+						(expr.range)
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					dep.optional = Boolean(parser.scope.inTry);
+					parser.state.current.addDependency(dep);
+					return true;
 				}
-			});
+			}
+		});
 	}
 };