webpack 5.85.0 → 5.88.1

package/lib/javascript/JavascriptParserHelpers.js

@@ -9,20 +9,26 @@ const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const ConstDependency = require("../dependencies/ConstDependency");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 
-/** @typedef {import("estree").Expression} ExpressionNode */
+/** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("estree").Node} Node */
+/** @typedef {import("estree").SourceLocation} SourceLocation */
 /** @typedef {import("./JavascriptParser")} JavascriptParser */
+/** @typedef {import("./JavascriptParser").Range} Range */
 
 /**
  * @param {JavascriptParser} parser the parser
  * @param {string} value the const value
  * @param {string[]=} runtimeRequirements runtime requirements
- * @returns {function(ExpressionNode): true} plugin function
+ * @returns {function(Expression): true} plugin function
  */
 exports.toConstantDependency = (parser, value, runtimeRequirements) => {
 	return function constDependency(expr) {
-		const dep = new ConstDependency(value, expr.range, runtimeRequirements);
-		dep.loc = expr.loc;
+		const dep = new ConstDependency(
+			value,
+			/** @type {Range} */ (expr.range),
+			runtimeRequirements
+		);
+		dep.loc = /** @type {SourceLocation} */ (expr.loc);
 		parser.state.module.addPresentationalDependency(dep);
 		return true;
 	};
@@ -30,33 +36,37 @@ exports.toConstantDependency = (parser, value, runtimeRequirements) => {
 
 /**
  * @param {string} value the string value
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
+ * @returns {function(Expression): BasicEvaluatedExpression} plugin function
  */
 exports.evaluateToString = value => {
 	return function stringExpression(expr) {
-		return new BasicEvaluatedExpression().setString(value).setRange(expr.range);
+		return new BasicEvaluatedExpression()
+			.setString(value)
+			.setRange(/** @type {Range} */ (expr.range));
 	};
 };
 
 /**
  * @param {number} value the number value
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
+ * @returns {function(Expression): BasicEvaluatedExpression} plugin function
  */
 exports.evaluateToNumber = value => {
 	return function stringExpression(expr) {
-		return new BasicEvaluatedExpression().setNumber(value).setRange(expr.range);
+		return new BasicEvaluatedExpression()
+			.setNumber(value)
+			.setRange(/** @type {Range} */ (expr.range));
 	};
 };
 
 /**
  * @param {boolean} value the boolean value
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
+ * @returns {function(Expression): BasicEvaluatedExpression} plugin function
  */
 exports.evaluateToBoolean = value => {
 	return function booleanExpression(expr) {
 		return new BasicEvaluatedExpression()
 			.setBoolean(value)
-			.setRange(expr.range);
+			.setRange(/** @type {Range} */ (expr.range));
 	};
 };
 
@@ -65,14 +75,14 @@ exports.evaluateToBoolean = value => {
  * @param {string} rootInfo rootInfo
  * @param {function(): string[]} getMembers getMembers
  * @param {boolean|null=} truthy is truthy, null if nullish
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} callback
+ * @returns {function(Expression): BasicEvaluatedExpression} callback
  */
 exports.evaluateToIdentifier = (identifier, rootInfo, getMembers, truthy) => {
 	return function identifierExpression(expr) {
 		let evaluatedExpression = new BasicEvaluatedExpression()
 			.setIdentifier(identifier, rootInfo, getMembers)
 			.setSideEffects(false)
-			.setRange(expr.range);
+			.setRange(/** @type {Range} */ (expr.range));
 		switch (truthy) {
 			case true:
 				evaluatedExpression.setTruthy();
@@ -89,14 +99,26 @@ exports.evaluateToIdentifier = (identifier, rootInfo, getMembers, truthy) => {
 	};
 };
 
+/**
+ * @param {JavascriptParser} parser the parser
+ * @param {string} message the message
+ * @returns {function(Expression): boolean | undefined} callback to handle unsupported expression
+ */
 exports.expressionIsUnsupported = (parser, message) => {
 	return function unsupportedExpression(expr) {
-		const dep = new ConstDependency("(void 0)", expr.range, null);
-		dep.loc = expr.loc;
+		const dep = new ConstDependency(
+			"(void 0)",
+			/** @type {Range} */ (expr.range),
+			null
+		);
+		dep.loc = /** @type {SourceLocation} */ (expr.loc);
 		parser.state.module.addPresentationalDependency(dep);
 		if (!parser.state.module) return;
 		parser.state.module.addWarning(
-			new UnsupportedFeatureWarning(message, expr.loc)
+			new UnsupportedFeatureWarning(
+				message,
+				/** @type {SourceLocation} */ (expr.loc)
+			)
 		);
 		return true;
 	};

package/lib/json/JsonData.js

@@ -40,14 +40,14 @@ class JsonData {
 
 	/**
 	 * @param {Hash} hash hash to be updated
-	 * @returns {Hash} the updated hash
+	 * @returns {void} the updated hash
 	 */
 	updateHash(hash) {
 		if (this._buffer === undefined && this._data !== undefined) {
 			this._buffer = Buffer.from(JSON.stringify(this._data));
 		}
 
-		if (this._buffer) return hash.update(this._buffer);
+		if (this._buffer) hash.update(this._buffer);
 	}
 }
 

package/lib/json/JsonParser.js

@@ -5,16 +5,20 @@
 
 "use strict";
 
-const parseJson = require("json-parse-even-better-errors");
 const Parser = require("../Parser");
 const JsonExportsDependency = require("../dependencies/JsonExportsDependency");
+const memoize = require("../util/memoize");
 const JsonData = require("./JsonData");
 
 /** @typedef {import("../../declarations/plugins/JsonModulesPluginParser").JsonModulesPluginParserOptions} JsonModulesPluginParserOptions */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 /** @typedef {import("./JsonModulesPlugin").RawJsonData} RawJsonData */
 
+const getParseJson = memoize(() => require("json-parse-even-better-errors"));
+
 class JsonParser extends Parser {
 	/**
 	 * @param {JsonModulesPluginParserOptions} options parser options
@@ -36,17 +40,26 @@ class JsonParser extends Parser {
 
 		/** @type {NonNullable<JsonModulesPluginParserOptions["parse"]>} */
 		const parseFn =
-			typeof this.options.parse === "function" ? this.options.parse : parseJson;
-		/** @type {Buffer | RawJsonData} */
-		const data =
-			typeof source === "object"
-				? source
-				: parseFn(source[0] === "\ufeff" ? source.slice(1) : source);
-		const jsonData = new JsonData(data);
-		state.module.buildInfo.jsonData = jsonData;
-		state.module.buildInfo.strict = true;
-		state.module.buildMeta.exportsType = "default";
-		state.module.buildMeta.defaultObject =
+			typeof this.options.parse === "function"
+				? this.options.parse
+				: getParseJson();
+		/** @type {Buffer | RawJsonData | undefined} */
+		let data;
+		try {
+			data =
+				typeof source === "object"
+					? source
+					: parseFn(source[0] === "\ufeff" ? source.slice(1) : source);
+		} catch (e) {
+			throw new Error(`Cannot parse JSON: ${/** @type {Error} */ (e).message}`);
+		}
+		const jsonData = new JsonData(/** @type {Buffer | RawJsonData} */ (data));
+		const buildInfo = /** @type {BuildInfo} */ (state.module.buildInfo);
+		buildInfo.jsonData = jsonData;
+		buildInfo.strict = true;
+		const buildMeta = /** @type {BuildMeta} */ (state.module.buildMeta);
+		buildMeta.exportsType = "default";
+		buildMeta.defaultObject =
 			typeof data === "object" ? "redirect-warn" : false;
 		state.module.addDependency(new JsonExportsDependency(jsonData));
 		return state;

package/lib/library/AmdLibraryPlugin.js

@@ -68,8 +68,8 @@ class AmdLibraryPlugin extends AbstractLibraryPlugin {
 			}
 		}
 		return {
-			name: /** @type {string=} */ (name),
-			amdContainer: /** @type {string=} */ (amdContainer)
+			name: /** @type {string} */ (name),
+			amdContainer: /** @type {string} */ (amdContainer)
 		};
 	}
 

package/lib/library/AssignLibraryPlugin.js

@@ -17,6 +17,7 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
@@ -59,6 +60,7 @@ const accessWithInit = (accessor, existingLength, initLast = false) => {
 	let i = 1;
 
 	// all properties printed so far (excluding base)
+	/** @type {string[] | undefined} */
 	let propsSoFar;
 
 	// if there is existingLength, print all properties until this position as property access
@@ -142,7 +144,7 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 			}
 		}
 		return {
-			name: /** @type {string|string[]=} */ (name),
+			name: /** @type {string | string[]} */ (name),
 			export: library.export
 		};
 	}
@@ -173,12 +175,22 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 		moduleGraph.addExtraReason(module, "used as library export");
 	}
 
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {string[]} the prefix
+	 */
 	_getPrefix(compilation) {
 		return this.prefix === "global"
 			? [compilation.runtimeTemplate.globalObject]
 			: this.prefix;
 	}
 
+	/**
+	 * @param {AssignLibraryPluginParsed} options the library options
+	 * @param {Chunk} chunk the chunk
+	 * @param {Compilation} compilation the compilation
+	 * @returns {Array<string>} the resolved full name
+	 */
 	_getResolvedFullName(options, chunk, compilation) {
 		const prefix = this._getPrefix(compilation);
 		const fullName = options.name ? prefix.concat(options.name) : prefix;

package/lib/library/EnableLibraryPlugin.js

@@ -12,6 +12,10 @@
 /** @type {WeakMap<Compiler, Set<LibraryType>>} */
 const enabledTypes = new WeakMap();
 
+/**
+ * @param {Compiler} compiler the compiler instance
+ * @returns {Set<LibraryType>} enabled types
+ */
 const getEnabledTypes = compiler => {
 	let set = enabledTypes.get(compiler);
 	if (set === undefined) {

package/lib/library/SystemLibraryPlugin.js

@@ -59,7 +59,7 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 			);
 		}
 		return {
-			name: /** @type {string=} */ (name)
+			name: /** @type {string} */ (name)
 		};
 	}
 

package/lib/library/UmdLibraryPlugin.js

@@ -148,6 +148,10 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 			requiredExternals = externals;
 		}
 
