webpack 5.106.1 → 5.107.0

package/lib/runtime/MakeDeferredNamespaceObjectRuntime.js

@@ -58,6 +58,7 @@ class MakeOptimizedDeferredNamespaceObjectRuntimeModule extends HelperRuntimeMod
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
@@ -108,6 +109,7 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
@@ -119,15 +121,40 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 			? "init?.();"
 			: "if (init) init();";
 		return `${fn} = ${runtimeTemplate.basicFunction("moduleId, mode", [
+			// Per the TC39 import-defer spec, deferred namespaces are
+			// distinct from their eager counterparts and the same module
+			// referenced from multiple defer-import sites must yield the
+			// same object. Cache the Proxy / fake namespace per-moduleId so
+			// repeated calls (including across files) share identity.
+			//
+			// Bit 16 (`createFakeNamespaceObject`'s "return value when
+			// it's Promise-like" flag added by
+			// `RuntimeTemplate.moduleNamespacePromise` for dynamic
+			// imports) is irrelevant for deferred namespaces — the value
+			// passed into `createFakeNamespaceObject` here is always the
+			// resolved module exports (after unwrapping the async-module
+			// export symbol when present), never a Promise. Strip it
+			// once so all downstream behavior, the cache key, and the
+			// `createFakeNamespaceObject` call below see the same shape
+			// mode. This keeps static defer (mode 8) and dynamic
+			// `await import.defer` (mode 8 | 16) sharing the same
+			// Deferred Module Namespace object, while still keying by
+			// `(moduleId, mode)` so distinct exports-type shapes
+			// (e.g. one importer treats a CJS module as
+			// "default-with-named", another as "namespace") get
+			// distinct cache entries.
+			"mode &= ~16;",
+			"var byMode = __webpack_module_deferred_namespace_cache__[moduleId];",
+			"if (byMode && byMode[mode] !== undefined) return byMode[mode];",
+			"if (!byMode) byMode = __webpack_module_deferred_namespace_cache__[moduleId] = {};",
 			"var cachedModule = __webpack_module_cache__[moduleId];",
-			"if (cachedModule && cachedModule.error === undefined) {",
+			"if (cachedModule && cachedModule.error === undefined && !(mode & 8)) {",
 			Template.indent([
 				"var exports = cachedModule.exports;",
 				hasAsync
 					? `if (${RuntimeGlobals.asyncModuleExportSymbol} in exports) exports = exports[${RuntimeGlobals.asyncModuleExportSymbol}];`
 					: "",
-				"if (mode & 8) return exports;",
-				`return ${RuntimeGlobals.createFakeNamespaceObject}(exports, mode);`
+				`return byMode[mode] = ${RuntimeGlobals.createFakeNamespaceObject}(exports, mode);`
 			]),
 			"}",
 			"",
@@ -139,9 +166,23 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 				"init = null;",
 				"if (mode & 8 || mode & 4 && ns.__esModule && typeof ns === 'object') {",
 				Template.indent([
-					"delete handler.defineProperty;",
-					"delete handler.deleteProperty;",
-					"delete handler.set;",
+					// Drop only the read-side traps after init: with the
+					// resolved namespace's own keys mirrored onto
+					// `ns_target` below, the default `Reflect` behavior
+					// returns the right values via the live-binding
+					// getters, so we no longer need to intercept `get` /
+					// `has` / `ownKeys` / `getOwnPropertyDescriptor`.
+					//
+					// The mutation traps (`set`, `deleteProperty`,
+					// `defineProperty`) are kept because per the TC39
+					// import-defer spec, `[[Set]]` / `[[Delete]]` /
+					// `[[DefineOwnProperty]]` on a Deferred Module
+					// Namespace Exotic Object never succeed — and the
+					// proxy target itself remains extensible
+					// (architecturally we cannot freeze it up-front),
+					// so without these traps `ns.notExported = "x"`
+					// after evaluation would silently create a property
+					// on the target instead of returning false.
 					"delete handler.get;",
 					"delete handler.has;",
 					"delete handler.ownKeys;",
@@ -151,13 +192,58 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 				Template.indent([
 					`ns = ${RuntimeGlobals.createFakeNamespaceObject}(ns, mode);`
 				]),
+				"}",
+				// Mirror own properties from the resolved namespace onto the proxy
+				// target so that proxy invariants hold for callers that structurally
+				// introspect via `Object.keys` / `Object.getOwnPropertyNames` /
+				// `Object.getOwnPropertyDescriptor`: when our trap reports a
+				// non-configurable descriptor for a key, the target must also have
+				// that key with a matching descriptor.
+				//
+				// `__esModule` and `Symbol.toStringTag` are intentionally skipped:
+				// the proxy synthesizes "Deferred Module" / true regardless of what
+				// the underlying namespace exposes (per the TC39 import-defer
+				// proposal, the [[StringTag]] of a Deferred Module Namespace
+				// Exotic Object is "Deferred Module"), and the target was already
+				// pre-populated with those values below.
+				"var keys = Reflect.ownKeys(ns);",
+				"for (var i = 0; i < keys.length; i++) {",
+				Template.indent([
+					"var k = keys[i];",
+					'if (k === "__esModule" || k === Symbol.toStringTag) continue;',
+					"if (!Object.prototype.hasOwnProperty.call(ns_target, k)) {",
+					Template.indent([
+						"try { Object.defineProperty(ns_target, k, Reflect.getOwnPropertyDescriptor(ns, k)); } catch (_) {}"
+					]),
+					"}"
+				]),
 				"}"
 			])};`,
 			"",
