webpack 5.111.0 → 5.111.1

package/lib/index.js

@@ -38,7 +38,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./asset/AssetModule").AssetModuleBuildInfo} AssetModuleBuildInfo */
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
 /** @typedef {import("./Compiler").AssetEmittedInfo} AssetEmittedInfo */
-/** @typedef {import("./ContextModule").ContextModuleBuildInfo} ContextModuleBuildInfo */
+/** @typedef {import("./context/ContextModule").ContextModuleBuildInfo} ContextModuleBuildInfo */
 /** @typedef {import("./css/CssModule").CssModuleBuildInfo} CssModuleBuildInfo */
 /** @typedef {import("./css/CssModule").CssModuleBuildMeta} CssModuleBuildMeta */
 /** @typedef {import("./ExternalModule").ExternalModuleBuildInfo} ExternalModuleBuildInfo */
@@ -237,10 +237,10 @@ module.exports = mergeExports(fn, {
 		return require("./ConcatenationScope");
 	},
 	get ContextExclusionPlugin() {
-		return require("./ContextExclusionPlugin");
+		return require("./context/ContextExclusionPlugin");
 	},
 	get ContextReplacementPlugin() {
-		return require("./ContextReplacementPlugin");
+		return require("./context/ContextReplacementPlugin");
 	},
 	get CopyPlugin() {
 		return require("./CopyPlugin");
@@ -743,3 +743,46 @@ module.exports = mergeExports(fn, {
 		}
 	}
 });
+
+/**
+ * The loader-authoring types, re-exported here because this file is what
+ * `generate-types.js` reads webpack's public type surface from
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {import("./loaders/LoaderRunner").LoaderModule<OptionsType, ContextAdditions>} LoaderModule
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {import("./loaders/LoaderRunner").RawLoaderDefinition<OptionsType, ContextAdditions>} RawLoaderDefinition
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {import("./loaders/LoaderRunner").LoaderDefinition<OptionsType, ContextAdditions>} LoaderDefinition
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {import("./loaders/LoaderRunner").LoaderDefinitionFunction<OptionsType, ContextAdditions>} LoaderDefinitionFunction
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {import("./loaders/LoaderRunner").PitchLoaderDefinitionFunction<OptionsType, ContextAdditions>} PitchLoaderDefinitionFunction
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {import("./loaders/LoaderRunner").RawLoaderDefinitionFunction<OptionsType, ContextAdditions>} RawLoaderDefinitionFunction
+ */
+
+/**
+ * @template OptionsType
+ * @typedef {import("./NormalModule").LoaderContext<OptionsType>} LoaderContext
+ */

package/lib/javascript/ChunkFormatHelpers.js

