webpack 5.85.1 → 5.86.0

package/lib/ProgressPlugin.js

@@ -11,9 +11,20 @@ const NormalModule = require("./NormalModule");
 const createSchemaValidation = require("./util/create-schema-validation");
 const { contextify } = require("./util/identifier");
 
+/** @typedef {import("tapable").Tap} Tap */
 /** @typedef {import("../declarations/plugins/ProgressPlugin").HandlerFunction} HandlerFunction */
 /** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginArgument} ProgressPluginArgument */
 /** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginOptions} ProgressPluginOptions */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./logging/Logger").Logger} Logger */
+
+/**
+ * @typedef {Object} CountsData
+ * @property {number} modulesCount modules count
+ * @property {number} dependenciesCount dependencies count
+ */
 
 const validate = createSchemaValidation(
 	require("../schemas/plugins/ProgressPlugin.check.js"),
@@ -23,14 +34,31 @@ const validate = createSchemaValidation(
 		baseDataPath: "options"
 	}
 );
+
+/**
+ * @param {number} a a
+ * @param {number} b b
+ * @param {number} c c
+ * @returns {number} median
+ */
 const median3 = (a, b, c) => {
 	return a + b + c - Math.max(a, b, c) - Math.min(a, b, c);
 };
 
+/**
+ * @param {boolean | null | undefined} profile need profile
+ * @param {Logger} logger logger
+ * @returns {defaultHandler} default handler
+ */
 const createDefaultHandler = (profile, logger) => {
-	/** @type {{ value: string, time: number }[]} */
+	/** @type {{ value: string | undefined, time: number }[]} */
 	const lastStateInfo = [];
 
+	/**
+	 * @param {number} percentage percentage
+	 * @param {string} msg message
+	 * @param {...string} args additional arguments
+	 */
 	const defaultHandler = (percentage, msg, ...args) => {
 		if (profile) {
 			if (percentage === 0) {
@@ -95,18 +123,18 @@ const createDefaultHandler = (profile, logger) => {
 
 /**
  * @callback ReportProgress
- * @param {number} p
- * @param {...string} [args]
+ * @param {number} p percentage
+ * @param {...string} args additional arguments
  * @returns {void}
  */
 
-/** @type {WeakMap<Compiler,ReportProgress>} */
+/** @type {WeakMap<Compiler, ReportProgress | undefined>} */
 const progressReporters = new WeakMap();
 
 class ProgressPlugin {
 	/**
 	 * @param {Compiler} compiler the current compiler
-	 * @returns {ReportProgress} a progress reporter, if any
+	 * @returns {ReportProgress | undefined} a progress reporter, if any
 	 */
 	static getReporter(compiler) {
 		return progressReporters.get(compiler);
@@ -288,6 +316,9 @@ class ProgressPlugin {
 		};
 
 		// only used when showActiveModules is set
+		/**
+		 * @param {Module} module the module
+		 */
 		const moduleBuild = module => {
 			const ident = module.identifier();
 			if (ident) {
@@ -297,11 +328,18 @@ class ProgressPlugin {
 			}
 		};
 
+		/**
+		 * @param {Dependency} entry entry dependency
+		 * @param {EntryOptions} options options object
+		 */
 		const entryAdd = (entry, options) => {
 			entriesCount++;
 			if (entriesCount < 5 || entriesCount % 10 === 0) updateThrottled();
 		};
 
+		/**
+		 * @param {Module} module the module
+		 */
 		const moduleDone = module => {
 			doneModules++;
 			if (showActiveModules) {
@@ -321,6 +359,10 @@ class ProgressPlugin {
 			if (doneModules < 50 || doneModules % 100 === 0) updateThrottled();
 		};
 
+		/**
+		 * @param {Dependency} entry entry dependency
+		 * @param {EntryOptions} options options object
+		 */
 		const entryDone = (entry, options) => {
 			doneEntries++;
 			update();
@@ -330,6 +372,7 @@ class ProgressPlugin {
 			.getCache("ProgressPlugin")
 			.getItemCache("counts", null);
 
+		/** @type {Promise<CountsData> | undefined} */
 		let cacheGetPromise;
 
 		compiler.hooks.beforeCompile.tap("ProgressPlugin", () => {
@@ -352,15 +395,17 @@ class ProgressPlugin {
 
 		compiler.hooks.afterCompile.tapPromise("ProgressPlugin", compilation => {
 			if (compilation.compiler.isChild()) return Promise.resolve();
-			return cacheGetPromise.then(async oldData => {
-				if (
-					!oldData ||
-					oldData.modulesCount !== modulesCount ||
-					oldData.dependenciesCount !== dependenciesCount
-				) {
-					await cache.storePromise({ modulesCount, dependenciesCount });
+			return /** @type {Promise<CountsData>} */ (cacheGetPromise).then(
+				async oldData => {
+					if (
+						!oldData ||
+						oldData.modulesCount !== modulesCount ||
+						oldData.dependenciesCount !== dependenciesCount
+					) {
+						await cache.storePromise({ modulesCount, dependenciesCount });
+					}
 				}
-			});
+			);
 		});
 
 		compiler.hooks.compilation.tap("ProgressPlugin", compilation => {
@@ -463,9 +508,9 @@ class ProgressPlugin {
 			};
 			const numberOfHooks = Object.keys(hooks).length;
 			Object.keys(hooks).forEach((name, idx) => {
-				const title = hooks[name];
+				const title = hooks[/** @type {keyof typeof hooks} */ (name)];
 				const percentage = (idx / numberOfHooks) * 0.25 + 0.7;
-				compilation.hooks[name].intercept({
+				compilation.hooks[/** @type {keyof typeof hooks} */ (name)].intercept({
 					name: "ProgressPlugin",
 					call() {
 						handler(percentage, "sealing", title);
@@ -500,6 +545,12 @@ class ProgressPlugin {
 				handler(0.65, "building");
 			}
 		});
+		/**
+		 * @param {TODO} hook hook
+		 * @param {number} progress progress from 0 to 1
+		 * @param {string} category category
+		 * @param {string} name name
+		 */
 		const interceptHook = (hook, progress, category, name) => {
 			hook.intercept({
 				name: "ProgressPlugin",
@@ -516,6 +567,9 @@ class ProgressPlugin {
 				error() {
 					handler(progress, category, name);
 				},
+				/**
+				 * @param {Tap} tap tap
+				 */
 				tap(tap) {
 					progressReporters.set(compiler, (p, ...args) => {
 						handler(progress, category, name, tap.name, ...args);
@@ -610,4 +664,6 @@ ProgressPlugin.defaultOptions = {
 	entries: true
 };
 
+ProgressPlugin.createDefaultHandler = createDefaultHandler;
+
 module.exports = ProgressPlugin;

package/lib/WebpackOptionsApply.js

@@ -368,7 +368,9 @@ class WebpackOptionsApply extends OptionsApply {
 			const NodeStuffPlugin = require("./NodeStuffPlugin");
 			new NodeStuffPlugin(options.node).apply(compiler);
 		}
-		new APIPlugin().apply(compiler);
+		new APIPlugin({
+			module: options.output.module
+		}).apply(compiler);
 		new ExportsInfoApiPlugin().apply(compiler);
 		new WebpackIsIncludedPlugin().apply(compiler);
 		new ConstPlugin().apply(compiler);

package/lib/css/CssExportsGenerator.js

@@ -19,6 +19,11 @@ const Template = require("../Template");
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../util/Hash")} Hash */
 
+/**
+ * @template T
+ * @typedef {import("../InitFragment")<T>} InitFragment
+ */
+
 const TYPES = new Set(["javascript"]);
 
 class CssExportsGenerator extends Generator {
@@ -36,6 +41,7 @@ class CssExportsGenerator extends Generator {
 	 */
 	generate(module, generateContext) {
 		const source = new ReplaceSource(new RawSource(""));
+		/** @type {InitFragment<TODO>[]} */
 		const initFragments = [];
 		const cssExports = new Map();
 
@@ -57,6 +63,9 @@ class CssExportsGenerator extends Generator {
 			cssExports
 		};
 
+		/**
+		 * @param {Dependency} dependency the dependency
+		 */
 		const handleDependency = dependency => {
 			const constructor = /** @type {new (...args: any[]) => Dependency} */ (
 				dependency.constructor

package/lib/css/CssGenerator.js

@@ -30,7 +30,7 @@ class CssGenerator extends Generator {
 	 * @returns {Source} generated code
 	 */
 	generate(module, generateContext) {
-		const originalSource = module.originalSource();
+		const originalSource = /** @type {Source} */ (module.originalSource());
 		const source = new ReplaceSource(originalSource);
 		/** @type {InitFragment[]} */
 		const initFragments = [];

package/lib/css/CssLoadingRuntimeModule.js

@@ -14,6 +14,7 @@ const compileBooleanMatcher = require("../util/compileBooleanMatcher");
 const { chunkHasCss } = require("./CssModulesPlugin");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation").RuntimeRequirementsContext} RuntimeRequirementsContext */
 
 /**
@@ -67,10 +68,15 @@ class CssLoadingRuntimeModule extends RuntimeModule {
 				uniqueName,
 				chunkLoadTimeout: loadTimeout
 			}
-		} = compilation;
+		} = /** @type {Compilation} */ (compilation);
 		const fn = RuntimeGlobals.ensureChunkHandlers;
 		const conditionMap = chunkGraph.getChunkConditionMap(
-			chunk,
+			/** @type {Chunk} */ (chunk),
+			/**
+			 * @param {Chunk} chunk the chunk
+			 * @param {ChunkGraph} chunkGraph the chunk graph
+			 * @returns {boolean} true, if the chunk has css
+			 */
 			(chunk, chunkGraph) =>
 				!!chunkGraph.getChunkModulesIterableBySourceType(chunk, "css")
 		);
@@ -87,7 +93,7 @@ class CssLoadingRuntimeModule extends RuntimeModule {
 		const initialChunkIdsWithCss = new Set();
 		/** @type {Set<number | string | null>} */
 		const initialChunkIdsWithoutCss = new Set();
-		for (const c of chunk.getAllInitialChunks()) {
+		for (const c of /** @type {Chunk} */ (chunk).getAllInitialChunks()) {
 			(chunkHasCss(c, chunkGraph)
 				? initialChunkIdsWithCss
 				: initialChunkIdsWithoutCss
@@ -98,8 +104,9 @@ class CssLoadingRuntimeModule extends RuntimeModule {
 			return null;
 		}
 
-		const { createStylesheet } =
-			CssLoadingRuntimeModule.getCompilationHooks(compilation);
+		const { createStylesheet } = CssLoadingRuntimeModule.getCompilationHooks(
+			/** @type {Compilation} */ (compilation)
+		);
 
 		const stateExpression = withHmr
 			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_css`
@@ -239,7 +246,7 @@ class CssLoadingRuntimeModule extends RuntimeModule {
 					"if(!link) {",
 					Template.indent([
 						"needAttach = true;",
-						createStylesheet.call(code, this.chunk)
+						createStylesheet.call(code, /** @type {Chunk} */ (this.chunk))
 					]),
 					"}",
 					`var onLinkComplete = ${runtimeTemplate.basicFunction(

package/lib/css/CssModulesPlugin.js

@@ -46,6 +46,10 @@ const getCssLoadingRuntimeModule = memoize(() =>
 	require("./CssLoadingRuntimeModule")
 );
 
+/**
+ * @param {string} name name
+ * @returns {{oneOf: [{$ref: string}], definitions: *}} schema
+ */
 const getSchema = name => {
 	const { definitions } = require("../../schemas/WebpackOptions.json");
 	return {
@@ -302,6 +306,10 @@ class CssModulesPlugin {
 					return result;
 				});
 				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				/**
+				 * @param {Chunk} chunk the chunk
+				 * @returns {boolean} true, when enabled
+				 */
 				const isEnabledForChunk = chunk => {
 					const options = chunk.getEntryOptions();
 					const chunkLoading =
@@ -311,6 +319,10 @@ class CssModulesPlugin {
 					return chunkLoading === "jsonp";
 				};
 				const onceForChunkSet = new WeakSet();
+				/**
+				 * @param {Chunk} chunk chunk to check
+				 * @param {Set<string>} set runtime requirements
+				 */
 				const handler = (chunk, set) => {
 					if (onceForChunkSet.has(chunk)) return;
 					onceForChunkSet.add(chunk);
@@ -361,7 +373,10 @@ class CssModulesPlugin {
 					};
 				})
 				.filter(item => item.index !== undefined)
-				.sort((a, b) => b.index - a.index)
+				.sort(
+					(a, b) =>
+						/** @type {number} */ (b.index) - /** @type {number} */ (a.index)
+				)
 				.map(item => item.module);
 
 			return { list: sortedModules, set: new Set(sortedModules) };
@@ -455,19 +470,25 @@ class CssModulesPlugin {
 		return [
 			...this.getModulesInOrder(
 				chunk,
-				chunkGraph.getOrderedChunkModulesIterableBySourceType(
-					chunk,
-					"css-import",
-					compareModulesByIdentifier
+				/** @type {Iterable<Module>} */
+				(
+					chunkGraph.getOrderedChunkModulesIterableBySourceType(
+						chunk,
+						"css-import",
+						compareModulesByIdentifier
+					)
 				),
 				compilation
 			),
 			...this.getModulesInOrder(
 				chunk,
-				chunkGraph.getOrderedChunkModulesIterableBySourceType(
-					chunk,
-					"css",
-					compareModulesByIdentifier
+				/** @type {Iterable<Module>} */
+				(
+					chunkGraph.getOrderedChunkModulesIterableBySourceType(
+						chunk,
+						"css",
+						compareModulesByIdentifier
+					)
 				),
 				compilation
 			)
@@ -498,8 +519,11 @@ class CssModulesPlugin {
 				const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
 
 				let moduleSource =
-					codeGenResult.sources.get("css") ||
-					codeGenResult.sources.get("css-import");
+					/** @type {Source} */
+					(
+						codeGenResult.sources.get("css") ||
+							codeGenResult.sources.get("css-import")
+					);
 
 				let inheritance = [[module.cssLayer, module.supports, module.media]];
 
@@ -569,7 +593,8 @@ class CssModulesPlugin {
 					}${escapeCss(moduleId)}`
 				);
 			} catch (e) {
-				e.message += `\nduring rendering of css ${module.identifier()}`;
+				/** @type {Error} */
+				(e).message += `\nduring rendering of css ${module.identifier()}`;
 				throw e;
 			}
 		}

package/lib/dependencies/JsonExportsDependency.js

@@ -47,7 +47,7 @@ const getExportsFromData = data => {
 
 class JsonExportsDependency extends NullDependency {
 	/**
-	 * @param {JsonData=} data json data
+	 * @param {JsonData} data json data
 	 */
 	constructor(data) {
 		super();

package/lib/javascript/JavascriptModulesPlugin.js

@@ -937,6 +937,7 @@ class JavascriptModulesPlugin {
 				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderContent plugins should return something"
 			);
 		}
+
 		finalSource = InitFragment.addToSource(
 			finalSource,
 			chunkRenderContext.chunkInitFragments,

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