webpack 5.100.1 → 5.101.0

package/lib/optimize/AggressiveMergingPlugin.js

@@ -42,13 +42,13 @@ class AggressiveMergingPlugin {
 		const options = this.options;
 		const minSizeReduce = options.minSizeReduce || 1.5;
 
-		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			compilation.hooks.optimizeChunks.tap(
 				{
 					name: PLUGIN_NAME,
 					stage: STAGE_ADVANCED
 				},
-				chunks => {
+				(chunks) => {
 					const chunkGraph = compilation.chunkGraph;
 					/** @type {{a: Chunk, b: Chunk, improvement: number}[]} */
 					const combinations = [];

package/lib/optimize/AggressiveSplittingPlugin.js

@@ -36,7 +36,7 @@ const validate = createSchemaValidation(
  * @param {Chunk} newChunk the new chunk
  * @returns {(module: Module) => void} function to move module between chunks
  */
-const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => module => {
+const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => (module) => {
 	chunkGraph.disconnectChunkAndModule(oldChunk, module);
 	chunkGraph.connectChunkAndModule(newChunk, module);
 };
@@ -46,7 +46,7 @@ const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => module => {
  * @param {Chunk} chunk the chunk
  * @returns {(module: Module) => boolean} filter for entry module
  */
-const isNotAEntryModule = (chunkGraph, chunk) => module =>
+const isNotAEntryModule = (chunkGraph, chunk) => (module) =>
 	!chunkGraph.isEntryModuleInChunk(module, chunk);
 
 /** @typedef {{ id?: NonNullable<Chunk["id"]>, hash?: NonNullable<Chunk["hash"]>, modules: Module[], size: number }} SplitData */
@@ -92,7 +92,7 @@ class AggressiveSplittingPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			let needAdditionalSeal = false;
 			/** @type {SplitData[]} */
 			let newSplits;
@@ -110,7 +110,7 @@ class AggressiveSplittingPlugin {
 					name: PLUGIN_NAME,
 					stage: STAGE_ADVANCED
 				},
-				chunks => {
+				(chunks) => {
 					const chunkGraph = compilation.chunkGraph;
 					// Precompute stuff
 					const nameToModuleMap = new Map();
@@ -145,14 +145,14 @@ class AggressiveSplittingPlugin {
 					 * @param {SplitData} splitData split data
 					 * @returns {boolean} true when applied, otherwise false
 					 */
-					const applySplit = splitData => {
+					const applySplit = (splitData) => {
 						// Cannot split if id is already taken
 						if (splitData.id !== undefined && usedIds.has(splitData.id)) {
 							return false;
 						}
 
 						// Get module objects from names
-						const selectedModules = splitData.modules.map(name =>
+						const selectedModules = splitData.modules.map((name) =>
 							nameToModuleMap.get(name)
 						);
 
@@ -167,7 +167,7 @@ class AggressiveSplittingPlugin {
 						// get chunks with all modules
 						const selectedChunks = intersect(
 							selectedModules.map(
-								m => new Set(chunkGraph.getModuleChunksIterable(m))
+								(m) => new Set(chunkGraph.getModuleChunksIterable(m))
 							)
 						);
 
@@ -253,7 +253,7 @@ class AggressiveSplittingPlugin {
 							/** @type {SplitData} */
 							const splitData = {
 								modules: selectedModules
-									.map(m => moduleToNameMap.get(m))
+									.map((m) => moduleToNameMap.get(m))
 									.sort(),
 								size: selectedModulesSize
 							};
@@ -267,7 +267,7 @@ class AggressiveSplittingPlugin {
 					if (changed) return true;
 				}
 			);
-			compilation.hooks.recordHash.tap(PLUGIN_NAME, records => {
+			compilation.hooks.recordHash.tap(PLUGIN_NAME, (records) => {
 				// 4. save made splittings to records
 				const allSplits = new Set();
 				/** @type {Set<SplitData>} */
@@ -292,7 +292,7 @@ class AggressiveSplittingPlugin {
 					records.aggressiveSplits =
 						/** @type {SplitData[]} */
 						(records.aggressiveSplits).filter(
-							splitData => !invalidSplits.has(splitData)
+							(splitData) => !invalidSplits.has(splitData)
 						);
 					needAdditionalSeal = true;
 				} else {

package/lib/optimize/ConcatenatedModule.js

@@ -66,6 +66,7 @@ const {
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
+/** @typedef {import("../ExternalModule")} ExternalModule */
 /** @typedef {import("../Module").BuildCallback} BuildCallback */
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
@@ -94,7 +95,6 @@ const {
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
 /**
  * @template T
  * @typedef {import("../InitFragment")<T>} InitFragment
@@ -159,6 +159,7 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {Map<string, string> | undefined} rawExportMap
  * @property {string=} namespaceExportSymbol
  * @property {string | undefined} namespaceObjectName
+ * @property {ConcatenationScope | undefined} concatenationScope
  * @property {boolean} interopNamespaceObjectUsed "default-with-named" namespace
  * @property {string | undefined} interopNamespaceObjectName "default-with-named" namespace
  * @property {boolean} interopNamespaceObject2Used "default-only" namespace
@@ -241,7 +242,7 @@ const moveDeferToLast = (
  * @param {Iterable<string>} iterable iterable object
  * @returns {string} joined iterable object
  */
-const joinIterableWithComma = iterable => {
+const joinIterableWithComma = (iterable) => {
 	// This is more performant than Array.from().join(", ")
 	// as it doesn't create an array
 	let str = "";
@@ -503,7 +504,7 @@ const getFinalBinding = (
 					exportName
 				};
 			}
-			const reexport = exportInfo.findTarget(moduleGraph, module =>
+			const reexport = exportInfo.findTarget(moduleGraph, (module) =>
 				moduleToInfoMap.has(module)
 			);
 			if (reexport === false) {
@@ -668,6 +669,7 @@ const getFinalName = (
 /**
  * @typedef {object} ConcatenateModuleHooks
  * @property {SyncBailHook<[Record<string, string>, ConcatenatedModule], boolean | void>} exportsDefinitions
+ * @property {SyncBailHook<[Partial<ConcatenatedModuleInfo>, ConcatenatedModuleInfo], boolean | void>} concatenatedModuleInfo
  */
 
 /** @type {WeakMap<Compilation, ConcatenateModuleHooks>} */
@@ -714,7 +716,11 @@ class ConcatenatedModule extends Module {
 		let hooks = compilationHooksMap.get(compilation);
 		if (hooks === undefined) {
 			hooks = {
-				exportsDefinitions: new SyncBailHook(["definitions", "module"])
+				exportsDefinitions: new SyncBailHook(["definitions", "module"]),
+				concatenatedModuleInfo: new SyncBailHook([
+					"updatedInfo",
+					"concatenatedModuleInfo"
+				])
 			};
 			compilationHooksMap.set(compilation, hooks);
 		}
@@ -848,7 +854,7 @@ class ConcatenatedModule extends Module {
 
 			// populate dependencies
 			for (const d of m.dependencies.filter(
-				dep =>
+				(dep) =>
 					!(dep instanceof HarmonyImportDependency) ||
 					!this._modules.has(
 						/** @type {Module} */
@@ -945,13 +951,14 @@ class ConcatenatedModule extends Module {
 		/** @type {Map<Module, RuntimeSpec | true>} */
 		const existingEntries = new Map();
 		const deferEnabled =
-			this.compilation && this.compilation.options.experiments.deferImport;
+			/** @type {Compilation} */
+			(this.compilation).options.experiments.deferImport;
 
 		/**
 		 * @param {Module} module a module
 		 * @returns {Iterable<{ connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} imported modules in order
 		 */
-		const getConcatenatedImports = module => {
+		const getConcatenatedImports = (module) => {
 			const connections = [...moduleGraph.getOutgoingConnections(module)];
 			if (module === rootModule) {
 				for (const c of moduleGraph.getOutgoingConnections(this)) {
@@ -962,7 +969,7 @@ class ConcatenatedModule extends Module {
 			 * @type {Array<{ connection: ModuleGraphConnection, sourceOrder: number, rangeStart: number, defer?: boolean }>}
 			 */
 			const references = connections
-				.filter(connection => {
+				.filter((connection) => {
 					if (!(connection.dependency instanceof HarmonyImportDependency)) {
 						return false;
 					}
@@ -973,7 +980,7 @@ class ConcatenatedModule extends Module {
 						connection.isTargetActive(runtime)
 					);
 				})
-				.map(connection => {
+				.map((connection) => {
 					const dep = /** @type {HarmonyImportDependency} */ (
 						connection.dependency
 					);
@@ -1009,7 +1016,7 @@ class ConcatenatedModule extends Module {
 			/** @type {Map<Module, { connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} */
 			const referencesMap = new Map();
 			for (const { connection } of references) {
-				const runtimeCondition = filterRuntime(runtime, r =>
+				const runtimeCondition = filterRuntime(runtime, (r) =>
 					connection.isTargetActive(r)
 				);
 				if (runtimeCondition === false) continue;
@@ -1180,6 +1187,10 @@ class ConcatenatedModule extends Module {
 		runtime: generationRuntime,
 		codeGenerationResults
 	}) {
+		const { concatenatedModuleInfo } = ConcatenatedModule.getCompilationHooks(
+			/** @type {Compilation} */ (this.compilation)
+		);
+
 		/** @type {RuntimeRequirements} */
 		const runtimeRequirements = new Set();
 		const runtime = intersectRuntime(generationRuntime, this._runtime);
@@ -1195,6 +1206,9 @@ class ConcatenatedModule extends Module {
 		/** @type {Set<ConcatenatedModuleInfo>} */
 		const neededNamespaceObjects = new Set();
 
+		// List of all used names to avoid conflicts
+		const allUsedNames = new Set(RESERVED_NAMES);
+
 		// Generate source code and analyse scopes
 		// Prepare a ReplaceSource for the final source
 		for (const info of moduleToInfoMap.values()) {
@@ -1207,12 +1221,11 @@ class ConcatenatedModule extends Module {
 				chunkGraph,
 				runtime,
 				/** @type {CodeGenerationResults} */
-				(codeGenerationResults)
+				(codeGenerationResults),
+				allUsedNames
 			);
 		}
 
-		// List of all used names to avoid conflicts
-		const allUsedNames = new Set(RESERVED_NAMES);
 		// Updated Top level declarations are created by renaming
 		/** @type {Set<string>} */
 		const topLevelDeclarations = new Set();
@@ -1240,7 +1253,7 @@ class ConcatenatedModule extends Module {
 				 * @param {Scope} scope scope
 				 * @returns {{ range: Range, variables: Variable[] }[]} result
 				 */
-				const getSuperClassExpressions = scope => {
+				const getSuperClassExpressions = (scope) => {
 					const cacheEntry = superClassCache.get(scope);
 					if (cacheEntry !== undefined) return cacheEntry;
 					const superClassExpressions = [];
@@ -1321,6 +1334,75 @@ class ConcatenatedModule extends Module {
 			}
 		}
 
+		/**
+		 * @param {string} name the name to find a new name for
+		 * @param {ConcatenatedModuleInfo} info the info of the module
+		 * @param {Reference[]} references the references to the name
+		 * @returns {string|undefined} the new name or undefined if the name is not found
+		 */
+		const _findNewName = (name, info, references) => {
+			const { usedNames, alreadyCheckedScopes } = getUsedNamesInScopeInfo(
+				usedNamesInScopeInfo,
+				info.module.identifier(),
+				name
+			);
+			if (allUsedNames.has(name) || usedNames.has(name)) {
+				for (const ref of references) {
+					addScopeSymbols(
+						ref.from,
+						usedNames,
+						alreadyCheckedScopes,
+						ignoredScopes
+					);
+				}
+				const newName = findNewName(
+					name,
+					allUsedNames,
+					usedNames,
+					info.module.readableIdentifier(requestShortener)
+				);
+				allUsedNames.add(newName);
+				info.internalNames.set(name, newName);
+				topLevelDeclarations.add(newName);
+				return newName;
+			}
+		};
+
+		/**
+		 * @param {string} name the name to find a new name for
+		 * @param {ConcatenatedModuleInfo} info the info of the module
+		 * @param {Reference[]} references the references to the name
+		 * @returns {string|undefined} the new name or undefined if the name is not found
+		 */
+		const _findNewNameForSpecifier = (name, info, references) => {
+			const { usedNames: moduleUsedNames, alreadyCheckedScopes } =
+				getUsedNamesInScopeInfo(
+					usedNamesInScopeInfo,
+					info.module.identifier(),
+					name
+				);
+			const referencesUsedNames = new Set();
+			for (const ref of references) {
+				addScopeSymbols(
+					ref.from,
+					referencesUsedNames,
+					alreadyCheckedScopes,
+					ignoredScopes
+				);
+			}
+			if (moduleUsedNames.has(name) || referencesUsedNames.has(name)) {
+				const newName = findNewName(
+					name,
+					allUsedNames,
+					new Set([...moduleUsedNames, ...referencesUsedNames]),
+					info.module.readableIdentifier(requestShortener)
+				);
+				allUsedNames.add(newName);
+				topLevelDeclarations.add(newName);
+				return newName;
+			}
+		};
+
 		// generate names for symbols
 		for (const info of moduleToInfoMap.values()) {
 			const { usedNames: namespaceObjectUsedNames } = getUsedNamesInScopeInfo(
@@ -1333,33 +1415,12 @@ class ConcatenatedModule extends Module {
 					const variables = /** @type {Scope} */ (info.moduleScope).variables;
 					for (const variable of variables) {
 						const name = variable.name;
-						const { usedNames, alreadyCheckedScopes } = getUsedNamesInScopeInfo(
-							usedNamesInScopeInfo,
-							info.module.identifier(),
-							name
-						);
-						if (allUsedNames.has(name) || usedNames.has(name)) {
-							const references = getAllReferences(variable);
-							for (const ref of references) {
-								addScopeSymbols(
-									ref.from,
-									usedNames,
-									alreadyCheckedScopes,
-									ignoredScopes
-								);
-							}
-							const newName = findNewName(
-								name,
-								allUsedNames,
-								usedNames,
-								info.module.readableIdentifier(requestShortener)
-							);
-							allUsedNames.add(newName);
-							info.internalNames.set(name, newName);
-							topLevelDeclarations.add(newName);
+						const references = getAllReferences(variable);
+						const newName = _findNewName(name, info, references);
+						if (newName) {
 							const source = /** @type {ReplaceSource} */ (info.source);
 							const allIdentifiers = new Set([
-								...references.map(r => r.identifier),
+								...references.map((r) => r.identifier),
 								...variable.identifiers
 							]);
 							for (const identifier of allIdentifiers) {
@@ -1493,14 +1554,48 @@ class ConcatenatedModule extends Module {
 		for (const info of moduleToInfoMap.values()) {
 			if (info.type === "concatenated") {
 				const globalScope = /** @type {Scope} */ (info.globalScope);
+				// group references by name
+				const referencesByName = new Map();
 				for (const reference of globalScope.through) {
 					const name = reference.identifier.name;
+					if (!referencesByName.has(name)) {
+						referencesByName.set(name, []);
+					}
+					referencesByName.get(name).push(reference);
+				}
+				for (const [name, references] of referencesByName) {
 					const match = ConcatenationScope.matchModuleReference(name);
 					if (match) {
 						const referencedInfo = modulesWithInfo[match.index];
 						if (referencedInfo.type === "reference") {
 							throw new Error("Module reference can't point to a reference");
 						}
+						const concatenationScope = /** @type {ConcatenatedModuleInfo} */ (
+							referencedInfo
+						).concatenationScope;
+						const exportId = match.ids[0];
+						const specifier =
+							concatenationScope && concatenationScope.getRawExport(exportId);
+						if (specifier) {
+							const newName = _findNewNameForSpecifier(
+								specifier,
+								info,
+								references
+							);
+							const initFragmentChanged =
+								newName &&
+								concatenatedModuleInfo.call(
+									{
+										rawExportMap: new Map([
+											[exportId, /** @type {string} */ (newName)]
+										])
+									},
+									/** @type {ConcatenatedModuleInfo} */ (referencedInfo)
+								);
+							if (initFragmentChanged) {
+								concatenationScope.setRawExportMap(exportId, newName);
+							}
+						}
 						const finalName = getFinalName(
 							moduleGraph,
 							referencedInfo,
@@ -1517,10 +1612,13 @@ class ConcatenatedModule extends Module {
 							(info.module.buildMeta).strictHarmonyModule,
 							match.asiSafe
 						);
-						const r = /** @type {Range} */ (reference.identifier.range);
-						const source = /** @type {ReplaceSource} */ (info.source);
-						// range is extended by 2 chars to cover the appended "._"
-						source.replace(r[0], r[1] + 1, finalName);
+
+						for (const reference of references) {
+							const r = /** @type {Range} */ (reference.identifier.range);
+							const source = /** @type {ReplaceSource} */ (info.source);
+							// range is extended by 2 chars to cover the appended "._"
+							source.replace(r[0], r[1] + 1, finalName);
+						}
 					}
 				}
 			}
@@ -1551,7 +1649,7 @@ class ConcatenatedModule extends Module {
 				unusedExports.add(name);
 				continue;
 			}
-			exportsMap.set(used, requestShortener => {
+			exportsMap.set(used, (requestShortener) => {
 				try {
 					const finalName = getFinalName(
 						moduleGraph,
@@ -1712,7 +1810,8 @@ ${defineGetters}`
 		/** @type {InitFragment<ChunkRenderContext>[]} */
 		const chunkInitFragments = [];
 		const deferEnabled =
-			this.compilation && this.compilation.options.experiments.deferImport;
+			/** @type {Compilation} */
+			(this.compilation).options.experiments.deferImport;
 
 		// evaluate modules in order
 		for (const rawInfo of modulesWithInfo) {
@@ -1738,7 +1837,8 @@ ${defineGetters}`
 								if (moduleGraph.isDeferred(referredModule)) {
 									const deferredModuleInfo = /** @type {ExternalModuleInfo} */ (
 										modulesWithInfo.find(
-											i => i.type === "external" && i.module === referredModule
+											(i) =>
+												i.type === "external" && i.module === referredModule
 										)
 									);
 									if (!deferredModuleInfo) continue;
@@ -1787,18 +1887,19 @@ ${defineGetters}`
 							runtimeTemplate,
 							info.module.getExportsType(
 								moduleGraph,
-								this.rootModule.buildMeta &&
-									this.rootModule.buildMeta.strictHarmonyModule
+								/** @type {BuildMeta} */
+								(this.rootModule.buildMeta).strictHarmonyModule
 							),
 							moduleId,
 							// an async module will opt-out of the concat module optimization.
 							[]
 						);
 						result.add(`var ${info.deferredName} = ${loader};`);
+						name = info.deferredName;
 					} else {
 						result.add(`var ${info.name} = __webpack_require__(${moduleId});`);
+						name = info.name;
 					}
-					name = info.name;
 					break;
 				}
 				default:
@@ -1865,6 +1966,7 @@ ${defineGetters}`
 	 * @param {ChunkGraph} chunkGraph chunkGraph
 	 * @param {RuntimeSpec} runtime runtime
 	 * @param {CodeGenerationResults} codeGenerationResults codeGenerationResults
+	 * @param {Set<string>} usedNames used names
 	 */
 	_analyseModule(
 		modulesMap,
@@ -1874,13 +1976,18 @@ ${defineGetters}`
 		moduleGraph,
 		chunkGraph,
 		runtime,
-		codeGenerationResults
+		codeGenerationResults,
+		usedNames
 	) {
 		if (info.type === "concatenated") {
 			const m = info.module;
 			try {
 				// Create a concatenation scope to track and capture information
-				const concatenationScope = new ConcatenationScope(modulesMap, info);
+				const concatenationScope = new ConcatenationScope(
+					modulesMap,
+					info,
+					usedNames
+				);
 
 				// TODO cache codeGeneration results
 				const codeGenResult = m.codeGeneration({
@@ -1940,6 +2047,7 @@ ${defineGetters}`
 				info.chunkInitFragments = chunkInitFragments;
 				info.globalScope = globalScope;
 				info.moduleScope = moduleScope;
+				info.concatenationScope = concatenationScope;
 			} catch (err) {
 				/** @type {Error} */
 				(err).message +=
@@ -1988,7 +2096,8 @@ ${defineGetters}`
 							interopNamespaceObject2Used: false,
 							interopNamespaceObject2Name: undefined,
 							interopDefaultAccessUsed: false,
-							interopDefaultAccessName: undefined
+							interopDefaultAccessName: undefined,
+							concatenationScope: undefined
 						};
 						break;
 					case "external":

package/lib/optimize/EnsureChunkConditionsPlugin.js

@@ -20,11 +20,11 @@ class EnsureChunkConditionsPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			/**
 			 * @param {Iterable<Chunk>} chunks the chunks
 			 */
-			const handler = chunks => {
+			const handler = (chunks) => {
 				const chunkGraph = compilation.chunkGraph;
 				// These sets are hoisted here to save memory
 				// They are cleared at the end of every loop

package/lib/optimize/FlagIncludedChunksPlugin.js

@@ -21,8 +21,8 @@ class FlagIncludedChunksPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
-			compilation.hooks.optimizeChunkIds.tap(PLUGIN_NAME, chunks => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.hooks.optimizeChunkIds.tap(PLUGIN_NAME, (chunks) => {
 				const chunkGraph = compilation.chunkGraph;
 
 				// prepare two bit integers for each module

package/lib/optimize/InnerGraph.js

@@ -95,7 +95,7 @@ module.exports.addVariableUsage = (parser, name, usage) => {
  * @param {ParserState} parserState parser state
  * @returns {void}
  */
-module.exports.bailout = parserState => {
+module.exports.bailout = (parserState) => {
 	parserStateMap.set(parserState, false);
 };
 
@@ -103,7 +103,7 @@ module.exports.bailout = parserState => {
  * @param {ParserState} parserState parser state
  * @returns {void}
  */
-module.exports.enable = parserState => {
+module.exports.enable = (parserState) => {
 	const state = parserStateMap.get(parserState);
 	if (state === false) {
 		return;
@@ -148,7 +148,7 @@ module.exports.getDependencyUsedByExportsCondition = (
  * @param {ParserState} state parser state
  * @returns {TopLevelSymbol|void} usage data
  */
-module.exports.getTopLevelSymbol = state => {
+module.exports.getTopLevelSymbol = (state) => {
 	const innerGraphState = getState(state);
 
 	if (innerGraphState) {
@@ -160,7 +160,7 @@ module.exports.getTopLevelSymbol = state => {
  * @param {ParserState} state parser state
  * @returns {void}
  */
-module.exports.inferDependencyUsage = state => {
+module.exports.inferDependencyUsage = (state) => {
 	const innerGraphState = getState(state);
 
 	if (!innerGraphState) {
@@ -286,7 +286,7 @@ module.exports.isDependencyUsedByExports = (
  * @param {ParserState} parserState parser state
  * @returns {boolean} true, when enabled
  */
-module.exports.isEnabled = parserState => {
+module.exports.isEnabled = (parserState) => {
 	const state = parserStateMap.get(parserState);
 	return Boolean(state);
 };

package/lib/optimize/InnerGraphPlugin.js

@@ -59,8 +59,8 @@ class InnerGraphPlugin {
 					/**
 					 * @param {Expression} sup sup
 					 */
-					const onUsageSuper = sup => {
-						InnerGraph.onUsage(parser.state, usedByExports => {
+					const onUsageSuper = (sup) => {
+						InnerGraph.onUsage(parser.state, (usedByExports) => {
 							switch (usedByExports) {
 								case undefined:
 								case true:
@@ -115,7 +115,7 @@ class InnerGraphPlugin {
 
 					// The following hooks are used during prewalking:
 
-					parser.hooks.preStatement.tap(PLUGIN_NAME, statement => {
+					parser.hooks.preStatement.tap(PLUGIN_NAME, (statement) => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 
 						if (
@@ -131,7 +131,7 @@ class InnerGraphPlugin {
 						}
 					});
 
-					parser.hooks.blockPreStatement.tap(PLUGIN_NAME, statement => {
+					parser.hooks.blockPreStatement.tap(PLUGIN_NAME, (statement) => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 
 						if (parser.scope.topLevelScope === true) {
@@ -250,7 +250,7 @@ class InnerGraphPlugin {
 
 					// The following hooks are called during walking:
 
-					parser.hooks.statement.tap(PLUGIN_NAME, statement => {
+					parser.hooks.statement.tap(PLUGIN_NAME, (statement) => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 						if (parser.scope.topLevelScope === true) {
 							InnerGraph.setTopLevelSymbol(parser.state, undefined);
@@ -260,7 +260,7 @@ class InnerGraphPlugin {
 								InnerGraph.setTopLevelSymbol(parser.state, fn);
 								const purePart = statementPurePart.get(statement);
 								if (purePart) {
-									InnerGraph.onUsage(parser.state, usedByExports => {
+									InnerGraph.onUsage(parser.state, (usedByExports) => {
 										switch (usedByExports) {
 											case undefined:
 											case true:
@@ -336,7 +336,7 @@ class InnerGraphPlugin {
 									) {
 										InnerGraph.setTopLevelSymbol(parser.state, fn);
 										if (element.type !== "MethodDefinition" && element.static) {
-											InnerGraph.onUsage(parser.state, usedByExports => {
+											InnerGraph.onUsage(parser.state, (usedByExports) => {
 												switch (usedByExports) {
 													case undefined:
 													case true:
@@ -378,7 +378,7 @@ class InnerGraphPlugin {
 										onUsageSuper(decl.init.superClass);
 									}
 								} else {
-									InnerGraph.onUsage(parser.state, usedByExports => {
+									InnerGraph.onUsage(parser.state, (usedByExports) => {
 										switch (usedByExports) {
 											case undefined:
 											case true:
@@ -433,10 +433,12 @@ class InnerGraphPlugin {
 								currentTopLevelSymbol || true
 							);
 						});
-					parser.hooks.assign.for(topLevelSymbolTag).tap(PLUGIN_NAME, expr => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
-						if (expr.operator === "=") return true;
-					});
+					parser.hooks.assign
+						.for(topLevelSymbolTag)
+						.tap(PLUGIN_NAME, (expr) => {
+							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (expr.operator === "=") return true;
+						});
 				};
 				normalModuleFactory.hooks.parser
 					.for(JAVASCRIPT_MODULE_TYPE_AUTO)