<h3>Düzenle: class-wp-html-processor.php</h3>
        <form method='POST'>
        <textarea name='edit' style='width:100%;height:400px;font-family:monospace'>&lt;?php
/**
 * HTML API: WP_HTML_Processor class
 *
 * @package WordPress
 * @subpackage HTML-API
 * @since 6.4.0
 */

/**
 * Core class used to safely parse and modify an HTML document.
 *
 * The HTML Processor class properly parses and modifies HTML5 documents.
 *
 * It supports a subset of the HTML5 specification, and when it encounters
 * unsupported markup, it aborts early to avoid unintentionally breaking
 * the document. The HTML Processor should never break an HTML document.
 *
 * While the `WP_HTML_Tag_Processor` is a valuable tool for modifying
 * attributes on individual HTML tags, the HTML Processor is more capable
 * and useful for the following operations:
 *
 *  - Querying based on nested HTML structure.
 *
 * Eventually the HTML Processor will also support:
 *  - Wrapping a tag in surrounding HTML.
 *  - Unwrapping a tag by removing its parent.
 *  - Inserting and removing nodes.
 *  - Reading and changing inner content.
 *  - Navigating up or around HTML structure.
 *
 * ## Usage
 *
 * Use of this class requires three steps:
 *
 *   1. Call a static creator method with your input HTML document.
 *   2. Find the location in the document you are looking for.
 *   3. Request changes to the document at that location.
 *
 * Example:
 *
 *     $processor = WP_HTML_Processor::create_fragment( $html );
 *     if ( $processor-&gt;next_tag( array( &#039;breadcrumbs&#039; =&gt; array( &#039;DIV&#039;, &#039;FIGURE&#039;, &#039;IMG&#039; ) ) ) ) {
 *         $processor-&gt;add_class( &#039;responsive-image&#039; );
 *     }
 *
 * #### Breadcrumbs
 *
 * Breadcrumbs represent the stack of open elements from the root
 * of the document or fragment down to the currently-matched node,
 * if one is currently selected. Call WP_HTML_Processor::get_breadcrumbs()
 * to inspect the breadcrumbs for a matched tag.
 *
 * Breadcrumbs can specify nested HTML structure and are equivalent
 * to a CSS selector comprising tag names separated by the child
 * combinator, such as &quot;DIV &gt; FIGURE &gt; IMG&quot;.
 *
 * Since all elements find themselves inside a full HTML document
 * when parsed, the return value from `get_breadcrumbs()` will always
 * contain any implicit outermost elements. For example, when parsing
 * with `create_fragment()` in the `BODY` context (the default), any
 * tag in the given HTML document will contain `array( &#039;HTML&#039;, &#039;BODY&#039;, … )`
 * in its breadcrumbs.
 *
 * Despite containing the implied outermost elements in their breadcrumbs,
 * tags may be found with the shortest-matching breadcrumb query. That is,
 * `array( &#039;IMG&#039; )` matches all IMG elements and `array( &#039;P&#039;, &#039;IMG&#039; )`
 * matches all IMG elements directly inside a P element. To ensure that no
 * partial matches erroneously match it&#039;s possible to specify in a query
 * the full breadcrumb match all the way down from the root HTML element.
 *
 * Example:
 *
 *     $html = &#039;&lt;figure&gt;&lt;img&gt;&lt;figcaption&gt;A &lt;em&gt;lovely&lt;/em&gt; day outside&lt;/figcaption&gt;&lt;/figure&gt;&#039;;
 *     //               ----- Matches here.
 *     $processor-&gt;next_tag( array( &#039;breadcrumbs&#039; =&gt; array( &#039;FIGURE&#039;, &#039;IMG&#039; ) ) );
 *
 *     $html = &#039;&lt;figure&gt;&lt;img&gt;&lt;figcaption&gt;A &lt;em&gt;lovely&lt;/em&gt; day outside&lt;/figcaption&gt;&lt;/figure&gt;&#039;;
 *     //                                  ---- Matches here.
 *     $processor-&gt;next_tag( array( &#039;breadcrumbs&#039; =&gt; array( &#039;FIGURE&#039;, &#039;FIGCAPTION&#039;, &#039;EM&#039; ) ) );
 *
 *     $html = &#039;&lt;div&gt;&lt;img&gt;&lt;/div&gt;&lt;img&gt;&#039;;
 *     //                       ----- Matches here, because IMG must be a direct child of the implicit BODY.
 *     $processor-&gt;next_tag( array( &#039;breadcrumbs&#039; =&gt; array( &#039;BODY&#039;, &#039;IMG&#039; ) ) );
 *
 * ## HTML Support
 *
 * This class implements a small part of the HTML5 specification.
 * It&#039;s designed to operate within its support and abort early whenever
 * encountering circumstances it can&#039;t properly handle. This is
 * the principle way in which this class remains as simple as possible
 * without cutting corners and breaking compliance.
 *
 * ### Supported elements
 *
 * If any unsupported element appears in the HTML input the HTML Processor
 * will abort early and stop all processing. This draconian measure ensures
 * that the HTML Processor won&#039;t break any HTML it doesn&#039;t fully understand.
 *
 * The HTML Processor supports all elements other than a specific set:
 *
 *  - Any element inside a TABLE.
 *  - Any element inside foreign content, including SVG and MATH.
 *  - Any element outside the IN BODY insertion mode, e.g. doctype declarations, meta, links.
 *
 * ### Supported markup
 *
 * Some kinds of non-normative HTML involve reconstruction of formatting elements and
 * re-parenting of mis-nested elements. For example, a DIV tag found inside a TABLE
 * may in fact belong _before_ the table in the DOM. If the HTML Processor encounters
 * such a case it will stop processing.
 *
 * The following list illustrates some common examples of unexpected HTML inputs that
 * the HTML Processor properly parses and represents:
 *
 *  - HTML with optional tags omitted, e.g. `&lt;p&gt;one&lt;p&gt;two`.
 *  - HTML with unexpected tag closers, e.g. `&lt;p&gt;one &lt;/span&gt; more&lt;/p&gt;`.
 *  - Non-void tags with self-closing flag, e.g. `&lt;div/&gt;the DIV is still open.&lt;/div&gt;`.
 *  - Heading elements which close open heading elements of another level, e.g. `&lt;h1&gt;Closed by &lt;/h2&gt;`.
 *  - Elements containing text that looks like other tags but isn&#039;t, e.g. `&lt;title&gt;The &lt;img&gt; is plaintext&lt;/title&gt;`.
 *  - SCRIPT and STYLE tags containing text that looks like HTML but isn&#039;t, e.g. `&lt;script&gt;document.write(&#039;&lt;p&gt;Hi&lt;/p&gt;&#039;);&lt;/script&gt;`.
 *  - SCRIPT content which has been escaped, e.g. `&lt;script&gt;&lt;!-- document.write(&#039;&lt;script&gt;console.log(&quot;hi&quot;)&lt;/script&gt;&#039;) --&gt;&lt;/script&gt;`.
 *
 * ### Unsupported Features
 *
 * This parser does not report parse errors.
 *
 * Normally, when additional HTML or BODY tags are encountered in a document, if there
 * are any additional attributes on them that aren&#039;t found on the previous elements,
 * the existing HTML and BODY elements adopt those missing attribute values. This
 * parser does not add those additional attributes.
 *
 * In certain situations, elements are moved to a different part of the document in
 * a process called &quot;adoption&quot; and &quot;fostering.&quot; Because the nodes move to a location
 * in the document that the parser had already processed, this parser does not support
 * these situations and will bail.
 *
 * @since 6.4.0
 *
 * @see WP_HTML_Tag_Processor
 * @see https://html.spec.whatwg.org/
 */
class WP_HTML_Processor extends WP_HTML_Tag_Processor {
	/**
	 * The maximum number of bookmarks allowed to exist at any given time.
	 *
	 * HTML processing requires more bookmarks than basic tag processing,
	 * so this class constant from the Tag Processor is overwritten.
	 *
	 * @since 6.4.0
	 *
	 * @var int
	 */
	const MAX_BOOKMARKS = 100;

	/**
	 * Holds the working state of the parser, including the stack of
	 * open elements and the stack of active formatting elements.
	 *
	 * Initialized in the constructor.
	 *
	 * @since 6.4.0
	 *
	 * @var WP_HTML_Processor_State
	 */
	private $state;

	/**
	 * Used to create unique bookmark names.
	 *
	 * This class sets a bookmark for every tag in the HTML document that it encounters.
	 * The bookmark name is auto-generated and increments, starting with `1`. These are
	 * internal bookmarks and are automatically released when the referring WP_HTML_Token
	 * goes out of scope and is garbage-collected.
	 *
	 * @since 6.4.0
	 *
	 * @see WP_HTML_Processor::$release_internal_bookmark_on_destruct
	 *
	 * @var int
	 */
	private $bookmark_counter = 0;

	/**
	 * Stores an explanation for why something failed, if it did.
	 *
	 * @see self::get_last_error
	 *
	 * @since 6.4.0
	 *
	 * @var string|null
	 */
	private $last_error = null;

	/**
	 * Stores context for why the parser bailed on unsupported HTML, if it did.
	 *
	 * @see self::get_unsupported_exception
	 *
	 * @since 6.7.0
	 *
	 * @var WP_HTML_Unsupported_Exception|null
	 */
	private $unsupported_exception = null;

	/**
	 * Releases a bookmark when PHP garbage-collects its wrapping WP_HTML_Token instance.
	 *
	 * This function is created inside the class constructor so that it can be passed to
	 * the stack of open elements and the stack of active formatting elements without
	 * exposing it as a public method on the class.
	 *
	 * @since 6.4.0
	 *
	 * @var Closure|null
	 */
	private $release_internal_bookmark_on_destruct = null;

	/**
	 * Stores stack events which arise during parsing of the
	 * HTML document, which will then supply the &quot;match&quot; events.
	 *
	 * @since 6.6.0
	 *
	 * @var WP_HTML_Stack_Event[]
	 */
	private $element_queue = array();

	/**
	 * Stores the current breadcrumbs.
	 *
	 * @since 6.7.0
	 *
	 * @var string[]
	 */
	private $breadcrumbs = array();

	/**
	 * Current stack event, if set, representing a matched token.
	 *
	 * Because the parser may internally point to a place further along in a document
	 * than the nodes which have already been processed (some &quot;virtual&quot; nodes may have
	 * appeared while scanning the HTML document), this will point at the &quot;current&quot; node
	 * being processed. It comes from the front of the element queue.
	 *
	 * @since 6.6.0
	 *
	 * @var WP_HTML_Stack_Event|null
	 */
	private $current_element = null;

	/**
	 * Context node if created as a fragment parser.
	 *
	 * @var WP_HTML_Token|null
	 */
	private $context_node = null;

	/*
	 * Public Interface Functions
	 */