-			"var ns = __webpack_module_deferred_exports__[moduleId] || (__webpack_module_deferred_exports__[moduleId] = { __proto__: null });",
+			// The proxy target is a fresh placeholder, separate from
+			// `__webpack_module_deferred_exports__[moduleId]` (which is reused
+			// by `__webpack_require__` as `module.exports` for deferred-loaded
+			// modules and would conflict with our pre-populated synthetic
+			// `__esModule` / `Symbol.toStringTag` non-configurable properties).
+			// Using a dedicated target keeps the proxy invariant-compliant
+			// without interfering with the module's own exports object.
+			"var ns_target = { __proto__: null };",
+			// Pre-populate the synthetic deferred-namespace properties with
+			// fully non-configurable, non-writable, non-enumerable descriptors
+			// (matching the TC39 import-defer spec for Module Namespace
+			// Exotic Objects). The trap returns the same descriptors below.
+			'Object.defineProperty(ns_target, "__esModule", { value: true });',
+			'Object.defineProperty(ns_target, Symbol.toStringTag, { value: "Deferred Module" });',
+			"var ns = ns_target;",
 			"var handler = {",
 			Template.indent([
 				"__proto__: null,",
+				// Per the TC39 import-defer proposal, `IsSymbolLikeNamespaceKey`
+				// returns true for any Symbol-keyed access (and for "then"); such
+				// accesses go through `OrdinaryGetOwnProperty` and must not
+				// trigger evaluation of the deferred module. The Symbol checks
+				// below short-circuit to the pre-populated target without
+				// running `init()`.
 				`get: ${runtimeTemplate.basicFunction("_, name", [
 					"switch (name) {",
 					Template.indent([
@@ -166,6 +252,7 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 						'case "then": return undefined;'
 					]),
 					"}",
+					'if (typeof name === "symbol") return ns_target[name];',
 					init,
 					"return ns[name];"
 				])},`,
@@ -184,6 +271,7 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 						].filter(Boolean)
 					),
 					"}",
