webpack 5.93.0 → 5.95.0

package/lib/node/nodeConsole.js

@@ -19,7 +19,7 @@ const truncateArgs = require("../logging/truncateArgs");
  */
 module.exports = ({ colors, appendOnly, stream }) => {
 	/** @type {string[] | undefined} */
-	let currentStatusMessage = undefined;
+	let currentStatusMessage;
 	let hasStatusMessage = false;
 	let currentIndent = "";
 	let currentCollapsed = 0;
@@ -38,17 +38,17 @@ module.exports = ({ colors, appendOnly, stream }) => {
 			return (
 				prefix +
 				colorPrefix +
-				str.replace(/\n/g, colorSuffix + "\n" + prefix + colorPrefix) +
+				str.replace(/\n/g, `${colorSuffix}\n${prefix}${colorPrefix}`) +
 				colorSuffix
 			);
-		} else {
-			return prefix + str.replace(/\n/g, "\n" + prefix);
 		}
+
+		return prefix + str.replace(/\n/g, `\n${prefix}`);
 	};
 
 	const clearStatusMessage = () => {
 		if (hasStatusMessage) {
-			stream.write("\x1b[2K\r");
+			stream.write("\u001B[2K\r");
 			hasStatusMessage = false;
 		}
 	};
@@ -58,8 +58,8 @@ module.exports = ({ colors, appendOnly, stream }) => {
 		const l = /** @type {TODO} */ (stream).columns || 40;
 		const args = truncateArgs(currentStatusMessage, l - 1);
 		const str = args.join(" ");
-		const coloredStr = `\u001b[1m${str}\u001b[39m\u001b[22m`;
-		stream.write(`\x1b[2K\r${coloredStr}`);
+		const coloredStr = `\u001B[1m${str}\u001B[39m\u001B[22m`;
+		stream.write(`\u001B[2K\r${coloredStr}`);
 		hasStatusMessage = true;
 	};
 
