webpack 5.110.2 → 5.111.0

package/lib/library/ModuleLibraryPlugin.js

@@ -14,9 +14,11 @@ const Template = require("../Template");
 const HarmonyExportExpressionDependency = require("../dependencies/HarmonyExportExpressionDependency");
 const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
 const HarmonyExportSpecifierDependency = require("../dependencies/HarmonyExportSpecifierDependency");
+const ExternalStarReexportError = require("../errors/ExternalStarReexportError");
 const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
 const ConcatenatedModule = require("../optimize/ConcatenatedModule");
 const { InlinedUsedName } = require("../optimize/InlineExports");
+const { toJsStringLiteral } = require("../util/identifier");
 const {
 	RESERVED_IDENTIFIER,
 	SAFE_IDENTIFIER,
@@ -44,6 +46,7 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
  * 	ModuleRenderContext
  * } from "../javascript/JavascriptModulesPlugin"
  */
+/** @import { ImportAttributes } from "../javascript/JavascriptParser" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 /**
  * @import {
@@ -122,6 +125,18 @@ const definesOnlyNativeExports = (module, moduleGraph) => {
 const toExportName = (name) =>
 	SAFE_IDENTIFIER.test(name) ? name : JSON.stringify(name);
 
+/**
+ * Renders the import attributes of a reexport in the syntax the author wrote,
+ * since a legacy `assert` clause and a `with` clause are not interchangeable.
+ * @param {ImportAttributes | undefined} attributes the import attributes
+ * @returns {string} the attributes clause, empty when there are none
+ */
+const toAttributesClause = (attributes) => {
+	if (!attributes) return "";
+	const { _isLegacyAssert: isLegacyAssert, ...values } = attributes;
+	return ` ${isLegacyAssert ? "assert" : "with"} ${JSON.stringify(values)}`;
+};
+
 /**
  * Whether the export name can also be used as the declared binding name.
  * @param {string} name export name
@@ -367,6 +382,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				}
 			}
 		}
+		this._checkStarReexportedExternals(module, compilation);
 		moduleGraph.addExtraReason(module, "used as library export");
 		let entries = libraryEntryModules.get(compilation);
 		if (entries === undefined) {
@@ -376,6 +392,61 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		entries.add(module);
 	}
 
+	/**
+	 * Reports every external the entry star-reexports whose request names a property
+	 * path, which `export *` has no way to reference.
+	 * @param {Module} module the library entry module
+	 * @param {Compilation} compilation the compilation
+	 * @returns {void}
+	 */
+	_checkStarReexportedExternals(module, compilation) {
+		const { moduleGraph } = compilation;
+		/** @type {Set<Module>} */
+		const visitedReexportModules = new Set([module]);
+		/** @type {Module[]} */
+		const queue = [module];
+		/** @type {Set<ExternalModule>} */
+		const unsupportedExternals = new Set();
+
+		for (const current of queue) {
+			for (const connection of moduleGraph.getOutgoingConnections(current)) {
+				const dep = connection.dependency;
+
+				// Only handle star-reexport statement
+				if (
+					!(dep instanceof HarmonyExportImportedSpecifierDependency) ||
+					dep.name !== null
+				) {
+					continue;
+				}
+				const importedModule = connection.resolvedModule;
+
+				// Only a module providing unknown exports keeps its reexport rendered
+				if (
+					moduleGraph.getExportsInfo(importedModule)._otherExportsInfo
+						.provided !== null
+				) {
+					continue;
+				}
+				if (importedModule instanceof ExternalModule) {
+					const request = importedModule.getResolvedRequest();
+					if (Array.isArray(request) && request.length > 1) {
+						unsupportedExternals.add(importedModule);
+					}
+				} else if (!visitedReexportModules.has(importedModule)) {
+					visitedReexportModules.add(importedModule);
+					queue.push(importedModule);
+				}
+			}
+		}
+
+		for (const externalModule of unsupportedExternals) {
+			compilation.errors.push(
+				new ExternalStarReexportError(externalModule, module)
+			);
+		}
+	}
+
 	/**
 	 * Returns preprocess as needed by overriding.
 	 * @param {LibraryOptions} library normalized library option
@@ -415,14 +486,17 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 	) {
 		const result = new ConcatSource(source);
 		/** @type {Set<string>} */
-		const moduleRequests = new Set();
+		const externalReexports = new Set();
 		/** @type {Map<string, string | InlinedUsedName>} */
 		const unknownProvidedExports = new Map();
