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..7f1222ad58dbc
--- /dev/null
+++ b/src/wp-includes/html-api/class-wp-html-element-stack-item.php
@@ -0,0 +1,46 @@
+<?php
+
+class WP_HTML_Element_Stack_Item {
+	const NO_FLAGS = 0;
+	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 = self::NO_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..f95a7753dcd11
--- /dev/null
+++ b/src/wp-includes/html-api/class-wp-html-element-stack.php
@@ -0,0 +1,306 @@
+<?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();
+
+	/**
+	 * Returns a copy of the nth element on the stack for inspection.
+	 *
+	 * 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_bottom ) {
+		if ( $nth_from_bottom < 0 || $nth_from_bottom >= $this->count() ) {
+			return null;
+		}
+
+		return $this->stack[ $this->count() - $nth_from_bottom - 1 ];
+	}
+
+	/**
+	 * Add an item to the top of the stack.
+	 *
+	 * @TODO: Do we need to insertion-sort these?
+	 *
+	 * @param WP_HTML_Element_Stack_Item $stack_item
+	 * @return void
+	 */
+	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 );
+	}
+
+	/**
+	 * Returns the bottom-most node on the stack.
+	 *
+	 * @return WP_HTML_Element_Stack_Item|null
+	 */
+	public function current_node() {
+		$count = $this->count();
+
+		return $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 = 0; $i < $this->count(); $i++ ) {
+			if ( $this->peek( $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   $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( $target_node, $termination_list ) {
+		$i = $this->count();
+		if ( $i === 0 ) {
+			return false;
+		}
+
+		$node = $this->stack[ --$i ];
+
+		if ( $node->element === $target_node ) {
+			return true;
+		}
+
+		if ( in_array( $target_node, $termination_list, true ) ) {
+			return false;
+		}
+
+		while ( $i > 0 && null !== ( $node = $this->stack[ --$i ] ) ) {
+			if ( $node->element === $target_node ) {
+				return true;
+			}
+
+			if ( in_array( $target_node, $termination_list, true ) ) {
+				return false;
+			}
+		}
+
+		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
new file mode 100644
index 0000000000000..748e3eabdb318
--- /dev/null
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -0,0 +1,1271 @@
+<?php
+
+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;
+
+	/**
+	 * 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';
+
+	/*
+	 * 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';
+
+
+	/*
+	 * 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' );
+
+	/**
+	 * @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 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.
+	 */
+	private $insertion_mode = 'initial';
+
+	/**
+	 * Context node initializing HTML fragment parsing, if in that mode.
+	 *
+	 * @var [string, array]|null
+	 */
+	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;
+
+	/**
+	 * Original insertion mode when entering 'text' or 'in-table-text' modes.
+	 *
+	 * Not implemented yet.
+	 *
+	 * @var string|null
+	 */
+	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.
+	 *
+	 * Not implemented yet.
+	 *
+	 * @var string[]
+	 */
+	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.
+	 *
+	 * 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 );
+		}
+
+		// @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 $h;
+	}
+
+	/**
+	 * 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, $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();
+
+		$initial_state = $use_the_static_create_functions_instead;
+		$this->insertion_mode = $initial_state['insertion_mode'];
+
+		if ( self::FRAGMENT_PARSER === $initial_state['parser_mode'] ) {
+			$this->context_node = array( $initial_state['context_node'], $initial_state['context_attributes'] );
+
+			// @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
+				)
+			);
+		}
+	}
+
+	/**
+	 * 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 $node_to_process Indicates if the current or next token should be processed.
+	 *
+	 * @return boolean Whether an element was found.
+	 */
+	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 ( $this->insertion_mode ) {
+				case self::IN_BODY:
+					return $this->step_in_body();
+
+				default:
+					return self::NOT_IMPLEMENTED_YET;
+			}
+		} 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.
+			 */
+			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.
+	 * @throws WP_HTML_API_Unsupported_Exception
+	 */
+	private function step_in_body() {
+		$tag_name = $this->get_tag();
+		$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':
+				// Ignore the token.
+				return $this->step();
+
+			/*
+			 * > A start tag whose tag name is "html"
+			 */
+			case '+HTML':
+				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.' );
+				}
+
+			/*
+			 * > 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':
+				$this->insertion_mode = self::IN_HEAD;
+				return $this->step( self::REPROCESS_THIS_NODE );
+
+			/*
+			 * > A start tag whose tag name is "body"
+			 */
+			case '+BODY':
+				/*
+				 * > 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)
+				 *
+				 * 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 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 (
+					// @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.' );
+				}
+
+
+			/*
+			 * > 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':
+				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.');
+
+			/*
+			 * > 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".
+				 */
+				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",
+			 * > "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->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();
+				}
+
+				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.' );
+
+			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
+			 *
+			 * Stop parsing.
+			 */
+			default:
+				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 );
+	}
+
+	/**
+	 * Sets a non-prefixed bookmark for the current tag.
+	 *
+	 * @return string Name of the created bookmark.
+	 * @throws WP_HTML_API_Unsupported_Exception
+	 */
+	private function tag_bookmark() {
+		$name = (string) ++$this->bookmark_id;
+
+		if ( false === parent::set_bookmark( $name ) ) {
+			throw new WP_HTML_API_Unsupported_Exception( 'Could not set tag bookmark' );
+		}
+
+		return $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;
+
+		$this->bookmarks[ $name ] = new WP_HTML_Span( $index, $index );
+
+		return $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}" );
+	}
+
+	/**
+	 * @see https://html.spec.whatwg.org/#close-a-p-element
+	 * @return void
+	 */
+	private function close_p_element() {
+		$this->generate_implied_end_tags( 'P' );
+
+
+	}
+
+	/**
+	 * 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 ) {
+		$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.
+		//        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;
+
+			if ( $element === $except_for_this_element || ! in_array( $element, $elements_with_implied_end_tags, true ) ) {
+				break;
+			}
+
+			$this->tag_closers->push(
+				new WP_HTML_Element_Stack_Item(
+					$tag,
+					$current_node->element,
+					WP_HTML_Element_Stack_Item::IS_CLOSER,
+					$current_node
+				)
+			);
+		}
+	}
+
+	/**
+	 * Closes elements that have implied end tags, thoroughly.
+	 *
+	 * @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 generate_implied_end_tags_thoroughly( $except_for_this_element = null ) {
+		$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.
+		//        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;
+
+			if ( $element === $except_for_this_element || ! in_array( $element, $elements_with_implied_end_tags, true ) ) {
+				break;
+			}
+
+			$this->tag_closers->push(
+				new WP_HTML_Element_Stack_Item(
+					$tag,
+					$current_node->element,
+					WP_HTML_Element_Stack_Item::IS_CLOSER,
+					$current_node
+				)
+			);
+		}
+	}
+
+	public function seek( $bookmark_name ) {
+		parent::seek( '_' . $bookmark_name );
+
+		$max_depth = $this->depth;
+		foreach ( $this->bookmarks as $name => $mark ) {
+			// 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;
+	}
+
+	/**
+	 * 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 );
+
+		while ( $this->next_tag() ) {
+			$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 ( ! $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 ( ! $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 ( ! $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 ( ! $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' );
+	}
+
+	/*
+	 * HTML5 Parsing Algorithms
+	 */
+
+	/**
+	 * Resets the insertion mode appropriately.
+	 *
+	 * @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;
+		$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 WP_HTML_API_Unsupported_Exception( 'Cannot process TEMPLATE elements.' );
+
+				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;
+					}
+			}
+		}
+	}
+
+	/**
+	 * 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
new file mode 100644
index 0000000000000..ebd2cb79140bd
--- /dev/null
+++ b/src/wp-includes/html-api/class-wp-html-spec.php
@@ -0,0 +1,874 @@
+<?php
+
+
+/**
+ * Source of knowledge about HTML according to the HTML 5 specification.
+ *
+ * @since 6.3.0
+ */
+class WP_HTML_Spec {
+	/**
+	 * Returns class defining attributes of an element with the given name.
+	 *
+	 * @since 6.3.0
+	 *
+	 * @param string $tag_name
+	 * @return WP_HTML_Element_Meta::class
+	 */
+	public static function element_info( $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;
+
+			// Deprecated elements
+			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 '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':
+				return WP_HTMLPreElement::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 {
+	/**
+	 * 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;
+}
+
+class WP_HTMLMarker extends WP_HTML_Element_Meta {
+
+}
+
+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 {
+	const IS_FORMATTING = true;
+}
+
+class WP_HTMLAbbrElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLAddressElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
+}
+
+class WP_HTMLAppletElement extends WP_HTML_Element_Meta {
+	const IS_OBSOLETE = true;
+	const IS_SPECIAL = true;
+}
+
+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 {
+}
+
+class WP_HTMLBElement extends WP_HTML_Element_Meta {
+	const IS_FORMATTING = true;
+}
+
+class WP_HTMLBaseElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
+	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;
+}
+
+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_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 {
+	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 {
+}
+
+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 {
+}
+
+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;
+}
+
+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 {
+	const IS_FORMATTING = true;
+}
+
+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_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;
+}
+
+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 {
+	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_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 {
+	const IS_FORMATTING = true;
+}
+
+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;
+}
+
+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 {
+}
+
+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_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;
+}
+
+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 {
+}
+
+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;
+}
+
+class WP_HTMLMeterElement extends WP_HTML_Element_Meta {
+}
+
+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 {
+}
+
+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 {
+}
+
+class WP_HTMLOptionElement extends WP_HTML_Element_Meta {
+}
+
+class WP_HTMLOutputElement extends WP_HTML_Element_Meta {
+}
+
+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;
+}
+
+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 {
+	const IS_FORMATTING = true;
+}
+
+class WP_HTMLSampElement extends WP_HTML_Element_Meta {
+}
+
+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;
+}
+
+class WP_HTMLSelectElement extends WP_HTML_Element_Meta {
+	const IS_SPECIAL = true;
+}
+
+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 {
+	const IS_SPECIAL = true;
+	const IS_VOID = true;
+}
+
+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 {
+	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 {
+}
+
+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;
+}
+
+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 {
+	const IS_SPECIAL = true;
+}
+
+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_SPECIAL = true;
+	const IS_VOID = true;
+}
+
+class WP_HTMLXmpElement extends WP_HTML_Element_Meta {
+	const IS_OBSOLETE = true;
+	const IS_SPECIAL = true;
+}
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 {}
diff --git a/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php b/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
new file mode 100644
index 0000000000000..92e29101b1ba1
--- /dev/null
+++ b/tests/phpunit/tests/html-api/Tests_HtmlApi_wpHtmlProcessor_Support.php
@@ -0,0 +1,328 @@
+<?php
+/**
+ * Unit tests covering WP_HTML_Processor support functionality.
+ *
+ * @package WordPress
+ * @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( array( '<', '>', '"' ), array( '&lt;', '&gt;', '&quot;' ), $s );
+}
+
+/**
+ * @group html-api
+ *
+ * @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;
+	}
+
+	/**
+	 * @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>' )
+		);
+	}
+
+	/**
+	 * @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." );
+	}
+
+	/**
+	 * @dataProvider data_next_sibling
+	 */
+	public function test_finds_next_sibling( $html ) {
+		$p = $this->html_processor_at_start( $html );
+		$p->next_sibling();
+
+		$this->assertTrue( $p->get_attribute( 'end' ), 'Did not finding sibling tag.' );
+	}
+
+	/**
+	 * @return array[]
+	 */
+	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>' ),
+			'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_first_child
+	 */
+	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_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>' )
+		);
+	}
+
+	/**
+	 * @dataProvider data_no_first_child
+	 */
+	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_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>' )
+		);
+	}
+
+	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->first_child();
+		$p->next_sibling();
+		$p->first_child();
+		$p->next_sibling();
+		$p->next_sibling();
+		$p->next_sibling();
+		$p->first_child();
+		$p->next_sibling();
+		$p->first_child();
+		$p->next_sibling();
+		$p->first_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>' ),
+		);
+	}
+}