webpack 5.100.1 → 5.101.0

package/lib/Compiler.js

@@ -125,7 +125,7 @@ const webpack = require(".");
  * @param {string[]} array an array
  * @returns {boolean} true, if the array is sorted
  */
-const isSorted = array => {
+const isSorted = (array) => {
 	for (let i = 1; i < array.length; i++) {
 		if (array[i - 1] > array[i]) return false;
 	}
@@ -154,7 +154,7 @@ const sortObject = (obj, keys) => {
 const includesHash = (filename, hashes) => {
 	if (!hashes) return false;
 	if (Array.isArray(hashes)) {
-		return hashes.some(hash => filename.includes(hash));
+		return hashes.some((hash) => filename.includes(hash));
 	}
 	return filename.includes(hashes);
 };
@@ -388,7 +388,7 @@ class Compiler {
 					this.infrastructureLogger(name, type, args);
 				}
 			},
-			childName => {
+			(childName) => {
 				if (typeof name === "function") {
 					if (typeof childName === "function") {
 						return this.getInfrastructureLogger(() => {
@@ -540,7 +540,7 @@ class Compiler {
 				compilation.startTime = startTime;
 				compilation.endTime = Date.now();
 				const stats = new Stats(compilation);
-				this.hooks.done.callAsync(stats, err => {
+				this.hooks.done.callAsync(stats, (err) => {
 					if (err) return finalCallback(err);
 					return finalCallback(null, stats);
 				});
@@ -550,7 +550,7 @@ class Compiler {
 			process.nextTick(() => {
 				logger = compilation.getLogger("webpack.Compiler");
 				logger.time("emitAssets");
-				this.emitAssets(compilation, err => {
+				this.emitAssets(compilation, (err) => {
 					/** @type {Logger} */
 					(logger).timeEnd("emitAssets");
 					if (err) return finalCallback(err);
@@ -563,12 +563,12 @@ class Compiler {
 						/** @type {Logger} */
 						(logger).time("done hook");
 						const stats = new Stats(compilation);
-						this.hooks.done.callAsync(stats, err => {
+						this.hooks.done.callAsync(stats, (err) => {
 							/** @type {Logger} */
 							(logger).timeEnd("done hook");
 							if (err) return finalCallback(err);
 
-							this.hooks.additionalPass.callAsync(err => {
+							this.hooks.additionalPass.callAsync((err) => {
 								if (err) return finalCallback(err);
 								this.compile(onCompiled);
 							});
@@ -578,7 +578,7 @@ class Compiler {
 
 					/** @type {Logger} */
 					(logger).time("emitRecords");
-					this.emitRecords(err => {
+					this.emitRecords((err) => {
 						/** @type {Logger} */
 						(logger).timeEnd("emitRecords");
 						if (err) return finalCallback(err);
@@ -588,13 +588,13 @@ class Compiler {
 						/** @type {Logger} */
 						(logger).time("done hook");
 						const stats = new Stats(compilation);
-						this.hooks.done.callAsync(stats, err => {
+						this.hooks.done.callAsync(stats, (err) => {
 							/** @type {Logger} */
 							(logger).timeEnd("done hook");
 							if (err) return finalCallback(err);
 							this.cache.storeBuildDependencies(
 								compilation.buildDependencies,
-								err => {
+								(err) => {
 									if (err) return finalCallback(err);
 									return finalCallback(null, stats);
 								}
@@ -606,13 +606,13 @@ class Compiler {
 		};
 
 		const run = () => {
-			this.hooks.beforeRun.callAsync(this, err => {
+			this.hooks.beforeRun.callAsync(this, (err) => {
 				if (err) return finalCallback(err);
 
-				this.hooks.run.callAsync(this, err => {
+				this.hooks.run.callAsync(this, (err) => {
 					if (err) return finalCallback(err);
 
-					this.readRecords(err => {
+					this.readRecords((err) => {
 						if (err) return finalCallback(err);
 
 						this.compile(onCompiled);
@@ -622,7 +622,7 @@ class Compiler {
 		};
 
 		if (this.idle) {
-			this.cache.endIdle(err => {
+			this.cache.endIdle((err) => {
 				if (err) return finalCallback(err);
 
 				this.idle = false;
@@ -706,7 +706,7 @@ class Compiler {
 		 * @param {Error=} err error
 		 * @returns {void}
 		 */
-		const emitFiles = err => {
+		const emitFiles = (err) => {
 			if (err) return callback(err);
 
 			const assets = compilation.getAssets();
@@ -739,7 +739,7 @@ class Compiler {
 					 * @param {Error=} err error
 					 * @returns {void}
 					 */
-					const writeOut = err => {
+					const writeOut = (err) => {
 						if (err) return callback(err);
 						const targetPath = join(
 							/** @type {OutputFileSystem} */
@@ -838,9 +838,9 @@ ${other}`);
 						 * @param {Buffer} content content to be written
 						 * @returns {void}
 						 */
-						const doWrite = content => {
+						const doWrite = (content) => {
 							/** @type {OutputFileSystem} */
-							(this.outputFileSystem).writeFile(targetPath, content, err => {
+							(this.outputFileSystem).writeFile(targetPath, content, (err) => {
 								if (err) return callback(err);
 
 								// information marker that the asset has been emitted
@@ -871,7 +871,7 @@ ${other}`);
 						/**
 						 * @param {number} size size
 						 */
-						const updateWithReplacementSource = size => {
+						const updateWithReplacementSource = (size) => {
 							updateFileWithReplacementSource(
 								file,
 								/** @type {CacheEntry} */ (cacheEntry),
@@ -915,7 +915,7 @@ ${other}`);
 						 * @param {IStats} stats stats
 						 * @returns {void}
 						 */
-						const processExistingFile = stats => {
+						const processExistingFile = (stats) => {
 							// skip emitting if it's already there and an immutable file
 							if (immutable) {
 								updateWithReplacementSource(/** @type {number} */ (stats.size));
@@ -1015,7 +1015,7 @@ ${other}`);
 						writeOut();
 					}
 				},
-				err => {
+				(err) => {
 					// Clear map to free up memory
 					caseInsensitiveMap.clear();
 					if (err) {
@@ -1025,7 +1025,7 @@ ${other}`);
 
 					this._assetEmittingPreviousFiles = allTargetPaths;
 
-					this.hooks.afterEmit.callAsync(compilation, err => {
+					this.hooks.afterEmit.callAsync(compilation, (err) => {
 						if (err) return callback(err);
 
 						return callback();
@@ -1034,7 +1034,7 @@ ${other}`);
 			);
 		};
 
-		this.hooks.emit.callAsync(compilation, err => {
+		this.hooks.emit.callAsync(compilation, (err) => {
 			if (err) return callback(err);
 			outputPath = compilation.getPath(this.outputPath, {});
 			mkdirp(
@@ -1054,10 +1054,10 @@ ${other}`);
 			if (this.recordsOutputPath) {
 				asyncLib.parallel(
 					[
-						cb => this.hooks.emitRecords.callAsync(cb),
+						(cb) => this.hooks.emitRecords.callAsync(cb),
 						this._emitRecords.bind(this)
 					],
-					err => callback(err)
+					(err) => callback(err)
 				);
 			} else {
 				this.hooks.emitRecords.callAsync(callback);
@@ -1111,7 +1111,7 @@ ${other}`);
 		mkdirp(
 			/** @type {OutputFileSystem} */ (this.outputFileSystem),
 			recordsOutputPathDirectory,
-			err => {
+			(err) => {
 				if (err) return callback(err);
 				writeFile();
 			}
@@ -1127,10 +1127,10 @@ ${other}`);
 			if (this.recordsInputPath) {
 				asyncLib.parallel(
 					[
-						cb => this.hooks.readRecords.callAsync(cb),
+						(cb) => this.hooks.readRecords.callAsync(cb),
 						this._readRecords.bind(this)
 					],
-					err => callback(err)
+					(err) => callback(err)
 				);
 			} else {
 				this.records = {};
@@ -1154,7 +1154,7 @@ ${other}`);
 			return callback();
 		}
 		/** @type {InputFileSystem} */
-		(this.inputFileSystem).stat(this.recordsInputPath, err => {
+		(this.inputFileSystem).stat(this.recordsInputPath, (err) => {
 			// It doesn't exist
 			// We can ignore this.
 			if (err) return callback();
@@ -1339,7 +1339,7 @@ ${other}`);
 	 */
 	compile(callback) {
 		const params = this.newCompilationParams();
-		this.hooks.beforeCompile.callAsync(params, err => {
+		this.hooks.beforeCompile.callAsync(params, (err) => {
 			if (err) return callback(err);
 
 			this.hooks.compile.call(params);
@@ -1349,28 +1349,28 @@ ${other}`);
 			const logger = compilation.getLogger("webpack.Compiler");
 
 			logger.time("make hook");
-			this.hooks.make.callAsync(compilation, err => {
+			this.hooks.make.callAsync(compilation, (err) => {
 				logger.timeEnd("make hook");
 				if (err) return callback(err);
 
 				logger.time("finish make hook");
-				this.hooks.finishMake.callAsync(compilation, err => {
+				this.hooks.finishMake.callAsync(compilation, (err) => {
 					logger.timeEnd("finish make hook");
 					if (err) return callback(err);
 
 					process.nextTick(() => {
 						logger.time("finish compilation");
-						compilation.finish(err => {
+						compilation.finish((err) => {
 							logger.timeEnd("finish compilation");
 							if (err) return callback(err);
 
 							logger.time("seal compilation");
-							compilation.seal(err => {
+							compilation.seal((err) => {
 								logger.timeEnd("seal compilation");
 								if (err) return callback(err);
 
 								logger.time("afterCompile hook");
-								this.hooks.afterCompile.callAsync(compilation, err => {
+								this.hooks.afterCompile.callAsync(compilation, (err) => {
 									logger.timeEnd("afterCompile hook");
 									if (err) return callback(err);
 
@@ -1391,12 +1391,12 @@ ${other}`);
 	close(callback) {
 		if (this.watching) {
 			// When there is still an active watching, close this first
-			this.watching.close(_err => {
+			this.watching.close((_err) => {
 				this.close(callback);
 			});
 			return;
 		}
-		this.hooks.shutdown.callAsync(err => {
+		this.hooks.shutdown.callAsync((err) => {
 			if (err) return callback(err);
 			// Get rid of reference to last compilation to avoid leaking memory
 			// We can't run this._cleanupLastCompilation() as the Stats to this compilation

package/lib/ConcatenationScope.js

@@ -30,8 +30,9 @@ class ConcatenationScope {
 	/**
 	 * @param {ModuleInfo[] | Map<Module, ModuleInfo>} modulesMap all module info by module
 	 * @param {ConcatenatedModuleInfo} currentModule the current module info
+	 * @param {Set<string>} usedNames all used names
 	 */
-	constructor(modulesMap, currentModule) {
+	constructor(modulesMap, currentModule, usedNames) {
 		this._currentModule = currentModule;
 		if (Array.isArray(modulesMap)) {
 			const map = new Map();
@@ -40,6 +41,7 @@ class ConcatenationScope {
 			}
 			modulesMap = map;
 		}
+		this.usedNames = usedNames;
 		this._modulesMap = modulesMap;
 	}
 
@@ -77,6 +79,30 @@ class ConcatenationScope {
 		}
 	}
 
+	/**
+	 * @param {string} exportName name of the export
+	 * @returns {string | undefined} the expression of the export
+	 */
+	getRawExport(exportName) {
+		if (!this._currentModule.rawExportMap) {
+			return undefined;
+		}
+		return this._currentModule.rawExportMap.get(exportName);
+	}
+
+	/**
+	 * @param {string} exportName name of the export
+	 * @param {string} expression expression to be used
+	 */
+	setRawExportMap(exportName, expression) {
+		if (!this._currentModule.rawExportMap) {
+			this._currentModule.rawExportMap = new Map();
+		}
+		if (this._currentModule.rawExportMap.has(exportName)) {
+			this._currentModule.rawExportMap.set(exportName, expression);
+		}
+	}
+
 	/**
 	 * @param {string} symbol identifier of the export in source code
 	 */
@@ -84,6 +110,18 @@ class ConcatenationScope {
 		this._currentModule.namespaceExportSymbol = symbol;
 	}
 
+	/**
+	 * @param {string} symbol identifier of the export in source code
+	 * @returns {boolean} registered success
+	 */
+	registerUsedName(symbol) {
+		if (this.usedNames.has(symbol)) {
+			return false;
+		}
+		this.usedNames.add(symbol);
+		return true;
+	}
+
 	/**
 	 * @param {Module} module the referenced module
 	 * @param {Partial<ModuleReferenceOptions>} options options

package/lib/ConstPlugin.js

@@ -159,9 +159,9 @@ class ConstPlugin {
 				/**
 				 * @param {JavascriptParser} parser the parser
 				 */
-				const handler = parser => {
-					parser.hooks.terminate.tap(PLUGIN_NAME, _statement => true);
-					parser.hooks.statementIf.tap(PLUGIN_NAME, statement => {
+				const handler = (parser) => {
+					parser.hooks.terminate.tap(PLUGIN_NAME, (_statement) => true);
+					parser.hooks.statementIf.tap(PLUGIN_NAME, (statement) => {
 						if (parser.scope.isAsmJs) return;
 						const param = parser.evaluateExpression(statement.test);
 						const bool = param.asBool();
@@ -185,7 +185,7 @@ class ConstPlugin {
 							return bool;
 						}
 					});
-					parser.hooks.unusedStatement.tap(PLUGIN_NAME, statement => {
+					parser.hooks.unusedStatement.tap(PLUGIN_NAME, (statement) => {
 						if (
 							parser.scope.isAsmJs ||
 							// Check top level scope here again
@@ -198,7 +198,7 @@ class ConstPlugin {
 					});
 					parser.hooks.expressionConditionalOperator.tap(
 						PLUGIN_NAME,
-						expression => {
+						(expression) => {
 							if (parser.scope.isAsmJs) return;
 							const param = parser.evaluateExpression(expression.test);
 							const bool = param.asBool();
@@ -239,7 +239,7 @@ class ConstPlugin {
 					);
 					parser.hooks.expressionLogicalOperator.tap(
 						PLUGIN_NAME,
-						expression => {
+						(expression) => {
 							if (parser.scope.isAsmJs) return;
 							if (
 								expression.operator === "&&" ||
@@ -381,7 +381,7 @@ class ConstPlugin {
 							}
 						}
 					);
-					parser.hooks.optionalChaining.tap(PLUGIN_NAME, expr => {
+					parser.hooks.optionalChaining.tap(PLUGIN_NAME, (expr) => {
 						/** @type {Expression[]} */
 						const optionalExpressionsStack = [];
 						/** @type {Expression | Super} */
@@ -441,7 +441,7 @@ class ConstPlugin {
 					});
 					parser.hooks.evaluateIdentifier
 						.for("__resourceQuery")
-						.tap(PLUGIN_NAME, expr => {
+						.tap(PLUGIN_NAME, (expr) => {
 							if (parser.scope.isAsmJs) return;
 							if (!parser.state.module) return;
 							return evaluateToString(
@@ -450,7 +450,7 @@ class ConstPlugin {
 						});
 					parser.hooks.expression
 						.for("__resourceQuery")
-						.tap(PLUGIN_NAME, expr => {
+						.tap(PLUGIN_NAME, (expr) => {
 							if (parser.scope.isAsmJs) return;
 							if (!parser.state.module) return;
 							const dep = new CachedConstDependency(
@@ -467,7 +467,7 @@ class ConstPlugin {
 
 					parser.hooks.evaluateIdentifier
 						.for("__resourceFragment")
-						.tap(PLUGIN_NAME, expr => {
+						.tap(PLUGIN_NAME, (expr) => {
 							if (parser.scope.isAsmJs) return;
 							if (!parser.state.module) return;
 							return evaluateToString(
@@ -476,7 +476,7 @@ class ConstPlugin {
 						});
 					parser.hooks.expression
 						.for("__resourceFragment")
-						.tap(PLUGIN_NAME, expr => {
+						.tap(PLUGIN_NAME, (expr) => {
 							if (parser.scope.isAsmJs) return;
 							if (!parser.state.module) return;
 							const dep = new CachedConstDependency(

package/lib/ContextExclusionPlugin.js

@@ -23,9 +23,9 @@ class ContextExclusionPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.contextModuleFactory.tap(PLUGIN_NAME, cmf => {
-			cmf.hooks.contextModuleFiles.tap(PLUGIN_NAME, files =>
-				files.filter(filePath => !this.negativeMatcher.test(filePath))
+		compiler.hooks.contextModuleFactory.tap(PLUGIN_NAME, (cmf) => {
+			cmf.hooks.contextModuleFiles.tap(PLUGIN_NAME, (files) =>
+				files.filter((filePath) => !this.negativeMatcher.test(filePath))
 			);
 		});
 	}

package/lib/ContextModule.js

@@ -283,7 +283,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) {
@@ -309,7 +309,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) {
@@ -355,7 +355,7 @@ class ContextModule extends Module {
 			identifier = "false";
 		} else {
 			identifier = this.options.resource
-				.map(res =>
+				.map((res) =>
 					contextify(options.context, res, options.associatedObjectForCache)
 				)
 				.join(" ");
@@ -386,7 +386,7 @@ class ContextModule extends Module {
 		}
 		if (this.options.referencedExports) {
 			identifier += ` referencedExports: ${this.options.referencedExports
-				.map(e => e.join("."))
+				.map((e) => e.join("."))
 				.join(", ")}`;
 		}
 
@@ -466,7 +466,7 @@ class ContextModule extends Module {
 			}
 			dependencies.sort(
 				concatComparators(
-					compareSelect(a => a.loc, compareLocations),
+					compareSelect((a) => a.loc, compareLocations),
 					keepOriginalOrder(this.dependencies)
 				)
 			);
@@ -588,7 +588,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;
@@ -621,7 +621,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);
@@ -945,7 +946,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";
@@ -954,7 +955,7 @@ module.exports = webpackAsyncContext;`;
 		 * @type {Item[]}
 		 */
 		const items = blocks
-			.map(block => {
+			.map((block) => {
 				const dependency =
 					/** @type {ContextElementDependency} */
 					(block.dependencies[0]);
@@ -966,7 +967,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) || [];
@@ -1000,7 +1001,7 @@ module.exports = webpackAsyncContext;`;
 				map[item.userRequest] = [
 					...arrayStart,
 					.../** @type {Chunk[]} */
-					(item.chunks).map(chunk => /** @type {ChunkId} */ (chunk.id))
+					(item.chunks).map((chunk) => /** @type {ChunkId} */ (chunk.id))
 				];
 			}
 		}

package/lib/ContextModuleFactory.js

@@ -56,7 +56,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"
 						);
@@ -169,13 +169,13 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 
 				asyncLib.parallel(
 					[
-						callback => {
+						(callback) => {
 							const results = /** @type ResolveRequest[] */ ([]);
 							/**
 							 * @param {ResolveRequest} obj obj
 							 * @returns {void}
 							 */
-							const yield_ = obj => {
+							const yield_ = (obj) => {
 								results.push(obj);
 							};
 
@@ -189,13 +189,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) => {
@@ -230,7 +230,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,7 +241,7 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 									(loaderResult.length > 0 ? "!" : ""),
 								resource:
 									contextResult.length > 1
-										? contextResult.map(r => r.path)
+										? contextResult.map((r) => r.path)
 										: contextResult[0].path,
 								resolveDependencies: this.resolveDependencies.bind(this),
 								resourceQuery: contextResult[0].query,
@@ -342,13 +342,13 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 			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) {
 					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);
 
@@ -387,10 +387,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,

package/lib/ContextReplacementPlugin.js

@@ -97,8 +97,8 @@ class ContextReplacementPlugin {
 		const newContentRegExp = this.newContentRegExp;
 		const newContentCreateContextMap = this.newContentCreateContextMap;
 
-		compiler.hooks.contextModuleFactory.tap(PLUGIN_NAME, cmf => {
-			cmf.hooks.beforeResolve.tap(PLUGIN_NAME, result => {
+		compiler.hooks.contextModuleFactory.tap(PLUGIN_NAME, (cmf) => {
+			cmf.hooks.beforeResolve.tap(PLUGIN_NAME, (result) => {
 				if (!result) return;
 				if (resourceRegExp.test(result.request)) {
 					if (newContentResource !== undefined) {
@@ -120,7 +120,7 @@ class ContextReplacementPlugin {
 				}
 				return result;
 			});
-			cmf.hooks.afterResolve.tap(PLUGIN_NAME, result => {
+			cmf.hooks.afterResolve.tap(PLUGIN_NAME, (result) => {
 				if (!result) return;
 				if (resourceRegExp.test(result.resource)) {
 					if (newContentResource !== undefined) {
@@ -183,11 +183,11 @@ class ContextReplacementPlugin {
  * @returns {(fs: InputFileSystem, options: ContextModuleOptions, callback: (err: null | Error, dependencies?: ContextElementDependency[]) => void) => void} resolve resolve dependencies from context map function
  */
 const createResolveDependenciesFromContextMap =
-	createContextMap => (fs, options, callback) => {
+	(createContextMap) => (fs, options, callback) => {
 		createContextMap(fs, (err, map) => {
 			if (err) return callback(err);
 			const dependencies = Object.keys(map).map(
-				key =>
+				(key) =>
 					new ContextElementDependency(
 						map[key] + options.resourceQuery + options.resourceFragment,
 						key,