+					'if (typeof name === "symbol") return name in ns_target;',
 					init,
 					"return name in ns;"
 				])},`,
@@ -195,11 +283,16 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 				`getOwnPropertyDescriptor: ${runtimeTemplate.basicFunction("_, name", [
 					"switch (name) {",
 					Template.indent([
-						'case "__esModule": return { value: true, configurable: !(mode & 8) };',
-						'case Symbol.toStringTag: return { value: "Deferred Module", configurable: !(mode & 8) };',
+						// Match the descriptors actually defined on `ns_target`
+						// (non-configurable, non-writable, non-enumerable) so the
+						// proxy invariant holds for both the trap result and any
+						// post-init forwarding via the deleted-handler path.
+						'case "__esModule": return { value: true, writable: false, enumerable: false, configurable: false };',
+						'case Symbol.toStringTag: return { value: "Deferred Module", writable: false, enumerable: false, configurable: false };',
 						'case "then": return undefined;'
 					]),
 					"}",
+					'if (typeof name === "symbol") return Reflect.getOwnPropertyDescriptor(ns_target, name);',
 					init,
 					"var desc = Reflect.getOwnPropertyDescriptor(ns, name);",
 					'if (mode & 2 && name == "default" && !desc) {',
@@ -207,18 +300,33 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 					"}",
 					"return desc;"
 				])},`,
+				// `defineProperty` always rejects, but per the TC39 spec it
+				// must still trigger evaluation for string keys (the spec
+				// algorithm calls `[[GetOwnProperty]]` first, which forces
+				// evaluation on a deferred namespace). Symbol keys go through
+				// OrdinaryDefineOwnProperty and do not trigger eval.
 				`defineProperty: ${runtimeTemplate.basicFunction("_, name", [
+					'if (typeof name === "symbol" || name === "then") return false;',
+					init,
+					"return false;"
+				])},`,
+				// `deleteProperty` rejects, but per the TC39 spec it must
+				// still trigger evaluation for string keys (the spec
+				// algorithm calls `GetModuleExportsList` for non-symbol-like
+				// keys, forcing evaluation on a deferred namespace).
+				`deleteProperty: ${runtimeTemplate.basicFunction("_, name", [
+					'if (typeof name === "symbol" || name === "then") return false;',
 					init,
-					// Note: This behavior does not match the spec one, but since webpack does not do it either
-					// for a normal Module Namespace object (in MakeNamespaceObjectRuntimeModule), let's keep it simple.
 					"return false;"
 				])},`,
-				`deleteProperty: ${runtimeTemplate.returningFunction("false")},`,
+				// `set` always returns false without triggering evaluation —
+				// the spec [[Set]] algorithm for Module Namespaces is just
+				// "return false" (no [[GetOwnProperty]], no eval).
 				`set: ${runtimeTemplate.returningFunction("false")},`
 			]),
 			"}",
 			// we don't fully emulate ES Module semantics in this Proxy to align with normal webpack esm namespace object.
-			"return new Proxy(ns, handler);"
+			"return byMode[mode] = new Proxy(ns_target, handler);"
 		])};`;
 	}
 }

package/lib/runtime/MakeNamespaceObjectRuntimeModule.js

@@ -16,6 +16,7 @@ class MakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/runtime/NonceRuntimeModule.js

@@ -14,6 +14,7 @@ class NonceRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/runtime/OnChunksLoadedRuntimeModule.js

@@ -16,6 +16,7 @@ class OnChunksLoadedRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/runtime/PublicPathRuntimeModule.js

@@ -21,6 +21,7 @@ class PublicPathRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/runtime/RelativeUrlRuntimeModule.js

@@ -16,6 +16,7 @@ class RelativeUrlRuntimeModule extends HelperRuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/runtime/RuntimeIdRuntimeModule.js

@@ -16,6 +16,7 @@ class RuntimeIdRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/runtime/SetAnonymousDefaultNameRuntimeModule.js

