webpack 5.109.0 → 5.109.1

package/lib/dependencies/CommonJsExportRequireDependency.js

@@ -240,6 +240,25 @@ class CommonJsExportRequireDependency extends ModuleDependency {
 				dependencies: [from.module]
 			};
 		}
+		// The imported namespace ESM hasn't been flagged by
+		// FlagDependencyExportsPlugin yet (no exports determined), so its
+		// `"module.exports"` unwrap eligibility is still unknown. Star-reexporting
+		// now would add `__esModule` (and names) the monotonic merge can't retract
+		// once the module turns out to unwrap, making the result order-dependent
+		// across runtimes; defer — the `from.module` dependency re-queues us once
+		// its exports (owned names, or dynamic `other`) become known.
+		if (
+			importedModule &&
+			importedModule.getExportsType(moduleGraph, false) === "namespace"
+		) {
+			const importedExportsInfo = moduleGraph.getExportsInfo(importedModule);
+			if (
+				importedExportsInfo.otherExportsInfo.provided === false &&
+				importedExportsInfo.ownedExports[Symbol.iterator]().next().done
+			) {
+				return { exports: [], dependencies: [from.module] };
+			}
+		}
 		const reexportInfo = this.getStarReexports(
 			moduleGraph,
 			undefined,

package/lib/dependencies/HarmonyEvaluatedImportSpecifierDependency.js

@@ -179,7 +179,8 @@ HarmonyEvaluatedImportSpecifierDependency.Template = class HarmonyEvaluatedImpor
 				dep,
 				source,
 				templateContext,
-				ids.slice(0, -1)
+				ids.slice(0, -1),
+				connection
 			);
 			source.replace(
 				dep.range[0],

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -191,8 +191,11 @@ const isStarReexportBackToParent = (moduleGraph, exportInfo, parentModule) => {
 	let current = moduleGraph
 		.getExportsInfo(firstTarget.module)
 		.getReadOnlyExportInfo(firstTarget.export[0]);
-	/** @type {Set<ExportInfo>} */
-	const visited = new Set([exportInfo, current]);
+	// Allocated lazily: a single-extra-hop chain that terminates (the common
+	// `barrel -> leaf local binding` case) returns before `next` is ever
+	// computed, so the visited set is pure waste there.
+	/** @type {Set<ExportInfo> | undefined} */
+	let visited;
 	for (;;) {
 		const target = current.findTarget(moduleGraph, RETURNS_TRUE);
 		if (!target || typeof target !== "object") return false;
@@ -210,6 +213,7 @@ const isStarReexportBackToParent = (moduleGraph, exportInfo, parentModule) => {
 		const next = moduleGraph
 			.getExportsInfo(target.module)
 			.getReadOnlyExportInfo(target.export[0]);
+		if (visited === undefined) visited = new Set([exportInfo, current]);
 		if (visited.has(next)) return false;
 		visited.add(next);
 		current = next;
@@ -635,7 +639,8 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused;
 
 		/** @type {IgnoredExports} */
-		const ignoredExports = new Set(["default", ...this.activeExports]);
+		const ignoredExports = new Set(this.activeExports);
+		ignoredExports.add("default");
 
 		/** @type {Hidden | undefined} */
 		let hiddenExports;
@@ -1387,7 +1392,12 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 				);
 				break;
 
-			case "normal-reexport":
+			case "normal-reexport": {
+				// loop-invariants hoisted out of the per-item loop below (a barrel
+				// re-exporting N names otherwise repeats these lookups N times)
+				const connection = moduleGraph.getConnection(dep);
+				const selfExportsInfo = moduleGraph.getExportsInfo(module);
+				const importedExportsInfo = moduleGraph.getExportsInfo(importedModule);
 				for (const {
 					name,
 					ids,
@@ -1396,7 +1406,6 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 				} of /** @type {NormalReexportItem[]} */ (mode.items)) {
 					if (hidden) continue;
 					if (checked) {
-						const connection = moduleGraph.getConnection(dep);
 						const key = `harmony reexport (checked) ${importVar} ${name}`;
 						const runtimeCondition = dep.weak
 							? false
@@ -1425,11 +1434,9 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 							this.getReexportFragment(
 								module,
 								"reexport safe",
-								moduleGraph.getExportsInfo(module).getUsedName(name, runtime),
+								selfExportsInfo.getUsedName(name, runtime),
 								importVar,
-								moduleGraph
-									.getExportsInfo(importedModule)
-									.getUsedName(ids, runtime),
+								importedExportsInfo.getUsedName(ids, runtime),
 								runtimeRequirements,
 								ids
 							)
@@ -1437,6 +1444,7 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 					}
 				}
 				break;
+			}
 
 			case "dynamic-reexport": {
 				const ignored = mode.hidden

package/lib/dependencies/HarmonyImportDependency.js

@@ -191,7 +191,7 @@ class HarmonyImportDependency extends ModuleDependency {
 
 		let importVar = importVarMap.get(importedModule);
 		if (importVar) return importVar;
-		importVar = `${Template.toIdentifier(`${this.userRequest}`)}__WEBPACK_${
+		importVar = `${Template.toIdentifier(this.userRequest)}__WEBPACK_${
 			isDeferred ? "DEFERRED_" : ""
 		}IMPORTED_MODULE_${importVarMap.size}__`;
 		importVarMap.set(importedModule, importVar);

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -32,6 +32,7 @@ const { ImportPhaseUtils } = require("./ImportPhase");
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("../errors/WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperties} DestructuringAssignmentProperties */
@@ -475,7 +476,8 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 			dep,
 			source,
 			templateContext,
-			trimmedIds
+			trimmedIds,
+			connection
 		);
 		if (dep.shorthand) {
 			source.insert(trimmedRangeEnd, `: ${exportExpr}`);
@@ -521,13 +523,14 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 					});
 				}
 			);
+			// loop-invariant: resolve the imported module's exports info once
+			const destructuredExportsInfo = moduleGraph.getExportsInfo(
+				/** @type {Module} */ (moduleGraph.getModule(dep))
+			);
 			for (const { ids, shorthand, range } of replacementsInDestructuring) {
 				/** @type {Ids} */
 				const concatedIds = [...prefixedIds, ...ids];
-				const module = /** @type {Module} */ (moduleGraph.getModule(dep));
-				const used = moduleGraph
-					.getExportsInfo(module)
-					.getUsedName(concatedIds, runtime);
+				const used = destructuredExportsInfo.getUsedName(concatedIds, runtime);
 				if (!used) {
 					return;
 				} else if (used instanceof InlinedUsedName) {
@@ -559,12 +562,12 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 	 * @param {ReplaceSource} source source
 	 * @param {DependencyTemplateContext} templateContext context
 	 * @param {Ids} ids ids
+	 * @param {ModuleGraphConnection | undefined} connection the resolved connection for dep
 	 * @returns {string} generated code
 	 */
-	_getCodeForIds(dep, source, templateContext, ids) {
+	_getCodeForIds(dep, source, templateContext, ids, connection) {
 		const { moduleGraph, module, runtime, concatenationScope } =
 			templateContext;
-		const connection = moduleGraph.getConnection(dep);
 		/** @type {string} */
 		let exportExpr;
 

package/lib/hmr/lazyCompilationBackend.js

@@ -94,7 +94,9 @@ module.exports = (options) => (compiler, callback) => {
 			if (timer.unref) timer.unref();
 			idleTimers.add(timer);
 		});
-		req.socket.setNoDelay(true);
+		// Not all runtimes expose `setNoDelay` on the request socket (e.g. Deno's
+		// HTTP server); it's only a latency optimization, so skip it when absent.
+		if (req.socket.setNoDelay) req.socket.setNoDelay(true);
 		res.writeHead(200, {
 			"content-type": "text/event-stream",
 			"Access-Control-Allow-Origin": "*",
@@ -168,12 +170,25 @@ module.exports = (options) => (compiler, callback) => {
 					idleTimers.clear();
 					// Removing the listener is a workaround for a memory leak in node.js
 					server.off("request", requestListener);
-					server.close((err) => {
-						callback(err);
-					});
 					for (const socket of sockets) {
 						socket.destroy(new Error("Server is disposing"));
 					}
+					// Some runtimes (e.g. Deno) don't emit "connection", so `sockets`
+					// misses the open SSE connections and `server.close` would hang;
+					// force-close everything before waiting for it.
+					if (server.closeAllConnections) server.closeAllConnections();
+					server.close((err) => {
+						// `closeAllConnections()` already stops the server on some runtimes
+						// (e.g. Bun), so `close` then reports ERR_SERVER_NOT_RUNNING; the
+						// server is closed either way, so that's not a dispose failure.
+						callback(
+							err &&
+								/** @type {NodeJS.ErrnoException} */ (err).code !==
+									"ERR_SERVER_NOT_RUNNING"
+								? err
+								: null
+						);
+					});
 				},
 				module(originalModule) {
 					const key = `${encodeURIComponent(

package/lib/html/HtmlGenerator.js

@@ -161,6 +161,7 @@ const metaIsCsp = (attrs) => {
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").SourceType} SourceType */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
@@ -201,6 +202,27 @@ const getChunksById = (compilation) => {
 	return chunksById;
 };
 
+/** @type {WeakMap<Compilation, Map<string, Module>>} */
+const modulesByIdentifierCache = new WeakMap();
+
+/**
+ * `module.identifier()` → module lookup, memoized per compilation so the asset
+ * URL sentinel resolver doesn't re-scan the whole module graph per HTML module.
+ * @param {Compilation} compilation compilation
+ * @returns {Map<string, Module>} modules keyed by identifier
+ */
+const getModulesByIdentifier = (compilation) => {
+	let modulesByIdentifier = modulesByIdentifierCache.get(compilation);
+	if (modulesByIdentifier === undefined) {
+		modulesByIdentifier = new Map();
+		for (const module of compilation.modules) {
+			modulesByIdentifier.set(module.identifier(), module);
+		}
+		modulesByIdentifierCache.set(compilation, modulesByIdentifier);
+	}
+	return modulesByIdentifier;
+};
+
 // Hoisted so `resolveChunkUrlSentinels` (per chunk × module) doesn't allocate a
 // fresh `RegExp` each call. `String#replace` resets `lastIndex`, so sharing the
 // global-flag instance is safe under these synchronous, non-reentrant calls.
@@ -413,9 +435,7 @@ class HtmlGenerator extends Generator {
 	 */
 	static resolveAssetUrlSentinels(content, compilation) {
 		if (!content.includes("__WEBPACK_HTML_ASSET_URL__")) return content;
-		/** @type {Map<string, import("../Module")>} */
-		const byIdentifier = new Map();
-		for (const m of compilation.modules) byIdentifier.set(m.identifier(), m);
+		const byIdentifier = getModulesByIdentifier(compilation);
 		const codeGenerationResults =
 			/** @type {import("../CodeGenerationResults")} */
 			(compilation.codeGenerationResults);