From 805fb5534f2bdff7493a057578cb0154f820aa18 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Fri, 24 Feb 2023 16:32:25 -0700
Subject: [PATCH 01/39] WIP: HTML API: Add HTML Spec class to convey
 information related to the HTML specification

---
 .../html-api/class-wp-html-spec.php           | 292 ++++++++++++++++++
 1 file changed, 292 insertions(+)
 create mode 100644 src/wp-includes/html-api/class-wp-html-spec.php

diff --git a/src/wp-includes/html-api/class-wp-html-spec.php b/src/wp-includes/html-api/class-wp-html-spec.php
new file mode 100644
index 0000000000000..cef3e07c0bdff
--- /dev/null
+++ b/src/wp-includes/html-api/class-wp-html-spec.php
@@ -0,0 +1,292 @@
+<?php
+
+
+/**
+ * Source of knowledge about HTML according to the HTML 5 specification.
+ *
+ * @since 6.3.0
+ */
+class WP_HTML_Spec {
+	/**
+	 * Returns meta information about an HTML tag.
+	 *
+	 * @since 6.3.0
+	 *
+	 * @param string $tag_name
+	 * @return WP_HTML_Element_Meta::class
+	 */
+	public static function element_info( $tag_name ) {
+		switch ( strtolower( $tag_name ) ) {
+			// Normal elements
+			case 'a': return WP_HTMLAnchorElement::class;
+			case 'abbr': return WP_HTMLAbbrElement::class;
+			case 'address': return WP_HTMLAddressElement::class;
+			case 'area': return WP_HTMLAreaElement::class;
+			case 'article': return WP_HTMLArticleElement::class;
+			case 'aside': return WP_HTMLAsideElement::class;
+			case 'audio': return WP_HTMLAudioElement::class;
+			case 'b': return WP_HTMLBElement::class;
+			case 'base': return WP_HTMLBaseElement::class;
+			case 'bdi': return WP_HTMLBdiElement::class;
+			case 'bdo': return WP_HTMLBdoElement::class;
+			case 'blockquote': return WP_HTMLBlockquoteElement::class;
+			case 'body': return WP_HTMLBodyElement::class;
+			case 'br': return WP_HTMLBrElement::class;
+			case 'button': return WP_HTMLButtonElement::class;
+			case 'canvas': return WP_HTMLCanvasElement::class;
+			case 'caption': return WP_HTMLCaptionElement::class;
+			case 'cite': return WP_HTMLCiteElement::class;
+			case 'code': return WP_HTMLCodeElement::class;
+			case 'col': return WP_HTMLColElement::class;
+			case 'colgroup': return WP_HTMLColgroupElement::class;
+			case 'data': return WP_HTMLDataElement::class;
+			case 'datalist': return WP_HTMLDataListElement::class;
+			case 'dd': return WP_HTMLDdElement::class;
+			case 'del': return WP_HTMLDelElement::class;
+			case 'details': return WP_HTMLDetailsElement::class;
+			case 'dfn': return WP_HTMLDfnElement::class;
+			case 'dialog': return WP_HTMLDialogElement::class;
+			case 'div': return WP_HTMLDivElement::class;
+			case 'dl': return WP_HTMLDlElement::class;
+			case 'dt': return WP_HTMLDtElement::class;
+			case 'em': return WP_HTMLEmElement::class;
+			case 'embed': return WP_HTMLEmbedElement::class;
+			case 'fieldset': return WP_HTMLFieldsetElement::class;
+			case 'figcaption': return WP_HTMLFigcaptionElement::class;
+			case 'figure': return WP_HTMLFigureElement::class;
+			case 'footer': return WP_HTMLFooterElement::class;
+			case 'form': return WP_HTMLFormElement::class;
+			case 'h1': return WP_HTMLH1Element::class;
+			case 'h2': return WP_HTMLH2Element::class;
+			case 'h3': return WP_HTMLH3Element::class;
+			case 'h4': return WP_HTMLH4Element::class;
+			case 'h5': return WP_HTMLH5Element::class;
+			case 'h6': return WP_HTMLH6Element::class;
+			case 'head': return WP_HTMLHeadElement::class;
+			case 'header': return WP_HTMLHeaderElement::class;
+			case 'hgroup': return WP_HTMLHgropuElement::class;
+			case 'hr': return WP_HTMLHrElement::class;
+			case 'html': return WP_HTMLHtmlElement::class;
+			case 'i': return WP_HTMLIElement::class;
+			case 'iframe': return WP_HTMLIframeElement::class;
+			case 'img': return WP_HTMLImgElement::class;
+			case 'input': return WP_HTMLInputElement::class;
+			case 'ins': return WP_HTMLInsElement::class;
+			case 'kbd': return WP_HTMLKbdElement::class;
+			case 'label': return WP_HTMLLabelElement::class;
+			case 'legend': return WP_HTMLLegendElement::class;
+			case 'li': return WP_HTMLLiElement::class;
+			case 'link': return WP_HTMLLinkElement::class;
+			case 'main': return WP_HTMLMainElement::class;
+			case 'map': return WP_HTMLMapElement::class;
+			case 'mark': return WP_HTMLMarkElement::class;
+			case 'math': return WP_HTMLMathElement::class;
+			case 'menu': return WP_HTMLMenuElement::class;
+			case 'meta': return WP_HTMLMetaElement::class;
+			case 'meter': return WP_HTMLMeterElement::class;
+			case 'nav': return WP_HTMLNavElement::class;
+			case 'noscript': return WP_HTMLNoscriptElement::class;
+			case 'object': return WP_HTMLObjectElement::class;
+			case 'ol': return WP_HTMLOlElement::class;
+			case 'optgroup': return WP_HTMLOptgroupElement::class;
+			case 'option': return WP_HTMLOptionElement::class;
+			case 'output': return WP_HTMLOutputElement::class;
+			case 'p': return WP_HTMLPElement::class;
+			case 'picture': return WP_HTMLPictureElement::class;
+			case 'pre': return WP_HTMLPreElement::class;
+			case 'progress': return WP_HTMLProgressElement::class;
+			case 'q': return WP_HTMLQElement::class;
+			case 'rp': return WP_HTMLRpElement::class;
+			case 'rt': return WP_HTMLRtElement::class;
+			case 'ruby': return WP_HTMLRubyElement::class;
+			case 's': return WP_HTMLSElement::class;
+			case 'samp': return WP_HTMLSampElement::class;
+			case 'script': return WP_HTMLScriptElement::class;
+			case 'section': return WP_HTMLSectionElement::class;
+			case 'select': return WP_HTMLSelectElement::class;
+			case 'slot': return WP_HTMLSlotElement::class;
+			case 'small': return WP_HTMLSmallElement::class;
+			case 'source': return WP_HTMLSourceElement::class;
+			case 'span': return WP_HTMLSpanElement::class;
+			case 'strong': return WP_HTMLStrongElement::class;
+			case 'style': return WP_HTMLStyleElement::class;
+			case 'sub': return WP_HTMLSubElement::class;
+			case 'summary': return WP_HTMLSummaryElement::class;
+			case 'sup': return WP_HTMLSupElement::class;
+			case 'svg': return WP_HTMLSvgElement::class;
+			case 'table': return WP_HTMLTableElement::class;
+			case 'tbody': return WP_HTMLTbodyElement::class;
+			case 'td': return WP_HTMLTdElement::class;
+			case 'template': return WP_HTMLTemplateElement::class;
+			case 'textarea': return WP_HTMLTextareaElement::class;
+			case 'tfoot': return WP_HTMLTfootElement::class;
+			case 'th': return WP_HTMLThElement::class;
+			case 'thead': return WP_HTMLTheadElement::class;
+			case 'time': return WP_HTMLTimeElement::class;
+			case 'title': return WP_HTMLTitleElement::class;
+			case 'tr': return WP_HTMLTrElement::class;
+			case 'track': return WP_HTMLTrackElement::class;
+			case 'u': return WP_HTMLUElement::class;
+			case 'ul': return WP_HTMLUlElement::class;
+			case 'var': return WP_HTMLVarElement::class;
+			case 'video': return WP_HTMLVideoElement::class;
+			case 'wbr': return WP_HTMLWbrElement::class;
+
+			// Deprecated elements
+			case 'applet':
+			case 'bgsound':
+			case 'blink':
+			case 'isindex':
+			case 'keygen':
+			case 'multicol':
+			case 'nextid':
+			case 'spacer':
+				return WP_HTMLUnknownElement::class;
+
+			// Neutralized elements
+			case 'acronym':
+			case 'basefont':
+			case 'big':
+			case 'center':
+			case 'nobr':
+			case 'noembed':
+			case 'noframes':
+			case 'plaintext':
+			case 'rb':
+			case 'rtc':
+			case 'strike':
+			case 'tt':
+				return WP_HTMLElement::class;
+
+			// Substitutions
+			case 'listing':
+			case 'xmp':
+				return WP_HTMLPreElement::class;
+
+			default:
+				return WP_HTMLUnknownElement::class;
+		}
+	}
+}
+
+class WP_HTML_Element_Meta {
+	const is_void = false;
+	const is_html = true;
+}
+
+class WP_HTMLUnknownElement extends WP_HTML_Element_Meta { const is_html = false; }
+class WP_HTMLElement extends WP_HTML_Element_Meta {}
+
+class WP_HTMLAnchorElement extends WP_HTML_Element_Meta {}
+class WP_HTMLAbbrElement extends WP_HTML_Element_Meta {}
+class WP_HTMLAddressElement extends WP_HTML_Element_Meta {}
+class WP_HTMLAreaElement extends WP_HTML_Element_Meta { const is_void = true; }
+class WP_HTMLArticleElement extends WP_HTML_Element_Meta {}
+class WP_HTMLAsideElement extends WP_HTML_Element_Meta {}
+class WP_HTMLAudioElement extends WP_HTML_Element_Meta {}
+class WP_HTMLBElement extends WP_HTML_Element_Meta {}
+class WP_HTMLBaseElement extends WP_HTML_Element_Meta { const is_void = true; }
+class WP_HTMLBdiElement extends WP_HTML_Element_Meta {}
+class WP_HTMLBdoElement extends WP_HTML_Element_Meta {}
+class WP_HTMLBlockquoteElement extends WP_HTML_Element_Meta {}
+class WP_HTMLBodyElement extends WP_HTML_Element_Meta {}
+class WP_HTMLBrElement extends WP_HTML_Element_Meta { const is_void = true; }
+class WP_HTMLButtonElement extends WP_HTML_Element_Meta {}
+class WP_HTMLCanvasElement extends WP_HTML_Element_Meta {}
+class WP_HTMLCaptionElement extends WP_HTML_Element_Meta {}
+class WP_HTMLCiteElement extends WP_HTML_Element_Meta {}
+class WP_HTMLCodeElement extends WP_HTML_Element_Meta {}
+class WP_HTMLColElement extends WP_HTML_Element_Meta { const is_void = true; }
+class WP_HTMLColgroupElement extends WP_HTML_Element_Meta {}
+class WP_HTMLDataElement extends WP_HTML_Element_Meta {}
+class WP_HTMLDataListElement extends WP_HTML_Element_Meta {}
+class WP_HTMLDdElement extends WP_HTML_Element_Meta {}
+class WP_HTMLDelElement extends WP_HTML_Element_Meta {}
+class WP_HTMLDetailsElement extends WP_HTML_Element_Meta {}
+class WP_HTMLDfnElement extends WP_HTML_Element_Meta {}
+class WP_HTMLDialogElement extends WP_HTML_Element_Meta {}
+class WP_HTMLDivElement extends WP_HTML_Element_Meta {}
+class WP_HTMLDlElement extends WP_HTML_Element_Meta {}
+class WP_HTMLDtElement extends WP_HTML_Element_Meta {}
+class WP_HTMLEmElement extends WP_HTML_Element_Meta {}
+class WP_HTMLEmbedElement extends WP_HTML_Element_Meta { const is_void = true; }
+class WP_HTMLFieldsetElement extends WP_HTML_Element_Meta {}
+class WP_HTMLFigcaptionElement extends WP_HTML_Element_Meta {}
+class WP_HTMLFigureElement extends WP_HTML_Element_Meta {}
+class WP_HTMLFooterElement extends WP_HTML_Element_Meta {}
+class WP_HTMLFormElement extends WP_HTML_Element_Meta {}
+class WP_HTMLH1Element extends WP_HTML_Element_Meta {}
+class WP_HTMLH2Element extends WP_HTML_Element_Meta {}
+class WP_HTMLH3Element extends WP_HTML_Element_Meta {}
+class WP_HTMLH4Element extends WP_HTML_Element_Meta {}
+class WP_HTMLH5Element extends WP_HTML_Element_Meta {}
+class WP_HTMLH6Element extends WP_HTML_Element_Meta {}
+class WP_HTMLHeadElement extends WP_HTML_Element_Meta {}
+class WP_HTMLHeaderElement extends WP_HTML_Element_Meta {}
+class WP_HTMLHgropuElement extends WP_HTML_Element_Meta {}
+class WP_HTMLHrElement extends WP_HTML_Element_Meta { const is_void = true; }
+class WP_HTMLHtmlElement extends WP_HTML_Element_Meta {}
+class WP_HTMLIElement extends WP_HTML_Element_Meta {}
+class WP_HTMLIframeElement extends WP_HTML_Element_Meta {}
+class WP_HTMLImgElement extends WP_HTML_Element_Meta { const is_void = true; }
+class WP_HTMLInputElement extends WP_HTML_Element_Meta { const is_void = true; }
+class WP_HTMLInsElement extends WP_HTML_Element_Meta {}
+class WP_HTMLKbdElement extends WP_HTML_Element_Meta {}
+class WP_HTMLLabelElement extends WP_HTML_Element_Meta {}
+class WP_HTMLLegendElement extends WP_HTML_Element_Meta {}
+class WP_HTMLLiElement extends WP_HTML_Element_Meta {}
+class WP_HTMLLinkElement extends WP_HTML_Element_Meta { const is_void = true; }
+class WP_HTMLMainElement extends WP_HTML_Element_Meta {}
+class WP_HTMLMapElement extends WP_HTML_Element_Meta {}
+class WP_HTMLMarkElement extends WP_HTML_Element_Meta {}
+class WP_HTMLMathElement extends WP_HTML_Element_Meta {}
+class WP_HTMLMenuElement extends WP_HTML_Element_Meta {}
+class WP_HTMLMetaElement extends WP_HTML_Element_Meta { const is_void = true; }
+class WP_HTMLMeterElement extends WP_HTML_Element_Meta {}
+class WP_HTMLNavElement extends WP_HTML_Element_Meta {}
+class WP_HTMLNoscriptElement extends WP_HTML_Element_Meta {}
+class WP_HTMLObjectElement extends WP_HTML_Element_Meta {}
+class WP_HTMLOlElement extends WP_HTML_Element_Meta {}
+class WP_HTMLOptgroupElement extends WP_HTML_Element_Meta {}
+class WP_HTMLOptionElement extends WP_HTML_Element_Meta {}
+class WP_HTMLOutputElement extends WP_HTML_Element_Meta {}
+class WP_HTMLPElement extends WP_HTML_Element_Meta {}
+class WP_HTMLPictureElement extends WP_HTML_Element_Meta {}
+class WP_HTMLPreElement extends WP_HTML_Element_Meta {}
+class WP_HTMLProgressElement extends WP_HTML_Element_Meta {}
+class WP_HTMLQElement extends WP_HTML_Element_Meta {}
+class WP_HTMLRpElement extends WP_HTML_Element_Meta {}
+class WP_HTMLRtElement extends WP_HTML_Element_Meta {}
+class WP_HTMLRubyElement extends WP_HTML_Element_Meta {}
+class WP_HTMLSElement extends WP_HTML_Element_Meta {}
+class WP_HTMLSampElement extends WP_HTML_Element_Meta {}
+class WP_HTMLScriptElement extends WP_HTML_Element_Meta {}
+class WP_HTMLSectionElement extends WP_HTML_Element_Meta {}
+class WP_HTMLSelectElement extends WP_HTML_Element_Meta {}
+class WP_HTMLSlotElement extends WP_HTML_Element_Meta {}
+class WP_HTMLSmallElement extends WP_HTML_Element_Meta {}
+class WP_HTMLSourceElement extends WP_HTML_Element_Meta { const is_void = true; }
+class WP_HTMLSpanElement extends WP_HTML_Element_Meta {}
+class WP_HTMLStrongElement extends WP_HTML_Element_Meta {}
+class WP_HTMLStyleElement extends WP_HTML_Element_Meta {}
+class WP_HTMLSubElement extends WP_HTML_Element_Meta {}
+class WP_HTMLSummaryElement extends WP_HTML_Element_Meta {}
+class WP_HTMLSupElement extends WP_HTML_Element_Meta {}
+class WP_HTMLSvgElement extends WP_HTML_Element_Meta {}
+class WP_HTMLTableElement extends WP_HTML_Element_Meta {}
+class WP_HTMLTbodyElement extends WP_HTML_Element_Meta {}
+class WP_HTMLTdElement extends WP_HTML_Element_Meta {}
+class WP_HTMLTemplateElement extends WP_HTML_Element_Meta {}
+class WP_HTMLTextareaElement extends WP_HTML_Element_Meta {}
+class WP_HTMLTfootElement extends WP_HTML_Element_Meta {}
+class WP_HTMLThElement extends WP_HTML_Element_Meta {}
+class WP_HTMLTheadElement extends WP_HTML_Element_Meta {}
+class WP_HTMLTimeElement extends WP_HTML_Element_Meta {}
+class WP_HTMLTitleElement extends WP_HTML_Element_Meta {}
+class WP_HTMLTrElement extends WP_HTML_Element_Meta {}
+class WP_HTMLTrackElement extends WP_HTML_Element_Meta { const is_void = true; }
+class WP_HTMLUElement extends WP_HTML_Element_Meta {}
+class WP_HTMLUlElement extends WP_HTML_Element_Meta {}
+class WP_HTMLVarElement extends WP_HTML_Element_Meta {}
+class WP_HTMLVideoElement extends WP_HTML_Element_Meta {}
+class WP_HTMLWbrElement extends WP_HTML_Element_Meta { const is_void = true; }

From 84e35efa24b291faf72cb92872c7eca0a1e939dd Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Wed, 1 Mar 2023 18:13:43 -0700
Subject: [PATCH 02/39] WIP: HTML API: Expose self-closing flag in Tag
 Processor

---
 .../html-api/class-wp-html-tag-processor.php  |  8 +++++
 .../tests/html-api/wpHtmlTagProcessor.php     | 32 +++++++++++++++++++
 2 files changed, 40 insertions(+)

diff --git a/src/wp-includes/html-api/class-wp-html-tag-processor.php b/src/wp-includes/html-api/class-wp-html-tag-processor.php
index 0b3dab1ad2ae4..a8a1c14a1e69a 100644
--- a/src/wp-includes/html-api/class-wp-html-tag-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-tag-processor.php
@@ -1743,6 +1743,14 @@ public function get_tag() {
 		return strtoupper( $tag_name );
 	}
 
+	public function has_self_closing_flag() {
+		if ( ! $this->tag_name_starts_at ) {
+			return false;
+		}
+
+		return '/' === $this->html[ $this->tag_ends_at - 1 ];
+	}
+
 	/**
 	 * Indicates if the current tag token is a tag closer.
 	 *
diff --git a/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php b/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
index d006b3294c9ea..33692267f4f4d 100644
--- a/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
+++ b/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
@@ -51,6 +51,38 @@ public function test_get_tag_returns_open_tag_name() {
 		$this->assertSame( 'DIV', $p->get_tag(), 'Accessing an existing tag name did not return "div"' );
 	}
 
+	/**
+	 * @ticket NEEDS TICKET
+	 *
+	 * @covers WP_HTML_Tag_Processor::has_self_closing_flag()
+	 *
+	 * @dataProvider data_has_self_closing_flag
+	 *
+	 * @param string $html input HTML whose first tag might contain the self-closing flag `/`.
+	 * @param bool $flag_is_set whether the input HTML's first tag contains the self-closing flag.
+	 */
+	public function test_has_self_closing_flag_matches_input_html( $html, $flag_is_set ) {
+		$p = new WP_HTML_Tag_Processor( $html );
+		$p->next_tag( array( 'tag_closers' => 'visit' ) );
+
+		if ( $flag_is_set ) {
+			$this->assertTrue( $p->has_self_closing_flag(), 'Did not find the self-closing tag when it was present.' );
+		} else {
+			$this->assertFalse( $p->has_self_closing_flag(), 'Found the self-closing tag when it was absent.' );
+		}
+	}
+
+	public function data_has_self_closing_flag() {
+		return array(
+			array( '<div />', true ),
+			array( '<div>', false ),
+			array( '<img />', true ),
+			array( '<img>', false ),
+			array( '</textarea>', false ),
+			array( '</textarea />', true ),
+		);
+	}
+
 	/**
 	 * @ticket 56299
 	 *

From 84e25cfabdbb99b2067e25cba37ea9d66ec624d1 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Wed, 1 Mar 2023 19:31:14 -0700
Subject: [PATCH 03/39] Expand documentation

---
 .../html-api/class-wp-html-tag-processor.php  | 17 ++++++++++++++
 .../tests/html-api/wpHtmlTagProcessor.php     | 23 ++++++++++++++-----
 2 files changed, 34 insertions(+), 6 deletions(-)

diff --git a/src/wp-includes/html-api/class-wp-html-tag-processor.php b/src/wp-includes/html-api/class-wp-html-tag-processor.php
index a8a1c14a1e69a..ec8855d472b78 100644
--- a/src/wp-includes/html-api/class-wp-html-tag-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-tag-processor.php
@@ -1743,6 +1743,23 @@ public function get_tag() {
 		return strtoupper( $tag_name );
 	}
 
+	/**
+	 * Indicates if the currently matched tag contains the self-closing flag.
+	 *
+	 * No HTML elements ought to have the self-closing flag and for those, the self-closing
+	 * flag will be ignored. For void elements this is benign because they "self close"
+	 * automatically. For non-void HTML elements though problems will appear if someone
+	 * intends to use a self-closing element in place of that element with an empty body.
+	 * For HTML foreign elements and custom elements the self-closing flag determines if
+	 * they self-close or not.
+	 *
+	 * This function does not determine if a tag is self-closing,
+	 * but only if the self-closing flag is present in the syntax.
+	 *
+	 * @since 6.3.0
+	 *
+	 * @return bool Whether the currently matched tag contains the self-closing flag.
+	 */
 	public function has_self_closing_flag() {
 		if ( ! $this->tag_name_starts_at ) {
 			return false;
diff --git a/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php b/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
index 33692267f4f4d..7402df600e17d 100644
--- a/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
+++ b/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
@@ -72,14 +72,25 @@ public function test_has_self_closing_flag_matches_input_html( $html, $flag_is_s
 		}
 	}
 
+	/**
+	 * Data provider. HTML tags which might have a self-closing flag, and an indicator if they do.
+	 *
+	 * @return array[]
+	 */
 	public function data_has_self_closing_flag() {
 		return array(
-			array( '<div />', true ),
-			array( '<div>', false ),
-			array( '<img />', true ),
-			array( '<img>', false ),
-			array( '</textarea>', false ),
-			array( '</textarea />', true ),
+			// These should not have a self-closer, and will leave an element un-closed if it's assumed they are self-closing.
+			'Self-closing flag on non-void HTML element'    => array( '<div />', true ),
+			'No self-closing flag on non-void HTML element' => array( '<div>', false ),
+			// These should not have a self-closer, but are benign when used because the elements are void.
+			'Self-closing flag on void HTML element'        => array( '<img />', true ),
+			'No self-closing flag on void HTML element'     => array( '<img>', false ),
+			// These should not have a self-closer, but as part of a tag closer they are entirely ignored.
+			'Self-closing flag on tag closer'               => array( '</textarea />', true ),
+			'No self-closing flag on tag closer'            => array( '</textarea>', false ),
+			// These can and should have self-closers, and will leave an element un-closed if it's assumed they aren't self-closing.
+			'Self-closing flag on a foreign element'        => array( '<circle />', true ),
+			'No self-closing flag on a foreign element'     => array( '<circle>', false ),
 		);
 	}
 

From c18a81acbadeddddc19625bd1ef0d1d12d14806a Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Wed, 1 Mar 2023 20:20:53 -0700
Subject: [PATCH 04/39] Appease the linting gods

---
 tests/phpunit/tests/html-api/wpHtmlTagProcessor.php | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php b/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
index 7402df600e17d..7568bbfa5a759 100644
--- a/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
+++ b/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
@@ -83,14 +83,14 @@ public function data_has_self_closing_flag() {
 			'Self-closing flag on non-void HTML element'    => array( '<div />', true ),
 			'No self-closing flag on non-void HTML element' => array( '<div>', false ),
 			// These should not have a self-closer, but are benign when used because the elements are void.
-			'Self-closing flag on void HTML element'        => array( '<img />', true ),
-			'No self-closing flag on void HTML element'     => array( '<img>', false ),
+			'Self-closing flag on void HTML element'    => array( '<img />', true ),
+			'No self-closing flag on void HTML element' => array( '<img>', false ),
 			// These should not have a self-closer, but as part of a tag closer they are entirely ignored.
-			'Self-closing flag on tag closer'               => array( '</textarea />', true ),
-			'No self-closing flag on tag closer'            => array( '</textarea>', false ),
+			'Self-closing flag on tag closer'    => array( '</textarea />', true ),
+			'No self-closing flag on tag closer' => array( '</textarea>', false ),
 			// These can and should have self-closers, and will leave an element un-closed if it's assumed they aren't self-closing.
-			'Self-closing flag on a foreign element'        => array( '<circle />', true ),
-			'No self-closing flag on a foreign element'     => array( '<circle>', false ),
+			'Self-closing flag on a foreign element'    => array( '<circle />', true ),
+			'No self-closing flag on a foreign element' => array( '<circle>', false ),
 		);
 	}
 

From af8d49dc2471f88cf7813941e538c22254cd5ee8 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Wed, 1 Mar 2023 20:27:53 -0700
Subject: [PATCH 05/39] Add extra tests for syntax peculiarities.

---
 tests/phpunit/tests/html-api/wpHtmlTagProcessor.php | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php b/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
index 7568bbfa5a759..ee8ec7a8b0e2f 100644
--- a/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
+++ b/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
@@ -91,6 +91,11 @@ public function data_has_self_closing_flag() {
 			// These can and should have self-closers, and will leave an element un-closed if it's assumed they aren't self-closing.
 			'Self-closing flag on a foreign element'    => array( '<circle />', true ),
 			'No self-closing flag on a foreign element' => array( '<circle>', false ),
+			// These involve syntax peculiarities.
+			'Self-closing flag after extra spaces'      => array( '<div      />', true ),
+			'Self-closing flag after attribute'         => array( '<div id=test/>', true ),
+			'Self-closing flag after quoted attribute'  => array( '<div id="test"/>', true ),
+			'Self-closing flag after boolean attribute' => array( '<div enabled/>', true ),
 		);
 	}
 

From 72e5de0646005bd133dcc0b854526db80f10715a Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Wed, 1 Mar 2023 20:39:08 -0700
Subject: [PATCH 06/39] Appease the linting gods

---
 .../phpunit/tests/html-api/wpHtmlTagProcessor.php  | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php b/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
