webpack 5.99.6 → 5.99.7

package/lib/cache/IdleFileCachePlugin.js

@@ -12,6 +12,7 @@ const ProgressPlugin = require("../ProgressPlugin");
 /** @typedef {import("./PackFileCacheStrategy")} PackFileCacheStrategy */
 
 const BUILD_DEPENDENCIES_KEY = Symbol("build dependencies key");
+const PLUGIN_NAME = "IdleFileCachePlugin";
 
 class IdleFileCachePlugin {
 	/**
@@ -55,7 +56,7 @@ class IdleFileCachePlugin {
 		const pendingIdleTasks = new Map();
 
 		compiler.cache.hooks.store.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			(identifier, etag, data) => {
 				pendingIdleTasks.set(identifier, () =>
 					strategy.store(identifier, etag, data)
@@ -64,7 +65,7 @@ class IdleFileCachePlugin {
 		);
 
 		compiler.cache.hooks.get.tapPromise(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			(identifier, etag, gotHandlers) => {
 				const restore = () =>
 					strategy.restore(identifier, etag).then(cacheEntry => {
@@ -91,7 +92,7 @@ class IdleFileCachePlugin {
 		);
 
 		compiler.cache.hooks.storeBuildDependencies.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			dependencies => {
 				pendingIdleTasks.set(BUILD_DEPENDENCIES_KEY, () =>
 					Promise.resolve().then(() =>
@@ -102,7 +103,7 @@ class IdleFileCachePlugin {
 		);
 
 		compiler.cache.hooks.shutdown.tapPromise(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			() => {
 				if (idleTimer) {
 					clearTimeout(idleTimer);
@@ -165,9 +166,7 @@ class IdleFileCachePlugin {
 						timeSpendInBuild = 0;
 					})
 					.catch(err => {
-						const logger = compiler.getInfrastructureLogger(
-							"IdleFileCachePlugin"
-						);
+						const logger = compiler.getInfrastructureLogger(PLUGIN_NAME);
 						logger.warn(`Background tasks during idle failed: ${err.message}`);
 						logger.debug(err.stack);
 					});
@@ -177,12 +176,12 @@ class IdleFileCachePlugin {
 		/** @type {ReturnType<typeof setTimeout> | undefined} */
 		let idleTimer;
 		compiler.cache.hooks.beginIdle.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			() => {
 				const isLargeChange = timeSpendInBuild > avgTimeSpendInStore * 2;
 				if (isInitialStore && idleTimeoutForInitialStore < idleTimeout) {
 					compiler
-						.getInfrastructureLogger("IdleFileCachePlugin")
+						.getInfrastructureLogger(PLUGIN_NAME)
 						.log(
 							`Initial cache was generated and cache will be persisted in ${
 								idleTimeoutForInitialStore / 1000
@@ -193,7 +192,7 @@ class IdleFileCachePlugin {
 					idleTimeoutAfterLargeChanges < idleTimeout
 				) {
 					compiler
-						.getInfrastructureLogger("IdleFileCachePlugin")
+						.getInfrastructureLogger(PLUGIN_NAME)
 						.log(
 							`Spend ${Math.round(timeSpendInBuild) / 1000}s in build and ${
 								Math.round(avgTimeSpendInStore) / 1000
@@ -218,7 +217,7 @@ class IdleFileCachePlugin {
 			}
 		);
 		compiler.cache.hooks.endIdle.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			() => {
 				if (idleTimer) {
 					clearTimeout(idleTimer);
@@ -227,7 +226,7 @@ class IdleFileCachePlugin {
 				isIdle = false;
 			}
 		);
-		compiler.hooks.done.tap("IdleFileCachePlugin", stats => {
+		compiler.hooks.done.tap(PLUGIN_NAME, stats => {
 			// 10% build overhead is ignored, as it's not cacheable
 			timeSpendInBuild *= 0.9;
 			timeSpendInBuild +=

package/lib/cache/MemoryWithGcCachePlugin.js

@@ -18,6 +18,8 @@ const Cache = require("../Cache");
  * @property {number} maxGenerations max generations
  */
 
+const PLUGIN_NAME = "MemoryWithGcCachePlugin";
+
 class MemoryWithGcCachePlugin {
 	/**
 	 * @param {MemoryWithGcCachePluginOptions} options options
@@ -39,8 +41,8 @@ class MemoryWithGcCachePlugin {
 		const oldCache = new Map();
 		let generation = 0;
 		let cachePosition = 0;
-		const logger = compiler.getInfrastructureLogger("MemoryWithGcCachePlugin");
-		compiler.hooks.afterDone.tap("MemoryWithGcCachePlugin", () => {
+		const logger = compiler.getInfrastructureLogger(PLUGIN_NAME);
+		compiler.hooks.afterDone.tap(PLUGIN_NAME, () => {
 			generation++;
 			let clearedEntries = 0;
 			let lastClearedIdentifier;
@@ -91,13 +93,13 @@ class MemoryWithGcCachePlugin {
 			}
 		});
 		compiler.cache.hooks.store.tap(
-			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_MEMORY },
 			(identifier, etag, data) => {
 				cache.set(identifier, { etag, data });
 			}
 		);
 		compiler.cache.hooks.get.tap(
-			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_MEMORY },
 			(identifier, etag, gotHandlers) => {
 				const cacheEntry = cache.get(identifier);
 				if (cacheEntry === null) {
@@ -129,7 +131,7 @@ class MemoryWithGcCachePlugin {
 			}
 		);
 		compiler.cache.hooks.shutdown.tap(
-			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_MEMORY },
 			() => {
 				cache.clear();
 				oldCache.clear();

package/lib/cache/ResolverCachePlugin.js

@@ -97,6 +97,8 @@ const objectToString = (object, excludeContext) => {
 
 /** @typedef {NonNullable<ResolveContext["yield"]>} Yield */
 
+const PLUGIN_NAME = "ResolverCachePlugin";
+
 class ResolverCachePlugin {
 	/**
 	 * Apply the plugin
@@ -104,7 +106,7 @@ class ResolverCachePlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const cache = compiler.getCache("ResolverCachePlugin");
+		const cache = compiler.getCache(PLUGIN_NAME);
 		/** @type {FileSystemInfo} */
 		let fileSystemInfo;
 		/** @type {SnapshotOptions | undefined} */
@@ -113,12 +115,12 @@ class ResolverCachePlugin {
 		let cachedResolves = 0;
 		let cacheInvalidResolves = 0;
 		let concurrentResolves = 0;
-		compiler.hooks.thisCompilation.tap("ResolverCachePlugin", compilation => {
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
 			snapshotOptions = compilation.options.snapshot.resolve;
 			fileSystemInfo = compilation.fileSystemInfo;
-			compilation.hooks.finishModules.tap("ResolverCachePlugin", () => {
+			compilation.hooks.finishModules.tap(PLUGIN_NAME, () => {
 				if (realResolves + cachedResolves > 0) {
-					const logger = compilation.getLogger("webpack.ResolverCachePlugin");
+					const logger = compilation.getLogger(`webpack.${PLUGIN_NAME}`);
 					logger.log(
 						`${Math.round(
 							(100 * realResolves) / (realResolves + cachedResolves)
@@ -260,7 +262,7 @@ class ResolverCachePlugin {
 				const hook =
 					/** @type {SyncHook<[Resolver, ResolveOptions, ResolveOptionsWithDependencyType]>} */
 					(_hook);
-				hook.tap("ResolverCachePlugin", (resolver, options, userOptions) => {
+				hook.tap(PLUGIN_NAME, (resolver, options, userOptions) => {
 					if (
 						/** @type {ResolveOptions & { cache: boolean }} */
 						(options).cache !== true
@@ -273,7 +275,7 @@ class ResolverCachePlugin {
 							: false;
 					resolver.hooks.resolve.tapAsync(
 						{
-							name: "ResolverCachePlugin",
+							name: PLUGIN_NAME,
 							stage: -100
 						},
 						(request, resolveContext, callback) => {

package/lib/cli.js

@@ -8,7 +8,11 @@
 const path = require("path");
 const webpackSchema = require("../schemas/WebpackOptions.json");
 
-/** @typedef {Parameters<import("schema-utils").validate>[0] & { absolutePath: boolean, instanceof: string, cli: { helper?: boolean, exclude?: boolean, description?: string, negatedDescription?: string, resetDescription?: string } }} Schema */
+/** @typedef {import("json-schema").JSONSchema4} JSONSchema4 */
+/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */
+/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */
+/** @typedef {JSONSchema4 | JSONSchema6 | JSONSchema7} JSONSchema */
+/** @typedef {JSONSchema & { absolutePath: boolean, instanceof: string, cli: { helper?: boolean, exclude?: boolean, description?: string, negatedDescription?: string, resetDescription?: string } }} Schema */
 
 // TODO add originPath to PathItem for better errors
 /**

package/lib/config/normalization.js

@@ -22,6 +22,7 @@ const util = require("util");
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
 /** @typedef {import("../Entrypoint")} Entrypoint */
+/** @typedef {import("../WebpackError")} WebpackError */
 
 const handledDeprecatedNoEmitOnErrors = util.deprecate(
 	/**
@@ -210,14 +211,19 @@ const getNormalizedWebpackOptions = config => ({
 					}
 					if (
 						i.module &&
-						(!warning.module ||
+						(!(/** @type {WebpackError} */ (warning).module) ||
 							!i.module.test(
-								warning.module.readableIdentifier(requestShortener)
+								/** @type {WebpackError} */
+								(warning).module.readableIdentifier(requestShortener)
 							))
 					) {
 						return false;
 					}
-					if (i.file && (!warning.file || !i.file.test(warning.file))) {
+					if (
+						i.file &&
+						(!(/** @type {WebpackError} */ (warning).file) ||
+							!i.file.test(/** @type {WebpackError} */ (warning).file))
+					) {
 						return false;
 					}
 					return true;

package/lib/container/ContainerReferencePlugin.js

@@ -31,6 +31,7 @@ const validate = createSchemaValidation(
 );
 
 const slashCode = "/".charCodeAt(0);
+const PLUGIN_NAME = "ContainerReferencePlugin";
 
 class ContainerReferencePlugin {
 	/**
@@ -79,7 +80,7 @@ class ContainerReferencePlugin {
 		new ExternalsPlugin(remoteType, remoteExternals).apply(compiler);
 
 		compiler.hooks.compilation.tap(
-			"ContainerReferencePlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					RemoteToExternalDependency,
@@ -96,37 +97,34 @@ class ContainerReferencePlugin {
 					new FallbackModuleFactory()
 				);
 
-				normalModuleFactory.hooks.factorize.tap(
-					"ContainerReferencePlugin",
-					data => {
-						if (!data.request.includes("!")) {
-							for (const [key, config] of remotes) {
-								if (
-									data.request.startsWith(`${key}`) &&
-									(data.request.length === key.length ||
-										data.request.charCodeAt(key.length) === slashCode)
-								) {
-									return new RemoteModule(
-										data.request,
-										config.external.map((external, i) =>
-											external.startsWith("internal ")
-												? external.slice(9)
-												: `webpack/container/reference/${key}${
-														i ? `/fallback-${i}` : ""
-													}`
-										),
-										`.${data.request.slice(key.length)}`,
-										config.shareScope
-									);
-								}
+				normalModuleFactory.hooks.factorize.tap(PLUGIN_NAME, data => {
+					if (!data.request.includes("!")) {
+						for (const [key, config] of remotes) {
+							if (
+								data.request.startsWith(`${key}`) &&
+								(data.request.length === key.length ||
+									data.request.charCodeAt(key.length) === slashCode)
+							) {
+								return new RemoteModule(
+									data.request,
+									config.external.map((external, i) =>
+										external.startsWith("internal ")
+											? external.slice(9)
+											: `webpack/container/reference/${key}${
+													i ? `/fallback-${i}` : ""
+												}`
+									),
+									`.${data.request.slice(key.length)}`,
+									config.shareScope
+								);
 							}
 						}
 					}
-				);
+				});
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("ContainerReferencePlugin", (chunk, set) => {
+					.tap(PLUGIN_NAME, (chunk, set) => {
 						set.add(RuntimeGlobals.module);
 						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
 						set.add(RuntimeGlobals.hasOwnProperty);

package/lib/container/ModuleFederationPlugin.js

@@ -37,6 +37,7 @@ const validate = createSchemaValidation(
 
 /** @type {WeakMap<Compilation, CompilationHooks>} */
 const compilationHooksMap = new WeakMap();
+const PLUGIN_NAME = "ModuleFederationPlugin";
 
 class ModuleFederationPlugin {
 	/**
@@ -89,7 +90,7 @@ class ModuleFederationPlugin {
 		) {
 			compiler.options.output.enabledLibraryTypes.push(library.type);
 		}
-		compiler.hooks.afterPlugins.tap("ModuleFederationPlugin", () => {
+		compiler.hooks.afterPlugins.tap(PLUGIN_NAME, () => {
 			if (
 				options.exposes &&
 				(Array.isArray(options.exposes)

package/lib/css/CssGenerator.js

@@ -292,7 +292,7 @@ class CssGenerator extends Generator {
 					Array.from(exports).reduce((obj, [key, value]) => {
 						obj[key] = value;
 						return obj;
-					}, {})
+					}, /** @type {Record<string, string>} */ ({}))
 				);
 
 				return stringifiedExports.length + 42;

package/lib/css/CssModulesPlugin.js

@@ -385,15 +385,17 @@ class CssModulesPlugin {
 					compilation
 				).renderModuleContent.tap(PLUGIN_NAME, (source, module) => {
 					if (module instanceof CssModule && module.hot) {
-						const exports =
-							/** @type {BuildInfo} */
-							(module.buildInfo).cssData.exports;
+						const cssData = /** @type {BuildInfo} */ (module.buildInfo).cssData;
+						if (!cssData) {
+							return source;
+						}
+						const exports = cssData.exports;
 						const stringifiedExports = JSON.stringify(
 							JSON.stringify(
 								Array.from(exports).reduce((obj, [key, value]) => {
 									obj[key] = value;
 									return obj;
-								}, {})
+								}, /** @type {Record<string, string>} */ ({}))
 							)
 						);
 

package/lib/dependencies/HarmonyDetectionParserPlugin.js

@@ -15,6 +15,8 @@ const HarmonyExports = require("./HarmonyExports");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("./HarmonyModulesPlugin").HarmonyModulesPluginOptions} HarmonyModulesPluginOptions */
 
+const PLUGIN_NAME = "HarmonyDetectionParserPlugin";
+
 module.exports = class HarmonyDetectionParserPlugin {
 	/**
 	 * @param {HarmonyModulesPluginOptions} options options
@@ -29,7 +31,7 @@ module.exports = class HarmonyDetectionParserPlugin {
 	 * @returns {void}
 	 */
 	apply(parser) {
-		parser.hooks.program.tap("HarmonyDetectionParserPlugin", ast => {
+		parser.hooks.program.tap(PLUGIN_NAME, ast => {
 			const isStrictHarmony =
 				parser.state.module.type === JAVASCRIPT_MODULE_TYPE_ESM;
 			const isHarmony =
@@ -62,7 +64,7 @@ module.exports = class HarmonyDetectionParserPlugin {
 			}
 		});
 
-		parser.hooks.topLevelAwait.tap("HarmonyDetectionParserPlugin", () => {
+		parser.hooks.topLevelAwait.tap(PLUGIN_NAME, () => {
 			const module = parser.state.module;
 			if (!this.topLevelAwait) {
 				throw new Error(
@@ -105,19 +107,11 @@ module.exports = class HarmonyDetectionParserPlugin {
 		for (const identifier of nonHarmonyIdentifiers) {
 			parser.hooks.evaluateTypeof
 				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", nullInHarmony);
-			parser.hooks.typeof
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
-			parser.hooks.evaluate
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", nullInHarmony);
-			parser.hooks.expression
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
-			parser.hooks.call
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
+				.tap(PLUGIN_NAME, nullInHarmony);
+			parser.hooks.typeof.for(identifier).tap(PLUGIN_NAME, skipInHarmony);
+			parser.hooks.evaluate.for(identifier).tap(PLUGIN_NAME, nullInHarmony);
+			parser.hooks.expression.for(identifier).tap(PLUGIN_NAME, skipInHarmony);
+			parser.hooks.call.for(identifier).tap(PLUGIN_NAME, skipInHarmony);
 		}
 	}
 };

package/lib/dependencies/HarmonyTopLevelThisParserPlugin.js

@@ -12,27 +12,27 @@ const HarmonyExports = require("./HarmonyExports");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
+const PLUGIN_NAME = "HarmonyTopLevelThisParserPlugin";
+
 class HarmonyTopLevelThisParserPlugin {
 	/**
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
 	apply(parser) {
-		parser.hooks.expression
-			.for("this")
-			.tap("HarmonyTopLevelThisParserPlugin", node => {
-				if (!parser.scope.topLevelScope) return;
-				if (HarmonyExports.isEnabled(parser.state)) {
-					const dep = new ConstDependency(
-						"undefined",
-						/** @type {Range} */ (node.range),
-						null
-					);
-					dep.loc = /** @type {DependencyLocation} */ (node.loc);
-					parser.state.module.addPresentationalDependency(dep);
-					return true;
-				}
-			});
+		parser.hooks.expression.for("this").tap(PLUGIN_NAME, node => {
+			if (!parser.scope.topLevelScope) return;
+			if (HarmonyExports.isEnabled(parser.state)) {
+				const dep = new ConstDependency(
+					"undefined",
+					/** @type {Range} */ (node.range),
+					null
+				);
+				dep.loc = /** @type {DependencyLocation} */ (node.loc);
+				parser.state.module.addPresentationalDependency(dep);
+				return true;
+			}
+		});
 	}
 }
 

package/lib/dependencies/ImportMetaContextDependencyParserPlugin.js

@@ -52,6 +52,8 @@ function createError(msg, loc) {
 	return error;
 }
 
+const PLUGIN_NAME = "ImportMetaContextDependencyParserPlugin";
+
 module.exports = class ImportMetaContextDependencyParserPlugin {
 	/**
 	 * @param {JavascriptParser} parser the parser
@@ -60,7 +62,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 	apply(parser) {
 		parser.hooks.evaluateIdentifier
 			.for("import.meta.webpackContext")
-			.tap("ImportMetaContextDependencyParserPlugin", expr =>
+			.tap(PLUGIN_NAME, expr =>
 				evaluateToIdentifier(
 					"import.meta.webpackContext",
 					"import.meta",
@@ -70,7 +72,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 			);
 		parser.hooks.call
 			.for("import.meta.webpackContext")
-			.tap("ImportMetaContextDependencyParserPlugin", expr => {
+			.tap(PLUGIN_NAME, expr => {
 				if (expr.arguments.length < 1 || expr.arguments.length > 2) return;
 				const [directoryNode, optionsNode] = expr.arguments;
 				if (optionsNode && optionsNode.type !== "ObjectExpression") return;

package/lib/dependencies/LoaderPlugin.js

@@ -31,6 +31,8 @@ const LoaderImportDependency = require("./LoaderImportDependency");
  * @property {string=} baseUri target base uri
  */
 
+const PLUGIN_NAME = "LoaderPlugin";
+
 class LoaderPlugin {
 	/**
 	 * Apply the plugin
@@ -39,7 +41,7 @@ class LoaderPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"LoaderPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					LoaderDependency,
@@ -52,10 +54,10 @@ 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",
+				PLUGIN_NAME,
 				loaderContext => {
 					loaderContext.loadModule = (request, callback) => {
 						const dep = new LoaderDependency(request);

package/lib/dependencies/RequireContextDependencyParserPlugin.js

@@ -12,58 +12,58 @@ const RequireContextDependency = require("./RequireContextDependency");
 /** @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;
-				/** @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;
-					}
+		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;
 				}
-			});
+			}
+		});
 	}
 };