webpack 5.97.1 → 5.104.1

package/lib/ModuleGraph.js

@@ -8,16 +8,24 @@
 const util = require("util");
 const ExportsInfo = require("./ExportsInfo");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
+const HarmonyImportDependency = require("./dependencies/HarmonyImportDependency");
+const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
 const SortableSet = require("./util/SortableSet");
 const WeakTupleMap = require("./util/WeakTupleMap");
+const { sortWithSourceOrder } = require("./util/comparators");
 
+/** @typedef {import("./Compilation").ModuleMemCaches} ModuleMemCaches */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./ExportsInfo").ExportInfo} ExportInfo */
+/** @typedef {import("./ExportsInfo").ExportInfoName} ExportInfoName */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleProfile")} ModuleProfile */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./dependencies/HarmonyImportSideEffectDependency")} HarmonyImportSideEffectDependency */
+/** @typedef {import("./dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
+/** @typedef {import("./util/comparators").DependencySourceOrder} DependencySourceOrder */
 
 /**
  * @callback OptimizationBailoutFunction
@@ -28,30 +36,32 @@ const WeakTupleMap = require("./util/WeakTupleMap");
 const EMPTY_SET = new Set();
 
 /**
+ * @template {Module | null | undefined} T
  * @param {SortableSet<ModuleGraphConnection>} set input
- * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by origin module
+ * @param {(connection: ModuleGraphConnection) => T} getKey function to extract key from connection
+ * @returns {ReadonlyMap<T, ReadonlyArray<ModuleGraphConnection>>} mapped by key
  */