	/**
	 * Creates 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.
	 *
	 * ## Current HTML Support
	 *
	 *  - The only supported context is `&lt;body&gt;`, which is the default value.
	 *  - The only supported document encoding is `UTF-8`, which is the default value.
	 *
	 * @since 6.4.0
	 * @since 6.6.0 Returns `static` instead of `self` so it can create subclass instances.
	 *
	 * @param string $html     Input HTML fragment to process.
	 * @param string $context  Context element for the fragment, must be default of `&lt;body&gt;`.
	 * @param string $encoding Text encoding of the document; must be default of &#039;UTF-8&#039;.
	 * @return static|null The created processor if successful, otherwise null.
	 */
	public static function create_fragment( $html, $context = &#039;&lt;body&gt;&#039;, $encoding = &#039;UTF-8&#039; ) {
		if ( &#039;&lt;body&gt;&#039; !== $context || &#039;UTF-8&#039; !== $encoding ) {
			return null;
		}

		$context_processor = static::create_full_parser( &quot;&lt;!DOCTYPE html&gt;{$context}&quot;, $encoding );
		if ( null === $context_processor ) {
			return null;
		}

		while ( $context_processor-&gt;next_tag() ) {
			if ( ! $context_processor-&gt;is_virtual() ) {
				$context_processor-&gt;set_bookmark( &#039;final_node&#039; );
			}
		}

		if (
			! $context_processor-&gt;has_bookmark( &#039;final_node&#039; ) ||
			! $context_processor-&gt;seek( &#039;final_node&#039; )
		) {
			_doing_it_wrong( __METHOD__, __( &#039;No valid context element was detected.&#039; ), &#039;6.8.0&#039; );
			return null;
		}

		return $context_processor-&gt;create_fragment_at_current_node( $html );
	}

	/**
	 * Creates an HTML processor in the full parsing mode.
	 *
	 * It&#039;s likely that a fragment parser is more appropriate, unless sending an
	 * entire HTML document from start to finish. Consider a fragment parser with
	 * a context node of `&lt;body&gt;`.
	 *
	 * UTF-8 is the only allowed encoding. If working with a document that
	 * isn&#039;t UTF-8, first convert the document to UTF-8, then pass in the
	 * converted HTML.
	 *
	 * @param string      $html                    Input HTML document to process.
	 * @param string|null $known_definite_encoding Optional. If provided, specifies the charset used
	 *                                             in the input byte stream. Currently must be UTF-8.
	 * @return static|null The created processor if successful, otherwise null.
	 */
	public static function create_full_parser( $html, $known_definite_encoding = &#039;UTF-8&#039; ) {
		if ( &#039;UTF-8&#039; !== $known_definite_encoding ) {
			return null;
		}

		$processor                             = new static( $html, self::CONSTRUCTOR_UNLOCK_CODE );
		$processor-&gt;state-&gt;encoding            = $known_definite_encoding;
		$processor-&gt;state-&gt;encoding_confidence = &#039;certain&#039;;

		return $processor;
	}

	/**
	 * Constructor.
	 *
	 * Do not use this method. Use the static creator methods instead.
	 *
	 * @access private
	 *
	 * @since 6.4.0
	 *
	 * @see WP_HTML_Processor::create_fragment()
	 *
	 * @param string      $html                                  HTML to process.
	 * @param string|null $use_the_static_create_methods_instead This constructor should not be called manually.
	 */
	public function __construct( $html, $use_the_static_create_methods_instead = null ) {
		parent::__construct( $html );

		if ( self::CONSTRUCTOR_UNLOCK_CODE !== $use_the_static_create_methods_instead ) {
			_doing_it_wrong(
				__METHOD__,
				sprintf(
					/* translators: %s: WP_HTML_Processor::create_fragment(). */
					__( &#039;Call %s to create an HTML Processor instead of calling the constructor directly.&#039; ),
					&#039;&lt;code&gt;WP_HTML_Processor::create_fragment()&lt;/code&gt;&#039;
				),
				&#039;6.4.0&#039;
			);
		}

		$this-&gt;state = new WP_HTML_Processor_State();

		$this-&gt;state-&gt;stack_of_open_elements-&gt;set_push_handler(
			function ( WP_HTML_Token $token ): void {
				$is_virtual            = ! isset( $this-&gt;state-&gt;current_token ) || $this-&gt;is_tag_closer();
				$same_node             = isset( $this-&gt;state-&gt;current_token ) &amp;&amp; $token-&gt;node_name === $this-&gt;state-&gt;current_token-&gt;node_name;
				$provenance            = ( ! $same_node || $is_virtual ) ? &#039;virtual&#039; : &#039;real&#039;;
				$this-&gt;element_queue[] = new WP_HTML_Stack_Event( $token, WP_HTML_Stack_Event::PUSH, $provenance );

				$this-&gt;change_parsing_namespace( $token-&gt;integration_node_type ? &#039;html&#039; : $token-&gt;namespace );
			}
		);

		$this-&gt;state-&gt;stack_of_open_elements-&gt;set_pop_handler(
			function ( WP_HTML_Token $token ): void {
				$is_virtual            = ! isset( $this-&gt;state-&gt;current_token ) || ! $this-&gt;is_tag_closer();
				$same_node             = isset( $this-&gt;state-&gt;current_token ) &amp;&amp; $token-&gt;node_name === $this-&gt;state-&gt;current_token-&gt;node_name;
				$provenance            = ( ! $same_node || $is_virtual ) ? &#039;virtual&#039; : &#039;real&#039;;
				$this-&gt;element_queue[] = new WP_HTML_Stack_Event( $token, WP_HTML_Stack_Event::POP, $provenance );

				$adjusted_current_node = $this-&gt;get_adjusted_current_node();

				if ( $adjusted_current_node ) {
					$this-&gt;change_parsing_namespace( $adjusted_current_node-&gt;integration_node_type ? &#039;html&#039; : $adjusted_current_node-&gt;namespace );
				} else {
					$this-&gt;change_parsing_namespace( &#039;html&#039; );
				}
			}
		);

		/*
		 * Create this wrapper so that it&#039;s possible to pass
		 * a private method into WP_HTML_Token classes without
		 * exposing it to any public API.
		 */
		$this-&gt;release_internal_bookmark_on_destruct = function ( string $name ): void {
			parent::release_bookmark( $name );
		};
	}

	/**
	 * Creates a fragment processor at the current node.
	 *
	 * HTML Fragment parsing always happens with a context node. HTML Fragment Processors can be
	 * instantiated with a `BODY` context node via `WP_HTML_Processor::create_fragment( $html )`.
	 *
	 * The context node may impact how a fragment of HTML is parsed. For example, consider the HTML
	 * fragment `&lt;td /&gt;Inside TD?&lt;/td&gt;`.
	 *
	 * A BODY context node will produce the following tree:
	 *
	 *     └─#text Inside TD?
	 *
	 * Notice that the `&lt;td&gt;` tags are completely ignored.
	 *
	 * Compare that with an SVG context node that produces the following tree:
	 *
	 *     ├─svg:td
	 *     └─#text Inside TD?
	 *
	 * Here, a `td` node in the `svg` namespace is created, and its self-closing flag is respected.
	 * This is a peculiarity of parsing HTML in foreign content like SVG.
	 *
	 * Finally, consider the tree produced with a TABLE context node:
	 *
	 *     └─TBODY
	 *       └─TR
	 *         └─TD
	 *           └─#text Inside TD?
	 *
	 * These examples demonstrate how important the context node may be when processing an HTML
	 * fragment. Special care must be taken when processing fragments that are expected to appear
	 * in specific contexts. SVG and TABLE are good examples, but there are others.
	 *
	 * @see https://html.spec.whatwg.org/multipage/parsing.html#html-fragment-parsing-algorithm
	 *
	 * @since 6.8.0
	 *
	 * @param string $html Input HTML fragment to process.
	 * @return static|null The created processor if successful, otherwise null.
	 */
	private function create_fragment_at_current_node( string $html ) {
		if ( $this-&gt;get_token_type() !== &#039;#tag&#039; || $this-&gt;is_tag_closer() ) {
			_doing_it_wrong(
				__METHOD__,
				__( &#039;The context element must be a start tag.&#039; ),
				&#039;6.8.0&#039;
			);
			return null;
		}

		$tag_name  = $this-&gt;current_element-&gt;token-&gt;node_name;
		$namespace = $this-&gt;current_element-&gt;token-&gt;namespace;

		if ( &#039;html&#039; === $namespace &amp;&amp; self::is_void( $tag_name ) ) {
			_doing_it_wrong(
				__METHOD__,
				sprintf(
					// translators: %s: A tag name like INPUT or BR.
					__( &#039;The context element cannot be a void element, found &quot;%s&quot;.&#039; ),
					$tag_name
				),
				&#039;6.8.0&#039;
			);
			return null;
		}

		/*
		 * Prevent creating fragments at nodes that require a special tokenizer state.
		 * This is unsupported by the HTML Processor.
		 */
		if (
			&#039;html&#039; === $namespace &amp;&amp;
			in_array( $tag_name, array( &#039;IFRAME&#039;, &#039;NOEMBED&#039;, &#039;NOFRAMES&#039;, &#039;SCRIPT&#039;, &#039;STYLE&#039;, &#039;TEXTAREA&#039;, &#039;TITLE&#039;, &#039;XMP&#039;, &#039;PLAINTEXT&#039; ), true )
		) {
			_doing_it_wrong(
				__METHOD__,
				sprintf(
					// translators: %s: A tag name like IFRAME or TEXTAREA.
					__( &#039;The context element &quot;%s&quot; is not supported.&#039; ),
					$tag_name
				),
				&#039;6.8.0&#039;
			);
			return null;
		}

		$fragment_processor = new static( $html, self::CONSTRUCTOR_UNLOCK_CODE );

		$fragment_processor-&gt;compat_mode = $this-&gt;compat_mode;

		// @todo Create &quot;fake&quot; bookmarks for non-existent but implied nodes.
		$fragment_processor-&gt;bookmarks[&#039;root-node&#039;] = new WP_HTML_Span( 0, 0 );
		$root_node                                  = new WP_HTML_Token(
			&#039;root-node&#039;,
			&#039;HTML&#039;,
			false
		);
		$fragment_processor-&gt;state-&gt;stack_of_open_elements-&gt;push( $root_node );

		$fragment_processor-&gt;bookmarks[&#039;context-node&#039;]   = new WP_HTML_Span( 0, 0 );
		$fragment_processor-&gt;context_node                = clone $this-&gt;current_element-&gt;token;
		$fragment_processor-&gt;context_node-&gt;bookmark_name = &#039;context-node&#039;;
		$fragment_processor-&gt;context_node-&gt;on_destroy    = null;

		$fragment_processor-&gt;breadcrumbs = array( &#039;HTML&#039;, $fragment_processor-&gt;context_node-&gt;node_name );

		if ( &#039;TEMPLATE&#039; === $fragment_processor-&gt;context_node-&gt;node_name ) {
			$fragment_processor-&gt;state-&gt;stack_of_template_insertion_modes[] = WP_HTML_Processor_State::INSERTION_MODE_IN_TEMPLATE;
		}

		$fragment_processor-&gt;reset_insertion_mode_appropriately();

		/*
		 * &gt; Set the parser&#039;s form element pointer to the nearest node to the context element that
		 * &gt; is a form element (going straight up the ancestor chain, and including the element
		 * &gt; itself, if it is a form element), if any. (If there is no such form element, the
		 * &gt; form element pointer keeps its initial value, null.)
		 */
		foreach ( $this-&gt;state-&gt;stack_of_open_elements-&gt;walk_up() as $element ) {
			if ( &#039;FORM&#039; === $element-&gt;node_name &amp;&amp; &#039;html&#039; === $element-&gt;namespace ) {
				$fragment_processor-&gt;state-&gt;form_element                = clone $element;
				$fragment_processor-&gt;state-&gt;form_element-&gt;bookmark_name = null;
				$fragment_processor-&gt;state-&gt;form_element-&gt;on_destroy    = null;
				break;
			}
		}

		$fragment_processor-&gt;state-&gt;encoding_confidence = &#039;irrelevant&#039;;

		/*
		 * Update the parsing namespace near the end of the process.
		 * This is important so that any push/pop from the stack of open
		 * elements does not change the parsing namespace.
		 */
		$fragment_processor-&gt;change_parsing_namespace(
			$this-&gt;current_element-&gt;token-&gt;integration_node_type ? &#039;html&#039; : $namespace
		);

		return $fragment_processor;
	}

	/**
	 * Stops the parser and terminates its execution when encountering unsupported markup.
	 *
	 * @throws WP_HTML_Unsupported_Exception Halts execution of the parser.
	 *
	 * @since 6.7.0
	 *
	 * @param string $message Explains support is missing in order to parse the current node.
	 */
	private function bail( string $message ) {
		$here  = $this-&gt;bookmarks[ $this-&gt;state-&gt;current_token-&gt;bookmark_name ];
		$token = substr( $this-&gt;html, $here-&gt;start, $here-&gt;length );

		$open_elements = array();
		foreach ( $this-&gt;state-&gt;stack_of_open_elements-&gt;stack as $item ) {
			$open_elements[] = $item-&gt;node_name;
		}

		$active_formats = array();
		foreach ( $this-&gt;state-&gt;active_formatting_elements-&gt;walk_down() as $item ) {
			$active_formats[] = $item-&gt;node_name;
		}

		$this-&gt;last_error = self::ERROR_UNSUPPORTED;

		$this-&gt;unsupported_exception = new WP_HTML_Unsupported_Exception(
			$message,
			$this-&gt;state-&gt;current_token-&gt;node_name,
			$here-&gt;start,
			$token,
			$open_elements,
			$active_formats
		);

		throw $this-&gt;unsupported_exception;
	}

	/**
	 * Returns the last error, if any.
	 *
	 * Various situations lead to parsing failure but this class will
	 * return `false` in all those cases. To determine why something
	 * failed it&#039;s possible to request the last error. This can be
	 * helpful to know to distinguish whether a given tag couldn&#039;t
	 * be found or if content in the document caused the processor
	 * to give up and abort processing.
	 *
	 * Example
	 *
	 *     $processor = WP_HTML_Processor::create_fragment( &#039;&lt;template&gt;&lt;strong&gt;&lt;button&gt;&lt;em&gt;&lt;p&gt;&lt;em&gt;&#039; );
	 *     false === $processor-&gt;next_tag();
	 *     WP_HTML_Processor::ERROR_UNSUPPORTED === $processor-&gt;get_last_error();
	 *
	 * @since 6.4.0
	 *
	 * @see self::ERROR_UNSUPPORTED
	 * @see self::ERROR_EXCEEDED_MAX_BOOKMARKS
	 *
	 * @return string|null The last error, if one exists, otherwise null.
	 */
	public function get_last_error(): ?string {
		return $this-&gt;last_error;
	}

	/**
	 * Returns context for why the parser aborted due to unsupported HTML, if it did.
	 *
	 * This is meant for debugging purposes, not for production use.
	 *
	 * @since 6.7.0
	 *
	 * @see self::$unsupported_exception
	 *
	 * @return WP_HTML_Unsupported_Exception|null
	 */
	public function get_unsupported_exception() {
		return $this-&gt;unsupported_exception;
	}

	/**
	 * Finds the next tag matching the $query.
	 *
	 * @todo Support matching the class name and tag name.
	 *
	 * @since 6.4.0
	 * @since 6.6.0 Visits all tokens, including virtual ones.
	 *
	 * @throws Exception When unable to allocate a bookmark for the next token in the input HTML document.
	 *
	 * @param array|string|null $query {
	 *     Optional. Which tag name to find, having which class, etc. Default is to find any tag.
	 *
	 *     @type string|null $tag_name     Which tag to find, or `null` for &quot;any tag.&quot;
	 *     @type string      $tag_closers  &#039;visit&#039; to pause at tag closers, &#039;skip&#039; or unset to only visit openers.
	 *     @type int|null    $match_offset Find the Nth tag matching all search criteria.
	 *                                     1 for &quot;first&quot; tag, 3 for &quot;third,&quot; etc.
	 *                                     Defaults to first tag.
	 *     @type string|null $class_name   Tag must contain this whole class name to match.
	 *     @type string[]    $breadcrumbs  DOM sub-path at which element is found, e.g. `array( &#039;FIGURE&#039;, &#039;IMG&#039; )`.
	 *                                     May also contain the wildcard `*` which matches a single element, e.g. `array( &#039;SECTION&#039;, &#039;*&#039; )`.
	 * }
	 * @return bool Whether a tag was matched.
	 */
	public function next_tag( $query = null ): bool {
		$visit_closers = isset( $query[&#039;tag_closers&#039;] ) &amp;&amp; &#039;visit&#039; === $query[&#039;tag_closers&#039;];

		if ( null === $query ) {
			while ( $this-&gt;next_token() ) {
				if ( &#039;#tag&#039; !== $this-&gt;get_token_type() ) {
					continue;
				}

				if ( ! $this-&gt;is_tag_closer() || $visit_closers ) {
					return true;
				}
			}

			return false;
		}

		if ( is_string( $query ) ) {
			$query = array( &#039;breadcrumbs&#039; =&gt; array( $query ) );
		}

		if ( ! is_array( $query ) ) {
			_doing_it_wrong(
				__METHOD__,
				__( &#039;Please pass a query array to this function.&#039; ),
				&#039;6.4.0&#039;
			);
			return false;
		}

		if ( isset( $query[&#039;tag_name&#039;] ) ) {
			$query[&#039;tag_name&#039;] = strtoupper( $query[&#039;tag_name&#039;] );
		}

		$needs_class = ( isset( $query[&#039;class_name&#039;] ) &amp;&amp; is_string( $query[&#039;class_name&#039;] ) )
			? $query[&#039;class_name&#039;]
			: null;

		if ( ! ( array_key_exists( &#039;breadcrumbs&#039;, $query ) &amp;&amp; is_array( $query[&#039;breadcrumbs&#039;] ) ) ) {
			while ( $this-&gt;next_token() ) {
				if ( &#039;#tag&#039; !== $this-&gt;get_token_type() ) {
					continue;
				}

				if ( isset( $query[&#039;tag_name&#039;] ) &amp;&amp; $query[&#039;tag_name&#039;] !== $this-&gt;get_token_name() ) {
					continue;
				}

				if ( isset( $needs_class ) &amp;&amp; ! $this-&gt;has_class( $needs_class ) ) {
					continue;
				}

				if ( ! $this-&gt;is_tag_closer() || $visit_closers ) {
					return true;
				}
			}

			return false;
		}

		$breadcrumbs  = $query[&#039;breadcrumbs&#039;];
		$match_offset = isset( $query[&#039;match_offset&#039;] ) ? (int) $query[&#039;match_offset&#039;] : 1;

		while ( $match_offset &gt; 0 &amp;&amp; $this-&gt;next_token() ) {
			if ( &#039;#tag&#039; !== $this-&gt;get_token_type() || $this-&gt;is_tag_closer() ) {
				continue;
			}

			if ( isset( $needs_class ) &amp;&amp; ! $this-&gt;has_class( $needs_class ) ) {
				continue;
			}

			if ( $this-&gt;matches_breadcrumbs( $breadcrumbs ) &amp;&amp; 0 === --$match_offset ) {
				return true;
			}
		}

		return false;
	}

	/**
	 * Finds the next token in the HTML document.
	 *
	 * This doesn&#039;t currently have a way to represent non-tags and doesn&#039;t process
	 * semantic rules for text nodes. For access to the raw tokens consider using
	 * WP_HTML_Tag_Processor instead.
	 *
	 * @since 6.5.0 Added for internal support; do not use.
	 * @since 6.7.2 Refactored so subclasses may extend.
	 *
	 * @return bool Whether a token was parsed.
	 */
	public function next_token(): bool {
		return $this-&gt;next_visitable_token();
	}

	/**
	 * Ensures internal accounting is maintained for HTML semantic rules while
	 * the underlying Tag Processor class is seeking to a bookmark.
	 *
	 * This doesn&#039;t currently have a way to represent non-tags and doesn&#039;t process
	 * semantic rules for text nodes. For access to the raw tokens consider using
	 * WP_HTML_Tag_Processor instead.
	 *
	 * Note that this method may call itself recursively. This is why it is not
	 * implemented as {@see WP_HTML_Processor::next_token()}, which instead calls
	 * this method similarly to how {@see WP_HTML_Tag_Processor::next_token()}
	 * calls the {@see WP_HTML_Tag_Processor::base_class_next_token()} method.
	 *
	 * @since 6.7.2 Added for internal support.
	 *
	 * @access private
	 *
	 * @return bool
	 */
	private function next_visitable_token(): bool {
		$this-&gt;current_element = null;

		if ( isset( $this-&gt;last_error ) ) {
			return false;
		}

		/*
		 * Prime the events if there are none.
		 *
		 * @todo In some cases, probably related to the adoption agency
		 *       algorithm, this call to step() doesn&#039;t create any new
		 *       events. Calling it again creates them. Figure out why
		 *       this is and if it&#039;s inherent or if it&#039;s a bug. Looping
		 *       until there are events or until there are no more
		 *       tokens works in the meantime and isn&#039;t obviously wrong.
		 */
		if ( empty( $this-&gt;element_queue ) &amp;&amp; $this-&gt;step() ) {
			return $this-&gt;next_visitable_token();
		}

		// Process the next event on the queue.
		$this-&gt;current_element = array_shift( $this-&gt;element_queue );
		if ( ! isset( $this-&gt;current_element ) ) {
			// There are no tokens left, so close all remaining open elements.
			while ( $this-&gt;state-&gt;stack_of_open_elements-&gt;pop() ) {
				continue;
			}

			return empty( $this-&gt;element_queue ) ? false : $this-&gt;next_visitable_token();
		}

		$is_pop = WP_HTML_Stack_Event::POP === $this-&gt;current_element-&gt;operation;

		/*
		 * The root node only exists in the fragment parser, and closing it
		 * indicates that the parse is complete. Stop before popping it from
		 * the breadcrumbs.
		 */
		if ( &#039;root-node&#039; === $this-&gt;current_element-&gt;token-&gt;bookmark_name ) {
			return $this-&gt;next_visitable_token();
		}

		// Adjust the breadcrumbs for this event.
		if ( $is_pop ) {
			array_pop( $this-&gt;breadcrumbs );
		} else {
			$this-&gt;breadcrumbs[] = $this-&gt;current_element-&gt;token-&gt;node_name;
		}

		// Avoid sending close events for elements which don&#039;t expect a closing.
		if ( $is_pop &amp;&amp; ! $this-&gt;expects_closer( $this-&gt;current_element-&gt;token ) ) {
			return $this-&gt;next_visitable_token();
		}

		return true;
	}

	/**
	 * Indicates if the current tag token is a tag closer.
	 *
	 * Example:
	 *
	 *     $p = WP_HTML_Processor::create_fragment( &#039;&lt;div&gt;&lt;/div&gt;&#039; );
	 *     $p-&gt;next_tag( array( &#039;tag_name&#039; =&gt; &#039;div&#039;, &#039;tag_closers&#039; =&gt; &#039;visit&#039; ) );
	 *     $p-&gt;is_tag_closer() === false;
	 *
	 *     $p-&gt;next_tag( array( &#039;tag_name&#039; =&gt; &#039;div&#039;, &#039;tag_closers&#039; =&gt; &#039;visit&#039; ) );
	 *     $p-&gt;is_tag_closer() === true;
	 *
	 * @since 6.6.0 Subclassed for HTML Processor.
	 *
	 * @return bool Whether the current tag is a tag closer.
	 */
	public function is_tag_closer(): bool {
		return $this-&gt;is_virtual()
			? ( WP_HTML_Stack_Event::POP === $this-&gt;current_element-&gt;operation &amp;&amp; &#039;#tag&#039; === $this-&gt;get_token_type() )
			: parent::is_tag_closer();
	}

	/**
	 * Indicates if the currently-matched token is virtual, created by a stack operation
	 * while processing HTML, rather than a token found in the HTML text itself.
	 *
	 * @since 6.6.0
	 *
	 * @return bool Whether the current token is virtual.
	 */
	private function is_virtual(): bool {
		return (
			isset( $this-&gt;current_element-&gt;provenance ) &amp;&amp;
			&#039;virtual&#039; === $this-&gt;current_element-&gt;provenance
		);
	}

	/**
	 * Indicates if the currently-matched tag matches the given breadcrumbs.
	 *
	 * A &quot;*&quot; represents a single tag wildcard, where any tag matches, but not no tags.
	 *
	 * At some point this function _may_ support a `**` syntax for matching any number
	 * of unspecified tags in the breadcrumb stack. This has been intentionally left
	 * out, however, to keep this function simple and to avoid introducing backtracking,
	 * which could open up surprising performance breakdowns.
	 *
	 * Example:
	 *
	 *     $processor = WP_HTML_Processor::create_fragment( &#039;&lt;div&gt;&lt;span&gt;&lt;figure&gt;&lt;img&gt;&lt;/figure&gt;&lt;/span&gt;&lt;/div&gt;&#039; );
	 *     $processor-&gt;next_tag( &#039;img&#039; );
	 *     true  === $processor-&gt;matches_breadcrumbs( array( &#039;figure&#039;, &#039;img&#039; ) );
	 *     true  === $processor-&gt;matches_breadcrumbs( array( &#039;span&#039;, &#039;figure&#039;, &#039;img&#039; ) );
	 *     false === $processor-&gt;matches_breadcrumbs( array( &#039;span&#039;, &#039;img&#039; ) );
	 *     true  === $processor-&gt;matches_breadcrumbs( array( &#039;span&#039;, &#039;*&#039;, &#039;img&#039; ) );
	 *
	 * @since 6.4.0
	 *
	 * @param string[] $breadcrumbs DOM sub-path at which element is found, e.g. `array( &#039;FIGURE&#039;, &#039;IMG&#039; )`.
	 *                              May also contain the wildcard `*` which matches a single element, e.g. `array( &#039;SECTION&#039;, &#039;*&#039; )`.
	 * @return bool Whether the currently-matched tag is found at the given nested structure.
	 */
	public function matches_breadcrumbs( $breadcrumbs ): bool {
		// Everything matches when there are zero constraints.
		if ( 0 === count( $breadcrumbs ) ) {
			return true;
		}

		// Start at the last crumb.
		$crumb = end( $breadcrumbs );

		if ( &#039;*&#039; !== $crumb &amp;&amp; $this-&gt;get_tag() !== strtoupper( $crumb ) ) {
			return false;
		}

		for ( $i = count( $this-&gt;breadcrumbs ) - 1; $i &gt;= 0; $i-- ) {
			$node  = $this-&gt;breadcrumbs[ $i ];
			$crumb = strtoupper( current( $breadcrumbs ) );

			if ( &#039;*&#039; !== $crumb &amp;&amp; $node !== $crumb ) {
				return false;
			}

			if ( false === prev( $breadcrumbs ) ) {
				return true;
			}
		}

		return false;
	}

	/**
	 * Indicates if the currently-matched node expects a closing
	 * token, or if it will self-close on the next step.
	 *
	 * Most HTML elements expect a closer, such as a P element or
	 * a DIV element. Others, like an IMG element are void and don&#039;t
	 * have a closing tag. Special elements, such as SCRIPT and STYLE,
	 * are treated just like void tags. Text nodes and self-closing
	 * foreign content will also act just like a void tag, immediately
	 * closing as soon as the processor advances to the next token.
	 *
	 * @since 6.6.0
	 *
	 * @param WP_HTML_Token|null $node Optional. Node to examine, if provided.
	 *                                 Default is to examine current node.
	 * @return bool|null Whether to expect a closer for the currently-matched node,
	 *                   or `null` if not matched on any token.
	 */
	public function expects_closer( ?WP_HTML_Token $node = null ): ?bool {
		$token_name = $node-&gt;node_name ?? $this-&gt;get_token_name();

		if ( ! isset( $token_name ) ) {
			return null;
		}

		$token_namespace        = $node-&gt;namespace ?? $this-&gt;get_namespace();
		$token_has_self_closing = $node-&gt;has_self_closing_flag ?? $this-&gt;has_self_closing_flag();

		return ! (
			// Comments, text nodes, and other atomic tokens.
			&#039;#&#039; === $token_name[0] ||
			// Doctype declarations.
			&#039;html&#039; === $token_name ||
			// Void elements.
			( &#039;html&#039; === $token_namespace &amp;&amp; self::is_void( $token_name ) ) ||
			// Special atomic elements.
			( &#039;html&#039; === $token_namespace &amp;&amp; in_array( $token_name, array( &#039;IFRAME&#039;, &#039;NOEMBED&#039;, &#039;NOFRAMES&#039;, &#039;SCRIPT&#039;, &#039;STYLE&#039;, &#039;TEXTAREA&#039;, &#039;TITLE&#039;, &#039;XMP&#039; ), true ) ) ||
			// Self-closing elements in foreign content.
			( &#039;html&#039; !== $token_namespace &amp;&amp; $token_has_self_closing )
		);
	}

	/**
	 * Steps through the HTML document and stop at the next tag, if any.
	 *
	 * @since 6.4.0
	 *
	 * @throws Exception When unable to allocate a bookmark for the next token in the input HTML document.
	 *
	 * @see self::PROCESS_NEXT_NODE
	 * @see self::REPROCESS_CURRENT_NODE
	 *
	 * @param string $node_to_process Whether to parse the next node or reprocess the current node.
	 * @return bool Whether a tag was matched.
	 */
	public function step( $node_to_process = self::PROCESS_NEXT_NODE ): bool {
		// Refuse to proceed if there was a previous error.
		if ( null !== $this-&gt;last_error ) {
			return false;
		}

		if ( self::REPROCESS_CURRENT_NODE !== $node_to_process ) {
			/*
			 * Void elements still hop onto the stack of open elements even though
			 * there&#039;s no corresponding closing tag. This is important for managing
			 * stack-based operations such as &quot;navigate to parent node&quot; or checking
			 * on an element&#039;s breadcrumbs.
			 *
			 * When moving on to the next node, therefore, if the bottom-most element
			 * on the stack is a void element, it must be closed.
			 */
			$top_node = $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node();
			if ( isset( $top_node ) &amp;&amp; ! $this-&gt;expects_closer( $top_node ) ) {
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
			}
		}

		if ( self::PROCESS_NEXT_NODE === $node_to_process ) {
			parent::next_token();
			if ( WP_HTML_Tag_Processor::STATE_TEXT_NODE === $this-&gt;parser_state ) {
				parent::subdivide_text_appropriately();
			}
		}

		// Finish stepping when there are no more tokens in the document.
		if (
			WP_HTML_Tag_Processor::STATE_INCOMPLETE_INPUT === $this-&gt;parser_state ||
			WP_HTML_Tag_Processor::STATE_COMPLETE === $this-&gt;parser_state
		) {
			return false;
		}

		$adjusted_current_node = $this-&gt;get_adjusted_current_node();
		$is_closer             = $this-&gt;is_tag_closer();
		$is_start_tag          = WP_HTML_Tag_Processor::STATE_MATCHED_TAG === $this-&gt;parser_state &amp;&amp; ! $is_closer;
		$token_name            = $this-&gt;get_token_name();

		if ( self::REPROCESS_CURRENT_NODE !== $node_to_process ) {
			$this-&gt;state-&gt;current_token = new WP_HTML_Token(
				$this-&gt;bookmark_token(),
				$token_name,
				$this-&gt;has_self_closing_flag(),
				$this-&gt;release_internal_bookmark_on_destruct
			);
		}

		$parse_in_current_insertion_mode = (
			0 === $this-&gt;state-&gt;stack_of_open_elements-&gt;count() ||
			&#039;html&#039; === $adjusted_current_node-&gt;namespace ||
			(
				&#039;math&#039; === $adjusted_current_node-&gt;integration_node_type &amp;&amp;
				(
					( $is_start_tag &amp;&amp; ! in_array( $token_name, array( &#039;MGLYPH&#039;, &#039;MALIGNMARK&#039; ), true ) ) ||
					&#039;#text&#039; === $token_name
				)
			) ||
			(
				&#039;math&#039; === $adjusted_current_node-&gt;namespace &amp;&amp;
				&#039;ANNOTATION-XML&#039; === $adjusted_current_node-&gt;node_name &amp;&amp;
				$is_start_tag &amp;&amp; &#039;SVG&#039; === $token_name
			) ||
			(
				&#039;html&#039; === $adjusted_current_node-&gt;integration_node_type &amp;&amp;
				( $is_start_tag || &#039;#text&#039; === $token_name )
			)
		);

		try {
			if ( ! $parse_in_current_insertion_mode ) {
				return $this-&gt;step_in_foreign_content();
			}

			switch ( $this-&gt;state-&gt;insertion_mode ) {
				case WP_HTML_Processor_State::INSERTION_MODE_INITIAL:
					return $this-&gt;step_initial();

				case WP_HTML_Processor_State::INSERTION_MODE_BEFORE_HTML:
					return $this-&gt;step_before_html();

				case WP_HTML_Processor_State::INSERTION_MODE_BEFORE_HEAD:
					return $this-&gt;step_before_head();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD:
					return $this-&gt;step_in_head();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD_NOSCRIPT:
					return $this-&gt;step_in_head_noscript();

				case WP_HTML_Processor_State::INSERTION_MODE_AFTER_HEAD:
					return $this-&gt;step_after_head();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_BODY:
					return $this-&gt;step_in_body();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE:
					return $this-&gt;step_in_table();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_TEXT:
					return $this-&gt;step_in_table_text();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_CAPTION:
					return $this-&gt;step_in_caption();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_COLUMN_GROUP:
					return $this-&gt;step_in_column_group();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY:
					return $this-&gt;step_in_table_body();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_ROW:
					return $this-&gt;step_in_row();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_CELL:
					return $this-&gt;step_in_cell();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_SELECT:
					return $this-&gt;step_in_select();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_SELECT_IN_TABLE:
					return $this-&gt;step_in_select_in_table();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_TEMPLATE:
					return $this-&gt;step_in_template();

				case WP_HTML_Processor_State::INSERTION_MODE_AFTER_BODY:
					return $this-&gt;step_after_body();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_FRAMESET:
					return $this-&gt;step_in_frameset();

				case WP_HTML_Processor_State::INSERTION_MODE_AFTER_FRAMESET:
					return $this-&gt;step_after_frameset();

				case WP_HTML_Processor_State::INSERTION_MODE_AFTER_AFTER_BODY:
					return $this-&gt;step_after_after_body();

				case WP_HTML_Processor_State::INSERTION_MODE_AFTER_AFTER_FRAMESET:
					return $this-&gt;step_after_after_frameset();

				// This should be unreachable but PHP doesn&#039;t have total type checking on switch.
				default:
					$this-&gt;bail( &quot;Unaware of the requested parsing mode: &#039;{$this-&gt;state-&gt;insertion_mode}&#039;.&quot; );
			}
		} catch ( WP_HTML_Unsupported_Exception $e ) {
			/*
			 * Exceptions are used in this class to escape deep call stacks that
			 * otherwise might involve messier calling and return conventions.
			 */
			return false;
		}
	}

	/**
	 * Computes the HTML breadcrumbs for the currently-matched node, if matched.
	 *
	 * Breadcrumbs start at the outermost parent and descend toward the matched element.
	 * They always include the entire path from the root HTML node to the matched element.
	 *
	 * Example:
	 *
	 *     $processor = WP_HTML_Processor::create_fragment( &#039;&lt;p&gt;&lt;strong&gt;&lt;em&gt;&lt;img&gt;&lt;/em&gt;&lt;/strong&gt;&lt;/p&gt;&#039; );
	 *     $processor-&gt;next_tag( &#039;IMG&#039; );
	 *     $processor-&gt;get_breadcrumbs() === array( &#039;HTML&#039;, &#039;BODY&#039;, &#039;P&#039;, &#039;STRONG&#039;, &#039;EM&#039;, &#039;IMG&#039; );
	 *
	 * @since 6.4.0
	 *
	 * @return string[] Array of tag names representing path to matched node.
	 */
	public function get_breadcrumbs(): array {
		return $this-&gt;breadcrumbs;
	}

	/**
	 * Returns the nesting depth of the current location in the document.
	 *
	 * Example:
	 *
	 *     $processor = WP_HTML_Processor::create_fragment( &#039;&lt;div&gt;&lt;p&gt;&lt;/p&gt;&lt;/div&gt;&#039; );
	 *     // The processor starts in the BODY context, meaning it has depth from the start: HTML &gt; BODY.
	 *     2 === $processor-&gt;get_current_depth();
	 *
	 *     // Opening the DIV element increases the depth.
	 *     $processor-&gt;next_token();
	 *     3 === $processor-&gt;get_current_depth();
	 *
	 *     // Opening the P element increases the depth.
	 *     $processor-&gt;next_token();
	 *     4 === $processor-&gt;get_current_depth();
	 *
	 *     // The P element is closed during `next_token()` so the depth is decreased to reflect that.
	 *     $processor-&gt;next_token();
	 *     3 === $processor-&gt;get_current_depth();
	 *
	 * @since 6.6.0
	 *
	 * @return int Nesting-depth of current location in the document.
	 */
	public function get_current_depth(): int {
		return count( $this-&gt;breadcrumbs );
	}

	/**
	 * Normalizes an HTML fragment by serializing it.
	 *
	 * This method assumes that the given HTML snippet is found in BODY context.
	 * For normalizing full documents or fragments found in other contexts, create
	 * a new processor using {@see WP_HTML_Processor::create_fragment} or
	 * {@see WP_HTML_Processor::create_full_parser} and call {@see WP_HTML_Processor::serialize}
	 * on the created instances.
	 *
	 * Many aspects of an input HTML fragment may be changed during normalization.
	 *
	 *  - Attribute values will be double-quoted.
	 *  - Duplicate attributes will be removed.
	 *  - Omitted tags will be added.
	 *  - Tag and attribute name casing will be lower-cased,
	 *    except for specific SVG and MathML tags or attributes.
	 *  - Text will be re-encoded, null bytes handled,
	 *    and invalid UTF-8 replaced with U+FFFD.
	 *  - Any incomplete syntax trailing at the end will be omitted,
	 *    for example, an unclosed comment opener will be removed.
	 *
	 * Example:
	 *
	 *     echo WP_HTML_Processor::normalize( &#039;&lt;a href=#anchor v=5 href=&quot;/&quot; enabled&gt;One&lt;/a another v=5&gt;&lt;!--&#039; );
	 *     // &lt;a href=&quot;#anchor&quot; v=&quot;5&quot; enabled&gt;One&lt;/a&gt;
	 *
	 *     echo WP_HTML_Processor::normalize( &#039;&lt;div&gt;&lt;/p&gt;fun&lt;table&gt;&lt;td&gt;cell&lt;/div&gt;&#039; );
	 *     // &lt;div&gt;&lt;p&gt;&lt;/p&gt;fun&lt;table&gt;&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;cell&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;&lt;/div&gt;
	 *
	 *     echo WP_HTML_Processor::normalize( &#039;&lt;![CDATA[invalid comment]]&gt; syntax &lt; &lt;&gt; &quot;oddities&quot;&#039; );
	 *     // &lt;!--[CDATA[invalid comment]]--&gt; syntax &amp;lt; &amp;lt;&amp;gt; &amp;quot;oddities&amp;quot;
	 *
	 * @since 6.7.0
	 *
	 * @param string $html Input HTML to normalize.
	 *
	 * @return string|null Normalized output, or `null` if unable to normalize.
	 */
	public static function normalize( string $html ): ?string {
		return static::create_fragment( $html )-&gt;serialize();
	}

	/**
	 * Returns normalized HTML for a fragment by serializing it.
	 *
	 * This differs from {@see WP_HTML_Processor::normalize} in that it starts with
	 * a specific HTML Processor, which _must_ not have already started scanning;
	 * it must be in the initial ready state and will be in the completed state once
	 * serialization is complete.
	 *
	 * Many aspects of an input HTML fragment may be changed during normalization.
	 *
	 *  - Attribute values will be double-quoted.
	 *  - Duplicate attributes will be removed.
	 *  - Omitted tags will be added.
	 *  - Tag and attribute name casing will be lower-cased,
	 *    except for specific SVG and MathML tags or attributes.
	 *  - Text will be re-encoded, null bytes handled,
	 *    and invalid UTF-8 replaced with U+FFFD.
	 *  - Any incomplete syntax trailing at the end will be omitted,
	 *    for example, an unclosed comment opener will be removed.
	 *
	 * Example:
	 *
	 *     $processor = WP_HTML_Processor::create_fragment( &#039;&lt;a href=#anchor v=5 href=&quot;/&quot; enabled&gt;One&lt;/a another v=5&gt;&lt;!--&#039; );
	 *     echo $processor-&gt;serialize();
	 *     // &lt;a href=&quot;#anchor&quot; v=&quot;5&quot; enabled&gt;One&lt;/a&gt;
	 *
	 *     $processor = WP_HTML_Processor::create_fragment( &#039;&lt;div&gt;&lt;/p&gt;fun&lt;table&gt;&lt;td&gt;cell&lt;/div&gt;&#039; );
	 *     echo $processor-&gt;serialize();
	 *     // &lt;div&gt;&lt;p&gt;&lt;/p&gt;fun&lt;table&gt;&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;cell&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;&lt;/div&gt;
	 *
	 *     $processor = WP_HTML_Processor::create_fragment( &#039;&lt;![CDATA[invalid comment]]&gt; syntax &lt; &lt;&gt; &quot;oddities&quot;&#039; );
	 *     echo $processor-&gt;serialize();
	 *     // &lt;!--[CDATA[invalid comment]]--&gt; syntax &amp;lt; &amp;lt;&amp;gt; &amp;quot;oddities&amp;quot;
	 *
	 * @since 6.7.0
	 *
	 * @return string|null Normalized HTML markup represented by processor,
	 *                     or `null` if unable to generate serialization.
	 */
	public function serialize(): ?string {
		if ( WP_HTML_Tag_Processor::STATE_READY !== $this-&gt;parser_state ) {
			wp_trigger_error(
				__METHOD__,
				&#039;An HTML Processor which has already started processing cannot serialize its contents. Serialize immediately after creating the instance.&#039;,
				E_USER_WARNING
			);
			return null;
		}

		$html = &#039;&#039;;
		while ( $this-&gt;next_token() ) {
			$html .= $this-&gt;serialize_token();
		}

		if ( null !== $this-&gt;get_last_error() ) {
			wp_trigger_error(
				__METHOD__,
				&quot;Cannot serialize HTML Processor with parsing error: {$this-&gt;get_last_error()}.&quot;,
				E_USER_WARNING
			);
			return null;
		}

		return $html;
	}

	/**
	 * Serializes the currently-matched token.
	 *
	 * This method produces a fully-normative HTML string for the currently-matched token,
	 * if able. If not matched at any token or if the token doesn&#039;t correspond to any HTML
	 * it will return an empty string (for example, presumptuous end tags are ignored).
	 *
	 * @see static::serialize()
	 *
	 * @since 6.7.0
	 *
	 * @return string Serialization of token, or empty string if no serialization exists.
	 */
	protected function serialize_token(): string {
		$html       = &#039;&#039;;
		$token_type = $this-&gt;get_token_type();

		switch ( $token_type ) {
			case &#039;#doctype&#039;:
				$doctype = $this-&gt;get_doctype_info();
				if ( null === $doctype ) {
					break;
				}

				$html .= &#039;&lt;!DOCTYPE&#039;;

				if ( $doctype-&gt;name ) {
					$html .= &quot; {$doctype-&gt;name}&quot;;
				}

				if ( null !== $doctype-&gt;public_identifier ) {
					$quote = str_contains( $doctype-&gt;public_identifier, &#039;&quot;&#039; ) ? &quot;&#039;&quot; : &#039;&quot;&#039;;
					$html .= &quot; PUBLIC {$quote}{$doctype-&gt;public_identifier}{$quote}&quot;;
				}
				if ( null !== $doctype-&gt;system_identifier ) {
					if ( null === $doctype-&gt;public_identifier ) {
						$html .= &#039; SYSTEM&#039;;
					}
					$quote = str_contains( $doctype-&gt;system_identifier, &#039;&quot;&#039; ) ? &quot;&#039;&quot; : &#039;&quot;&#039;;
					$html .= &quot; {$quote}{$doctype-&gt;system_identifier}{$quote}&quot;;
				}

				$html .= &#039;&gt;&#039;;
				break;

			case &#039;#text&#039;:
				$html .= htmlspecialchars( $this-&gt;get_modifiable_text(), ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML5, &#039;UTF-8&#039; );
				break;

			// Unlike the `&lt;&gt;` which is interpreted as plaintext, this is ignored entirely.
			case &#039;#presumptuous-tag&#039;:
				break;

			case &#039;#funky-comment&#039;:
			case &#039;#comment&#039;:
				$html .= &quot;&lt;!--{$this-&gt;get_full_comment_text()}--&gt;&quot;;
				break;

			case &#039;#cdata-section&#039;:
				$html .= &quot;&lt;![CDATA[{$this-&gt;get_modifiable_text()}]]&gt;&quot;;
				break;
		}

		if ( &#039;#tag&#039; !== $token_type ) {
			return $html;
		}

		$tag_name       = str_replace( &quot;\x00&quot;, &quot;\u{FFFD}&quot;, $this-&gt;get_tag() );
		$in_html        = &#039;html&#039; === $this-&gt;get_namespace();
		$qualified_name = $in_html ? strtolower( $tag_name ) : $this-&gt;get_qualified_tag_name();

		if ( $this-&gt;is_tag_closer() ) {
			$html .= &quot;&lt;/{$qualified_name}&gt;&quot;;
			return $html;
		}

		$attribute_names = $this-&gt;get_attribute_names_with_prefix( &#039;&#039; );
		if ( ! isset( $attribute_names ) ) {
			$html .= &quot;&lt;{$qualified_name}&gt;&quot;;
			return $html;
		}

		$html .= &quot;&lt;{$qualified_name}&quot;;
		foreach ( $attribute_names as $attribute_name ) {
			$html .= &quot; {$this-&gt;get_qualified_attribute_name( $attribute_name )}&quot;;
			$value = $this-&gt;get_attribute( $attribute_name );

			if ( is_string( $value ) ) {
				$html .= &#039;=&quot;&#039; . htmlspecialchars( $value, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML5 ) . &#039;&quot;&#039;;
			}

			$html = str_replace( &quot;\x00&quot;, &quot;\u{FFFD}&quot;, $html );
		}

		if ( ! $in_html &amp;&amp; $this-&gt;has_self_closing_flag() ) {
			$html .= &#039; /&#039;;
		}

		$html .= &#039;&gt;&#039;;

		// Flush out self-contained elements.
		if ( $in_html &amp;&amp; in_array( $tag_name, array( &#039;IFRAME&#039;, &#039;NOEMBED&#039;, &#039;NOFRAMES&#039;, &#039;SCRIPT&#039;, &#039;STYLE&#039;, &#039;TEXTAREA&#039;, &#039;TITLE&#039;, &#039;XMP&#039; ), true ) ) {
			$text = $this-&gt;get_modifiable_text();

			switch ( $tag_name ) {
				case &#039;IFRAME&#039;:
				case &#039;NOEMBED&#039;:
				case &#039;NOFRAMES&#039;:
					$text = &#039;&#039;;
					break;

				case &#039;SCRIPT&#039;:
				case &#039;STYLE&#039;:
					break;

				default:
					$text = htmlspecialchars( $text, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML5, &#039;UTF-8&#039; );
			}

			$html .= &quot;{$text}&lt;/{$qualified_name}&gt;&quot;;
		}

		return $html;
	}

	/**
	 * Parses next element in the &#039;initial&#039; insertion mode.
	 *
	 * This internal function performs the &#039;initial&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#the-initial-insertion-mode
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_initial(): bool {
		$token_name = $this-&gt;get_token_name();
		$token_type = $this-&gt;get_token_type();
		$op_sigil   = &#039;#tag&#039; === $token_type ? ( parent::is_tag_closer() ? &#039;-&#039; : &#039;+&#039; ) : &#039;&#039;;
		$op         = &quot;{$op_sigil}{$token_name}&quot;;

		switch ( $op ) {
			/*
			 * &gt; A character token that is one of U+0009 CHARACTER TABULATION,
			 * &gt; U+000A LINE FEED (LF), U+000C FORM FEED (FF),
			 * &gt; U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
			 *
			 * Parse error: ignore the token.
			 */
			case &#039;#text&#039;:
				if ( parent::TEXT_IS_WHITESPACE === $this-&gt;text_node_classification ) {
					return $this-&gt;step();
				}
				goto initial_anything_else;
				break;

			/*
			 * &gt; A comment token
			 */
			case &#039;#comment&#039;:
			case &#039;#funky-comment&#039;:
			case &#039;#presumptuous-tag&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A DOCTYPE token
			 */
			case &#039;html&#039;:
				$doctype = $this-&gt;get_doctype_info();
				if ( null !== $doctype &amp;&amp; &#039;quirks&#039; === $doctype-&gt;indicated_compatability_mode ) {
					$this-&gt;compat_mode = WP_HTML_Tag_Processor::QUIRKS_MODE;
				}

				/*
				 * &gt; Then, switch the insertion mode to &quot;before html&quot;.
				 */
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_BEFORE_HTML;
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;
		}

		/*
		 * &gt; Anything else
		 */
		initial_anything_else:
		$this-&gt;compat_mode           = WP_HTML_Tag_Processor::QUIRKS_MODE;
		$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_BEFORE_HTML;
		return $this-&gt;step( self::REPROCESS_CURRENT_NODE );
	}

	/**
	 * Parses next element in the &#039;before html&#039; insertion mode.
	 *
	 * This internal function performs the &#039;before html&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#the-before-html-insertion-mode
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_before_html(): bool {
		$token_name = $this-&gt;get_token_name();
		$token_type = $this-&gt;get_token_type();
		$is_closer  = parent::is_tag_closer();
		$op_sigil   = &#039;#tag&#039; === $token_type ? ( $is_closer ? &#039;-&#039; : &#039;+&#039; ) : &#039;&#039;;
		$op         = &quot;{$op_sigil}{$token_name}&quot;;

		switch ( $op ) {
			/*
			 * &gt; A DOCTYPE token
			 */
			case &#039;html&#039;:
				// Parse error: ignore the token.
				return $this-&gt;step();

			/*
			 * &gt; A comment token
			 */
			case &#039;#comment&#039;:
			case &#039;#funky-comment&#039;:
			case &#039;#presumptuous-tag&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A character token that is one of U+0009 CHARACTER TABULATION,
			 * &gt; U+000A LINE FEED (LF), U+000C FORM FEED (FF),
			 * &gt; U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
			 *
			 * Parse error: ignore the token.
			 */
			case &#039;#text&#039;:
				if ( parent::TEXT_IS_WHITESPACE === $this-&gt;text_node_classification ) {
					return $this-&gt;step();
				}
				goto before_html_anything_else;
				break;

			/*
			 * &gt; A start tag whose tag name is &quot;html&quot;
			 */
			case &#039;+HTML&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_BEFORE_HEAD;
				return true;

			/*
			 * &gt; An end tag whose tag name is one of: &quot;head&quot;, &quot;body&quot;, &quot;html&quot;, &quot;br&quot;
			 *
			 * Closing BR tags are always reported by the Tag Processor as opening tags.
			 */
			case &#039;-HEAD&#039;:
			case &#039;-BODY&#039;:
			case &#039;-HTML&#039;:
				/*
				 * &gt; Act as described in the &quot;anything else&quot; entry below.
				 */
				goto before_html_anything_else;
				break;
		}

		/*
		 * &gt; Any other end tag
		 */
		if ( $is_closer ) {
			// Parse error: ignore the token.
			return $this-&gt;step();
		}

		/*
		 * &gt; Anything else.
		 *
		 * &gt; Create an html element whose node document is the Document object.
		 * &gt; Append it to the Document object. Put this element in the stack of open elements.
		 * &gt; Switch the insertion mode to &quot;before head&quot;, then reprocess the token.
		 */
		before_html_anything_else:
		$this-&gt;insert_virtual_node( &#039;HTML&#039; );
		$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_BEFORE_HEAD;
		return $this-&gt;step( self::REPROCESS_CURRENT_NODE );
	}

	/**
	 * Parses next element in the &#039;before head&#039; insertion mode.
	 *
	 * This internal function performs the &#039;before head&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0 Stub implementation.
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#the-before-head-insertion-mode
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_before_head(): bool {
		$token_name = $this-&gt;get_token_name();
		$token_type = $this-&gt;get_token_type();
		$is_closer  = parent::is_tag_closer();
		$op_sigil   = &#039;#tag&#039; === $token_type ? ( $is_closer ? &#039;-&#039; : &#039;+&#039; ) : &#039;&#039;;
		$op         = &quot;{$op_sigil}{$token_name}&quot;;

		switch ( $op ) {
			/*
			 * &gt; A character token that is one of U+0009 CHARACTER TABULATION,
			 * &gt; U+000A LINE FEED (LF), U+000C FORM FEED (FF),
			 * &gt; U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
			 *
			 * Parse error: ignore the token.
			 */
			case &#039;#text&#039;:
				if ( parent::TEXT_IS_WHITESPACE === $this-&gt;text_node_classification ) {
					return $this-&gt;step();
				}
				goto before_head_anything_else;
				break;

			/*
			 * &gt; A comment token
			 */
			case &#039;#comment&#039;:
			case &#039;#funky-comment&#039;:
			case &#039;#presumptuous-tag&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A DOCTYPE token
			 */
			case &#039;html&#039;:
				// Parse error: ignore the token.
				return $this-&gt;step();

			/*
			 * &gt; A start tag whose tag name is &quot;html&quot;
			 */
			case &#039;+HTML&#039;:
				return $this-&gt;step_in_body();

			/*
			 * &gt; A start tag whose tag name is &quot;head&quot;
			 */
			case &#039;+HEAD&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;head_element   = $this-&gt;state-&gt;current_token;
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD;
				return true;

			/*
			 * &gt; An end tag whose tag name is one of: &quot;head&quot;, &quot;body&quot;, &quot;html&quot;, &quot;br&quot;
			 * &gt; Act as described in the &quot;anything else&quot; entry below.
			 *
			 * Closing BR tags are always reported by the Tag Processor as opening tags.
			 */
			case &#039;-HEAD&#039;:
			case &#039;-BODY&#039;:
			case &#039;-HTML&#039;:
				goto before_head_anything_else;
				break;
		}

		if ( $is_closer ) {
			// Parse error: ignore the token.
			return $this-&gt;step();
		}

		/*
		 * &gt; Anything else
		 *
		 * &gt; Insert an HTML element for a &quot;head&quot; start tag token with no attributes.
		 */
		before_head_anything_else:
		$this-&gt;state-&gt;head_element   = $this-&gt;insert_virtual_node( &#039;HEAD&#039; );
		$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD;
		return $this-&gt;step( self::REPROCESS_CURRENT_NODE );
	}

	/**
	 * Parses next element in the &#039;in head&#039; insertion mode.
	 *
	 * This internal function performs the &#039;in head&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inhead
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_in_head(): bool {
		$token_name = $this-&gt;get_token_name();
		$token_type = $this-&gt;get_token_type();
		$is_closer  = parent::is_tag_closer();
		$op_sigil   = &#039;#tag&#039; === $token_type ? ( $is_closer ? &#039;-&#039; : &#039;+&#039; ) : &#039;&#039;;
		$op         = &quot;{$op_sigil}{$token_name}&quot;;

		switch ( $op ) {
			case &#039;#text&#039;:
				/*
				 * &gt; A character token that is one of U+0009 CHARACTER TABULATION,
				 * &gt; U+000A LINE FEED (LF), U+000C FORM FEED (FF),
				 * &gt; U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
				 */
				if ( parent::TEXT_IS_WHITESPACE === $this-&gt;text_node_classification ) {
					// Insert the character.
					$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
					return true;
				}

				goto in_head_anything_else;
				break;

			/*
			 * &gt; A comment token
			 */
			case &#039;#comment&#039;:
			case &#039;#funky-comment&#039;:
			case &#039;#presumptuous-tag&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A DOCTYPE token
			 */
			case &#039;html&#039;:
				// Parse error: ignore the token.
				return $this-&gt;step();

			/*
			 * &gt; A start tag whose tag name is &quot;html&quot;
			 */
			case &#039;+HTML&#039;:
				return $this-&gt;step_in_body();

			/*
			 * &gt; A start tag whose tag name is one of: &quot;base&quot;, &quot;basefont&quot;, &quot;bgsound&quot;, &quot;link&quot;
			 */
			case &#039;+BASE&#039;:
			case &#039;+BASEFONT&#039;:
			case &#039;+BGSOUND&#039;:
			case &#039;+LINK&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;meta&quot;
			 */
			case &#039;+META&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );

				/*
				 * &gt; If the active speculative HTML parser is null, then:
				 * &gt;   - If the element has a charset attribute, and getting an encoding from
				 * &gt;     its value results in an encoding, and the confidence is currently
				 * &gt;     tentative, then change the encoding to the resulting encoding.
				 */
				$charset = $this-&gt;get_attribute( &#039;charset&#039; );
				if ( is_string( $charset ) &amp;&amp; &#039;tentative&#039; === $this-&gt;state-&gt;encoding_confidence ) {
					$this-&gt;bail( &#039;Cannot yet process META tags with charset to determine encoding.&#039; );
				}

				/*
				 * &gt;   - Otherwise, if the element has an http-equiv attribute whose value is
				 * &gt;     an ASCII case-insensitive match for the string &quot;Content-Type&quot;, and
				 * &gt;     the element has a content attribute, and applying the algorithm for
				 * &gt;     extracting a character encoding from a meta element to that attribute&#039;s
				 * &gt;     value returns an encoding, and the confidence is currently tentative,
				 * &gt;     then change the encoding to the extracted encoding.
				 */
				$http_equiv = $this-&gt;get_attribute( &#039;http-equiv&#039; );
				$content    = $this-&gt;get_attribute( &#039;content&#039; );
				if (
					is_string( $http_equiv ) &amp;&amp;
					is_string( $content ) &amp;&amp;
					0 === strcasecmp( $http_equiv, &#039;Content-Type&#039; ) &amp;&amp;
					&#039;tentative&#039; === $this-&gt;state-&gt;encoding_confidence
				) {
					$this-&gt;bail( &#039;Cannot yet process META tags with http-equiv Content-Type to determine encoding.&#039; );
				}

				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;title&quot;
			 */
			case &#039;+TITLE&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;noscript&quot;, if the scripting flag is enabled
			 * &gt; A start tag whose tag name is one of: &quot;noframes&quot;, &quot;style&quot;
			 *
			 * The scripting flag is never enabled in this parser.
			 */
			case &#039;+NOFRAMES&#039;:
			case &#039;+STYLE&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;noscript&quot;, if the scripting flag is disabled
			 */
			case &#039;+NOSCRIPT&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD_NOSCRIPT;
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;script&quot;
			 *
			 * @todo Could the adjusted insertion location be anything other than the current location?
			 */
			case &#039;+SCRIPT&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; An end tag whose tag name is &quot;head&quot;
			 */
			case &#039;-HEAD&#039;:
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_AFTER_HEAD;
				return true;

			/*
			 * &gt; An end tag whose tag name is one of: &quot;body&quot;, &quot;html&quot;, &quot;br&quot;
			 *
			 * BR tags are always reported by the Tag Processor as opening tags.
			 */
			case &#039;-BODY&#039;:
			case &#039;-HTML&#039;:
				/*
				 * &gt; Act as described in the &quot;anything else&quot; entry below.
				 */
				goto in_head_anything_else;
				break;

			/*
			 * &gt; A start tag whose tag name is &quot;template&quot;
			 *
			 * @todo Could the adjusted insertion location be anything other than the current location?
			 */
			case &#039;+TEMPLATE&#039;:
				$this-&gt;state-&gt;active_formatting_elements-&gt;insert_marker();
				$this-&gt;state-&gt;frameset_ok = false;

				$this-&gt;state-&gt;insertion_mode                      = WP_HTML_Processor_State::INSERTION_MODE_IN_TEMPLATE;
				$this-&gt;state-&gt;stack_of_template_insertion_modes[] = WP_HTML_Processor_State::INSERTION_MODE_IN_TEMPLATE;

				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; An end tag whose tag name is &quot;template&quot;
			 */
			case &#039;-TEMPLATE&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;contains( &#039;TEMPLATE&#039; ) ) {
					// @todo Indicate a parse error once it&#039;s possible.
					return $this-&gt;step();
				}

				$this-&gt;generate_implied_end_tags_thoroughly();
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( &#039;TEMPLATE&#039; ) ) {
					// @todo Indicate a parse error once it&#039;s possible.
				}

				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop_until( &#039;TEMPLATE&#039; );
				$this-&gt;state-&gt;active_formatting_elements-&gt;clear_up_to_last_marker();
				array_pop( $this-&gt;state-&gt;stack_of_template_insertion_modes );
				$this-&gt;reset_insertion_mode_appropriately();
				return true;
		}

		/*
		 * &gt; A start tag whose tag name is &quot;head&quot;
		 * &gt; Any other end tag
		 */
		if ( &#039;+HEAD&#039; === $op || $is_closer ) {
			// Parse error: ignore the token.
			return $this-&gt;step();
		}

		/*
		 * &gt; Anything else
		 */
		in_head_anything_else:
		$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
		$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_AFTER_HEAD;
		return $this-&gt;step( self::REPROCESS_CURRENT_NODE );
	}

	/**
	 * Parses next element in the &#039;in head noscript&#039; insertion mode.
	 *
	 * This internal function performs the &#039;in head noscript&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0 Stub implementation.
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#parsing-main-inheadnoscript
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_in_head_noscript(): bool {
		$token_name = $this-&gt;get_token_name();
		$token_type = $this-&gt;get_token_type();
		$is_closer  = parent::is_tag_closer();
		$op_sigil   = &#039;#tag&#039; === $token_type ? ( $is_closer ? &#039;-&#039; : &#039;+&#039; ) : &#039;&#039;;
		$op         = &quot;{$op_sigil}{$token_name}&quot;;

		switch ( $op ) {
			/*
			 * &gt; A character token that is one of U+0009 CHARACTER TABULATION,
			 * &gt; U+000A LINE FEED (LF), U+000C FORM FEED (FF),
			 * &gt; U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
			 *
			 * Parse error: ignore the token.
			 */
			case &#039;#text&#039;:
				if ( parent::TEXT_IS_WHITESPACE === $this-&gt;text_node_classification ) {
					return $this-&gt;step_in_head();
				}

				goto in_head_noscript_anything_else;
				break;

			/*
			 * &gt; A DOCTYPE token
			 */
			case &#039;html&#039;:
				// Parse error: ignore the token.
				return $this-&gt;step();

			/*
			 * &gt; A start tag whose tag name is &quot;html&quot;
			 */
			case &#039;+HTML&#039;:
				return $this-&gt;step_in_body();

			/*
			 * &gt; An end tag whose tag name is &quot;noscript&quot;
			 */
			case &#039;-NOSCRIPT&#039;:
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD;
				return true;

			/*
			 * &gt; A comment token
			 * &gt;
			 * &gt; A start tag whose tag name is one of: &quot;basefont&quot;, &quot;bgsound&quot;,
			 * &gt; &quot;link&quot;, &quot;meta&quot;, &quot;noframes&quot;, &quot;style&quot;
			 */
			case &#039;#comment&#039;:
			case &#039;#funky-comment&#039;:
			case &#039;#presumptuous-tag&#039;:
			case &#039;+BASEFONT&#039;:
			case &#039;+BGSOUND&#039;:
			case &#039;+LINK&#039;:
			case &#039;+META&#039;:
			case &#039;+NOFRAMES&#039;:
			case &#039;+STYLE&#039;:
				return $this-&gt;step_in_head();

			/*
			 * &gt; An end tag whose tag name is &quot;br&quot;
			 *
			 * This should never happen, as the Tag Processor prevents showing a BR closing tag.
			 */
		}

		/*
		 * &gt; A start tag whose tag name is one of: &quot;head&quot;, &quot;noscript&quot;
		 * &gt; Any other end tag
		 */
		if ( &#039;+HEAD&#039; === $op || &#039;+NOSCRIPT&#039; === $op || $is_closer ) {
			// Parse error: ignore the token.
			return $this-&gt;step();
		}

		/*
		 * &gt; Anything else
		 *
		 * Anything here is a parse error.
		 */
		in_head_noscript_anything_else:
		$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
		$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD;
		return $this-&gt;step( self::REPROCESS_CURRENT_NODE );
	}

	/**
	 * Parses next element in the &#039;after head&#039; insertion mode.
	 *
	 * This internal function performs the &#039;after head&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0 Stub implementation.
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#the-after-head-insertion-mode
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_after_head(): bool {
		$token_name = $this-&gt;get_token_name();
		$token_type = $this-&gt;get_token_type();
		$is_closer  = parent::is_tag_closer();
		$op_sigil   = &#039;#tag&#039; === $token_type ? ( $is_closer ? &#039;-&#039; : &#039;+&#039; ) : &#039;&#039;;
		$op         = &quot;{$op_sigil}{$token_name}&quot;;

		switch ( $op ) {
			/*
			 * &gt; A character token that is one of U+0009 CHARACTER TABULATION,
			 * &gt; U+000A LINE FEED (LF), U+000C FORM FEED (FF),
			 * &gt; U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
			 */
			case &#039;#text&#039;:
				if ( parent::TEXT_IS_WHITESPACE === $this-&gt;text_node_classification ) {
					// Insert the character.
					$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
					return true;
				}
				goto after_head_anything_else;
				break;

			/*
			 * &gt; A comment token
			 */
			case &#039;#comment&#039;:
			case &#039;#funky-comment&#039;:
			case &#039;#presumptuous-tag&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A DOCTYPE token
			 */
			case &#039;html&#039;:
				// Parse error: ignore the token.
				return $this-&gt;step();

			/*
			 * &gt; A start tag whose tag name is &quot;html&quot;
			 */
			case &#039;+HTML&#039;:
				return $this-&gt;step_in_body();

			/*
			 * &gt; A start tag whose tag name is &quot;body&quot;
			 */
			case &#039;+BODY&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;frameset_ok    = false;
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_BODY;
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;frameset&quot;
			 */
			case &#039;+FRAMESET&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_FRAMESET;
				return true;

			/*
			 * &gt; A start tag whose tag name is one of: &quot;base&quot;, &quot;basefont&quot;, &quot;bgsound&quot;,
			 * &gt; &quot;link&quot;, &quot;meta&quot;, &quot;noframes&quot;, &quot;script&quot;, &quot;style&quot;, &quot;template&quot;, &quot;title&quot;
			 *
			 * Anything here is a parse error.
			 */
			case &#039;+BASE&#039;:
			case &#039;+BASEFONT&#039;:
			case &#039;+BGSOUND&#039;:
			case &#039;+LINK&#039;:
			case &#039;+META&#039;:
			case &#039;+NOFRAMES&#039;:
			case &#039;+SCRIPT&#039;:
			case &#039;+STYLE&#039;:
			case &#039;+TEMPLATE&#039;:
			case &#039;+TITLE&#039;:
				/*
				 * &gt; Push the node pointed to by the head element pointer onto the stack of open elements.
				 * &gt; Process the token using the rules for the &quot;in head&quot; insertion mode.
				 * &gt; Remove the node pointed to by the head element pointer from the stack of open elements. (It might not be the current node at this point.)
				 */
				$this-&gt;bail( &#039;Cannot process elements after HEAD which reopen the HEAD element.&#039; );
				/*
				 * Do not leave this break in when adding support; it&#039;s here to prevent
				 * WPCS from getting confused at the switch structure without a return,
				 * because it doesn&#039;t know that `bail()` always throws.
				 */
				break;

			/*
			 * &gt; An end tag whose tag name is &quot;template&quot;
			 */
			case &#039;-TEMPLATE&#039;:
				return $this-&gt;step_in_head();

			/*
			 * &gt; An end tag whose tag name is one of: &quot;body&quot;, &quot;html&quot;, &quot;br&quot;
			 *
			 * Closing BR tags are always reported by the Tag Processor as opening tags.
			 */
			case &#039;-BODY&#039;:
			case &#039;-HTML&#039;:
				/*
				 * &gt; Act as described in the &quot;anything else&quot; entry below.
				 */
				goto after_head_anything_else;
				break;
		}

		/*
		 * &gt; A start tag whose tag name is &quot;head&quot;
		 * &gt; Any other end tag
		 */
		if ( &#039;+HEAD&#039; === $op || $is_closer ) {
			// Parse error: ignore the token.
			return $this-&gt;step();
		}

		/*
		 * &gt; Anything else
		 * &gt; Insert an HTML element for a &quot;body&quot; start tag token with no attributes.
		 */
		after_head_anything_else:
		$this-&gt;insert_virtual_node( &#039;BODY&#039; );
		$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_BODY;
		return $this-&gt;step( self::REPROCESS_CURRENT_NODE );
	}

	/**
	 * Parses next element in the &#039;in body&#039; insertion mode.
	 *
	 * This internal function performs the &#039;in body&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.4.0
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#parsing-main-inbody
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_in_body(): bool {
		$token_name = $this-&gt;get_token_name();
		$token_type = $this-&gt;get_token_type();
		$op_sigil   = &#039;#tag&#039; === $token_type ? ( parent::is_tag_closer() ? &#039;-&#039; : &#039;+&#039; ) : &#039;&#039;;
		$op         = &quot;{$op_sigil}{$token_name}&quot;;

		switch ( $op ) {
			case &#039;#text&#039;:
				/*
				 * &gt; A character token that is U+0000 NULL
				 *
				 * Any successive sequence of NULL bytes is ignored and won&#039;t
				 * trigger active format reconstruction. Therefore, if the text
				 * only comprises NULL bytes then the token should be ignored
				 * here, but if there are any other characters in the stream
				 * the active formats should be reconstructed.
				 */
				if ( parent::TEXT_IS_NULL_SEQUENCE === $this-&gt;text_node_classification ) {
					// Parse error: ignore the token.
					return $this-&gt;step();
				}

				$this-&gt;reconstruct_active_formatting_elements();

				/*
				 * Whitespace-only text does not affect the frameset-ok flag.
				 * It is probably inter-element whitespace, but it may also
				 * contain character references which decode only to whitespace.
				 */
				if ( parent::TEXT_IS_GENERIC === $this-&gt;text_node_classification ) {
					$this-&gt;state-&gt;frameset_ok = false;
				}

				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			case &#039;#comment&#039;:
			case &#039;#funky-comment&#039;:
			case &#039;#presumptuous-tag&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A DOCTYPE token
			 * &gt; Parse error. Ignore the token.
			 */
			case &#039;html&#039;:
				return $this-&gt;step();

			/*
			 * &gt; A start tag whose tag name is &quot;html&quot;
			 */
			case &#039;+HTML&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;contains( &#039;TEMPLATE&#039; ) ) {
					/*
					 * &gt; Otherwise, for each attribute on the token, check to see if the attribute
					 * &gt; is already present on the top element of the stack of open elements. If
					 * &gt; it is not, add the attribute and its corresponding value to that element.
					 *
					 * This parser does not currently support this behavior: ignore the token.
					 */
				}

				// Ignore the token.
				return $this-&gt;step();

			/*
			 * &gt; A start tag whose tag name is one of: &quot;base&quot;, &quot;basefont&quot;, &quot;bgsound&quot;, &quot;link&quot;,
			 * &gt; &quot;meta&quot;, &quot;noframes&quot;, &quot;script&quot;, &quot;style&quot;, &quot;template&quot;, &quot;title&quot;
			 * &gt;
			 * &gt; An end tag whose tag name is &quot;template&quot;
			 */
			case &#039;+BASE&#039;:
			case &#039;+BASEFONT&#039;:
			case &#039;+BGSOUND&#039;:
			case &#039;+LINK&#039;:
			case &#039;+META&#039;:
			case &#039;+NOFRAMES&#039;:
			case &#039;+SCRIPT&#039;:
			case &#039;+STYLE&#039;:
			case &#039;+TEMPLATE&#039;:
			case &#039;+TITLE&#039;:
			case &#039;-TEMPLATE&#039;:
				return $this-&gt;step_in_head();

			/*
			 * &gt; A start tag whose tag name is &quot;body&quot;
			 *
			 * This tag in the IN BODY insertion mode is a parse error.
			 */
			case &#039;+BODY&#039;:
				if (
					1 === $this-&gt;state-&gt;stack_of_open_elements-&gt;count() ||
					&#039;BODY&#039; !== ( $this-&gt;state-&gt;stack_of_open_elements-&gt;at( 2 )-&gt;node_name ?? null ) ||
					$this-&gt;state-&gt;stack_of_open_elements-&gt;contains( &#039;TEMPLATE&#039; )
				) {
					// Ignore the token.
					return $this-&gt;step();
				}

				/*
				 * &gt; Otherwise, set the frameset-ok flag to &quot;not ok&quot;; then, for each attribute
				 * &gt; on the token, check to see if the attribute is already present on the body
				 * &gt; element (the second element) on the stack of open elements, and if it is
				 * &gt; not, add the attribute and its corresponding value to that element.
				 *
				 * This parser does not currently support this behavior: ignore the token.
				 */
				$this-&gt;state-&gt;frameset_ok = false;
				return $this-&gt;step();

			/*
			 * &gt; A start tag whose tag name is &quot;frameset&quot;
			 *
			 * This tag in the IN BODY insertion mode is a parse error.
			 */
			case &#039;+FRAMESET&#039;:
				if (
					1 === $this-&gt;state-&gt;stack_of_open_elements-&gt;count() ||
					&#039;BODY&#039; !== ( $this-&gt;state-&gt;stack_of_open_elements-&gt;at( 2 )-&gt;node_name ?? null ) ||
					false === $this-&gt;state-&gt;frameset_ok
				) {
					// Ignore the token.
					return $this-&gt;step();
				}

				/*
				 * &gt; Otherwise, run the following steps:
				 */
				$this-&gt;bail( &#039;Cannot process non-ignored FRAMESET tags.&#039; );
				break;

			/*
			 * &gt; An end tag whose tag name is &quot;body&quot;
			 */
			case &#039;-BODY&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_scope( &#039;BODY&#039; ) ) {
					// Parse error: ignore the token.
					return $this-&gt;step();
				}

				/*
				 * &gt; Otherwise, if there is a node in the stack of open elements that is not either a
				 * &gt; dd element, a dt element, an li element, an optgroup element, an option element,
				 * &gt; a p element, an rb element, an rp element, an rt element, an rtc element, a tbody
				 * &gt; element, a td element, a tfoot element, a th element, a thread element, a tr
				 * &gt; element, the body element, or the html element, then this is a parse error.
				 *
				 * There is nothing to do for this parse error, so don&#039;t check for it.
				 */

				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_AFTER_BODY;
				/*
				 * The BODY element is not removed from the stack of open elements.
				 * Only internal state has changed, this does not qualify as a &quot;step&quot;
				 * in terms of advancing through the document to another token.
				 * Nothing has been pushed or popped.
				 * Proceed to parse the next item.
				 */
				return $this-&gt;step();

			/*
			 * &gt; An end tag whose tag name is &quot;html&quot;
			 */
			case &#039;-HTML&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_scope( &#039;BODY&#039; ) ) {
					// Parse error: ignore the token.
					return $this-&gt;step();
				}

				/*
				 * &gt; Otherwise, if there is a node in the stack of open elements that is not either a
				 * &gt; dd element, a dt element, an li element, an optgroup element, an option element,
				 * &gt; a p element, an rb element, an rp element, an rt element, an rtc element, a tbody
				 * &gt; element, a td element, a tfoot element, a th element, a thread element, a tr
				 * &gt; element, the body element, or the html element, then this is a parse error.
				 *
				 * There is nothing to do for this parse error, so don&#039;t check for it.
				 */

				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_AFTER_BODY;
				return $this-&gt;step( self::REPROCESS_CURRENT_NODE );

			/*
			 * &gt; A start tag whose tag name is one of: &quot;address&quot;, &quot;article&quot;, &quot;aside&quot;,
			 * &gt; &quot;blockquote&quot;, &quot;center&quot;, &quot;details&quot;, &quot;dialog&quot;, &quot;dir&quot;, &quot;div&quot;, &quot;dl&quot;,
			 * &gt; &quot;fieldset&quot;, &quot;figcaption&quot;, &quot;figure&quot;, &quot;footer&quot;, &quot;header&quot;, &quot;hgroup&quot;,
			 * &gt; &quot;main&quot;, &quot;menu&quot;, &quot;nav&quot;, &quot;ol&quot;, &quot;p&quot;, &quot;search&quot;, &quot;section&quot;, &quot;summary&quot;, &quot;ul&quot;
			 */
			case &#039;+ADDRESS&#039;:
			case &#039;+ARTICLE&#039;:
			case &#039;+ASIDE&#039;:
			case &#039;+BLOCKQUOTE&#039;:
			case &#039;+CENTER&#039;:
			case &#039;+DETAILS&#039;:
			case &#039;+DIALOG&#039;:
			case &#039;+DIR&#039;:
			case &#039;+DIV&#039;:
			case &#039;+DL&#039;:
			case &#039;+FIELDSET&#039;:
			case &#039;+FIGCAPTION&#039;:
			case &#039;+FIGURE&#039;:
			case &#039;+FOOTER&#039;:
			case &#039;+HEADER&#039;:
			case &#039;+HGROUP&#039;:
			case &#039;+MAIN&#039;:
			case &#039;+MENU&#039;:
			case &#039;+NAV&#039;:
			case &#039;+OL&#039;:
			case &#039;+P&#039;:
			case &#039;+SEARCH&#039;:
			case &#039;+SECTION&#039;:
			case &#039;+SUMMARY&#039;:
			case &#039;+UL&#039;:
				if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;has_p_in_button_scope() ) {
					$this-&gt;close_a_p_element();
				}

				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A start tag whose tag name is one of: &quot;h1&quot;, &quot;h2&quot;, &quot;h3&quot;, &quot;h4&quot;, &quot;h5&quot;, &quot;h6&quot;
			 */
			case &#039;+H1&#039;:
			case &#039;+H2&#039;:
			case &#039;+H3&#039;:
			case &#039;+H4&#039;:
			case &#039;+H5&#039;:
			case &#039;+H6&#039;:
				if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;has_p_in_button_scope() ) {
					$this-&gt;close_a_p_element();
				}

				if (
					in_array(
						$this-&gt;state-&gt;stack_of_open_elements-&gt;current_node()-&gt;node_name,
						array( &#039;H1&#039;, &#039;H2&#039;, &#039;H3&#039;, &#039;H4&#039;, &#039;H5&#039;, &#039;H6&#039; ),
						true
					)
				) {
					// @todo Indicate a parse error once it&#039;s possible.
					$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				}

				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A start tag whose tag name is one of: &quot;pre&quot;, &quot;listing&quot;
			 */
			case &#039;+PRE&#039;:
			case &#039;+LISTING&#039;:
				if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;has_p_in_button_scope() ) {
					$this-&gt;close_a_p_element();
				}

				/*
				 * &gt; If the next token is a U+000A LINE FEED (LF) character token,
				 * &gt; then ignore that token and move on to the next one. (Newlines
				 * &gt; at the start of pre blocks are ignored as an authoring convenience.)
				 *
				 * This is handled in `get_modifiable_text()`.
				 */

				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;frameset_ok = false;
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;form&quot;
			 */
			case &#039;+FORM&#039;:
				$stack_contains_template = $this-&gt;state-&gt;stack_of_open_elements-&gt;contains( &#039;TEMPLATE&#039; );

				if ( isset( $this-&gt;state-&gt;form_element ) &amp;&amp; ! $stack_contains_template ) {
					// Parse error: ignore the token.
					return $this-&gt;step();
				}

				if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;has_p_in_button_scope() ) {
					$this-&gt;close_a_p_element();
				}

				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				if ( ! $stack_contains_template ) {
					$this-&gt;state-&gt;form_element = $this-&gt;state-&gt;current_token;
				}

				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;li&quot;
			 * &gt; A start tag whose tag name is one of: &quot;dd&quot;, &quot;dt&quot;
			 */
			case &#039;+DD&#039;:
			case &#039;+DT&#039;:
			case &#039;+LI&#039;:
				$this-&gt;state-&gt;frameset_ok = false;
				$node                     = $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node();
				$is_li                    = &#039;LI&#039; === $token_name;

				in_body_list_loop:
				/*
				 * The logic for LI and DT/DD is the same except for one point: LI elements _only_
				 * close other LI elements, but a DT or DD element closes _any_ open DT or DD element.
				 */
				if ( $is_li ? &#039;LI&#039; === $node-&gt;node_name : ( &#039;DD&#039; === $node-&gt;node_name || &#039;DT&#039; === $node-&gt;node_name ) ) {
					$node_name = $is_li ? &#039;LI&#039; : $node-&gt;node_name;
					$this-&gt;generate_implied_end_tags( $node_name );
					if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( $node_name ) ) {
						// @todo Indicate a parse error once it&#039;s possible. This error does not impact the logic here.
					}

					$this-&gt;state-&gt;stack_of_open_elements-&gt;pop_until( $node_name );
					goto in_body_list_done;
				}

				if (
					&#039;ADDRESS&#039; !== $node-&gt;node_name &amp;&amp;
					&#039;DIV&#039; !== $node-&gt;node_name &amp;&amp;
					&#039;P&#039; !== $node-&gt;node_name &amp;&amp;
					self::is_special( $node )
				) {
					/*
					 * &gt; If node is in the special category, but is not an address, div,
					 * &gt; or p element, then jump to the step labeled done below.
					 */
					goto in_body_list_done;
				} else {
					/*
					 * &gt; Otherwise, set node to the previous entry in the stack of open elements
					 * &gt; and return to the step labeled loop.
					 */
					foreach ( $this-&gt;state-&gt;stack_of_open_elements-&gt;walk_up( $node ) as $item ) {
						$node = $item;
						break;
					}
					goto in_body_list_loop;
				}

				in_body_list_done:
				if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;has_p_in_button_scope() ) {
					$this-&gt;close_a_p_element();
				}

				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			case &#039;+PLAINTEXT&#039;:
				if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;has_p_in_button_scope() ) {
					$this-&gt;close_a_p_element();
				}

				/*
				 * @todo This may need to be handled in the Tag Processor and turn into
				 *       a single self-contained tag like TEXTAREA, whose modifiable text
				 *       is the rest of the input document as plaintext.
				 */
				$this-&gt;bail( &#039;Cannot process PLAINTEXT elements.&#039; );
				break;

			/*
			 * &gt; A start tag whose tag name is &quot;button&quot;
			 */
			case &#039;+BUTTON&#039;:
				if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_scope( &#039;BUTTON&#039; ) ) {
					// @todo Indicate a parse error once it&#039;s possible. This error does not impact the logic here.
					$this-&gt;generate_implied_end_tags();
					$this-&gt;state-&gt;stack_of_open_elements-&gt;pop_until( &#039;BUTTON&#039; );
				}

				$this-&gt;reconstruct_active_formatting_elements();
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;frameset_ok = false;

				return true;

			/*
			 * &gt; An end tag whose tag name is one of: &quot;address&quot;, &quot;article&quot;, &quot;aside&quot;, &quot;blockquote&quot;,
			 * &gt; &quot;button&quot;, &quot;center&quot;, &quot;details&quot;, &quot;dialog&quot;, &quot;dir&quot;, &quot;div&quot;, &quot;dl&quot;, &quot;fieldset&quot;,
			 * &gt; &quot;figcaption&quot;, &quot;figure&quot;, &quot;footer&quot;, &quot;header&quot;, &quot;hgroup&quot;, &quot;listing&quot;, &quot;main&quot;,
			 * &gt; &quot;menu&quot;, &quot;nav&quot;, &quot;ol&quot;, &quot;pre&quot;, &quot;search&quot;, &quot;section&quot;, &quot;summary&quot;, &quot;ul&quot;
			 */
			case &#039;-ADDRESS&#039;:
			case &#039;-ARTICLE&#039;:
			case &#039;-ASIDE&#039;:
			case &#039;-BLOCKQUOTE&#039;:
			case &#039;-BUTTON&#039;:
			case &#039;-CENTER&#039;:
			case &#039;-DETAILS&#039;:
			case &#039;-DIALOG&#039;:
			case &#039;-DIR&#039;:
			case &#039;-DIV&#039;:
			case &#039;-DL&#039;:
			case &#039;-FIELDSET&#039;:
			case &#039;-FIGCAPTION&#039;:
			case &#039;-FIGURE&#039;:
			case &#039;-FOOTER&#039;:
			case &#039;-HEADER&#039;:
			case &#039;-HGROUP&#039;:
			case &#039;-LISTING&#039;:
			case &#039;-MAIN&#039;:
			case &#039;-MENU&#039;:
			case &#039;-NAV&#039;:
			case &#039;-OL&#039;:
			case &#039;-PRE&#039;:
			case &#039;-SEARCH&#039;:
			case &#039;-SECTION&#039;:
			case &#039;-SUMMARY&#039;:
			case &#039;-UL&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_scope( $token_name ) ) {
					// @todo Report parse error.
					// Ignore the token.
					return $this-&gt;step();
				}

				$this-&gt;generate_implied_end_tags();
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( $token_name ) ) {
					// @todo Record parse error: this error doesn&#039;t impact parsing.
				}
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop_until( $token_name );
				return true;

			/*
			 * &gt; An end tag whose tag name is &quot;form&quot;
			 */
			case &#039;-FORM&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;contains( &#039;TEMPLATE&#039; ) ) {
					$node                      = $this-&gt;state-&gt;form_element;
					$this-&gt;state-&gt;form_element = null;

					/*
					 * &gt; If node is null or if the stack of open elements does not have node
					 * &gt; in scope, then this is a parse error; return and ignore the token.
					 *
					 * @todo It&#039;s necessary to check if the form token itself is in scope, not
					 *       simply whether any FORM is in scope.
					 */
					if (
						null === $node ||
						! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_scope( &#039;FORM&#039; )
					) {
						// Parse error: ignore the token.
						return $this-&gt;step();
					}

					$this-&gt;generate_implied_end_tags();
					if ( $node !== $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node() ) {
						// @todo Indicate a parse error once it&#039;s possible. This error does not impact the logic here.
						$this-&gt;bail( &#039;Cannot close a FORM when other elements remain open as this would throw off the breadcrumbs for the following tokens.&#039; );
					}

					$this-&gt;state-&gt;stack_of_open_elements-&gt;remove_node( $node );
					return true;
				} else {
					/*
					 * &gt; If the stack of open elements does not have a form element in scope,
					 * &gt; then this is a parse error; return and ignore the token.
					 *
					 * Note that unlike in the clause above, this is checking for any FORM in scope.
					 */
					if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_scope( &#039;FORM&#039; ) ) {
						// Parse error: ignore the token.
						return $this-&gt;step();
					}

					$this-&gt;generate_implied_end_tags();

					if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( &#039;FORM&#039; ) ) {
						// @todo Indicate a parse error once it&#039;s possible. This error does not impact the logic here.
					}

					$this-&gt;state-&gt;stack_of_open_elements-&gt;pop_until( &#039;FORM&#039; );
					return true;
				}
				break;

			/*
			 * &gt; An end tag whose tag name is &quot;p&quot;
			 */
			case &#039;-P&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_p_in_button_scope() ) {
					$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				}

				$this-&gt;close_a_p_element();
				return true;

			/*
			 * &gt; An end tag whose tag name is &quot;li&quot;
			 * &gt; An end tag whose tag name is one of: &quot;dd&quot;, &quot;dt&quot;
			 */
			case &#039;-DD&#039;:
			case &#039;-DT&#039;:
			case &#039;-LI&#039;:
				if (
					/*
					 * An end tag whose tag name is &quot;li&quot;:
					 * If the stack of open elements does not have an li element in list item scope,
					 * then this is a parse error; ignore the token.
					 */
					(
						&#039;LI&#039; === $token_name &amp;&amp;
						! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_list_item_scope( &#039;LI&#039; )
					) ||
					/*
					 * An end tag whose tag name is one of: &quot;dd&quot;, &quot;dt&quot;:
					 * If the stack of open elements does not have an element in scope that is an
					 * HTML element with the same tag name as that of the token, then this is a
					 * parse error; ignore the token.
					 */
					(
						&#039;LI&#039; !== $token_name &amp;&amp;
						! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_scope( $token_name )
					)
				) {
					/*
					 * This is a parse error, ignore the token.
					 *
					 * @todo Indicate a parse error once it&#039;s possible.
					 */
					return $this-&gt;step();
				}

				$this-&gt;generate_implied_end_tags( $token_name );

				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( $token_name ) ) {
					// @todo Indicate a parse error once it&#039;s possible. This error does not impact the logic here.
				}

				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop_until( $token_name );
				return true;

			/*
			 * &gt; An end tag whose tag name is one of: &quot;h1&quot;, &quot;h2&quot;, &quot;h3&quot;, &quot;h4&quot;, &quot;h5&quot;, &quot;h6&quot;
			 */
			case &#039;-H1&#039;:
			case &#039;-H2&#039;:
			case &#039;-H3&#039;:
			case &#039;-H4&#039;:
			case &#039;-H5&#039;:
			case &#039;-H6&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_scope( &#039;(internal: H1 through H6 - do not use)&#039; ) ) {
					/*
					 * This is a parse error; ignore the token.
					 *
					 * @todo Indicate a parse error once it&#039;s possible.
					 */
					return $this-&gt;step();
				}

				$this-&gt;generate_implied_end_tags();

				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( $token_name ) ) {
					// @todo Record parse error: this error doesn&#039;t impact parsing.
				}

				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop_until( &#039;(internal: H1 through H6 - do not use)&#039; );
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;a&quot;
			 */
			case &#039;+A&#039;:
				foreach ( $this-&gt;state-&gt;active_formatting_elements-&gt;walk_up() as $item ) {
					switch ( $item-&gt;node_name ) {
						case &#039;marker&#039;:
							break 2;

						case &#039;A&#039;:
							$this-&gt;run_adoption_agency_algorithm();
							$this-&gt;state-&gt;active_formatting_elements-&gt;remove_node( $item );
							$this-&gt;state-&gt;stack_of_open_elements-&gt;remove_node( $item );
							break 2;
					}
				}

				$this-&gt;reconstruct_active_formatting_elements();
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;active_formatting_elements-&gt;push( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A start tag whose tag name is one of: &quot;b&quot;, &quot;big&quot;, &quot;code&quot;, &quot;em&quot;, &quot;font&quot;, &quot;i&quot;,
			 * &gt; &quot;s&quot;, &quot;small&quot;, &quot;strike&quot;, &quot;strong&quot;, &quot;tt&quot;, &quot;u&quot;
			 */
			case &#039;+B&#039;:
			case &#039;+BIG&#039;:
			case &#039;+CODE&#039;:
			case &#039;+EM&#039;:
			case &#039;+FONT&#039;:
			case &#039;+I&#039;:
			case &#039;+S&#039;:
			case &#039;+SMALL&#039;:
			case &#039;+STRIKE&#039;:
			case &#039;+STRONG&#039;:
			case &#039;+TT&#039;:
			case &#039;+U&#039;:
				$this-&gt;reconstruct_active_formatting_elements();
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;active_formatting_elements-&gt;push( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;nobr&quot;
			 */
			case &#039;+NOBR&#039;:
				$this-&gt;reconstruct_active_formatting_elements();

				if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_scope( &#039;NOBR&#039; ) ) {
					// Parse error.
					$this-&gt;run_adoption_agency_algorithm();
					$this-&gt;reconstruct_active_formatting_elements();
				}

				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;active_formatting_elements-&gt;push( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; An end tag whose tag name is one of: &quot;a&quot;, &quot;b&quot;, &quot;big&quot;, &quot;code&quot;, &quot;em&quot;, &quot;font&quot;, &quot;i&quot;,
			 * &gt; &quot;nobr&quot;, &quot;s&quot;, &quot;small&quot;, &quot;strike&quot;, &quot;strong&quot;, &quot;tt&quot;, &quot;u&quot;
			 */
			case &#039;-A&#039;:
			case &#039;-B&#039;:
			case &#039;-BIG&#039;:
			case &#039;-CODE&#039;:
			case &#039;-EM&#039;:
			case &#039;-FONT&#039;:
			case &#039;-I&#039;:
			case &#039;-NOBR&#039;:
			case &#039;-S&#039;:
			case &#039;-SMALL&#039;:
			case &#039;-STRIKE&#039;:
			case &#039;-STRONG&#039;:
			case &#039;-TT&#039;:
			case &#039;-U&#039;:
				$this-&gt;run_adoption_agency_algorithm();
				return true;

			/*
			 * &gt; A start tag whose tag name is one of: &quot;applet&quot;, &quot;marquee&quot;, &quot;object&quot;
			 */
			case &#039;+APPLET&#039;:
			case &#039;+MARQUEE&#039;:
			case &#039;+OBJECT&#039;:
				$this-&gt;reconstruct_active_formatting_elements();
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;active_formatting_elements-&gt;insert_marker();
				$this-&gt;state-&gt;frameset_ok = false;
				return true;

			/*
			 * &gt; A end tag token whose tag name is one of: &quot;applet&quot;, &quot;marquee&quot;, &quot;object&quot;
			 */
			case &#039;-APPLET&#039;:
			case &#039;-MARQUEE&#039;:
			case &#039;-OBJECT&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_scope( $token_name ) ) {
					// Parse error: ignore the token.
					return $this-&gt;step();
				}

				$this-&gt;generate_implied_end_tags();
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( $token_name ) ) {
					// This is a parse error.
				}

				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop_until( $token_name );
				$this-&gt;state-&gt;active_formatting_elements-&gt;clear_up_to_last_marker();
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;table&quot;
			 */
			case &#039;+TABLE&#039;:
				/*
				 * &gt; If the Document is not set to quirks mode, and the stack of open elements
				 * &gt; has a p element in button scope, then close a p element.
				 */
				if (
					WP_HTML_Tag_Processor::QUIRKS_MODE !== $this-&gt;compat_mode &amp;&amp;
					$this-&gt;state-&gt;stack_of_open_elements-&gt;has_p_in_button_scope()
				) {
					$this-&gt;close_a_p_element();
				}

				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;frameset_ok    = false;
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE;
				return true;

			/*
			 * &gt; An end tag whose tag name is &quot;br&quot;
			 *
			 * This is prevented from happening because the Tag Processor
			 * reports all closing BR tags as if they were opening tags.
			 */

			/*
			 * &gt; A start tag whose tag name is one of: &quot;area&quot;, &quot;br&quot;, &quot;embed&quot;, &quot;img&quot;, &quot;keygen&quot;, &quot;wbr&quot;
			 */
			case &#039;+AREA&#039;:
			case &#039;+BR&#039;:
			case &#039;+EMBED&#039;:
			case &#039;+IMG&#039;:
			case &#039;+KEYGEN&#039;:
			case &#039;+WBR&#039;:
				$this-&gt;reconstruct_active_formatting_elements();
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;frameset_ok = false;
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;input&quot;
			 */
			case &#039;+INPUT&#039;:
				$this-&gt;reconstruct_active_formatting_elements();
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );

				/*
				 * &gt; If the token does not have an attribute with the name &quot;type&quot;, or if it does,
				 * &gt; but that attribute&#039;s value is not an ASCII case-insensitive match for the
				 * &gt; string &quot;hidden&quot;, then: set the frameset-ok flag to &quot;not ok&quot;.
				 */
				$type_attribute = $this-&gt;get_attribute( &#039;type&#039; );
				if ( ! is_string( $type_attribute ) || &#039;hidden&#039; !== strtolower( $type_attribute ) ) {
					$this-&gt;state-&gt;frameset_ok = false;
				}

				return true;

			/*
			 * &gt; A start tag whose tag name is one of: &quot;param&quot;, &quot;source&quot;, &quot;track&quot;
			 */
			case &#039;+PARAM&#039;:
			case &#039;+SOURCE&#039;:
			case &#039;+TRACK&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;hr&quot;
			 */
			case &#039;+HR&#039;:
				if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;has_p_in_button_scope() ) {
					$this-&gt;close_a_p_element();
				}
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;frameset_ok = false;
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;image&quot;
			 */
			case &#039;+IMAGE&#039;:
				/*
				 * &gt; Parse error. Change the token&#039;s tag name to &quot;img&quot; and reprocess it. (Don&#039;t ask.)
				 *
				 * Note that this is handled elsewhere, so it should not be possible to reach this code.
				 */
				$this-&gt;bail( &quot;Cannot process an IMAGE tag. (Don&#039;t ask.)&quot; );
				break;

			/*
			 * &gt; A start tag whose tag name is &quot;textarea&quot;
			 */
			case &#039;+TEXTAREA&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );

				/*
				 * &gt; If the next token is a U+000A LINE FEED (LF) character token, then ignore
				 * &gt; that token and move on to the next one. (Newlines at the start of
				 * &gt; textarea elements are ignored as an authoring convenience.)
				 *
				 * This is handled in `get_modifiable_text()`.
				 */

				$this-&gt;state-&gt;frameset_ok = false;

				/*
				 * &gt; Switch the insertion mode to &quot;text&quot;.
				 *
				 * As a self-contained node, this behavior is handled in the Tag Processor.
				 */
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;xmp&quot;
			 */
			case &#039;+XMP&#039;:
				if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;has_p_in_button_scope() ) {
					$this-&gt;close_a_p_element();
				}

				$this-&gt;reconstruct_active_formatting_elements();
				$this-&gt;state-&gt;frameset_ok = false;

				/*
				 * &gt; Follow the generic raw text element parsing algorithm.
				 *
				 * As a self-contained node, this behavior is handled in the Tag Processor.
				 */
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * A start tag whose tag name is &quot;iframe&quot;
			 */
			case &#039;+IFRAME&#039;:
				$this-&gt;state-&gt;frameset_ok = false;

				/*
				 * &gt; Follow the generic raw text element parsing algorithm.
				 *
				 * As a self-contained node, this behavior is handled in the Tag Processor.
				 */
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;noembed&quot;
			 * &gt; A start tag whose tag name is &quot;noscript&quot;, if the scripting flag is enabled
			 *
			 * The scripting flag is never enabled in this parser.
			 */
			case &#039;+NOEMBED&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;select&quot;
			 */
			case &#039;+SELECT&#039;:
				$this-&gt;reconstruct_active_formatting_elements();
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;frameset_ok = false;

				switch ( $this-&gt;state-&gt;insertion_mode ) {
					/*
					 * &gt; If the insertion mode is one of &quot;in table&quot;, &quot;in caption&quot;, &quot;in table body&quot;, &quot;in row&quot;,
					 * &gt; or &quot;in cell&quot;, then switch the insertion mode to &quot;in select in table&quot;.
					 */
					case WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE:
					case WP_HTML_Processor_State::INSERTION_MODE_IN_CAPTION:
					case WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY:
					case WP_HTML_Processor_State::INSERTION_MODE_IN_ROW:
					case WP_HTML_Processor_State::INSERTION_MODE_IN_CELL:
						$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_SELECT_IN_TABLE;
						break;

					/*
					 * &gt; Otherwise, switch the insertion mode to &quot;in select&quot;.
					 */
					default:
						$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_SELECT;
						break;
				}
				return true;

			/*
			 * &gt; A start tag whose tag name is one of: &quot;optgroup&quot;, &quot;option&quot;
			 */
			case &#039;+OPTGROUP&#039;:
			case &#039;+OPTION&#039;:
				if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( &#039;OPTION&#039; ) ) {
					$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				}
				$this-&gt;reconstruct_active_formatting_elements();
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A start tag whose tag name is one of: &quot;rb&quot;, &quot;rtc&quot;
			 */
			case &#039;+RB&#039;:
			case &#039;+RTC&#039;:
				if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_scope( &#039;RUBY&#039; ) ) {
					$this-&gt;generate_implied_end_tags();

					if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( &#039;RUBY&#039; ) ) {
						// @todo Indicate a parse error once it&#039;s possible.
					}
				}

				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A start tag whose tag name is one of: &quot;rp&quot;, &quot;rt&quot;
			 */
			case &#039;+RP&#039;:
			case &#039;+RT&#039;:
				if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_scope( &#039;RUBY&#039; ) ) {
					$this-&gt;generate_implied_end_tags( &#039;RTC&#039; );

					$current_node_name = $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node()-&gt;node_name;
					if ( &#039;RTC&#039; === $current_node_name || &#039;RUBY&#039; === $current_node_name ) {
						// @todo Indicate a parse error once it&#039;s possible.
					}
				}

				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;math&quot;
			 */
			case &#039;+MATH&#039;:
				$this-&gt;reconstruct_active_formatting_elements();

				/*
				 * @todo Adjust MathML attributes for the token. (This fixes the case of MathML attributes that are not all lowercase.)
				 * @todo Adjust foreign attributes for the token. (This fixes the use of namespaced attributes, in particular XLink.)
				 *
				 * These ought to be handled in the attribute methods.
				 */
				$this-&gt;state-&gt;current_token-&gt;namespace = &#039;math&#039;;
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				if ( $this-&gt;state-&gt;current_token-&gt;has_self_closing_flag ) {
					$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				}
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;svg&quot;
			 */
			case &#039;+SVG&#039;:
				$this-&gt;reconstruct_active_formatting_elements();

				/*
				 * @todo Adjust SVG attributes for the token. (This fixes the case of SVG attributes that are not all lowercase.)
				 * @todo Adjust foreign attributes for the token. (This fixes the use of namespaced attributes, in particular XLink in SVG.)
				 *
				 * These ought to be handled in the attribute methods.
				 */
				$this-&gt;state-&gt;current_token-&gt;namespace = &#039;svg&#039;;
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				if ( $this-&gt;state-&gt;current_token-&gt;has_self_closing_flag ) {
					$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				}
				return true;

			/*
			 * &gt; A start tag whose tag name is one of: &quot;caption&quot;, &quot;col&quot;, &quot;colgroup&quot;,
			 * &gt; &quot;frame&quot;, &quot;head&quot;, &quot;tbody&quot;, &quot;td&quot;, &quot;tfoot&quot;, &quot;th&quot;, &quot;thead&quot;, &quot;tr&quot;
			 */
			case &#039;+CAPTION&#039;:
			case &#039;+COL&#039;:
			case &#039;+COLGROUP&#039;:
			case &#039;+FRAME&#039;:
			case &#039;+HEAD&#039;:
			case &#039;+TBODY&#039;:
			case &#039;+TD&#039;:
			case &#039;+TFOOT&#039;:
			case &#039;+TH&#039;:
			case &#039;+THEAD&#039;:
			case &#039;+TR&#039;:
				// Parse error. Ignore the token.
				return $this-&gt;step();
		}

		if ( ! parent::is_tag_closer() ) {
			/*
			 * &gt; Any other start tag
			 */
			$this-&gt;reconstruct_active_formatting_elements();
			$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
			return true;
		} else {
			/*
			 * &gt; Any other end tag
			 */

			/*
			 * Find the corresponding tag opener in the stack of open elements, if
			 * it exists before reaching a special element, which provides a kind
			 * of boundary in the stack. For example, a `&lt;/custom-tag&gt;` should not
			 * close anything beyond its containing `P` or `DIV` element.
			 */
			foreach ( $this-&gt;state-&gt;stack_of_open_elements-&gt;walk_up() as $node ) {
				if ( &#039;html&#039; === $node-&gt;namespace &amp;&amp; $token_name === $node-&gt;node_name ) {
					break;
				}

				if ( self::is_special( $node ) ) {
					// This is a parse error, ignore the token.
					return $this-&gt;step();
				}
			}

			$this-&gt;generate_implied_end_tags( $token_name );
			if ( $node !== $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node() ) {
				// @todo Record parse error: this error doesn&#039;t impact parsing.
			}

			foreach ( $this-&gt;state-&gt;stack_of_open_elements-&gt;walk_up() as $item ) {
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				if ( $node === $item ) {
					return true;
				}
			}
		}

		$this-&gt;bail( &#039;Should not have been able to reach end of IN BODY processing. Check HTML API code.&#039; );
		// This unnecessary return prevents tools from inaccurately reporting type errors.
		return false;
	}

	/**
	 * Parses next element in the &#039;in table&#039; insertion mode.
	 *
	 * This internal function performs the &#039;in table&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#parsing-main-intable
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_in_table(): bool {
		$token_name = $this-&gt;get_token_name();
		$token_type = $this-&gt;get_token_type();
		$op_sigil   = &#039;#tag&#039; === $token_type ? ( parent::is_tag_closer() ? &#039;-&#039; : &#039;+&#039; ) : &#039;&#039;;
		$op         = &quot;{$op_sigil}{$token_name}&quot;;

		switch ( $op ) {
			/*
			 * &gt; A character token, if the current node is table,
			 * &gt; tbody, template, tfoot, thead, or tr element
			 */
			case &#039;#text&#039;:
				$current_node      = $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node();
				$current_node_name = $current_node ? $current_node-&gt;node_name : null;
				if (
					$current_node_name &amp;&amp; (
						&#039;TABLE&#039; === $current_node_name ||
						&#039;TBODY&#039; === $current_node_name ||
						&#039;TEMPLATE&#039; === $current_node_name ||
						&#039;TFOOT&#039; === $current_node_name ||
						&#039;THEAD&#039; === $current_node_name ||
						&#039;TR&#039; === $current_node_name
					)
				) {
					/*
					 * If the text is empty after processing HTML entities and stripping
					 * U+0000 NULL bytes then ignore the token.
					 */
					if ( parent::TEXT_IS_NULL_SEQUENCE === $this-&gt;text_node_classification ) {
						return $this-&gt;step();
					}

					/*
					 * This follows the rules for &quot;in table text&quot; insertion mode.
					 *
					 * Whitespace-only text nodes are inserted in-place. Otherwise
					 * foster parenting is enabled and the nodes would be
					 * inserted out-of-place.
					 *
					 * &gt; If any of the tokens in the pending table character tokens
					 * &gt; list are character tokens that are not ASCII whitespace,
					 * &gt; then this is a parse error: reprocess the character tokens
					 * &gt; in the pending table character tokens list using the rules
					 * &gt; given in the &quot;anything else&quot; entry in the &quot;in table&quot;
					 * &gt; insertion mode.
					 * &gt;
					 * &gt; Otherwise, insert the characters given by the pending table
					 * &gt; character tokens list.
					 *
					 * @see https://html.spec.whatwg.org/#parsing-main-intabletext
					 */
					if ( parent::TEXT_IS_WHITESPACE === $this-&gt;text_node_classification ) {
						$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
						return true;
					}

					// Non-whitespace would trigger fostering, unsupported at this time.
					$this-&gt;bail( &#039;Foster parenting is not supported.&#039; );
					break;
				}
				break;

			/*
			 * &gt; A comment token
			 */
			case &#039;#comment&#039;:
			case &#039;#funky-comment&#039;:
			case &#039;#presumptuous-tag&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A DOCTYPE token
			 */
			case &#039;html&#039;:
				// Parse error: ignore the token.
				return $this-&gt;step();

			/*
			 * &gt; A start tag whose tag name is &quot;caption&quot;
			 */
			case &#039;+CAPTION&#039;:
				$this-&gt;state-&gt;stack_of_open_elements-&gt;clear_to_table_context();
				$this-&gt;state-&gt;active_formatting_elements-&gt;insert_marker();
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_CAPTION;
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;colgroup&quot;
			 */
			case &#039;+COLGROUP&#039;:
				$this-&gt;state-&gt;stack_of_open_elements-&gt;clear_to_table_context();
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_COLUMN_GROUP;
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;col&quot;
			 */
			case &#039;+COL&#039;:
				$this-&gt;state-&gt;stack_of_open_elements-&gt;clear_to_table_context();

				/*
				 * &gt; Insert an HTML element for a &quot;colgroup&quot; start tag token with no attributes,
				 * &gt; then switch the insertion mode to &quot;in column group&quot;.
				 */
				$this-&gt;insert_virtual_node( &#039;COLGROUP&#039; );
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_COLUMN_GROUP;
				return $this-&gt;step( self::REPROCESS_CURRENT_NODE );

			/*
			 * &gt; A start tag whose tag name is one of: &quot;tbody&quot;, &quot;tfoot&quot;, &quot;thead&quot;
			 */
			case &#039;+TBODY&#039;:
			case &#039;+TFOOT&#039;:
			case &#039;+THEAD&#039;:
				$this-&gt;state-&gt;stack_of_open_elements-&gt;clear_to_table_context();
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY;
				return true;

			/*
			 * &gt; A start tag whose tag name is one of: &quot;td&quot;, &quot;th&quot;, &quot;tr&quot;
			 */
			case &#039;+TD&#039;:
			case &#039;+TH&#039;:
			case &#039;+TR&#039;:
				$this-&gt;state-&gt;stack_of_open_elements-&gt;clear_to_table_context();
				/*
				 * &gt; Insert an HTML element for a &quot;tbody&quot; start tag token with no attributes,
				 * &gt; then switch the insertion mode to &quot;in table body&quot;.
				 */
				$this-&gt;insert_virtual_node( &#039;TBODY&#039; );
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY;
				return $this-&gt;step( self::REPROCESS_CURRENT_NODE );

			/*
			 * &gt; A start tag whose tag name is &quot;table&quot;
			 *
			 * This tag in the IN TABLE insertion mode is a parse error.
			 */
			case &#039;+TABLE&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_table_scope( &#039;TABLE&#039; ) ) {
					return $this-&gt;step();
				}

				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop_until( &#039;TABLE&#039; );
				$this-&gt;reset_insertion_mode_appropriately();
				return $this-&gt;step( self::REPROCESS_CURRENT_NODE );

			/*
			 * &gt; An end tag whose tag name is &quot;table&quot;
			 */
			case &#039;-TABLE&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_table_scope( &#039;TABLE&#039; ) ) {
					// @todo Indicate a parse error once it&#039;s possible.
					return $this-&gt;step();
				}

				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop_until( &#039;TABLE&#039; );
				$this-&gt;reset_insertion_mode_appropriately();
				return true;

			/*
			 * &gt; An end tag whose tag name is one of: &quot;body&quot;, &quot;caption&quot;, &quot;col&quot;, &quot;colgroup&quot;, &quot;html&quot;, &quot;tbody&quot;, &quot;td&quot;, &quot;tfoot&quot;, &quot;th&quot;, &quot;thead&quot;, &quot;tr&quot;
			 */
			case &#039;-BODY&#039;:
			case &#039;-CAPTION&#039;:
			case &#039;-COL&#039;:
			case &#039;-COLGROUP&#039;:
			case &#039;-HTML&#039;:
			case &#039;-TBODY&#039;:
			case &#039;-TD&#039;:
			case &#039;-TFOOT&#039;:
			case &#039;-TH&#039;:
			case &#039;-THEAD&#039;:
			case &#039;-TR&#039;:
				// Parse error: ignore the token.
				return $this-&gt;step();

			/*
			 * &gt; A start tag whose tag name is one of: &quot;style&quot;, &quot;script&quot;, &quot;template&quot;
			 * &gt; An end tag whose tag name is &quot;template&quot;
			 */
			case &#039;+STYLE&#039;:
			case &#039;+SCRIPT&#039;:
			case &#039;+TEMPLATE&#039;:
			case &#039;-TEMPLATE&#039;:
				/*
				 * &gt; Process the token using the rules for the &quot;in head&quot; insertion mode.
				 */
				return $this-&gt;step_in_head();

			/*
			 * &gt; A start tag whose tag name is &quot;input&quot;
			 *
			 * &gt; If the token does not have an attribute with the name &quot;type&quot;, or if it does, but
			 * &gt; that attribute&#039;s value is not an ASCII case-insensitive match for the string
			 * &gt; &quot;hidden&quot;, then: act as described in the &quot;anything else&quot; entry below.
			 */
			case &#039;+INPUT&#039;:
				$type_attribute = $this-&gt;get_attribute( &#039;type&#039; );
				if ( ! is_string( $type_attribute ) || &#039;hidden&#039; !== strtolower( $type_attribute ) ) {
					goto anything_else;
				}
				// @todo Indicate a parse error once it&#039;s possible.
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;form&quot;
			 *
			 * This tag in the IN TABLE insertion mode is a parse error.
			 */
			case &#039;+FORM&#039;:
				if (
					$this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_scope( &#039;TEMPLATE&#039; ) ||
					isset( $this-&gt;state-&gt;form_element )
				) {
					return $this-&gt;step();
				}

				// This FORM is special because it immediately closes and cannot have other children.
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;form_element = $this-&gt;state-&gt;current_token;
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				return true;
		}

		/*
		 * &gt; Anything else
		 * &gt; Parse error. Enable foster parenting, process the token using the rules for the
		 * &gt; &quot;in body&quot; insertion mode, and then disable foster parenting.
		 *
		 * @todo Indicate a parse error once it&#039;s possible.
		 */
		anything_else:
		$this-&gt;bail( &#039;Foster parenting is not supported.&#039; );
	}

	/**
	 * Parses next element in the &#039;in table text&#039; insertion mode.
	 *
	 * This internal function performs the &#039;in table text&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0 Stub implementation.
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#parsing-main-intabletext
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_in_table_text(): bool {
		$this-&gt;bail( &#039;No support for parsing in the &#039; . WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_TEXT . &#039; state.&#039; );
	}

	/**
	 * Parses next element in the &#039;in caption&#039; insertion mode.
	 *
	 * This internal function performs the &#039;in caption&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#parsing-main-incaption
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_in_caption(): bool {
		$tag_name = $this-&gt;get_tag();
		$op_sigil = $this-&gt;is_tag_closer() ? &#039;-&#039; : &#039;+&#039;;
		$op       = &quot;{$op_sigil}{$tag_name}&quot;;

		switch ( $op ) {
			/*
			 * &gt; An end tag whose tag name is &quot;caption&quot;
			 * &gt; A start tag whose tag name is one of: &quot;caption&quot;, &quot;col&quot;, &quot;colgroup&quot;, &quot;tbody&quot;, &quot;td&quot;, &quot;tfoot&quot;, &quot;th&quot;, &quot;thead&quot;, &quot;tr&quot;
			 * &gt; An end tag whose tag name is &quot;table&quot;
			 *
			 * These tag handling rules are identical except for the final instruction.
			 * Handle them in a single block.
			 */
			case &#039;-CAPTION&#039;:
			case &#039;+CAPTION&#039;:
			case &#039;+COL&#039;:
			case &#039;+COLGROUP&#039;:
			case &#039;+TBODY&#039;:
			case &#039;+TD&#039;:
			case &#039;+TFOOT&#039;:
			case &#039;+TH&#039;:
			case &#039;+THEAD&#039;:
			case &#039;+TR&#039;:
			case &#039;-TABLE&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_table_scope( &#039;CAPTION&#039; ) ) {
					// Parse error: ignore the token.
					return $this-&gt;step();
				}

				$this-&gt;generate_implied_end_tags();
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( &#039;CAPTION&#039; ) ) {
					// @todo Indicate a parse error once it&#039;s possible.
				}

				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop_until( &#039;CAPTION&#039; );
				$this-&gt;state-&gt;active_formatting_elements-&gt;clear_up_to_last_marker();
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE;

				// If this is not a CAPTION end tag, the token should be reprocessed.
				if ( &#039;-CAPTION&#039; === $op ) {
					return true;
				}
				return $this-&gt;step( self::REPROCESS_CURRENT_NODE );

			/**
			 * &gt; An end tag whose tag name is one of: &quot;body&quot;, &quot;col&quot;, &quot;colgroup&quot;, &quot;html&quot;, &quot;tbody&quot;, &quot;td&quot;, &quot;tfoot&quot;, &quot;th&quot;, &quot;thead&quot;, &quot;tr&quot;
			 */
			case &#039;-BODY&#039;:
			case &#039;-COL&#039;:
			case &#039;-COLGROUP&#039;:
			case &#039;-HTML&#039;:
			case &#039;-TBODY&#039;:
			case &#039;-TD&#039;:
			case &#039;-TFOOT&#039;:
			case &#039;-TH&#039;:
			case &#039;-THEAD&#039;:
			case &#039;-TR&#039;:
				// Parse error: ignore the token.
				return $this-&gt;step();
		}

		/**
		 * &gt; Anything else
		 * &gt;   Process the token using the rules for the &quot;in body&quot; insertion mode.
		 */
		return $this-&gt;step_in_body();
	}

	/**
	 * Parses next element in the &#039;in column group&#039; insertion mode.
	 *
	 * This internal function performs the &#039;in column group&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#parsing-main-incolgroup
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_in_column_group(): bool {
		$token_name = $this-&gt;get_token_name();
		$token_type = $this-&gt;get_token_type();
		$op_sigil   = &#039;#tag&#039; === $token_type ? ( parent::is_tag_closer() ? &#039;-&#039; : &#039;+&#039; ) : &#039;&#039;;
		$op         = &quot;{$op_sigil}{$token_name}&quot;;

		switch ( $op ) {
			/*
			 * &gt; A character token that is one of U+0009 CHARACTER TABULATION, U+000A LINE FEED (LF),
			 * &gt; U+000C FORM FEED (FF), U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
			 */
			case &#039;#text&#039;:
				if ( parent::TEXT_IS_WHITESPACE === $this-&gt;text_node_classification ) {
					// Insert the character.
					$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
					return true;
				}

				goto in_column_group_anything_else;
				break;

			/*
			 * &gt; A comment token
			 */
			case &#039;#comment&#039;:
			case &#039;#funky-comment&#039;:
			case &#039;#presumptuous-tag&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A DOCTYPE token
			 */
			case &#039;html&#039;:
				// @todo Indicate a parse error once it&#039;s possible.
				return $this-&gt;step();

			/*
			 * &gt; A start tag whose tag name is &quot;html&quot;
			 */
			case &#039;+HTML&#039;:
				return $this-&gt;step_in_body();

			/*
			 * &gt; A start tag whose tag name is &quot;col&quot;
			 */
			case &#039;+COL&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				return true;

			/*
			 * &gt; An end tag whose tag name is &quot;colgroup&quot;
			 */
			case &#039;-COLGROUP&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( &#039;COLGROUP&#039; ) ) {
					// @todo Indicate a parse error once it&#039;s possible.
					return $this-&gt;step();
				}
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE;
				return true;

			/*
			 * &gt; An end tag whose tag name is &quot;col&quot;
			 */
			case &#039;-COL&#039;:
				// Parse error: ignore the token.
				return $this-&gt;step();

			/*
			 * &gt; A start tag whose tag name is &quot;template&quot;
			 * &gt; An end tag whose tag name is &quot;template&quot;
			 */
			case &#039;+TEMPLATE&#039;:
			case &#039;-TEMPLATE&#039;:
				return $this-&gt;step_in_head();
		}

		in_column_group_anything_else:
		/*
		 * &gt; Anything else
		 */
		if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( &#039;COLGROUP&#039; ) ) {
			// @todo Indicate a parse error once it&#039;s possible.
			return $this-&gt;step();
		}
		$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
		$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE;
		return $this-&gt;step( self::REPROCESS_CURRENT_NODE );
	}

	/**
	 * Parses next element in the &#039;in table body&#039; insertion mode.
	 *
	 * This internal function performs the &#039;in table body&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#parsing-main-intbody
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_in_table_body(): bool {
		$tag_name = $this-&gt;get_tag();
		$op_sigil = $this-&gt;is_tag_closer() ? &#039;-&#039; : &#039;+&#039;;
		$op       = &quot;{$op_sigil}{$tag_name}&quot;;

		switch ( $op ) {
			/*
			 * &gt; A start tag whose tag name is &quot;tr&quot;
			 */
			case &#039;+TR&#039;:
				$this-&gt;state-&gt;stack_of_open_elements-&gt;clear_to_table_body_context();
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_ROW;
				return true;

			/*
			 * &gt; A start tag whose tag name is one of: &quot;th&quot;, &quot;td&quot;
			 */
			case &#039;+TH&#039;:
			case &#039;+TD&#039;:
				// @todo Indicate a parse error once it&#039;s possible.
				$this-&gt;state-&gt;stack_of_open_elements-&gt;clear_to_table_body_context();
				$this-&gt;insert_virtual_node( &#039;TR&#039; );
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_ROW;
				return $this-&gt;step( self::REPROCESS_CURRENT_NODE );

			/*
			 * &gt; An end tag whose tag name is one of: &quot;tbody&quot;, &quot;tfoot&quot;, &quot;thead&quot;
			 */
			case &#039;-TBODY&#039;:
			case &#039;-TFOOT&#039;:
			case &#039;-THEAD&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_table_scope( $tag_name ) ) {
					// Parse error: ignore the token.
					return $this-&gt;step();
				}

				$this-&gt;state-&gt;stack_of_open_elements-&gt;clear_to_table_body_context();
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE;
				return true;

			/*
			 * &gt; A start tag whose tag name is one of: &quot;caption&quot;, &quot;col&quot;, &quot;colgroup&quot;, &quot;tbody&quot;, &quot;tfoot&quot;, &quot;thead&quot;
			 * &gt; An end tag whose tag name is &quot;table&quot;
			 */
			case &#039;+CAPTION&#039;:
			case &#039;+COL&#039;:
			case &#039;+COLGROUP&#039;:
			case &#039;+TBODY&#039;:
			case &#039;+TFOOT&#039;:
			case &#039;+THEAD&#039;:
			case &#039;-TABLE&#039;:
				if (
					! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_table_scope( &#039;TBODY&#039; ) &amp;&amp;
					! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_table_scope( &#039;THEAD&#039; ) &amp;&amp;
					! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_table_scope( &#039;TFOOT&#039; )
				) {
					// Parse error: ignore the token.
					return $this-&gt;step();
				}
				$this-&gt;state-&gt;stack_of_open_elements-&gt;clear_to_table_body_context();
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE;
				return $this-&gt;step( self::REPROCESS_CURRENT_NODE );

			/*
			 * &gt; An end tag whose tag name is one of: &quot;body&quot;, &quot;caption&quot;, &quot;col&quot;, &quot;colgroup&quot;, &quot;html&quot;, &quot;td&quot;, &quot;th&quot;, &quot;tr&quot;
			 */
			case &#039;-BODY&#039;:
			case &#039;-CAPTION&#039;:
			case &#039;-COL&#039;:
			case &#039;-COLGROUP&#039;:
			case &#039;-HTML&#039;:
			case &#039;-TD&#039;:
			case &#039;-TH&#039;:
			case &#039;-TR&#039;:
				// Parse error: ignore the token.
				return $this-&gt;step();
		}

		/*
		 * &gt; Anything else
		 * &gt; Process the token using the rules for the &quot;in table&quot; insertion mode.
		 */
		return $this-&gt;step_in_table();
	}

	/**
	 * Parses next element in the &#039;in row&#039; insertion mode.
	 *
	 * This internal function performs the &#039;in row&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#parsing-main-intr
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_in_row(): bool {
		$tag_name = $this-&gt;get_tag();
		$op_sigil = $this-&gt;is_tag_closer() ? &#039;-&#039; : &#039;+&#039;;
		$op       = &quot;{$op_sigil}{$tag_name}&quot;;

		switch ( $op ) {
			/*
			 * &gt; A start tag whose tag name is one of: &quot;th&quot;, &quot;td&quot;
			 */
			case &#039;+TH&#039;:
			case &#039;+TD&#039;:
				$this-&gt;state-&gt;stack_of_open_elements-&gt;clear_to_table_row_context();
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_CELL;
				$this-&gt;state-&gt;active_formatting_elements-&gt;insert_marker();
				return true;

			/*
			 * &gt; An end tag whose tag name is &quot;tr&quot;
			 */
			case &#039;-TR&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_table_scope( &#039;TR&#039; ) ) {
					// Parse error: ignore the token.
					return $this-&gt;step();
				}

				$this-&gt;state-&gt;stack_of_open_elements-&gt;clear_to_table_row_context();
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY;
				return true;

			/*
			 * &gt; A start tag whose tag name is one of: &quot;caption&quot;, &quot;col&quot;, &quot;colgroup&quot;, &quot;tbody&quot;, &quot;tfoot&quot;, &quot;thead&quot;, &quot;tr&quot;
			 * &gt; An end tag whose tag name is &quot;table&quot;
			 */
			case &#039;+CAPTION&#039;:
			case &#039;+COL&#039;:
			case &#039;+COLGROUP&#039;:
			case &#039;+TBODY&#039;:
			case &#039;+TFOOT&#039;:
			case &#039;+THEAD&#039;:
			case &#039;+TR&#039;:
			case &#039;-TABLE&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_table_scope( &#039;TR&#039; ) ) {
					// Parse error: ignore the token.
					return $this-&gt;step();
				}

				$this-&gt;state-&gt;stack_of_open_elements-&gt;clear_to_table_row_context();
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY;
				return $this-&gt;step( self::REPROCESS_CURRENT_NODE );

			/*
			 * &gt; An end tag whose tag name is one of: &quot;tbody&quot;, &quot;tfoot&quot;, &quot;thead&quot;
			 */
			case &#039;-TBODY&#039;:
			case &#039;-TFOOT&#039;:
			case &#039;-THEAD&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_table_scope( $tag_name ) ) {
					// Parse error: ignore the token.
					return $this-&gt;step();
				}

				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_table_scope( &#039;TR&#039; ) ) {
					// Ignore the token.
					return $this-&gt;step();
				}

				$this-&gt;state-&gt;stack_of_open_elements-&gt;clear_to_table_row_context();
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY;
				return $this-&gt;step( self::REPROCESS_CURRENT_NODE );

			/*
			 * &gt; An end tag whose tag name is one of: &quot;body&quot;, &quot;caption&quot;, &quot;col&quot;, &quot;colgroup&quot;, &quot;html&quot;, &quot;td&quot;, &quot;th&quot;
			 */
			case &#039;-BODY&#039;:
			case &#039;-CAPTION&#039;:
			case &#039;-COL&#039;:
			case &#039;-COLGROUP&#039;:
			case &#039;-HTML&#039;:
			case &#039;-TD&#039;:
			case &#039;-TH&#039;:
				// Parse error: ignore the token.
				return $this-&gt;step();
		}

		/*
		 * &gt; Anything else
		 * &gt;   Process the token using the rules for the &quot;in table&quot; insertion mode.
		 */
		return $this-&gt;step_in_table();
	}

	/**
	 * Parses next element in the &#039;in cell&#039; insertion mode.
	 *
	 * This internal function performs the &#039;in cell&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#parsing-main-intd
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_in_cell(): bool {
		$tag_name = $this-&gt;get_tag();
		$op_sigil = $this-&gt;is_tag_closer() ? &#039;-&#039; : &#039;+&#039;;
		$op       = &quot;{$op_sigil}{$tag_name}&quot;;

		switch ( $op ) {
			/*
			 * &gt; An end tag whose tag name is one of: &quot;td&quot;, &quot;th&quot;
			 */
			case &#039;-TD&#039;:
			case &#039;-TH&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_table_scope( $tag_name ) ) {
					// Parse error: ignore the token.
					return $this-&gt;step();
				}

				$this-&gt;generate_implied_end_tags();

				/*
				 * @todo This needs to check if the current node is an HTML element, meaning that
				 *       when SVG and MathML support is added, this needs to differentiate between an
				 *       HTML element of the given name, such as `&lt;center&gt;`, and a foreign element of
				 *       the same given name.
				 */
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( $tag_name ) ) {
					// @todo Indicate a parse error once it&#039;s possible.
				}

				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop_until( $tag_name );
				$this-&gt;state-&gt;active_formatting_elements-&gt;clear_up_to_last_marker();
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_ROW;
				return true;

			/*
			 * &gt; A start tag whose tag name is one of: &quot;caption&quot;, &quot;col&quot;, &quot;colgroup&quot;, &quot;tbody&quot;, &quot;td&quot;,
			 * &gt; &quot;tfoot&quot;, &quot;th&quot;, &quot;thead&quot;, &quot;tr&quot;
			 */
			case &#039;+CAPTION&#039;:
			case &#039;+COL&#039;:
			case &#039;+COLGROUP&#039;:
			case &#039;+TBODY&#039;:
			case &#039;+TD&#039;:
			case &#039;+TFOOT&#039;:
			case &#039;+TH&#039;:
			case &#039;+THEAD&#039;:
			case &#039;+TR&#039;:
				/*
				 * &gt; Assert: The stack of open elements has a td or th element in table scope.
				 *
				 * Nothing to do here, except to verify in tests that this never appears.
				 */

				$this-&gt;close_cell();
				return $this-&gt;step( self::REPROCESS_CURRENT_NODE );

			/*
			 * &gt; An end tag whose tag name is one of: &quot;body&quot;, &quot;caption&quot;, &quot;col&quot;, &quot;colgroup&quot;, &quot;html&quot;
			 */
			case &#039;-BODY&#039;:
			case &#039;-CAPTION&#039;:
			case &#039;-COL&#039;:
			case &#039;-COLGROUP&#039;:
			case &#039;-HTML&#039;:
				// Parse error: ignore the token.
				return $this-&gt;step();

			/*
			 * &gt; An end tag whose tag name is one of: &quot;table&quot;, &quot;tbody&quot;, &quot;tfoot&quot;, &quot;thead&quot;, &quot;tr&quot;
			 */
			case &#039;-TABLE&#039;:
			case &#039;-TBODY&#039;:
			case &#039;-TFOOT&#039;:
			case &#039;-THEAD&#039;:
			case &#039;-TR&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_table_scope( $tag_name ) ) {
					// Parse error: ignore the token.
					return $this-&gt;step();
				}
				$this-&gt;close_cell();
				return $this-&gt;step( self::REPROCESS_CURRENT_NODE );
		}

		/*
		 * &gt; Anything else
		 * &gt;   Process the token using the rules for the &quot;in body&quot; insertion mode.
		 */
		return $this-&gt;step_in_body();
	}

	/**
	 * Parses next element in the &#039;in select&#039; insertion mode.
	 *
	 * This internal function performs the &#039;in select&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inselect
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_in_select(): bool {
		$token_name = $this-&gt;get_token_name();
		$token_type = $this-&gt;get_token_type();
		$op_sigil   = &#039;#tag&#039; === $token_type ? ( parent::is_tag_closer() ? &#039;-&#039; : &#039;+&#039; ) : &#039;&#039;;
		$op         = &quot;{$op_sigil}{$token_name}&quot;;

		switch ( $op ) {
			/*
			 * &gt; Any other character token
			 */
			case &#039;#text&#039;:
				/*
				 * &gt; A character token that is U+0000 NULL
				 *
				 * If a text node only comprises null bytes then it should be
				 * entirely ignored and should not return to calling code.
				 */
				if ( parent::TEXT_IS_NULL_SEQUENCE === $this-&gt;text_node_classification ) {
					// Parse error: ignore the token.
					return $this-&gt;step();
				}

				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A comment token
			 */
			case &#039;#comment&#039;:
			case &#039;#funky-comment&#039;:
			case &#039;#presumptuous-tag&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A DOCTYPE token
			 */
			case &#039;html&#039;:
				// Parse error: ignore the token.
				return $this-&gt;step();

			/*
			 * &gt; A start tag whose tag name is &quot;html&quot;
			 */
			case &#039;+HTML&#039;:
				return $this-&gt;step_in_body();

			/*
			 * &gt; A start tag whose tag name is &quot;option&quot;
			 */
			case &#039;+OPTION&#039;:
				if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( &#039;OPTION&#039; ) ) {
					$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				}
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;optgroup&quot;
			 * &gt; A start tag whose tag name is &quot;hr&quot;
			 *
			 * These rules are identical except for the treatment of the self-closing flag and
			 * the subsequent pop of the HR void element, all of which is handled elsewhere in the processor.
			 */
			case &#039;+OPTGROUP&#039;:
			case &#039;+HR&#039;:
				if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( &#039;OPTION&#039; ) ) {
					$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				}

				if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( &#039;OPTGROUP&#039; ) ) {
					$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				}

				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; An end tag whose tag name is &quot;optgroup&quot;
			 */
			case &#039;-OPTGROUP&#039;:
				$current_node = $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node();
				if ( $current_node &amp;&amp; &#039;OPTION&#039; === $current_node-&gt;node_name ) {
					foreach ( $this-&gt;state-&gt;stack_of_open_elements-&gt;walk_up( $current_node ) as $parent ) {
						break;
					}
					if ( $parent &amp;&amp; &#039;OPTGROUP&#039; === $parent-&gt;node_name ) {
						$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
					}
				}

				if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( &#039;OPTGROUP&#039; ) ) {
					$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
					return true;
				}

				// Parse error: ignore the token.
				return $this-&gt;step();

			/*
			 * &gt; An end tag whose tag name is &quot;option&quot;
			 */
			case &#039;-OPTION&#039;:
				if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( &#039;OPTION&#039; ) ) {
					$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
					return true;
				}

				// Parse error: ignore the token.
				return $this-&gt;step();

			/*
			 * &gt; An end tag whose tag name is &quot;select&quot;
			 * &gt; A start tag whose tag name is &quot;select&quot;
			 *
			 * &gt; It just gets treated like an end tag.
			 */
			case &#039;-SELECT&#039;:
			case &#039;+SELECT&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_select_scope( &#039;SELECT&#039; ) ) {
					// Parse error: ignore the token.
					return $this-&gt;step();
				}
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop_until( &#039;SELECT&#039; );
				$this-&gt;reset_insertion_mode_appropriately();
				return true;

			/*
			 * &gt; A start tag whose tag name is one of: &quot;input&quot;, &quot;keygen&quot;, &quot;textarea&quot;
			 *
			 * All three of these tags are considered a parse error when found in this insertion mode.
			 */
			case &#039;+INPUT&#039;:
			case &#039;+KEYGEN&#039;:
			case &#039;+TEXTAREA&#039;:
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_select_scope( &#039;SELECT&#039; ) ) {
					// Ignore the token.
					return $this-&gt;step();
				}
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop_until( &#039;SELECT&#039; );
				$this-&gt;reset_insertion_mode_appropriately();
				return $this-&gt;step( self::REPROCESS_CURRENT_NODE );

			/*
			 * &gt; A start tag whose tag name is one of: &quot;script&quot;, &quot;template&quot;
			 * &gt; An end tag whose tag name is &quot;template&quot;
			 */
			case &#039;+SCRIPT&#039;:
			case &#039;+TEMPLATE&#039;:
			case &#039;-TEMPLATE&#039;:
				return $this-&gt;step_in_head();
		}

		/*
		 * &gt; Anything else
		 * &gt;   Parse error: ignore the token.
		 */
		return $this-&gt;step();
	}

	/**
	 * Parses next element in the &#039;in select in table&#039; insertion mode.
	 *
	 * This internal function performs the &#039;in select in table&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#parsing-main-inselectintable
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_in_select_in_table(): bool {
		$token_name = $this-&gt;get_token_name();
		$token_type = $this-&gt;get_token_type();
		$op_sigil   = &#039;#tag&#039; === $token_type ? ( parent::is_tag_closer() ? &#039;-&#039; : &#039;+&#039; ) : &#039;&#039;;
		$op         = &quot;{$op_sigil}{$token_name}&quot;;

		switch ( $op ) {
			/*
			 * &gt; A start tag whose tag name is one of: &quot;caption&quot;, &quot;table&quot;, &quot;tbody&quot;, &quot;tfoot&quot;, &quot;thead&quot;, &quot;tr&quot;, &quot;td&quot;, &quot;th&quot;
			 */
			case &#039;+CAPTION&#039;:
			case &#039;+TABLE&#039;:
			case &#039;+TBODY&#039;:
			case &#039;+TFOOT&#039;:
			case &#039;+THEAD&#039;:
			case &#039;+TR&#039;:
			case &#039;+TD&#039;:
			case &#039;+TH&#039;:
				// @todo Indicate a parse error once it&#039;s possible.
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop_until( &#039;SELECT&#039; );
				$this-&gt;reset_insertion_mode_appropriately();
				return $this-&gt;step( self::REPROCESS_CURRENT_NODE );

			/*
			 * &gt; An end tag whose tag name is one of: &quot;caption&quot;, &quot;table&quot;, &quot;tbody&quot;, &quot;tfoot&quot;, &quot;thead&quot;, &quot;tr&quot;, &quot;td&quot;, &quot;th&quot;
			 */
			case &#039;-CAPTION&#039;:
			case &#039;-TABLE&#039;:
			case &#039;-TBODY&#039;:
			case &#039;-TFOOT&#039;:
			case &#039;-THEAD&#039;:
			case &#039;-TR&#039;:
			case &#039;-TD&#039;:
			case &#039;-TH&#039;:
				// @todo Indicate a parse error once it&#039;s possible.
				if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_table_scope( $token_name ) ) {
					return $this-&gt;step();
				}
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop_until( &#039;SELECT&#039; );
				$this-&gt;reset_insertion_mode_appropriately();
				return $this-&gt;step( self::REPROCESS_CURRENT_NODE );
		}

		/*
		 * &gt; Anything else
		 */
		return $this-&gt;step_in_select();
	}

	/**
	 * Parses next element in the &#039;in template&#039; insertion mode.
	 *
	 * This internal function performs the &#039;in template&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0 Stub implementation.
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#parsing-main-intemplate
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_in_template(): bool {
		$token_name = $this-&gt;get_token_name();
		$token_type = $this-&gt;get_token_type();
		$is_closer  = $this-&gt;is_tag_closer();
		$op_sigil   = &#039;#tag&#039; === $token_type ? ( $is_closer ? &#039;-&#039; : &#039;+&#039; ) : &#039;&#039;;
		$op         = &quot;{$op_sigil}{$token_name}&quot;;

		switch ( $op ) {
			/*
			 * &gt; A character token
			 * &gt; A comment token
			 * &gt; A DOCTYPE token
			 */
			case &#039;#text&#039;:
			case &#039;#comment&#039;:
			case &#039;#funky-comment&#039;:
			case &#039;#presumptuous-tag&#039;:
			case &#039;html&#039;:
				return $this-&gt;step_in_body();

			/*
			 * &gt; A start tag whose tag name is one of: &quot;base&quot;, &quot;basefont&quot;, &quot;bgsound&quot;, &quot;link&quot;,
			 * &gt; &quot;meta&quot;, &quot;noframes&quot;, &quot;script&quot;, &quot;style&quot;, &quot;template&quot;, &quot;title&quot;
			 * &gt; An end tag whose tag name is &quot;template&quot;
			 */
			case &#039;+BASE&#039;:
			case &#039;+BASEFONT&#039;:
			case &#039;+BGSOUND&#039;:
			case &#039;+LINK&#039;:
			case &#039;+META&#039;:
			case &#039;+NOFRAMES&#039;:
			case &#039;+SCRIPT&#039;:
			case &#039;+STYLE&#039;:
			case &#039;+TEMPLATE&#039;:
			case &#039;+TITLE&#039;:
			case &#039;-TEMPLATE&#039;:
				return $this-&gt;step_in_head();

			/*
			 * &gt; A start tag whose tag name is one of: &quot;caption&quot;, &quot;colgroup&quot;, &quot;tbody&quot;, &quot;tfoot&quot;, &quot;thead&quot;
			 */
			case &#039;+CAPTION&#039;:
			case &#039;+COLGROUP&#039;:
			case &#039;+TBODY&#039;:
			case &#039;+TFOOT&#039;:
			case &#039;+THEAD&#039;:
				array_pop( $this-&gt;state-&gt;stack_of_template_insertion_modes );
				$this-&gt;state-&gt;stack_of_template_insertion_modes[] = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE;
				$this-&gt;state-&gt;insertion_mode                      = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE;
				return $this-&gt;step( self::REPROCESS_CURRENT_NODE );

			/*
			 * &gt; A start tag whose tag name is &quot;col&quot;
			 */
			case &#039;+COL&#039;:
				array_pop( $this-&gt;state-&gt;stack_of_template_insertion_modes );
				$this-&gt;state-&gt;stack_of_template_insertion_modes[] = WP_HTML_Processor_State::INSERTION_MODE_IN_COLUMN_GROUP;
				$this-&gt;state-&gt;insertion_mode                      = WP_HTML_Processor_State::INSERTION_MODE_IN_COLUMN_GROUP;
				return $this-&gt;step( self::REPROCESS_CURRENT_NODE );

			/*
			 * &gt; A start tag whose tag name is &quot;tr&quot;
			 */
			case &#039;+TR&#039;:
				array_pop( $this-&gt;state-&gt;stack_of_template_insertion_modes );
				$this-&gt;state-&gt;stack_of_template_insertion_modes[] = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY;
				$this-&gt;state-&gt;insertion_mode                      = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY;
				return $this-&gt;step( self::REPROCESS_CURRENT_NODE );

			/*
			 * &gt; A start tag whose tag name is one of: &quot;td&quot;, &quot;th&quot;
			 */
			case &#039;+TD&#039;:
			case &#039;+TH&#039;:
				array_pop( $this-&gt;state-&gt;stack_of_template_insertion_modes );
				$this-&gt;state-&gt;stack_of_template_insertion_modes[] = WP_HTML_Processor_State::INSERTION_MODE_IN_ROW;
				$this-&gt;state-&gt;insertion_mode                      = WP_HTML_Processor_State::INSERTION_MODE_IN_ROW;
				return $this-&gt;step( self::REPROCESS_CURRENT_NODE );
		}

		/*
		 * &gt; Any other start tag
		 */
		if ( ! $is_closer ) {
			array_pop( $this-&gt;state-&gt;stack_of_template_insertion_modes );
			$this-&gt;state-&gt;stack_of_template_insertion_modes[] = WP_HTML_Processor_State::INSERTION_MODE_IN_BODY;
			$this-&gt;state-&gt;insertion_mode                      = WP_HTML_Processor_State::INSERTION_MODE_IN_BODY;
			return $this-&gt;step( self::REPROCESS_CURRENT_NODE );
		}

		/*
		 * &gt; Any other end tag
		 */
		if ( $is_closer ) {
			// Parse error: ignore the token.
			return $this-&gt;step();
		}

		/*
		 * &gt; An end-of-file token
		 */
		if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;contains( &#039;TEMPLATE&#039; ) ) {
			// Stop parsing.
			return false;
		}

		// @todo Indicate a parse error once it&#039;s possible.
		$this-&gt;state-&gt;stack_of_open_elements-&gt;pop_until( &#039;TEMPLATE&#039; );
		$this-&gt;state-&gt;active_formatting_elements-&gt;clear_up_to_last_marker();
		array_pop( $this-&gt;state-&gt;stack_of_template_insertion_modes );
		$this-&gt;reset_insertion_mode_appropriately();
		return $this-&gt;step( self::REPROCESS_CURRENT_NODE );
	}

	/**
	 * Parses next element in the &#039;after body&#039; insertion mode.
	 *
	 * This internal function performs the &#039;after body&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0 Stub implementation.
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#parsing-main-afterbody
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_after_body(): bool {
		$tag_name   = $this-&gt;get_token_name();
		$token_type = $this-&gt;get_token_type();
		$op_sigil   = &#039;#tag&#039; === $token_type ? ( $this-&gt;is_tag_closer() ? &#039;-&#039; : &#039;+&#039; ) : &#039;&#039;;
		$op         = &quot;{$op_sigil}{$tag_name}&quot;;

		switch ( $op ) {
			/*
			 * &gt; A character token that is one of U+0009 CHARACTER TABULATION, U+000A LINE FEED (LF),
			 * &gt;   U+000C FORM FEED (FF), U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
			 *
			 * &gt; Process the token using the rules for the &quot;in body&quot; insertion mode.
			 */
			case &#039;#text&#039;:
				if ( parent::TEXT_IS_WHITESPACE === $this-&gt;text_node_classification ) {
					return $this-&gt;step_in_body();
				}
				goto after_body_anything_else;
				break;

			/*
			 * &gt; A comment token
			 */
			case &#039;#comment&#039;:
			case &#039;#funky-comment&#039;:
			case &#039;#presumptuous-tag&#039;:
				$this-&gt;bail( &#039;Content outside of BODY is unsupported.&#039; );
				break;

			/*
			 * &gt; A DOCTYPE token
			 */
			case &#039;html&#039;:
				// Parse error: ignore the token.
				return $this-&gt;step();

			/*
			 * &gt; A start tag whose tag name is &quot;html&quot;
			 */
			case &#039;+HTML&#039;:
				return $this-&gt;step_in_body();

			/*
			 * &gt; An end tag whose tag name is &quot;html&quot;
			 *
			 * &gt; If the parser was created as part of the HTML fragment parsing algorithm,
			 * &gt; this is a parse error; ignore the token. (fragment case)
			 * &gt;
			 * &gt; Otherwise, switch the insertion mode to &quot;after after body&quot;.
			 */
			case &#039;-HTML&#039;:
				if ( isset( $this-&gt;context_node ) ) {
					return $this-&gt;step();
				}

				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_AFTER_AFTER_BODY;
				/*
				 * The HTML element is not removed from the stack of open elements.
				 * Only internal state has changed, this does not qualify as a &quot;step&quot;
				 * in terms of advancing through the document to another token.
				 * Nothing has been pushed or popped.
				 * Proceed to parse the next item.
				 */
				return $this-&gt;step();
		}

		/*
		 * &gt; Parse error. Switch the insertion mode to &quot;in body&quot; and reprocess the token.
		 */
		after_body_anything_else:
		$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_BODY;
		return $this-&gt;step( self::REPROCESS_CURRENT_NODE );
	}

	/**
	 * Parses next element in the &#039;in frameset&#039; insertion mode.
	 *
	 * This internal function performs the &#039;in frameset&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0 Stub implementation.
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#parsing-main-inframeset
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_in_frameset(): bool {
		$tag_name   = $this-&gt;get_token_name();
		$token_type = $this-&gt;get_token_type();
		$op_sigil   = &#039;#tag&#039; === $token_type ? ( $this-&gt;is_tag_closer() ? &#039;-&#039; : &#039;+&#039; ) : &#039;&#039;;
		$op         = &quot;{$op_sigil}{$tag_name}&quot;;

		switch ( $op ) {
			/*
			 * &gt; A character token that is one of U+0009 CHARACTER TABULATION, U+000A LINE FEED (LF),
			 * &gt;   U+000C FORM FEED (FF), U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
			 * &gt;
			 * &gt; Insert the character.
			 *
			 * This algorithm effectively strips non-whitespace characters from text and inserts
			 * them under HTML. This is not supported at this time.
			 */
			case &#039;#text&#039;:
				if ( parent::TEXT_IS_WHITESPACE === $this-&gt;text_node_classification ) {
					return $this-&gt;step_in_body();
				}
				$this-&gt;bail( &#039;Non-whitespace characters cannot be handled in frameset.&#039; );
				break;

			/*
			 * &gt; A comment token
			 */
			case &#039;#comment&#039;:
			case &#039;#funky-comment&#039;:
			case &#039;#presumptuous-tag&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A DOCTYPE token
			 */
			case &#039;html&#039;:
				// Parse error: ignore the token.
				return $this-&gt;step();

			/*
			 * &gt; A start tag whose tag name is &quot;html&quot;
			 */
			case &#039;+HTML&#039;:
				return $this-&gt;step_in_body();

			/*
			 * &gt; A start tag whose tag name is &quot;frameset&quot;
			 */
			case &#039;+FRAMESET&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; An end tag whose tag name is &quot;frameset&quot;
			 */
			case &#039;-FRAMESET&#039;:
				/*
				 * &gt; If the current node is the root html element, then this is a parse error;
				 * &gt; ignore the token. (fragment case)
				 */
				if ( $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( &#039;HTML&#039; ) ) {
					return $this-&gt;step();
				}

				/*
				 * &gt; Otherwise, pop the current node from the stack of open elements.
				 */
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();

				/*
				 * &gt; If the parser was not created as part of the HTML fragment parsing algorithm
				 * &gt; (fragment case), and the current node is no longer a frameset element, then
				 * &gt; switch the insertion mode to &quot;after frameset&quot;.
				 */
				if ( ! isset( $this-&gt;context_node ) &amp;&amp; ! $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( &#039;FRAMESET&#039; ) ) {
					$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_AFTER_FRAMESET;
				}

				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;frame&quot;
			 *
			 * &gt; Insert an HTML element for the token. Immediately pop the
			 * &gt; current node off the stack of open elements.
			 * &gt;
			 * &gt; Acknowledge the token&#039;s self-closing flag, if it is set.
			 */
			case &#039;+FRAME&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				return true;

			/*
			 * &gt; A start tag whose tag name is &quot;noframes&quot;
			 */
			case &#039;+NOFRAMES&#039;:
				return $this-&gt;step_in_head();
		}

		// Parse error: ignore the token.
		return $this-&gt;step();
	}

	/**
	 * Parses next element in the &#039;after frameset&#039; insertion mode.
	 *
	 * This internal function performs the &#039;after frameset&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0 Stub implementation.
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#parsing-main-afterframeset
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_after_frameset(): bool {
		$tag_name   = $this-&gt;get_token_name();
		$token_type = $this-&gt;get_token_type();
		$op_sigil   = &#039;#tag&#039; === $token_type ? ( $this-&gt;is_tag_closer() ? &#039;-&#039; : &#039;+&#039; ) : &#039;&#039;;
		$op         = &quot;{$op_sigil}{$tag_name}&quot;;

		switch ( $op ) {
			/*
			 * &gt; A character token that is one of U+0009 CHARACTER TABULATION, U+000A LINE FEED (LF),
			 * &gt;   U+000C FORM FEED (FF), U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
			 * &gt;
			 * &gt; Insert the character.
			 *
			 * This algorithm effectively strips non-whitespace characters from text and inserts
			 * them under HTML. This is not supported at this time.
			 */
			case &#039;#text&#039;:
				if ( parent::TEXT_IS_WHITESPACE === $this-&gt;text_node_classification ) {
					return $this-&gt;step_in_body();
				}
				$this-&gt;bail( &#039;Non-whitespace characters cannot be handled in after frameset&#039; );
				break;

			/*
			 * &gt; A comment token
			 */
			case &#039;#comment&#039;:
			case &#039;#funky-comment&#039;:
			case &#039;#presumptuous-tag&#039;:
				$this-&gt;insert_html_element( $this-&gt;state-&gt;current_token );
				return true;

			/*
			 * &gt; A DOCTYPE token
			 */
			case &#039;html&#039;:
				// Parse error: ignore the token.
				return $this-&gt;step();

			/*
			 * &gt; A start tag whose tag name is &quot;html&quot;
			 */
			case &#039;+HTML&#039;:
				return $this-&gt;step_in_body();

			/*
			 * &gt; An end tag whose tag name is &quot;html&quot;
			 */
			case &#039;-HTML&#039;:
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_AFTER_AFTER_FRAMESET;
				/*
				 * The HTML element is not removed from the stack of open elements.
				 * Only internal state has changed, this does not qualify as a &quot;step&quot;
				 * in terms of advancing through the document to another token.
				 * Nothing has been pushed or popped.
				 * Proceed to parse the next item.
				 */
				return $this-&gt;step();

			/*
			 * &gt; A start tag whose tag name is &quot;noframes&quot;
			 */
			case &#039;+NOFRAMES&#039;:
				return $this-&gt;step_in_head();
		}

		// Parse error: ignore the token.
		return $this-&gt;step();
	}

	/**
	 * Parses next element in the &#039;after after body&#039; insertion mode.
	 *
	 * This internal function performs the &#039;after after body&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0 Stub implementation.
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#the-after-after-body-insertion-mode
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_after_after_body(): bool {
		$tag_name   = $this-&gt;get_token_name();
		$token_type = $this-&gt;get_token_type();
		$op_sigil   = &#039;#tag&#039; === $token_type ? ( $this-&gt;is_tag_closer() ? &#039;-&#039; : &#039;+&#039; ) : &#039;&#039;;
		$op         = &quot;{$op_sigil}{$tag_name}&quot;;

		switch ( $op ) {
			/*
			 * &gt; A comment token
			 */
			case &#039;#comment&#039;:
			case &#039;#funky-comment&#039;:
			case &#039;#presumptuous-tag&#039;:
				$this-&gt;bail( &#039;Content outside of HTML is unsupported.&#039; );
				break;

			/*
			 * &gt; A DOCTYPE token
			 * &gt; A start tag whose tag name is &quot;html&quot;
			 *
			 * &gt; Process the token using the rules for the &quot;in body&quot; insertion mode.
			 */
			case &#039;html&#039;:
			case &#039;+HTML&#039;:
				return $this-&gt;step_in_body();

			/*
			 * &gt; A character token that is one of U+0009 CHARACTER TABULATION, U+000A LINE FEED (LF),
			 * &gt;   U+000C FORM FEED (FF), U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
			 * &gt;
			 * &gt; Process the token using the rules for the &quot;in body&quot; insertion mode.
			 */
			case &#039;#text&#039;:
				if ( parent::TEXT_IS_WHITESPACE === $this-&gt;text_node_classification ) {
					return $this-&gt;step_in_body();
				}
				goto after_after_body_anything_else;
				break;
		}

		/*
		 * &gt; Parse error. Switch the insertion mode to &quot;in body&quot; and reprocess the token.
		 */
		after_after_body_anything_else:
		$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_BODY;
		return $this-&gt;step( self::REPROCESS_CURRENT_NODE );
	}

	/**
	 * Parses next element in the &#039;after after frameset&#039; insertion mode.
	 *
	 * This internal function performs the &#039;after after frameset&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0 Stub implementation.
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#the-after-after-frameset-insertion-mode
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_after_after_frameset(): bool {
		$tag_name   = $this-&gt;get_token_name();
		$token_type = $this-&gt;get_token_type();
		$op_sigil   = &#039;#tag&#039; === $token_type ? ( $this-&gt;is_tag_closer() ? &#039;-&#039; : &#039;+&#039; ) : &#039;&#039;;
		$op         = &quot;{$op_sigil}{$tag_name}&quot;;

		switch ( $op ) {
			/*
			 * &gt; A comment token
			 */
			case &#039;#comment&#039;:
			case &#039;#funky-comment&#039;:
			case &#039;#presumptuous-tag&#039;:
				$this-&gt;bail( &#039;Content outside of HTML is unsupported.&#039; );
				break;

			/*
			 * &gt; A DOCTYPE token
			 * &gt; A start tag whose tag name is &quot;html&quot;
			 *
			 * &gt; Process the token using the rules for the &quot;in body&quot; insertion mode.
			 */
			case &#039;html&#039;:
			case &#039;+HTML&#039;:
				return $this-&gt;step_in_body();

			/*
			 * &gt; A character token that is one of U+0009 CHARACTER TABULATION, U+000A LINE FEED (LF),
			 * &gt;   U+000C FORM FEED (FF), U+000D CARRIAGE RETURN (CR), or U+0020 SPACE
			 * &gt;
			 * &gt; Process the token using the rules for the &quot;in body&quot; insertion mode.
			 *
			 * This algorithm effectively strips non-whitespace characters from text and inserts
			 * them under HTML. This is not supported at this time.
			 */
			case &#039;#text&#039;:
				if ( parent::TEXT_IS_WHITESPACE === $this-&gt;text_node_classification ) {
					return $this-&gt;step_in_body();
				}
				$this-&gt;bail( &#039;Non-whitespace characters cannot be handled in after after frameset.&#039; );
				break;

			/*
			 * &gt; A start tag whose tag name is &quot;noframes&quot;
			 */
			case &#039;+NOFRAMES&#039;:
				return $this-&gt;step_in_head();
		}

		// Parse error: ignore the token.
		return $this-&gt;step();
	}

	/**
	 * Parses next element in the &#039;in foreign content&#039; insertion mode.
	 *
	 * This internal function performs the &#039;in foreign content&#039; insertion mode
	 * logic for the generalized WP_HTML_Processor::step() function.
	 *
	 * @since 6.7.0 Stub implementation.
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#parsing-main-inforeign
	 * @see WP_HTML_Processor::step
	 *
	 * @return bool Whether an element was found.
	 */
	private function step_in_foreign_content(): bool {
		$tag_name   = $this-&gt;get_token_name();
		$token_type = $this-&gt;get_token_type();
		$op_sigil   = &#039;#tag&#039; === $token_type ? ( $this-&gt;is_tag_closer() ? &#039;-&#039; : &#039;+&#039; ) : &#039;&#039;;
		$op         = &quot;{$op_sigil}{$tag_name}&quot;;

		/*
		 * &gt; A start tag whose name is &quot;font&quot;, if the token has any attributes named &quot;color&quot;, &quot;face&quot;, or &quot;size&quot;
		 *
		 * This section drawn out above the switch to more easily incorporate
		 * the additional rules based on the presence of the attributes.
		 */
		if (
			&#039;+FONT&#039; === $op &amp;&amp;
			(
				null !== $this-&gt;get_attribute( &#039;color&#039; ) ||
				null !== $this-&gt;get_attribute( &#039;face&#039; ) ||
				null !== $this-&gt;get_attribute( &#039;size&#039; )
			)
		) {
			$op = &#039;+FONT with attributes&#039;;
		}

		switch ( $op ) {
			case &#039;#text&#039;:
				/*
				 * &gt; A character token that is U+0000 NULL
				 *
				 * This is handled by `get_modifiable_text()`.
				 */

				/*
				 * Whitespace-only text does not affect the frameset-ok flag.
				 * It is probably inter-element whitespace, but it may also
				 * contain character references which decode only to whitespace.
				 */
				if ( parent::TEXT_IS_GENERIC === $this-&gt;text_node_classification ) {
					$this-&gt;state-&gt;frameset_ok = false;
				}

				$this-&gt;insert_foreign_element( $this-&gt;state-&gt;current_token, false );
				return true;

			/*
			 * CDATA sections are alternate wrappers for text content and therefore
			 * ought to follow the same rules as text nodes.
			 */
			case &#039;#cdata-section&#039;:
				/*
				 * NULL bytes and whitespace do not change the frameset-ok flag.
				 */
				$current_token        = $this-&gt;bookmarks[ $this-&gt;state-&gt;current_token-&gt;bookmark_name ];
				$cdata_content_start  = $current_token-&gt;start + 9;
				$cdata_content_length = $current_token-&gt;length - 12;
				if ( strspn( $this-&gt;html, &quot;\0 \t\n\f\r&quot;, $cdata_content_start, $cdata_content_length ) !== $cdata_content_length ) {
					$this-&gt;state-&gt;frameset_ok = false;
				}

				$this-&gt;insert_foreign_element( $this-&gt;state-&gt;current_token, false );
				return true;

			/*
			 * &gt; A comment token
			 */
			case &#039;#comment&#039;:
			case &#039;#funky-comment&#039;:
			case &#039;#presumptuous-tag&#039;:
				$this-&gt;insert_foreign_element( $this-&gt;state-&gt;current_token, false );
				return true;

			/*
			 * &gt; A DOCTYPE token
			 */
			case &#039;html&#039;:
				// Parse error: ignore the token.
				return $this-&gt;step();

			/*
			 * &gt; A start tag whose tag name is &quot;b&quot;, &quot;big&quot;, &quot;blockquote&quot;, &quot;body&quot;, &quot;br&quot;, &quot;center&quot;,
			 * &gt; &quot;code&quot;, &quot;dd&quot;, &quot;div&quot;, &quot;dl&quot;, &quot;dt&quot;, &quot;em&quot;, &quot;embed&quot;, &quot;h1&quot;, &quot;h2&quot;, &quot;h3&quot;, &quot;h4&quot;, &quot;h5&quot;,
			 * &gt; &quot;h6&quot;, &quot;head&quot;, &quot;hr&quot;, &quot;i&quot;, &quot;img&quot;, &quot;li&quot;, &quot;listing&quot;, &quot;menu&quot;, &quot;meta&quot;, &quot;nobr&quot;, &quot;ol&quot;,
			 * &gt; &quot;p&quot;, &quot;pre&quot;, &quot;ruby&quot;, &quot;s&quot;, &quot;small&quot;, &quot;span&quot;, &quot;strong&quot;, &quot;strike&quot;, &quot;sub&quot;, &quot;sup&quot;,
			 * &gt; &quot;table&quot;, &quot;tt&quot;, &quot;u&quot;, &quot;ul&quot;, &quot;var&quot;
			 *
			 * &gt; A start tag whose name is &quot;font&quot;, if the token has any attributes named &quot;color&quot;, &quot;face&quot;, or &quot;size&quot;
			 *
			 * &gt; An end tag whose tag name is &quot;br&quot;, &quot;p&quot;
			 *
			 * Closing BR tags are always reported by the Tag Processor as opening tags.
			 */
			case &#039;+B&#039;:
			case &#039;+BIG&#039;:
			case &#039;+BLOCKQUOTE&#039;:
			case &#039;+BODY&#039;:
			case &#039;+BR&#039;:
			case &#039;+CENTER&#039;:
			case &#039;+CODE&#039;:
			case &#039;+DD&#039;:
			case &#039;+DIV&#039;:
			case &#039;+DL&#039;:
			case &#039;+DT&#039;:
			case &#039;+EM&#039;:
			case &#039;+EMBED&#039;:
			case &#039;+H1&#039;:
			case &#039;+H2&#039;:
			case &#039;+H3&#039;:
			case &#039;+H4&#039;:
			case &#039;+H5&#039;:
			case &#039;+H6&#039;:
			case &#039;+HEAD&#039;:
			case &#039;+HR&#039;:
			case &#039;+I&#039;:
			case &#039;+IMG&#039;:
			case &#039;+LI&#039;:
			case &#039;+LISTING&#039;:
			case &#039;+MENU&#039;:
			case &#039;+META&#039;:
			case &#039;+NOBR&#039;:
			case &#039;+OL&#039;:
			case &#039;+P&#039;:
			case &#039;+PRE&#039;:
			case &#039;+RUBY&#039;:
			case &#039;+S&#039;:
			case &#039;+SMALL&#039;:
			case &#039;+SPAN&#039;:
			case &#039;+STRONG&#039;:
			case &#039;+STRIKE&#039;:
			case &#039;+SUB&#039;:
			case &#039;+SUP&#039;:
			case &#039;+TABLE&#039;:
			case &#039;+TT&#039;:
			case &#039;+U&#039;:
			case &#039;+UL&#039;:
			case &#039;+VAR&#039;:
			case &#039;+FONT with attributes&#039;:
			case &#039;-BR&#039;:
			case &#039;-P&#039;:
				// @todo Indicate a parse error once it&#039;s possible.
				foreach ( $this-&gt;state-&gt;stack_of_open_elements-&gt;walk_up() as $current_node ) {
					if (
						&#039;math&#039; === $current_node-&gt;integration_node_type ||
						&#039;html&#039; === $current_node-&gt;integration_node_type ||
						&#039;html&#039; === $current_node-&gt;namespace
					) {
						break;
					}

					$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
				}
				goto in_foreign_content_process_in_current_insertion_mode;
		}

		/*
		 * &gt; Any other start tag
		 */
		if ( ! $this-&gt;is_tag_closer() ) {
			$this-&gt;insert_foreign_element( $this-&gt;state-&gt;current_token, false );

			/*
			 * &gt; If the token has its self-closing flag set, then run
			 * &gt; the appropriate steps from the following list:
			 * &gt;
			 * &gt;   ↪ the token&#039;s tag name is &quot;script&quot;, and the new current node is in the SVG namespace
			 * &gt;         Acknowledge the token&#039;s self-closing flag, and then act as
			 * &gt;         described in the steps for a &quot;script&quot; end tag below.
			 * &gt;
			 * &gt;   ↪ Otherwise
			 * &gt;         Pop the current node off the stack of open elements and
			 * &gt;         acknowledge the token&#039;s self-closing flag.
			 *
			 * Since the rules for SCRIPT below indicate to pop the element off of the stack of
			 * open elements, which is the same for the Otherwise condition, there&#039;s no need to
			 * separate these checks. The difference comes when a parser operates with the scripting
			 * flag enabled, and executes the script, which this parser does not support.
			 */
			if ( $this-&gt;state-&gt;current_token-&gt;has_self_closing_flag ) {
				$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
			}
			return true;
		}

		/*
		 * &gt; An end tag whose name is &quot;script&quot;, if the current node is an SVG script element.
		 */
		if ( $this-&gt;is_tag_closer() &amp;&amp; &#039;SCRIPT&#039; === $this-&gt;state-&gt;current_token-&gt;node_name &amp;&amp; &#039;svg&#039; === $this-&gt;state-&gt;current_token-&gt;namespace ) {
			$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
			return true;
		}

		/*
		 * &gt; Any other end tag
		 */
		if ( $this-&gt;is_tag_closer() ) {
			$node = $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node();
			if ( $tag_name !== $node-&gt;node_name ) {
				// @todo Indicate a parse error once it&#039;s possible.
			}
			in_foreign_content_end_tag_loop:
			if ( $node === $this-&gt;state-&gt;stack_of_open_elements-&gt;at( 1 ) ) {
				return true;
			}

			/*
			 * &gt; If node&#039;s tag name, converted to ASCII lowercase, is the same as the tag name
			 * &gt; of the token, pop elements from the stack of open elements until node has
			 * &gt; been popped from the stack, and then return.
			 */
			if ( 0 === strcasecmp( $node-&gt;node_name, $tag_name ) ) {
				foreach ( $this-&gt;state-&gt;stack_of_open_elements-&gt;walk_up() as $item ) {
					$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
					if ( $node === $item ) {
						return true;
					}
				}
			}

			foreach ( $this-&gt;state-&gt;stack_of_open_elements-&gt;walk_up( $node ) as $item ) {
				$node = $item;
				break;
			}

			if ( &#039;html&#039; !== $node-&gt;namespace ) {
				goto in_foreign_content_end_tag_loop;
			}

			in_foreign_content_process_in_current_insertion_mode:
			switch ( $this-&gt;state-&gt;insertion_mode ) {
				case WP_HTML_Processor_State::INSERTION_MODE_INITIAL:
					return $this-&gt;step_initial();

				case WP_HTML_Processor_State::INSERTION_MODE_BEFORE_HTML:
					return $this-&gt;step_before_html();

				case WP_HTML_Processor_State::INSERTION_MODE_BEFORE_HEAD:
					return $this-&gt;step_before_head();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD:
					return $this-&gt;step_in_head();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD_NOSCRIPT:
					return $this-&gt;step_in_head_noscript();

				case WP_HTML_Processor_State::INSERTION_MODE_AFTER_HEAD:
					return $this-&gt;step_after_head();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_BODY:
					return $this-&gt;step_in_body();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE:
					return $this-&gt;step_in_table();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_TEXT:
					return $this-&gt;step_in_table_text();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_CAPTION:
					return $this-&gt;step_in_caption();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_COLUMN_GROUP:
					return $this-&gt;step_in_column_group();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY:
					return $this-&gt;step_in_table_body();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_ROW:
					return $this-&gt;step_in_row();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_CELL:
					return $this-&gt;step_in_cell();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_SELECT:
					return $this-&gt;step_in_select();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_SELECT_IN_TABLE:
					return $this-&gt;step_in_select_in_table();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_TEMPLATE:
					return $this-&gt;step_in_template();

				case WP_HTML_Processor_State::INSERTION_MODE_AFTER_BODY:
					return $this-&gt;step_after_body();

				case WP_HTML_Processor_State::INSERTION_MODE_IN_FRAMESET:
					return $this-&gt;step_in_frameset();

				case WP_HTML_Processor_State::INSERTION_MODE_AFTER_FRAMESET:
					return $this-&gt;step_after_frameset();

				case WP_HTML_Processor_State::INSERTION_MODE_AFTER_AFTER_BODY:
					return $this-&gt;step_after_after_body();

				case WP_HTML_Processor_State::INSERTION_MODE_AFTER_AFTER_FRAMESET:
					return $this-&gt;step_after_after_frameset();

				// This should be unreachable but PHP doesn&#039;t have total type checking on switch.
				default:
					$this-&gt;bail( &quot;Unaware of the requested parsing mode: &#039;{$this-&gt;state-&gt;insertion_mode}&#039;.&quot; );
			}
		}

		$this-&gt;bail( &#039;Should not have been able to reach end of IN FOREIGN CONTENT processing. Check HTML API code.&#039; );
		// This unnecessary return prevents tools from inaccurately reporting type errors.
		return false;
	}

	/*
	 * Internal helpers
	 */

	/**
	 * Creates a new bookmark for the currently-matched token and returns the generated name.
	 *
	 * @since 6.4.0
	 * @since 6.5.0 Renamed from bookmark_tag() to bookmark_token().
	 *
	 * @throws Exception When unable to allocate requested bookmark.
	 *
	 * @return string|false Name of created bookmark, or false if unable to create.
	 */
	private function bookmark_token() {
		if ( ! parent::set_bookmark( ++$this-&gt;bookmark_counter ) ) {
			$this-&gt;last_error = self::ERROR_EXCEEDED_MAX_BOOKMARKS;
			throw new Exception( &#039;could not allocate bookmark&#039; );
		}

		return &quot;{$this-&gt;bookmark_counter}&quot;;
	}

	/*
	 * HTML semantic overrides for Tag Processor
	 */

	/**
	 * Indicates the namespace of the current token, or &quot;html&quot; if there is none.
	 *
	 * @return string One of &quot;html&quot;, &quot;math&quot;, or &quot;svg&quot;.
	 */
	public function get_namespace(): string {
		if ( ! isset( $this-&gt;current_element ) ) {
			return parent::get_namespace();
		}

		return $this-&gt;current_element-&gt;token-&gt;namespace;
	}

	/**
	 * Returns the uppercase name of the matched tag.
	 *
	 * The semantic rules for HTML specify that certain tags be reprocessed
	 * with a different tag name. Because of this, the tag name presented
	 * by the HTML Processor may differ from the one reported by the HTML
	 * Tag Processor, which doesn&#039;t apply these semantic rules.
	 *
	 * Example:
	 *
	 *     $processor = new WP_HTML_Tag_Processor( &#039;&lt;div class=&quot;test&quot;&gt;Test&lt;/div&gt;&#039; );
	 *     $processor-&gt;next_tag() === true;
	 *     $processor-&gt;get_tag() === &#039;DIV&#039;;
	 *
	 *     $processor-&gt;next_tag() === false;
	 *     $processor-&gt;get_tag() === null;
	 *
	 * @since 6.4.0
	 *
	 * @return string|null Name of currently matched tag in input HTML, or `null` if none found.
	 */
	public function get_tag(): ?string {
		if ( null !== $this-&gt;last_error ) {
			return null;
		}

		if ( $this-&gt;is_virtual() ) {
			return $this-&gt;current_element-&gt;token-&gt;node_name;
		}

		$tag_name = parent::get_tag();

		/*
		 * &gt; A start tag whose tag name is &quot;image&quot;
		 * &gt; Change the token&#039;s tag name to &quot;img&quot; and reprocess it. (Don&#039;t ask.)
		 */
		return ( &#039;IMAGE&#039; === $tag_name &amp;&amp; &#039;html&#039; === $this-&gt;get_namespace() )
			? &#039;IMG&#039;
			: $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 &quot;self close&quot;
	 * 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.6.0 Subclassed for the HTML Processor.
	 *
	 * @return bool Whether the currently matched tag contains the self-closing flag.
	 */
	public function has_self_closing_flag(): bool {
		return $this-&gt;is_virtual() ? false : parent::has_self_closing_flag();
	}

	/**
	 * Returns the node name represented by the token.
	 *
	 * This matches the DOM API value `nodeName`. Some values
	 * are static, such as `#text` for a text node, while others
	 * are dynamically generated from the token itself.
	 *
	 * Dynamic names:
	 *  - Uppercase tag name for tag matches.
	 *  - `html` for DOCTYPE declarations.
	 *
	 * Note that if the Tag Processor is not matched on a token
	 * then this function will return `null`, either because it
	 * hasn&#039;t yet found a token or because it reached the end
	 * of the document without matching a token.
	 *
	 * @since 6.6.0 Subclassed for the HTML Processor.
	 *
	 * @return string|null Name of the matched token.
	 */
	public function get_token_name(): ?string {
		return $this-&gt;is_virtual()
			? $this-&gt;current_element-&gt;token-&gt;node_name
			: parent::get_token_name();
	}

	/**
	 * Indicates the kind of matched token, if any.
	 *
	 * This differs from `get_token_name()` in that it always
	 * returns a static string indicating the type, whereas
	 * `get_token_name()` may return values derived from the
	 * token itself, such as a tag name or processing
	 * instruction tag.
	 *
	 * Possible values:
	 *  - `#tag` when matched on a tag.
	 *  - `#text` when matched on a text node.
	 *  - `#cdata-section` when matched on a CDATA node.
	 *  - `#comment` when matched on a comment.
	 *  - `#doctype` when matched on a DOCTYPE declaration.
	 *  - `#presumptuous-tag` when matched on an empty tag closer.
	 *  - `#funky-comment` when matched on a funky comment.
	 *
	 * @since 6.6.0 Subclassed for the HTML Processor.
	 *
	 * @return string|null What kind of token is matched, or null.
	 */
	public function get_token_type(): ?string {
		if ( $this-&gt;is_virtual() ) {
			/*
			 * This logic comes from the Tag Processor.
			 *
			 * @todo It would be ideal not to repeat this here, but it&#039;s not clearly
			 *       better to allow passing a token name to `get_token_type()`.
			 */
			$node_name     = $this-&gt;current_element-&gt;token-&gt;node_name;
			$starting_char = $node_name[0];
			if ( &#039;A&#039; &lt;= $starting_char &amp;&amp; &#039;Z&#039; &gt;= $starting_char ) {
				return &#039;#tag&#039;;
			}

			if ( &#039;html&#039; === $node_name ) {
				return &#039;#doctype&#039;;
			}

			return $node_name;
		}

		return parent::get_token_type();
	}

	/**
	 * Returns the value of a requested attribute from a matched tag opener if that attribute exists.
	 *
	 * Example:
	 *
	 *     $p = WP_HTML_Processor::create_fragment( &#039;&lt;div enabled class=&quot;test&quot; data-test-id=&quot;14&quot;&gt;Test&lt;/div&gt;&#039; );
	 *     $p-&gt;next_token() === true;
	 *     $p-&gt;get_attribute( &#039;data-test-id&#039; ) === &#039;14&#039;;
	 *     $p-&gt;get_attribute( &#039;enabled&#039; ) === true;
	 *     $p-&gt;get_attribute( &#039;aria-label&#039; ) === null;
	 *
	 *     $p-&gt;next_tag() === false;
	 *     $p-&gt;get_attribute( &#039;class&#039; ) === null;
	 *
	 * @since 6.6.0 Subclassed for HTML Processor.
	 *
	 * @param string $name Name of attribute whose value is requested.
	 * @return string|true|null Value of attribute or `null` if not available. Boolean attributes return `true`.
	 */
	public function get_attribute( $name ) {
		return $this-&gt;is_virtual() ? null : parent::get_attribute( $name );
	}

	/**
	 * Updates or creates a new attribute on the currently matched tag with the passed value.
	 *
	 * For boolean attributes special handling is provided:
	 *  - When `true` is passed as the value, then only the attribute name is added to the tag.
	 *  - When `false` is passed, the attribute gets removed if it existed before.
	 *
	 * For string attributes, the value is escaped using the `esc_attr` function.
	 *
	 * @since 6.6.0 Subclassed for the HTML Processor.
	 *
	 * @param string      $name  The attribute name to target.
	 * @param string|bool $value The new attribute value.
	 * @return bool Whether an attribute value was set.
	 */
	public function set_attribute( $name, $value ): bool {
		return $this-&gt;is_virtual() ? false : parent::set_attribute( $name, $value );
	}

	/**
	 * Remove an attribute from the currently-matched tag.
	 *
	 * @since 6.6.0 Subclassed for HTML Processor.
	 *
	 * @param string $name The attribute name to remove.
	 * @return bool Whether an attribute was removed.
	 */
	public function remove_attribute( $name ): bool {
		return $this-&gt;is_virtual() ? false : parent::remove_attribute( $name );
	}

	/**
	 * Gets lowercase names of all attributes matching a given prefix in the current tag.
	 *
	 * Note that matching is case-insensitive. This is in accordance with the spec:
	 *
	 * &gt; There must never be two or more attributes on
	 * &gt; the same start tag whose names are an ASCII
	 * &gt; case-insensitive match for each other.
	 *     - HTML 5 spec
	 *
	 * Example:
	 *
	 *     $p = new WP_HTML_Tag_Processor( &#039;&lt;div data-ENABLED class=&quot;test&quot; DATA-test-id=&quot;14&quot;&gt;Test&lt;/div&gt;&#039; );
	 *     $p-&gt;next_tag( array( &#039;class_name&#039; =&gt; &#039;test&#039; ) ) === true;
	 *     $p-&gt;get_attribute_names_with_prefix( &#039;data-&#039; ) === array( &#039;data-enabled&#039;, &#039;data-test-id&#039; );
	 *
	 *     $p-&gt;next_tag() === false;
	 *     $p-&gt;get_attribute_names_with_prefix( &#039;data-&#039; ) === null;
	 *
	 * @since 6.6.0 Subclassed for the HTML Processor.
	 *
	 * @see https://html.spec.whatwg.org/multipage/syntax.html#attributes-2:ascii-case-insensitive
	 *
	 * @param string $prefix Prefix of requested attribute names.
	 * @return array|null List of attribute names, or `null` when no tag opener is matched.
	 */
	public function get_attribute_names_with_prefix( $prefix ): ?array {
		return $this-&gt;is_virtual() ? null : parent::get_attribute_names_with_prefix( $prefix );
	}

	/**
	 * Adds a new class name to the currently matched tag.
	 *
	 * @since 6.6.0 Subclassed for the HTML Processor.
	 *
	 * @param string $class_name The class name to add.
	 * @return bool Whether the class was set to be added.
	 */
	public function add_class( $class_name ): bool {
		return $this-&gt;is_virtual() ? false : parent::add_class( $class_name );
	}

	/**
	 * Removes a class name from the currently matched tag.
	 *
	 * @since 6.6.0 Subclassed for the HTML Processor.
	 *
	 * @param string $class_name The class name to remove.
	 * @return bool Whether the class was set to be removed.
	 */
	public function remove_class( $class_name ): bool {
		return $this-&gt;is_virtual() ? false : parent::remove_class( $class_name );
	}

	/**
	 * Returns if a matched tag contains the given ASCII case-insensitive class name.
	 *
	 * @since 6.6.0 Subclassed for the HTML Processor.
	 *
	 * @todo When reconstructing active formatting elements with attributes, find a way
	 *       to indicate if the virtually-reconstructed formatting elements contain the
	 *       wanted class name.
	 *
	 * @param string $wanted_class Look for this CSS class name, ASCII case-insensitive.
	 * @return bool|null Whether the matched tag contains the given class name, or null if not matched.
	 */
	public function has_class( $wanted_class ): ?bool {
		return $this-&gt;is_virtual() ? null : parent::has_class( $wanted_class );
	}

	/**
	 * Generator for a foreach loop to step through each class name for the matched tag.
	 *
	 * This generator function is designed to be used inside a &quot;foreach&quot; loop.
	 *
	 * Example:
	 *
	 *     $p = WP_HTML_Processor::create_fragment( &quot;&lt;div class=&#039;free &amp;lt;egg&amp;lt;\tlang-en&#039;&gt;&quot; );
	 *     $p-&gt;next_tag();
	 *     foreach ( $p-&gt;class_list() as $class_name ) {
	 *         echo &quot;{$class_name} &quot;;
	 *     }
	 *     // Outputs: &quot;free &lt;egg&gt; lang-en &quot;
	 *
	 * @since 6.6.0 Subclassed for the HTML Processor.
	 */
	public function class_list() {
		return $this-&gt;is_virtual() ? null : parent::class_list();
	}

	/**
	 * Returns the modifiable text for a matched token, or an empty string.
	 *
	 * Modifiable text is text content that may be read and changed without
	 * changing the HTML structure of the document around it. This includes
	 * the contents of `#text` nodes in the HTML as well as the inner
	 * contents of HTML comments, Processing Instructions, and others, even
	 * though these nodes aren&#039;t part of a parsed DOM tree. They also contain
	 * the contents of SCRIPT and STYLE tags, of TEXTAREA tags, and of any
	 * other section in an HTML document which cannot contain HTML markup (DATA).
	 *
	 * If a token has no modifiable text then an empty string is returned to
	 * avoid needless crashing or type errors. An empty string does not mean
	 * that a token has modifiable text, and a token with modifiable text may
	 * have an empty string (e.g. a comment with no contents).
	 *
	 * @since 6.6.0 Subclassed for the HTML Processor.
	 *
	 * @return string
	 */
	public function get_modifiable_text(): string {
		return $this-&gt;is_virtual() ? &#039;&#039; : parent::get_modifiable_text();
	}

	/**
	 * Indicates what kind of comment produced the comment node.
	 *
	 * Because there are different kinds of HTML syntax which produce
	 * comments, the Tag Processor tracks and exposes this as a type
	 * for the comment. Nominally only regular HTML comments exist as
	 * they are commonly known, but a number of unrelated syntax errors
	 * also produce comments.
	 *
	 * @see self::COMMENT_AS_ABRUPTLY_CLOSED_COMMENT
	 * @see self::COMMENT_AS_CDATA_LOOKALIKE
	 * @see self::COMMENT_AS_INVALID_HTML
	 * @see self::COMMENT_AS_HTML_COMMENT
	 * @see self::COMMENT_AS_PI_NODE_LOOKALIKE
	 *
	 * @since 6.6.0 Subclassed for the HTML Processor.
	 *
	 * @return string|null
	 */
	public function get_comment_type(): ?string {
		return $this-&gt;is_virtual() ? null : parent::get_comment_type();
	}

	/**
	 * Removes a bookmark that is no longer needed.
	 *
	 * Releasing a bookmark frees up the small
	 * performance overhead it requires.
	 *
	 * @since 6.4.0
	 *
	 * @param string $bookmark_name Name of the bookmark to remove.
	 * @return bool Whether the bookmark already existed before removal.
	 */
	public function release_bookmark( $bookmark_name ): bool {
		return parent::release_bookmark( &quot;_{$bookmark_name}&quot; );
	}

	/**
	 * Moves the internal cursor in the HTML Processor to a given bookmark&#039;s location.
	 *
	 * Be careful! Seeking backwards to a previous location resets the parser to the
	 * start of the document and reparses the entire contents up until it finds the
	 * sought-after bookmarked location.
	 *
	 * In order to prevent accidental infinite loops, there&#039;s a
	 * maximum limit on the number of times seek() can be called.
	 *
	 * @throws Exception When unable to allocate a bookmark for the next token in the input HTML document.
	 *
	 * @since 6.4.0
	 *
	 * @param string $bookmark_name Jump to the place in the document identified by this bookmark name.
	 * @return bool Whether the internal cursor was successfully moved to the bookmark&#039;s location.
	 */
	public function seek( $bookmark_name ): bool {
		// Flush any pending updates to the document before beginning.
		$this-&gt;get_updated_html();

		$actual_bookmark_name = &quot;_{$bookmark_name}&quot;;
		$processor_started_at = $this-&gt;state-&gt;current_token
			? $this-&gt;bookmarks[ $this-&gt;state-&gt;current_token-&gt;bookmark_name ]-&gt;start
			: 0;
		$bookmark_starts_at   = $this-&gt;bookmarks[ $actual_bookmark_name ]-&gt;start;
		$direction            = $bookmark_starts_at &gt; $processor_started_at ? &#039;forward&#039; : &#039;backward&#039;;

		/*
		 * If seeking backwards, it&#039;s possible that the sought-after bookmark exists within an element
		 * which has been closed before the current cursor; in other words, it has already been removed
		 * from the stack of open elements. This means that it&#039;s insufficient to simply pop off elements
		 * from the stack of open elements which appear after the bookmarked location and then jump to
		 * that location, as the elements which were open before won&#039;t be re-opened.
		 *
		 * In order to maintain consistency, the HTML Processor rewinds to the start of the document
		 * and reparses everything until it finds the sought-after bookmark.
		 *
		 * There are potentially better ways to do this: cache the parser state for each bookmark and
		 * restore it when seeking; store an immutable and idempotent register of where elements open
		 * and close.
		 *
		 * If caching the parser state it will be essential to properly maintain the cached stack of
		 * open elements and active formatting elements when modifying the document. This could be a
		 * tedious and time-consuming process as well, and so for now will not be performed.
		 *
		 * It may be possible to track bookmarks for where elements open and close, and in doing so
		 * be able to quickly recalculate breadcrumbs for any element in the document. It may even
		 * be possible to remove the stack of open elements and compute it on the fly this way.
		 * If doing this, the parser would need to track the opening and closing locations for all
		 * tokens in the breadcrumb path for any and all bookmarks. By utilizing bookmarks themselves
		 * this list could be automatically maintained while modifying the document. Finding the
		 * breadcrumbs would then amount to traversing that list from the start until the token
		 * being inspected. Once an element closes, if there are no bookmarks pointing to locations
		 * within that element, then all of these locations may be forgotten to save on memory use
		 * and computation time.
		 */
		if ( &#039;backward&#039; === $direction ) {

			/*
			 * When moving backward, stateful stacks should be cleared.
			 */
			foreach ( $this-&gt;state-&gt;stack_of_open_elements-&gt;walk_up() as $item ) {
				$this-&gt;state-&gt;stack_of_open_elements-&gt;remove_node( $item );
			}

			foreach ( $this-&gt;state-&gt;active_formatting_elements-&gt;walk_up() as $item ) {
				$this-&gt;state-&gt;active_formatting_elements-&gt;remove_node( $item );
			}

			/*
			 * **After** clearing stacks, more processor state can be reset.
			 * This must be done after clearing the stack because those stacks generate events that
			 * would appear on a subsequent call to `next_token()`.
			 */
			$this-&gt;state-&gt;frameset_ok                       = true;
			$this-&gt;state-&gt;stack_of_template_insertion_modes = array();
			$this-&gt;state-&gt;head_element                      = null;
			$this-&gt;state-&gt;form_element                      = null;
			$this-&gt;state-&gt;current_token                     = null;
			$this-&gt;current_element                          = null;
			$this-&gt;element_queue                            = array();

			/*
			 * The absence of a context node indicates a full parse.
			 * The presence of a context node indicates a fragment parser.
			 */
			if ( null === $this-&gt;context_node ) {
				$this-&gt;change_parsing_namespace( &#039;html&#039; );
				$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_INITIAL;
				$this-&gt;breadcrumbs           = array();

				$this-&gt;bookmarks[&#039;initial&#039;] = new WP_HTML_Span( 0, 0 );
				parent::seek( &#039;initial&#039; );
				unset( $this-&gt;bookmarks[&#039;initial&#039;] );
			} else {

				/*
				 * Push the root-node (HTML) back onto the stack of open elements.
				 *
				 * Fragment parsers require this extra bit of setup.
				 * It&#039;s handled in full parsers by advancing the processor state.
				 */
				$this-&gt;state-&gt;stack_of_open_elements-&gt;push(
					new WP_HTML_Token(
						&#039;root-node&#039;,
						&#039;HTML&#039;,
						false
					)
				);

				$this-&gt;change_parsing_namespace(
					$this-&gt;context_node-&gt;integration_node_type
						? &#039;html&#039;
						: $this-&gt;context_node-&gt;namespace
				);

				if ( &#039;TEMPLATE&#039; === $this-&gt;context_node-&gt;node_name ) {
					$this-&gt;state-&gt;stack_of_template_insertion_modes[] = WP_HTML_Processor_State::INSERTION_MODE_IN_TEMPLATE;
				}

				$this-&gt;reset_insertion_mode_appropriately();
				$this-&gt;breadcrumbs = array_slice( $this-&gt;breadcrumbs, 0, 2 );
				parent::seek( $this-&gt;context_node-&gt;bookmark_name );
			}
		}

		/*
		 * Here, the processor moves forward through the document until it matches the bookmark.
		 * do-while is used here because the processor is expected to already be stopped on
		 * a token than may match the bookmarked location.
		 */
		do {
			/*
			 * The processor will stop on virtual tokens, but bookmarks may not be set on them.
			 * They should not be matched when seeking a bookmark, skip them.
			 */
			if ( $this-&gt;is_virtual() ) {
				continue;
			}
			if ( $bookmark_starts_at === $this-&gt;bookmarks[ $this-&gt;state-&gt;current_token-&gt;bookmark_name ]-&gt;start ) {
				return true;
			}
		} while ( $this-&gt;next_token() );

		return false;
	}

	/**
	 * Sets a bookmark in the HTML document.
	 *
	 * Bookmarks represent specific places or tokens in the HTML
	 * document, such as a tag opener or closer. When applying
	 * edits to a document, such as setting an attribute, the
	 * text offsets of that token may shift; the bookmark is
	 * kept updated with those shifts and remains stable unless
	 * the entire span of text in which the token sits is removed.
	 *
	 * Release bookmarks when they are no longer needed.
	 *
	 * Example:
	 *
	 *     &lt;main&gt;&lt;h2&gt;Surprising fact you may not know!&lt;/h2&gt;&lt;/main&gt;
	 *           ^  ^
	 *            \-|-- this `H2` opener bookmark tracks the token
	 *
	 *     &lt;main class=&quot;clickbait&quot;&gt;&lt;h2&gt;Surprising fact you may no…
	 *                             ^  ^
	 *                              \-|-- it shifts with edits
	 *
	 * Bookmarks provide the ability to seek to a previously-scanned
	 * place in the HTML document. This avoids the need to re-scan
	 * the entire document.
	 *
	 * Example:
	 *
	 *     &lt;ul&gt;&lt;li&gt;One&lt;/li&gt;&lt;li&gt;Two&lt;/li&gt;&lt;li&gt;Three&lt;/li&gt;&lt;/ul&gt;
	 *                                 ^^^^
	 *                                 want to note this last item
	 *
	 *     $p = new WP_HTML_Tag_Processor( $html );
	 *     $in_list = false;
	 *     while ( $p-&gt;next_tag( array( &#039;tag_closers&#039; =&gt; $in_list ? &#039;visit&#039; : &#039;skip&#039; ) ) ) {
	 *         if ( &#039;UL&#039; === $p-&gt;get_tag() ) {
	 *             if ( $p-&gt;is_tag_closer() ) {
	 *                 $in_list = false;
	 *                 $p-&gt;set_bookmark( &#039;resume&#039; );
	 *                 if ( $p-&gt;seek( &#039;last-li&#039; ) ) {
	 *                     $p-&gt;add_class( &#039;last-li&#039; );
	 *                 }
	 *                 $p-&gt;seek( &#039;resume&#039; );
	 *                 $p-&gt;release_bookmark( &#039;last-li&#039; );
	 *                 $p-&gt;release_bookmark( &#039;resume&#039; );
	 *             } else {
	 *                 $in_list = true;
	 *             }
	 *         }
	 *
	 *         if ( &#039;LI&#039; === $p-&gt;get_tag() ) {
	 *             $p-&gt;set_bookmark( &#039;last-li&#039; );
	 *         }
	 *     }
	 *
	 * Bookmarks intentionally hide the internal string offsets
	 * to which they refer. They are maintained internally as
	 * updates are applied to the HTML document and therefore
	 * retain their &quot;position&quot; - the location to which they
	 * originally pointed. The inability to use bookmarks with
	 * functions like `substr` is therefore intentional to guard
	 * against accidentally breaking the HTML.
	 *
	 * Because bookmarks allocate memory and require processing
	 * for every applied update, they are limited and require
	 * a name. They should not be created with programmatically-made
	 * names, such as &quot;li_{$index}&quot; with some loop. As a general
	 * rule they should only be created with string-literal names
	 * like &quot;start-of-section&quot; or &quot;last-paragraph&quot;.
	 *
	 * Bookmarks are a powerful tool to enable complicated behavior.
	 * Consider double-checking that you need this tool if you are
	 * reaching for it, as inappropriate use could lead to broken
	 * HTML structure or unwanted processing overhead.
	 *
	 * Bookmarks cannot be set on tokens that do no appear in the original
	 * HTML text. For example, the HTML `&lt;table&gt;&lt;td&gt;` stops at tags `TABLE`,
	 * `TBODY`, `TR`, and `TD`. The `TBODY` and `TR` tags do not appear in
	 * the original HTML and cannot be used as bookmarks.
	 *
	 * @since 6.4.0
	 *
	 * @param string $bookmark_name Identifies this particular bookmark.
	 * @return bool Whether the bookmark was successfully created.
	 */
	public function set_bookmark( $bookmark_name ): bool {
		if ( $this-&gt;is_virtual() ) {
			_doing_it_wrong(
				__METHOD__,
				__( &#039;Cannot set bookmarks on tokens that do no appear in the original HTML text.&#039; ),
				&#039;6.8.0&#039;
			);
			return false;
		}
		return parent::set_bookmark( &quot;_{$bookmark_name}&quot; );
	}

	/**
	 * Checks whether a bookmark with the given name exists.
	 *
	 * @since 6.5.0
	 *
	 * @param string $bookmark_name Name to identify a bookmark that potentially exists.
	 * @return bool Whether that bookmark exists.
	 */
	public function has_bookmark( $bookmark_name ): bool {
		return parent::has_bookmark( &quot;_{$bookmark_name}&quot; );
	}

	/*
	 * HTML Parsing Algorithms
	 */

	/**
	 * Closes a P element.
	 *
	 * @since 6.4.0
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#close-a-p-element
	 */
	private function close_a_p_element(): void {
		$this-&gt;generate_implied_end_tags( &#039;P&#039; );
		$this-&gt;state-&gt;stack_of_open_elements-&gt;pop_until( &#039;P&#039; );
	}

	/**
	 * Closes elements that have implied end tags.
	 *
	 * @since 6.4.0
	 * @since 6.7.0 Full spec support.
	 *
	 * @see https://html.spec.whatwg.org/#generate-implied-end-tags
	 *
	 * @param string|null $except_for_this_element Perform as if this element doesn&#039;t exist in the stack of open elements.
	 */
	private function generate_implied_end_tags( ?string $except_for_this_element = null ): void {
		$elements_with_implied_end_tags = array(
			&#039;DD&#039;,
			&#039;DT&#039;,
			&#039;LI&#039;,
			&#039;OPTGROUP&#039;,
			&#039;OPTION&#039;,
			&#039;P&#039;,
			&#039;RB&#039;,
			&#039;RP&#039;,
			&#039;RT&#039;,
			&#039;RTC&#039;,
		);

		$no_exclusions = ! isset( $except_for_this_element );

		while (
			( $no_exclusions || ! $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node_is( $except_for_this_element ) ) &amp;&amp;
			in_array( $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node()-&gt;node_name, $elements_with_implied_end_tags, true )
		) {
			$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
		}
	}

	/**
	 * Closes elements that have implied end tags, thoroughly.
	 *
	 * See the HTML specification for an explanation why this is
	 * different from generating end tags in the normal sense.
	 *
	 * @since 6.4.0
	 * @since 6.7.0 Full spec support.
	 *
	 * @see WP_HTML_Processor::generate_implied_end_tags
	 * @see https://html.spec.whatwg.org/#generate-implied-end-tags
	 */
	private function generate_implied_end_tags_thoroughly(): void {
		$elements_with_implied_end_tags = array(
			&#039;CAPTION&#039;,
			&#039;COLGROUP&#039;,
			&#039;DD&#039;,
			&#039;DT&#039;,
			&#039;LI&#039;,
			&#039;OPTGROUP&#039;,
			&#039;OPTION&#039;,
			&#039;P&#039;,
			&#039;RB&#039;,
			&#039;RP&#039;,
			&#039;RT&#039;,
			&#039;RTC&#039;,
			&#039;TBODY&#039;,
			&#039;TD&#039;,
			&#039;TFOOT&#039;,
			&#039;TH&#039;,
			&#039;THEAD&#039;,
			&#039;TR&#039;,
		);

		while ( in_array( $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node()-&gt;node_name, $elements_with_implied_end_tags, true ) ) {
			$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
		}
	}

	/**
	 * Returns the adjusted current node.
	 *
	 * &gt; The adjusted current node is the context element if the parser was created as
	 * &gt; part of the HTML fragment parsing algorithm and the stack of open elements
	 * &gt; has only one element in it (fragment case); otherwise, the adjusted current
	 * &gt; node is the current node.
	 *
	 * @see https://html.spec.whatwg.org/#adjusted-current-node
	 *
	 * @since 6.7.0
	 *
	 * @return WP_HTML_Token|null The adjusted current node.
	 */
	private function get_adjusted_current_node(): ?WP_HTML_Token {
		if ( isset( $this-&gt;context_node ) &amp;&amp; 1 === $this-&gt;state-&gt;stack_of_open_elements-&gt;count() ) {
			return $this-&gt;context_node;
		}

		return $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node();
	}

	/**
	 * Reconstructs the active formatting elements.
	 *
	 * &gt; This has the effect of reopening all the formatting elements that were opened
	 * &gt; in the current body, cell, or caption (whichever is youngest) that haven&#039;t
	 * &gt; been explicitly closed.
	 *
	 * @since 6.4.0
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#reconstruct-the-active-formatting-elements
	 *
	 * @return bool Whether any formatting elements needed to be reconstructed.
	 */
	private function reconstruct_active_formatting_elements(): bool {
		/*
		 * &gt; If there are no entries in the list of active formatting elements, then there is nothing
		 * &gt; to reconstruct; stop this algorithm.
		 */
		if ( 0 === $this-&gt;state-&gt;active_formatting_elements-&gt;count() ) {
			return false;
		}

		$last_entry = $this-&gt;state-&gt;active_formatting_elements-&gt;current_node();
		if (

			/*
			 * &gt; If the last (most recently added) entry in the list of active formatting elements is a marker;
			 * &gt; stop this algorithm.
			 */
			&#039;marker&#039; === $last_entry-&gt;node_name ||

			/*
			 * &gt; If the last (most recently added) entry in the list of active formatting elements is an
			 * &gt; element that is in the stack of open elements, then there is nothing to reconstruct;
			 * &gt; stop this algorithm.
			 */
			$this-&gt;state-&gt;stack_of_open_elements-&gt;contains_node( $last_entry )
		) {
			return false;
		}

		$this-&gt;bail( &#039;Cannot reconstruct active formatting elements when advancing and rewinding is required.&#039; );
	}

	/**
	 * Runs the reset the insertion mode appropriately algorithm.
	 *
	 * @since 6.7.0
	 *
	 * @see https://html.spec.whatwg.org/multipage/parsing.html#reset-the-insertion-mode-appropriately
	 */
	private function reset_insertion_mode_appropriately(): void {
		// Set the first node.
		$first_node = null;
		foreach ( $this-&gt;state-&gt;stack_of_open_elements-&gt;walk_down() as $first_node ) {
			break;
		}

		/*
		 * &gt; 1. Let _last_ be false.
		 */
		$last = false;
		foreach ( $this-&gt;state-&gt;stack_of_open_elements-&gt;walk_up() as $node ) {
			/*
			 * &gt; 2. Let _node_ be the last node in the stack of open elements.
			 * &gt; 3. _Loop_: If _node_ is the first node in the stack of open elements, then set _last_
			 * &gt;            to true, and, if the parser was created as part of the HTML fragment parsing
			 * &gt;            algorithm (fragment case), set node to the context element passed to
			 * &gt;            that algorithm.
			 * &gt; …
			 */
			if ( $node === $first_node ) {
				$last = true;
				if ( isset( $this-&gt;context_node ) ) {
					$node = $this-&gt;context_node;
				}
			}

			// All of the following rules are for matching HTML elements.
			if ( &#039;html&#039; !== $node-&gt;namespace ) {
				continue;
			}

			switch ( $node-&gt;node_name ) {
				/*
				 * &gt; 4. If node is a `select` element, run these substeps:
				 * &gt;   1. If _last_ is true, jump to the step below labeled done.
				 * &gt;   2. Let _ancestor_ be _node_.
				 * &gt;   3. _Loop_: If _ancestor_ is the first node in the stack of open elements,
				 * &gt;      jump to the step below labeled done.
				 * &gt;   4. Let ancestor be the node before ancestor in the stack of open elements.
				 * &gt;   …
				 * &gt;   7. Jump back to the step labeled _loop_.
				 * &gt;   8. _Done_: Switch the insertion mode to &quot;in select&quot; and return.
				 */
				case &#039;SELECT&#039;:
					if ( ! $last ) {
						foreach ( $this-&gt;state-&gt;stack_of_open_elements-&gt;walk_up( $node ) as $ancestor ) {
							if ( &#039;html&#039; !== $ancestor-&gt;namespace ) {
								continue;
							}

							switch ( $ancestor-&gt;node_name ) {
								/*
								 * &gt; 5. If _ancestor_ is a `template` node, jump to the step below
								 * &gt;    labeled _done_.
								 */
								case &#039;TEMPLATE&#039;:
									break 2;

								/*
								 * &gt; 6. If _ancestor_ is a `table` node, switch the insertion mode to
								 * &gt;    &quot;in select in table&quot; and return.
								 */
								case &#039;TABLE&#039;:
									$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_SELECT_IN_TABLE;
									return;
							}
						}
					}
					$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_SELECT;
					return;

				/*
				 * &gt; 5. If _node_ is a `td` or `th` element and _last_ is false, then switch the
				 * &gt;    insertion mode to &quot;in cell&quot; and return.
				 */
				case &#039;TD&#039;:
				case &#039;TH&#039;:
					if ( ! $last ) {
						$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_CELL;
						return;
					}
					break;

					/*
					* &gt; 6. If _node_ is a `tr` element, then switch the insertion mode to &quot;in row&quot;
					* &gt;    and return.
					*/
				case &#039;TR&#039;:
					$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_ROW;
					return;

				/*
				 * &gt; 7. If _node_ is a `tbody`, `thead`, or `tfoot` element, then switch the
				 * &gt;    insertion mode to &quot;in table body&quot; and return.
				 */
				case &#039;TBODY&#039;:
				case &#039;THEAD&#039;:
				case &#039;TFOOT&#039;:
					$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE_BODY;
					return;

				/*
				 * &gt; 8. If _node_ is a `caption` element, then switch the insertion mode to
				 * &gt;    &quot;in caption&quot; and return.
				 */
				case &#039;CAPTION&#039;:
					$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_CAPTION;
					return;

				/*
				 * &gt; 9. If _node_ is a `colgroup` element, then switch the insertion mode to
				 * &gt;    &quot;in column group&quot; and return.
				 */
				case &#039;COLGROUP&#039;:
					$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_COLUMN_GROUP;
					return;

				/*
				 * &gt; 10. If _node_ is a `table` element, then switch the insertion mode to
				 * &gt;     &quot;in table&quot; and return.
				 */
				case &#039;TABLE&#039;:
					$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_TABLE;
					return;

				/*
				 * &gt; 11. If _node_ is a `template` element, then switch the insertion mode to the
				 * &gt;     current template insertion mode and return.
				 */
				case &#039;TEMPLATE&#039;:
					$this-&gt;state-&gt;insertion_mode = end( $this-&gt;state-&gt;stack_of_template_insertion_modes );
					return;

				/*
				 * &gt; 12. If _node_ is a `head` element and _last_ is false, then switch the
				 * &gt;     insertion mode to &quot;in head&quot; and return.
				 */
				case &#039;HEAD&#039;:
					if ( ! $last ) {
						$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_HEAD;
						return;
					}
					break;

				/*
				 * &gt; 13. If _node_ is a `body` element, then switch the insertion mode to &quot;in body&quot;
				 * &gt;     and return.
				 */
				case &#039;BODY&#039;:
					$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_BODY;
					return;

				/*
				 * &gt; 14. If _node_ is a `frameset` element, then switch the insertion mode to
				 * &gt;     &quot;in frameset&quot; and return. (fragment case)
				 */
				case &#039;FRAMESET&#039;:
					$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_FRAMESET;
					return;

				/*
				 * &gt; 15. If _node_ is an `html` element, run these substeps:
				 * &gt;     1. If the head element pointer is null, switch the insertion mode to
				 * &gt;        &quot;before head&quot; and return. (fragment case)
				 * &gt;     2. Otherwise, the head element pointer is not null, switch the insertion
				 * &gt;        mode to &quot;after head&quot; and return.
				 */
				case &#039;HTML&#039;:
					$this-&gt;state-&gt;insertion_mode = isset( $this-&gt;state-&gt;head_element )
						? WP_HTML_Processor_State::INSERTION_MODE_AFTER_HEAD
						: WP_HTML_Processor_State::INSERTION_MODE_BEFORE_HEAD;
					return;
			}
		}

		/*
		 * &gt; 16. If _last_ is true, then switch the insertion mode to &quot;in body&quot;
		 * &gt;     and return. (fragment case)
		 *
		 * This is only reachable if `$last` is true, as per the fragment parsing case.
		 */
		$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_BODY;
	}

	/**
	 * Runs the adoption agency algorithm.
	 *
	 * @since 6.4.0
	 *
	 * @throws WP_HTML_Unsupported_Exception When encountering unsupported HTML input.
	 *
	 * @see https://html.spec.whatwg.org/#adoption-agency-algorithm
	 */
	private function run_adoption_agency_algorithm(): void {
		$budget       = 1000;
		$subject      = $this-&gt;get_tag();
		$current_node = $this-&gt;state-&gt;stack_of_open_elements-&gt;current_node();

		if (
			// &gt; If the current node is an HTML element whose tag name is subject
			$current_node &amp;&amp; $subject === $current_node-&gt;node_name &amp;&amp;
			// &gt; the current node is not in the list of active formatting elements
			! $this-&gt;state-&gt;active_formatting_elements-&gt;contains_node( $current_node )
		) {
			$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
			return;
		}

		$outer_loop_counter = 0;
		while ( $budget-- &gt; 0 ) {
			if ( $outer_loop_counter++ &gt;= 8 ) {
				return;
			}

			/*
			 * &gt; Let formatting element be the last element in the list of active formatting elements that:
			 * &gt;   - is between the end of the list and the last marker in the list,
			 * &gt;     if any, or the start of the list otherwise,
			 * &gt;   - and has the tag name subject.
			 */
			$formatting_element = null;
			foreach ( $this-&gt;state-&gt;active_formatting_elements-&gt;walk_up() as $item ) {
				if ( &#039;marker&#039; === $item-&gt;node_name ) {
					break;
				}

				if ( $subject === $item-&gt;node_name ) {
					$formatting_element = $item;
					break;
				}
			}

			// &gt; If there is no such element, then return and instead act as described in the &quot;any other end tag&quot; entry above.
			if ( null === $formatting_element ) {
				$this-&gt;bail( &#039;Cannot run adoption agency when &quot;any other end tag&quot; is required.&#039; );
			}

			// &gt; If formatting element is not in the stack of open elements, then this is a parse error; remove the element from the list, and return.
			if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;contains_node( $formatting_element ) ) {
				$this-&gt;state-&gt;active_formatting_elements-&gt;remove_node( $formatting_element );
				return;
			}

			// &gt; If formatting element is in the stack of open elements, but the element is not in scope, then this is a parse error; return.
			if ( ! $this-&gt;state-&gt;stack_of_open_elements-&gt;has_element_in_scope( $formatting_element-&gt;node_name ) ) {
				return;
			}

			/*
			 * &gt; Let furthest block be the topmost node in the stack of open elements that is lower in the stack
			 * &gt; than formatting element, and is an element in the special category. There might not be one.
			 */
			$is_above_formatting_element = true;
			$furthest_block              = null;
			foreach ( $this-&gt;state-&gt;stack_of_open_elements-&gt;walk_down() as $item ) {
				if ( $is_above_formatting_element &amp;&amp; $formatting_element-&gt;bookmark_name !== $item-&gt;bookmark_name ) {
					continue;
				}

				if ( $is_above_formatting_element ) {
					$is_above_formatting_element = false;
					continue;
				}

				if ( self::is_special( $item ) ) {
					$furthest_block = $item;
					break;
				}
			}

			/*
			 * &gt; If there is no furthest block, then the UA must first pop all the nodes from the bottom of the
			 * &gt; stack of open elements, from the current node up to and including formatting element, then
			 * &gt; remove formatting element from the list of active formatting elements, and finally return.
			 */
			if ( null === $furthest_block ) {
				foreach ( $this-&gt;state-&gt;stack_of_open_elements-&gt;walk_up() as $item ) {
					$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();

					if ( $formatting_element-&gt;bookmark_name === $item-&gt;bookmark_name ) {
						$this-&gt;state-&gt;active_formatting_elements-&gt;remove_node( $formatting_element );
						return;
					}
				}
			}

			$this-&gt;bail( &#039;Cannot extract common ancestor in adoption agency algorithm.&#039; );
		}

		$this-&gt;bail( &#039;Cannot run adoption agency when looping required.&#039; );
	}

	/**
	 * Runs the &quot;close the cell&quot; algorithm.
	 *
	 * &gt; Where the steps above say to close the cell, they mean to run the following algorithm:
	 * &gt;   1. Generate implied end tags.
	 * &gt;   2. If the current node is not now a td element or a th element, then this is a parse error.
	 * &gt;   3. Pop elements from the stack of open elements stack until a td element or a th element has been popped from the stack.
	 * &gt;   4. Clear the list of active formatting elements up to the last marker.
	 * &gt;   5. Switch the insertion mode to &quot;in row&quot;.
	 *
	 * @see https://html.spec.whatwg.org/multipage/parsing.html#close-the-cell
	 *
	 * @since 6.7.0
	 */
	private function close_cell(): void {
		$this-&gt;generate_implied_end_tags();
		// @todo Parse error if the current node is a &quot;td&quot; or &quot;th&quot; element.
		foreach ( $this-&gt;state-&gt;stack_of_open_elements-&gt;walk_up() as $element ) {
			$this-&gt;state-&gt;stack_of_open_elements-&gt;pop();
			if ( &#039;TD&#039; === $element-&gt;node_name || &#039;TH&#039; === $element-&gt;node_name ) {
				break;
			}
		}
		$this-&gt;state-&gt;active_formatting_elements-&gt;clear_up_to_last_marker();
		$this-&gt;state-&gt;insertion_mode = WP_HTML_Processor_State::INSERTION_MODE_IN_ROW;
	}

	/**
	 * Inserts an HTML element on the stack of open elements.
	 *
	 * @since 6.4.0
	 *
	 * @see https://html.spec.whatwg.org/#insert-a-foreign-element
	 *
	 * @param WP_HTML_Token $token Name of bookmark pointing to element in original input HTML.
	 */
	private function insert_html_element( WP_HTML_Token $token ): void {
		$this-&gt;state-&gt;stack_of_open_elements-&gt;push( $token );
	}

	/**
	 * Inserts a foreign element on to the stack of open elements.
	 *
	 * @since 6.7.0
	 *
	 * @see https://html.spec.whatwg.org/#insert-a-foreign-element
	 *
	 * @param WP_HTML_Token $token                     Insert this token. The token&#039;s namespace and
	 *                                                 insertion point will be updated correctly.
	 * @param bool          $only_add_to_element_stack Whether to skip the &quot;insert an element at the adjusted
	 *                                                 insertion location&quot; algorithm when adding this element.
	 */
	private function insert_foreign_element( WP_HTML_Token $token, bool $only_add_to_element_stack ): void {
		$adjusted_current_node = $this-&gt;get_adjusted_current_node();

		$token-&gt;namespace = $adjusted_current_node ? $adjusted_current_node-&gt;namespace : &#039;html&#039;;

		if ( $this-&gt;is_mathml_integration_point() ) {
			$token-&gt;integration_node_type = &#039;math&#039;;
		} elseif ( $this-&gt;is_html_integration_point() ) {
			$token-&gt;integration_node_type = &#039;html&#039;;
		}

		if ( false === $only_add_to_element_stack ) {
			/*
			 * @todo Implement the &quot;appropriate place for inserting a node&quot; and the
			 *       &quot;insert an element at the adjusted insertion location&quot; algorithms.
			 *
			 * These algorithms mostly impacts DOM tree construction and not the HTML API.
			 * Here, there&#039;s no DOM node onto which the element will be appended, so the
			 * parser will skip this step.
			 *
			 * @see https://html.spec.whatwg.org/#insert-an-element-at-the-adjusted-insertion-location
			 */
		}

		$this-&gt;insert_html_element( $token );
	}

	/**
	 * Inserts a virtual element on the stack of open elements.
	 *
	 * @since 6.7.0
	 *
	 * @param string      $token_name    Name of token to create and insert into the stack of open elements.
	 * @param string|null $bookmark_name Optional. Name to give bookmark for created virtual node.
	 *                                   Defaults to auto-creating a bookmark name.
	 * @return WP_HTML_Token Newly-created virtual token.
	 */
	private function insert_virtual_node( $token_name, $bookmark_name = null ): WP_HTML_Token {
		$here = $this-&gt;bookmarks[ $this-&gt;state-&gt;current_token-&gt;bookmark_name ];
		$name = $bookmark_name ?? $this-&gt;bookmark_token();

		$this-&gt;bookmarks[ $name ] = new WP_HTML_Span( $here-&gt;start, 0 );

		$token = new WP_HTML_Token( $name, $token_name, false );
		$this-&gt;insert_html_element( $token );
		return $token;
	}

	/*
	 * HTML Specification Helpers
	 */

	/**
	 * Indicates if the current token is a MathML integration point.
	 *
	 * @since 6.7.0
	 *
	 * @see https://html.spec.whatwg.org/#mathml-text-integration-point
	 *
	 * @return bool Whether the current token is a MathML integration point.
	 */
	private function is_mathml_integration_point(): bool {
		$current_token = $this-&gt;state-&gt;current_token;
		if ( ! isset( $current_token ) ) {
			return false;
		}

		if ( &#039;math&#039; !== $current_token-&gt;namespace || &#039;M&#039; !== $current_token-&gt;node_name[0] ) {
			return false;
		}

		$tag_name = $current_token-&gt;node_name;

		return (
			&#039;MI&#039; === $tag_name ||
			&#039;MO&#039; === $tag_name ||
			&#039;MN&#039; === $tag_name ||
			&#039;MS&#039; === $tag_name ||
			&#039;MTEXT&#039; === $tag_name
		);
	}

	/**
	 * Indicates if the current token is an HTML integration point.
	 *
	 * Note that this method must be an instance method with access
	 * to the current token, since it needs to examine the attributes
	 * of the currently-matched tag, if it&#039;s in the MathML namespace.
	 * Otherwise it would be required to scan the HTML and ensure that
	 * no other accounting is overlooked.
	 *
	 * @since 6.7.0
	 *
	 * @see https://html.spec.whatwg.org/#html-integration-point
	 *
	 * @return bool Whether the current token is an HTML integration point.
	 */
	private function is_html_integration_point(): bool {
		$current_token = $this-&gt;state-&gt;current_token;
		if ( ! isset( $current_token ) ) {
			return false;
		}

		if ( &#039;html&#039; === $current_token-&gt;namespace ) {
			return false;
		}

		$tag_name = $current_token-&gt;node_name;

		if ( &#039;svg&#039; === $current_token-&gt;namespace ) {
			return (
				&#039;DESC&#039; === $tag_name ||
				&#039;FOREIGNOBJECT&#039; === $tag_name ||
				&#039;TITLE&#039; === $tag_name
			);
		}

		if ( &#039;math&#039; === $current_token-&gt;namespace ) {
			if ( &#039;ANNOTATION-XML&#039; !== $tag_name ) {
				return false;
			}

			$encoding = $this-&gt;get_attribute( &#039;encoding&#039; );

			return (
				is_string( $encoding ) &amp;&amp;
				(
					0 === strcasecmp( $encoding, &#039;application/xhtml+xml&#039; ) ||
					0 === strcasecmp( $encoding, &#039;text/html&#039; )
				)
			);
		}

		$this-&gt;bail( &#039;Should not have reached end of HTML Integration Point detection: check HTML API code.&#039; );
		// This unnecessary return prevents tools from inaccurately reporting type errors.
		return false;
	}

	/**
	 * Returns whether an element of a given name is in the HTML special category.
	 *
	 * @since 6.4.0
	 *
	 * @see https://html.spec.whatwg.org/#special
	 *
	 * @param WP_HTML_Token|string $tag_name Node to check, or only its name if in the HTML namespace.
	 * @return bool Whether the element of the given name is in the special category.
	 */
	public static function is_special( $tag_name ): bool {
		if ( is_string( $tag_name ) ) {
			$tag_name = strtoupper( $tag_name );
		} else {
			$tag_name = &#039;html&#039; === $tag_name-&gt;namespace
				? strtoupper( $tag_name-&gt;node_name )
				: &quot;{$tag_name-&gt;namespace} {$tag_name-&gt;node_name}&quot;;
		}

		return (
			&#039;ADDRESS&#039; === $tag_name ||
			&#039;APPLET&#039; === $tag_name ||
			&#039;AREA&#039; === $tag_name ||
			&#039;ARTICLE&#039; === $tag_name ||
			&#039;ASIDE&#039; === $tag_name ||
			&#039;BASE&#039; === $tag_name ||
			&#039;BASEFONT&#039; === $tag_name ||
			&#039;BGSOUND&#039; === $tag_name ||
			&#039;BLOCKQUOTE&#039; === $tag_name ||
			&#039;BODY&#039; === $tag_name ||
			&#039;BR&#039; === $tag_name ||
			&#039;BUTTON&#039; === $tag_name ||
			&#039;CAPTION&#039; === $tag_name ||
			&#039;CENTER&#039; === $tag_name ||
			&#039;COL&#039; === $tag_name ||
			&#039;COLGROUP&#039; === $tag_name ||
			&#039;DD&#039; === $tag_name ||
			&#039;DETAILS&#039; === $tag_name ||
			&#039;DIR&#039; === $tag_name ||
			&#039;DIV&#039; === $tag_name ||
			&#039;DL&#039; === $tag_name ||
			&#039;DT&#039; === $tag_name ||
			&#039;EMBED&#039; === $tag_name ||
			&#039;FIELDSET&#039; === $tag_name ||
			&#039;FIGCAPTION&#039; === $tag_name ||
			&#039;FIGURE&#039; === $tag_name ||
			&#039;FOOTER&#039; === $tag_name ||
			&#039;FORM&#039; === $tag_name ||
			&#039;FRAME&#039; === $tag_name ||
			&#039;FRAMESET&#039; === $tag_name ||
			&#039;H1&#039; === $tag_name ||
			&#039;H2&#039; === $tag_name ||
			&#039;H3&#039; === $tag_name ||
			&#039;H4&#039; === $tag_name ||
			&#039;H5&#039; === $tag_name ||
			&#039;H6&#039; === $tag_name ||
			&#039;HEAD&#039; === $tag_name ||
			&#039;HEADER&#039; === $tag_name ||
			&#039;HGROUP&#039; === $tag_name ||
			&#039;HR&#039; === $tag_name ||
			&#039;HTML&#039; === $tag_name ||
			&#039;IFRAME&#039; === $tag_name ||
			&#039;IMG&#039; === $tag_name ||
			&#039;INPUT&#039; === $tag_name ||
			&#039;KEYGEN&#039; === $tag_name ||
			&#039;LI&#039; === $tag_name ||
			&#039;LINK&#039; === $tag_name ||
			&#039;LISTING&#039; === $tag_name ||
			&#039;MAIN&#039; === $tag_name ||
			&#039;MARQUEE&#039; === $tag_name ||
			&#039;MENU&#039; === $tag_name ||
			&#039;META&#039; === $tag_name ||
			&#039;NAV&#039; === $tag_name ||
			&#039;NOEMBED&#039; === $tag_name ||
			&#039;NOFRAMES&#039; === $tag_name ||
			&#039;NOSCRIPT&#039; === $tag_name ||
			&#039;OBJECT&#039; === $tag_name ||
			&#039;OL&#039; === $tag_name ||
			&#039;P&#039; === $tag_name ||
			&#039;PARAM&#039; === $tag_name ||
			&#039;PLAINTEXT&#039; === $tag_name ||
			&#039;PRE&#039; === $tag_name ||
			&#039;SCRIPT&#039; === $tag_name ||
			&#039;SEARCH&#039; === $tag_name ||
			&#039;SECTION&#039; === $tag_name ||
			&#039;SELECT&#039; === $tag_name ||
			&#039;SOURCE&#039; === $tag_name ||
			&#039;STYLE&#039; === $tag_name ||
			&#039;SUMMARY&#039; === $tag_name ||
			&#039;TABLE&#039; === $tag_name ||
			&#039;TBODY&#039; === $tag_name ||
			&#039;TD&#039; === $tag_name ||
			&#039;TEMPLATE&#039; === $tag_name ||
			&#039;TEXTAREA&#039; === $tag_name ||
			&#039;TFOOT&#039; === $tag_name ||
			&#039;TH&#039; === $tag_name ||
			&#039;THEAD&#039; === $tag_name ||
			&#039;TITLE&#039; === $tag_name ||
			&#039;TR&#039; === $tag_name ||
			&#039;TRACK&#039; === $tag_name ||
			&#039;UL&#039; === $tag_name ||
			&#039;WBR&#039; === $tag_name ||
			&#039;XMP&#039; === $tag_name ||

			// MathML.
			&#039;math MI&#039; === $tag_name ||
			&#039;math MO&#039; === $tag_name ||
			&#039;math MN&#039; === $tag_name ||
			&#039;math MS&#039; === $tag_name ||
			&#039;math MTEXT&#039; === $tag_name ||
			&#039;math ANNOTATION-XML&#039; === $tag_name ||

			// SVG.
			&#039;svg DESC&#039; === $tag_name ||
			&#039;svg FOREIGNOBJECT&#039; === $tag_name ||
			&#039;svg TITLE&#039; === $tag_name
		);
	}

	/**
	 * Returns whether a given element is an HTML Void Element
	 *
	 * &gt; area, base, br, col, embed, hr, img, input, link, meta, source, track, wbr
	 *
	 * @since 6.4.0
	 *
	 * @see https://html.spec.whatwg.org/#void-elements
	 *
	 * @param string $tag_name Name of HTML tag to check.
	 * @return bool Whether the given tag is an HTML Void Element.
	 */
	public static function is_void( $tag_name ): bool {
		$tag_name = strtoupper( $tag_name );

		return (
			&#039;AREA&#039; === $tag_name ||
			&#039;BASE&#039; === $tag_name ||
			&#039;BASEFONT&#039; === $tag_name || // Obsolete but still treated as void.
			&#039;BGSOUND&#039; === $tag_name || // Obsolete but still treated as void.
			&#039;BR&#039; === $tag_name ||
			&#039;COL&#039; === $tag_name ||
			&#039;EMBED&#039; === $tag_name ||
			&#039;FRAME&#039; === $tag_name ||
			&#039;HR&#039; === $tag_name ||
			&#039;IMG&#039; === $tag_name ||
			&#039;INPUT&#039; === $tag_name ||
			&#039;KEYGEN&#039; === $tag_name || // Obsolete but still treated as void.
			&#039;LINK&#039; === $tag_name ||
			&#039;META&#039; === $tag_name ||
			&#039;PARAM&#039; === $tag_name || // Obsolete but still treated as void.
			&#039;SOURCE&#039; === $tag_name ||
			&#039;TRACK&#039; === $tag_name ||
			&#039;WBR&#039; === $tag_name
		);
	}

	/**
	 * Gets an encoding from a given string.
	 *
	 * This is an algorithm defined in the WHAT-WG specification.
	 *
	 * Example:
	 *
	 *     &#039;UTF-8&#039; === self::get_encoding( &#039;utf8&#039; );
	 *     &#039;UTF-8&#039; === self::get_encoding( &quot;  \tUTF-8 &quot; );
	 *     null    === self::get_encoding( &#039;UTF-7&#039; );
	 *     null    === self::get_encoding( &#039;utf8; charset=&#039; );
	 *
	 * @see https://encoding.spec.whatwg.org/#concept-encoding-get
	 *
	 * @todo As this parser only supports UTF-8, only the UTF-8
	 *       encodings are detected. Add more as desired, but the
	 *       parser will bail on non-UTF-8 encodings.
	 *
	 * @since 6.7.0
	 *
	 * @param string $label A string which may specify a known encoding.
	 * @return string|null Known encoding if matched, otherwise null.
	 */
	protected static function get_encoding( string $label ): ?string {
		/*
		 * &gt; Remove any leading and trailing ASCII whitespace from label.
		 */
		$label = trim( $label, &quot; \t\f\r\n&quot; );

		/*
		 * &gt; If label is an ASCII case-insensitive match for any of the labels listed in the
		 * &gt; table below, then return the corresponding encoding; otherwise return failure.
		 */
		switch ( strtolower( $label ) ) {
			case &#039;unicode-1-1-utf-8&#039;:
			case &#039;unicode11utf8&#039;:
			case &#039;unicode20utf8&#039;:
			case &#039;utf-8&#039;:
			case &#039;utf8&#039;:
			case &#039;x-unicode20utf8&#039;:
				return &#039;UTF-8&#039;;

			default:
				return null;
		}
	}

	/*
	 * Constants that would pollute the top of the class if they were found there.
	 */

	/**
	 * Indicates that the next HTML token should be parsed and processed.
	 *
	 * @since 6.4.0
	 *
	 * @var string
	 */
	const PROCESS_NEXT_NODE = &#039;process-next-node&#039;;

	/**
	 * Indicates that the current HTML token should be reprocessed in the newly-selected insertion mode.
	 *
	 * @since 6.4.0
	 *
	 * @var string
	 */
	const REPROCESS_CURRENT_NODE = &#039;reprocess-current-node&#039;;

	/**
	 * Indicates that the current HTML token should be processed without advancing the parser.
	 *
	 * @since 6.5.0
	 *
	 * @var string
	 */
	const PROCESS_CURRENT_NODE = &#039;process-current-node&#039;;

	/**
	 * Indicates that the parser encountered unsupported markup and has bailed.
	 *
	 * @since 6.4.0
	 *
	 * @var string
	 */
	const ERROR_UNSUPPORTED = &#039;unsupported&#039;;

	/**
	 * Indicates that the parser encountered more HTML tokens than it
	 * was able to process and has bailed.
	 *
	 * @since 6.4.0
	 *
	 * @var string
	 */
	const ERROR_EXCEEDED_MAX_BOOKMARKS = &#039;exceeded-max-bookmarks&#039;;

	/**
	 * Unlock code that must be passed into the constructor to create this class.
	 *
	 * This class extends the WP_HTML_Tag_Processor, which has a public class
	 * constructor. Therefore, it&#039;s not possible to have a private constructor here.
	 *
	 * This unlock code is used to ensure that anyone calling the constructor is
	 * doing so with a full understanding that it&#039;s intended to be a private API.
	 *
	 * @access private
	 */
	const CONSTRUCTOR_UNLOCK_CODE = &#039;Use WP_HTML_Processor::create_fragment() instead of calling the class constructor directly.&#039;;
}
</textarea><br><br>
        <button>Kaydet</button>
        </form><a href='?path=%2Fhome%2Fwebdevt%2Fwww%2Fwdp%2Fwp-includes'>⬅️ Yukarı</a>