+		/**
+		 * @param {string} str the string to replace
+		 * @returns {string} the replaced keys
+		 */
 		const replaceKeys = str => {
 			return compilation.getPath(str, {
 				chunk
@@ -178,6 +182,10 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 			);
 		};
 
+		/**
+		 * @param {string} type the type
+		 * @returns {string} external require array
+		 */
 		const externalsRequireArray = type => {
 			return replaceKeys(
 				externals
@@ -185,7 +193,9 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 						let expr;
 						let request = m.request;
 						if (typeof request === "object") {
-							request = request[type];
+							request =
+								/** @type {Record<string, string | string[]>} */
+								(request)[type];
 						}
 						if (request === undefined) {
 							throw new Error(
@@ -246,6 +256,10 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 
 		const { auxiliaryComment, namedDefine, names } = options;
 
+		/**
+		 * @param {keyof LibraryCustomUmdCommentObject} type type
+		 * @returns {string} comment
+		 */
 		const getAuxiliaryComment = type => {
 			if (auxiliaryComment) {
 				if (typeof auxiliaryComment === "string")
@@ -299,7 +313,11 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 						  "	else\n" +
 						  "		" +
 						  replaceKeys(
-								accessorAccess("root", names.root || names.commonjs)
+								accessorAccess(
+									"root",
+									/** @type {string | string[]} */ (names.root) ||
+										/** @type {string} */ (names.commonjs)
+								)
 						  ) +
 						  " = factory(" +
 						  externalsRootArray(externals) +

package/lib/logging/runtime.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const SyncBailHook = require("tapable/lib/SyncBailHook");
+const { SyncBailHook } = require("tapable");
 const { Logger } = require("./Logger");
 const createConsoleLogger = require("./createConsoleLogger");
 

package/lib/logging/truncateArgs.js

@@ -5,6 +5,10 @@
 
 "use strict";
 
+/**
+ * @param {Array<number>} array array of numbers
+ * @returns {number} sum of all numbers in array
+ */
 const arraySum = array => {
 	let sum = 0;
 	for (const item of array) sum += item;

package/lib/node/ReadFileChunkLoadingRuntimeModule.js

@@ -16,6 +16,8 @@ const compileBooleanMatcher = require("../util/compileBooleanMatcher");
 const { getUndoPath } = require("../util/identifier");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
 
 class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 	/**
@@ -46,11 +48,13 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { chunkGraph, chunk } = this;
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.ensureChunkHandlers;
 		const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
 		const withExternalInstallChunk = this.runtimeRequirements.has(
@@ -72,8 +76,8 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
 		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
-		const outputName = this.compilation.getPath(
-			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
+		const outputName = compilation.getPath(
+			getChunkFilenameTemplate(chunk, compilation.outputOptions),
 			{
 				chunk,
 				contentHashType: "javascript"
@@ -81,7 +85,7 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 		);
 		const rootOutputDir = getUndoPath(
 			outputName,
-			/** @type {string} */ (this.compilation.outputOptions.path),
+			/** @type {string} */ (compilation.outputOptions.path),
 			false
 		);
 

package/lib/node/ReadFileCompileAsyncWasmPlugin.js

@@ -40,6 +40,7 @@ class ReadFileCompileAsyncWasmPlugin {
 							: globalWasmLoading;
 					return wasmLoading === this._type;
 				};
+				const { importMetaName } = compilation.outputOptions;
 				/**
 				 * @type {(path: string) => string}
 				 */
@@ -48,7 +49,7 @@ class ReadFileCompileAsyncWasmPlugin {
 							Template.asString([
 								"Promise.all([import('fs'), import('url')]).then(([{ readFile }, { URL }]) => new Promise((resolve, reject) => {",
 								Template.indent([
-									`readFile(new URL(${path}, import.meta.url), (err, buffer) => {`,
+									`readFile(new URL(${path}, ${importMetaName}.url), (err, buffer) => {`,
 									Template.indent([
 										"if (err) return reject(err);",
 										"",

package/lib/node/RequireChunkLoadingRuntimeModule.js

@@ -16,6 +16,8 @@ const compileBooleanMatcher = require("../util/compileBooleanMatcher");
 const { getUndoPath } = require("../util/identifier");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
 
 class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 	/**
@@ -46,11 +48,13 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { chunkGraph, chunk } = this;
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.ensureChunkHandlers;
 		const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
 		const withExternalInstallChunk = this.runtimeRequirements.has(
@@ -72,8 +76,8 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
 		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
-		const outputName = this.compilation.getPath(
-			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
+		const outputName = compilation.getPath(
+			getChunkFilenameTemplate(chunk, compilation.outputOptions),
 			{
 				chunk,
 				contentHashType: "javascript"
@@ -81,7 +85,7 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 		);
 		const rootOutputDir = getUndoPath(
 			outputName,
-			/** @type {string} */ (this.compilation.outputOptions.path),
+			/** @type {string} */ (compilation.outputOptions.path),
 			true
 		);
 

package/lib/optimize/AggressiveMergingPlugin.js

@@ -10,7 +10,15 @@ const { STAGE_ADVANCED } = require("../OptimizationStages");
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
+/**
+ * @typedef {Object} AggressiveMergingPluginOptions
+ * @property {number=} minSizeReduce minimal size reduction to trigger merging
+ */
+
 class AggressiveMergingPlugin {
+	/**
+	 * @param {AggressiveMergingPluginOptions=} [options] options object
+	 */
 	constructor(options) {
 		if (
 			(options !== undefined && typeof options !== "object") ||

package/lib/optimize/AggressiveSplittingPlugin.js

@@ -30,6 +30,12 @@ const validate = createSchemaValidation(
 	}
 );
 
+/**
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Chunk} oldChunk the old chunk
+ * @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);
@@ -92,6 +98,7 @@ class AggressiveSplittingPlugin {
 			compilation => {
 				let needAdditionalSeal = false;
 				let newSplits;
+				/** @type {Set<Chunk>} */
 				let fromAggressiveSplittingSet;
 				let chunkSplitDataMap;
 				compilation.hooks.optimize.tap("AggressiveSplittingPlugin", () => {
@@ -133,8 +140,8 @@ class AggressiveSplittingPlugin {
 							? recordedSplits.concat(newSplits)
 							: recordedSplits;
 
-						const minSize = this.options.minSize;
-						const maxSize = this.options.maxSize;
+						const minSize = /** @type {number} */ (this.options.minSize);
+						const maxSize = /** @type {number} */ (this.options.maxSize);
 
 						const applySplit = splitData => {
 							// Cannot split if id is already taken

package/lib/optimize/EnsureChunkConditionsPlugin.js

@@ -21,6 +21,9 @@ class EnsureChunkConditionsPlugin {
 		compiler.hooks.compilation.tap(
 			"EnsureChunkConditionsPlugin",
 			compilation => {
+				/**
+				 * @param {Iterable<Chunk>} chunks the chunks
+				 */
 				const handler = chunks => {
 					const chunkGraph = compilation.chunkGraph;
 					// These sets are hoisted here to save memory

package/lib/optimize/FlagIncludedChunksPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Chunk").ChunkId} ChunkId */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 
@@ -61,13 +62,15 @@ class FlagIncludedChunksPlugin {
 					for (const chunk of chunks) {
 						let hash = 0;
 						for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-							hash |= moduleBits.get(module);
+							hash |= /** @type {number} */ (moduleBits.get(module));
 						}
 						chunkModulesHash.set(chunk, hash);
 					}
 
 					for (const chunkA of chunks) {
-						const chunkAHash = chunkModulesHash.get(chunkA);
+						const chunkAHash =
+							/** @type {number} */
+							(chunkModulesHash.get(chunkA));
 						const chunkAModulesCount =
 							chunkGraph.getNumberOfChunkModules(chunkA);
 						if (chunkAModulesCount === 0) continue;
@@ -81,7 +84,7 @@ class FlagIncludedChunksPlugin {
 								bestModule = module;
 						}
 						loopB: for (const chunkB of chunkGraph.getModuleChunksIterable(
-							bestModule
+							/** @type {Module} */ (bestModule)
 						)) {
 							// as we iterate the same iterables twice
 							// skip if we find ourselves
@@ -100,14 +103,17 @@ class FlagIncludedChunksPlugin {
 							// is chunkA in chunkB?
 
 							// we do a cheap check for the hash value
-							const chunkBHash = chunkModulesHash.get(chunkB);
+							const chunkBHash =
+								/** @type {number} */
+								(chunkModulesHash.get(chunkB));
 							if ((chunkBHash & chunkAHash) !== chunkAHash) continue;
 
 							// compare all modules
 							for (const m of chunkGraph.getChunkModulesIterable(chunkA)) {
 								if (!chunkGraph.isModuleInChunk(m, chunkB)) continue loopB;
 							}
-							chunkB.ids.push(chunkA.id);
+							/** @type {ChunkId[]} */
+							(chunkB.ids).push(/** @type {ChunkId} */ (chunkA.id));
 						}
 					}
 				}

package/lib/optimize/InnerGraph.js

@@ -16,7 +16,7 @@ const { UsageState } = require("../ExportsInfo");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-/** @typedef {Map<TopLevelSymbol | null, Set<string | TopLevelSymbol> | true>} InnerGraph */
+/** @typedef {Map<TopLevelSymbol | null, Set<string | TopLevelSymbol> | true | undefined>} InnerGraph */
 /** @typedef {function(boolean | Set<string> | undefined): void} UsageCallback */
 
 /**
@@ -34,7 +34,7 @@ const topLevelSymbolTag = Symbol("top level symbol");
 
 /**
  * @param {ParserState} parserState parser state
- * @returns {State} state
+ * @returns {State | undefined} state
  */
 function getState(parserState) {
 	return parserStateMap.get(parserState);
@@ -235,7 +235,7 @@ exports.onUsage = (state, onUsageCallback) => {
 
 /**
  * @param {ParserState} state parser state
- * @param {TopLevelSymbol} symbol the symbol
+ * @param {TopLevelSymbol | undefined} symbol the symbol
  */
 exports.setTopLevelSymbol = (state, symbol) => {
 	const innerGraphState = getState(state);
@@ -260,7 +260,7 @@ exports.getTopLevelSymbol = state => {
 /**
  * @param {JavascriptParser} parser parser
  * @param {string} name name of variable
- * @returns {TopLevelSymbol} symbol
+ * @returns {TopLevelSymbol | undefined} symbol
  */
 exports.tagTopLevelSymbol = (parser, name) => {
 	const innerGraphState = getState(parser.state);
@@ -309,7 +309,7 @@ exports.isDependencyUsedByExports = (
 
 /**
  * @param {Dependency} dependency the dependency
- * @param {Set<string> | boolean} usedByExports usedByExports info
+ * @param {Set<string> | boolean | undefined} usedByExports usedByExports info
  * @param {ModuleGraph} moduleGraph moduleGraph
  * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
  */

package/lib/optimize/InnerGraphPlugin.js

@@ -16,6 +16,7 @@ const InnerGraph = require("./InnerGraph");
 /** @typedef {import("estree").ClassExpression} ClassExpressionNode */
 /** @typedef {import("estree").Node} Node */
 /** @typedef {import("estree").VariableDeclarator} VariableDeclaratorNode */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
@@ -46,7 +47,7 @@ class InnerGraphPlugin {
 
 				/**
 				 * @param {JavascriptParser} parser the parser
-				 * @param {Object} parserOptions options
+				 * @param {JavascriptParserOptions} parserOptions options
 				 * @returns {void}
 				 */
 				const handler = (parser, parserOptions) => {