webpack 5.97.1 → 5.104.1

package/lib/ContextModule.js

@@ -9,43 +9,51 @@ const { OriginalSource, RawSource } = require("webpack-sources");
 const AsyncDependenciesBlock = require("./AsyncDependenciesBlock");
 const { makeWebpackError } = require("./HookWebpackError");
 const Module = require("./Module");
-const { JS_TYPES } = require("./ModuleSourceTypesConstants");
+const {
+	JAVASCRIPT_TYPE,
+	JAVASCRIPT_TYPES
+} = require("./ModuleSourceTypeConstants");
 const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
 const WebpackError = require("./WebpackError");
 const {
 	compareLocations,
-	concatComparators,
+	compareModulesById,
 	compareSelect,
-	keepOriginalOrder,
-	compareModulesById
+	concatComparators,
+	keepOriginalOrder
 } = require("./util/comparators");
 const {
 	contextify,
-	parseResource,
-	makePathsRelative
+	makePathsRelative,
+	parseResource
 } = require("./util/identifier");
 const makeSerializable = require("./util/makeSerializable");
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
+/** @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 */
@@ -53,7 +61,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 */
@@ -62,26 +69,26 @@ 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
  */
 
 /**
  * @typedef {object} ContextModuleOptionsExtras
- * @property {false|string|string[]} resource
+ * @property {false | string | string[]} resource
  * @property {string=} resourceQuery
  * @property {string=} resourceFragment
- * @property {TODO} resolveOptions
+ * @property {ResolveOptions=} resolveOptions
  */
 
 /** @typedef {ContextOptions & ContextModuleOptionsExtras} ContextModuleOptions */
@@ -90,6 +97,7 @@ const makeSerializable = require("./util/makeSerializable");
  * @callback ResolveDependenciesCallback
  * @param {Error | null} err
  * @param {ContextElementDependency[]=} dependencies
