webpack 5.111.0 → 5.111.1

package/lib/debug/ProfilingPlugin.js

@@ -150,10 +150,9 @@ class Profiler {
 			// Avoid coverage problems due indirect changes
 			/* istanbul ignore next */
 			if (profile.startTime < this._startTime || profile.endTime > endTime) {
-				// In some cases timestamps mismatch and we need to adjust them
-				// Both process.hrtime and the inspector timestamps claim to be relative
-				// to a unknown point in time. But they do not guarantee that this is the
-				// same point in time.
+				// `process.hrtime` and the inspector timestamps are each relative to an
+				// unknown point in time, with no guarantee it is the same point, so the
+				// two are rescaled onto one another here.
 				const duration = profile.endTime - profile.startTime;
 				const ownDuration = endTime - this._startTime;
 				const untracked = Math.max(0, ownDuration - duration);

package/lib/dependencies/CommonJsExportRequireDependency.js

@@ -273,23 +273,22 @@ class CommonJsExportRequireDependency extends ModuleDependency {
 		const from = moduleGraph.getConnection(this);
 		if (!from) return;
 		if (esmUnwrap) {
-			// Full re-export `module.exports = require("./esm")` of a module
-			// with a `"module.exports"` named export: the wrapping module's
-			// `module.exports` becomes the unwrapped value, whose own
-			// properties webpack cannot enumerate statically.
+			// In `module.exports = require("./esm")` of a module carrying a
+			// `"module.exports"` export, this module's own exports become the
+			// unwrapped value, whose properties cannot be enumerated statically.
 			return {
 				exports: true,
 				canMangle: false,
 				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.
+		// WHY: the imported namespace ESM has not been flagged by
+		// FlagDependencyExportsPlugin yet, so its `"module.exports"` unwrap
+		// eligibility is still unknown. Star-reexporting now would add `__esModule`,
+		// and names, that the monotonic merge cannot retract once the module turns
+		// out to unwrap, making the result order-dependent across runtimes. Deferring
+		// is safe: the `from.module` dependency re-queues this once its exports —
+		// owned names, or a dynamic `other` — become known.
 		if (
 			importedModule &&
 			importedModule.getExportsType(moduleGraph, false) === "namespace"

package/lib/dependencies/CommonJsImportsParserPlugin.js

@@ -738,11 +738,10 @@ class CommonJsImportsParserPlugin {
 		// #endregion
 
 		// #region Require bound to a const variable
-		// Track `const NAME = require(LITERAL)` so that static member accesses on
-		// `NAME` (e.g. `NAME.foo`, `NAME.foo()`) are forwarded to the same
-		// `CommonJsRequireDependency` as referenced exports — enabling tree
-		// shaking of CommonJS modules that are imported into a named binding
-		// rather than destructured.
+
+		// Track `const NAME = require(LITERAL)`, so a static member access on `NAME`
+		// forwards to the same dependency as a referenced export and a CommonJS
+		// module bound to a name still tree-shakes.
 		parser.hooks.preDeclarator.tap(PLUGIN_NAME, (declarator, statement) => {
 			if (statement.kind !== "const") return;
 			if (declarator.id.type !== "Identifier") return;

package/lib/dependencies/CommonJsSelfReferenceDependency.js

@@ -207,10 +207,8 @@ CommonJsSelfReferenceDependency.Template = class CommonJsSelfReferenceDependency
 		}
 
 		if (base === dep.base && equals(used, dep.names)) {
-			// Nothing has to be changed
-			// We don't use a replacement for compat reasons
-			// for plugins that update `module._source` which they
-			// shouldn't do!
+			// Nothing has to change, and no replacement is emitted: plugins that
+			// update `module._source`, which they should not, depend on that.
 			return;
 		}
 

package/lib/dependencies/ContextDependency.js

@@ -15,7 +15,7 @@ const getCriticalDependencyWarning = memoize(() =>
 );
 
 /** @import { Range } from "../javascript/JavascriptParser" */
-/** @import { ContextOptions } from "../ContextModule" */
+/** @import { ContextOptions } from "../context/ContextModule" */
 /** @import { TRANSITIVE } from "../Dependency" */
 /** @import ModuleGraph from "../ModuleGraph" */
 /** @import WebpackError from "../errors/WebpackError" */

package/lib/dependencies/ContextDependencyHelpers.js

@@ -107,15 +107,9 @@ module.exports.create = (
 				)
 				.join("");
 
-		// Example: `./context/pre${e}inner${e}inner2${e}post?query#frag`
-		// context: "./context"
-		// prefix: "./pre"
-		// innerQuasis: [BEE("inner"), BEE("inner2")]
-		// (BEE = BasicEvaluatedExpression)
-		// postfix: "post"
-		// query: "?query"
-		// fragment: "#frag"
-		// regExp: /^\.\/pre.*inner.*inner2.*post$/
+		// The template's quasis become the literal anchors of the regexp and its
+		// expressions the gaps between them, so `./context/pre${e}inner${e}post`
+		// matches `/^\.\/pre.*inner.*post$/` under the context `./context`.
 		const regExp = new RegExp(
 			`^${quoteMeta(prefix)}${innerRegExp}${quoteMeta(postfix)}$`
 		);

package/lib/dependencies/ContextElementDependency.js

@@ -9,7 +9,7 @@ const Dependency = require("../Dependency");
 const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
-/** @import ContextModule from "../ContextModule" */
+/** @import ContextModule from "../context/ContextModule" */
 /** @import { RawReferencedExports, ReferencedExports } from "../Dependency" */
 /** @import Module from "../Module" */
 /** @import ModuleGraph from "../ModuleGraph" */

package/lib/dependencies/CssIcssExportDependency.js

@@ -370,10 +370,9 @@ class CssIcssExportDependency extends NullDependency {
 	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
-		// `composes: foo;` (SELF_REFERENCE) references the composed class
-		// (`entry.value`), not the composing class. Every other entry mode
-		// keeps the whole exports object referenced (legacy behaviour), so the
-		// presence of any such entry subsumes the self-reference names.
+		// `composes: foo;` references the composed class, not the composing one.
+		// Every other entry mode references the whole exports object, so one such
+		// entry subsumes the self-reference names.
 		let hasNonSelfReference = false;
 		/** @type {ReferencedExports} */
 		const referenced = [];
@@ -850,10 +849,9 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 		if (!entry.interpolate) return value;
 		const { moduleGraph, module, chunkGraph, runtimeTemplate } =
 			templateContext;
-		// Key order is by rising cardinality: `moduleGraph.cached` is a trie that
-		// allocates a node per level per new prefix, so the per-export `value` goes
-		// last — otherwise every export name forks the trie and re-allocates the
-		// three elements below it, which are constant for the whole compilation.
+		// Keys are ordered by rising cardinality, since `moduleGraph.cached` is a
+		// trie allocating a node per level per prefix: the per-export `value` last,
+		// or every name forks the trie above the parts constant for the build.
 		return moduleGraph.cached(
 			computeInterpolatedIdentifier,
 			/** @type {CssModule} */ (module),

package/lib/dependencies/CssIcssImportDependency.js

@@ -100,12 +100,9 @@ class CssIcssImportDependency extends CssImportDependency {
 
 		if (!module) return null;
 
-		// The target module stores exports under the names produced by its
-		// `exportsConvention`, so a raw `isExportProvided(this.importName)`
-		// would false-positive against `camel-case-only` / `dashes-only` (and
-		// any custom function that drops the original spelling). Expand
-		// `importName` through the *target* module's convention and accept
-		// if any alias is provided.
+		// The target stores exports under its own `exportsConvention`, so asking for
+		// the raw name misses under `camel-case-only` or any convention dropping the
+		// original spelling. Expand through that convention and accept any alias.
 		const generator =
 			/** @type {CssGenerator | undefined} */
 			(module.generator);

package/lib/dependencies/CssUrlDependency.js

@@ -84,11 +84,9 @@ class CssUrlDependency extends ModuleDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		// The dependency template substitutes the referenced asset's hashed
-		// filename into the rendered CSS at code-generation time. Folding the
-		// asset module's content hash into the dependency hash ensures the
-		// CSS module's hash invalidates — and the CSS chunk's contenthash
-		// updates — whenever the referenced asset's content changes.
+		// The template substitutes the asset's hashed filename into the rendered CSS,
+		// so folding that asset's content hash in here is what makes the CSS module's
+		// hash, and the chunk's contenthash, follow the asset.
 		const { chunkGraph } = context;
 		const module = chunkGraph.moduleGraph.getModule(this);
 		if (!module) return;

package/lib/dependencies/HarmonyCompatibilityDependency.js

@@ -13,11 +13,8 @@ const makeSerializable = require("../util/makeSerializable");
 const memoize = require("../util/memoize");
 const NullDependency = require("./NullDependency");
 
-// Required here rather than at the top: the plugin reaches back into the dependencies.
-const getJavascriptModulesPlugin = memoize(() =>
-	require("../javascript/JavascriptModulesPlugin")
-);
-// Same reason: the deferred-namespace runtime imports dependencies from here.
+// Required here rather than at the top: the deferred-namespace runtime imports
+// dependencies from here.
 const getDeferredCycleHelpers = memoize(() =>
 	require("../runtime/MakeDeferredNamespaceObjectRuntime")
 );
@@ -99,7 +96,8 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 			initFragments,
 			runtimeRequirements,
 			runtime,
-			concatenationScope
+			concatenationScope,
+			getData
 		}
 	) {
 		// a wrapped module has a real exports object that still needs `__esModule`
@@ -113,20 +111,13 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 				exportsArgument: module.exportsArgument,
 				runtimeRequirements
 			});
-			// A library exporting the same bindings natively never reads the marker back
-			// off the exports object, so it takes the call over and emits it where wrapped.
-			const hooks = getJavascriptModulesPlugin().getCompilationHooks(
-				runtimeTemplate.compilation
-			);
-			const takenOver =
-				hooks.onDemandExportsGeneration.isUsed() &&
-				hooks.onDemandExportsGeneration.call(
-					module,
-					runtime,
-					content,
-					false
-				) === true;
-			if (!takenOver) {
+
+			const meta = moduleGraph.getMetaIfExisting(module);
+			if (!concatenationScope && meta && meta.onDemandExports && getData) {
+				const data = getData();
+				const before = data.get("exportsSource");
+				data.set("exportsSource", before ? `${before}${content}` : content);
+			} else {
 				initFragments.push(
 					new InitFragment(
 						content,

package/lib/dependencies/HarmonyDetectionParserPlugin.js

@@ -109,10 +109,9 @@ module.exports = class HarmonyDetectionParserPlugin {
 			}
 		});
 
-		// Using `import.meta` only parses as a module, so it marks the module ESM.
-		// Non-bailing; staged before the bailing DefinePlugin and ImportMetaPlugin
-		// replacement taps so it observes every access; unknown members go
-		// through `unhandledExpressionMemberChain`.
+		// `import.meta` parses only as a module, so it marks this one ESM. Staged
+		// before the bailing DefinePlugin and ImportMetaPlugin taps, so it observes
+		// every access without ending the chain.
 		const onImportMeta = () => {
 			enableHarmony(false);
 		};

package/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -112,10 +112,8 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 			return true;
 		});
 		// `export default <namespace binding>` is the same export as
-		// `export { ns as default }`, so it is claimed here and rewritten into the
-		// same re-export. Stage -10 runs before the inner-graph tap, which would
-		// otherwise wrap the identifier in a pure-expression guard whose insertions
-		// outlive the statement this removes.
+		// `export { ns as default }`, so it becomes the same re-export. Stage -10
+		// beats the inner-graph tap, whose guard would outlive the removed statement.
 		parser.hooks.statement.tap(
 			{ name: PLUGIN_NAME, stage: -10 },
 			(statement) => {

package/lib/dependencies/HarmonyExportExpressionDependency.js

@@ -293,10 +293,9 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 				} else if (used) {
 					defaultIsUsed = true;
 					runtimeRequirements.add(RuntimeGlobals.exports);
-					// This is a little bit incorrect as TDZ is not correct, but we can't use const.
-					// No local `__WEBPACK_DEFAULT_EXPORT__` binding is created in this path,
-					// so the anonymous-default `.name` fix-up below must reference the actual
-					// assignment target instead. See issue #20793.
+					// The TDZ is not reproduced here, `const` being unavailable. No local
+					// binding is created either, so the anonymous-default `.name` fix-up
+					// below names the assignment target instead. See issue #20793.
 					name = `${exportsName}${propertyAccess(
 						typeof used === "string" ? [used] : used
 					)}`;

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -1547,10 +1547,9 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 			}
 
 			case "reexport-fake-namespace-object":
-				// `${name}_namespace_cache` needs an identifier to suffix, but an
-				// in-scope target is an expression. The concatenation already builds
-				// the same object, memoized: its interop namespace picks the mode from
-				// the exports type, which is what `fakeType` mirrors.
+				// `${name}_namespace_cache` needs an identifier to suffix, and an in-scope
+				// target is an expression. The concatenation already memoizes the same
+				// object, its interop namespace taking the mode `fakeType` mirrors.
 				if (inScope) {
 					initFragments.push(
 						this.getReexportFragment(

package/lib/dependencies/HarmonyExportInitFragment.js

@@ -43,12 +43,6 @@ const ExportBindingType = Object.freeze({
 /** @typedef {Map<UsedName, { value: string, type: typeof ExportBindingType.Getter | typeof ExportBindingType.Value }>} ExportMap */
 /** @typedef {Set<string>} UnusedExports */
 
-/**
- * Lets a consumer take over the rendered `d()` call at its required position.
- * End-position value bindings cannot move before the module body.
- * @typedef {(source: string, placeAtEnd: boolean) => boolean} OnDemandGeneration
- */
-
 /** @type {ExportMap} */
 const EMPTY_MAP = new Map();
 /** @type {UnusedExports} */
@@ -64,13 +58,13 @@ class HarmonyExportInitFragment extends InitFragment {
 	 * @param {string} exportsArgument the exports identifier
 	 * @param {ExportMap} exportMap mapping from used name to exposed variable name
 	 * @param {UnusedExports} unusedExports list of unused export names
-	 * @param {OnDemandGeneration=} onDemand offered the call instead of emitting it
+	 * @param {boolean} onDemand leave the call out of the source and hand it over in the code generation data (see `KnownMeta.onDemandExports`)
 	 */
 	constructor(
 		exportsArgument,
 		exportMap = EMPTY_MAP,
 		unusedExports = EMPTY_SET,
-		onDemand = undefined
+		onDemand = false
 	) {
 		super(undefined, InitFragment.STAGE_HARMONY_EXPORTS, 1, "harmony-exports");
 		/** @type {string} */
@@ -79,7 +73,7 @@ class HarmonyExportInitFragment extends InitFragment {
 		this.exportMap = exportMap;
 		/** @type {UnusedExports} */
 		this.unusedExports = unusedExports;
-		/** @type {OnDemandGeneration | undefined} */
+		/** @type {boolean} */
 		this.onDemand = onDemand;
 
 		this._generated = false;
@@ -138,8 +132,8 @@ class HarmonyExportInitFragment extends InitFragment {
 		/** @type {undefined | UnusedExports} */
 		let unusedExports;
 		let unusedExportsOwned = false;
-		/** @type {OnDemandGeneration=} */
-		let onDemand;
+		/** @type {boolean} */
+		let onDemand = false;
 
 		for (const fragment of fragments) {
 			if (fragment.exportMap.size !== 0) {
@@ -227,7 +221,7 @@ class HarmonyExportInitFragment extends InitFragment {
 	getContent(context) {
 		this._generate(context);
 
-		const { runtimeRequirements } = context;
+		const { runtimeRequirements, getData } = context;
 		const unusedPart =
 			this.unusedExports.size > 1
 				? `/* unused harmony exports ${joinIterableWithComma(
@@ -248,7 +242,13 @@ class HarmonyExportInitFragment extends InitFragment {
 			}(${this.exportsArgument}, {${this._defsGetter.join(
 				","
 			)}\n/* harmony export */ });\n`;
-			if (this.onDemand !== undefined && this.onDemand(definePart, false)) {
+			if (this.onDemand && getData !== undefined) {
+				const data = getData();
+				const before = data.get("exportsSource");
+				data.set(
+					"exportsSource",
+					before ? `${before}${definePart}` : definePart
+				);
 				definePart = "";
 			}
 		}
@@ -261,7 +261,7 @@ class HarmonyExportInitFragment extends InitFragment {
 	 * @param {GenerateContext} context context
 	 * @returns {string | Source | undefined} the source code that will be included at the end of the module
 	 */
-	getEndContent({ runtimeRequirements }) {
+	getEndContent({ runtimeRequirements, getData }) {
 		let definePart = "";
 
 		if (this._defsValue && this._defsValue.length) {
@@ -272,14 +272,21 @@ class HarmonyExportInitFragment extends InitFragment {
 			// Only this fragment emits the array form, so the runtime helper drops the
 			// branch reading it unless this asks for it.
 			runtimeRequirements.add(RuntimeGlobals.definePropertyGettersFromArray);
-			const definition = `/* harmony export */ ${
+			definePart = `/* harmony export */ ${
 				RuntimeGlobals.definePropertyGetters
 			}(${this.exportsArgument}, [${this._defsValue.join(",")}\n/* harmony export */ ]);\n`;
 
-			definePart =
-				this.onDemand !== undefined && this.onDemand(definition, true)
-					? definePart
-					: `\n${definition}`;
+			if (this.onDemand && getData !== undefined) {
+				const data = getData();
+				const before = data.get("exportsBindingSource");
+				data.set(
+					"exportsBindingSource",
+					before ? `${before}${definePart}` : definePart
+				);
+				definePart = "";
+			} else {
+				definePart = `\n${definePart}`;
+			}
 		}
 
 		return definePart;

package/lib/dependencies/HarmonyExportSpecifierDependency.js

@@ -8,7 +8,6 @@
 const Dependency = require("../Dependency");
 const { InlinedUsedName } = require("../optimize/InlineExports");
 const makeSerializable = require("../util/makeSerializable");
-const memoize = require("../util/memoize");
 const HarmonyExportInitFragment = require("./HarmonyExportInitFragment");
 
 const { ExportBindingType } = HarmonyExportInitFragment;
@@ -30,11 +29,6 @@ const NullDependency = require("./NullDependency");
  * } from "../javascript/JavascriptModule"
  */
 
-// Required here rather than at the top: the plugin reaches back into the dependencies.
-const getJavascriptModulesPlugin = memoize(() =>
-	require("../javascript/JavascriptModulesPlugin")
-);
-
 class HarmonyExportSpecifierDependency extends NullDependency {
 	/**
 	 * Creates an instance of HarmonyExportSpecifierDependency.
@@ -149,14 +143,7 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 	apply(
 		dependency,
 		source,
-		{
-			module,
-			moduleGraph,
-			initFragments,
-			runtime,
-			runtimeTemplate,
-			concatenationScope
-		}
+		{ module, moduleGraph, initFragments, runtime, concatenationScope }
 	) {
 		const dep = /** @type {HarmonyExportSpecifierDependency} */ (dependency);
 		// a wrapped module's bindings stay inside the wrapper, not in the shared scope
@@ -187,20 +174,12 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 			/** @type {import("../Module").BuildInfo} */ (module.buildInfo)
 				.isCircular === false;
 
-		// A library exporting the same bindings natively reads none of them back off the
-		// exports object, so it takes the call over and emits it only where wrapped.
-		const hooks = getJavascriptModulesPlugin().getCompilationHooks(
-			runtimeTemplate.compilation
-		);
-		const onDemand = hooks.onDemandExportsGeneration.isUsed()
-			? (/** @type {string} */ definition, /** @type {boolean} */ placeAtEnd) =>
-					hooks.onDemandExportsGeneration.call(
-						module,
-						runtime,
-						definition,
-						placeAtEnd
-					) === true
-			: undefined;
+		const meta = moduleGraph.getMetaIfExisting(module);
+
+		const onDemand =
+			!concatenationScope &&
+			meta !== undefined &&
+			meta.onDemandExports === true;
 
 		/** @type {ExportMap} */
 		const map = new Map();