@depup/webpack 5.111.1-depup.1 → 5.112.0-depup.0

package/lib/html/HtmlModulesPlugin.js

@@ -4,23 +4,20 @@
 
 "use strict";
 
-const { basename, extname } = require("path");
 const { pathToFileURL } = require("url");
 const { AsyncSeriesHook, AsyncSeriesWaterfallHook } = require("tapable");
 const { RawSource } = require("webpack-sources");
 const Compilation = require("../Compilation");
-const EntryOptionPlugin = require("../EntryOptionPlugin");
-const EntryPlugin = require("../EntryPlugin");
-const HotUpdateChunk = require("../HotUpdateChunk");
-const { HTML_TYPE } = require("../ModuleSourceTypeConstants");
-const { HTML_MODULE_TYPE } = require("../ModuleTypeConstants");
-const NormalModule = require("../NormalModule");
-const { toTemplateSourceFileName } = require("../TemplatedPathPlugin");
-const ConstDependency = require("../dependencies/ConstDependency");
-const StaticExportsDependency = require("../dependencies/StaticExportsDependency");
+const ConstDependency = require("../dependencies/core/ConstDependency");
+const StaticExportsDependency = require("../dependencies/core/StaticExportsDependency");
+const EntryOptionPlugin = require("../entry/EntryOptionPlugin");
+const EntryPlugin = require("../entry/EntryPlugin");
 const WebpackError = require("../errors/WebpackError");
 const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
