@depup/webpack 5.110.1-depup.0 → 5.110.3-depup.0

package/lib/html/syntax.js

@@ -12,7 +12,7 @@ const {
 } = require("../ModuleSourceTypeConstants");
 const GenericSourceProcessor = require("../util/SourceProcessor");
 
-const { deferredWrite } = GenericSourceProcessor;
+const { deferredWrite, declineDeferredWrites } = GenericSourceProcessor;
 
 /** @import { CssEnvironment, CssProcessOptions, CssTransformOptions } from "../css/syntax" */
 /** @import { OutputHtmlOptions } from "../../declarations/WebpackOptions" */
@@ -5237,11 +5237,13 @@ const _makeProcessingInstructionNode = (target, data, start, end) => {
 // Marker entry in the active-formatting-elements list (never a valid ref).
 const AFE_MARKER = -1;
 
-// Clone of an element's attribute run: keep name/value (and the serializer
-// name flag) but drop source offsets so the consumer doesn't emit a duplicate
-// dependency for the reopened element's spans. Values are materialized since
-// the offsets are gone.
-const cloneAttrs = (/** @type {HtmlElement} */ el) => {
+/**
+ * Clones an element's attribute run, dropping source offsets so the consumer
+ * emits no duplicate dependency for the reopened element's spans.
+ * @param {HtmlElement} el element whose attributes are cloned
+ * @returns {AttributeRun} the cloned run
+ */
+const cloneAttrs = (el) => {
 	const start = _nodeAttrStarts[el];
 	const count = _nodeAttrCounts[el];
 	const newStart = _attrCount + 1;
@@ -5252,14 +5254,15 @@ const cloneAttrs = (/** @type {HtmlElement} */ el) => {
 	return { start: newStart, count };
 };
 
-// Merge a repeated `<html>`/`<body>` tag's attributes into the element: only
-// names not already present are added (in source order after the existing
-// ones). Runs are contiguous, so any addition re-allocates the whole run; the
-// old slots are orphaned (at most once per repeated tag, rare).
-const mergeAttrs = (
-	/** @type {HtmlElement} */ el,
-	/** @type {AttributeRun} */ run
-) => {
+/**
+ * Merges a repeated `<html>`/`<body>` tag's attributes into the element, adding
+ * only names not already present. Runs are contiguous, so any addition
+ * re-allocates the whole run and orphans the old slots.
+ * @param {HtmlElement} el element receiving the attributes
+ * @param {AttributeRun} run attributes of the repeated tag
+ * @returns {void}
+ */
+const mergeAttrs = (el, run) => {
 	const start = _nodeAttrStarts[el];
 	const count = _nodeAttrCounts[el];
 	let extra = 0;
@@ -5335,9 +5338,13 @@ const TOKEN_PROCESSING_INSTRUCTION = 7;
 /** @typedef {{ type: typeof TOKEN_EOF }} EofToken */
 /** @typedef {{ type: typeof TOKEN_PROCESSING_INSTRUCTION, name: string, data: string, start: number, end: number }} ProcessingInstructionToken the target rides in `name`, as the doctype's does */
 
-// Every insertion mode handles a processing instruction token on the same arc
-// as a comment token, so the arcs test both.
-const isCommentOrProcessingInstruction = (/** @type {Token} */ t) =>
+/**
+ * Every insertion mode handles a processing instruction token on the same arc
+ * as a comment token, so the arcs test both.
+ * @param {Token} t current token
+ * @returns {t is CommentToken | ProcessingInstructionToken} true for a comment or processing instruction token
+ */
+const isCommentOrProcessingInstruction = (t) =>
 	t.type === TOKEN_COMMENT || t.type === TOKEN_PROCESSING_INSTRUCTION;
 
 /**
@@ -5399,9 +5406,12 @@ const TEMPLATE_START_TAG_MODES = new Map(
 	})
 );
 
-// MathML/SVG specials handled via namespace checks below.
-
-const isSpecial = (/** @type {HtmlElement} */ el) => {
+/**
+ * MathML/SVG specials are handled via namespace checks rather than one table.
+ * @param {HtmlElement} el element to test
+ * @returns {boolean} true when the element is "special" (§13.2.4.2)
+ */
+const isSpecial = (el) => {
 	const ns = _namespaceOf(el);
 	const tag = _tagNameOf(el);
 	if (ns === NS_HTML) return SPECIAL.has(tag);
@@ -5410,8 +5420,12 @@ const isSpecial = (/** @type {HtmlElement} */ el) => {
 	return false;
 };
 
-// `<font color|face|size>` breaks out of foreign content (§13.2.6.5).
-const hasFontBreakoutAttr = (/** @type {AttributeRun} */ run) => {
+/**
+ * `<font color|face|size>` breaks out of foreign content (§13.2.6.5).
+ * @param {AttributeRun} run the tag's attributes
+ * @returns {boolean} true when one of the breakout attributes is present
+ */
+const hasFontBreakoutAttr = (run) => {
 	for (let i = run.start; i < run.start + run.count; i++) {
 		if (FONT_BREAKOUT_ATTRS.has(_attrNames[i])) return true;
 	}
@@ -5590,9 +5604,13 @@ const ATTR_NAME_INTERN = buildNameInternTable(
 	)
 );
 
-// Hoisted so the many `open.some(...)` "is there an open HTML <template>?"
-// checks reuse one predicate instead of allocating an arrow per call.
-const isHtmlTemplateEl = (/** @type {HtmlElement} */ e) =>
+/**
+ * Hoisted so the many `open.some(...)` "is there an open HTML `<template>`?"
+ * checks reuse one predicate instead of allocating an arrow per call.
+ * @param {HtmlElement} e element to test
+ * @returns {boolean} true for an HTML `<template>` element
+ */
+const isHtmlTemplateEl = (e) =>
 	_tagNameOf(e) === "template" && _namespaceOf(e) === NS_HTML;
 
 /**
@@ -5651,12 +5669,15 @@ const isQuirky = (name, pub, sys) => {
 	return false;
 };
 
-const mkEl = (
-	/** @type {string} */ tagName,
-	/** @type {number} */ ns,
-	/** @type {AttributeRun} */ attrs,
-	/** @type {TagPos | null | undefined} */ pos
-) => {
+/**
+ * Allocates an element node.
+ * @param {string} tagName tag name
+ * @param {number} ns namespace flag (`NS_HTML`, `NS_MATHML`, `NS_SVG`)
+ * @param {AttributeRun} attrs the element's attributes
+ * @param {TagPos | null | undefined} pos source position, absent for synthesized elements
+ * @returns {HtmlElement} the new element
+ */
+const mkEl = (tagName, ns, attrs, pos) => {
 	// Inlined element allocation: every column is written exactly once (the
 	// generic _allocNode would zero five columns mkEl immediately overwrites).
 	const el = ++_nodeCount;
@@ -5702,7 +5723,12 @@ const effParent = (parent) => {
 	return tc !== 0 ? tc : parent;
 };
 
-const isScopeBoundary = (/** @type {HtmlElement} */ el) => {
+/**
+ * Elements that stop a "have an element in scope" walk (§13.2.4.2).
+ * @param {HtmlElement} el element to test
+ * @returns {boolean} true when the element bounds a scope
+ */
+const isScopeBoundary = (el) => {
 	if (_namespaceOf(el) === NS_HTML) return HTML_SCOPE.has(_tagNameOf(el));
 	if (_namespaceOf(el) === NS_MATHML) {
 		return MATHML_SPECIAL.has(_tagNameOf(el));
@@ -5713,10 +5739,13 @@ const isScopeBoundary = (/** @type {HtmlElement} */ el) => {
 	return false;
 };
 
-// Attribute values are stored raw (offsets into the source), so two unresolved
-// values compare by range — `_attrValueOf` would slice a string per side just
-// to throw it away.
-/** @type {(i: number, j: number) => boolean} */
+/**
+ * Compares two attribute values, by source range while both are unresolved —
+ * `_attrValueOf` would slice a string per side just to throw it away.
+ * @param {number} i first attribute id
+ * @param {number} j second attribute id
+ * @returns {boolean} true when both values are equal
+ */
 const _attrValueEquals = (i, j) => {
 	if (_attrValues[i] === null && _attrValues[j] === null) {
 		const start = _attrValueStarts[i];
@@ -5736,10 +5765,14 @@ const _attrValueEquals = (i, j) => {
 	return _attrValueOf(i) === _attrValueOf(j);
 };
 
-const sameAttrs = (
-	/** @type {HtmlElement} */ a,
-	/** @type {HtmlElement} */ b
-) => {
+/**
+ * Compares two elements' attribute runs, as the active-formatting-elements
+ * "Noah's Ark" clause does.
+ * @param {HtmlElement} a first element
+ * @param {HtmlElement} b second element
+ * @returns {boolean} true when both carry the same attributes
+ */
+const sameAttrs = (a, b) => {
 	const aStart = _nodeAttrStarts[a];
 	const aCount = _nodeAttrCounts[a];
 	const bStart = _nodeAttrStarts[b];
@@ -5754,12 +5787,20 @@ const sameAttrs = (
 	return true;
 };
 
-const startsWithWs = (/** @type {string} */ s) => {
+/**
+ * @param {string} s text to test
+ * @returns {boolean} true when the text starts with HTML whitespace
+ */
+const startsWithWs = (s) => {
 	const c = s.charCodeAt(0);
 	return c === 0x09 || c === 0x0a || c === 0x0c || c === 0x0d || c === 0x20;
 };
 
-const isAllWs = (/** @type {string} */ s) => {
+/**
+ * @param {string} s text to test
+ * @returns {boolean} true when the text is HTML whitespace only
+ */
+const isAllWs = (s) => {
 	for (let i = 0; i < s.length; i++) {
 		const c = s.charCodeAt(i);
 		// HTML whitespace: tab / LF / FF / CR / space. A charCodeAt loop avoids
@@ -5807,10 +5848,18 @@ const collapseWhitespaceRuns = (s) => {
 	return last === 0 ? s : out + s.slice(last);
 };
 
-const mathmlTextIntegrationPoint = (/** @type {HtmlElement} */ el) =>
+/**
+ * @param {HtmlElement} el element to test
+ * @returns {boolean} true for a MathML text integration point (§13.2.6.5)
+ */
+const mathmlTextIntegrationPoint = (el) =>
 	_namespaceOf(el) === NS_MATHML && MATHML_TEXT_INTEGRATION.has(_tagNameOf(el));
 
-const htmlIntegrationPoint = (/** @type {HtmlElement} */ el) => {
+/**
+ * @param {HtmlElement} el element to test
+ * @returns {boolean} true for an HTML integration point (§13.2.6.5)
+ */
+const htmlIntegrationPoint = (el) => {
 	if (_namespaceOf(el) === NS_MATHML && _tagNameOf(el) === "annotation-xml") {
 		const enc = _findAttr(_nodeAttrStarts[el], _nodeAttrCounts[el], "encoding");
 		if (enc !== 0) {
@@ -5830,13 +5879,14 @@ const htmlIntegrationPoint = (/** @type {HtmlElement} */ el) => {
 	return false;
 };
 
-// Adjust a foreign start tag's attribute run in place (the run is consumed
-// only by this tag's element): SVG camelCase names are rewritten, and
-// namespaced names get the serializer-name flag (see `_attrSerializedName`).
-const adjustForeignAttrs = (
-	/** @type {AttributeRun} */ run,
-	/** @type {number} */ ns
-) => {
+/**
+ * Rewrites SVG camelCase names and flags namespaced ones for the serializer.
+ * In place: the run is consumed only by this tag's element.
+ * @param {AttributeRun} run the tag's attributes
+ * @param {number} ns namespace flag of the tag
+ * @returns {AttributeRun} the same run
+ */
+const adjustForeignAttrs = (run, ns) => {
 	for (let i = run.start; i < run.start + run.count; i++) {
 		const name = _attrNames[i];
 		if (
@@ -5854,9 +5904,13 @@ const adjustForeignAttrs = (
 	return run;
 };
 
-// Only `definitionurl` is rewritten (in place — the run is consumed only by
-// this tag's element); the camelCase name serializes as itself.
-const adjustMathmlAttrs = (/** @type {AttributeRun} */ run) => {
+/**
+ * Only `definitionurl` is rewritten (in place — the run is consumed only by
+ * this tag's element); the camelCase name serializes as itself.
+ * @param {AttributeRun} run the tag's attributes
+ * @returns {AttributeRun} the same run
+ */
+const adjustMathmlAttrs = (run) => {
 	for (let i = run.start; i < run.start + run.count; i++) {
 		if (_attrNames[i] === "definitionurl") _attrNames[i] = "definitionURL";
 	}
@@ -5956,10 +6010,13 @@ const adjustedCurrent = () => {
 	return cur();
 };
 
-const appendTo = (
-	/** @type {HtmlNodeRef} */ parent,
-	/** @type {HtmlNodeRef} */ node
-) => {
+/**
+ * Appends a node, merging it into the previous sibling when both are text.
+ * @param {HtmlNodeRef} parent container
+ * @param {HtmlNodeRef} node node to append
+ * @returns {void}
+ */
+const appendTo = (parent, node) => {
 	const p = effParent(parent);
 	const last = _nodeLastChildren[p];
 	if (
@@ -5979,10 +6036,12 @@ const appendTo = (
 // allocation per inserted node.
 /** @type {InsertionPlace} */
 const sharedPlace = { parent: doc, beforeNode: 0 };
-const placeAt = (
-	/** @type {HtmlNodeRef} */ parent,
-	/** @type {HtmlNodeRef} */ beforeNode
-) => {
+/**
+ * @param {HtmlNodeRef} parent container
+ * @param {HtmlNodeRef} beforeNode node to insert before (`0` = append)
+ * @returns {InsertionPlace} the shared insertion place
+ */
+const placeAt = (parent, beforeNode) => {
 	sharedPlace.parent = parent;
 	sharedPlace.beforeNode = beforeNode;
 	return sharedPlace;
@@ -6030,10 +6089,13 @@ const appropriatePlace = () => {
 	return placeAt(target, 0);
 };
 
-const insertAtPlace = (
-	/** @type {InsertionPlace} */ place,
-	/** @type {HtmlNodeRef} */ node
-) => {
+/**
+ * Inserts a node at an insertion place, appending when `beforeNode` is `0`.
+ * @param {InsertionPlace} place where the node goes
+ * @param {HtmlNodeRef} node node to insert
+ * @returns {void}
+ */
+const insertAtPlace = (place, node) => {
 	const before = place.beforeNode;
 	if (before !== 0) {
 		const p = effParent(place.parent);
@@ -6084,11 +6146,14 @@ const _recordFostered = (table, node) => {
 	_fosteredLog.push(table, node);
 };
 
-const insertCharacters = (
-	/** @type {string} */ data,
-	/** @type {number} */ start,
-	/** @type {number} */ end
-) => {
+/**
+ * Inserts a character run at the appropriate place (§13.2.6.1).
+ * @param {string} data decoded text
+ * @param {number} start source offset of the run
+ * @param {number} end source offset past the run
+ * @returns {void}
+ */
+const insertCharacters = (data, start, end) => {
 	const place = appropriatePlace();
 	if (_nodeTypes[place.parent] === NodeType.Document) return; // never insert text into document
 	// `skip.text`: drop every `Text` node — construction already used the
@@ -6149,11 +6214,12 @@ const insertCharacters = (
 };
 
 /**
+ * Every insertion mode inserts a processing instruction where it inserts a
+ * comment (§13.2.6.4). `skip.comments` drops comments alone.
  * @param {CommentToken | ProcessingInstructionToken} t comment or processing instruction token
  * @param {InsertionPlace=} place explicit insertion place
+ * @returns {void}
  */
-// Every insertion mode inserts a processing instruction where it inserts a
-// comment (§13.2.6.4). `skip.comments` drops comments alone.
 const insertCommentOrProcessingInstruction = (t, place) => {
 	const isPi = t.type === TOKEN_PROCESSING_INSTRUCTION;
 	if (skipComments && !isPi) return;
@@ -6166,11 +6232,14 @@ const insertCommentOrProcessingInstruction = (t, place) => {
 	);
 };
 
-const insertHtmlElement = (
-	/** @type {string} */ tagName,
-	/** @type {AttributeRun} */ attrs,
-	/** @type {TagPos | null} */ pos
-) => {
+/**
+ * Inserts an HTML element and pushes it onto the open element stack.
+ * @param {string} tagName tag name
+ * @param {AttributeRun} attrs the element's attributes
+ * @param {TagPos | null} pos source position, `null` for a synthesized element
+ * @returns {HtmlElement} the inserted element
+ */
+const insertHtmlElement = (tagName, attrs, pos) => {
 	const el = mkEl(tagName, NS_HTML, attrs, pos);
 	const place = appropriatePlace();
 	insertAtPlace(place, el);
@@ -6178,12 +6247,15 @@ const insertHtmlElement = (
 	return el;
 };
 
-const insertForeignElement = (
-	/** @type {string} */ tagName,
-	/** @type {number} */ ns,
-	/** @type {AttributeRun} */ attrs,
-	/** @type {TagPos | null} */ pos
-) => {
+/**
+ * Inserts a MathML/SVG element and pushes it onto the open element stack.
+ * @param {string} tagName tag name
+ * @param {number} ns namespace flag (`NS_MATHML`, `NS_SVG`)
+ * @param {AttributeRun} attrs the element's attributes
+ * @param {TagPos | null} pos source position, `null` for a synthesized element
+ * @returns {HtmlElement} the inserted element
+ */
+const insertForeignElement = (tagName, ns, attrs, pos) => {
 	const el = mkEl(tagName, ns, attrs, pos);
 	const place = appropriatePlace();
 	insertAtPlace(place, el);
@@ -6198,10 +6270,12 @@ const insertForeignElement = (
 const SCOPE_DEFAULT = 0;
 const SCOPE_BUTTON = 1;
 const SCOPE_LIST_ITEM = 2;
-const isBoundaryForKind = (
-	/** @type {HtmlElement} */ el,
-	/** @type {number} */ kind
-) => {
+/**
+ * @param {HtmlElement} el element to test
+ * @param {number} kind scope kind (`SCOPE_DEFAULT`, `SCOPE_BUTTON`, `SCOPE_LIST_ITEM`)
+ * @returns {boolean} true when the element bounds that scope
+ */
+const isBoundaryForKind = (el, kind) => {
 	if (isScopeBoundary(el)) return true;
 	if (_namespaceOf(el) !== NS_HTML) return false;
 	if (kind === SCOPE_BUTTON) return _tagNameOf(el) === "button";
@@ -6210,12 +6284,14 @@ const isBoundaryForKind = (
 	}
 	return false;
 };
-// "have an element in scope": walk the open stack from the top until the
-// named HTML element is found (true) or a scope boundary is hit (false).
-const hasNameInScope = (
-	/** @type {string} */ tagName,
-	/** @type {number} */ kind
-) => {
+/**
+ * "have an element in scope": walks the open stack from the top until the
+ * named HTML element is found (true) or a scope boundary is hit (false).
+ * @param {string} tagName tag name to look for
+ * @param {number} kind scope kind (`SCOPE_DEFAULT`, `SCOPE_BUTTON`, `SCOPE_LIST_ITEM`)
+ * @returns {boolean} true when the element is in that scope
+ */
+const hasNameInScope = (tagName, kind) => {
 	for (let i = open.length - 1; i >= 0; i--) {
 		const el = open[i];
 		if (_namespaceOf(el) === NS_HTML && _tagNameOf(el) === tagName) {
@@ -6225,13 +6301,26 @@ const hasNameInScope = (
 	}
 	return false;
 };
-const inScope = (/** @type {string} */ tagName) =>
-	hasNameInScope(tagName, SCOPE_DEFAULT);
-const inButtonScope = (/** @type {string} */ tagName) =>
-	hasNameInScope(tagName, SCOPE_BUTTON);
-const inListItemScope = (/** @type {string} */ tagName) =>
-	hasNameInScope(tagName, SCOPE_LIST_ITEM);
-const inScopeEl = (/** @type {HtmlElement} */ target) => {
+/**
+ * @param {string} tagName tag name to look for
+ * @returns {boolean} true when the element is in scope
+ */
+const inScope = (tagName) => hasNameInScope(tagName, SCOPE_DEFAULT);
+/**
+ * @param {string} tagName tag name to look for
+ * @returns {boolean} true when the element is in button scope
+ */
+const inButtonScope = (tagName) => hasNameInScope(tagName, SCOPE_BUTTON);
+/**
+ * @param {string} tagName tag name to look for
+ * @returns {boolean} true when the element is in list item scope
+ */
+const inListItemScope = (tagName) => hasNameInScope(tagName, SCOPE_LIST_ITEM);
+/**
+ * @param {HtmlElement} target element to look for
+ * @returns {boolean} true when that element itself is in scope
+ */
+const inScopeEl = (target) => {
 	for (let i = open.length - 1; i >= 0; i--) {
 		const el = open[i];
 		if (el === target) return true;
@@ -6239,8 +6328,11 @@ const inScopeEl = (/** @type {HtmlElement} */ target) => {
 	}
 	return false;
 };
-// `target` is a single tag name (the common case) or a Set of names.
-const inTableScope = (/** @type {string | Set<string>} */ target) => {
+/**
+ * @param {string | Set<string>} target a single tag name (the common case) or a set of names
+ * @returns {boolean} true when one of them is in table scope
+ */
+const inTableScope = (target) => {
 	const set = typeof target === "string" ? null : target;
 	for (let i = open.length - 1; i >= 0; i--) {
 		const el = open[i];
@@ -6279,15 +6371,25 @@ const generateImpliedEndTagsThorough = () => {
 };
 
 // ---- active formatting elements ----
-// `splice` allocates an array for the removed element on every call; the list
-// is short, so shifting in place is both cheaper and allocation-free.
-/** @type {(i: number) => void} */
+
+/**
+ * `splice` allocates an array for the removed element on every call; the list
+ * is short, so shifting in place is both cheaper and allocation-free.
+ * @param {number} i position in `afe` to remove
+ * @returns {void}
+ */
 const afeRemoveAt = (i) => {
 	const last = afe.length - 1;
 	for (let k = i; k < last; k++) afe[k] = afe[k + 1];
 	afe.pop();
 };
-const pushAfe = (/** @type {HtmlElement} */ el) => {
+/**
+ * Pushes a formatting element, applying the "Noah's Ark" clause: a third
+ * equal entry since the last marker drops the earliest of them.
+ * @param {HtmlElement} el formatting element to push
+ * @returns {void}
+ */
+const pushAfe = (el) => {
 	let count = 0;
 	for (let i = afe.length - 1; i >= 0; i--) {
 		const e = afe[i];
@@ -6349,7 +6451,12 @@ const closePElement = () => {
 	}
 };
 
-const popUntil = (/** @type {string} */ tagName) => {
+/**
+ * Pops the open element stack through the named HTML element.
+ * @param {string} tagName tag name to pop through
+ * @returns {void}
+ */
+const popUntil = (tagName) => {
 	while (open.length) {
 		const el = /** @type {HtmlElement} */ (popOpen());
 		_nodeEnds[el] = tokenEnd;
@@ -6358,7 +6465,12 @@ const popUntil = (/** @type {string} */ tagName) => {
 		}
 	}
 };
-const popUntilOneOf = (/** @type {Set<string>} */ set) => {
+/**
+ * Pops the open element stack through the first of the named HTML elements.
+ * @param {Set<string>} set tag names to pop through
+ * @returns {void}
+ */
+const popUntilOneOf = (set) => {
 	while (open.length) {
 		const el = /** @type {HtmlElement} */ (popOpen());
 		_nodeEnds[el] = tokenEnd;
@@ -6432,14 +6544,14 @@ const resetInsertionMode = () => {
 };
 
 // ---------- token processing ----------
-// Split a character token's leading whitespace; per the spec each character
-// is its own token, so a mixed run can straddle a mode change. Inserts the
-// leading whitespace when `insert`, returns the non-whitespace remainder
-// token (or null when the token was entirely whitespace).
-const leadingWs = (
-	/** @type {CharToken} */ t,
-	/** @type {boolean} */ insert
-) => {
+/**
+ * Splits a character token's leading whitespace; per the spec each character
+ * is its own token, so a mixed run can straddle a mode change.
+ * @param {CharToken} t character token
+ * @param {boolean} insert whether to insert the leading whitespace
+ * @returns {CharToken | null} the non-whitespace remainder, `null` when the token was all whitespace
+ */
+const leadingWs = (t, insert) => {
 	const m = /^[\t\n\f\r ]+/.exec(t.data);
 	const ws = m ? m[0] : "";
 	// `t.data` is decoded, the offsets are raw, so counting one in the other
@@ -6458,7 +6570,12 @@ const leadingWs = (
 	};
 };
 
-const process = (/** @type {Token} */ t) => {
+/**
+ * Runs one token through tree construction (§13.2.6).
+ * @param {Token} t token to process
+ * @returns {void}
+ */
+const process = (t) => {
 	// Track the current token's end so explicit closes can set element `.end`.
 	// Dispatch on `type` instead of the `in` operator, which goes megamorphic
 	// across the token union and shows up on the per-token hot path.
@@ -6480,10 +6597,12 @@ const process = (/** @type {Token} */ t) => {
 	runMode(t);
 };
 
-const shouldUseForeignRules = (
-	/** @type {HtmlElement} */ ac,
-	/** @type {Token} */ t
-) => {
+/**
+ * @param {HtmlElement} ac adjusted current node
+ * @param {Token} t token to process
+ * @returns {boolean} true when the token follows the foreign content rules
+ */
+const shouldUseForeignRules = (ac, t) => {
 	if (_namespaceOf(ac) === NS_HTML) return false;
 	if (t.type === TOKEN_START_TAG) {
 		if (
@@ -6513,7 +6632,12 @@ const shouldUseForeignRules = (
 	return false;
 };
 
-const foreignContent = (/** @type {Token} */ t) => {
+/**
+ * "in foreign content" rules (§13.2.6.5).
+ * @param {Token} t token to process
+ * @returns {void}
+ */
+const foreignContent = (t) => {
 	if (t.type === TOKEN_CHAR) {
 		const data = inputHasNul ? t.data.replace(/\0/g, "�") : t.data;
 		insertCharacters(data, t.start, t.end);
@@ -6612,10 +6736,13 @@ const foreignContent = (/** @type {Token} */ t) => {
 };
 
 // ---------- adoption agency algorithm ----------
-const adoptionAgency = (
-	/** @type {string} */ subject,
-	/** @type {TagPos | null} */ pos
-) => {
+/**
+ * Adoption agency algorithm (§13.2.6.4.7).
+ * @param {string} subject tag name of the end tag being handled
+ * @param {TagPos | null} pos source position of that end tag
+ * @returns {boolean} false when the caller must fall back to "any other end tag"
+ */
+const adoptionAgency = (subject, pos) => {
 	// step 1
 	const c = cur();
 	if (
@@ -6752,7 +6879,11 @@ const adoptionAgency = (
 	return true;
 };
 
-const placeForCommonAncestor = (/** @type {HtmlElement} */ commonAncestor) => {
+/**
+ * @param {HtmlElement} commonAncestor common ancestor node of the adoption agency
+ * @returns {InsertionPlace} where the moved node goes
+ */
+const placeForCommonAncestor = (commonAncestor) => {
 	if (
 		TABLE_CONTEXT.has(_tagNameOf(commonAncestor)) &&
 		_namespaceOf(commonAncestor) === NS_HTML
@@ -6766,7 +6897,12 @@ const placeForCommonAncestor = (/** @type {HtmlElement} */ commonAncestor) => {
 	return { parent: commonAncestor, beforeNode: 0 };
 };
 
-const detach = (/** @type {HtmlNodeRef} */ node) => {
+/**
+ * Unlinks a node from its parent so it can be inserted again.
+ * @param {HtmlNodeRef} node node to detach
+ * @returns {void}
+ */
+const detach = (node) => {
 	const p = _nodeParents[node];
 	if (p === 0) return;
 	let prev = 0;
@@ -6788,11 +6924,13 @@ const detach = (/** @type {HtmlNodeRef} */ node) => {
 /** @type {Record<string, (t: Token) => void>} */
 const modes = {};
 
-// Dispatch the current insertion mode. An integer switch (cases ordered by
-// frequency) keeps each `modes.x(t)` call site monomorphic, where a keyed
-// `modes[mode]` load + indirect call would defeat inlining on the per-token
-// hot path.
-const runMode = (/** @type {Token} */ t) => {
+/**
+ * Dispatches the current insertion mode. An integer switch keeps each
+ * `modes.x(t)` call site monomorphic, where `modes[mode]` would not.
+ * @param {Token} t token to process
+ * @returns {void}
+ */
+const runMode = (t) => {
 	switch (mode) {
 		case MODE_IN_BODY:
 			return modes.inBody(t);
@@ -7137,9 +7275,13 @@ const closeIfPInButtonScope = () => {
 	if (inButtonScope("p")) closePElement();
 };
 
-// "any other end tag" in body: pop to the matching open element, stopping at
-// the first special element; also the adoption agency's no-element fallback.
-const anyOtherEndTag = (/** @type {string} */ name) => {
+/**
+ * "any other end tag" in body: pops to the matching open element, stopping at
+ * the first special element; also the adoption agency's no-element fallback.
+ * @param {string} name tag name of the end tag
+ * @returns {void}
+ */
+const anyOtherEndTag = (name) => {
 	for (let i = open.length - 1; i >= 0; i--) {
 		const node = open[i];
 		if (_namespaceOf(node) === NS_HTML && _tagNameOf(node) === name) {
@@ -7154,7 +7296,12 @@ const anyOtherEndTag = (/** @type {string} */ name) => {
 	}
 };
 
-const startTagInBody = (/** @type {StartTagToken} */ t) => {
+/**
+ * "in body" start tag rules (§13.2.6.4.7).
+ * @param {StartTagToken} t start tag token
+ * @returns {void}
+ */
+const startTagInBody = (t) => {
 	const name = t.name;
 	if (name === "html") {
 		if (open.some(isHtmlTemplateEl)) {
@@ -7479,7 +7626,12 @@ const startTagInBody = (/** @type {StartTagToken} */ t) => {
 	insertHtmlElement(name, t.attrs, t.pos);
 };
 
-const endTagInBody = (/** @type {EndTagToken} */ t) => {
+/**
+ * "in body" end tag rules (§13.2.6.4.7).
+ * @param {EndTagToken} t end tag token
+ * @returns {void}
+ */
+const endTagInBody = (t) => {
 	const name = t.name;
 	if (name === "template") return modes.inHead(t);
 	if (name === "select") {
@@ -7573,15 +7725,24 @@ const endTagInBody = (/** @type {EndTagToken} */ t) => {
 	anyOtherEndTag(name);
 };
 
-// generic RCDATA/RAWTEXT: tokenizer already emits the text + end tag, so we
-// just insert the element and switch to "text" mode; text mode appends chars
-// and the matching end tag pops.
-const genericRawtext = (/** @type {StartTagToken} */ t) => {
+/**
+ * Generic RAWTEXT: inserts the element and switches to "text" mode, which
+ * appends the characters the tokenizer already emits and pops on the end tag.
+ * @param {StartTagToken} t start tag token
+ * @returns {void}
+ */
+const genericRawtext = (t) => {
 	insertHtmlElement(t.name, t.attrs, t.pos);
 	originalMode = mode;
 	mode = MODE_TEXT;
 };
-const genericRcdata = (/** @type {StartTagToken} */ t, swallow = false) => {
+/**
+ * Generic RCDATA, as `genericRawtext` for the elements whose text is decoded.
+ * @param {StartTagToken} t start tag token
+ * @param {boolean=} swallow whether a newline right after the tag is dropped
+ * @returns {void}
+ */
+const genericRcdata = (t, swallow = false) => {
 	insertHtmlElement(t.name, t.attrs, t.pos);
 	if (swallow) t.swallowNewline = true;
 	originalMode = mode;
@@ -11508,11 +11669,19 @@ const _settleFosteredRuns = (path) => {
 	_fosterHolders = holders;
 };
 
+// Stands in for what the print chooses the bytes of: a raw-text body it
+// rewrites whole, or an attribute value it respells.
+const _DIGEST_OPAQUE = "\u0003";
+
 /**
  * The tree as a string, for the one check the printer cannot make from the tree
- * alone: whether what it printed parses back to what it printed from. Values are
- * compared as the DOM holds them, so the same attribute written with a different
- * quote or escape is the same attribute.
+ * alone: whether what it printed parses back to what it printed from. Read in
+ * the form the print is licensed to leave — comments gone, a run of text
+ * collapsed and joined, the elements and attributes the options drop dropped,
+ * every value the printer respells standing in for itself — so an equal digest
+ * says the print moved nothing, not that it changed nothing. What a repair does
+ * move (a node under another parent, an attribute a bad quote swallowed)
+ * reshapes the tree, and that is what parts the two.
  * @param {HtmlNodeRef} root the node whose children are read
  * @returns {string} a rendering equal for equal trees
  */
@@ -11525,6 +11694,15 @@ const _digest = (root) => {
 	const stack = [];
 	const first = A.firstChild(root);
 	if (first !== 0) stack.push(first, 0);
+	// A run of text siblings reads as one string: dropping the comment or the
+	// empty element between two of them is what joins them in the output.
+	let pendingText = "";
+	let pendingDepth = 0;
+	const flushText = () => {
+		const text = _asciiTrim(pendingText);
+		pendingText = "";
+		if (text !== "") out.push(`${pendingDepth}\u0001t\u0001${text}`);
+	};
 	while (stack.length !== 0) {
 		const depth = /** @type {number} */ (stack.pop());
 		const node = /** @type {HtmlNodeRef} */ (stack.pop());
@@ -11532,27 +11710,87 @@ const _digest = (root) => {
 		const next = A.nextSibling(node);
 		if (next !== 0) stack.push(next, depth);
 		const type = A.type(node);
-		if (type !== NodeType.Element) {
-			out.push(`${depth}\u0001${type}\u0001${A.data(node)}`);
+		// Not flushed: a comment minifying drops leaves the text around it one run.
+		if (type === NodeType.Comment) continue;
+		if (type === NodeType.Text) {
+			if (depth !== pendingDepth) flushText();
+			pendingDepth = depth;
+			const parent = A.parentOf(node);
+			pendingText +=
+				parent !== 0 && LITERAL_TEXT_PARENTS.has(A.tagName(parent))
+					? _DIGEST_OPAQUE
+					: collapseWhitespaceRuns(A.data(node));
 			continue;
 		}
-		out.push(
-			`${depth}\u0001e\u0001${A.namespace(node)}\u0001${A.tagName(node)}`
-		);
-		const attributes = [];
-		for (const a of A.attributes(node)) {
-			// The value as the DOM holds it: the same value can be written with a
-			// different quote and a different escape and still be the same attribute.
-			attributes.push(
-				`${a.serializedName || a.name}=${decodeEntities(a.value, true)}`
-			);
+		if (type === NodeType.Element) {
+			// Same as a comment: an element the print drops joins what surrounds it.
+			if (
+				_isRemovableEmptyElement(A, node) ||
+				(_absorbedStyles !== null && _absorbedStyles.has(node))
+			) {
+				continue;
+			}
+			flushText();
+			const elementName = A.tagName(node);
+			const html = A.namespace(node) === NS_HTML;
+			out.push(`${depth}\u0001e\u0001${A.namespace(node)}\u0001${elementName}`);
+			// Per element, as in `_minifyOpenTag`: every attribute of one tag gets the
+			// same answer out of these tables.
+			const markers =
+				html && _removeRedundantAttributes !== "none"
+					? REDUNDANT_TYPE_ATTRIBUTES[elementName]
+					: undefined;
+			const defaults =
+				html && _removeRedundantAttributes === "all"
+					? REDUNDANT_DEFAULT_ATTRIBUTES[elementName]
+					: undefined;
+			const attributes = [];
+			for (const a of A.attributes(node)) {
+				if (
+					html &&
+					(((markers !== undefined || defaults !== undefined) &&
+						_isRedundantAttribute(
+							markers,
+							defaults,
+							elementName,
+							a.name,
+							a.value
+						)) ||
+						_isRemovableEmptyAttribute(elementName, a.name, a.value))
+				) {
+					continue;
+				}
+				const name = a.serializedName || a.name;
+				if (REWRITABLE_ATTRIBUTES.has(a.name) || a.name === "srcdoc") {
+					attributes.push(`${name}=${_DIGEST_OPAQUE}`);
+					continue;
+				}
+				// The value as the DOM holds it — the same value can be written with a
+				// different quote and a different escape and still be the same
+				// attribute — with a boolean spelled by its own name as the bare
+				// presence the printer writes it back as.
+				attributes.push(
+					`${name}=${
+						html &&
+						a.value.length === a.name.length &&
+						_isBooleanAttribute(elementName, a.name) &&
+						_asciiLowerCase(a.value) === a.name
+							? ""
+							: decodeEntities(a.value, true)
+					}`
+				);
+			}
+			attributes.sort();
+			out.push(attributes.join("\u0002"));
+			const content = A.templateContent(node);
+			const inner = content !== 0 ? A.firstChild(content) : A.firstChild(node);
+			if (inner !== 0) stack.push(inner, depth + 1);
+			continue;
 		}
-		attributes.sort();
-		out.push(attributes.join("\u0002"));
-		const content = A.templateContent(node);
-		const inner = content !== 0 ? A.firstChild(content) : A.firstChild(node);
-		if (inner !== 0) stack.push(inner, depth + 1);
+		flushText();
+		out.push(`${depth}\u0001${type}\u0001${A.data(node)}`);
 	}
+	flushText();
 	return out.join("\n");
 };
 
@@ -12549,12 +12787,11 @@ const grammar = (input, visitors, writer, options) => {
 	_printDepth = 0;
 	try {
 		const root = parseHtml(input, 0, options);
-		let digest = "";
 		if (writer !== undefined) {
 			if (_fosteredLog !== null) _settleFosteredRuns(A);
 			// A shape no arrangement of tags reaches, or foster parenting — whose repair
 			// is checked, not trusted. No real document reaches either.
-			if (_printFromSource || _fosteredLog !== null) digest = _digest(root);
+			const verify = _printFromSource || _fosteredLog !== null;
 			_walkRun(_nodeParents[root], root, _nodeNextSiblings[root]);
 			// A single root: take its text as the output (the printer read every node's
 			// source into the store during the walk, so this needs no source). A root
@@ -12562,9 +12799,20 @@ const grammar = (input, visitors, writer, options) => {
 			if (_printOpen[0] === 1) writer.dropStore();
 			else writer.take(root);
 			// Print, then read the output back: the source always parses to its own
-			// tree, so it stands in when the printed form does not.
-			if (digest !== "") {
-				const printed = writer.result();
+			// tree, so it stands in when the printed form does not. Digested after the
+			// walk, which is what settles the elements the print left out.
+			if (verify) {
+				const digest = _digest(root);
+				// A deferred body prints as a marker, which reads back as text where
+				// its node stood — put it back, or the whole document is handed back.
+				const printed =
+					_deferEmbeddedSource === undefined ||
+					_deferEmbeddedSource.length === 0
+						? writer.result()
+						: declineDeferredWrites(writer.result(), _deferEmbeddedSource);
+				// Both are keyed by node id, which the next parse hands out afresh.
+				_emptyElements.clear();
+				_absorbedStyles = null;
 				if (_digest(parseHtml(printed, 0, options)) !== digest) {
 					writer.replaceAll(input);
 				}