index ee8ec7a8b0e2f..e292afb730fea 100644
--- a/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
+++ b/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
@@ -80,21 +80,21 @@ public function test_has_self_closing_flag_matches_input_html( $html, $flag_is_s
 	public function data_has_self_closing_flag() {
 		return array(
 			// These should not have a self-closer, and will leave an element un-closed if it's assumed they are self-closing.
-			'Self-closing flag on non-void HTML element'    => array( '<div />', true ),
+			'Self-closing flag on non-void HTML element' => array( '<div />', true ),
 			'No self-closing flag on non-void HTML element' => array( '<div>', false ),
 			// These should not have a self-closer, but are benign when used because the elements are void.
-			'Self-closing flag on void HTML element'    => array( '<img />', true ),
+			'Self-closing flag on void HTML element' => array( '<img />', true ),
 			'No self-closing flag on void HTML element' => array( '<img>', false ),
 			// These should not have a self-closer, but as part of a tag closer they are entirely ignored.
-			'Self-closing flag on tag closer'    => array( '</textarea />', true ),
+			'Self-closing flag on tag closer' => array( '</textarea />', true ),
 			'No self-closing flag on tag closer' => array( '</textarea>', false ),
 			// These can and should have self-closers, and will leave an element un-closed if it's assumed they aren't self-closing.
-			'Self-closing flag on a foreign element'    => array( '<circle />', true ),
+			'Self-closing flag on a foreign element' => array( '<circle />', true ),
 			'No self-closing flag on a foreign element' => array( '<circle>', false ),
 			// These involve syntax peculiarities.
-			'Self-closing flag after extra spaces'      => array( '<div      />', true ),
-			'Self-closing flag after attribute'         => array( '<div id=test/>', true ),
-			'Self-closing flag after quoted attribute'  => array( '<div id="test"/>', true ),
+			'Self-closing flag after extra spaces' => array( '<div      />', true ),
+			'Self-closing flag after attribute' => array( '<div id=test/>', true ),
+			'Self-closing flag after quoted attribute' => array( '<div id="test"/>', true ),
 			'Self-closing flag after boolean attribute' => array( '<div enabled/>', true ),
 		);
 	}

From 095a110510ac85a018e560d645892eb47d713039 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Wed, 1 Mar 2023 20:42:05 -0700
Subject: [PATCH 07/39] Appease the linting gods

---
 .../tests/html-api/wpHtmlTagProcessor.php      | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php b/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
index e292afb730fea..c1f711eb7c6d4 100644
--- a/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
+++ b/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
@@ -80,22 +80,22 @@ public function test_has_self_closing_flag_matches_input_html( $html, $flag_is_s
 	public function data_has_self_closing_flag() {
 		return array(
 			// These should not have a self-closer, and will leave an element un-closed if it's assumed they are self-closing.
-			'Self-closing flag on non-void HTML element' => array( '<div />', true ),
+			'Self-closing flag on non-void HTML element'     => array( '<div />', true ),
 			'No self-closing flag on non-void HTML element' => array( '<div>', false ),
 			// These should not have a self-closer, but are benign when used because the elements are void.
 			'Self-closing flag on void HTML element' => array( '<img />', true ),
-			'No self-closing flag on void HTML element' => array( '<img>', false ),
+			'No self-closing flag on void HTML element'  => array( '<img>', false ),
 			// These should not have a self-closer, but as part of a tag closer they are entirely ignored.
 			'Self-closing flag on tag closer' => array( '</textarea />', true ),
-			'No self-closing flag on tag closer' => array( '</textarea>', false ),
+			'No self-closing flag on tag closer'         => array( '</textarea>', false ),
 			// These can and should have self-closers, and will leave an element un-closed if it's assumed they aren't self-closing.
-			'Self-closing flag on a foreign element' => array( '<circle />', true ),
-			'No self-closing flag on a foreign element' => array( '<circle>', false ),
+			'Self-closing flag on a foreign element'     => array( '<circle />', true ),
+			'No self-closing flag on a foreign element'  => array( '<circle>', false ),
 			// These involve syntax peculiarities.
-			'Self-closing flag after extra spaces' => array( '<div      />', true ),
-			'Self-closing flag after attribute' => array( '<div id=test/>', true ),
-			'Self-closing flag after quoted attribute' => array( '<div id="test"/>', true ),
-			'Self-closing flag after boolean attribute' => array( '<div enabled/>', true ),
+			'Self-closing flag after extra spaces'       => array( '<div      />', true ),
+			'Self-closing flag after attribute'          => array( '<div id=test/>', true ),
+			'Self-closing flag after quoted attribute'   => array( '<div id="test"/>', true ),
+			'Self-closing flag after boolean attribute'  => array( '<div enabled/>', true ),
 		);
 	}
 

From 9b3f90d7bdf26c0c61ab63888f122b2bc196a83c Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Wed, 1 Mar 2023 20:44:12 -0700
Subject: [PATCH 08/39] Appease the linting gods

---
 tests/phpunit/tests/html-api/wpHtmlTagProcessor.php | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php b/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
index c1f711eb7c6d4..6ad80a29cf72f 100644
--- a/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
+++ b/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
@@ -80,13 +80,13 @@ public function test_has_self_closing_flag_matches_input_html( $html, $flag_is_s
 	public function data_has_self_closing_flag() {
 		return array(
 			// These should not have a self-closer, and will leave an element un-closed if it's assumed they are self-closing.
-			'Self-closing flag on non-void HTML element'     => array( '<div />', true ),
+			'Self-closing flag on non-void HTML element' => array( '<div />', true ),
 			'No self-closing flag on non-void HTML element' => array( '<div>', false ),
 			// These should not have a self-closer, but are benign when used because the elements are void.
-			'Self-closing flag on void HTML element' => array( '<img />', true ),
+			'Self-closing flag on void HTML element'     => array( '<img />', true ),
 			'No self-closing flag on void HTML element'  => array( '<img>', false ),
 			// These should not have a self-closer, but as part of a tag closer they are entirely ignored.
-			'Self-closing flag on tag closer' => array( '</textarea />', true ),
+			'Self-closing flag on tag closer'            => array( '</textarea />', true ),
 			'No self-closing flag on tag closer'         => array( '</textarea>', false ),
 			// These can and should have self-closers, and will leave an element un-closed if it's assumed they aren't self-closing.
 			'Self-closing flag on a foreign element'     => array( '<circle />', true ),

From 396285b0c9b9f4b32c1dd59e6d23667b458f5a92 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Mon, 6 Mar 2023 22:18:57 -0700
Subject: [PATCH 09/39] Add `ensure_support()` and tests

---
 .../html-api/class-wp-html-processor.php      | 76 +++++++++++++++++++
 .../html-api/wpHtmlTagProcessor-support.php   | 72 ++++++++++++++++++
 2 files changed, 148 insertions(+)
 create mode 100644 src/wp-includes/html-api/class-wp-html-processor.php
 create mode 100644 tests/phpunit/tests/html-api/wpHtmlTagProcessor-support.php

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
new file mode 100644
index 0000000000000..16dc92f61ec5f
--- /dev/null
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -0,0 +1,76 @@
+<?php
+
+class WP_HTML_Processor extends WP_HTML_Tag_Processor {
+	public $fully_supported_input = null;
+
+	public function ensure_support() {
+		if ( null !== $this->fully_supported_input ) {
+			return $this->fully_supported_input;
+		}
+
+		$stack = array();
+
+		$p = new WP_HTML_Tag_Processor( $this->html );
+		while ( $p->next_tag( array( 'tag_closers' => 'visit' ) ) ) {
+			$tag_name = $p->get_tag();
+
+			if ( ! $p->is_tag_closer() ) {
+				$element = WP_HTML_Spec::element_info( $tag_name );
+
+				$self_closes = $element::is_void || ( ! $element::is_html && $p->has_self_closing_flag() );
+				if ( ! $self_closes ) {
+					$stack[] = $tag_name;
+				}
+			} else {
+				if ( end( $stack ) === $tag_name ) {
+					array_pop( $stack );
+					continue;
+				}
+
+				$this->fully_supported_input = false;
+				return false;
+			}
+		}
+
+		$this->fully_supported_input = 0 === count( $stack );
+
+		return $this->fully_supported_input;
+	}
+
+	public function next_tag( $query = null ) {
+		if ( false === $this->fully_supported_input || false === $this->ensure_support() ) {
+			return false;
+		}
+
+		return parent::next_tag( $query );
+	}
+
+	public function proceed_to_end_of_next_tag() {
+		if ( $this->fully_supported_input ) {
+			return false;
+		}
+
+		$open_elements = array();
+
+		while ( $this->next_tag( array( 'tag_closers' => 'visit' ) ) ) {
+			$tag_name = $this->get_tag();
+			$element = WP_HTML_Spec::element_info( $tag_name );
+
+			if ( $element::is_void ) {
+				return true;
+			}
+
+			if ( $this->is_tag_closer() ) {
+				if ( 0 === count( $open_elements ) || $open_elements[ count( $open_elements ) - 1 ] !== $tag_name ) {
+					$this->fully_supported_input = true;
+					return false;
+				}
+
+				array_pop( $open_elements );
+				if ( 0 === count( $open_elements ) ) {
+					return true;
+				}
+			}
+		}
+	}
+}
diff --git a/tests/phpunit/tests/html-api/wpHtmlTagProcessor-support.php b/tests/phpunit/tests/html-api/wpHtmlTagProcessor-support.php
new file mode 100644
index 0000000000000..11b1eb8c418ca
--- /dev/null
+++ b/tests/phpunit/tests/html-api/wpHtmlTagProcessor-support.php
@@ -0,0 +1,72 @@
+<?php
+/**
+ * Unit tests covering WP_HTML_Processor support functionality.
+ *
+ * @package WordPress
+ * @subpackage HTML-API
+ */
+
+/**
+ * @group html-api
+ *
+ * @coversDefaultClass WP_HTML_Processor
+ */
+class Tests_HtmlApi_wpHtmlProcessor_Support extends WP_UnitTestCase {
+	/**
+	 * @dataProvider data_fully_balanced_html
+	 */
+	public function test_detects_fully_balanced_html( $html ) {
+		$p = new WP_HTML_Processor( $html );
+
+		$this->assertTrue( $p->ensure_support(), "Detected that supported HTML input isn't supported." );
+	}
+
+	/**
+	 * @return array[]
+	 */
+	public function data_fully_balanced_html() {
+		return array(
+			'Fully-nested balanced tags'                => array( '<div><p><strong>Test</strong></p></div>' ),
+			'Sibling nested tags'                       => array( '<ul><li>One</li><li>Two</li><li>Three</li></ul>' ),
+			'Top-level siblings'                        => array( '<li>One</li><li>Two</li><li>Three</li>' ),
+			'Void tags'                                 => array( '<img><br><hr>' ),
+			'Void tags with invalid self-closing flags' => array( '<img /><br/><hr />' ),
+			'Invalid self-closing non-void'              => array( 'This <div/> is (not) empty.</div>' ),
+			'Nested with void tags'                     => array( '<div><p><img>Text<br>More Text</p></div>'),
+			'HTML foreign elements'                     => array( '<svg><circle /></svg>'),
+		);
+	}
+
+	/**
+	 * @dataProvider data_not_fully_balanced_html
+	 */
+	public function test_detects_not_fully_balanced_html( $html ) {
+		$p = new WP_HTML_Processor( $html );
+
+		$this->assertFalse( $p->ensure_support(), 'Detected that unsupported HTML input is supported.' );
+	}
+
+	/**
+	 * @return array[]
+	 */
+	public function data_not_fully_balanced_html() {
+		return array(
+			'Unclosed tag'                               => array( '<p>Unclosed paragraph' ),
+			'Unclosed nested tag'                        => array( '<div><p>Unclosed paragraph</div>' ),
+			'Overlapping tags'                           => array( '<strong><p>Important</strong></p>' ),
+			'Overlapping nested tags'                    => array( '<div><strong><p>Important</strong></p></div>' ),
+			'Invalid self-closing non-void'              => array( 'This <div/> is (not) empty.' ),
+			'Un-closed HTML foreign self-closer'         => array( '<svg><circle></svg>'),
+			'Improperly-closed HTML foreign self-closer' => array( '<svg><circle /></circle></svg>'),
+		);
+	}
+
+	/**
+	 * @dataProvider data_not_fully_balanced_html
+	 */
+	public function test_does_not_call_next_tag_for_unsupported_html( $html ) {
+		$p = new WP_HTML_Processor( $html );
+
+		$this->assertFalse( $p->next_tag(), "Advanced to '{$p->get_tag()}' even though input HTML isn't supported." );
+	}
+}

From b2e6856b6604b272d647b1b4e2ab986eec0a3beb Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Mon, 6 Mar 2023 23:20:58 -0700
Subject: [PATCH 10/39] WIP: Work on next_sibling

---
 .../html-api/class-wp-html-processor.php      | 55 +++++++++++++------
 ...Tests_HtmlApi_wpHtmlProcessor_Support.php} | 35 ++++++++++++
 2 files changed, 73 insertions(+), 17 deletions(-)
 rename tests/phpunit/tests/html-api/{wpHtmlTagProcessor-support.php => Tests_HtmlApi_wpHtmlProcessor_Support.php} (66%)

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index 16dc92f61ec5f..c7de3079970f0 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -2,6 +2,7 @@
 
 class WP_HTML_Processor extends WP_HTML_Tag_Processor {
 	public $fully_supported_input = null;
+	public $open_elements = array();
 
 	public function ensure_support() {
 		if ( null !== $this->fully_supported_input ) {
@@ -42,35 +43,55 @@ public function next_tag( $query = null ) {
 			return false;
 		}
 
-		return parent::next_tag( $query );
+		if ( false === parent::next_tag( array( 'tag_closers' => 'visit' ) ) ) {
+			return false;
+		}
+
+		$tag_name = $this->get_tag();
+		$element = WP_HTML_Spec::element_info( $tag_name );
+
+		$self_closes = $element::is_void || ( ! $element::is_html && $this->has_self_closing_flag() );
+		if ( $self_closes ) {
+			return true;
+		}
+
+		if ( $this->is_tag_closer() ) {
+			array_pop( $this->open_elements );
+		} else {
+			$this->open_elements[] = $tag_name;
+		}
+
+		return true;
 	}
 
-	public function proceed_to_end_of_next_tag() {
+	public function next_sibling() {
 		if ( $this->fully_supported_input ) {
 			return false;
 		}
 
-		$open_elements = array();
+		$starting_depth = count( $this->open_elements );
 
-		while ( $this->next_tag( array( 'tag_closers' => 'visit' ) ) ) {
-			$tag_name = $this->get_tag();
-			$element = WP_HTML_Spec::element_info( $tag_name );
+		/*
+		 * If we aren't already inside a tag then advance to the first one.
+		 * If that tag is self-closing then we're done. Otherwise, open the
+		 * stack with that tag name and prepare to close out the stack.
+		 */
+		if ( ! $this->get_tag() ) {
+			if ( ! $this->next_tag() ) {
+				return false;
+			}
 
-			if ( $element::is_void ) {
+			if ( $starting_depth === count( $this->open_elements ) ) {
 				return true;
 			}
+		}
 
-			if ( $this->is_tag_closer() ) {
-				if ( 0 === count( $open_elements ) || $open_elements[ count( $open_elements ) - 1 ] !== $tag_name ) {
-					$this->fully_supported_input = true;
-					return false;
-				}
-
-				array_pop( $open_elements );
-				if ( 0 === count( $open_elements ) ) {
-					return true;
-				}
+		while ( $this->next_tag() ) {
+			if ( $starting_depth === count( $this->open_elements ) ) {
+				return true;
 			}
 		}
+
+		return false;
 	}
 }
diff --git a/tests/phpunit/tests/html-api/wpHtmlTagProcessor-support.php b/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
similarity index 66%
rename from tests/phpunit/tests/html-api/wpHtmlTagProcessor-support.php
rename to tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
index 11b1eb8c418ca..90d11a7f60af9 100644
--- a/tests/phpunit/tests/html-api/wpHtmlTagProcessor-support.php
+++ b/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
@@ -6,6 +6,17 @@
  * @subpackage HTML-API
  */
 
+require_once '/Users/dmsnell/code/WordPress-develop/src/wp-includes/html-api/class-wp-html-attribute-token.php';
+require_once '/Users/dmsnell/code/WordPress-develop/src/wp-includes/html-api/class-wp-html-span.php';
+require_once '/Users/dmsnell/code/WordPress-develop/src/wp-includes/html-api/class-wp-html-spec.php';
+require_once '/Users/dmsnell/code/WordPress-develop/src/wp-includes/html-api/class-wp-html-text-replacement.php';
+require_once '/Users/dmsnell/code/WordPress-develop/src/wp-includes/html-api/class-wp-html-tag-processor.php';
+require_once '/Users/dmsnell/code/WordPress-develop/src/wp-includes/html-api/class-wp-html-processor.php';
+
+class WP_UnitTestCase extends PHPUnit\Framework\TestCase {}
+
+function esc_attr( $s ) { return str_replace( [ '<', '>', '"' ], [ '&lt;', '&gt;', '&quot;' ], $s ); }
+
 /**
  * @group html-api
  *
@@ -69,4 +80,28 @@ public function test_does_not_call_next_tag_for_unsupported_html( $html ) {
 
 		$this->assertFalse( $p->next_tag(), "Advanced to '{$p->get_tag()}' even though input HTML isn't supported." );
 	}
+
+	/**
+	 * @dataProvider data_next_sibling
+	 */
+	public function test_finds_next_sibling( $html ) {
+		$p = new WP_HTML_Processor( $html );
+
+		while ( true !== $p->get_attribute( 'start' ) ) {
+			$p->next_tag();
+		}
+		$p->next_sibling();
+
+		$this->assertTrue( $p->get_attribute( 'end' ) );
+	}
+
+	/**
+	 * @return array[]
+	 */
+	public function data_next_sibling() {
+		return array(
+			'Top-level siblings' => array( '<img start><img end><img>' ),
+			'List items'         => array( '<ul><li>One</li><li start>Two</lista><li end>Three</li><li>Four</li></ul>' ),
+		);
+	}
 }

From 65c9f5b37335d7888fd7b0831691ad2377b5996b Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Thu, 9 Mar 2023 17:47:18 -0700
Subject: [PATCH 11/39] Add the rest of it

---
 .../html-api/class-wp-html-processor.php      | 182 ++++++++++++-
 .../Tests_HtmlApi_wpHtmlProcessor_Support.php | 248 +++++++++++++++++-
 2 files changed, 413 insertions(+), 17 deletions(-)

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index c7de3079970f0..29b6fe81955f6 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -43,6 +43,14 @@ public function next_tag( $query = null ) {
 			return false;
 		}
 
+		if ( 0 < count( $this->open_elements ) ) {
+			$element = WP_HTML_Spec::element_info( end( $this->open_elements ) );
+			// @TODO: Handle self-closing HTML foreign elements: must convey self-closing flag on stack.
+			if ( $element::is_void ) {
+				array_pop( $this->open_elements );
+			}
+		}
+
 		if ( false === parent::next_tag( array( 'tag_closers' => 'visit' ) ) ) {
 			return false;
 		}
@@ -52,6 +60,7 @@ public function next_tag( $query = null ) {
 
 		$self_closes = $element::is_void || ( ! $element::is_html && $this->has_self_closing_flag() );
 		if ( $self_closes ) {
+			$this->open_elements[] = $tag_name;
 			return true;
 		}
 
@@ -65,33 +74,186 @@ public function next_tag( $query = null ) {
 	}
 
 	public function next_sibling() {
-		if ( $this->fully_supported_input ) {
+		if ( false === $this->fully_supported_input || false === $this->ensure_support() ) {
 			return false;
 		}
 
 		$starting_depth = count( $this->open_elements );
 
-		/*
-		 * If we aren't already inside a tag then advance to the first one.
-		 * If that tag is self-closing then we're done. Otherwise, open the
-		 * stack with that tag name and prepare to close out the stack.
-		 */
-		if ( ! $this->get_tag() ) {
-			if ( ! $this->next_tag() ) {
+		while ( $this->next_tag() ) {
+			$current_depth = count( $this->open_elements );
+
+			if ( ! $this->is_tag_closer() && $current_depth === $starting_depth ) {
+				return true;
+			}
+
+			if ( ! $this->is_tag_closer() && $current_depth < $starting_depth ) {
 				return false;
 			}
+		}
+
+		return false;
+	}
+
+	public function next_child() {
+		if ( false === $this->fully_supported_input || false === $this->ensure_support() ) {
+			return false;
+		}
 
-			if ( $starting_depth === count( $this->open_elements ) ) {
+		$starting_depth = count( $this->open_elements );
+
+		while ( $this->next_tag() ) {
+			$current_depth = count( $this->open_elements );
+
+			if ( ! $this->is_tag_closer() && $current_depth === $starting_depth + 1 ) {
 				return true;
 			}
 		}
 
+		return false;
+	}
+
+	private function find_closing_tag() {
+		$starting_depth = count( $this->open_elements );
+
 		while ( $this->next_tag() ) {
-			if ( $starting_depth === count( $this->open_elements ) ) {
+			$current_depth = count( $this->open_elements );
+
+			if ( $this->is_tag_closer() && $current_depth < $starting_depth ) {
 				return true;
 			}
 		}
 
 		return false;
 	}
+
+	public function get_inner_content() {
+		if ( false === $this->fully_supported_input || false === $this->ensure_support() ) {
+			return false;
+		}
+
+		if ( ! $this->get_tag() || $this->is_tag_closer() ) {
+			return false;
+		}
+
+		$element = WP_HTML_Spec::element_info( $this->get_tag() );
+		if ( $element::is_void || ( ! $element::is_html && $this->has_self_closing_flag() ) ) {
+			return false;
+		}
+
+		// @TODO: Unique bookmark names
+		$this->set_bookmark( 'start' );
+		if ( ! $this->find_closing_tag() ) {
+			return false;
+		}
+		$this->set_bookmark( 'end' );
+
+		$start = $this->bookmarks['start']->end + 1;
+		$end = $this->bookmarks['end']->start - 1;
+		$inner_content = substr( $this->html, $start, $end - $start + 1 );
+
+		$this->release_bookmark( 'start' );
+		$this->release_bookmark( 'end' );
+
+		return $inner_content;
+	}
+
+	public function set_inner_content( $new_html ) {
+		if ( false === $this->fully_supported_input || false === $this->ensure_support() ) {
+			return false;
+		}
+
+		if ( ! $this->get_tag() || $this->is_tag_closer() ) {
+			return false;
+		}
+
+		$element = WP_HTML_Spec::element_info( $this->get_tag() );
+		if ( $element::is_void || ( ! $element::is_html && $this->has_self_closing_flag() ) ) {
+			return false;
+		}
+
+		// @TODO: Unique bookmark names
+		$this->set_bookmark( 'start' );
+		if ( ! $this->find_closing_tag() ) {
+			return false;
+		}
+		$this->set_bookmark( 'end' );
+
+		$start = $this->bookmarks['start']->end + 1;
+		$end = $this->bookmarks['end']->start;
+		$this->lexical_updates[] = new WP_HTML_Text_Replacement( $start, $end, $new_html );
+		$this->get_updated_html();
+		$this->seek( 'start' );
+
+		$this->release_bookmark( 'start' );
+		$this->release_bookmark( 'end' );
+	}
+
+	public function get_outer_content() {
+		if ( false === $this->fully_supported_input || false === $this->ensure_support() ) {
+			return false;
+		}
+
+		if ( ! $this->get_tag() || $this->is_tag_closer() ) {
+			return false;
+		}
+
+		$element = WP_HTML_Spec::element_info( $this->get_tag() );
+		if ( $element::is_void || ( ! $element::is_html && $this->has_self_closing_flag() ) ) {
+			$this->set_bookmark( 'start' );
+			$here = $this->bookmarks['start'];
+			return substr( $this->html, $here->start, $here->end - $here->start + 1 );
+		}
+
+		// @TODO: Unique bookmark names
+		$this->set_bookmark( 'start' );
+		if ( ! $this->find_closing_tag() ) {
+			return false;
+		}
+		$this->set_bookmark( 'end' );
+
+		$start = $this->bookmarks['start']->start;
+		$end = $this->bookmarks['end']->end;
+		$inner_content = substr( $this->html, $start, $end - $start + 1 );
+		$this->seek( 'start' );
+
+		$this->release_bookmark( 'start' );
+		$this->release_bookmark( 'end' );
+
+		return $inner_content;
+	}
+
+	public function set_outer_content( $new_html ) {
+		if ( false === $this->fully_supported_input || false === $this->ensure_support() ) {
+			return false;
+		}
+
+		if ( ! $this->get_tag() || $this->is_tag_closer() ) {
+			return false;
+		}
+
+		$element = WP_HTML_Spec::element_info( $this->get_tag() );
+		// @TODO: Replace void and self-closing tags.
+		if ( $element::is_void || ( ! $element::is_html && $this->has_self_closing_flag() ) ) {
+			return false;
+		}
+
+		// @TODO: Unique bookmark names
+		$this->set_bookmark( 'start' );
+		if ( ! $this->find_closing_tag() ) {
+			return false;
+		}
+		$this->set_bookmark( 'end' );
+
+		$start = $this->bookmarks['start']->start;
+		$end = $this->bookmarks['end']->end + 1;
+		$this->lexical_updates[] = new WP_HTML_Text_Replacement( $start, $end, $new_html );
+		$this->get_updated_html();
+		$this->bookmarks['start']->start = $start;
+		$this->bookmarks['start']->end = $start;
+		$this->seek( 'start' );
+
+		$this->release_bookmark( 'start' );
+		$this->release_bookmark( 'end' );
+	}
 }
diff --git a/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php b/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
index 90d11a7f60af9..f83529f9f0d1c 100644
--- a/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
+++ b/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
@@ -23,6 +23,16 @@ function esc_attr( $s ) { return str_replace( [ '<', '>', '"' ], [ '&lt;', '&gt;
  * @coversDefaultClass WP_HTML_Processor
  */
 class Tests_HtmlApi_wpHtmlProcessor_Support extends WP_UnitTestCase {
+	private function html_processor_at_start( $html ) {
+		$p = new WP_HTML_Processor( $html );
+
+		while ( true !== $p->get_attribute( 'start' ) && $p->next_tag() ) {
+			continue;
+		}
+
+		return $p;
+	}
+
 	/**
 	 * @dataProvider data_fully_balanced_html
 	 */
@@ -85,14 +95,10 @@ public function test_does_not_call_next_tag_for_unsupported_html( $html ) {
 	 * @dataProvider data_next_sibling
 	 */
 	public function test_finds_next_sibling( $html ) {
-		$p = new WP_HTML_Processor( $html );
-
-		while ( true !== $p->get_attribute( 'start' ) ) {
-			$p->next_tag();
-		}
+		$p = $this->html_processor_at_start( $html );
 		$p->next_sibling();
 
-		$this->assertTrue( $p->get_attribute( 'end' ) );
+		$this->assertTrue( $p->get_attribute( 'end' ), 'Did not finding sibling tag.' );
 	}
 
 	/**
@@ -100,8 +106,236 @@ public function test_finds_next_sibling( $html ) {
 	 */
 	public function data_next_sibling() {
 		return array(
+			'Leading markup'     => array( 'before<img start><img end><img>' ),
 			'Top-level siblings' => array( '<img start><img end><img>' ),
-			'List items'         => array( '<ul><li>One</li><li start>Two</lista><li end>Three</li><li>Four</li></ul>' ),
+			'Nested siblings'    => array( '<ul><li>One</li><li start>Two</li><li end>Three</li><li>Four</li></ul>' ),
+			'Nesting avalanche'  => array( '<img start><ul end><li><div><p><strong><a><img></a></strong></p></div></li></ul><div></div><footer></footer>'),
+		);
+	}
+
+	/**
+	 * @dataProvider data_no_next_sibling
+	 */
+	public function test_finds_no_next_sibling_when_none_exists( $html ) {
+		$p = $this->html_processor_at_start( $html );
+		$this->assertFalse( $p->next_sibling(), 'Found a sibling when none exists.' );
+	}
+
+	public function data_no_next_sibling() {
+		return array(
+			'Leading markup'        => array( 'before<div><img start></div><img end><img>' ),
+			'No more siblings'      => array( '<ul><li></li><li start></li></ul><ul><li end></li></ul>' ),
+			'Tag-closing avalanche' => array( '<ul><li><div><p><strong><a><img start></a></strong></p></div></li></ul><div end></div><footer></footer>'),
+		);
+	}
+
+	/**
+	 * @dataProvider data_next_child
+	 */
+	public function test_finds_next_child( $html ) {
+		$p = $this->html_processor_at_start( $html );
+
+		$p->next_child();
+		$this->assertTrue( $p->get_attribute( 'end' ), 'Did not find child tag.' );
+	}
+
+	public function data_next_child() {
+		return array(
+			'Leading markup' => array( 'this is not tag content<div start><img end></div>afterwards' ),
+			'Normal nesting' => array( '<ul><li></li><li><p start>text<img end></p></li><li></li></ul>' ),
+		);
+	}
+
+	/**
+	 * @dataProvider data_no_next_child
+	 */
+	public function test_finds_no_next_child( $html ) {
+		$p = $this->html_processor_at_start( $html );
+
+		$this->assertFalse( $p->next_child(), 'Did not find child tag.' );
+	}
+
+	public function data_no_next_child() {
+		return array(
+			'Leading markup' => array( 'this is not tag content<div start></div><img end>afterwards' ),
+			'Already nested' => array( '<li><li></li><li><p start>text</p><img end></li><li></li></ul>', ),
+		);
+	}
+
+	public function test_finds_chain_of_elements() {
+		$p = new WP_HTML_Processor( <<<HTML
+<main>
+	<h2>Things I could be eating right now</h2>
+	<ul>
+		<li>Apples</li>
+		<li>Pears</li>
+		<li><em>Prickly</em> pears</li>
+		<li>
+			<img src="yum.avif">
+			<details>
+				<summary>Scwarzwälder Kirschtorte</summary>
+				<ul>
+					<li>Flour</li>
+					<li>Eggs</li>
+					<li this-one>Sugar</li>
+					<li>Cream</li>
+					<li>Cherries</li>
+					<li>Chocolate</li>
+				</ul>
+			</details>
+		</li>
+	</ul>
+</main>
+HTML
+		);
+
+		$p->next_tag();
+		$p->next_child();
+		$p->next_sibling();
+		$p->next_child();
+		$p->next_sibling();
+		$p->next_sibling();
+		$p->next_sibling();
+		$p->next_child();
+		$p->next_sibling();
+		$p->next_child();
+		$p->next_sibling();
+		$p->next_child();
+		$p->next_sibling();
+		$p->next_sibling();
+
+		$this->assertTrue( $p->get_attribute( 'this-one' ) );
+	}
+
+	/**
+	 * @dataProvider data_inner_content
+	 */
+	public function test_get_inner_content( $before, $inner, $after ) {
+		$p = $this->html_processor_at_start( $before . $inner . $after );
+
+		$this->assertSame( $inner, $p->get_inner_content(), 'Found the wrong inner content.' );
+	}
+
+	public function data_inner_content() {
+		return array(
+			'Leading text' => array( '<!-- when will this start? --><div start>', 'text', '</div>' ),
+			'Single tag'   => array( '<div start>', 'text', '</div>' ),
+			'Nested tags'  => array( '<div start>', '<ul><li>One</li><li><strong>Two<img></strong></li></ul>', '</div>' ),
+			'Complex HTML' => array(
+				<<<HTML
+<main>
+	<h2>Things I could be eating right now</h2>
+	<ul>
+		<li>Apples</li>
+		<li>Pears</li>
+		<li><em>Prickly</em> pears</li>
+		<li>
+			<img src="yum.avif">
+			<details start>
+HTML,
+				<<<HTML
+				<summary>Scwarzwälder Kirschtorte</summary>
+				<ul>
+					<li>Flour</li>
+					<li>Eggs</li>
+					<li>Sugar</li>
+					<li>Cream</li>
+					<li>Cherries</li>
+					<li>Chocolate</li>
+				</ul>
+
+HTML,
+			<<<HTML
+</details>
+		</li>
+	</ul>
+</main>
+HTML
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider data_set_inner_content
+	 */
+	public function test_set_inner_content( $before, $old, $new, $after ) {
+		$p = $this->html_processor_at_start( $before . $old . $after );
+
+		$p->set_inner_content( $new );
+
+		$this->assertSame( $before . $new . $after, $p->get_updated_html(), 'Did not properly swap out inner content.' );
+	}
+
+	public function data_set_inner_content() {
+		return array(
+			'Single tag'  => array( '<div start>', 'boring text', 'exciting text', '</div>' ),
+			'Nested tags' => array( '<div><ul><li start>', '<p><img>This is <strong>neat</strong></p>', 'this<br>is<br>not', '</li></ul></div>' ),
+		);
+	}
+
+	/**
+	 * @dataProvider data_outer_content
+	 */
+	public function test_get_outer_content( $before, $outer, $after ) {
+		$p = $this->html_processor_at_start( $before . $outer . $after );
+
+		$this->assertSame( $outer, $p->get_outer_content(), 'Found the wrong outer content.' );
+	}
+
+	public function data_outer_content() {
+		return array(
+			'Leading text' => array( '<!-- when will this start? -->', '<div start>text</div>', 'when will it end?' ),
+			'Single tag'   => array( '', '<div start>text</div>', '' ),
+			'Nested tags'  => array( '<div>', '<ul start><li>One</li><li><strong>Two<img></strong></li></ul>', '</div>' ),
+			'Complex HTML' => array(
+				<<<HTML
+<main>
+	<h2>Things I could be eating right now</h2>
+	<ul>
+		<li>Apples</li>
+		<li>Pears</li>
+		<li><em>Prickly</em> pears</li>
+		<li>
+			<img src="yum.avif">
+
+HTML,
+				<<<HTML
+<details start>
+				<summary>Scwarzwälder Kirschtorte</summary>
+				<ul>
+					<li>Flour</li>
+					<li>Eggs</li>
+					<li>Sugar</li>
+					<li>Cream</li>
+					<li>Cherries</li>
+					<li>Chocolate</li>
+				</ul>
+			</details>
+HTML,
+			<<<HTML
+		</li>
+	</ul>
+</main>
+HTML
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider data_set_outer_content
+	 */
+	public function test_set_outer_content( $before, $old, $new, $after ) {
+		$p = $this->html_processor_at_start( $before . $old . $after );
+
+		$p->set_outer_content( $new );
+
+		$this->assertSame( $before . $new . $after, $p->get_updated_html(), 'Did not properly swap out outer content.' );
+	}
+
+	public function data_set_outer_content() {
+		return array(
+			'Single tag'  => array( '', '<div start>boring text</div>', 'exciting text', '' ),
+			'Nested tags' => array( '<div><ul>', '<li start><p><img>This is <strong>neat</strong></p></li>', '<li>this is<br>not</li>', '<li></li></ul></div>' ),
 		);
 	}
 }

From 247966b4c4b9fe35727f86e88e77f6b2c528f7a9 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Tue, 21 Mar 2023 16:56:34 -0700
Subject: [PATCH 12/39] Rename "next_child" to "first_child" to better match
 its purpose

---
 .../html-api/class-wp-html-processor.php           |  2 +-
 .../Tests_HtmlApi_wpHtmlProcessor_Support.php      | 14 +++++++-------
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index 29b6fe81955f6..bee001da42d88 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -95,7 +95,7 @@ public function next_sibling() {
 		return false;
 	}
 
-	public function next_child() {
+	public function first_child() {
 		if ( false === $this->fully_supported_input || false === $this->ensure_support() ) {
 			return false;
 		}
diff --git a/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php b/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
index f83529f9f0d1c..85848c7f31f07 100644
--- a/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
+++ b/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
@@ -135,7 +135,7 @@ public function data_no_next_sibling() {
 	public function test_finds_next_child( $html ) {
 		$p = $this->html_processor_at_start( $html );
 
-		$p->next_child();
+		$p->first_child();
 		$this->assertTrue( $p->get_attribute( 'end' ), 'Did not find child tag.' );
 	}
 
@@ -152,7 +152,7 @@ public function data_next_child() {
 	public function test_finds_no_next_child( $html ) {
 		$p = $this->html_processor_at_start( $html );
 
-		$this->assertFalse( $p->next_child(), 'Did not find child tag.' );
+		$this->assertFalse( $p->first_child(), 'Did not find child tag.' );
 	}
 
 	public function data_no_next_child() {
@@ -190,17 +190,17 @@ public function test_finds_chain_of_elements() {
 		);
 
 		$p->next_tag();
-		$p->next_child();
+		$p->first_child();
 		$p->next_sibling();
-		$p->next_child();
+		$p->first_child();
 		$p->next_sibling();
 		$p->next_sibling();
 		$p->next_sibling();
-		$p->next_child();
+		$p->first_child();
 		$p->next_sibling();
-		$p->next_child();
+		$p->first_child();
 		$p->next_sibling();
-		$p->next_child();
+		$p->first_child();
 		$p->next_sibling();
 		$p->next_sibling();
 

From f1ccd9be082b2c2c47e7a4ec72f86f1f7979f751 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Tue, 21 Mar 2023 18:01:03 -0700
Subject: [PATCH 13/39] Ensure no children are found for void elements.

---
 .../tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php     | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php b/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
index 85848c7f31f07..7b3a97e549bfe 100644
--- a/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
+++ b/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
@@ -159,6 +159,7 @@ public function data_no_next_child() {
 		return array(
 			'Leading markup' => array( 'this is not tag content<div start></div><img end>afterwards' ),
 			'Already nested' => array( '<li><li></li><li><p start>text</p><img end></li><li></li></ul>', ),
+			'Void element'   => array( '<img start>' ),
 		);
 	}
 

From fb31ea1c0824fcfa2cca57bf05d213cafdd2ee93 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Tue, 21 Mar 2023 18:02:04 -0700
Subject: [PATCH 14/39] rename next_child to first_child in test names

---
 .../Tests_HtmlApi_wpHtmlProcessor_Support.php        | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php b/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
index 7b3a97e549bfe..9acb589360356 100644
--- a/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
+++ b/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
@@ -130,16 +130,16 @@ public function data_no_next_sibling() {
 	}
 
 	/**
-	 * @dataProvider data_next_child
+	 * @dataProvider data_first_child
 	 */
-	public function test_finds_next_child( $html ) {
+	public function test_finds_first_child( $html ) {
 		$p = $this->html_processor_at_start( $html );
 
 		$p->first_child();
 		$this->assertTrue( $p->get_attribute( 'end' ), 'Did not find child tag.' );
 	}
 
-	public function data_next_child() {
+	public function data_first_child() {
 		return array(
 			'Leading markup' => array( 'this is not tag content<div start><img end></div>afterwards' ),
 			'Normal nesting' => array( '<ul><li></li><li><p start>text<img end></p></li><li></li></ul>' ),
@@ -147,15 +147,15 @@ public function data_next_child() {
 	}
 
 	/**
-	 * @dataProvider data_no_next_child
+	 * @dataProvider data_no_first_child
 	 */
-	public function test_finds_no_next_child( $html ) {
+	public function test_finds_no_first_child( $html ) {
 		$p = $this->html_processor_at_start( $html );
 
 		$this->assertFalse( $p->first_child(), 'Did not find child tag.' );
 	}
 
-	public function data_no_next_child() {
+	public function data_no_first_child() {
 		return array(
 			'Leading markup' => array( 'this is not tag content<div start></div><img end>afterwards' ),
 			'Already nested' => array( '<li><li></li><li><p start>text</p><img end></li><li></li></ul>', ),

From e945f16fb8843c209083d03375aa0d162f824f49 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Wed, 29 Mar 2023 05:35:30 -0700
Subject: [PATCH 15/39] Add Trac ticket reference to tests

---
 tests/phpunit/tests/html-api/wpHtmlTagProcessor.php | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php b/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
index 6ad80a29cf72f..f938a14441a58 100644
--- a/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
+++ b/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
@@ -52,7 +52,7 @@ public function test_get_tag_returns_open_tag_name() {
 	}
 
 	/**
-	 * @ticket NEEDS TICKET
+	 * @ticket 58009 TICKET
 	 *
 	 * @covers WP_HTML_Tag_Processor::has_self_closing_flag()
 	 *

From 96053c9c737891287e68a1ead2113fa3e79284b4 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Wed, 29 Mar 2023 05:40:41 -0700
Subject: [PATCH 16/39] fixup! Add Trac ticket reference to tests

---
 tests/phpunit/tests/html-api/wpHtmlTagProcessor.php | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php b/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
index f938a14441a58..3d12f065f5168 100644
--- a/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
+++ b/tests/phpunit/tests/html-api/wpHtmlTagProcessor.php
@@ -52,7 +52,7 @@ public function test_get_tag_returns_open_tag_name() {
 	}
 
 	/**
-	 * @ticket 58009 TICKET
+	 * @ticket 58009
 	 *
 	 * @covers WP_HTML_Tag_Processor::has_self_closing_flag()
 	 *

From 04a37b5e1fbfb333f584d37f3286889f65e4f082 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Wed, 29 Mar 2023 07:33:40 -0700
Subject: [PATCH 17/39] Linting issues

---
 .../html-api/class-wp-html-processor.php      |  14 +-
 .../html-api/class-wp-html-spec.php           | 894 +++++++++++++-----
 .../Tests_HtmlApi_wpHtmlProcessor_Support.php |  32 +-
 3 files changed, 659 insertions(+), 281 deletions(-)

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index bee001da42d88..e9e64647506e2 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -18,7 +18,7 @@ public function ensure_support() {
 			if ( ! $p->is_tag_closer() ) {
 				$element = WP_HTML_Spec::element_info( $tag_name );
 
-				$self_closes = $element::is_void || ( ! $element::is_html && $p->has_self_closing_flag() );
+				$self_closes = $element::IS_VOID || ( ! $element::IS_HTML && $p->has_self_closing_flag() );
 				if ( ! $self_closes ) {
 					$stack[] = $tag_name;
 				}
@@ -46,7 +46,7 @@ public function next_tag( $query = null ) {
 		if ( 0 < count( $this->open_elements ) ) {
 			$element = WP_HTML_Spec::element_info( end( $this->open_elements ) );
 			// @TODO: Handle self-closing HTML foreign elements: must convey self-closing flag on stack.
-			if ( $element::is_void ) {
+			if ( $element::IS_VOID ) {
 				array_pop( $this->open_elements );
 			}
 		}
@@ -58,7 +58,7 @@ public function next_tag( $query = null ) {
 		$tag_name = $this->get_tag();
 		$element = WP_HTML_Spec::element_info( $tag_name );
 
-		$self_closes = $element::is_void || ( ! $element::is_html && $this->has_self_closing_flag() );
+		$self_closes = $element::IS_VOID || ( ! $element::IS_HTML && $this->has_self_closing_flag() );
 		if ( $self_closes ) {
 			$this->open_elements[] = $tag_name;
 			return true;
@@ -137,7 +137,7 @@ public function get_inner_content() {
 		}
 
 		$element = WP_HTML_Spec::element_info( $this->get_tag() );
-		if ( $element::is_void || ( ! $element::is_html && $this->has_self_closing_flag() ) ) {
+		if ( $element::IS_VOID || ( ! $element::IS_HTML && $this->has_self_closing_flag() ) ) {
 			return false;
 		}
 
@@ -168,7 +168,7 @@ public function set_inner_content( $new_html ) {
 		}
 
 		$element = WP_HTML_Spec::element_info( $this->get_tag() );
-		if ( $element::is_void || ( ! $element::is_html && $this->has_self_closing_flag() ) ) {
+		if ( $element::IS_VOID || ( ! $element::IS_HTML && $this->has_self_closing_flag() ) ) {
 			return false;
 		}
 
@@ -199,7 +199,7 @@ public function get_outer_content() {
 		}
 
 		$element = WP_HTML_Spec::element_info( $this->get_tag() );
-		if ( $element::is_void || ( ! $element::is_html && $this->has_self_closing_flag() ) ) {
+		if ( $element::IS_VOID || ( ! $element::IS_HTML && $this->has_self_closing_flag() ) ) {
 			$this->set_bookmark( 'start' );
 			$here = $this->bookmarks['start'];
 			return substr( $this->html, $here->start, $here->end - $here->start + 1 );
@@ -234,7 +234,7 @@ public function set_outer_content( $new_html ) {
 
 		$element = WP_HTML_Spec::element_info( $this->get_tag() );
 		// @TODO: Replace void and self-closing tags.
-		if ( $element::is_void || ( ! $element::is_html && $this->has_self_closing_flag() ) ) {
+		if ( $element::IS_VOID || ( ! $element::IS_HTML && $this->has_self_closing_flag() ) ) {
 			return false;
 		}
 
diff --git a/src/wp-includes/html-api/class-wp-html-spec.php b/src/wp-includes/html-api/class-wp-html-spec.php
index cef3e07c0bdff..a82826903a422 100644
--- a/src/wp-includes/html-api/class-wp-html-spec.php
+++ b/src/wp-includes/html-api/class-wp-html-spec.php
@@ -8,7 +8,7 @@
  */
 class WP_HTML_Spec {
 	/**
-	 * Returns meta information about an HTML tag.
+	 * Returns class defining attributes of an element with the given name.
 	 *
 	 * @since 6.3.0
 	 *
@@ -16,277 +16,651 @@ class WP_HTML_Spec {
 	 * @return WP_HTML_Element_Meta::class
 	 */
 	public static function element_info( $tag_name ) {
-		switch ( strtolower( $tag_name ) ) {
+		// We have to force casing on this because someone might call it with mixed casing.
+		switch ( strtoupper( $tag_name ) ) {
 			// Normal elements
-			case 'a': return WP_HTMLAnchorElement::class;
-			case 'abbr': return WP_HTMLAbbrElement::class;
-			case 'address': return WP_HTMLAddressElement::class;
-			case 'area': return WP_HTMLAreaElement::class;
-			case 'article': return WP_HTMLArticleElement::class;
-			case 'aside': return WP_HTMLAsideElement::class;
-			case 'audio': return WP_HTMLAudioElement::class;
-			case 'b': return WP_HTMLBElement::class;
-			case 'base': return WP_HTMLBaseElement::class;
-			case 'bdi': return WP_HTMLBdiElement::class;
-			case 'bdo': return WP_HTMLBdoElement::class;
-			case 'blockquote': return WP_HTMLBlockquoteElement::class;
-			case 'body': return WP_HTMLBodyElement::class;
-			case 'br': return WP_HTMLBrElement::class;
-			case 'button': return WP_HTMLButtonElement::class;
-			case 'canvas': return WP_HTMLCanvasElement::class;
-			case 'caption': return WP_HTMLCaptionElement::class;
-			case 'cite': return WP_HTMLCiteElement::class;
-			case 'code': return WP_HTMLCodeElement::class;
-			case 'col': return WP_HTMLColElement::class;
-			case 'colgroup': return WP_HTMLColgroupElement::class;
-			case 'data': return WP_HTMLDataElement::class;
-			case 'datalist': return WP_HTMLDataListElement::class;
-			case 'dd': return WP_HTMLDdElement::class;
-			case 'del': return WP_HTMLDelElement::class;
-			case 'details': return WP_HTMLDetailsElement::class;
-			case 'dfn': return WP_HTMLDfnElement::class;
-			case 'dialog': return WP_HTMLDialogElement::class;
-			case 'div': return WP_HTMLDivElement::class;
-			case 'dl': return WP_HTMLDlElement::class;
-			case 'dt': return WP_HTMLDtElement::class;
-			case 'em': return WP_HTMLEmElement::class;
-			case 'embed': return WP_HTMLEmbedElement::class;
-			case 'fieldset': return WP_HTMLFieldsetElement::class;
-			case 'figcaption': return WP_HTMLFigcaptionElement::class;
-			case 'figure': return WP_HTMLFigureElement::class;
-			case 'footer': return WP_HTMLFooterElement::class;
-			case 'form': return WP_HTMLFormElement::class;
-			case 'h1': return WP_HTMLH1Element::class;
-			case 'h2': return WP_HTMLH2Element::class;
-			case 'h3': return WP_HTMLH3Element::class;
-			case 'h4': return WP_HTMLH4Element::class;
-			case 'h5': return WP_HTMLH5Element::class;
-			case 'h6': return WP_HTMLH6Element::class;
-			case 'head': return WP_HTMLHeadElement::class;
-			case 'header': return WP_HTMLHeaderElement::class;
-			case 'hgroup': return WP_HTMLHgropuElement::class;
-			case 'hr': return WP_HTMLHrElement::class;
-			case 'html': return WP_HTMLHtmlElement::class;
-			case 'i': return WP_HTMLIElement::class;
-			case 'iframe': return WP_HTMLIframeElement::class;
-			case 'img': return WP_HTMLImgElement::class;
-			case 'input': return WP_HTMLInputElement::class;
-			case 'ins': return WP_HTMLInsElement::class;
-			case 'kbd': return WP_HTMLKbdElement::class;
-			case 'label': return WP_HTMLLabelElement::class;
-			case 'legend': return WP_HTMLLegendElement::class;
-			case 'li': return WP_HTMLLiElement::class;
-			case 'link': return WP_HTMLLinkElement::class;
-			case 'main': return WP_HTMLMainElement::class;
-			case 'map': return WP_HTMLMapElement::class;
-			case 'mark': return WP_HTMLMarkElement::class;
-			case 'math': return WP_HTMLMathElement::class;
-			case 'menu': return WP_HTMLMenuElement::class;
-			case 'meta': return WP_HTMLMetaElement::class;
-			case 'meter': return WP_HTMLMeterElement::class;
-			case 'nav': return WP_HTMLNavElement::class;
-			case 'noscript': return WP_HTMLNoscriptElement::class;
-			case 'object': return WP_HTMLObjectElement::class;
-			case 'ol': return WP_HTMLOlElement::class;
-			case 'optgroup': return WP_HTMLOptgroupElement::class;
-			case 'option': return WP_HTMLOptionElement::class;
-			case 'output': return WP_HTMLOutputElement::class;
-			case 'p': return WP_HTMLPElement::class;
-			case 'picture': return WP_HTMLPictureElement::class;
-			case 'pre': return WP_HTMLPreElement::class;
-			case 'progress': return WP_HTMLProgressElement::class;
-			case 'q': return WP_HTMLQElement::class;
-			case 'rp': return WP_HTMLRpElement::class;
-			case 'rt': return WP_HTMLRtElement::class;
-			case 'ruby': return WP_HTMLRubyElement::class;
-			case 's': return WP_HTMLSElement::class;
-			case 'samp': return WP_HTMLSampElement::class;
-			case 'script': return WP_HTMLScriptElement::class;
-			case 'section': return WP_HTMLSectionElement::class;
-			case 'select': return WP_HTMLSelectElement::class;
-			case 'slot': return WP_HTMLSlotElement::class;
-			case 'small': return WP_HTMLSmallElement::class;
-			case 'source': return WP_HTMLSourceElement::class;
-			case 'span': return WP_HTMLSpanElement::class;
-			case 'strong': return WP_HTMLStrongElement::class;
-			case 'style': return WP_HTMLStyleElement::class;
-			case 'sub': return WP_HTMLSubElement::class;
-			case 'summary': return WP_HTMLSummaryElement::class;
-			case 'sup': return WP_HTMLSupElement::class;
-			case 'svg': return WP_HTMLSvgElement::class;
-			case 'table': return WP_HTMLTableElement::class;
-			case 'tbody': return WP_HTMLTbodyElement::class;
-			case 'td': return WP_HTMLTdElement::class;
-			case 'template': return WP_HTMLTemplateElement::class;
-			case 'textarea': return WP_HTMLTextareaElement::class;
-			case 'tfoot': return WP_HTMLTfootElement::class;
-			case 'th': return WP_HTMLThElement::class;
-			case 'thead': return WP_HTMLTheadElement::class;
-			case 'time': return WP_HTMLTimeElement::class;
-			case 'title': return WP_HTMLTitleElement::class;
-			case 'tr': return WP_HTMLTrElement::class;
-			case 'track': return WP_HTMLTrackElement::class;
-			case 'u': return WP_HTMLUElement::class;
-			case 'ul': return WP_HTMLUlElement::class;
-			case 'var': return WP_HTMLVarElement::class;
-			case 'video': return WP_HTMLVideoElement::class;
-			case 'wbr': return WP_HTMLWbrElement::class;
+			case 'A':
+				return WP_HTMLAnchorElement::class;
+			case 'ABBR':
+				return WP_HTMLAbbrElement::class;
+			case 'ADDRESS':
+				return WP_HTMLAddressElement::class;
+			case 'AREA':
+				return WP_HTMLAreaElement::class;
+			case 'ARTICLE':
+				return WP_HTMLArticleElement::class;
+			case 'ASIDE':
+				return WP_HTMLAsideElement::class;
+			case 'AUDIO':
+				return WP_HTMLAudioElement::class;
+			case 'B':
+				return WP_HTMLBElement::class;
+			case 'BASE':
+				return WP_HTMLBaseElement::class;
+			case 'BDI':
+				return WP_HTMLBdiElement::class;
+			case 'BDO':
+				return WP_HTMLBdoElement::class;
+			case 'BLOCKQUOTE':
+				return WP_HTMLBlockquoteElement::class;
+			case 'BODY':
+				return WP_HTMLBodyElement::class;
+			case 'BR':
+				return WP_HTMLBrElement::class;
+			case 'BUTTON':
+				return WP_HTMLButtonElement::class;
+			case 'CANVAS':
+				return WP_HTMLCanvasElement::class;
+			case 'CAPTION':
+				return WP_HTMLCaptionElement::class;
+			case 'CITE':
+				return WP_HTMLCiteElement::class;
+			case 'CODE':
+				return WP_HTMLCodeElement::class;
+			case 'COL':
+				return WP_HTMLColElement::class;
+			case 'COLGROUP':
+				return WP_HTMLColgroupElement::class;
+			case 'DATA':
+				return WP_HTMLDataElement::class;
+			case 'DATALIST':
+				return WP_HTMLDataListElement::class;
+			case 'DD':
+				return WP_HTMLDdElement::class;
+			case 'DEL':
+				return WP_HTMLDelElement::class;
+			case 'DETAILS':
+				return WP_HTMLDetailsElement::class;
+			case 'DFN':
+				return WP_HTMLDfnElement::class;
+			case 'DIALOG':
+				return WP_HTMLDialogElement::class;
+			case 'DIV':
+				return WP_HTMLDivElement::class;
+			case 'DL':
+				return WP_HTMLDlElement::class;
+			case 'DT':
+				return WP_HTMLDtElement::class;
+			case 'EM':
+				return WP_HTMLEmElement::class;
+			case 'EMBED':
+				return WP_HTMLEmbedElement::class;
+			case 'FIELDSET':
+				return WP_HTMLFieldsetElement::class;
+			case 'FIGCAPTION':
+				return WP_HTMLFigcaptionElement::class;
+			case 'FIGURE':
+				return WP_HTMLFigureElement::class;
+			case 'FOOTER':
+				return WP_HTMLFooterElement::class;
+			case 'FORM':
+				return WP_HTMLFormElement::class;
+			case 'H1':
+				return WP_HTMLH1Element::class;
+			case 'H2':
+				return WP_HTMLH2Element::class;
+			case 'H3':
+				return WP_HTMLH3Element::class;
+			case 'H4':
+				return WP_HTMLH4Element::class;
+			case 'H5':
+				return WP_HTMLH5Element::class;
+			case 'H6':
+				return WP_HTMLH6Element::class;
+			case 'HEAD':
+				return WP_HTMLHeadElement::class;
+			case 'HEADER':
+				return WP_HTMLHeaderElement::class;
+			case 'HGROUP':
+				return WP_HTMLHgropuElement::class;
+			case 'HR':
+				return WP_HTMLHrElement::class;
+			case 'HTML':
+				return WP_HTMLHtmlElement::class;
+			case 'I':
+				return WP_HTMLIElement::class;
+			case 'IFRAME':
+				return WP_HTMLIframeElement::class;
+			case 'IMG':
+				return WP_HTMLImgElement::class;
+			case 'INPUT':
+				return WP_HTMLInputElement::class;
+			case 'INS':
+				return WP_HTMLInsElement::class;
+			case 'KBD':
+				return WP_HTMLKbdElement::class;
+			case 'LABEL':
+				return WP_HTMLLabelElement::class;
+			case 'LEGEND':
+				return WP_HTMLLegendElement::class;
+			case 'LI':
+				return WP_HTMLLiElement::class;
+			case 'LINK':
+				return WP_HTMLLinkElement::class;
+			case 'MAIN':
+				return WP_HTMLMainElement::class;
+			case 'MAP':
+				return WP_HTMLMapElement::class;
+			case 'MARK':
+				return WP_HTMLMarkElement::class;
+			case 'MATH':
+				return WP_HTMLMathElement::class;
+			case 'MENU':
+				return WP_HTMLMenuElement::class;
+			case 'META':
+				return WP_HTMLMetaElement::class;
+			case 'METER':
+				return WP_HTMLMeterElement::class;
+			case 'NAV':
+				return WP_HTMLNavElement::class;
+			case 'NOSCRIPT':
+				return WP_HTMLNoscriptElement::class;
+			case 'OBJECT':
+				return WP_HTMLObjectElement::class;
+			case 'OL':
+				return WP_HTMLOlElement::class;
+			case 'OPTGROUP':
+				return WP_HTMLOptgroupElement::class;
+			case 'OPTION':
+				return WP_HTMLOptionElement::class;
+			case 'OUTPUT':
+				return WP_HTMLOutputElement::class;
+			case 'P':
+				return WP_HTMLPElement::class;
+			case 'PICTURE':
+				return WP_HTMLPictureElement::class;
+			case 'PRE':
+				return WP_HTMLPreElement::class;
+			case 'PROGRESS':
+				return WP_HTMLProgressElement::class;
+			case 'Q':
+				return WP_HTMLQElement::class;
+			case 'RP':
+				return WP_HTMLRpElement::class;
+			case 'RT':
+				return WP_HTMLRtElement::class;
+			case 'RUBY':
+				return WP_HTMLRubyElement::class;
+			case 'S':
+				return WP_HTMLSElement::class;
+			case 'SAMP':
+				return WP_HTMLSampElement::class;
+			case 'SCRIPT':
+				return WP_HTMLScriptElement::class;
+			case 'SECTION':
+				return WP_HTMLSectionElement::class;
+			case 'SELECT':
+				return WP_HTMLSelectElement::class;
+			case 'SLOT':
+				return WP_HTMLSlotElement::class;
+			case 'SMALL':
+				return WP_HTMLSmallElement::class;
+			case 'SOURCE':
+				return WP_HTMLSourceElement::class;
+			case 'SPAN':
+				return WP_HTMLSpanElement::class;
+			case 'STRONG':
+				return WP_HTMLStrongElement::class;
+			case 'STYLE':
+				return WP_HTMLStyleElement::class;
+			case 'SUB':
+				return WP_HTMLSubElement::class;
+			case 'SUMMARY':
+				return WP_HTMLSummaryElement::class;
+			case 'SUP':
+				return WP_HTMLSupElement::class;
+			case 'SVG':
+				return WP_HTMLSvgElement::class;
+			case 'TABLE':
+				return WP_HTMLTableElement::class;
+			case 'TBODY':
+				return WP_HTMLTbodyElement::class;
+			case 'TD':
+				return WP_HTMLTdElement::class;
+			case 'TEMPLATE':
+				return WP_HTMLTemplateElement::class;
+			case 'TEXTAREA':
+				return WP_HTMLTextareaElement::class;
+			case 'TFOOT':
+				return WP_HTMLTfootElement::class;
+			case 'TH':
+				return WP_HTMLThElement::class;
+			case 'THEAD':
+				return WP_HTMLTheadElement::class;
+			case 'TIME':
+				return WP_HTMLTimeElement::class;
+			case 'TITLE':
+				return WP_HTMLTitleElement::class;
+			case 'TR':
+				return WP_HTMLTrElement::class;
+			case 'TRACK':
+				return WP_HTMLTrackElement::class;
+			case 'U':
+				return WP_HTMLUElement::class;
+			case 'UL':
+				return WP_HTMLUlElement::class;
+			case 'VAR':
+				return WP_HTMLVarElement::class;
+			case 'VIDEO':
+				return WP_HTMLVideoElement::class;
+			case 'WBR':
+				return WP_HTMLWbrElement::class;
 
 			// Deprecated elements
-			case 'applet':
-			case 'bgsound':
-			case 'blink':
-			case 'isindex':
-			case 'keygen':
-			case 'multicol':
-			case 'nextid':
-			case 'spacer':
+			case 'APPLET':
+			case 'BLINK':
+			case 'ISINDEX':
+			case 'MULTICOL':
+			case 'NEXTID':
+			case 'SPACER':
+				return WP_HTMLUnknownHTMLElement::class;
+
+			case 'BGSOUND': // may be self-closing
 				return WP_HTMLUnknownElement::class;
 
+			case 'KEYGEN':
+				return WP_HTML_Void_Element::class;
+
 			// Neutralized elements
-			case 'acronym':
-			case 'basefont':
-			case 'big':
-			case 'center':
-			case 'nobr':
-			case 'noembed':
-			case 'noframes':
-			case 'plaintext':
-			case 'rb':
-			case 'rtc':
-			case 'strike':
-			case 'tt':
+			case 'ACRONYM':
+			case 'BIG':
+			case 'CENTER':
+			case 'NOBR':
+			case 'NOEMBED':
+			case 'NOFRAMES':
+			case 'PLAINTEXT':
+			case 'RB':
+			case 'RTC':
+			case 'STRIKE':
+			case 'TT':
 				return WP_HTMLElement::class;
 
+			case 'BASEFONT':
+				return WP_HTML_Void_Element::class;
+
 			// Substitutions
-			case 'listing':
-			case 'xmp':
+			case 'LISTING':
+			case 'XMP':
 				return WP_HTMLPreElement::class;
-
-			default:
-				return WP_HTMLUnknownElement::class;
 		}
+
+		$is_valid_custom_name = false !== strpos( $tag_name, '-' );
+
+		return $is_valid_custom_name
+			? WP_HTMLElement::class
+			: WP_HTMLUnknownElement::class;
 	}
 }
 
 class WP_HTML_Element_Meta {
-	const is_void = false;
-	const is_html = true;
-}
-
-class WP_HTMLUnknownElement extends WP_HTML_Element_Meta { const is_html = false; }
-class WP_HTMLElement extends WP_HTML_Element_Meta {}
-
-class WP_HTMLAnchorElement extends WP_HTML_Element_Meta {}
-class WP_HTMLAbbrElement extends WP_HTML_Element_Meta {}
-class WP_HTMLAddressElement extends WP_HTML_Element_Meta {}
-class WP_HTMLAreaElement extends WP_HTML_Element_Meta { const is_void = true; }
-class WP_HTMLArticleElement extends WP_HTML_Element_Meta {}
-class WP_HTMLAsideElement extends WP_HTML_Element_Meta {}
-class WP_HTMLAudioElement extends WP_HTML_Element_Meta {}
-class WP_HTMLBElement extends WP_HTML_Element_Meta {}
-class WP_HTMLBaseElement extends WP_HTML_Element_Meta { const is_void = true; }
-class WP_HTMLBdiElement extends WP_HTML_Element_Meta {}
-class WP_HTMLBdoElement extends WP_HTML_Element_Meta {}
-class WP_HTMLBlockquoteElement extends WP_HTML_Element_Meta {}
-class WP_HTMLBodyElement extends WP_HTML_Element_Meta {}
-class WP_HTMLBrElement extends WP_HTML_Element_Meta { const is_void = true; }
-class WP_HTMLButtonElement extends WP_HTML_Element_Meta {}
-class WP_HTMLCanvasElement extends WP_HTML_Element_Meta {}
-class WP_HTMLCaptionElement extends WP_HTML_Element_Meta {}
-class WP_HTMLCiteElement extends WP_HTML_Element_Meta {}
-class WP_HTMLCodeElement extends WP_HTML_Element_Meta {}
-class WP_HTMLColElement extends WP_HTML_Element_Meta { const is_void = true; }
-class WP_HTMLColgroupElement extends WP_HTML_Element_Meta {}
-class WP_HTMLDataElement extends WP_HTML_Element_Meta {}
-class WP_HTMLDataListElement extends WP_HTML_Element_Meta {}
-class WP_HTMLDdElement extends WP_HTML_Element_Meta {}
-class WP_HTMLDelElement extends WP_HTML_Element_Meta {}
-class WP_HTMLDetailsElement extends WP_HTML_Element_Meta {}
-class WP_HTMLDfnElement extends WP_HTML_Element_Meta {}
-class WP_HTMLDialogElement extends WP_HTML_Element_Meta {}
-class WP_HTMLDivElement extends WP_HTML_Element_Meta {}
-class WP_HTMLDlElement extends WP_HTML_Element_Meta {}
-class WP_HTMLDtElement extends WP_HTML_Element_Meta {}
-class WP_HTMLEmElement extends WP_HTML_Element_Meta {}
-class WP_HTMLEmbedElement extends WP_HTML_Element_Meta { const is_void = true; }
-class WP_HTMLFieldsetElement extends WP_HTML_Element_Meta {}
-class WP_HTMLFigcaptionElement extends WP_HTML_Element_Meta {}
-class WP_HTMLFigureElement extends WP_HTML_Element_Meta {}
-class WP_HTMLFooterElement extends WP_HTML_Element_Meta {}
-class WP_HTMLFormElement extends WP_HTML_Element_Meta {}
-class WP_HTMLH1Element extends WP_HTML_Element_Meta {}
-class WP_HTMLH2Element extends WP_HTML_Element_Meta {}
-class WP_HTMLH3Element extends WP_HTML_Element_Meta {}
-class WP_HTMLH4Element extends WP_HTML_Element_Meta {}
-class WP_HTMLH5Element extends WP_HTML_Element_Meta {}
-class WP_HTMLH6Element extends WP_HTML_Element_Meta {}
-class WP_HTMLHeadElement extends WP_HTML_Element_Meta {}
-class WP_HTMLHeaderElement extends WP_HTML_Element_Meta {}
-class WP_HTMLHgropuElement extends WP_HTML_Element_Meta {}
-class WP_HTMLHrElement extends WP_HTML_Element_Meta { const is_void = true; }
-class WP_HTMLHtmlElement extends WP_HTML_Element_Meta {}
-class WP_HTMLIElement extends WP_HTML_Element_Meta {}
-class WP_HTMLIframeElement extends WP_HTML_Element_Meta {}
-class WP_HTMLImgElement extends WP_HTML_Element_Meta { const is_void = true; }
-class WP_HTMLInputElement extends WP_HTML_Element_Meta { const is_void = true; }
-class WP_HTMLInsElement extends WP_HTML_Element_Meta {}
-class WP_HTMLKbdElement extends WP_HTML_Element_Meta {}
-class WP_HTMLLabelElement extends WP_HTML_Element_Meta {}
-class WP_HTMLLegendElement extends WP_HTML_Element_Meta {}
-class WP_HTMLLiElement extends WP_HTML_Element_Meta {}
-class WP_HTMLLinkElement extends WP_HTML_Element_Meta { const is_void = true; }
-class WP_HTMLMainElement extends WP_HTML_Element_Meta {}
-class WP_HTMLMapElement extends WP_HTML_Element_Meta {}
-class WP_HTMLMarkElement extends WP_HTML_Element_Meta {}
-class WP_HTMLMathElement extends WP_HTML_Element_Meta {}
-class WP_HTMLMenuElement extends WP_HTML_Element_Meta {}
-class WP_HTMLMetaElement extends WP_HTML_Element_Meta { const is_void = true; }
-class WP_HTMLMeterElement extends WP_HTML_Element_Meta {}
-class WP_HTMLNavElement extends WP_HTML_Element_Meta {}
-class WP_HTMLNoscriptElement extends WP_HTML_Element_Meta {}
-class WP_HTMLObjectElement extends WP_HTML_Element_Meta {}
-class WP_HTMLOlElement extends WP_HTML_Element_Meta {}
-class WP_HTMLOptgroupElement extends WP_HTML_Element_Meta {}
-class WP_HTMLOptionElement extends WP_HTML_Element_Meta {}
-class WP_HTMLOutputElement extends WP_HTML_Element_Meta {}
-class WP_HTMLPElement extends WP_HTML_Element_Meta {}
-class WP_HTMLPictureElement extends WP_HTML_Element_Meta {}
-class WP_HTMLPreElement extends WP_HTML_Element_Meta {}
-class WP_HTMLProgressElement extends WP_HTML_Element_Meta {}
-class WP_HTMLQElement extends WP_HTML_Element_Meta {}
-class WP_HTMLRpElement extends WP_HTML_Element_Meta {}
-class WP_HTMLRtElement extends WP_HTML_Element_Meta {}
-class WP_HTMLRubyElement extends WP_HTML_Element_Meta {}
-class WP_HTMLSElement extends WP_HTML_Element_Meta {}
-class WP_HTMLSampElement extends WP_HTML_Element_Meta {}
-class WP_HTMLScriptElement extends WP_HTML_Element_Meta {}
-class WP_HTMLSectionElement extends WP_HTML_Element_Meta {}
-class WP_HTMLSelectElement extends WP_HTML_Element_Meta {}
-class WP_HTMLSlotElement extends WP_HTML_Element_Meta {}
-class WP_HTMLSmallElement extends WP_HTML_Element_Meta {}
-class WP_HTMLSourceElement extends WP_HTML_Element_Meta { const is_void = true; }
-class WP_HTMLSpanElement extends WP_HTML_Element_Meta {}
-class WP_HTMLStrongElement extends WP_HTML_Element_Meta {}
-class WP_HTMLStyleElement extends WP_HTML_Element_Meta {}
-class WP_HTMLSubElement extends WP_HTML_Element_Meta {}
-class WP_HTMLSummaryElement extends WP_HTML_Element_Meta {}
-class WP_HTMLSupElement extends WP_HTML_Element_Meta {}
-class WP_HTMLSvgElement extends WP_HTML_Element_Meta {}
-class WP_HTMLTableElement extends WP_HTML_Element_Meta {}
-class WP_HTMLTbodyElement extends WP_HTML_Element_Meta {}
-class WP_HTMLTdElement extends WP_HTML_Element_Meta {}
-class WP_HTMLTemplateElement extends WP_HTML_Element_Meta {}
-class WP_HTMLTextareaElement extends WP_HTML_Element_Meta {}
-class WP_HTMLTfootElement extends WP_HTML_Element_Meta {}
-class WP_HTMLThElement extends WP_HTML_Element_Meta {}
-class WP_HTMLTheadElement extends WP_HTML_Element_Meta {}
-class WP_HTMLTimeElement extends WP_HTML_Element_Meta {}
-class WP_HTMLTitleElement extends WP_HTML_Element_Meta {}
-class WP_HTMLTrElement extends WP_HTML_Element_Meta {}
-class WP_HTMLTrackElement extends WP_HTML_Element_Meta { const is_void = true; }
-class WP_HTMLUElement extends WP_HTML_Element_Meta {}
-class WP_HTMLUlElement extends WP_HTML_Element_Meta {}
-class WP_HTMLVarElement extends WP_HTML_Element_Meta {}
-class WP_HTMLVideoElement extends WP_HTML_Element_Meta {}
-class WP_HTMLWbrElement extends WP_HTML_Element_Meta { const is_void = true; }
+	const IS_VOID = false;
+	const IS_HTML = true;
+}
+
+class WP_HTMLElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTML_Void_Element extends WP_HTMLElement {
+	const IS_VOID = true;
+}
+
+class WP_HTMLUnknownElement extends WP_HTML_Element_Meta {
+	const IS_HTML = false;
+}
+
+// this one is a bit weird, but so are the deprecated HTML elements belonging to this category.
+class WP_HTMLUnknownHTMLElement extends WP_HTMLUnknownElement {
+	const IS_HTML = true;
+}
+
+class WP_HTMLAnchorElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLAbbrElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLAddressElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLAreaElement extends WP_HTML_Element_Meta {
+	const IS_VOID = true;
+}
+
+class WP_HTMLArticleElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLAsideElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLAudioElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLBElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLBaseElement extends WP_HTML_Element_Meta {
+	const IS_VOID = true;
+}
+
+class WP_HTMLBdiElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLBdoElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLBlockquoteElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLBodyElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLBrElement extends WP_HTML_Element_Meta {
+	const IS_VOID = true;
+}
+
+class WP_HTMLButtonElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLCanvasElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLCaptionElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLCiteElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLCodeElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLColElement extends WP_HTML_Element_Meta {
+	const IS_VOID = true;
+}
+
+class WP_HTMLColgroupElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLDataElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLDataListElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLDdElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLDelElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLDetailsElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLDfnElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLDialogElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLDivElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLDlElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLDtElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLEmElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLEmbedElement extends WP_HTML_Element_Meta {
+	const IS_VOID = true;
+}
+
+class WP_HTMLFieldsetElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLFigcaptionElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLFigureElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLFooterElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLFormElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLH1Element extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLH2Element extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLH3Element extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLH4Element extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLH5Element extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLH6Element extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLHeadElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLHeaderElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLHgropuElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLHrElement extends WP_HTML_Element_Meta {
+	const IS_VOID = true;
+}
+
+class WP_HTMLHtmlElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLIElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLIframeElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLImgElement extends WP_HTML_Element_Meta {
+	const IS_VOID = true;
+}
+
+class WP_HTMLInputElement extends WP_HTML_Element_Meta {
+	const IS_VOID = true;
+}
+
+class WP_HTMLInsElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLKbdElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLLabelElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLLegendElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLLiElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLLinkElement extends WP_HTML_Element_Meta {
+	const IS_VOID = true;
+}
+
+class WP_HTMLMainElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLMapElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLMarkElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLMathElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLMenuElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLMetaElement extends WP_HTML_Element_Meta {
+	const IS_VOID = true;
+}
+
+class WP_HTMLMeterElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLNavElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLNoscriptElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLObjectElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLOlElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLOptgroupElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLOptionElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLOutputElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLPElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLPictureElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLPreElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLProgressElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLQElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLRpElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLRtElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLRubyElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLSElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLSampElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLScriptElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLSectionElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLSelectElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLSlotElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLSmallElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLSourceElement extends WP_HTML_Element_Meta {
+	const IS_VOID = true;
+}
+
+class WP_HTMLSpanElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLStrongElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLStyleElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLSubElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLSummaryElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLSupElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLSvgElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLTableElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLTbodyElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLTdElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLTemplateElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLTextareaElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLTfootElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLThElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLTheadElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLTimeElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLTitleElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLTrElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLTrackElement extends WP_HTML_Element_Meta {
+	const IS_VOID = true;
+}
+
+class WP_HTMLUElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLUlElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLVarElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLVideoElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLWbrElement extends WP_HTML_Element_Meta {
+	const IS_VOID = true;
+}
diff --git a/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php b/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
index 9acb589360356..87c194ea1c637 100644
--- a/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
+++ b/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
@@ -13,9 +13,13 @@
 require_once '/Users/dmsnell/code/WordPress-develop/src/wp-includes/html-api/class-wp-html-tag-processor.php';
 require_once '/Users/dmsnell/code/WordPress-develop/src/wp-includes/html-api/class-wp-html-processor.php';
 
-class WP_UnitTestCase extends PHPUnit\Framework\TestCase {}
+class WP_UnitTestCase extends PHPUnit\Framework\TestCase {
 
-function esc_attr( $s ) { return str_replace( [ '<', '>', '"' ], [ '&lt;', '&gt;', '&quot;' ], $s ); }
+}
+
+function esc_attr( $s ) {
+	return str_replace( array( '<', '>', '"' ), array( '&lt;', '&gt;', '&quot;' ), $s );
+}
 
 /**
  * @group html-api
@@ -53,8 +57,8 @@ public function data_fully_balanced_html() {
 			'Void tags'                                 => array( '<img><br><hr>' ),
 			'Void tags with invalid self-closing flags' => array( '<img /><br/><hr />' ),
 			'Invalid self-closing non-void'              => array( 'This <div/> is (not) empty.</div>' ),
-			'Nested with void tags'                     => array( '<div><p><img>Text<br>More Text</p></div>'),
-			'HTML foreign elements'                     => array( '<svg><circle /></svg>'),
+			'Nested with void tags'                     => array( '<div><p><img>Text<br>More Text</p></div>' ),
+			'HTML foreign elements'                     => array( '<svg><circle /></svg>' )
 		);
 	}
 
@@ -77,8 +81,8 @@ public function data_not_fully_balanced_html() {
 			'Overlapping tags'                           => array( '<strong><p>Important</strong></p>' ),
 			'Overlapping nested tags'                    => array( '<div><strong><p>Important</strong></p></div>' ),
 			'Invalid self-closing non-void'              => array( 'This <div/> is (not) empty.' ),
-			'Un-closed HTML foreign self-closer'         => array( '<svg><circle></svg>'),
-			'Improperly-closed HTML foreign self-closer' => array( '<svg><circle /></circle></svg>'),
+			'Un-closed HTML foreign self-closer'         => array( '<svg><circle></svg>' ),
+			'Improperly-closed HTML foreign self-closer' => array( '<svg><circle /></circle></svg>' )
 		);
 	}
 
@@ -109,7 +113,7 @@ public function data_next_sibling() {
 			'Leading markup'     => array( 'before<img start><img end><img>' ),
 			'Top-level siblings' => array( '<img start><img end><img>' ),
 			'Nested siblings'    => array( '<ul><li>One</li><li start>Two</li><li end>Three</li><li>Four</li></ul>' ),
-			'Nesting avalanche'  => array( '<img start><ul end><li><div><p><strong><a><img></a></strong></p></div></li></ul><div></div><footer></footer>'),
+			'Nesting avalanche'  => array( '<img start><ul end><li><div><p><strong><a><img></a></strong></p></div></li></ul><div></div><footer></footer>' )
 		);
 	}
 
@@ -125,7 +129,7 @@ public function data_no_next_sibling() {
 		return array(
 			'Leading markup'        => array( 'before<div><img start></div><img end><img>' ),
 			'No more siblings'      => array( '<ul><li></li><li start></li></ul><ul><li end></li></ul>' ),
-			'Tag-closing avalanche' => array( '<ul><li><div><p><strong><a><img start></a></strong></p></div></li></ul><div end></div><footer></footer>'),
+			'Tag-closing avalanche' => array( '<ul><li><div><p><strong><a><img start></a></strong></p></div></li></ul><div end></div><footer></footer>' )
 		);
 	}
 
@@ -142,7 +146,7 @@ public function test_finds_first_child( $html ) {
 	public function data_first_child() {
 		return array(
 			'Leading markup' => array( 'this is not tag content<div start><img end></div>afterwards' ),
-			'Normal nesting' => array( '<ul><li></li><li><p start>text<img end></p></li><li></li></ul>' ),
+			'Normal nesting' => array( '<ul><li></li><li><p start>text<img end></p></li><li></li></ul>' )
 		);
 	}
 
@@ -159,7 +163,7 @@ public function data_no_first_child() {
 		return array(
 			'Leading markup' => array( 'this is not tag content<div start></div><img end>afterwards' ),
 			'Already nested' => array( '<li><li></li><li><p start>text</p><img end></li><li></li></ul>', ),
-			'Void element'   => array( '<img start>' ),
+			'Void element'   => array( '<img start>' )
 		);
 	}
 
@@ -223,7 +227,7 @@ public function data_inner_content() {
 			'Single tag'   => array( '<div start>', 'text', '</div>' ),
 			'Nested tags'  => array( '<div start>', '<ul><li>One</li><li><strong>Two<img></strong></li></ul>', '</div>' ),
 			'Complex HTML' => array(
-				<<<HTML
+					<<<HTML
 <main>
 	<h2>Things I could be eating right now</h2>
 	<ul>
@@ -234,7 +238,7 @@ public function data_inner_content() {
 			<img src="yum.avif">
 			<details start>
 HTML,
-				<<<HTML
+					<<<HTML
 				<summary>Scwarzwälder Kirschtorte</summary>
 				<ul>
 					<li>Flour</li>
@@ -246,7 +250,7 @@ public function data_inner_content() {
 				</ul>
 
 HTML,
-			<<<HTML
+				<<<HTML
 </details>
 		</li>
 	</ul>
@@ -318,7 +322,7 @@ public function data_outer_content() {
 	</ul>
 </main>
 HTML
-			),
+			)
 		);
 	}
 

From 0975e345e1ce2580148adf38ed9601ed756ba586 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Thu, 20 Apr 2023 15:42:04 +0200
Subject: [PATCH 18/39] Wrap bookmarking to create special internal bookmarks
 used in HTML traversal

---
 .../html-api/class-wp-html-processor.php            | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index e9e64647506e2..2e0cbe0291820 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -61,13 +61,16 @@ public function next_tag( $query = null ) {
 		$self_closes = $element::IS_VOID || ( ! $element::IS_HTML && $this->has_self_closing_flag() );
 		if ( $self_closes ) {
 			$this->open_elements[] = $tag_name;
+			$this->set_bookmark( '__open_elements_' . count( $this->open_elements ) );
 			return true;
 		}
 
 		if ( $this->is_tag_closer() ) {
+			$this->release_bookmark( '__open_elements_' . count( $this->open_elements ) );
 			array_pop( $this->open_elements );
 		} else {
 			$this->open_elements[] = $tag_name;
+			$this->set_bookmark( '__open_elements_' . count( $this->open_elements ) );
 		}
 
 		return true;
@@ -113,6 +116,16 @@ public function first_child() {
 		return false;
 	}
 
+	public function seek( $bookmark_name ) {
+		parent::seek( $bookmark_name );
+
+		foreach ( $this->bookmarks as $name => $mark ) {
+			if ( str_starts_with( $name, '__open_elements_' ) && $mark->start > $this->bookmarks[ $bookmark_name ]->start ) {
+				$this->release_bookmark( $name );
+			}
+		}
+	}
+
 	private function find_closing_tag() {
 		$starting_depth = count( $this->open_elements );
 

From cafee034c77216292b5206290300847f6aae5b4f Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Thu, 20 Apr 2023 15:55:30 +0200
Subject: [PATCH 19/39] Remove `ensure_support`

---
 .../html-api/class-wp-html-processor.php      | 66 +------------------
 .../Tests_HtmlApi_wpHtmlProcessor_Support.php | 18 -----
 2 files changed, 1 insertion(+), 83 deletions(-)

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index 2e0cbe0291820..717d692b703b0 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -1,52 +1,12 @@
 <?php
 
 class WP_HTML_Processor extends WP_HTML_Tag_Processor {
-	public $fully_supported_input = null;
 	public $open_elements = array();
 
-	public function ensure_support() {
-		if ( null !== $this->fully_supported_input ) {
-			return $this->fully_supported_input;
-		}
-
-		$stack = array();
-
-		$p = new WP_HTML_Tag_Processor( $this->html );
-		while ( $p->next_tag( array( 'tag_closers' => 'visit' ) ) ) {
-			$tag_name = $p->get_tag();
-
-			if ( ! $p->is_tag_closer() ) {
-				$element = WP_HTML_Spec::element_info( $tag_name );
-
-				$self_closes = $element::IS_VOID || ( ! $element::IS_HTML && $p->has_self_closing_flag() );
-				if ( ! $self_closes ) {
-					$stack[] = $tag_name;
-				}
-			} else {
-				if ( end( $stack ) === $tag_name ) {
-					array_pop( $stack );
-					continue;
-				}
-
-				$this->fully_supported_input = false;
-				return false;
-			}
-		}
-
-		$this->fully_supported_input = 0 === count( $stack );
-
-		return $this->fully_supported_input;
-	}
-
 	public function next_tag( $query = null ) {
-		if ( false === $this->fully_supported_input || false === $this->ensure_support() ) {
-			return false;
-		}
-
 		if ( 0 < count( $this->open_elements ) ) {
 			$element = WP_HTML_Spec::element_info( end( $this->open_elements ) );
-			// @TODO: Handle self-closing HTML foreign elements: must convey self-closing flag on stack.
-			if ( $element::IS_VOID ) {
+			if ( $element::IS_VOID  || ( ! $element::IS_HTML && $this->has_self_closing_flag() ) ) {
 				array_pop( $this->open_elements );
 			}
 		}
@@ -77,10 +37,6 @@ public function next_tag( $query = null ) {
 	}
 
 	public function next_sibling() {
-		if ( false === $this->fully_supported_input || false === $this->ensure_support() ) {
-			return false;
-		}
-
 		$starting_depth = count( $this->open_elements );
 
 		while ( $this->next_tag() ) {
@@ -99,10 +55,6 @@ public function next_sibling() {
 	}
 
 	public function first_child() {
-		if ( false === $this->fully_supported_input || false === $this->ensure_support() ) {
-			return false;
-		}
-
 		$starting_depth = count( $this->open_elements );
 
 		while ( $this->next_tag() ) {
@@ -141,10 +93,6 @@ private function find_closing_tag() {
 	}
 
 	public function get_inner_content() {
-		if ( false === $this->fully_supported_input || false === $this->ensure_support() ) {
-			return false;
-		}
-
 		if ( ! $this->get_tag() || $this->is_tag_closer() ) {
 			return false;
 		}
@@ -172,10 +120,6 @@ public function get_inner_content() {
 	}
 
 	public function set_inner_content( $new_html ) {
-		if ( false === $this->fully_supported_input || false === $this->ensure_support() ) {
-			return false;
-		}
-
 		if ( ! $this->get_tag() || $this->is_tag_closer() ) {
 			return false;
 		}
@@ -203,10 +147,6 @@ public function set_inner_content( $new_html ) {
 	}
 
 	public function get_outer_content() {
-		if ( false === $this->fully_supported_input || false === $this->ensure_support() ) {
-			return false;
-		}
-
 		if ( ! $this->get_tag() || $this->is_tag_closer() ) {
 			return false;
 		}
@@ -237,10 +177,6 @@ public function get_outer_content() {
 	}
 
 	public function set_outer_content( $new_html ) {
-		if ( false === $this->fully_supported_input || false === $this->ensure_support() ) {
-			return false;
-		}
-
 		if ( ! $this->get_tag() || $this->is_tag_closer() ) {
 			return false;
 		}
diff --git a/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php b/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
index 87c194ea1c637..92e29101b1ba1 100644
--- a/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
+++ b/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
@@ -37,15 +37,6 @@ private function html_processor_at_start( $html ) {
 		return $p;
 	}
 
-	/**
-	 * @dataProvider data_fully_balanced_html
-	 */
-	public function test_detects_fully_balanced_html( $html ) {
-		$p = new WP_HTML_Processor( $html );
-
-		$this->assertTrue( $p->ensure_support(), "Detected that supported HTML input isn't supported." );
-	}
-
 	/**
 	 * @return array[]
 	 */
@@ -62,15 +53,6 @@ public function data_fully_balanced_html() {
 		);
 	}
 
-	/**
-	 * @dataProvider data_not_fully_balanced_html
-	 */
-	public function test_detects_not_fully_balanced_html( $html ) {
-		$p = new WP_HTML_Processor( $html );
-
-		$this->assertFalse( $p->ensure_support(), 'Detected that unsupported HTML input is supported.' );
-	}
-
 	/**
 	 * @return array[]
 	 */

From 67bef483c55187623aa41e0ec07fcb413e7506cc Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Thu, 20 Apr 2023 17:55:44 +0200
Subject: [PATCH 20/39] Introduce step function and insertion mode

---
 .../html-api/class-wp-html-processor.php      | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index 717d692b703b0..86566dbda20cf 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -3,7 +3,48 @@
 class WP_HTML_Processor extends WP_HTML_Tag_Processor {
 	public $open_elements = array();
 
+	/**
+	 * Advance the parser by one step.
+	 *
+	 * Implements the HTML fragment parsing algorithm.
+	 * See https://html.spec.whatwg.org/#parsing-html-fragments
+	 *
+	 * Only parts of the full algorithm are supported in this class.
+	 * For cases where the input HTML doesn't conform to the supported
+	 * domain of the fragment parsing algorithm this method will abort
+	 * and return `false`.
+	 *
+	 * @param string $insertion_mode Starting insertion mode for parser, best to leave as the default value
+	 *                               unless knowingly handling HTML that will be included inside known tags.
+	 *
+	 * @return boolean Whether an element was found.
+	 */
+	public function step( $insertion_mode = 'in-body' ) {
+		switch ( $insertion_mode ) {
+			case 'in-body':
+				return $this->step_in_body();
+
+			default:
+				return false;
+		}
+	}
+
+	/**
+	 * Parses next element in the 'in body' insertion mode.
+	 *
+	 * @return boolean Whether an element was found.
+	 */
+	private function step_in_body() {
+		return false;
+	}
+
 	public function next_tag( $query = null ) {
+		/*
+		 * The first thing that needs to happen when stepping through the HTML is to
+		 * close any void and self-closing elements. These appear on the open stack
+		 * to support matching CSS selectors and gauging depths, but they don't
+		 * truly have distinct openings and closings.
+		 */
 		if ( 0 < count( $this->open_elements ) ) {
 			$element = WP_HTML_Spec::element_info( end( $this->open_elements ) );
 			if ( $element::IS_VOID  || ( ! $element::IS_HTML && $this->has_self_closing_flag() ) ) {

From be6e9011e0d2d2fbbcc7daddc5a436cb8b2aee9d Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Wed, 3 May 2023 20:15:05 +0200
Subject: [PATCH 21/39] Create some IS_SPECIAL flags

---
 .../html-api/class-wp-html-spec.php           | 71 ++++++++++++++++++-
 1 file changed, 70 insertions(+), 1 deletion(-)

diff --git a/src/wp-includes/html-api/class-wp-html-spec.php b/src/wp-includes/html-api/class-wp-html-spec.php
index a82826903a422..a714ad9bcb614 100644
--- a/src/wp-includes/html-api/class-wp-html-spec.php
+++ b/src/wp-includes/html-api/class-wp-html-spec.php
@@ -295,6 +295,7 @@ public static function element_info( $tag_name ) {
 class WP_HTML_Element_Meta {
 	const IS_VOID = false;
 	const IS_HTML = true;
+	const IS_SPECIAL = false;
 }
 
 class WP_HTMLElement extends WP_HTML_Element_Meta {
@@ -320,16 +321,22 @@ class WP_HTMLAbbrElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLAddressElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
+// @TODO: Add deprecated special rule: APPLET
+
 class WP_HTMLAreaElement extends WP_HTML_Element_Meta {
 	const IS_VOID = true;
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLArticleElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLAsideElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLAudioElement extends WP_HTML_Element_Meta {
@@ -339,6 +346,7 @@ class WP_HTMLBElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLBaseElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 	const IS_VOID = true;
 }
 
@@ -349,22 +357,27 @@ class WP_HTMLBdoElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLBlockquoteElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLBodyElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLBrElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 	const IS_VOID = true;
 }
 
 class WP_HTMLButtonElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLCanvasElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLCaptionElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLCiteElement extends WP_HTML_Element_Meta {
@@ -374,10 +387,12 @@ class WP_HTMLCodeElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLColElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 	const IS_VOID = true;
 }
 
 class WP_HTMLColgroupElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLDataElement extends WP_HTML_Element_Meta {
@@ -387,12 +402,14 @@ class WP_HTMLDataListElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLDdElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLDelElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLDetailsElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLDfnElement extends WP_HTML_Element_Meta {
@@ -402,81 +419,104 @@ class WP_HTMLDialogElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLDivElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLDlElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLDtElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLEmElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLEmbedElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 	const IS_VOID = true;
 }
 
 class WP_HTMLFieldsetElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLFigcaptionElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLFigureElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLFooterElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLFormElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLH1Element extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLH2Element extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLH3Element extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLH4Element extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLH5Element extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLH6Element extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLHeadElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLHeaderElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
-class WP_HTMLHgropuElement extends WP_HTML_Element_Meta {
+class WP_HTMLHgroupElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLHrElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 	const IS_VOID = true;
 }
 
 class WP_HTMLHtmlElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLIElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLIframeElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLImgElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 	const IS_VOID = true;
 }
 
 class WP_HTMLInputElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 	const IS_VOID = true;
 }
 
@@ -493,13 +533,16 @@ class WP_HTMLLegendElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLLiElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLLinkElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 	const IS_VOID = true;
 }
 
 class WP_HTMLMainElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLMapElement extends WP_HTML_Element_Meta {
@@ -512,9 +555,11 @@ class WP_HTMLMathElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLMenuElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLMetaElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 	const IS_VOID = true;
 }
 
@@ -522,15 +567,18 @@ class WP_HTMLMeterElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLNavElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLNoscriptElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLObjectElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLOlElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLOptgroupElement extends WP_HTML_Element_Meta {
@@ -543,12 +591,14 @@ class WP_HTMLOutputElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLPElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLPictureElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLPreElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLProgressElement extends WP_HTML_Element_Meta {
@@ -573,12 +623,15 @@ class WP_HTMLSampElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLScriptElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLSectionElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLSelectElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLSlotElement extends WP_HTML_Element_Meta {
@@ -588,6 +641,7 @@ class WP_HTMLSmallElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLSourceElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 	const IS_VOID = true;
 }
 
@@ -598,12 +652,14 @@ class WP_HTMLStrongElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLStyleElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLSubElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLSummaryElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLSupElement extends WP_HTML_Element_Meta {
@@ -613,39 +669,50 @@ class WP_HTMLSvgElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLTableElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLTbodyElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLTdElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLTemplateElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLTextareaElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLTfootElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLThElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLTheadElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLTimeElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLTitleElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLTrElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLTrackElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 	const IS_VOID = true;
 }
 
@@ -653,6 +720,7 @@ class WP_HTMLUElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLUlElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLVarElement extends WP_HTML_Element_Meta {
@@ -662,5 +730,6 @@ class WP_HTMLVideoElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLWbrElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 	const IS_VOID = true;
 }

From 2e874e4f67acc38e8954327f247d69c980f32f5c Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Thu, 4 May 2023 10:17:09 +0200
Subject: [PATCH 22/39] Some bookmarking stuff

---
 .../html-api/class-wp-html-processor.php      | 58 +++++++++++++++++--
 1 file changed, 54 insertions(+), 4 deletions(-)

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index 86566dbda20cf..45fa3d70ffef4 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -1,7 +1,7 @@
 <?php
 
 class WP_HTML_Processor extends WP_HTML_Tag_Processor {
-	public $open_elements = array();
+	private $depth = 0;
 
 	/**
 	 * Advance the parser by one step.
@@ -38,6 +38,44 @@ private function step_in_body() {
 		return false;
 	}
 
+	public function set_bookmark( $bookmark_name ) {
+		return parent::set_bookmark( '_' . $bookmark_name );
+	}
+
+	public function release_bookmark( $bookmark_name ) {
+		return parent::release_bookmark( '_' . $bookmark_name );
+	}
+
+	private function enter_element( $element ) {
+		$this->depth++;
+
+		parent::set_bookmark( "{$this->depth}_{$element}" );
+	}
+
+	private function exit_element( $element ) {
+		parent::release_bookmark( "{$this->depth}_{$element}" );
+	}
+
+	private function opened_element() {
+		if ( 0 === $this->depth ) {
+			return false;
+		}
+
+		$max_depth = 0;
+		foreach ( $this->bookmarks as $name => $bookmark ) {
+			if ( '_' === $name[0] ) {
+				continue;
+			}
+
+			list( $depth, $element ) = explode( '_', $name );
+			if ( $depth === "{$this->depth}" ) {
+				return $element;
+			}
+		}
+
+		return false;
+	}
+
 	public function next_tag( $query = null ) {
 		/*
 		 * The first thing that needs to happen when stepping through the HTML is to
@@ -110,13 +148,25 @@ public function first_child() {
 	}
 
 	public function seek( $bookmark_name ) {
-		parent::seek( $bookmark_name );
+		parent::seek( '_' . $bookmark_name );
 
+		$max_depth = $this->depth;
 		foreach ( $this->bookmarks as $name => $mark ) {
-			if ( str_starts_with( $name, '__open_elements_' ) && $mark->start > $this->bookmarks[ $bookmark_name ]->start ) {
-				$this->release_bookmark( $name );
+			// Regular bookmarks are prefixed with "_" so they can be ignored here.
+			if ( '_' === $name[0] ) {
+				continue;
+			}
+
+			// Element stack bookmarks are like "3_P" and "4_DIV".
+			if ( $mark->start > $this->bookmarks[ $bookmark_name ]->start ) {
+				parent::release_bookmark( $name );
+			} else {
+				$this_depth = (int) explode( '_', $name )[0];
+				$max_depth  = max( $max_depth, $this_depth );
 			}
 		}
+
+		$this->depth = $max_depth;
 	}
 
 	private function find_closing_tag() {

From ece3a68c07be29c210fd2591d3d67f035811349c Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Thu, 4 May 2023 17:43:56 +0200
Subject: [PATCH 23/39] I think we need a separate actual stack for open
 elements

---
 .../html-api/class-wp-html-processor.php      | 187 +++++++++++++++++-
 1 file changed, 183 insertions(+), 4 deletions(-)

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index 45fa3d70ffef4..cd55326b9dfd6 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -1,7 +1,11 @@
 <?php
 
 class WP_HTML_Processor extends WP_HTML_Tag_Processor {
+	const NOT_IMPLEMENTED_YET = false;
+
 	private $depth = 0;
+	private static $query = array( 'tag_closers' => 'visit' );
+	private $insertion_mode = 'in-body';
 
 	/**
 	 * Advance the parser by one step.
@@ -19,22 +23,158 @@ class WP_HTML_Processor extends WP_HTML_Tag_Processor {
 	 *
 	 * @return boolean Whether an element was found.
 	 */
-	public function step( $insertion_mode = 'in-body' ) {
-		switch ( $insertion_mode ) {
+	public function step( $insertion_mode = null ) {
+		switch ( $insertion_mode ?: $this->insertion_mode ) {
 			case 'in-body':
 				return $this->step_in_body();
 
 			default:
-				return false;
+				return self::NOT_IMPLEMENTED_YET;
 		}
 	}
 
+	/**
+	 * Parses next element in the 'in head' insertion mode.
+	 *
+	 * Not yet implemented.
+	 *
+	 * @see https://html.spec.whatwg.org/#parsing-main-inhead
+	 *
+	 * @return false
+	 */
+	private function step_in_head() {
+		return self::NOT_IMPLEMENTED_YET;
+	}
+
 	/**
 	 * Parses next element in the 'in body' insertion mode.
 	 *
+	 * @see https://html.spec.whatwg.org/#parsing-main-inbody
+	 *
 	 * @return boolean Whether an element was found.
 	 */
 	private function step_in_body() {
+		ignored:
+		parent::set_bookmark( 'current' );
+		if ( ! $this->next_tag( self::$query ) ) {
+			return false;
+		}
+
+		$tag_name = $this->get_tag();
+		$tag_type = $this->is_tag_closer() ? 'closer' : 'opener';
+
+		/*
+		 * > A start tag whose tag name is "html"
+		 */
+		if ( 'HTML' === $tag_name && 'opener' === $tag_type ) {
+			goto ignored;
+		}
+
+		/*
+		 * > A start tag whose tag name is one of: "base", "basefont", "bgsound",
+		 * > "link", "meta", "noframes", "script", "style", "template", "title"
+		 *
+		 * > An end tag whose tag name is "template"
+		 */
+		if (
+			'opener' === $tag_type && (
+				'BASE' === $tag_name ||
+				'BASEFONT' === $tag_name ||
+				'BGSOUND' === $tag_name ||
+				'LINK' === $tag_name ||
+				'META' === $tag_name ||
+				'NOFRAMES' === $tag_name ||
+				'SCRIPT' === $tag_name ||
+				'STYLE' === $tag_name ||
+				'TEMPLATE' === $tag_name ||
+				'TITLE' === $tag_name
+			) ||
+			(
+				'closer' === $tag_type &&
+				'TEMPLATE' === $tag_name
+			) )
+		{
+			parent::seek( 'current' );
+			$this->insertion_mode = 'in-head';
+			return $this->step();
+		}
+
+		/*
+		 * > A start tag whose tag name is "body"
+		 */
+		if ( 'opener' === $tag_type && 'BODY' === $tag_name ) {
+			goto ignored;
+		}
+
+		/*
+		 * > A start tag whose tag name is "frameset"
+		 */
+		if ( 'opener' === $tag_type && 'FRAMESET' === $tag_name ) {
+			return self::NOT_IMPLEMENTED_YET;
+		}
+
+		/*
+		 * > An end-of-file token
+		 *
+		 * Stop parsing.
+		 */
+
+		/*
+		 * > An end tag whose tag name is "body"
+		 * > An end tag whose tag name is "html"
+		 */
+		if ( 'closer' === $tag_type && ( 'BODY' === $tag_name || 'HTML' === $tag_name ) ) {
+			/*
+			 * > If the stack of open elements does not have a body element in scope, this is a parse error; ignore the token.
+			 *
+			 * @TODO: We didn't construct an open HTML or BODY tag, but we have to make a choice here based on that.
+			 *        Probably need to create these _or_ assume this will always transfer to "after body".
+			 */
+			$this->insertion_mode = 'after-body';
+			return true;
+		}
+
+		/*
+		 * > A start tag whose tag name is one of: "address", "article", "aside", "blockquote", "center",
+		 * > "details", "dialog", "dir", "div", "dl", "fieldset", "figcaption", "figure", "footer",
+		 * > "header", "hgroup", "main", "menu", "nav", "ol", "p", "search", "section", "summary", "ul"
+		 */
+		if (
+			'opener' === $tag_type && (
+				'ADDRESS' === $tag_name ||
+				'ARTICLE' === $tag_name ||
+				'ASIDE' === $tag_name ||
+				'BLOCKQUOTE' === $tag_name ||
+				'CENTER' === $tag_name ||
+				'DETAILS' === $tag_name ||
+				'DIALOG' === $tag_name ||
+				'DIR' === $tag_name ||
+				'DIV' === $tag_name ||
+				'DL' === $tag_name ||
+				'FIELDSET' === $tag_name ||
+				'FIGCAPTION' === $tag_name ||
+				'FIGURE' === $tag_name ||
+				'FOOTER' === $tag_name ||
+				'HEADER' === $tag_name ||
+				'HGROUP' === $tag_name ||
+				'MAIN' === $tag_name ||
+				'MENU' === $tag_name ||
+				'NAV' === $tag_name ||
+				'OL' === $tag_name ||
+				'P' === $tag_name ||
+				'SEARCH' === $tag_name ||
+				'SECTION' === $tag_name ||
+				'SUMMARY' === $tag_name ||
+				'UL' === $tag_name
+			)
+		) {
+			if ( $this->has_in_scope( 'P', 'BUTTON' ) ) {
+				$this->close_p_element();
+			}
+
+			$this->enter_element( $tag_name );
+		}
+
 		return false;
 	}
 
@@ -56,7 +196,35 @@ private function exit_element( $element ) {
 		parent::release_bookmark( "{$this->depth}_{$element}" );
 	}
 
-	private function opened_element() {
+	/**
+	 * @see https://html.spec.whatwg.org/#close-a-p-element
+	 * @return void
+	 */
+	private function close_p_element() {
+		$this->generate_implied_end_tags( 'P' );
+
+
+	}
+
+	/**
+	 * @TODO: Implement this
+	 *
+	 * @see https://html.spec.whatwg.org/#generate-implied-end-tags
+	 *
+	 * @param string|null $except_for_this_element Perform as if this element doesn't exist in the stack of open elements.
+	 * @return void
+	 */
+	private function generate_implied_end_tags( $except_for_this_element = null ) {
+		
+	}
+
+	/**
+	 * The current node is the bottommost node in this stack of open elements.
+	 *
+	 * @see https://html.spec.whatwg.org/#current-node
+	 * @return false|mixed|string
+	 */
+	private function current_node() {
 		if ( 0 === $this->depth ) {
 			return false;
 		}
@@ -76,6 +244,17 @@ private function opened_element() {
 		return false;
 	}
 
+	/**
+	 * Indicates if the stack of open elements has an element in a given scope.
+	 *
+	 * @param $element
+	 * @param $scope
+	 * @return false
+	 */
+	private function has_in_scope( $element, $scope ) {
+		return self::NOT_IMPLEMENTED_YET;
+	}
+
 	public function next_tag( $query = null ) {
 		/*
 		 * The first thing that needs to happen when stepping through the HTML is to

From 98180bc40373ec3178a182be7b8afacac73283a6 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Wed, 17 May 2023 16:58:36 +0200
Subject: [PATCH 24/39] Add WIP stack class, trap exceptions in `step()` to
 allow nested calls to escape

---
 .../class-wp-html-element-stack-item.php      |  45 +++
 .../html-api/class-wp-html-element-stack.php  | 266 ++++++++++++++++++
 .../html-api/class-wp-html-processor.php      |  20 +-
 3 files changed, 325 insertions(+), 6 deletions(-)
 create mode 100644 src/wp-includes/html-api/class-wp-html-element-stack-item.php
 create mode 100644 src/wp-includes/html-api/class-wp-html-element-stack.php

diff --git a/src/wp-includes/html-api/class-wp-html-element-stack-item.php b/src/wp-includes/html-api/class-wp-html-element-stack-item.php
new file mode 100644
index 0000000000000..a9cf9caf84b25
--- /dev/null
+++ b/src/wp-includes/html-api/class-wp-html-element-stack-item.php
@@ -0,0 +1,45 @@
+<?php
+
+class WP_HTML_Element_Stack_Item {
+	const IS_CLOSER = 1 << 0;
+	const HAS_SELF_CLOSING_FLAG = 1 << 1;
+
+	/**
+	 * Stores the name of the bookmark pointing to the element at the position of the item.
+	 *
+	 * @var string|null
+	 */
+	public $bookmark_name = null;
+
+	/**
+	 * Stores the element class name for the element at the position of the item.
+	 *
+	 * This is the name of the PHP class representing the element.
+	 * For example, `WP_HTMLDivElement` from calling `WP_HTMLDivElement::class`.
+	 *
+	 * @var string|null
+	 */
+	public $element = null;
+
+	/**
+	 * Properties about this item in the stack that are relevant for relating opening and closing tags.
+	 *
+	 * @var int
+	 */
+	public $flags = 0;
+
+	/**
+	 * Pointer to related item on the stack, if one exists.
+	 * For example, a tag opener that opens the current tag closer.
+	 *
+	 * @var WP_HTML_Element_Stack_Item|null
+	 */
+	public $related_item = null;
+
+	public function __construct( $bookmark_name, $element, $flags, $related_item = null ) {
+		$this->bookmark_name = $bookmark_name;
+		$this->element       = $element;
+		$this->flags         = $flags;
+		$this->related_item  = $related_item;
+	}
+}
diff --git a/src/wp-includes/html-api/class-wp-html-element-stack.php b/src/wp-includes/html-api/class-wp-html-element-stack.php
new file mode 100644
index 0000000000000..cff94e2b76aed
--- /dev/null
+++ b/src/wp-includes/html-api/class-wp-html-element-stack.php
@@ -0,0 +1,266 @@
+<?php
+
+class WP_HTML_Element_Stack {
+	/**
+	 * Stack holding HTML tokens, tag openers, tag closers, or plain bookmarks.
+	 *
+	 * @var WP_HTML_Element_Stack_Item[]
+	 */
+	public $stack = array();
+
+	public function __construct( $bookmark_name, $element, $flags ) {
+		$this->bookmark_name = $bookmark_name;
+		$this->element       = $element;
+		$this->flags         = $flags;
+	}
+
+	/**
+	 * Add an item to the top of the stack.
+	 *
+	 * @TODO: Do we need to insertion-sort these?
+	 *
+	 * @param $stack_item
+	 * @return void
+	 */
+	public function push( $stack_item ) {
+		$this->stack[] = $stack_item;
+	}
+
+	public function count() {
+		return count( $this->stack );
+	}
+
+	/**
+	 * Returns the bottom-most node on the stack.
+	 *
+	 * @return WP_HTML_Element_Stack_Item|null
+	 */
+	public function current_node() {
+		$count = $this->count();
+
+		return $this->count() > 0
+			? $this->stack[ $count - 1 ]
+			: null;
+	}
+
+	/**
+	 * Returns whether the given element is on the stack.
+	 *
+	 * @param string $element the ::class name of the element to check for.
+	 * @return boolean whether the given element is on the stack.
+	 */
+	public function has_element( $element ) {
+		for ( $i = count( $this->stack ) - 1; $i > 0; $i++ ) {
+			if ( $this->stack[ $i ]->element === $element ) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Returns whether an element is in a specific scope.
+	 *
+	 * @see https://html.spec.whatwg.org/#has-an-element-in-the-specific-scope
+	 *
+	 * @param string   $element The target node.
+	 * @param string[] $termination_list List of elements that terminate the search.
+	 * @return bool
+	 */
+	public function has_element_in_specific_scope( $element, $termination_list ) {
+		$i = $this->count();
+		if ( $i === 0 ) {
+			return false;
+		}
+
+		$node = $this->stack[ --$i ];
+
+		if ( $node->element === $element ) {
+			return true;
+		}
+
+		if ( in_array( $element, $termination_list, true ) ) {
+			return false;
+		}
+
+		while ( $i > 0 && null !== ( $node = $this->stack[ --$i ] ) ) {
+			if ( $node->element === $element ) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Returns whether a given element is in a particular scope.
+	 *
+	 * @see https://html.spec.whatwg.org/#has-an-element-in-scope
+	 *
+	 * @param string $element
+	 * @return bool
+	 */
+	public function has_element_in_particular_scope( $element ) {
+		return $this->has_element_in_specific_scope( $element, array(
+			WP_HTMLAppletElement::class,
+			WP_HTMLCaptionElement::class,
+			WP_HTMLHtmlElement::class,
+			WP_HTMLTableElement::class,
+			WP_HTMLTdElement::class,
+			WP_HTMLThElement::class,
+			WP_HTMLMarqueeElement::class,
+			WP_HTMLObjectElement::class,
+			WP_HTMLTemplateElement::class,
+			WP_MathML_Mi_Element::class,
+			WP_MathML_Mo_Element::class,
+			WP_MathML_Mn_Element::class,
+			WP_MathML_Ms_Element::class,
+			WP_MathML_Mtext_Element::class,
+			WP_MathML_Annotation_Xml_Element::class,
+			WP_SVG_ForeignObject_Element::class,
+			WP_SVG_Description_Element::class,
+			WP_SVG_Title_Element::class,
+		) );
+	}
+
+	/**
+	 * Returns whether a given element is in list item scope.
+	 *
+	 * @see https://html.spec.whatwg.org/#has-an-element-in-list-item-scope
+	 *
+	 * @param $element
+	 * @return void
+	 */
+	public function has_element_in_list_item_scope( $element ) {
+		return $this->has_element_in_specific_scope( $element, array(
+			WP_HTMLAppletElement::class,
+			WP_HTMLCaptionElement::class,
+			WP_HTMLHtmlElement::class,
+			WP_HTMLTableElement::class,
+			WP_HTMLTdElement::class,
+			WP_HTMLThElement::class,
+			WP_HTMLMarqueeElement::class,
+			WP_HTMLObjectElement::class,
+			WP_HTMLTemplateElement::class,
+			WP_MathML_Mi_Element::class,
+			WP_MathML_Mo_Element::class,
+			WP_MathML_Mn_Element::class,
+			WP_MathML_Ms_Element::class,
+			WP_MathML_Mtext_Element::class,
+			WP_MathML_Annotation_Xml_Element::class,
+			WP_SVG_ForeignObject_Element::class,
+			WP_SVG_Description_Element::class,
+			WP_SVG_Title_Element::class,
+
+			// Additionally these elements.
+			WP_HTMLOlElement::class,
+			WP_HTMLUlElement::class,
+		) );
+	}
+
+	/**
+	 * Returns whether a given element is in button scope.
+	 *
+	 * @see https://html.spec.whatwg.org/#has-an-element-in-button-scope
+	 *
+	 * @param string $element
+	 * @return boolean
+	 */
+	public function has_element_in_button_scope( $element ) {
+		return $this->has_element_in_specific_scope( $element, array(
+			WP_HTMLAppletElement::class,
+			WP_HTMLCaptionElement::class,
+			WP_HTMLHtmlElement::class,
+			WP_HTMLTableElement::class,
+			WP_HTMLTdElement::class,
+			WP_HTMLThElement::class,
+			WP_HTMLMarqueeElement::class,
+			WP_HTMLObjectElement::class,
+			WP_HTMLTemplateElement::class,
+			WP_MathML_Mi_Element::class,
+			WP_MathML_Mo_Element::class,
+			WP_MathML_Mn_Element::class,
+			WP_MathML_Ms_Element::class,
+			WP_MathML_Mtext_Element::class,
+			WP_MathML_Annotation_Xml_Element::class,
+			WP_SVG_ForeignObject_Element::class,
+			WP_SVG_Description_Element::class,
+			WP_SVG_Title_Element::class,
+
+			// Additionally these elements.
+			WP_HTMLButtonElement::class,
+		) );
+	}
+
+	/**
+	 * Returns whether the given element is in table scope.
+	 *
+	 * @see https://html.spec.whatwg.org/#has-an-element-in-table-scope
+	 *
+	 * @param string $element
+	 * @return bool
+	 */
+	public function has_element_in_table_scope( $element ) {
+		return $this->has_element_in_specific_scope( $element, array(
+			WP_HTMLAppletElement::class,
+			WP_HTMLCaptionElement::class,
+			WP_HTMLHtmlElement::class,
+			WP_HTMLTableElement::class,
+			WP_HTMLTdElement::class,
+			WP_HTMLThElement::class,
+			WP_HTMLMarqueeElement::class,
+			WP_HTMLObjectElement::class,
+			WP_HTMLTemplateElement::class,
+			WP_MathML_Mi_Element::class,
+			WP_MathML_Mo_Element::class,
+			WP_MathML_Mn_Element::class,
+			WP_MathML_Ms_Element::class,
+			WP_MathML_Mtext_Element::class,
+			WP_MathML_Annotation_Xml_Element::class,
+			WP_SVG_ForeignObject_Element::class,
+			WP_SVG_Description_Element::class,
+			WP_SVG_Title_Element::class,
+
+			// Additionally these elements.
+			WP_HTMLHtmlElement::class,
+			WP_HTMLTableElement::class,
+			WP_HTMLTemplateElement::class,
+		) );
+	}
+
+	/**
+	 * Returns whether a given element is in select scope.
+	 *
+	 * @see https://html.spec.whatwg.org/#has-an-element-in-select-scope
+	 *
+	 * @param string $element
+	 * @return bool
+	 */
+	public function has_element_in_select_scope( $element ) {
+		return $this->has_element_in_specific_scope( $element, array(
+			WP_HTMLAppletElement::class,
+			WP_HTMLCaptionElement::class,
+			WP_HTMLHtmlElement::class,
+			WP_HTMLTableElement::class,
+			WP_HTMLTdElement::class,
+			WP_HTMLThElement::class,
+			WP_HTMLMarqueeElement::class,
+			WP_HTMLObjectElement::class,
+			WP_HTMLTemplateElement::class,
+			WP_MathML_Mi_Element::class,
+			WP_MathML_Mo_Element::class,
+			WP_MathML_Mn_Element::class,
+			WP_MathML_Ms_Element::class,
+			WP_MathML_Mtext_Element::class,
+			WP_MathML_Annotation_Xml_Element::class,
+			WP_SVG_ForeignObject_Element::class,
+			WP_SVG_Description_Element::class,
+			WP_SVG_Title_Element::class,
+
+			// Additionally these elements.
+			WP_HTMLOptgroupElement::class,
+			WP_HTMLOptionElement::class,
+		) );
+	}
+}
diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index cd55326b9dfd6..3249ac3e07feb 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -24,12 +24,20 @@ class WP_HTML_Processor extends WP_HTML_Tag_Processor {
 	 * @return boolean Whether an element was found.
 	 */
 	public function step( $insertion_mode = null ) {
-		switch ( $insertion_mode ?: $this->insertion_mode ) {
-			case 'in-body':
-				return $this->step_in_body();
+		try {
+			switch ( $insertion_mode ?: $this->insertion_mode ) {
+				case 'in-body':
+					return $this->step_in_body();
 
-			default:
-				return self::NOT_IMPLEMENTED_YET;
+				default:
+					return self::NOT_IMPLEMENTED_YET;
+			}
+		} catch ( Exception $e ) {
+			/*
+			 * Exceptions are used in this class to escape deep call stacks that
+			 * otherwise might involve messier calling and return conventions.
+			 */
+			return false;
 		}
 	}
 
@@ -215,7 +223,7 @@ private function close_p_element() {
 	 * @return void
 	 */
 	private function generate_implied_end_tags( $except_for_this_element = null ) {
-		
+
 	}
 
 	/**

From 0e3ada551f91fa062d3afe5cb6c6408a36f6def7 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Wed, 17 May 2023 17:25:23 +0200
Subject: [PATCH 25/39] Play with an alternate matching syntax

---
 .../html-api/class-wp-html-element-stack.php  |   6 -
 .../html-api/class-wp-html-processor.php      | 135 +++++++++++++++++-
 2 files changed, 134 insertions(+), 7 deletions(-)

diff --git a/src/wp-includes/html-api/class-wp-html-element-stack.php b/src/wp-includes/html-api/class-wp-html-element-stack.php
index cff94e2b76aed..3e9cd6f3fc1bd 100644
--- a/src/wp-includes/html-api/class-wp-html-element-stack.php
+++ b/src/wp-includes/html-api/class-wp-html-element-stack.php
@@ -8,12 +8,6 @@ class WP_HTML_Element_Stack {
 	 */
 	public $stack = array();
 
-	public function __construct( $bookmark_name, $element, $flags ) {
-		$this->bookmark_name = $bookmark_name;
-		$this->element       = $element;
-		$this->flags         = $flags;
-	}
-
 	/**
 	 * Add an item to the top of the stack.
 	 *
diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index 3249ac3e07feb..2ffb992eace58 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -1,5 +1,7 @@
 <?php
 
+require_once __DIR__ . '/class-wp-html-element-stack.php';
+
 class WP_HTML_Processor extends WP_HTML_Tag_Processor {
 	const NOT_IMPLEMENTED_YET = false;
 
@@ -7,6 +9,33 @@ class WP_HTML_Processor extends WP_HTML_Tag_Processor {
 	private static $query = array( 'tag_closers' => 'visit' );
 	private $insertion_mode = 'in-body';
 
+	/**
+	 * @var int Unique id for creating bookmarks.
+	 */
+	private $bookmark_id = 0;
+
+	/**
+	 * @var WP_HTML_Element_Stack Refers to element opening tags.
+	 */
+	private $tag_openers = null;
+
+	/**
+	 * @var WP_HTML_Element_Stack Referes to element closing tags.
+	 */
+	private $tag_closers = null;
+
+	/**
+	 * Create a new HTML Processor for reading and modifying HTML structure.
+	 *
+	 * @param string $html Input HTML document.
+	 */
+	public function __construct( $html ) {
+		parent::__construct( $html );
+
+		$this->tag_openers = new WP_HTML_Element_Stack();
+		$this->tag_closers = new WP_HTML_Element_Stack();
+	}
+
 	/**
 	 * Advance the parser by one step.
 	 *
@@ -70,6 +99,110 @@ private function step_in_body() {
 
 		$tag_name = $this->get_tag();
 		$tag_type = $this->is_tag_closer() ? 'closer' : 'opener';
+		$op_sigil = $this->is_tag_closer() ? '-' : '+';
+		$op       = "{$op_sigil}{$tag_name}";
+
+		switch ( $op ) {
+			/*
+			 * > A start tag whose tag name is "html"
+			 */
+			case '+HTML':
+				goto ignored;
+
+			/*
+			 * > A start tag whose tag name is one of: "base", "basefont", "bgsound",
+			 * > "link", "meta", "noframes", "script", "style", "template", "title"
+			 *
+			 * > An end tag whose tag name is "template"
+			 */
+			case '+BASE':
+			case '+BASEFONT':
+			case '+BGSOUND':
+			case '+LINK':
+			case '+META':
+			case '+NOFRAMES':
+			case '+SCRIPT':
+			case '+STYLE':
+			case '+TEMPLATE':
+			case '+TITLE':
+			case '-TEMPLATE':
+				parent::seek( 'current' );
+				$this->insertion_mode = 'in-head';
+				return $this->step();
+
+			/*
+			 * > A start tag whose tag name is "body"
+			 */
+			case '+BODY':
+				goto ignored;
+
+
+			/*
+			 * > A start tag whose tag name is "frameset"
+			 */
+			case '+FRAMESET':
+				throw new Exception( self::NOT_IMPLEMENTED_YET );
+
+			/*
+			 * > An end tag whose tag name is "body"
+			 * > An end tag whose tag name is "html"
+			 */
+			case '-BODY':
+			case '-HTML':
+				/*
+				 * > If the stack of open elements does not have a body element in scope, this is a parse error; ignore the token.
+				 *
+				 * @TODO: We didn't construct an open HTML or BODY tag, but we have to make a choice here based on that.
+				 *        Probably need to create these _or_ assume this will always transfer to "after body".
+				 */
+				$this->insertion_mode = 'after-body';
+				return true;
+
+			/*
+			 * > A start tag whose tag name is one of: "address", "article", "aside", "blockquote", "center",
+			 * > "details", "dialog", "dir", "div", "dl", "fieldset", "figcaption", "figure", "footer",
+			 * > "header", "hgroup", "main", "menu", "nav", "ol", "p", "search", "section", "summary", "ul"
+			 */
+			case '+ADDRESS':
+			case '+ARTICLE':
+			case '+ASIDE':
+			case '+BLOCKQUOTE':
+			case '+CENTER':
+			case '+DETAILS':
+			case '+DIALOG':
+			case '+DIR':
+			case '+DIV':
+			case '+DL':
+			case '+FIELDSET':
+			case '+FIGCAPTION':
+			case '+FIGURE':
+			case '+FOOTER':
+			case '+HEADER':
+			case '+HGROUP':
+			case '+MAIN':
+			case '+MENU':
+			case '+NAV':
+			case '+OL':
+			case '+P':
+			case '+SEARCH':
+			case '+SECTION':
+			case '+SUMMARY':
+			case '+UL':
+				if ( $this->has_in_scope( 'P', 'BUTTON' ) ) {
+					$this->close_p_element();
+				}
+
+				$this->enter_element( $tag_name );
+				return;
+
+			/*
+			 * > An end-of-file token
+			 *
+			 * Stop parsing.
+			 */
+			default:
+				return false;
+		}
 
 		/*
 		 * > A start tag whose tag name is "html"
@@ -260,7 +393,7 @@ private function current_node() {
 	 * @return false
 	 */
 	private function has_in_scope( $element, $scope ) {
-		return self::NOT_IMPLEMENTED_YET;
+		throw new Exception( self::NOT_IMPLEMENTED_YET );
 	}
 
 	public function next_tag( $query = null ) {

From 739b4aa7ca1b68315fc44420ebfc2022fa556578 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Thu, 18 May 2023 01:40:56 +0200
Subject: [PATCH 26/39] Add reset_insertion_mode_appropriately

---
 .../class-wp-html-element-stack-item.php      |   1 +
 .../html-api/class-wp-html-element-stack.php  |  16 +-
 .../html-api/class-wp-html-processor.php      | 404 +++++++++++++-----
 .../html-api/class-wp-html-spec.php           |   3 +
 4 files changed, 305 insertions(+), 119 deletions(-)

diff --git a/src/wp-includes/html-api/class-wp-html-element-stack-item.php b/src/wp-includes/html-api/class-wp-html-element-stack-item.php
index a9cf9caf84b25..527b526c0e02a 100644
--- a/src/wp-includes/html-api/class-wp-html-element-stack-item.php
+++ b/src/wp-includes/html-api/class-wp-html-element-stack-item.php
@@ -1,6 +1,7 @@
 <?php
 
 class WP_HTML_Element_Stack_Item {
+	const NO_FLAGS = 0;
 	const IS_CLOSER = 1 << 0;
 	const HAS_SELF_CLOSING_FLAG = 1 << 1;
 
diff --git a/src/wp-includes/html-api/class-wp-html-element-stack.php b/src/wp-includes/html-api/class-wp-html-element-stack.php
index 3e9cd6f3fc1bd..1f2b1485f5949 100644
--- a/src/wp-includes/html-api/class-wp-html-element-stack.php
+++ b/src/wp-includes/html-api/class-wp-html-element-stack.php
@@ -8,12 +8,26 @@ class WP_HTML_Element_Stack {
 	 */
 	public $stack = array();
 
+	/**
+	 * Returns a copy of the ith element on the stack for inspection.
+	 *
+	 * @param int $nth_from_top Which item on the stack to return.
+	 * @return WP_HTML_Element_Stack_Item|null
+	 */
+	public function peek( $nth_from_top ) {
+		if ( $nth_from_top < 0 || $nth_from_top >= $this->count() ) {
+			return null;
+		}
+
+		return $this->stack[ $this->count() - $nth_from_top - 1 ];
+	}
+
 	/**
 	 * Add an item to the top of the stack.
 	 *
 	 * @TODO: Do we need to insertion-sort these?
 	 *
-	 * @param $stack_item
+	 * @param WP_HTML_Element_Stack_Item $stack_item
 	 * @return void
 	 */
 	public function push( $stack_item ) {
diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index 2ffb992eace58..1f03d1045d456 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -1,13 +1,44 @@
 <?php
 
 require_once __DIR__ . '/class-wp-html-element-stack.php';
+require_once __DIR__ . '/class-wp-html-spec.php';
 
 class WP_HTML_Processor extends WP_HTML_Tag_Processor {
 	const NOT_IMPLEMENTED_YET = false;
 
+	/**
+	 * These constants seem redundant, but they are in use to
+	 * differentiate pure strings and the insertion modes.
+	 *
+	 * @TODO: This pollutes the top of the class.
+	 */
+	const INITIAL_MODE = 'initial';
+	const BEFORE_HTML = 'before-html';
+	const BEFORE_HEAD = 'before-head';
+	const IN_HEAD = 'in-head';
+	const IN_HEAD_NOSCRIPT = 'in-head-noscript';
+	const AFTER_HEAD = 'after-head';
+	const IN_BODY = 'in-body';
+	const TEXT = 'text';
+	const IN_TABLE = 'in-table';
+	const IN_TABLE_TEXT = 'in-table-text';
+	const IN_CAPTION = 'in-caption';
+	const IN_COLUMN_GROUP = 'in-column-group';
+	const IN_TABLE_BODY = 'in-table-body';
+	const IN_ROW = 'in-row';
+	const IN_CELL = 'in-cell';
+	const IN_SELECT = 'in-select';
+	const IN_SELECT_IN_TABLE = 'in-select-in-table';
+	const IN_TEMPLATE = 'in-template';
+	const AFTER_BODY = 'after-body';
+	const IN_FRAMESET = 'in-frameset';
+	const AFTER_FRAMESET = 'after-frameset';
+	const AFTER_AFTER_BODY = 'after-after-body';
+	const AFTER_AFTER_FRAMESET = 'after-after-frameset';
+
+
 	private $depth = 0;
 	private static $query = array( 'tag_closers' => 'visit' );
-	private $insertion_mode = 'in-body';
 
 	/**
 	 * @var int Unique id for creating bookmarks.
@@ -24,16 +55,125 @@ class WP_HTML_Processor extends WP_HTML_Tag_Processor {
 	 */
 	private $tag_closers = null;
 
+	/**
+	 * @var string Tree construction insertion mode.
+	 */
+	private $insertion_mode = 'initial';
+
+	/**
+	 * Context node initializing HTML fragment parsing, if in that mode.
+	 *
+	 * @var [string, array]|null
+	 */
+	private $context_node = null;
+
+	/**
+	 * @TODO: Implement this.
+	 *
+	 * @var null
+	 */
+	private $head_element_pointer = null;
+
+	/**
+	 * @TODO: Implement this.
+	 *
+	 * @var null
+	 */
+	private $form_element_pointer = null;
+
+	/**
+	 * Original insertion mode when entering 'text' or 'in-table-text' modes.
+	 *
+	 * Not implemented yet.
+	 *
+	 * @var string|null
+	 */
+	private $original_insertion_mode = null;
+
+	/**
+	 * Stack of template insertion modes.
+	 *
+	 * Not implemented yet.
+	 *
+	 * @var null
+	 */
+	private $template_insertion_mode_stack = null;
+
 	/**
 	 * Create a new HTML Processor for reading and modifying HTML structure.
 	 *
+	 * ## Initial mode
+	 *
+	 * Most invocations of the HTML parser operate in the "fragment parsing" mode,
+	 * which assumes that the given HTML document existing within an existing HTML
+	 * document. For example, block HTML exists within a larger document, and some
+	 * inner block HTML might exist within a TABLE element, which holds special
+	 * parsing rules.
+	 *
+	 * The parser can operate in a full parsing mode or the fragment parsing mode,
+	 * and it's important to indicate which is necessary when creating the HTML
+	 * processor.
+	 *
+	 * Example
+	 *     // Parse an entire HTML document
+	 *     $p = new WP_HTML_Processor( $html, array( 'full', WP_HTML_Processor::INITIAL ) );
+	 *
+	 *     // Parse a full HTML document, but inside a BODY element. E.g. when parsing `post_content`.
+	 *     $p = new WP_HTML_Processor( $html, array( 'full', WP_HTML_Processor::IN_BODY ) );
+	 *
+	 *     // Parse a chunk of HTML provided inside a post's block content.
+	 *     $p = new WP_HTML_Processor( $html, array( 'fragment', '<body>' ) );
+	 *
+	 *     // Parse a chunk of HTML provided inside a post's block content, using the default initial mode.
+	 *     $p = new WP_HTML_Processor( $html );
+	 *
+	 *     // Parse a chunk of HTML known to exist within a TEXTAREA element. E.g. when parsing code input.
+	 *     $p = new WP_HTML_Processor( $html, array( 'fragment', '<textarea rows="5">' ) );
+	 *
+	 *     // Parse a chunk of HTML known to existing within a SCRIPT element. E.g. when sanitizing JavaScript code.
+	 *     $p = new WP_HTML_Processor( $html, array( 'fragment', '<script>' ) );
+	 *
 	 * @param string $html Input HTML document.
+	 * @param string[] $initial_mode Initial mode for parser, if provided. Defaults to a fragment parser in the BODY element.
+	 * @param string $encoding Must be utf-8
 	 */
-	public function __construct( $html ) {
+	public function __construct( $html, $initial_mode = array( 'fragment', 'body' ), $encoding = 'utf8' ) {
 		parent::__construct( $html );
 
 		$this->tag_openers = new WP_HTML_Element_Stack();
 		$this->tag_closers = new WP_HTML_Element_Stack();
+
+		list( $parser_type, $initial_context ) = $initial_mode;
+
+		switch ( $parser_type ) {
+			// Can we convert a full parser into a fragment parser re-using the existing
+			// intial parsing state? E.g. is [ 'full', WP_HTML_Processor:IN_BODY ] the same as  [ 'fragment', '<body>' ]
+			case 'full':
+				$this->insertion_mode = $initial_context;
+				break;
+
+			case 'fragment':
+				$p = new WP_HTML_Tag_Processor( $initial_context );
+				$p->next_tag();
+				$context_node = WP_HTML_Spec::element_info( $p->next_tag() );
+				$context_attributes = array();
+				foreach ( $p->get_attribute_names_with_prefix( '' ) as $attribute_name ) {
+					$context_attributes[ $attribute_name ] = $p->get_attribute( $attribute_name );
+				}
+
+				$this->context_node = array( $context_node, $context_attributes );
+
+				$this->tag_openers->push(
+					new WP_HTML_Element_Stack_Item(
+						$this->spot_bookmark( 0 ),
+						'HTML',
+						WP_HTML_Element_Stack_Item::NO_FLAGS
+					)
+				);
+
+				// Create the context node somehow. We can't/don't want to prepend it
+				// to the HTML, unless we _can_ do that without disturbing the output.
+		}
 	}
 
 	/**
@@ -55,7 +195,7 @@ public function __construct( $html ) {
 	public function step( $insertion_mode = null ) {
 		try {
 			switch ( $insertion_mode ?: $this->insertion_mode ) {
-				case 'in-body':
+				case self::IN_BODY:
 					return $this->step_in_body();
 
 				default:
@@ -92,13 +232,11 @@ private function step_in_head() {
 	 */
 	private function step_in_body() {
 		ignored:
-		parent::set_bookmark( 'current' );
 		if ( ! $this->next_tag( self::$query ) ) {
 			return false;
 		}
 
 		$tag_name = $this->get_tag();
-		$tag_type = $this->is_tag_closer() ? 'closer' : 'opener';
 		$op_sigil = $this->is_tag_closer() ? '-' : '+';
 		$op       = "{$op_sigil}{$tag_name}";
 
@@ -203,128 +341,44 @@ private function step_in_body() {
 			default:
 				return false;
 		}
+	}
 
-		/*
-		 * > A start tag whose tag name is "html"
-		 */
-		if ( 'HTML' === $tag_name && 'opener' === $tag_type ) {
-			goto ignored;
-		}
-
-		/*
-		 * > A start tag whose tag name is one of: "base", "basefont", "bgsound",
-		 * > "link", "meta", "noframes", "script", "style", "template", "title"
-		 *
-		 * > An end tag whose tag name is "template"
-		 */
-		if (
-			'opener' === $tag_type && (
-				'BASE' === $tag_name ||
-				'BASEFONT' === $tag_name ||
-				'BGSOUND' === $tag_name ||
-				'LINK' === $tag_name ||
-				'META' === $tag_name ||
-				'NOFRAMES' === $tag_name ||
-				'SCRIPT' === $tag_name ||
-				'STYLE' === $tag_name ||
-				'TEMPLATE' === $tag_name ||
-				'TITLE' === $tag_name
-			) ||
-			(
-				'closer' === $tag_type &&
-				'TEMPLATE' === $tag_name
-			) )
-		{
-			parent::seek( 'current' );
-			$this->insertion_mode = 'in-head';
-			return $this->step();
-		}
-
-		/*
-		 * > A start tag whose tag name is "body"
-		 */
-		if ( 'opener' === $tag_type && 'BODY' === $tag_name ) {
-			goto ignored;
-		}
-
-		/*
-		 * > A start tag whose tag name is "frameset"
-		 */
-		if ( 'opener' === $tag_type && 'FRAMESET' === $tag_name ) {
-			return self::NOT_IMPLEMENTED_YET;
-		}
-
-		/*
-		 * > An end-of-file token
-		 *
-		 * Stop parsing.
-		 */
+	public function set_bookmark( $bookmark_name ) {
+		return parent::set_bookmark( '_' . $bookmark_name );
+	}
 
-		/*
-		 * > An end tag whose tag name is "body"
-		 * > An end tag whose tag name is "html"
-		 */
-		if ( 'closer' === $tag_type && ( 'BODY' === $tag_name || 'HTML' === $tag_name ) ) {
-			/*
-			 * > If the stack of open elements does not have a body element in scope, this is a parse error; ignore the token.
-			 *
-			 * @TODO: We didn't construct an open HTML or BODY tag, but we have to make a choice here based on that.
-			 *        Probably need to create these _or_ assume this will always transfer to "after body".
-			 */
-			$this->insertion_mode = 'after-body';
-			return true;
-		}
+	public function release_bookmark( $bookmark_name ) {
+		return parent::release_bookmark( '_' . $bookmark_name );
+	}
 
-		/*
-		 * > A start tag whose tag name is one of: "address", "article", "aside", "blockquote", "center",
-		 * > "details", "dialog", "dir", "div", "dl", "fieldset", "figcaption", "figure", "footer",
-		 * > "header", "hgroup", "main", "menu", "nav", "ol", "p", "search", "section", "summary", "ul"
-		 */
-		if (
-			'opener' === $tag_type && (
-				'ADDRESS' === $tag_name ||
-				'ARTICLE' === $tag_name ||
-				'ASIDE' === $tag_name ||
-				'BLOCKQUOTE' === $tag_name ||
-				'CENTER' === $tag_name ||
-				'DETAILS' === $tag_name ||
-				'DIALOG' === $tag_name ||
-				'DIR' === $tag_name ||
-				'DIV' === $tag_name ||
-				'DL' === $tag_name ||
-				'FIELDSET' === $tag_name ||
-				'FIGCAPTION' === $tag_name ||
-				'FIGURE' === $tag_name ||
-				'FOOTER' === $tag_name ||
-				'HEADER' === $tag_name ||
-				'HGROUP' === $tag_name ||
-				'MAIN' === $tag_name ||
-				'MENU' === $tag_name ||
-				'NAV' === $tag_name ||
-				'OL' === $tag_name ||
-				'P' === $tag_name ||
-				'SEARCH' === $tag_name ||
-				'SECTION' === $tag_name ||
-				'SUMMARY' === $tag_name ||
-				'UL' === $tag_name
-			)
-		) {
-			if ( $this->has_in_scope( 'P', 'BUTTON' ) ) {
-				$this->close_p_element();
-			}
+	/**
+	 * Sets a non-prefixed bookmark for the current tag.
+	 *
+	 * @return string Name of the created bookmark.
+	 * @throws Exception
+	 */
+	private function tag_bookmark() {
+		$name = (string) ++$this->bookmark_id;
 
-			$this->enter_element( $tag_name );
+		if ( false === parent::set_bookmark( $name ) ) {
+			throw new Exception( 'Could not set tag bookmark' );
 		}
 
-		return false;
+		return $name;
 	}
 
-	public function set_bookmark( $bookmark_name ) {
-		return parent::set_bookmark( '_' . $bookmark_name );
-	}
+	/**
+	 * Sets a non-prefixed bookmark for a given point position in the input HTML.
+	 *
+	 * @param int $index Where in the document the bookmark points; should be on a token boundary.
+	 * @return string Name of the created bookmark.
+	 */
+	private function spot_bookmark( $index ) {
+		$name = (string) ++$this->bookmark_id;
 
-	public function release_bookmark( $bookmark_name ) {
-		return parent::release_bookmark( '_' . $bookmark_name );
+		$this->bookmarks[ $name ] = new WP_HTML_Span( $index, $index );
+
+		return $name;
 	}
 
 	private function enter_element( $element ) {
@@ -616,4 +670,118 @@ public function set_outer_content( $new_html ) {
 		$this->release_bookmark( 'start' );
 		$this->release_bookmark( 'end' );
 	}
+
+	/*
+	 * HTML5 Parsing Algorithms
+	 */
+
+	/**
+	 * Resets the insertion mode appropriately.
+	 *
+	 * @see https://html.spec.whatwg.org/#reset-the-insertion-mode-appropriately
+	 * @return void
+	 */
+	private function reset_insertion_mode_appropriately() {
+		$last = false;
+		$depth = $this->tag_openers->count();
+
+		for ( $nth_from_top = 0; $nth_from_top < $depth; $nth_from_top++ ) {
+			$node = $this->tag_openers->peek( $nth_from_top );
+
+			if ( $nth_from_top === $depth - 1 ) {
+				$last = true;
+
+				if ( null !== $this->context_node ) {
+					$node = $this->context_node;
+				}
+			}
+
+			switch ( $node->element ) {
+				// SELECT is a nasty beast we don't support anyway..
+				case WP_HTMLSelectElement::class:
+					if ( $last ) {
+						$this->insertion_mode = self::IN_SELECT;
+						return;
+					}
+
+					$ancestor = $node;
+					for ( $nth_ancestor = 0; $nth_ancestor + $nth_from_top < $depth; ) {
+						if ( $ancestor === $this->tag_openers->peek( $depth - 1 ) ) {
+							$this->insertion_mode = self::IN_SELECT;
+							return;
+						}
+
+						$nth_ancestor++;
+						$ancestor = $this->tag_openers->peek( $nth_ancestor + $nth_from_top );
+						switch ( $ancestor->element ) {
+							case WP_HTMLTemplateElement::class:
+								$this->insertion_mode = self::IN_SELECT;
+								return;
+
+							case WP_HTMLTableElement::class:
+								$this->insertion_mode = self::IN_SELECT_IN_TABLE;
+								return;
+						}
+					}
+
+				case WP_HTMLTdElement::class:
+				case WP_HTMLThElement::class:
+					if ( ! $last ) {
+						$this->insertion_mode = self::IN_CELL;
+						return;
+					}
+					break;
+
+				case WP_HTMLTrElement::class:
+					$this->insertion_mode = self::IN_ROW;
+					return;
+
+				case WP_HTMLTheadElement::class:
+				case WP_HTMLTbodyElement::class:
+				case WP_HTMLTfootElement::class:
+					$this->insertion_mode = self::IN_TABLE_BODY;
+					return;
+
+				case WP_HTMLCaptionElement::class:
+					$this->insertion_mode = self::IN_CAPTION;
+					return;
+
+				case WP_HTMLColgroupElement::class:
+					$this->insertion_mode = self::IN_COLUMN_GROUP;
+					return;
+
+				case WP_HTMLTableElement::class:
+					$this->insertion_mode = self::IN_TABLE;
+					return;
+
+				case WP_HTMLTemplateElement::class:
+					// @TODO: support current template insertion mode/stack
+					throw new Exception( self::NOT_IMPLEMENTED_YET );
+
+				case WP_HTMLHeadElement::class:
+					$this->insertion_mode = self::IN_HEAD;
+					return;
+
+				case WP_HTMLBodyElement::class:
+					$this->insertion_mode = self::IN_BODY;
+					return;
+
+				case WP_HTMLFramesetElement::class:
+					$this->insertion_mode = self::IN_FRAMESET;
+					return;
+
+				case WP_HTMLHtmlElement::class:
+					$this->insertion_mode = null === $this->head_element_pointer
+						? self::BEFORE_HEAD
+						: self::AFTER_HEAD;
+					return;
+
+				default:
+					if ( $last ) {
+						$this->insertion_mode = self::IN_BODY;
+						return;
+					}
+			}
+		}
+	}
 }
diff --git a/src/wp-includes/html-api/class-wp-html-spec.php b/src/wp-includes/html-api/class-wp-html-spec.php
index a714ad9bcb614..77df612d7a9a6 100644
--- a/src/wp-includes/html-api/class-wp-html-spec.php
+++ b/src/wp-includes/html-api/class-wp-html-spec.php
@@ -458,6 +458,9 @@ class WP_HTMLFormElement extends WP_HTML_Element_Meta {
 	const IS_SPECIAL = true;
 }
 
+class WP_HTMLFramesetElement extends WP_HTML_Element_Meta {
+}
+
 class WP_HTMLH1Element extends WP_HTML_Element_Meta {
 	const IS_SPECIAL = true;
 }

From bc61ea881b36cbb542ddb49dfce28683448783f5 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Sat, 20 May 2023 16:21:53 +0200
Subject: [PATCH 27/39] Add custom "Unsupported Exception" class to
 differentiate from other errors

---
 src/wp-includes/html-api/class-wp-html-processor.php  | 11 ++++++-----
 .../html-api/class-wp-html-unsupported-exception.php  |  9 +++++++++
 2 files changed, 15 insertions(+), 5 deletions(-)
 create mode 100644 src/wp-includes/html-api/class-wp-html-unsupported-exception.php

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index 1f03d1045d456..2d5c055cd66c2 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -2,6 +2,7 @@
 
 require_once __DIR__ . '/class-wp-html-element-stack.php';
 require_once __DIR__ . '/class-wp-html-spec.php';
+require_once __DIR__ . '/class-wp-html-unsupported-exception.php';
 
 class WP_HTML_Processor extends WP_HTML_Tag_Processor {
 	const NOT_IMPLEMENTED_YET = false;
@@ -201,7 +202,7 @@ public function step( $insertion_mode = null ) {
 				default:
 					return self::NOT_IMPLEMENTED_YET;
 			}
-		} catch ( Exception $e ) {
+		} catch ( WP_HTML_API_Unsupported_Exception $e ) {
 			/*
 			 * Exceptions are used in this class to escape deep call stacks that
 			 * otherwise might involve messier calling and return conventions.
@@ -279,7 +280,7 @@ private function step_in_body() {
 			 * > A start tag whose tag name is "frameset"
 			 */
 			case '+FRAMESET':
-				throw new Exception( self::NOT_IMPLEMENTED_YET );
+				throw new WP_HTML_API_Unsupported_Exception( 'Cannot process FRAMESET elements.');
 
 			/*
 			 * > An end tag whose tag name is "body"
@@ -361,7 +362,7 @@ private function tag_bookmark() {
 		$name = (string) ++$this->bookmark_id;
 
 		if ( false === parent::set_bookmark( $name ) ) {
-			throw new Exception( 'Could not set tag bookmark' );
+			throw new WP_HTML_API_Unsupported_Exception( 'Could not set tag bookmark' );
 		}
 
 		return $name;
@@ -447,7 +448,7 @@ private function current_node() {
 	 * @return false
 	 */
 	private function has_in_scope( $element, $scope ) {
-		throw new Exception( self::NOT_IMPLEMENTED_YET );
+		throw new WP_HTML_API_Unsupported_Exception( 'Cannot check for element in scope.');
 	}
 
 	public function next_tag( $query = null ) {
@@ -756,7 +757,7 @@ private function reset_insertion_mode_appropriately() {
 
 				case WP_HTMLTemplateElement::class:
 					// @TODO: support current template insertion mode/stack
-					throw new Exception( self::NOT_IMPLEMENTED_YET );
+					throw new WP_HTML_API_Unsupported_Exception( 'Cannot process TEMPLATE elements.' );
 
 				case WP_HTMLHeadElement::class:
 					$this->insertion_mode = self::IN_HEAD;
diff --git a/src/wp-includes/html-api/class-wp-html-unsupported-exception.php b/src/wp-includes/html-api/class-wp-html-unsupported-exception.php
new file mode 100644
index 0000000000000..0ef8b2f45be74
--- /dev/null
+++ b/src/wp-includes/html-api/class-wp-html-unsupported-exception.php
@@ -0,0 +1,9 @@
+<?php
+
+/**
+ * Class representing that an unsupported operation was attempted in the HTML API.
+ *
+ * @TODO: Update the since version
+ * @since 6.3.0
+ */
+class WP_HTML_API_Unsupported_Exception extends Exception {}

From 6f58b70edb619db2c4411e36221f3929cf5a751a Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Sat, 20 May 2023 16:23:06 +0200
Subject: [PATCH 28/39] Set template insertion mode stack to empty array, not
 null

---
 src/wp-includes/html-api/class-wp-html-processor.php | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index 2d5c055cd66c2..04785fa8d8a9f 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -96,9 +96,9 @@ class WP_HTML_Processor extends WP_HTML_Tag_Processor {
 	 *
 	 * Not implemented yet.
 	 *
-	 * @var null
+	 * @var string[]
 	 */
-	private $template_insertion_mode_stack = null;
+	private $template_insertion_mode_stack = array();
 
 	/**
 	 * Create a new HTML Processor for reading and modifying HTML structure.

From d82b1461332310e59f867944b287088c6f13f7b3 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Sun, 21 May 2023 12:27:04 +0200
Subject: [PATCH 29/39] Expand SPEC data for IS_SPECIAL and IS_OBSOLETE

---
 .../html-api/class-wp-html-spec.php           | 107 +++++++++++++++++-
 1 file changed, 106 insertions(+), 1 deletion(-)

diff --git a/src/wp-includes/html-api/class-wp-html-spec.php b/src/wp-includes/html-api/class-wp-html-spec.php
index 77df612d7a9a6..d25944509bc6b 100644
--- a/src/wp-includes/html-api/class-wp-html-spec.php
+++ b/src/wp-includes/html-api/class-wp-html-spec.php
@@ -296,6 +296,8 @@ class WP_HTML_Element_Meta {
 	const IS_VOID = false;
 	const IS_HTML = true;
 	const IS_SPECIAL = false;
+	const IS_FORMATTING = false;
+	const IS_OBSOLETE = false;
 }
 
 class WP_HTMLElement extends WP_HTML_Element_Meta {
@@ -315,6 +317,7 @@ class WP_HTMLUnknownHTMLElement extends WP_HTMLUnknownElement {
 }
 
 class WP_HTMLAnchorElement extends WP_HTML_Element_Meta {
+	const IS_FORMATTING = true;
 }
 
 class WP_HTMLAbbrElement extends WP_HTML_Element_Meta {
@@ -324,7 +327,9 @@ class WP_HTMLAddressElement extends WP_HTML_Element_Meta {
 	const IS_SPECIAL = true;
 }
 
-// @TODO: Add deprecated special rule: APPLET
+class WP_HTMLAppletElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
+}
 
 class WP_HTMLAreaElement extends WP_HTML_Element_Meta {
 	const IS_VOID = true;
@@ -343,6 +348,7 @@ class WP_HTMLAudioElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLBElement extends WP_HTML_Element_Meta {
+	const IS_FORMATTING = true;
 }
 
 class WP_HTMLBaseElement extends WP_HTML_Element_Meta {
@@ -350,12 +356,27 @@ class WP_HTMLBaseElement extends WP_HTML_Element_Meta {
 	const IS_VOID = true;
 }
 
+class WP_HTMLBasefontElement extends WP_HTML_Element_Meta {
+	const IS_OBSOLETE = true;
+	const IS_SPECIAL = true;
+}
+
 class WP_HTMLBdiElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLBdoElement extends WP_HTML_Element_Meta {
 }
 
+class WP_HTMLBgsoundElement extends WP_HTML_Element_Meta {
+	const IS_OBSOLETE = true;
+	const IS_SPECIAL = true;
+}
+
+class WP_HTMLBigElement extends WP_HTML_Element_Meta {
+	const IS_OBSOLETE = true;
+	const IS_FORMATTING = true;
+}
+
 class WP_HTMLBlockquoteElement extends WP_HTML_Element_Meta {
 	const IS_SPECIAL = true;
 }
@@ -380,10 +401,16 @@ class WP_HTMLCaptionElement extends WP_HTML_Element_Meta {
 	const IS_SPECIAL = true;
 }
 
+class WP_HTMLCenterElement extends WP_HTML_Element_Meta {
+	const IS_OBSOLETE = true;
+	const IS_SPECIAL = true;
+}
+
 class WP_HTMLCiteElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLCodeElement extends WP_HTML_Element_Meta {
+	const IS_FORMATTING = true;
 }
 
 class WP_HTMLColElement extends WP_HTML_Element_Meta {
@@ -418,6 +445,11 @@ class WP_HTMLDfnElement extends WP_HTML_Element_Meta {
 class WP_HTMLDialogElement extends WP_HTML_Element_Meta {
 }
 
+class WP_HTMLDirElement extends WP_HTML_Element_Meta {
+	const IS_OBSOLETE = true;
+	const IS_SPECIAL = true;
+}
+
 class WP_HTMLDivElement extends WP_HTML_Element_Meta {
 	const IS_SPECIAL = true;
 }
@@ -431,6 +463,7 @@ class WP_HTMLDtElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLEmElement extends WP_HTML_Element_Meta {
+	const IS_FORMATTING = true;
 }
 
 class WP_HTMLEmbedElement extends WP_HTML_Element_Meta {
@@ -450,6 +483,11 @@ class WP_HTMLFigureElement extends WP_HTML_Element_Meta {
 	const IS_SPECIAL = true;
 }
 
+class WP_HTMLFontElement extends PW_HTML_Element_Meta {
+	const IS_OBSOLETE = true;
+	const IS_FORMATTING = true;
+}
+
 class WP_HTMLFooterElement extends WP_HTML_Element_Meta {
 	const IS_SPECIAL = true;
 }
@@ -458,7 +496,12 @@ class WP_HTMLFormElement extends WP_HTML_Element_Meta {
 	const IS_SPECIAL = true;
 }
 
+class WP_HTMLFrameElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
+}
+
 class WP_HTMLFramesetElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLH1Element extends WP_HTML_Element_Meta {
@@ -507,6 +550,7 @@ class WP_HTMLHtmlElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLIElement extends WP_HTML_Element_Meta {
+	const IS_FORMATTING = true;
 }
 
 class WP_HTMLIframeElement extends WP_HTML_Element_Meta {
@@ -529,6 +573,11 @@ class WP_HTMLInsElement extends WP_HTML_Element_Meta {
 class WP_HTMLKbdElement extends WP_HTML_Element_Meta {
 }
 
+class WP_HTMLKeygenElement extends WP_HTML_Element_Meta {
+	const IS_OBSOLETE = true;
+	const IS_SPECIAL = true;
+}
+
 class WP_HTMLLabelElement extends WP_HTML_Element_Meta {
 }
 
@@ -544,6 +593,11 @@ class WP_HTMLLinkElement extends WP_HTML_Element_Meta {
 	const IS_VOID = true;
 }
 
+class WP_HTMLListingElement extends WP_HTML_Element_Meta {
+	const IS_OBSOLETE = true;
+	const IS_SPECIAL = true;
+}
+
 class WP_HTMLMainElement extends WP_HTML_Element_Meta {
 	const IS_SPECIAL = true;
 }
@@ -551,6 +605,10 @@ class WP_HTMLMainElement extends WP_HTML_Element_Meta {
 class WP_HTMLMapElement extends WP_HTML_Element_Meta {
 }
 
+class WP_HTMLMarqueeElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
+}
+
 class WP_HTMLMarkElement extends WP_HTML_Element_Meta {
 }
 
@@ -573,6 +631,21 @@ class WP_HTMLNavElement extends WP_HTML_Element_Meta {
 	const IS_SPECIAL = true;
 }
 
+class WP_HTMLNobrElement extends WP_HTML_Element_Meta {
+	const IS_OBSOLETE = true;
+	const IS_FORMATTING = true;
+}
+
+class WP_HTMLNoembedElement extends WP_HTML_Element_Meta {
+	const IS_OBSOLETE = true;
+	const IS_SPECIAL = true;
+}
+
+class WP_HTMLNoframesElement extends WP_HTML_Element_Meta {
+	const IS_OBSOLETE = true;
+	const IS_SPECIAL = true;
+}
+
 class WP_HTMLNoscriptElement extends WP_HTML_Element_Meta {
 }
 
@@ -597,9 +670,18 @@ class WP_HTMLPElement extends WP_HTML_Element_Meta {
 	const IS_SPECIAL = true;
 }
 
+class WP_HTMLParamElement extends WP_HTML_Element_Meta {
+	const IS_OBSOLETE = true;
+	const IS_SPECIAL = true;
+}
+
 class WP_HTMLPictureElement extends WP_HTML_Element_Meta {
 }
 
+class WP_HTMLPlaintextElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
+}
+
 class WP_HTMLPreElement extends WP_HTML_Element_Meta {
 	const IS_SPECIAL = true;
 }
@@ -620,6 +702,7 @@ class WP_HTMLRubyElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLSElement extends WP_HTML_Element_Meta {
+	const IS_FORMATTING = true;
 }
 
 class WP_HTMLSampElement extends WP_HTML_Element_Meta {
@@ -629,6 +712,10 @@ class WP_HTMLScriptElement extends WP_HTML_Element_Meta {
 	const IS_SPECIAL = true;
 }
 
+class WP_HTMLSearchElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
+}
+
 class WP_HTMLSectionElement extends WP_HTML_Element_Meta {
 	const IS_SPECIAL = true;
 }
@@ -641,6 +728,7 @@ class WP_HTMLSlotElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLSmallElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
 }
 
 class WP_HTMLSourceElement extends WP_HTML_Element_Meta {
@@ -651,7 +739,13 @@ class WP_HTMLSourceElement extends WP_HTML_Element_Meta {
 class WP_HTMLSpanElement extends WP_HTML_Element_Meta {
 }
 
+class WP_HTMLStrikeElement extends WP_HTML_Element_Meta {
+	const IS_OBSOLETE = true;
+	const IS_FORMATTING = true;
+}
+
 class WP_HTMLStrongElement extends WP_HTML_Element_Meta {
+	const IS_FORMATTING = true;
 }
 
 class WP_HTMLStyleElement extends WP_HTML_Element_Meta {
@@ -719,7 +813,13 @@ class WP_HTMLTrackElement extends WP_HTML_Element_Meta {
 	const IS_VOID = true;
 }
 
+class WP_HTMLTtElement extends WP_HTML_Element_Meta {
+	const IS_OBSOLETE = true;
+	const IS_FORMATTING = true;
+}
+
 class WP_HTMLUElement extends WP_HTML_Element_Meta {
+	const IS_FORMATTING = true;
 }
 
 class WP_HTMLUlElement extends WP_HTML_Element_Meta {
@@ -736,3 +836,8 @@ class WP_HTMLWbrElement extends WP_HTML_Element_Meta {
 	const IS_SPECIAL = true;
 	const IS_VOID = true;
 }
+
+class WP_HTMLXmpElement extends WP_HTML_Element_Meta {
+	const IS_OBSOLETE = true;
+	const IS_SPECIAL = true;
+}

From a6e5323e5e753f7b39dd8dc54b981442372ac759 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Sun, 21 May 2023 12:41:24 +0200
Subject: [PATCH 30/39] Docs for SPEC and some minor refactoring

---
 .../html-api/class-wp-html-element-stack.php  | 18 ++++++++-----
 .../html-api/class-wp-html-spec.php           | 27 +++++++++++++++++++
 2 files changed, 38 insertions(+), 7 deletions(-)

diff --git a/src/wp-includes/html-api/class-wp-html-element-stack.php b/src/wp-includes/html-api/class-wp-html-element-stack.php
index 1f2b1485f5949..a0ac0d353b632 100644
--- a/src/wp-includes/html-api/class-wp-html-element-stack.php
+++ b/src/wp-includes/html-api/class-wp-html-element-stack.php
@@ -58,8 +58,8 @@ public function current_node() {
 	 * @return boolean whether the given element is on the stack.
 	 */
 	public function has_element( $element ) {
-		for ( $i = count( $this->stack ) - 1; $i > 0; $i++ ) {
-			if ( $this->stack[ $i ]->element === $element ) {
+		for ( $i = 0; $i < $this->count(); $i++ ) {
+			if ( $this->peek( $i )->element === $element ) {
 				return true;
 			}
 		}
@@ -72,11 +72,11 @@ public function has_element( $element ) {
 	 *
 	 * @see https://html.spec.whatwg.org/#has-an-element-in-the-specific-scope
 	 *
-	 * @param string   $element The target node.
+	 * @param string   $target_node      The target node.
 	 * @param string[] $termination_list List of elements that terminate the search.
 	 * @return bool
 	 */
-	public function has_element_in_specific_scope( $element, $termination_list ) {
+	public function has_element_in_specific_scope( $target_node, $termination_list ) {
 		$i = $this->count();
 		if ( $i === 0 ) {
 			return false;
@@ -84,18 +84,22 @@ public function has_element_in_specific_scope( $element, $termination_list ) {
 
 		$node = $this->stack[ --$i ];
 
-		if ( $node->element === $element ) {
+		if ( $node->element === $target_node ) {
 			return true;
 		}
 
-		if ( in_array( $element, $termination_list, true ) ) {
+		if ( in_array( $target_node, $termination_list, true ) ) {
 			return false;
 		}
 
 		while ( $i > 0 && null !== ( $node = $this->stack[ --$i ] ) ) {
-			if ( $node->element === $element ) {
+			if ( $node->element === $target_node ) {
 				return true;
 			}
+
+			if ( in_array( $target_node, $termination_list, true ) ) {
+				return false;
+			}
 		}
 
 		return false;
diff --git a/src/wp-includes/html-api/class-wp-html-spec.php b/src/wp-includes/html-api/class-wp-html-spec.php
index d25944509bc6b..ea34d3964f627 100644
--- a/src/wp-includes/html-api/class-wp-html-spec.php
+++ b/src/wp-includes/html-api/class-wp-html-spec.php
@@ -293,10 +293,36 @@ public static function element_info( $tag_name ) {
 }
 
 class WP_HTML_Element_Meta {
+	/**
+	 * Whether the element only has a start tag and cannot have an ending tag.
+	 *
+	 * @see https://html.spec.whatwg.org/#void-elements
+	 */
 	const IS_VOID = false;
+
 	const IS_HTML = true;
+	/**
+	 * Whether the element has varying levels of special parsing rules.
+	 *
+	 * @see https://html.spec.whatwg.org/#special
+	 */
 	const IS_SPECIAL = false;
+
+	/**
+	 * Whether the element ends up in the list of active formatting elements.
+	 *
+	 * @see https://html.spec.whatwg.org/#formatting
+	 */
 	const IS_FORMATTING = false;
+
+	/**
+	 * Whether the element is entirely obsolete, and must not be used by authors.
+	 *
+	 * Obsolete elements must not be used, but they may still appear in markup
+	 * and must be supported by parsers.
+	 *
+	 * @see https://html.spec.whatwg.org/#non-conforming-features
+	 */
 	const IS_OBSOLETE = false;
 }
 
@@ -328,6 +354,7 @@ class WP_HTMLAddressElement extends WP_HTML_Element_Meta {
 }
 
 class WP_HTMLAppletElement extends WP_HTML_Element_Meta {
+	const IS_OBSOLETE = true;
 	const IS_SPECIAL = true;
 }
 

From 8a2215e8710bebd27941ca7129994a4079c5d960 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Sun, 21 May 2023 13:13:49 +0200
Subject: [PATCH 31/39] Add algorithms for handling list of active formatting
 elements.

---
 .../class-wp-html-element-stack-item.php      |   2 +-
 .../html-api/class-wp-html-element-stack.php  |  40 ++++++-
 .../html-api/class-wp-html-processor.php      | 108 +++++++++++++++++-
 .../html-api/class-wp-html-spec.php           |   4 +
 4 files changed, 143 insertions(+), 11 deletions(-)

diff --git a/src/wp-includes/html-api/class-wp-html-element-stack-item.php b/src/wp-includes/html-api/class-wp-html-element-stack-item.php
index 527b526c0e02a..7f1222ad58dbc 100644
--- a/src/wp-includes/html-api/class-wp-html-element-stack-item.php
+++ b/src/wp-includes/html-api/class-wp-html-element-stack-item.php
@@ -37,7 +37,7 @@ class WP_HTML_Element_Stack_Item {
 	 */
 	public $related_item = null;
 
-	public function __construct( $bookmark_name, $element, $flags, $related_item = null ) {
+	public function __construct( $bookmark_name, $element, $flags = self::NO_FLAGS, $related_item = null ) {
 		$this->bookmark_name = $bookmark_name;
 		$this->element       = $element;
 		$this->flags         = $flags;
diff --git a/src/wp-includes/html-api/class-wp-html-element-stack.php b/src/wp-includes/html-api/class-wp-html-element-stack.php
index a0ac0d353b632..f95a7753dcd11 100644
--- a/src/wp-includes/html-api/class-wp-html-element-stack.php
+++ b/src/wp-includes/html-api/class-wp-html-element-stack.php
@@ -9,17 +9,21 @@ class WP_HTML_Element_Stack {
 	public $stack = array();
 
 	/**
-	 * Returns a copy of the ith element on the stack for inspection.
+	 * Returns a copy of the nth element on the stack for inspection.
 	 *
-	 * @param int $nth_from_top Which item on the stack to return.
+	 * The top element is the oldest element on the stack. The 0th
+	 * element will therefore always be the last element added, the
+	 * 1st element will be the next-to-last element added, etc...
+	 *
+	 * @param int $nth_from_bottom Which item on the stack to return.
 	 * @return WP_HTML_Element_Stack_Item|null
 	 */
-	public function peek( $nth_from_top ) {
-		if ( $nth_from_top < 0 || $nth_from_top >= $this->count() ) {
+	public function peek( $nth_from_bottom ) {
+		if ( $nth_from_bottom < 0 || $nth_from_bottom >= $this->count() ) {
 			return null;
 		}
 
-		return $this->stack[ $this->count() - $nth_from_top - 1 ];
+		return $this->stack[ $this->count() - $nth_from_bottom - 1 ];
 	}
 
 	/**
@@ -34,6 +38,30 @@ public function push( $stack_item ) {
 		$this->stack[] = $stack_item;
 	}
 
+	/**
+	 * Removes an item of a given value from the stack.
+	 *
+	 * @TODO: Should this be done by index? What performance
+	 *        tradeoffs are we making here by isolating the
+	 *        index from the callee? It's safer, but is it
+	 *        worth the cost?
+	 *
+	 * @TODO: Measure performance against `remove_at( $nth_from_bottom )`.
+	 *
+	 * @param string $stack_item Which item to remove.
+	 * @return bool Whether the item was removed.
+	 */
+	public function remove( $stack_item ) {
+		for ( $i = $this->count() - 1; $i >= 0; $i++ ) {
+			if ( $this->stack[ $i ] === $stack_item ) {
+				array_splice( $this->stack, $i, 1 );
+				return true;
+			}
+		}
+
+		return false;
+	}
+
 	public function count() {
 		return count( $this->stack );
 	}
@@ -46,7 +74,7 @@ public function count() {
 	public function current_node() {
 		$count = $this->count();
 
-		return $this->count() > 0
+		return $count > 0
 			? $this->stack[ $count - 1 ]
 			: null;
 	}
diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index 04785fa8d8a9f..f7bb1b7be0daa 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -52,10 +52,19 @@ class WP_HTML_Processor extends WP_HTML_Tag_Processor {
 	private $tag_openers = null;
 
 	/**
-	 * @var WP_HTML_Element_Stack Referes to element closing tags.
+	 * @var WP_HTML_Element_Stack Refers to element closing tags.
 	 */
 	private $tag_closers = null;
 
+	/**
+	 * Used to handle mis-nested formatting element tags.
+	 *
+	 * @see https://html.spec.whatwg.org/#the-list-of-active-formatting-elements
+	 *
+	 * @var WP_HTML_Element_Stack
+	 */
+	private $active_formatting_elements = null;
+
 	/**
 	 * @var string Tree construction insertion mode.
 	 */
@@ -141,8 +150,9 @@ class WP_HTML_Processor extends WP_HTML_Tag_Processor {
 	public function __construct( $html, $initial_mode = array( 'fragment', 'body' ), $encoding = 'utf8' ) {
 		parent::__construct( $html );
 
-		$this->tag_openers = new WP_HTML_Element_Stack();
-		$this->tag_closers = new WP_HTML_Element_Stack();
+		$this->tag_openers                = new WP_HTML_Element_Stack();
+		$this->tag_closers                = new WP_HTML_Element_Stack();
+		$this->active_formatting_elements = new WP_HTML_Element_Stack();
 
 		list( $parser_type, $initial_context ) = $initial_mode;
 
@@ -356,7 +366,7 @@ public function release_bookmark( $bookmark_name ) {
 	 * Sets a non-prefixed bookmark for the current tag.
 	 *
 	 * @return string Name of the created bookmark.
-	 * @throws Exception
+	 * @throws WP_HTML_API_Unsupported_Exception
 	 */
 	private function tag_bookmark() {
 		$name = (string) ++$this->bookmark_id;
@@ -681,6 +691,7 @@ public function set_outer_content( $new_html ) {
 	 *
 	 * @see https://html.spec.whatwg.org/#reset-the-insertion-mode-appropriately
 	 * @return void
+	 * @throws WP_HTML_API_Unsupported_Exception
 	 */
 	private function reset_insertion_mode_appropriately() {
 		$last = false;
@@ -785,4 +796,93 @@ private function reset_insertion_mode_appropriately() {
 			}
 		}
 	}
+
+	/**
+	 * Track a formatting element on the stack of active formatting elements.
+	 *
+	 * This is used to handle improperly closed or overlapping elements.
+	 *
+	 * @see https://html.spec.whatwg.org/#push-onto-the-list-of-active-formatting-elements
+	 *
+	 * @param string $element Which element to push onto the list of active formatting elements.
+	 * @return void
+	 * @throws WP_HTML_API_Unsupported_Exception
+	 */
+	private function push_onto_list_of_active_formatting_elements( $element ) {
+		$same_element_count = 0;
+		for ( $i = 0; $i < $this->active_formatting_elements->count(); $i++ ) {
+			$stack_element = $this->active_formatting_elements->peek( $i );
+
+			if ( $stack_element->element === WP_HTMLMarker::class ) {
+				break;
+			}
+
+			if ( $stack_element->element !== $element ) {
+				continue;
+			}
+
+			/*
+			 * @TODO: Implement the "Noah's Ark Clause" by parsing and comparing
+			 *        the attributes within each element. For now we assume that
+			 *        if the tag name matches, it's the same element, but this
+			 *        is wrong according to the specification.
+			 */
+			if ( 3 >= ++$same_element_count ) {
+				$this->active_formatting_elements->remove( $stack_element );
+				break;
+			}
+		}
+
+		$this->active_formatting_elements->push( new WP_HTML_Element_Stack_Item( $this->tag_bookmark(), $element ) );
+	}
+
+	/**
+	 * Reconstructs the active formatting elements.
+	 *
+	 * @see https://html.spec.whatwg.org/#reconstruct-the-active-formatting-elements
+	 *
+	 * @return bool Whether any formatting elements were reconstructed.
+	 * @throws WP_HTML_API_Unsupported_Exception
+	 */
+	public function reconstruct_active_formatting_elements() {
+		if ( 0 === $this->active_formatting_elements->count() ) {
+			return false;
+		}
+
+		$last_entry = $this->active_formatting_elements->current_node();
+		if ( $last_entry->element === WP_HTMLMarker::class ) {
+			return false;
+		}
+
+		if ( $this->tag_openers->has_element( $last_entry->element ) ) {
+			return false;
+		}
+
+		throw new WP_HTML_API_Unsupported_Exception( 'Cannot reconstruct the active formatting elements.' );
+	}
+
+	/**
+	 * Clears the list of active formatting elements up to the last marker.
+	 *
+	 * @see https://html.spec.whatwg.org/#clear-the-list-of-active-formatting-elements-up-to-the-last-marker
+	 *
+	 * @return void
+	 */
+	public function clear_list_of_formatting_elements_up_to_the_last_marker() {
+		$to_remove = array();
+
+		for ( $i = 0; $i < $this->active_formatting_elements->count(); $i++ ) {
+			$stack_item = $this->active_formatting_elements->peek( $i );
+
+			if ( $stack_item->element === WP_HTMLMarker::class ) {
+				break;
+			}
+
+			$to_remove[] = $stack_item;
+		}
+
+		for ( $i = 0; $i < count( $to_remove ); $i++ ) {
+			$this->active_formatting_elements->remove( $to_remove[ $i ] );
+		}
+	}
 }
diff --git a/src/wp-includes/html-api/class-wp-html-spec.php b/src/wp-includes/html-api/class-wp-html-spec.php
index ea34d3964f627..ebd2cb79140bd 100644
--- a/src/wp-includes/html-api/class-wp-html-spec.php
+++ b/src/wp-includes/html-api/class-wp-html-spec.php
@@ -326,6 +326,10 @@ class WP_HTML_Element_Meta {
 	const IS_OBSOLETE = false;
 }
 
+class WP_HTMLMarker extends WP_HTML_Element_Meta {
+
+}
+
 class WP_HTMLElement extends WP_HTML_Element_Meta {
 }
 

From d96c05ae994824bf2b276ed1fb443c8a04085c7b Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Sun, 21 May 2023 13:18:01 +0200
Subject: [PATCH 32/39] Add docs for HEAD and FORM pointers.

---
 src/wp-includes/html-api/class-wp-html-processor.php | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index f7bb1b7be0daa..bc8b48d2b474d 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -78,15 +78,26 @@ class WP_HTML_Processor extends WP_HTML_Tag_Processor {
 	private $context_node = null;
 
 	/**
+	 * Points to the HEAD element once one has been parsed, either implicitly or explicitly.
+	 *
 	 * @TODO: Implement this.
 	 *
+	 * @see https://html.spec.whatwg.org/#head-element-pointer
+	 *
 	 * @var null
 	 */
 	private $head_element_pointer = null;
 
 	/**
+	 * Points to the last form element that was opened and whose end tag has not yet been seen, if any.
+	 *
 	 * @TODO: Implement this.
 	 *
+	 * This is used to make form controls associate with forms in the face of dramatically
+	 * bad markup, for historical reasons. It is ignored inside template elements.
+	 *
+	 * @see https://html.spec.whatwg.org/#form-element-pointer
+	 *
 	 * @var null
 	 */
 	private $form_element_pointer = null;

From c93d4206e7ad4978a3f5751561d5ac0844ea81f4 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Sun, 21 May 2023 13:47:00 +0200
Subject: [PATCH 33/39] Generate implied end tags, poorly and naively.

---
 .../html-api/class-wp-html-processor.php      | 188 +++++++++---------
 1 file changed, 89 insertions(+), 99 deletions(-)

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index bc8b48d2b474d..b696728fc1d98 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -424,123 +424,113 @@ private function close_p_element() {
 	}
 
 	/**
-	 * @TODO: Implement this
+	 * Closes elements that have implied end tags.
 	 *
 	 * @see https://html.spec.whatwg.org/#generate-implied-end-tags
 	 *
 	 * @param string|null $except_for_this_element Perform as if this element doesn't exist in the stack of open elements.
 	 * @return void
+	 * @throws WP_HTML_API_Unsupported_Exception
 	 */
 	private function generate_implied_end_tags( $except_for_this_element = null ) {
-
-	}
-
-	/**
-	 * The current node is the bottommost node in this stack of open elements.
-	 *
-	 * @see https://html.spec.whatwg.org/#current-node
-	 * @return false|mixed|string
-	 */
-	private function current_node() {
-		if ( 0 === $this->depth ) {
-			return false;
-		}
-
-		$max_depth = 0;
-		foreach ( $this->bookmarks as $name => $bookmark ) {
-			if ( '_' === $name[0] ) {
-				continue;
+		$current_node = $this->tag_openers->current_node();
+
+		$elements_with_implied_end_tags = array(
+			WP_HTMLDdElement::class,
+			WP_HTMLDtElement::class,
+			WP_HTMLLiElement::class,
+			WP_HTMLOptgroupElement::class,
+			WP_HTMLOptionElement::class,
+			WP_HTMLPElement::class,
+			WP_HTMLRbElement::class,
+			WP_HTMLRpElement::class,
+			WP_HTMLRtElement::class,
+			WP_HTMLRtcElement::class,
+		);
+
+		// @TODO: spot_bookmark needs to get "the current position".
+		$tag = $this->tag_bookmark();
+		$this->bookmarks[ $tag ]->end = $this->bookmarks[ $tag ]->start;
+
+		// @TODO: Use $this->tag_closers to compute "open" tags. We're probably duplicating
+		//        actual tag closers right now because we assume that if a tag is in the
+		//        openers list, it has no closing tag. This is probably wrong.
+		for ( $i = 0; $i < $this->tag_openers->count(); $i++ ) {
+			$current_node = $this->tag_openers->peek( $i );
+			$element      = $current_node->element;
+
+			if ( $element === $except_for_this_element || ! in_array( $element, $elements_with_implied_end_tags, true ) ) {
+				break;
 			}
 
-			list( $depth, $element ) = explode( '_', $name );
-			if ( $depth === "{$this->depth}" ) {
-				return $element;
-			}
+			$this->tag_closers->push(
+				new WP_HTML_Element_Stack_Item(
+					$tag,
+					$current_node->element,
+					WP_HTML_Element_Stack_Item::IS_CLOSER,
+					$current_node
+				)
+			);
 		}
-
-		return false;
 	}
 
 	/**
-	 * Indicates if the stack of open elements has an element in a given scope.
+	 * Closes elements that have implied end tags, thoroughly.
 	 *
-	 * @param $element
-	 * @param $scope
-	 * @return false
+	 * @see https://html.spec.whatwg.org/#generate-all-implied-end-tags-thoroughly
+	 *
+	 * @param string|null $except_for_this_element Perform as if this element doesn't exist in the stack of open elements.
+	 * @return void
+	 * @throws WP_HTML_API_Unsupported_Exception
 	 */
-	private function has_in_scope( $element, $scope ) {
-		throw new WP_HTML_API_Unsupported_Exception( 'Cannot check for element in scope.');
-	}
-
-	public function next_tag( $query = null ) {
-		/*
-		 * The first thing that needs to happen when stepping through the HTML is to
-		 * close any void and self-closing elements. These appear on the open stack
-		 * to support matching CSS selectors and gauging depths, but they don't
-		 * truly have distinct openings and closings.
-		 */
-		if ( 0 < count( $this->open_elements ) ) {
-			$element = WP_HTML_Spec::element_info( end( $this->open_elements ) );
-			if ( $element::IS_VOID  || ( ! $element::IS_HTML && $this->has_self_closing_flag() ) ) {
-				array_pop( $this->open_elements );
-			}
-		}
-
-		if ( false === parent::next_tag( array( 'tag_closers' => 'visit' ) ) ) {
-			return false;
-		}
-
-		$tag_name = $this->get_tag();
-		$element = WP_HTML_Spec::element_info( $tag_name );
-
-		$self_closes = $element::IS_VOID || ( ! $element::IS_HTML && $this->has_self_closing_flag() );
-		if ( $self_closes ) {
-			$this->open_elements[] = $tag_name;
-			$this->set_bookmark( '__open_elements_' . count( $this->open_elements ) );
-			return true;
-		}
-
-		if ( $this->is_tag_closer() ) {
-			$this->release_bookmark( '__open_elements_' . count( $this->open_elements ) );
-			array_pop( $this->open_elements );
-		} else {
-			$this->open_elements[] = $tag_name;
-			$this->set_bookmark( '__open_elements_' . count( $this->open_elements ) );
-		}
-
-		return true;
-	}
-
-	public function next_sibling() {
-		$starting_depth = count( $this->open_elements );
-
-		while ( $this->next_tag() ) {
-			$current_depth = count( $this->open_elements );
-
-			if ( ! $this->is_tag_closer() && $current_depth === $starting_depth ) {
-				return true;
-			}
-
-			if ( ! $this->is_tag_closer() && $current_depth < $starting_depth ) {
-				return false;
+	private function generate_implied_end_tags_thoroughly( $except_for_this_element = null ) {
+		$current_node = $this->tag_openers->current_node();
+
+		$elements_with_implied_end_tags = array(
+			WP_HTMLCaptionElement::class,
+			WP_HTMLColgroupElement::class,
+			WP_HTMLDdElement::class,
+			WP_HTMLDtElement::class,
+			WP_HTMLLiElement::class,
+			WP_HTMLOptgroupElement::class,
+			WP_HTMLOptionElement::class,
+			WP_HTMLPElement::class,
+			WP_HTMLRbElement::class,
+			WP_HTMLRpElement::class,
+			WP_HTMLRtElement::class,
+			WP_HTMLRtcElement::class,
+			WP_HTMLTbodyElement::class,
+			WP_HTMLTdElement::class,
+			WP_HTMLTfootElement::class,
+			WP_HTMLThElement::class,
+			WP_HTMLTheadElement::class,
+			WP_HTMLTrElement::class,
+		);
+
+		// @TODO: spot_bookmark needs to get "the current position".
+		$tag = $this->tag_bookmark();
+		$this->bookmarks[ $tag ]->end = $this->bookmarks[ $tag ]->start;
+
+		// @TODO: Use $this->tag_closers to compute "open" tags. We're probably duplicating
+		//        actual tag closers right now because we assume that if a tag is in the
+		//        openers list, it has no closing tag. This is probably wrong.
+		for ( $i = 0; $i < $this->tag_openers->count(); $i++ ) {
+			$current_node = $this->tag_openers->peek( $i );
+			$element      = $current_node->element;
+
+			if ( $element === $except_for_this_element || ! in_array( $element, $elements_with_implied_end_tags, true ) ) {
+				break;
 			}
-		}
-
-		return false;
-	}
-
-	public function first_child() {
-		$starting_depth = count( $this->open_elements );
 
-		while ( $this->next_tag() ) {
-			$current_depth = count( $this->open_elements );
-
-			if ( ! $this->is_tag_closer() && $current_depth === $starting_depth + 1 ) {
-				return true;
-			}
+			$this->tag_closers->push(
+				new WP_HTML_Element_Stack_Item(
+					$tag,
+					$current_node->element,
+					WP_HTML_Element_Stack_Item::IS_CLOSER,
+					$current_node
+				)
+			);
 		}
-
-		return false;
 	}
 
 	public function seek( $bookmark_name ) {

From 2e0e4f94bc39bb53a4d278f0714451b85c43fb5a Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Sun, 21 May 2023 13:48:36 +0200
Subject: [PATCH 34/39] More docs, remove something not necessary.

---
 src/wp-includes/html-api/class-wp-html-processor.php | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index b696728fc1d98..d47b3cb5c6988 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -433,8 +433,6 @@ private function close_p_element() {
 	 * @throws WP_HTML_API_Unsupported_Exception
 	 */
 	private function generate_implied_end_tags( $except_for_this_element = null ) {
-		$current_node = $this->tag_openers->current_node();
-
 		$elements_with_implied_end_tags = array(
 			WP_HTMLDdElement::class,
 			WP_HTMLDtElement::class,
@@ -455,6 +453,8 @@ private function generate_implied_end_tags( $except_for_this_element = null ) {
 		// @TODO: Use $this->tag_closers to compute "open" tags. We're probably duplicating
 		//        actual tag closers right now because we assume that if a tag is in the
 		//        openers list, it has no closing tag. This is probably wrong.
+		//        We could be jumping into an already-parsed section via `seek()`, so we
+		//        have to determine if we're in opened tags or not.
 		for ( $i = 0; $i < $this->tag_openers->count(); $i++ ) {
 			$current_node = $this->tag_openers->peek( $i );
 			$element      = $current_node->element;
@@ -484,8 +484,6 @@ private function generate_implied_end_tags( $except_for_this_element = null ) {
 	 * @throws WP_HTML_API_Unsupported_Exception
 	 */
 	private function generate_implied_end_tags_thoroughly( $except_for_this_element = null ) {
-		$current_node = $this->tag_openers->current_node();
-
 		$elements_with_implied_end_tags = array(
 			WP_HTMLCaptionElement::class,
 			WP_HTMLColgroupElement::class,
@@ -514,6 +512,8 @@ private function generate_implied_end_tags_thoroughly( $except_for_this_element
 		// @TODO: Use $this->tag_closers to compute "open" tags. We're probably duplicating
 		//        actual tag closers right now because we assume that if a tag is in the
 		//        openers list, it has no closing tag. This is probably wrong.
+		//        We could be jumping into an already-parsed section via `seek()`, so we
+		//        have to determine if we're in opened tags or not.
 		for ( $i = 0; $i < $this->tag_openers->count(); $i++ ) {
 			$current_node = $this->tag_openers->peek( $i );
 			$element      = $current_node->element;

From f5c7651ba7b7cee92e577f334b323c624cfbf12b Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Mon, 22 May 2023 13:35:02 +0200
Subject: [PATCH 35/39] Introduce static factory methods

---
 .../html-api/class-wp-html-processor.php      | 178 ++++++++++++++----
 1 file changed, 145 insertions(+), 33 deletions(-)

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index d47b3cb5c6988..c7536c169c432 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -37,6 +37,15 @@ class WP_HTML_Processor extends WP_HTML_Tag_Processor {
 	const AFTER_AFTER_BODY = 'after-after-body';
 	const AFTER_AFTER_FRAMESET = 'after-after-frameset';
 
+	/*
+	 * These don't have to be globally unique; as constants they
+	 * are provided as a means to link the strings to the meanings
+     * but their text values are provided as a convenience for
+	 * calling functions and sccripts.
+	 */
+	const FULL_PARSER = 'full';
+	const FRAGMENT_PARSER = 'fragment';
+
 
 	private $depth = 0;
 	private static $query = array( 'tag_closers' => 'visit' );
@@ -120,6 +129,78 @@ class WP_HTML_Processor extends WP_HTML_Tag_Processor {
 	 */
 	private $template_insertion_mode_stack = array();
 
+	/**
+	 * Create an HTML processor in the full HTML parsing mode.
+	 *
+	 * Use this for cases where you have an entire HTML document from
+	 * the start to the end. If you have a section of HTML that's part
+	 * of a bigger document, then use `createFragment()` instead.
+	 *
+	 * @TODO: Proper version number.
+	 * @since 6.3.0
+	 *
+	 * @param string $html     Input HTML document to process.
+	 * @param string $encoding Text encoding of the document; only supported value is 'utf-8'.
+	 * @return WP_HTML_Processor|null The created processor if successfull, otherwise null.
+	 */
+	public static function createDocument( $html, $encoding = 'utf-8' ) {
+		$options = array(
+			'parser_mode'    => self::FULL_PARSER,
+			'insertion_mode' => self::INITIAL_MODE,
+			'context_node'   => null,
+		);
+
+		return new self( $html, $options, $encoding );
+	}
+
+	/**
+	 * Create an HTML processor in the fragment parsing mode.
+	 *
+	 * Use this for cases where you are processing chunks of HTML that
+	 * will be found within a bigger HTML document, such as rendered
+	 * block output that exists within a post, `the_content` inside a
+	 * rendered site layout.
+	 *
+	 * Fragment parsing occurs within a context, which is an HTML element
+	 * that the document will eventually be placed in. It becomes important
+	 * when special elements have different rules than others, such as inside
+	 * a TEXTAREA or a TITLE tag where things that look like tags are text,
+	 * or inside a SCRIPT tag where things that look like HTML syntax are JS.
+	 *
+	 * The context value should be a representation of the tag into which the
+	 * HTML is found. For most cases this will be the body element. The HTML
+	 * form is provided because a context element may have attributes that
+	 * impact the parse, such as with a SCRIPT tag and its `type` attribute.
+	 *
+	 * @TODO: Proper version number.
+	 * @since 6.3.0
+	 *
+	 * @param string $html     Input HTML fragment to process.
+	 * @param string $context  Context element for the fragment, defaults to `<body>`.
+	 * @param string $encoding Text encoding of the document; only supported value is 'utf-8'.
+	 * @return WP_HTML_Processor|null The created processor if successfull, otherwise null.
+	 */
+	public static function createFragment( $html, $context = '<body>', $encoding = 'utf8' ) {
+		$p = new WP_HTML_Tag_Processor( $context );
+		if ( ! $p->next_tag() ) {
+			return null;
+		}
+
+		$context_node = WP_HTML_Spec::element_info( $p->next_tag() );
+		$context_attributes = array();
+		foreach ( $p->get_attribute_names_with_prefix( '' ) as $attribute_name ) {
+			$context_attributes[ $attribute_name ] = $p->get_attribute( $attribute_name );
+		}
+
+		$options = array(
+			'parser_mode'    => self::FRAGMENT_PARSER,
+			'insertion_mode' => null,
+			'context_node'   => array( $context_node, $context_attributes ),
+		);
+
+		return new self( $html, $options, $encoding );
+	}
+
 	/**
 	 * Create a new HTML Processor for reading and modifying HTML structure.
 	 *
@@ -158,43 +239,28 @@ class WP_HTML_Processor extends WP_HTML_Tag_Processor {
 	 * @param string[] $initial_mode Initial mode for parser, if provided. Defaults to a fragment parser in the BODY element.
 	 * @param string $encoding Must be utf-8
 	 */
-	public function __construct( $html, $initial_mode = array( 'fragment', 'body' ), $encoding = 'utf8' ) {
+	public function __construct( $html, $use_the_static_create_functions_instead ) {
 		parent::__construct( $html );
 
 		$this->tag_openers                = new WP_HTML_Element_Stack();
 		$this->tag_closers                = new WP_HTML_Element_Stack();
 		$this->active_formatting_elements = new WP_HTML_Element_Stack();
 
-		list( $parser_type, $initial_context ) = $initial_mode;
-
-		switch ( $parser_type ) {
-			// Can we convert a full parser into a fragment parser re-using the existing
-			// intial parsing state? E.g. is [ 'full', WP_HTML_Processor:IN_BODY ] the same as  [ 'fragment', '<body>' ]
-			case 'full':
-				$this->insertion_mode = $initial_context;
-				break;
-
-			case 'fragment':
-				$p = new WP_HTML_Tag_Processor( $initial_context );
-				$p->next_tag();
-				$context_node = WP_HTML_Spec::element_info( $p->next_tag() );
-				$context_attributes = array();
-				foreach ( $p->get_attribute_names_with_prefix( '' ) as $attribute_name ) {
-					$context_attributes[ $attribute_name ] = $p->get_attribute( $attribute_name );
-				}
-
-				$this->context_node = array( $context_node, $context_attributes );
+		$initial_state = $use_the_static_create_functions_instead;
+		$this->insertion_mode = $initial_state['insertion_mode'];
 
-				$this->tag_openers->push(
-					new WP_HTML_Element_Stack_Item(
-						$this->spot_bookmark( 0 ),
-						'HTML',
-						WP_HTML_Element_Stack_Item::NO_FLAGS
-					)
-				);
+		if ( self::FRAGMENT_PARSER === $initial_state['parser_mode'] ) {
+			$this->context_node = array( $initial_state['context_node'], $initial_state['context_attributes'] );
 
-				// Create the context node somehow. We can't/don't want to prepend it
-				// to the HTML, unless we _can_ do that without disturbing the output.
+			// @TODO: Put this somewhere.
+			// @TODO: How can we bookmark this without having an instance yet?
+			$this->tag_openers->push(
+				new WP_HTML_Element_Stack_Item(
+					$this->spot_bookmark( 0 ),
+					'HTML',
+					WP_HTML_Element_Stack_Item::NO_FLAGS
+				)
+			);
 		}
 	}
 
@@ -228,7 +294,7 @@ public function step( $insertion_mode = null ) {
 			 * Exceptions are used in this class to escape deep call stacks that
 			 * otherwise might involve messier calling and return conventions.
 			 */
-			return false;
+			return self::NOT_IMPLEMENTED_YET;
 		}
 	}
 
@@ -262,12 +328,24 @@ private function step_in_body() {
 		$op_sigil = $this->is_tag_closer() ? '-' : '+';
 		$op       = "{$op_sigil}{$tag_name}";
 
+		/*
+		 * @TODO: What's up with reconstructing active formatting elements for
+		 *        text within IN_BODY? How can we get into this situation?
+		 */
+
 		switch ( $op ) {
+			case '+DOCTYPE':
+				goto ignored;
+
 			/*
 			 * > A start tag whose tag name is "html"
 			 */
 			case '+HTML':
-				goto ignored;
+				if ( $this->has_element_on_stack_of_open_elements( WP_HTMLTemplateElement::class ) ) {
+					goto ignored;
+				} else {
+					throw new WP_HTML_API_Unsupported_Exception( 'Cannot add inner HTML attributes to outer HTML element.' );
+				}
 
 			/*
 			 * > A start tag whose tag name is one of: "base", "basefont", "bgsound",
@@ -286,19 +364,42 @@ private function step_in_body() {
 			case '+TEMPLATE':
 			case '+TITLE':
 			case '-TEMPLATE':
+				// @TODO: Do we need to back up one more character?
 				parent::seek( 'current' );
-				$this->insertion_mode = 'in-head';
+				$this->insertion_mode = self::IN_HEAD;
 				return $this->step();
 
 			/*
 			 * > A start tag whose tag name is "body"
 			 */
 			case '+BODY':
-				goto ignored;
+				/*
+				 * @TODO: There is an unsupported case for adding attributes to an open
+				 *        BODY tag, but also a confusing description.
+				 *
+				 * > If the second element on the stack of open elements is not a body element,
+				 * > if the stack of open elements has only one node on it, or if there is a
+				 * > template element on the stack of open elements, then ignore the token. (fragment case)
+				 *
+				 * Why the "second element"?   --> is this a fragment in "<body>" context?
+				 * Why if only a single node?  --> have we closed the context element?
+				 *
+				 * In a fragment case the first element on the stack of open elements will _always_
+				 * be HTML _root_ with _no attributes_, and the second element on the stack will be
+				 * the context node with its attributes.
+				 */
+				if ( false || false || $this->has_element_on_stack_of_open_elements( WP_HTMLTemplateElement::class ) ) {
+					goto ignored;
+				} else {
+					throw new WP_HTML_API_Unsupported_Exception( 'Cannot add inner BODY attributes to outer BODY element.' );
+				}
 
 
 			/*
 			 * > A start tag whose tag name is "frameset"
+			 *
+			 * @TODO: Framesets apparently refuse to exist within BODY tags.
+			 *        But we still need to skip their children when we encounter them.
 			 */
 			case '+FRAMESET':
 				throw new WP_HTML_API_Unsupported_Exception( 'Cannot process FRAMESET elements.');
@@ -555,6 +656,17 @@ public function seek( $bookmark_name ) {
 		$this->depth = $max_depth;
 	}
 
+	/**
+	 * Determines if an element exists on the stack of open elements.
+	 *
+	 * @param string $element Which element to find.
+	 * @return boolean
+	 * @throws WP_HTML_API_Unsupported_Exception
+	 */
+	private function has_element_on_stack_of_open_elements( $element ) {
+		throw new WP_HTML_API_Unsupported_Exception();
+	}
+
 	private function find_closing_tag() {
 		$starting_depth = count( $this->open_elements );
 

From 3956ad98423cbc7c9be4b67a8c5352ebe0bcb153 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Tue, 23 May 2023 08:52:08 +0200
Subject: [PATCH 36/39] Access private methods and properties of friend class

---
 src/wp-includes/html-api/class-wp-html-processor.php | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index c7536c169c432..19b8d67bac234 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -192,13 +192,21 @@ public static function createFragment( $html, $context = '<body>', $encoding = '
 			$context_attributes[ $attribute_name ] = $p->get_attribute( $attribute_name );
 		}
 
+		// @TODO: we have to manually "pump" the tokenizer to skip the initial content.
+		$h = new self( $html );
+		switch ( $context_node ) {
+			case WP_HTMLTitleElement::class:
+			case WP_HTMLTextareaElement::class:
+				$h->
+		}
+
 		$options = array(
 			'parser_mode'    => self::FRAGMENT_PARSER,
 			'insertion_mode' => null,
 			'context_node'   => array( $context_node, $context_attributes ),
 		);
 
-		return new self( $html, $options, $encoding );
+		return $h;
 	}
 
 	/**

From 613ae1a688d00be9c1d924c2d941f6c96ba25a3c Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Wed, 24 May 2023 11:56:16 +0200
Subject: [PATCH 37/39] Replace goto:ignored with recursion

---
 src/wp-includes/html-api/class-wp-html-processor.php | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index 19b8d67bac234..41f63cb6edb86 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -325,9 +325,9 @@ private function step_in_head() {
 	 * @see https://html.spec.whatwg.org/#parsing-main-inbody
 	 *
 	 * @return boolean Whether an element was found.
+	 * @throws WP_HTML_API_Unsupported_Exception
 	 */
 	private function step_in_body() {
-		ignored:
 		if ( ! $this->next_tag( self::$query ) ) {
 			return false;
 		}
@@ -343,14 +343,14 @@ private function step_in_body() {
 
 		switch ( $op ) {
 			case '+DOCTYPE':
-				goto ignored;
+				return $this->step_in_body();
 
 			/*
 			 * > A start tag whose tag name is "html"
 			 */
 			case '+HTML':
 				if ( $this->has_element_on_stack_of_open_elements( WP_HTMLTemplateElement::class ) ) {
-					goto ignored;
+					return $this->step_in_body();
 				} else {
 					throw new WP_HTML_API_Unsupported_Exception( 'Cannot add inner HTML attributes to outer HTML element.' );
 				}
@@ -397,7 +397,7 @@ private function step_in_body() {
 				 * the context node with its attributes.
 				 */
 				if ( false || false || $this->has_element_on_stack_of_open_elements( WP_HTMLTemplateElement::class ) ) {
-					goto ignored;
+					return $this->step_in_body();
 				} else {
 					throw new WP_HTML_API_Unsupported_Exception( 'Cannot add inner BODY attributes to outer BODY element.' );
 				}

From 46e377736a786e21d3d60086d9997209b5d044c4 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Thu, 25 May 2023 18:14:56 +0200
Subject: [PATCH 38/39] Continue adding IN BODY handling.

TODO:
 - abstract and optimize "if P in button scope then close P"
---
 .../html-api/class-wp-html-processor.php      | 242 ++++++++++++++++--
 1 file changed, 214 insertions(+), 28 deletions(-)

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index 41f63cb6edb86..8f526ec925590 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -47,6 +47,15 @@ class WP_HTML_Processor extends WP_HTML_Tag_Processor {
 	const FRAGMENT_PARSER = 'fragment';
 
 
+	/*
+	 * In some cases a transition to another insertion mode is followed
+	 * by reprocessing the existing token in the stream. These constants
+	 * indicate whether that should happen.
+	 */
+	const REPROCESS_THIS_NODE = 'reprocess-this-node';
+	const PROCESS_NEXT_NODE = 'process-next-node';
+
+
 	private $depth = 0;
 	private static $query = array( 'tag_closers' => 'visit' );
 
@@ -120,6 +129,15 @@ class WP_HTML_Processor extends WP_HTML_Tag_Processor {
 	 */
 	private $original_insertion_mode = null;
 
+	/**
+	 * Specifies whether FRAMESET elements can be processed in the current mode.
+	 *
+	 * @see https://html.spec.whatwg.org/#frameset-ok-flag
+	 *
+	 * @var bool
+	 */
+	private $frameset_ok = true;
+
 	/**
 	 * Stack of template insertion modes.
 	 *
@@ -129,6 +147,16 @@ class WP_HTML_Processor extends WP_HTML_Tag_Processor {
 	 */
 	private $template_insertion_mode_stack = array();
 
+	/**
+	 * Indicates if the stack of open elements contains a TEMPLATE element.
+	 *
+	 * This is an optimization to bypass scanning the stack of open elements
+	 * in less common cases.
+	 *
+	 * @var bool
+	 */
+	private $template_element_is_on_stack_of_open_elements = false;
+
 	/**
 	 * Create an HTML processor in the full HTML parsing mode.
 	 *
@@ -283,14 +311,24 @@ public function __construct( $html, $use_the_static_create_functions_instead ) {
 	 * domain of the fragment parsing algorithm this method will abort
 	 * and return `false`.
 	 *
-	 * @param string $insertion_mode Starting insertion mode for parser, best to leave as the default value
-	 *                               unless knowingly handling HTML that will be included inside known tags.
+	 * @param string $node_to_process Indicates if the current or next token should be processed.
 	 *
 	 * @return boolean Whether an element was found.
 	 */
-	public function step( $insertion_mode = null ) {
+	public function step( $node_to_process = self::PROCESS_NEXT_NODE ) {
+		if ( self::PROCESS_NEXT_NODE === $node_to_process ) {
+			$this->next_tag( self::$query );
+		}
+
+		// Finish stepping when there are no more tokens in the document.
+		if ( null === $this->get_tag() ) {
+			return false;
+		}
+
+		parent::set_bookmark( 'here' );
+
 		try {
-			switch ( $insertion_mode ?: $this->insertion_mode ) {
+			switch ( $this->insertion_mode ) {
 				case self::IN_BODY:
 					return $this->step_in_body();
 
@@ -328,10 +366,6 @@ private function step_in_head() {
 	 * @throws WP_HTML_API_Unsupported_Exception
 	 */
 	private function step_in_body() {
-		if ( ! $this->next_tag( self::$query ) ) {
-			return false;
-		}
-
 		$tag_name = $this->get_tag();
 		$op_sigil = $this->is_tag_closer() ? '-' : '+';
 		$op       = "{$op_sigil}{$tag_name}";
@@ -343,14 +377,16 @@ private function step_in_body() {
 
 		switch ( $op ) {
 			case '+DOCTYPE':
-				return $this->step_in_body();
+				// Ignore the token.
+				return $this->step();
 
 			/*
 			 * > A start tag whose tag name is "html"
 			 */
 			case '+HTML':
-				if ( $this->has_element_on_stack_of_open_elements( WP_HTMLTemplateElement::class ) ) {
-					return $this->step_in_body();
+				if ( $this->template_element_is_on_stack_of_open_elements ) {
+					// Ignore the token.
+					return $this->step();
 				} else {
 					throw new WP_HTML_API_Unsupported_Exception( 'Cannot add inner HTML attributes to outer HTML element.' );
 				}
@@ -372,33 +408,35 @@ private function step_in_body() {
 			case '+TEMPLATE':
 			case '+TITLE':
 			case '-TEMPLATE':
-				// @TODO: Do we need to back up one more character?
-				parent::seek( 'current' );
 				$this->insertion_mode = self::IN_HEAD;
-				return $this->step();
+				return $this->step( self::REPROCESS_THIS_NODE );
 
 			/*
 			 * > A start tag whose tag name is "body"
 			 */
 			case '+BODY':
 				/*
-				 * @TODO: There is an unsupported case for adding attributes to an open
-				 *        BODY tag, but also a confusing description.
-				 *
 				 * > If the second element on the stack of open elements is not a body element,
 				 * > if the stack of open elements has only one node on it, or if there is a
 				 * > template element on the stack of open elements, then ignore the token. (fragment case)
 				 *
-				 * Why the "second element"?   --> is this a fragment in "<body>" context?
-				 * Why if only a single node?  --> have we closed the context element?
-				 *
 				 * In a fragment case the first element on the stack of open elements will _always_
 				 * be HTML _root_ with _no attributes_, and the second element on the stack will be
-				 * the context node with its attributes.
+				 * the context node with its attributes. If the stack of open elements is only one
+				 * element deep it implies that the BODY has been closed, _or_ in the case of a fragment
+				 * parser, that there's no available BODY onto which to add new attributes.
 				 */
-				if ( false || false || $this->has_element_on_stack_of_open_elements( WP_HTMLTemplateElement::class ) ) {
-					return $this->step_in_body();
+				if (
+					// @TODO: Should this be tag_openers of some "stack_of_open_elements".
+					1 === $this->tag_openers->count() ||
+					( $this->context_node && WP_HTMLBodyElement::class !== $this->context_node[0] ) ||
+					$this->template_element_is_on_stack_of_open_elements
+				) {
+					// Ignore the token.
+					return $this->step();
 				} else {
+					// @TODO: We could ignore this, but it could mess up CSS selectors. Do we support that?
+					//        In always ignoring it we cut out all this cumbersome detection logic.
 					throw new WP_HTML_API_Unsupported_Exception( 'Cannot add inner BODY attributes to outer BODY element.' );
 				}
 
@@ -410,6 +448,20 @@ private function step_in_body() {
 			 *        But we still need to skip their children when we encounter them.
 			 */
 			case '+FRAMESET':
+				if (
+					1 === $this->tag_openers->count() ||
+					( $this->context_node && WP_HTMLBodyElement::class !== $this->context_node[0] ) ||
+					! $this->frameset_ok
+				) {
+					// Ignore the token.
+					return $this->step();
+				}
+
+				/*
+				 * When encountering a FRAMESET in this state it should climb to the top of the DOM
+				 * tree under the HTML element and adopt all of the current open nodes, then switch
+				 * to self::IN_FRAMESET insertion mode.
+				 */
 				throw new WP_HTML_API_Unsupported_Exception( 'Cannot process FRAMESET elements.');
 
 			/*
@@ -424,8 +476,27 @@ private function step_in_body() {
 				 * @TODO: We didn't construct an open HTML or BODY tag, but we have to make a choice here based on that.
 				 *        Probably need to create these _or_ assume this will always transfer to "after body".
 				 */
-				$this->insertion_mode = 'after-body';
-				return true;
+				if ( ! $this->tag_openers->has_element_in_particular_scope( WP_HTMLBodyElement::class ) ) {
+					// Ignore the token.
+					return $this->step();
+				}
+
+				/*
+				 * > if there is a node in the stack of open elements that is not either a dd element,
+				 * > a dt element, an li element, an optgroup element, an option element, a p element,
+				 * > an rb element, an rp element, an rt element, an rtc element, a tbody element,
+				 * > a td element, a tfoot element, a th element, a thead element, a tr element,
+				 * > the body element, or the html element, then this is a parse error.
+				 *
+				 * Parse errors do not affect anything so there is nothing required to handle these cases.
+				 */
+
+				$this->insertion_mode = self::AFTER_BODY;
+				return $this->step(
+					'HTML' === $tag_name
+						? self::REPROCESS_THIS_NODE
+						: self::PROCESS_NEXT_NODE
+				);
 
 			/*
 			 * > A start tag whose tag name is one of: "address", "article", "aside", "blockquote", "center",
@@ -457,12 +528,127 @@ private function step_in_body() {
 			case '+SECTION':
 			case '+SUMMARY':
 			case '+UL':
-				if ( $this->has_in_scope( 'P', 'BUTTON' ) ) {
+				if ( $this->tag_openers->has_element_in_button_scope( WP_HTMLPElement::class ) ) {
+					$this->close_p_element();
+				}
+
+				// @TODO: We need to push the item onto the stack. Anything else?
+				$this->insert_html_element();
+				return true;
+
+			case '+H1':
+			case '+H2':
+			case '+H3':
+			case '+H4':
+			case '+H5':
+			case '+H6':
+				if ( $this->tag_openers->has_element_in_button_scope( WP_HTMLPElement::class ) ) {
 					$this->close_p_element();
 				}
 
-				$this->enter_element( $tag_name );
-				return;
+				switch ( $this->tag_openers->current_node()->element ) {
+					case WP_HTMLH1Element::class:
+					case WP_HTMLH2Element::class:
+					case WP_HTMLH3Element::class:
+					case WP_HTMLH4Element::class:
+					case WP_HTMLH5Element::class:
+					case WP_HTMLH6Element::class:
+						/*
+						 * > If the current node is an HTML element whose tag name is one of
+						 * > "h1", "h2", "h3", "h4", "h5", or "h6", then this is a parse error;
+						 * > pop the current node off the stack of open elements.
+						 *
+						 * If encountering a heading element inside another, the open one implicitly
+						 * closes and the new one opens. Not sure why here we don't "close" the first
+						 * one but effectively it does that.
+						 *
+						 * @TODO: Is this different when reconstructing the active formats from a P?
+						 */
+						$this->pop_node_off_of_stack_of_open_elements();
+				}
+
+				$this->insert_html_element();
+				return true;
+
+
+			case '+PRE':
+			case '+LISTING':
+				if ( $this->tag_openers->has_element_in_button_scope( WP_HTMLPElement::class ) ) {
+					$this->close_p_element();
+				}
+
+				$this->insert_html_element();
+
+				/*
+				 * > If the next token is a U+000A LINE FEED (LF) character token, then ignore that
+				 * > token and move on to the next one. (Newlines at the start of pre blocks are
+				 * > ignored as an authoring convenience.)
+				 *
+				 * Ignoring this here so that the function getting content can handle it.
+				 */
+				$this->frameset_ok = false;
+				return true;
+
+			case '+FORM':
+				if ( null !== $this->form_element_pointer && ! $this->template_element_is_on_stack_of_open_elements ) {
+					// Ignore the token.
+					return $this->step();
+				}
+
+				if ( $this->tag_openers->has_element_in_button_scope( WP_HTMLPElement::class ) ) {
+					$this->close_p_element();
+				}
+
+				$this->insert_html_element();
+				if ( ! $this->template_element_is_on_stack_of_open_elements ) {
+					$this->form_element_pointer = $this->get_bookmark_of_current_element();
+				}
+				return true;
+
+			case '+LI':
+				$this->frameset_ok = false;
+				throw new WP_HTML_API_Unsupported_Exception( 'Cannot descend into LI nodes yet.' );
+
+				/*
+				 * @TODO: Fix this logic.
+				 *
+				 * When encountering an LI close out all of the previous elements up to the containing LI,
+				 * then close the containing LI, then open this LI.
+				 *
+				 * If there are markers or special nodes that remove the containing LIs from the scope then
+				 * there's no need to close anything - they are structurally separated.
+				 */
+				$node = $this->tag_openers->current_node();
+				while ( WP_HTMLLiElement::class === $node->element ) {
+					$this->generate_implied_end_tags( WP_HTMLLiElement::class );
+
+					while ( WP_HTMLLiElement::class !== $this->pop_element_from_stack_of_open_elements() ) {
+						continue;
+					}
+
+					if ( $this->tag_openers->has_element_in_button_scope( WP_HTMLPElement::class ) ) {
+						$this->close_p_element();
+						$this->insert_html_element();
+						return true;
+					}
+
+					$element = $node->element;
+					if (
+						$element::IS_SPECIAL &&
+						WP_HTMLAddressElement::class !== $element &&
+						WP_HTMLDivElement::class !== $element &&
+						WP_HTMLPElement::class !== $element
+					) {
+						$this->close_p_element();
+						$this->insert_html_element();
+						return true;
+					}
+
+					// @TODO: Reset $node to next higher item in stack.
+				}
+
+				throw new Exception( 'This should never be reachable.' );
+
 
 			/*
 			 * > An end-of-file token

From c29570e349fe23001013b5e48fb027b73dd9c690 Mon Sep 17 00:00:00 2001
From: Dennis Snell <dennis.snell@automattic.com>
Date: Mon, 29 May 2023 15:42:37 +0200
Subject: [PATCH 39/39] More support

---
 .../html-api/class-wp-html-processor.php      | 76 +++++++++++++++++++
 1 file changed, 76 insertions(+)

diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index 8f526ec925590..748e3eabdb318 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -649,6 +649,82 @@ private function step_in_body() {
 
 				throw new Exception( 'This should never be reachable.' );
 
+			case '+DD':
+			case '+DT':
+				// @TODO: This is just like the LI case, but different in that it has two loops.
+				throw new WP_HTML_API_Unsupported_Exception( 'Cannot process DD or DT elementes yet.' );
+
+			case '+PLAINTEXT':
+				if ( $this->tag_openers->has_element_in_button_scope( WP_HTMLPElement::class ) ) {
+					$this->close_p_element();
+				}
+
+				// @TODO: Close the parser at this point. We might need to invent an insertion mode
+				//        that means "stop processing all elements."
+				$this->insert_html_element();
+				return true;
+
+			case '+BUTTON':
+				if ( $this->tag_openers->has_element_in_specific_scope( WP_HTMLButtonElement::class ) ) {
+					$this->generate_implied_end_tags();
+
+					// @TODO: Pop elements off of the open elements stack until a BUTTON has been removed.
+				}
+
+				$this->reconstruct_active_formatting_elements();
+				$this->insert_html_element();
+				$this->frameset_ok = false;
+				return true;
+
+			case '-ADDRESS':
+			case '-ARTICLE':
+			case '-ASIDE':
+			case '-BLOCKQUOTE':
+			case '-BUTTON':
+			case '-CENTER':
+			case '-DETAILS':
+			case '-DIALOG':
+			case '-DIR':
+			case '-DIV':
+			case '-DL':
+			case '-FIELDSET':
+			case '-FIGCAPTION':
+			case '-FIGURE':
+			case '-FOOTER':
+			case '-HEADER':
+			case '-HGROUP':
+			case '-LISTING':
+			case '-MAIN':
+			case '-MENU':
+			case '-NAV':
+			case '-OL':
+			case '-PRE':
+			case '-SEARCH':
+			case '-SECTION':
+			case '-SUMMARY':
+			case '-UL':
+				if ( ! $this->tag_openers->has_element_in_particular_scope( WP_HTML_Spec::element_info( $tag_name ) ) ) {
+					// Ignore token.
+					return $this->step();
+				}
+
+				$this->generate_implied_end_tags();
+
+				// @TODO: Should we mark parse errors?
+				// @TODO: Pop elements off of the open elements stack until a BUTTON has been removed.
+				return true;
+
+			case '-FORM':
+				if ( ! $this->template_element_is_on_stack_of_open_elements ) {
+					// @TODO: Implement
+					throw new WP_HTML_API_Unsupported_Exception( 'Cannot process FORM elements.' );
+				} else {
+					// @TODO: Implement
+					throw new WP_HTML_API_Unsupported_Exception( 'Cannot process FORM elements.' );
+				}
+
+			case '-P':
+				throw new WP_HTML_API_Unsupported_Exception( 'Cannot process P elements.' );
 
 			/*
 			 * > An end-of-file token