-const getConnectionsByOriginModule = set => {
+const getConnectionsByKey = (set, getKey) => {
 	const map = new Map();
-	/** @type {Module | 0} */
-	let lastModule = 0;
+	/** @type {T | 0} */
+	let lastKey = 0;
 	/** @type {ModuleGraphConnection[] | undefined} */
 	let lastList;
 	for (const connection of set) {
-		const { originModule } = connection;
-		if (lastModule === originModule) {
+		const key = getKey(connection);
+		if (lastKey === key) {
 			/** @type {ModuleGraphConnection[]} */
 			(lastList).push(connection);
 		} else {
-			lastModule = /** @type {Module} */ (originModule);
-			const list = map.get(originModule);
+			lastKey = key;
+			const list = map.get(key);
 			if (list !== undefined) {
 				lastList = list;
 				list.push(connection);
 			} else {
 				const list = [connection];
 				lastList = list;
-				map.set(originModule, list);
+				map.set(key, list);
 			}
 		}
 	}
@@ -60,37 +70,22 @@ const getConnectionsByOriginModule = set => {
 
 /**
  * @param {SortableSet<ModuleGraphConnection>} set input
- * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by module
+ * @returns {ReadonlyMap<Module | undefined | null, ReadonlyArray<ModuleGraphConnection>>} mapped by origin module
  */
-const getConnectionsByModule = set => {
-	const map = new Map();
-	/** @type {Module | 0} */
-	let lastModule = 0;
-	/** @type {ModuleGraphConnection[] | undefined} */
-	let lastList;
-	for (const connection of set) {
-		const { module } = connection;
-		if (lastModule === module) {
-			/** @type {ModuleGraphConnection[]} */
-			(lastList).push(connection);
-		} else {
-			lastModule = module;
-			const list = map.get(module);
-			if (list !== undefined) {
-				lastList = list;
-				list.push(connection);
-			} else {
-				const list = [connection];
-				lastList = list;
-				map.set(module, list);
-			}
-		}
-	}
-	return map;
-};
+const getConnectionsByOriginModule = (set) =>
+	getConnectionsByKey(set, (connection) => connection.originModule);
+
+/**
+ * @param {SortableSet<ModuleGraphConnection>} set input
+ * @returns {ReadonlyMap<Module | undefined, ReadonlyArray<ModuleGraphConnection>>} mapped by module
+ */
+const getConnectionsByModule = (set) =>
+	getConnectionsByKey(set, (connection) => connection.module);
 
 /** @typedef {SortableSet<ModuleGraphConnection>} IncomingConnections */
 /** @typedef {SortableSet<ModuleGraphConnection>} OutgoingConnections */
+/** @typedef {Module | null | undefined} Issuer */
+/** @typedef {(string | OptimizationBailoutFunction)[]} OptimizationBailouts */
 
 class ModuleGraphModule {
 	constructor() {
@@ -98,9 +93,9 @@ class ModuleGraphModule {
 		this.incomingConnections = new SortableSet();
 		/** @type {OutgoingConnections | undefined} */
 		this.outgoingConnections = undefined;
-		/** @type {Module | null | undefined} */
+		/** @type {Issuer} */
 		this.issuer = undefined;
-		/** @type {(string | OptimizationBailoutFunction)[]} */
+		/** @type {OptimizationBailouts} */
 		this.optimizationBailout = [];
 		/** @type {ExportsInfo} */
 		this.exports = new ExportsInfo();
@@ -119,6 +114,22 @@ class ModuleGraphModule {
 	}
 }
 
+/** @typedef {(moduleGraphConnection: ModuleGraphConnection) => boolean} FilterConnection */
+
+/** @typedef {EXPECTED_OBJECT} MetaKey */
+
+/** @typedef {import("./dependencies/CommonJsExportRequireDependency").idsSymbol} CommonJsExportRequireDependencyIDsSymbol */
+/** @typedef {import("./dependencies/HarmonyImportSpecifierDependency").idsSymbol} HarmonyImportSpecifierDependencyIDsSymbol */
+/** @typedef {import("./dependencies/HarmonyExportImportedSpecifierDependency").idsSymbol} HarmonyExportImportedSpecifierDependencyIDsSymbol */
+
+/**
+ * @typedef {object} KnownMeta
+ * @property {Map<Module, string>=} importVarMap
+ * @property {Map<Module, string>=} deferredImportVarMap
+ */
+
+/** @typedef {KnownMeta & Record<CommonJsExportRequireDependencyIDsSymbol | HarmonyImportSpecifierDependencyIDsSymbol | HarmonyExportImportedSpecifierDependencyIDsSymbol, string[]> & Record<string, EXPECTED_ANY>} Meta */
+
 class ModuleGraph {
 	constructor() {
 		/**
@@ -132,17 +143,17 @@ class ModuleGraph {
 		 */
 		this._moduleMap = new Map();
 		/**
-		 * @type {WeakMap<any, object>}
+		 * @type {WeakMap<MetaKey, Meta>}
 		 * @private
 		 */
 		this._metaMap = new WeakMap();
 		/**
-		 * @type {WeakTupleMap<any[], any> | undefined}
+		 * @type {WeakTupleMap<EXPECTED_ANY[], EXPECTED_ANY> | undefined}
 		 * @private
 		 */
 		this._cache = undefined;
 		/**
-		 * @type {Map<Module, WeakTupleMap<any, any>> | undefined}
+		 * @type {ModuleMemCaches | undefined}
 		 * @private
 		 */
 		this._moduleMemCaches = undefined;
@@ -152,6 +163,18 @@ class ModuleGraph {
 		 * @private
 		 */
 		this._cacheStage = undefined;
+
+		/**
+		 * @type {WeakMap<Dependency, DependencySourceOrder>}
+		 * @private
+		 */
+		this._dependencySourceOrderMap = new WeakMap();
+
+		/**
+		 * @type {Set<Module>}
+		 * @private
+		 */
+		this._modulesNeedingSort = new Set();
 	}
 
 	/**
@@ -180,6 +203,15 @@ class ModuleGraph {
 		dependency._parentModule = module;
 	}
 
+	/**
+	 * @param {Dependency} dependency the dependency
+	 * @param {number} index the index
+	 * @returns {void}
+	 */
+	setParentDependenciesBlockIndex(dependency, index) {
+		dependency._parentDependenciesBlockIndex = index;
+	}
+
 	/**
 	 * @param {Dependency} dependency the dependency
 	 * @returns {Module | undefined} parent module
@@ -259,6 +291,73 @@ class ModuleGraph {
 		targetMgm.incomingConnections.add(newConnection);
 	}
 
+	/**
+	 * @param {Dependency} dependency the need update dependency
+	 * @param {ModuleGraphConnection=} connection the target connection
+	 * @param {Module=} parentModule the parent module
+	 * @returns {void}
+	 */
+	updateParent(dependency, connection, parentModule) {
+		if (this._dependencySourceOrderMap.has(dependency)) {
+			return;
+		}
+		if (!connection || !parentModule) {
+			return;
+		}
+		const originDependency = connection.dependency;
+
+		// src/index.js
+		// import { c } from "lib/c" -> c = 0
+		// import { a, b } from "lib" -> a and b have the same source order -> a = b = 1
+		// import { d } from "lib/d" -> d = 2
+		const currentSourceOrder =
+			/** @type {HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */
+			(dependency).sourceOrder;
+
+		// lib/index.js (reexport)
+		// import { a } from "lib/a" -> a = 0
+		// import { b } from "lib/b" -> b = 1
+		const originSourceOrder =
+			/** @type {HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */
+			(originDependency).sourceOrder;
+		if (
+			typeof currentSourceOrder === "number" &&
+			typeof originSourceOrder === "number"
+		) {
+			// src/index.js
+			// import { c } from "lib/c" -> c = 0
+			// import { a } from "lib/a" -> a = 1.0 = 1(main) + 0.0(sub)
+			// import { b } from "lib/b" -> b = 1.1 = 1(main) + 0.1(sub)
+			// import { d } from "lib/d" -> d = 2
+			this._dependencySourceOrderMap.set(dependency, {
+				main: currentSourceOrder,
+				sub: originSourceOrder
+			});
+
+			// Save for later batch sorting
+			this._modulesNeedingSort.add(parentModule);
+		}
+	}
+
+	/**
+	 * @returns {void}
+	 */
+	finishUpdateParent() {
+		if (this._modulesNeedingSort.size === 0) {
+			return;
+		}
+		for (const mod of this._modulesNeedingSort) {
+			// If dependencies like HarmonyImportSideEffectDependency and HarmonyImportSpecifierDependency have a SourceOrder,
+			// we sort based on it; otherwise, we preserve the original order.
+			sortWithSourceOrder(
+				mod.dependencies,
+				this._dependencySourceOrderMap,
+				(dep, index) => this.setParentDependenciesBlockIndex(dep, index)
+			);
+		}
+		this._modulesNeedingSort.clear();
+	}
+
 	/**
 	 * @param {Dependency} dependency the referencing dependency
 	 * @returns {void}
@@ -331,7 +430,7 @@ class ModuleGraph {
 	/**
 	 * @param {Module} oldModule the old referencing module
 	 * @param {Module} newModule the new referencing module
-	 * @param {function(ModuleGraphConnection): boolean} filterConnection filter predicate for replacement
+	 * @param {FilterConnection} filterConnection filter predicate for replacement
 	 * @returns {void}
 	 */
 	moveModuleConnections(oldModule, newModule, filterConnection) {
@@ -368,7 +467,7 @@ class ModuleGraph {
 	/**
 	 * @param {Module} oldModule the old referencing module
 	 * @param {Module} newModule the new referencing module
-	 * @param {function(ModuleGraphConnection): boolean} filterConnection filter predicate for replacement
+	 * @param {FilterConnection} filterConnection filter predicate for replacement
 	 * @returns {void}
 	 */
 	copyOutgoingModuleConnections(oldModule, newModule, filterConnection) {
@@ -435,8 +534,9 @@ class ModuleGraph {
 							/** @type {Dependency} */ (connection.dependency),
 							connection
 						);
-						if (connection.dependency === dependency)
+						if (connection.dependency === dependency) {
 							foundConnection = connection;
+						}
 					}
 					mgm._unassignedConnections.length = 0;
 					if (foundConnection !== undefined) {
@@ -497,7 +597,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {readonly Map<Module | undefined | null, readonly ModuleGraphConnection[]>} reasons why a module is included, in a map by source module
+	 * @returns {ReadonlyMap<Module | undefined | null, ReadonlyArray<ModuleGraphConnection>>} reasons why a module is included, in a map by source module
 	 */
 	getIncomingConnectionsByOriginModule(module) {
 		const connections = this._getModuleGraphModule(module).incomingConnections;
@@ -506,7 +606,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]> | undefined} connections to modules, in a map by module
+	 * @returns {ReadonlyMap<Module | undefined, ReadonlyArray<ModuleGraphConnection>> | undefined} connections to modules, in a map by module
 	 */
 	getOutgoingConnectionsByModule(module) {
 		const connections = this._getModuleGraphModule(module).outgoingConnections;
@@ -536,7 +636,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {Module | null | undefined} the issuer module
+	 * @returns {Issuer} the issuer module
 	 */
 	getIssuer(module) {
 		const mgm = this._getModuleGraphModule(module);
@@ -565,7 +665,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {(string | OptimizationBailoutFunction)[]} optimization bailouts
+	 * @returns {OptimizationBailouts} optimization bailouts
 	 */
 	getOptimizationBailout(module) {
 		const mgm = this._getModuleGraphModule(module);
@@ -574,7 +674,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {true | string[] | null} the provided exports
+	 * @returns {null | true | ExportInfoName[]} the provided exports
 	 */
 	getProvidedExports(module) {
 		const mgm = this._getModuleGraphModule(module);
@@ -583,7 +683,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @param {string | string[]} exportName a name of an export
+	 * @param {ExportInfoName | ExportInfoName[]} exportName a name of an export
 	 * @returns {boolean | null} true, if the export is provided by the module.
 	 * null, if it's unknown.
 	 * false, if it's not provided.
@@ -746,6 +846,25 @@ class ModuleGraph {
 		return mgm.async;
 	}
 
+	/**
+	 * @param {Module} module the module
+	 * @returns {boolean} true, if the module is used as a deferred module at least once
+	 */
+	isDeferred(module) {
+		if (this.isAsync(module)) return false;
+		const connections = this.getIncomingConnections(module);
+		for (const connection of connections) {
+			if (
+				!connection.dependency ||
+				!(connection.dependency instanceof HarmonyImportDependency)
+			) {
+				continue;
+			}
+			if (ImportPhaseUtils.isDefer(connection.dependency.phase)) return true;
+		}
+		return false;
+	}
+
 	/**
 	 * @param {Module} module the module
 	 * @returns {void}
@@ -756,21 +875,21 @@ class ModuleGraph {
 	}
 
 	/**
-	 * @param {any} thing any thing
-	 * @returns {object} metadata
+	 * @param {MetaKey} thing any thing
+	 * @returns {Meta} metadata
 	 */
 	getMeta(thing) {
 		let meta = this._metaMap.get(thing);
 		if (meta === undefined) {
-			meta = Object.create(null);
-			this._metaMap.set(thing, /** @type {object} */ (meta));
+			meta = /** @type {Meta} */ (Object.create(null));
+			this._metaMap.set(thing, meta);
 		}
-		return /** @type {object} */ (meta);
+		return meta;
 	}
 
 	/**
-	 * @param {any} thing any thing
-	 * @returns {object | undefined} metadata
+	 * @param {MetaKey} thing any thing
+	 * @returns {Meta | undefined} metadata
 	 */
 	getMetaIfExisting(thing) {
 		return this._metaMap.get(thing);
@@ -790,11 +909,11 @@ class ModuleGraph {
 	}
 
 	/**
-	 * @template {any[]} T
-	 * @template V
-	 * @param {(moduleGraph: ModuleGraph, ...args: T) => V} fn computer
+	 * @template {EXPECTED_ANY[]} T
+	 * @template R
+	 * @param {(moduleGraph: ModuleGraph, ...args: T) => R} fn computer
 	 * @param {T} args arguments
-	 * @returns {V} computed value or cached
+	 * @returns {R} computed value or cached
 	 */
 	cached(fn, ...args) {
 		if (this._cache === undefined) return fn(this, ...args);
@@ -802,23 +921,28 @@ class ModuleGraph {
 	}
 
 	/**
-	 * @param {Map<Module, WeakTupleMap<any, any>>} moduleMemCaches mem caches for modules for better caching
+	 * @param {ModuleMemCaches} moduleMemCaches mem caches for modules for better caching
 	 */
 	setModuleMemCaches(moduleMemCaches) {
 		this._moduleMemCaches = moduleMemCaches;
 	}
 
 	/**
-	 * @param {Dependency} dependency dependency
-	 * @param {...any} args arguments, last argument is a function called with moduleGraph, dependency, ...args
-	 * @returns {any} computed value or cached
+	 * @template {Dependency} D
+	 * @template {EXPECTED_ANY[]} ARGS
+	 * @template R
+	 * @param {D} dependency dependency
+	 * @param {[...ARGS, (moduleGraph: ModuleGraph, dependency: D, ...args: ARGS) => R]} args arguments, last argument is a function called with moduleGraph, dependency, ...args
+	 * @returns {R} computed value or cached
 	 */
 	dependencyCacheProvide(dependency, ...args) {
-		/** @type {(moduleGraph: ModuleGraph, dependency: Dependency, ...args: any[]) => any} */
-		const fn = args.pop();
+		const fn =
+			/** @type {(moduleGraph: ModuleGraph, dependency: D, ...args: EXPECTED_ANY[]) => R} */
+			(args.pop());
 		if (this._moduleMemCaches && this._cacheStage) {
 			const memCache = this._moduleMemCaches.get(
-				/** @type {Module} */ (this.getParentModule(dependency))
+				/** @type {Module} */
+				(this.getParentModule(dependency))
 			);
 			if (memCache !== undefined) {
 				return memCache.provide(dependency, this._cacheStage, ...args, () =>
@@ -847,14 +971,15 @@ class ModuleGraph {
 			 * @param {Module} module the module
 			 * @returns {ModuleGraph} the module graph
 			 */
-			module => {
+			(module) => {
 				const moduleGraph = moduleGraphForModuleMap.get(module);
-				if (!moduleGraph)
+				if (!moduleGraph) {
 					throw new Error(
 						`${
 							deprecateMessage
 						}There was no ModuleGraph assigned to the Module for backward-compat (Use the new API)`
 					);
+				}
 				return moduleGraph;
 			},
 			`${deprecateMessage}: Use new ModuleGraph API`,

package/lib/ModuleGraphConnection.js

@@ -52,8 +52,8 @@ const intersectConnectionStates = (a, b) => {
 
 class ModuleGraphConnection {
 	/**
-	 * @param {Module|null} originModule the referencing module
-	 * @param {Dependency|null} dependency the referencing dependency
+	 * @param {Module | null} originModule the referencing module
+	 * @param {Dependency | null} dependency the referencing dependency
 	 * @param {Module} module the referenced module
 	 * @param {string=} explanation some extra detail
 	 * @param {boolean=} weak the reference is weak
@@ -75,7 +75,6 @@ class ModuleGraphConnection {
 		this.weak = weak;
 		this.conditional = Boolean(condition);
 		this._active = condition !== false;
-		/** @type {(function(ModuleGraphConnection, RuntimeSpec): ConnectionState) | undefined} */
 		this.condition = condition || undefined;
 		/** @type {Set<string> | undefined} */
 		this.explanations = undefined;
@@ -103,15 +102,16 @@ class ModuleGraphConnection {
 	}
 
 	/**
-	 * @param {function(ModuleGraphConnection, RuntimeSpec): ConnectionState} condition condition for the connection
+	 * @param {GetConditionFn} condition condition for the connection
 	 * @returns {void}
 	 */
 	addCondition(condition) {
 		if (this.conditional) {
 			const old =
-				/** @type {(function(ModuleGraphConnection, RuntimeSpec): ConnectionState)} */
+				/** @type {GetConditionFn} */
 				(this.condition);
-			this.condition = (c, r) =>
+			/** @type {GetConditionFn} */
+			(this.condition) = (c, r) =>
 				intersectConnectionStates(old(c, r), condition(c, r));
 		} else if (this._active) {
 			this.conditional = true;
@@ -132,7 +132,7 @@ class ModuleGraphConnection {
 
 	get explanation() {
 		if (this.explanations === undefined) return "";
-		return Array.from(this.explanations).join(" ");
+		return [...this.explanations].join(" ");
 	}
 
 	/**
@@ -143,9 +143,7 @@ class ModuleGraphConnection {
 		if (!this.conditional) return this._active;
 
 		return (
-			/** @type {(function(ModuleGraphConnection, RuntimeSpec): ConnectionState)} */ (
-				this.condition
-			)(this, runtime) !== false
+			/** @type {GetConditionFn} */ (this.condition)(this, runtime) !== false
 		);
 	}
 
@@ -156,9 +154,7 @@ class ModuleGraphConnection {
 	isTargetActive(runtime) {
 		if (!this.conditional) return this._active;
 		return (
-			/** @type {(function(ModuleGraphConnection, RuntimeSpec): ConnectionState)} */ (
-				this.condition
-			)(this, runtime) === true
+			/** @type {GetConditionFn} */ (this.condition)(this, runtime) === true
 		);
 	}
 
@@ -168,9 +164,7 @@ class ModuleGraphConnection {
 	 */
 	getActiveState(runtime) {
 		if (!this.conditional) return this._active;
-		return /** @type {(function(ModuleGraphConnection, RuntimeSpec): ConnectionState)} */ (
-			this.condition
-		)(this, runtime);
+		return /** @type {GetConditionFn} */ (this.condition)(this, runtime);
 	}
 
 	/**
@@ -196,10 +190,10 @@ class ModuleGraphConnection {
 /** @typedef {typeof CIRCULAR_CONNECTION} CIRCULAR_CONNECTION */
 
 module.exports = ModuleGraphConnection;
-module.exports.addConnectionStates = addConnectionStates;
-module.exports.TRANSITIVE_ONLY = /** @type {typeof TRANSITIVE_ONLY} */ (
-	TRANSITIVE_ONLY
-);
 module.exports.CIRCULAR_CONNECTION = /** @type {typeof CIRCULAR_CONNECTION} */ (
 	CIRCULAR_CONNECTION
 );
+module.exports.TRANSITIVE_ONLY = /** @type {typeof TRANSITIVE_ONLY} */ (
+	TRANSITIVE_ONLY
+);
+module.exports.addConnectionStates = addConnectionStates;

package/lib/ModuleInfoHeaderPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const { ConcatSource, RawSource, CachedSource } = require("webpack-sources");
+const { CachedSource, ConcatSource, RawSource } = require("webpack-sources");
 const { UsageState } = require("./ExportsInfo");
 const Template = require("./Template");
 const CssModulesPlugin = require("./css/CssModulesPlugin");
@@ -18,7 +18,6 @@ const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./Module").BuildMeta} BuildMeta */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./ModuleTemplate")} ModuleTemplate */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 
 /**
@@ -26,7 +25,7 @@ const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
  * @param {Iterable<T>} iterable iterable
  * @returns {string} joined with comma
  */
-const joinIterableWithComma = iterable => {
+const joinIterableWithComma = (iterable) => {
 	// This is more performant than Array.from().join(", ")
 	// as it doesn't create an array
 	let str = "";
@@ -94,7 +93,7 @@ const printExportsInfoToSource = (
 						? ` -> ${target.module.readableIdentifier(requestShortener)}${
 								target.export
 									? ` .${target.export
-											.map(e => JSON.stringify(e).slice(1, -1))
+											.map((e) => JSON.stringify(e).slice(1, -1))
 											.join(".")}`
 									: ""
 							}`
@@ -149,6 +148,8 @@ const printExportsInfoToSource = (
 /** @type {WeakMap<RequestShortener, WeakMap<Module, { header: RawSource | undefined, full: WeakMap<Source, CachedSource> }>>} */
 const caches = new WeakMap();
 
+const PLUGIN_NAME = "ModuleInfoHeaderPlugin";
+
 class ModuleInfoHeaderPlugin {
 	/**
 	 * @param {boolean=} verbose add more information like exports, runtime requirements and bailouts
@@ -163,11 +164,11 @@ class ModuleInfoHeaderPlugin {
 	 */
 	apply(compiler) {
 		const { _verbose: verbose } = this;
-		compiler.hooks.compilation.tap("ModuleInfoHeaderPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			const javascriptHooks =
 				JavascriptModulesPlugin.getCompilationHooks(compilation);
 			javascriptHooks.renderModulePackage.tap(
-				"ModuleInfoHeaderPlugin",
+				PLUGIN_NAME,
 				(
 					moduleSource,
 					module,
@@ -246,16 +247,13 @@ class ModuleInfoHeaderPlugin {
 					return cachedSource;
 				}
 			);
-			javascriptHooks.chunkHash.tap(
-				"ModuleInfoHeaderPlugin",
-				(_chunk, hash) => {
-					hash.update("ModuleInfoHeaderPlugin");
-					hash.update("1");
-				}
-			);
+			javascriptHooks.chunkHash.tap(PLUGIN_NAME, (_chunk, hash) => {
+				hash.update(PLUGIN_NAME);
+				hash.update("1");
+			});
 			const cssHooks = CssModulesPlugin.getCompilationHooks(compilation);
 			cssHooks.renderModulePackage.tap(
-				"ModuleInfoHeaderPlugin",
+				PLUGIN_NAME,
 				(moduleSource, module, { runtimeTemplate }) => {
 					const { requestShortener } = runtimeTemplate;
 					let cacheEntry;
@@ -291,8 +289,8 @@ class ModuleInfoHeaderPlugin {
 					return cachedSource;
 				}
 			);
-			cssHooks.chunkHash.tap("ModuleInfoHeaderPlugin", (_chunk, hash) => {
-				hash.update("ModuleInfoHeaderPlugin");
+			cssHooks.chunkHash.tap(PLUGIN_NAME, (_chunk, hash) => {
+				hash.update(PLUGIN_NAME);
 				hash.update("1");
 			});
 		});
@@ -311,4 +309,5 @@ class ModuleInfoHeaderPlugin {
 		return new RawSource(headerStr);
 	}
 }
+
 module.exports = ModuleInfoHeaderPlugin;

package/lib/ModuleNotFoundError.js

@@ -44,7 +44,7 @@ const previouslyPolyfilledBuiltinModules = {
 class ModuleNotFoundError extends WebpackError {
 	/**
 	 * @param {Module | null} module module tied to dependency
-	 * @param {Error&any} err error thrown
+	 * @param {Error & { details?: string }} err error thrown
 	 * @param {DependencyLocation} loc location of dependency
 	 */
 	constructor(module, err, loc) {