diff --git a/src/wp-includes/html-api/class-wp-html-processor.php b/src/wp-includes/html-api/class-wp-html-processor.php
index d64574e2a8db2..a17ba18de3340 100644
--- a/src/wp-includes/html-api/class-wp-html-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-processor.php
@@ -637,6 +637,57 @@ public function get_unsupported_exception() {
 		return $this->unsupported_exception;
 	}
 
+	/**
+	 * Progress through a document pausing on tags matching the provided CSS selector string.
+	 *
+	 * Example:
+	 *
+	 *     $processor = WP_HTML_Processor::create_fragment(
+	 *         '<meta charset="utf-8"><title>Example</title><meta property="og:type" content="website"><meta property="og:description" content="An example.">'
+	 *     );
+	 *     while ( $processor->select( 'meta[property^="og:" i]' ) ) {
+	 *         // Loop is entered twice.
+	 *         var_dump(
+	 *             $processor->get_tag(),                   // string(4) "META"
+	 *             $processor->get_attribute( 'property' ), // string(7) "og:type" / string(14) "og:description"
+	 *             $processor->get_attribute( 'content' ),  // string(7) "website" / string(11) "An example."
+	 *         );
+	 *     }
+	 *
+	 * @since {WP_VERSION}
+	 *
+	 * @param string $selector_string Selector string.
+	 * @return bool Whether a selection was found.
+	 */
+	public function select( $selector_string ): bool {
+		static $previous_selector_string = null;
+		static $previous_selector        = null;
+
+		$selector = $selector_string === $previous_selector_string
+			? $previous_selector
+			: WP_CSS_Complex_Selector_List::from_selectors( $selector_string );
+
+		$previous_selector        = $selector;
+		$previous_selector_string = $selector_string;
+
+		if ( null === $selector ) {
+			_doing_it_wrong(
+				__METHOD__,
+				sprintf( 'Received unsupported or invalid selector "%s".', $selector_string ),
+				'{WP_VERSION}'
+			);
+			return false;
+		}
+
+		while ( $this->next_tag() ) {
+			if ( $selector->matches( $this ) ) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
 	/**
 	 * Finds the next tag matching the $query.
 	 *
diff --git a/src/wp-includes/html-api/class-wp-html-tag-processor.php b/src/wp-includes/html-api/class-wp-html-tag-processor.php
index 032ca2af32e57..ac066a908b6c9 100644
--- a/src/wp-includes/html-api/class-wp-html-tag-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-tag-processor.php
@@ -537,6 +537,10 @@ class WP_HTML_Tag_Processor {
 	 */
 	protected $compat_mode = self::NO_QUIRKS_MODE;
 
+	public function is_quirks_mode() {
+		return self::QUIRKS_MODE === $this->compat_mode;
+	}
+
 	/**
 	 * Indicates whether the parser is inside foreign content,
 	 * e.g. inside an SVG or MathML element.
@@ -856,6 +860,57 @@ public function change_parsing_namespace( string $new_namespace ): bool {
 		return true;
 	}
 
+	/**
+	 * Progress through a document pausing on tags matching the provided CSS selector string.
+	 *
+	 * Example:
+	 *
+	 *     $processor = new WP_HTML_Tag_Processor(
+	 *         '<meta charset="utf-8"><title>Example</title><meta property="og:type" content="website"><meta property="og:description" content="An example.">'
+	 *     );
+	 *     while ( $processor->select( 'meta[property^="og:" i]' ) ) {
+	 *         // Loop is entered twice.
+	 *         var_dump(
+	 *             $processor->get_tag(),                   // string(4) "META"
+	 *             $processor->get_attribute( 'property' ), // string(7) "og:type" / string(14) "og:description"
+	 *             $processor->get_attribute( 'content' ),  // string(7) "website" / string(11) "An example."
+	 *         );
+	 *     }
+	 *
+	 * @since {WP_VERSION}
+	 *
+	 * @param string $selector_string Selector string.
+	 * @return bool Whether a selection was found.
+	 */
+	public function select( $selector_string ): bool {
+		static $previous_selector_string = null;
+		static $previous_selector        = null;
+
+		$selector = $selector_string === $previous_selector_string
+			? $previous_selector
+			: WP_CSS_Compound_Selector_List::from_selectors( $selector_string );
+
+		$previous_selector        = $selector;
+		$previous_selector_string = $selector_string;
+
+		if ( null === $selector ) {
+			_doing_it_wrong(
+				__METHOD__,
+				sprintf( 'Received unsupported or invalid selector "%s".', $selector_string ),
+				'{WP_VERSION}'
+			);
+			return false;
+		}
+
+		while ( $this->next_tag() ) {
+			if ( $selector->matches( $this ) ) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
 	/**
 	 * Finds the next tag matching the $query.
 	 *
diff --git a/src/wp-includes/html-api/css/class-wp-css-attribute-selector.php b/src/wp-includes/html-api/css/class-wp-css-attribute-selector.php
new file mode 100644
index 0000000000000..a63dfaba66b61
--- /dev/null
+++ b/src/wp-includes/html-api/css/class-wp-css-attribute-selector.php
@@ -0,0 +1,357 @@
+<?php
+/**
+ * HTML API: WP_CSS_Attribute_Selector class
+ *
+ * @package WordPress
+ * @subpackage HTML-API
+ * @since {WP_VERSION}
+ */
+
+/**
+ * CSS attribute selector.
+ *
+ * This class is used to test for matching HTML tags in a {@see WP_HTML_Tag_Processor}.
+ *
+ * @since {WP_VERSION}
+ *
+ * @access private
+ */
+final class WP_CSS_Attribute_Selector extends WP_CSS_Selector_Parser_Matcher {
+	/**
+	 * The attribute value is matched exactly.
+	 *
+	 * @example
+	 *
+	 *     [attr=val]
+	 */
+	const MATCH_EXACT = 'exact';
+
+	/**
+	 * The attribute value matches any value in a whitespace separated list of words exactly.
+	 *
+	 * @example
+	 *
+	 *     [attr~=value]
+	 */
+	const MATCH_ONE_OF_EXACT = 'one-of';
+
+	/**
+	 * The attribute value is matched exactly or matches the beginning of the attribute
+	 * immediately followed by a hyphen.
+	 *
+	 * @example
+	 *
+	 *     [attr|=value]
+	 */
+	const MATCH_EXACT_OR_HYPHEN_SUFFIXED = 'exact-or-hyphen-suffixed';
+
+	/**
+	 * The attribute value matches the start of the attribute.
+	 *
+	 * @example
+	 *
+	 *     [attr^=value]
+	 */
+	const MATCH_PREFIXED_BY = 'prefixed';
+
+	/**
+	 * The attribute value matches the end of the attribute.
+	 *
+	 * @example
+	 *
+	 *     [attr$=value]
+	 */
+	const MATCH_SUFFIXED_BY = 'suffixed';
+
+	/**
+	 * The attribute value is contained in the attribute.
+	 *
+	 * @example
+	 *
+	 *     [attr*=value]
+	 */
+	const MATCH_CONTAINS = 'contains';
+
+	/**
+	 * Modifier for case sensitive matching.
+	 *
+	 * @example
+	 *
+	 *     [attr=value s]
+	 */
+	const MODIFIER_CASE_SENSITIVE = 'case-sensitive';
+
+	/**
+	 * Modifier for case insensitive matching.
+	 *
+	 * @example
+	 *
+	 *     [attr=value i]
+	 */
+	const MODIFIER_CASE_INSENSITIVE = 'case-insensitive';
+
+	/**
+	 * The name of the attribute to match.
+	 *
+	 * @var string
+	 */
+	public $name;
+
+	/**
+	 * The attribute matcher.
+	 *
+	 * Allowed string values are the class constants:
+	 *   - {@see WP_CSS_Attribute_Selector::MATCH_EXACT}
+	 *   - {@see WP_CSS_Attribute_Selector::MATCH_ONE_OF_EXACT}
+	 *   - {@see WP_CSS_Attribute_Selector::MATCH_EXACT_OR_HYPHEN_SUFFIXED}
+	 *   - {@see WP_CSS_Attribute_Selector::MATCH_PREFIXED_BY}
+	 *   - {@see WP_CSS_Attribute_Selector::MATCH_SUFFIXED_BY}
+	 *   - {@see WP_CSS_Attribute_Selector::MATCH_CONTAINS}
+	 *
+	 * @var string|null
+	 */
+	public $matcher;
+
+	/**
+	 * The attribute value to match.
+	 *
+	 * @var string|null
+	 */
+	public $value;
+
+	/**
+	 * The attribute modifier.
+	 *
+	 * Allowed string values are the class constants:
+	 *   - {@see WP_CSS_Attribute_Selector::MODIFIER_CASE_SENSITIVE}
+	 *   - {@see WP_CSS_Attribute_Selector::MODIFIER_CASE_INSENSITIVE}
+	 *
+	 * @var string|null
+	 */
+	public $modifier;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param string $name The attribute name.
+	 * @param string|null $matcher The attribute matcher.
+	 *        Must be one of the class MATCH_* constants or null.
+	 * @param string|null $value The attribute value to match.
+	 * @param string|null $modifier The attribute case modifier.
+	 *        Must be one of the class MODIFIER_* constants or null.
+	 */
+	private function __construct( string $name, ?string $matcher = null, ?string $value = null, ?string $modifier = null ) {
+		$this->name     = $name;
+		$this->matcher  = $matcher;
+		$this->value    = $value;
+		$this->modifier = $modifier;
+	}
+
+	/**
+	 * Determines if the processor's current position matches the selector.
+	 *
+	 * @param WP_HTML_Tag_Processor $processor The processor.
+	 * @return bool True if the processor's current position matches the selector.
+	 */
+	public function matches( WP_HTML_Tag_Processor $processor ): bool {
+		$attr_value = $processor->get_attribute( $this->name );
+		if ( null === $attr_value ) {
+			return false;
+		}
+
+		if ( null === $this->value ) {
+			return true;
+		}
+
+		if ( true === $attr_value ) {
+			$attr_value = '';
+		}
+
+		$case_insensitive = self::MODIFIER_CASE_INSENSITIVE === $this->modifier;
+
+		switch ( $this->matcher ) {
+			case self::MATCH_EXACT:
+				return $case_insensitive
+					? 0 === strcasecmp( $attr_value, $this->value )
+					: $attr_value === $this->value;
+
+			case self::MATCH_ONE_OF_EXACT:
+				foreach ( $this->whitespace_delimited_list( $attr_value ) as $val ) {
+					if (
+						$case_insensitive
+							? 0 === strcasecmp( $val, $this->value )
+							: $val === $this->value
+					) {
+						return true;
+					}
+				}
+				return false;
+
+			case self::MATCH_EXACT_OR_HYPHEN_SUFFIXED:
+				$exact_length   = strlen( $this->value );
+				$matches_prefix = substr_compare( $attr_value, $this->value, 0, $exact_length, $case_insensitive );
+				return (
+					0 === $matches_prefix &&
+					( strlen( $attr_value ) === $exact_length || '-' === $attr_value[ $exact_length ] )
+				);
+
+			case self::MATCH_PREFIXED_BY:
+				return 0 === substr_compare( $attr_value, $this->value, 0, strlen( $this->value ), $case_insensitive );
+
+			case self::MATCH_SUFFIXED_BY:
+				return 0 === substr_compare( $attr_value, $this->value, -strlen( $this->value ), null, $case_insensitive );
+
+			case self::MATCH_CONTAINS:
+				return false !== (
+					$case_insensitive
+						? stripos( $attr_value, $this->value )
+						: strpos( $attr_value, $this->value )
+				);
+		}
+	}
+
+	/**
+	 * Splits a string into a list of whitespace delimited values.
+	 *
+	 * This is useful for the {@see WP_CSS_Attribute_Selector::MATCH_ONE_OF_EXACT} matcher.
+	 *
+	 * @param string $input
+	 *
+	 * @return Generator<string> Yields each whitespace-delimited value from the input string.
+	 */
+	private function whitespace_delimited_list( string $input ): Generator {
+		// Start by skipping whitespace.
+		$offset = strspn( $input, self::WHITESPACE_CHARACTERS );
+
+		while ( $offset < strlen( $input ) ) {
+			// Find the byte length until the next boundary.
+			$length = strcspn( $input, self::WHITESPACE_CHARACTERS, $offset );
+			$value  = substr( $input, $offset, $length );
+
+			// Move past trailing whitespace.
+			$offset += $length + strspn( $input, self::WHITESPACE_CHARACTERS, $offset + $length );
+
+			yield $value;
+		}
+	}
+
+	/**
+	 * Parses a selector string to create a selector instance.
+	 *
+	 * To create an instance of this class, use the {@see WP_CSS_Compound_Selector_List::from_selectors()} method.
+	 *
+	 * @param string $input The selector string.
+	 * @param int    $offset The offset into the string. The offset is passed by reference and
+	 *                       will be updated if the parse is successful.
+	 * @return static|null The selector instance, or null if the parse was unsuccessful.
+	 */
+	public static function parse( string $input, int &$offset ) {
+		// Need at least 3 bytes [x]
+		if ( $offset + 2 >= strlen( $input ) ) {
+			return null;
+		}
+
+		$updated_offset = $offset;
+
+		if ( '[' !== $input[ $updated_offset ] ) {
+			return null;
+		}
+		++$updated_offset;
+
+		self::parse_whitespace( $input, $updated_offset );
+		$attr_name = self::parse_ident( $input, $updated_offset );
+		if ( null === $attr_name ) {
+			return null;
+		}
+		self::parse_whitespace( $input, $updated_offset );
+
+		if ( $updated_offset >= strlen( $input ) ) {
+			return null;
+		}
+
+		if ( ']' === $input[ $updated_offset ] ) {
+			$offset = $updated_offset + 1;
+			return new WP_CSS_Attribute_Selector( $attr_name );
+		}
+
+		// need to match at least `=x]` at this point
+		if ( $updated_offset + 3 >= strlen( $input ) ) {
+			return null;
+		}
+
+		if ( '=' === $input[ $updated_offset ] ) {
+			++$updated_offset;
+			$attr_matcher = WP_CSS_Attribute_Selector::MATCH_EXACT;
+		} elseif ( '=' === $input[ $updated_offset + 1 ] ) {
+			switch ( $input[ $updated_offset ] ) {
+				case '~':
+					$attr_matcher    = WP_CSS_Attribute_Selector::MATCH_ONE_OF_EXACT;
+					$updated_offset += 2;
+					break;
+				case '|':
+					$attr_matcher    = WP_CSS_Attribute_Selector::MATCH_EXACT_OR_HYPHEN_SUFFIXED;
+					$updated_offset += 2;
+					break;
+				case '^':
+					$attr_matcher    = WP_CSS_Attribute_Selector::MATCH_PREFIXED_BY;
+					$updated_offset += 2;
+					break;
+				case '$':
+					$attr_matcher    = WP_CSS_Attribute_Selector::MATCH_SUFFIXED_BY;
+					$updated_offset += 2;
+					break;
+				case '*':
+					$attr_matcher    = WP_CSS_Attribute_Selector::MATCH_CONTAINS;
+					$updated_offset += 2;
+					break;
+				default:
+					return null;
+			}
+		} else {
+			return null;
+		}
+
+		self::parse_whitespace( $input, $updated_offset );
+		$attr_val =
+			self::parse_string( $input, $updated_offset ) ??
+			self::parse_ident( $input, $updated_offset );
+
+		if ( null === $attr_val ) {
+			return null;
+		}
+
+		self::parse_whitespace( $input, $updated_offset );
+		if ( $updated_offset >= strlen( $input ) ) {
+			return null;
+		}
+
+		$attr_modifier = null;
+		switch ( $input[ $updated_offset ] ) {
+			case 'i':
+			case 'I':
+				$attr_modifier = WP_CSS_Attribute_Selector::MODIFIER_CASE_INSENSITIVE;
+				++$updated_offset;
+				break;
+
+			case 's':
+			case 'S':
+				$attr_modifier = WP_CSS_Attribute_Selector::MODIFIER_CASE_SENSITIVE;
+				++$updated_offset;
+				break;
+		}
+
+		if ( null !== $attr_modifier ) {
+			self::parse_whitespace( $input, $updated_offset );
+			if ( $updated_offset >= strlen( $input ) ) {
+				return null;
+			}
+		}
+
+		if ( ']' === $input[ $updated_offset ] ) {
+			$offset = $updated_offset + 1;
+			return new self( $attr_name, $attr_matcher, $attr_val, $attr_modifier );
+		}
+
+		return null;
+	}
+}
diff --git a/src/wp-includes/html-api/css/class-wp-css-class-selector.php b/src/wp-includes/html-api/css/class-wp-css-class-selector.php
new file mode 100644
index 0000000000000..121b3abf10f96
--- /dev/null
+++ b/src/wp-includes/html-api/css/class-wp-css-class-selector.php
@@ -0,0 +1,71 @@
+<?php
+/**
+ * HTML API: WP_CSS_Class_Selector class
+ *
+ * @package WordPress
+ * @subpackage HTML-API
+ * @since {WP_VERSION}
+ */
+
+/**
+ * CSS class selector.
+ *
+ * This class is used to test for matching HTML tags in a {@see WP_HTML_Tag_Processor}.
+ *
+ * @since {WP_VERSION}
+ *
+ * @access private
+ */
+final class WP_CSS_Class_Selector extends WP_CSS_Selector_Parser_Matcher {
+	/**
+	 * The class name to match.
+	 *
+	 * @var string
+	 */
+	public $class_name;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param string $class_name The class name to match.
+	 */
+	private function __construct( string $class_name ) {
+		$this->class_name = $class_name;
+	}
+
+	/**
+	 * Determines if the processor's current position matches the selector.
+	 *
+	 * @param WP_HTML_Tag_Processor $processor The processor.
+	 * @return bool True if the processor's current position matches the selector.
+	 */
+	public function matches( WP_HTML_Tag_Processor $processor ): bool {
+		return (bool) $processor->has_class( $this->class_name );
+	}
+
+	/**
+	 * Parses a selector string to create a selector instance.
+	 *
+	 * To create an instance of this class, use the {@see WP_CSS_Compound_Selector_List::from_selectors()} method.
+	 *
+	 * @param string $input The selector string.
+	 * @param int    $offset The offset into the string. The offset is passed by reference and
+	 *                       will be updated if the parse is successful.
+	 * @return static|null The selector instance, or null if the parse was unsuccessful.
+	 */
+	public static function parse( string $input, int &$offset ) {
+		if ( $offset + 1 >= strlen( $input ) || '.' !== $input[ $offset ] ) {
+			return null;
+		}
+
+		$updated_offset = $offset + 1;
+		$result         = self::parse_ident( $input, $updated_offset );
+
+		if ( null === $result ) {
+			return null;
+		}
+
+		$offset = $updated_offset;
+		return new self( $result );
+	}
+}
diff --git a/src/wp-includes/html-api/css/class-wp-css-complex-selector-list.php b/src/wp-includes/html-api/css/class-wp-css-complex-selector-list.php
new file mode 100644
index 0000000000000..da5e17011e0d8
--- /dev/null
+++ b/src/wp-includes/html-api/css/class-wp-css-complex-selector-list.php
@@ -0,0 +1,81 @@
+<?php
+/**
+ * HTML API: WP_CSS_Complex_Selector_List class
+ *
+ * @package WordPress
+ * @subpackage HTML-API
+ * @since {WP_VERSION}
+ */
+
+/**
+ * Core class used by the {@see WP_HTML_Processor} to parse and match CSS selectors.
+ *
+ * This class is designed for internal use by the HTML processor.
+ *
+ * For usage, see {@see WP_HTML_Processor::select()}.
+ *
+ * This class is instantiated via the {@see WP_CSS_Complex_Selector_List::from_selectors()} method.
+ * It takes a CSS selector string and returns an instance of itself or `null` if the selector
+ * is invalid or unsupported.
+ *
+ * A subset of the CSS selector grammar is supported. The grammar is defined in the CSS Syntax
+ * specification, which is available at {@link https://www.w3.org/TR/selectors/#grammar}.
+ *
+ * This class is roughly analogous to the <selector-list> in the grammar.
+ * See {@see WP_CSS_Compound_Selector_List} for more details on the grammar.
+ *
+ * This class supports the same selector syntax as {@see WP_CSS_Compound_Selector_List} as well as
+ * the following combinators:
+ *   - Descendant (`ancestor descendant`)
+ *   - Child (`parent > child`)
+ *
+ * Combinators may only be used with type selectors in the non-final position, for example:
+ *   - `div [type=input]` is valid because the `div` type selector appears in a non-final position.
+ *   - `[disabled] option` is NOT valid, because the `[disabled]` attribute selector appears
+ *     in a non-final position.
+ *
+ * These combinators are not supported:
+ *   - Next sibling (`former-sibling + next-sibling`)
+ *   - Subsequent sibling (`former-sibling ~ subsequent-sibling`)
+ *
+ * @since {WP_VERSION}
+ *
+ * @access private
+ */
+class WP_CSS_Complex_Selector_List extends WP_CSS_Compound_Selector_List {
+	/**
+	 * Parses a selector string to create a selector instance.
+	 *
+	 * To create an instance of this class, use the {@see WP_CSS_Compound_Selector_List::from_selectors()} method.
+	 *
+	 * @param string $input The selector string.
+	 * @param int    $offset The offset into the string. The offset is passed by reference and
+	 *                       will be updated if the parse is successful.
+	 * @return static|null The selector instance, or null if the parse was unsuccessful.
+	 */
+	public static function parse( string $input, int &$offset ) {
+		$selector = WP_CSS_Complex_Selector::parse( $input, $offset );
+		if ( null === $selector ) {
+			return null;
+		}
+		self::parse_whitespace( $input, $offset );
+
+		$selectors = array( $selector );
+		while ( $offset < strlen( $input ) ) {
+			// Each loop should stop on a `,` selector list delimiter.
+			if ( ',' !== $input[ $offset ] ) {
+				return null;
+			}
+			++$offset;
+			self::parse_whitespace( $input, $offset );
+			$selector = WP_CSS_Complex_Selector::parse( $input, $offset );
+			if ( null === $selector ) {
+				return null;
+			}
+			$selectors[] = $selector;
+			self::parse_whitespace( $input, $offset );
+		}
+
+		return new self( $selectors );
+	}
+}
diff --git a/src/wp-includes/html-api/css/class-wp-css-complex-selector.php b/src/wp-includes/html-api/css/class-wp-css-complex-selector.php
new file mode 100644
index 0000000000000..fd05c29daba91
--- /dev/null
+++ b/src/wp-includes/html-api/css/class-wp-css-complex-selector.php
@@ -0,0 +1,260 @@
+<?php
+/**
+ * HTML API: WP_CSS_Complex_Selector class
+ *
+ * @package WordPress
+ * @subpackage HTML-API
+ * @since {WP_VERSION}
+ */
+
+/**
+ * CSS complex selector.
+ *
+ * This class is used to test for matching HTML tags in a {@see WP_HTML_Processor}.
+ *
+ * A complex selector is at least a single compound selector. There may be additional selectors
+ * with combinators.
+ *
+ * @since {WP_VERSION}
+ *
+ * @access private
+ */
+final class WP_CSS_Complex_Selector extends WP_CSS_Selector_Parser_Matcher {
+	/**
+	 * Child combinator.
+	 */
+	const COMBINATOR_CHILD = '>';
+
+	/**
+	 * Descendant combinator.
+	 */
+	const COMBINATOR_DESCENDANT = ' ';
+
+	/**
+	 * Next sibling combinator.
+	 *
+	 * This combinator is not currently supported.
+	 */
+	const COMBINATOR_NEXT_SIBLING = '+';
+
+	/**
+	 * Subsequent sibling combinator.
+	 *
+	 * This combinator is not currently supported.
+	 */
+	const COMBINATOR_SUBSEQUENT_SIBLING = '~';
+
+	/**
+	 * The "self selector" is the last element in a complex selector, it corresponds to the
+	 * selected element.
+	 *
+	 * Example:
+	 *
+	 *                   $self_selector
+	 *                   ┏━━━━┻━━━━┓
+	 *     .heading h1 > el.selected
+	 *
+	 * @readonly
+	 * @var WP_CSS_Compound_Selector
+	 */
+	public $self_selector;
+
+	/**
+	 * The "context selectors" are zero or more elements that provide additional constraints for
+	 * the "self selector."
+	 *
+	 * These selectors are represented as 2-tuples where the element at index 0 is the selector and
+	 * the element at index 1 is the combinator string constant from this class,
+	 * e.g. `WP_CSS_Complex_Selector::COMBINATOR_CHILD`.
+	 *
+	 * In the example selector below, an element like `<strong class="selected">` matches iff:
+	 *   - it is a child of an `H1` element
+	 *   - that `H1` element is a descendant of a `SECTION` element.
+	 *
+	 * The `section` and `h1` parts of this selector and their combinators are the
+	 * "context selectors." Note that this terminology does not correspond to language in the
+	 * specification texts.
+	 *
+	 *     $context_selectors
+	 *     ┏━━━━━┻━━━━┓
+	 *     section h1 > strong.selected
+	 *
+	 * The example would have the following context selectors:
+	 *
+	 *     // Pseudo-code
+	 *     array(
+	 *       array( WP_CSS_Type_Selector( 'type'=>'h1' ), '>' ),
+	 *       array( WP_CSS_Type_Selector( 'type'=>'section' ), ' ' ),
+	 *     )
+	 *
+	 * Context selectors are ordered from right to left in the selector text. The selectors closest
+	 * to the target appear at the start of the `context_selectors` array.
+	 *
+	 * @readonly
+	 * @var array{WP_CSS_Type_Selector, string}[]|null
+	 */
+	public $context_selectors;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param WP_CSS_Compound_Selector $self_selector The selector in the final position.
+	 * @param array{WP_CSS_Type_Selector, string}[]|null $context_selectors The context selectors.
+	 */
+	private function __construct(
+		WP_CSS_Compound_Selector $self_selector,
+		?array $context_selectors
+	) {
+		$this->self_selector     = $self_selector;
+		$this->context_selectors = $context_selectors;
+	}
+
+	/**
+	 * Determines if the processor's current position matches the selector.
+	 *
+	 * @param WP_HTML_Processor $processor The processor.
+	 * @return bool True if the processor's current position matches the selector.
+	 */
+	public function matches( $processor ): bool {
+		// First selector must match this location.
+		if ( ! $this->self_selector->matches( $processor ) ) {
+			return false;
+		}
+
+		if ( null === $this->context_selectors || array() === $this->context_selectors ) {
+			return true;
+		}
+
+		$breadcrumbs = array_slice( array_reverse( $processor->get_breadcrumbs() ), 1 );
+		return $this->explore_matches( $this->context_selectors, $breadcrumbs );
+	}
+
+	/**
+	 * Checks for matches by recursively comparing context selectors with breadcrumbs.
+	 *
+	 * @param array{WP_CSS_Type_Selector, string}[] $selectors Selectors to match.
+	 * @param string[] $breadcrumbs Breadcrumbs.
+	 * @return bool True if a match is found, otherwise false.
+	 */
+	private function explore_matches( array $selectors, array $breadcrumbs ): bool {
+		if ( array() === $selectors ) {
+			return true;
+		}
+		if ( array() === $breadcrumbs ) {
+			return false;
+		}
+
+		$selector   = $selectors[0][0];
+		$combinator = $selectors[0][1];
+
+		switch ( $combinator ) {
+			case self::COMBINATOR_CHILD:
+				if ( $selector->matches_tag( $breadcrumbs[0] ) ) {
+					return $this->explore_matches( array_slice( $selectors, 1 ), array_slice( $breadcrumbs, 1 ) );
+				}
+				return false;
+
+			case self::COMBINATOR_DESCENDANT:
+				// Find _all_ the breadcrumbs that match and recurse from each of them.
+				for ( $i = 0; $i < count( $breadcrumbs ); $i++ ) {
+					if ( $selector->matches_tag( $breadcrumbs[ $i ] ) ) {
+						$next_breadcrumbs = array_slice( $breadcrumbs, $i + 1 );
+						if ( $this->explore_matches( array_slice( $selectors, 1 ), $next_breadcrumbs ) ) {
+							return true;
+						}
+					}
+				}
+				return false;
+
+			default:
+				_doing_it_wrong(
+					__METHOD__,
+					sprintf(
+						// translators: %s: A CSS selector combinator like ">" or "+".
+						__( 'Unsupported combinator "%s" found.' ),
+						$combinator
+					),
+					'{WP_VERSION}'
+				);
+				return false;
+		}
+	}
+
+	/**
+	 * Parses a selector string to create a selector instance.
+	 *
+	 * To create an instance of this class, use the {@see WP_CSS_Compound_Selector_List::from_selectors()} method.
+	 *
+	 * @param string $input The selector string.
+	 * @param int    $offset The offset into the string. The offset is passed by reference and
+	 *                       will be updated if the parse is successful.
+	 * @return static|null The selector instance, or null if the parse was unsuccessful.
+	 */
+	public static function parse( string $input, int &$offset ) {
+		if ( $offset >= strlen( $input ) ) {
+			return null;
+		}
+
+		$updated_offset = $offset;
+		$self_selector  = WP_CSS_Compound_Selector::parse( $input, $updated_offset );
+		if ( null === $self_selector ) {
+			return null;
+		}
+		/** @var array{WP_CSS_Compound_Selector, string}[] */
+		$selectors = array();
+
+		$found_whitespace = self::parse_whitespace( $input, $updated_offset );
+		while ( $updated_offset < strlen( $input ) ) {
+			$combinator    = null;
+			$next_selector = null;
+
+			// Sibling (`+` and `~`) combinators are not supported at this time.
+			if (
+				WP_CSS_Complex_Selector::COMBINATOR_NEXT_SIBLING === $input[ $updated_offset ] ||
+				WP_CSS_Complex_Selector::COMBINATOR_SUBSEQUENT_SIBLING === $input[ $updated_offset ]
+			) {
+				return null;
+			} elseif (
+				WP_CSS_Complex_Selector::COMBINATOR_CHILD === $input[ $updated_offset ]
+			) {
+				$combinator = $input[ $updated_offset ];
+				++$updated_offset;
+				self::parse_whitespace( $input, $updated_offset );
+
+				// A combinator has been found, failure to find a selector here is a parse error.
+				$next_selector = WP_CSS_Compound_Selector::parse( $input, $updated_offset );
+				if ( null === $next_selector ) {
+					return null;
+				}
+			} elseif ( $found_whitespace ) {
+				/*
+				* Whitespace is ambiguous, it could be a descendant combinator or
+				* insignificant whitespace.
+				*/
+				$next_selector = WP_CSS_Compound_Selector::parse( $input, $updated_offset );
+				if ( null !== $next_selector ) {
+					$combinator = WP_CSS_Complex_Selector::COMBINATOR_DESCENDANT;
+				}
+			}
+
+			if ( null === $next_selector ) {
+				break;
+			}
+
+			// $self_selector will pass to a relative selector where only the type selector is allowed.
+			if ( null !== $self_selector->subclass_selectors || null === $self_selector->type_selector ) {
+				return null;
+			}
+
+			/** @var array{WP_CSS_Type_Selector, string} */
+			$selector_pair = array( $self_selector->type_selector, $combinator );
+			$selectors[]   = $selector_pair;
+			$self_selector = $next_selector;
+
+			$found_whitespace = self::parse_whitespace( $input, $updated_offset );
+		}
+		$offset = $updated_offset;
+
+		return new self( $self_selector, array_reverse( $selectors ) );
+	}
+}
diff --git a/src/wp-includes/html-api/css/class-wp-css-compound-selector-list.php b/src/wp-includes/html-api/css/class-wp-css-compound-selector-list.php
new file mode 100644
index 0000000000000..c9eb936ff7371
--- /dev/null
+++ b/src/wp-includes/html-api/css/class-wp-css-compound-selector-list.php
@@ -0,0 +1,167 @@
+<?php
+/**
+ * HTML API: WP_CSS_Compound_Selector_List class
+ *
+ * @package WordPress
+ * @subpackage HTML-API
+ * @since {WP_VERSION}
+ */
+
+/**
+ * Core class used by the {@see WP_HTML_Tag_Processor} to parse and match CSS selectors.
+ *
+ * This class is designed for internal use by the HTML Tag Processor.
+ *
+ * For usage, see {@see WP_HTML_Tag_Processor::select()}.
+ *
+ * This class is instantiated via the {@see WP_CSS_Compound_Selector_List::from_selectors()} method.
+ * It takes a CSS selector string and returns an instance of itself or `null` if the selector
+ * is invalid or unsupported.
+ *
+ * A subset of the CSS selector grammar is supported. The grammar is defined in the CSS Syntax
+ * specification, which is available at {@link https://www.w3.org/TR/selectors/#grammar}.
+ *
+ * This class is analogous to <compound-selector-list> in the grammar. The supported grammar is:
+ *
+ *     <selector-list> = <complex-selector-list>
+ *     <complex-selector-list> = <complex-selector>#
+ *     <compound-selector-list> = <compound-selector>#
+ *     <complex-selector> = [ <type-selector> <combinator>? ]* <compound-selector>
+ *     <compound-selector> = [ <type-selector>? <subclass-selector>* ]!
+ *     <combinator> = '>' | [ '|' '|' ]
+ *     <type-selector> = <ident-token> | '*'
+ *     <subclass-selector> = <id-selector> | <class-selector> | <attribute-selector>
+ *     <id-selector> = <hash-token>
+ *     <class-selector> = '.' <ident-token>
+ *     <attribute-selector> = '[' <ident-token> ']' |
+ *                            '[' <ident-token> <attr-matcher> [ <string-token> | <ident-token> ] <attr-modifier>? ']'
+ *     <attr-matcher> = [ '~' | '|' | '^' | '$' | '*' ]? '='
+ *     <attr-modifier> = i | s
+ *
+ * @link https://www.w3.org/TR/selectors/#grammar Refer to the grammar for more details.
+ *
+ * This class of selectors does not support "complex" selectors. That is any selector with a
+ * combinator such as descendant (`.ancestor .descendant`) or child (`.parent > .child`).
+ * See {@see WP_CSS_Complex_Selector_List} for support of some combinators.
+ *
+ * Note that this grammar has been adapted and does not support the full CSS selector grammar.
+ * Supported selector syntax:
+ * - Type selectors (tag names, e.g. `div`)
+ * - Class selectors (e.g. `.class-name`)
+ * - ID selectors (e.g. `#unique-id`)
+ * - Attribute selectors (e.g. `[attribute-name]` or `[attribute-name="value"]`)
+ * - Comma-separated selector lists (e.g. `.selector-1, .selector-2`)
+ * - Compound selectors (e.g. `div.class-name#id[attr]`)
+ *
+ * Unsupported selector syntax:
+ * - Pseudo-element selectors (`::before`)
+ * - Pseudo-class selectors (`:hover` or `:nth-child(2)`)
+ * - Namespace prefixes (`svg|title` or `[xlink|href]`)
+ * - Combinators are not supported by this class (descendant, child, next sibling,
+ *   subsequent sibling). See {@see WP_CSS_Complex_Selector_List} for combinator support.
+ *
+ * Future ideas:
+ * - Namespace type selectors could be implemented with select namespaces in order to
+ *   select elements from a namespace, for example:
+ *   - `svg|*` to select all SVG elements
+ *   - `html|title` to select only HTML TITLE elements.
+ *
+ * @since {WP_VERSION}
+ *
+ * @access private
+ *
+ * @link https://www.w3.org/TR/css-syntax-3/
+ * @link https://www.w3.org/tr/selectors/
+ * @link https://www.w3.org/TR/selectors-api2/
+ * @link https://www.w3.org/TR/selectors-4/
+ */
+class WP_CSS_Compound_Selector_List extends WP_CSS_Selector_Parser_Matcher {
+	/**
+	 * Determines if the processor's current position matches the selector.
+	 *
+	 * @param WP_HTML_Tag_Processor $processor The processor.
+	 * @return bool True if the processor's current position matches the selector.
+	 */
+	public function matches( $processor ): bool {
+		if ( $processor->get_token_type() !== '#tag' ) {
+			return false;
+		}
+
+		foreach ( $this->selectors as $selector ) {
+			if ( $selector->matches( $processor ) ) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Array of selectors.
+	 *
+	 * @var array
+	 */
+	private $selectors;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param array $selectors Array of selectors.
+	 */
+	protected function __construct( array $selectors ) {
+		$this->selectors = $selectors;
+	}
+
+	/**
+	 * Takes a CSS selector string and returns an instance of itself or `null` if the selector
+	 * string is invalid or unsupported.
+	 *
+	 * @param string $input CSS selectors.
+	 * @return static|null
+	 */
+	public static function from_selectors( string $input ) {
+		$input = self::normalize_selector_input( $input );
+
+		if ( '' === $input ) {
+			return null;
+		}
+
+		$offset = 0;
+		return static::parse( $input, $offset );
+	}
+
+	/**
+	 * Parses a selector string to create a selector instance.
+	 *
+	 * To create an instance of this class, use the {@see WP_CSS_Compound_Selector_List::from_selectors()} method.
+	 *
+	 * @param string $input The selector string.
+	 * @param int    $offset The offset into the string. The offset is passed by reference and
+	 *                       will be updated if the parse is successful.
+	 * @return static|null The selector instance, or null if the parse was unsuccessful.
+	 */
+	public static function parse( string $input, int &$offset ) {
+		$selector = WP_CSS_Compound_Selector::parse( $input, $offset );
+		if ( null === $selector ) {
+			return null;
+		}
+		self::parse_whitespace( $input, $offset );
+
+		$selectors = array( $selector );
+		while ( $offset < strlen( $input ) ) {
+			// Each loop should stop on a `,` selector list delimiter.
+			if ( ',' !== $input[ $offset ] ) {
+				return null;
+			}
+			++$offset;
+			self::parse_whitespace( $input, $offset );
+			$selector = WP_CSS_Compound_Selector::parse( $input, $offset );
+			if ( null === $selector ) {
+				return null;
+			}
+			$selectors[] = $selector;
+			self::parse_whitespace( $input, $offset );
+		}
+
+		return new self( $selectors );
+	}
+}
diff --git a/src/wp-includes/html-api/css/class-wp-css-compound-selector.php b/src/wp-includes/html-api/css/class-wp-css-compound-selector.php
new file mode 100644
index 0000000000000..48e206819c0d3
--- /dev/null
+++ b/src/wp-includes/html-api/css/class-wp-css-compound-selector.php
@@ -0,0 +1,130 @@
+<?php
+/**
+ * HTML API: WP_CSS_Compound_Selector class
+ *
+ * @package WordPress
+ * @subpackage HTML-API
+ * @since {WP_VERSION}
+ */
+
+/**
+ * CSS compound selector.
+ *
+ * This class is used to test for matching HTML tags in a {@see WP_HTML_Tag_Processor}.
+ *
+ * A compound selector is a combination of:
+ *   - An optional type selector.
+ *   - Zero or more subclass selectors (ID, class, or attribute selectors).
+ *   - At least one of the above.
+ *
+ * @since {WP_VERSION}
+ *
+ * @access private
+ */
+final class WP_CSS_Compound_Selector extends WP_CSS_Selector_Parser_Matcher {
+	/**
+	 * The type selector.
+	 *
+	 * @var WP_CSS_Type_Selector|null
+	 */
+	public $type_selector;
+
+	/**
+	 * The subclass selectors.
+	 *
+	 * Subclass selectors are ID, class, or attribute selectors.
+	 *
+	 * @var (WP_CSS_ID_Selector|WP_CSS_Class_Selector|WP_CSS_Attribute_Selector)[]|null
+	 */
+	public $subclass_selectors;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param WP_CSS_Type_Selector|null $type_selector The type selector or null.
+	 * @param (WP_CSS_ID_Selector|WP_CSS_Class_Selector|WP_CSS_Attribute_Selector)[]|null $subclass_selectors
+	 *        The array of subclass selectors or null.
+	 */
+	private function __construct( ?WP_CSS_Type_Selector $type_selector, ?array $subclass_selectors ) {
+		$this->type_selector      = $type_selector;
+		$this->subclass_selectors = array() === $subclass_selectors ? null : $subclass_selectors;
+	}
+
+	/**
+	 * Determines if the processor's current position matches the selector.
+	 *
+	 * @param WP_HTML_Tag_Processor $processor The processor.
+	 * @return bool True if the processor's current position matches the selector.
+	 */
+	public function matches( WP_HTML_Tag_Processor $processor ): bool {
+		if ( $this->type_selector && ! $this->type_selector->matches( $processor ) ) {
+			return false;
+		}
+		if ( null !== $this->subclass_selectors ) {
+			foreach ( $this->subclass_selectors as $subclass_selector ) {
+				if ( ! $subclass_selector->matches( $processor ) ) {
+					return false;
+				}
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Parses a selector string to create a selector instance.
+	 *
+	 * To create an instance of this class, use the {@see WP_CSS_Compound_Selector_List::from_selectors()} method.
+	 *
+	 * @param string $input The selector string.
+	 * @param int    $offset The offset into the string. The offset is passed by reference and
+	 *                       will be updated if the parse is successful.
+	 * @return static|null The selector instance, or null if the parse was unsuccessful.
+	 */
+	public static function parse( string $input, int &$offset ) {
+		if ( $offset >= strlen( $input ) ) {
+			return null;
+		}
+
+		$updated_offset = $offset;
+		$type_selector  = WP_CSS_Type_Selector::parse( $input, $updated_offset );
+
+		$subclass_selectors            = array();
+		$last_parsed_subclass_selector = self::parse_subclass_selector( $input, $updated_offset );
+		while ( null !== $last_parsed_subclass_selector ) {
+			$subclass_selectors[]          = $last_parsed_subclass_selector;
+			$last_parsed_subclass_selector = self::parse_subclass_selector( $input, $updated_offset );
+		}
+
+		// There must be at least one selector.
+		if ( null === $type_selector && array() === $subclass_selectors ) {
+			return null;
+		}
+
+		$offset = $updated_offset;
+		return new self( $type_selector, $subclass_selectors );
+	}
+
+	/**
+	 * Parses a subclass selector.
+	 *
+	 * > <subclass-selector> = <id-selector> | <class-selector> | <attribute-selector>
+	 *
+	 * @return WP_CSS_ID_Selector|WP_CSS_Class_Selector|WP_CSS_Attribute_Selector|null
+	 */
+	private static function parse_subclass_selector( string $input, int &$offset ) {
+		if ( $offset >= strlen( $input ) ) {
+			return null;
+		}
+
+		switch ( $input[ $offset ] ) {
+			case '.':
+				return WP_CSS_Class_Selector::parse( $input, $offset );
+			case '#':
+				return WP_CSS_ID_Selector::parse( $input, $offset );
+			case '[':
+				return WP_CSS_Attribute_Selector::parse( $input, $offset );
+		}
+
+		return null;
+	}
+}
diff --git a/src/wp-includes/html-api/css/class-wp-css-id-selector.php b/src/wp-includes/html-api/css/class-wp-css-id-selector.php
new file mode 100644
index 0000000000000..e2e47a24d1e6c
--- /dev/null
+++ b/src/wp-includes/html-api/css/class-wp-css-id-selector.php
@@ -0,0 +1,72 @@
+<?php
+/**
+ * HTML API: WP_CSS_ID_Selector class
+ *
+ * @package WordPress
+ * @subpackage HTML-API
+ * @since {WP_VERSION}
+ */
+
+/**
+ * CSS ID selector.
+ *
+ * This class is used to test for matching HTML tags in a {@see WP_HTML_Tag_Processor}.
+ *
+ * @since {WP_VERSION}
+ *
+ * @access private
+ */
+final class WP_CSS_ID_Selector extends WP_CSS_Selector_Parser_Matcher {
+	/**
+	 * The ID to match.
+	 *
+	 * @var string
+	 */
+	public $id;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param string $id The ID to match.
+	 */
+	private function __construct( string $id ) {
+		$this->id = $id;
+	}
+
+	/**
+	 * Determines if the processor's current position matches the selector.
+	 *
+	 * @param WP_HTML_Tag_Processor $processor The processor.
+	 * @return bool True if the processor's current position matches the selector.
+	 */
+	public function matches( WP_HTML_Tag_Processor $processor ): bool {
+		$id = $processor->get_attribute( 'id' );
+		if ( ! is_string( $id ) ) {
+			return false;
+		}
+
+		$case_insensitive = $processor->is_quirks_mode();
+
+		return $case_insensitive
+			? 0 === strcasecmp( $id, $this->id )
+			: $id === $this->id;
+	}
+
+	/**
+	 * Parses a selector string to create a selector instance.
+	 *
+	 * To create an instance of this class, use the {@see WP_CSS_Compound_Selector_List::from_selectors()} method.
+	 *
+	 * @param string $input The selector string.
+	 * @param int    $offset The offset into the string. The offset is passed by reference and
+	 *                       will be updated if the parse is successful.
+	 * @return static|null The selector instance, or null if the parse was unsuccessful.
+	 */
+	public static function parse( string $input, int &$offset ) {
+		$ident = self::parse_hash_token( $input, $offset );
+		if ( null === $ident ) {
+			return null;
+		}
+		return new self( $ident );
+	}
+}
diff --git a/src/wp-includes/html-api/css/class-wp-css-selector-parser-matcher.php b/src/wp-includes/html-api/css/class-wp-css-selector-parser-matcher.php
new file mode 100644
index 0000000000000..cac314e8b6c27
--- /dev/null
+++ b/src/wp-includes/html-api/css/class-wp-css-selector-parser-matcher.php
@@ -0,0 +1,502 @@
+<?php
+/**
+ * HTML API: WP_CSS_Selector_Parser_Matcher class
+ *
+ * @package WordPress
+ * @subpackage HTML-API
+ * @since 6.8.0
+ */
+
+/**
+ * Base class for all CSS Selector parser/matcher classes.
+ *
+ * @since 6.8.0
+ *
+ * @access private
+ */
+abstract class WP_CSS_Selector_Parser_Matcher {
+	const UTF8_MAX_CODEPOINT_VALUE = 0x10FFFF;
+	const WHITESPACE_CHARACTERS    = " \t\r\n\f";
+
+	/**
+	 * Determines if the processor's current position matches the selector.
+	 *
+	 * @param WP_HTML_Tag_Processor $processor The processor.
+	 * @return bool True if the processor's current position matches the selector.
+	 */
+	abstract public function matches( WP_HTML_Tag_Processor $processor ): bool;
+
+	/**
+	 * Parses a selector string to create a selector instance.
+	 *
+	 * @param string $input The selector string.
+	 * @param int    $offset The offset into the string. The offset is passed by reference and
+	 *                       will be updated if the parse is successful.
+	 * @return static|null The selector instance, or null if the parse was unsuccessful.
+	 */
+	abstract public static function parse( string $input, int &$offset );
+
+	/*
+	 * ------------------------
+	 * Selector partial parsing
+	 * ------------------------
+	 *
+	 * These functions consume parts of a selector string input when successful
+	 * and return meaningful values to be used by selectors.
+	 */
+
+	/**
+	 * Consumes whitespace from the input string.
+	 *
+	 * @param string $input The selector string.
+	 * @param int    $offset The offset into the string. The offset is passed by reference and will
+	 *                       be updated to the byte after the whitespace sequence.
+	 * @return bool True if whitespace was consumed.
+	 */
+	final protected static function parse_whitespace( string $input, int &$offset ): bool {
+		$length   = strspn( $input, self::WHITESPACE_CHARACTERS, $offset );
+		$advanced = $length > 0;
+		$offset  += $length;
+		return $advanced;
+	}
+
+	/**
+	 * Tokenization of hash tokens
+	 *
+	 * > U+0023 NUMBER SIGN (#)
+	 * >   If the next input code point is an ident code point or the next two input code points are a valid escape, then:
+	 * >     1. Create a <hash-token>.
+	 * >     2. If the next 3 input code points would start an ident sequence, set the
+	 * >        <hash-token>’s type flag to "id".
+	 * >     3. Consume an ident sequence, and set the <hash-token>’s value to the
+	 * >        returned string.
+	 * >     4. Return the <hash-token>.
+	 * >   Otherwise, return a <delim-token> with its value set to the current input code point.
+	 *
+	 * This implementation is not interested in the <delim-token>, a '#' delim token is not relevant for selectors.
+	 */
+	final protected static function parse_hash_token( string $input, int &$offset ): ?string {
+		if ( $offset + 1 >= strlen( $input ) || '#' !== $input[ $offset ] ) {
+			return null;
+		}
+
+		$updated_offset = $offset + 1;
+		$result         = self::parse_ident( $input, $updated_offset );
+
+		if ( null === $result ) {
+			return null;
+		}
+
+		$offset = $updated_offset;
+		return $result;
+	}
+
+	/**
+	 * Parse a string token
+	 *
+	 * > 4.3.5. Consume a string token
+	 * > This section describes how to consume a string token from a stream of code points. It returns either a <string-token> or <bad-string-token>.
+	 * >
+	 * > This algorithm may be called with an ending code point, which denotes the code point that ends the string. If an ending code point is not specified, the current input code point is used.
+	 * >
+	 * > Initially create a <string-token> with its value set to the empty string.
+	 * >
+	 * > Repeatedly consume the next input code point from the stream:
+	 * >
+	 * > ending code point
+	 * >   Return the <string-token>.
+	 * > EOF
+	 * >   This is a parse error. Return the <string-token>.
+	 * > newline
+	 * >   This is a parse error. Reconsume the current input code point, create a <bad-string-token>, and return it.
+	 * > U+005C REVERSE SOLIDUS (\)
+	 * >   If the next input code point is EOF, do nothing.
+	 * >   Otherwise, if the next input code point is a newline, consume it.
+	 * >   Otherwise, (the stream starts with a valid escape) consume an escaped code point and append the returned code point to the <string-token>’s value.
+	 * >
+	 * > anything else
+	 * >   Append the current input code point to the <string-token>’s value.
+	 *
+	 * https://www.w3.org/TR/css-syntax-3/#consume-string-token
+	 *
+	 * This implementation will never return a <bad-string-token> because
+	 * the <bad-string-token> is not a part of the selector grammar. That
+	 * case is treated as failure to parse and null is returned.
+	 *
+	 * @return string|null The parsed string token value, or null if parsing failed.
+	 */
+	final protected static function parse_string( string $input, int &$offset ): ?string {
+		if ( $offset >= strlen( $input ) ) {
+			return null;
+		}
+
+		$ending_code_point = $input[ $offset ];
+		if ( '"' !== $ending_code_point && "'" !== $ending_code_point ) {
+			return null;
+		}
+
+		$string_token = '';
+
+		$updated_offset     = $offset + 1;
+		$anything_else_mask = "\\\n{$ending_code_point}";
+		while ( $updated_offset < strlen( $input ) ) {
+			$anything_else_length = strcspn( $input, $anything_else_mask, $updated_offset );
+			if ( $anything_else_length > 0 ) {
+				$string_token   .= substr( $input, $updated_offset, $anything_else_length );
+				$updated_offset += $anything_else_length;
+
+				if ( $updated_offset >= strlen( $input ) ) {
+					break;
+				}
+			}
+
+			switch ( $input[ $updated_offset ] ) {
+				case '\\':
+					++$updated_offset;
+					if ( $updated_offset >= strlen( $input ) ) {
+						break;
+					}
+					if ( "\n" === $input[ $updated_offset ] ) {
+						++$updated_offset;
+						break;
+					} else {
+						$string_token .= self::consume_escaped_codepoint( $input, $updated_offset );
+					}
+					break;
+
+				/*
+				 * This case would return a <bad-string-token>.
+				 * The <bad-string-token> is not a part of the selector grammar
+				 * so we do not return it and instead treat this as a
+				 * failure to parse a string token.
+				 */
+				case "\n":
+					return null;
+
+				case $ending_code_point:
+					++$updated_offset;
+					break 2;
+			}
+		}
+
+		$offset = $updated_offset;
+		return $string_token;
+	}
+
+	/**
+	 * Consume an escaped code point.
+	 *
+	 * > 4.3.7. Consume an escaped code point
+	 * > This section describes how to consume an escaped code point. It assumes that the U+005C
+	 * > REVERSE SOLIDUS (\) has already been consumed and that the next input code point has
+	 * > already been verified to be part of a valid escape. It will return a code point.
+	 * >
+	 * > Consume the next input code point.
+	 * >
+	 * > hex digit
+	 * >   Consume as many hex digits as possible, but no more than 5. Note that this means 1-6
+	 * >   hex digits have been consumed in total. If the next input code point is whitespace,
+	 * >   consume it as well. Interpret the hex digits as a hexadecimal number. If this number is
+	 * >   zero, or is for a surrogate, or is greater than the maximum allowed code point, return
+	 * >   U+FFFD REPLACEMENT CHARACTER (�). Otherwise, return the code point with that value.
+	 * > EOF
+	 * >   This is a parse error. Return U+FFFD REPLACEMENT CHARACTER (�).
+	 * > anything else
+	 * >   Return the current input code point.
+	 *
+	 * @param string $input
+	 * @param int $offset
+	 * @return string
+	 */
+	final protected static function consume_escaped_codepoint( $input, &$offset ): string {
+		$hex_length = strspn( $input, '0123456789abcdefABCDEF', $offset, 6 );
+		if ( $hex_length > 0 ) {
+			/**
+			 * The 6-character hex string has a maximum value of 0xFFFFFF.
+			 * It is likely to fit in an int value and not be a float.
+			 *
+			 * @var int
+			 */
+			$codepoint_value = hexdec( substr( $input, $offset, $hex_length ) );
+
+			/*
+			 * > A surrogate is a leading surrogate or a trailing surrogate.
+			 * > A leading surrogate is a code point that is in the range U+D800 to U+DBFF, inclusive.
+			 * > A trailing surrogate is a code point that is in the range U+DC00 to U+DFFF, inclusive.
+			 *
+			 * The surrogate ranges are adjacent, so the complete range is 0xD800 to 0xDFFF, inclusive.
+			 */
+			$codepoint_char = (
+				0 === $codepoint_value ||
+				$codepoint_value > self::UTF8_MAX_CODEPOINT_VALUE ||
+				( 0xD800 <= $codepoint_value && $codepoint_value <= 0xDFFF )
+			)
+				? "\u{FFFD}"
+				: mb_chr( $codepoint_value, 'UTF-8' );
+
+			$offset += $hex_length;
+
+			// If the next input code point is whitespace, consume it as well.
+			if (
+				strlen( $input ) > $offset &&
+				(
+					"\n" === $input[ $offset ] ||
+					"\t" === $input[ $offset ] ||
+					' ' === $input[ $offset ]
+				)
+			) {
+				++$offset;
+			}
+			return $codepoint_char;
+		}
+
+		$codepoint_char = mb_substr( $input, $offset, 1, 'UTF-8' );
+		$offset        += strlen( $codepoint_char );
+		return $codepoint_char;
+	}
+
+	/**
+	 * Parse an ident token
+	 *
+	 * CAUTION: This method is _not_ for parsing an ID selector!
+	 *
+	 * > 4.3.11. Consume an ident sequence
+	 * > This section describes how to consume an ident sequence from a stream of code points. It returns a string containing the largest name that can be formed from adjacent code points in the stream, starting from the first.
+	 * >
+	 * > Note: This algorithm does not do the verification of the first few code points that are necessary to ensure the returned code points would constitute an <ident-token>. If that is the intended use, ensure that the stream starts with an ident sequence before calling this algorithm.
+	 * >
+	 * > Let result initially be an empty string.
+	 * >
+	 * > Repeatedly consume the next input code point from the stream:
+	 * >
+	 * > ident code point
+	 * >   Append the code point to result.
+	 * > the stream starts with a valid escape
+	 * >   Consume an escaped code point. Append the returned code point to result.
+	 * > anything else
+	 * >   Reconsume the current input code point. Return result.
+	 *
+	 * https://www.w3.org/TR/css-syntax-3/#consume-name
+	 *
+	 * @return string|null The parsed identifier name, or null if parsing failed.
+	 */
+	final protected static function parse_ident( string $input, int &$offset ): ?string {
+		if ( ! self::check_if_three_code_points_would_start_an_ident_sequence( $input, $offset ) ) {
+			return null;
+		}
+
+		$ident = '';
+
+		while ( $offset < strlen( $input ) ) {
+			if ( self::next_two_are_valid_escape( $input, $offset ) ) {
+				// Move past the `\` character.
+				++$offset;
+				$ident .= self::consume_escaped_codepoint( $input, $offset );
+				continue;
+			} elseif ( self::is_ident_codepoint( $input, $offset ) ) {
+				$ident .= $input[ $offset ];
+				++$offset;
+				continue;
+			}
+			break;
+		}
+
+		return $ident;
+	}
+
+	/*
+	 * --------------------------
+	 * Selector parsing utilities
+	 * --------------------------
+	 *
+	 * The following functions are used for parsing but do not consume any input.
+	 */
+
+	/**
+	 * Checks for two valid escape codepoints.
+	 *
+	 * > 4.3.8. Check if two code points are a valid escape
+	 * > This section describes how to check if two code points are a valid escape. The algorithm
+	 * > described here can be called explicitly with two code points, or can be called with the
+	 * > input stream itself. In the latter case, the two code points in question are the current
+	 * > input code point and the next input code point, in that order.
+	 * >
+	 * > Note: This algorithm will not consume any additional code point.
+	 * >
+	 * > If the first code point is not U+005C REVERSE SOLIDUS (\), return false.
+	 * >
+	 * > Otherwise, if the second code point is a newline, return false.
+	 * >
+	 * > Otherwise, return true.
+	 *
+	 * https://www.w3.org/TR/css-syntax-3/#starts-with-a-valid-escape
+	 *
+	 * @todo The second codepoint is not checked for validity.
+	 *
+	 * @param string $input The input string.
+	 * @param int $offset The byte offset in the string.
+	 * @return bool True if the next two codepoints are a valid escape, otherwise false.
+	 */
+	final protected static function next_two_are_valid_escape( string $input, int $offset ): bool {
+		if ( $offset + 1 >= strlen( $input ) ) {
+			return false;
+		}
+		return '\\' === $input[ $offset ] && "\n" !== $input[ $offset + 1 ];
+	}
+
+	/**
+	 * Checks if the next code point is an "ident start code point."
+	 *
+	 * Caution! This method does not do any bounds checking, it should not be passed
+	 * a string with an offset that is out of bounds.
+	 *
+	 * > ident-start code point
+	 * >   A letter, a non-ASCII code point, or U+005F LOW LINE (_).
+	 * > uppercase letter
+	 * >   A code point between U+0041 LATIN CAPITAL LETTER A (A) and U+005A LATIN CAPITAL LETTER Z (Z) inclusive.
+	 * > lowercase letter
+	 * >   A code point between U+0061 LATIN SMALL LETTER A (a) and U+007A LATIN SMALL LETTER Z (z) inclusive.
+	 * > letter
+	 * >   An uppercase letter or a lowercase letter.
+	 * > non-ASCII code point
+	 * >   A code point with a value equal to or greater than U+0080 <control>.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#ident-start-code-point
+	 *
+	 * @param string $input The input string.
+	 * @param int $offset The byte offset in the string.
+	 * @return bool True if the next codepoint is an ident start code point, otherwise false.
+	 */
+	final protected static function is_ident_start_codepoint( string $input, int $offset ): bool {
+		return (
+			'_' === $input[ $offset ] ||
+			( 'a' <= $input[ $offset ] && $input[ $offset ] <= 'z' ) ||
+			( 'A' <= $input[ $offset ] && $input[ $offset ] <= 'Z' ) ||
+			ord( $input[ $offset ] ) > 0x7F
+		);
+	}
+
+	/**
+	 * Checks if the next code point is an "ident code point."
+	 *
+	 * Caution! This method does not do any bounds checking, it should not be passed
+	 * a string with an offset that is out of bounds.
+	 *
+	 * > ident code point
+	 * >   An ident-start code point, a digit, or U+002D HYPHEN-MINUS (-).
+	 * > digit
+	 * >   A code point between U+0030 DIGIT ZERO (0) and U+0039 DIGIT NINE (9) inclusive.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#ident-code-point
+	 *
+	 * @param string $input The input string.
+	 * @param int $offset The byte offset in the string.
+	 * @return bool True if the next codepoint is an ident code point, otherwise false.
+	 */
+	final protected static function is_ident_codepoint( string $input, int $offset ): bool {
+		return '-' === $input[ $offset ] ||
+			( '0' <= $input[ $offset ] && $input[ $offset ] <= '9' ) ||
+			self::is_ident_start_codepoint( $input, $offset );
+	}
+
+	/**
+	 * Checks if three code points would start an ident sequence.
+	 *
+	 * > 4.3.9. Check if three code points would start an ident sequence
+	 * > This section describes how to check if three code points would start an ident sequence. The algorithm described here can be called explicitly with three code points, or can be called with the input stream itself. In the latter case, the three code points in question are the current input code point and the next two input code points, in that order.
+	 * >
+	 * > Note: This algorithm will not consume any additional code points.
+	 * >
+	 * > Look at the first code point:
+	 * >
+	 * > U+002D HYPHEN-MINUS
+	 * >   If the second code point is an ident-start code point or a U+002D HYPHEN-MINUS, or the second and third code points are a valid escape, return true. Otherwise, return false.
+	 * > ident-start code point
+	 * >   Return true.
+	 * > U+005C REVERSE SOLIDUS (\)
+	 * >   If the first and second code points are a valid escape, return true. Otherwise, return false.
+	 * > anything else
+	 * >   Return false.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#would-start-an-identifier
+	 *
+	 * @param string $input The input string.
+	 * @param int $offset The byte offset in the string.
+	 * @return bool True if the next three codepoints would start an ident sequence, otherwise false.
+	 */
+	final protected static function check_if_three_code_points_would_start_an_ident_sequence( string $input, int $offset ): bool {
+		if ( $offset >= strlen( $input ) ) {
+			return false;
+		}
+
+		// > U+005C REVERSE SOLIDUS (\)
+		if ( '\\' === $input[ $offset ] ) {
+			return self::next_two_are_valid_escape( $input, $offset );
+		}
+
+		// > U+002D HYPHEN-MINUS
+		if ( '-' === $input[ $offset ] ) {
+			$after_initial_hyphen_minus_offset = $offset + 1;
+			if ( $after_initial_hyphen_minus_offset >= strlen( $input ) ) {
+				return false;
+			}
+
+			// > If the second code point is… U+002D HYPHEN-MINUS… return true
+			if ( '-' === $input[ $after_initial_hyphen_minus_offset ] ) {
+				return true;
+			}
+
+			// > If the second and third code points are a valid escape… return true.
+			if ( self::next_two_are_valid_escape( $input, $after_initial_hyphen_minus_offset ) ) {
+				return true;
+			}
+
+			// > If the second code point is an ident-start code point… return true.
+			if ( self::is_ident_start_codepoint( $input, $after_initial_hyphen_minus_offset ) ) {
+				return true;
+			}
+
+			// > Otherwise, return false.
+			return false;
+		}
+
+		// > ident-start code point
+		// >   Return true.
+		// > anything else
+		// >   Return false.
+		return self::is_ident_start_codepoint( $input, $offset );
+	}
+
+	/**
+	 * Normalizes selector input for processing.
+	 *
+	 * @see https://www.w3.org/TR/css-syntax-3/#input-preprocessing
+	 *
+	 * @param string $input The selector string.
+	 * @return string The normalized selector string.
+	 */
+	final protected static function normalize_selector_input( string $input ): string {
+		/*
+		 * > A selector string is a list of one or more complex selectors ([SELECTORS4], section 3.1) that may be surrounded by whitespace…
+		 *
+		 * This list includes \f.
+		 * A later step would normalize it to a known whitespace character, but it can be trimmed here as well.
+		 */
+		$input = trim( $input, " \t\r\n\f" );
+
+		/*
+		 * > The input stream consists of the filtered code points pushed into it as the input byte stream is decoded.
+		 * >
+		 * > To filter code points from a stream of (unfiltered) code points input:
+		 * > Replace any U+000D CARRIAGE RETURN (CR) code points, U+000C FORM FEED (FF) code points, or pairs of U+000D CARRIAGE RETURN (CR) followed by U+000A LINE FEED (LF) in input by a single U+000A LINE FEED (LF) code point.
+		 * > Replace any U+0000 NULL or surrogate code points in input with U+FFFD REPLACEMENT CHARACTER (�).
+		 *
+		 * https://www.w3.org/TR/css-syntax-3/#input-preprocessing
+		 */
+		$input = str_replace( array( "\r\n" ), "\n", $input );
+		$input = str_replace( array( "\r", "\f" ), "\n", $input );
+		$input = str_replace( "\0", "\u{FFFD}", $input );
+
+		return $input;
+	}
+}
diff --git a/src/wp-includes/html-api/css/class-wp-css-type-selector.php b/src/wp-includes/html-api/css/class-wp-css-type-selector.php
new file mode 100644
index 0000000000000..c7c7baa2d5508
--- /dev/null
+++ b/src/wp-includes/html-api/css/class-wp-css-type-selector.php
@@ -0,0 +1,90 @@
+<?php
+/**
+ * HTML API: WP_CSS_Type_Selector class
+ *
+ * @package WordPress
+ * @subpackage HTML-API
+ * @since {WP_VERSION}
+ */
+
+/**
+ * CSS type selector.
+ *
+ * This class is used to test for matching HTML tags in a {@see WP_HTML_Tag_Processor}.
+ *
+ * @since {WP_VERSION}
+ *
+ * @access private
+ */
+final class WP_CSS_Type_Selector extends WP_CSS_Selector_Parser_Matcher {
+	/**
+	 * The element type (tag name) to match or '*' to match any element.
+	 *
+	 * @var string
+	 */
+	public $type;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param string $type The element type (tag name) to match or '*' to match any element.
+	 */
+	private function __construct( string $type ) {
+		$this->type = $type;
+	}
+
+	/**
+	 * Determines if the processor's current position matches the selector.
+	 *
+	 * @param WP_HTML_Tag_Processor $processor The processor.
+	 * @return bool True if the processor's current position matches the selector.
+	 */
+	public function matches( WP_HTML_Tag_Processor $processor ): bool {
+		$tag_name = $processor->get_tag();
+		if ( null === $tag_name ) {
+			return false;
+		}
+		return $this->matches_tag( $tag_name );
+	}
+
+	/**
+	 * Checks whether the selector matches the provided tag name.
+	 *
+	 * @param string $tag_name
+	 * @return bool
+	 */
+	public function matches_tag( string $tag_name ): bool {
+		if ( '*' === $this->type ) {
+			return true;
+		}
+		return 0 === strcasecmp( $tag_name, $this->type );
+	}
+
+	/**
+	 * Parses a selector string to create a selector instance.
+	 *
+	 * To create an instance of this class, use the {@see WP_CSS_Compound_Selector_List::from_selectors()} method.
+	 *
+	 * @param string $input The selector string.
+	 * @param int    $offset The offset into the string. The offset is passed by reference and
+	 *                       will be updated if the parse is successful.
+	 * @return static|null The selector instance, or null if the parse was unsuccessful.
+	 */
+	public static function parse( string $input, int &$offset ) {
+		if ( $offset >= strlen( $input ) ) {
+			return null;
+		}
+
+		if ( '*' === $input[ $offset ] ) {
+			++$offset;
+			return new WP_CSS_Type_Selector( '*' );
+		}
+
+		$result = self::parse_ident( $input, $offset );
+		if ( null === $result ) {
+			return null;
+		}
+
+		return new self( $result );
+	}
+}
diff --git a/src/wp-settings.php b/src/wp-settings.php
index 60ffc307c5f6e..9337af05da3ae 100644
--- a/src/wp-settings.php
+++ b/src/wp-settings.php
@@ -266,6 +266,15 @@
 require ABSPATH . WPINC . '/html-api/class-wp-html-stack-event.php';
 require ABSPATH . WPINC . '/html-api/class-wp-html-processor-state.php';
 require ABSPATH . WPINC . '/html-api/class-wp-html-processor.php';
+require ABSPATH . WPINC . '/html-api/css/class-wp-css-selector-parser-matcher.php';
+require ABSPATH . WPINC . '/html-api/css/class-wp-css-attribute-selector.php';
+require ABSPATH . WPINC . '/html-api/css/class-wp-css-class-selector.php';
+require ABSPATH . WPINC . '/html-api/css/class-wp-css-id-selector.php';
+require ABSPATH . WPINC . '/html-api/css/class-wp-css-type-selector.php';
+require ABSPATH . WPINC . '/html-api/css/class-wp-css-compound-selector.php';
+require ABSPATH . WPINC . '/html-api/css/class-wp-css-complex-selector.php';
+require ABSPATH . WPINC . '/html-api/css/class-wp-css-compound-selector-list.php';
+require ABSPATH . WPINC . '/html-api/css/class-wp-css-complex-selector-list.php';
 require ABSPATH . WPINC . '/class-wp-http.php';
 require ABSPATH . WPINC . '/class-wp-http-streams.php';
 require ABSPATH . WPINC . '/class-wp-http-curl.php';
diff --git a/tests/phpunit/tests/html-api/wpCssAttributeSelector.php b/tests/phpunit/tests/html-api/wpCssAttributeSelector.php
new file mode 100644
index 0000000000000..e574cedd1876b
--- /dev/null
+++ b/tests/phpunit/tests/html-api/wpCssAttributeSelector.php
@@ -0,0 +1,90 @@
+<?php
+/**
+ * Unit tests covering WP_CSS_Attribute_Selector functionality.
+ *
+ * @package WordPress
+ *
+ * @subpackage HTML-API
+ *
+ * @since {WP_VERSION}
+ *
+ * @group html-api
+ *
+ * @coversDefaultClass WP_CSS_Attribute_Selector
+ */
+class Tests_HtmlApi_WpCssAttributeSelector extends WP_UnitTestCase {
+	/**
+	 * @ticket 62653
+	 *
+	 * @dataProvider data_attribute_selectors
+	 */
+	public function test_parse_attribute(
+		string $input,
+		?string $expected_name = null,
+		?string $expected_matcher = null,
+		?string $expected_value = null,
+		?string $expected_modifier = null,
+		?string $rest = null
+	) {
+		$offset = 0;
+		$result = WP_CSS_Attribute_Selector::parse( $input, $offset );
+		if ( null === $expected_name ) {
+			$this->assertNull( $result );
+		} else {
+			$this->assertSame( $expected_name, $result->name );
+			$this->assertSame( $expected_matcher, $result->matcher );
+			$this->assertSame( $expected_value, $result->value );
+			$this->assertSame( $expected_modifier, $result->modifier );
+			$this->assertSame( $rest, substr( $input, $offset ) );
+		}
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public static function data_attribute_selectors(): array {
+		return array(
+			'[href]'                   => array( '[href]', 'href', null, null, null, '' ),
+			'[href] type'              => array( '[href] type', 'href', null, null, null, ' type' ),
+			'[href]#id'                => array( '[href]#id', 'href', null, null, null, '#id' ),
+			'[href].class'             => array( '[href].class', 'href', null, null, null, '.class' ),
+			'[href][href2]'            => array( '[href][href2]', 'href', null, null, null, '[href2]' ),
+			'[\n href\t\r]'            => array( "[\n href\t\r]", 'href', null, null, null, '' ),
+			'[href=foo]'               => array( '[href=foo]', 'href', WP_CSS_Attribute_Selector::MATCH_EXACT, 'foo', null, '' ),
+			'[href \n =   bar   ]'     => array( "[href \n =   bar   ]", 'href', WP_CSS_Attribute_Selector::MATCH_EXACT, 'bar', null, '' ),
+			'[href \n ^=   baz   ]'    => array( "[href \n ^=   baz   ]", 'href', WP_CSS_Attribute_Selector::MATCH_PREFIXED_BY, 'baz', null, '' ),
+
+			'[match $= insensitive i]' => array( '[match $= insensitive i]', 'match', WP_CSS_Attribute_Selector::MATCH_SUFFIXED_BY, 'insensitive', WP_CSS_Attribute_Selector::MODIFIER_CASE_INSENSITIVE, '' ),
+			'[match|=sensitive s]'     => array( '[match|=sensitive s]', 'match', WP_CSS_Attribute_Selector::MATCH_EXACT_OR_HYPHEN_SUFFIXED, 'sensitive', WP_CSS_Attribute_Selector::MODIFIER_CASE_SENSITIVE, '' ),
+			'[att=val I]'              => array( '[att=val I]', 'att', WP_CSS_Attribute_Selector::MATCH_EXACT, 'val', WP_CSS_Attribute_Selector::MODIFIER_CASE_INSENSITIVE, '' ),
+			'[att=val S]'              => array( '[att=val S]', 'att', WP_CSS_Attribute_Selector::MATCH_EXACT, 'val', WP_CSS_Attribute_Selector::MODIFIER_CASE_SENSITIVE, '' ),
+
+			'[match~="quoted[][]"]'    => array( '[match~="quoted[][]"]', 'match', WP_CSS_Attribute_Selector::MATCH_ONE_OF_EXACT, 'quoted[][]', null, '' ),
+			"[match$='quoted!{}']"     => array( "[match$='quoted!{}']", 'match', WP_CSS_Attribute_Selector::MATCH_SUFFIXED_BY, 'quoted!{}', null, '' ),
+			"[match*='quoted's]"       => array( "[match*='quoted's]", 'match', WP_CSS_Attribute_Selector::MATCH_CONTAINS, 'quoted', WP_CSS_Attribute_Selector::MODIFIER_CASE_SENSITIVE, '' ),
+
+			'[escape-nl="foo\\nbar"]'  => array( "[escape-nl='foo\\\nbar']", 'escape-nl', WP_CSS_Attribute_Selector::MATCH_EXACT, 'foobar', null, '' ),
+			'[escape-seq="\\31 23"]'   => array( "[escape-seq='\\31 23']", 'escape-seq', WP_CSS_Attribute_Selector::MATCH_EXACT, '123', null, '' ),
+
+			// Invalid
+			'Invalid: (empty string)'  => array( '' ),
+			'Invalid: foo'             => array( 'foo' ),
+			'Invalid: [foo'            => array( '[foo' ),
+			'Invalid: [#foo]'          => array( '[#foo]' ),
+			'Invalid: [*|*]'           => array( '[*|*]' ),
+			'Invalid: [ns|*]'          => array( '[ns|*]' ),
+			'Invalid: [* |att]'        => array( '[* |att]' ),
+			'Invalid: [*| att]'        => array( '[*| att]' ),
+			'Invalid: [att * =]'       => array( '[att * =]' ),
+			'Invalid: [att+=val]'      => array( '[att+=val]' ),
+			'Invalid: [att=val '       => array( '[att=val ' ),
+			'Invalid: [att i]'         => array( '[att i]' ),
+			'Invalid: [att s]'         => array( '[att s]' ),
+			"Invalid: [att='val\\n']"  => array( "[att='val\n']" ),
+			'Invalid: [att=val i '     => array( '[att=val i ' ),
+			'Invalid: [att="val"ix'    => array( '[att="val"ix' ),
+		);
+	}
+}
diff --git a/tests/phpunit/tests/html-api/wpCssClassSelector.php b/tests/phpunit/tests/html-api/wpCssClassSelector.php
new file mode 100644
index 0000000000000..9646d05da23d5
--- /dev/null
+++ b/tests/phpunit/tests/html-api/wpCssClassSelector.php
@@ -0,0 +1,49 @@
+<?php
+/**
+ * Unit tests covering WP_CSS_Class_Selector functionality.
+ *
+ * @package WordPress
+ *
+ * @subpackage HTML-API
+ *
+ * @since {WP_VERSION}
+ *
+ * @group html-api
+ *
+ * @coversDefaultClass WP_CSS_Class_Selector
+ */
+class Tests_HtmlApi_WpCssClassSelector extends WP_UnitTestCase {
+	/**
+	 * @ticket 62653
+	 *
+	 * @dataProvider data_class_selectors
+	 */
+	public function test_parse_class( string $input, ?string $expected = null, ?string $rest = null ) {
+		$offset = 0;
+		$result = WP_CSS_Class_Selector::parse( $input, $offset );
+		if ( null === $expected ) {
+			$this->assertNull( $result );
+		} else {
+			$this->assertSame( $expected, $result->class_name );
+			$this->assertSame( $rest, substr( $input, $offset ) );
+		}
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public static function data_class_selectors(): array {
+		return array(
+			'valid ._-foo123'             => array( '._-foo123', '_-foo123', '' ),
+			'valid .foo.bar'              => array( '.foo.bar', 'foo', '.bar' ),
+			'escaped .\31 23'             => array( '.\\31 23', '123', '' ),
+			'with descendant .\31 23 div' => array( '.\\31 23 div', '123', ' div' ),
+
+			'not class foo'               => array( 'foo' ),
+			'not class #bar'              => array( '#bar' ),
+			'not valid .1foo'             => array( '.1foo' ),
+		);
+	}
+}
diff --git a/tests/phpunit/tests/html-api/wpCssComplexSelector.php b/tests/phpunit/tests/html-api/wpCssComplexSelector.php
new file mode 100644
index 0000000000000..8738bb6fc32d2
--- /dev/null
+++ b/tests/phpunit/tests/html-api/wpCssComplexSelector.php
@@ -0,0 +1,71 @@
+<?php
+/**
+ * Unit tests covering WP_CSS_Complex_Selector functionality.
+ *
+ * @package WordPress
+ *
+ * @subpackage HTML-API
+ *
+ * @since {WP_VERSION}
+ *
+ * @group html-api
+ *
+ * @coversDefaultClass WP_CSS_Complex_Selector
+ */
+class Tests_HtmlApi_WpCssComplexSelector extends WP_UnitTestCase {
+	/**
+	 * @ticket 62653
+	 */
+	public function test_parse_complex_selector() {
+		$input  = 'el1 el2 > .child#bar[baz=quux] , rest';
+		$offset = 0;
+
+		/** @var WP_CSS_Complex_Selector|null */
+		$sel = WP_CSS_Complex_Selector::parse( $input, $offset );
+
+		$this->assertSame( 2, count( $sel->context_selectors ) );
+
+		// Relative selectors should be reverse ordered.
+		$this->assertSame( 'el2', $sel->context_selectors[0][0]->type );
+		$this->assertSame( WP_CSS_Complex_Selector::COMBINATOR_CHILD, $sel->context_selectors[0][1] );
+
+		$this->assertSame( 'el1', $sel->context_selectors[1][0]->type );
+		$this->assertSame( WP_CSS_Complex_Selector::COMBINATOR_DESCENDANT, $sel->context_selectors[1][1] );
+
+		$this->assertSame( 3, count( $sel->self_selector->subclass_selectors ) );
+		$this->assertNull( $sel->self_selector->type_selector );
+		$this->assertSame( 'child', $sel->self_selector->subclass_selectors[0]->class_name );
+
+		$this->assertSame( ', rest', substr( $input, $offset ) );
+	}
+
+	/**
+	 * @ticket 62653
+	 */
+	public function test_parse_invalid_complex_selector() {
+		$input  = 'el.foo#bar[baz=quux] > , rest';
+		$offset = 0;
+		$result = WP_CSS_Complex_Selector::parse( $input, $offset );
+		$this->assertNull( $result );
+	}
+
+	/**
+	 * @ticket 62653
+	 */
+	public function test_parse_invalid_complex_selector_nonfinal_subclass() {
+		$input  = 'el.foo#bar[baz=quux] > final, rest';
+		$offset = 0;
+		$result = WP_CSS_Complex_Selector::parse( $input, $offset );
+		$this->assertNull( $result );
+	}
+
+	/**
+	 * @ticket 62653
+	 */
+	public function test_parse_empty_complex_selector() {
+		$input  = '';
+		$offset = 0;
+		$result = WP_CSS_Complex_Selector::parse( $input, $offset );
+		$this->assertNull( $result );
+	}
+}
diff --git a/tests/phpunit/tests/html-api/wpCssComplexSelectorList.php b/tests/phpunit/tests/html-api/wpCssComplexSelectorList.php
new file mode 100644
index 0000000000000..edf912e97f490
--- /dev/null
+++ b/tests/phpunit/tests/html-api/wpCssComplexSelectorList.php
@@ -0,0 +1,51 @@
+<?php
+/**
+ * Unit tests covering WP_CSS_Complex_Selector_List functionality.
+ *
+ * @package WordPress
+ *
+ * @subpackage HTML-API
+ *
+ * @since {WP_VERSION}
+ *
+ * @group html-api
+ *
+ * @coversDefaultClass WP_CSS_Complex_Selector_List
+ */
+class Tests_HtmlApi_WpCssComplexSelectorList extends WP_UnitTestCase {
+	/**
+	 * @ticket 62653
+	 */
+	public function test_parse_complex_selector_list() {
+		$input  = 'el1 el2 el.foo#bar[baz=quux], second > selector';
+		$result = WP_CSS_Complex_Selector_List::from_selectors( $input );
+		$this->assertNotNull( $result );
+	}
+
+	/**
+	 * @ticket 62653
+	 */
+	public function test_parse_invalid_selector_list() {
+		$input  = 'el,,';
+		$result = WP_CSS_Complex_Selector_List::from_selectors( $input );
+		$this->assertNull( $result );
+	}
+
+	/**
+	 * @ticket 62653
+	 */
+	public function test_parse_invalid_selector_list2() {
+		$input  = 'el!';
+		$result = WP_CSS_Complex_Selector_List::from_selectors( $input );
+		$this->assertNull( $result );
+	}
+
+	/**
+	 * @ticket 62653
+	 */
+	public function test_parse_empty_selector_list() {
+		$input  = " \t   \t\n\r\f";
+		$result = WP_CSS_Complex_Selector_List::from_selectors( $input );
+		$this->assertNull( $result );
+	}
+}
diff --git a/tests/phpunit/tests/html-api/wpCssCompoundSelector.php b/tests/phpunit/tests/html-api/wpCssCompoundSelector.php
new file mode 100644
index 0000000000000..8092ee049b6e1
--- /dev/null
+++ b/tests/phpunit/tests/html-api/wpCssCompoundSelector.php
@@ -0,0 +1,44 @@
+<?php
+/**
+ * Unit tests covering WP_CSS_Compound_Selector functionality.
+ *
+ * @package WordPress
+ *
+ * @subpackage HTML-API
+ *
+ * @since {WP_VERSION}
+ *
+ * @group html-api
+ *
+ * @coversDefaultClass WP_CSS_Compound_Selector
+ */
+class Tests_HtmlApi_WpCssCompoundSelector extends WP_UnitTestCase {
+	/**
+	 * @ticket 62653
+	 */
+	public function test_parse_selector() {
+		$input  = 'el.foo#bar[baz=quux] > .child';
+		$offset = 0;
+		$sel    = WP_CSS_Compound_Selector::parse( $input, $offset );
+
+		$this->assertSame( 'el', $sel->type_selector->type );
+		$this->assertSame( 3, count( $sel->subclass_selectors ) );
+		$this->assertSame( 'foo', $sel->subclass_selectors[0]->class_name, 'foo' );
+		$this->assertSame( 'bar', $sel->subclass_selectors[1]->id, 'bar' );
+		$this->assertSame( 'baz', $sel->subclass_selectors[2]->name, 'baz' );
+		$this->assertSame( WP_CSS_Attribute_Selector::MATCH_EXACT, $sel->subclass_selectors[2]->matcher );
+		$this->assertSame( 'quux', $sel->subclass_selectors[2]->value );
+		$this->assertSame( ' > .child', substr( $input, $offset ) );
+	}
+
+	/**
+	 * @ticket 62653
+	 */
+	public function test_parse_empty_selector() {
+		$input  = '';
+		$offset = 0;
+		$result = WP_CSS_Compound_Selector::parse( $input, $offset );
+		$this->assertNull( $result );
+		$this->assertSame( 0, $offset );
+	}
+}
diff --git a/tests/phpunit/tests/html-api/wpCssCompoundSelectorList.php b/tests/phpunit/tests/html-api/wpCssCompoundSelectorList.php
new file mode 100644
index 0000000000000..8f1d3dfb88a45
--- /dev/null
+++ b/tests/phpunit/tests/html-api/wpCssCompoundSelectorList.php
@@ -0,0 +1,60 @@
+<?php
+/**
+ * Unit tests covering WP_CSS_Compound_Selector_List functionality.
+ *
+ * @package WordPress
+ *
+ * @subpackage HTML-API
+ *
+ * @since {WP_VERSION}
+ *
+ * @group html-api
+ *
+ * @coversDefaultClass WP_CSS_Compound_Selector_List
+ */
+class Tests_HtmlApi_WpCssCompoundSelectorList extends WP_UnitTestCase {
+	/**
+	 * @ticket 62653
+	 */
+	public function test_parse_selector_list() {
+		$input  = 'el1, el2, el.foo#bar[baz=quux]';
+		$result = WP_CSS_Compound_Selector_List::from_selectors( $input );
+		$this->assertNotNull( $result );
+	}
+
+	/**
+	 * @ticket 62653
+	 */
+	public function test_parse_invalid_selector_list() {
+		$input  = 'el,,';
+		$result = WP_CSS_Compound_Selector_List::from_selectors( $input );
+		$this->assertNull( $result );
+	}
+
+	/**
+	 * @ticket 62653
+	 */
+	public function test_parse_invalid_selector_list2() {
+		$input  = 'el!';
+		$result = WP_CSS_Compound_Selector_List::from_selectors( $input );
+		$this->assertNull( $result );
+	}
+
+	/**
+	 * @ticket 62653
+	 */
+	public function test_parse_empty_selector_list() {
+		$input  = " \t   \t\n\r\f";
+		$result = WP_CSS_Compound_Selector_List::from_selectors( $input );
+		$this->assertNull( $result );
+	}
+
+	/**
+	 * @ticket 62653
+	 */
+	public function test_unsupported_complex_selector() {
+		$input  = 'ancestor descendant';
+		$result = WP_CSS_Compound_Selector_List::from_selectors( $input );
+		$this->assertNull( $result );
+	}
+}
diff --git a/tests/phpunit/tests/html-api/wpCssIdSelector.php b/tests/phpunit/tests/html-api/wpCssIdSelector.php
new file mode 100644
index 0000000000000..6dc2e5461ea03
--- /dev/null
+++ b/tests/phpunit/tests/html-api/wpCssIdSelector.php
@@ -0,0 +1,50 @@
+<?php
+/**
+ * Unit tests covering WP_CSS_ID_Selector functionality.
+ *
+ * @package WordPress
+ *
+ * @subpackage HTML-API
+ *
+ * @since {WP_VERSION}
+ *
+ * @group html-api
+ *
+ * @coversDefaultClass WP_CSS_ID_Selector
+ */
+class Tests_HtmlApi_WpCssIdSelector extends WP_UnitTestCase {
+	/**
+	 * @ticket 62653
+	 *
+	 * @dataProvider data_id_selectors
+	 */
+	public function test_parse_id( string $input, ?string $expected = null, ?string $rest = null ) {
+		$offset = 0;
+		$result = WP_CSS_ID_Selector::parse( $input, $offset );
+		if ( null === $expected ) {
+			$this->assertNull( $result );
+		} else {
+			$this->assertSame( $expected, $result->id );
+			$this->assertSame( $rest, substr( $input, $offset ) );
+		}
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public static function data_id_selectors(): array {
+		return array(
+			'valid #_-foo123'             => array( '#_-foo123', '_-foo123', '' ),
+			'valid #foo#bar'              => array( '#foo#bar', 'foo', '#bar' ),
+			'escaped #\31 23'             => array( '#\\31 23', '123', '' ),
+			'with descendant #\31 23 div' => array( '#\\31 23 div', '123', ' div' ),
+
+			// Invalid
+			'not ID foo'                  => array( 'foo' ),
+			'not ID .bar'                 => array( '.bar' ),
+			'not valid #1foo'             => array( '#1foo' ),
+		);
+	}
+}
diff --git a/tests/phpunit/tests/html-api/wpCssSelectorParserMatcher.php b/tests/phpunit/tests/html-api/wpCssSelectorParserMatcher.php
new file mode 100644
index 0000000000000..29372172da2b1
--- /dev/null
+++ b/tests/phpunit/tests/html-api/wpCssSelectorParserMatcher.php
@@ -0,0 +1,179 @@
+<?php
+/**
+ * Unit tests covering WP_CSS_Selector_Parser_Matcher functionality.
+ *
+ * @package WordPress
+ *
+ * @subpackage HTML-API
+ *
+ * @since {WP_VERSION}
+ *
+ * @group html-api
+ */
+class Tests_HtmlApi_WpCssSelectorParserMatcher extends WP_UnitTestCase {
+	private $test_class;
+
+	public function set_up(): void {
+		parent::set_up();
+		$this->test_class = new class() extends WP_CSS_Selector_Parser_Matcher {
+			public function matches( $processor ): bool {
+				throw new Error( 'Matches called on test class.' );
+			}
+			public static function parse( string $input, int &$offset ) {
+				throw new Error( 'Parse called on test class.' );
+			}
+
+			/*
+			 * Parsing
+			 */
+			public static function test_parse_ident( string $input, int &$offset ) {
+				return self::parse_ident( $input, $offset );
+			}
+
+			public static function test_parse_string( string $input, int &$offset ) {
+				return self::parse_string( $input, $offset );
+			}
+
+			/*
+			 * Utilities
+			 */
+			public static function test_is_ident_codepoint( string $input, int $offset ) {
+				return self::is_ident_codepoint( $input, $offset );
+			}
+
+			public static function test_is_ident_start_codepoint( string $input, int $offset ) {
+				return self::is_ident_start_codepoint( $input, $offset );
+			}
+		};
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public static function data_idents(): array {
+		return array(
+			'trailing #'                         => array( '_-foo123#xyz', '_-foo123', '#xyz' ),
+			'trailing .'                         => array( '😍foo123.xyz', '😍foo123', '.xyz' ),
+			'trailing " "'                       => array( '😍foo123 more', '😍foo123', ' more' ),
+			'escaped ASCII character'            => array( '\\xyz', 'xyz', '' ),
+			'escaped space'                      => array( '\\ x', ' x', '' ),
+			'escaped emoji'                      => array( '\\😍', '😍', '' ),
+			'hex unicode codepoint'              => array( '\\1f0a1', '🂡', '' ),
+			'HEX UNICODE CODEPOINT'              => array( '\\1D4B2', '𝒲', '' ),
+
+			'hex tab-suffixed 1'                 => array( "\\31\t23", '123', '' ),
+			'hex newline-suffixed 1'             => array( "\\31\n23", '123', '' ),
+			'hex space-suffixed 1'               => array( "\\31 23", '123', '' ),
+			'hex tab'                            => array( '\\9', "\t", '' ),
+			'hex a'                              => array( '\\61 bc', 'abc', '' ),
+			'hex a max escape length'            => array( '\\000061bc', 'abc', '' ),
+
+			'out of range replacement min'       => array( '\\110000 ', "\u{fffd}", '' ),
+			'out of range replacement max'       => array( '\\ffffff ', "\u{fffd}", '' ),
+			'leading surrogate min replacement'  => array( '\\d800 ', "\u{fffd}", '' ),
+			'leading surrogate max replacement'  => array( '\\dbff ', "\u{fffd}", '' ),
+			'trailing surrogate min replacement' => array( '\\dc00 ', "\u{fffd}", '' ),
+			'trailing surrogate max replacement' => array( '\\dfff ', "\u{fffd}", '' ),
+			'can start with -ident'              => array( '-ident', '-ident', '' ),
+			'can start with --anything'          => array( '--anything', '--anything', '' ),
+			'can start with ---anything'         => array( '--_anything', '--_anything', '' ),
+			'can start with --1anything'         => array( '--1anything', '--1anything', '' ),
+			'can start with -\31 23'             => array( '-\31 23', '-123', '' ),
+			'can start with --\31 23'            => array( '--\31 23', '--123', '' ),
+			'ident ends before ]'                => array( 'ident]', 'ident', ']' ),
+
+			// Invalid
+			'Invalid: (empty string)'            => array( '' ),
+			'Invalid: bad start >'               => array( '>ident' ),
+			'Invalid: bad start ['               => array( '[ident' ),
+			'Invalid: bad start #'               => array( '#ident' ),
+			'Invalid: bad start " "'             => array( ' ident' ),
+			'Invalid: bad start 1'               => array( '1ident' ),
+			'Invalid: bad start -1'              => array( '-1ident' ),
+			'Invalid: bad start -'               => array( '-' ),
+		);
+	}
+
+	/**
+	 * @ticket 62653
+	 */
+	public function test_is_ident_and_is_ident_start() {
+		$this->assertFalse( $this->test_class::test_is_ident_codepoint( '[', 0 ) );
+		$this->assertFalse( $this->test_class::test_is_ident_codepoint( ']', 0 ) );
+		$this->assertFalse( $this->test_class::test_is_ident_start_codepoint( '[', 0 ) );
+		$this->assertFalse( $this->test_class::test_is_ident_start_codepoint( ']', 0 ) );
+	}
+
+	/**
+	 * @ticket 62653
+	 *
+	 * @dataProvider data_idents
+	 */
+	public function test_parse_ident( string $input, ?string $expected = null, ?string $rest = null ) {
+
+		$offset = 0;
+		$result = $this->test_class::test_parse_ident( $input, $offset );
+		if ( null === $expected ) {
+			$this->assertNull( $result );
+		} else {
+			$this->assertSame( $expected, $result, 'Ident did not match.' );
+			$this->assertSame( $rest, substr( $input, $offset ), 'Offset was not updated correctly.' );
+		}
+	}
+
+	/**
+	 * @ticket 62653
+	 *
+	 * @dataProvider data_strings
+	 */
+	public function test_parse_string( string $input, ?string $expected = null, ?string $rest = null ) {
+		$offset = 0;
+		$result = $this->test_class::test_parse_string( $input, $offset );
+		if ( null === $expected ) {
+			$this->assertNull( $result );
+		} else {
+			$this->assertSame( $expected, $result, 'String did not match.' );
+			$this->assertSame( $rest, substr( $input, $offset ), 'Offset was not updated correctly.' );
+		}
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public static function data_strings(): array {
+		return array(
+			'"foo"'                   => array( '"foo"', 'foo', '' ),
+			'"foo"after'              => array( '"foo"after', 'foo', 'after' ),
+			'"foo""two"'              => array( '"foo""two"', 'foo', '"two"' ),
+			'"foo"\'two\''            => array( '"foo"\'two\'', 'foo', "'two'" ),
+
+			"'foo'"                   => array( "'foo'", 'foo', '' ),
+			"'foo'after"              => array( "'foo'after", 'foo', 'after' ),
+			"'foo'\"two\""            => array( "'foo'\"two\"", 'foo', '"two"' ),
+			"'foo''two'"              => array( "'foo''two'", 'foo', "'two'" ),
+
+			"'foo\\nbar'"             => array( "'foo\\\nbar'", 'foobar', '' ),
+			"'foo\\31 23'"            => array( "'foo\\31 23'", 'foo123', '' ),
+			"'foo\\31\\n23'"          => array( "'foo\\31\n23'", 'foo123', '' ),
+			"'foo\\31\\t23'"          => array( "'foo\\31\t23'", 'foo123', '' ),
+			"'foo\\00003123'"         => array( "'foo\\00003123'", 'foo123', '' ),
+
+			"'foo\\"                  => array( "'foo\\", 'foo', '' ),
+
+			'"'                       => array( '"', '', '' ),
+			'"\\"'                    => array( '"\\"', '"', '' ),
+			'"missing close'          => array( '"missing close', 'missing close', '' ),
+
+			// Invalid
+			'Invalid: (empty string)' => array( '' ),
+			'Invalid: .foo'           => array( '.foo' ),
+			'Invalid: #foo'           => array( '#foo' ),
+			"Invalid: 'newline\\n'"   => array( "'newline\n'" ),
+			'Invalid: foo'            => array( 'foo' ),
+		);
+	}
+}
diff --git a/tests/phpunit/tests/html-api/wpCssTypeSelector.php b/tests/phpunit/tests/html-api/wpCssTypeSelector.php
new file mode 100644
index 0000000000000..23d5f5517453a
--- /dev/null
+++ b/tests/phpunit/tests/html-api/wpCssTypeSelector.php
@@ -0,0 +1,51 @@
+<?php
+/**
+ * Unit tests covering WP_CSS_Type_Selector functionality.
+ *
+ * @package WordPress
+ *
+ * @subpackage HTML-API
+ *
+ * @since {WP_VERSION}
+ *
+ * @group html-api
+ *
+ * @coversDefaultClass WP_CSS_Type_Selector
+ */
+class Tests_HtmlApi_WpCssTypeSelector extends WP_UnitTestCase {
+	/**
+	 * @ticket 62653
+	 *
+	 * @dataProvider data_type_selectors
+	 */
+	public function test_parse_type( string $input, ?string $expected = null, ?string $rest = null ) {
+		$offset = 0;
+		$result = WP_CSS_Type_Selector::parse( $input, $offset );
+		if ( null === $expected ) {
+			$this->assertNull( $result );
+		} else {
+			$this->assertSame( $expected, $result->type );
+			$this->assertSame( $rest, substr( $input, $offset ) );
+		}
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public static function data_type_selectors(): array {
+		return array(
+			'any *'                   => array( '* .class', '*', ' .class' ),
+			'a'                       => array( 'a', 'a', '' ),
+			'div.class'               => array( 'div.class', 'div', '.class' ),
+			'custom-type#id'          => array( 'custom-type#id', 'custom-type', '#id' ),
+
+			// Invalid
+			'Invalid: (empty string)' => array( '' ),
+			'Invalid: #id'            => array( '#id' ),
+			'Invalid: .class'         => array( '.class' ),
+			'Invalid: [attr]'         => array( '[attr]' ),
+		);
+	}
+}
diff --git a/tests/phpunit/tests/html-api/wpHtmlProcessor-select.php b/tests/phpunit/tests/html-api/wpHtmlProcessor-select.php
new file mode 100644
index 0000000000000..003e65e69ebce
--- /dev/null
+++ b/tests/phpunit/tests/html-api/wpHtmlProcessor-select.php
@@ -0,0 +1,89 @@
+<?php
+/**
+ * Unit tests covering WP_HTML_Processor select functionality.
+ *
+ * Covers functionality related to CSS selectors and the {@see WP_HTML_Processor::select()}
+ * and {@see WP_HTML_Processor::select()} methods.
+ *
+ * @since {WP_VERSION}
+ *
+ * @group html-api
+ */
+class Tests_HtmlApi_WpHtmlProcessor_Select extends WP_UnitTestCase {
+	/**
+	 * @ticket 62653
+	 */
+	public function test_select_miss() {
+		$processor = WP_HTML_Processor::create_full_parser( '<span>' );
+		$this->assertFalse( $processor->select( 'div' ) );
+	}
+
+	/**
+	 * @ticket 62653
+	 *
+	 * @dataProvider data_selectors
+	 */
+	public function test_selects_all_matches( string $html, string $selector, int $match_count ) {
+		$processor = WP_HTML_Processor::create_full_parser( $html );
+		$count     = 0;
+		while ( $processor->select( $selector ) ) {
+			$breadcrumb_string = implode( ', ', $processor->get_breadcrumbs() );
+			$this->assertTrue(
+				$processor->get_attribute( 'match' ),
+				"Matched unexpected tag {$processor->get_tag()} @ {$breadcrumb_string}"
+			);
+			++$count;
+		}
+		$this->assertSame( $match_count, $count, 'Did not match expected number of tags.' );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public static function data_selectors(): array {
+		return array(
+			'any'                            => array( '<html match><head match><meta match><body match><p match>', '*', 5 ),
+			'quirks mode ID'                 => array( '<p id="id" match><p id="ID" match>In quirks mode, ID matching is case-insensitive.', '#id', 2 ),
+			'quirks mode class'              => array( '<p class="c" match><p class="C" match>In quirks mode, class matching is case-insensitive.', '.c', 2 ),
+			'no-quirks mode ID'              => array( '<!DOCTYPE html><p id="id" match><p id="ID" match>In no-quirks mode, ID matching is case-sensitive.', '#id', 1 ),
+			'no-quirks mode class'           => array( '<!DOCTYPE html><p class="c" match><p class="C">In no-quirks mode, class matching is case-sensitive.', '.c', 1 ),
+			'any descendant'                 => array( '<section><p match><i match><em match><p match>', 'section *', 4 ),
+			'any child matches all children' => array( '<section><p match><i><em><p match>', 'section > *', 2 ),
+
+			'multiple complex selectors'     => array( '<section><div><p><span><i></i><p><i match>', 'section > div p > i', 1 ),
+		);
+	}
+
+	/**
+	 * @ticket 62653
+	 *
+	 * @expectedIncorrectUsage WP_HTML_Processor::select
+	 *
+	 * @dataProvider data_invalid_selectors
+	 */
+	public function test_invalid_selector( string $selector ) {
+		$processor = WP_HTML_Processor::create_fragment( 'irrelevant' );
+		$this->assertFalse( $processor->select( $selector ) );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public static function data_invalid_selectors(): array {
+		return array(
+			'invalid selector'                        => array( '[invalid!selector]' ),
+
+			// The class selectors below are not allowed in non-final position.
+			'unsupported child selector'              => array( '.parent > .child' ),
+			'unsupported descendant selector'         => array( '.ancestor .descendant' ),
+
+			// Unsupported combinators
+			'unsupported next sibling selector'       => array( 'p + p' ),
+			'unsupported subsequent sibling selector' => array( 'p ~ p' ),
+		);
+	}
+}
diff --git a/tests/phpunit/tests/html-api/wpHtmlTagProcessor-select.php b/tests/phpunit/tests/html-api/wpHtmlTagProcessor-select.php
new file mode 100644
index 0000000000000..1d09c61b4760d
--- /dev/null
+++ b/tests/phpunit/tests/html-api/wpHtmlTagProcessor-select.php
@@ -0,0 +1,107 @@
+<?php
+/**
+ * Unit tests covering WP_HTML_Tag_Processor CSS selection functionality.
+ *
+ * Covers functionality related to CSS selectors and the {@see WP_HTML_Tag_Processor::select()} method.
+ *
+ * @since {WP_VERSION}
+ *
+ * @group html-api
+ */
+class Tests_HtmlApi_WpHtmlTagProcessor_Select extends WP_UnitTestCase {
+	/**
+	 * @ticket 62653
+	 */
+	public function test_select_miss() {
+		$processor = new WP_HTML_Tag_Processor( '<span>' );
+		$this->assertFalse( $processor->select( 'div' ) );
+	}
+
+	/**
+	 * @ticket 62653
+	 *
+	 * @dataProvider data_selectors
+	 */
+	public function test_select( string $html, string $selector, int $match_count ) {
+		$processor = new WP_HTML_Tag_Processor( $html );
+		$count     = 0;
+		while ( $processor->select( $selector ) ) {
+			$this->assertTrue(
+				$processor->get_attribute( 'match' ),
+				"Matched unexpected tag {$processor->get_tag()}"
+			);
+			++$count;
+		}
+		$this->assertSame( $match_count, $count, 'Did not match expected number of tags.' );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public static function data_selectors(): array {
+		return array(
+			'simple type'                         => array( '<div match><div match><span>', 'div', 2 ),
+			'any type'                            => array( '<div match><span match>', '*', 2 ),
+			'simple class'                        => array( '<div><div class="x" match><span><span class="x" match>', '.x', 2 ),
+			'simple id'                           => array( '<div><div id="x" match><span id="x" match>', '#x', 2 ),
+
+			'attribute presence'                  => array( '<div tta><div att match><span att="foo" match>', '[att]', 2 ),
+			'attribute empty string match'        => array( '<div tta><div att match><span match att=>', '[att=""]', 2 ),
+			'attribute value'                     => array( '<div att="v"><div att="val" match><p match att=val>', '[att=val]', 2 ),
+			'attribute quoted value'              => array( '<div att><div att="::" match><p att=\'::\' match>', '[att="::"]', 2 ),
+			'attribute case insensitive'          => array( '<div att="value"><div att="val" match><p match att=VaL>', '[att="VAL"i]', 2 ),
+			'attribute case sensitive mod'        => array( '<div att="VAL"><div att="val" match><p att=val match>', '[att="val"s]', 2 ),
+
+			'attribute one of'                    => array( '<div att="a B c"><div att="a b c" match><p att="b" match><p att="abc"><p att="abcdef b   " match>', '[att~="b"]', 3 ),
+			'attribute one of insensitive'        => array( '<div att="a c"><div att="a B c" match>', '[att~="b"i]', 1 ),
+			'attribute one of mod sensitive'      => array( '<div att="a B c"><div att="a b c" match>', '[att~="b"s]', 1 ),
+			'attribute one of whitespace cases'   => array( "<div att='     a'><div att='\na\ta   b   ' match>", '[att~="b"]', 1 ),
+
+			'attribute with-hyphen'               => array( '<p att="special_not"><p att="special" match><p att="special-great" match>', '[att|="special"]', 2 ),
+			'attribute with-hyphen insensitive'   => array( '<p att="special_not"><p att="SPECIAL" match><p att="SPECIAL-great" match>', '[att|="special" i]', 2 ),
+			'attribute with-hyphen sensitive mod' => array( '<p att="SPECIAL"><p att="special" match>', '[att|="special"s]', 1 ),
+
+			'attribute prefixed'                  => array( '<p att="notprefix"><p att="prefix" match><p att="perfect" match>', '[att^="p"]', 2 ),
+			'attribute prefixed insensitive'      => array( '<p att="notprefix"><p att="Prefix" match>', '[att^="p"i]', 1 ),
+			'attribute prefixed sensitive mod'    => array( '<p att="Prefix"><p att="prefix" match>', '[att^="p"s]', 1 ),
+
+			'attribute suffixed'                  => array( '<p att="suffix_"><p att="suffix" match><p att="brilliant…x" match>', '[att$="x"]', 2 ),
+			'attribute suffixed insensitive'      => array( '<p att="suffix_"><p att="suffiX" match>', '[att$="x"i]', 1 ),
+			'attribute suffixed sensitive mod'    => array( '<p att="suffiX"><p att="suffix" match>', '[att$="x"s]', 1 ),
+
+			'attribute contains'                  => array( '<p att="abcyz"><p att="abcxyz" match><p att="x" match>', '[att*="x"]', 2 ),
+			'attribute contains insensitive'      => array( '<p att="abcyz"><p att="abcXyz" match>', '[att*="x"i]', 1 ),
+			'attribute contains sensitive mod'    => array( '<p att="abcXyz"><p att="abcxyz" match>', '[att*="x"s]', 1 ),
+
+			'list'                                => array( '<div><p match><a match><span>', 'a, p, .class, #id, [att]', 2 ),
+			'compound'                            => array( '<div att><custom-el att="bar" fruit="APPLE BANANA" match>', 'custom-el[att="bar"][    fruit ~= "banana" i]', 1 ),
+		);
+	}
+
+	/**
+	 * @ticket 62653
+	 *
+	 * @expectedIncorrectUsage WP_HTML_Tag_Processor::select
+	 *
+	 * @dataProvider data_invalid_selectors
+	 */
+	public function test_invalid_selector( string $selector ) {
+		$processor = new WP_HTML_Tag_Processor( 'irrelevant' );
+		$this->assertFalse( $processor->select( $selector ) );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array
+	 */
+	public static function data_invalid_selectors(): array {
+		return array(
+			'complex descendant' => array( 'div *' ),
+			'complex child'      => array( 'div > *' ),
+			'invalid selector'   => array( '[invalid!selector]' ),
+		);
+	}
+}