+		/** @type {Set<Module>} */
+		const visitedReexportModules = new Set();
 
 		/**
 		 * Resolves dynamic star reexport.
 		 * @param {Module} module the module
 		 * @param {boolean} isDynamicReexport if module is dynamic reexported
+		 * @returns {void}
 		 */
 		const resolveDynamicStarReexport = (module, isDynamicReexport) => {
 			for (const connection of moduleGraph.getOutgoingConnections(module)) {
@@ -445,8 +519,22 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 					) {
 						// Handle export * from 'external'
 						if (importedModule instanceof ExternalModule) {
-							moduleRequests.add(importedModule.userRequest);
-						} else {
+							const request = importedModule.getResolvedRequest();
+							// A property path is reported by `_checkStarReexportedExternals`,
+							// and an absent one by the external's own build
+							const specifier =
+								typeof request === "string"
+									? request
+									: Array.isArray(request) && request.length === 1
+										? request[0]
+										: undefined;
+							if (specifier !== undefined) {
+								externalReexports.add(
+									`export * from ${toJsStringLiteral(specifier)}${toAttributesClause(dep.attributes)};\n`
+								);
+							}
+						} else if (!visitedReexportModules.has(importedModule)) {
+							visitedReexportModules.add(importedModule);
 							resolveDynamicStarReexport(importedModule, true);
 						}
 					}
@@ -473,8 +561,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 
 		resolveDynamicStarReexport(module, false);
 
-		for (const request of moduleRequests) {
-			result.add(`export * from "${request}";\n`);
+		for (const reexport of externalReexports) {
+			result.add(reexport);
 		}
 
 		for (const [origin, used] of unknownProvidedExports) {
@@ -648,6 +736,29 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				}
 			}
 
+			const externalTarget = exportInfo.getTarget(moduleGraph);
+			if (
+				externalTarget &&
+				externalTarget.module instanceof ExternalModule &&
+				externalTarget.export &&
+				externalTarget.export.length === 1 &&
+				codeGenerationResults.has(externalTarget.module, chunk.runtime)
+			) {
+				const reexport = codeGenerationResults.getData(
+					externalTarget.module,
+					chunk.runtime,
+					"externalReexport"
+				);
+				if (reexport) {
+					if (!bindingsTakenOver) needExportsDeclaration = true;
+					result.add(
+						`export { ${toExportName(externalTarget.export[0])} as ${toExportName(originalName)} } ${reexport};\n`
+					);
+					alreadyRenderedExports.add(originalName);
+					continue;
+				}
+			}
+
 			// The exports of entry module are never inlined
 			const usedName =
 				/** @type {string} */

package/lib/node/ReadFileChunkLoadingRuntimeModule.js

@@ -32,6 +32,28 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 		this.runtimeRequirements = runtimeRequirements;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		const runtimeRequirements = this.runtimeRequirements;
+		/** @type {[string, string][]} */
+		const handlers = [];
+		if (runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)) {
+			handlers.push([RuntimeGlobals.ensureChunkHandlers, "readFileVm"]);
+		}
+		// The hot update flow installs this one onto the same map while it runs.
+		if (runtimeRequirements.has(RuntimeGlobals.hmrDownloadUpdateHandlers)) {
+			handlers.push([RuntimeGlobals.ensureChunkHandlers, "readFileVmHmr"]);
+		}
+		if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
+			handlers.push([RuntimeGlobals.onChunksLoaded, "readFileVm"]);
+		}
+		return handlers;
+	}
+
 	/**
 	 * Returns generated code.
 	 * @private

package/lib/node/RequireChunkLoadingRuntimeModule.js

@@ -32,6 +32,28 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 		this.runtimeRequirements = runtimeRequirements;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		const runtimeRequirements = this.runtimeRequirements;
+		/** @type {[string, string][]} */
+		const handlers = [];
+		if (runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)) {
+			handlers.push([RuntimeGlobals.ensureChunkHandlers, "require"]);
+		}
+		// The hot update flow installs this one onto the same map while it runs.
+		if (runtimeRequirements.has(RuntimeGlobals.hmrDownloadUpdateHandlers)) {
+			handlers.push([RuntimeGlobals.ensureChunkHandlers, "requireHmr"]);
+		}
+		if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
+			handlers.push([RuntimeGlobals.onChunksLoaded, "require"]);
+		}
+		return handlers;
+	}
+
 	/**
 	 * Returns generated code.
 	 * @private

package/lib/optimize/ConcatenatedModule.js

@@ -34,11 +34,13 @@ const analyzeScope = require("../javascript/ScopeAnalyzer");
 const {
 	getDeferredCycleModuleIds,
 	getDeferredCycleModules,
+	getKnownExportNames,
 	getMakeDeferredNamespaceModeFromExportsType,
 	getOptimizedDeferredModule
 } = require("../runtime/MakeDeferredNamespaceObjectRuntime");
 const { equals } = require("../util/ArrayHelpers");
 const LazySet = require("../util/LazySet");
+const { getBuildDiagnostics } = require("../util/buildDiagnostics");
 const {
 	compareModulesByFullName,
 	concatComparators
@@ -116,8 +118,7 @@ const { InlinedUsedName } = require("./InlineExports");
  * @import {
  * 	ChunkRenderContext,
  * 	Scope,
- * 	Reference,
- * 	Variable
+ * 	Reference
  * } from "../javascript/JavascriptModulesPlugin"
  */
 /** @import { Range } from "../javascript/JavascriptParser" */