@@ -55,10 +55,11 @@ function createChunkHashHandler(name) {
 		hash.update(name);
 		hash.update("1");
 		if (runtimeChunk && runtimeChunk.hash) {
-			// https://github.com/webpack/webpack/issues/19439
-			// Any change to runtimeChunk should trigger a hash update,
-			// we shouldn't depend on or inspect its internal implementation.
+			// WHY: any change to the runtime chunk must move this hash, and its
+			// internal implementation is not ours to depend on or inspect — the import
+			// names its hashed filename:
 			// import __webpack_require__ from "./runtime-main.e9400aee33633a3973bd.js";
+			// https://github.com/webpack/webpack/issues/19439
 			hash.update(runtimeChunk.hash);
 		}
 		updateHashForEntryStartup(hash, chunkGraph, entries, chunk);

package/lib/javascript/JavascriptGenerator.js

@@ -256,6 +256,7 @@ class JavascriptGenerator extends Generator {
 				/** @type {NonNullable<GenerateContext["codeGenerationResults"]>} */
 				(generateContext.codeGenerationResults),
 			initFragments,
+			getData: generateContext.getData,
 			get chunkInitFragments() {
 				if (!chunkInitFragments) {
 					const data =
@@ -332,7 +333,13 @@ class JavascriptGenerator extends Generator {
 	 * @returns {Source | null} generated code
 	 */
 	generateError(error, module, generateContext) {
-		return new RawSource(Generator.throwBuildErrorCode(error));
+		return new RawSource(
+			Generator.throwBuildErrorCode(
+				error,
+				undefined,
+				generateContext.runtimeTemplate.requestShortener
+			)
+		);
 	}
 }
 

package/lib/javascript/JavascriptModulesPlugin.js

@@ -78,7 +78,6 @@ const { releaseParserCaches } = require("./syntax");
 /** @import DependencyTemplates from "../DependencyTemplates" */
 /** @import Entrypoint from "../Entrypoint" */
 /** @import Module, { BuildInfo, CodeGenerationResultData } from "../Module" */
-/** @import { RuntimeSpec } from "../util/runtime" */
 /** @import ModuleGraph from "../ModuleGraph" */
 /** @import RuntimeTemplate from "../RuntimeTemplate" */
 /** @import WebpackError from "../errors/WebpackError" */
@@ -332,18 +331,6 @@ const createCompilationHooks = () => ({
 	 * @since 5.22.0
 	 */
 	inlineInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
-	/**
-	 * Offers a module's rendered export-definition call to a consumer that can place
-	 * it better — a library whose entry exports the same bindings natively takes it
-	 * over and emits it only where the module is wrapped. Return true to take it.
-	 * @type {SyncBailHook<[Module, RuntimeSpec, string, boolean], boolean | void>}
-	 */
-	onDemandExportsGeneration: new SyncBailHook([
-		"module",
-		"runtime",
-		"source",
-		"placeAtEnd"
-	]),
 	/**
 	 * @type {SyncBailHook<[Module, RenderContext], string | void>}
 	 * @since 5.22.0
@@ -1597,17 +1584,14 @@ class JavascriptModulesPlugin {
 		}
 
 		if (runtimeRequirements.has(RuntimeGlobals.makeDeferredNamespaceObject)) {
-			// in order to optimize of DeferredNamespaceObject, we remove all proxy handlers after the module initialize
-			// (see MakeDeferredNamespaceObjectRuntimeModule)
-			// This requires all deferred imports to a module can get the module export object before the module
-			// is evaluated.
+			// The deferred namespace drops its proxy handlers once the module has
+			// initialized, which needs every deferred import of it to reach the exports
+			// object before evaluation.
 			buf.push("// The deferred module cache");
 			buf.push(`${bootstrapCst} __webpack_module_deferred_exports__ = {};`);
-			// Per the TC39 import-defer spec, every defer-import call site for
-			// the same module must yield the same Deferred Module Namespace
-			// Exotic Object (and a distinct one from any eager namespace).
-			// Cache the deferred namespace proxy here so calls from different
-			// files share identity.
+			// Every defer-import site for one module must yield the same Deferred
+			// Module Namespace, distinct from any eager one, so the proxy is cached
+			// here for call sites in different files to share.
 			buf.push("// The deferred namespace cache");
 			buf.push(
 				`${bootstrapCst} __webpack_module_deferred_namespace_cache__ = {};`
@@ -1797,13 +1781,9 @@ class JavascriptModulesPlugin {
 						result.allowInlineStartup = false;
 					}
 
-					// `__webpack_exports__` may be reassigned later — by the
-					// `onChunksLoaded` wrapper below, by an inlined entry
-					// module that uses top-level `await` (the emitted
-					// bridge reassigns `__webpack_exports__` to the awaited
-					// value), or by other downstream codegen. Always declare
-					// with `let` (or `var` if `let` is unsupported) so
-					// reassignment is allowed.
+					// `__webpack_exports__` may be reassigned later, by the
+					// `onChunksLoaded` wrapper, a top-level `await` bridge or other
+					// codegen, so it is never declared as a constant.
 					const exportsDecl = runtimeTemplate.renderLet();
 					if (chunks.length > 0) {
 						const awaitEntry =
@@ -2012,11 +1992,9 @@ class JavascriptModulesPlugin {
 		const needModuleDefer = runtimeRequirements.has(
 			RuntimeGlobals.makeDeferredNamespaceObject
 		);
-		// Both deferred-namespace runtimes re-invoke `__webpack_require__` on
-		// access, so a module's evaluation error must be retained and re-thrown
-		// (a Cyclic Module Record's [[EvaluationError]]); the optimized variant
-		// does not use `__webpack_module_deferred_exports__`, so it is tracked
-		// separately from `needModuleDefer`.
+		// Both deferred-namespace runtimes re-invoke `__webpack_require__` on access,
+		// so an evaluation error must be retained and re-thrown. The optimized one
+		// skips the deferred exports object, hence the separate flag.
 		const needModuleDeferAny =
 			needModuleDefer ||
 			runtimeRequirements.has(
@@ -2144,10 +2122,9 @@ class JavascriptModulesPlugin {
 			allModules.every((m) => /** @type {BuildInfo} */ (m.buildInfo).strict);
 		const isMultipleEntries = inlinedModules.size > 1;
 		const singleEntryWithModules = inlinedModules.size === 1 && hasChunkModules;
-		// This step is before the IIFE reason calculation; it only runs for the
-		// cases whose IIFE reason it can remove: multiple inlined entry modules, or a
-		// single inlined entry alongside other chunk modules. The remaining reason
-		// ('it uses a non-standard name for the exports') is not handled here.
+		// Runs before the IIFE reason is calculated, and only for the cases whose
+		// reason it can remove: several inlined entries, or one beside other chunk
+		// modules. A non-standard exports name is not handled here.
 		if (innerStrict || (!isMultipleEntries && !singleEntryWithModules)) {
 			return false;
 		}
@@ -2206,11 +2183,9 @@ class JavascriptModulesPlugin {
 			}
 		}
 
-		// Fast path: codegen reports each inlined entry's rendered top-level
-		// declarations and free names (post-concatenation), so when no declaration
-		// collides with a free name of any other module, another entry's
-		// declarations, or a reserved name, no renaming is needed and the entries
-		// don't have to be parsed at all.
+		// Codegen reports each inlined entry's rendered top-level declarations and
+		// free names, so where nothing collides there is no renaming to do and the
+		// entries need not be parsed at all.
 		fastPath: {
 			const { codeGenerationResults, chunk } = renderContext;
 			/** @type {Set<string>} */
@@ -2295,11 +2270,9 @@ class JavascriptModulesPlugin {
 			}
 		}
 
-		// Multiple inlined entry modules share the chunk's startup scope. Rename any
-		// top-level declaration that would collide with another inlined module's
-		// declaration, with any inlined or non-inlined module's free (global)
-		// reference, or with a reserved name, so the modules can be emitted without a
-		// per-entry IIFE.
+		// Several inlined entries share the chunk's startup scope, so any top-level
+		// declaration colliding with another's declaration, any module's free
+		// reference or a reserved name is renamed, sparing them a per-entry IIFE.
 		if (isMultipleEntries) {
 			/** @type {Set<string>} */
 			const allUsedNames = new Set(nonInlinedModuleThroughIdentifiers);