webpack 5.92.1 → 5.94.0

package/lib/optimize/ConcatenatedModule.js

@@ -7,6 +7,7 @@
 
 const eslintScope = require("eslint-scope");
 const Referencer = require("eslint-scope/lib/referencer");
+const { SyncBailHook } = require("tapable");
 const {
 	CachedSource,
 	ConcatSource,
@@ -61,6 +62,7 @@ const {
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../ModuleParseError")} ModuleParseError */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
@@ -127,12 +129,12 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {Module} module
  * @property {number} index
  * @property {Program | undefined} ast
- * @property {Source} internalSource
+ * @property {Source | undefined} internalSource
  * @property {ReplaceSource} source
  * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
- * @property {ReadOnlyRuntimeRequirements} runtimeRequirements
- * @property {Scope} globalScope
- * @property {Scope} moduleScope
+ * @property {ReadOnlyRuntimeRequirements | undefined} runtimeRequirements
+ * @property {Scope | undefined} globalScope
+ * @property {Scope | undefined} moduleScope
  * @property {Map<string, string>} internalNames
  * @property {Map<string, string> | undefined} exportMap
  * @property {Map<string, string> | undefined} rawExportMap
@@ -152,13 +154,13 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {Module} module
  * @property {RuntimeSpec | boolean} runtimeCondition
  * @property {number} index
- * @property {string} name
+ * @property {string | undefined} name
  * @property {boolean} interopNamespaceObjectUsed
- * @property {string} interopNamespaceObjectName
+ * @property {string | undefined} interopNamespaceObjectName
  * @property {boolean} interopNamespaceObject2Used
- * @property {string} interopNamespaceObject2Name
+ * @property {string | undefined} interopNamespaceObject2Name
  * @property {boolean} interopDefaultAccessUsed
- * @property {string} interopDefaultAccessName
+ * @property {string | undefined} interopDefaultAccessName
  */
 
 /**
@@ -208,8 +210,17 @@ const RESERVED_NAMES = new Set(
 		.split(",")
 );
 
+/**
+ * @template T
+ * @param {string} property property
+ * @param {function(T[keyof T], T[keyof T]): 0 | 1 | -1} comparator comparator
+ * @returns {Comparator<T>} comparator
+ */
 const createComparator = (property, comparator) => (a, b) =>
-	comparator(a[property], b[property]);
+	comparator(
+		a[/** @type {keyof T} */ (property)],
+		b[/** @type {keyof T} */ (property)]
+	);
 
 /**
  * @param {number} a a
@@ -217,12 +228,12 @@ const createComparator = (property, comparator) => (a, b) =>
  * @returns {0 | 1 | -1} result
  */
 const compareNumbers = (a, b) => {
-	if (isNaN(a)) {
-		if (!isNaN(b)) {
+	if (Number.isNaN(a)) {
+		if (!Number.isNaN(b)) {
 			return 1;
 		}
 	} else {
-		if (isNaN(b)) {
+		if (Number.isNaN(b)) {
 			return -1;
 		}
 		if (a !== b) {
@@ -396,12 +407,21 @@ const getFinalBinding = (
 				neededNamespaceObjects.add(info);
 				return {
 					info,
-					rawName: /** @type {string} */ (info.namespaceObjectName),
+					rawName:
+						/** @type {NonNullable<ConcatenatedModuleInfo["namespaceObjectName"]>} */
+						(info.namespaceObjectName),
 					ids: exportName,
 					exportName
 				};
 			case "external":
-				return { info, rawName: info.name, ids: exportName, exportName };
+				return {
+					info,
+					rawName:
+						/** @type {NonNullable<ExternalModuleInfo["name"]>} */
+						(info.name),
+					ids: exportName,
+					exportName
+				};
 		}
 	}
 	const exportsInfo = moduleGraph.getExportsInfo(info.module);
@@ -628,11 +648,20 @@ const addScopeSymbols = (s, nameSet, scopeSet1, scopeSet2) => {
 
 const TYPES = new Set(["javascript"]);
 
+/**
+ * @typedef {object} ConcatenateModuleHooks
+ * @property {SyncBailHook<[Record<string, string>], boolean>} exportsDefinitions
+ */
+
+/** @type {WeakMap<Compilation, ConcatenateModuleHooks>} */
+const compilationHooksMap = new WeakMap();
+
 class ConcatenatedModule extends Module {
 	/**
 	 * @param {Module} rootModule the root module of the concatenation
 	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
 	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {Compilation} compilation the compilation
 	 * @param {object=} associatedObjectForCache object for caching
 	 * @param {string | HashConstructor=} hashFunction hash function to use
 	 * @returns {ConcatenatedModule} the module
@@ -641,6 +670,7 @@ class ConcatenatedModule extends Module {
 		rootModule,
 		modules,
 		runtime,
+		compilation,
 		associatedObjectForCache,
 		hashFunction = "md4"
 	) {
@@ -654,18 +684,35 @@ class ConcatenatedModule extends Module {
 			identifier,
 			rootModule,
 			modules,
-			runtime
+			runtime,
+			compilation
 		});
 	}
 
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {ConcatenateModuleHooks} the attached hooks
+	 */
+	static getCompilationHooks(compilation) {
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				exportsDefinitions: new SyncBailHook(["definitions"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
+
 	/**
 	 * @param {object} options options
 	 * @param {string} options.identifier the identifier of the module
 	 * @param {Module=} options.rootModule the root module of the concatenation
 	 * @param {RuntimeSpec} options.runtime the selected runtime
 	 * @param {Set<Module>=} options.modules all concatenated modules
+	 * @param {Compilation} options.compilation the compilation
 	 */
-	constructor({ identifier, rootModule, modules, runtime }) {
+	constructor({ identifier, rootModule, modules, runtime, compilation }) {
 		super(JAVASCRIPT_MODULE_TYPE_ESM, null, rootModule && rootModule.layer);
 
 		// Info from Factory
@@ -677,6 +724,8 @@ class ConcatenatedModule extends Module {
 		this._modules = modules;
 		this._runtime = runtime;
 		this.factoryMeta = rootModule && rootModule.factoryMeta;
+		/** @type {Compilation | undefined} */
+		this.compilation = compilation;
 	}
 
 	/**
@@ -713,10 +762,9 @@ class ConcatenatedModule extends Module {
 	 * @returns {string} a user readable identifier of the module
 	 */
 	readableIdentifier(requestShortener) {
-		return (
-			this.rootModule.readableIdentifier(requestShortener) +
-			` + ${this._modules.size - 1} modules`
-		);
+		return `${this.rootModule.readableIdentifier(
+			requestShortener
+		)} + ${this._modules.size - 1} modules`;
 	}
 
 	/**
@@ -827,7 +875,14 @@ class ConcatenatedModule extends Module {
 				if (this.buildInfo.assets === undefined) {
 					this.buildInfo.assets = Object.create(null);
 				}
-				Object.assign(/** @type {BuildInfo} */ (this.buildInfo).assets, assets);
+				Object.assign(
+					/** @type {NonNullable<BuildInfo["assets"]>} */
+					(
+						/** @type {BuildInfo} */
+						(this.buildInfo).assets
+					),
+					assets
+				);
 			}
 			if (assetsInfo) {
 				if (this.buildInfo.assetsInfo === undefined) {
@@ -873,7 +928,9 @@ class ConcatenatedModule extends Module {
 		 * @returns {Iterable<{ connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} imported modules in order
 		 */
 		const getConcatenatedImports = module => {
-			let connections = Array.from(moduleGraph.getOutgoingConnections(module));
+			const connections = Array.from(
+				moduleGraph.getOutgoingConnections(module)
+			);
 			if (module === rootModule) {
 				for (const c of moduleGraph.getOutgoingConnections(this))
 					connections.push(c);
@@ -1047,14 +1104,14 @@ class ConcatenatedModule extends Module {
 			/** @type {string} */ (rootModule.context),
 			associatedObjectForCache
 		);
-		let identifiers = [];
+		const identifiers = [];
 		for (const module of modules) {
 			identifiers.push(cachedMakePathsRelative(module.identifier()));
 		}
 		identifiers.sort();
 		const hash = createHash(hashFunction);
 		hash.update(identifiers.join(" "));
-		return rootModule.identifier() + "|" + hash.digest("hex");
+		return `${rootModule.identifier()}|${hash.digest("hex")}`;
 	}
 
 	/**
@@ -1283,7 +1340,11 @@ class ConcatenatedModule extends Module {
 							);
 							for (const identifier of allIdentifiers) {
 								const r = /** @type {Range} */ (identifier.range);
-								const path = getPathInAst(info.ast, identifier);
+								const path = getPathInAst(
+									/** @type {NonNullable<ConcatenatedModuleInfo["ast"]>} */
+									(info.ast),
+									identifier
+								);
 								if (path && path.length > 1) {
 									const maybeProperty =
 										path[1].type === "AssignmentPattern" &&
@@ -1381,7 +1442,8 @@ class ConcatenatedModule extends Module {
 		// Find and replace references to modules
 		for (const info of moduleToInfoMap.values()) {
 			if (info.type === "concatenated") {
-				for (const reference of info.globalScope.through) {
+				const globalScope = /** @type {Scope} */ (info.globalScope);
+				for (const reference of globalScope.through) {
 					const name = reference.identifier.name;
 					const match = ConcatenationScope.matchModuleReference(name);
 					if (match) {
@@ -1427,6 +1489,8 @@ class ConcatenatedModule extends Module {
 			/** @type {BuildMeta} */
 			(rootInfo.module.buildMeta).strictHarmonyModule;
 		const exportsInfo = moduleGraph.getExportsInfo(rootInfo.module);
+		/** @type {Record<string, string>} */
+		const exportsFinalName = {};
 		for (const exportInfo of exportsInfo.orderedExports) {
 			const name = exportInfo.name;
 			if (exportInfo.provided === false) continue;
@@ -1451,14 +1515,15 @@ class ConcatenatedModule extends Module {
 						strictHarmonyModule,
 						true
 					);
+					exportsFinalName[used] = finalName;
 					return `/* ${
 						exportInfo.isReexport() ? "reexport" : "binding"
 					} */ ${finalName}`;
-				} catch (e) {
+				} catch (err) {
 					/** @type {Error} */
-					(e).message +=
+					(err).message +=
 						`\nwhile generating the root export '${name}' (used name: '${used}')`;
-					throw e;
+					throw err;
 				}
 			});
 		}
@@ -1466,23 +1531,20 @@ class ConcatenatedModule extends Module {
 		const result = new ConcatSource();
 
 		// add harmony compatibility flag (must be first because of possible circular dependencies)
+		let shouldAddHarmonyFlag = false;
 		if (
 			moduleGraph.getExportsInfo(this).otherExportsInfo.getUsed(runtime) !==
 			UsageState.Unused
 		) {
-			result.add(`// ESM COMPAT FLAG\n`);
-			result.add(
-				runtimeTemplate.defineEsModuleFlagStatement({
-					exportsArgument: this.exportsArgument,
-					runtimeRequirements
-				})
-			);
+			shouldAddHarmonyFlag = true;
 		}
 
 		// define exports
 		if (exportsMap.size > 0) {
-			runtimeRequirements.add(RuntimeGlobals.exports);
-			runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+			const { exportsDefinitions } = ConcatenatedModule.getCompilationHooks(
+				/** @type {Compilation} */ (this.compilation)
+			);
+
 			const definitions = [];
 			for (const [key, value] of exportsMap) {
 				definitions.push(
@@ -1491,12 +1553,33 @@ class ConcatenatedModule extends Module {
 					)}`
 				);
 			}
-			result.add(`\n// EXPORTS\n`);
-			result.add(
-				`${RuntimeGlobals.definePropertyGetters}(${
-					this.exportsArgument
-				}, {${definitions.join(",")}\n});\n`
-			);
+			const shouldSkipRenderDefinitions =
+				exportsDefinitions.call(exportsFinalName);
+
+			if (!shouldSkipRenderDefinitions) {
+				runtimeRequirements.add(RuntimeGlobals.exports);
+				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+
+				if (shouldAddHarmonyFlag) {
+					result.add("// ESM COMPAT FLAG\n");
+					result.add(
+						runtimeTemplate.defineEsModuleFlagStatement({
+							exportsArgument: this.exportsArgument,
+							runtimeRequirements
+						})
+					);
+				}
+
+				result.add("\n// EXPORTS\n");
+				result.add(
+					`${RuntimeGlobals.definePropertyGetters}(${
+						this.exportsArgument
+					}, {${definitions.join(",")}\n});\n`
+				);
+			} else {
+				/** @type {BuildMeta} */
+				(this.buildMeta).exportsFinalName = exportsFinalName;
+			}
 		}
 
 		// list unused exports
@@ -1710,7 +1793,8 @@ ${defineGetters}`
 					ast = JavascriptParser._parse(code, {
 						sourceType: "module"
 					});
-				} catch (err) {
+				} catch (_err) {
+					const err = /** @type {TODO} */ (_err);
 					if (
 						err.loc &&
 						typeof err.loc === "object" &&
@@ -1718,11 +1802,9 @@ ${defineGetters}`
 					) {
 						const lineNumber = err.loc.line;
 						const lines = code.split("\n");
-						err.message +=
-							"\n| " +
-							lines
-								.slice(Math.max(0, lineNumber - 3), lineNumber + 2)
-								.join("\n| ");
+						err.message += `\n| ${lines
+							.slice(Math.max(0, lineNumber - 3), lineNumber + 2)
+							.join("\n| ")}`;
 					}
 					throw err;
 				}
@@ -1818,16 +1900,15 @@ ${defineGetters}`
 					/** @type {ModuleInfo} */ (item).module,
 					/** @type {ModuleInfo} */ (item)
 				);
-				return item;
-			} else {
-				/** @type {ReferenceToModuleInfo} */
-				const ref = {
-					type: "reference",
-					runtimeCondition: info.runtimeCondition,
-					target: item
-				};
-				return ref;
+				return /** @type {ModuleInfo} */ (item);
 			}
+			/** @type {ReferenceToModuleInfo} */
+			const ref = {
+				type: "reference",
+				runtimeCondition: info.runtimeCondition,
+				target: item
+			};
+			return ref;
 		});
 		return [list, map];
 	}
@@ -1857,7 +1938,7 @@ ${defineGetters}`
 
 		const splittedInfo = extraInfo.split("/");
 		while (splittedInfo.length) {
-			name = splittedInfo.pop() + (name ? "_" + name : "");
+			name = splittedInfo.pop() + (name ? `_${name}` : "");
 			const nameIdent = Template.toIdentifier(name);
 			if (
 				!usedNamed1.has(nameIdent) &&
@@ -1870,6 +1951,7 @@ ${defineGetters}`
 		let nameWithNumber = Template.toIdentifier(`${name}_${i}`);
 		while (
 			usedNamed1.has(nameWithNumber) ||
+			// eslint-disable-next-line no-unmodified-loop-condition
 			(usedNamed2 && usedNamed2.has(nameWithNumber))
 		) {
 			i++;
@@ -1913,7 +1995,8 @@ ${defineGetters}`
 			identifier: undefined,
 			rootModule: undefined,
 			modules: undefined,
-			runtime: undefined
+			runtime: undefined,
+			compilation: undefined
 		});
 		obj.deserialize(context);
 		return obj;

package/lib/optimize/EnsureChunkConditionsPlugin.js

@@ -56,7 +56,7 @@ class EnsureChunkConditionsPlugin {
 							// We reached the entrypoint: fail
 							if (chunkGroup.isInitial()) {
 								throw new Error(
-									"Cannot fulfil chunk condition of " + module.identifier()
+									`Cannot fulfil chunk condition of ${module.identifier()}`
 								);
 							}
 							// Try placing in all parents

package/lib/optimize/FlagIncludedChunksPlugin.js

@@ -39,10 +39,10 @@ class FlagIncludedChunksPlugin {
 					const modulesCount = compilation.modules.size;
 
 					// precalculate the modulo values for each bit
-					const modulo = 1 / Math.pow(1 / modulesCount, 1 / 31);
+					const modulo = 1 / (1 / modulesCount) ** (1 / 31);
 					const modulos = Array.from(
 						{ length: 31 },
-						(x, i) => Math.pow(modulo, i) | 0
+						(x, i) => (modulo ** i) | 0
 					);
 
 					// iterate all modules to generate bit values
@@ -74,7 +74,7 @@ class FlagIncludedChunksPlugin {
 						const chunkAModulesCount =
 							chunkGraph.getNumberOfChunkModules(chunkA);
 						if (chunkAModulesCount === 0) continue;
-						let bestModule = undefined;
+						let bestModule;
 						for (const module of chunkGraph.getChunkModulesIterable(chunkA)) {
 							if (
 								bestModule === undefined ||

package/lib/optimize/InnerGraph.js

@@ -45,7 +45,7 @@ function getState(parserState) {
  * @param {ParserState} parserState parser state
  * @returns {void}
  */
-exports.bailout = parserState => {
+module.exports.bailout = parserState => {
 	parserStateMap.set(parserState, false);
 };
 
@@ -53,7 +53,7 @@ exports.bailout = parserState => {
  * @param {ParserState} parserState parser state
  * @returns {void}
  */
-exports.enable = parserState => {
+module.exports.enable = parserState => {
 	const state = parserStateMap.get(parserState);
 	if (state === false) {
 		return;
@@ -69,9 +69,9 @@ exports.enable = parserState => {
  * @param {ParserState} parserState parser state
  * @returns {boolean} true, when enabled
  */
-exports.isEnabled = parserState => {
+module.exports.isEnabled = parserState => {
 	const state = parserStateMap.get(parserState);
-	return !!state;
+	return Boolean(state);
 };
 
 /**
@@ -80,7 +80,7 @@ exports.isEnabled = parserState => {
  * @param {string | TopLevelSymbol | true} usage usage data
  * @returns {void}
  */
-exports.addUsage = (state, symbol, usage) => {
+module.exports.addUsage = (state, symbol, usage) => {
 	const innerGraphState = getState(state);
 
 	if (innerGraphState) {
@@ -102,13 +102,13 @@ exports.addUsage = (state, symbol, usage) => {
  * @param {string | TopLevelSymbol | true} usage usage data
  * @returns {void}
  */
-exports.addVariableUsage = (parser, name, usage) => {
+module.exports.addVariableUsage = (parser, name, usage) => {
 	const symbol =
 		/** @type {TopLevelSymbol} */ (
 			parser.getTagData(name, topLevelSymbolTag)
-		) || exports.tagTopLevelSymbol(parser, name);
+		) || module.exports.tagTopLevelSymbol(parser, name);
 	if (symbol) {
-		exports.addUsage(parser.state, symbol, usage);
+		module.exports.addUsage(parser.state, symbol, usage);
 	}
 };
 
@@ -116,7 +116,7 @@ exports.addVariableUsage = (parser, name, usage) => {
  * @param {ParserState} state parser state
  * @returns {void}
  */
-exports.inferDependencyUsage = state => {
+module.exports.inferDependencyUsage = state => {
 	const innerGraphState = getState(state);
 
 	if (!innerGraphState) {
@@ -212,7 +212,7 @@ exports.inferDependencyUsage = state => {
  * @param {ParserState} state parser state
  * @param {UsageCallback} onUsageCallback on usage callback
  */
-exports.onUsage = (state, onUsageCallback) => {
+module.exports.onUsage = (state, onUsageCallback) => {
 	const innerGraphState = getState(state);
 
 	if (innerGraphState) {
@@ -238,7 +238,7 @@ exports.onUsage = (state, onUsageCallback) => {
  * @param {ParserState} state parser state
  * @param {TopLevelSymbol | undefined} symbol the symbol
  */
-exports.setTopLevelSymbol = (state, symbol) => {
+module.exports.setTopLevelSymbol = (state, symbol) => {
 	const innerGraphState = getState(state);
 
 	if (innerGraphState) {
@@ -250,7 +250,7 @@ exports.setTopLevelSymbol = (state, symbol) => {
  * @param {ParserState} state parser state
  * @returns {TopLevelSymbol|void} usage data
  */
-exports.getTopLevelSymbol = state => {
+module.exports.getTopLevelSymbol = state => {
 	const innerGraphState = getState(state);
 
 	if (innerGraphState) {
@@ -263,7 +263,7 @@ exports.getTopLevelSymbol = state => {
  * @param {string} name name of variable
  * @returns {TopLevelSymbol | undefined} symbol
  */
-exports.tagTopLevelSymbol = (parser, name) => {
+module.exports.tagTopLevelSymbol = (parser, name) => {
 	const innerGraphState = getState(parser.state);
 	if (!innerGraphState) return;
 
@@ -288,7 +288,7 @@ exports.tagTopLevelSymbol = (parser, name) => {
  * @param {RuntimeSpec} runtime runtime
  * @returns {boolean} false, when unused. Otherwise true
  */
-exports.isDependencyUsedByExports = (
+module.exports.isDependencyUsedByExports = (
 	dependency,
 	usedByExports,
 	moduleGraph,
@@ -316,7 +316,7 @@ exports.isDependencyUsedByExports = (
  * @param {ModuleGraph} moduleGraph moduleGraph
  * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
  */
-exports.getDependencyUsedByExportsCondition = (
+module.exports.getDependencyUsedByExportsCondition = (
 	dependency,
 	usedByExports,
 	moduleGraph
@@ -347,5 +347,5 @@ class TopLevelSymbol {
 	}
 }
 
-exports.TopLevelSymbol = TopLevelSymbol;
-exports.topLevelSymbolTag = topLevelSymbolTag;
+module.exports.TopLevelSymbol = TopLevelSymbol;
+module.exports.topLevelSymbolTag = topLevelSymbolTag;

package/lib/optimize/InnerGraphPlugin.js

@@ -109,13 +109,14 @@ class InnerGraphPlugin {
 					parser.hooks.preStatement.tap(PLUGIN_NAME, statement => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 
-						if (parser.scope.topLevelScope === true) {
-							if (statement.type === "FunctionDeclaration") {
-								const name = statement.id ? statement.id.name : "*default*";
-								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
-								statementWithTopLevelSymbol.set(statement, fn);
-								return true;
-							}
+						if (
+							parser.scope.topLevelScope === true &&
+							statement.type === "FunctionDeclaration"
+						) {
+							const name = statement.id ? statement.id.name : "*default*";
+							const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+							statementWithTopLevelSymbol.set(statement, fn);
+							return true;
 						}
 					});
 

package/lib/optimize/LimitChunkCountPlugin.js

@@ -119,7 +119,7 @@ class LimitChunkCountPlugin {
 					/** @type {Map<Chunk, Set<ChunkCombination>>} */
 					const combinationsByChunk = new Map();
 
-					orderedChunks.forEach((b, bIdx) => {
+					for (const [bIdx, b] of orderedChunks.entries()) {
 						// create combination pairs with size and integrated size
 						for (let aIdx = 0; aIdx < bIdx; aIdx++) {
 							const a = orderedChunks[aIdx];
@@ -149,8 +149,7 @@ class LimitChunkCountPlugin {
 							addToSetMap(combinationsByChunk, a, c);
 							addToSetMap(combinationsByChunk, b, c);
 						}
-						return combinations;
-					});
+					}
 
 					// list of modified chunks during this run
 					// combinations affected by this change are skipped to allow

package/lib/optimize/MangleExportsPlugin.js

@@ -149,6 +149,7 @@ class MangleExportsPlugin {
 	constructor(deterministic) {
 		this._deterministic = deterministic;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance

package/lib/optimize/MinMaxSizeWarning.js

@@ -23,7 +23,7 @@ class MinMaxSizeWarning extends WebpackError {
 					: `Cache group ${keys[0]}`;
 		}
 		super(
-			`SplitChunksPlugin\n` +
+			"SplitChunksPlugin\n" +
 				`${keysMessage}\n` +
 				`Configured minSize (${SizeFormatHelpers.formatSize(minSize)}) is ` +
 				`bigger than maxSize (${SizeFormatHelpers.formatSize(maxSize)}).\n` +