-const ConcatenatedModule = require("../optimize/ConcatenatedModule");
+const { HTML_TYPE } = require("../module/ModuleSourceTypeConstants");
+const { HTML_MODULE_TYPE } = require("../module/ModuleTypeConstants");
+const NormalModule = require("../module/NormalModule");
+const { toTemplateSourceFileName } = require("../template/TemplatedPathPlugin");
 const {
 	compareModulesByFullName,
 	compareModulesByIdentifier
@@ -28,9 +25,9 @@ const {
 const createHash = require("../util/createHash");
 const createHooksRegistry = require("../util/createHooksRegistry");
 const {
+	getRequestBaseName,
 	getUndoPath,
-	makePathsRelative,
-	parseResource
+	makePathsRelative
 } = require("../util/identifier");
 const implicitTypeLoaderFallback = require("../util/implicitTypeLoaderFallback");
 const lazyModule = require("../util/lazyModule");
@@ -45,7 +42,7 @@ const HtmlModule = require("./HtmlModule");
 
 const getMimeTypes = memoize(() => require("../util/mimeTypes"));
 
-const getHtmlSyntax = memoize(() => require("./syntax"));
+const getHtmlSyntax = memoize(() => require("./syntax-parser"));
 
 // Lazy: this plugin is applied on every build (`experiments.html` defaults on),
 // but the HTML parser and tokenizer are only reached once HTML is in the graph.
@@ -73,14 +70,14 @@ const getCssModulesPlugin = memoize(() => require("../css/CssModulesPlugin"));
 /** @typedef {import("../../declarations/WebpackOptions").OutputHtmlOptions["favicon"]} FaviconOption */
 /** @typedef {import("../../declarations/WebpackOptions").OutputHtmlOptions["manifest"]} ManifestOption */
 /** @typedef {Exclude<HtmlFaviconIcon, string>} FaviconIcon */
-/** @import Chunk, { ChunkFilenameTemplate } from "../Chunk" */
-/** @import ChunkGraph from "../ChunkGraph" */
+/** @import Chunk, { ChunkFilenameTemplate } from "../graph/Chunk" */
+/** @import ChunkGraph from "../graph/ChunkGraph" */
 /** @import Compiler from "../Compiler" */
-/** @import Module from "../Module" */
+/** @import Module from "../module/Module" */
 /** @typedef {import("../Compilation").EntryData} EntryData */
 /** @import { HtmlModuleBuildInfo } from "./HtmlModule" */
 /** @import HtmlParser from "./HtmlParser" */
-/** @typedef {{ request: string, entryName: string, index: number, type: "script" | "script-module" | "modulepreload" | "stylesheet" | "html" | "preload" | "prefetch", css?: boolean }} HtmlEntryInfo */
+/** @typedef {{ request: string, entryName: string, index: number, type: "script" | "script-module" | "modulepreload" | "stylesheet" | "html" | "preload" | "prefetch", css?: boolean, chunkName?: string }} HtmlEntryInfo */
 /**
  * What one extracted entry needs to be named. Recorded in page order once
  * every page is built, and resolved to filenames once chunks exist.
@@ -114,6 +111,7 @@ const getCssModulesPlugin = memoize(() => require("../css/CssModulesPlugin"));
  * @property {boolean=} remove set true to delete the whole element
  */
 /** @typedef {{ outputName: string, html: string }} HtmlTransformTagsContext */
+/** @typedef {{ context: string, request: string, name: string, index: number, dependOn: string[] | undefined, page: boolean }} HtmlEntrySpec */
 
 const createCompilationHooks = () => ({
 	/**
@@ -289,29 +287,19 @@ const getPageOnlyEntry = (compilation, module) => {
 	return configured === undefined ? entry : undefined;
 };
 
-/**
- * The basename a tag's url lends to the entry it becomes, so
- * `src="./my-script.js"` emits `my-script.js`. Undefined for an inline body.
- * @param {string} request the tag's request
- * @returns {string | undefined} the basename, when the url carries one
- */
-const getRequestBaseName = (request) => {
-	// An inline `<script>` body is a `data:` request webpack writes itself.
-	if (request.startsWith("data:")) return undefined;
-	const { path: file } = parseResource(request);
-	return basename(file, extname(file)) || undefined;
-};
-
 /**
  * Claims `base`, numbering it while something else already emits under that
  * name, so two tags sharing a basename stay distinct.
  * @param {string} base preferred name
  * @param {Set<string>} taken names this kind of output already emits under
+ * @param {Map<string, number>} next per base, the number every lower one is taken up to
  * @returns {string} the claimed name
  */
-const claimName = (base, taken) => {
-	let name = base;
-	for (let index = 1; taken.has(name); index++) name = `${base}${index}`;
+const claimName = (base, taken, next) => {
+	let index = next.get(base) || 0;
+	let name = index === 0 ? base : `${base}${index}`;
+	while (taken.has(name)) name = `${base}${++index}`;
+	next.set(base, index + 1);
 	taken.add(name);
 	return name;
 };
@@ -417,7 +405,7 @@ const collectHtmlEntryRequests = (name, entries) => {
 
 /**
  * @param {string} name definition name in `schemas/WebpackOptions.json`
- * @returns {EXPECTED_OBJECT} a schema referencing `#/definitions/<name>`
+ * @returns {{ oneOf: [{ $ref: string }], definitions: import("../../schemas/WebpackOptions.json")["definitions"] }} a schema referencing `#/definitions/<name>`
  */
 const getSchema = (name) => {
 	const { definitions } = require("../../schemas/WebpackOptions.json");
@@ -465,16 +453,16 @@ class HtmlModulesPlugin {
 	 * Filename template for an extracted HTML page: `output.htmlFilename` for
 	 * initial chunks, `output.htmlChunkFilename` otherwise — the HTML counterpart
 	 * of `CssModulesPlugin.getChunkFilenameTemplate`.
-	 * @param {import("../Chunk")} chunk chunk
+	 * @param {import("../graph/Chunk")} chunk chunk
 	 * @param {OutputOptions} outputOptions output options
-	 * @returns {import("../Chunk").ChunkFilenameTemplate} used filename template
+	 * @returns {import("../graph/Chunk").ChunkFilenameTemplate} used filename template
 	 */
 	static getChunkFilenameTemplate(chunk, outputOptions) {
 		return chunk.canBeInitial()
-			? /** @type {import("../Chunk").ChunkFilenameTemplate} */ (
+			? /** @type {import("../graph/Chunk").ChunkFilenameTemplate} */ (
 					outputOptions.htmlFilename
 				)
-			: /** @type {import("../Chunk").ChunkFilenameTemplate} */ (
+			: /** @type {import("../graph/Chunk").ChunkFilenameTemplate} */ (
 					outputOptions.htmlChunkFilename
 				);
 	}
@@ -626,11 +614,11 @@ class HtmlModulesPlugin {
 		// Per-compilation state: the HTML modules seen during make, so `finishMake`
 		// creates their entries without scanning the module graph, plus the
 		// stylesheet entry names and each emitted page's html options.
-		/** @type {WeakMap<import("../Compilation"), { htmlModules: Set<Module>, stylesheetEntries: Set<string>, pendingNames: Map<string, PendingName>, htmlAssetOptions: Map<string, OutputHtmlOptions> }>} */
+		/** @type {WeakMap<import("../Compilation"), { htmlModules: Set<Module>, stylesheetEntries: Set<string>, pendingNames: Map<string, PendingName>, htmlAssetOptions: Map<string, OutputHtmlOptions>, pageNames: Map<string, string> }>} */
 		const compilationState = new WeakMap();
 		/**
 		 * @param {import("../Compilation")} compilation compilation
-		 * @returns {{ htmlModules: Set<Module>, stylesheetEntries: Set<string>, pendingNames: Map<string, PendingName>, htmlAssetOptions: Map<string, OutputHtmlOptions> }} per-compilation state
+		 * @returns {{ htmlModules: Set<Module>, stylesheetEntries: Set<string>, pendingNames: Map<string, PendingName>, htmlAssetOptions: Map<string, OutputHtmlOptions>, pageNames: Map<string, string> }} per-compilation state
 		 */
 		const getState = (compilation) => {
 			let state = compilationState.get(compilation);
@@ -639,14 +627,15 @@ class HtmlModulesPlugin {
 					htmlModules: new Set(),
 					stylesheetEntries: new Set(),
 					pendingNames: new Map(),
-					htmlAssetOptions: new Map()
+					htmlAssetOptions: new Map(),
+					pageNames: new Map()
 				};
 				compilationState.set(compilation, state);
 			}
 			return state;
 		};
 		compiler.hooks.finishMake.tapAsync(PLUGIN_NAME, (compilation, callback) => {
-			const { htmlModules, stylesheetEntries, pendingNames } =
+			const { htmlModules, stylesheetEntries, pendingNames, pageNames } =
 				getState(compilation);
 			/** @type {Set<string>} */
 			const extractedNames = new Set();
@@ -658,22 +647,29 @@ class HtmlModulesPlugin {
 			// Collect the entries an HTML module asks for. Only the script chains share
 			// a runtime, through a leader-only `dependOn`; chaining a CSS or page entry
 			// into a JS leader would mix unrelated outputs into one chunk.
-			/** @type {(module: Module) => { context: string, request: string, name: string, dependOn: string[] | undefined }[]} */
+			/** @type {(module: Module) => HtmlEntrySpec[]} */
 			const collectEntrySpecs = (module) => {
 				const { htmlEntries } = /** @type {HtmlModuleBuildInfo} */ (
 					module.buildInfo
 				);
 				if (!htmlEntries) return [];
 				const context = /** @type {string} */ (module.context);
+				/** @type {HtmlEntrySpec[]} */
 				const specs = [];
+				/** @type {Set<string>} */
+				const specNames = new Set();
 				for (const [groupKind, group] of Object.entries(htmlEntries)) {
 					const isChainGroup =
 						groupKind === "script" || groupKind === "script-module";
 					/** @type {string | undefined} */
 					let leaderName;
 					for (const entry of group) {
+						// A run's tags are added under one entry name and the first of
+						// them carries its options, so a later one re-decides nothing.
 						const dependOn =
-							isChainGroup && leaderName !== undefined
+							isChainGroup &&
+							leaderName !== undefined &&
+							!specNames.has(entry.entryName)
 								? [leaderName]
 								: undefined;
 						if (isChainGroup && leaderName === undefined) {
@@ -685,14 +681,39 @@ class HtmlModulesPlugin {
 							stylesheetEntries.add(entry.entryName);
 						}
 						extractedNames.add(entry.entryName);
+						specNames.add(entry.entryName);
 						specs.push({
 							context,
 							request: entry.request,
 							name: entry.entryName,
-							dependOn
+							index: entry.index,
+							dependOn,
+							page: groupKind === "html"
 						});
 					}
 				}
+				// A run is collected group by group, so its members are put back into
+				// the document's order — an entry's array is executed in it.
+				/** @type {Map<string, number[]>} */
+				const positionsByName = new Map();
+				for (let position = 0; position < specs.length; position++) {
+					const { name } = specs[position];
+					const positions = positionsByName.get(name);
+					if (positions === undefined) {
+						positionsByName.set(name, [position]);
+					} else {
+						positions.push(position);
+					}
+				}
+				for (const positions of positionsByName.values()) {
+					if (positions.length < 2) continue;
+					const ordered = positions
+						.map((position) => specs[position])
+						.sort((a, b) => a.index - b.index);
+					for (let i = 0; i < positions.length; i++) {
+						specs[positions[i]] = ordered[i];
+					}
+				}
 				return specs;
 			};
 
@@ -737,13 +758,29 @@ class HtmlModulesPlugin {
 					}
 				}
 				ordered.sort((a, b) => a.index - b.index);
+				// An inline body has no url to be named after, so its page lends the
+				// name — and a `data:` page has none either, so its holder is walked to.
+				/** @type {string | undefined} */
+				let pageBase;
+				/** @type {Module | null | undefined} */
+				let holder = module;
+				while (pageBase === undefined && holder) {
+					const holderResource = /** @type {NormalModule} */ (holder).resource;
+					if (typeof holderResource === "string") {
+						pageBase = getRequestBaseName(holderResource);
+					}
+					holder = compilation.moduleGraph.getIssuer(holder);
+				}
 				for (const entry of ordered) {
-					// An inline `<script>` body has no url to be named after, so it
-					// keeps the name of its own entry, page hash and tag index.
+					// A name the page or `module.parser.html.chunkName` asked for is what
+					// the file is called too; otherwise the tag's url lends its basename.
 					const base =
 						wrapsEntry && namedEntry
 							? namedEntry.name
-							: getRequestBaseName(entry.request) || entry.entryName;
+							: entry.chunkName ||
+								getRequestBaseName(entry.request) ||
+								pageBase ||
+								entry.entryName;
 					pendingNames.set(entry.entryName, {
 						base,
 						jsTemplate,
@@ -752,6 +789,11 @@ class HtmlModulesPlugin {
 				}
 				links.sort((a, b) => a.index - b.index);
 				for (const link of links) {
+					// A linked page is named after its own path; a name the page asked
+					// for replaces that, and the link to it is rewritten either way.
+					if (link.chunkName && !contestedPageNames.has(link.entryName)) {
+						pageNames.set(link.entryName, link.chunkName);
+					}
 					const page = linkedPages.get(link.entryName);
 					if (page) recordNames(page, seen);
 				}
@@ -759,7 +801,7 @@ class HtmlModulesPlugin {
 
 			// Push one collected reference as a compilation entry; resolves with
 			// the built entry module.
-			/** @type {(spec: { context: string, request: string, name: string, dependOn: string[] | undefined }) => Promise<Module | null>} */
+			/** @type {(spec: HtmlEntrySpec) => Promise<Module | null>} */
 			const addEntry = (spec) =>
 				new Promise((resolve, reject) => {
 					compilation.addEntry(
@@ -777,10 +819,32 @@ class HtmlModulesPlugin {
 					);
 				});
 
+			// What each page name was claimed for, so a second page asking for a
+			// taken one is refused rather than appended to the entry holding it.
+			/** @type {Map<string, string>} */
+			const pageRequests = new Map();
+			// Names a second page asked for and did not get, so it keeps the one its
+			// own path lends and emits beside the page holding the name.
+			/** @type {Set<string>} */
+			const contestedPageNames = new Set();
+			/**
+			 * @param {string} name the name two things ask for
+			 * @param {string} taken what holds it
+			 * @param {string} request what asked for it
+			 */
+			const reportNameTaken = (name, taken, request) => {
+				contestedPageNames.add(name);
+				compilation.errors.push(
+					new WebpackError(
+						`The name "${name}" is asked for by ${request} and is already taken by ${taken}. A page is emitted as its name, so give one of them another.`
+					)
+				);
+			};
+
 			// Create one HTML module's entries. A `type: "html"` link is itself an
 			// HTML entry, so after it builds we recurse into it — the same handling
 			// every HTML entry already gets. `processed` guards diamonds and cycles.
-			/** @type {WeakSet<import("../Module")>} */
+			/** @type {WeakSet<import("../module/Module")>} */
 			const processed = new WeakSet();
 			/** @type {(module: Module) => Promise<void>} */
 			const processEntry = async (module) => {
@@ -788,8 +852,33 @@ class HtmlModulesPlugin {
 				processed.add(module);
 				await Promise.all(
 					collectEntrySpecs(module).map(async (spec) => {
+						if (spec.page) {
+							const claimed = pageRequests.get(spec.name);
+							// The page holding the name is already an entry of its own:
+							// a second link to it adds nothing, a second page cannot have it.
+							if (claimed !== undefined) {
+								if (claimed !== spec.request) {
+									reportNameTaken(spec.name, claimed, spec.request);
+								}
+								return;
+							}
+							pageRequests.set(spec.name, spec.request);
+						}
 						const entryModule = await addEntry(spec);
-						if (entryModule && entryModule.type === HTML_MODULE_TYPE) {
+						// A page entry webpack made for us holds that page alone; anything
+						// else in it named the same and would be emitted over.
+						if (spec.page) {
+							const entry = compilation.entries.get(spec.name);
+							if (entry && entry.dependencies.length !== 1) {
+								reportNameTaken(
+									spec.name,
+									`entry "${spec.name}"`,
+									spec.request
+								);
+								return;
+							}
+						}
+						if (entryModule && entryModule.is("html")) {
 							linkedPages.set(spec.name, entryModule);
 							await processEntry(entryModule);
 						}
@@ -814,7 +903,7 @@ class HtmlModulesPlugin {
 
 		// `"auto"` marks implicit enablement, the one case where loaders win over
 		// the built-in type — see `applyExperimentsDefaults`.
-		// TODO webpack 6: html defaults to `true`, drop this implicit-only fallback.
+		// TODO in the next major release: html defaults to `true`, drop this implicit-only fallback.
 		const implicitlyEnabled = compiler.options.experiments.html === "auto";
 		compiler.hooks.compilation.tap(
 			PLUGIN_NAME,
@@ -831,11 +920,11 @@ class HtmlModulesPlugin {
 				/**
 				 * Records HTML modules as they are built or restored, so `finishMake`
 				 * creates their entries without scanning the whole module graph.
-				 * @param {import("../Module")} module built or restored module
+				 * @param {import("../module/Module")} module built or restored module
 				 * @returns {void}
 				 */
 				const trackHtmlModule = (module) => {
-					if (module.type !== HTML_MODULE_TYPE) return;
+					if (!module.is("html")) return;
 					// enabled here, not on the compilation hook: an integrity build
 					// with no html module must not load the generator
 					if (anyIntegrity) {
@@ -985,6 +1074,10 @@ class HtmlModulesPlugin {
 					// documents' order rather than their builds'.
 					const takenJsNames = new Set(compilation.entries.keys());
 					const takenCssNames = new Set(takenJsNames);
+					/** @type {Map<string, number>} */
+					const nextJsIndex = new Map();
+					/** @type {Map<string, number>} */
+					const nextCssIndex = new Map();
 					// An extracted entry emits nothing under its own synthetic name, so
 					// that name never stands in the way of the one its tag asks for.
 					for (const entryName of pendingNames.keys()) {
@@ -1012,7 +1105,7 @@ class HtmlModulesPlugin {
 							chunk.filenameTemplate = getEntryTemplate(
 								jsTemplate,
 								jsExtension,
-								claimName(base, takenJsNames)
+								claimName(base, takenJsNames, nextJsIndex)
 							);
 						}
 						// A `<script src>` whose chunk carries no CSS claims no CSS name, so
@@ -1026,7 +1119,7 @@ class HtmlModulesPlugin {
 						chunk.cssFilenameTemplate = getEntryTemplate(
 							outputOptions.cssFilename,
 							".css",
-							claimName(base, takenCssNames)
+							claimName(base, takenCssNames, nextCssIndex)
 						);
 					}
 				});
@@ -1046,11 +1139,11 @@ class HtmlModulesPlugin {
 				normalModuleFactory.hooks.prepareModuleType
 					.for(HTML_MODULE_TYPE)
 					.tap(PLUGIN_NAME, () => {
-						const HtmlSourceDependency = require("../dependencies/HtmlSourceDependency");
-						const HtmlEntryDependency = require("../dependencies/HtmlEntryDependency");
-						const HtmlInlineScriptDependency = require("../dependencies/HtmlInlineScriptDependency");
-						const HtmlInlineStyleDependency = require("../dependencies/HtmlInlineStyleDependency");
-						const HtmlInlineHtmlDependency = require("../dependencies/HtmlInlineHtmlDependency");
+						const HtmlSourceDependency = require("../dependencies/html/HtmlSourceDependency");
+						const HtmlEntryDependency = require("../dependencies/html/HtmlEntryDependency");
+						const HtmlInlineScriptDependency = require("../dependencies/html/HtmlInlineScriptDependency");
+						const HtmlInlineStyleDependency = require("../dependencies/html/HtmlInlineStyleDependency");
+						const HtmlInlineHtmlDependency = require("../dependencies/html/HtmlInlineHtmlDependency");
 
 						compilation.dependencyFactories.set(
 							HtmlSourceDependency,
@@ -1149,7 +1242,7 @@ class HtmlModulesPlugin {
 				NormalModule.getCompilationHooks(compilation).processResult.tap(
 					PLUGIN_NAME,
 					(result, module) => {
-						if (module.type === HTML_MODULE_TYPE) {
+						if (module.is("html")) {
 							const [source, ...rest] = removeBOMFromResult(result);
 							// Run here, where the returned source becomes the module's stored
 							// source, so the parser's dependency offsets and the generator's
@@ -1185,13 +1278,13 @@ class HtmlModulesPlugin {
 				 * content hash. Links to other pages stay sentinels, so a page's filename
 				 * never depends on the filenames of the pages it links to.
 				 * @param {NormalModule} module the page's html module
-				 * @param {import("../Chunk")} chunk chunk the page is emitted from
+				 * @param {import("../graph/Chunk")} chunk chunk the page is emitted from
 				 * @returns {{ resolvedContent: string, contentHash: string, filename: string, info: import("../Compilation").AssetInfo } | undefined} the page's emit, or `undefined` when it generates no html
 				 */
 				const computePageEmit = (module, chunk) => {
 					const { chunkGraph, outputOptions } = compilation;
 					const codeGenResult =
-						/** @type {import("../CodeGenerationResults")} */ (
+						/** @type {import("../module/CodeGenerationResults")} */ (
 							compilation.codeGenerationResults
 						).get(module, chunk.runtime);
 					const placeholderSource = codeGenResult.sources.get(HTML_TYPE);
@@ -1224,10 +1317,14 @@ class HtmlModulesPlugin {
 						resolvedSentinelHashCache.set(placeholderSource, cached);
 					}
 					const resource = module.getResource() || module.resource;
-					// Synthetic `output.html` entries are `data:text/html` modules with no
-					// real basename — name the file after the entry instead.
+					// A page is named after its own path, unless it asked for a name; a
+					// synthetic `output.html` entry has none, so its entry names it.
+					const requestedPageName = chunk.name
+						? getState(compilation).pageNames.get(chunk.name)
+						: undefined;
 					const sourceFilename =
-						resource.startsWith("data:text/html") && chunk.name
+						requestedPageName ||
+						(resource.startsWith("data:text/html") && chunk.name
 							? chunk.name
 							: toTemplateSourceFileName(
 									makePathsRelative(
@@ -1236,13 +1333,13 @@ class HtmlModulesPlugin {
 										compiler.root
 									).replace(/^\.\//, ""),
 									compilation
-								);
+								));
 					const filenameTemplate = HtmlModulesPlugin.getChunkFilenameTemplate(
 						chunk,
 						outputOptions
 					);
 					const { path: filename, info } = compilation.getPathWithInfo(
-						/** @type {import("../TemplatedPathPlugin").TemplatePath} */
+						/** @type {import("../template/TemplatedPathPlugin").TemplatePath} */
 						(filenameTemplate),
 						{
 							module,
@@ -1302,7 +1399,7 @@ class HtmlModulesPlugin {
 						// HMR's `HotUpdateChunk`s reach this hook but are not output chunks,
 						// so extracting `.html` for them would emit stray hot-update files.
 						// `CssModulesPlugin` early-returns for the same reason.
-						if (chunk instanceof HotUpdateChunk) return result;
+						if (chunk.isHotUpdate()) return result;
 						const { chunkGraph } = compilation;
 						const modules =
 							chunkGraph.getOrderedChunkModulesIterableBySourceType(
@@ -1490,11 +1587,10 @@ class HtmlModulesPlugin {
 		// Scope-hoisted HTML loses HTML_TYPE on the ConcatenatedModule, but its
 		// JS export can still carry unresolved sentinels that need this path.
 		for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-			if (module instanceof HtmlModule) return true;
-			if (module instanceof ConcatenatedModule) {
-				for (const inner of module.modules) {
-					if (inner instanceof HtmlModule) return true;
-				}
+			if (module.is("html")) return true;
+			if (module.getRootModule() === module) continue;
+			for (const inner of module.getSourceModules()) {
+				if (inner.is("html")) return true;
 			}
 		}
 		return false;