+ * @returns {void}
  */
 
 /**
@@ -103,8 +111,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
@@ -159,7 +165,7 @@ class ContextModule extends Module {
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
-		return JS_TYPES;
+		return JAVASCRIPT_TYPES;
 	}
 
 	/**
@@ -251,10 +257,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;
 	}
 
@@ -280,7 +288,7 @@ class ContextModule extends Module {
 			identifier = `${requestShortener.shorten(`${this.options.resource}`)}/`;
 		} else {
 			identifier = this.options.resource
-				.map(r => `${requestShortener.shorten(r)}/`)
+				.map((r) => `${requestShortener.shorten(r)}/`)
 				.join(" ");
 		}
 		if (this.options.resourceQuery) {
@@ -306,7 +314,7 @@ class ContextModule extends Module {
 		}
 		if (this.options.referencedExports) {
 			identifier += ` referencedExports: ${this.options.referencedExports
-				.map(e => e.join("."))
+				.map((e) => e.join("."))
 				.join(", ")}`;
 		}
 		if (this.options.chunkName) {
@@ -331,7 +339,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;
@@ -352,7 +360,7 @@ class ContextModule extends Module {
 			identifier = "false";
 		} else {
 			identifier = this.options.resource
-				.map(res =>
+				.map((res) =>
 					contextify(options.context, res, options.associatedObjectForCache)
 				)
 				.join(" ");
@@ -383,7 +391,7 @@ class ContextModule extends Module {
 		}
 		if (this.options.referencedExports) {
 			identifier += ` referencedExports: ${this.options.referencedExports
-				.map(e => e.join("."))
+				.map((e) => e.join("."))
 				.join(", ")}`;
 		}
 
@@ -399,7 +407,7 @@ class ContextModule extends Module {
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild({ fileSystemInfo }, callback) {
@@ -409,8 +417,9 @@ class ContextModule extends Module {
 		const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
 
 		// always build when we have no snapshot and context
-		if (!buildInfo.snapshot)
+		if (!buildInfo.snapshot) {
 			return callback(null, Boolean(this.context || this.options.resource));
+		}
 
 		fileSystemInfo.checkSnapshotValid(buildInfo.snapshot, (err, valid) => {
 			callback(err, !valid);
@@ -422,7 +431,7 @@ class ContextModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {BuildCallback} callback callback function
 	 * @returns {void}
 	 */
 	build(options, compilation, resolver, fs, callback) {
@@ -462,7 +471,7 @@ class ContextModule extends Module {
 			}
 			dependencies.sort(
 				concatComparators(
-					compareSelect(a => a.loc, compareLocations),
+					compareSelect((a) => a.loc, compareLocations),
 					keepOriginalOrder(this.dependencies)
 				)
 			);
@@ -528,6 +537,8 @@ class ContextModule extends Module {
 			}
 			if (!this.context && !this.options.resource) return callback();
 
+			const snapshotOptions = compilation.options.snapshot.contextModule;
+
 			compilation.fileSystemInfo.createSnapshot(
 				startTime,
 				null,
@@ -537,7 +548,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} */
@@ -549,10 +560,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,
@@ -574,7 +585,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;
@@ -584,7 +595,7 @@ class ContextModule extends Module {
 		const sortedDependencies =
 			/** @type {ContextElementDependency[]} */
 			(dependencies)
-				.filter(dependency => moduleGraph.getModule(dependency))
+				.filter((dependency) => moduleGraph.getModule(dependency))
 				.sort((a, b) => {
 					if (a.userRequest === b.userRequest) {
 						return 0;
@@ -617,7 +628,8 @@ class ContextModule extends Module {
 		// therefore the order of this is !important!
 		const sortedModules = dependencies
 			.map(
-				dependency => /** @type {Module} */ (moduleGraph.getModule(dependency))
+				(dependency) =>
+					/** @type {Module} */ (moduleGraph.getModule(dependency))
 			)
 			.filter(Boolean)
 			.sort(comparator);
@@ -941,7 +953,7 @@ module.exports = webpackAsyncContext;`;
 		let hasMultipleOrNoChunks = false;
 		let hasNoChunk = true;
 		const fakeMap = this.getFakeMap(
-			blocks.map(b => b.dependencies[0]),
+			blocks.map((b) => b.dependencies[0]),
 			chunkGraph
 		);
 		const hasFakeMap = typeof fakeMap === "object";
@@ -950,7 +962,7 @@ module.exports = webpackAsyncContext;`;
 		 * @type {Item[]}
 		 */
 		const items = blocks
-			.map(block => {
+			.map((block) => {
 				const dependency =
 					/** @type {ContextElementDependency} */
 					(block.dependencies[0]);
@@ -962,7 +974,7 @@ module.exports = webpackAsyncContext;`;
 					chunks: undefined
 				};
 			})
-			.filter(item => item.module);
+			.filter((item) => item.module);
 		for (const item of items) {
 			const chunkGroup = chunkGraph.getBlockChunkGroup(item.block);
 			const chunks = (chunkGroup && chunkGroup.chunks) || [];
@@ -993,10 +1005,11 @@ module.exports = webpackAsyncContext;`;
 				if (hasFakeMap) {
 					arrayStart.push(fakeMap[moduleId]);
 				}
-				map[item.userRequest] = arrayStart.concat(
-					/** @type {Chunk[]} */
-					(item.chunks).map(chunk => /** @type {ChunkId} */ (chunk.id))
-				);
+				map[item.userRequest] = [
+					...arrayStart,
+					.../** @type {Chunk[]} */
+					(item.chunks).map((chunk) => /** @type {ChunkId} */ (chunk.id))
+				];
 			}
 		}
 
@@ -1174,7 +1187,7 @@ module.exports = webpackEmptyAsyncContext;`;
 		const { chunkGraph, compilation } = context;
 		const sources = new Map();
 		sources.set(
-			"javascript",
+			JAVASCRIPT_TYPE,
 			this.getSource(
 				this.getSourceString(this.options.mode, context),
 				compilation
@@ -1183,11 +1196,13 @@ module.exports = webpackEmptyAsyncContext;`;
 		const set = new Set();
 		const allDeps =
 			this.dependencies.length > 0
-				? /** @type {ContextElementDependency[]} */ (this.dependencies).slice()
+				? /** @type {ContextElementDependency[]} */ [...this.dependencies]
 				: [];
-		for (const block of this.blocks)
-			for (const dep of block.dependencies)
+		for (const block of this.blocks) {
+			for (const dep of block.dependencies) {
 				allDeps.push(/** @type {ContextElementDependency} */ (dep));
+			}
+		}
 		set.add(RuntimeGlobals.module);
 		set.add(RuntimeGlobals.hasOwnProperty);
 		if (allDeps.length > 0) {

package/lib/ContextModuleFactory.js

@@ -15,14 +15,16 @@ const { cachedSetProperty } = require("./util/cleverMerge");
 const { createFakeHook } = require("./util/deprecation");
 const { join } = require("./util/fs");
 
+/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Compilation").FileSystemDependencies} FileSystemDependencies */
 /** @typedef {import("./ContextModule").ContextModuleOptions} ContextModuleOptions */
 /** @typedef {import("./ContextModule").ResolveDependenciesCallback} ResolveDependenciesCallback */
-/** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
 /** @typedef {import("./ResolverFactory")} ResolverFactory */
 /** @typedef {import("./dependencies/ContextDependency")} ContextDependency */
-/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
+/** @typedef {import("./dependencies/ContextDependency").ContextOptions} ContextOptions */
+
 /**
  * @template T
  * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T>
@@ -31,9 +33,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 {FileSystemDependencies} fileDependencies
+ * @property {FileSystemDependencies} missingDependencies
+ * @property {FileSystemDependencies} 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 +61,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"]),
@@ -56,7 +72,7 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 				{
 					name: "alternatives",
 					/** @type {AsyncSeriesWaterfallHook<[ContextAlternativeRequest[]]>["intercept"]} */
-					intercept: interceptor => {
+					intercept: (interceptor) => {
 						throw new Error(
 							"Intercepting fake hook ContextModuleFactory.hooks.alternatives is not possible, use ContextModuleFactory.hooks.alternativeRequests instead"
 						);
@@ -86,14 +102,14 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
+	 * @param {ModuleFactoryCallback} callback callback
 	 * @returns {void}
 	 */
 	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 +146,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("!");
@@ -169,13 +187,13 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 
 				asyncLib.parallel(
 					[
-						callback => {
-							const results = /** @type ResolveRequest[] */ ([]);
+						(callback) => {
+							const results = /** @type {ResolveRequest[]} */ ([]);
 							/**
 							 * @param {ResolveRequest} obj obj
 							 * @returns {void}
 							 */
-							const yield_ = obj => {
+							const yield_ = (obj) => {
 								results.push(obj);
 							};
 
@@ -189,13 +207,13 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 									contextDependencies,
 									yield: yield_
 								},
-								err => {
+								(err) => {
 									if (err) return callback(err);
 									callback(null, results);
 								}
 							);
 						},
-						callback => {
+						(callback) => {
 							asyncLib.map(
 								loaders,
 								(loader, callback) => {
@@ -210,7 +228,7 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 										},
 										(err, result) => {
 											if (err) return callback(err);
-											callback(null, /** @type {string} */ (result));
+											callback(null, result);
 										}
 									);
 								},
@@ -230,7 +248,7 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 							/** @type {[ResolveRequest[], string[]]} */ (result);
 						if (contextResult.length > 1) {
 							const first = contextResult[0];
-							contextResult = contextResult.filter(r => r.path);
+							contextResult = contextResult.filter((r) => r.path);
 							if (contextResult.length === 0) contextResult.push(first);
 						}
 						this.hooks.afterResolve.callAsync(
@@ -241,8 +259,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,
@@ -335,23 +353,25 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 		/**
 		 * @param {string} ctx context
 		 * @param {string} directory directory
-		 * @param {function(string, string, function(): void): void} addSubDirectory addSubDirectoryFn
+		 * @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) => {
 				if (err) return callback(err);
 				const processedFiles = cmf.hooks.contextModuleFiles.call(
-					/** @type {string[]} */ (files).map(file => file.normalize("NFC"))
+					/** @type {string[]} */ (files).map((file) => file.normalize("NFC"))
 				);
-				if (!processedFiles || processedFiles.length === 0)
+				if (!processedFiles || processedFiles.length === 0) {
 					return callback(null, []);
+				}
 				asyncLib.map(
-					processedFiles.filter(p => p.indexOf(".") !== 0),
+					processedFiles.filter((p) => p.indexOf(".") !== 0),
 					(segment, callback) => {
 						const subResource = join(fs, directory, segment);
 
-						if (!exclude || !subResource.match(exclude)) {
+						if (!exclude || !exclude.test(subResource)) {
 							fs.stat(subResource, (err, _stat) => {
 								if (err) {
 									if (err.code === "ENOENT") {
@@ -369,7 +389,7 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 									addSubDirectory(ctx, subResource, callback);
 								} else if (
 									stat.isFile() &&
-									(!include || subResource.match(include))
+									(!include || include.test(subResource))
 								) {
 									/** @type {{ context: string, request: string }} */
 									const obj = {
@@ -386,10 +406,10 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 												null,
 												/** @type {ContextAlternativeRequest[]} */
 												(alternatives)
-													.filter(obj =>
+													.filter((obj) =>
 														regExp.test(/** @type {string} */ (obj.request))
 													)
-													.map(obj => {
+													.map((obj) => {
 														const dep = new ContextElementDependency(
 															`${obj.request}${resourceQuery}${resourceFragment}`,
 															obj.request,
@@ -397,8 +417,7 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 															/** @type {string} */
 															(category),
 															referencedExports,
-															/** @type {TODO} */
-															(obj.context),
+															obj.context,
 															attributes
 														);
 														dep.optional = true;
@@ -478,4 +497,6 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 			});
 		}
 	}
-};
+}
+
+module.exports = ContextModuleFactory;