githubmirror/webpack

lib/html/HtmlParser.js
1 970 строк73 KB
Alexander Akait
perf: faster JS, CSS and HTML syntax parsers with less heap churn (#21461)
21 июл 2026, 09:07
21 июл 2026, 09:07d3c2c4e
/*
	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;