@@ -69,8 +69,9 @@ module.exports = ({ colors, appendOnly, stream }) => {
 	 * @param {string} colorSuffix color suffix
 	 * @returns {(function(...any[]): void)} function to write with colors
 	 */
-	const writeColored = (prefix, colorPrefix, colorSuffix) => {
-		return (...args) => {
+	const writeColored =
+		(prefix, colorPrefix, colorSuffix) =>
+		(...args) => {
 			if (currentCollapsed > 0) return;
 			clearStatusMessage();
 			const str = indent(
@@ -79,34 +80,33 @@ module.exports = ({ colors, appendOnly, stream }) => {
 				colorPrefix,
 				colorSuffix
 			);
-			stream.write(str + "\n");
+			stream.write(`${str}\n`);
 			writeStatusMessage();
 		};
-	};
 
 	const writeGroupMessage = writeColored(
 		"<-> ",
-		"\u001b[1m\u001b[36m",
-		"\u001b[39m\u001b[22m"
+		"\u001B[1m\u001B[36m",
+		"\u001B[39m\u001B[22m"
 	);
 
 	const writeGroupCollapsedMessage = writeColored(
 		"<+> ",
-		"\u001b[1m\u001b[36m",
-		"\u001b[39m\u001b[22m"
+		"\u001B[1m\u001B[36m",
+		"\u001B[39m\u001B[22m"
 	);
 
 	return {
-		log: writeColored("    ", "\u001b[1m", "\u001b[22m"),
+		log: writeColored("    ", "\u001B[1m", "\u001B[22m"),
 		debug: writeColored("    ", "", ""),
 		trace: writeColored("    ", "", ""),
-		info: writeColored("<i> ", "\u001b[1m\u001b[32m", "\u001b[39m\u001b[22m"),
-		warn: writeColored("<w> ", "\u001b[1m\u001b[33m", "\u001b[39m\u001b[22m"),
-		error: writeColored("<e> ", "\u001b[1m\u001b[31m", "\u001b[39m\u001b[22m"),
+		info: writeColored("<i> ", "\u001B[1m\u001B[32m", "\u001B[39m\u001B[22m"),
+		warn: writeColored("<w> ", "\u001B[1m\u001B[33m", "\u001B[39m\u001B[22m"),
+		error: writeColored("<e> ", "\u001B[1m\u001B[31m", "\u001B[39m\u001B[22m"),
 		logTime: writeColored(
 			"<t> ",
-			"\u001b[1m\u001b[35m",
-			"\u001b[39m\u001b[22m"
+			"\u001B[1m\u001B[35m",
+			"\u001B[39m\u001B[22m"
 		),
 		group: (...args) => {
 			writeGroupMessage(...args);
@@ -123,7 +123,7 @@ module.exports = ({ colors, appendOnly, stream }) => {
 		groupEnd: () => {
 			if (currentCollapsed > 0) currentCollapsed--;
 			else if (currentIndent.length >= 2)
-				currentIndent = currentIndent.slice(0, currentIndent.length - 2);
+				currentIndent = currentIndent.slice(0, -2);
 		},
 		profile: console.profile && (name => console.profile(name)),
 		profileEnd: console.profileEnd && (name => console.profileEnd(name)),

package/lib/optimize/AggressiveMergingPlugin.js

@@ -51,7 +51,7 @@ class AggressiveMergingPlugin {
 					chunks => {
 						const chunkGraph = compilation.chunkGraph;
 						/** @type {{a: Chunk, b: Chunk, improvement: number}[]} */
-						let combinations = [];
+						const combinations = [];
 						for (const a of chunks) {
 							if (a.canBeInitial()) continue;
 							for (const b of chunks) {
@@ -78,9 +78,7 @@ class AggressiveMergingPlugin {
 							}
 						}
 
-						combinations.sort((a, b) => {
-							return b.improvement - a.improvement;
-						});
+						combinations.sort((a, b) => b.improvement - a.improvement);
 
 						const pair = combinations[0];
 

package/lib/optimize/AggressiveSplittingPlugin.js

@@ -36,11 +36,9 @@ const validate = createSchemaValidation(
  * @param {Chunk} newChunk the new chunk
  * @returns {(module: Module) => void} function to move module between chunks
  */
-const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => {
-	return module => {
-		chunkGraph.disconnectChunkAndModule(oldChunk, module);
-		chunkGraph.connectChunkAndModule(newChunk, module);
-	};
+const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => module => {
+	chunkGraph.disconnectChunkAndModule(oldChunk, module);
+	chunkGraph.connectChunkAndModule(newChunk, module);
 };
 
 /**
@@ -48,11 +46,8 @@ const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => {
  * @param {Chunk} chunk the chunk
  * @returns {function(Module): boolean} filter for entry module
  */
-const isNotAEntryModule = (chunkGraph, chunk) => {
-	return module => {
-		return !chunkGraph.isEntryModuleInChunk(module, chunk);
-	};
-};
+const isNotAEntryModule = (chunkGraph, chunk) => module =>
+	!chunkGraph.isEntryModuleInChunk(module, chunk);
 
 /** @type {WeakSet<Chunk>} */
 const recordedChunks = new WeakSet();
@@ -191,9 +186,9 @@ class AggressiveSplittingPlugin {
 							const newChunk = compilation.addChunk();
 							newChunk.chunkReason = "aggressive splitted";
 							for (const chunk of selectedChunks) {
-								selectedModules.forEach(
-									moveModuleBetween(chunkGraph, chunk, newChunk)
-								);
+								for (const module of selectedModules) {
+									moveModuleBetween(chunkGraph, chunk, newChunk)(module);
+								}
 								chunk.split(newChunk);
 								chunk.name = null;
 							}
@@ -277,12 +272,14 @@ class AggressiveSplittingPlugin {
 						// We remove invalid splittings and try again
 						for (const chunk of compilation.chunks) {
 							const splitData = chunkSplitDataMap.get(chunk);
-							if (splitData !== undefined) {
-								if (splitData.hash && chunk.hash !== splitData.hash) {
-									// Split was successful, but hash doesn't equal
-									// We can throw away the split since it's useless now
-									invalidSplits.add(splitData);
-								}
+							if (
+								splitData !== undefined &&
+								splitData.hash &&
+								chunk.hash !== splitData.hash
+							) {
+								// Split was successful, but hash doesn't equal
+								// We can throw away the split since it's useless now
+								invalidSplits.add(splitData);
 							}
 						}
 

package/lib/optimize/ConcatenatedModule.js

@@ -62,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 */
@@ -128,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
@@ -153,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
  */
 
 /**
@@ -209,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
@@ -218,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) {
@@ -397,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);
@@ -631,7 +650,7 @@ const TYPES = new Set(["javascript"]);
 
 /**
  * @typedef {object} ConcatenateModuleHooks
- * @property {SyncBailHook<[Record<string, string>]>} exportsDefinitions
+ * @property {SyncBailHook<[Record<string, string>], boolean>} exportsDefinitions
  */
 
 /** @type {WeakMap<Compilation, ConcatenateModuleHooks>} */
@@ -743,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`;
 	}
 
 	/**
@@ -857,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) {
@@ -903,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);
@@ -1077,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")}`;
 	}
 
 	/**
@@ -1313,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" &&
@@ -1411,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) {
@@ -1487,11 +1519,11 @@ class ConcatenatedModule extends Module {
 					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;
 				}
 			});
 		}
@@ -1510,7 +1542,7 @@ class ConcatenatedModule extends Module {
 		// define exports
 		if (exportsMap.size > 0) {
 			const { exportsDefinitions } = ConcatenatedModule.getCompilationHooks(
-				this.compilation
+				/** @type {Compilation} */ (this.compilation)
 			);
 
 			const definitions = [];
@@ -1529,7 +1561,7 @@ class ConcatenatedModule extends Module {
 				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
 
 				if (shouldAddHarmonyFlag) {
-					result.add(`// ESM COMPAT FLAG\n`);
+					result.add("// ESM COMPAT FLAG\n");
 					result.add(
 						runtimeTemplate.defineEsModuleFlagStatement({
 							exportsArgument: this.exportsArgument,
@@ -1538,14 +1570,15 @@ class ConcatenatedModule extends Module {
 					);
 				}
 
-				result.add(`\n// EXPORTS\n`);
+				result.add("\n// EXPORTS\n");
 				result.add(
 					`${RuntimeGlobals.definePropertyGetters}(${
 						this.exportsArgument
 					}, {${definitions.join(",")}\n});\n`
 				);
 			} else {
-				this.buildMeta.exportsFinalName = exportsFinalName;
+				/** @type {BuildMeta} */
+				(this.buildMeta).exportsFinalName = exportsFinalName;
 			}
 		}
 
@@ -1627,9 +1660,7 @@ ${defineGetters}`
 			switch (info.type) {
 				case "concatenated": {
 					result.add(
-						`\n;// CONCATENATED MODULE: ${info.module.readableIdentifier(
-							requestShortener
-						)}\n`
+						`\n;// ${info.module.readableIdentifier(requestShortener)}\n`
 					);
 					result.add(info.source);
 					if (info.chunkInitFragments) {
@@ -1760,7 +1791,8 @@ ${defineGetters}`
 					ast = JavascriptParser._parse(code, {
 						sourceType: "module"
 					});
-				} catch (err) {
+				} catch (_err) {
+					const err = /** @type {TODO} */ (_err);
 					if (
 						err.loc &&
 						typeof err.loc === "object" &&
@@ -1768,11 +1800,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;
 				}
@@ -1868,16 +1898,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];
 	}
@@ -1907,7 +1936,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) &&
@@ -1920,6 +1949,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++;

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;
 						}
 					});