@@ -181,6 +182,7 @@ const findIdentifiers = (source) => {
  * @property {string=} comment
  * @property {ExportName} ids
  * @property {ExportName} exportName
+ * @property {boolean=} accessorCall the raw name is the wrapper accessor call itself, so it binds looser than the identifier it replaces
  */
 
 /**
@@ -246,6 +248,7 @@ const findIdentifiers = (source) => {
  * @property {boolean} deferred the module is deferred at least once
  * @property {boolean} deferredNamespaceObjectUsed deferred namespace object that being used in a not-analyzable way so it must be materialized
  * @property {string | undefined} deferredNamespaceObjectName deferred namespace object that being used in a not-analyzable way so it must be materialized
+ * @property {boolean} specNamespaceObjectUsed an import reads the spec namespace object the module hands out
  * @property {boolean} interopNamespaceObjectUsed "default-with-named" namespace
  * @property {string | undefined} interopNamespaceObjectName "default-with-named" namespace
  * @property {boolean} interopNamespaceObject2Used "default-only" namespace
@@ -422,13 +425,26 @@ const getInteropExpr = (info, interopName) =>
  * slot, but a wrapped one only runs when its accessor is called, so dropping
  * the reference would drop the module's side effects with it.
  * @param {ConcatenatedModuleInfo} info module info
+ * @param {boolean | undefined} asiSafe asiSafe
  * @returns {string} expression evaluating to undefined
  */
-const getUnusedExportExpr = (info) =>
+const getUnusedExportExpr = (info, asiSafe) =>
 	info.wrapped
-		? `/* unused export */ (${info.namespaceObjectName}, undefined)`
+		? `${asiSafe === false ? ";" : ""}/* unused export */ (${info.namespaceObjectName}, undefined)`
 		: "/* unused export */ undefined";
 
+/**
+ * Parenthesizes a reference that may already carry an ASI guard of its own,
+ * keeping that guard outside the new parentheses — nested it would not parse.
+ * @param {string} reference the reference
+ * @param {boolean | undefined} asiSafe asiSafe
+ * @returns {string} the parenthesized reference
+ */
+const parenthesizeReference = (reference, asiSafe) =>
+	asiSafe === false
+		? `;(${reference.startsWith(";") ? reference.slice(1) : reference})`
+		: `(${reference})`;
+
 /**
  * @param {ModuleGraph} moduleGraph the module graph
  * @param {ModuleInfo} info module info
@@ -483,7 +499,7 @@ const getFinalBinding = (
 		if (!usedName) {
 			return {
 				info,
-				rawName: getUnusedExportExpr(info),
+				rawName: getUnusedExportExpr(info, asiSafe),
 				ids: [],
 				exportName
 			};
@@ -494,11 +510,14 @@ const getFinalBinding = (
 				/** @type {NonNullable<ConcatenatedModuleInfo["namespaceObjectName"]>} */
 				(info.namespaceObjectName),
 			ids: /** @type {ExportName} */ (usedName),
-			exportName
+			exportName,
+			accessorCall: info.wrapped
 		};
 	}
 
