webpack 5.76.1 → 5.88.0

package/lib/Module.js

@@ -28,11 +28,14 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./ExportsInfo").UsageStateType} UsageStateType */
 /** @typedef {import("./FileSystemInfo")} FileSystemInfo */
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("./ModuleTypeConstants").ModuleTypes} ModuleTypes */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./util/Hash")} Hash */
 /** @template T @typedef {import("./util/LazySet")<T>} LazySet<T> */
 /** @template T @typedef {import("./util/SortableSet")<T>} SortableSet<T> */
@@ -104,6 +107,12 @@ const makeSerializable = require("./util/makeSerializable");
  */
 
 /** @typedef {KnownBuildMeta & Record<string, any>} BuildMeta */
+/** @typedef {Record<string, any>} BuildInfo */
+
+/**
+ * @typedef {Object} FactoryMeta
+ * @property {boolean=} sideEffectFree
+ */
 
 const EMPTY_RESOLVE_OPTIONS = {};
 
@@ -113,6 +122,11 @@ const DEFAULT_TYPES_UNKNOWN = new Set(["unknown"]);
 const DEFAULT_TYPES_JS = new Set(["javascript"]);
 
 const deprecatedNeedRebuild = util.deprecate(
+	/**
+	 * @param {Module} module the module
+	 * @param {NeedBuildContext} context context info
+	 * @returns {boolean} true, when rebuild is needed
+	 */
 	(module, context) => {
 		return module.needRebuild(
 			context.fileSystemInfo.getDeprecatedFileTimestamps(),
@@ -127,14 +141,14 @@ const deprecatedNeedRebuild = util.deprecate(
 
 class Module extends DependenciesBlock {
 	/**
-	 * @param {string} type the module type
-	 * @param {string=} context an optional context
-	 * @param {string=} layer an optional layer in which the module is
+	 * @param {ModuleTypes | ""} type the module type, when deserializing the type is not known and is an empty string
+	 * @param {(string | null)=} context an optional context
+	 * @param {(string | null)=} layer an optional layer in which the module is
 	 */
 	constructor(type, context = null, layer = null) {
 		super();
 
-		/** @type {string} */
+		/** @type {ModuleTypes} */
 		this.type = type;
 		/** @type {string | null} */
 		this.context = context;
@@ -148,9 +162,9 @@ class Module extends DependenciesBlock {
 		this.debugId = debugId++;
 
 		// Info from Factory
-		/** @type {ResolveOptions} */
+		/** @type {ResolveOptions | undefined} */
 		this.resolveOptions = EMPTY_RESOLVE_OPTIONS;
-		/** @type {object | undefined} */
+		/** @type {FactoryMeta | undefined} */
 		this.factoryMeta = undefined;
 		// TODO refactor this -> options object filled from Factory
 		// TODO webpack 6: use an enum
@@ -164,9 +178,9 @@ class Module extends DependenciesBlock {
 		this._warnings = undefined;
 		/** @type {WebpackError[] | undefined} */
 		this._errors = undefined;
-		/** @type {BuildMeta} */
+		/** @type {BuildMeta | undefined} */
 		this.buildMeta = undefined;
-		/** @type {Record<string, any>} */
+		/** @type {BuildInfo | undefined} */
 		this.buildInfo = undefined;
 		/** @type {Dependency[] | undefined} */
 		this.presentationalDependencies = undefined;
@@ -328,6 +342,10 @@ class Module extends DependenciesBlock {
 		);
 	}
 
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {boolean} true, when the module was added
+	 */
 	addChunk(chunk) {
 		const chunkGraph = ChunkGraph.getChunkGraphForModule(
 			this,
@@ -339,6 +357,10 @@ class Module extends DependenciesBlock {
 		return true;
 	}
 
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {void}
+	 */
 	removeChunk(chunk) {
 		return ChunkGraph.getChunkGraphForModule(
 			this,
@@ -347,6 +369,10 @@ class Module extends DependenciesBlock {
 		).disconnectChunkAndModule(chunk, this);
 	}
 
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {boolean} true, when the module is in the chunk
+	 */
 	isInChunk(chunk) {
 		return ChunkGraph.getChunkGraphForModule(
 			this,
@@ -418,7 +444,7 @@ class Module extends DependenciesBlock {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {boolean} strict the importing module is strict
+	 * @param {boolean | undefined} strict the importing module is strict
 	 * @returns {"namespace" | "default-only" | "default-with-named" | "dynamic"} export type
 	 * "namespace": Exports is already a namespace object. namespace = exports.
 	 * "dynamic": Check at runtime if __esModule is set. When set: namespace = { ...exports, default: exports }. When not set: namespace = { default: exports }.
@@ -432,7 +458,7 @@ class Module extends DependenciesBlock {
 			case "namespace":
 				return "namespace";
 			case "default":
-				switch (this.buildMeta.defaultObject) {
+				switch (/** @type {BuildMeta} */ (this.buildMeta).defaultObject) {
 					case "redirect":
 						return "default-with-named";
 					case "redirect-warn":
@@ -444,7 +470,7 @@ class Module extends DependenciesBlock {
 				if (strict) return "default-with-named";
 				// Try to figure out value of __esModule by following reexports
 				const handleDefault = () => {
-					switch (this.buildMeta.defaultObject) {
+					switch (/** @type {BuildMeta} */ (this.buildMeta).defaultObject) {
 						case "redirect":
 						case "redirect-warn":
 							return "default-with-named";
@@ -661,7 +687,7 @@ class Module extends DependenciesBlock {
 		] of moduleGraph.getIncomingConnectionsByOriginModule(this)) {
 			if (!connections.some(c => c.isTargetActive(chunk.runtime))) continue;
 			for (const originChunk of chunkGraph.getModuleChunksIterable(
-				fromModule
+				/** @type {Module} */ (fromModule)
 			)) {
 				// return true if module this is not reachable from originChunk when ignoring chunk
 				if (!this.isAccessibleInChunk(chunkGraph, originChunk, chunk))
@@ -976,6 +1002,9 @@ class Module extends DependenciesBlock {
 		buildDependencies
 	) {}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		write(this.type);
@@ -1002,6 +1031,9 @@ class Module extends DependenciesBlock {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 		this.type = read();

package/lib/ModuleBuildError.js

@@ -9,6 +9,9 @@ const { cutOffLoaderExecution } = require("./ErrorHelpers");
 const WebpackError = require("./WebpackError");
 const makeSerializable = require("./util/makeSerializable");
 
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
 class ModuleBuildError extends WebpackError {
 	/**
 	 * @param {string | Error&any} err error thrown
@@ -55,6 +58,9 @@ class ModuleBuildError extends WebpackError {
 		this.error = err;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 
@@ -63,6 +69,9 @@ class ModuleBuildError extends WebpackError {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 

package/lib/ModuleDependencyError.js

@@ -23,7 +23,7 @@ class ModuleDependencyError extends WebpackError {
 		this.name = "ModuleDependencyError";
 		this.details =
 			err && !(/** @type {any} */ (err).hideStack)
-				? err.stack.split("\n").slice(1).join("\n")
+				? /** @type {string} */ (err.stack).split("\n").slice(1).join("\n")
 				: undefined;
 		this.module = module;
 		this.loc = loc;
@@ -32,7 +32,9 @@ class ModuleDependencyError extends WebpackError {
 
 		if (err && /** @type {any} */ (err).hideStack) {
 			this.stack =
-				err.stack.split("\n").slice(1).join("\n") + "\n\n" + this.stack;
+				/** @type {string} */ (err.stack).split("\n").slice(1).join("\n") +
+				"\n\n" +
+				this.stack;
 		}
 	}
 }

package/lib/ModuleDependencyWarning.js

@@ -23,7 +23,7 @@ class ModuleDependencyWarning extends WebpackError {
 		this.name = "ModuleDependencyWarning";
 		this.details =
 			err && !(/** @type {any} */ (err).hideStack)
-				? err.stack.split("\n").slice(1).join("\n")
+				? /** @type {string} */ (err.stack).split("\n").slice(1).join("\n")
 				: undefined;
 		this.module = module;
 		this.loc = loc;
@@ -32,7 +32,9 @@ class ModuleDependencyWarning extends WebpackError {
 
 		if (err && /** @type {any} */ (err).hideStack) {
 			this.stack =
-				err.stack.split("\n").slice(1).join("\n") + "\n\n" + this.stack;
+				/** @type {string} */ (err.stack).split("\n").slice(1).join("\n") +
+				"\n\n" +
+				this.stack;
 		}
 	}
 }

package/lib/ModuleError.js

@@ -9,6 +9,9 @@ const { cleanUp } = require("./ErrorHelpers");
 const WebpackError = require("./WebpackError");
 const makeSerializable = require("./util/makeSerializable");
 
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
 class ModuleError extends WebpackError {
 	/**
 	 * @param {Error} err error thrown
@@ -39,6 +42,9 @@ class ModuleError extends WebpackError {
 				: undefined;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 
@@ -47,6 +53,9 @@ class ModuleError extends WebpackError {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 

package/lib/ModuleFactory.js

@@ -38,7 +38,7 @@ class ModuleFactory {
 	/**
 	 * @abstract
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {

package/lib/ModuleFilenameHelpers.js

@@ -14,6 +14,9 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {typeof import("./util/Hash")} Hash */
 
+/** @typedef {string | RegExp | (string | RegExp)[]} Matcher */
+/** @typedef {{test?: Matcher, include?: Matcher, exclude?: Matcher }} MatchObject */
+
 const ModuleFilenameHelpers = exports;
 
 // TODO webpack 6: consider removing these
@@ -43,6 +46,12 @@ ModuleFilenameHelpers.REGEXP_HASH = /\[hash\]/gi;
 ModuleFilenameHelpers.NAMESPACE = "[namespace]";
 ModuleFilenameHelpers.REGEXP_NAMESPACE = /\[namespace\]/gi;
 
+/**
+ * Returns a function that returns the part of the string after the token
+ * @param {() => string} strFn the function to get the string
+ * @param {string} token the token to search for
+ * @returns {() => string} a function that returns the part of the string after the token
+ */
 const getAfter = (strFn, token) => {
 	return () => {
 		const str = strFn();
@@ -51,6 +60,12 @@ const getAfter = (strFn, token) => {
 	};
 };
 
+/**
+ * Returns a function that returns the part of the string before the token
+ * @param {() => string} strFn the function to get the string
+ * @param {string} token the token to search for
+ * @returns {() => string} a function that returns the part of the string before the token
+ */
 const getBefore = (strFn, token) => {
 	return () => {
 		const str = strFn();
@@ -59,6 +74,12 @@ const getBefore = (strFn, token) => {
 	};
 };
 
+/**
+ * Returns a function that returns a hash of the string
+ * @param {() => string} strFn the function to get the string
+ * @param {string | Hash} hashFunction the hash function to use
+ * @returns {() => string} a function that returns the hash of the string
+ */
 const getHash = (strFn, hashFunction) => {
 	return () => {
 		const hash = createHash(hashFunction);
@@ -68,13 +89,35 @@ const getHash = (strFn, hashFunction) => {
 	};
 };
 
+/**
+ * Returns a function that returns the string with the token replaced with the replacement
+ * @param {string|RegExp} test A regular expression string or Regular Expression object
+ * @returns	{RegExp} A regular expression object
+ * @example
+ * ```js
+ * const test = asRegExp("test");
+ * test.test("test"); // true
+ *
+ * const test2 = asRegExp(/test/);
+ * test2.test("test"); // true
+ * ```
+ */
 const asRegExp = test => {
 	if (typeof test === "string") {
+		// Escape special characters in the string to prevent them from being interpreted as special characters in a regular expression. Do this by
+		// adding a backslash before each special character
 		test = new RegExp("^" + test.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"));
 	}
 	return test;
 };
 
+/**
+ * @template T
+ * Returns a lazy object. The object is lazy in the sense that the properties are
+ * only evaluated when they are accessed. This is only obtained by setting a function as the value for each key.
+ * @param {Record<string, () => T>} obj the object to covert to a lazy access object
+ * @returns {Object} the lazy access object
+ */
 const lazyObject = obj => {
 	const newObj = {};
 	for (const key of Object.keys(obj)) {
@@ -95,7 +138,7 @@ const lazyObject = obj => {
 	return newObj;
 };
 
-const REGEXP = /\[\\*([\w-]+)\\*\]/gi;
+const SQUARE_BRACKET_TAG_REGEXP = /\[\\*([\w-]+)\\*\]/gi;
 
 /**
  *
@@ -162,6 +205,7 @@ ModuleFilenameHelpers.createFilename = (
 				resource: resource,
 				resourcePath: memoize(resourcePath),
 				absoluteResourcePath: memoize(absoluteResourcePath),
+				loaders: memoize(loaders),
 				allLoaders: memoize(allLoaders),
 				query: memoize(query),
 				moduleId: memoize(moduleId),
@@ -211,7 +255,7 @@ ModuleFilenameHelpers.createFilename = (
 			ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE,
 			"[short-identifier]"
 		)
-		.replace(REGEXP, (match, content) => {
+		.replace(SQUARE_BRACKET_TAG_REGEXP, (match, content) => {
 			if (content.length + 2 === match.length) {
 				const replacement = replacements.get(content.toLowerCase());
 				if (replacement !== undefined) {
@@ -224,9 +268,28 @@ ModuleFilenameHelpers.createFilename = (
 		});
 };
 
+/**
+ * Replaces duplicate items in an array with new values generated by a callback function.
+ * The callback function is called with the duplicate item, the index of the duplicate item, and the number of times the item has been replaced.
+ * The callback function should return the new value for the duplicate item.
+ *
+ * @template T
+ * @param {T[]} array the array with duplicates to be replaced
+ * @param {(duplicateItem: T, duplicateItemIndex: number, numberOfTimesReplaced: number) => T} fn callback function to generate new values for the duplicate items
+ * @param {(firstElement:T, nextElement:T) => -1 | 0 | 1} [comparator] optional comparator function to sort the duplicate items
+ * @returns {T[]} the array with duplicates replaced
+ *
+ * @example
+ * ```js
+ * const array = ["a", "b", "c", "a", "b", "a"];
+ * const result = ModuleFilenameHelpers.replaceDuplicates(array, (item, index, count) => `${item}-${count}`);
+ * // result: ["a-1", "b-1", "c", "a-2", "b-2", "a-3"]
+ * ```
+ */
 ModuleFilenameHelpers.replaceDuplicates = (array, fn, comparator) => {
 	const countMap = Object.create(null);
 	const posMap = Object.create(null);
+
 	array.forEach((item, idx) => {
 		countMap[item] = countMap[item] || [];
 		countMap[item].push(idx);
@@ -247,16 +310,63 @@ ModuleFilenameHelpers.replaceDuplicates = (array, fn, comparator) => {
 	});
 };
 
+/**
+ * Tests if a string matches a RegExp or an array of RegExp.
+ *
+ * @param {string} str string to test
+ * @param {Matcher} test value which will be used to match against the string
+ * @returns {boolean} true, when the RegExp matches
+ *
+ * @example
+ * ```js
+ * ModuleFilenameHelpers.matchPart("foo.js", "foo"); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", "foo.js"); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", "foo."); // false
+ * ModuleFilenameHelpers.matchPart("foo.js", "foo*"); // false
+ * ModuleFilenameHelpers.matchPart("foo.js", "foo.*"); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", /^foo/); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", [/^foo/, "bar"]); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", [/^foo/, "bar"]); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", [/^foo/, /^bar/]); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", [/^baz/, /^bar/]); // false
+ * ```
+ */
 ModuleFilenameHelpers.matchPart = (str, test) => {
 	if (!test) return true;
-	test = asRegExp(test);
+
 	if (Array.isArray(test)) {
 		return test.map(asRegExp).some(regExp => regExp.test(str));
 	} else {
-		return test.test(str);
+		return asRegExp(test).test(str);
 	}
 };
 
+/**
+ * Tests if a string matches a match object. The match object can have the following properties:
+ * - `test`: a RegExp or an array of RegExp
+ * - `include`: a RegExp or an array of RegExp
+ * - `exclude`: a RegExp or an array of RegExp
+ *
+ * The `test` property is tested first, then `include` and then `exclude`.
+ *
+ * @param {MatchObject} obj a match object to test against the string
+ * @param {string} str string to test against the matching object
+ * @returns {boolean} true, when the object matches
+ * @example
+ * ```js
+ * ModuleFilenameHelpers.matchObject({ test: "foo.js" }, "foo.js"); // true
+ * ModuleFilenameHelpers.matchObject({ test: /^foo/ }, "foo.js"); // true
+ * ModuleFilenameHelpers.matchObject({ test: [/^foo/, "bar"] }, "foo.js"); // true
+ * ModuleFilenameHelpers.matchObject({ test: [/^foo/, "bar"] }, "baz.js"); // false
+ * ModuleFilenameHelpers.matchObject({ include: "foo.js" }, "foo.js"); // true
+ * ModuleFilenameHelpers.matchObject({ include: "foo.js" }, "bar.js"); // false
+ * ModuleFilenameHelpers.matchObject({ include: /^foo/ }, "foo.js"); // true
+ * ModuleFilenameHelpers.matchObject({ include: [/^foo/, "bar"] }, "foo.js"); // true
+ * ModuleFilenameHelpers.matchObject({ include: [/^foo/, "bar"] }, "baz.js"); // false
+ * ModuleFilenameHelpers.matchObject({ exclude: "foo.js" }, "foo.js"); // false
+ * ModuleFilenameHelpers.matchObject({ exclude: [/^foo/, "bar"] }, "foo.js"); // false
+ * ```
+ */
 ModuleFilenameHelpers.matchObject = (obj, str) => {
 	if (obj.test) {
 		if (!ModuleFilenameHelpers.matchPart(str, obj.test)) {

package/lib/ModuleGraph.js

@@ -35,14 +35,15 @@ const getConnectionsByOriginModule = set => {
 	const map = new Map();
 	/** @type {Module | 0} */
 	let lastModule = 0;
-	/** @type {ModuleGraphConnection[]} */
+	/** @type {ModuleGraphConnection[] | undefined} */
 	let lastList = undefined;
 	for (const connection of set) {
 		const { originModule } = connection;
 		if (lastModule === originModule) {
-			lastList.push(connection);
+			/** @type {ModuleGraphConnection[]} */
+			(lastList).push(connection);
 		} else {
-			lastModule = originModule;
+			lastModule = /** @type {Module} */ (originModule);
 			const list = map.get(originModule);
 			if (list !== undefined) {
 				lastList = list;
@@ -65,12 +66,13 @@ const getConnectionsByModule = set => {
 	const map = new Map();
 	/** @type {Module | 0} */
 	let lastModule = 0;
-	/** @type {ModuleGraphConnection[]} */
+	/** @type {ModuleGraphConnection[] | undefined} */
 	let lastList = undefined;
 	for (const connection of set) {
 		const { module } = connection;
 		if (lastModule === module) {
-			lastList.push(connection);
+			/** @type {ModuleGraphConnection[]} */
+			(lastList).push(connection);
 		} else {
 			lastModule = module;
 			const list = map.get(module);
@@ -99,13 +101,13 @@ class ModuleGraphModule {
 		this.optimizationBailout = [];
 		/** @type {ExportsInfo} */
 		this.exports = new ExportsInfo();
-		/** @type {number} */
+		/** @type {number | null} */
 		this.preOrderIndex = null;
-		/** @type {number} */
+		/** @type {number | null} */
 		this.postOrderIndex = null;
-		/** @type {number} */
+		/** @type {number | null} */
 		this.depth = null;
-		/** @type {ModuleProfile} */
+		/** @type {ModuleProfile | undefined | null} */
 		this.profile = undefined;
 		/** @type {boolean} */
 		this.async = false;
@@ -116,18 +118,21 @@ class ModuleGraphModule {
 
 class ModuleGraph {
 	constructor() {
-		/** @type {WeakMap<Dependency, ModuleGraphConnection>} */
+		/** @type {WeakMap<Dependency, ModuleGraphConnection | null>} */
 		this._dependencyMap = new WeakMap();
 		/** @type {Map<Module, ModuleGraphModule>} */
 		this._moduleMap = new Map();
 		/** @type {WeakMap<any, Object>} */
 		this._metaMap = new WeakMap();
 
-		/** @type {WeakTupleMap<any[], any>} */
+		/** @type {WeakTupleMap<any[], any> | undefined} */
 		this._cache = undefined;
 
 		/** @type {Map<Module, WeakTupleMap<any, any>>} */
 		this._moduleMemCaches = undefined;
+
+		/** @type {string | undefined} */
+		this._cacheStage = undefined;
 	}
 
 	/**
@@ -218,7 +223,9 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	updateModule(dependency, module) {
-		const connection = this.getConnection(dependency);
+		const connection =
+			/** @type {ModuleGraphConnection} */
+			(this.getConnection(dependency));
 		if (connection.module === module) return;
 		const newConnection = connection.clone();
 		newConnection.module = module;
@@ -372,7 +379,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Dependency} dependency the dependency to look for a referenced module
-	 * @returns {Module} the referenced module
+	 * @returns {Module | null} the referenced module
 	 */
 	getResolvedModule(dependency) {
 		const connection = this.getConnection(dependency);
@@ -395,7 +402,10 @@ class ModuleGraph {
 				) {
 					let foundConnection;
 					for (const connection of mgm._unassignedConnections) {
-						this._dependencyMap.set(connection.dependency, connection);
+						this._dependencyMap.set(
+							/** @type {Dependency} */ (connection.dependency),
+							connection
+						);
 						if (connection.dependency === dependency)
 							foundConnection = connection;
 					}
@@ -413,7 +423,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Dependency} dependency the dependency to look for a referenced module
-	 * @returns {Module} the referenced module
+	 * @returns {Module | null} the referenced module
 	 */
 	getModule(dependency) {
 		const connection = this.getConnection(dependency);
@@ -422,7 +432,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Dependency} dependency the dependency to look for a referencing module
-	 * @returns {Module} the referencing module
+	 * @returns {Module | null} the referencing module
 	 */
 	getOrigin(dependency) {
 		const connection = this.getConnection(dependency);
@@ -431,7 +441,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Dependency} dependency the dependency to look for a referencing module
-	 * @returns {Module} the original referencing module
+	 * @returns {Module | null} the original referencing module
 	 */
 	getResolvedOrigin(dependency) {
 		const connection = this.getConnection(dependency);
@@ -601,7 +611,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {number} the index of the module
+	 * @returns {number | null} the index of the module
 	 */
 	getPreOrderIndex(module) {
 		const mgm = this._getModuleGraphModule(module);
@@ -610,7 +620,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {number} the index of the module
+	 * @returns {number | null} the index of the module
 	 */
 	getPostOrderIndex(module) {
 		const mgm = this._getModuleGraphModule(module);
@@ -667,7 +677,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {number} the depth of the module
+	 * @returns {number | null} the depth of the module
 	 */
 	getDepth(module) {
 		const mgm = this._getModuleGraphModule(module);
@@ -724,14 +734,14 @@ class ModuleGraph {
 		let meta = this._metaMap.get(thing);
 		if (meta === undefined) {
 			meta = Object.create(null);
-			this._metaMap.set(thing, meta);
+			this._metaMap.set(thing, /** @type {Object} */ (meta));
 		}
-		return meta;
+		return /** @type {Object} */ (meta);
 	}
 
 	/**
 	 * @param {any} thing any thing
-	 * @returns {Object} metadata
+	 * @returns {Object | undefined} metadata
 	 */
 	getMetaIfExisting(thing) {
 		return this._metaMap.get(thing);