webpack 5.111.0 → 5.111.1

package/lib/html/HtmlParser.js

@@ -90,10 +90,9 @@ const STYLE_ATTR_URL_REGEXP = /url\(|src\(|image\(|image-set\(/i;
 // 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.
+// Cheap pre-filter for `<iframe srcdoc>`: a nested HTML module is only worth
+// building when the markup can reference an asset — any attribute, a CSS
+// `url(...)` or an `@import`. Pure text markup rewrites to itself.
 const SRCDOC_ASSET_REGEXP = /[=]|url\(|@import/i;
 
 // A URL carrying its own scheme (`https:`, `data:`, …) ignores the document
@@ -370,10 +369,9 @@ const isLinkStylesheet = (attributes) => {
  */
 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`.
+// One shared `SourceItem` per kind, so the walk's lookups stay on a single V8
+// hidden class. `srcset` is its own type: the walk picks `parseSrcset` for it
+// and otherwise treats it like `src`.
 /** @type {SourceItem} */
 const PLAIN_SRC = { type: "src", filter: undefined };
 /** @type {SourceItem} */
@@ -389,10 +387,9 @@ 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.
+		// `rel="preload"/"prefetch"` with `as="script"` — or `as="style"` under
+		// `experiments.css` — becomes a non-executing entry pointing at the built
+		// chunk; every other `as` target stays a plain asset URL.
 		const rel = getAttributeValue(attrs, "rel");
 		if (rel) {
 			const rels = rel.trim().toLowerCase().split(/\s+/);
@@ -446,11 +443,9 @@ const META_CONTENT = {
 	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.
+// Written in its final resolved shape, `[tag][attribute] = item`, rather than
+// built from an array at module load: a parser on the default `sources` config
+// references this table and pays nothing per instance.
 /** @type {Record<string, Record<string, SourceItem>>} */
 const DEFAULT_SOURCES_BY_TAG = dict({
 	// Obsolete Java-applet element; `code`/`object` are single class/object URLs.
@@ -489,13 +484,14 @@ const DEFAULT_SOURCES_BY_TAG = dict({
 	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).
+	// WHY: SVG. Tag names match the tree builder's adjusted camelCase
+	// (`feImage`/`textPath`/`linearGradient`/`radialGradient`). `href` and
+	// `xlink:href` reference another element or resource, and a fragment-only
+	// `#id` value is left untouched, so only an external `file.svg#id` is
+	// rewritten. `color-profile`'s `xlink:href` points at an external ICC profile
+	// file; `cursor` and `font-face-uri` at an external image or font file; and
+	// `altGlyph`, `glyphRef` and `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 }),
@@ -515,11 +511,11 @@ const DEFAULT_SOURCES_BY_TAG = dict({
 	// 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`).
+// WHY: SVG presentation attributes (`fill`, `stroke`, …) carry CSS `url(...)`
+// FuncIRIs, whose external refs `parseCssUrls` extracts as assets, leaving an
+// internal `url(#id)` untouched. They apply to every SVG-namespace element, so
+// the item is `namespace`-gated rather than placed in a tag bucket, and the
+// filter is a cheap pre-check skipping the common plain values (`red`, `none`).
 /** @type {SourceItem} */
 const SVG_CSS_URL = {
 	type: "css-url",
@@ -527,21 +523,18 @@ const SVG_CSS_URL = {
 	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()`/… .
+// The global `style=""` attribute, available on every tag and even under
+// `sources: false`. Like every `stylesheet-style*` source it only emits when
+// `experiments.css` is on, checked where the dependency is created.
 /** @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`.
+// Any-tag sources, folded into each tag bucket so the walk resolves one object
+// per element and one property per attribute. `sources: false` leaves only the
+// always-on style attribute.
 /** @type {Record<string, SourceItem>} */
 const DEFAULT_ANY_SOURCES = dict({ style: STYLE_ATTRIBUTE });
 for (const name of [
@@ -625,10 +618,9 @@ const styleContentFilter = (attrs) => {
 	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).
+// Element-body sources, independent of the `sources` option: a `<script>` body
+// is always processed, while a `<style>` body only emits when `experiments.css`
+// is on, checked where the dependency is created.
 /** @type {Record<string, ContentSourceItem>} */
 const CONTENT_SOURCES = dict({
 	script: { type: scriptContentType, filter: scriptContentFilter },
@@ -649,11 +641,9 @@ class HtmlParser extends Parser {
 		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.
+		// `as` selects the parse mode: `"document"` parses a full page, any other
+		// value names the context element whose inner HTML this is, so that a
+		// partial's `<tr>`, `<td>` or `<option>` is kept rather than dropped.
 		/** @type {string | undefined} */
 		this.fragmentContext =
 			options.as === undefined || options.as === "document"
@@ -673,13 +663,9 @@ class HtmlParser extends Parser {
 			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.
+		// `"..."` anywhere opts the per-tag defaults in as the base, and a user
+		// entry with no `tag` is an any-tag source; user entries override wherever
+		// they sit. Per-tag writes rebuild the bucket, so the defaults stay intact.
 		/** @type {SourceTable} */
 		const byTag = sources.includes("...")
 			? dict(DEFAULT_SOURCES_BY_TAG)
@@ -804,14 +790,9 @@ class HtmlParser extends Parser {
 		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.
+		// Per-module prefix keeping generated entry names from colliding across the
+		// HTML modules of one compilation. It hashes `module.resource` rather than
+		// `identifier()`, whose `html|` prefix `contextify` would leave absolute.
 		/** @type {string} */
 		const resource =
 			/** @type {EXPECTED_ANY} */ (module).resource || module.identifier();
@@ -820,11 +801,9 @@ class HtmlParser extends Parser {
 			.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.
+		// `output.html` head injection collects facts during the walk and turns
+		// them into presentational dependencies after, so no later pass re-parses
+		// the page. `data:` documents are skipped — they already carry the tags.
 		const htmlOutputOptions =
 			compilation.options && compilation.options.output
 				? compilation.options.output.html
@@ -846,10 +825,9 @@ class HtmlParser extends Parser {
 		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).
+		// Depth of open `<template>` elements anywhere in the tree: their content
+		// is an inert fragment, so a `<base>` inside one must not set the document
+		// base. `headTemplateDepth` covers only `<head>`, so it cannot guard this.
 		let templateDepth = 0;
 		let headHasTitle = false;
 		let headHasBase = false;
@@ -857,13 +835,9 @@ class HtmlParser extends Parser {
 		/** @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.
+		// Collected per type during the walk; HtmlModulesPlugin turns them into
+		// entries. `script` and `script-module` chain through a leader-only
+		// dependOn; modulepreload stays independent, as it must not run.
 		/**
 		 * @typedef {object} HtmlEntryInfo
 		 * @property {string} request
@@ -892,28 +866,26 @@ class HtmlParser extends Parser {
 		/** @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).
+		// Offset of the first classic blocking script tag, which injected stylesheet
+		// `<link>`s stay ahead of. `defer`/`async`/module scripts do not anchor: they
+		// run after parsing and after pending stylesheets.
 		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).
+		// WHY: `<base href>` resolves the relative URLs that follow it. A relative base
+		// (`./assets/`) rewrites them into a subdirectory and they stay bundled; a
+		// root-relative or absolute one (`/`, `https://cdn/`) points outside the
+		// build, so those URLs are left untouched. Resolved in the walk below from
+		// the first `<base href>` seen, `documentBase` being 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).
+		// Prepended to the emitted URLs' auto-public-path undo path: the browser
+		// resolves them against the base dir, so one `../` per base segment cancels
+		// it. Undefined for an absolute publicPath, which emits no undo path.
 		/** @type {string | undefined} */
 		let baseUrlPrefix;
 
@@ -1017,10 +989,9 @@ class HtmlParser extends Parser {
 				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.
+			// Normalize the base path into descending directory segments, resolving
+			// `.`/`..` as the URL spec does. The final segment names a file and is
+			// dropped; `up` counts the `..`s climbing above the document dir.
 			const parts = documentBase.split("/");
 			/** @type {string[]} */
 			const dirs = [];
@@ -1070,9 +1041,8 @@ class HtmlParser extends Parser {
 		};
 
 		// 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).
+		// The walker descends into children and `<template>` content itself, and the
+		// Element `exit` clears a pending `webpackIgnore` once they are done.
 		new SourceProcessor()
 			.use({
 				[NodeType.Comment]: (path) => {
@@ -1220,9 +1190,8 @@ class HtmlParser extends Parser {
 						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
+						// `<head>` anchors are collected for every page, since they place
+						// `inject: "head"` siblings and resource hints. Structural, so this
 						// runs even for `webpackIgnore`d elements.
 						{
 							const name = path.tagName();
@@ -1447,11 +1416,9 @@ class HtmlParser extends Parser {
 									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.
+								// `<iframe srcdoc>` is an entity-encoded document, fed back through
+								// the pipeline as a nested `data:text/html` module. Its URL is
+								// `about:srcdoc`, so asset URLs resolve against this file.
 								case "srcdoc": {
 									const htmlText = decodeEntities(value, true);
 									// Only spin up a nested module when there is markup that can
@@ -1579,10 +1546,9 @@ class HtmlParser extends Parser {
 										}
 										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.
+										// `html` links the URL as its own emitted page: the same dependency
+										// as `<script src>`, but rewriting to the page's filename and
+										// emitting no siblings. Independent, like an entry point.
 										if (type === "html") {
 											const index = nextEntryIndex++;
 											const entryName = `__html_${moduleHash}_${index}`;
@@ -1598,10 +1564,9 @@ class HtmlParser extends Parser {
 											htmlLinkEntries.push({ request, entryName, index, 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.
+										// `rel="preload"/"prefetch"` of a bundled resource: an independent,
+										// non-executing entry rewritten to the built chunk's URL. No
+										// siblings — a resource hint references exactly one URL.
 										if (type === "preload" || type === "prefetch") {
 											const as = getAttributeValue(getAttributesMap(), "as");
 											const asStyle = as
@@ -1609,10 +1574,9 @@ class HtmlParser extends Parser {
 												: false;
 											const index = nextEntryIndex++;
 											const entryName = `__html_${moduleHash}_${index}`;
-											// 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.
+											// Tag metadata letting the template mirror `crossorigin` and
+											// `integrity` onto a native `preload` `<link>`. `prefetch` is not
+											// integrity-eligible per the SRI spec, so its is left uncaptured.
 											const isNativeLink = elementName === "link";
 											const dep = new HtmlEntryDependency(
 												request,
@@ -1700,13 +1664,9 @@ class HtmlParser extends Parser {
 													}
 												}
 											}
-											// 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).
+											// Blocking-ness of the tag as emitted, not as authored:
+											// `reconcileScriptTypeAttr` decides the final `type`, so only
+											// non-module output without `defer`/`async` blocks.
 											if (
 												firstBlockingScriptStart === -1 &&
 												(type === "script" || type === "script-module") &&
@@ -1717,11 +1677,9 @@ class HtmlParser extends Parser {
 											) {
 												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).
+											// Sibling-clone attribute edits, captured as offsets relative to
+											// the tag so the template need not re-parse it: `integrity` is
+											// content-specific and dropped, `script-module` forces `type`.
 											const integrityRange =
 												elementStart >= 0 && elementName === nativeTag
 													? captureIntegrityRange(path, source, elementStart)
@@ -1823,10 +1781,9 @@ class HtmlParser extends Parser {
 					}
 				}
 			})
-			// 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`).
+			// Skip AST output this walk never reads: `text`, since script and style
+			// bodies are read by offset, and `doctype` unless head injection needs it
+			// as an anchor. `comments` stays, for `webpackIgnore`.
 			.process(source, {
 				fragmentContext: this.fragmentContext,
 				skip: { text: true, doctype: headOptions === undefined }
@@ -1881,13 +1838,12 @@ class HtmlParser extends Parser {
 		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.
+		// WHY: hand the collected entries to HtmlModulesPlugin, which creates the
+		// real compilation entries during the finishMake hook. The `script` and
+		// `script-module` groups chain through a leader-only `dependOn` so they share
+		// a runtime, while `modulepreload` and `stylesheet` entries are independent:
+		// `<link rel=modulepreload>` must preload without running, and a stylesheet
+		// has no runtime. `html` links are independent page entries too.
 		if (
 			scriptEntries.length > 0 ||
 			scriptModuleEntries.length > 0 ||

package/lib/html/data.js

@@ -130,6 +130,7 @@ const REWRITABLE_ATTRIBUTES = new Set([
 	"blocking",
 	"cite",
 	"class",
+	"closedby",
 	"codebase",
 	"cols",
 	"colspan",
@@ -170,6 +171,7 @@ const REWRITABLE_ATTRIBUTES = new Set([
 	"part",
 	"ping",
 	"popover",
+	"popovertargetaction",
 	"poster",
 	"preload",
 	"referrerpolicy",
@@ -180,6 +182,7 @@ const REWRITABLE_ATTRIBUTES = new Set([
 	"scope",
 	"scrollamount",
 	"scrolldelay",
+	"shadowrootmode",
 	"size",
 	"sizes",
 	"span",
@@ -206,6 +209,7 @@ const REWRITABLE_ATTRIBUTES = new Set([
 const ENUMERATED_ATTRIBUTE_NAMES = new Set([
 	"autocapitalize",
 	"autocomplete",
+	"closedby",
 	"contenteditable",
 	"crossorigin",
 	"decoding",
@@ -222,9 +226,11 @@ const ENUMERATED_ATTRIBUTE_NAMES = new Set([
 	"loading",
 	"method",
 	"popover",
+	"popovertargetaction",
 	"preload",
 	"referrerpolicy",
 	"scope",
+	"shadowrootmode",
 	"spellcheck",
 	"translate",
 	"type",
@@ -1767,8 +1773,12 @@ const ENUMERATED_KEYWORDS = Object.assign(Object.create(null), {
 			"text/plain"
 		]),
 		formmethod: new Set(["get", "post", "dialog"]),
+		popovertargetaction: new Set(["toggle", "show", "hide"]),
 		type: new Set(["submit", "reset", "button"])
 	}),
+	dialog: Object.assign(Object.create(null), {
+		closedby: new Set(["any", "closerequest", "none"])
+	}),
 	form: Object.assign(Object.create(null), {
 		autocomplete: new Set(["on", "off"]),
 		enctype: new Set([
@@ -1794,6 +1804,7 @@ const ENUMERATED_KEYWORDS = Object.assign(Object.create(null), {
 			"text/plain"
 		]),
 		formmethod: new Set(["get", "post", "dialog"]),
+		popovertargetaction: new Set(["toggle", "show", "hide"]),
 		type: new Set([
 			"hidden",
 			"text",
@@ -1830,6 +1841,9 @@ const ENUMERATED_KEYWORDS = Object.assign(Object.create(null), {
 	td: Object.assign(Object.create(null), {
 		scope: new Set(["row", "col", "rowgroup", "colgroup"])
 	}),
+	template: Object.assign(Object.create(null), {
+		shadowrootmode: new Set(["open", "closed"])
+	}),
 	th: Object.assign(Object.create(null), {
 		scope: new Set(["row", "col", "rowgroup", "colgroup"])
 	}),
@@ -1848,6 +1862,12 @@ const ENUMERATED_KEYWORDS = Object.assign(Object.create(null), {
 	})
 });
 
+/**
+ * `<element> <attribute>` for each enumerated attribute whose invalid value default names a different state from its missing value default, so a value matching no keyword may not be dropped as redundant.
+ * @type {Set<string>}
+ */
+const INVALID_VALUE_DEFAULT_DIFFERS = new Set(["track kind"]);
+
 /**
  * Elements `removeEmptyElements` never drops: with no children and no attributes each is still doing its job, so an empty one is not a leftover.
  * @type {Set<string>}
@@ -1991,6 +2011,7 @@ module.exports.IGNORED_BODY_TABLE_STARTS = IGNORED_BODY_TABLE_STARTS;
 module.exports.IMPLIED = IMPLIED;
 module.exports.IMPLIED_THOROUGH = IMPLIED_THOROUGH;
 module.exports.INTEGER_ATTRIBUTES = INTEGER_ATTRIBUTES;
+module.exports.INVALID_VALUE_DEFAULT_DIFFERS = INVALID_VALUE_DEFAULT_DIFFERS;
 module.exports.IN_HEAD_NOSCRIPT_PASSTHROUGH = IN_HEAD_NOSCRIPT_PASSTHROUGH;
 module.exports.IN_TABLE_IGNORED_ENDS = IN_TABLE_IGNORED_ENDS;
 module.exports.JAVASCRIPT_SCRIPT_TYPES = JAVASCRIPT_SCRIPT_TYPES;

package/lib/html/htmlMinify.js

@@ -44,8 +44,6 @@ const htmlMinify = async (input, sourceMap, minimizerOptions = {}) => {
 		require(/** @type {string} */ ("webpack"))
 	);
 
-	// TODO widen the value rewrites the switches below name: an enumerated
-	// value the spec does not name.
 	const {
 		askEmbeddedRenderer,
 		builtinEmbeddedRenderer,
@@ -105,9 +103,10 @@ const htmlMinify = async (input, sourceMap, minimizerOptions = {}) => {
 		sortTokenLists,
 		removeImpliedTags
 	};
-	// Handed each body the print offers, with what it reported kept: how the
-	// element or attribute around one is written is decided from the answer, and
-	// a body declined or thrown on is spelled as an untapped run spells it.
+	// Handed each body the print offers, keeping what it reported: the element or
+	// attribute around one is written from that answer, and a body declined or
+	// thrown on is spelled as an untapped run spells it.
+
 	// A caller's renderer is asked first; whatever it declines this minifies
 	// itself, for the languages webpack ships a minifier for.
 	const renderer = async (
@@ -151,8 +150,9 @@ const htmlMinify = async (input, sourceMap, minimizerOptions = {}) => {
 
 	// Recursion goes through this local name, never the module's own: the plugin
 	// ships this function to its workers as source, where that binding is absent.
-	// A marker cannot cross a parse — the HTML preprocessor turns its NUL into
-	// U+FFFD — so each nested document is finished before it is spliced in.
+
+	// A marker cannot cross a parse, the preprocessor turning its NUL into U+FFFD,
+	// so each nested document is finished before it is spliced in.
 	/**
 	 * @param {string} text a whole document
 	 * @returns {Promise<string>} the same document, minified
@@ -246,10 +246,9 @@ htmlMinify.getEmbeddedTypes = () => {
 	return languages;
 };
 
-// When several minify functions share one `minimizer-webpack-plugin` instance,
-// each asset is dispatched only to the ones whose `filter` accepts it — this
-// claims HTML, so terser (JS), cssMinify and this can coexist in a single
-// plugin / worker pool.
+// Sharing one `minimizer-webpack-plugin` instance, each asset reaches only the
+// minify functions whose `filter` accepts it. This claims HTML, so terser and
+// cssMinify coexist with it in one worker pool.
 /**
  * @param {string} name asset filename
  * @returns {boolean} true for HTML assets