webpack 5.101.3 → 5.102.1

package/lib/Compiler.js

@@ -38,9 +38,9 @@ const webpack = require(".");
 /** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
 /** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
+/** @typedef {import("../declarations/WebpackOptions").Plugins} Plugins */
+/** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
 /** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./HotModuleReplacementPlugin").ChunkHashes} ChunkHashes */
 /** @typedef {import("./HotModuleReplacementPlugin").ChunkModuleHashes} ChunkModuleHashes */
@@ -70,23 +70,18 @@ const webpack = require(".");
 
 /**
  * @template T
- * @callback RunCallback
- * @param {Error | null} err
- * @param {T=} result
+ * @template [R=void]
+ * @typedef {import("./webpack").Callback<T, R>} Callback
  */
 
-/**
- * @template T
- * @callback Callback
- * @param {(Error | null)=} err
- * @param {T=} result
- */
+/** @typedef {import("./webpack").ErrorCallback} ErrorCallback */
 
 /**
  * @callback RunAsChildCallback
  * @param {Error | null} err
  * @param {Chunk[]=} entries
  * @param {Compilation=} compilation
+ * @returns {void}
  */
 
 /**
@@ -122,7 +117,8 @@ const webpack = require(".");
 /** @typedef {{ buildInfo: BuildInfo, references: WeakReferences | undefined, memCache: MemCache }} ModuleMemCachesItem */
 
 /**
- * @param {string[]} array an array
+ * @template T
+ * @param {T[]} array an array
  * @returns {boolean} true, if the array is sorted
  */
 const isSorted = (array) => {
@@ -478,12 +474,13 @@ class Compiler {
 
 	/**
 	 * @param {WatchOptions} watchOptions the watcher's options
-	 * @param {RunCallback<Stats>} handler signals when the call finishes
-	 * @returns {Watching} a compiler watcher
+	 * @param {Callback<Stats>} handler signals when the call finishes
+	 * @returns {Watching | undefined} a compiler watcher
 	 */
 	watch(watchOptions, handler) {
 		if (this.running) {
-			return handler(new ConcurrentCompilationError());
+			handler(new ConcurrentCompilationError());
+			return;
 		}
 
 		this.running = true;
@@ -493,12 +490,13 @@ class Compiler {
 	}
 
 	/**
-	 * @param {RunCallback<Stats>} callback signals when the call finishes
+	 * @param {Callback<Stats>} callback signals when the call finishes
 	 * @returns {void}
 	 */
 	run(callback) {
 		if (this.running) {
-			return callback(new ConcurrentCompilationError());
+			callback(new ConcurrentCompilationError());
+			return;
 		}
 
 		/** @type {Logger | undefined} */
@@ -695,7 +693,7 @@ class Compiler {
 
 	/**
 	 * @param {Compilation} compilation the compilation
-	 * @param {Callback<void>} callback signals when the assets are emitted
+	 * @param {ErrorCallback} callback signals when the assets are emitted
 	 * @returns {void}
 	 */
 	emitAssets(compilation, callback) {
@@ -1028,7 +1026,7 @@ ${other}`);
 					this.hooks.afterEmit.callAsync(compilation, (err) => {
 						if (err) return callback(err);
 
-						return callback();
+						return callback(null);
 					});
 				}
 			);
@@ -1046,7 +1044,7 @@ ${other}`);
 	}
 
 	/**
-	 * @param {Callback<void>} callback signals when the call finishes
+	 * @param {ErrorCallback} callback signals when the call finishes
 	 * @returns {void}
 	 */
 	emitRecords(callback) {
@@ -1065,12 +1063,12 @@ ${other}`);
 		} else if (this.recordsOutputPath) {
 			this._emitRecords(callback);
 		} else {
-			callback();
+			callback(null);
 		}
 	}
 
 	/**
-	 * @param {Callback<void>} callback signals when the call finishes
+	 * @param {ErrorCallback} callback signals when the call finishes
 	 * @returns {void}
 	 */
 	_emitRecords(callback) {
@@ -1119,7 +1117,7 @@ ${other}`);
 	}
 
 	/**
-	 * @param {Callback<void>} callback signals when the call finishes
+	 * @param {ErrorCallback} callback signals when the call finishes
 	 * @returns {void}
 	 */
 	readRecords(callback) {
@@ -1140,28 +1138,29 @@ ${other}`);
 			this._readRecords(callback);
 		} else {
 			this.records = {};
-			callback();
+			callback(null);
 		}
 	}
 
 	/**
-	 * @param {Callback<void>} callback signals when the call finishes
+	 * @param {ErrorCallback} callback signals when the call finishes
 	 * @returns {void}
 	 */
 	_readRecords(callback) {
 		if (!this.recordsInputPath) {
 			this.records = {};
-			return callback();
+			return callback(null);
 		}
 		/** @type {InputFileSystem} */
 		(this.inputFileSystem).stat(this.recordsInputPath, (err) => {
 			// It doesn't exist
 			// We can ignore this.
-			if (err) return callback();
+			if (err) return callback(null);
 
 			/** @type {InputFileSystem} */
 			(this.inputFileSystem).readFile(
-				/** @type {string} */ (this.recordsInputPath),
+				/** @type {string} */
+				(this.recordsInputPath),
 				(err, content) => {
 					if (err) return callback(err);
 
@@ -1177,7 +1176,7 @@ ${other}`);
 						);
 					}
 
-					return callback();
+					return callback(null);
 				}
 			);
 		});