-	if (exportName.length === 0) {
+	if (moduleExportsAccess) {
+		// Skip ESM interop when require() targets a module outside the concatenation
+	} else if (exportName.length === 0) {
 		switch (exportsType) {
 			case "default-only":
 				if (deferred) info.deferredNamespaceObjectUsed = true;
@@ -509,7 +528,8 @@ const getFinalBinding = (
 						? /** @type {string} */ (info.deferredNamespaceObjectName)
 						: getInteropExpr(info, info.interopNamespaceObject2Name),
 					ids: exportName,
-					exportName
+					exportName,
+					accessorCall: !deferred && info.wrapped
 				};
 			case "default-with-named":
 				if (deferred) info.deferredNamespaceObjectUsed = true;
@@ -520,7 +540,8 @@ const getFinalBinding = (
 						? /** @type {string} */ (info.deferredNamespaceObjectName)
 						: getInteropExpr(info, info.interopNamespaceObjectName),
 					ids: exportName,
-					exportName
+					exportName,
+					accessorCall: !deferred && info.wrapped
 				};
 			case "namespace":
 			case "dynamic":
@@ -611,7 +632,8 @@ const getFinalBinding = (
 								info,
 								rawName: getExternalModuleExpr(info),
 								ids: exportName,
-								exportName
+								exportName,
+								accessorCall: info.wrapped
 							};
 						}
 						info.interopDefaultAccessUsed = true;
@@ -657,9 +679,10 @@ const getFinalBinding = (
 						/** @type {NonNullable<ConcatenatedModuleInfo["namespaceObjectName"]>} */
 						(info.namespaceObjectName),
 					ids: exportName,
-					exportName
+					exportName,
+					accessorCall: info.wrapped
 				};
-			case "external":
+			case "external": {
 				if (deferred) {
 					info.deferredNamespaceObjectUsed = true;
 					return {
@@ -669,12 +692,30 @@ const getFinalBinding = (
 						exportName
 					};
 				}
+
+				// `require()` reads the exports object rather than a namespace, so
+				// only an import gets the spec object and interop keeps working.
+				const spec =
+					!moduleExportsAccess &&
+					exportsType === "namespace" &&
+					Boolean(
+						/** @type {BuildInfo} */
+						(info.module.buildInfo).specNamespaceObject
+					);
+				const rawName = getExternalModuleExpr(info);
+
+				if (spec) info.specNamespaceObjectUsed = true;
+
 				return {
 					info,
-					rawName: getExternalModuleExpr(info),
+					rawName: spec
+						? `${RuntimeGlobals.specNamespaceObject}(${rawName})`
+						: rawName,
 					ids: exportName,
-					exportName
+					exportName,
+					accessorCall: spec || info.wrapped
 				};
+			}
 		}
 	}
 	const exportsInfo = moduleGraph.getExportsInfo(info.module);
@@ -938,9 +979,13 @@ const getFinalName = (
 		let reference;
 		/** @type {boolean} */
 		let isPropertyAccess;
+		// the raw name is the wrapper accessor call itself, so the reference binds
+		// looser than the identifier it stands in for
+		let accessorCall = false;
 		if ("rawName" in binding) {
 			reference = `${binding.rawName}${comment || ""}${propertyAccess(ids)}`;
 			isPropertyAccess = ids.length > 0;
+			accessorCall = binding.accessorCall === true;
 		} else {
 			const { info, name: exportId } = binding;
 			const name = info.internalNames.get(exportId);
@@ -968,8 +1013,12 @@ const getFinalName = (
 						? `;(0,${reference})`
 						: `/*#__PURE__*/Object(${reference})`;
 			} else if (binding.info.wrapped) {
-				return asiSafe === false ? `;(${reference})` : `(${reference})`;
+				return parenthesizeReference(reference, asiSafe);
 			}
+		} else if (accessorCall && !asCall) {
+			// without parentheses `new X()` would construct the accessor rather
+			// than what it returns
+			return parenthesizeReference(reference, asiSafe);
 		}
 
 		return reference;
@@ -1166,15 +1215,17 @@ class ConcatenatedModule extends Module {
 
 		for (const m of this._modules) {
 			// populate cacheable
-			const { cacheable, notCacheableReasons } = /** @type {BuildInfo} */ (
-				m.buildInfo
-			);
+			const { cacheable, diagnostics } = /** @type {BuildInfo} */ (m.buildInfo);
 			if (!cacheable) {
 				this.buildInfo.cacheable = false;
+				const notCacheableReasons =
+					diagnostics === undefined
+						? undefined
+						: diagnostics.notCacheableReasons;
 				if (notCacheableReasons) {
+					const own = getBuildDiagnostics(this.buildInfo);
 					const reasons =
-						this.buildInfo.notCacheableReasons ||
-						(this.buildInfo.notCacheableReasons = []);
+						own.notCacheableReasons || (own.notCacheableReasons = []);
 					for (const reason of notCacheableReasons) {
 						if (!reasons.includes(reason)) reasons.push(reason);
 					}
@@ -1804,6 +1855,15 @@ class ConcatenatedModule extends Module {
 				return info.escapeNamespaceObjectName;
 			}
 			const exportsInfo = moduleGraph.getExportsInfo(info.module);
+			// Its names are not mangled, and the wrapped binding is already the
+			// namespace, so a decoupled object would only shadow it.
+			if (
+				/** @type {BuildInfo} */
+				(info.module.buildInfo).specNamespaceObject
+			) {
+				return undefined;
+			}
+
 			let mangled = false;
 			for (const exportInfo of exportsInfo.orderedExports) {
 				if (exportInfo.provided === false) continue;
@@ -1849,6 +1909,13 @@ class ConcatenatedModule extends Module {
 					for (const reference of ConcatenationScope.findModuleReferences(
 						/** @type {Source} */ (info.internalSource)
 					)) {
+						if (reference.leaked) {
+							throw new Error(
+								`Unsubstituted module reference "${reference.name}" in ${info.module.readableIdentifier(
+									requestShortener
+								)}`
+							);
+						}
 						if (visitedReferences.has(reference.name)) continue;
 						visitedReferences.add(reference.name);
 						const match = ConcatenationScope.matchModuleReference(
@@ -1942,6 +2009,13 @@ class ConcatenatedModule extends Module {
 									ignoredScopes
 								);
 							} else {
+								if (ConcatenationScope.isLeakedModuleReference(name)) {
+									throw new Error(
+										`Unsubstituted module reference "${name}" in ${info.module.readableIdentifier(
+											requestShortener
+										)}`
+									);
+								}
 								allUsedNames.add(name);
 								freeNames.add(name);
 							}
@@ -2688,10 +2762,18 @@ ${defineGetters}`
 					runtimeRequirements
 				});
 				const moduleId = JSON.stringify(chunkGraph.getModuleId(info.module));
+				const required = `${RuntimeGlobals.require}(${moduleId})`;
+
+				// The wrapping happens per reference, so only the helper has to be
+				// declared here.
+				if (info.specNamespaceObjectUsed) {
+					runtimeRequirements.add(RuntimeGlobals.specNamespaceObject);
+				}
+
 				const body =
 					condition === "true"
-						? `return ${RuntimeGlobals.require}(${moduleId});`
-						: `if (${condition}) return ${RuntimeGlobals.require}(${moduleId});`;
+						? `return ${required};`
+						: `if (${condition}) return ${required};`;
 				result.add(
 					`\n// EXTERNAL MODULE: ${info.module.readableIdentifier(
 						requestShortener
@@ -2747,14 +2829,31 @@ ${defineGetters}`
 				);
 				if (info.deferredNamespaceObjectUsed) {
 					runtimeRequirements.add(RuntimeGlobals.makeDeferredNamespaceObject);
+					// Every call site for a module must agree on the shape, since the
+					// runtime caches one namespace object per module and mode.
+					const deferredExportsType = getExportsType(
+						moduleGraph,
+						info,
+						strictHarmonyModule
+					);
+					const names = getKnownExportNames(
+						moduleGraph,
+						info.module,
+						deferredExportsType
+					);
+					runtimeRequirements.add(
+						names
+							? RuntimeGlobals.hasSealedDeferredNamespace
+							: RuntimeGlobals.hasSynthesizedDeferredNamespace
+					);
 					result.add(
 						`\nvar ${info.deferredNamespaceObjectName} = /*#__PURE__*/${
 							RuntimeGlobals.makeDeferredNamespaceObject
 						}(${JSON.stringify(
 							chunkGraph.getModuleId(info.module)
 						)}, ${getMakeDeferredNamespaceModeFromExportsType(
-							getExportsType(moduleGraph, info, strictHarmonyModule)
-						)});`
+							deferredExportsType
+						)}${names ? `, ${JSON.stringify(names)}` : ""});`
 					);
 				}
 			}
@@ -2840,7 +2939,15 @@ ${defineGetters}`
 						// External module bindings may be wrapped in
 						// runtime-condition `if` blocks but referenced outside,
 						// so they must remain function-scoped (`var`).
-						result.add(`var ${info.name} = __webpack_require__(${moduleId});`);
+						const required = `__webpack_require__(${moduleId})`;
+
+						// The wrapping happens per reference, so only the helper has
+						// to be declared here.
+						if (info.specNamespaceObjectUsed) {
+							runtimeRequirements.add(RuntimeGlobals.specNamespaceObject);
+						}
+
+						result.add(`var ${info.name} = ${required};`);
 
 						// Decoupled namespace object for an escaping mangled external
 						// module must come after its import variable is defined.
@@ -3148,6 +3255,7 @@ ${defineGetters}`
 							namespaceFnName: undefined,
 							escapeNamespaceObjectName: undefined,
 							deferredName: undefined,
+							specNamespaceObjectUsed: false,
 							interopNamespaceObjectUsed: false,
 							interopNamespaceObjectName: undefined,
 							interopNamespaceObject2Used: false,