@depup/webpack 5.109.0-depup.0 → 5.109.2-depup.0

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/CommonJsFullRequireDependency.js

@@ -9,6 +9,7 @@ const Template = require("../Template");
 const { equals } = require("../util/ArrayHelpers");
 const { getTrimmedIdsAndRange } = require("../util/chainedImports");
 const makeSerializable = require("../util/makeSerializable");
+const memoize = require("../util/memoize");
 const { propertyAccess } = require("../util/property");
 const {
 	ESM_MODULE_EXPORTS_NAME,
@@ -19,6 +20,7 @@ const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
 /** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
@@ -26,8 +28,11 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("../util/chainedImports").IdRanges} IdRanges */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[ExportInfoName[], IdRanges | undefined, boolean, undefined | boolean]>} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[ExportInfoName[], IdRanges | undefined, boolean, undefined | boolean]>} ObjectSerializerContext */
+/** @typedef {import("./HarmonyImportGuard").DependencyGuard} DependencyGuard */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[ExportInfoName[], IdRanges | undefined, boolean, undefined | boolean, DependencyGuard[] | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[ExportInfoName[], IdRanges | undefined, boolean, undefined | boolean, DependencyGuard[] | undefined]>} ObjectSerializerContext */
+
+const getHarmonyImportGuard = memoize(() => require("./HarmonyImportGuard"));
 
 class CommonJsFullRequireDependency extends ModuleDependency {
 	/**
@@ -53,6 +58,20 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 		this.call = false;
 		/** @type {undefined | boolean} */
 		this.asiSafe = undefined;
+		/** @type {DependencyGuard[] | undefined} */
+		this.branchGuards = undefined;
+	}
+
+	/**
+	 * Returns function to determine if the connection is active.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		const guards = this.branchGuards;
+		if (guards === undefined) return null;
+		return (connection, runtime) =>
+			!getHarmonyImportGuard().isDeadByGuards(guards, moduleGraph, runtime);
 	}
 
 	/**
@@ -92,7 +111,8 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 			.write(this.names)
 			.write(this.idRanges)
 			.write(this.call)
-			.write(this.asiSafe);
+			.write(this.asiSafe)
+			.write(this.branchGuards);
 		super.serialize(context);
 	}
 
@@ -108,7 +128,9 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 		this.call = c2.read();
 		const c3 = c2.rest;
 		this.asiSafe = c3.read();
-		super.deserialize(c3.rest);
+		const c4 = c3.rest;
+		this.branchGuards = c4.read();
+		super.deserialize(c4.rest);
 	}
 
 	get type() {
@@ -137,6 +159,13 @@ CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemp
 	) {
 		const dep = /** @type {CommonJsFullRequireDependency} */ (dependency);
 		if (!dep.range) return;
+		const connection = moduleGraph.getConnection(dep);
+		// Dead branch: module is excluded and has no id; code is never executed.
+		if (connection && !connection.isTargetActive(runtime)) {
+			// Replaces the whole member chain, so no property access is left dangling
+			source.replace(dep.range[0], dep.range[1] - 1, "null /* dead branch */");
+			return;
+		}
 		const importedModule = moduleGraph.getModule(dep);
 		let requireExpr = runtimeTemplate.moduleExports({
 			module: importedModule,

package/lib/dependencies/CommonJsImportsParserPlugin.js

@@ -642,6 +642,7 @@ class CommonJsImportsParserPlugin {
 				dep.optional = Boolean(parser.scope.inTry);
 				dep.loc = parser.getLocation(expr);
 				parser.state.current.addDependency(dep);
+				getHarmonyImportGuard().attachDependencyGuards(parser, dep);
 				return true;
 			}
 		};
@@ -680,6 +681,7 @@ class CommonJsImportsParserPlugin {
 				dep.optional = Boolean(parser.scope.inTry);
 				dep.loc = parser.getLocation(expr.callee);
 				parser.state.current.addDependency(dep);
+				getHarmonyImportGuard().attachDependencyGuards(parser, dep);
 				parser.walkExpressions(expr.arguments);
 				return true;
 			}

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/HarmonyImportGuard.js

@@ -14,6 +14,7 @@ const memoize = require("../util/memoize");
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./CommonJsFullRequireDependency")} CommonJsFullRequireDependency */
 /** @typedef {import("./CommonJsRequireDependency")} CommonJsRequireDependency */
 /** @typedef {import("./HarmonyEvaluatedImportSpecifierDependency")} HarmonyEvaluatedImportSpecifierDependency */
 /** @typedef {import("./HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
@@ -29,7 +30,7 @@ const memoize = require("../util/memoize");
 /** @typedef {["&&" | "||" | "??", GuardFormula, GuardFormula]} GuardLogical */
 /** @typedef {GuardAtom | GuardPresenceAtom | GuardUnknown | GuardNot | GuardLogical} GuardFormula */
 /** @typedef {{ formula: GuardFormula, value: boolean }} DependencyGuard branch guard: the dependency is live only when the formula evaluates to `value` */
-/** @typedef {HarmonyImportSpecifierDependency | CommonJsRequireDependency | ImportDependency} GuardableDependency */
+/** @typedef {HarmonyImportSpecifierDependency | CommonJsRequireDependency | CommonJsFullRequireDependency | ImportDependency} GuardableDependency */
 
 /**
  * A guard frame pushed onto `parser.state.guardStack` for the duration of one

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/esm/ModuleChunkLoadingRuntimeModule.js

@@ -25,11 +25,21 @@ const { getUndoPath } = require("../util/identifier");
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 
+const createCompilationHooks = () => ({
+	/**
+	 * @type {SyncWaterfallHook<[string, Chunk]>}
+	 * @since 5.41.0
+	 */
+	linkPreload: new SyncWaterfallHook(["source", "chunk"]),
+	/**
+	 * @type {SyncWaterfallHook<[string, Chunk]>}
+	 * @since 5.41.0
+	 */
+	linkPrefetch: new SyncWaterfallHook(["source", "chunk"])
+});
+
 /**
- * Defines the jsonp compilation plugin hooks type used by this module.
- * @typedef {object} JsonpCompilationPluginHooks
- * @property {SyncWaterfallHook<[string, Chunk]>} linkPreload
- * @property {SyncWaterfallHook<[string, Chunk]>} linkPrefetch
+ * @typedef {ReturnType<typeof createCompilationHooks>} JsonpCompilationPluginHooks
  */
 
 class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