@@ -0,0 +1,35 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/** @typedef {import("../Compilation")} Compilation */
+
+class SetAnonymousDefaultNameRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("set anonymous default export name");
+	}
+
+	/**
+	 * Generates runtime code for this runtime module.
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
+		const fn = RuntimeGlobals.setAnonymousDefaultName;
+		return Template.asString([
+			"// set .name for anonymous default exports per ES spec",
+			`${fn} = ${runtimeTemplate.basicFunction("x", [
+				'(Object.getOwnPropertyDescriptor(x, "name") || {}).writable || Object.defineProperty(x, "name", { value: "default", configurable: true });'
+			])};`
+		]);
+	}
+}
+
+module.exports = SetAnonymousDefaultNameRuntimeModule;

package/lib/runtime/StartupChunkDependenciesPlugin.js

@@ -13,6 +13,9 @@ const StartupEntrypointRuntimeModule = require("./StartupEntrypointRuntimeModule
 /** @typedef {import("../Compiler")} Compiler */
 
 /**
+ * Options that describe which chunk loading backend should receive startup
+ * dependency handling and whether the runtime should wait for those chunks
+ * asynchronously.
  * @typedef {object} Options
  * @property {ChunkLoadingType} chunkLoading
  * @property {boolean=} asyncChunkLoading
@@ -20,8 +23,14 @@ const StartupEntrypointRuntimeModule = require("./StartupEntrypointRuntimeModule
 
 const PLUGIN_NAME = "StartupChunkDependenciesPlugin";
 
+/**
+ * Adds runtime modules that delay entry startup until entry-dependent chunks
+ * required by the selected chunk loading strategy have been loaded.
+ */
 class StartupChunkDependenciesPlugin {
 	/**
+	 * Configures which chunk loading implementation this plugin should enhance
+	 * and whether startup waits should use promises or synchronous ensures.
 	 * @param {Options} options options
 	 */
 	constructor(options) {
@@ -35,7 +44,8 @@ class StartupChunkDependenciesPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Registers compilation hooks that attach the startup dependency runtime
+	 * modules to entry chunks using the configured chunk loading mechanism.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -43,6 +53,8 @@ class StartupChunkDependenciesPlugin {
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const globalChunkLoading = compilation.outputOptions.chunkLoading;
 			/**
+			 * Determines whether a chunk uses the chunk loading backend that this
+			 * plugin is responsible for augmenting.
 			 * @param {Chunk} chunk chunk to check
 			 * @returns {boolean} true, when the plugin is enabled for the chunk
 			 */

package/lib/runtime/StartupChunkDependenciesRuntimeModule.js

@@ -24,6 +24,7 @@ class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/runtime/StartupEntrypointRuntimeModule.js

@@ -20,6 +20,7 @@ class StartupEntrypointRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/runtime/SystemContextRuntimeModule.js

@@ -13,6 +13,7 @@ class SystemContextRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/runtime/ToBinaryRuntimeModule.js

@@ -17,6 +17,7 @@ class ToBinaryRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/schemes/DataUriPlugin.js

@@ -14,7 +14,7 @@ const PLUGIN_NAME = "DataUriPlugin";
 
 class DataUriPlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -24,7 +24,7 @@ class DataUriPlugin {
 			(compilation, { normalModuleFactory }) => {
 				normalModuleFactory.hooks.resolveForScheme
 					.for("data")
-					.tap(PLUGIN_NAME, (resourceData) => {
+					.tap(PLUGIN_NAME, (resourceData, resolveData) => {
 						const match = URIRegEx.exec(resourceData.resource);
 						if (match) {
 							resourceData.data.mimetype = match[1] || "";
@@ -34,6 +34,18 @@ class DataUriPlugin {
 							);
 							resourceData.data.encodedContent = match[4] || "";
 						}
+						// Inherit the issuer's resolution context so any nested
+						// dependencies discovered while parsing the data URI's body
+						// (e.g. `url(...)` / `@import` inside an inline CSS data
+						// URI) resolve relative to where the URI was referenced
+						// from, instead of against the synthetic `data:.../` path
+						// that `getContext("data:…")` would otherwise infer.
+						if (
+							resourceData.context === undefined &&
+							resolveData.context !== undefined
+						) {
+							resourceData.context = resolveData.context;
+						}
 					});
 
 				NormalModule.getCompilationHooks(compilation)

package/lib/schemes/FileUriPlugin.js

@@ -14,7 +14,7 @@ const PLUGIN_NAME = "FileUriPlugin";
 
 class FileUriPlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */