webpack 5.102.0 → 5.103.0

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -15,6 +15,7 @@ const makeSerializable = require("../util/makeSerializable");
 const propertyAccess = require("../util/propertyAccess");
 const traverseDestructuringAssignmentProperties = require("../util/traverseDestructuringAssignmentProperties");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
+const { ImportPhaseUtils } = require("./ImportPhase");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
@@ -36,6 +37,7 @@ const HarmonyImportDependency = require("./HarmonyImportDependency");
 /** @typedef {import("../util/chainedImports").IdRanges} IdRanges */
 /** @typedef {import("./HarmonyImportDependency").ExportPresenceMode} ExportPresenceMode */
 /** @typedef {HarmonyImportDependency.Ids} Ids */
+/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 
 const idsSymbol = Symbol("HarmonyImportSpecifierDependency.ids");
 
@@ -49,9 +51,9 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	 * @param {string} name name
 	 * @param {Range} range range
 	 * @param {ExportPresenceMode} exportPresenceMode export presence mode
+	 * @param {ImportPhaseType} phase import phase
 	 * @param {ImportAttributes | undefined} attributes import attributes
 	 * @param {IdRanges | undefined} idRanges ranges for members of ids; the two arrays are right-aligned
-	 * @param {boolean=} defer is defer phase
 	 */
 	constructor(
 		request,
@@ -60,11 +62,11 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		name,
 		range,
 		exportPresenceMode,
+		phase,
 		attributes,
-		idRanges, // TODO webpack 6 make this non-optional. It must always be set to properly trim ids.
-		defer
+		idRanges // TODO webpack 6 make this non-optional. It must always be set to properly trim ids.
 	) {
-		super(request, sourceOrder, attributes, defer);
+		super(request, sourceOrder, phase, attributes);
 		this.ids = ids;
 		this.name = name;
 		this.range = range;
@@ -440,14 +442,14 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 					connection.module,
 					{
 						asiSafe: dep.asiSafe,
-						deferredImport: dep.defer
+						deferredImport: ImportPhaseUtils.isDefer(dep.phase)
 					}
 				);
 			} else if (dep.namespaceObjectAsContext && ids.length === 1) {
 				exportExpr =
 					concatenationScope.createModuleReference(connection.module, {
 						asiSafe: dep.asiSafe,
-						deferredImport: dep.defer
+						deferredImport: ImportPhaseUtils.isDefer(dep.phase)
 					}) + propertyAccess(ids);
 			} else {
 				exportExpr = concatenationScope.createModuleReference(
@@ -457,7 +459,7 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 						call: dep.call,
 						directImport: dep.directImport,
 						asiSafe: dep.asiSafe,
-						deferredImport: dep.defer
+						deferredImport: ImportPhaseUtils.isDefer(dep.phase)
 					}
 				);
 			}
@@ -482,7 +484,7 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 				initFragments,
 				runtime,
 				runtimeRequirements,
-				defer: dep.defer
+				dependency: dep
 			});
 		}
 		return exportExpr;

package/lib/dependencies/ImportContextDependency.js

@@ -35,6 +35,19 @@ class ImportContextDependency extends ContextDependency {
 		return "esm";
 	}
 
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		let str = super.getResourceIdentifier();
+
+		if (this.options.attributes) {
+			str += `|importAttributes${JSON.stringify(this.options.attributes)}`;
+		}
+
+		return str;
+	}
+
 	/**
 	 * @param {ObjectSerializerContext} context context
 	 */

package/lib/dependencies/ImportDependency.js

@@ -22,18 +22,21 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 
 class ImportDependency extends ModuleDependency {
 	/**
 	 * @param {string} request the request
 	 * @param {Range} range expression range
-	 * @param {RawReferencedExports | null=} referencedExports list of referenced exports
+	 * @param {RawReferencedExports | null} referencedExports list of referenced exports
+	 * @param {ImportPhaseType} phase import phase
 	 * @param {ImportAttributes=} attributes import attributes
 	 */
-	constructor(request, range, referencedExports, attributes) {
+	constructor(request, range, referencedExports, phase, attributes) {
 		super(request);
 		this.range = range;
 		this.referencedExports = referencedExports;
+		this.phase = phase;
 		this.attributes = attributes;
 	}
 
@@ -50,8 +53,8 @@ class ImportDependency extends ModuleDependency {
 	 */
 	getResourceIdentifier() {
 		let str = super.getResourceIdentifier();
-		if (this.attributes !== undefined) {
-			str += JSON.stringify(this.attributes);
+		if (this.attributes) {
+			str += `|importAttributes${JSON.stringify(this.attributes)}`;
 		}
 		return str;
 	}
@@ -99,6 +102,7 @@ class ImportDependency extends ModuleDependency {
 	serialize(context) {
 		context.write(this.range);
 		context.write(this.referencedExports);
+		context.write(this.phase);
 		context.write(this.attributes);
 		super.serialize(context);
 	}
@@ -109,6 +113,7 @@ class ImportDependency extends ModuleDependency {
 	deserialize(context) {
 		this.range = context.read();
 		this.referencedExports = context.read();
+		this.phase = context.read();
 		this.attributes = context.read();
 		super.deserialize(context);
 	}
@@ -140,6 +145,7 @@ ImportDependency.Template = class ImportDependencyTemplate extends (
 			module: /** @type {Module} */ (moduleGraph.getModule(dep)),
 			request: dep.request,
 			strict: /** @type {BuildMeta} */ (module.buildMeta).strictHarmonyModule,
+			dependency: dep,
 			message: "import()",
 			runtimeRequirements
 		});

package/lib/dependencies/ImportEagerDependency.js

@@ -16,16 +16,18 @@ const ImportDependency = require("./ImportDependency");
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {ImportDependency.RawReferencedExports} RawReferencedExports */
+/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 
 class ImportEagerDependency extends ImportDependency {
 	/**
 	 * @param {string} request the request
 	 * @param {Range} range expression range
-	 * @param {RawReferencedExports | null=} referencedExports list of referenced exports
+	 * @param {RawReferencedExports | null} referencedExports list of referenced exports
+	 * @param {ImportPhaseType} phase import phase
 	 * @param {ImportAttributes=} attributes import attributes
 	 */
-	constructor(request, range, referencedExports, attributes) {
-		super(request, range, referencedExports, attributes);
+	constructor(request, range, referencedExports, phase, attributes) {
+		super(request, range, referencedExports, phase, attributes);
 	}
 
 	get type() {
@@ -63,6 +65,7 @@ ImportEagerDependency.Template = class ImportEagerDependencyTemplate extends (
 			request: dep.request,
 			strict: /** @type {BuildMeta} */ (module.buildMeta).strictHarmonyModule,
 			message: "import() eager",
+			dependency: dep,
 			runtimeRequirements
 		});
 

package/lib/dependencies/ImportMetaPlugin.js

@@ -6,11 +6,14 @@
 "use strict";
 
 const { pathToFileURL } = require("url");
+const { SyncBailHook } = require("tapable");
+const Compilation = require("../Compilation");
 const ModuleDependencyWarning = require("../ModuleDependencyWarning");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
+const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
 const {
@@ -31,6 +34,8 @@ const ConstDependency = require("./ConstDependency");
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../javascript/JavascriptParser").Members} Members */
+/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperty} DestructuringAssignmentProperty */
+/** @typedef {import("./ConstDependency").RawRuntimeRequirements} RawRuntimeRequirements */
 
 const getCriticalDependencyWarning = memoize(() =>
 	require("./CriticalDependencyWarning")
@@ -38,7 +43,35 @@ const getCriticalDependencyWarning = memoize(() =>
 
 const PLUGIN_NAME = "ImportMetaPlugin";
 
+/**
+ * @typedef {object} ImportMetaPluginHooks
+ * @property {SyncBailHook<[DestructuringAssignmentProperty], string | void>} propertyInDestructuring
+ */
+
+/** @type {WeakMap<Compilation, ImportMetaPluginHooks>} */
+const compilationHooksMap = new WeakMap();
+
 class ImportMetaPlugin {
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {ImportMetaPluginHooks} the attached hooks
+	 */
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				propertyInDestructuring: new SyncBailHook(["property"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
+
 	/**
 	 * @param {Compiler} compiler compiler
 	 */
@@ -46,6 +79,8 @@ class ImportMetaPlugin {
 		compiler.hooks.compilation.tap(
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
+				const hooks = ImportMetaPlugin.getCompilationHooks(compilation);
+
 				/**
 				 * @param {NormalModule} module module
 				 * @returns {string} file url
@@ -115,7 +150,7 @@ class ImportMetaPlugin {
 									new ModuleDependencyWarning(
 										parser.state.module,
 										new CriticalDependencyWarning(
-											"Accessing import.meta directly is unsupported (only property access or destructuring is supported)"
+											"'import.meta' cannot be used as a standalone expression. For static analysis, its properties must be accessed directly (e.g., 'import.meta.url') or through destructuring."
 										),
 										/** @type {DependencyLocation} */ (metaProperty.loc)
 									)
@@ -135,25 +170,44 @@ class ImportMetaPlugin {
 								return true;
 							}
 
+							/** @type {RawRuntimeRequirements} */
+							const runtimeRequirements = [];
+
 							let str = "";
-							for (const { id: prop } of referencedPropertiesInDestructuring) {
-								switch (prop) {
+							for (const prop of referencedPropertiesInDestructuring) {
+								const value = hooks.propertyInDestructuring.call(prop);
+
+								if (value) {
+									str += value;
+									continue;
+								}
+
+								switch (prop.id) {
 									case "url":
 										str += `url: ${importMetaUrl()},`;
 										break;
 									case "webpack":
 										str += `webpack: ${importMetaWebpackVersion()},`;
 										break;
+									case "main":
+										str += `main: ${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${RuntimeGlobals.module},`;
+										runtimeRequirements.push(
+											RuntimeGlobals.moduleCache,
+											RuntimeGlobals.entryModuleId,
+											RuntimeGlobals.module
+										);
+										break;
 									default:
 										str += `[${JSON.stringify(
-											prop
-										)}]: ${importMetaUnknownProperty([prop])},`;
+											prop.id
+										)}]: ${importMetaUnknownProperty([prop.id])},`;
 										break;
 								}
 							}
 							const dep = new ConstDependency(
 								`({${str}})`,
-								/** @type {Range} */ (metaProperty.range)
+								/** @type {Range} */ (metaProperty.range),
+								runtimeRequirements
 							);
 							dep.loc = /** @type {DependencyLocation} */ (metaProperty.loc);
 							parser.state.module.addPresentationalDependency(dep);
@@ -197,17 +251,17 @@ class ImportMetaPlugin {
 						);
 
 					// import.meta.webpack
-					parser.hooks.typeof
+					parser.hooks.expression
 						.for("import.meta.webpack")
 						.tap(
 							PLUGIN_NAME,
-							toConstantDependency(parser, JSON.stringify("number"))
+							toConstantDependency(parser, importMetaWebpackVersion())
 						);
-					parser.hooks.expression
+					parser.hooks.typeof
 						.for("import.meta.webpack")
 						.tap(
 							PLUGIN_NAME,
-							toConstantDependency(parser, importMetaWebpackVersion())
+							toConstantDependency(parser, JSON.stringify("number"))
 						);
 					parser.hooks.evaluateTypeof
 						.for("import.meta.webpack")
@@ -216,10 +270,44 @@ class ImportMetaPlugin {
 						.for("import.meta.webpack")
 						.tap(PLUGIN_NAME, evaluateToNumber(webpackVersion));
 
+					parser.hooks.expression
+						.for("import.meta.main")
+						.tap(
+							PLUGIN_NAME,
+							toConstantDependency(
+								parser,
+								`${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${RuntimeGlobals.module}`,
+								[
+									RuntimeGlobals.moduleCache,
+									RuntimeGlobals.entryModuleId,
+									RuntimeGlobals.module
+								]
+							)
+						);
+					parser.hooks.typeof
+						.for("import.meta.main")
+						.tap(
+							PLUGIN_NAME,
+							toConstantDependency(parser, JSON.stringify("boolean"))
+						);
+					parser.hooks.evaluateTypeof
+						.for("import.meta.main")
+						.tap(PLUGIN_NAME, evaluateToString("boolean"));
+
 					// Unknown properties
 					parser.hooks.unhandledExpressionMemberChain
 						.for("import.meta")
 						.tap(PLUGIN_NAME, (expr, members) => {
+							// keep import.meta.env unknown property
+							// don't evaluate import.meta.env.UNKNOWN_PROPERTY -> undefined.UNKNOWN_PROPERTY
+							// `dirname` and `filename` logic in NodeStuffPlugin
+							if (
+								members[0] === "env" ||
+								members[0] === "dirname" ||
+								members[0] === "filename"
+							) {
+								return true;
+							}
 							const dep = new ConstDependency(
 								importMetaUnknownProperty(members),
 								/** @type {Range} */ (expr.range)

package/lib/dependencies/ImportParserPlugin.js

@@ -17,6 +17,7 @@ const ContextDependencyHelpers = require("./ContextDependencyHelpers");
 const ImportContextDependency = require("./ImportContextDependency");
 const ImportDependency = require("./ImportDependency");
 const ImportEagerDependency = require("./ImportEagerDependency");
+const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
 const ImportWeakDependency = require("./ImportWeakDependency");
 
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
@@ -311,27 +312,11 @@ class ImportParserPlugin {
 				}
 			}
 
-			let phase = expr.phase;
-			if (!phase && importOptions && importOptions.webpackDefer !== undefined) {
-				if (typeof importOptions.webpackDefer !== "boolean") {
-					parser.state.module.addWarning(
-						new UnsupportedFeatureWarning(
-							`\`webpackDefer\` expected a boolean, but received: ${importOptions.webpackDefer}.`,
-							/** @type {DependencyLocation} */ (expr.loc)
-						)
-					);
-				} else if (importOptions.webpackDefer) {
-					phase = "defer";
-				}
-			}
-			if (phase === "defer") {
-				parser.state.module.addWarning(
-					new UnsupportedFeatureWarning(
-						"import.defer() is not implemented yet.",
-						/** @type {DependencyLocation} */ (expr.loc)
-					)
-				);
-			}
+			const phase = createGetImportPhase(this.options.deferImport)(
+				parser,
+				expr,
+				() => importOptions
+			);
 
 			if (importOptions) {
 				if (importOptions.webpackIgnore !== undefined) {
@@ -533,6 +518,7 @@ class ImportParserPlugin {
 						/** @type {string} */ (param.string),
 						/** @type {Range} */ (expr.range),
 						exports,
+						phase,
 						attributes
 					);
 					parser.state.current.addDependency(dep);
@@ -541,6 +527,7 @@ class ImportParserPlugin {
 						/** @type {string} */ (param.string),
 						/** @type {Range} */ (expr.range),
 						exports,
+						phase,
 						attributes
 					);
 					parser.state.current.addDependency(dep);
@@ -557,6 +544,7 @@ class ImportParserPlugin {
 						/** @type {string} */ (param.string),
 						/** @type {Range} */ (expr.range),
 						exports,
+						phase,
 						attributes
 					);
 					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
@@ -568,6 +556,16 @@ class ImportParserPlugin {
 				if (mode === "weak") {
 					mode = "async-weak";
 				}
+
+				if (ImportPhaseUtils.isDefer(phase)) {
+					parser.state.module.addWarning(
+						new UnsupportedFeatureWarning(
+							"import.defer() is not yet supported for ContextModule (the import path is a dynamic expression).",
+							/** @type {DependencyLocation} */ (expr.loc)
+						)
+					);
+				}
+
 				const dep = ContextDependencyHelpers.create(
 					ImportContextDependency,
 					/** @type {Range} */ (expr.range),

package/lib/dependencies/ImportPhase.js

@@ -0,0 +1,121 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Haijie Xie @hai-x
+*/
+
+"use strict";
+
+const memoize = require("../util/memoize");
+
+const getCommentCompilationWarning = memoize(() =>
+	require("../CommentCompilationWarning")
+);
+
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").ExportAllDeclaration} ExportAllDeclaration */
+/** @typedef {import("../javascript/JavascriptParser").ExportNamedDeclaration} ExportNamedDeclaration */
+/** @typedef {import("../javascript/JavascriptParser").ImportDeclaration} ImportDeclaration */
+/** @typedef {import("../javascript/JavascriptParser").ImportExpression} ImportExpression */
+
+/** @typedef {typeof ImportPhase.Evaluation | typeof ImportPhase.Defer | typeof ImportPhase.Source}  ImportPhaseType */
+
+const ImportPhase = Object.freeze({
+	Evaluation: 0b00,
+	Defer: 0b01,
+	Source: 0b10
+});
+
+/**
+ * @typedef {object} ImportPhaseUtils
+ * @property {(phase: ImportPhaseType) => boolean} isDefer true if phase is defer
+ * @property {(phase: ImportPhaseType) => boolean} isSource true if phase is source
+ */
+
+/** @type {ImportPhaseUtils} */
+const ImportPhaseUtils = {
+	isDefer(phase) {
+		return phase === ImportPhase.Defer;
+	},
+	isSource(phase) {
+		return phase === ImportPhase.Source;
+	}
+};
+
+/**
+ * @typedef {() => Record<string, EXPECTED_ANY> | null} GetCommentOptions
+ */
+
+/**
+ * @callback GetImportPhase
+ * @param {JavascriptParser} parser parser
+ * @param {ExportNamedDeclaration | ExportAllDeclaration | ImportDeclaration | ImportExpression} node node
+ * @param {GetCommentOptions=} getCommentOptions optional function that returns the comment options object.
+ * @returns {ImportPhaseType} import phase
+ */
+
+/**
+ * @param {boolean=} enableImportPhase enable import phase detection
+ * @returns {GetImportPhase} evaluates the import phase for ast node
+ */
+function createGetImportPhase(enableImportPhase) {
+	return (parser, node, getCommentOptions) => {
+		if (!enableImportPhase) return ImportPhase.Evaluation;
+
+		// We now only support `defer import`
+		const phaseBySyntax =
+			"phase" in node && node.phase === "defer"
+				? ImportPhase.Defer
+				: ImportPhase.Evaluation;
+
+		if (!node.range) {
+			return phaseBySyntax;
+		}
+
+		getCommentOptions =
+			getCommentOptions ||
+			(() => {
+				if (!node.range) return null;
+				const { options, errors } = parser.parseCommentOptions(node.range);
+				if (errors) {
+					for (const e of errors) {
+						const { comment } = e;
+						if (!comment.loc) continue;
+
+						const CommentCompilationWarning = getCommentCompilationWarning();
+						parser.state.module.addWarning(
+							new CommentCompilationWarning(
+								`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+								comment.loc
+							)
+						);
+					}
+				}
+				return options;
+			});
+
+		const options = getCommentOptions();
+
+		if (!options || !options.webpackDefer) return phaseBySyntax;
+
+		const { webpackDefer } = options;
+		if (typeof webpackDefer === "boolean") {
+			return webpackDefer ? ImportPhase.Defer : phaseBySyntax;
+		} else if (node.loc) {
+			const CommentCompilationWarning = getCommentCompilationWarning();
+			parser.state.module.addWarning(
+				new CommentCompilationWarning(
+					"webpackDefer magic comment expected a boolean value.",
+					node.loc
+				)
+			);
+		}
+
+		return phaseBySyntax;
+	};
+}
+
+module.exports = {
+	ImportPhase,
+	ImportPhaseUtils,
+	createGetImportPhase
+};

package/lib/dependencies/ImportWeakDependency.js

@@ -16,16 +16,18 @@ const ImportDependency = require("./ImportDependency");
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {ImportDependency.RawReferencedExports} RawReferencedExports */
+/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 
 class ImportWeakDependency extends ImportDependency {
 	/**
 	 * @param {string} request the request
 	 * @param {Range} range expression range
-	 * @param {RawReferencedExports | null=} referencedExports list of referenced exports
+	 * @param {RawReferencedExports | null} referencedExports list of referenced exports
+	 * @param {ImportPhaseType} phase import phase
 	 * @param {ImportAttributes=} attributes import attributes
 	 */
-	constructor(request, range, referencedExports, attributes) {
-		super(request, range, referencedExports, attributes);
+	constructor(request, range, referencedExports, phase, attributes) {
+		super(request, range, referencedExports, phase, attributes);
 		this.weak = true;
 	}
 
@@ -61,6 +63,7 @@ ImportWeakDependency.Template = class ImportDependencyTemplate extends (
 			strict: /** @type {BuildMeta} */ (module.buildMeta).strictHarmonyModule,
 			message: "import() weak",
 			weak: true,
+			dependency: dep,
 			runtimeRequirements
 		});
 

package/lib/dependencies/ModuleDependency.js

@@ -18,11 +18,13 @@ const DependencyTemplate = require("../DependencyTemplate");
 class ModuleDependency extends Dependency {
 	/**
 	 * @param {string} request request path which needs resolving
+	 * @param {number=} sourceOrder source order
 	 */
-	constructor(request) {
+	constructor(request, sourceOrder) {
 		super();
 		this.request = request;
 		this.userRequest = request;
+		this.sourceOrder = sourceOrder;
 		/** @type {Range | undefined} */
 		this.range = undefined;
 		this._context = undefined;
@@ -74,6 +76,7 @@ class ModuleDependency extends Dependency {
 		write(this.userRequest);
 		write(this._context);
 		write(this.range);
+		write(this.sourceOrder);
 		super.serialize(context);
 	}
 
@@ -86,6 +89,7 @@ class ModuleDependency extends Dependency {
 		this.userRequest = read();
 		this._context = read();
 		this.range = read();
+		this.sourceOrder = read();
 		super.deserialize(context);
 	}
 }

package/lib/dependencies/ModuleHotAcceptDependency.js

@@ -17,7 +17,7 @@ class ModuleHotAcceptDependency extends ModuleDependency {
 	 * @param {Range} range location in source code
 	 */
 	constructor(request, range) {
-		super(request);
+		super(request, Infinity);
 		this.range = range;
 		this.weak = true;
 	}

package/lib/dependencies/WorkerPlugin.js

@@ -378,9 +378,7 @@ class WorkerPlugin {
 							)}|${i}`;
 							const hash = createHash(compilation.outputOptions.hashFunction);
 							hash.update(name);
-							const digest =
-								/** @type {string} */
-								(hash.digest(compilation.outputOptions.hashDigest));
+							const digest = hash.digest(compilation.outputOptions.hashDigest);
 							entryOptions.runtime = digest.slice(
 								0,
 								compilation.outputOptions.hashDigestLength

package/lib/esm/ExportWebpackRequireRuntimeModule.js

@@ -6,10 +6,6 @@
 
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
-const Template = require("../Template");
-
-// CompatibilityPlugin renames `__webpack_require__` but doesn’t account for `export { __webpack_require__ }`, so we create a temporary variable to handle it.
-const EXPORT_TEMP_NAME = "__webpack_require_temp__";
 
 class ExportWebpackRequireRuntimeModule extends RuntimeModule {
 	constructor() {
@@ -27,10 +23,7 @@ class ExportWebpackRequireRuntimeModule extends RuntimeModule {
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		return Template.asString([
-			`var ${EXPORT_TEMP_NAME} = ${RuntimeGlobals.require};`,
-			`export { ${EXPORT_TEMP_NAME} as ${RuntimeGlobals.require} };`
-		]);
+		return `export { ${RuntimeGlobals.require} };`;
 	}
 }