@@ -1188,7 +1187,7 @@ ${other}`);
 	 * @param {string} compilerName the compiler's name
 	 * @param {number} compilerIndex the compiler's index
 	 * @param {Partial<OutputOptions>=} outputOptions the output options
-	 * @param {WebpackPluginInstance[]=} plugins the plugins to apply
+	 * @param {Plugins=} plugins the plugins to apply
 	 * @returns {Compiler} a child compiler
 	 */
 	createChildCompiler(
@@ -1239,7 +1238,10 @@ ${other}`);
 		childCompiler.root = this.root;
 		if (Array.isArray(plugins)) {
 			for (const plugin of plugins) {
-				if (plugin) {
+				if (typeof plugin === "function") {
+					/** @type {WebpackPluginFunction} */
+					(plugin).call(childCompiler, childCompiler);
+				} else if (plugin) {
 					plugin.apply(childCompiler);
 				}
 			}
@@ -1311,8 +1313,7 @@ ${other}`);
 			fs: /** @type {InputFileSystem} */ (this.inputFileSystem),
 			resolverFactory: this.resolverFactory,
 			options: this.options.module,
-			associatedObjectForCache: this.root,
-			layers: this.options.experiments.layers
+			associatedObjectForCache: this.root
 		});
 		this._lastNormalModuleFactory = normalModuleFactory;
 		this.hooks.normalModuleFactory.call(normalModuleFactory);
@@ -1334,7 +1335,7 @@ ${other}`);
 	}
 
 	/**
-	 * @param {RunCallback<Compilation>} callback signals when the compilation finishes
+	 * @param {Callback<Compilation>} callback signals when the compilation finishes
 	 * @returns {void}
 	 */
 	compile(callback) {
@@ -1385,7 +1386,7 @@ ${other}`);
 	}
 
 	/**
-	 * @param {RunCallback<void>} callback signals when the compiler closes
+	 * @param {ErrorCallback} callback signals when the compiler closes
 	 * @returns {void}
 	 */
 	close(callback) {

package/lib/ConcatenationScope.js

@@ -10,16 +10,18 @@ const {
 	NAMESPACE_OBJECT_EXPORT
 } = require("./util/concatenate");
 
+/** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./optimize/ConcatenatedModule").ConcatenatedModuleInfo} ConcatenatedModuleInfo */
 /** @typedef {import("./optimize/ConcatenatedModule").ModuleInfo} ModuleInfo */
+/** @typedef {import("./optimize/ConcatenatedModule").ExportName} Ids */
 
 const MODULE_REFERENCE_REGEXP =
 	/^__WEBPACK_MODULE_REFERENCE__(\d+)_([\da-f]+|ns)(_call)?(_directImport)?(_deferredImport)?(?:_asiSafe(\d))?__$/;
 
 /**
  * @typedef {object} ModuleReferenceOptions
- * @property {string[]} ids the properties/exports of the module
+ * @property {Ids} ids the properties/exports of the module
  * @property {boolean} call true, when this referenced export is called
  * @property {boolean} directImport true, when this referenced export is directly imported (not via property access)
  * @property {boolean} deferredImport true, when this referenced export is deferred
@@ -187,4 +189,7 @@ class ConcatenationScope {
 ConcatenationScope.DEFAULT_EXPORT = DEFAULT_EXPORT;
 ConcatenationScope.NAMESPACE_OBJECT_EXPORT = NAMESPACE_OBJECT_EXPORT;
 
+/** @type {WeakMap<Chunk, Set<string>>} */
+ConcatenationScope.chunkUsedNames = new WeakMap();
+
 module.exports = ConcatenationScope;

package/lib/ConditionalInitFragment.js

@@ -78,7 +78,7 @@ class ConditionalInitFragment extends InitFragment {
 
 	/**
 	 * @param {GenerateContext} context context
-	 * @returns {string | Source=} the source code that will be included at the end of the module
+	 * @returns {string | Source | undefined} the source code that will be included at the end of the module
 	 */
 	getEndContent(context) {
 		if (this.runtimeCondition === false || !this.endContent) return "";

package/lib/ConstPlugin.js

@@ -24,12 +24,13 @@ const { parseResource } = require("./util/identifier");
 /** @typedef {import("estree").Super} Super */
 /** @typedef {import("estree").VariableDeclaration} VariableDeclaration */
 /** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("./javascript/JavascriptParser").Range} Range */
 
+/** @typedef {Set<string>} Declarations */
+
 /**
- * @param {Set<string>} declarations set of declarations
+ * @param {Declarations} declarations set of declarations
  * @param {Identifier | Pattern} pattern pattern to collect declarations from
  */
 const collectDeclaration = (declarations, pattern) => {
@@ -65,12 +66,12 @@ const collectDeclaration = (declarations, pattern) => {
 /**
  * @param {Statement} branch branch to get hoisted declarations from
  * @param {boolean} includeFunctionDeclarations whether to include function declarations
- * @returns {Array<string>} hoisted declarations
+ * @returns {string[]} hoisted declarations
  */
 const getHoistedDeclarations = (branch, includeFunctionDeclarations) => {
-	/** @type {Set<string>} */
+	/** @type {Declarations} */
 	const declarations = new Set();
-	/** @type {Array<Statement | null | undefined>} */
+	/** @type {(Statement | null | undefined)[]} */
 	const stack = [branch];
 	while (stack.length > 0) {
 		const node = stack.pop();

package/lib/ContextExclusionPlugin.js

@@ -5,7 +5,6 @@
 "use strict";
 
 /** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./ContextModuleFactory")} ContextModuleFactory */
 
 const PLUGIN_NAME = "ContextExclusionPlugin";
 

package/lib/ContextModule.js

@@ -30,25 +30,27 @@ const makeSerializable = require("./util/makeSerializable");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./Chunk").ChunkId} ChunkId */
+/** @typedef {import("./Chunk").ChunkName} ChunkName */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("./ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./Dependency").RawReferencedExports} RawReferencedExports */
 /** @typedef {import("./Generator").SourceTypes} SourceTypes */
 /** @typedef {import("./Module").BuildCallback} BuildCallback */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
+/** @typedef {import("./Module").FileSystemDependencies} FileSystemDependencies */
 /** @typedef {import("./Module").BuildMeta} BuildMeta */
 /** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("./Module").LibIdent} LibIdent */
 /** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
@@ -56,7 +58,6 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @template T @typedef {import("./util/LazySet")<T>} LazySet<T> */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
 /** @typedef {"sync" | "eager" | "weak" | "async-weak" | "lazy" | "lazy-once"} ContextMode Context mode */
@@ -65,17 +66,17 @@ const makeSerializable = require("./util/makeSerializable");
  * @typedef {object} ContextOptions
  * @property {ContextMode} mode
  * @property {boolean} recursive
- * @property {RegExp} regExp
- * @property {("strict" | boolean)=} namespaceObject
+ * @property {RegExp | false | null} regExp
+ * @property {"strict" | boolean=} namespaceObject
  * @property {string=} addon
- * @property {(string | null)=} chunkName
- * @property {(RegExp | null)=} include
- * @property {(RegExp | null)=} exclude
+ * @property {ChunkName=} chunkName
+ * @property {RegExp | null=} include
+ * @property {RegExp | null=} exclude
  * @property {RawChunkGroupOptions=} groupOptions
  * @property {string=} typePrefix
  * @property {string=} category
- * @property {(string[][] | null)=} referencedExports exports referenced from modules (won't be mangled)
- * @property {string=} layer
+ * @property {RawReferencedExports | null=} referencedExports exports referenced from modules (won't be mangled)
+ * @property {string | null=} layer
  * @property {ImportAttributes=} attributes
  */
 
@@ -93,6 +94,7 @@ const makeSerializable = require("./util/makeSerializable");
  * @callback ResolveDependenciesCallback
  * @param {Error | null} err
  * @param {ContextElementDependency[]=} dependencies
+ * @returns {void}
  */
 
 /**
@@ -106,8 +108,6 @@ const makeSerializable = require("./util/makeSerializable");
 
 /** @typedef {Record<ModuleId, FakeMapType>} FakeMap */
 
-const SNAPSHOT_OPTIONS = { timestamp: true };
-
 class ContextModule extends Module {
 	/**
 	 * @param {ResolveDependencies} resolveDependencies function to get dependencies in this context
@@ -254,10 +254,12 @@ class ContextModule extends Module {
 		} else if (this.options.namespaceObject) {
 			identifier += "|namespace object";
 		}
+		if (this.options.attributes) {
+			identifier += `|importAttributes: ${JSON.stringify(this.options.attributes)}`;
+		}
 		if (this.layer) {
 			identifier += `|layer: ${this.layer}`;
 		}
-
 		return identifier;
 	}
 
@@ -334,7 +336,7 @@ class ContextModule extends Module {
 
 	/**
 	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @returns {LibIdent | null} an identifier for library inclusion
 	 */
 	libIdent(options) {
 		let identifier;
@@ -532,6 +534,8 @@ class ContextModule extends Module {
 			}
 			if (!this.context && !this.options.resource) return callback();
 
+			const snapshotOptions = compilation.options.snapshot.contextModule;
+
 			compilation.fileSystemInfo.createSnapshot(
 				startTime,
 				null,
@@ -541,7 +545,7 @@ class ContextModule extends Module {
 						? [this.options.resource]
 						: /** @type {string[]} */ (this.options.resource),
 				null,
-				SNAPSHOT_OPTIONS,
+				snapshotOptions,
 				(err, snapshot) => {
 					if (err) return callback(err);
 					/** @type {BuildInfo} */
@@ -553,10 +557,10 @@ class ContextModule extends Module {
 	}
 
 	/**
-	 * @param {LazySet<string>} fileDependencies set where file dependencies are added to
-	 * @param {LazySet<string>} contextDependencies set where context dependencies are added to
-	 * @param {LazySet<string>} missingDependencies set where missing dependencies are added to
-	 * @param {LazySet<string>} buildDependencies set where build dependencies are added to
+	 * @param {FileSystemDependencies} fileDependencies set where file dependencies are added to
+	 * @param {FileSystemDependencies} contextDependencies set where context dependencies are added to
+	 * @param {FileSystemDependencies} missingDependencies set where missing dependencies are added to
+	 * @param {FileSystemDependencies} buildDependencies set where build dependencies are added to
 	 */
 	addCacheDependencies(
 		fileDependencies,
@@ -578,7 +582,7 @@ class ContextModule extends Module {
 	/**
 	 * @param {Dependency[]} dependencies all dependencies
 	 * @param {ChunkGraph} chunkGraph chunk graph
-	 * @returns {Map<string, string | number>} map with user requests
+	 * @returns {Map<string, ModuleId>} map with user requests
 	 */
 	getUserRequestMap(dependencies, chunkGraph) {
 		const moduleGraph = chunkGraph.moduleGraph;

package/lib/ContextModuleFactory.js

@@ -17,11 +17,11 @@ const { join } = require("./util/fs");
 
 /** @typedef {import("./ContextModule").ContextModuleOptions} ContextModuleOptions */
 /** @typedef {import("./ContextModule").ResolveDependenciesCallback} ResolveDependenciesCallback */
-/** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
 /** @typedef {import("./ResolverFactory")} ResolverFactory */
 /** @typedef {import("./dependencies/ContextDependency")} ContextDependency */
+/** @typedef {import("./dependencies/ContextDependency").ContextOptions} ContextOptions */
 /** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
 /**
  * @template T
@@ -31,9 +31,23 @@ const { join } = require("./util/fs");
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {{ context: string, request: string }} ContextAlternativeRequest */
 
+/**
+ * @typedef {object} ContextResolveData
+ * @property {string} context
+ * @property {string} request
+ * @property {ModuleFactoryCreateData["resolveOptions"]} resolveOptions
+ * @property {LazySet<string>} fileDependencies
+ * @property {LazySet<string>} missingDependencies
+ * @property {LazySet<string>} contextDependencies
+ * @property {ContextDependency[]} dependencies
+ */
+
+/** @typedef {ContextResolveData & ContextOptions} BeforeContextResolveData */
+/** @typedef {BeforeContextResolveData & { resource: string | string[], resourceQuery: string | undefined, resourceFragment: string | undefined, resolveDependencies: ContextModuleFactory["resolveDependencies"] }} AfterContextResolveData */
+
 const EMPTY_RESOLVE_OPTIONS = {};
 
-module.exports = class ContextModuleFactory extends ModuleFactory {
+class ContextModuleFactory extends ModuleFactory {
 	/**
 	 * @param {ResolverFactory} resolverFactory resolverFactory
 	 */
@@ -45,9 +59,9 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 			"options"
 		]);
 		this.hooks = Object.freeze({
-			/** @type {AsyncSeriesWaterfallHook<[TODO]>} */
+			/** @type {AsyncSeriesWaterfallHook<[BeforeContextResolveData], BeforeContextResolveData | false | void>} */
 			beforeResolve: new AsyncSeriesWaterfallHook(["data"]),
-			/** @type {AsyncSeriesWaterfallHook<[TODO]>} */
+			/** @type {AsyncSeriesWaterfallHook<[AfterContextResolveData], AfterContextResolveData | false | void>} */
 			afterResolve: new AsyncSeriesWaterfallHook(["data"]),
 			/** @type {SyncWaterfallHook<[string[]]>} */
 			contextModuleFiles: new SyncWaterfallHook(["files"]),
@@ -91,9 +105,9 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 	 */
 	create(data, callback) {
 		const context = data.context;
-		const dependencies = data.dependencies;
+		const dependencies = /** @type {ContextDependency[]} */ (data.dependencies);
 		const resolveOptions = data.resolveOptions;
-		const dependency = /** @type {ContextDependency} */ (dependencies[0]);
+		const dependency = dependencies[0];
 		const fileDependencies = new LazySet();
 		const missingDependencies = new LazySet();
 		const contextDependencies = new LazySet();
@@ -130,7 +144,9 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 				const request = beforeResolveResult.request;
 				const resolveOptions = beforeResolveResult.resolveOptions;
 
+				/** @type {undefined | string[]} */
 				let loaders;
+				/** @type {undefined | string} */
 				let resource;
 				let loadersPrefix = "";
 				const idx = request.lastIndexOf("!");
@@ -170,7 +186,7 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 				asyncLib.parallel(
 					[
 						(callback) => {
-							const results = /** @type ResolveRequest[] */ ([]);
+							const results = /** @type {ResolveRequest[]} */ ([]);
 							/**
 							 * @param {ResolveRequest} obj obj
 							 * @returns {void}
@@ -210,7 +226,7 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 										},
 										(err, result) => {
 											if (err) return callback(err);
-											callback(null, /** @type {string} */ (result));
+											callback(null, result);
 										}
 									);
 								},
@@ -241,8 +257,8 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 									(loaderResult.length > 0 ? "!" : ""),
 								resource:
 									contextResult.length > 1
-										? contextResult.map((r) => r.path)
-										: contextResult[0].path,
+										? /** @type {string[]} */ (contextResult.map((r) => r.path))
+										: /** @type {string} */ (contextResult[0].path),
 								resolveDependencies: this.resolveDependencies.bind(this),
 								resourceQuery: contextResult[0].query,
 								resourceFragment: contextResult[0].fragment,
@@ -337,6 +353,7 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 		 * @param {string} directory directory
 		 * @param {(context: string, subResource: string, callback: () => void) => void} addSubDirectory addSubDirectoryFn
 		 * @param {ResolveDependenciesCallback} callback callback
+		 * @returns {void}
 		 */
 		const addDirectory = (ctx, directory, addSubDirectory, callback) => {
 			fs.readdir(directory, (err, files) => {
@@ -478,4 +495,6 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 			});
 		}
 	}
-};
+}
+
+module.exports = ContextModuleFactory;

package/lib/ContextReplacementPlugin.js

@@ -10,6 +10,8 @@ const { join } = require("./util/fs");
 
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./ContextModule").ContextModuleOptions} ContextModuleOptions */
+/** @typedef {import("./ContextModuleFactory").BeforeContextResolveData} BeforeContextResolveData */
+/** @typedef {import("./ContextModuleFactory").AfterContextResolveData} AfterContextResolveData */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
 /** @typedef {Record<string, string>} NewContentCreateContextMap */
@@ -19,7 +21,7 @@ const PLUGIN_NAME = "ContextReplacementPlugin";
 class ContextReplacementPlugin {
 	/**
 	 * @param {RegExp} resourceRegExp A regular expression that determines which files will be selected
-	 * @param {(string | ((context: TODO) => void) | RegExp | boolean)=} newContentResource A new resource to replace the match
+	 * @param {(string | ((context: BeforeContextResolveData | AfterContextResolveData) => void) | RegExp | boolean)=} newContentResource A new resource to replace the match
 	 * @param {(boolean | NewContentCreateContextMap | RegExp)=} newContentRecursive If true, all subdirectories are searched for matches
 	 * @param {RegExp=} newContentRegExp A regular expression that determines which files will be selected
 	 */
@@ -122,7 +124,14 @@ class ContextReplacementPlugin {
 			});
 			cmf.hooks.afterResolve.tap(PLUGIN_NAME, (result) => {
 				if (!result) return;
-				if (resourceRegExp.test(result.resource)) {
+				const isMatchResourceRegExp = () => {
+					if (Array.isArray(result.resource)) {
+						return result.resource.some((item) => resourceRegExp.test(item));
+					}
+
+					return resourceRegExp.test(result.resource);
+				};
+				if (isMatchResourceRegExp()) {
 					if (newContentResource !== undefined) {
 						if (
 							newContentResource.startsWith("/") ||
@@ -130,10 +139,15 @@ class ContextReplacementPlugin {
 						) {
 							result.resource = newContentResource;
 						} else {
+							const rootPath =
+								typeof result.resource === "string"
+									? result.resource
+									: /** @type {string} */
+										(result.resource.find((item) => resourceRegExp.test(item)));
 							result.resource = join(
 								/** @type {InputFileSystem} */
 								(compiler.inputFileSystem),
-								result.resource,
+								rootPath,
 								newContentResource
 							);
 						}
@@ -153,18 +167,27 @@ class ContextReplacementPlugin {
 					if (typeof newContentCallback === "function") {
 						const origResource = result.resource;
 						newContentCallback(result);
-						if (
-							result.resource !== origResource &&
-							!result.resource.startsWith("/") &&
-							(result.resource.length <= 1 || result.resource[1] !== ":")
-						) {
-							// When the function changed it to an relative path
-							result.resource = join(
-								/** @type {InputFileSystem} */
-								(compiler.inputFileSystem),
-								origResource,
-								result.resource
-							);
+						if (result.resource !== origResource) {
+							const newResource = Array.isArray(result.resource)
+								? result.resource
+								: [result.resource];
+
+							for (let i = 0; i < newResource.length; i++) {
+								if (
+									!newResource[i].startsWith("/") &&
+									(newResource[i].length <= 1 || newResource[i][1] !== ":")
+								) {
+									// When the function changed it to an relative path
+									newResource[i] = join(
+										/** @type {InputFileSystem} */
+										(compiler.inputFileSystem),
+										origResource[i],
+										newResource[i]
+									);
+								}
+							}
+
+							result.resource = newResource;
 						}
 					} else {
 						for (const d of result.dependencies) {