webpack 5.97.1 → 5.99.0

package/lib/hmr/LazyCompilationPlugin.js

@@ -23,14 +23,16 @@ const { registerNotSerializable } = require("../util/serialization");
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Module").BuildCallback} BuildCallback */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
+/** @typedef {import("../ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
 /** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../WebpackError")} WebpackError */
@@ -42,8 +44,8 @@ const { registerNotSerializable } = require("../util/serialization");
 
 /**
  * @typedef {object} BackendApi
- * @property {function(function((Error | null)=) : void): void} dispose
- * @property {function(Module): ModuleResult} module
+ * @property {(callback: (err?: (Error | null)) => void) => void} dispose
+ * @property {(module: Module) => ModuleResult} module
  */
 
 const HMR_DEPENDENCY_TYPES = new Set([
@@ -54,7 +56,7 @@ const HMR_DEPENDENCY_TYPES = new Set([
 ]);
 
 /**
- * @param {undefined|string|RegExp|Function} test test option
+ * @param {Options["test"]} test test option
  * @param {Module} module the module
  * @returns {boolean | null | string} true, if the module should be selected
  */
@@ -169,7 +171,7 @@ class LazyCompilationProxyModule extends Module {
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {
@@ -181,7 +183,7 @@ class LazyCompilationProxyModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
 	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {BuildCallback} callback callback function
 	 * @returns {void}
 	 */
 	build(options, compilation, resolver, fs, callback) {
@@ -315,13 +317,13 @@ class LazyCompilationDependencyFactory extends ModuleFactory {
 
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
+	 * @param {ModuleFactoryCallback} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {
-		const dependency = /** @type {LazyCompilationDependency} */ (
-			data.dependencies[0]
-		);
+		const dependency =
+			/** @type {LazyCompilationDependency} */
+			(data.dependencies[0]);
 		callback(null, {
 			module: dependency.proxyModule.originalModule
 		});
@@ -331,7 +333,7 @@ class LazyCompilationDependencyFactory extends ModuleFactory {
 /**
  * @callback BackendHandler
  * @param {Compiler} compiler compiler
- * @param {function(Error | null, BackendApi=): void} callback callback
+ * @param {(err: Error | null, backendApi?: BackendApi) => void} callback callback
  * @returns {void}
  */
 
@@ -341,13 +343,19 @@ class LazyCompilationDependencyFactory extends ModuleFactory {
  * @returns {Promise<BackendApi>} backend
  */
 
+/** @typedef {BackendHandler | PromiseBackendHandler} BackEnd */
+
+/**
+ * @typedef {object} Options options
+ * @property {BackEnd} backend the backend
+ * @property {boolean=} entries
+ * @property {boolean=} imports
+ * @property {(RegExp | string | ((module: Module) => boolean))=} test additional filter for lazy compiled entrypoint modules
+ */
+
 class LazyCompilationPlugin {
 	/**
-	 * @param {object} options options
-	 * @param {BackendHandler | PromiseBackendHandler} options.backend the backend
-	 * @param {boolean} options.entries true, when entries are lazy compiled
-	 * @param {boolean} options.imports true, when import() modules are lazy compiled
-	 * @param {RegExp | string | (function(Module): boolean) | undefined} options.test additional filter for lazy compiled entrypoint modules
+	 * @param {Options} options options
 	 */
 	constructor({ backend, entries, imports, test }) {
 		this.backend = backend;
@@ -386,7 +394,7 @@ class LazyCompilationPlugin {
 			(compilation, { normalModuleFactory }) => {
 				normalModuleFactory.hooks.module.tap(
 					"LazyCompilationPlugin",
-					(originalModule, createData, resolveData) => {
+					(module, createData, resolveData) => {
 						if (
 							resolveData.dependencies.every(dep =>
 								HMR_DEPENDENCY_TYPES.has(dep.type)
@@ -407,7 +415,7 @@ class LazyCompilationPlugin {
 												hmrDep.request
 									)
 							);
-							if (!isReferringToDynamicImport) return;
+							if (!isReferringToDynamicImport) return module;
 						} else if (
 							!resolveData.dependencies.every(
 								dep =>
@@ -418,21 +426,21 @@ class LazyCompilationPlugin {
 									(this.entries && dep.type === "entry")
 							)
 						)
-							return;
+							return module;
 						if (
 							/webpack[/\\]hot[/\\]|webpack-dev-server[/\\]client|webpack-hot-middleware[/\\]client/.test(
 								resolveData.request
 							) ||
-							!checkTest(this.test, originalModule)
+							!checkTest(this.test, module)
 						)
-							return;
-						const moduleInfo = backend.module(originalModule);
-						if (!moduleInfo) return;
+							return module;
+						const moduleInfo = backend.module(module);
+						if (!moduleInfo) return module;
 						const { client, data, active } = moduleInfo;
 
 						return new LazyCompilationProxyModule(
 							compiler.context,
-							originalModule,
+							module,
 							resolveData.request,
 							client,
 							data,

package/lib/hmr/lazyCompilationBackend.js

@@ -43,7 +43,7 @@ module.exports = options => (compiler, callback) => {
 						(options.server)
 					);
 				})();
-	/** @type {function(Server): void} */
+	/** @type {(server: Server) => void} */
 	const listen =
 		typeof options.listen === "function"
 			? options.listen

package/lib/ids/DeterministicModuleIdsPlugin.js

@@ -20,7 +20,7 @@ const {
 /**
  * @typedef {object} DeterministicModuleIdsPluginOptions
  * @property {string=} context context relative to which module identifiers are computed
- * @property {function(Module): boolean=} test selector function for modules
+ * @property {((module: Module) => boolean)=} test selector function for modules
  * @property {number=} maxLength maximum id length in digits (used as starting point)
  * @property {number=} salt hash salt for ids
  * @property {boolean=} fixedLength do not increase the maxLength to find an optimal id space size

package/lib/ids/HashedModuleIdsPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const { DEFAULTS } = require("../config/defaults");
 const {
 	compareModulesByPreOrderIndexOrIdentifier
 } = require("../util/comparators");
@@ -37,7 +38,7 @@ class HashedModuleIdsPlugin {
 		/** @type {HashedModuleIdsPluginOptions} */
 		this.options = {
 			context: undefined,
-			hashFunction: "md4",
+			hashFunction: DEFAULTS.HASH_FUNCTION,
 			hashDigest: "base64",
 			hashDigestLength: 4,
 			...options

package/lib/ids/IdHelpers.js

@@ -14,6 +14,7 @@ const numberHash = require("../util/numberHash");
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Module")} Module */
 /** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("../util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
 
 /**
  * @param {string} str string to hash
@@ -75,7 +76,7 @@ const shortenLongString = (string, delimiter, hashFunction) => {
 /**
  * @param {Module} module the module
  * @param {string} context context directory
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} short module name
  */
 const getShortModuleName = (module, context, associatedObjectForCache) => {
@@ -95,7 +96,7 @@ module.exports.getShortModuleName = getShortModuleName;
  * @param {Module} module the module
  * @param {string} context context directory
  * @param {string | Hash} hashFunction hash function to use
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} long module name
  */
 const getLongModuleName = (
@@ -113,7 +114,7 @@ module.exports.getLongModuleName = getLongModuleName;
 /**
  * @param {Module} module the module
  * @param {string} context context directory
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} full module name
  */
 const getFullModuleName = (module, context, associatedObjectForCache) =>
@@ -126,7 +127,7 @@ module.exports.getFullModuleName = getFullModuleName;
  * @param {string} context context directory
  * @param {string} delimiter delimiter for names
  * @param {string | Hash} hashFunction hash function to use
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} short chunk name
  */
 const getShortChunkName = (
@@ -156,7 +157,7 @@ module.exports.getShortChunkName = getShortChunkName;
  * @param {string} context context directory
  * @param {string} delimiter delimiter for names
  * @param {string | Hash} hashFunction hash function to use
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} short chunk name
  */
 const getLongChunkName = (
@@ -189,7 +190,7 @@ module.exports.getLongChunkName = getLongChunkName;
  * @param {Chunk} chunk the chunk
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {string} context context directory
- * @param {object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} full chunk name
  */
 const getFullChunkName = (
@@ -226,7 +227,7 @@ const addToMapOfItems = (map, key, value) => {
 
 /**
  * @param {Compilation} compilation the compilation
- * @param {function(Module): boolean=} filter filter modules
+ * @param {((module: Module) => boolean)=} filter filter modules
  * @returns {[Set<string>, Module[]]} used module ids as strings and modules without id matching the filter
  */
 const getUsedModuleIdsAndModules = (compilation, filter) => {
@@ -286,11 +287,11 @@ module.exports.getUsedChunkIds = getUsedChunkIds;
 /**
  * @template T
  * @param {Iterable<T>} items list of items to be named
- * @param {function(T): string} getShortName get a short name for an item
- * @param {function(T, string): string} getLongName get a long name for an item
- * @param {function(T, T): -1|0|1} comparator order of items
+ * @param {(item: T) => string} getShortName get a short name for an item
+ * @param {(item: T, name: string) => string} getLongName get a long name for an item
+ * @param {(a: T, b: T) => -1 | 0 | 1} comparator order of items
  * @param {Set<string>} usedIds already used ids, will not be assigned
- * @param {function(T, string): void} assignName assign a name to an item
+ * @param {(item: T, name: string) => void} assignName assign a name to an item
  * @returns {T[]} list of items without a name
  */
 const assignNames = (
@@ -354,9 +355,9 @@ module.exports.assignNames = assignNames;
 /**
  * @template T
  * @param {T[]} items list of items to be named
- * @param {function(T): string} getName get a name for an item
- * @param {function(T, T): -1|0|1} comparator order of items
- * @param {function(T, number): boolean} assignId assign an id to an item
+ * @param {(item: T) => string} getName get a name for an item
+ * @param {(a: T, n: T) => -1 | 0 | 1} comparator order of items
+ * @param {(item: T, id: number) => boolean} assignId assign an id to an item
  * @param {number[]} ranges usable ranges for ids
  * @param {number} expandFactor factor to create more ranges
  * @param {number} extraSpace extra space to allocate, i. e. when some ids are already used

package/lib/ids/SyncModuleIdsPlugin.js

@@ -14,13 +14,17 @@ const { getUsedModuleIdsAndModules } = require("./IdHelpers");
 
 const plugin = "SyncModuleIdsPlugin";
 
+/**
+ * @typedef {object} SyncModuleIdsPluginOptions
+ * @property {string} path path to file
+ * @property {string=} context context for module names
+ * @property {((module: Module) => boolean)=} test selector for modules
+ * @property {"read" | "create" | "merge" | "update"=} mode operation mode (defaults to merge)
+ */
+
 class SyncModuleIdsPlugin {
 	/**
-	 * @param {object} options options
-	 * @param {string} options.path path to file
-	 * @param {string=} options.context context for module names
-	 * @param {function(Module): boolean} options.test selector for modules
-	 * @param {"read" | "create" | "merge" | "update"=} options.mode operation mode (defaults to merge)
+	 * @param {SyncModuleIdsPluginOptions} options options
 	 */
 	constructor({ path, context, test, mode }) {
 		this._path = path;

package/lib/index.js

@@ -64,15 +64,15 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
 
 /**
- * @template {Function} T
- * @param {function(): T} factory factory function
+ * @template {EXPECTED_FUNCTION} T
+ * @param {() => T} factory factory function
  * @returns {T} function
  */
 const lazyFunction = factory => {
 	const fac = memoize(factory);
 	const f = /** @type {any} */ (
 		/**
-		 * @param {...any} args args
+		 * @param {...EXPECTED_ANY} args args
 		 * @returns {T} result
 		 */
 		(...args) => fac()(...args)
@@ -120,13 +120,13 @@ module.exports = mergeExports(fn, {
 		return require("./webpack");
 	},
 	/**
-	 * @returns {function(Configuration | Configuration[]): void} validate fn
+	 * @returns {(configuration: Configuration | Configuration[]) => void} validate fn
 	 */
 	get validate() {
 		const webpackOptionsSchemaCheck = require("../schemas/WebpackOptions.check.js");
 		const getRealValidate = memoize(
 			/**
-			 * @returns {function(Configuration | Configuration[]): void} validate fn
+			 * @returns {(configuration: Configuration | Configuration[]) => void} validate fn
 			 */
 			() => {
 				const validateSchema = require("./validateSchema");

package/lib/javascript/BasicEvaluatedExpression.js

@@ -7,7 +7,7 @@
 
 /** @typedef {import("estree").Node} Node */
 /** @typedef {import("./JavascriptParser").Range} Range */
-/** @typedef {import("./JavascriptParser").VariableInfoInterface} VariableInfoInterface */
+/** @typedef {import("./JavascriptParser").VariableInfo} VariableInfo */
 
 const TypeUnknown = 0;
 const TypeUndefined = 1;
@@ -51,7 +51,7 @@ class BasicEvaluatedExpression {
 		this.quasis = undefined;
 		/** @type {BasicEvaluatedExpression[] | undefined} */
 		this.parts = undefined;
-		/** @type {any[] | undefined} */
+		/** @type {EXPECTED_ANY[] | undefined} */
 		this.array = undefined;
 		/** @type {BasicEvaluatedExpression[] | undefined} */
 		this.items = undefined;
@@ -63,9 +63,9 @@ class BasicEvaluatedExpression {
 		this.postfix = undefined;
 		/** @type {BasicEvaluatedExpression[] | undefined} */
 		this.wrappedInnerExpressions = undefined;
-		/** @type {string | VariableInfoInterface | undefined} */
+		/** @type {string | VariableInfo | undefined} */
 		this.identifier = undefined;
-		/** @type {string | VariableInfoInterface | undefined} */
+		/** @type {string | VariableInfo | undefined} */
 		this.rootInfo = undefined;
 		/** @type {(() => string[]) | undefined} */
 		this.getMembers = undefined;
@@ -386,8 +386,8 @@ class BasicEvaluatedExpression {
 
 	/**
 	 * Set's the value of this expression to a particular identifier and its members.
-	 * @param {string | VariableInfoInterface} identifier identifier to set
-	 * @param {string | VariableInfoInterface} rootInfo root info
+	 * @param {string | VariableInfo} identifier identifier to set
+	 * @param {string | VariableInfo} rootInfo root info
 	 * @param {() => string[]} getMembers members
 	 * @param {() => boolean[]=} getMembersOptionals optional members
 	 * @param {() => Range[]=} getMemberRanges ranges of progressively increasing sub-expressions

package/lib/javascript/JavascriptGenerator.js

@@ -36,7 +36,7 @@ const deprecatedGetInitFragments = util.deprecate(
 	 * @returns {InitFragment<GenerateContext>[]} init fragments
 	 */
 	(template, dependency, templateContext) =>
-		/** @type {DependencyTemplate & { getInitFragments: function(Dependency, DependencyTemplateContext): InitFragment<GenerateContext>[] }} */
+		/** @type {DependencyTemplate & { getInitFragments: (dependency: Dependency, dependencyTemplateContext: DependencyTemplateContext) => InitFragment<GenerateContext>[] }} */
 		(template).getInitFragments(dependency, templateContext),
 	"DependencyTemplate.getInitFragment is deprecated (use apply(dep, source, { initFragments }) instead)",
 	"DEP_WEBPACK_JAVASCRIPT_GENERATOR_GET_INIT_FRAGMENTS"
@@ -110,6 +110,16 @@ class JavascriptGenerator extends Generator {
 		return InitFragment.addToSource(source, initFragments, generateContext);
 	}
 
+	/**
+	 * @param {Error} error the error
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source | null} generated code
+	 */
+	generateError(error, module, generateContext) {
+		return new RawSource(`throw new Error(${JSON.stringify(error.message)});`);
+	}
+
 	/**
 	 * @param {Module} module the module to generate
 	 * @param {InitFragment<GenerateContext>[]} initFragments mutable list of init fragments

package/lib/javascript/JavascriptModulesPlugin.js

@@ -26,11 +26,12 @@ const {
 	JAVASCRIPT_MODULE_TYPE_ESM,
 	WEBPACK_MODULE_TYPE_RUNTIME
 } = require("../ModuleTypeConstants");
+const NormalModule = require("../NormalModule");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const { last, someInIterable } = require("../util/IterableHelpers");
 const StringXor = require("../util/StringXor");
-const { compareModulesByIdentifier } = require("../util/comparators");
+const { compareModulesByIdOrIdentifier } = require("../util/comparators");
 const {
 	getPathInAst,
 	getAllReferences,
@@ -41,6 +42,7 @@ const {
 } = require("../util/concatenate");
 const createHash = require("../util/createHash");
 const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
+const removeBOM = require("../util/removeBOM");
 const { intersectRuntime } = require("../util/runtime");
 const JavascriptGenerator = require("./JavascriptGenerator");
 const JavascriptParser = require("./JavascriptParser");
@@ -48,13 +50,14 @@ const JavascriptParser = require("./JavascriptParser");
 /** @typedef {import("eslint-scope").Reference} Reference */
 /** @typedef {import("eslint-scope").Scope} Scope */
 /** @typedef {import("eslint-scope").Variable} Variable */
+/** @typedef {import("estree").Program} Program */
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../../declarations/WebpackOptions").Output} OutputOptions */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("../Compilation").ModuleObject} ModuleObject */
+/** @typedef {import("../Compilation").ExecuteModuleObject} ExecuteModuleObject */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../Entrypoint")} Entrypoint */
@@ -248,7 +251,7 @@ class JavascriptModulesPlugin {
 
 	constructor(options = {}) {
 		this.options = options;
-		/** @type {WeakMap<Source, TODO>} */
+		/** @type {WeakMap<Source, { source: Source, needModule:boolean, needExports: boolean, needRequire: boolean, needThisAsExports: boolean, needStrict: boolean | undefined }>} */
 		this._moduleFactoryCache = new WeakMap();
 	}
 
@@ -262,24 +265,45 @@ class JavascriptModulesPlugin {
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
-				normalModuleFactory.hooks.createParser
-					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
-					.tap(PLUGIN_NAME, options => new JavascriptParser("auto"));
-				normalModuleFactory.hooks.createParser
-					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
-					.tap(PLUGIN_NAME, options => new JavascriptParser("script"));
-				normalModuleFactory.hooks.createParser
-					.for(JAVASCRIPT_MODULE_TYPE_ESM)
-					.tap(PLUGIN_NAME, options => new JavascriptParser("module"));
-				normalModuleFactory.hooks.createGenerator
-					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
-					.tap(PLUGIN_NAME, () => new JavascriptGenerator());
-				normalModuleFactory.hooks.createGenerator
-					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
-					.tap(PLUGIN_NAME, () => new JavascriptGenerator());
-				normalModuleFactory.hooks.createGenerator
-					.for(JAVASCRIPT_MODULE_TYPE_ESM)
-					.tap(PLUGIN_NAME, () => new JavascriptGenerator());
+
+				for (const type of [
+					JAVASCRIPT_MODULE_TYPE_AUTO,
+					JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+					JAVASCRIPT_MODULE_TYPE_ESM
+				]) {
+					normalModuleFactory.hooks.createParser
+						.for(type)
+						.tap(PLUGIN_NAME, _options => {
+							switch (type) {
+								case JAVASCRIPT_MODULE_TYPE_AUTO: {
+									return new JavascriptParser("auto");
+								}
+								case JAVASCRIPT_MODULE_TYPE_DYNAMIC: {
+									return new JavascriptParser("script");
+								}
+								case JAVASCRIPT_MODULE_TYPE_ESM: {
+									return new JavascriptParser("module");
+								}
+							}
+						});
+					normalModuleFactory.hooks.createGenerator
+						.for(type)
+						.tap(PLUGIN_NAME, () => new JavascriptGenerator());
+
+					NormalModule.getCompilationHooks(compilation).processResult.tap(
+						PLUGIN_NAME,
+						(result, module) => {
+							if (module.type === type) {
+								const [source, ...rest] = result;
+
+								return [removeBOM(source), ...rest];
+							}
+
+							return result;
+						}
+					);
+				}
+
 				compilation.hooks.renderManifest.tap(PLUGIN_NAME, (result, options) => {
 					const {
 						hash,
@@ -487,7 +511,7 @@ class JavascriptModulesPlugin {
 					);
 
 					const moduleObject =
-						/** @type {ModuleObject} */
+						/** @type {ExecuteModuleObject} */
 						(options.moduleObject);
 
 					try {
@@ -678,7 +702,7 @@ class JavascriptModulesPlugin {
 		const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
 			chunk,
 			"javascript",
-			compareModulesByIdentifier
+			compareModulesByIdOrIdentifier(chunkGraph)
 		);
 		const allModules = modules ? Array.from(modules) : [];
 		let strictHeader;
@@ -757,7 +781,7 @@ class JavascriptModulesPlugin {
 			chunkGraph.getOrderedChunkModulesIterableBySourceType(
 				chunk,
 				"javascript",
-				compareModulesByIdentifier
+				compareModulesByIdOrIdentifier(chunkGraph)
 			) || []
 		);
 
@@ -977,7 +1001,7 @@ class JavascriptModulesPlugin {
 			const lastEntryModule =
 				/** @type {Module} */
 				(last(chunkGraph.getChunkEntryModulesIterable(chunk)));
-			/** @type {function(string[], string): Source} */
+			/** @type {(content: string[], name: string) => Source} */
 			const toSource = useSourceMap
 				? (content, name) =>
 						new OriginalSource(Template.asString(content), name)
@@ -1506,7 +1530,7 @@ class JavascriptModulesPlugin {
 		const renamedInlinedModules = new Map();
 		const { runtimeTemplate } = renderContext;
 
-		/** @typedef {{ source: Source, module: Module, ast: any, variables: Set<Variable>, through: Set<Reference>, usedInNonInlined: Set<Variable>, moduleScope: Scope }} Info */
+		/** @typedef {{ source: Source, module: Module, ast: Program, variables: Set<Variable>, through: Set<Reference>, usedInNonInlined: Set<Variable>, moduleScope: Scope }} Info */
 		/** @type {Map<Module, Info>} */
 		const inlinedModulesToInfo = new Map();
 		/** @type {Set<string>} */
@@ -1583,12 +1607,6 @@ class JavascriptModulesPlugin {
 			}
 
 			for (const variable of info.variables) {
-				allUsedNames.add(variable.name);
-				const references = getAllReferences(variable);
-				const allIdentifiers = new Set(
-					references.map(r => r.identifier).concat(variable.identifiers)
-				);
-
 				const usedNamesInScopeInfo = new Map();
 				const ignoredScopes = new Set();
 
@@ -1601,6 +1619,9 @@ class JavascriptModulesPlugin {
 
 				if (allUsedNames.has(name) || usedNames.has(name)) {
 					const references = getAllReferences(variable);
+					const allIdentifiers = new Set(
+						references.map(r => r.identifier).concat(variable.identifiers)
+					);
 					for (const ref of references) {
 						addScopeSymbols(
 							ref.from,
@@ -1635,9 +1656,8 @@ class JavascriptModulesPlugin {
 						}
 						source.replace(r[0], r[1] - 1, newName);
 					}
-				} else {
-					allUsedNames.add(name);
 				}
+				allUsedNames.add(name);
 			}
 
 			renamedInlinedModules.set(m, source);