@@ -438,11 +448,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 }
 
 ModuleChunkLoadingRuntimeModule.getCompilationHooks = createHooksRegistry(
-	() =>
-		/** @type {JsonpCompilationPluginHooks} */ ({
-			linkPreload: new SyncWaterfallHook(["source", "chunk"]),
-			linkPrefetch: new SyncWaterfallHook(["source", "chunk"])
-		})
+	createCompilationHooks
 );
 
 module.exports = ModuleChunkLoadingRuntimeModule;

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);

package/lib/html/HtmlModulesPlugin.js

@@ -72,12 +72,36 @@ const { escapeAttribute } = require("./syntax");
  * @property {boolean=} remove set true to delete the whole element
  */
 /** @typedef {{ outputName: string, html: string }} HtmlTransformTagsContext */
+
+const createCompilationHooks = () => ({
+	/**
+	 * Called with the list of extra tags to inject into each page (initially empty) plus the current HTML; push `HtmlTagDescriptor`s and return the list — webpack serializes and places them by `injectTo`. A structured alternative to the string-level `transformHtml` for adding tags; runs before CSP so injected inline tags are hashed.
+	 * @type {AsyncSeriesWaterfallHook<[HtmlTagDescriptor[], HtmlInjectTagsContext]>}
+	 * @since 5.109.0
+	 */
+	injectTags: new AsyncSeriesWaterfallHook(["tags", "context"]),
+	/**
+	 * Called with the page's `<script>`/`<link>`/`<style>`/`<meta>` tags (webpack's own and any injected) as mutable descriptors; mutate `attrs` (add a `nonce`/`data-*`, switch `defer`↔`async`, …), set `remove: true`, or change `injectTo` to move a tag between `<head>` and `<body>`, and webpack rewrites the changed tags. Add new tags with `injectTags` instead.
+	 * @type {AsyncSeriesHook<[HtmlMutableTag[], HtmlTransformTagsContext]>}
+	 * @since 5.109.0
+	 */
+	transformTags: new AsyncSeriesHook(["tags", "context"]),
+	/**
+	 * Called with each emitted page's final HTML (all sentinels resolved) just before it is written; return the (possibly transformed) HTML — e.g. to minify, inject a CSP meta, or rewrite tags.
+	 * @type {AsyncSeriesWaterfallHook<[string, HtmlTransformHtmlContext]>}
+	 * @since 5.109.0
+	 */
+	transformHtml: new AsyncSeriesWaterfallHook(["html", "context"]),
+	/**
+	 * Called once each page's HTML asset has been finalized — a post-emit notification (nothing to return).
+	 * @type {AsyncSeriesHook<[HtmlEmittedContext]>}
+	 * @since 5.109.0
+	 */
+	htmlEmitted: new AsyncSeriesHook(["context"])
+});
+
 /**
- * @typedef {object} HtmlCompilationHooks
- * @property {AsyncSeriesWaterfallHook<[HtmlTagDescriptor[], HtmlInjectTagsContext]>} injectTags called with the list of extra tags to inject into each page (initially empty) plus the current HTML; push `HtmlTagDescriptor`s and return the list — webpack serializes and places them by `injectTo`. A structured alternative to the string-level `transformHtml` for adding tags; runs before CSP so injected inline tags are hashed
- * @property {AsyncSeriesHook<[HtmlMutableTag[], HtmlTransformTagsContext]>} transformTags called with the page's `<script>`/`<link>`/`<style>`/`<meta>` tags (webpack's own and any injected) as mutable descriptors; mutate `attrs` (add a `nonce`/`data-*`, switch `defer`↔`async`, …), set `remove: true`, or change `injectTo` to move a tag between `<head>` and `<body>`, and webpack rewrites the changed tags. Add new tags with `injectTags` instead
- * @property {AsyncSeriesWaterfallHook<[string, HtmlTransformHtmlContext]>} transformHtml called with each emitted page's final HTML (all sentinels resolved) just before it is written; return the (possibly transformed) HTML — e.g. to minify, inject a CSP meta, or rewrite tags
- * @property {AsyncSeriesHook<[HtmlEmittedContext]>} htmlEmitted called once each page's HTML asset has been finalized — a post-emit notification (nothing to return)
+ * @typedef {ReturnType<typeof createCompilationHooks>} HtmlCompilationHooks
  */
 
 const PLUGIN_NAME = "HtmlModulesPlugin";
@@ -1099,13 +1123,7 @@ class HtmlModulesPlugin {
  * @returns {HtmlCompilationHooks} the hooks
  */
 HtmlModulesPlugin.getCompilationHooks = createHooksRegistry(
-	() =>
-		/** @type {HtmlCompilationHooks} */ ({
-			injectTags: new AsyncSeriesWaterfallHook(["tags", "context"]),
-			transformTags: new AsyncSeriesHook(["tags", "context"]),
-			transformHtml: new AsyncSeriesWaterfallHook(["html", "context"]),
-			htmlEmitted: new AsyncSeriesHook(["context"])
-		})
+	createCompilationHooks
 );
 
 module.exports = HtmlModulesPlugin;