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

package/lib/html/HtmlParser.js

@@ -0,0 +1,1970 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const Parser = require("../Parser");
+const ConstDependency = require("../dependencies/ConstDependency");
+const HtmlEntryDependency = require("../dependencies/HtmlEntryDependency");
+const HtmlInlineHtmlDependency = require("../dependencies/HtmlInlineHtmlDependency");
+const HtmlInlineScriptDependency = require("../dependencies/HtmlInlineScriptDependency");
+const HtmlInlineStyleDependency = require("../dependencies/HtmlInlineStyleDependency");
+const HtmlSourceDependency = require("../dependencies/HtmlSourceDependency");
+const StaticExportsDependency = require("../dependencies/StaticExportsDependency");
+const CommentCompilationWarning = require("../errors/CommentCompilationWarning");
+const ModuleDependencyError = require("../errors/ModuleDependencyError");
+const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
+const WebpackError = require("../errors/WebpackError");
+const ResourceHintPlugin = require("../prefetch/ResourceHintPlugin");
+const parseResourceHintOptions = require("../prefetch/parseResourceHintOptions");
+const LazySet = require("../util/LazySet");
+const LocConverter = require("../util/LocConverter");
+const createHash = require("../util/createHash");
+const { contextify } = require("../util/identifier");
+const {
+	createMagicCommentContext,
+	parseMagicComment,
+	webpackCommentRegExp
+} = require("../util/magicComment");
+const {
+	NS_HTML,
+	NS_SVG,
+	NodeType,
+	SVG_TAG_ADJUST,
+	SourceProcessor,
+	decodeEntities,
+	escapeAttribute,
+	escapeText,
+	isAsciiWhitespace,
+	parseCssUrls,
+	parseMsapplicationTask,
+	parseSrc,
+	parseSrcset
+} = require("./syntax");
+
+/** @typedef {import("../../declarations/WebpackOptions").HtmlParserOptions} HtmlParserOptions */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Compilation").FileSystemDependencies} FileSystemDependencies */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+/** @typedef {import("./HtmlModule").HtmlModuleBuildInfo} HtmlModuleBuildInfo */
+
+/**
+ * @typedef {object} HtmlTemplateContext
+ * @property {Module} module the html module being transformed
+ * @property {string} resource absolute path of the module's resource
+ * @property {(dependency: string) => void} addDependency register a file (e.g. a template partial) as a build dependency so editing it triggers a rebuild
+ * @property {(dependency: string) => void} addContextDependency register a directory as a build dependency
+ * @property {(dependency: string) => void} addMissingDependency register a not-yet-existing path as a build dependency so creating it triggers a rebuild
+ * @property {(dependency: string) => void} addBuildDependency register a build dependency (e.g. a template engine config) so changing it invalidates the cache
+ * @property {(warning: Error | string) => void} emitWarning report a non-fatal warning on the module
+ * @property {(error: Error | string) => void} emitError report an error on the module
+ */
+/** @typedef {(source: string, context: HtmlTemplateContext) => string} HtmlTemplateFunction */
+
+/** @typedef {import("./syntax").ParsedSource} ParsedSource */
+
+// Cheap pre-filter for a `style="..."` attribute: only route it through the
+// CSS pipeline when it can hold a URL-bearing function (`url()` / `src()` /
+// `image()` / `image-set()`), otherwise the processed text equals the input.
+const STYLE_ATTR_URL_REGEXP = /url\(|src\(|image\(|image-set\(/i;
+
+// Cheap pre-filter for a `css-url` attribute value (an SVG presentation
+// attribute such as `fill`, `clip-path`, …): only tokenize values that can
+// hold a `url(...)` FuncIRI. Most are plain colors/keywords (`#fff`, `red`).
+const FUNC_IRI_URL_REGEXP = /url\(/i;
+
+// Cheap pre-filter for `<iframe srcdoc>` markup: only spin up a nested HTML
+// module when the document can reference an asset — via any attribute (`src=`,
+// `href=`, `style=`, …), a CSS `url(...)`, or a CSS `@import`. Pure
+// formatting/text markup (`<p>hi</p>`) rewrites to itself, so skip it.
+const SRCDOC_ASSET_REGEXP = /[=]|url\(|@import/i;
+
+// A URL carrying its own scheme (`https:`, `data:`, …) ignores the document
+// base per the URL spec, so `<base href>` never rewrites it.
+const ABSOLUTE_URL_SCHEME_REGEXP = /^[a-zA-Z][a-zA-Z\d+\-.]*:/;
+
+// a `charset=` declaration inside an `http-equiv="content-type"` content value
+const CHARSET_DECLARATION_REGEXP = /charset\s*=/i;
+
+/**
+ * @param {string} name meta name
+ * @param {string} content meta content
+ * @returns {string} meta tag
+ */
+const metaTag = (name, content) => {
+	// og: uses property=; all others (including twitter:) use name=
+	const attr = name.startsWith("og:")
+		? `property="${escapeAttribute(name)}"`
+		: `name="${escapeAttribute(name)}"`;
+	return `<meta ${attr} content="${escapeAttribute(content)}">`;
+};
+
+/**
+ * @param {string | { href: string, target?: string }} base base option
+ * @returns {string} base tag
+ */
+const baseTag = (base) => {
+	const href = typeof base === "string" ? base : base.href;
+	const targetAttr =
+		typeof base === "object" && base.target
+			? ` target="${escapeAttribute(base.target)}"`
+			: "";
+	return `<base href="${escapeAttribute(href)}"${targetAttr}>`;
+};
+
+/**
+ * Serializes every head tag an `output.html` options object asks for, in
+ * spec order: charset, base, meta tags, title. Used where a page is created
+ * from scratch (HtmlModulesPlugin's synthetic entry wrapper); authored pages
+ * instead merge the options against their existing tags during `parse` —
+ * existing tags win.
+ * @param {import("../../declarations/WebpackOptions").OutputHtmlOptions} opts html options
+ * @returns {string} head tags string
+ */
+const buildHeadTags = (opts) => {
+	let out = "";
+	const meta = opts.meta;
+	if (meta && meta.charset) {
+		out += `<meta charset="${escapeAttribute(meta.charset)}">`;
+	}
+	if (opts.base) out += baseTag(opts.base);
+	if (meta) {
+		for (const [name, content] of Object.entries(meta)) {
+			if (name === "charset") continue;
+			out += metaTag(name, content);
+		}
+	}
+	if (opts.title) {
+		out += `<title>${escapeText(opts.title)}</title>`;
+	}
+	return out;
+};
+
+// CSP/fetch attributes copied verbatim onto a synthesized sibling `<link>` /
+// `<script>` (`HtmlEntryDependency`). Fixed output order, independent of
+// source order.
+const COPYABLE_SIBLING_ATTRS = ["nonce", "crossorigin", "referrerpolicy"];
+
+const CC_QUOTATION = '"'.charCodeAt(0);
+const CC_APOSTROPHE = "'".charCodeAt(0);
+const CC_SLASH = "/".charCodeAt(0);
+
+/**
+ * Byte-exact source span of an attribute including the single leading
+ * whitespace (` name`, ` name=value`, ` name="value"`), mirroring the
+ * tokenizer's end-of-attribute rule (`valueEnd + 1` past the closing quote).
+ * @param {import("./syntax").HtmlPath} path walk path (used only for attribute-ref reads)
+ * @param {string} source HTML source
+ * @param {import("./syntax").HtmlAttributeRef} attr attribute ref
+ * @returns {string} the attribute's source slice
+ */
+const attrSourceSpan = (path, source, attr) => {
+	const valueStart = path.attributeValueStart(attr);
+	const valueEnd = path.attributeValueEnd(attr);
+	const end =
+		valueStart === -1
+			? path.attributeNameEnd(attr)
+			: source.charCodeAt(valueStart - 1) === CC_QUOTATION ||
+				  source.charCodeAt(valueStart - 1) === CC_APOSTROPHE
+				? valueEnd + 1
+				: valueEnd;
+	return source.slice(path.attributeNameStart(attr) - 1, end);
+};
+
+/**
+ * Source span of a tag's `integrity` attribute (offsets relative to
+ * `elementStart`, leading whitespace and quotes included), so the template can
+ * drop the content-specific author value without re-parsing. Null when absent.
+ * @param {import("./syntax").HtmlPath} path walk path (for attribute reads)
+ * @param {string} source HTML source
+ * @param {number} elementStart offset of the tag's opening `<`
+ * @returns {Range | null} the span, or null when there is no `integrity`
+ */
+const captureIntegrityRange = (path, source, elementStart) => {
+	const integrityAttr = path.findAttribute("integrity");
+	if (integrityAttr === 0 || path.attributeNameStart(integrityAttr) < 0) {
+		return null;
+	}
+	let rs = path.attributeNameStart(integrityAttr);
+	while (rs > 0 && isAsciiWhitespace(source.charCodeAt(rs - 1))) {
+		rs--;
+	}
+	let re;
+	const ivs = path.attributeValueStart(integrityAttr);
+	if (ivs === -1) {
+		re = path.attributeNameEnd(integrityAttr);
+	} else {
+		const q = source.charCodeAt(ivs - 1);
+		const ive = path.attributeValueEnd(integrityAttr);
+		re = q === CC_QUOTATION || q === CC_APOSTROPHE ? ive + 1 : ive;
+	}
+	return [rs - elementStart, re - elementStart];
+};
+
+/**
+ * @param {Map<string, string>} attributes attributes
+ * @param {string} name name
+ * @returns {string | undefined} attribute value
+ */
+const getAttributeValue = (attributes, name) => attributes.get(name);
+
+/** @type {Map<string, Set<string>>} */
+const META = new Map([
+	[
+		"name",
+		new Set([
+			// msapplication-TileImage
+			"msapplication-tileimage",
+			"msapplication-square70x70logo",
+			"msapplication-square150x150logo",
+			"msapplication-wide310x150logo",
+			"msapplication-square310x310logo",
+			"msapplication-config",
+			// Only the `icon-uri` part is an asset, see `parseMsapplicationTask`
+			"msapplication-task",
+			"twitter:image",
+			"twitter:image:src",
+			// Twitter player card: URL to the raw video/media stream
+			"twitter:player:stream",
+			// Legacy preview-image hint
+			"thumbnail"
+		])
+	],
+	[
+		"property",
+		new Set([
+			"og:image",
+			"og:image:url",
+			"og:image:secure_url",
+			"og:audio",
+			"og:audio:secure_url",
+			"og:video",
+			"og:video:secure_url",
+			"vk:image"
+		])
+	],
+	[
+		"itemprop",
+		new Set([
+			"image",
+			"logo",
+			"screenshot",
+			"thumbnailurl",
+			"contenturl",
+			"downloadurl",
+			"duringmedia",
+			"embedurl",
+			"installurl",
+			"layoutimage"
+		])
+	]
+]);
+
+/**
+ * @param {Map<string, string>} attributes attributes
+ * @returns {boolean} true when need to parse, otherwise false
+ */
+const filterLinkItemprop = (attributes) => {
+	const itemprop = getAttributeValue(attributes, "itemprop");
+	if (!itemprop) return false;
+	const allowedAttributes = META.get("itemprop");
+	if (!allowedAttributes) return false;
+
+	return allowedAttributes.has(itemprop.trim().toLowerCase());
+};
+
+// `<link rel>` values whose `href`/`imagesrcset` webpack treats as a reference.
+const ALLOWED_LINK_RELS = new Set([
+	"stylesheet",
+	"icon",
+	"mask-icon",
+	"apple-touch-icon",
+	"apple-touch-icon-precomposed",
+	"apple-touch-startup-image",
+	// Routed to the `asset/webmanifest` module type, which parses its icon URLs.
+	"manifest",
+	"prefetch",
+	"preload",
+	"modulepreload",
+	// Legacy preview-image hint (`<link rel="image_src" href>`)
+	"image_src"
+]);
+
+/**
+ * @param {Map<string, string>} attributes attributes
+ * @returns {boolean} true when need to parse, otherwise false
+ */
+const filterLinkHref = (attributes) => {
+	const rel = getAttributeValue(attributes, "rel");
+	if (!rel) return false;
+	const usedRels = rel.trim().toLowerCase().split(/\s+/);
+	for (let i = 0; i < usedRels.length; i++) {
+		if (ALLOWED_LINK_RELS.has(usedRels[i])) return true;
+	}
+	return false;
+};
+
+/**
+ * @param {Map<string, string>} attributes attributes
+ * @returns {boolean} true when need to parse, otherwise false
+ */
+const filterLinkUnion = (attributes) =>
+	filterLinkHref(attributes) || filterLinkItemprop(attributes);
+
+/**
+ * @param {Map<string, string>} attributes attributes
+ * @returns {boolean} true when need to parse, otherwise false
+ */
+const filterMetaContent = (attributes) => {
+	for (const item of META) {
+		const [key, allowedNames] = item;
+		const name = getAttributeValue(attributes, key);
+		if (!name) continue;
+		// Check every present attribute, not only the first one
+		if (allowedNames.has(name.trim().toLowerCase())) return true;
+	}
+
+	return false;
+};
+
+/**
+ * `<param value>` (obsolete `<object>`/`<applet>` child) is only a URL when
+ * `valuetype="ref"`; otherwise it's an opaque string.
+ * @param {Map<string, string>} attributes attributes
+ * @returns {boolean} true when `value` is a URL reference
+ */
+const filterParamRef = (attributes) => {
+	const valuetype = getAttributeValue(attributes, "valuetype");
+	if (!valuetype) return false;
+	return valuetype.trim().toLowerCase() === "ref";
+};
+
+/**
+ * @param {Map<string, string>} attributes attributes
+ * @returns {boolean} true when the script element opts into ES module semantics
+ */
+const isModuleScript = (attributes) => {
+	const type = getAttributeValue(attributes, "type");
+	if (!type) return false;
+	return type.trim().toLowerCase() === "module";
+};
+
+// HTML `<script>` `type` values that the browser treats as executable
+// JavaScript. Anything outside this set (e.g. `application/ld+json`,
+// `importmap`, `application/wasm`) is a data block — webpack must not
+// try to bundle it as a JS entry; it should pass through as an asset URL.
+const JS_SCRIPT_TYPES = new Set([
+	"",
+	"module",
+	"text/javascript",
+	"application/javascript",
+	"text/ecmascript",
+	"application/ecmascript"
+]);
+
+/**
+ * @param {Map<string, string>} attributes attributes
+ * @returns {boolean} true when the script element's `type` is executable JS
+ */
+const isExecutableJsScript = (attributes) => {
+	const type = getAttributeValue(attributes, "type");
+	if (type === undefined) return true;
+	return JS_SCRIPT_TYPES.has(type.trim().toLowerCase());
+};
+
+/**
+ * @param {Map<string, string>} attributes attributes
+ * @returns {boolean} true when the link points at an ES module that should be bundled as an entry chunk
+ */
+const isLinkModulePreload = (attributes) => {
+	const rel = getAttributeValue(attributes, "rel");
+	if (!rel) return false;
+	return rel.trim().toLowerCase().split(/\s+/).includes("modulepreload");
+};
+
+/**
+ * @param {Map<string, string>} attributes attributes
+ * @returns {boolean} true when the link is a `<link rel="stylesheet">` that should be bundled as a CSS entry chunk
+ */
+const isLinkStylesheet = (attributes) => {
+	const rel = getAttributeValue(attributes, "rel");
+	if (!rel) return false;
+	return rel.trim().toLowerCase().split(/\s+/).includes("stylesheet");
+};
+
+/** @typedef {"src" | "srcset" | "css-url" | "msapplication-task" | "script" | "script-module" | "modulepreload" | "stylesheet" | "html" | "preload" | "prefetch" | "stylesheet-style" | "stylesheet-style-attribute" | "srcdoc"} SourceType */
+/** Entry types: a `type` whose value is loaded as its own compilation entry chunk. */
+/** @typedef {"script" | "script-module" | "modulepreload" | "stylesheet" | "html" | "preload" | "prefetch"} EntrySourceType */
+/** @typedef {SourceType | ((attrs: Map<string, string>, css: boolean) => SourceType)} SourceTypeOrResolver */
+/** @typedef {(attributes: Map<string, string>, value: string) => boolean} SourceFilter */
+/** @typedef {{ tag?: string, attribute: string, type: SourceType, filter?: SourceFilter }} SourceEntry */
+/** A `type` plus optional gates: `filter` (the decoded attribute map + the decoded value; return false to skip — covers both cross-attribute checks and cheap value checks) and `namespace` (restrict to an element namespace, e.g. SVG). */
+/** @typedef {{ type: SourceTypeOrResolver, filter?: SourceFilter, namespace?: number }} SourceItem */
+/** A tag→attribute lookup; a `undefined` value marks a built-in source disabled via `sources` (`type: false`). */
+/** @typedef {Record<string, SourceItem | undefined>} SourceBucket */
+/** @typedef {Record<string, SourceBucket>} SourceTable */
+/** A source whose value is the element's text content (a `<style>`/`<script>` body) rather than an attribute. */
+/** @typedef {{ type: SourceTypeOrResolver, filter?: (attributes: Map<string, string>) => boolean }} ContentSourceItem */
+
+/**
+ * Builds a null-prototype dictionary from the given property bags
+ * (later bags win; `undefined` bags are skipped). A null prototype is
+ * essential here: the tables are indexed by HTML tag and attribute
+ * names, so a plain object would let names like `__proto__`,
+ * `constructor`, or `toString` resolve to inherited values at lookup
+ * time — producing bogus dependencies and letting `sources: false` be
+ * bypassed.
+ * @param {...(Record<string, EXPECTED_ANY> | undefined)} bags property bags
+ * @returns {EXPECTED_ANY} null-prototype dictionary
+ */
+const dict = (...bags) => Object.assign(Object.create(null), ...bags);
+
+// Shared `SourceItem` singletons used by the built-in defaults —
+// keeping one instance per kind stabilizes V8's hidden classes across
+// lookups in the walk. `srcset` is its own type; the walk picks the
+// `parseSrcset` parser for it and otherwise treats it like `src`.
+/** @type {SourceItem} */
+const PLAIN_SRC = { type: "src", filter: undefined };
+/** @type {SourceItem} */
+const PLAIN_SRCSET = { type: "srcset", filter: undefined };
+
+/**
+ * `<link href>` is polymorphic: `rel="modulepreload"` → an ESM
+ * preload entry, `rel="stylesheet"` (with `experiments.css`) → a CSS
+ * entry, otherwise a plain asset URL.
+ * @type {SourceItem}
+ */
+const LINK_HREF = {
+	type: (attrs, css) => {
+		if (isLinkModulePreload(attrs)) return "modulepreload";
+		if (css && isLinkStylesheet(attrs)) return "stylesheet";
+		// `rel="preload"/"prefetch"` with `as="script"` (or `as="style"` when
+		// `experiments.css` is on) becomes a bundled, non-executing entry whose
+		// `href` is rewritten to the built chunk; other `as` targets (image,
+		// font, fetch, …) stay plain asset URLs.
+		const rel = getAttributeValue(attrs, "rel");
+		if (rel) {
+			const rels = rel.trim().toLowerCase().split(/\s+/);
+			const kind = rels.includes("preload")
+				? "preload"
+				: rels.includes("prefetch")
+					? "prefetch"
+					: undefined;
+			if (kind) {
+				const as = getAttributeValue(attrs, "as");
+				const asLower = as ? as.trim().toLowerCase() : "";
+				if (asLower === "script" || (css && asLower === "style")) return kind;
+			}
+		}
+		return "src";
+	},
+	filter: filterLinkUnion
+};
+
+/**
+ * `<script src>`: non-JS types (e.g. `application/ld+json`,
+ * `importmap`) stay plain asset URLs so the browser keeps seeing them
+ * as data blocks; `type="module"` opts into the ESM entry chunk;
+ * everything else in `JS_SCRIPT_TYPES` is a classic script.
+ * @type {SourceItem}
+ */
+const SCRIPT_SRC = {
+	type: (attrs) =>
+		isExecutableJsScript(attrs)
+			? isModuleScript(attrs)
+				? "script-module"
+				: "script"
+			: "src",
+	filter: undefined
+};
+
+/**
+ * `<meta content>`: most referenced names hold a single URL (`src`); the
+ * `msapplication-task` value is a `;`-delimited list whose `icon-uri` part
+ * is the only asset, so it selects the `msapplication-task` parser.
+ * @type {SourceItem}
+ */
+const META_CONTENT = {
+	type: (attrs) => {
+		const name = attrs.get("name");
+		return name !== undefined &&
+			name.trim().toLowerCase() === "msapplication-task"
+			? "msapplication-task"
+			: "src";
+	},
+	filter: filterMetaContent
+};
+
+// Built-in lookup table, written directly in its final resolved shape:
+// `DEFAULT_SOURCES_BY_TAG[tag][attribute] = item`. No module-load
+// loop, no separate array representation — every parser created with
+// the default `sources` config just references this table and pays
+// zero per-parser work.
+/** @type {Record<string, Record<string, SourceItem>>} */
+const DEFAULT_SOURCES_BY_TAG = dict({
+	// Obsolete Java-applet element; `code`/`object` are single class/object URLs.
+	applet: dict({ code: PLAIN_SRC, object: PLAIN_SRC }),
+	audio: dict({ src: PLAIN_SRC }),
+	// Deprecated presentational `background` attribute — an image URL.
+	body: dict({ background: PLAIN_SRC }),
+	embed: dict({ src: PLAIN_SRC }),
+	// `srcdoc` is an entity-encoded HTML document parsed and rewritten as a
+	// nested module — its handling lives in the generic source loop so the
+	// `sources` option can re-target it (or other tags/attributes) freely.
+	iframe: dict({ srcdoc: { type: "srcdoc", filter: undefined } }),
+	img: dict({ src: PLAIN_SRC, srcset: PLAIN_SRCSET }),
+	input: dict({ src: PLAIN_SRC }),
+	link: dict({
+		href: LINK_HREF,
+		imagesrcset: { type: "srcset", filter: filterLinkHref }
+	}),
+	meta: dict({ content: META_CONTENT }),
+	// MathML `<mglyph src>` references an image.
+	mglyph: dict({ src: PLAIN_SRC }),
+	// `classid` is a single object URI (`codebase`/`archive` are a base/list, skipped).
+	object: dict({ data: PLAIN_SRC, classid: PLAIN_SRC }),
+	// Obsolete `<param valuetype="ref" value="url">` child of `<object>`.
+	param: dict({ value: { type: "src", filter: filterParamRef } }),
+	// `href`/`xlink:href` reference the source of SVG `<script>` elements
+	script: dict({
+		src: SCRIPT_SRC,
+		href: SCRIPT_SRC,
+		"xlink:href": SCRIPT_SRC
+	}),
+	source: dict({ src: PLAIN_SRC, srcset: PLAIN_SRCSET }),
+	// Deprecated presentational `background` attribute — an image URL.
+	table: dict({ background: PLAIN_SRC }),
+	td: dict({ background: PLAIN_SRC }),
+	th: dict({ background: PLAIN_SRC }),
+	track: dict({ src: PLAIN_SRC }),
+	video: dict({ poster: PLAIN_SRC, src: PLAIN_SRC }),
+	// SVG. Tag names match the tree builder's adjusted camelCase
+	// (`feImage`/`textPath`/`linearGradient`/`radialGradient`). `href`/
+	// `xlink:href` reference another element/resource; fragment-only `#id`
+	// values are left untouched, so only external `file.svg#id` is rewritten.
+	// `color-profile`'s `xlink:href` points at an external ICC profile file.
+	// `cursor`/`font-face-uri` point at an external image/font file; `altGlyph`/
+	// `glyphRef`/`tref` are legacy element references (removed in SVG 2).
+	altGlyph: dict({ "xlink:href": PLAIN_SRC, href: PLAIN_SRC }),
+	"color-profile": dict({ "xlink:href": PLAIN_SRC, href: PLAIN_SRC }),
+	cursor: dict({ "xlink:href": PLAIN_SRC, href: PLAIN_SRC }),
+	feImage: dict({ "xlink:href": PLAIN_SRC, href: PLAIN_SRC }),
+	filter: dict({ "xlink:href": PLAIN_SRC, href: PLAIN_SRC }),
+	"font-face-uri": dict({ "xlink:href": PLAIN_SRC, href: PLAIN_SRC }),
+	glyphRef: dict({ "xlink:href": PLAIN_SRC, href: PLAIN_SRC }),
+	image: dict({ "xlink:href": PLAIN_SRC, href: PLAIN_SRC }),
+	linearGradient: dict({ "xlink:href": PLAIN_SRC, href: PLAIN_SRC }),
+	mpath: dict({ "xlink:href": PLAIN_SRC, href: PLAIN_SRC }),
+	pattern: dict({ "xlink:href": PLAIN_SRC, href: PLAIN_SRC }),
+	radialGradient: dict({ "xlink:href": PLAIN_SRC, href: PLAIN_SRC }),
+	textPath: dict({ "xlink:href": PLAIN_SRC, href: PLAIN_SRC }),
+	tref: dict({ "xlink:href": PLAIN_SRC, href: PLAIN_SRC }),
+	use: dict({ "xlink:href": PLAIN_SRC, href: PLAIN_SRC })
+	// CSS `url(...)` references in SVG presentation attributes (fill, stroke,
+	// clip-path, …) are handled separately during the walk (`parseCssUrls`).
+});
+
+// SVG presentation attributes (`fill`, `stroke`, …) carry CSS `url(...)`
+// FuncIRIs; `parseCssUrls` extracts external refs as assets (internal
+// `url(#id)` is left untouched). They apply to every SVG-namespace element, so
+// the item is `namespace`-gated rather than placed in a tag bucket. The filter
+// is a cheap pre-check skipping the common plain values (`red`, `none`, `#fff`).
+/** @type {SourceItem} */
+const SVG_CSS_URL = {
+	type: "css-url",
+	filter: (attributes, value) => FUNC_IRI_URL_REGEXP.test(value),
+	namespace: NS_SVG
+};
+
+// The global `style=""` attribute (a CSS declaration list), available on every
+// tag and even with `sources: false`. Like every `stylesheet-style*` source it
+// only emits when `experiments.css` is on (checked where the dependency is
+// created); the filter is a cheap pre-check skipping declarations without a
+// `url()`/`src()`/… .
+/** @type {SourceItem} */
+const STYLE_ATTRIBUTE = {
+	type: "stylesheet-style-attribute",
+	filter: (attributes, value) => STYLE_ATTR_URL_REGEXP.test(value)
+};
+
+// Any-tag sources — applied to every element as a fallback and folded into
+// each tag bucket, so the walk resolves one object per element and reads one
+// property per attribute. `DEFAULT` (svg presentation + style) is active
+// unless `sources: false`; only the always-on style attribute survives `false`.
+/** @type {Record<string, SourceItem>} */
+const DEFAULT_ANY_SOURCES = dict({ style: STYLE_ATTRIBUTE });
+for (const name of [
+	"fill",
+	"stroke",
+	"clip-path",
+	"mask",
+	"filter",
+	"marker",
+	"marker-start",
+	"marker-mid",
+	"marker-end",
+	"cursor"
+]) {
+	DEFAULT_ANY_SOURCES[name] = SVG_CSS_URL;
+}
+/** @type {Record<string, SourceItem>} */
+const ALWAYS_ANY_SOURCES = dict({ style: STYLE_ATTRIBUTE });
+
+// Reserved key holding the any-tag sources inside the per-tag table — the
+// schema forbids an empty `tag`, so it never collides with a real tag. The
+// walk falls back to it for elements without their own bucket.
+const ANY_TAG = "";
+
+/**
+ * Folds the any-tag sources into every per-tag bucket (tag-specific entries
+ * win) and stores them under `ANY_TAG`, so the whole source model is one
+ * object and the walk's per-attribute lookup is a single property read.
+ * @param {SourceTable} byTag per-tag sources
+ * @param {SourceBucket} any any-tag sources
+ * @returns {SourceTable} folded table
+ */
+const foldAnySources = (byTag, any) => {
+	for (const tag of Object.keys(byTag)) {
+		byTag[tag] = dict(any, byTag[tag]);
+	}
+	byTag[ANY_TAG] = any;
+	return byTag;
+};
+
+// Default table (per-tag defaults + any-tag sources folded in) and the
+// `sources: false` table (only the always-on `style=""` attribute). Both are
+// precomputed so the common cases reference them with zero per-parser work.
+/** @type {SourceTable} */
+const DEFAULT_SOURCES_FOLDED = foldAnySources(
+	dict(DEFAULT_SOURCES_BY_TAG),
+	DEFAULT_ANY_SOURCES
+);
+/** @type {SourceTable} */
+const DISABLED_SOURCES_FOLDED = foldAnySources(dict(), ALWAYS_ANY_SOURCES);
+
+/**
+ * Inline `<script>` body: classic JS unless `type="module"` opts into ESM.
+ * @param {Map<string, string>} attrs attributes
+ * @returns {SourceType} the entry type for the inline script
+ */
+const scriptContentType = (attrs) =>
+	isModuleScript(attrs) ? "script-module" : "script";
+
+/**
+ * Inline `<script>` body: only an executable JS block with no external source
+ * carries content webpack should bundle.
+ * @param {Map<string, string>} attrs attributes
+ * @returns {boolean} true when the inline body should be bundled
+ */
+const scriptContentFilter = (attrs) =>
+	!attrs.has("src") &&
+	!attrs.has("href") &&
+	!attrs.has("xlink:href") &&
+	isExecutableJsScript(attrs);
+
+/**
+ * `<style>` body is a stylesheet only when its `type` is empty or `text/css`.
+ * @param {Map<string, string>} attrs attributes
+ * @returns {boolean} true when the body is CSS
+ */
+const styleContentFilter = (attrs) => {
+	const type = attrs.get("type");
+	if (type === undefined) return true;
+	const t = type.trim().toLowerCase();
+	return t === "" || t === "text/css";
+};
+
+// Element-body sources, independent of the `sources` option (even `sources:
+// false`): inline `<script>` bodies are always processed; the `<style>` body
+// only emits when `experiments.css` is on (checked where the dependency is
+// created, like every `stylesheet-style*` source).
+/** @type {Record<string, ContentSourceItem>} */
+const CONTENT_SOURCES = dict({
+	script: { type: scriptContentType, filter: scriptContentFilter },
+	style: { type: "stylesheet-style", filter: styleContentFilter }
+});
+
+class HtmlParser extends Parser {
+	/**
+	 * Creates an instance of HtmlParser.
+	 * @param {HtmlParserOptions} options parser options (from `module.parser.html`; always passed by the `createParser` hook)
+	 */
+	constructor(options) {
+		super();
+		this.magicCommentContext = createMagicCommentContext();
+		// Read by HtmlModulesPlugin's `processResult` hook, which transforms
+		// the module source before it is stored and parsed.
+		/** @type {HtmlTemplateFunction | undefined} */
+		this.template = options.template;
+		/** @type {import("../../declarations/WebpackOptions").UrlHintRule[] | undefined} */
+		this._urlHints = options.urlHints;
+		// `as` selects the parse mode — the HTML analog of the CSS parser's `as`.
+		// `"document"` (default) parses a full page; any other value is the
+		// context element whose inner HTML the source is parsed as (a fragment),
+		// so context-sensitive tags (`<tr>`, `<td>`, `<option>`, …) in a partial
+		// are kept, not dropped. `"template"` is the neutral generic fragment.
+		/** @type {string | undefined} */
+		this.fragmentContext =
+			options.as === undefined || options.as === "document"
+				? undefined
+				: options.as;
+		// One source model: a per-tag table that also holds the any-tag sources
+		// under `ANY_TAG`. The common cases reference precomputed tables.
+		/** @type {SourceTable} */
+		this.sourcesByTag = DEFAULT_SOURCES_FOLDED;
+
+		const sources = options.sources;
+		if (sources === undefined || sources === true) return;
+		if (sources === false) {
+			// Only the always-on `style=""` attribute survives; nothing else is
+			// extracted (svg presentation, `<script src>`, `<link>` entries, …).
+			this.sourcesByTag = DISABLED_SOURCES_FOLDED;
+			return;
+		}
+
+		// User array — `"..."` anywhere opts the per-tag defaults in as the
+		// base; the built-in any-tag sources (svg presentation + style) are
+		// always present. A user entry with no `tag` is an any-tag source (e.g.
+		// `{ attribute: "data-style", type: "stylesheet-style-attribute" }`).
+		// User entries override regardless of position. `dict()` keeps every
+		// table null-prototype (see its doc), and per-tag writes rebuild the
+		// bucket so the aliased default buckets stay intact.
+		/** @type {SourceTable} */
+		const byTag = sources.includes("...")
+			? dict(DEFAULT_SOURCES_BY_TAG)
+			: dict();
+		/** @type {SourceBucket} */
+		const any = dict(DEFAULT_ANY_SOURCES);
+		for (const entry of sources) {
+			if (entry === "...") continue;
+			// `type: false` disables a built-in source: writing `undefined` over the
+			// attribute makes the walk's `sources[name]` lookup skip it (see below).
+			/** @type {SourceItem | undefined} */
+			const item =
+				entry.type === false
+					? undefined
+					: {
+							type: entry.type,
+							filter:
+								typeof entry.filter === "function" ? entry.filter : undefined
+						};
+			const attr = entry.attribute.toLowerCase();
+			if (entry.tag === undefined) {
+				any[attr] = item;
+			} else {
+				const tag = entry.tag.toLowerCase();
+				byTag[tag] = dict(byTag[tag], { [attr]: item });
+				// The AST carries adjusted camelCase names for foreign-content
+				// tags (e.g. `feImage`) — register the entry under both.
+				const adjusted = SVG_TAG_ADJUST[tag];
+				if (adjusted !== undefined) {
+					byTag[adjusted] = dict(byTag[adjusted], { [attr]: item });
+				}
+			}
+		}
+		/** @type {SourceTable} */
+		this.sourcesByTag = foldAnySources(byTag, any);
+	}
+
+	/**
+	 * Runs the `template` option over the source and returns the transformed
+	 * html. Called from HtmlModulesPlugin's `processResult`, where the return
+	 * value becomes the module's stored source so the parser (which records
+	 * dependency offsets against it) and the generator (which renders from
+	 * `module.originalSource()`) stay in agreement.
+	 * @param {string | Buffer} source the original source
+	 * @param {NormalModule} module the html module
+	 * @returns {string | Buffer} the transformed source
+	 */
+	applyTemplate(source, module) {
+		if (!this.template) return source;
+		// `processResult` runs after `_doBuild` has initialized these
+		// dependency sets, so they are always present here.
+		const buildInfo = /** @type {BuildInfo} */ (module.buildInfo);
+		const fileDependencies = /** @type {FileSystemDependencies} */ (
+			buildInfo.fileDependencies
+		);
+		const contextDependencies = /** @type {FileSystemDependencies} */ (
+			buildInfo.contextDependencies
+		);
+		const missingDependencies = /** @type {FileSystemDependencies} */ (
+			buildInfo.missingDependencies
+		);
+		const transformed = this.template(
+			typeof source === "string" ? source : source.toString("utf8"),
+			{
+				module,
+				resource: module.resource,
+				addDependency: (dependency) => {
+					fileDependencies.add(dependency);
+				},
+				addContextDependency: (dependency) => {
+					contextDependencies.add(dependency);
+				},
+				addMissingDependency: (dependency) => {
+					missingDependencies.add(dependency);
+				},
+				addBuildDependency: (dependency) => {
+					if (buildInfo.buildDependencies === undefined) {
+						buildInfo.buildDependencies = new LazySet();
+					}
+					buildInfo.buildDependencies.add(dependency);
+				},
+				emitWarning: (warning) =>
+					module.addWarning(
+						warning instanceof Error ? warning : new WebpackError(warning)
+					),
+				emitError: (error) =>
+					module.addError(
+						error instanceof Error ? error : new WebpackError(error)
+					)
+			}
+		);
+		if (typeof transformed !== "string") {
+			throw new Error(
+				"The `template` html parser option must return a string."
+			);
+		}
+		return transformed;
+	}
+
+	/**
+	 * Parses the provided source and updates the parser state.
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
+	 */
+	parse(source, state) {
+		if (Buffer.isBuffer(source)) {
+			source = source.toString("utf8");
+		} else if (typeof source === "object") {
+			throw new Error("webpackAst is unexpected for the HtmlParser");
+		}
+		if (source[0] === "\uFEFF") {
+			source = source.slice(1);
+		}
+
+		const locConverter = new LocConverter(source);
+
+		const module = state.module;
+		const compilation = state.compilation;
+		const { hashFunction, module: outputModule } = compilation.outputOptions;
+		const context = compilation.compiler.context;
+		const css = Boolean(compilation.options.experiments.css);
+		const urlHints = this._urlHints;
+
+		// Stable, per-HTML-module prefix used when generating entry names for
+		// script src / modulepreload references so they don't collide across
+		// HTML modules in the same compilation. We hash the module's resource
+		// path (a plain absolute path) — going through `contextify` against
+		// the compilation root keeps the hash machine-stable for the same
+		// project layout. Note: `module.identifier()` returns `html|<path>`
+		// for HTML modules, which doesn't start with `/`, so contextify would
+		// leave it absolute. `module.resource` is the bare path.
+		/** @type {string} */
+		const resource =
+			/** @type {EXPECTED_ANY} */ (module).resource || module.identifier();
+		const moduleHash = createHash(hashFunction || "md4")
+			.update(context ? contextify(context, resource) : resource)
+			.digest("hex")
+			.slice(0, 8);
+
+		// `output.html` head injection: facts are collected during the walk and
+		// become presentational dependencies afterwards — no later asset pass has
+		// to re-parse the page. `data:` documents are skipped: synthetic entry
+		// wrappers already carry the tags and iframe srcdoc pages must stay
+		// untouched.
+		const htmlOutputOptions =
+			compilation.options && compilation.options.output
+				? compilation.options.output.html
+				: undefined;
+		const headOptions =
+			typeof htmlOutputOptions === "object" &&
+			(htmlOutputOptions.title !== undefined ||
+				htmlOutputOptions.meta !== undefined ||
+				htmlOutputOptions.base !== undefined) &&
+			!resource.startsWith("data:")
+				? htmlOutputOptions
+				: undefined;
+		let doctypeEnd = -1;
+		let htmlTagEnd = -1;
+		// insertion offsets just inside the (possibly implicit) head
+		let headStart = 0;
+		let headLastEnd = 0;
+		let headSeen = false;
+		let inHead = false;
+		// `<template>` contents are inert
+		let headTemplateDepth = 0;
+		// Depth of open `<template>` elements anywhere in the tree. Template
+		// content is an inert, separate fragment per spec, so a `<base>` inside
+		// it must NOT set the document base (`headTemplateDepth` only covers
+		// templates seen while in `<head>`, so it can't guard body templates).
+		let templateDepth = 0;
+		let headHasTitle = false;
+		let headHasBase = false;
+		let headCharsetEnd = -1;
+		/** @type {Set<string> | undefined} */
+		let headMetaNames;
+
+		// Script src / modulepreload references are collected per-type
+		// during the walk; HtmlModulesPlugin later turns them into real
+		// entries. `script` and `script-module` entries are chained via a
+		// leader-only dependOn so they share a runtime.
+		// `<link rel="modulepreload">` entries are kept independent — they
+		// must preload without running, so they can never become a runtime
+		// leader that other entries would import.
+		/**
+		 * @typedef {object} HtmlEntryInfo
+		 * @property {string} request
+		 * @property {string} entryName
+		 * @property {"script" | "script-module" | "modulepreload" | "stylesheet" | "html" | "preload" | "prefetch"} type
+		 * @property {boolean=} css entry emits a CSS chunk (`<link rel="preload" as="style">`), so it needs the CSS filename template
+		 */
+		/** @type {HtmlEntryInfo[]} */
+		const scriptEntries = [];
+		/** @type {HtmlEntryInfo[]} */
+		const scriptModuleEntries = [];
+		/** @type {HtmlEntryInfo[]} */
+		const modulePreloadEntries = [];
+		/** @type {HtmlEntryInfo[]} */
+		const stylesheetEntries = [];
+		// `type: "html"` links — each referenced `.html` becomes its own page
+		// entry (`<a href="page.html">`), independent (no dependOn).
+		/** @type {HtmlEntryInfo[]} */
+		const htmlLinkEntries = [];
+		// `<link rel="preload"/"prefetch">` of a bundled resource: each becomes an
+		// independent, non-executing entry whose `href` is rewritten to the built
+		// chunk's URL (JS for `as="script"`, CSS for `as="style"`).
+		/** @type {HtmlEntryInfo[]} */
+		const preloadEntries = [];
+		/** @type {HtmlEntryInfo[]} */
+		const prefetchEntries = [];
+
+		// Offset of the first classic blocking script tag; injected stylesheet
+		// `<link>`s stay ahead of it. `defer`/`async`/module scripts don't
+		// anchor — they execute after parsing (and after pending stylesheets),
+		// so CSS may follow their tags (the order Vite emits).
+		let firstBlockingScriptStart = -1;
+
+		let nextEntryIndex = 0;
+
+		// `<base href>` resolves the relative URLs that follow it. A relative base
+		// (`./assets/`) rewrites them into a subdirectory — still bundled; a
+		// root-relative or absolute base (`/`, `https://cdn/`) points them outside
+		// the build, so those URLs are left untouched. Resolved in the walk below
+		// from the first `<base href>` seen (`documentBase` undefined until then).
+		/** @type {string | undefined} */
+		let documentBase;
+		/** @type {string | undefined} */
+		let baseDir;
+		let baseIsExternal = false;
+		// Prepended to the emitted URLs' auto-public-path undo path so the base
+		// doesn't misdirect them: the browser resolves rewritten (relative)
+		// output URLs against the base dir, so one `../` per base segment cancels
+		// it. Undefined for absolute publicPath (no undo path is emitted).
+		/** @type {string | undefined} */
+		let baseUrlPrefix;
+
+		/**
+		 * Tracks the `webpackIgnore` value from the most recent comment that
+		 * appears before the next tag. Reset whenever a tag is emitted or a
+		 * comment without a `webpackIgnore` value is encountered.
+		 * @type {boolean | undefined}
+		 */
+		let pendingWebpackIgnore;
+		/** @type {boolean | undefined} */
+		let pendingWebpackInline;
+		/**
+		 * Tracks the resource-hint values from the most recent `<!-- webpackPrefetch: … -->`
+		 * (etc.) comment so the next asset URL attribute picks them up.
+		 * @type {import("../prefetch/parseResourceHintOptions").ResourceHintOptions | undefined}
+		 */
+		let pendingHints;
+
+		const magicCommentContext = this.magicCommentContext;
+
+		/**
+		 * @param {import("./syntax").HtmlPath} path walk path (used only for attribute-ref reads)
+		 * @param {import("./syntax").HtmlAttributeRef} typeAttr type attribute ref (0 = none)
+		 * @param {number} nameEnd end offset of the tag name
+		 * @param {string} type type of the script
+		 * @param {string} input source string
+		 */
+		const reconcileScriptTypeAttr = (path, typeAttr, nameEnd, type, input) => {
+			const valueStart =
+				typeAttr !== 0 ? path.attributeValueStart(typeAttr) : -1;
+			const valueEnd = typeAttr !== 0 ? path.attributeValueEnd(typeAttr) : -1;
+			if (outputModule && type === "script") {
+				// Chunk is an ES module; upgrade the tag.
+				if (typeAttr !== 0 && valueStart !== -1) {
+					module.addPresentationalDependency(
+						new ConstDependency("module", [valueStart, valueEnd])
+					);
+				} else {
+					module.addPresentationalDependency(
+						new ConstDependency(' type="module"', nameEnd)
+					);
+				}
+			} else if (!outputModule && type === "script-module" && typeAttr !== 0) {
+				// Chunk is a classic IIFE; drop `type="module"` so the
+				// browser doesn't load it under module semantics.
+				let attrEnd;
+				if (valueStart === -1) {
+					attrEnd = path.attributeNameEnd(typeAttr);
+				} else if (input[valueEnd] === '"' || input[valueEnd] === "'") {
+					attrEnd = valueEnd + 1;
+				} else {
+					attrEnd = valueEnd;
+				}
+				let attrStart = path.attributeNameStart(typeAttr);
+				if (
+					attrStart > 0 &&
+					isAsciiWhitespace(input.charCodeAt(attrStart - 1))
+				) {
+					attrStart -= 1;
+				}
+				module.addPresentationalDependency(
+					new ConstDependency("", [attrStart, attrEnd])
+				);
+			}
+		};
+
+		/**
+		 * @param {string} mime mime type
+		 * @param {string} text inline text
+		 * @returns {string} a `data:` request for the text
+		 */
+		const dataUri = (mime, text) =>
+			`data:${mime};base64,${Buffer.from(text, "utf8").toString("base64")}`;
+
+		/**
+		 * @param {ConstDependency | HtmlSourceDependency | HtmlEntryDependency | HtmlInlineStyleDependency | HtmlInlineScriptDependency | HtmlInlineHtmlDependency} dep dependency
+		 * @param {number} start raw start offset
+		 * @param {number} end raw end offset
+		 */
+		const setLoc = (dep, start, end) => {
+			const s = locConverter.get(start);
+			const e = locConverter.get(end);
+			dep.setLoc(s.line, s.column, e.line, e.column);
+		};
+
+		/**
+		 * Classifies the first `<base href>` seen in the walk, setting
+		 * `documentBase`/`baseDir`/`baseIsExternal`/`baseUrlPrefix` for the URLs
+		 * that follow it.
+		 * @param {import("./syntax").HtmlPath} path walk path (for attribute reads)
+		 * @param {import("./syntax").HtmlAttributeRef} hrefAttr the base's href attribute
+		 */
+		const resolveDocumentBase = (path, hrefAttr) => {
+			documentBase = decodeEntities(path.attributeValue(hrefAttr), true).trim();
+			if (!documentBase) return;
+			if (
+				ABSOLUTE_URL_SCHEME_REGEXP.test(documentBase) ||
+				documentBase.charCodeAt(0) === CC_SLASH
+			) {
+				baseIsExternal = true;
+				return;
+			}
+			// Normalize the base path into its descending directory segments,
+			// resolving `.`/`..` like the URL spec. The final segment is the
+			// referenced file (dropped) unless the href ends with `/` or a
+			// dot-segment; `up` counts `..`s that climb above the document dir.
+			const parts = documentBase.split("/");
+			/** @type {string[]} */
+			const dirs = [];
+			let up = 0;
+			for (let i = 0; i < parts.length; i++) {
+				const part = parts[i];
+				if (part === "" || part === ".") continue;
+				if (part === "..") {
+					if (dirs.length > 0) dirs.pop();
+					else up++;
+					continue;
+				}
+				// A trailing plain segment (no following `/`) is the file, not a dir.
+				if (i === parts.length - 1) continue;
+				dirs.push(part);
+			}
+			baseDir = `${"../".repeat(up)}${dirs.length > 0 ? `${dirs.join("/")}/` : ""}`;
+			// A base above the document dir can't be cancelled with `../` (the
+			// document's own dir name is unknown) — leave the output URLs
+			// un-prefixed; they still resolve under an absolute publicPath.
+			if (up === 0 && dirs.length > 0) {
+				baseUrlPrefix = "../".repeat(dirs.length);
+			}
+		};
+
+		// Lazy decoded-attribute map for the current element — parse-scoped
+		// to avoid a closure and memo slot per element.
+		/** @type {import("./syntax").HtmlPath | undefined} */
+		let attrMapPath;
+		let attrMapCount = 0;
+		/** @type {Map<string, string> | undefined} */
+		let currentAttributesMap;
+		const getAttributesMap = () => {
+			if (currentAttributesMap) return currentAttributesMap;
+			currentAttributesMap = new Map();
+			const path = /** @type {import("./syntax").HtmlPath} */ (attrMapPath);
+			for (let i = 0; i < attrMapCount; i++) {
+				const attr = path.attributeAt(i);
+				// Decoded values — filters and type resolvers compare what
+				// the browser sees (e.g. `rel="&#105;con"` means `icon`)
+				currentAttributesMap.set(
+					path.attributeName(attr),
+					decodeEntities(path.attributeValue(attr), true)
+				);
+			}
+			return currentAttributesMap;
+		};
+
+		// TODO implement full HTML parser (WASM)
+		// The walker descends into children (and `<template>` content) itself;
+		// the Element `exit` clears a pending `webpackIgnore` once an element's
+		// children are done (the old `walkChildren` behaviour).
+		new SourceProcessor()
+			.use({
+				[NodeType.Comment]: (path) => {
+					const start = path.start();
+					const end = path.end();
+					// comments count toward the head-end insertion anchor
+					if (inHead && headTemplateDepth === 0 && end > headLastEnd) {
+						headLastEnd = end;
+					}
+					// Only proper `<!-- ... -->` comments carry magic comments.
+					if (
+						end - start < 7 ||
+						source.charCodeAt(start) !== 0x3c ||
+						source.charCodeAt(start + 1) !== 0x21 ||
+						source.charCodeAt(start + 2) !== 0x2d ||
+						source.charCodeAt(start + 3) !== 0x2d ||
+						source.charCodeAt(end - 1) !== 0x3e ||
+						source.charCodeAt(end - 2) !== 0x2d ||
+						source.charCodeAt(end - 3) !== 0x2d
+					) {
+						pendingWebpackIgnore = undefined;
+						pendingWebpackInline = undefined;
+						pendingHints = undefined;
+						return;
+					}
+					const value = path.data();
+					if (!webpackCommentRegExp.test(value)) {
+						pendingWebpackIgnore = undefined;
+						pendingWebpackInline = undefined;
+						pendingHints = undefined;
+						return;
+					}
+					/** @type {Record<string, EXPECTED_ANY>} */
+					let options;
+					try {
+						options = parseMagicComment(value, magicCommentContext);
+					} catch (err) {
+						const { line: sl, column: sc } = locConverter.get(start);
+						const { line: el, column: ec } = locConverter.get(end);
+						module.addWarning(
+							new CommentCompilationWarning(
+								`Compilation error while processing magic comment(-s): /*${value}*/: ${
+									/** @type {Error} */ (err).message
+								}`,
+								{
+									start: { line: sl, column: sc },
+									end: { line: el, column: ec }
+								}
+							)
+						);
+						pendingWebpackIgnore = undefined;
+						pendingWebpackInline = undefined;
+						pendingHints = undefined;
+						return;
+					}
+					if (
+						options.webpackIgnore === undefined &&
+						options.webpackInline === undefined &&
+						options.webpackPrefetch === undefined &&
+						options.webpackPreload === undefined &&
+						options.webpackFetchPriority === undefined
+					) {
+						pendingWebpackIgnore = undefined;
+						pendingWebpackInline = undefined;
+						pendingHints = undefined;
+						return;
+					}
+					if (
+						options.webpackIgnore !== undefined &&
+						typeof options.webpackIgnore !== "boolean"
+					) {
+						const { line: sl, column: sc } = locConverter.get(start);
+						const { line: el, column: ec } = locConverter.get(end);
+						module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackIgnore\` expected a boolean, but received: ${options.webpackIgnore}.`,
+								{
+									start: { line: sl, column: sc },
+									end: { line: el, column: ec }
+								}
+							)
+						);
+						pendingWebpackIgnore = undefined;
+						pendingWebpackInline = undefined;
+						pendingHints = undefined;
+						return;
+					}
+					if (
+						options.webpackInline !== undefined &&
+						typeof options.webpackInline !== "boolean"
+					) {
+						const { line: sl, column: sc } = locConverter.get(start);
+						const { line: el, column: ec } = locConverter.get(end);
+						module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackInline\` expected a boolean, but received: ${options.webpackInline}.`,
+								{
+									start: { line: sl, column: sc },
+									end: { line: el, column: ec }
+								}
+							)
+						);
+						pendingWebpackIgnore = undefined;
+						pendingWebpackInline = undefined;
+						pendingHints = undefined;
+						return;
+					}
+					pendingWebpackIgnore = options.webpackIgnore;
+					pendingWebpackInline = options.webpackInline;
+					if (
+						options.webpackPrefetch !== undefined ||
+						options.webpackPreload !== undefined ||
+						options.webpackFetchPriority !== undefined
+					) {
+						const s = locConverter.get(start);
+						const e = locConverter.get(end);
+						const parsedHints = parseResourceHintOptions(options, module, {
+							start: { line: s.line, column: s.column },
+							end: { line: e.line, column: e.column }
+						});
+						pendingHints =
+							parsedHints.prefetch !== undefined ||
+							parsedHints.preload !== undefined ||
+							parsedHints.fetchPriority !== undefined
+								? parsedHints
+								: undefined;
+					} else {
+						pendingHints = undefined;
+					}
+				},
+				[NodeType.Doctype]: (path) => {
+					// only visited when head injection is active (see `skip` below)
+					if (doctypeEnd === -1) doctypeEnd = path.end();
+					pendingWebpackIgnore = undefined;
+					pendingWebpackInline = undefined;
+					pendingHints = undefined;
+				},
+				[NodeType.Element]: {
+					// Children (and `<template>` content) are walked by the
+					// processor after `enter`; `exit` clears a pending
+					// `webpackIgnore` once they're done.
+					enter: (path) => {
+						const ignore = pendingWebpackIgnore === true;
+						const forceInline = pendingWebpackInline === true;
+						pendingWebpackIgnore = undefined;
+						pendingWebpackInline = undefined;
+
+						// `<head>` anchors are collected for every page — they place
+						// `inject: "head"` siblings and resource hints; the
+						// title/meta/base facts only when configured. Structural, so it
+						// runs even for `webpackIgnore`d elements.
+						{
+							const name = path.tagName();
+							if (name === "template" && path.namespace() === NS_HTML) {
+								templateDepth++;
+							}
+							if (headTemplateDepth > 0) {
+								if (name === "template" && path.namespace() === NS_HTML) {
+									headTemplateDepth++;
+								}
+							} else if (inHead) {
+								if (headOptions !== undefined && path.namespace() === NS_HTML) {
+									switch (name) {
+										case "title":
+											headHasTitle = true;
+											break;
+										case "base":
+											headHasBase = true;
+											break;
+										case "meta": {
+											if (path.findAttribute("charset") !== 0) {
+												headCharsetEnd = path.tagEnd();
+											} else {
+												const httpEquiv = path.findAttribute("http-equiv");
+												const contentAttr =
+													httpEquiv !== 0 &&
+													decodeEntities(
+														path.attributeValue(httpEquiv),
+														true
+													).toLowerCase() === "content-type"
+														? path.findAttribute("content")
+														: 0;
+												if (
+													contentAttr !== 0 &&
+													CHARSET_DECLARATION_REGEXP.test(
+														decodeEntities(
+															path.attributeValue(contentAttr),
+															true
+														)
+													)
+												) {
+													headCharsetEnd = path.tagEnd();
+												}
+											}
+											const nameAttr = path.findAttribute("name");
+											const propertyAttr = path.findAttribute("property");
+											if (nameAttr !== 0 || propertyAttr !== 0) {
+												if (headMetaNames === undefined) {
+													headMetaNames = new Set();
+												}
+												if (nameAttr !== 0) {
+													headMetaNames.add(
+														decodeEntities(
+															path.attributeValue(nameAttr),
+															true
+														).toLowerCase()
+													);
+												}
+												if (propertyAttr !== 0) {
+													headMetaNames.add(
+														decodeEntities(
+															path.attributeValue(propertyAttr),
+															true
+														).toLowerCase()
+													);
+												}
+											}
+											break;
+										}
+										case "template":
+											headTemplateDepth++;
+											break;
+									}
+								} else if (
+									name === "template" &&
+									path.namespace() === NS_HTML
+								) {
+									headTemplateDepth++;
+								}
+								if (path.end() > headLastEnd) headLastEnd = path.end();
+							} else if (!headSeen && path.namespace() === NS_HTML) {
+								if (name === "html") {
+									htmlTagEnd = path.tagEnd();
+								} else if (name === "head") {
+									headSeen = true;
+									inHead = true;
+									// explicit head has real offsets; an implicit one (head
+									// tags are optional in HTML5) anchors after `<html>`,
+									// the doctype, or the document start
+									const tagEnd = path.tagEnd();
+									headStart =
+										tagEnd > 0
+											? tagEnd
+											: htmlTagEnd > 0
+												? htmlTagEnd
+												: doctypeEnd > 0
+													? doctypeEnd
+													: 0;
+									headLastEnd = headStart;
+								}
+							}
+						}
+
+						if (ignore) {
+							return;
+						}
+
+						const elementName = path.tagName();
+						const attributeCount = path.attributeCount();
+						const elementStart = path.start();
+						const tagEnd = path.tagEnd();
+						const nameEnd = path.nameEnd();
+
+						// The first `<base href>` freezes the base for later URLs — but
+						// only one in the real document tree, not inside an inert
+						// `<template>` (whose contents are a separate fragment).
+						if (
+							documentBase === undefined &&
+							templateDepth === 0 &&
+							elementName === "base" &&
+							path.namespace() === NS_HTML
+						) {
+							const hrefAttr = path.findAttribute("href");
+							if (hrefAttr !== 0) resolveDocumentBase(path, hrefAttr);
+						}
+
+						// Rebind the parse-scoped lazy attribute map to this element.
+						attrMapPath = path;
+						attrMapCount = attributeCount;
+						currentAttributesMap = undefined;
+
+						// Each matched attribute is a source; the element body (inline
+						// `<style>`/`<script>`) is one more — content rather than an attribute.
+						// All are dispatched by the same `switch (type)`.
+						const sources =
+							this.sourcesByTag[elementName] || this.sourcesByTag[ANY_TAG];
+						const bodyItem = CONTENT_SOURCES[elementName];
+						// Iterate the attributes, then one extra step for the element
+						// body (`i === attributeCount`); the attribute ref is only read on the
+						// attribute steps, so it stays in bounds.
+						for (let i = 0; i < attributeCount + 1; i++) {
+							const content = i === attributeCount;
+							/** @type {SourceType} */
+							let type;
+							/** @type {string} */
+							let value;
+							/** @type {number} */
+							let start;
+							/** @type {number} */
+							let end;
+							/** @type {import("./syntax").HtmlAttributeRef} */
+							let attr = 0;
+							if (content) {
+								if (!bodyItem) continue;
+								if (bodyItem.filter && !bodyItem.filter(getAttributesMap())) {
+									continue;
+								}
+								// `skip.text` drops the body `Text` node; the raw content
+								// span is [`tagEnd`, `contentEnd`] on the element.
+								const bodyStart = tagEnd;
+								const bodyEnd = path.contentEnd();
+								if (bodyEnd <= bodyStart) continue;
+								value = source.slice(bodyStart, bodyEnd);
+								if (value.trim() === "") continue;
+								start = bodyStart;
+								end = bodyEnd;
+								type =
+									typeof bodyItem.type === "function"
+										? bodyItem.type(getAttributesMap(), css)
+										: bodyItem.type;
+							} else {
+								attr = path.attributeAt(i);
+								const item = sources[path.attributeName(attr)];
+								if (!item) continue;
+								if (
+									item.namespace !== undefined &&
+									path.namespace() !== item.namespace
+								) {
+									continue;
+								}
+								// Adoption-agency clones carry no offsets; skip blank values.
+								if (path.attributeValueStart(attr) === -1) {
+									continue;
+								}
+								value = path.attributeValue(attr);
+								if (!value || !/\S/.test(value)) continue;
+								const filter = item.filter;
+								if (filter) {
+									// The filter also sees the decoded value (the browser tokenizes it
+									// decoded, e.g. `&#117;rl(`), so a value-only check needn't re-read it.
+									const decoded = value.includes("&")
+										? decodeEntities(value, true)
+										: value;
+									if (!filter(getAttributesMap(), decoded)) continue;
+								}
+								start = path.attributeValueStart(attr);
+								end = path.attributeValueEnd(attr);
+								type =
+									typeof item.type === "function"
+										? item.type(getAttributesMap(), css)
+										: item.type;
+							}
+							// A resolved `type` selects the parse algorithm and the dependency
+							// kind — the only dispatch in the parser.
+							switch (type) {
+								// Inline CSS — a `<style>` body (raw, a full stylesheet) or an
+								// attribute value (decoded, re-escaped on write-back; `*-attribute`
+								// is a declaration list). Needs `experiments.css`.
+								case "stylesheet-style":
+								case "stylesheet-style-attribute": {
+									if (!css) break;
+									const cssText = content ? value : decodeEntities(value, true);
+									if (cssText.trim() === "") break;
+									const dep = new HtmlInlineStyleDependency(
+										dataUri("text/css", cssText),
+										[start, end],
+										content ? false : type === "stylesheet-style-attribute",
+										!content
+									);
+									setLoc(dep, start, end);
+									module.addDependency(dep);
+									module.addCodeGenerationDependency(dep);
+									break;
+								}
+								// `<iframe srcdoc>`: an entity-encoded HTML document. Feed the
+								// decoded markup back through the HTML pipeline as a nested
+								// `data:text/html` module. Per spec the value is a full document
+								// whose URL is `about:srcdoc`, so its base URL is inherited from
+								// this document — asset URLs resolve against this file's context.
+								case "srcdoc": {
+									const htmlText = decodeEntities(value, true);
+									// Only spin up a nested module when there is markup that can
+									// reference an asset; text/formatting-only markup is identical
+									// after rewriting (see `SRCDOC_ASSET_REGEXP`).
+									if (
+										!htmlText.includes("<") ||
+										!SRCDOC_ASSET_REGEXP.test(htmlText)
+									) {
+										break;
+									}
+									const dep = new HtmlInlineHtmlDependency(
+										dataUri("text/html", htmlText),
+										[start, end]
+									);
+									setLoc(dep, start, end);
+									module.addDependency(dep);
+									module.addCodeGenerationDependency(dep);
+									break;
+								}
+								// Inline `<script>` body — bundled as its own entry chunk.
+								case "script":
+								case "script-module":
+									if (content) {
+										const scriptType =
+											/** @type {"script" | "script-module"} */ (type);
+										const request = dataUri("text/javascript", value);
+										const entryName = `__html_${moduleHash}_${nextEntryIndex++}`;
+										const dep = new HtmlInlineScriptDependency(
+											request,
+											nameEnd,
+											[start, end],
+											entryName,
+											scriptType === "script-module" ? "esm" : "commonjs"
+										);
+										setLoc(dep, start, end);
+										module.addPresentationalDependency(dep);
+										reconcileScriptTypeAttr(
+											path,
+											path.findAttribute("type"),
+											nameEnd,
+											scriptType,
+											source
+										);
+										(scriptType === "script"
+											? scriptEntries
+											: scriptModuleEntries
+										).push({
+											request,
+											entryName,
+											type: scriptType
+										});
+										break;
+									}
+								// falls through — external `<script src>` joins the URL-bearing types
+								case "src":
+								case "srcset":
+								case "css-url":
+								case "msapplication-task":
+								case "modulepreload":
+								case "stylesheet":
+								case "html":
+								case "preload":
+								case "prefetch": {
+									// Parse the value into one or more URLs (decoding character
+									// references, mapping spans back to raw offsets), then emit a plain
+									// asset reference or an entry chunk per URL.
+									const parse =
+										type === "srcset"
+											? parseSrcset
+											: type === "css-url"
+												? parseCssUrls
+												: type === "msapplication-task"
+													? parseMsapplicationTask
+													: parseSrc;
+									let text = value;
+									/** @type {number[] | undefined} */
+									let map;
+									if (value.includes("&")) {
+										({ text, map } = decodeEntities(value, true, true));
+										if (!/\S/.test(text)) break;
+									}
+									/** @type {ParsedSource[] | undefined} */
+									let parsed;
+									try {
+										parsed = parse(text);
+									} catch (err) {
+										const ds = locConverter.get(start);
+										const de = locConverter.get(end);
+										module.addError(
+											new ModuleDependencyError(
+												module,
+												new WebpackError(
+													`Bad value for attribute "${path.attributeName(
+														attr
+													)}" on element "${elementName}": ${
+														/** @type {Error} */ (err).message
+													}`
+												),
+												{
+													start: { line: ds.line, column: ds.column },
+													end: { line: de.line, column: de.column }
+												}
+											)
+										);
+										break;
+									}
+									if (!parsed) break;
+									for (const [url, us, ue] of parsed) {
+										// Internal `url(#id)` / fragment-only refs aren't assets.
+										if (!url || url.startsWith("#")) continue;
+										// Resolve the request against `<base href>`. Only relative
+										// URLs are affected (scheme / `//` / `/` URLs ignore the
+										// base); an external base drops them from the build.
+										let request = url;
+										if (
+											documentBase &&
+											url.charCodeAt(0) !== CC_SLASH &&
+											!ABSOLUTE_URL_SCHEME_REGEXP.test(url)
+										) {
+											if (baseIsExternal) continue;
+											request = baseDir + url;
+										}
+										const s = start + (map ? map[us] : us);
+										const e = start + (map ? map[ue] : ue);
+										// `html` links the URL as its own emitted page: the same
+										// `HtmlEntryDependency` as `<script src>` / `<link>`, but the `html`
+										// kind rewrites to the page's filename and emits no sibling tags.
+										// Recorded as an independent entry (no `dependOn`), like an entry point.
+										if (type === "html") {
+											const entryName = `__html_${moduleHash}_${nextEntryIndex++}`;
+											const dep = new HtmlEntryDependency(
+												request,
+												[s, e],
+												entryName,
+												undefined,
+												"html"
+											);
+											setLoc(dep, s, e);
+											module.addPresentationalDependency(dep);
+											htmlLinkEntries.push({ request, entryName, type });
+											continue;
+										}
+										// `rel="preload"/"prefetch"` of a bundled resource: an
+										// independent, non-executing entry whose `href` is rewritten to
+										// the built chunk's URL (CSS for `as="style"`, JS otherwise). No
+										// sibling tags — a resource hint references exactly one URL.
+										if (type === "preload" || type === "prefetch") {
+											const as = getAttributeValue(getAttributesMap(), "as");
+											const asStyle = as
+												? as.trim().toLowerCase() === "style"
+												: false;
+											const entryName = `__html_${moduleHash}_${nextEntryIndex++}`;
+											// Tag metadata so the template can mirror `crossorigin`/
+											// `integrity` onto a native `preload` `<link>` (integrity-
+											// eligible per the SRI spec). `prefetch` gets none — the spec
+											// doesn't list it — so its `integrity` is left uncaptured.
+											const isNativeLink = elementName === "link";
+											const dep = new HtmlEntryDependency(
+												request,
+												[s, e],
+												entryName,
+												asStyle ? "css-import" : undefined,
+												type,
+												elementStart,
+												tagEnd,
+												isNativeLink,
+												"",
+												nameEnd,
+												isNativeLink && path.findAttribute("crossorigin") !== 0,
+												-1,
+												type === "preload" && isNativeLink
+													? captureIntegrityRange(path, source, elementStart)
+													: null,
+												null
+											);
+											setLoc(dep, s, e);
+											module.addPresentationalDependency(dep);
+											(type === "preload"
+												? preloadEntries
+												: prefetchEntries
+											).push({
+												request,
+												entryName,
+												type,
+												css: asStyle
+											});
+											continue;
+										}
+										// `src`/`srcset`/`css-url`/`msapplication-task` are plain assets;
+										// the rest are narrowed to entry types here and share one
+										// `HtmlEntryDependency`, recorded for HtmlModulesPlugin.
+										if (
+											type === "script" ||
+											type === "script-module" ||
+											type === "modulepreload" ||
+											type === "stylesheet"
+										) {
+											const entryName = `__html_${moduleHash}_${nextEntryIndex++}`;
+											const willBeModuleScript =
+												type === "script-module" ||
+												(outputModule && type === "script");
+											/** @type {EntrySourceType} */
+											const elementKind =
+												type === "modulepreload"
+													? "modulepreload"
+													: type === "stylesheet"
+														? "stylesheet"
+														: willBeModuleScript
+															? "script-module"
+															: "script";
+											const entryCategory =
+												type === "stylesheet"
+													? "css-import"
+													: type === "script-module" || type === "modulepreload"
+														? "esm"
+														: undefined;
+											// Native = the loading element is the tag the template clones
+											// verbatim (`<script>` / `<link>`); a custom element is not.
+											const nativeTag =
+												elementKind === "stylesheet" ||
+												elementKind === "modulepreload"
+													? "link"
+													: "script";
+											// CSP/fetch attributes the template copies onto siblings.
+											let copyableAttrsText = "";
+											let hasOwnCrossOrigin = false;
+											if (elementStart >= 0) {
+												for (const copyableName of COPYABLE_SIBLING_ATTRS) {
+													const copyableAttr = path.findAttribute(copyableName);
+													if (copyableAttr !== 0) {
+														copyableAttrsText += attrSourceSpan(
+															path,
+															source,
+															copyableAttr
+														);
+														if (copyableName === "crossorigin") {
+															hasOwnCrossOrigin = true;
+														}
+													}
+												}
+											}
+											// Blocking-ness of the tag as *emitted*:
+											// `reconcileScriptTypeAttr` upgrades every script entry
+											// to `type="module"` under `output.module` and strips an
+											// authored `type="module"` otherwise — so only non-module
+											// output without `defer`/`async` blocks. Non-native
+											// elements anchor conservatively (their synthesized
+											// siblings may be plain blocking `<script>`s).
+											if (
+												firstBlockingScriptStart === -1 &&
+												(type === "script" || type === "script-module") &&
+												!outputModule &&
+												(elementName !== nativeTag ||
+													(path.findAttribute("defer") === 0 &&
+														path.findAttribute("async") === 0))
+											) {
+												firstBlockingScriptStart = elementStart;
+											}
+											// Sibling-clone attribute edits, captured from the parsed
+											// attributes (offsets relative to the tag) so the template
+											// needn't re-parse the tag text: `integrity` is dropped
+											// (content-specific) and `script-module` clones are forced
+											// to `type="module"` (its value range, else inserted).
+											const integrityRange =
+												elementStart >= 0 && elementName === nativeTag
+													? captureIntegrityRange(path, source, elementStart)
+													: null;
+											/** @type {Range | null} */
+											let typeValueRange = null;
+											if (
+												elementStart >= 0 &&
+												elementName === nativeTag &&
+												elementKind === "script-module"
+											) {
+												const typeAttr = path.findAttribute("type");
+												if (
+													typeAttr !== 0 &&
+													path.attributeValueStart(typeAttr) >= 0
+												) {
+													typeValueRange = [
+														path.attributeValueStart(typeAttr) - elementStart,
+														path.attributeValueEnd(typeAttr) - elementStart
+													];
+												}
+											}
+											const dep = new HtmlEntryDependency(
+												request,
+												[s, e],
+												entryName,
+												entryCategory,
+												elementKind,
+												elementStart,
+												tagEnd,
+												elementName === nativeTag,
+												copyableAttrsText,
+												nameEnd,
+												hasOwnCrossOrigin,
+												firstBlockingScriptStart,
+												integrityRange,
+												typeValueRange,
+												forceInline,
+												headSeen && headStart > 0 ? headStart : -1,
+												headSeen && headLastEnd > 0 ? headLastEnd : -1
+											);
+											setLoc(dep, s, e);
+											module.addPresentationalDependency(dep);
+											if (
+												elementName === "script" &&
+												(type === "script" || type === "script-module")
+											) {
+												reconcileScriptTypeAttr(
+													path,
+													path.findAttribute("type"),
+													nameEnd,
+													type,
+													source
+												);
+											}
+											(type === "script"
+												? scriptEntries
+												: type === "script-module"
+													? scriptModuleEntries
+													: type === "stylesheet"
+														? stylesheetEntries
+														: modulePreloadEntries
+											).push({ request, entryName, type });
+										} else {
+											const dep = new HtmlSourceDependency(request, [s, e]);
+											ResourceHintPlugin.applyDefaults(
+												dep,
+												ResourceHintPlugin.matchUrlHints(urlHints, request)
+											);
+											// `<!-- webpackPrefetch: true -->` (etc.) immediately
+											// before this tag wins over the project-wide default.
+											if (pendingHints) {
+												ResourceHintPlugin.applyParsedHints(dep, pendingHints);
+												pendingHints = undefined;
+											}
+											setLoc(dep, s, e);
+											module.addDependency(dep);
+											module.addCodeGenerationDependency(dep);
+										}
+									}
+									break;
+								}
+							}
+						}
+					},
+					exit: (path) => {
+						if (path.namespace() === NS_HTML) {
+							const name = path.tagName();
+							if (name === "template") {
+								if (templateDepth > 0) templateDepth--;
+								if (headTemplateDepth > 0) headTemplateDepth--;
+							} else if (name === "head") {
+								inHead = false;
+							}
+						}
+						pendingWebpackIgnore = undefined;
+						pendingWebpackInline = undefined;
+						pendingHints = undefined;
+					}
+				}
+			})
+			// Skip AST output this walk never reads: `text` (script/style bodies are
+			// read by offset via `contentEnd`) and `doctype` — unless head injection
+			// needs the doctype as an insertion anchor; keep `comments` for
+			// magic comments (`webpackIgnore`).
+			.process(source, {
+				fragmentContext: this.fragmentContext,
+				skip: { text: true, doctype: headOptions === undefined }
+			});
+
+		// `output.html` head injection: existing tags win, injected values are
+		// escaped, insertions at the same offset are merged to keep their order.
+		if (headOptions !== undefined && headSeen) {
+			const { title, meta, base } = headOptions;
+			let startTags = "";
+			if (meta && meta.charset && headCharsetEnd === -1) {
+				startTags += `<meta charset="${escapeAttribute(meta.charset)}">`;
+			}
+			// <base> must follow the charset declaration per spec
+			let baseAfterCharset = "";
+			if (base && !headHasBase) {
+				if (headCharsetEnd !== -1) baseAfterCharset = baseTag(base);
+				else startTags += baseTag(base);
+			}
+			let endTags = "";
+			if (meta) {
+				for (const [name, value] of Object.entries(meta)) {
+					if (
+						name === "charset" ||
+						(headMetaNames !== undefined &&
+							headMetaNames.has(name.toLowerCase()))
+					) {
+						continue;
+					}
+					endTags += metaTag(name, value);
+				}
+			}
+			if (title && !headHasTitle) {
+				endTags += `<title>${escapeText(title)}</title>`;
+			}
+			/** @type {[number, string][]} */
+			const inserts = [];
+			if (startTags) inserts.push([headStart, startTags]);
+			if (baseAfterCharset) inserts.push([headCharsetEnd, baseAfterCharset]);
+			if (endTags) inserts.push([headLastEnd, endTags]);
+			inserts.sort((a, b) => a[0] - b[0]);
+			for (let i = 0; i < inserts.length; i++) {
+				const at = inserts[i][0];
+				let tags = inserts[i][1];
+				while (i + 1 < inserts.length && inserts[i + 1][0] === at) {
+					tags += inserts[++i][1];
+				}
+				module.addPresentationalDependency(new ConstDependency(tags, at));
+			}
+		}
+
+		const buildInfo = /** @type {HtmlModuleBuildInfo} */ (module.buildInfo);
+		buildInfo.strict = true;
+		if (baseUrlPrefix !== undefined) buildInfo.baseUrlPrefix = baseUrlPrefix;
+		// Hand off the collected entries to HtmlModulesPlugin; it creates the
+		// real compilation entries during the finishMake hook. The `script`
+		// and `script-module` groups are chained via a leader-only dependOn
+		// so they share a runtime; `modulepreload` and `stylesheet` entries
+		// are emitted as independent entries since `<link rel=modulepreload>`
+		// must preload without running and stylesheets have no runtime. `html`
+		// links are independent page entries too.
+		if (
+			scriptEntries.length > 0 ||
+			scriptModuleEntries.length > 0 ||
+			modulePreloadEntries.length > 0 ||
+			stylesheetEntries.length > 0 ||
+			htmlLinkEntries.length > 0 ||
+			preloadEntries.length > 0 ||
+			prefetchEntries.length > 0
+		) {
+			buildInfo.htmlEntries = {
+				script: scriptEntries,
+				"script-module": scriptModuleEntries,
+				modulepreload: modulePreloadEntries,
+				stylesheet: stylesheetEntries,
+				html: htmlLinkEntries,
+				preload: preloadEntries,
+				prefetch: prefetchEntries
+			};
+		}
+
+		const buildMeta = /** @type {BuildMeta} */ (state.module.buildMeta);
+		buildMeta.exportsType = "default";
+
+		state.module.addDependency(new StaticExportsDependency(["default"], true));
+
+		return state;
+	}
+}
+
+HtmlParser.buildHeadTags = buildHeadTags;
+
+module.exports = HtmlParser;