diff --git a/src/wp-includes/css-api/class-wp-css-builder.php b/src/wp-includes/css-api/class-wp-css-builder.php
new file mode 100644
index 0000000000000..d778780c91462
--- /dev/null
+++ b/src/wp-includes/css-api/class-wp-css-builder.php
@@ -0,0 +1,110 @@
+<?php
+/**
+ * CSS API: WP_CSS_Builder class
+ *
+ * @package WordPress
+ * @subpackage CSS-API
+ * @since 7.3.0
+ */
+
+/**
+ * Writes PHP values as CSS text.
+ *
+ * Each method returns CSS text that reads back as the given value: a string
+ * token, a `url()` function holding a string token, or an identifier. Combine
+ * the results with literal CSS to write a value with parts that come from
+ * input.
+ *
+ * Example:
+ *
+ * ```php interactive
+ * $image_url = 'https://example.com/a (1) "b".jpg';
+ * echo 'background-image: ' . WP_CSS_Builder::url( $image_url );
+ * // Outputs: background-image: url("https://example.com/a (1) \22 b\22 .jpg")
+ * ```
+ *
+ * The characters escaped beyond those CSS requires may change; the value
+ * the text reads back as does not.
+ *
+ * @since 7.3.0
+ *
+ * @see WP_CSS_Token_Serializer
+ */
+class WP_CSS_Builder {
+	/**
+	 * Writes a value as a quoted CSS string.
+	 *
+	 * Quotes, `\` and control characters are hex-escaped, as are `< > & , ;
+	 * { }`, which may be problematic in HTML or for rudimentary CSS
+	 * processors. CSS cannot represent NULL, so it reads back as U+FFFD.
+	 * Invalid UTF-8 reads back as U+FFFD.
+	 *
+	 * Example:
+	 *
+	 * ```php interactive
+	 * echo 'content: ' . WP_CSS_Builder::string( 'Say "hi"' );
+	 * // Outputs: content: "Say \22 hi\22 "
+	 * ```
+	 *
+	 * @since 7.3.0
+	 *
+	 * @param string $value Value the string should read back as.
+	 * @return string Quoted CSS string.
+	 */
+	public static function string( string $value ): string {
+		return WP_CSS_Token_Serializer::escape_string( $value );
+	}
+
+	/**
+	 * Writes a URL as a CSS `url()` function holding a quoted string.
+	 *
+	 * The URL is written as string() writes it. It is not validated or
+	 * sanitized; pass it through esc_url() or sanitize_url() first when it
+	 * comes from input.
+	 *
+	 * Example:
+	 *
+	 * ```php interactive
+	 * echo WP_CSS_Builder::url( 'https://example.com/a(1).png' );
+	 * // Outputs: url("https://example.com/a(1).png")
+	 * ```
+	 *
+	 * @since 7.3.0
+	 *
+	 * @link https://www.w3.org/TR/css-values-4/#urls
+	 *
+	 * @param string $url URL the function should read back as.
+	 * @return string CSS `url()` function.
+	 */
+	public static function url( string $url ): string {
+		return 'url(' . self::string( $url ) . ')';
+	}
+
+	/**
+	 * Writes a value as a CSS identifier.
+	 *
+	 * Code points that cannot appear in an identifier at their position are
+	 * hex-escaped, as are the characters string() escapes. Use it for a
+	 * property name, a custom property name in `var()`, or a keyword or
+	 * family name written without quotes.
+	 *
+	 * An empty value returns an empty string, which is not an identifier.
+	 *
+	 * Example:
+	 *
+	 * ```php interactive
+	 * echo 'font-family: ' . WP_CSS_Builder::ident( '1st Font' );
+	 * // Outputs: font-family: \31 st\20 Font
+	 * ```
+	 *
+	 * @since 7.3.0
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
+	 *
+	 * @param string $value Value the identifier should read back as.
+	 * @return string CSS identifier, or an empty string for an empty value.
+	 */
+	public static function ident( string $value ): string {
+		return WP_CSS_Token_Serializer::escape_ident( $value );
+	}
+}
diff --git a/src/wp-includes/css-api/class-wp-css-token-processor.php b/src/wp-includes/css-api/class-wp-css-token-processor.php
new file mode 100644
index 0000000000000..e9b0e27e4bd7e
--- /dev/null
+++ b/src/wp-includes/css-api/class-wp-css-token-processor.php
@@ -0,0 +1,1791 @@
+<?php
+/**
+ * CSS API: WP_CSS_Token_Processor class
+ *
+ * @package WordPress
+ * @subpackage CSS-API
+ * @since 7.3.0
+ */
+
+/**
+ * Tokenizes CSS according to the CSS Syntax Level 3 specification.
+ *
+ * This class follows the algorithm in https://www.w3.org/TR/css-syntax-3/ and
+ * exposes a pull-based API so callers can stream over large stylesheets without
+ * allocating every token up front. Each call to next_token() advances the cursor
+ * and fills in metadata (type, value, raw slice, byte offsets) that the getter
+ * methods read.
+ *
+ * ## Design choices
+ *
+ * ### On-the-fly normalization
+ *
+ * The CSS Spec requires the following normalization step:
+ *
+ * > 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 (�).
+ *
+ * This processor delays normalization as much as possible. That keeps the raw byte
+ * positions intact for accurate rewrites; WP_CSS_Token::get_value() normalizes and
+ * decodes a token's value when it is asked for.
+ * For example, `url(a<NUL>b)` is a URL token whose value is `a�b`, where `<NUL>`
+ * means one zero byte in the source. That byte stays in the raw token, so later
+ * edits still use byte offsets from the original input.
+ *
+ * ### No EOF token
+ *
+ * The EOF token is a CSS parsing concept, not CSS tokenization concept. Therefore,
+ * this processor does not produce it.
+ *
+ * ### UTF-8 handling
+ *
+ * Only UTF-8 strings are supported. Invalid sequences are replaced with U+FFFD (�)
+ * by the maximal subpart rule of the Unicode Standard, section 3.9.6, U+FFFD
+ * Substitution of Maximal Subparts.
+ *
+ * ## Usage
+ *
+ * Basic iteration:
+ *
+ * ```php interactive
+ * $processor = new WP_CSS_Token_Processor( 'width: 10px;' );
+ * while ( $processor->next_token() ) {
+ *     echo $processor->get_token_type() . "\n";
+ * }
+ * // Outputs:
+ * // ident-token
+ * // colon-token
+ * // whitespace-token
+ * // dimension-token
+ * // semicolon-token
+ * ```
+ *
+ * Gathering diagnostics with byte offsets:
+ *
+ * ```php interactive
+ * $css       = "color: red;\ncolor: \"re\nd\";";
+ * $processor = new WP_CSS_Token_Processor( $css );
+ * while ( $processor->next_token() ) {
+ *     if ( WP_CSS_Token_Processor::TOKEN_BAD_STRING === $processor->get_token_type() ) {
+ *         echo "Bad string at byte {$processor->get_token_start()}, {$processor->get_token_length()} bytes long.\n";
+ *     }
+ * }
+ * // Outputs: "Bad string at byte 19, 3 bytes long."
+ * ```
+ *
+ * @since 7.3.0
+ *
+ * @link https://www.w3.org/TR/css-syntax-3/#tokenization
+ * @link https://www.unicode.org/versions/Unicode18.0.0/core-spec/chapter-3/#G66453
+ */
+class WP_CSS_Token_Processor {
+	/**
+	 * Token type constants matching the CSS Syntax Level 3 specification.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#tokenization
+	 */
+	public const TOKEN_WHITESPACE = 'whitespace-token';
+
+	/**
+	 * Comment tokens, which open with `/` `*` and close with `*` `/`.
+	 *
+	 * The specification's tokenizer produces no comment tokens. This processor
+	 * does, so callers can find comments by their byte offsets. CSS Syntax
+	 * Level 3 §9 allows this:
+	 *
+	 * > Implementations may preserve the contents of comments and their location in the token stream.
+	 * > If they do, this preserved information must have no effect on the parsing step.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#serialization
+	 */
+	public const TOKEN_COMMENT = 'comment';
+
+	/**
+	 * String tokens, such as `"hello"` and `'world'`.
+	 *
+	 * @see WP_CSS_Token_Processor::TOKEN_BAD_STRING
+	 * @link https://www.w3.org/TR/css-syntax-3/#typedef-string-token
+	 */
+	public const TOKEN_STRING = 'string-token';
+
+	/**
+	 * BAD-STRING tokens occur when a string contains an unescaped newline.
+	 *
+	 * These are valid strings; the last contains an escaped newline:
+	 *
+	 *     "hello" 'world' "line1\Aline2"
+	 *
+	 * This string produces a bad-string token, because a literal newline ends it:
+	 *
+	 *     "hello
+	 *     world"
+	 *
+	 * The processor stops at the newline and produces a bad-string token for error recovery.
+	 *
+	 * @see WP_CSS_Token_Processor::TOKEN_STRING
+	 * @link https://www.w3.org/TR/css-syntax-3/#typedef-bad-string-token
+	 */
+	public const TOKEN_BAD_STRING = 'bad-string-token';
+
+	/**
+	 * Hash tokens, such as `#fff` and `#header`.
+	 *
+	 * A hash token has an "id" or "unrestricted" type flag.
+	 *
+	 * @see WP_CSS_Token_Processor::HASH_TOKEN_ID
+	 * @see WP_CSS_Token_Processor::HASH_TOKEN_UNRESTRICTED
+	 * @link https://www.w3.org/TR/css-syntax-3/#typedef-hash-token
+	 */
+	public const TOKEN_HASH = 'hash-token';
+
+	/**
+	 * Type flag of a hash token whose name would start an identifier, such as `#header`.
+	 *
+	 * @see WP_CSS_Token_Processor::TOKEN_HASH
+	 */
+	public const HASH_TOKEN_ID = 'id';
+
+	/**
+	 * Type flag of a hash token whose name would not start an identifier, such as `#123`.
+	 *
+	 * @see WP_CSS_Token_Processor::TOKEN_HASH
+	 */
+	public const HASH_TOKEN_UNRESTRICTED = 'unrestricted';
+
+	public const TOKEN_DELIM         = 'delim-token';
+	public const TOKEN_NUMBER        = 'number-token';
+	public const TOKEN_PERCENTAGE    = 'percentage-token';
+	public const TOKEN_DIMENSION     = 'dimension-token';
+	public const TOKEN_AT_KEYWORD    = 'at-keyword-token';
+	public const TOKEN_COLON         = 'colon-token';
+	public const TOKEN_SEMICOLON     = 'semicolon-token';
+	public const TOKEN_COMMA         = 'comma-token';
+	public const TOKEN_LEFT_PAREN    = '(-token';
+	public const TOKEN_RIGHT_PAREN   = ')-token';
+	public const TOKEN_LEFT_BRACKET  = '[-token';
+	public const TOKEN_RIGHT_BRACKET = ']-token';
+	public const TOKEN_LEFT_BRACE    = '{-token';
+	public const TOKEN_RIGHT_BRACE   = '}-token';
+	public const TOKEN_FUNCTION      = 'function-token';
+
+	/**
+	 * URL tokens represent unquoted URLs in url() notation.
+	 *
+	 * For example, `url(image.jpg)` is a URL token.
+	 *
+	 * Quoted URLs like `url( "https://example.com" )` are handled as a function
+	 * token, _not_ a URL token.
+	 *
+	 * Bad URL tokens are created when invalid characters are encountered in
+	 * a URL token.
+	 *
+	 * @see WP_CSS_Token_Processor::TOKEN_BAD_URL
+	 * @see WP_CSS_Token_Processor::TOKEN_FUNCTION
+	 * @link https://www.w3.org/TR/css-syntax-3/#typedef-url-token
+	 */
+	public const TOKEN_URL = 'url-token';
+
+	/**
+	 * BAD-URL tokens occur when a URL contains invalid characters.
+	 *
+	 * Invalid characters include quotes (`"`), apostrophes (`'`) and opening
+	 * parentheses (`(`), as in `url(image(.jpg)` or `url(image".jpg)`.
+	 *
+	 * When detected, the processor consumes everything up to `)` or EOF.
+	 * This prevents the bad URL from breaking subsequent tokens.
+	 *
+	 * @see WP_CSS_Token_Processor::TOKEN_URL
+	 * @link https://www.w3.org/TR/css-syntax-3/#typedef-bad-url-token
+	 */
+	public const TOKEN_BAD_URL = 'bad-url-token';
+
+	/**
+	 * Identifier tokens, such as `color`, `margin-top`, `red`,
+	 * `inherit`, `--my-var`, `\x-escaped`, `über` (Unicode), etc.
+	 *
+	 * There are restrictions on the codepoints that start or are contained in
+	 * an identifier, and identifiers may contain escape sequences.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#typedef-ident-token
+	 */
+	public const TOKEN_IDENT = 'ident-token';
+
+	/**
+	 * CDC (Comment Delimiter Close) token: `-->`
+	 *
+	 * Legacy token from when CSS was embedded in HTML `<style>` tags
+	 * and needed to be hidden from old browsers using HTML comments:
+	 *
+	 *     <style>
+	 *     <!--
+	 *     body { color: red; }
+	 *     -->
+	 *     </style>
+	 *
+	 * Modern CSS no longer needs these, but they're preserved for compatibility.
+	 * In stylesheets, they're typically treated like whitespace.
+	 *
+	 * @see WP_CSS_Token_Processor::TOKEN_CDO
+	 * @link https://www.w3.org/TR/css-syntax-3/#typedef-cdc-token
+	 */
+	public const TOKEN_CDC = 'CDC-token';
+
+	/**
+	 * CDO (Comment Delimiter Open) token: `<!--`
+	 *
+	 * Legacy token from when CSS was embedded in HTML `<style>` tags.
+	 * TOKEN_CDC describes the HTML comment compatibility.
+	 *
+	 * @see WP_CSS_Token_Processor::TOKEN_CDC
+	 * @link https://www.w3.org/TR/css-syntax-3/#typedef-cdo-token
+	 */
+	public const TOKEN_CDO = 'CDO-token';
+
+	/**
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var string
+	 */
+	private $css;
+
+	/**
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var int
+	 */
+	private $length = 0;
+
+	/**
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var int
+	 */
+	private $at = 0;
+
+	/**
+	 * The type of the current token. One of the self::TOKEN_* constants.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var string|null
+	 * @phpstan-var self::TOKEN_*|null
+	 */
+	private $token_type = null;
+
+	/**
+	 * The type flag for the current token, if any.
+	 *
+	 * Hash tokens carry an "id" or "unrestricted" flag. Per CSS Syntax Level 3,
+	 * `<number-token>` and `<dimension-token>` have a type flag indicating whether
+	 * the number was written as an integer or a number (with decimal point or
+	 * exponent). `<percentage-token>` does not have a type flag.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#consume-number
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var string|null
+	 * @phpstan-var 'id'|'unrestricted'|'integer'|'number'|null
+	 */
+	private $token_type_flag = null;
+
+	/**
+	 * The byte offset at which the current token starts.
+	 *
+	 * Example:
+	 *
+	 *     background: url( a.png );
+	 *                 ↑
+	 *     The url token starts at byte 12.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var int|null
+	 */
+	private $token_starts_at = null;
+
+	/**
+	 * The byte length of the current token.
+	 *
+	 * Example:
+	 *
+	 *     background: url( a.png );
+	 *                 ╰────┬─────╯
+	 *     The url token is 12 bytes long.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var int|null
+	 */
+	private $token_length = null;
+
+	/**
+	 * The byte offset at which the value of the current token starts.
+	 *
+	 * It is used for string, url and comment tokens. The value of a string
+	 * token excludes its quotes; the value of a url token excludes `url(`, `)`
+	 * and the whitespace inside them; the value of a comment excludes its
+	 * delimiters. For example:
+	 *
+	 *     background: url( a.png );
+	 *                      ↑
+	 *     The url value starts at byte 17.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var int|null
+	 */
+	private $token_value_starts_at = null;
+
+	/**
+	 * The byte length of the value of the current token.
+	 *
+	 * It is used for string, url and comment tokens. For example:
+	 *
+	 *     background: url( a.png );
+	 *                      ╰─┬─╯
+	 *     The url value is 5 bytes long.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var int|null
+	 */
+	private $token_value_length = null;
+
+	/**
+	 * The current token, created on the first call to get_token().
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var WP_CSS_Token|null
+	 */
+	private $token = null;
+
+	/**
+	 * The unit of the current token, e.g. "px", "em", "deg", etc.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var string|null
+	 */
+	private $token_unit = null;
+
+	/**
+	 * Whether the current token ended at its closing delimiter.
+	 *
+	 * Comment, string, url and bad-url tokens end at `*` `/`, the matching
+	 * quote or `)`. When the input ends first, the token is complete but this
+	 * flag is false. Every other token type is always terminated.
+	 *
+	 *     color: "red
+	 *            ╰─┬╯
+	 *     The string token is not terminated: the input ends before the closing quote.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var bool
+	 */
+	private $token_is_terminated = true;
+
+	/**
+	 * Constructor.
+	 *
+	 * The CSS is read as UTF-8. Convert CSS in another encoding to UTF-8 first.
+	 *
+	 * @since 7.3.0
+	 *
+	 * @param string $css CSS source to tokenize.
+	 */
+	public function __construct( string $css ) {
+		$this->css    = $css;
+		$this->length = strlen( $css );
+	}
+
+	/**
+	 * Moves to the next token in the CSS stream.
+	 *
+	 * Implements the main tokenization loop, consuming the next token from the input stream.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#consume-token
+	 *
+	 * @since 7.3.0
+	 *
+	 * @return bool Whether a token was found.
+	 *
+	 * @phpstan-impure
+	 */
+	public function next_token(): bool {
+		$this->after_token();
+
+		// Stop at the end of the input.
+		if ( $this->at >= $this->length ) {
+			return false;
+		}
+
+		/*
+		 * CSS comments. The specification does not produce comment tokens; this
+		 * processor does.
+		 *
+		 * @link https://www.w3.org/TR/css-syntax-3/#consume-comment
+		 */
+		if (
+			$this->at + 1 < $this->length &&
+			'/' === $this->css[ $this->at ] &&
+			'*' === $this->css[ $this->at + 1 ]
+		) {
+			$this->token_type            = self::TOKEN_COMMENT;
+			$this->token_starts_at       = $this->at;
+			$this->token_value_starts_at = $this->at + 2;
+
+			$end = strpos( $this->css, '*/', $this->at + 2 );
+			if ( false === $end ) {
+				// The comment runs to the end of the input.
+				$this->token_is_terminated = false;
+				$this->at                  = $this->length;
+				$value_ends_at             = $this->length;
+			} else {
+				$this->at      = $end + 2;
+				$value_ends_at = $end;
+			}
+			$this->token_length       = $this->at - $this->token_starts_at;
+			$this->token_value_length = $value_ends_at - $this->token_value_starts_at;
+			return true;
+		}
+
+		/*
+		 * Whitespace tokens.
+		 *
+		 * The spec defines U+000A LINE FEED, U+0009 CHARACTER TABULATION, and U+0020 SPACE as whitespace.
+		 * In addition, U+000D CARRIAGE RETURN and U+000C FORM FEED are handled here, which the preprocessing
+		 * phase would convert to U+000A LINE FEED.
+		 *
+		 * @link https://www.w3.org/TR/css-syntax-3/#newline
+		 * @link https://www.w3.org/TR/css-syntax-3/#whitespace
+		 */
+		$whitespace_length = strspn( $this->css, "\t\n\f\r ", $this->at );
+		if ( $whitespace_length > 0 ) {
+			$this->token_type      = self::TOKEN_WHITESPACE;
+			$this->token_length    = $whitespace_length;
+			$this->token_starts_at = $this->at;
+			$this->at             += $whitespace_length;
+			return true;
+		}
+
+		/*
+		 * String tokens with either " or ' as delimiters.
+		 *
+		 * @link https://www.w3.org/TR/css-syntax-3/#consume-string-token
+		 */
+		if ( '"' === $this->css[ $this->at ] || "'" === $this->css[ $this->at ] ) {
+			return $this->consume_string();
+		}
+
+		$char                  = $this->css[ $this->at ];
+		$this->token_starts_at = $this->at;
+
+		/*
+		 * U+0023 NUMBER SIGN (#)
+		 *
+		 * A hash token is created when # is followed by an ident code point or valid escape.
+		 * This is commonly used for hex colors (#fff) or ID selectors (#header).
+		 *
+		 * @link https://www.w3.org/TR/css-syntax-3/#consume-token
+		 */
+		if ( '#' === $char ) {
+			if ( $this->at + 1 < $this->length ) {
+				if (
+					$this->consume_ident_codepoint( $this->at + 1 ) > 0 ||
+					// The next two input code points are a valid escape.
+					self::is_valid_escape( $this->css, $this->at + 1 )
+				) {
+					// Create a <hash-token>.
+					++$this->at;
+
+					// > If the next 3 input code points would start an ident sequence,
+					// > set the <hash-token>'s type flag to "id".
+					$this->token_type_flag = $this->check_if_3_code_points_start_an_ident_sequence( $this->at )
+						? self::HASH_TOKEN_ID
+						: self::HASH_TOKEN_UNRESTRICTED;
+
+					// Consume an ident sequence, and set the <hash-token>'s value to the returned string.
+					$this->consume_ident_sequence();
+					$this->token_type   = self::TOKEN_HASH;
+					$this->token_length = $this->at - $this->token_starts_at;
+					return true;
+				}
+			}
+			// Otherwise, return a <delim-token> with its value set to the current input code point.
+			++$this->at;
+			$this->token_type   = self::TOKEN_DELIM;
+			$this->token_length = 1;
+			return true;
+		}
+
+		/*
+		 * Simple single-byte tokens
+		 *
+		 * These characters form their own tokens when encountered.
+		 * Note: ( tokens here are not function tokens - those are handled
+		 * in consume_ident_like() when ( follows an identifier.
+		 *
+		 * @link https://www.w3.org/TR/css-syntax-3/#tokenization
+		 */
+		$simple = array(
+			'(' => self::TOKEN_LEFT_PAREN,
+			')' => self::TOKEN_RIGHT_PAREN,
+			',' => self::TOKEN_COMMA,
+			':' => self::TOKEN_COLON,
+			';' => self::TOKEN_SEMICOLON,
+			'[' => self::TOKEN_LEFT_BRACKET,
+			']' => self::TOKEN_RIGHT_BRACKET,
+			'{' => self::TOKEN_LEFT_BRACE,
+			'}' => self::TOKEN_RIGHT_BRACE,
+		);
+		if ( isset( $simple[ $char ] ) ) {
+			++$this->at;
+			$this->token_type   = $simple[ $char ];
+			$this->token_length = 1;
+			return true;
+		}
+
+		/*
+		 * U+0040 COMMERCIAL AT (@)
+		 *
+		 * An at-keyword is @ followed by an identifier, used for at-rules like
+		 * @media, @import, @keyframes, etc.
+		 *
+		 * @link https://www.w3.org/TR/css-syntax-3/#consume-token
+		 */
+		if ( '@' === $char ) {
+			++$this->at;
+			// If the next 3 input code points after the @ would start an ident sequence,
+			// consume an ident sequence, create an <at-keyword-token> with its value set to the returned value,
+			// and return it.
+			if ( $this->check_if_3_code_points_start_an_ident_sequence( $this->at ) ) {
+				$this->consume_ident_sequence();
+				$this->token_type   = self::TOKEN_AT_KEYWORD;
+				$this->token_length = $this->at - $this->token_starts_at;
+				return true;
+			} else {
+				// Otherwise, return a <delim-token> with its value set to the current input code point.
+				$this->token_type   = self::TOKEN_DELIM;
+				$this->token_length = 1;
+				return true;
+			}
+		}
+
+		/*
+		 * Numbers start with digits, the plus sign, minus sign, and decimal point.
+		 *
+		 * @link https://www.w3.org/TR/css-syntax-3/#starts-with-a-number
+		 */
+		if ( $this->would_next_3_code_points_start_a_number() ) {
+			return $this->consume_numeric();
+		}
+
+		/*
+		 * U+002D HYPHEN-MINUS (-)
+		 */
+		if ( '-' === $char ) {
+			// This case is covered above:
+			// > If the input stream starts with a number.
+
+			/*
+			 * If followed by another hyphen and `>`, this is a CDC token (`-->`).
+			 *
+			 * Comment Delimiter Close - legacy HTML comment syntax in CSS.
+			 *
+			 * @link https://www.w3.org/TR/css-syntax-3/#CDC-token-diagram
+			 */
+			if (
+				$this->at + 2 < $this->length &&
+				'-' === $this->css[ $this->at + 1 ] &&
+				'>' === $this->css[ $this->at + 2 ]
+			) {
+				// Consume them and return a <CDC-token>.
+				$this->at          += 3;
+				$this->token_type   = self::TOKEN_CDC;
+				$this->token_length = 3;
+				return true;
+			}
+
+			// Otherwise, if the input stream starts with an ident sequence,
+			// reconsume the current input code point, consume an ident-like
+			// token, and return it.
+			if ( $this->check_if_3_code_points_start_an_ident_sequence( $this->at ) ) {
+				return $this->consume_ident_like();
+			}
+
+			// Otherwise, return a <delim-token> with its value set to the current input code point.
+			++$this->at;
+			$this->token_type   = self::TOKEN_DELIM;
+			$this->token_length = 1;
+			return true;
+		}
+
+		/*
+		 * U+003C LESS-THAN SIGN (<)
+		 * If followed by `!--`, this is a CDO token (`<!--`).
+		 *
+		 * Comment Delimiter Open - legacy HTML comment syntax in CSS.
+		 *
+		 * @link https://www.w3.org/TR/css-syntax-3/#CDO-token-diagram
+		 */
+		if ( '<' === $char && $this->at + 3 < $this->length &&
+			'!' === $this->css[ $this->at + 1 ] &&
+			'-' === $this->css[ $this->at + 2 ] &&
+			'-' === $this->css[ $this->at + 3 ] ) {
+			// Consume them and return a <CDO-token>.
+			$this->at          += 4;
+			$this->token_type   = self::TOKEN_CDO;
+			$this->token_length = 4;
+			return true;
+		}
+
+		/*
+		 * Ident-start code point
+		 *
+		 * If the input stream starts with an ident sequence, reconsume the current
+		 * input code point, consume an ident-like token, and return it.
+		 *
+		 * Could be an identifier, function, or url() token.
+		 *
+		 * @link https://www.w3.org/TR/css-syntax-3/#consume-ident-like-token
+		 */
+		if ( $this->check_if_3_code_points_start_an_ident_sequence( $this->at ) ) {
+			return $this->consume_ident_like();
+		}
+
+		/*
+		 * Delim token (delimiter)
+		 *
+		 * Any code point that doesn't match above rules becomes a delim token.
+		 * Handle multi-byte UTF-8 characters properly.
+		 *
+		 * @link https://www.w3.org/TR/css-syntax-3/#typedef-delim-token
+		 */
+		if ( ord( $char ) >= 0x80 ) {
+			$new_at         = $this->at;
+			$invalid_length = 0;
+			if ( 1 !== _wp_scan_utf8( $this->css, $new_at, $invalid_length, null, 1 ) ) {
+				/*
+				 * The bytes at the cursor are not a valid UTF-8 sequence. Skip the
+				 * $invalid_length bytes of the maximal subpart; decoding replaces them
+				 * with U+FFFD.
+				 */
+				$matched_bytes = $invalid_length;
+			} else {
+				$matched_bytes = $new_at - $this->at;
+			}
+
+			$this->at          += $matched_bytes;
+			$this->token_type   = self::TOKEN_DELIM;
+			$this->token_length = $matched_bytes;
+			return true;
+		}
+
+		// Single ASCII delim.
+		++$this->at;
+		$this->token_type   = self::TOKEN_DELIM;
+		$this->token_length = 1;
+		return true;
+	}
+
+	/**
+	 * Gets the current token.
+	 *
+	 * The token keeps its values after the processor moves on, so callers can
+	 * collect tokens and read them later. Calls for the same token return the
+	 * same object.
+	 *
+	 * Example:
+	 *
+	 * ```php interactive
+	 * $processor = new WP_CSS_Token_Processor( 'a "b"' );
+	 * $tokens    = array();
+	 * while ( $processor->next_token() ) {
+	 *     $tokens[] = $processor->get_token();
+	 * }
+	 * echo $tokens[2]->get_value();
+	 * // Outputs: "b"
+	 * ```
+	 *
+	 * @since 7.3.0
+	 *
+	 * @return WP_CSS_Token|null The current token, or null before the first
+	 *                           token and after the last.
+	 */
+	public function get_token(): ?WP_CSS_Token {
+		if ( null === $this->token_type ) {
+			return null;
+		}
+
+		if ( null === $this->token ) {
+			$this->token = new WP_CSS_Token(
+				$this->css,
+				$this->token_type,
+				$this->token_starts_at,
+				$this->token_length,
+				$this->token_type_flag,
+				$this->token_unit,
+				$this->token_value_starts_at,
+				$this->token_value_length,
+				$this->token_is_terminated
+			);
+		}
+
+		return $this->token;
+	}
+
+	/**
+	 * Gets the current token type.
+	 *
+	 * @since 7.3.0
+	 *
+	 * @return string|null
+	 * @phpstan-return self::TOKEN_*|null
+	 */
+	public function get_token_type(): ?string {
+		return $this->token_type;
+	}
+
+	/**
+	 * Gets the byte offset at which the current token starts.
+	 *
+	 * @since 7.3.0
+	 *
+	 * @return int|null
+	 */
+	public function get_token_start(): ?int {
+		return $this->token_starts_at;
+	}
+
+	/**
+	 * Gets the byte length of the current token.
+	 *
+	 * @since 7.3.0
+	 *
+	 * @return int|null
+	 */
+	public function get_token_length(): ?int {
+		return $this->token_length;
+	}
+
+	/**
+	 * Clears token state between tokens.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 */
+	private function after_token(): void {
+		$this->token_type            = null;
+		$this->token_type_flag       = null;
+		$this->token_starts_at       = null;
+		$this->token_length          = null;
+		$this->token                 = null;
+		$this->token_unit            = null;
+		$this->token_is_terminated   = true;
+		$this->token_value_starts_at = null;
+		$this->token_value_length    = null;
+	}
+
+	/**
+	 * Consumes a string token.
+	 *
+	 * Strings are quoted with either " or ' and can contain escape sequences.
+	 * Newlines inside strings (without escaping) make the string invalid.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#consume-string-token
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @return bool
+	 */
+	private function consume_string(): bool {
+		// Initially create a <string-token> with its value set to the empty string.
+		$this->token_starts_at = $this->at;
+		$ending_char           = $this->css[ $this->at ];
+
+		// Skip past the opening quote.
+		++$this->at;
+		$value_starts_at = $this->at;
+
+		// Characters that need special handling: the ending quote, newlines, backslashes.
+		$special_chars = "'" === $ending_char ? "'\n\f\r\\" : "\"\n\f\r\\";
+
+		while ( $this->at < $this->length ) {
+			// Consume normal characters up to the next special character.
+			$normal_len = strcspn( $this->css, $special_chars, $this->at );
+			if ( $normal_len > 0 ) {
+				$this->at += $normal_len;
+			}
+
+			if ( $this->at >= $this->length ) {
+				break; // EOF.
+			}
+
+			$char = $this->css[ $this->at ];
+			switch ( $char ) {
+				case $ending_char:
+					// Ending quote.
+					// Return the <string-token>.
+					++$this->at;
+					$this->token_type            = self::TOKEN_STRING;
+					$this->token_length          = $this->at - $this->token_starts_at;
+					$this->token_value_starts_at = $value_starts_at;
+					$this->token_value_length    = $this->at - $value_starts_at - 1;
+					return true;
+
+				case "\n":
+				case "\f":
+				case "\r":
+					/*
+					 * Newline.
+					 *
+					 * This is a parse error. Reconsume the current input code point,
+					 * create a <bad-string-token>, and return it.
+					 *
+					 * Unescaped newlines are not allowed in strings. To include a newline,
+					 * it must be escaped as \A or the string must end and a new one begin.
+					 *
+					 * @link https://www.w3.org/TR/css-syntax-3/#consume-string-token
+					 */
+					$this->token_type            = self::TOKEN_BAD_STRING;
+					$this->token_length          = $this->at - $this->token_starts_at;
+					$this->token_value_starts_at = $value_starts_at;
+					$this->token_value_length    = $this->at - $value_starts_at;
+					return true;
+
+				case '\\':
+					// U+005C REVERSE SOLIDUS (\)
+					// If the next input code point is EOF, do nothing.
+					++$this->at;
+					if ( $this->at >= $this->length ) {
+						// Backslash-EOF: do nothing, just consume the backslash.
+						continue 2;
+					}
+
+					// Otherwise, if the next input code point is a newline, consume it.
+					$next = $this->css[ $this->at ];
+					if ( "\n" === $next || "\f" === $next ) {
+						++$this->at;
+						continue 2;
+					} elseif ( "\r" === $next ) {
+						++$this->at;
+						// Handle \r\n as a single newline.
+						if ( $this->at < $this->length && "\n" === $this->css[ $this->at ] ) {
+							++$this->at;
+						}
+						continue 2;
+					}
+
+					// Otherwise, (the stream starts with a valid escape) consume an escaped
+					// code point (just to advance position, don't store the result).
+					self::decode_escape_at( $this->css, $this->at, $matched_bytes );
+					$this->at += $matched_bytes;
+					continue 2;
+
+				default:
+					_doing_it_wrong( __METHOD__, 'Unexpected character in string: ' . $char, '7.3.0' );
+					break;
+			}
+		}
+
+		// EOF
+		// This is a parse error. Return the <string-token>.
+		$this->token_type            = self::TOKEN_STRING;
+		$this->token_is_terminated   = false;
+		$this->token_length          = $this->at - $this->token_starts_at;
+		$this->token_value_starts_at = $value_starts_at;
+		$this->token_value_length    = $this->at - $value_starts_at;
+		return true;
+	}
+
+	/**
+	 * Consumes a numeric token (number, percentage, dimension).
+	 *
+	 * Numbers can be integers or decimals, with optional sign and exponent.
+	 * They can be followed by % (percentage) or an identifier (dimension).
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#consume-numeric-token
+	 * @link https://www.w3.org/TR/css-syntax-3/#consume-number
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @return bool
+	 */
+	private function consume_numeric(): bool {
+		// Consume a number and let number be the result.
+		// The type flag defaults to "integer".
+		$number_type = 'integer';
+
+		// If the next input code point is U+002B PLUS SIGN (+) or U+002D HYPHEN-MINUS (-),
+		// consume it and append it to repr.
+		if ( '+' === $this->css[ $this->at ] || '-' === $this->css[ $this->at ] ) {
+			++$this->at;
+		}
+
+		// While the next input code point is a digit, consume it and append it to repr.
+		$digits = strspn( $this->css, '0123456789', $this->at );
+		if ( $digits > 0 ) {
+			$this->at += $digits;
+		}
+
+		// If the next 2 input code points are U+002E FULL STOP (.) followed by a digit, then.
+		if (
+			$this->at + 1 < $this->length &&
+			'.' === $this->css[ $this->at ] &&
+			$this->css[ $this->at + 1 ] >= '0' &&
+			$this->css[ $this->at + 1 ] <= '9'
+		) {
+			// Consume them.
+			++$this->at;
+			// Set type to "number".
+			$number_type = 'number';
+			// While the next input code point is a digit, consume it and append it to repr.
+			$digits = strspn( $this->css, '0123456789', $this->at );
+			if ( $digits > 0 ) {
+				$this->at += $digits;
+			}
+		}
+
+		// If the next 2 or 3 input code points are U+0045 LATIN CAPITAL LETTER E (E)
+		// or U+0065 LATIN SMALL LETTER E (e), optionally followed by U+002D HYPHEN-MINUS (-)
+		// or U+002B PLUS SIGN (+), followed by a digit, then.
+		if ( $this->at < $this->length ) {
+			$e = $this->css[ $this->at ];
+			if ( 'e' === $e || 'E' === $e ) {
+				$save_pos = $this->at;
+				++$this->at;
+				$has_exp = false;
+
+				if ( $this->at < $this->length ) {
+					$next = $this->css[ $this->at ];
+					if ( ( '+' === $next || '-' === $next ) && $this->at + 1 < $this->length &&
+						$this->css[ $this->at + 1 ] >= '0' && $this->css[ $this->at + 1 ] <= '9' ) {
+						// Consume them.
+						++$this->at;
+						$has_exp = true;
+					} elseif ( $next >= '0' && $next <= '9' ) {
+						$has_exp = true;
+					}
+				}
+
+				if ( $has_exp ) {
+					// Set type to "number".
+					$number_type = 'number';
+					// While the next input code point is a digit, consume it and append it to repr.
+					$digits = strspn( $this->css, '0123456789', $this->at );
+					if ( $digits > 0 ) {
+						$this->at += $digits;
+					}
+				} else {
+					$this->at = $save_pos;
+				}
+			}
+		}
+
+		/*
+		 * This is the end of spec section 4.3.12. Consume a number.
+		 * The rest follows section 4.3.3. Consume a numeric token.
+		 *
+		 * @link https://www.w3.org/TR/css-syntax-3/#consume-numeric-token
+		 */
+
+		// If the next 3 input code points would start an ident sequence, then.
+		if ( $this->check_if_3_code_points_start_an_ident_sequence( $this->at ) ) {
+			// Create a <dimension-token> with the same value and type flag as number,
+			// and a unit set initially to the empty string.
+			// Consume an ident sequence. Set the <dimension-token>'s unit to the returned value.
+			$unit_starts_at = $this->at;
+			$this->consume_ident_sequence();
+			$this->token_unit      = self::decode_range( $this->css, $unit_starts_at, $this->at - $unit_starts_at );
+			$this->token_type      = self::TOKEN_DIMENSION;
+			$this->token_type_flag = $number_type;
+			$this->token_length    = $this->at - $this->token_starts_at;
+			return true;
+		}
+
+		// Otherwise, if the next input code point is U+0025 PERCENTAGE SIGN (%), consume it.
+		// Create a <percentage-token> with the same value as number, and return it.
+		// Note: percentage tokens do not have a type flag per spec.
+		if ( $this->at < $this->length && '%' === $this->css[ $this->at ] ) {
+			++$this->at;
+			$this->token_type   = self::TOKEN_PERCENTAGE;
+			$this->token_length = $this->at - $this->token_starts_at;
+			return true;
+		}
+
+		// Otherwise, create a <number-token> with the same value and type flag as number, and return it.
+		$this->token_type      = self::TOKEN_NUMBER;
+		$this->token_type_flag = $number_type;
+		$this->token_length    = $this->at - $this->token_starts_at;
+		return true;
+	}
+
+	/**
+	 * Consumes an ident-like token (function, url, ident).
+	 *
+	 * After consuming an identifier, checks if it's followed by '(' to determine
+	 * if it's a function or url() token, otherwise it's a plain identifier.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#consume-ident-like-token
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @return bool
+	 */
+	private function consume_ident_like(): bool {
+		// Consume an ident sequence, and let string be the result.
+		$ident_start = $this->at;
+		$this->consume_ident_sequence();
+		$string = self::decode_range( $this->css, $ident_start, $this->at - $ident_start );
+
+		// If string's value is an ASCII case-insensitive match for "url",
+		// and the next input code point is U+0028 LEFT PARENTHESIS (().
+		if ( 0 === strcasecmp( $string, 'url' ) && $this->at < $this->length && '(' === $this->css[ $this->at ] ) {
+			// Consume it.
+			++$this->at;
+
+			// While the next two input code points are whitespace, consume the next input code point.
+			$ws_len = strspn( $this->css, "\t\n\f\r ", $this->at );
+
+			// If the next one or two input code points are U+0022 QUOTATION MARK ("),
+			// U+0027 APOSTROPHE ('), or whitespace followed by U+0022 QUOTATION MARK (")
+			// or U+0027 APOSTROPHE (').
+			if ( $this->at + $ws_len < $this->length ) {
+				$next = $this->css[ $this->at + $ws_len ];
+				if ( '"' === $next || "'" === $next ) {
+					// then create a <function-token> with its value set to string and return it.
+					$this->token_type   = self::TOKEN_FUNCTION;
+					$this->token_length = $this->at - $this->token_starts_at;
+					return true;
+				}
+			}
+
+			// Otherwise, consume a url token, and return it.
+			$this->at += $ws_len;
+			return $this->consume_url();
+		}
+
+		// Otherwise, if the next input code point is U+0028 LEFT PARENTHESIS (().
+		if ( $this->at < $this->length && '(' === $this->css[ $this->at ] ) {
+			// Consume it.
+			++$this->at;
+			// Create a <function-token> with its value set to string and return it.
+			$this->token_type   = self::TOKEN_FUNCTION;
+			$this->token_length = $this->at - $this->token_starts_at;
+			return true;
+		}
+
+		// Otherwise, create an <ident-token> with its value set to string and return it.
+		$this->token_type   = self::TOKEN_IDENT;
+		$this->token_length = $this->at - $this->token_starts_at;
+		return true;
+	}
+
+	/**
+	 * Consumes a url token.
+	 *
+	 * URL tokens can contain unquoted URLs with escape sequences but not quotes,
+	 * parentheses, or certain control characters. Invalid characters create a
+	 * bad-url token.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#consume-url-token
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @return bool
+	 */
+	private function consume_url(): bool {
+		// Initially create a <url-token> with its value set to the empty string.
+		// Consume as much whitespace as possible.
+		$this->at += strspn( $this->css, "\t\n\f\r ", $this->at );
+
+		$value_starts_at = $this->at;
+
+		// Repeatedly consume the next input code point from the stream.
+		while ( $this->at < $this->length ) {
+			// Scan runs such as https://example.com/photo.png in native code rather
+			// than one PHP iteration per byte. These ASCII bytes need no special
+			// handling in an unquoted URL. Quotes, parentheses, whitespace, escapes,
+			// and non-ASCII bytes fall through to the rules below.
+			// Only the cursor advances; source bytes stay unchanged.
+			// This set only selects the fast path; it does not validate the URL or
+			// reject other bytes, which still reach the CSS token rules below.
+			$plain = strspn( $this->css, 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~:/?#[]@!$&*+,;=%', $this->at );
+			if ( $plain > 0 ) {
+				$this->at += $plain;
+				continue;
+			}
+			// U+0029 RIGHT PARENTHESIS ())
+			// Return the <url-token>.
+			if ( ')' === $this->css[ $this->at ] ) {
+				++$this->at;
+				$this->token_type            = self::TOKEN_URL;
+				$this->token_length          = $this->at - $this->token_starts_at;
+				$this->token_value_starts_at = $value_starts_at;
+				$this->token_value_length    = $this->at - $value_starts_at - 1;
+				return true;
+			}
+
+			// whitespace
+			// Consume as much whitespace as possible. If the next input code point is
+			// U+0029 RIGHT PARENTHESIS ()) or EOF, consume it and return the <url-token>
+			// (if EOF was encountered, this is a parse error); otherwise, consume the
+			// remnants of a bad url, create a <bad-url-token>, and return it.
+			$ws_len = strspn( $this->css, "\t\n\f\r ", $this->at );
+			if ( $ws_len > 0 ) {
+				$value_ends_at = $this->at;
+				$this->at     += $ws_len;
+				// Accept either ) or EOF after whitespace.
+				if ( $this->at >= $this->length ) {
+					// EOF is a parse error, but the <url-token> is still returned.
+					$this->token_type            = self::TOKEN_URL;
+					$this->token_is_terminated   = false;
+					$this->token_length          = $this->at - $this->token_starts_at;
+					$this->token_value_starts_at = $value_starts_at;
+					$this->token_value_length    = $value_ends_at - $value_starts_at;
+					return true;
+				}
+
+				if ( ')' === $this->css[ $this->at ] ) {
+					// Skip the closing parenthesis and return the <url-token>.
+					++$this->at;
+					$this->token_type            = self::TOKEN_URL;
+					$this->token_length          = $this->at - $this->token_starts_at;
+					$this->token_value_starts_at = $value_starts_at;
+					$this->token_value_length    = $value_ends_at - $value_starts_at;
+					return true;
+				}
+
+				return $this->consume_remnants_of_bad_url();
+			}
+
+			// These codepoints trigger a parse error.
+			$byte = ord( $this->css[ $this->at ] );
+			if (
+				'"' === $this->css[ $this->at ] ||
+				"'" === $this->css[ $this->at ] ||
+				'(' === $this->css[ $this->at ] ||
+
+				// NUL becomes U+FFFD during CSS preprocessing, so it is valid here.
+				// Keep its source byte for offsets; decode_range() replaces it when
+				// the caller reads the value. Other non-printable controls stay invalid.
+				( $byte >= 0x01 && $byte <= 0x08 ) ||
+
+				// Line Tabulation.
+				0x0B === $byte ||
+
+				// Control characters.
+				( $byte >= 0x000E && $byte <= 0x001F ) ||
+
+				// Delete.
+				0x7F === $byte
+			) {
+				// Consume the remnants of a bad url,
+				// create a <bad-url-token>, and return it.
+				return $this->consume_remnants_of_bad_url();
+			}
+
+			// U+005C REVERSE SOLIDUS (\)
+			// If the stream starts with a valid escape, consume an escaped code point.
+			if ( '\\' === $this->css[ $this->at ] ) {
+				if ( self::is_valid_escape( $this->css, $this->at ) ) {
+					++$this->at;
+					self::decode_escape_at( $this->css, $this->at, $matched_bytes );
+					$this->at += $matched_bytes;
+					continue;
+				}
+				// Otherwise, this is a parse error. Consume the remnants of a bad url,
+				// create a <bad-url-token>, and return it.
+				return $this->consume_remnants_of_bad_url();
+			}
+
+			$at             = $this->at;
+			$invalid_length = 0;
+			if ( 1 !== _wp_scan_utf8( $this->css, $at, $invalid_length, null, 1 ) ) {
+				/*
+				 * The bytes at the cursor are not a valid UTF-8 sequence. Skip the
+				 * $invalid_length bytes of the maximal subpart; decoding replaces them
+				 * with U+FFFD.
+				 */
+				$this->at += $invalid_length;
+			} else {
+				$this->at = $at;
+			}
+		}
+
+		// EOF
+		// This is a parse error. Return the <url-token>.
+		$this->token_type            = self::TOKEN_URL;
+		$this->token_is_terminated   = false;
+		$this->token_length          = $this->at - $this->token_starts_at;
+		$this->token_value_starts_at = $value_starts_at;
+		$this->token_value_length    = $this->at - $value_starts_at;
+		return true;
+	}
+
+	/**
+	 * Finishes a bad url token by consuming remnants.
+	 *
+	 * When an invalid character is encountered in a URL, the remainder of
+	 * the URL up to the closing `)` or EOF is consumed.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#consume-remnants-of-bad-url
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @return bool
+	 */
+	private function consume_remnants_of_bad_url(): bool {
+		// Set to true when a `)` ends the token.
+		$this->token_is_terminated = false;
+
+		while ( $this->at < $this->length ) {
+			$this->at += strcspn( $this->css, ')\\', $this->at );
+
+			if ( $this->at >= $this->length ) {
+				break;
+			}
+
+			if ( '\\' === $this->css[ $this->at ] ) {
+				++$this->at;
+				if ( self::is_valid_escape( $this->css, $this->at - 1 ) ) {
+					self::decode_escape_at( $this->css, $this->at, $matched_bytes );
+					$this->at += $matched_bytes;
+					continue;
+				}
+			} elseif ( ')' === $this->css[ $this->at ] ) {
+				++$this->at;
+				$this->token_is_terminated = true;
+				break;
+			}
+		}
+
+		$this->token_type   = self::TOKEN_BAD_URL;
+		$this->token_length = $this->at - $this->token_starts_at;
+		return true;
+	}
+
+	/**
+	 * Consumes an identifier sequence.
+	 *
+	 * Identifiers can contain letters, digits, hyphens, underscores, non-ASCII
+	 * characters, and escape sequences. Null bytes are replaced with U+FFFD.
+	 *
+	 * Advances the cursor past the sequence; the caller decodes the bytes.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#consume-name
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 */
+	private function consume_ident_sequence(): void {
+		while ( $this->at < $this->length ) {
+			// Scan ASCII name characters, as in margin-top or item_2, in native
+			// code rather than one PHP iteration per byte. Letters, digits, "-",
+			// and "_" can continue a name; deciding whether an identifier may
+			// start here is a separate check, not the purpose of this byte list.
+			// Non-ASCII bytes, NULL, and escapes use the rules below. Advancing
+			// only the cursor preserves the source spelling for later decoding.
+			$plain = strspn( $this->css, 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_', $this->at );
+			if ( $plain > 0 ) {
+				$this->at += $plain;
+				continue;
+			}
+			$codepoint_bytes = $this->consume_ident_codepoint( $this->at );
+			if ( $codepoint_bytes > 0 ) {
+				$this->at += $codepoint_bytes;
+				continue;
+			}
+
+			if ( self::is_valid_escape( $this->css, $this->at ) ) {
+				++$this->at;
+
+				self::decode_escape_at( $this->css, $this->at, $matched_bytes );
+				$this->at += $matched_bytes;
+				continue;
+			}
+
+			break;
+		}
+	}
+
+	/**
+	 * Ident-start code point
+	 *     A letter, a non-ASCII code point, or U+005F LOW LINE (_).
+	 *
+	 * Ident code point
+	 *     An ident-start code point, a digit, or U+002D HYPHEN-MINUS (-).
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#ident-start-code-point
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @return int The number of bytes consumed.
+	 */
+	private function consume_ident_codepoint( $at ): int {
+		// ident code points.
+		if ( ( $this->css[ $at ] >= '0' && $this->css[ $at ] <= '9' ) ||
+			'-' === $this->css[ $at ] ) {
+			return 1;
+		}
+
+		return $this->consume_ident_start_codepoint( $at );
+	}
+
+	/**
+	 * Ident-start code point
+	 *     A letter, a non-ASCII code point, or U+005F LOW LINE (_).
+	 *
+	 * Ident code point
+	 *     An ident-start code point, a digit, or U+002D HYPHEN-MINUS (-).
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#ident-start-code-point
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @return int The number of bytes consumed.
+	 */
+	private function consume_ident_start_codepoint( $at ): int {
+		if ( $at >= $this->length ) {
+			return 0;
+		}
+
+		// ASCII codepoints.
+		if ( ( $this->css[ $at ] >= 'A' && $this->css[ $at ] <= 'Z' ) ||
+			( $this->css[ $at ] >= 'a' && $this->css[ $at ] <= 'z' ) ||
+			'_' === $this->css[ $at ] ) {
+			return 1;
+		}
+
+		// Special case for null bytes – they are replaced with U+FFFD during preprocessing.
+		if ( "\x00" === $this->css[ $at ] ) {
+			return 1;
+		}
+
+		$new_at         = $at;
+		$invalid_length = 0;
+		if ( 1 !== _wp_scan_utf8( $this->css, $new_at, $invalid_length, null, 1 ) ) {
+			/*
+			 * The bytes at $at are not a valid UTF-8 sequence. Their maximal subpart
+			 * of $invalid_length bytes counts as one code point; decoding replaces it
+			 * with U+FFFD.
+			 */
+			return $invalid_length;
+		}
+
+		$codepoint_byte_length = $new_at - $at;
+		$codepoint             = self::utf8_ord( substr( $this->css, $at, $codepoint_byte_length ) );
+		if ( $codepoint >= 0x80 ) {
+			return $codepoint_byte_length;
+		}
+		return 0;
+	}
+
+	/**
+	 * Decodes and normalizes ident-like or string CSS values from a byte range.
+	 *
+	 * The cursor and WP_CSS_Token both decode with this method.
+	 *
+	 * @since 7.3.0
+	 * @access private
+	 * @ignore
+	 *
+	 * @param string $css            CSS source the offsets index.
+	 * @param int    $start          Start byte offset.
+	 * @param int    $length         Length of the substring to decode.
+	 * @param bool   $string_escapes Optional, default false. When true, apply additional escape
+	 *                               rules that apply only to string tokens.
+	 * @return string Decoded and normalized string.
+	 */
+	public static function decode_range( string $css, int $start, int $length, bool $string_escapes = false ): string {
+		// Fast path: check if any processing is needed.
+		$slice         = wp_scrub_utf8( substr( $css, $start, $length ) );
+		$special_chars = "\\\r\f\x00";
+		if ( false === strpbrk( $slice, $special_chars ) ) {
+			// No special chars - return raw substring (almost zero allocations).
+			return $slice;
+		}
+
+		// Slow path: build decoded string (one allocation).
+		$decoded = '';
+		$at      = $start;
+		$end     = $start + $length;
+
+		while ( $at < $end ) {
+			// Find next special character within the token boundary.
+			$normal_len = strcspn( $css, $special_chars, $at, $end - $at );
+			if ( $normal_len > 0 ) {
+				$decoded .= wp_scrub_utf8( substr( $css, $at, $normal_len ) );
+				$at      += $normal_len;
+			}
+
+			if ( $at >= $end ) {
+				break;
+			}
+
+			$char = $css[ $at ];
+
+			// Handle escapes (if enabled).
+			if ( '\\' === $char ) {
+				if ( $string_escapes ) {
+					if ( $at + 1 >= $end ) {
+						// Backslash-EOF: consume the backslash and stop.
+						++$at;
+						continue;
+					}
+
+					$next = $css[ $at + 1 ];
+					if ( "\n" === $next || "\f" === $next ) {
+						// Backslash followed by LF or FF is a string line continuation.
+						$at += 2;
+						continue;
+					}
+
+					if ( "\r" === $next ) {
+						// Backslash followed by CR or CRLF is a string line continuation.
+						$at += 2;
+						if ( $at < $end && "\n" === $css[ $at ] ) {
+							++$at;
+						}
+						continue;
+					}
+				}
+
+				if ( self::is_valid_escape( $css, $at ) ) {
+					++$at;
+					$decoded .= self::decode_escape_at( $css, $at, $bytes_consumed );
+					$at      += $bytes_consumed;
+					continue;
+				}
+				// Invalid escape - consume the backslash and keep going.
+				$decoded .= '\\';
+				++$at;
+				continue;
+			}
+
+			// CSS normalization: \r\n, \r, and \f all become \n.
+			if ( "\r" === $char ) {
+				$decoded .= "\n";
+				++$at;
+				// Handle \r\n as single newline.
+				if ( $at < $end && "\n" === $css[ $at ] ) {
+					++$at;
+				}
+				continue;
+			}
+
+			if ( "\f" === $char ) {
+				$decoded .= "\n";
+				++$at;
+				continue;
+			}
+
+			// Null bytes become U+FFFD.
+			if ( "\x00" === $char ) {
+				$decoded .= "\u{FFFD}";
+				++$at;
+				continue;
+			}
+		}
+
+		return $decoded;
+	}
+
+	/**
+	 * Applies CSS input preprocessing to a byte range without decoding escapes.
+	 *
+	 * CR, CRLF and FF become LF, and NUL and invalid UTF-8 become U+FFFD.
+	 * Comments are read with this method because they contain no escapes.
+	 *
+	 * @since 7.3.0
+	 * @access private
+	 * @ignore
+	 *
+	 * @param string $css    CSS source the offsets index.
+	 * @param int    $start  Start byte offset.
+	 * @param int    $length Length of the substring to preprocess.
+	 * @return string Preprocessed string.
+	 */
+	public static function preprocess_range( string $css, int $start, int $length ): string {
+		return strtr(
+			wp_scrub_utf8( substr( $css, $start, $length ) ),
+			array(
+				"\r\n" => "\n",
+				"\r"   => "\n",
+				"\f"   => "\n",
+				"\0"   => "\u{FFFD}",
+			)
+		);
+	}
+
+	/**
+	 * Decodes an escape sequence starting at the given offset.
+	 *
+	 * Escape sequences are backslash followed by 1-6 hex digits (with optional
+	 * trailing whitespace) or any other character. Invalid code points are
+	 * replaced with U+FFFD.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#consume-escaped-code-point
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @param string $css             CSS source.
+	 * @param int    $offset          Byte offset (should point to the character after the backslash).
+	 * @param int    &$bytes_consumed Output parameter: number of bytes consumed.
+	 * @return string The decoded character(s).
+	 */
+	private static function decode_escape_at( string $css, int $offset, &$bytes_consumed ): string {
+		$css_length = strlen( $css );
+
+		// This method assumes the U+005C REVERSE SOLIDUS (\) has already been consumed
+		// and the next input code point has already been verified to be part of a valid
+		// escape sequence.
+		$at = $offset;
+
+		// EOF.
+		if ( $at >= $css_length ) {
+			// This is a parse error. Return U+FFFD REPLACEMENT CHARACTER (�).
+			$bytes_consumed = 0;
+			return "\u{FFFD}";
+		}
+
+		// Hex digits (CSS spec allows at most 6).
+		$hex_len = strspn( $css, '0123456789ABCDEFabcdef', $at, 6 );
+		if ( $hex_len > 0 ) {
+			$hex = substr( $css, $at, $hex_len );
+			$at += $hex_len;
+
+			// If the next input code point is whitespace, consume it as well.
+			if ( $at < $css_length ) {
+				$next = $css[ $at ];
+				if ( "\t" === $next || "\n" === $next || "\f" === $next || ' ' === $next ) {
+					++$at;
+				} elseif ( "\r" === $next ) {
+					++$at;
+					// Handle \r\n as a single whitespace – the preprocessing phase would replace \r\n with \n.
+					if ( $at < $css_length && "\n" === $css[ $at ] ) {
+						++$at;
+					}
+				}
+			}
+
+			$bytes_consumed = $at - $offset;
+			$code_point     = hexdec( $hex );
+			if (
+				$code_point <= 0 ||
+				( $code_point >= 0xD800 && $code_point <= 0xDFFF ) ||
+				$code_point > 0x10FFFF
+			) {
+				return "\u{FFFD}";
+			}
+
+			// Convert the hex digits to a UTF-8 string.
+			return WP_HTML_Decoder::code_point_to_utf8_bytes( $code_point );
+		}
+
+		// Anything else.
+		// Return the current input code point.
+		// Null bytes are replaced with U+FFFD during preprocessing.
+		if ( "\x00" === $css[ $at ] ) {
+			$bytes_consumed = 1;
+			return "\u{FFFD}";
+		}
+
+		$new_at         = $at;
+		$invalid_length = 0;
+		if ( 1 !== _wp_scan_utf8( $css, $new_at, $invalid_length, null, 1 ) ) {
+			// Consume the invalid subpart and return U+FFFD.
+			$bytes_consumed = $invalid_length;
+			return "\u{FFFD}";
+		}
+
+		$bytes_consumed = $new_at - $at;
+		return substr( $css, $at, $bytes_consumed );
+	}
+
+	/**
+	 * Checks if current position starts a valid escape sequence.
+	 *
+	 * A valid escape is a `\` not followed by a newline. A `\` at the end of
+	 * the input is a valid escape; consuming it produces U+FFFD.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#starts-with-a-valid-escape
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @param string $css    CSS source.
+	 * @param int    $offset Byte offset.
+	 * @return bool
+	 */
+	private static function is_valid_escape( string $css, int $offset ): bool {
+		$css_length = strlen( $css );
+
+		// If the first code point is not U+005C REVERSE SOLIDUS (\), return false.
+		if ( $offset >= $css_length || '\\' !== $css[ $offset ] ) {
+			return false;
+		}
+
+		// The end of the input is not a newline.
+		if ( $offset + 1 >= $css_length ) {
+			return true;
+		}
+
+		/*
+		 * Otherwise, if the second code point is a newline, return false.
+		 * Otherwise, return true.
+		 *
+		 * Preprocessing turns CR, FF and CRLF into a newline, so the CR check also covers CRLF.
+		 */
+		return (
+			"\n" !== $css[ $offset + 1 ] &&
+			"\f" !== $css[ $offset + 1 ] &&
+			"\r" !== $css[ $offset + 1 ]
+		);
+	}
+
+	/**
+	 * Checks if the next 3 code points would start a number.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#starts-with-a-number
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @return bool
+	 */
+	private function would_next_3_code_points_start_a_number(): bool {
+		if ( $this->at >= $this->length ) {
+			return false;
+		}
+
+		// Look at the first code point.
+
+		// U+002B PLUS SIGN (+) or U+002D HYPHEN-MINUS (-).
+		if ( '+' === $this->css[ $this->at ] || '-' === $this->css[ $this->at ] ) {
+			if ( $this->at + 1 >= $this->length ) {
+				return false;
+			}
+			// If the second code point is a digit, return true.
+			if ( $this->css[ $this->at + 1 ] >= '0' && $this->css[ $this->at + 1 ] <= '9' ) {
+				return true;
+			}
+			// Otherwise, the second code point must be a full stop (.) and the third code point must be a digit.
+			if ( '.' === $this->css[ $this->at + 1 ] && $this->at + 2 < $this->length ) {
+				return $this->css[ $this->at + 2 ] >= '0' && $this->css[ $this->at + 2 ] <= '9';
+			}
+
+			// Otherwise, return false.
+			return false;
+		}
+
+		// U+002E FULL STOP (.).
+		if ( '.' === $this->css[ $this->at ] ) {
+			if ( $this->at + 1 >= $this->length ) {
+				return false;
+			}
+			return $this->css[ $this->at + 1 ] >= '0' && $this->css[ $this->at + 1 ] <= '9';
+		}
+
+		// Digit.
+		if ( $this->css[ $this->at ] >= '0' && $this->css[ $this->at ] <= '9' ) {
+			return true;
+		}
+
+		// Anything else – return false.
+		return false;
+	}
+
+	/**
+	 * Checks if three code points would start an identifier sequence.
+	 *
+	 * This implements the CSS spec's "Check if three code points would start an ident sequence"
+	 * algorithm, which checks the code point at $offset and the following two code points.
+	 *
+	 * NOTE: "Three code points" means three Unicode code points, not three bytes.
+	 * Multi-byte UTF-8 sequences count as single code points.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#would-start-an-identifier
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @param int $offset Byte offset of the first code point to check.
+	 * @return bool
+	 */
+	private function check_if_3_code_points_start_an_ident_sequence( int $offset ): bool {
+		if ( $offset >= $this->length ) {
+			return false;
+		}
+
+		if ( '-' === $this->css[ $offset ] ) {
+			// If the second code point is a U+002D HYPHEN-MINUS (-), return true.
+			// e.g. --custom-property.
+			if ( $offset + 1 < $this->length && '-' === $this->css[ $offset + 1 ] ) {
+				return true;
+			}
+			// Otherwise, check if the second code point is an ident-START code point or valid escape.
+			// Note: After a hyphen, only ident-START code points are valid, NOT digits or hyphens.
+			++$offset;
+		}
+
+		return $this->consume_ident_start_codepoint( $offset ) > 0 || self::is_valid_escape( $this->css, $offset );
+	}
+
+	/**
+	 * Convert a UTF-8 byte sequence to its Unicode codepoint.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @param  string $character  UTF-8 encoded byte sequence representing a single Unicode character.
+	 *
+	 * @return int Unicode codepoint.
+	 */
+	private static function utf8_ord( string $character ): int {
+		// Convert the byte sequence to its binary representation.
+		$bytes = unpack( 'C*', $character );
+
+		// Initialize the codepoint.
+		$codepoint = 0;
+
+		// Calculate the codepoint based on the number of bytes.
+		if ( 1 === count( $bytes ) ) {
+			$codepoint = $bytes[1];
+		} elseif ( 2 === count( $bytes ) ) {
+			$codepoint = ( ( $bytes[1] & 0x1F ) << 6 ) | ( $bytes[2] & 0x3F );
+		} elseif ( 3 === count( $bytes ) ) {
+			$codepoint = ( ( $bytes[1] & 0x0F ) << 12 ) | ( ( $bytes[2] & 0x3F ) << 6 ) | ( $bytes[3] & 0x3F );
+		} elseif ( 4 === count( $bytes ) ) {
+			$codepoint = ( ( $bytes[1] & 0x07 ) << 18 ) | ( ( $bytes[2] & 0x3F ) << 12 ) | ( ( $bytes[3] & 0x3F ) << 6 ) | ( $bytes[4] & 0x3F );
+		}
+
+		return $codepoint;
+	}
+}
diff --git a/src/wp-includes/css-api/class-wp-css-token-serializer.php b/src/wp-includes/css-api/class-wp-css-token-serializer.php
new file mode 100644
index 0000000000000..5a0e0683b8035
--- /dev/null
+++ b/src/wp-includes/css-api/class-wp-css-token-serializer.php
@@ -0,0 +1,596 @@
+<?php
+/**
+ * CSS API: WP_CSS_Token_Serializer class
+ *
+ * @package WordPress
+ * @subpackage CSS-API
+ * @since 7.3.0
+ */
+
+/**
+ * Writes tokens read by WP_CSS_Token_Processor as CSS text.
+ *
+ * This class is not a public API. Its methods are public so other core
+ * classes can call them.
+ *
+ * The output parses to the same CSS as the tokens. Which characters are
+ * escaped may change.
+ *
+ * @since 7.3.0
+ * @access private
+ * @ignore
+ *
+ * @see WP_CSS_Token_Processor
+ * @see WP_CSS_Builder
+ */
+class WP_CSS_Token_Serializer {
+	/**
+	 * Token pairs that must be written with a comment between them.
+	 *
+	 * Keys are the first token and values list the second; a delim token is
+	 * named by its value, every other token by its type.
+	 *
+	 * @see WP_CSS_Token_Serializer::serialize()
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var array<string, string[]>
+	 */
+	private const MARKED_PAIRS = array(
+		WP_CSS_Token_Processor::TOKEN_IDENT      => array(
+			WP_CSS_Token_Processor::TOKEN_IDENT,
+			WP_CSS_Token_Processor::TOKEN_FUNCTION,
+			WP_CSS_Token_Processor::TOKEN_URL,
+			WP_CSS_Token_Processor::TOKEN_BAD_URL,
+			'-',
+			WP_CSS_Token_Processor::TOKEN_NUMBER,
+			WP_CSS_Token_Processor::TOKEN_PERCENTAGE,
+			WP_CSS_Token_Processor::TOKEN_DIMENSION,
+			WP_CSS_Token_Processor::TOKEN_CDC,
+			WP_CSS_Token_Processor::TOKEN_LEFT_PAREN,
+		),
+		WP_CSS_Token_Processor::TOKEN_AT_KEYWORD => self::IDENT_LIKE_FOLLOWERS,
+		WP_CSS_Token_Processor::TOKEN_HASH       => self::IDENT_LIKE_FOLLOWERS,
+		WP_CSS_Token_Processor::TOKEN_DIMENSION  => self::IDENT_LIKE_FOLLOWERS,
+		'#'                                      => self::IDENT_LIKE_FOLLOWERS,
+		'-'                                      => self::IDENT_LIKE_FOLLOWERS,
+		WP_CSS_Token_Processor::TOKEN_NUMBER     => array(
+			WP_CSS_Token_Processor::TOKEN_IDENT,
+			WP_CSS_Token_Processor::TOKEN_FUNCTION,
+			WP_CSS_Token_Processor::TOKEN_URL,
+			WP_CSS_Token_Processor::TOKEN_BAD_URL,
+			WP_CSS_Token_Processor::TOKEN_NUMBER,
+			WP_CSS_Token_Processor::TOKEN_PERCENTAGE,
+			WP_CSS_Token_Processor::TOKEN_DIMENSION,
+			WP_CSS_Token_Processor::TOKEN_CDC,
+			'%',
+		),
+		'@'                                      => array(
+			WP_CSS_Token_Processor::TOKEN_IDENT,
+			WP_CSS_Token_Processor::TOKEN_FUNCTION,
+			WP_CSS_Token_Processor::TOKEN_URL,
+			WP_CSS_Token_Processor::TOKEN_BAD_URL,
+			'-',
+			WP_CSS_Token_Processor::TOKEN_CDC,
+		),
+		'.'                                      => self::NUMERIC_TOKENS,
+		'+'                                      => self::NUMERIC_TOKENS,
+		'/'                                      => array( '*' ),
+	);
+
+	/**
+	 * Second tokens of the marked pairs shared by the at-keyword, hash,
+	 * dimension, `#` and `-` rows.
+	 *
+	 * @see WP_CSS_Token_Serializer::MARKED_PAIRS
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var string[]
+	 */
+	private const IDENT_LIKE_FOLLOWERS = array(
+		WP_CSS_Token_Processor::TOKEN_IDENT,
+		WP_CSS_Token_Processor::TOKEN_FUNCTION,
+		WP_CSS_Token_Processor::TOKEN_URL,
+		WP_CSS_Token_Processor::TOKEN_BAD_URL,
+		'-',
+		WP_CSS_Token_Processor::TOKEN_NUMBER,
+		WP_CSS_Token_Processor::TOKEN_PERCENTAGE,
+		WP_CSS_Token_Processor::TOKEN_DIMENSION,
+		WP_CSS_Token_Processor::TOKEN_CDC,
+	);
+
+	/**
+	 * Second tokens of the marked pairs in the `.` and `+` rows.
+	 *
+	 * @see WP_CSS_Token_Serializer::MARKED_PAIRS
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var string[]
+	 */
+	private const NUMERIC_TOKENS = array(
+		WP_CSS_Token_Processor::TOKEN_NUMBER,
+		WP_CSS_Token_Processor::TOKEN_PERCENTAGE,
+		WP_CSS_Token_Processor::TOKEN_DIMENSION,
+	);
+
+	/**
+	 * Text of the token types that have no value.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var array<string, string>
+	 */
+	private const FIXED_TEXT = array(
+		WP_CSS_Token_Processor::TOKEN_COLON         => ':',
+		WP_CSS_Token_Processor::TOKEN_SEMICOLON     => ';',
+		WP_CSS_Token_Processor::TOKEN_COMMA         => ',',
+		WP_CSS_Token_Processor::TOKEN_LEFT_PAREN    => '(',
+		WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN   => ')',
+		WP_CSS_Token_Processor::TOKEN_LEFT_BRACKET  => '[',
+		WP_CSS_Token_Processor::TOKEN_RIGHT_BRACKET => ']',
+		WP_CSS_Token_Processor::TOKEN_LEFT_BRACE    => '{',
+		WP_CSS_Token_Processor::TOKEN_RIGHT_BRACE   => '}',
+		WP_CSS_Token_Processor::TOKEN_CDO           => '<!--',
+		WP_CSS_Token_Processor::TOKEN_CDC           => '-->',
+		WP_CSS_Token_Processor::TOKEN_BAD_STRING    => "\"\n",
+		WP_CSS_Token_Processor::TOKEN_BAD_URL       => 'url(()',
+	);
+
+	/**
+	 * Closing token type of each token type that opens a block.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var array<string, string>
+	 */
+	private const BLOCK_CLOSERS = array(
+		WP_CSS_Token_Processor::TOKEN_FUNCTION     => WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN,
+		WP_CSS_Token_Processor::TOKEN_LEFT_PAREN   => WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN,
+		WP_CSS_Token_Processor::TOKEN_LEFT_BRACKET => WP_CSS_Token_Processor::TOKEN_RIGHT_BRACKET,
+		WP_CSS_Token_Processor::TOKEN_LEFT_BRACE   => WP_CSS_Token_Processor::TOKEN_RIGHT_BRACE,
+	);
+
+	/**
+	 * Serializes tokens as CSS text that parses to the same CSS.
+	 *
+	 * This follows CSS Syntax Level 3 §9 Serialization:
+	 *
+	 * > The only requirement for serialization is that it must "round-trip" with parsing,
+	 * > that is, parsing the stylesheet must produce the same data structures as
+	 * > parsing, serializing, and parsing again,
+	 * > except for consecutive <whitespace-token>s,
+	 * > which may be collapsed into a single token.
+	 *
+	 * Comment tokens are dropped. Each run of whitespace, including a run
+	 * broken by comments, is written as one space; a run is never removed.
+	 *
+	 * Tokens are written from their decoded values. Identifiers, function
+	 * names, at-keywords, hash names, dimension units, strings and url values
+	 * are escaped again, so `\66 oo` becomes `foo` and `"a&b"` becomes `"a\26 b"`.
+	 *
+	 * > A <delim-token> containing U+005C REVERSE SOLIDUS (\)
+	 * > must be serialized as U+005C REVERSE SOLIDUS
+	 * > followed by a newline.
+	 * > (The tokenizer only ever emits such a token followed by a <whitespace-token>
+	 * > that starts with a newline.)
+	 *
+	 * > A <hash-token> with the "unrestricted" type flag may not need
+	 * > as much escaping as the same token with the "id" type flag.
+	 *
+	 * A hash with the "id" flag is escaped as an identifier, so `#\31 a` stays
+	 * `#\31 a`. A hash with the "unrestricted" flag may start with a digit or
+	 * `-`, so `#1a` stays `#1a`.
+	 *
+	 * > The unit of a <dimension-token> may need escaping
+	 * > to disambiguate with scientific notation.
+	 *
+	 * A unit that starts with `e`, an optional `-`, and a digit has the `e`
+	 * escaped, so the unit `e3` is written `1\65 3`, not `1e3`.
+	 *
+	 * > For any consecutive pair of tokens,
+	 * > if the first token shows up in the row headings of the following table,
+	 * > and the second token shows up in the column headings,
+	 * > and there’s a ✗ in the cell denoted by the intersection of the chosen row and column,
+	 * > the pair of tokens must be serialized with a comment between them.
+	 * >
+	 * > Single characters in the row and column headings represent a <delim-token> with that value,
+	 * > except for "(",
+	 * > which represents a (-token.
+	 *
+	 *     ┌────────────┬───────┬──────────┬─────┬─────────┬───┬────────┬────────────┬───────────┬─────┬───┬───┬───┐
+	 *     │            │ ident │ function │ url │ bad url │ - │ number │ percentage │ dimension │ CDC │ ( │ * │ % │
+	 *     ├────────────┼───────┼──────────┼─────┼─────────┼───┼────────┼────────────┼───────────┼─────┼───┼───┼───┤
+	 *     │ ident      │   ✗   │    ✗     │  ✗  │    ✗    │ ✗ │   ✗    │     ✗      │     ✗     │  ✗  │ ✗ │   │   │
+	 *     │ at-keyword │   ✗   │    ✗     │  ✗  │    ✗    │ ✗ │   ✗    │     ✗      │     ✗     │  ✗  │   │   │   │
+	 *     │ hash       │   ✗   │    ✗     │  ✗  │    ✗    │ ✗ │   ✗    │     ✗      │     ✗     │  ✗  │   │   │   │
+	 *     │ dimension  │   ✗   │    ✗     │  ✗  │    ✗    │ ✗ │   ✗    │     ✗      │     ✗     │  ✗  │   │   │   │
+	 *     │ #          │   ✗   │    ✗     │  ✗  │    ✗    │ ✗ │   ✗    │     ✗      │     ✗     │  ✗  │   │   │   │
+	 *     │ -          │   ✗   │    ✗     │  ✗  │    ✗    │ ✗ │   ✗    │     ✗      │     ✗     │  ✗  │   │   │   │
+	 *     │ number     │   ✗   │    ✗     │  ✗  │    ✗    │   │   ✗    │     ✗      │     ✗     │  ✗  │   │   │ ✗ │
+	 *     │ @          │   ✗   │    ✗     │  ✗  │    ✗    │ ✗ │        │            │           │  ✗  │   │   │   │
+	 *     │ .          │       │          │     │         │   │   ✗    │     ✗      │     ✗     │     │   │   │   │
+	 *     │ +          │       │          │     │         │   │   ✗    │     ✗      │     ✗     │     │   │   │   │
+	 *     │ /          │       │          │     │         │   │        │            │           │     │   │ ✗ │   │
+	 *     └────────────┴───────┴──────────┴─────┴─────────┴───┴────────┴────────────┴───────────┴─────┴───┴───┴───┘
+	 *
+	 * Comments are not preserved, so an empty CSS comment is written between
+	 * the tokens of a marked pair when no whitespace is between them.
+	 *
+	 * The table compares token types in pairs, so it misses two sequences that
+	 * the tokenizer reads as a CDO or CDC token: `<`, `!` and a token that
+	 * starts with `--`, which spell `<!--`, and an ident `--` followed by `>`,
+	 * which spell `-->`. An empty CSS comment is written before the last token
+	 * of each.
+	 *
+	 * Bad-string and bad-url tokens have no value. A bad string is written as
+	 * a quote followed by a newline, where the tokenizer ends one; a bad url is
+	 * written as `url(()`. Both re-tokenize as the same bad token. If a later
+	 * step replaces the newline after a bad string with a space, the quote
+	 * starts a string that includes the text after it.
+	 *
+	 * Strings and urls cut off by the end of the input are written closed.
+	 * Blocks still open at the end are closed in reverse order, so `a(b[c` is
+	 * written `a(b[c])`.
+	 *
+	 * Example:
+	 *
+	 * ```php interactive
+	 * $processor = new WP_CSS_Token_Processor( 'url( a&b ) calc(1px  +  2px' );
+	 * $tokens    = array();
+	 * while ( $processor->next_token() ) {
+	 *     $tokens[] = $processor->get_token();
+	 * }
+	 * echo WP_CSS_Token_Serializer::serialize( $tokens );
+	 * // Outputs: "url(a\26 b) calc(1px + 2px)"
+	 * ```
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#serialization
+	 *
+	 * @since 7.3.0
+	 *
+	 * @param iterable<WP_CSS_Token> $tokens Tokens read by WP_CSS_Token_Processor::get_token().
+	 * @return string CSS text.
+	 */
+	public static function serialize( iterable $tokens ): string {
+		$output  = '';
+		$closers = array();
+
+		// Pair key of the last token written, or the whitespace type after a space.
+		$last = null;
+
+		// Text of the last two tokens written, or a space after whitespace.
+		$last_text        = '';
+		$before_last_text = '';
+
+		foreach ( $tokens as $token ) {
+			$type = $token->get_type();
+
+			if ( WP_CSS_Token_Processor::TOKEN_COMMENT === $type ) {
+				continue;
+			}
+
+			if ( WP_CSS_Token_Processor::TOKEN_WHITESPACE === $type ) {
+				if ( WP_CSS_Token_Processor::TOKEN_WHITESPACE !== $last ) {
+					$output          .= ' ';
+					$last             = WP_CSS_Token_Processor::TOKEN_WHITESPACE;
+					$before_last_text = $last_text;
+					$last_text        = ' ';
+				}
+				continue;
+			}
+
+			$key  = WP_CSS_Token_Processor::TOKEN_DELIM === $type ? $token->get_value() : $type;
+			$text = self::serialize_token( $token );
+
+			if (
+				( null !== $last && isset( self::MARKED_PAIRS[ $last ] ) && in_array( $key, self::MARKED_PAIRS[ $last ], true ) ) ||
+				// The table misses `<`, `!`, `--x`, which reads as `<!--`, and `--`, `>`, which reads as `-->`.
+				( '<' === $before_last_text && '!' === $last_text && 0 === strncmp( $text, '--', 2 ) ) ||
+				( '--' === $last_text && '>' === $text )
+			) {
+				$output .= '/**/';
+			}
+
+			$output          .= $text;
+			$last             = $key;
+			$before_last_text = $last_text;
+			$last_text        = $text;
+
+			if ( isset( self::BLOCK_CLOSERS[ $type ] ) ) {
+				$closers[] = self::BLOCK_CLOSERS[ $type ];
+			} elseif ( end( $closers ) === $type ) {
+				array_pop( $closers );
+			}
+		}
+
+		while ( array() !== $closers ) {
+			$output .= self::FIXED_TEXT[ array_pop( $closers ) ];
+		}
+
+		return $output;
+	}
+
+	/**
+	 * Serializes one token other than whitespace or a comment.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @param WP_CSS_Token $token Token.
+	 * @return string CSS text.
+	 */
+	private static function serialize_token( WP_CSS_Token $token ): string {
+		$value = $token->get_value();
+
+		switch ( $token->get_type() ) {
+			case WP_CSS_Token_Processor::TOKEN_IDENT:
+				return self::escape_ident( $value );
+
+			case WP_CSS_Token_Processor::TOKEN_FUNCTION:
+				return self::escape_ident( $value ) . '(';
+
+			case WP_CSS_Token_Processor::TOKEN_AT_KEYWORD:
+				return '@' . self::escape_ident( $value );
+
+			case WP_CSS_Token_Processor::TOKEN_HASH:
+				return WP_CSS_Token_Processor::HASH_TOKEN_ID === $token->get_flag()
+					? '#' . self::escape_ident( $value )
+					: '#' . self::escape_name( $value );
+
+			case WP_CSS_Token_Processor::TOKEN_STRING:
+				return self::escape_string( $value );
+
+			case WP_CSS_Token_Processor::TOKEN_URL:
+				return self::escape_url( $value );
+
+			case WP_CSS_Token_Processor::TOKEN_NUMBER:
+				return $value;
+
+			case WP_CSS_Token_Processor::TOKEN_PERCENTAGE:
+				return $value . '%';
+
+			case WP_CSS_Token_Processor::TOKEN_DIMENSION:
+				$unit = self::escape_ident( $token->get_unit() );
+				// A unit that starts with `e`, an optional `-`, and a digit would read as an exponent.
+				if ( 1 === preg_match( '/^[eE]-?[0-9]/', $unit ) ) {
+					$unit = sprintf( '\\%x ', ord( $unit[0] ) ) . substr( $unit, 1 );
+				}
+				return $value . $unit;
+
+			case WP_CSS_Token_Processor::TOKEN_DELIM:
+				return '\\' === $value ? "\\\n" : $value;
+
+			default:
+				return self::FIXED_TEXT[ $token->get_type() ];
+		}
+	}
+
+	/**
+	 * Escapes a decoded value as identifier text.
+	 *
+	 * Characters not valid in CSS identifiers are hex-escaped, as are the
+	 * characters escape_string() escapes for HTML and CSS.
+	 *
+	 * An empty value returns an empty string. Callers that require an ident
+	 * token must reject an empty value.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#escaping
+	 * @link https://www.w3.org/TR/css-syntax-3/#would-start-an-identifier
+	 *
+	 * @since 7.3.0
+	 * @access private
+	 * @ignore
+	 *
+	 * @param string $value Decoded value.
+	 * @return string Identifier text.
+	 */
+	public static function escape_ident( string $value ): string {
+		// A lone `-` cannot start an identifier.
+		if ( '-' === $value ) {
+			return '\\2d ';
+		}
+
+		// Neither can a digit or a `-` followed by a digit, so the digit is escaped.
+		$digit_at = ( isset( $value[0] ) && '-' === $value[0] ) ? 1 : 0;
+		if ( isset( $value[ $digit_at ] ) && $value[ $digit_at ] >= '0' && $value[ $digit_at ] <= '9' ) {
+			return substr( $value, 0, $digit_at ) . sprintf( '\\%x ', ord( $value[ $digit_at ] ) ) . self::escape_name( substr( $value, $digit_at + 1 ) );
+		}
+
+		return self::escape_name( $value );
+	}
+
+	/**
+	 * Escapes a decoded value as a quoted string.
+	 *
+	 * Quotes, `\` and the control characters U+0001 to U+001F and U+007F are
+	 * hex-escaped. So are `< > & , ; { }`, which may be problematic in HTML or
+	 * for rudimentary CSS processors. The string reads back as the same value,
+	 * except that NULL becomes U+FFFD.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#escaping
+	 * @link https://drafts.csswg.org/cssom/#serialize-a-string
+	 *
+	 * @since 7.3.0
+	 * @access private
+	 * @ignore
+	 *
+	 * @see WP_CSS_Builder::string()
+	 *
+	 * @param string $value Decoded value.
+	 * @return string Quoted string text.
+	 */
+	public static function escape_string( string $value ): string {
+		$value  = wp_scrub_utf8( $value );
+		$result = '';
+		$length = strlen( $value );
+
+		for ( $i = 0; $i < $length; $i++ ) {
+			$byte = ord( $value[ $i ] );
+
+			// CSS cannot represent NULL; preprocessing replaces it with U+FFFD.
+			if ( 0x00 === $byte ) {
+				$result .= "\u{FFFD}";
+				continue;
+			}
+
+			if (
+				$byte < 0x20 ||
+				0x7F === $byte ||
+				false !== strpos( '"\'\\<>&,;{}', $value[ $i ] )
+			) {
+				$result .= sprintf( '\\%x ', $byte );
+				continue;
+			}
+
+			$result .= $value[ $i ];
+		}
+
+		return "\"{$result}\"";
+	}
+
+	/**
+	 * Escapes every code point that cannot appear in an identifier.
+	 *
+	 * Letters, digits, `-`, `_` and the non-ASCII ident code points are
+	 * written as they are; every other code point is hex-escaped. Unlike
+	 * escape_ident(), a leading digit or `-` is not escaped, as the name of
+	 * a hash token with the "unrestricted" flag requires.
+	 *
+	 * The tokenizer reads every code point above U+007F as an identifier code
+	 * point, as browsers do. CSS Syntax allows fewer, so the others are escaped
+	 * and the output reads the same under both rules.
+	 *
+	 * @link https://drafts.csswg.org/css-syntax-3/#non-ascii-ident-code-point
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @param string $value Decoded name.
+	 * @return string Escaped name.
+	 */
+	private static function escape_name( string $value ): string {
+		$value  = wp_scrub_utf8( $value );
+		$result = '';
+		$length = strlen( $value );
+
+		for ( $i = 0; $i < $length; $i++ ) {
+			$byte = ord( $value[ $i ] );
+
+			if ( 0x00 === $byte ) {
+				$result .= "\u{FFFD}";
+				continue;
+			}
+
+			if ( $byte >= 0x80 ) {
+				// The value is valid UTF-8, so the leading byte gives the sequence length.
+				$sequence_length = $byte >= 0xF0 ? 4 : ( $byte >= 0xE0 ? 3 : 2 );
+				$code_point      = $byte & ( 0xFF >> ( $sequence_length + 1 ) );
+				for ( $j = 1; $j < $sequence_length; $j++ ) {
+					$code_point = ( $code_point << 6 ) | ( ord( $value[ $i + $j ] ) & 0x3F );
+				}
+
+				$result .= self::is_non_ascii_ident_code_point( $code_point )
+					? substr( $value, $i, $sequence_length )
+					: sprintf( '\\%x ', $code_point );
+				$i      += $sequence_length - 1;
+				continue;
+			}
+
+			if (
+				( $byte >= 0x30 && $byte <= 0x39 ) || // 0-9
+				( $byte >= 0x41 && $byte <= 0x5A ) || // A-Z
+				( $byte >= 0x61 && $byte <= 0x7A ) || // a-z
+				0x5F === $byte || // _
+				0x2D === $byte // -
+			) {
+				$result .= $value[ $i ];
+				continue;
+			}
+
+			$result .= sprintf( '\\%x ', $byte );
+		}
+
+		return $result;
+	}
+
+	/**
+	 * Reports whether a code point above U+007F is a non-ASCII ident code point.
+	 *
+	 * @link https://drafts.csswg.org/css-syntax-3/#non-ascii-ident-code-point
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @param int $code_point Code point above U+007F.
+	 * @return bool Whether the code point may appear unescaped in an identifier.
+	 */
+	private static function is_non_ascii_ident_code_point( int $code_point ): bool {
+		return (
+			0xB7 === $code_point ||
+			( $code_point >= 0xC0 && $code_point <= 0xD6 ) ||
+			( $code_point >= 0xD8 && $code_point <= 0xF6 ) ||
+			( $code_point >= 0xF8 && $code_point <= 0x37D ) ||
+			( $code_point >= 0x37F && $code_point <= 0x1FFF ) ||
+			0x200C === $code_point ||
+			0x200D === $code_point ||
+			0x203F === $code_point ||
+			0x2040 === $code_point ||
+			( $code_point >= 0x2070 && $code_point <= 0x218F ) ||
+			( $code_point >= 0x2C00 && $code_point <= 0x2FEF ) ||
+			( $code_point >= 0x3001 && $code_point <= 0xD7FF ) ||
+			( $code_point >= 0xF900 && $code_point <= 0xFDCF ) ||
+			( $code_point >= 0xFDF0 && $code_point <= 0xFFFD ) ||
+			$code_point >= 0x10000
+		);
+	}
+
+	/**
+	 * Escapes a decoded value as an unquoted url.
+	 *
+	 * The code points an unquoted url cannot contain are hex-escaped: quotes,
+	 * parentheses, `\`, whitespace and non-printable code points. So are the
+	 * code points escape_string() escapes for HTML and CSS: `< > & , ; { }`.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#consume-url-token
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @param string $value Decoded value.
+	 * @return string Url text, including `url(` and `)`.
+	 */
+	private static function escape_url( string $value ): string {
+		$value  = wp_scrub_utf8( $value );
+		$result = '';
+		$length = strlen( $value );
+
+		for ( $i = 0; $i < $length; $i++ ) {
+			$byte = ord( $value[ $i ] );
+
+			if ( 0x00 === $byte ) {
+				$result .= "\u{FFFD}";
+				continue;
+			}
+
+			if (
+				$byte <= 0x20 ||
+				0x7F === $byte ||
+				false !== strpos( '"\'()\\<>&,;{}', $value[ $i ] )
+			) {
+				$result .= sprintf( '\\%x ', $byte );
+				continue;
+			}
+
+			$result .= $value[ $i ];
+		}
+
+		return "url({$result})";
+	}
+}
diff --git a/src/wp-includes/css-api/class-wp-css-token.php b/src/wp-includes/css-api/class-wp-css-token.php
new file mode 100644
index 0000000000000..55af708415637
--- /dev/null
+++ b/src/wp-includes/css-api/class-wp-css-token.php
@@ -0,0 +1,364 @@
+<?php
+/**
+ * CSS API: WP_CSS_Token class
+ *
+ * @package WordPress
+ * @subpackage CSS-API
+ * @since 7.3.0
+ */
+
+/**
+ * A token read by WP_CSS_Token_Processor.
+ *
+ * A token keeps its values after the processor moves to the next token, so
+ * callers can collect tokens and read them later. The value is decoded from
+ * the CSS source on the first call to get_value().
+ *
+ * Example:
+ *
+ * ```php interactive
+ * $processor = new WP_CSS_Token_Processor( 'font-family: "Exo\20 2"' );
+ * $tokens    = array();
+ * while ( $processor->next_token() ) {
+ *     $tokens[] = $processor->get_token();
+ * }
+ * echo $tokens[3]->get_type() . "\n";
+ * echo $tokens[3]->get_value();
+ * // Outputs:
+ * // string-token
+ * // Exo 2
+ * ```
+ *
+ * @since 7.3.0
+ *
+ * @see WP_CSS_Token_Processor::get_token()
+ */
+final class WP_CSS_Token {
+	/**
+	 * CSS source the offsets index.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var string
+	 */
+	private $css;
+
+	/**
+	 * Token type.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var string
+	 * @phpstan-var WP_CSS_Token_Processor::TOKEN_*
+	 */
+	private $type;
+
+	/**
+	 * Byte offset at which the token starts.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var int
+	 */
+	private $start;
+
+	/**
+	 * Byte length of the token.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var int
+	 */
+	private $length;
+
+	/**
+	 * Type flag of a hash, number or dimension token.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var string|null
+	 * @phpstan-var 'id'|'unrestricted'|'integer'|'number'|null
+	 */
+	private $flag;
+
+	/**
+	 * Decoded unit of a dimension token.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var string|null
+	 */
+	private $unit;
+
+	/**
+	 * Byte offset at which the value of a string, url or comment token starts.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var int|null
+	 */
+	private $value_start;
+
+	/**
+	 * Byte length of the value of a string, url or comment token.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var int|null
+	 */
+	private $value_length;
+
+	/**
+	 * Whether the token ended at its closing delimiter.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var bool
+	 */
+	private $is_terminated;
+
+	/**
+	 * Decoded value, or false before the first call to get_value().
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @var string|null|false
+	 */
+	private $value = false;
+
+	/**
+	 * Constructor.
+	 *
+	 * Use WP_CSS_Token_Processor::get_token() to create tokens.
+	 *
+	 * @since 7.3.0
+	 * @access private
+	 * @ignore
+	 *
+	 * @param string      $css           CSS source the offsets index.
+	 * @param string      $type          Token type, one of the WP_CSS_Token_Processor::TOKEN_* constants.
+	 * @param int         $start         Byte offset at which the token starts.
+	 * @param int         $length        Byte length of the token.
+	 * @param string|null $flag          Type flag of a hash, number or dimension token.
+	 * @param string|null $unit          Decoded unit of a dimension token.
+	 * @param int|null    $value_start   Byte offset at which the value of a string, url or comment token starts.
+	 * @param int|null    $value_length  Byte length of the value of a string, url or comment token.
+	 * @param bool        $is_terminated Whether the token ended at its closing delimiter.
+	 */
+	public function __construct(
+		string $css,
+		string $type,
+		int $start,
+		int $length,
+		?string $flag,
+		?string $unit,
+		?int $value_start,
+		?int $value_length,
+		bool $is_terminated
+	) {
+		$this->css           = $css;
+		$this->type          = $type;
+		$this->start         = $start;
+		$this->length        = $length;
+		$this->flag          = $flag;
+		$this->unit          = $unit;
+		$this->value_start   = $value_start;
+		$this->value_length  = $value_length;
+		$this->is_terminated = $is_terminated;
+	}
+
+	/**
+	 * Gets the token type.
+	 *
+	 * @since 7.3.0
+	 *
+	 * @return string One of the WP_CSS_Token_Processor::TOKEN_* constants.
+	 * @phpstan-return WP_CSS_Token_Processor::TOKEN_*
+	 */
+	public function get_type(): string {
+		return $this->type;
+	}
+
+	/**
+	 * Gets the type flag.
+	 *
+	 * Hash tokens have an "id" or "unrestricted" flag. Number and dimension
+	 * tokens have an "integer" or "number" flag. Other tokens have none.
+	 *
+	 * @since 7.3.0
+	 *
+	 * @return string|null The type flag, or null.
+	 * @phpstan-return 'id'|'unrestricted'|'integer'|'number'|null
+	 */
+	public function get_flag(): ?string {
+		return $this->flag;
+	}
+
+	/**
+	 * Gets the decoded value.
+	 *
+	 * The value is the token's text after input preprocessing and escape
+	 * decoding, without its delimiters:
+	 *
+	 * - ident, delim: the whole token.
+	 * - function: the name, without `(`.
+	 * - at-keyword, hash: the name, without `@` or `#`.
+	 * - string, url: the contents, without quotes or `url(` and `)`.
+	 * - comment: the text between `/*` and `*` `/`. Comments contain no
+	 *   escapes, so only preprocessing applies.
+	 * - number, percentage, dimension: the number as written in the source,
+	 *   without `%` or the unit. CSS Syntax 3 parses it as a number; this
+	 *   method keeps the text.
+	 * - Every other type, including bad-string and bad-url: null.
+	 *
+	 * The value is decoded on the first call and kept for later calls.
+	 *
+	 * Example:
+	 *
+	 * ```php interactive
+	 * $processor = new WP_CSS_Token_Processor( '"a\\62 c"' );
+	 * $processor->next_token();
+	 * echo $processor->get_token()->get_value();
+	 * // Outputs: abc
+	 * ```
+	 *
+	 * @since 7.3.0
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#tokenization
+	 *
+	 * @return string|null The decoded value, or null for token types without a value.
+	 */
+	public function get_value(): ?string {
+		if ( false === $this->value ) {
+			$this->value = $this->decode_value();
+		}
+
+		return $this->value;
+	}
+
+	/**
+	 * Gets the decoded unit of a dimension token.
+	 *
+	 * @since 7.3.0
+	 *
+	 * @return string|null The unit, or null for other token types.
+	 */
+	public function get_unit(): ?string {
+		return $this->unit;
+	}
+
+	/**
+	 * Gets the byte offset at which the token starts in the CSS source.
+	 *
+	 * @since 7.3.0
+	 *
+	 * @return int Byte offset.
+	 */
+	public function get_start(): int {
+		return $this->start;
+	}
+
+	/**
+	 * Gets the byte length of the token in the CSS source.
+	 *
+	 * @since 7.3.0
+	 *
+	 * @return int Byte length.
+	 */
+	public function get_length(): int {
+		return $this->length;
+	}
+
+	/**
+	 * Reports whether the token ended at its closing delimiter.
+	 *
+	 * Comment, string, url and bad-url tokens have a closing delimiter: `*` `/`,
+	 * the matching quote, or `)`. When the input ends before the delimiter,
+	 * the tokenizer still returns the token, and this method returns false.
+	 * It returns true for every other token type, which have no closing
+	 * delimiter.
+	 *
+	 * Example:
+	 *
+	 * ```php interactive
+	 * $processor = new WP_CSS_Token_Processor( '"abc' );
+	 * $processor->next_token();
+	 * $token = $processor->get_token();
+	 * echo $token->get_type() . "\n";
+	 * var_dump( $token->is_terminated() );
+	 * // Outputs:
+	 * // string-token
+	 * // bool(false)
+	 * ```
+	 *
+	 * @since 7.3.0
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#consume-comment
+	 * @link https://www.w3.org/TR/css-syntax-3/#consume-string-token
+	 * @link https://www.w3.org/TR/css-syntax-3/#consume-url-token
+	 *
+	 * @return bool Whether the token ended at its closing delimiter.
+	 */
+	public function is_terminated(): bool {
+		return $this->is_terminated;
+	}
+
+	/**
+	 * Decodes the value from the CSS source.
+	 *
+	 * @since 7.3.0
+	 * @ignore
+	 *
+	 * @return string|null The decoded value, or null for token types without a value.
+	 */
+	private function decode_value(): ?string {
+		switch ( $this->type ) {
+			case WP_CSS_Token_Processor::TOKEN_HASH:
+			case WP_CSS_Token_Processor::TOKEN_AT_KEYWORD:
+				// The value starts after the `#` or `@`.
+				return WP_CSS_Token_Processor::decode_range( $this->css, $this->start + 1, $this->length - 1 );
+
+			case WP_CSS_Token_Processor::TOKEN_FUNCTION:
+				// The value ends before the `(`.
+				return WP_CSS_Token_Processor::decode_range( $this->css, $this->start, $this->length - 1 );
+
+			case WP_CSS_Token_Processor::TOKEN_IDENT:
+			case WP_CSS_Token_Processor::TOKEN_DELIM:
+				return WP_CSS_Token_Processor::decode_range( $this->css, $this->start, $this->length );
+
+			case WP_CSS_Token_Processor::TOKEN_STRING:
+				return WP_CSS_Token_Processor::decode_range( $this->css, $this->value_start, $this->value_length, true );
+
+			case WP_CSS_Token_Processor::TOKEN_URL:
+				return WP_CSS_Token_Processor::decode_range( $this->css, $this->value_start, $this->value_length );
+
+			case WP_CSS_Token_Processor::TOKEN_COMMENT:
+				return WP_CSS_Token_Processor::preprocess_range( $this->css, $this->value_start, $this->value_length );
+
+			case WP_CSS_Token_Processor::TOKEN_NUMBER:
+				// Numbers are ASCII and have no escapes.
+				return substr( $this->css, $this->start, $this->length );
+
+			case WP_CSS_Token_Processor::TOKEN_PERCENTAGE:
+				// The value ends before the `%`.
+				return substr( $this->css, $this->start, $this->length - 1 );
+
+			case WP_CSS_Token_Processor::TOKEN_DIMENSION:
+				// The value ends before the unit.
+				return substr( WP_CSS_Token_Processor::decode_range( $this->css, $this->start, $this->length ), 0, -strlen( $this->unit ) );
+
+			default:
+				return null;
+		}
+	}
+}
diff --git a/src/wp-settings.php b/src/wp-settings.php
index 92f9456aa02ca..366a7a469b8dd 100644
--- a/src/wp-settings.php
+++ b/src/wp-settings.php
@@ -289,6 +289,10 @@
 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 . '/css-api/class-wp-css-token.php';
+require ABSPATH . WPINC . '/css-api/class-wp-css-token-processor.php';
+require ABSPATH . WPINC . '/css-api/class-wp-css-token-serializer.php';
+require ABSPATH . WPINC . '/css-api/class-wp-css-builder.php';
 require ABSPATH . WPINC . '/class-wp-block-processor.php';
 require ABSPATH . WPINC . '/class-wp-http.php';
 require ABSPATH . WPINC . '/class-wp-http-streams.php';
diff --git a/tests/phpunit/data/css-api/LICENSE b/tests/phpunit/data/css-api/LICENSE
new file mode 100644
index 0000000000000..13b1ea364b27e
--- /dev/null
+++ b/tests/phpunit/data/css-api/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Romain Menke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/tests/phpunit/data/css-api/README.md b/tests/phpunit/data/css-api/README.md
new file mode 100644
index 0000000000000..93da314e4ef01
--- /dev/null
+++ b/tests/phpunit/data/css-api/README.md
@@ -0,0 +1,42 @@
+# CSS tokenizer test corpus
+
+This directory contains a third-party test corpus used for testing the WordPress CSS API tokenizer.
+
+`css-test-cases.json` derives from the npm package
+[`@rmenke/css-tokenizer-tests`](https://www.npmjs.com/package/@rmenke/css-tokenizer-tests)
+by Romain Menke, MIT licensed (see `LICENSE`). The package source is on GitHub at
+[romainmenke/css-tokenizer-tests](https://github.com/romainmenke/css-tokenizer-tests).
+
+The 185 cases match version 1.3.0 of the package, whose test content is identical to
+version 1.2.0. Version 1.4.0 adds 102 cases that are not in this file.
+
+## Transform
+
+The upstream corpus maps a case name to `{ css, tokens }`. Each upstream token has
+`type`, `raw`, `startIndex`, `endIndex` and `structured`. This file keeps the case names,
+`css`, `type` and `raw` unchanged and transforms the rest:
+
+- `startIndex` and `endIndex` are byte offsets into the UTF-8 source. Upstream uses
+  JavaScript string indexes (UTF-16 code units).
+- `value` is `structured.value` flattened onto the token. Numeric values are the
+  number's source text as a string (`"10e2"`, not `1000`); for dimension and
+  percentage tokens the unit or `%` is removed. A comment token, which has no
+  structured data upstream, has the text between its delimiters after input
+  preprocessing. Other tokens without structured data have `value: null`.
+- `unit` is `structured.unit`, present on dimension tokens only.
+- `numberType` is `structured.type` on number and dimension tokens. The upstream
+  `structured.type` of hash tokens (`id` or `unrestricted`) and `signCharacter` are
+  not kept.
+
+Three cases carry WordPress's token expectations where the upstream package contradicts
+CSS Syntax Level 3: `tests/ident/0007` (`-§`), `tests/ident/0008` (`-×`) and
+`tests/fuzz/b69ece36-057f-4450-9423-a1661787bce6`. In each, a non-ASCII code point or
+U+0000 (which preprocessing replaces with U+FFFD) is an ident code point, so the
+hyphen or identifier before it continues as one ident token. Upstream splits them into
+delim tokens.
+
+## Updating
+
+There is no conversion script. To update, take `testCorpus` from the package's
+`index.cjs`, apply the transform above, set `normalized` for each token per the
+specification, and update the version noted in this README.
diff --git a/tests/phpunit/data/css-api/css-test-cases.json b/tests/phpunit/data/css-api/css-test-cases.json
new file mode 100644
index 0000000000000..30e0dc8cdcccd
--- /dev/null
+++ b/tests/phpunit/data/css-api/css-test-cases.json
@@ -0,0 +1,4491 @@
+{
+	"tests/at-keyword/0001": {
+		"css": "@foo\n",
+		"tokens": [
+			{
+				"type": "at-keyword-token",
+				"raw": "@foo",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": "foo"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 4,
+				"endIndex": 5,
+				"value": null
+			}
+		]
+	},
+	"tests/at-keyword/0002": {
+		"css": "@--\n",
+		"tokens": [
+			{
+				"type": "at-keyword-token",
+				"raw": "@--",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "--"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/at-keyword/0003": {
+		"css": "@-1\n",
+		"tokens": [
+			{
+				"type": "delim-token",
+				"raw": "@",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "@"
+			},
+			{
+				"type": "number-token",
+				"raw": "-1",
+				"startIndex": 1,
+				"endIndex": 3,
+				"value": "-1",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/at-keyword/0004": {
+		"css": "@--1\n",
+		"tokens": [
+			{
+				"type": "at-keyword-token",
+				"raw": "@--1",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": "--1"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 4,
+				"endIndex": 5,
+				"value": null
+			}
+		]
+	},
+	"tests/at-keyword/0005": {
+		"css": "@\\@\n",
+		"tokens": [
+			{
+				"type": "at-keyword-token",
+				"raw": "@\\@",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "@"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/at-keyword/0006": {
+		"css": "@_\n",
+		"tokens": [
+			{
+				"type": "at-keyword-token",
+				"raw": "@_",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "_"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/at-keyword/0007": {
+		"css": "@\n",
+		"tokens": [
+			{
+				"type": "delim-token",
+				"raw": "@",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "@"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": null
+			}
+		]
+	},
+	"tests/at-keyword/0008": {
+		"css": "pvA3@\\\neBnP\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "pvA3",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": "pvA3"
+			},
+			{
+				"type": "delim-token",
+				"raw": "@",
+				"startIndex": 4,
+				"endIndex": 5,
+				"value": "@"
+			},
+			{
+				"type": "delim-token",
+				"raw": "\\",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": "\\"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 6,
+				"endIndex": 7,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "eBnP",
+				"startIndex": 7,
+				"endIndex": 11,
+				"value": "eBnP"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 11,
+				"endIndex": 12,
+				"value": null
+			}
+		]
+	},
+	"tests/at-keyword/0009": {
+		"css": "@aa𐀀\n",
+		"tokens": [
+			{
+				"type": "at-keyword-token",
+				"raw": "@aa𐀀",
+				"startIndex": 0,
+				"endIndex": 7,
+				"value": "aa𐀀"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 7,
+				"endIndex": 8,
+				"value": null
+			}
+		]
+	},
+	"tests/bad-string/0001": {
+		"css": "\"foo\n\"\n",
+		"tokens": [
+			{
+				"type": "bad-string-token",
+				"raw": "\"foo",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 4,
+				"endIndex": 5,
+				"value": null
+			},
+			{
+				"type": "bad-string-token",
+				"raw": "\"",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 6,
+				"endIndex": 7,
+				"value": null
+			}
+		]
+	},
+	"tests/bad-string/0002": {
+		"css": "\"foo\\\n\"\n",
+		"tokens": [
+			{
+				"type": "string-token",
+				"raw": "\"foo\\\n\"",
+				"startIndex": 0,
+				"endIndex": 7,
+				"value": "foo"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 7,
+				"endIndex": 8,
+				"value": null
+			}
+		]
+	},
+	"tests/bad-string/0003": {
+		"css": "\"foo\r\n\"\n",
+		"tokens": [
+			{
+				"type": "bad-string-token",
+				"raw": "\"foo",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\r\n",
+				"startIndex": 4,
+				"endIndex": 6,
+				"value": null
+			},
+			{
+				"type": "bad-string-token",
+				"raw": "\"",
+				"startIndex": 6,
+				"endIndex": 7,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 7,
+				"endIndex": 8,
+				"value": null
+			}
+		]
+	},
+	"tests/bad-string/0004": {
+		"css": "\"foo\\\r\n\"\n",
+		"tokens": [
+			{
+				"type": "string-token",
+				"raw": "\"foo\\\r\n\"",
+				"startIndex": 0,
+				"endIndex": 8,
+				"value": "foo"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 8,
+				"endIndex": 9,
+				"value": null
+			}
+		]
+	},
+	"tests/bad-string/0005": {
+		"css": "\"aa𐀀\n",
+		"tokens": [
+			{
+				"type": "bad-string-token",
+				"raw": "\"aa𐀀",
+				"startIndex": 0,
+				"endIndex": 7,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 7,
+				"endIndex": 8,
+				"value": null
+			}
+		]
+	},
+	"tests/bad-url/0001": {
+		"css": "url(\n",
+		"tokens": [
+			{
+				"type": "url-token",
+				"raw": "url(\n",
+				"startIndex": 0,
+				"endIndex": 5,
+				"value": ""
+			}
+		]
+	},
+	"tests/bad-url/0002": {
+		"css": "url( a\n",
+		"tokens": [
+			{
+				"type": "url-token",
+				"raw": "url( a\n",
+				"startIndex": 0,
+				"endIndex": 7,
+				"value": "a"
+			}
+		]
+	},
+	"tests/bad-url/0003": {
+		"css": "url( a a\n",
+		"tokens": [
+			{
+				"type": "bad-url-token",
+				"raw": "url( a a\n",
+				"startIndex": 0,
+				"endIndex": 9,
+				"value": null
+			}
+		]
+	},
+	"tests/bad-url/0004": {
+		"css": "url( a a)\n",
+		"tokens": [
+			{
+				"type": "bad-url-token",
+				"raw": "url( a a)",
+				"startIndex": 0,
+				"endIndex": 9,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 9,
+				"endIndex": 10,
+				"value": null
+			}
+		]
+	},
+	"tests/bad-url/0005": {
+		"css": "url( a a\\)\n",
+		"tokens": [
+			{
+				"type": "bad-url-token",
+				"raw": "url( a a\\)\n",
+				"startIndex": 0,
+				"endIndex": 11,
+				"value": null
+			}
+		]
+	},
+	"tests/bad-url/0006": {
+		"css": "url( \\\n",
+		"tokens": [
+			{
+				"type": "bad-url-token",
+				"raw": "url( \\\n",
+				"startIndex": 0,
+				"endIndex": 7,
+				"value": null
+			}
+		]
+	},
+	"tests/bad-url/0007": {
+		"css": "url(a'')\n",
+		"tokens": [
+			{
+				"type": "bad-url-token",
+				"raw": "url(a'')",
+				"startIndex": 0,
+				"endIndex": 8,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 8,
+				"endIndex": 9,
+				"value": null
+			}
+		]
+	},
+	"tests/bad-url/0008": {
+		"css": "url(a\")\n",
+		"tokens": [
+			{
+				"type": "bad-url-token",
+				"raw": "url(a\")",
+				"startIndex": 0,
+				"endIndex": 7,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 7,
+				"endIndex": 8,
+				"value": null
+			}
+		]
+	},
+	"tests/colon/0001": {
+		"css": ":\n",
+		"tokens": [
+			{
+				"type": "colon-token",
+				"raw": ":",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": null
+			}
+		]
+	},
+	"tests/comma/0001": {
+		"css": ",\n",
+		"tokens": [
+			{
+				"type": "comma-token",
+				"raw": ",",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": null
+			}
+		]
+	},
+	"tests/comment/0001": {
+		"css": "/* a comment */\n",
+		"tokens": [
+			{
+				"type": "comment",
+				"raw": "/* a comment */",
+				"startIndex": 0,
+				"endIndex": 15,
+				"value": " a comment "
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 15,
+				"endIndex": 16,
+				"value": null
+			}
+		]
+	},
+	"tests/comment/0002": {
+		"css": "/* a comment ",
+		"tokens": [
+			{
+				"type": "comment",
+				"raw": "/* a comment ",
+				"startIndex": 0,
+				"endIndex": 13,
+				"value": " a comment "
+			}
+		]
+	},
+	"tests/comment/0003": {
+		"css": "a/**/b\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "a",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "a"
+			},
+			{
+				"type": "comment",
+				"raw": "/**/",
+				"startIndex": 1,
+				"endIndex": 5,
+				"value": ""
+			},
+			{
+				"type": "ident-token",
+				"raw": "b",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": "b"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 6,
+				"endIndex": 7,
+				"value": null
+			}
+		]
+	},
+	"tests/comment/0004": {
+		"css": "/*\\*/*/\n",
+		"tokens": [
+			{
+				"type": "comment",
+				"raw": "/*\\*/",
+				"startIndex": 0,
+				"endIndex": 5,
+				"value": "\\"
+			},
+			{
+				"type": "delim-token",
+				"raw": "*",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": "*"
+			},
+			{
+				"type": "delim-token",
+				"raw": "/",
+				"startIndex": 6,
+				"endIndex": 7,
+				"value": "/"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 7,
+				"endIndex": 8,
+				"value": null
+			}
+		]
+	},
+	"tests/comment/0005": {
+		"css": "/* a comment *",
+		"tokens": [
+			{
+				"type": "comment",
+				"raw": "/* a comment *",
+				"startIndex": 0,
+				"endIndex": 14,
+				"value": " a comment *"
+			}
+		]
+	},
+	"tests/comment/0006": {
+		"css": "/*a𐀀*/\n",
+		"tokens": [
+			{
+				"type": "comment",
+				"raw": "/*a𐀀*/",
+				"startIndex": 0,
+				"endIndex": 9,
+				"value": "a𐀀"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 9,
+				"endIndex": 10,
+				"value": null
+			}
+		]
+	},
+	"tests/digit/0001": {
+		"css": "0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "0",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "0",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": null
+			},
+			{
+				"type": "number-token",
+				"raw": "1",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": "1",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			},
+			{
+				"type": "number-token",
+				"raw": "2",
+				"startIndex": 4,
+				"endIndex": 5,
+				"value": "2",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": null
+			},
+			{
+				"type": "number-token",
+				"raw": "3",
+				"startIndex": 6,
+				"endIndex": 7,
+				"value": "3",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 7,
+				"endIndex": 8,
+				"value": null
+			},
+			{
+				"type": "number-token",
+				"raw": "4",
+				"startIndex": 8,
+				"endIndex": 9,
+				"value": "4",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 9,
+				"endIndex": 10,
+				"value": null
+			},
+			{
+				"type": "number-token",
+				"raw": "5",
+				"startIndex": 10,
+				"endIndex": 11,
+				"value": "5",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 11,
+				"endIndex": 12,
+				"value": null
+			},
+			{
+				"type": "number-token",
+				"raw": "6",
+				"startIndex": 12,
+				"endIndex": 13,
+				"value": "6",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 13,
+				"endIndex": 14,
+				"value": null
+			},
+			{
+				"type": "number-token",
+				"raw": "7",
+				"startIndex": 14,
+				"endIndex": 15,
+				"value": "7",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 15,
+				"endIndex": 16,
+				"value": null
+			},
+			{
+				"type": "number-token",
+				"raw": "8",
+				"startIndex": 16,
+				"endIndex": 17,
+				"value": "8",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 17,
+				"endIndex": 18,
+				"value": null
+			},
+			{
+				"type": "number-token",
+				"raw": "9",
+				"startIndex": 18,
+				"endIndex": 19,
+				"value": "9",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 19,
+				"endIndex": 20,
+				"value": null
+			}
+		]
+	},
+	"tests/dimension/0001": {
+		"css": "10px\n",
+		"tokens": [
+			{
+				"type": "dimension-token",
+				"raw": "10px",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": "10",
+				"unit": "px",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 4,
+				"endIndex": 5,
+				"value": null
+			}
+		]
+	},
+	"tests/dimension/0002": {
+		"css": "10\\70 x\n",
+		"tokens": [
+			{
+				"type": "dimension-token",
+				"raw": "10\\70 x",
+				"startIndex": 0,
+				"endIndex": 7,
+				"value": "10",
+				"unit": "px",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 7,
+				"endIndex": 8,
+				"value": null
+			}
+		]
+	},
+	"tests/dimension/0003": {
+		"css": "10--custom-px\n",
+		"tokens": [
+			{
+				"type": "dimension-token",
+				"raw": "10--custom-px",
+				"startIndex": 0,
+				"endIndex": 13,
+				"value": "10",
+				"unit": "--custom-px",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 13,
+				"endIndex": 14,
+				"value": null
+			}
+		]
+	},
+	"tests/dimension/0004": {
+		"css": "10e2px\n",
+		"tokens": [
+			{
+				"type": "dimension-token",
+				"raw": "10e2px",
+				"startIndex": 0,
+				"endIndex": 6,
+				"value": "10e2",
+				"unit": "px",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 6,
+				"endIndex": 7,
+				"value": null
+			}
+		]
+	},
+	"tests/dimension/0005": {
+		"css": "10E2PX\n",
+		"tokens": [
+			{
+				"type": "dimension-token",
+				"raw": "10E2PX",
+				"startIndex": 0,
+				"endIndex": 6,
+				"value": "10E2",
+				"unit": "PX",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 6,
+				"endIndex": 7,
+				"value": null
+			}
+		]
+	},
+	"tests/dimension/0006": {
+		"css": "10\\0\n",
+		"tokens": [
+			{
+				"type": "dimension-token",
+				"raw": "10\\0\n",
+				"startIndex": 0,
+				"endIndex": 5,
+				"value": "10",
+				"unit": "�",
+				"numberType": "integer"
+			}
+		]
+	},
+	"tests/dimension/0007": {
+		"css": "10a𐀀\n",
+		"tokens": [
+			{
+				"type": "dimension-token",
+				"raw": "10a𐀀",
+				"startIndex": 0,
+				"endIndex": 7,
+				"value": "10",
+				"unit": "a𐀀",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 7,
+				"endIndex": 8,
+				"value": null
+			}
+		]
+	},
+	"tests/dimension/0008": {
+		"css": "10a\u0000",
+		"tokens": [
+			{
+				"type": "dimension-token",
+				"raw": "10a\u0000",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": "10",
+				"unit": "a�",
+				"numberType": "integer"
+			}
+		]
+	},
+	"tests/escaped-code-point/0001": {
+		"css": "\\",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "�"
+			}
+		]
+	},
+	"tests/escaped-code-point/0002": {
+		"css": "\\0",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\0",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "�"
+			}
+		]
+	},
+	"tests/escaped-code-point/0003": {
+		"css": "\\\\",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\\\",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "\\"
+			}
+		]
+	},
+	"tests/escaped-code-point/0004": {
+		"css": "\\0a b\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\0a b",
+				"startIndex": 0,
+				"endIndex": 5,
+				"value": "\nb"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": null
+			}
+		]
+	},
+	"tests/escaped-code-point/0005": {
+		"css": "\\0ab \n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\0ab ",
+				"startIndex": 0,
+				"endIndex": 5,
+				"value": "«"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": null
+			}
+		]
+	},
+	"tests/escaped-code-point/0006": {
+		"css": "\\0ab (foo)\n",
+		"tokens": [
+			{
+				"type": "function-token",
+				"raw": "\\0ab (",
+				"startIndex": 0,
+				"endIndex": 6,
+				"value": "«"
+			},
+			{
+				"type": "ident-token",
+				"raw": "foo",
+				"startIndex": 6,
+				"endIndex": 9,
+				"value": "foo"
+			},
+			{
+				"type": ")-token",
+				"raw": ")",
+				"startIndex": 9,
+				"endIndex": 10,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 10,
+				"endIndex": 11,
+				"value": null
+			}
+		]
+	},
+	"tests/escaped-code-point/0007": {
+		"css": "\\0ab  (foo)\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\0ab ",
+				"startIndex": 0,
+				"endIndex": 5,
+				"value": "«"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": " ",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": null
+			},
+			{
+				"type": "(-token",
+				"raw": "(",
+				"startIndex": 6,
+				"endIndex": 7,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "foo",
+				"startIndex": 7,
+				"endIndex": 10,
+				"value": "foo"
+			},
+			{
+				"type": ")-token",
+				"raw": ")",
+				"startIndex": 10,
+				"endIndex": 11,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 11,
+				"endIndex": 12,
+				"value": null
+			}
+		]
+	},
+	"tests/escaped-code-point/0008": {
+		"css": "\\0000ab\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\0000ab\n",
+				"startIndex": 0,
+				"endIndex": 8,
+				"value": "«"
+			}
+		]
+	},
+	"tests/escaped-code-point/0009": {
+		"css": "\\00000ab\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\00000ab",
+				"startIndex": 0,
+				"endIndex": 8,
+				"value": "\nb"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 8,
+				"endIndex": 9,
+				"value": null
+			}
+		]
+	},
+	"tests/escaped-code-point/0010": {
+		"css": "\\110000\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\110000\n",
+				"startIndex": 0,
+				"endIndex": 8,
+				"value": "�"
+			}
+		]
+	},
+	"tests/escaped-code-point/0011": {
+		"css": "\\00D800\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\00D800\n",
+				"startIndex": 0,
+				"endIndex": 8,
+				"value": "�"
+			}
+		]
+	},
+	"tests/escaped-code-point/0012": {
+		"css": "\\00DFFF\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\00DFFF\n",
+				"startIndex": 0,
+				"endIndex": 8,
+				"value": "�"
+			}
+		]
+	},
+	"tests/escaped-code-point/0013": {
+		"css": "\\\n",
+		"tokens": [
+			{
+				"type": "delim-token",
+				"raw": "\\",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "\\"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": null
+			}
+		]
+	},
+	"tests/escaped-code-point/0014": {
+		"css": "\\\u0000\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\\u0000",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "�"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/escaped-code-point/0015": {
+		"css": "\\\u0000\b\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\\u0000",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "�"
+			},
+			{
+				"type": "delim-token",
+				"raw": "\b",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": "\b"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/escaped-code-point/0016": {
+		"css": "\"a\\12\r\nb\"",
+		"tokens": [
+			{
+				"type": "string-token",
+				"raw": "\"a\\12\r\nb\"",
+				"startIndex": 0,
+				"endIndex": 9,
+				"value": "a\u0012b"
+			}
+		]
+	},
+	"tests/full-stop/0001": {
+		"css": ".\n",
+		"tokens": [
+			{
+				"type": "delim-token",
+				"raw": ".",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "."
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": null
+			}
+		]
+	},
+	"tests/full-stop/0002": {
+		"css": ".a\n",
+		"tokens": [
+			{
+				"type": "delim-token",
+				"raw": ".",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "."
+			},
+			{
+				"type": "ident-token",
+				"raw": "a",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": "a"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/full-stop/0003": {
+		"css": ".1\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": ".1",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": ".1",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/fuzz/01a166c0-ca20-43a5-9ab0-0984e4a5362b": {
+		"css": "4waPtwEEGH\\\u0000jV3zM6hh6w30N0PC 7m8KM0HcWGOPw28Gt(r19",
+		"tokens": [
+			{
+				"type": "dimension-token",
+				"raw": "4waPtwEEGH\\\u0000jV3zM6hh6w30N0PC",
+				"startIndex": 0,
+				"endIndex": 28,
+				"value": "4",
+				"unit": "waPtwEEGH�jV3zM6hh6w30N0PC",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": " ",
+				"startIndex": 28,
+				"endIndex": 29,
+				"value": null
+			},
+			{
+				"type": "dimension-token",
+				"raw": "7m8KM0HcWGOPw28Gt",
+				"startIndex": 29,
+				"endIndex": 46,
+				"value": "7",
+				"unit": "m8KM0HcWGOPw28Gt",
+				"numberType": "integer"
+			},
+			{
+				"type": "(-token",
+				"raw": "(",
+				"startIndex": 46,
+				"endIndex": 47,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "r19",
+				"startIndex": 47,
+				"endIndex": 50,
+				"value": "r19"
+			}
+		]
+	},
+	"tests/fuzz/2abe9406-c063-4e9a-85ac-b13660671553": {
+		"css": "ak]P0A}808G\"lQh{R5M!QyOWE}oC2{2K TIa9}zb2oXWREY]0aj5J\\\r\nBJ5CO-16W5H7noF 19䀹41H3e8Z9%tg[O5AHEY24xh'9\"\"c34Q\"iiC0e45Da5f\"F5X3\"o(",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "ak",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "ak"
+			},
+			{
+				"type": "]-token",
+				"raw": "]",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "P0A",
+				"startIndex": 3,
+				"endIndex": 6,
+				"value": "P0A"
+			},
+			{
+				"type": "}-token",
+				"raw": "}",
+				"startIndex": 6,
+				"endIndex": 7,
+				"value": null
+			},
+			{
+				"type": "dimension-token",
+				"raw": "808G",
+				"startIndex": 7,
+				"endIndex": 11,
+				"value": "808",
+				"unit": "G",
+				"numberType": "integer"
+			},
+			{
+				"type": "string-token",
+				"raw": "\"lQh{R5M!QyOWE}oC2{2K TIa9}zb2oXWREY]0aj5J\\\r\nBJ5CO-16W5H7noF 19䀹41H3e8Z9%tg[O5AHEY24xh'9\"",
+				"startIndex": 11,
+				"endIndex": 102,
+				"value": "lQh{R5M!QyOWE}oC2{2K TIa9}zb2oXWREY]0aj5JBJ5CO-16W5H7noF 19䀹41H3e8Z9%tg[O5AHEY24xh'9"
+			},
+			{
+				"type": "string-token",
+				"raw": "\"c34Q\"",
+				"startIndex": 102,
+				"endIndex": 108,
+				"value": "c34Q"
+			},
+			{
+				"type": "ident-token",
+				"raw": "iiC0e45Da5f",
+				"startIndex": 108,
+				"endIndex": 119,
+				"value": "iiC0e45Da5f"
+			},
+			{
+				"type": "string-token",
+				"raw": "\"F5X3\"",
+				"startIndex": 119,
+				"endIndex": 125,
+				"value": "F5X3"
+			},
+			{
+				"type": "function-token",
+				"raw": "o(",
+				"startIndex": 125,
+				"endIndex": 127,
+				"value": "o"
+			}
+		]
+	},
+	"tests/fuzz/4e630a47-507b-4b79-b00f-57f7dc1cc79d": {
+		"css": "\u000e7rSD6I5L1lglVRlL2X7BbEk\\3HCd\r94 \\\u0000skoW25d4%l64UUskN\"pHun\"!",
+		"tokens": [
+			{
+				"type": "delim-token",
+				"raw": "\u000e",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "\u000e"
+			},
+			{
+				"type": "dimension-token",
+				"raw": "7rSD6I5L1lglVRlL2X7BbEk\\3HCd",
+				"startIndex": 1,
+				"endIndex": 29,
+				"value": "7",
+				"unit": "rSD6I5L1lglVRlL2X7BbEk\u0003HCd",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\r",
+				"startIndex": 29,
+				"endIndex": 30,
+				"value": null
+			},
+			{
+				"type": "number-token",
+				"raw": "94",
+				"startIndex": 30,
+				"endIndex": 32,
+				"value": "94",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": " ",
+				"startIndex": 32,
+				"endIndex": 33,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "\\\u0000skoW25d4",
+				"startIndex": 33,
+				"endIndex": 43,
+				"value": "�skoW25d4"
+			},
+			{
+				"type": "delim-token",
+				"raw": "%",
+				"startIndex": 43,
+				"endIndex": 44,
+				"value": "%"
+			},
+			{
+				"type": "ident-token",
+				"raw": "l64UUskN",
+				"startIndex": 44,
+				"endIndex": 52,
+				"value": "l64UUskN"
+			},
+			{
+				"type": "string-token",
+				"raw": "\"pHun\"",
+				"startIndex": 52,
+				"endIndex": 58,
+				"value": "pHun"
+			},
+			{
+				"type": "delim-token",
+				"raw": "!",
+				"startIndex": 58,
+				"endIndex": 59,
+				"value": "!"
+			}
+		]
+	},
+	"tests/fuzz/4f865903-e4dd-4a0b-83ed-e630cfa9dcca": {
+		"css": "gzO0{(p{DzQ7\u0000(a1;r1iN7w)",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "gzO0",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": "gzO0"
+			},
+			{
+				"type": "{-token",
+				"raw": "{",
+				"startIndex": 4,
+				"endIndex": 5,
+				"value": null
+			},
+			{
+				"type": "(-token",
+				"raw": "(",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "p",
+				"startIndex": 6,
+				"endIndex": 7,
+				"value": "p"
+			},
+			{
+				"type": "{-token",
+				"raw": "{",
+				"startIndex": 7,
+				"endIndex": 8,
+				"value": null
+			},
+			{
+				"type": "function-token",
+				"raw": "DzQ7\u0000(",
+				"startIndex": 8,
+				"endIndex": 14,
+				"value": "DzQ7�"
+			},
+			{
+				"type": "ident-token",
+				"raw": "a1",
+				"startIndex": 14,
+				"endIndex": 16,
+				"value": "a1"
+			},
+			{
+				"type": "semicolon-token",
+				"raw": ";",
+				"startIndex": 16,
+				"endIndex": 17,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "r1iN7w",
+				"startIndex": 17,
+				"endIndex": 23,
+				"value": "r1iN7w"
+			},
+			{
+				"type": ")-token",
+				"raw": ")",
+				"startIndex": 23,
+				"endIndex": 24,
+				"value": null
+			}
+		]
+	},
+	"tests/fuzz/5181013c-60ab-483b-9c06-fb32c7e1e7e8": {
+		"css": "565'E{z\u0000U\u001fEG2}2Verb>nj3TVk3mu7wX1J\b.H\u000bi1Ga8f5 dserqydJ3\"xj398xy.W\" uHQbv7Bw1NtF;N3PwNY7Vx00BF o\"4CXzvP\"{594 6r}8QQKNQw135i1\\\r\nrey\thg7[5%rBK8RUC64Lu␌17O{E\\90873u}1O3vx4gHTC55Q9i4\"V3Vx4\"7r(34L]F\"ns2pPf\"V7b)EOBGH8rdC7\"\u000eVJ4OQ[ 9jtoMdINgS7o�206vo72kTcKkZR9wl30G'vK\ndhCEs3tValX ",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "565",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "565",
+				"numberType": "integer"
+			},
+			{
+				"type": "string-token",
+				"raw": "'E{z\u0000U\u001fEG2}2Verb>nj3TVk3mu7wX1J\b.H\u000bi1Ga8f5 dserqydJ3\"xj398xy.W\" uHQbv7Bw1NtF;N3PwNY7Vx00BF o\"4CXzvP\"{594 6r}8QQKNQw135i1\\\r\nrey\thg7[5%rBK8RUC64Lu␌17O{E\\90873u}1O3vx4gHTC55Q9i4\"V3Vx4\"7r(34L]F\"ns2pPf\"V7b)EOBGH8rdC7\"\u000eVJ4OQ[ 9jtoMdINgS7o�206vo72kTcKkZR9wl30G'",
+				"startIndex": 3,
+				"endIndex": 263,
+				"value": "E{z�U\u001fEG2}2Verb>nj3TVk3mu7wX1J\b.H\u000bi1Ga8f5 dserqydJ3\"xj398xy.W\" uHQbv7Bw1NtF;N3PwNY7Vx00BF o\"4CXzvP\"{594 6r}8QQKNQw135i1rey\thg7[5%rBK8RUC64Lu␌17O{E򐡳u}1O3vx4gHTC55Q9i4\"V3Vx4\"7r(34L]F\"ns2pPf\"V7b)EOBGH8rdC7\"\u000eVJ4OQ[ 9jtoMdINgS7o�206vo72kTcKkZR9wl30G"
+			},
+			{
+				"type": "ident-token",
+				"raw": "vK",
+				"startIndex": 263,
+				"endIndex": 265,
+				"value": "vK"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 265,
+				"endIndex": 266,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "dhCEs3tValX",
+				"startIndex": 266,
+				"endIndex": 277,
+				"value": "dhCEs3tValX"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": " ",
+				"startIndex": 277,
+				"endIndex": 278,
+				"value": null
+			}
+		]
+	},
+	"tests/fuzz/6d07fc79-586f-4efa-a0a2-37d4dd3beb09": {
+		"css": "FWUNqr7uv8300nz\b,8lU0j6B186kh \u00009 \u000eGZafxf2GIhL9%",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "FWUNqr7uv8300nz",
+				"startIndex": 0,
+				"endIndex": 15,
+				"value": "FWUNqr7uv8300nz"
+			},
+			{
+				"type": "delim-token",
+				"raw": "\b",
+				"startIndex": 15,
+				"endIndex": 16,
+				"value": "\b"
+			},
+			{
+				"type": "comma-token",
+				"raw": ",",
+				"startIndex": 16,
+				"endIndex": 17,
+				"value": null
+			},
+			{
+				"type": "dimension-token",
+				"raw": "8lU0j6B186kh",
+				"startIndex": 17,
+				"endIndex": 29,
+				"value": "8",
+				"unit": "lU0j6B186kh",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": " ",
+				"startIndex": 29,
+				"endIndex": 30,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "\u00009",
+				"startIndex": 30,
+				"endIndex": 32,
+				"value": "�9"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": " ",
+				"startIndex": 32,
+				"endIndex": 33,
+				"value": null
+			},
+			{
+				"type": "delim-token",
+				"raw": "\u000e",
+				"startIndex": 33,
+				"endIndex": 34,
+				"value": "\u000e"
+			},
+			{
+				"type": "ident-token",
+				"raw": "GZafxf2GIhL9",
+				"startIndex": 34,
+				"endIndex": 46,
+				"value": "GZafxf2GIhL9"
+			},
+			{
+				"type": "delim-token",
+				"raw": "%",
+				"startIndex": 46,
+				"endIndex": 47,
+				"value": "%"
+			}
+		]
+	},
+	"tests/fuzz/7f49c8fc-8292-4a3e-828b-b5d028a80d5f": {
+		"css": "FZ 0B120h5QUbNbmTD2K8mAD傿i+Yv9V0KS14Ng18ag'\\\r\n{X<E/9b}0nIa%eSz-vapw2GqeMsri#e1BQf3b\u001fPlEnFQg{ofB)L9b571J4!{mCN㐥a\\BgK48qgu9'jVRS䎟ROYRbe0m5508k,O0C\u001f",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "FZ",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "FZ"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": " ",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			},
+			{
+				"type": "dimension-token",
+				"raw": "0B120h5QUbNbmTD2K8mAD傿i",
+				"startIndex": 3,
+				"endIndex": 28,
+				"value": "0",
+				"unit": "B120h5QUbNbmTD2K8mAD傿i",
+				"numberType": "integer"
+			},
+			{
+				"type": "delim-token",
+				"raw": "+",
+				"startIndex": 28,
+				"endIndex": 29,
+				"value": "+"
+			},
+			{
+				"type": "ident-token",
+				"raw": "Yv9V0KS14Ng18ag",
+				"startIndex": 29,
+				"endIndex": 44,
+				"value": "Yv9V0KS14Ng18ag"
+			},
+			{
+				"type": "string-token",
+				"raw": "'\\\r\n{X<E/9b}0nIa%eSz-vapw2GqeMsri#e1BQf3b\u001fPlEnFQg{ofB)L9b571J4!{mCN㐥a\\BgK48qgu9'",
+				"startIndex": 44,
+				"endIndex": 126,
+				"value": "{X<E/9b}0nIa%eSz-vapw2GqeMsri#e1BQf3b\u001fPlEnFQg{ofB)L9b571J4!{mCN㐥a\u000bgK48qgu9"
+			},
+			{
+				"type": "ident-token",
+				"raw": "jVRS䎟ROYRbe0m5508k",
+				"startIndex": 126,
+				"endIndex": 146,
+				"value": "jVRS䎟ROYRbe0m5508k"
+			},
+			{
+				"type": "comma-token",
+				"raw": ",",
+				"startIndex": 146,
+				"endIndex": 147,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "O0C",
+				"startIndex": 147,
+				"endIndex": 150,
+				"value": "O0C"
+			},
+			{
+				"type": "delim-token",
+				"raw": "\u001f",
+				"startIndex": 150,
+				"endIndex": 151,
+				"value": "\u001f"
+			}
+		]
+	},
+	"tests/fuzz/864d7812-b82f-47c2-94e4-8402ba6ba94a": {
+		"css": "'TR(:\b5RN)_e3w<gD5iL1EO-3zZw ntX3@0<KP9}V0 3Q80{Tqp}7dkUykEm ks �(ZnXhqsp3)G4JKqbWAfx7sPRW\"zKg19p\"Gcoi22xb\"3h5WQan.I4EUmЕ1IBofxvJ73hTA2Em\bA97(qOU)1\u0000rV7P'5528LZ14)䓑gqcRX\"aiu� \"z3i74FJ3\u00004x8F-V5b1f(U\u000b bUc",
+		"tokens": [
+			{
+				"type": "string-token",
+				"raw": "'TR(:\b5RN)_e3w<gD5iL1EO-3zZw ntX3@0<KP9}V0 3Q80{Tqp}7dkUykEm ks �(ZnXhqsp3)G4JKqbWAfx7sPRW\"zKg19p\"Gcoi22xb\"3h5WQan.I4EUmЕ1IBofxvJ73hTA2Em\bA97(qOU)1\u0000rV7P'",
+				"startIndex": 0,
+				"endIndex": 156,
+				"value": "TR(:\b5RN)_e3w<gD5iL1EO-3zZw ntX3@0<KP9}V0 3Q80{Tqp}7dkUykEm ks �(ZnXhqsp3)G4JKqbWAfx7sPRW\"zKg19p\"Gcoi22xb\"3h5WQan.I4EUmЕ1IBofxvJ73hTA2Em\bA97(qOU)1�rV7P"
+			},
+			{
+				"type": "dimension-token",
+				"raw": "5528LZ14",
+				"startIndex": 156,
+				"endIndex": 164,
+				"value": "5528",
+				"unit": "LZ14",
+				"numberType": "integer"
+			},
+			{
+				"type": ")-token",
+				"raw": ")",
+				"startIndex": 164,
+				"endIndex": 165,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "䓑gqcRX",
+				"startIndex": 165,
+				"endIndex": 173,
+				"value": "䓑gqcRX"
+			},
+			{
+				"type": "string-token",
+				"raw": "\"aiu� \"",
+				"startIndex": 173,
+				"endIndex": 182,
+				"value": "aiu� "
+			},
+			{
+				"type": "function-token",
+				"raw": "z3i74FJ3\u00004x8F-V5b1f(",
+				"startIndex": 182,
+				"endIndex": 202,
+				"value": "z3i74FJ3�4x8F-V5b1f"
+			},
+			{
+				"type": "ident-token",
+				"raw": "U",
+				"startIndex": 202,
+				"endIndex": 203,
+				"value": "U"
+			},
+			{
+				"type": "delim-token",
+				"raw": "\u000b",
+				"startIndex": 203,
+				"endIndex": 204,
+				"value": "\u000b"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": " ",
+				"startIndex": 204,
+				"endIndex": 205,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "bUc",
+				"startIndex": 205,
+				"endIndex": 208,
+				"value": "bUc"
+			}
+		]
+	},
+	"tests/fuzz/91de56d3-d1c7-41c9-93e2-4b0770e36e79": {
+		"css": "\tb6SUejoqAEDa\u000e9,kYO\\",
+		"tokens": [
+			{
+				"type": "whitespace-token",
+				"raw": "\t",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "b6SUejoqAEDa",
+				"startIndex": 1,
+				"endIndex": 13,
+				"value": "b6SUejoqAEDa"
+			},
+			{
+				"type": "delim-token",
+				"raw": "\u000e",
+				"startIndex": 13,
+				"endIndex": 14,
+				"value": "\u000e"
+			},
+			{
+				"type": "number-token",
+				"raw": "9",
+				"startIndex": 14,
+				"endIndex": 15,
+				"value": "9",
+				"numberType": "integer"
+			},
+			{
+				"type": "comma-token",
+				"raw": ",",
+				"startIndex": 15,
+				"endIndex": 16,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "kYO\\",
+				"startIndex": 16,
+				"endIndex": 20,
+				"value": "kYO�"
+			}
+		]
+	},
+	"tests/fuzz/b69ece36-057f-4450-9423-a1661787bce6": {
+		"css": "Iv1\u0000B}1E+X9oO\u001fN3G",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "Iv1\u0000B",
+				"startIndex": 0,
+				"endIndex": 8,
+				"value": "Iv1�B"
+			},
+			{
+				"type": "}-token",
+				"raw": "}",
+				"startIndex": 8,
+				"endIndex": 9,
+				"value": null
+			},
+			{
+				"type": "dimension-token",
+				"raw": "1E",
+				"startIndex": 9,
+				"endIndex": 11,
+				"value": "1",
+				"unit": "E",
+				"numberType": "integer"
+			},
+			{
+				"type": "delim-token",
+				"raw": "+",
+				"startIndex": 11,
+				"endIndex": 12,
+				"value": "+"
+			},
+			{
+				"type": "ident-token",
+				"raw": "X9oO",
+				"startIndex": 12,
+				"endIndex": 16,
+				"value": "X9oO"
+			},
+			{
+				"type": "delim-token",
+				"raw": "\u001f",
+				"startIndex": 16,
+				"endIndex": 17,
+				"value": "\u001f"
+			},
+			{
+				"type": "ident-token",
+				"raw": "N3G",
+				"startIndex": 17,
+				"endIndex": 20,
+				"value": "N3G"
+			}
+		]
+	},
+	"tests/fuzz/ccfaf86d-7471-465b-bbc8-5b65be03e9cf": {
+		"css": "H%7Zkc0P17 m2cqKMI5Cz34YPit.2.7,oP ",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "H",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "H"
+			},
+			{
+				"type": "delim-token",
+				"raw": "%",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": "%"
+			},
+			{
+				"type": "dimension-token",
+				"raw": "7Zkc0P17",
+				"startIndex": 2,
+				"endIndex": 10,
+				"value": "7",
+				"unit": "Zkc0P17",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": " ",
+				"startIndex": 10,
+				"endIndex": 11,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "m2cqKMI5Cz34YPit",
+				"startIndex": 11,
+				"endIndex": 27,
+				"value": "m2cqKMI5Cz34YPit"
+			},
+			{
+				"type": "number-token",
+				"raw": ".2",
+				"startIndex": 27,
+				"endIndex": 29,
+				"value": ".2",
+				"numberType": "number"
+			},
+			{
+				"type": "number-token",
+				"raw": ".7",
+				"startIndex": 29,
+				"endIndex": 31,
+				"value": ".7",
+				"numberType": "number"
+			},
+			{
+				"type": "comma-token",
+				"raw": ",",
+				"startIndex": 31,
+				"endIndex": 32,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "oP",
+				"startIndex": 32,
+				"endIndex": 34,
+				"value": "oP"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": " ",
+				"startIndex": 34,
+				"endIndex": 35,
+				"value": null
+			}
+		]
+	},
+	"tests/fuzz/eb11f9d4-f8ef-4e11-88dc-2cbf7f56e537": {
+		"css": ">u)k2a76}y4\\6fb9ONI\\",
+		"tokens": [
+			{
+				"type": "delim-token",
+				"raw": ">",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": ">"
+			},
+			{
+				"type": "ident-token",
+				"raw": "u",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": "u"
+			},
+			{
+				"type": ")-token",
+				"raw": ")",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "k2a76",
+				"startIndex": 3,
+				"endIndex": 8,
+				"value": "k2a76"
+			},
+			{
+				"type": "}-token",
+				"raw": "}",
+				"startIndex": 8,
+				"endIndex": 9,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "y4\\6fb9ONI\\",
+				"startIndex": 9,
+				"endIndex": 20,
+				"value": "y4澹ONI�"
+			}
+		]
+	},
+	"tests/hash/0001": {
+		"css": "#1\n",
+		"tokens": [
+			{
+				"type": "hash-token",
+				"raw": "#1",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "1"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/hash/0002": {
+		"css": "#-2\n",
+		"tokens": [
+			{
+				"type": "hash-token",
+				"raw": "#-2",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "-2"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/hash/0003": {
+		"css": "#--3\n",
+		"tokens": [
+			{
+				"type": "hash-token",
+				"raw": "#--3",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": "--3"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 4,
+				"endIndex": 5,
+				"value": null
+			}
+		]
+	},
+	"tests/hash/0004": {
+		"css": "#---4\n",
+		"tokens": [
+			{
+				"type": "hash-token",
+				"raw": "#---4",
+				"startIndex": 0,
+				"endIndex": 5,
+				"value": "---4"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": null
+			}
+		]
+	},
+	"tests/hash/0005": {
+		"css": "#a\n",
+		"tokens": [
+			{
+				"type": "hash-token",
+				"raw": "#a",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "a"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/hash/0006": {
+		"css": "#-b\n",
+		"tokens": [
+			{
+				"type": "hash-token",
+				"raw": "#-b",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "-b"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/hash/0007": {
+		"css": "#--c\n",
+		"tokens": [
+			{
+				"type": "hash-token",
+				"raw": "#--c",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": "--c"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 4,
+				"endIndex": 5,
+				"value": null
+			}
+		]
+	},
+	"tests/hash/0008": {
+		"css": "#---d\n",
+		"tokens": [
+			{
+				"type": "hash-token",
+				"raw": "#---d",
+				"startIndex": 0,
+				"endIndex": 5,
+				"value": "---d"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": null
+			}
+		]
+	},
+	"tests/hash/0009": {
+		"css": "#_\n",
+		"tokens": [
+			{
+				"type": "hash-token",
+				"raw": "#_",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "_"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/hash/0010": {
+		"css": "#_1\n",
+		"tokens": [
+			{
+				"type": "hash-token",
+				"raw": "#_1",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "_1"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/hash/0011": {
+		"css": "#-\n",
+		"tokens": [
+			{
+				"type": "hash-token",
+				"raw": "#-",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "-"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/hash/0012": {
+		"css": "#+\n",
+		"tokens": [
+			{
+				"type": "delim-token",
+				"raw": "#",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "#"
+			},
+			{
+				"type": "delim-token",
+				"raw": "+",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": "+"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/hash/0013": {
+		"css": "##\n",
+		"tokens": [
+			{
+				"type": "delim-token",
+				"raw": "#",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "#"
+			},
+			{
+				"type": "delim-token",
+				"raw": "#",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": "#"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/hash/0014": {
+		"css": "#",
+		"tokens": [
+			{
+				"type": "delim-token",
+				"raw": "#",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "#"
+			}
+		]
+	},
+	"tests/hash/0015": {
+		"css": "#aa𐀀\n",
+		"tokens": [
+			{
+				"type": "hash-token",
+				"raw": "#aa𐀀",
+				"startIndex": 0,
+				"endIndex": 7,
+				"value": "aa𐀀"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 7,
+				"endIndex": 8,
+				"value": null
+			}
+		]
+	},
+	"tests/hyphen-minus/0001": {
+		"css": "-\n",
+		"tokens": [
+			{
+				"type": "delim-token",
+				"raw": "-",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "-"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": null
+			}
+		]
+	},
+	"tests/hyphen-minus/0002": {
+		"css": "-1\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "-1",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "-1",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/hyphen-minus/0003": {
+		"css": "-.1\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "-.1",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "-.1",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/hyphen-minus/0004": {
+		"css": "--1\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "--1",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "--1"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/hyphen-minus/0005": {
+		"css": "-0\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "-0",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "-0",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/hyphen-minus/0006": {
+		"css": "-->\n",
+		"tokens": [
+			{
+				"type": "CDC-token",
+				"raw": "-->",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/ident/0001": {
+		"css": "foo\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "foo",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "foo"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/ident/0002": {
+		"css": "--\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "--",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "--"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/ident/0003": {
+		"css": "--0\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "--0",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "--0"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/ident/0004": {
+		"css": "-\\\n",
+		"tokens": [
+			{
+				"type": "delim-token",
+				"raw": "-",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "-"
+			},
+			{
+				"type": "delim-token",
+				"raw": "\\",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": "\\"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/ident/0005": {
+		"css": "-\\ \n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "-\\ ",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "- "
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/ident/0006": {
+		"css": "--💅\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "--💅",
+				"startIndex": 0,
+				"endIndex": 6,
+				"value": "--💅"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 6,
+				"endIndex": 7,
+				"value": null
+			}
+		]
+	},
+	"tests/ident/0007": {
+		"css": "-§\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "-§",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "-§"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/ident/0008": {
+		"css": "-×\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "-×",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "-×"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/ident/0009": {
+		"css": "--a𐀀\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "--a𐀀",
+				"startIndex": 0,
+				"endIndex": 7,
+				"value": "--a𐀀"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 7,
+				"endIndex": 8,
+				"value": null
+			}
+		]
+	},
+	"tests/ident-like/0001": {
+		"css": "url(foo)\n",
+		"tokens": [
+			{
+				"type": "url-token",
+				"raw": "url(foo)",
+				"startIndex": 0,
+				"endIndex": 8,
+				"value": "foo"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 8,
+				"endIndex": 9,
+				"value": null
+			}
+		]
+	},
+	"tests/ident-like/0002": {
+		"css": "\\75 Rl(foo)\n",
+		"tokens": [
+			{
+				"type": "url-token",
+				"raw": "\\75 Rl(foo)",
+				"startIndex": 0,
+				"endIndex": 11,
+				"value": "foo"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 11,
+				"endIndex": 12,
+				"value": null
+			}
+		]
+	},
+	"tests/ident-like/0003": {
+		"css": "uR\\6c (foo)\n",
+		"tokens": [
+			{
+				"type": "url-token",
+				"raw": "uR\\6c (foo)",
+				"startIndex": 0,
+				"endIndex": 11,
+				"value": "foo"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 11,
+				"endIndex": 12,
+				"value": null
+			}
+		]
+	},
+	"tests/ident-like/0004": {
+		"css": "url('foo')\n",
+		"tokens": [
+			{
+				"type": "function-token",
+				"raw": "url(",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": "url"
+			},
+			{
+				"type": "string-token",
+				"raw": "'foo'",
+				"startIndex": 4,
+				"endIndex": 9,
+				"value": "foo"
+			},
+			{
+				"type": ")-token",
+				"raw": ")",
+				"startIndex": 9,
+				"endIndex": 10,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 10,
+				"endIndex": 11,
+				"value": null
+			}
+		]
+	},
+	"tests/ident-like/0005": {
+		"css": "url( 'foo')\n",
+		"tokens": [
+			{
+				"type": "function-token",
+				"raw": "url(",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": "url"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": " ",
+				"startIndex": 4,
+				"endIndex": 5,
+				"value": null
+			},
+			{
+				"type": "string-token",
+				"raw": "'foo'",
+				"startIndex": 5,
+				"endIndex": 10,
+				"value": "foo"
+			},
+			{
+				"type": ")-token",
+				"raw": ")",
+				"startIndex": 10,
+				"endIndex": 11,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 11,
+				"endIndex": 12,
+				"value": null
+			}
+		]
+	},
+	"tests/ident-like/0006": {
+		"css": "url(  'foo')\n",
+		"tokens": [
+			{
+				"type": "function-token",
+				"raw": "url(",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": "url"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "  ",
+				"startIndex": 4,
+				"endIndex": 6,
+				"value": null
+			},
+			{
+				"type": "string-token",
+				"raw": "'foo'",
+				"startIndex": 6,
+				"endIndex": 11,
+				"value": "foo"
+			},
+			{
+				"type": ")-token",
+				"raw": ")",
+				"startIndex": 11,
+				"endIndex": 12,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 12,
+				"endIndex": 13,
+				"value": null
+			}
+		]
+	},
+	"tests/ident-like/0007": {
+		"css": "url(   'foo')\n",
+		"tokens": [
+			{
+				"type": "function-token",
+				"raw": "url(",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": "url"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "   ",
+				"startIndex": 4,
+				"endIndex": 7,
+				"value": null
+			},
+			{
+				"type": "string-token",
+				"raw": "'foo'",
+				"startIndex": 7,
+				"endIndex": 12,
+				"value": "foo"
+			},
+			{
+				"type": ")-token",
+				"raw": ")",
+				"startIndex": 12,
+				"endIndex": 13,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 13,
+				"endIndex": 14,
+				"value": null
+			}
+		]
+	},
+	"tests/ident-like/0008": {
+		"css": "not-url(   'foo')\n",
+		"tokens": [
+			{
+				"type": "function-token",
+				"raw": "not-url(",
+				"startIndex": 0,
+				"endIndex": 8,
+				"value": "not-url"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "   ",
+				"startIndex": 8,
+				"endIndex": 11,
+				"value": null
+			},
+			{
+				"type": "string-token",
+				"raw": "'foo'",
+				"startIndex": 11,
+				"endIndex": 16,
+				"value": "foo"
+			},
+			{
+				"type": ")-token",
+				"raw": ")",
+				"startIndex": 16,
+				"endIndex": 17,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 17,
+				"endIndex": 18,
+				"value": null
+			}
+		]
+	},
+	"tests/ident-like/0009": {
+		"css": "url(   foo)\n",
+		"tokens": [
+			{
+				"type": "url-token",
+				"raw": "url(   foo)",
+				"startIndex": 0,
+				"endIndex": 11,
+				"value": "foo"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 11,
+				"endIndex": 12,
+				"value": null
+			}
+		]
+	},
+	"tests/left-curly-bracket/0001": {
+		"css": "{\n",
+		"tokens": [
+			{
+				"type": "{-token",
+				"raw": "{",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": null
+			}
+		]
+	},
+	"tests/left-parenthesis/0001": {
+		"css": "(\n",
+		"tokens": [
+			{
+				"type": "(-token",
+				"raw": "(",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": null
+			}
+		]
+	},
+	"tests/left-square-bracket/0001": {
+		"css": "[\n",
+		"tokens": [
+			{
+				"type": "[-token",
+				"raw": "[",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": null
+			}
+		]
+	},
+	"tests/less-than/0001": {
+		"css": "<\n",
+		"tokens": [
+			{
+				"type": "delim-token",
+				"raw": "<",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "<"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": null
+			}
+		]
+	},
+	"tests/less-than/0002": {
+		"css": "<!--\n",
+		"tokens": [
+			{
+				"type": "CDO-token",
+				"raw": "<!--",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 4,
+				"endIndex": 5,
+				"value": null
+			}
+		]
+	},
+	"tests/less-than/0003": {
+		"css": "<--\n",
+		"tokens": [
+			{
+				"type": "delim-token",
+				"raw": "<",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "<"
+			},
+			{
+				"type": "ident-token",
+				"raw": "--",
+				"startIndex": 1,
+				"endIndex": 3,
+				"value": "--"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/less-than/0004": {
+		"css": "<!-\n",
+		"tokens": [
+			{
+				"type": "delim-token",
+				"raw": "<",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "<"
+			},
+			{
+				"type": "delim-token",
+				"raw": "!",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": "!"
+			},
+			{
+				"type": "delim-token",
+				"raw": "-",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": "-"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0001": {
+		"css": "10\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "10",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "10",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0002": {
+		"css": "+10\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "+10",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "+10",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0003": {
+		"css": "-10\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "-10",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "-10",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0004": {
+		"css": "0\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "0",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "0",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0005": {
+		"css": "+0\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "+0",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "+0",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0006": {
+		"css": "-0\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "-0",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "-0",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0007": {
+		"css": ".0\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": ".0",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": ".0",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0008": {
+		"css": ".1\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": ".1",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": ".1",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0009": {
+		"css": "+.1\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "+.1",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "+.1",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0010": {
+		"css": "-.1\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "-.1",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "-.1",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0011": {
+		"css": "1.1\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "1.1",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "1.1",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0012": {
+		"css": "+1.1\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "+1.1",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": "+1.1",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 4,
+				"endIndex": 5,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0013": {
+		"css": "-1.1\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "-1.1",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": "-1.1",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 4,
+				"endIndex": 5,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0014": {
+		"css": "1.1e2\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "1.1e2",
+				"startIndex": 0,
+				"endIndex": 5,
+				"value": "1.1e2",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0015": {
+		"css": "+1.1e+2\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "+1.1e+2",
+				"startIndex": 0,
+				"endIndex": 7,
+				"value": "+1.1e+2",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 7,
+				"endIndex": 8,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0016": {
+		"css": "-1.1e-2\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "-1.1e-2",
+				"startIndex": 0,
+				"endIndex": 7,
+				"value": "-1.1e-2",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 7,
+				"endIndex": 8,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0017": {
+		"css": "-1.1e-22\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "-1.1e-22",
+				"startIndex": 0,
+				"endIndex": 8,
+				"value": "-1.1e-22",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 8,
+				"endIndex": 9,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0018": {
+		"css": "-1.1e-22e\n",
+		"tokens": [
+			{
+				"type": "dimension-token",
+				"raw": "-1.1e-22e",
+				"startIndex": 0,
+				"endIndex": 9,
+				"value": "-1.1e-22",
+				"unit": "e",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 9,
+				"endIndex": 10,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0019": {
+		"css": "1e+\n",
+		"tokens": [
+			{
+				"type": "dimension-token",
+				"raw": "1e",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "1",
+				"unit": "e",
+				"numberType": "integer"
+			},
+			{
+				"type": "delim-token",
+				"raw": "+",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": "+"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/number/0020": {
+		"css": ".2.7\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": ".2",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": ".2",
+				"numberType": "number"
+			},
+			{
+				"type": "number-token",
+				"raw": ".7",
+				"startIndex": 2,
+				"endIndex": 4,
+				"value": ".7",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 4,
+				"endIndex": 5,
+				"value": null
+			}
+		]
+	},
+	"tests/numeric/0001": {
+		"css": "-123.753e-2\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "-123.753e-2",
+				"startIndex": 0,
+				"endIndex": 11,
+				"value": "-123.753e-2",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 11,
+				"endIndex": 12,
+				"value": null
+			}
+		]
+	},
+	"tests/numeric/0002": {
+		"css": "-123.753e-2px\n",
+		"tokens": [
+			{
+				"type": "dimension-token",
+				"raw": "-123.753e-2px",
+				"startIndex": 0,
+				"endIndex": 13,
+				"value": "-123.753e-2",
+				"unit": "px",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 13,
+				"endIndex": 14,
+				"value": null
+			}
+		]
+	},
+	"tests/numeric/0003": {
+		"css": "-123.753e-2%\n",
+		"tokens": [
+			{
+				"type": "percentage-token",
+				"raw": "-123.753e-2%",
+				"startIndex": 0,
+				"endIndex": 12,
+				"value": "-123.753e-2"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 12,
+				"endIndex": 13,
+				"value": null
+			}
+		]
+	},
+	"tests/numeric/0004": {
+		"css": "1.2.3\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "1.2",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "1.2",
+				"numberType": "number"
+			},
+			{
+				"type": "number-token",
+				"raw": ".3",
+				"startIndex": 3,
+				"endIndex": 5,
+				"value": ".3",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": null
+			}
+		]
+	},
+	"tests/plus/0001": {
+		"css": "+\n",
+		"tokens": [
+			{
+				"type": "delim-token",
+				"raw": "+",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "+"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": null
+			}
+		]
+	},
+	"tests/plus/0002": {
+		"css": "+1\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "+1",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "+1",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/plus/0003": {
+		"css": "+.1\n",
+		"tokens": [
+			{
+				"type": "number-token",
+				"raw": "+.1",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": "+.1",
+				"numberType": "number"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/plus/0004": {
+		"css": "++1\n",
+		"tokens": [
+			{
+				"type": "delim-token",
+				"raw": "+",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "+"
+			},
+			{
+				"type": "number-token",
+				"raw": "+1",
+				"startIndex": 1,
+				"endIndex": 3,
+				"value": "+1",
+				"numberType": "integer"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			}
+		]
+	},
+	"tests/reverse-solidus/0001": {
+		"css": "\\\n",
+		"tokens": [
+			{
+				"type": "delim-token",
+				"raw": "\\",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "\\"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": null
+			}
+		]
+	},
+	"tests/reverse-solidus/0002": {
+		"css": "\\#\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\#",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": "#"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/reverse-solidus/0003": {
+		"css": "\\ \n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\ ",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": " "
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 2,
+				"endIndex": 3,
+				"value": null
+			}
+		]
+	},
+	"tests/reverse-solidus/0004": {
+		"css": "\\61 b\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\61 b",
+				"startIndex": 0,
+				"endIndex": 5,
+				"value": "ab"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": null
+			}
+		]
+	},
+	"tests/reverse-solidus/0005": {
+		"css": "\\",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "�"
+			}
+		]
+	},
+	"tests/right-curly-bracket/0001": {
+		"css": "}\n",
+		"tokens": [
+			{
+				"type": "}-token",
+				"raw": "}",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": null
+			}
+		]
+	},
+	"tests/right-parenthesis/0001": {
+		"css": ")\n",
+		"tokens": [
+			{
+				"type": ")-token",
+				"raw": ")",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": null
+			}
+		]
+	},
+	"tests/right-square-bracket/0001": {
+		"css": "]\n",
+		"tokens": [
+			{
+				"type": "]-token",
+				"raw": "]",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": null
+			}
+		]
+	},
+	"tests/semi-colon/0001": {
+		"css": ";\n",
+		"tokens": [
+			{
+				"type": "semicolon-token",
+				"raw": ";",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 1,
+				"endIndex": 2,
+				"value": null
+			}
+		]
+	},
+	"tests/string/0001": {
+		"css": "\"foo\"\n'foo'\n",
+		"tokens": [
+			{
+				"type": "string-token",
+				"raw": "\"foo\"",
+				"startIndex": 0,
+				"endIndex": 5,
+				"value": "foo"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": null
+			},
+			{
+				"type": "string-token",
+				"raw": "'foo'",
+				"startIndex": 6,
+				"endIndex": 11,
+				"value": "foo"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 11,
+				"endIndex": 12,
+				"value": null
+			}
+		]
+	},
+	"tests/string/0002": {
+		"css": "\"foo",
+		"tokens": [
+			{
+				"type": "string-token",
+				"raw": "\"foo",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": "foo"
+			}
+		]
+	},
+	"tests/string/0003": {
+		"css": "\"fo\no\"",
+		"tokens": [
+			{
+				"type": "bad-string-token",
+				"raw": "\"fo",
+				"startIndex": 0,
+				"endIndex": 3,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "o",
+				"startIndex": 4,
+				"endIndex": 5,
+				"value": "o"
+			},
+			{
+				"type": "string-token",
+				"raw": "\"",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": ""
+			}
+		]
+	},
+	"tests/string/0004": {
+		"css": "\"fo\\\no\"\n",
+		"tokens": [
+			{
+				"type": "string-token",
+				"raw": "\"fo\\\no\"",
+				"startIndex": 0,
+				"endIndex": 7,
+				"value": "foo"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 7,
+				"endIndex": 8,
+				"value": null
+			}
+		]
+	},
+	"tests/string/0005": {
+		"css": "\"fo\\",
+		"tokens": [
+			{
+				"type": "string-token",
+				"raw": "\"fo\\",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": "fo"
+			}
+		]
+	},
+	"tests/string/0006": {
+		"css": "\"esc\\61 ped\"\n",
+		"tokens": [
+			{
+				"type": "string-token",
+				"raw": "\"esc\\61 ped\"",
+				"startIndex": 0,
+				"endIndex": 12,
+				"value": "escaped"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 12,
+				"endIndex": 13,
+				"value": null
+			}
+		]
+	},
+	"tests/string/0007": {
+		"css": "\"foo\\\"",
+		"tokens": [
+			{
+				"type": "string-token",
+				"raw": "\"foo\\\"",
+				"startIndex": 0,
+				"endIndex": 6,
+				"value": "foo\""
+			}
+		]
+	},
+	"tests/string/0008": {
+		"css": "\"'foo'\"\n'\"foo\"'\n",
+		"tokens": [
+			{
+				"type": "string-token",
+				"raw": "\"'foo'\"",
+				"startIndex": 0,
+				"endIndex": 7,
+				"value": "'foo'"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 7,
+				"endIndex": 8,
+				"value": null
+			},
+			{
+				"type": "string-token",
+				"raw": "'\"foo\"'",
+				"startIndex": 8,
+				"endIndex": 15,
+				"value": "\"foo\""
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 15,
+				"endIndex": 16,
+				"value": null
+			}
+		]
+	},
+	"tests/string/0009": {
+		"css": "\"\\\"foo\\\"\"\n'\\'foo\\''\n",
+		"tokens": [
+			{
+				"type": "string-token",
+				"raw": "\"\\\"foo\\\"\"",
+				"startIndex": 0,
+				"endIndex": 9,
+				"value": "\"foo\""
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 9,
+				"endIndex": 10,
+				"value": null
+			},
+			{
+				"type": "string-token",
+				"raw": "'\\'foo\\''",
+				"startIndex": 10,
+				"endIndex": 19,
+				"value": "'foo'"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 19,
+				"endIndex": 20,
+				"value": null
+			}
+		]
+	},
+	"tests/url/0001": {
+		"css": "url(\n",
+		"tokens": [
+			{
+				"type": "url-token",
+				"raw": "url(\n",
+				"startIndex": 0,
+				"endIndex": 5,
+				"value": ""
+			}
+		]
+	},
+	"tests/url/0002": {
+		"css": "url(a\n",
+		"tokens": [
+			{
+				"type": "url-token",
+				"raw": "url(a\n",
+				"startIndex": 0,
+				"endIndex": 6,
+				"value": "a"
+			}
+		]
+	},
+	"tests/url/0003": {
+		"css": "url( a\n",
+		"tokens": [
+			{
+				"type": "url-token",
+				"raw": "url( a\n",
+				"startIndex": 0,
+				"endIndex": 7,
+				"value": "a"
+			}
+		]
+	},
+	"tests/url/0004": {
+		"css": "url()\n",
+		"tokens": [
+			{
+				"type": "url-token",
+				"raw": "url()",
+				"startIndex": 0,
+				"endIndex": 5,
+				"value": ""
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": null
+			}
+		]
+	},
+	"tests/url/0005": {
+		"css": "url( )\n",
+		"tokens": [
+			{
+				"type": "url-token",
+				"raw": "url( )",
+				"startIndex": 0,
+				"endIndex": 6,
+				"value": ""
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 6,
+				"endIndex": 7,
+				"value": null
+			}
+		]
+	},
+	"tests/url/0006": {
+		"css": "url( a)\n",
+		"tokens": [
+			{
+				"type": "url-token",
+				"raw": "url( a)",
+				"startIndex": 0,
+				"endIndex": 7,
+				"value": "a"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 7,
+				"endIndex": 8,
+				"value": null
+			}
+		]
+	},
+	"tests/url/0007": {
+		"css": "url( a )\n",
+		"tokens": [
+			{
+				"type": "url-token",
+				"raw": "url( a )",
+				"startIndex": 0,
+				"endIndex": 8,
+				"value": "a"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 8,
+				"endIndex": 9,
+				"value": null
+			}
+		]
+	},
+	"tests/url/0008": {
+		"css": "url( \\) )\n",
+		"tokens": [
+			{
+				"type": "url-token",
+				"raw": "url( \\) )",
+				"startIndex": 0,
+				"endIndex": 9,
+				"value": ")"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 9,
+				"endIndex": 10,
+				"value": null
+			}
+		]
+	},
+	"tests/url/0009": {
+		"css": "url(https://https:⁄⁄www.netmeister.org@https://www.netmeister.org/https:⁄⁄www.netmeister.org⁄?https://www.netmeister.org=https://www.netmeister.org;https://www.netmeister.org#https://www.netmeister.org)\n",
+		"tokens": [
+			{
+				"type": "url-token",
+				"raw": "url(https://https:⁄⁄www.netmeister.org@https://www.netmeister.org/https:⁄⁄www.netmeister.org⁄?https://www.netmeister.org=https://www.netmeister.org;https://www.netmeister.org#https://www.netmeister.org)",
+				"startIndex": 0,
+				"endIndex": 212,
+				"value": "https://https:⁄⁄www.netmeister.org@https://www.netmeister.org/https:⁄⁄www.netmeister.org⁄?https://www.netmeister.org=https://www.netmeister.org;https://www.netmeister.org#https://www.netmeister.org"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 212,
+				"endIndex": 213,
+				"value": null
+			}
+		]
+	},
+	"tests/url/0010": {
+		"css": "url(https://www.netmeister.org/%62%6C%6F%67/%75%72%6C%73%2E%68%74%6D%6C?!@#$%25=+_\\)\\(*&^#top)\n",
+		"tokens": [
+			{
+				"type": "url-token",
+				"raw": "url(https://www.netmeister.org/%62%6C%6F%67/%75%72%6C%73%2E%68%74%6D%6C?!@#$%25=+_\\)\\(*&^#top)",
+				"startIndex": 0,
+				"endIndex": 94,
+				"value": "https://www.netmeister.org/%62%6C%6F%67/%75%72%6C%73%2E%68%74%6D%6C?!@#$%25=+_)(*&^#top"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 94,
+				"endIndex": 95,
+				"value": null
+			}
+		]
+	},
+	"tests/url/0011": {
+		"css": "Url(a)\n",
+		"tokens": [
+			{
+				"type": "url-token",
+				"raw": "Url(a)",
+				"startIndex": 0,
+				"endIndex": 6,
+				"value": "a"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 6,
+				"endIndex": 7,
+				"value": null
+			}
+		]
+	},
+	"tests/url/0012": {
+		"css": "uRl(a)\n",
+		"tokens": [
+			{
+				"type": "url-token",
+				"raw": "uRl(a)",
+				"startIndex": 0,
+				"endIndex": 6,
+				"value": "a"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 6,
+				"endIndex": 7,
+				"value": null
+			}
+		]
+	},
+	"tests/url/0013": {
+		"css": "urL(a)\n",
+		"tokens": [
+			{
+				"type": "url-token",
+				"raw": "urL(a)",
+				"startIndex": 0,
+				"endIndex": 6,
+				"value": "a"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 6,
+				"endIndex": 7,
+				"value": null
+			}
+		]
+	},
+	"tests/url/0014": {
+		"css": "uri(a)\n",
+		"tokens": [
+			{
+				"type": "function-token",
+				"raw": "uri(",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": "uri"
+			},
+			{
+				"type": "ident-token",
+				"raw": "a",
+				"startIndex": 4,
+				"endIndex": 5,
+				"value": "a"
+			},
+			{
+				"type": ")-token",
+				"raw": ")",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 6,
+				"endIndex": 7,
+				"value": null
+			}
+		]
+	},
+	"tests/url/0015": {
+		"css": "uul(a)\n",
+		"tokens": [
+			{
+				"type": "function-token",
+				"raw": "uul(",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": "uul"
+			},
+			{
+				"type": "ident-token",
+				"raw": "a",
+				"startIndex": 4,
+				"endIndex": 5,
+				"value": "a"
+			},
+			{
+				"type": ")-token",
+				"raw": ")",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": null
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 6,
+				"endIndex": 7,
+				"value": null
+			}
+		]
+	},
+	"tests/whitespace/0001": {
+		"css": "\n",
+		"tokens": [
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": null
+			}
+		]
+	},
+	"tests/whitespace/0002": {
+		"css": " \n",
+		"tokens": [
+			{
+				"type": "whitespace-token",
+				"raw": " \n",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": null
+			}
+		]
+	},
+	"tests/whitespace/0003": {
+		"css": "a  b\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "a",
+				"startIndex": 0,
+				"endIndex": 1,
+				"value": "a"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "  ",
+				"startIndex": 1,
+				"endIndex": 3,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "b",
+				"startIndex": 3,
+				"endIndex": 4,
+				"value": "b"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 4,
+				"endIndex": 5,
+				"value": null
+			}
+		]
+	},
+	"tests/whitespace/0004": {
+		"css": "\\61 b\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\61 b",
+				"startIndex": 0,
+				"endIndex": 5,
+				"value": "ab"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": null
+			}
+		]
+	},
+	"tests/whitespace/0005": {
+		"css": "\\000061 b\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\000061 b",
+				"startIndex": 0,
+				"endIndex": 9,
+				"value": "ab"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 9,
+				"endIndex": 10,
+				"value": null
+			}
+		]
+	},
+	"tests/whitespace/0006": {
+		"css": "\\61  b\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "\\61 ",
+				"startIndex": 0,
+				"endIndex": 4,
+				"value": "a"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": " ",
+				"startIndex": 4,
+				"endIndex": 5,
+				"value": null
+			},
+			{
+				"type": "ident-token",
+				"raw": "b",
+				"startIndex": 5,
+				"endIndex": 6,
+				"value": "b"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 6,
+				"endIndex": 7,
+				"value": null
+			}
+		]
+	},
+	"tests/whitespace/0007": {
+		"css": "\t\n",
+		"tokens": [
+			{
+				"type": "whitespace-token",
+				"raw": "\t\n",
+				"startIndex": 0,
+				"endIndex": 2,
+				"value": null
+			}
+		]
+	},
+	"tests/whitespace/0008": {
+		"css": "f\\ o\\\to\n",
+		"tokens": [
+			{
+				"type": "ident-token",
+				"raw": "f\\ o\\\to",
+				"startIndex": 0,
+				"endIndex": 7,
+				"value": "f o\to"
+			},
+			{
+				"type": "whitespace-token",
+				"raw": "\n",
+				"startIndex": 7,
+				"endIndex": 8,
+				"value": null
+			}
+		]
+	}
+}
diff --git a/tests/phpunit/tests/css-api/wpCssBuilder.php b/tests/phpunit/tests/css-api/wpCssBuilder.php
new file mode 100644
index 0000000000000..bba5a66e05ee8
--- /dev/null
+++ b/tests/phpunit/tests/css-api/wpCssBuilder.php
@@ -0,0 +1,146 @@
+<?php
+
+/**
+ * Tests for WP_CSS_Builder.
+ *
+ * @group css-api
+ *
+ * @coversDefaultClass WP_CSS_Builder
+ */
+class Tests_CssApi_WpCssBuilder extends WP_UnitTestCase {
+	/**
+	 * Tests that string() writes one string token that reads back as the value.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_values
+	 *
+	 * @covers ::string
+	 */
+	public function test_string_reads_back_as_the_value( string $value, string $expected_value ): void {
+		$tokens = self::tokenize( WP_CSS_Builder::string( $value ) );
+
+		$this->assertCount( 1, $tokens );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_STRING, $tokens[0]->get_type() );
+		$this->assertTrue( $tokens[0]->is_terminated() );
+		$this->assertSame( $expected_value, $tokens[0]->get_value() );
+	}
+
+	/**
+	 * Tests that url() writes a url function holding one string token that reads back as the value.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_values
+	 *
+	 * @covers ::url
+	 */
+	public function test_url_reads_back_as_the_value( string $value, string $expected_value ): void {
+		$tokens = self::tokenize( WP_CSS_Builder::url( $value ) );
+
+		$this->assertCount( 3, $tokens );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_FUNCTION, $tokens[0]->get_type() );
+		$this->assertSame( 'url', $tokens[0]->get_value() );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_STRING, $tokens[1]->get_type() );
+		$this->assertSame( $expected_value, $tokens[1]->get_value() );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN, $tokens[2]->get_type() );
+	}
+
+	/**
+	 * Tests that ident() writes one ident token that reads back as the value.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_values
+	 *
+	 * @covers ::ident
+	 */
+	public function test_ident_reads_back_as_the_value( string $value, string $expected_value ): void {
+		$tokens = self::tokenize( WP_CSS_Builder::ident( $value ) );
+
+		$this->assertCount( 1, $tokens );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_IDENT, $tokens[0]->get_type() );
+		$this->assertSame( $expected_value, $tokens[0]->get_value() );
+	}
+
+	/**
+	 * Data provider.
+	 *
+	 * @return array[]
+	 */
+	public static function data_values(): array {
+		return array(
+			'plain'                  => array( 'abc', 'abc' ),
+			'url with a query'       => array( 'https://example.com/a?b=1&c=2', 'https://example.com/a?b=1&c=2' ),
+			'parentheses and spaces' => array( 'https://example.com/a (1).jpg', 'https://example.com/a (1).jpg' ),
+			'double quote'           => array( 'a"b', 'a"b' ),
+			'single quote'           => array( "a'b", "a'b" ),
+			'backslash'              => array( 'a\\b', 'a\\b' ),
+			'declaration delimiters' => array( 'a;b:c}d{e', 'a;b:c}d{e' ),
+			'html delimiters'        => array( '</style><a>&amp;', '</style><a>&amp;' ),
+			'newline and tab'        => array( "a\nb\tc\r\fd", "a\nb\tc\r\fd" ),
+			'leading digit'          => array( '1a', '1a' ),
+			'leading hyphen digit'   => array( '-1a', '-1a' ),
+			'lone hyphen'            => array( '-', '-' ),
+			'custom property name'   => array( '--a', '--a' ),
+			'non-ascii'              => array( 'café 😀', 'café 😀' ),
+			'null byte'              => array( "a\0b", "a\u{FFFD}b" ),
+			'invalid utf-8'          => array( "a\xFFb", "a\u{FFFD}b" ),
+		);
+	}
+
+	/**
+	 * Tests that string() and url() write an empty value as an empty string.
+	 *
+	 * @ticket 65738
+	 *
+	 * @covers ::string
+	 * @covers ::url
+	 */
+	public function test_empty_string_and_url(): void {
+		$this->assertSame( '""', WP_CSS_Builder::string( '' ) );
+		$this->assertSame( 'url("")', WP_CSS_Builder::url( '' ) );
+	}
+
+	/**
+	 * Tests that ident() returns an empty string for an empty value.
+	 *
+	 * @ticket 65738
+	 *
+	 * @covers ::ident
+	 */
+	public function test_empty_ident(): void {
+		$this->assertSame( '', WP_CSS_Builder::ident( '' ) );
+	}
+
+	/**
+	 * Tests the examples in the docblocks.
+	 *
+	 * @ticket 65738
+	 *
+	 * @covers ::string
+	 * @covers ::url
+	 * @covers ::ident
+	 */
+	public function test_docblock_examples(): void {
+		$this->assertSame(
+			'url("https://example.com/a (1) \\22 b\\22 .jpg")',
+			WP_CSS_Builder::url( 'https://example.com/a (1) "b".jpg' )
+		);
+		$this->assertSame( '"Say \\22 hi\\22 "', WP_CSS_Builder::string( 'Say "hi"' ) );
+		$this->assertSame( 'url("https://example.com/a(1).png")', WP_CSS_Builder::url( 'https://example.com/a(1).png' ) );
+		$this->assertSame( '\\31 st\\20 Font', WP_CSS_Builder::ident( '1st Font' ) );
+	}
+
+	/**
+	 * Tokenizes CSS.
+	 *
+	 * @param string $css CSS to tokenize.
+	 * @return WP_CSS_Token[] Tokens.
+	 */
+	private static function tokenize( string $css ): array {
+		$processor = new WP_CSS_Token_Processor( $css );
+		$tokens    = array();
+		while ( $processor->next_token() ) {
+			$tokens[] = $processor->get_token();
+		}
+		return $tokens;
+	}
+}
diff --git a/tests/phpunit/tests/css-api/wpCssToken.php b/tests/phpunit/tests/css-api/wpCssToken.php
new file mode 100644
index 0000000000000..10fa39d42fb23
--- /dev/null
+++ b/tests/phpunit/tests/css-api/wpCssToken.php
@@ -0,0 +1,219 @@
+<?php
+
+/**
+ * Tests for WP_CSS_Token and WP_CSS_Token_Processor::get_token().
+ *
+ * @group css-api
+ *
+ * @coversDefaultClass WP_CSS_Token
+ */
+class Tests_CssApi_WpCssToken extends WP_UnitTestCase {
+	/**
+	 * Tests that tokens read with get_token() match the corpus.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_corpus
+	 *
+	 * @covers WP_CSS_Token_Processor::get_token
+	 */
+	public function test_get_token_matches_spec( string $css, array $expected_tokens ): void {
+		$processor = new WP_CSS_Token_Processor( $css );
+		$tokens    = array();
+		while ( $processor->next_token() ) {
+			$tokens[] = $processor->get_token();
+		}
+
+		$actual_tokens = array();
+		foreach ( $tokens as $token ) {
+			$actual_token = array(
+				'type'       => $token->get_type(),
+				'startIndex' => $token->get_start(),
+				'endIndex'   => $token->get_start() + $token->get_length(),
+				'value'      => $token->get_value(),
+			);
+			if ( null !== $token->get_unit() ) {
+				$actual_token['unit'] = $token->get_unit();
+			}
+			if (
+				WP_CSS_Token_Processor::TOKEN_NUMBER === $token->get_type() ||
+				WP_CSS_Token_Processor::TOKEN_DIMENSION === $token->get_type()
+			) {
+				$actual_token['numberType'] = $token->get_flag();
+			}
+			$actual_tokens[] = $actual_token;
+		}
+
+		$expected_tokens = array_map(
+			static function ( array $token ): array {
+				unset( $token['raw'], $token['normalized'] );
+				return $token;
+			},
+			$expected_tokens
+		);
+
+		$this->assertSame( $expected_tokens, $actual_tokens );
+	}
+
+	/**
+	 * Data provider for test_get_token_matches_spec().
+	 *
+	 * @return array[]
+	 */
+	public static function data_corpus(): array {
+		return json_decode( file_get_contents( DIR_TESTDATA . '/css-api/css-test-cases.json' ), true );
+	}
+
+	/**
+	 * Tests that get_token() returns null when the processor has no current token.
+	 *
+	 * @ticket 65738
+	 *
+	 * @covers WP_CSS_Token_Processor::get_token
+	 */
+	public function test_get_token_returns_null_without_a_current_token(): void {
+		$processor = new WP_CSS_Token_Processor( 'a' );
+		$this->assertNull( $processor->get_token(), 'There is no token before next_token().' );
+
+		$this->assertTrue( $processor->next_token() );
+		$this->assertInstanceOf( WP_CSS_Token::class, $processor->get_token() );
+
+		$this->assertFalse( $processor->next_token() );
+		$this->assertNull( $processor->get_token(), 'There is no token after the last one.' );
+	}
+
+	/**
+	 * Tests that a token decodes its value after the processor has moved on.
+	 *
+	 * @ticket 65738
+	 *
+	 * @covers ::get_value
+	 */
+	public function test_value_decodes_after_the_processor_moves_on(): void {
+		$processor = new WP_CSS_Token_Processor( '\\66 oo "b\\61 r" url(b\\61 z) #\\31 a 1\\70 x' );
+		$tokens    = array();
+		while ( $processor->next_token() ) {
+			$tokens[] = $processor->get_token();
+		}
+
+		$values = array();
+		foreach ( $tokens as $token ) {
+			$values[] = array( $token->get_type(), $token->get_value() );
+		}
+
+		$this->assertSame(
+			array(
+				array( WP_CSS_Token_Processor::TOKEN_IDENT, 'foo' ),
+				array( WP_CSS_Token_Processor::TOKEN_WHITESPACE, null ),
+				array( WP_CSS_Token_Processor::TOKEN_STRING, 'bar' ),
+				array( WP_CSS_Token_Processor::TOKEN_WHITESPACE, null ),
+				array( WP_CSS_Token_Processor::TOKEN_URL, 'baz' ),
+				array( WP_CSS_Token_Processor::TOKEN_WHITESPACE, null ),
+				array( WP_CSS_Token_Processor::TOKEN_HASH, '1a' ),
+				array( WP_CSS_Token_Processor::TOKEN_WHITESPACE, null ),
+				array( WP_CSS_Token_Processor::TOKEN_DIMENSION, '1' ),
+			),
+			$values
+		);
+		$this->assertSame( 'px', $tokens[8]->get_unit() );
+	}
+
+	/**
+	 * Tests that a token reports the type flag of the token it was read from.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_flag
+	 *
+	 * @covers ::get_flag
+	 */
+	public function test_flag( string $css, string $expected_type, ?string $expected_flag ): void {
+		$processor = new WP_CSS_Token_Processor( $css );
+		$this->assertTrue( $processor->next_token() );
+
+		$token = $processor->get_token();
+		$this->assertSame( $expected_type, $token->get_type() );
+		$this->assertSame( $expected_flag, $token->get_flag() );
+	}
+
+	/**
+	 * Data provider for test_flag().
+	 *
+	 * @return array[]
+	 */
+	public static function data_flag(): array {
+		return array(
+			'hash id'            => array( '#a1', WP_CSS_Token_Processor::TOKEN_HASH, WP_CSS_Token_Processor::HASH_TOKEN_ID ),
+			'hash escaped digit' => array( '#\\31 a', WP_CSS_Token_Processor::TOKEN_HASH, WP_CSS_Token_Processor::HASH_TOKEN_ID ),
+			'hash unrestricted'  => array( '#1a', WP_CSS_Token_Processor::TOKEN_HASH, WP_CSS_Token_Processor::HASH_TOKEN_UNRESTRICTED ),
+			'integer'            => array( '12', WP_CSS_Token_Processor::TOKEN_NUMBER, 'integer' ),
+			'number'             => array( '1.5', WP_CSS_Token_Processor::TOKEN_NUMBER, 'number' ),
+			'integer dimension'  => array( '1px', WP_CSS_Token_Processor::TOKEN_DIMENSION, 'integer' ),
+			'number dimension'   => array( '1e2px', WP_CSS_Token_Processor::TOKEN_DIMENSION, 'number' ),
+			'percentage'         => array( '50%', WP_CSS_Token_Processor::TOKEN_PERCENTAGE, null ),
+			'ident'              => array( 'a', WP_CSS_Token_Processor::TOKEN_IDENT, null ),
+		);
+	}
+
+	/**
+	 * Tests that a token reports whether it ended at its closing delimiter.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_is_terminated
+	 *
+	 * @covers ::is_terminated
+	 */
+	public function test_is_terminated( string $css, bool $expected ): void {
+		$processor = new WP_CSS_Token_Processor( $css );
+		$this->assertTrue( $processor->next_token() );
+
+		$token = $processor->get_token();
+		$processor->next_token();
+		$this->assertSame( $expected, $token->is_terminated(), 'The flag must not change when the processor moves on.' );
+	}
+
+	/**
+	 * Data provider for test_is_terminated().
+	 *
+	 * @return array[]
+	 */
+	public static function data_is_terminated(): array {
+		return array(
+			'string terminated'    => array( '"a" b', true ),
+			'string unterminated'  => array( '"a', false ),
+			'url terminated'       => array( 'url(a) b', true ),
+			'url unterminated'     => array( 'url(a', false ),
+			'comment terminated'   => array( '/* a */ b', true ),
+			'comment unterminated' => array( '/* a', false ),
+			'ident'                => array( 'a b', true ),
+		);
+	}
+
+	/**
+	 * Tests that the value of a comment token is the text between its delimiters.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_comment_value
+	 *
+	 * @covers ::get_value
+	 */
+	public function test_comment_value( string $css, string $expected ): void {
+		$processor = new WP_CSS_Token_Processor( $css );
+		$this->assertTrue( $processor->next_token() );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_COMMENT, $processor->get_token_type() );
+
+		$this->assertSame( $expected, $processor->get_token()->get_value() );
+	}
+
+	/**
+	 * Data provider for test_comment_value().
+	 *
+	 * @return array[]
+	 */
+	public static function data_comment_value(): array {
+		return array(
+			'terminated'                        => array( '/* a */', ' a ' ),
+			'unterminated'                      => array( '/* a', ' a' ),
+			'opener star does not close'        => array( '/*/', '/' ),
+			'no escapes, newlines preprocessed' => array( "/*\\41\r\n*/", "\\41\n" ),
+		);
+	}
+}
diff --git a/tests/phpunit/tests/css-api/wpCssTokenProcessor.php b/tests/phpunit/tests/css-api/wpCssTokenProcessor.php
new file mode 100644
index 0000000000000..c4c190e87cec9
--- /dev/null
+++ b/tests/phpunit/tests/css-api/wpCssTokenProcessor.php
@@ -0,0 +1,2622 @@
+<?php
+
+/**
+ * Comprehensive CSS processor tests based on the CSS Syntax Level 3 specification.
+ *
+ * @group css-api
+ */
+class Tests_CssApi_WpCssTokenProcessor extends WP_UnitTestCase {
+	/**
+	 * Tests that the processor produces the expected tokens for all test cases.
+	 *
+	 * @dataProvider corpus_provider
+	 */
+	public function test_processor_matches_spec( string $css, array $expected_tokens ): void {
+		$actual_tokens = $this->collect_tokens( $css );
+		$this->assertSame( $expected_tokens, $actual_tokens );
+	}
+
+	/**
+	 * Provides the test cases derived from the @rmenke/css-tokenizer-tests corpus (MIT).
+	 *
+	 * @link https://github.com/romainmenke/css-tokenizer-tests/
+	 * @return array
+	 */
+	public static function corpus_provider(): array {
+		return json_decode( file_get_contents( DIR_TESTDATA . '/css-api/css-test-cases.json' ), true );
+	}
+
+	/**
+	 * Tokenizes CSS and collects every token into an array.
+	 *
+	 * @param string        $css  CSS to tokenize.
+	 * @param string[]|null $keys Optional. Keys to keep on each token. Default all.
+	 * @return array Array of tokens with type, raw, startIndex, endIndex, value, unit and numberType.
+	 */
+	public static function collect_tokens( string $css, ?array $keys = null ): array {
+		$processor = new WP_CSS_Token_Processor( $css );
+		$tokens    = array();
+
+		while ( $processor->next_token() ) {
+			$type = $processor->get_token_type();
+
+			$byte_start = $processor->get_token_start();
+			$byte_end   = $byte_start + $processor->get_token_length();
+
+			$token = array(
+				'type'       => $type,
+				'raw'        => substr( $css, $byte_start, $processor->get_token_length() ),
+				'startIndex' => $byte_start,
+				'endIndex'   => $byte_end,
+				'value'      => $processor->get_token()->get_value(),
+			);
+			if ( null !== $processor->get_token()->get_unit() ) {
+				$token['unit'] = $processor->get_token()->get_unit();
+			}
+			if (
+				WP_CSS_Token_Processor::TOKEN_NUMBER === $type ||
+				WP_CSS_Token_Processor::TOKEN_DIMENSION === $type
+			) {
+				$token['numberType'] = $processor->get_token()->get_flag();
+			}
+
+			if ( null !== $keys ) {
+				$token = array_intersect_key( $token, array_flip( $keys ) );
+			}
+
+			$tokens[] = $token;
+		}
+
+		return $tokens;
+	}
+
+	/**
+	 * Tests that backslash-newline in a string token contributes nothing to the value.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_string_backslash_newline
+	 */
+	public function test_string_backslash_newline( string $css, string $expected_value ): void {
+		$processor = new WP_CSS_Token_Processor( $css );
+
+		$this->assertTrue( $processor->next_token() );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_STRING, $processor->get_token_type() );
+		$this->assertSame( $expected_value, $processor->get_token()->get_value() );
+	}
+
+	/**
+	 * Data provider for test_string_backslash_newline().
+	 *
+	 * @return array[]
+	 */
+	public static function data_string_backslash_newline(): array {
+		return array(
+			'backslash-LF'   => array( "'str\\\ning'", 'string' ),
+			'backslash-FF'   => array( "'str\\\fing'", 'string' ),
+			'backslash-CR'   => array( "'str\\\ring'", 'string' ),
+			'backslash-CRLF' => array( "'str\\\r\ning'", 'string' ),
+		);
+	}
+
+	/**
+	 * Tests that backslash-EOF in a string token contributes nothing to the value.
+	 *
+	 * @ticket 65738
+	 */
+	public function test_string_backslash_eof(): void {
+		$processor = new WP_CSS_Token_Processor( "'string\\" );
+
+		$this->assertTrue( $processor->next_token() );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_STRING, $processor->get_token_type() );
+		$this->assertSame( 'string', $processor->get_token()->get_value() );
+	}
+
+	/**
+	 * Tests that backslash-newline in an unquoted URL produces a bad-url token.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_url_backslash_newline
+	 */
+	public function test_url_backslash_newline( string $css ): void {
+		$processor = new WP_CSS_Token_Processor( $css );
+
+		$this->assertTrue( $processor->next_token() );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_BAD_URL, $processor->get_token_type() );
+	}
+
+	/**
+	 * Data provider for test_url_backslash_newline().
+	 *
+	 * @return array[]
+	 */
+	public static function data_url_backslash_newline(): array {
+		return array(
+			'backslash-LF'   => array( "url(ab\\\ncd)" ),
+			'backslash-FF'   => array( "url(ab\\\fcd)" ),
+			'backslash-CR'   => array( "url(ab\\\rcd)" ),
+			'backslash-CRLF' => array( "url(ab\\\r\ncd)" ),
+		);
+	}
+
+	/**
+	 * Tests that backslash-EOF in an unquoted URL produces U+FFFD in the value.
+	 *
+	 * @ticket 65738
+	 */
+	public function test_url_backslash_eof(): void {
+		$processor = new WP_CSS_Token_Processor( 'url(string\\' );
+
+		$this->assertTrue( $processor->next_token() );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_URL, $processor->get_token_type() );
+		$this->assertSame( "string\u{FFFD}", $processor->get_token()->get_value() );
+	}
+
+	/**
+	 * Tests that preprocessing replaces NUL in the token value and keeps the source bytes.
+	 *
+	 * NUL becomes U+FFFD before tokenization, so it is valid inside an unquoted
+	 * URL. Other control bytes still produce a bad-url token.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_preprocessed_token_keeps_source_bytes
+	 */
+	public function test_preprocessed_token_keeps_source_bytes( string $css, string $expected_type, ?string $expected_value ): void {
+		$processor = new WP_CSS_Token_Processor( $css );
+
+		$this->assertTrue( $processor->next_token() );
+		$this->assertSame( $expected_type, $processor->get_token_type() );
+		$this->assertSame( $expected_value, $processor->get_token()->get_value() );
+		$this->assertSame( 0, $processor->get_token_start() );
+		$this->assertSame( strlen( $css ), $processor->get_token_length() );
+		$this->assertFalse( $processor->next_token() );
+	}
+
+	/**
+	 * Data provider for test_preprocessed_token_keeps_source_bytes().
+	 *
+	 * @return Generator
+	 */
+	public static function data_preprocessed_token_keeps_source_bytes(): Generator {
+		yield 'NUL as the URL' => array( "url(\x00)", WP_CSS_Token_Processor::TOKEN_URL, "\u{FFFD}" );
+		yield 'NUL before text' => array( "url(\x00a)", WP_CSS_Token_Processor::TOKEN_URL, "\u{FFFD}a" );
+		yield 'NUL inside text' => array( "url(a\x00b)", WP_CSS_Token_Processor::TOKEN_URL, "a\u{FFFD}b" );
+		yield 'NUL before closing parenthesis' => array( "url(a\x00)", WP_CSS_Token_Processor::TOKEN_URL, "a\u{FFFD}" );
+		yield 'NUL before EOF' => array( "url(a\x00", WP_CSS_Token_Processor::TOKEN_URL, "a\u{FFFD}" );
+		yield 'consecutive NUL bytes' => array( "url(a\x00\x00b)", WP_CSS_Token_Processor::TOKEN_URL, "a\u{FFFD}\u{FFFD}b" );
+		yield 'escaped literal NUL' => array( "url(a\\\x00b)", WP_CSS_Token_Processor::TOKEN_URL, "a\u{FFFD}b" );
+		yield 'zero escape' => array( 'url(a\0 b)', WP_CSS_Token_Processor::TOKEN_URL, "a\u{FFFD}b" );
+		yield 'zero escape followed by CRLF' => array( "url(a\\0\r\nb)", WP_CSS_Token_Processor::TOKEN_URL, "a\u{FFFD}b" );
+		yield 'NUL followed by trailing CRLF' => array( "url(a\x00\r\n)", WP_CSS_Token_Processor::TOKEN_URL, "a\u{FFFD}" );
+		yield 'NUL in a string' => array( "\"a\x00b\"", WP_CSS_Token_Processor::TOKEN_STRING, "a\u{FFFD}b" );
+		yield 'NUL in a name' => array( "a\x00b", WP_CSS_Token_Processor::TOKEN_IDENT, "a\u{FFFD}b" );
+		yield 'NUL after trailing whitespace' => array( "url(a \x00)", WP_CSS_Token_Processor::TOKEN_BAD_URL, null );
+		yield 'NUL after a forbidden control' => array( "url(a\x01\x00b)", WP_CSS_Token_Processor::TOKEN_BAD_URL, null );
+
+		foreach ( array( "\t", "\n", "\r", "\f", "\r\n" ) as $whitespace ) {
+			yield 'internal whitespace ' . bin2hex( $whitespace ) => array( "url(a{$whitespace}b)", WP_CSS_Token_Processor::TOKEN_BAD_URL, null );
+		}
+
+		foreach ( array_merge( range( 0x01, 0x08 ), array( 0x0B ), range( 0x0E, 0x1F ), array( 0x7F ) ) as $byte ) {
+			yield 'forbidden control ' . dechex( $byte ) => array( 'url(a' . chr( $byte ) . 'b)', WP_CSS_Token_Processor::TOKEN_BAD_URL, null );
+		}
+	}
+
+	/**
+	 * Tests that backslash-newline stops an ident sequence.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_ident_backslash_newline
+	 */
+	public function test_ident_backslash_newline( string $css ): void {
+		$processor = new WP_CSS_Token_Processor( $css );
+
+		$this->assertTrue( $processor->next_token() );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_IDENT, $processor->get_token_type() );
+		$this->assertSame( 'abc', $processor->get_token()->get_value() );
+	}
+
+	/**
+	 * Data provider for test_ident_backslash_newline().
+	 *
+	 * @return array[]
+	 */
+	public static function data_ident_backslash_newline(): array {
+		return array(
+			'backslash-LF'   => array( "abc\\\n" ),
+			'backslash-FF'   => array( "abc\\\f" ),
+			'backslash-CR'   => array( "abc\\\r" ),
+			'backslash-CRLF' => array( "abc\\\r\n" ),
+		);
+	}
+
+	/**
+	 * Tests that backslash-EOF in an ident produces U+FFFD in the value.
+	 *
+	 * @ticket 65738
+	 */
+	public function test_ident_backslash_eof(): void {
+		$processor = new WP_CSS_Token_Processor( 'abc\\' );
+
+		$this->assertTrue( $processor->next_token() );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_IDENT, $processor->get_token_type() );
+		$this->assertSame( "abc\u{FFFD}", $processor->get_token()->get_value() );
+	}
+
+	/**
+	 * Bad string tokens have no associated value.
+	 *
+	 * @ticket 65738
+	 */
+	public function test_bad_string_token_value_is_null(): void {
+		$processor = new WP_CSS_Token_Processor( "'str\ning'" );
+
+		$this->assertTrue( $processor->next_token() );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_BAD_STRING, $processor->get_token_type() );
+		$this->assertNull( $processor->get_token()->get_value() );
+	}
+
+	/**
+	 * Tests that WP_CSS_Token::is_terminated() reports whether the last token ended at its closing delimiter.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_is_terminated
+	 */
+	public function test_is_terminated( string $css, string $expected_type, bool $expected ): void {
+		$processor = new WP_CSS_Token_Processor( $css );
+
+		$this->assertNull( $processor->get_token(), 'Before the first token there is nothing to report.' );
+
+		$type = null;
+		while ( $processor->next_token() ) {
+			$type       = $processor->get_token_type();
+			$terminated = $processor->get_token()->is_terminated();
+		}
+
+		$this->assertSame( $expected_type, $type, 'The last token type did not match.' );
+		$this->assertSame( $expected, $terminated, 'The last token termination flag did not match.' );
+	}
+
+	/**
+	 * Data provider for test_is_terminated().
+	 *
+	 * @return array[]
+	 */
+	public static function data_is_terminated(): array {
+		return array(
+			'comment terminated'                 => array( '/* a */', WP_CSS_Token_Processor::TOKEN_COMMENT, true ),
+			'comment empty terminated'           => array( '/**/', WP_CSS_Token_Processor::TOKEN_COMMENT, true ),
+			'comment unterminated'               => array( '/* a', WP_CSS_Token_Processor::TOKEN_COMMENT, false ),
+			'comment "/*/" unterminated'         => array( '/*/', WP_CSS_Token_Processor::TOKEN_COMMENT, false ),
+			'comment terminated at end of input' => array( 'a /**/', WP_CSS_Token_Processor::TOKEN_COMMENT, true ),
+			'string terminated'                  => array( '"a"', WP_CSS_Token_Processor::TOKEN_STRING, true ),
+			'string escaped backslash'           => array( '"a\\\\"', WP_CSS_Token_Processor::TOKEN_STRING, true ),
+			'string unterminated'                => array( '"a', WP_CSS_Token_Processor::TOKEN_STRING, false ),
+			'string escape consumed the quote'   => array( '"a\\"', WP_CSS_Token_Processor::TOKEN_STRING, false ),
+			'string lone quote'                  => array( '"', WP_CSS_Token_Processor::TOKEN_STRING, false ),
+			'string single quoted terminated'    => array( "a 'b'", WP_CSS_Token_Processor::TOKEN_STRING, true ),
+			'string single quoted unterminated'  => array( "a 'b", WP_CSS_Token_Processor::TOKEN_STRING, false ),
+			'url terminated'                     => array( 'url(a)', WP_CSS_Token_Processor::TOKEN_URL, true ),
+			'url escaped backslash'              => array( 'url(a\\\\)', WP_CSS_Token_Processor::TOKEN_URL, true ),
+			'url unterminated'                   => array( 'url(a', WP_CSS_Token_Processor::TOKEN_URL, false ),
+			'url escape consumed the paren'      => array( 'url(a\\)', WP_CSS_Token_Processor::TOKEN_URL, false ),
+			'url trailing whitespace'            => array( 'url(a ', WP_CSS_Token_Processor::TOKEN_URL, false ),
+			'url whitespace then paren'          => array( 'url(a )', WP_CSS_Token_Processor::TOKEN_URL, true ),
+			'url empty unterminated'             => array( 'url(', WP_CSS_Token_Processor::TOKEN_URL, false ),
+			'bad url terminated'                 => array( 'url(a b)', WP_CSS_Token_Processor::TOKEN_BAD_URL, true ),
+			'bad url unterminated'               => array( 'url(a b', WP_CSS_Token_Processor::TOKEN_BAD_URL, false ),
+			'ident at end of input'              => array( 'color: red', WP_CSS_Token_Processor::TOKEN_IDENT, true ),
+			'ident backslash at end of input'    => array( 'abc\\', WP_CSS_Token_Processor::TOKEN_IDENT, true ),
+			'function at end of input'           => array( 'calc(', WP_CSS_Token_Processor::TOKEN_FUNCTION, true ),
+		);
+	}
+
+	/**
+	 * Tests that WP_CSS_Token::is_terminated() is reset for the token after an unterminated one.
+	 *
+	 * @ticket 65738
+	 */
+	public function test_is_terminated_resets_between_tokens(): void {
+		$processor = new WP_CSS_Token_Processor( "'a\nb" );
+
+		$this->assertTrue( $processor->next_token() );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_BAD_STRING, $processor->get_token_type() );
+		$this->assertTrue( $processor->get_token()->is_terminated() );
+
+		$this->assertTrue( $processor->next_token() );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_WHITESPACE, $processor->get_token_type() );
+		$this->assertTrue( $processor->get_token()->is_terminated() );
+
+		$this->assertTrue( $processor->next_token() );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_IDENT, $processor->get_token_type() );
+		$this->assertTrue( $processor->get_token()->is_terminated() );
+	}
+
+	/**
+	 * Tests that hash tokens expose the proper type flag.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_hash_tokens_expose_type_flags
+	 */
+	public function test_hash_tokens_expose_type_flags( string $css, array $expected_tokens ): void {
+		$processor = new WP_CSS_Token_Processor( $css );
+
+		foreach ( $expected_tokens as $expected_token ) {
+			$this->assertTrue( $processor->next_token() );
+			$this->assertSame( $expected_token['type'], $processor->get_token_type() );
+			$this->assertSame( $expected_token['raw'], substr( $css, $processor->get_token_start(), $processor->get_token_length() ) );
+			$this->assertSame( $expected_token['type_flag'], $processor->get_token()->get_flag() );
+		}
+
+		$this->assertFalse( $processor->next_token() );
+		$this->assertNull( $processor->get_token() );
+	}
+
+	/**
+	 * Data provider for test_hash_tokens_expose_type_flags().
+	 *
+	 * @return array[]
+	 */
+	public static function data_hash_tokens_expose_type_flags(): array {
+		return array(
+			'id hash'                           => array(
+				'#id',
+				array(
+					array(
+						'type'      => WP_CSS_Token_Processor::TOKEN_HASH,
+						'raw'       => '#id',
+						'type_flag' => WP_CSS_Token_Processor::HASH_TOKEN_ID,
+					),
+				),
+			),
+			'unrestricted hash starting digit'  => array(
+				'#1id',
+				array(
+					array(
+						'type'      => WP_CSS_Token_Processor::TOKEN_HASH,
+						'raw'       => '#1id',
+						'type_flag' => WP_CSS_Token_Processor::HASH_TOKEN_UNRESTRICTED,
+					),
+				),
+			),
+			'id hash starting hyphen ident'     => array(
+				'#-id',
+				array(
+					array(
+						'type'      => WP_CSS_Token_Processor::TOKEN_HASH,
+						'raw'       => '#-id',
+						'type_flag' => WP_CSS_Token_Processor::HASH_TOKEN_ID,
+					),
+				),
+			),
+			'unrestricted hash starting hyphen' => array(
+				'#-1id',
+				array(
+					array(
+						'type'      => WP_CSS_Token_Processor::TOKEN_HASH,
+						'raw'       => '#-1id',
+						'type_flag' => WP_CSS_Token_Processor::HASH_TOKEN_UNRESTRICTED,
+					),
+				),
+			),
+			'id hash starting escape'           => array(
+				'#\\@special',
+				array(
+					array(
+						'type'      => WP_CSS_Token_Processor::TOKEN_HASH,
+						'raw'       => '#\\@special',
+						'type_flag' => WP_CSS_Token_Processor::HASH_TOKEN_ID,
+					),
+				),
+			),
+			'hash delimiter has no type flag'   => array(
+				'#',
+				array(
+					array(
+						'type'      => WP_CSS_Token_Processor::TOKEN_DELIM,
+						'raw'       => '#',
+						'type_flag' => null,
+					),
+				),
+			),
+			'following token clears type flag'  => array(
+				'#id .',
+				array(
+					array(
+						'type'      => WP_CSS_Token_Processor::TOKEN_HASH,
+						'raw'       => '#id',
+						'type_flag' => WP_CSS_Token_Processor::HASH_TOKEN_ID,
+					),
+					array(
+						'type'      => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+						'raw'       => ' ',
+						'type_flag' => null,
+					),
+					array(
+						'type'      => WP_CSS_Token_Processor::TOKEN_DELIM,
+						'raw'       => '.',
+						'type_flag' => null,
+					),
+				),
+			),
+		);
+	}
+
+	/**
+	 * Tests token type flags for numeric and non-numeric tokens.
+	 *
+	 * @dataProvider data_token_type_flag
+	 */
+	public function test_token_type_flag( string $css, ?string $expected_type ): void {
+		$processor = new WP_CSS_Token_Processor( $css );
+
+		$this->assertTrue( $processor->next_token() );
+		$this->assertSame( $expected_type, $processor->get_token()->get_flag() );
+	}
+
+	/**
+	 * Data provider for test_token_type_flag().
+	 *
+	 * @return array[]
+	 */
+	public static function data_token_type_flag(): array {
+		return array(
+			'integer'               => array( '42', 'integer' ),
+			'positive integer'      => array( '+42', 'integer' ),
+			'negative integer'      => array( '-42', 'integer' ),
+			'zero'                  => array( '0', 'integer' ),
+			'decimal'               => array( '42.0', 'number' ),
+			'decimal with fraction' => array( '42.5', 'number' ),
+			'leading decimal point' => array( '.5', 'number' ),
+			'exponent lowercase'    => array( '1e2', 'number' ),
+			'exponent uppercase'    => array( '1E2', 'number' ),
+			'exponent with plus'    => array( '1E+2', 'number' ),
+			'exponent with minus'   => array( '1e-2', 'number' ),
+			'dimension integer'     => array( '10px', 'integer' ),
+			'dimension decimal'     => array( '10.5px', 'number' ),
+			'dimension exponent'    => array( '1e2px', 'number' ),
+			'percentage integer'    => array( '20%', null ),
+			'percentage decimal'    => array( '20.0%', null ),
+			'ident token'           => array( 'red', null ),
+			'string token'          => array( '"hello"', null ),
+		);
+	}
+
+	/**
+	 * Tests handling of non-UTF-8 byte sequences in identifiers.
+	 *
+	 * Invalid UTF-8 sequences should be replaced with U+FFFD replacement characters
+	 * during tokenization, allowing the CSS to continue processing.
+	 */
+	public function test_non_utf8_sequences_in_identifiers(): void {
+		// Invalid UTF-8 sequence 0xC0 0x80 (overlong encoding).
+		$css = ".class\xF1name";
+
+		$expected = array(
+			// .class�name (0xF1 replaced with U+FFFD).
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'   => '.',
+				'value' => '.',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'   => "class\xF1name",
+				'value' => 'class�name',
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw', 'value', 'unit' ) );
+		$this->assertSame( $expected, $actual_tokens );
+	}
+
+	public function test_invalid_utf8_in_normal_segment_combined_with_escape(): void {
+		$css = ".test\xF1\\41name";
+
+		$expected = array(
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'   => '.',
+				'value' => '.',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'   => "test\xF1\\41name",
+				'value' => "test\u{FFFD}Aname",
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw', 'value' ) );
+		$this->assertSame( $expected, $actual_tokens );
+	}
+
+	public function test_invalid_utf8_as_escaped_character(): void {
+		$css = ".a\\\xF1b";
+
+		$expected = array(
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'   => '.',
+				'value' => '.',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'   => "a\\\xF1b",
+				'value' => "a\u{FFFD}b",
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw', 'value' ) );
+		$this->assertSame( $expected, $actual_tokens );
+	}
+
+	public function test_invalid_utf8_with_valid_prefix_in_identifiers(): void {
+		// Invalid 2-byte prefix is replaced with a single U+FFFD.
+		$css = ".test\xE2\x80name";
+
+		$expected = array(
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'   => '.',
+				'value' => '.',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'   => "test\xE2\x80name",
+				'value' => 'test�name',
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw', 'value' ) );
+		$this->assertSame( $expected, $actual_tokens );
+	}
+
+	public function test_invalid_utf8_with_two_single_byte_invalid_sequences(): void {
+		// Two distinct single byte invalid sequences are replaced with
+		// two separate U+FFFD replacement characters.
+		$css = ".test\xE2\xE2name";
+
+		$expected = array(
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'   => '.',
+				'value' => '.',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'   => "test\xE2\xE2name",
+				'value' => 'test��name',
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw', 'value' ) );
+		$this->assertSame( $expected, $actual_tokens );
+	}
+
+	/**
+	 * Legacy test to ensure basic tokenization still works.
+	 */
+	public function test_tokenize_labels_core_tokens(): void {
+		$css = <<<CSS
+@media screen and (min-width: 10px) {
+	background: url("/images/a.png");
+}
+CSS;
+
+		$expected = array(
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_AT_KEYWORD,
+				'raw'  => '@media',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'screen',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'and',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_LEFT_PAREN,
+				'raw'  => '(',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'min-width',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DIMENSION,
+				'raw'  => '10px',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN,
+				'raw'  => ')',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_LEFT_BRACE,
+				'raw'  => '{',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => "\n\t",
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'background',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_FUNCTION,
+				'raw'  => 'url(',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_STRING,
+				'raw'  => '"/images/a.png"',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN,
+				'raw'  => ')',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'  => ';',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => "\n",
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_BRACE,
+				'raw'  => '}',
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw' ) );
+		$this->assertSame( $actual_tokens, $expected );
+	}
+
+	/**
+	 * Tests tokenization of complex selectors with pseudo-classes.
+	 */
+	public function test_complex_selector_with_pseudo_classes(): void {
+		$css = 'a:hover::before, div.class#id:not(.disabled)';
+
+		$expected = array(
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'a',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'hover',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'before',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COMMA,
+				'raw'  => ',',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'div',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'  => '.',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'class',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_HASH,
+				'raw'  => '#id',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_FUNCTION,
+				'raw'  => 'not(',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'  => '.',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'disabled',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN,
+				'raw'  => ')',
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw' ) );
+		$this->assertSame( $actual_tokens, $expected );
+	}
+
+	/**
+	 * Tests tokenization of CSS comments.
+	 */
+	public function test_css_comments(): void {
+		$css = '/* This is a comment */ .class { color: red; /* Another comment */ }';
+
+		$expected = array(
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COMMENT,
+				'raw'  => '/* This is a comment */',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'  => '.',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'class',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_LEFT_BRACE,
+				'raw'  => '{',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'color',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'red',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'  => ';',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COMMENT,
+				'raw'  => '/* Another comment */',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_BRACE,
+				'raw'  => '}',
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw' ) );
+		$this->assertSame( $actual_tokens, $expected );
+	}
+
+	/**
+	 * Tests tokenization of media queries.
+	 */
+	public function test_media_query(): void {
+		$css = '@media screen and (min-width: 768px) and (max-width: 1024px)';
+
+		$expected = array(
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_AT_KEYWORD,
+				'raw'  => '@media',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'screen',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'and',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_LEFT_PAREN,
+				'raw'  => '(',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'min-width',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DIMENSION,
+				'raw'  => '768px',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN,
+				'raw'  => ')',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'and',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_LEFT_PAREN,
+				'raw'  => '(',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'max-width',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DIMENSION,
+				'raw'  => '1024px',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN,
+				'raw'  => ')',
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw' ) );
+		$this->assertSame( $actual_tokens, $expected );
+	}
+
+	/**
+	 * Tests tokenization of keyframes animation.
+	 */
+	public function test_keyframes_animation(): void {
+		$css = '@keyframes slide-in { 0% { opacity: 0; } 100% { opacity: 1; } }';
+
+		$expected = array(
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_AT_KEYWORD,
+				'raw'  => '@keyframes',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'slide-in',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_LEFT_BRACE,
+				'raw'  => '{',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_PERCENTAGE,
+				'raw'  => '0%',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_LEFT_BRACE,
+				'raw'  => '{',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'opacity',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_NUMBER,
+				'raw'  => '0',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'  => ';',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_BRACE,
+				'raw'  => '}',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_PERCENTAGE,
+				'raw'  => '100%',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_LEFT_BRACE,
+				'raw'  => '{',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'opacity',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_NUMBER,
+				'raw'  => '1',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'  => ';',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_BRACE,
+				'raw'  => '}',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_BRACE,
+				'raw'  => '}',
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw' ) );
+		$this->assertSame( $actual_tokens, $expected );
+	}
+
+	/**
+	 * Tests tokenization of vendor-prefixed properties.
+	 */
+	public function test_vendor_prefixed_properties(): void {
+		$css = '-webkit-transform: rotate(45deg); -moz-border-radius: 5px;';
+
+		$expected = array(
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => '-webkit-transform',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_FUNCTION,
+				'raw'  => 'rotate(',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DIMENSION,
+				'raw'  => '45deg',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN,
+				'raw'  => ')',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'  => ';',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => '-moz-border-radius',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DIMENSION,
+				'raw'  => '5px',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'  => ';',
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw' ) );
+		$this->assertSame( $actual_tokens, $expected );
+	}
+
+	/**
+	 * Tests tokenization of attribute selectors.
+	 */
+	public function test_attribute_selectors(): void {
+		$css = 'input[type="text"][required], a[href^="https://"]';
+
+		$expected = array(
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'input',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_LEFT_BRACKET,
+				'raw'  => '[',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'type',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'  => '=',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_STRING,
+				'raw'  => '"text"',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_BRACKET,
+				'raw'  => ']',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_LEFT_BRACKET,
+				'raw'  => '[',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'required',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_BRACKET,
+				'raw'  => ']',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COMMA,
+				'raw'  => ',',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'a',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_LEFT_BRACKET,
+				'raw'  => '[',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'href',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'  => '^',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'  => '=',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_STRING,
+				'raw'  => '"https://"',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_BRACKET,
+				'raw'  => ']',
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw' ) );
+		$this->assertSame( $actual_tokens, $expected );
+	}
+
+	/**
+	 * Tests tokenization of calc() function with complex expressions.
+	 */
+	public function test_calc_function(): void {
+		$css = 'width: calc(100% - 20px * 2 + 5em);';
+
+		$expected = array(
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'width',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_FUNCTION,
+				'raw'  => 'calc(',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_PERCENTAGE,
+				'raw'  => '100%',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'  => '-',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DIMENSION,
+				'raw'  => '20px',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'  => '*',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_NUMBER,
+				'raw'  => '2',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'  => '+',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DIMENSION,
+				'raw'  => '5em',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN,
+				'raw'  => ')',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'  => ';',
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw' ) );
+		$this->assertSame( $actual_tokens, $expected );
+	}
+
+	/**
+	 * Tests tokenization of RGB/RGBA color functions.
+	 */
+	public function test_color_functions(): void {
+		$css = 'color: rgb(255, 128, 0); background: rgba(0, 0, 0, 0.5);';
+
+		$expected = array(
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'color',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_FUNCTION,
+				'raw'  => 'rgb(',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_NUMBER,
+				'raw'  => '255',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COMMA,
+				'raw'  => ',',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_NUMBER,
+				'raw'  => '128',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COMMA,
+				'raw'  => ',',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_NUMBER,
+				'raw'  => '0',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN,
+				'raw'  => ')',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'  => ';',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'background',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_FUNCTION,
+				'raw'  => 'rgba(',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_NUMBER,
+				'raw'  => '0',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COMMA,
+				'raw'  => ',',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_NUMBER,
+				'raw'  => '0',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COMMA,
+				'raw'  => ',',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_NUMBER,
+				'raw'  => '0',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COMMA,
+				'raw'  => ',',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_NUMBER,
+				'raw'  => '0.5',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN,
+				'raw'  => ')',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'  => ';',
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw' ) );
+		$this->assertSame( $actual_tokens, $expected );
+	}
+
+	/**
+	 * Tests tokenization of CSS custom properties (variables).
+	 */
+	public function test_css_variables(): void {
+		$css = '--main-color: #ff0000; color: var(--main-color);';
+
+		$expected = array(
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => '--main-color',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_HASH,
+				'raw'  => '#ff0000',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'  => ';',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'color',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_FUNCTION,
+				'raw'  => 'var(',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => '--main-color',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN,
+				'raw'  => ')',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'  => ';',
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw' ) );
+		$this->assertSame( $actual_tokens, $expected );
+	}
+
+	/**
+	 * Tests tokenization of gradient functions.
+	 */
+	public function test_gradient_functions(): void {
+		$css = 'background: linear-gradient(to right, red 0%, blue 100%);';
+
+		$expected = array(
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'background',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_FUNCTION,
+				'raw'  => 'linear-gradient(',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'to',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'right',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COMMA,
+				'raw'  => ',',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'red',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_PERCENTAGE,
+				'raw'  => '0%',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COMMA,
+				'raw'  => ',',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'blue',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_PERCENTAGE,
+				'raw'  => '100%',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN,
+				'raw'  => ')',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'  => ';',
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw' ) );
+		$this->assertSame( $actual_tokens, $expected );
+	}
+
+	/**
+	 * Tests tokenization of grid layout properties.
+	 */
+	public function test_grid_layout(): void {
+		$css = 'grid-template-columns: repeat(3, 1fr); gap: 10px 20px;';
+
+		$expected = array(
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'grid-template-columns',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_FUNCTION,
+				'raw'  => 'repeat(',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_NUMBER,
+				'raw'  => '3',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COMMA,
+				'raw'  => ',',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DIMENSION,
+				'raw'  => '1fr',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN,
+				'raw'  => ')',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'  => ';',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'gap',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DIMENSION,
+				'raw'  => '10px',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DIMENSION,
+				'raw'  => '20px',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'  => ';',
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw' ) );
+		$this->assertSame( $actual_tokens, $expected );
+	}
+
+	/**
+	 * Tests tokenization of URL functions with various formats.
+	 */
+	public function test_url_formats(): void {
+		$css = 'background: url("image.png"), url(\'font.woff\'), url(https://example.com/bg.jpg);';
+
+		$expected = array(
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'background',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_FUNCTION,
+				'raw'  => 'url(',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_STRING,
+				'raw'  => '"image.png"',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN,
+				'raw'  => ')',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COMMA,
+				'raw'  => ',',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_FUNCTION,
+				'raw'  => 'url(',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_STRING,
+				'raw'  => "'font.woff'",
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN,
+				'raw'  => ')',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COMMA,
+				'raw'  => ',',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_URL,
+				'raw'  => 'url(https://example.com/bg.jpg)',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'  => ';',
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw' ) );
+		$this->assertSame( $actual_tokens, $expected );
+	}
+
+	/**
+	 * Tests tokenization of !important declarations.
+	 */
+	public function test_important_declarations(): void {
+		$css = 'color: red !important; margin: 0px !important;';
+
+		$expected = array(
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'color',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'red',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'  => '!',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'important',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'  => ';',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'margin',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DIMENSION,
+				'raw'  => '0px',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'  => '!',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'important',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'  => ';',
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw' ) );
+		$this->assertSame( $actual_tokens, $expected );
+	}
+
+	/**
+	 * Tests tokenization of multiple selectors with combinators.
+	 */
+	public function test_complex_combinators(): void {
+		$css = 'div > p + span ~ a.link';
+
+		$expected = array(
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'div',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'  => '>',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'p',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'  => '+',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'span',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'  => '~',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'a',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'  => '.',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'link',
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw' ) );
+		$this->assertSame( $actual_tokens, $expected );
+	}
+
+	/**
+	 * Tests tokenization of escaped characters in identifiers.
+	 */
+	public function test_escaped_identifiers(): void {
+		$css = '.class\\:name, #id\\@special { color: blue; }';
+
+		$expected = array(
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'  => '.',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'class\\:name',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COMMA,
+				'raw'  => ',',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_HASH,
+				'raw'  => '#id\\@special',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_LEFT_BRACE,
+				'raw'  => '{',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'color',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'  => ':',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'  => 'blue',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'  => ';',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'  => ' ',
+			),
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_RIGHT_BRACE,
+				'raw'  => '}',
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw' ) );
+		$this->assertSame( $actual_tokens, $expected );
+	}
+
+	/**
+	 * Tests that token values are decoded and normalized.
+	 *
+	 * Uses a comprehensive CSS selector with rules that includes:
+	 * - CSS escapes in class names and IDs
+	 * - URLs with escape sequences
+	 * - String values with escapes and line endings
+	 * - Comments with various line ending characters
+	 * - Null bytes in identifiers
+	 * - Mixed line endings (\r\n, \r, \f) that need normalization
+	 */
+	public function test_token_values_are_decoded_and_normalized(): void {
+		// Comprehensive CSS with normalization requirements.
+		$css = "/* Comment\r\nwith\flines */\r\n" .
+				".c\\6c ass.n\\61 me\r#id\\@value\r\n{\r\n" .
+				"\tbackground:\furl(path\\2f to\\2f image.png);\r\n" .
+				"\tcontent:\r\"text\\A string\";\r\n" .
+				'}';
+
+		$expected = array(
+			// Comment with \r\n and \f.
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_COMMENT,
+				'raw'   => "/* Comment\r\nwith\flines */",
+				'value' => " Comment\nwith\nlines ",
+			),
+			// Whitespace with \r\n.
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => "\r\n",
+				'value' => null,
+			),
+			// Class selector delimiter.
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'   => '.',
+				'value' => '.',
+			),
+			// Class name with escape (\6c = 'l'), space gets consumed by escape.
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'   => 'c\\6c ass',
+				'value' => 'class', // Decoded: \6c → l, space consumed.
+			),
+			// Delimiter.
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'   => '.',
+				'value' => '.',
+			),
+			// Identifier with escape (\61 = 'a'), space gets consumed.
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'   => 'n\\61 me',
+				'value' => 'name', // Decoded: \61 → a, space consumed.
+			),
+			// Whitespace with \r.
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => "\r",
+				'value' => null,
+			),
+			// ID selector with escape.
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_HASH,
+				'raw'   => '#id\\@value',
+				'value' => 'id@value', // Decoded value.
+			),
+			// Whitespace with \r\n.
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => "\r\n",
+				'value' => null,
+			),
+			// Opening brace.
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_LEFT_BRACE,
+				'raw'   => '{',
+				'value' => null,
+			),
+			// Whitespace with \r\n and tab (consumed together).
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => "\r\n\t",
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'   => 'background',
+				'value' => 'background',
+			),
+			// Colon.
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'   => ':',
+				'value' => null,
+			),
+			// Whitespace with \f.
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => "\f",
+				'value' => null,
+			),
+			// URL token with escapes (entire url(...) is one token).
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_URL,
+				'raw'   => 'url(path\\2f to\\2f image.png)',
+				'value' => 'path/to/image.png', // Decoded: \2f → /, spaces consumed.
+			),
+			// Semicolon.
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'   => ';',
+				'value' => null,
+			),
+			// Whitespace with \r\n and tab (consumed together).
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => "\r\n\t",
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'   => 'content',
+				'value' => 'content',
+			),
+			// Colon.
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'   => ':',
+				'value' => null,
+			),
+			// Whitespace with \r.
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => "\r",
+				'value' => null,
+			),
+			// String with escape (\A = newline, space consumed).
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_STRING,
+				'raw'   => '"text\\A string"',
+				'value' => "text\nstring", // \A → \n, space consumed.
+			),
+			// Semicolon.
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'   => ';',
+				'value' => null,
+			),
+			// Whitespace with \r\n.
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => "\r\n",
+				'value' => null,
+			),
+			// Closing brace.
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_RIGHT_BRACE,
+				'raw'   => '}',
+				'value' => null,
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw', 'value' ) );
+		$this->assertSame( $expected, $actual_tokens );
+	}
+
+	/**
+	 * Tests that a comment value keeps its escapes.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_comment_value
+	 */
+	public function test_comment_value_keeps_escapes( string $css, string $expected ): void {
+		$processor = new WP_CSS_Token_Processor( $css );
+		$this->assertTrue( $processor->next_token() );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_COMMENT, $processor->get_token_type() );
+
+		$this->assertSame( $expected, $processor->get_token()->get_value() );
+	}
+
+	/**
+	 * Data provider for test_comment_value_keeps_escapes().
+	 *
+	 * @return array[]
+	 */
+	public static function data_comment_value(): array {
+		return array(
+			'escape'                => array( '/* \\41 */', ' \\41 ' ),
+			'newlines preprocessed' => array( "/*\\41\r\n\f*/", "\\41\n\n" ),
+		);
+	}
+
+	public function test_dimension_token_value(): void {
+		$css           = '10px;15em;20%;30pt;40pc;50vw;';
+		$expected      = array(
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_DIMENSION,
+				'raw'   => '10px',
+				'value' => '10',
+				'unit'  => 'px',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'   => ';',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_DIMENSION,
+				'raw'   => '15em',
+				'value' => '15',
+				'unit'  => 'em',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'   => ';',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_PERCENTAGE,
+				'raw'   => '20%',
+				'value' => '20',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'   => ';',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_DIMENSION,
+				'raw'   => '30pt',
+				'value' => '30',
+				'unit'  => 'pt',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'   => ';',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_DIMENSION,
+				'raw'   => '40pc',
+				'value' => '40',
+				'unit'  => 'pc',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'   => ';',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_DIMENSION,
+				'raw'   => '50vw',
+				'value' => '50',
+				'unit'  => 'vw',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'   => ';',
+				'value' => null,
+			),
+		);
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw', 'value', 'unit' ) );
+		$this->assertSame( $expected, $actual_tokens );
+	}
+
+	/**
+	 * Tests escape sequences in unusual and edge-case positions.
+	 *
+	 * Covers:
+	 * - Multiple consecutive escapes
+	 * - Escapes in function names
+	 * - Escapes in at-keywords
+	 * - Escapes in dimension units
+	 * - Null byte escapes (\0)
+	 * - Escaped special characters (@, #, !, etc.)
+	 * - Escaped whitespace that gets consumed by the escape
+	 * - Unicode escapes for various characters
+	 */
+	public function test_escape_sequences_in_unusual_places() {
+		// Complex CSS with escapes in many unusual but valid positions
+		$css = '@\\6D edia ' . // @media with \6D (m) and space consumed
+				'\\73 creen ' . // screen with \73 (s) and space consumed
+				'{' .
+				' .\\63 l\\61 ss\\5F name ' . // .class_name with escapes and spaces consumed
+				"#\\69 d\\5C 0test\x00 " . // #id\0test with null byte escape (should be preserved)
+														// AND an actual null byte (should be replaced with a U+FFFD REPLACEMENT CHARACTER)
+				'{' .
+				' c\\6F lor: ' . // color: with \6F (o) and space consumed
+				'r\\65 d ' . // red with escape
+				'\\21 important;' . // !important with escaped !
+				' w\\69 dth: ' . // width:
+				'10\\70 x;' . // 10px (dimension with escaped unit)
+				' background: ' .
+				'\\75 rl(' . // url( with escaped u
+				'"p\\61 th\\2F img\\2E png"' . // "path/img.png" with escapes
+				');' .
+				' content: "\\5C \\5C ";' . // "\\ \\" - escaped backslashes
+				' font-family: \\22 Arial\\22 ;' . // "Arial" with escaped quotes
+				' }' .
+				'}';
+
+		$expected = array(
+			// @\6D edia -> @media
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_AT_KEYWORD,
+				'raw'   => '@\\6D edia',
+				'value' => 'media',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => ' ',
+				'value' => null,
+			),
+			// \73 creen -> screen
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'   => '\\73 creen',
+				'value' => 'screen',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => ' ',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_LEFT_BRACE,
+				'raw'   => '{',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => ' ',
+				'value' => null,
+			),
+			// Delimiter .
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'   => '.',
+				'value' => '.',
+			),
+			// \63 l\61 ss\5F name -> class_name
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'   => '\\63 l\\61 ss\\5F name',
+				'value' => 'class_name',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => ' ',
+				'value' => null,
+			),
+			// #\69 d\5C 0test -> #id\0test (with encoded null byte)
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_HASH,
+				'raw'   => "#\\69 d\\5C 0test\x00",
+				// Ensure the value is normalized.
+				'value' => "id\\0test�",
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => ' ',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_LEFT_BRACE,
+				'raw'   => '{',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => ' ',
+				'value' => null,
+			),
+			// c\6F lor -> color
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'   => 'c\\6F lor',
+				'value' => 'color',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'   => ':',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => ' ',
+				'value' => null,
+			),
+			// r\65 d -> red
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'   => 'r\\65 d',
+				'value' => 'red',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => ' ',
+				'value' => null,
+			),
+			// \21 important -> !important (single identifier with escaped !)
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'   => '\\21 important',
+				'value' => '!important',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'   => ';',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => ' ',
+				'value' => null,
+			),
+			// w\69 dth -> width
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'   => 'w\\69 dth',
+				'value' => 'width',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'   => ':',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => ' ',
+				'value' => null,
+			),
+			// 10\70 x -> 10px (dimension with escaped unit)
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_DIMENSION,
+				'raw'   => '10\\70 x',
+				'value' => '10',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'   => ';',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => ' ',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'   => 'background',
+				'value' => 'background',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'   => ':',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => ' ',
+				'value' => null,
+			),
+			// \75 rl( -> url( (escaped function name)
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_FUNCTION,
+				'raw'   => '\\75 rl(',
+				'value' => 'url',
+			),
+			// String with escapes: "p\61 th\2F img\2E png"
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_STRING,
+				'raw'   => '"p\\61 th\\2F img\\2E png"',
+				'value' => 'path/img.png',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN,
+				'raw'   => ')',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'   => ';',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => ' ',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'   => 'content',
+				'value' => 'content',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'   => ':',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => ' ',
+				'value' => null,
+			),
+			// String with escaped backslashes: "\5C \5C " -> "\\"
+			// Each \5C sequence (with trailing space consumed) becomes one backslash
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_STRING,
+				'raw'   => '"\\5C \\5C "',
+				'value' => '\\\\',  // Two backslashes total
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'   => ';',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => ' ',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'   => 'font-family',
+				'value' => 'font-family',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_COLON,
+				'raw'   => ':',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => ' ',
+				'value' => null,
+			),
+			// \22 Arial\22 -> "Arial" (escaped quotes make it an ident)
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_IDENT,
+				'raw'   => '\\22 Arial\\22 ',
+				'value' => '"Arial"',
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_SEMICOLON,
+				'raw'   => ';',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_WHITESPACE,
+				'raw'   => ' ',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_RIGHT_BRACE,
+				'raw'   => '}',
+				'value' => null,
+			),
+			array(
+				'type'  => WP_CSS_Token_Processor::TOKEN_RIGHT_BRACE,
+				'raw'   => '}',
+				'value' => null,
+			),
+		);
+
+		$actual_tokens = $this->collect_tokens( $css, array( 'type', 'raw', 'value' ) );
+		$this->assertSame( $expected, $actual_tokens );
+	}
+
+	/**
+	 * Tests that decode_range() respects the token's length boundary.
+	 *
+	 * The escape sequence \41 (= "A") triggers the slow path. The CSS after
+	 * the closing quote must not appear in the token value.
+	 */
+	public function test_decode_range_respects_length_boundary(): void {
+		$processor = new WP_CSS_Token_Processor( '"hello\\41 world"; color: red;' );
+
+		$this->assertTrue( $processor->next_token() );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_STRING, $processor->get_token_type() );
+		$this->assertSame( 'helloAworld', $processor->get_token()->get_value() );
+	}
+
+	/**
+	 * Tests that decode_escape_at() consumes at most six hex digits.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#consume-escaped-code-point
+	 */
+	public function test_decode_escape_at_hex_limit_is_six_digits(): void {
+		$processor = new WP_CSS_Token_Processor( '"\\0000411rest"' );
+
+		$this->assertTrue( $processor->next_token() );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_STRING, $processor->get_token_type() );
+		$this->assertSame( 'A1rest', $processor->get_token()->get_value() );
+	}
+
+	/**
+	 * Test bounds check when consuming and ident start token.
+	 */
+	public function test_ident_start_codepoint_bounds_check(): void {
+		$actual_tokens   = $this->collect_tokens( '-', array( 'type', 'raw' ) );
+		$expected_tokens = array(
+			array(
+				'type' => WP_CSS_Token_Processor::TOKEN_DELIM,
+				'raw'  => '-',
+			),
+		);
+		$this->assertSame( $expected_tokens, $actual_tokens );
+	}
+}
diff --git a/tests/phpunit/tests/css-api/wpCssTokenSerializer.php b/tests/phpunit/tests/css-api/wpCssTokenSerializer.php
new file mode 100644
index 0000000000000..07259163a8475
--- /dev/null
+++ b/tests/phpunit/tests/css-api/wpCssTokenSerializer.php
@@ -0,0 +1,585 @@
+<?php
+
+/**
+ * Tests for WP_CSS_Token_Serializer.
+ *
+ * @group css-api
+ *
+ * @coversDefaultClass WP_CSS_Token_Serializer
+ */
+class Tests_CssApi_WpCssTokenSerializer extends WP_UnitTestCase {
+	/**
+	 * Tests that serialize() escapes a string token again from its decoded value.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_string_escaping
+	 *
+	 * @covers ::serialize
+	 */
+	public function test_string_escaping( string $css, string $expected ): void {
+		$this->assertSame( $expected, WP_CSS_Token_Serializer::serialize( self::tokenize( $css ) ) );
+		$this->assertSame( self::significant_tokens( $css ), self::significant_tokens( $expected ), 'The output must read as the same tokens.' );
+	}
+
+	/**
+	 * Data provider for test_string_escaping().
+	 *
+	 * @return array[]
+	 */
+	public static function data_string_escaping(): array {
+		return array(
+			// Passthrough — no escaping needed, only quoting.
+			'empty string'            => array( "''", '""' ),
+			'simple ASCII'            => array( "'Arial'", '"Arial"' ),
+			'spaces preserved'        => array( "'Exo 2'", '"Exo 2"' ),
+			'leading/trailing spaces' => array( "'  Arial  '", '"  Arial  "' ),
+			'whitespace-only'         => array( "'   '", '"   "' ),
+			'numbers pass through'    => array( "'12345'", '"12345"' ),
+			'non-ASCII passthrough'   => array( "'café'", '"café"' ),
+
+			// Backslash escaping — must happen first to prevent double-escaping.
+			'backslash'               => array( '"Back\\\\Slash"', '"Back\\5c Slash"' ),
+			'double backslash'        => array( '"\\\\\\\\"', '"\\5c \\5c "' ),
+			'backslash before quote'  => array( '"a\\\\\'b"', '"a\\5c \\27 b"' ),
+
+			// NULL → U+FFFD replacement character.
+			'null byte'               => array( "\"a\x00b\"", '"a�b"' ),
+			'zero escape'             => array( '"a\\0 b"', '"a�b"' ),
+
+			// Control characters are escaped as code points; CR and FF are not normalized to LF.
+			'LF'                      => array( '"a\\A b"', '"a\\a b"' ),
+			'CR'                      => array( '"a\\D b"', '"a\\d b"' ),
+			'CRLF'                    => array( '"a\\D \\A b"', '"a\\d \\a b"' ),
+			'form feed'               => array( '"a\\C b"', '"a\\c b"' ),
+			'tab'                     => array( "\"a\tb\"", '"a\\9 b"' ),
+			'escaped tab'             => array( '"a\\9 b"', '"a\\9 b"' ),
+			'U+0001'                  => array( "\"a\x01b\"", '"a\\1 b"' ),
+			'U+001F'                  => array( '"a\\1F b"', '"a\\1f b"' ),
+			'delete'                  => array( "\"a\x7Fb\"", '"a\\7f b"' ),
+			'U+0080 is not escaped'   => array( '"a\\80 b"', "\"a\u{80}b\"" ),
+
+			// HTML-problematic characters.
+			'HTML characters < > &'   => array( '"a<b>c&d"', '"a\\3c b\\3e c\\26 d"' ),
+
+			// CSS-problematic characters.
+			'CSS syntax , ; { }'      => array( '"a,b;c{d}"', '"a\\2c b\\3b c\\7b d\\7d "' ),
+			'single quote'            => array( '"CSS\'s strings"', '"CSS\\27 s strings"' ),
+			'double quote'            => array( '\'Say "Hi"\'', '"Say \\22 Hi\\22 "' ),
+		);
+	}
+
+	/**
+	 * Tests the example in the serialize() docblock.
+	 *
+	 * @ticket 65738
+	 *
+	 * @covers ::serialize
+	 */
+	public function test_docblock_example(): void {
+		$this->assertSame(
+			'url(a\\26 b) calc(1px + 2px)',
+			WP_CSS_Token_Serializer::serialize( self::tokenize( 'url( a&b ) calc(1px  +  2px' ) )
+		);
+	}
+
+	/**
+	 * Tests WP_CSS_Token_Serializer::escape_ident() escapes CSS identifiers.
+	 *
+	 * @ticket 65738
+	 *
+	 * @dataProvider data_ident
+	 *
+	 * @covers ::escape_ident
+	 */
+	public function test_ident( string $input, string $expected ): void {
+		$serialized = WP_CSS_Token_Serializer::escape_ident( $input );
+		$this->assertSame( $expected, $serialized );
+
+		$processor = new WP_CSS_Token_Processor( $serialized );
+		if ( '' === $input ) {
+			$this->assertFalse( $processor->next_token() );
+			return;
+		}
+
+		$this->assertTrue( $processor->next_token() );
+		$this->assertSame( WP_CSS_Token_Processor::TOKEN_IDENT, $processor->get_token_type() );
+
+		$this->assertSame( str_replace( "\0", '�', $input ), $processor->get_token()->get_value() );
+		$this->assertFalse( $processor->next_token() );
+	}
+
+	/**
+	 * Data provider for test_ident().
+	 */
+	public static function data_ident(): Generator {
+		yield 'Empty identifier' => array( '', '' );
+
+		// Simple idents — no escaping needed.
+		yield 'Simple alpha ident' => array( 'serif', 'serif' );
+		yield 'Hyphenated ident' => array( 'sans-serif', 'sans-serif' );
+		yield 'Underscore prefix' => array( '_foo', '_foo' );
+		yield 'Single char' => array( 'a', 'a' );
+		yield 'Single hyphen' => array( '-', '\\2d ' );
+		yield 'Custom property prefix' => array( '--custom', '--custom' );
+		yield 'Non-ASCII' => array( 'café', 'café' );
+		yield 'Middle dot' => array( "a\u{B7}b", "a\u{B7}b" );
+		yield 'Zero width joiner' => array( "a\u{200D}b", "a\u{200D}b" );
+		yield 'Replacement character' => array( "a\u{FFFD}b", "a\u{FFFD}b" );
+		yield 'Supplementary plane' => array( "a\u{1F600}b", "a\u{1F600}b" );
+
+		// Non-ASCII code points outside the identifier code points — must be escaped.
+		yield 'Leading C1 control' => array( "\u{80}a", '\\80 a' );
+		yield 'No-break space within' => array( "a\u{A0}b", 'a\\a0 b' );
+		yield 'Multiplication sign within' => array( "a\u{D7}b", 'a\\d7 b' );
+		yield 'Greek question mark within' => array( "a\u{37E}b", 'a\\37e b' );
+		yield 'Zero width space within' => array( "a\u{200B}b", 'a\\200b b' );
+		yield 'U+FFFE within' => array( "a\u{FFFE}b", 'a\\fffe b' );
+
+		// Invalid ident starts — must be escaped.
+		yield 'Leading digits' => array( '123', '\\31 23' );
+		yield 'Leading digit with alpha' => array( '5foo', '\\35 foo' );
+		yield 'Hyphen then digit' => array( '-5px', '-\\35 px' );
+		yield 'Leading space' => array( ' leading-space', '\\20 leading-space' );
+		yield 'Leading tab' => array( "\tleading-tab", '\\9 leading-tab' );
+		yield 'Leading control character' => array( "\x01foo", '\\1 foo' );
+
+		// Whitespace within ident.
+		yield 'Space within' => array( 'My Font', 'My\\20 Font' );
+		yield 'Multiple spaces within' => array( 'a b c', 'a\\20 b\\20 c' );
+		yield 'Tab within' => array( "has\ttab", 'has\\9 tab' );
+		yield 'Newline within' => array( "has\nnewline", 'has\\a newline' );
+		yield 'Carriage return within' => array( "has\rreturn", 'has\\d return' );
+		yield 'NULL byte within' => array( "has\0null", 'has�null' );
+		yield 'DEL within' => array( "has\x7Fdelete", 'has\\7f delete' );
+
+		// Special characters.
+		yield 'Apostrophe' => array( "Font's", 'Font\\27 s' );
+		yield 'Angle brackets' => array( '<html>', '\\3c html\\3e ' );
+		yield 'Comma' => array( 'a,b', 'a\\2c b' );
+		yield 'Semicolon' => array( 'a;b', 'a\\3b b' );
+		yield 'Backslash' => array( 'a\\b', 'a\\5c b' );
+	}
+
+	/**
+	 * Tests that serialize() writes an empty CSS comment between the tokens of a marked pair.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_marked_pairs
+	 *
+	 * @covers ::serialize
+	 */
+	public function test_marked_pair_is_separated_by_an_empty_comment( string $css, string $expected ): void {
+		$this->assertSame( $expected, WP_CSS_Token_Serializer::serialize( self::tokenize( $css ) ) );
+		$this->assertSame( self::significant_tokens( $css ), self::significant_tokens( $expected ), 'The output must read as the same tokens.' );
+	}
+
+	/**
+	 * Data provider for test_marked_pair_is_separated_by_an_empty_comment().
+	 *
+	 * One case for each ✗ cell in the table in CSS Syntax Level 3 §9.
+	 *
+	 * @link https://www.w3.org/TR/css-syntax-3/#serialization
+	 *
+	 * @return Generator
+	 */
+	public static function data_marked_pairs(): Generator {
+		// Source text for the first token, keyed by its row heading.
+		$rows = array(
+			'ident'      => 'a',
+			'at-keyword' => '@a',
+			'hash'       => '#a',
+			'dimension'  => '1px',
+			'#'          => '#',
+			'-'          => '-',
+			'number'     => '1',
+			'@'          => '@',
+			'.'          => '.',
+			'+'          => '+',
+			'/'          => '/',
+		);
+
+		// Source text and its serialization for the second token, keyed by its column heading.
+		$columns = array(
+			'ident'      => array( 'b', 'b' ),
+			'function'   => array( 'b()', 'b()' ),
+			'url'        => array( 'url(b)', 'url(b)' ),
+			'bad url'    => array( 'url(b c)', 'url(()' ),
+			'-'          => array( '-', '-' ),
+			'number'     => array( '2', '2' ),
+			'percentage' => array( '2%', '2%' ),
+			'dimension'  => array( '2px', '2px' ),
+			'CDC'        => array( '-->', '-->' ),
+			'('          => array( '()', '()' ),
+			'*'          => array( '*', '*' ),
+			'%'          => array( '%', '%' ),
+		);
+
+		$marked = array(
+			'ident'      => array( 'ident', 'function', 'url', 'bad url', '-', 'number', 'percentage', 'dimension', 'CDC', '(' ),
+			'at-keyword' => array( 'ident', 'function', 'url', 'bad url', '-', 'number', 'percentage', 'dimension', 'CDC' ),
+			'hash'       => array( 'ident', 'function', 'url', 'bad url', '-', 'number', 'percentage', 'dimension', 'CDC' ),
+			'dimension'  => array( 'ident', 'function', 'url', 'bad url', '-', 'number', 'percentage', 'dimension', 'CDC' ),
+			'#'          => array( 'ident', 'function', 'url', 'bad url', '-', 'number', 'percentage', 'dimension', 'CDC' ),
+			'-'          => array( 'ident', 'function', 'url', 'bad url', '-', 'number', 'percentage', 'dimension', 'CDC' ),
+			'number'     => array( 'ident', 'function', 'url', 'bad url', 'number', 'percentage', 'dimension', 'CDC', '%' ),
+			'@'          => array( 'ident', 'function', 'url', 'bad url', '-', 'CDC' ),
+			'.'          => array( 'number', 'percentage', 'dimension' ),
+			'+'          => array( 'number', 'percentage', 'dimension' ),
+			'/'          => array( '*' ),
+		);
+
+		foreach ( $marked as $row => $row_columns ) {
+			foreach ( $row_columns as $column ) {
+				list( $column_css, $column_serialized ) = $columns[ $column ];
+				yield "{$row} followed by {$column}" => array(
+					"{$rows[ $row ]}/**/{$column_css}",
+					"{$rows[ $row ]}/**/{$column_serialized}",
+				);
+			}
+		}
+	}
+
+	/**
+	 * Tests that serialize() writes no comment between the tokens of an unmarked pair.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_unmarked_pairs
+	 *
+	 * @covers ::serialize
+	 */
+	public function test_unmarked_pair_is_not_separated( string $css, string $expected ): void {
+		$this->assertSame( $expected, WP_CSS_Token_Serializer::serialize( self::tokenize( $css ) ) );
+		$this->assertSame( self::significant_tokens( $css ), self::significant_tokens( $expected ), 'The output must read as the same tokens.' );
+	}
+
+	/**
+	 * Data provider for test_unmarked_pair_is_not_separated().
+	 *
+	 * @return array[]
+	 */
+	public static function data_unmarked_pairs(): array {
+		return array(
+			'ident followed by *'          => array( 'a/**/*', 'a*' ),
+			'ident followed by %'          => array( 'a/**/%', 'a%' ),
+			'ident followed by colon'      => array( 'a/**/:', 'a:' ),
+			'at-keyword followed by ('     => array( '@a/**/()', '@a()' ),
+			'hash followed by *'           => array( '#a/**/*', '#a*' ),
+			'dimension followed by %'      => array( '1px/**/%', '1px%' ),
+			'# followed by %'              => array( '#/**/%', '#%' ),
+			'- followed by *'              => array( '-/**/*', '-*' ),
+			'number followed by -'         => array( '1/**/-', '1-' ),
+			'number followed by ('         => array( '1/**/()', '1()' ),
+			'@ followed by number'         => array( '@/**/1', '@1' ),
+			'. followed by ident'          => array( './**/a', '.a' ),
+			'+ followed by ident'          => array( '+/**/a', '+a' ),
+			'/ followed by ident'          => array( '//**/a', '/a' ),
+			'string followed by ident'     => array( '"a"/**/b', '"a"b' ),
+			'url followed by ident'        => array( 'url(a)/**/b', 'url(a)b' ),
+			'function followed by ident'   => array( 'a(/**/b)', 'a(b)' ),
+			') followed by ident'          => array( '(a)/**/b', '(a)b' ),
+			'CDC followed by ident'        => array( '-->/**/a', '-->a' ),
+			'percentage followed by ident' => array( '1%/**/a', '1%a' ),
+		);
+	}
+
+	/**
+	 * Tests that serialize() drops comments and writes each whitespace run as one space.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_whitespace_and_comments
+	 *
+	 * @covers ::serialize
+	 */
+	public function test_whitespace_and_comments( string $css, string $expected ): void {
+		$this->assertSame( $expected, WP_CSS_Token_Serializer::serialize( self::tokenize( $css ) ) );
+	}
+
+	/**
+	 * Data provider for test_whitespace_and_comments().
+	 *
+	 * @return array[]
+	 */
+	public static function data_whitespace_and_comments(): array {
+		return array(
+			'empty input'               => array( '', '' ),
+			'one space'                 => array( 'a b', 'a b' ),
+			'mixed whitespace run'      => array( "a \t\r\n\f b", 'a b' ),
+			'run broken by a comment'   => array( 'a /* x */ b', 'a b' ),
+			'whitespace then a comment' => array( 'a /**/b', 'a b' ),
+			'a comment then whitespace' => array( 'a/**/ b', 'a b' ),
+			'leading whitespace'        => array( "\n a", ' a' ),
+			'trailing whitespace'       => array( "a \n", 'a ' ),
+			'only whitespace'           => array( "\t\n", ' ' ),
+			'only a comment'            => array( '/* x */', '' ),
+			'comment in unmarked pair'  => array( 'a/* x */,b', 'a,b' ),
+			'unterminated comment'      => array( 'a /* x', 'a ' ),
+		);
+	}
+
+	/**
+	 * Tests how serialize() writes each token type.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_token_serialization
+	 *
+	 * @covers ::serialize
+	 */
+	public function test_token_serialization( string $css, string $expected ): void {
+		$this->assertSame( $expected, WP_CSS_Token_Serializer::serialize( self::tokenize( $css ) ) );
+		$this->assertSame( self::significant_tokens( $css ), self::significant_tokens( $expected ), 'The output must read as the same tokens.' );
+	}
+
+	/**
+	 * Data provider for test_token_serialization().
+	 *
+	 * @return array[]
+	 */
+	public static function data_token_serialization(): array {
+		return array(
+			'ident escapes decoded'                  => array( '\\66 oo', 'foo' ),
+			'ident escapes added'                    => array( 'a\\:b', 'a\\3a b' ),
+			'function'                               => array( '\\66 oo(1)', 'foo(1)' ),
+			'at-keyword'                             => array( '@\\66 oo', '@foo' ),
+			'hash id'                                => array( '#a\\:', '#a\\3a ' ),
+			'hash id escaped digit'                  => array( '#\\31 a', '#\\31 a' ),
+			'hash unrestricted'                      => array( '#1a', '#1a' ),
+			'hash unrestricted escape'               => array( '#1\\:', '#1\\3a ' ),
+			'hash unrestricted hyphen'               => array( '#-', '#-' ),
+			'hash id non-ident code point'           => array( '#a\\d7 b', '#a\\d7 b' ),
+			'hash unrestricted non-ident code point' => array( '#1\\d7 b', '#1\\d7 b' ),
+			'dimension unit non-ident code point'    => array( '1\\a0 b', '1\\a0 b' ),
+			'string'                                 => array( "'a\"b'", '"a\\22 b"' ),
+			'string unterminated'                    => array( '"abc', '"abc"' ),
+			'bad string'                             => array( "'a\nb", "\"\n b" ),
+			'url'                                    => array( 'url( a )', 'url(a)' ),
+			'url empty'                              => array( 'url()', 'url()' ),
+			'url escaped parenthesis'                => array( 'url(a\\29 b)', 'url(a\\29 b)' ),
+			'url escaped space'                      => array( 'url(a\\20 b)', 'url(a\\20 b)' ),
+			'url escaped quote'                      => array( 'url(a\\"b)', 'url(a\\22 b)' ),
+			'url escaped backslash'                  => array( 'url(a\\\\b)', 'url(a\\5c b)' ),
+			'url escaped control'                    => array( 'url(a\\1 b)', 'url(a\\1 b)' ),
+			'url escaped newline'                    => array( 'url(a\\A b)', 'url(a\\a b)' ),
+			'url ampersand'                          => array( 'url(a&b)', 'url(a\\26 b)' ),
+			'url NUL'                                => array( "url(a\x00b)", "url(a\u{FFFD}b)" ),
+			'url unterminated'                       => array( 'url(a', 'url(a)' ),
+			'url function with a string'             => array( "url( 'a')", 'url( "a")' ),
+			'bad url'                                => array( 'url(a b)', 'url(()' ),
+			'number'                                 => array( '+.5e-3', '+.5e-3' ),
+			'percentage'                             => array( '-1.5%', '-1.5%' ),
+			'dimension'                              => array( '1.5e3PX', '1.5e3PX' ),
+			'dimension unit escape'                  => array( '1\\2D ', '1\\2d ' ),
+			'dimension unit read as exponent'        => array( '1\\65 3', '1\\65 3' ),
+			'dimension unit read as signed exponent' => array( '1\\45 -3', '1\\45 -3' ),
+			'dimension unit e'                       => array( '1e', '1e' ),
+			'backslash delim keeps newline'          => array( "a\\\nb", "a\\\n b" ),
+			'delim'                                  => array( '!', '!' ),
+			'DEL delim'                              => array( "a\x7Fb", "a\x7Fb" ),
+			'CDO and CDC'                            => array( '<!-- -->', '<!-- -->' ),
+			'punctuation'                            => array( 'a:b;c,d', 'a:b;c,d' ),
+		);
+	}
+
+	/**
+	 * Tests that serialize() does not spell a CDO or CDC token from other tokens.
+	 *
+	 * The table in CSS Syntax Level 3 §9 compares token pairs by type. It does
+	 * not cover `<`, `!` and a token that starts with `--`, which spell `<!--`,
+	 * or an ident `--` followed by `>`, which spell `-->`.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_cdo_and_cdc_sequences
+	 *
+	 * @covers ::serialize
+	 */
+	public function test_cdo_and_cdc_are_not_spelled( string $css, string $expected ): void {
+		$this->assertSame( $expected, WP_CSS_Token_Serializer::serialize( self::tokenize( $css ) ) );
+		$this->assertSame( self::significant_tokens( $css ), self::significant_tokens( $expected ), 'The output must read as the same tokens.' );
+	}
+
+	/**
+	 * Data provider for test_cdo_and_cdc_are_not_spelled().
+	 *
+	 * @return array[]
+	 */
+	public static function data_cdo_and_cdc_sequences(): array {
+		return array(
+			'< ! ident'                 => array( '<!/**/--x', '<!/**/--x' ),
+			'< ! ident --'              => array( '<!/**/--', '<!/**/--' ),
+			'< ! function'              => array( '<!/**/--x()', '<!/**/--x()' ),
+			'< ! CDC'                   => array( '<!/**/-->', '<!/**/-->' ),
+			'ident -- >'                => array( '--/**/>', '--/**/>' ),
+			'< space ! ident'           => array( '< !/**/--x', '< !--x' ),
+			'! ident without <'         => array( 'a!/**/--x', 'a!--x' ),
+			'< ! ident without --'      => array( '<!/**/x', '<!x' ),
+			'ident ending in -- then >' => array( 'a--/**/>', 'a-->' ),
+			'ident -- space >'          => array( '-- >', '-- >' ),
+		);
+	}
+
+	/**
+	 * Tests that serialize() closes blocks still open at the end, in reverse order.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_open_blocks
+	 *
+	 * @covers ::serialize
+	 */
+	public function test_open_blocks_are_closed( string $css, string $expected ): void {
+		$this->assertSame( $expected, WP_CSS_Token_Serializer::serialize( self::tokenize( $css ) ) );
+	}
+
+	/**
+	 * Data provider for test_open_blocks_are_closed().
+	 *
+	 * @return array[]
+	 */
+	public static function data_open_blocks(): array {
+		return array(
+			'function'               => array( 'calc(1px', 'calc(1px)' ),
+			'nested blocks'          => array( 'a(b[c{d', 'a(b[c{d}])' ),
+			'closed block'           => array( '(a)', '(a)' ),
+			'mismatched closer'      => array( '(]', '(])' ),
+			'closer without a block' => array( ')', ')' ),
+			'brace'                  => array( '{', '{}' ),
+			'function with a string' => array( 'url("a"', 'url("a")' ),
+			'inner block closed'     => array( 'a((b)', 'a((b))' ),
+		);
+	}
+
+	/**
+	 * Tests that the hash type flag is preserved.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_hash_flag_round_trips
+	 *
+	 * @covers ::serialize
+	 */
+	public function test_hash_flag_round_trips( string $css, string $expected_flag ): void {
+		$tokens     = self::tokenize( $css );
+		$serialized = WP_CSS_Token_Serializer::serialize( $tokens );
+		$reparsed   = self::tokenize( $serialized );
+
+		$this->assertSame( $expected_flag, $tokens[0]->get_flag(), 'The input has the wrong type flag.' );
+		$this->assertCount( 1, $reparsed, 'The hash must serialize as one token.' );
+		$this->assertSame( $tokens[0]->get_value(), $reparsed[0]->get_value(), 'The value changed.' );
+		$this->assertSame( $expected_flag, $reparsed[0]->get_flag(), 'The type flag changed.' );
+	}
+
+	/**
+	 * Data provider for test_hash_flag_round_trips().
+	 *
+	 * @return array[]
+	 */
+	public static function data_hash_flag_round_trips(): array {
+		return array(
+			'id with an escaped digit' => array( '#\\31 a', WP_CSS_Token_Processor::HASH_TOKEN_ID ),
+			'id'                       => array( '#a1', WP_CSS_Token_Processor::HASH_TOKEN_ID ),
+			'id starting with --'      => array( '#--', WP_CSS_Token_Processor::HASH_TOKEN_ID ),
+			'unrestricted digit'       => array( '#1a', WP_CSS_Token_Processor::HASH_TOKEN_UNRESTRICTED ),
+			'unrestricted - and digit' => array( '#-1', WP_CSS_Token_Processor::HASH_TOKEN_UNRESTRICTED ),
+			'unrestricted lone -'      => array( '#-', WP_CSS_Token_Processor::HASH_TOKEN_UNRESTRICTED ),
+		);
+	}
+
+	/**
+	 * Tests that serialize() accepts any iterable, such as a generator.
+	 *
+	 * @ticket 65738
+	 *
+	 * @covers ::serialize
+	 */
+	public function test_serialize_accepts_a_generator(): void {
+		$generator = ( static function ( string $css ): Generator {
+			$processor = new WP_CSS_Token_Processor( $css );
+			while ( $processor->next_token() ) {
+				yield $processor->get_token();
+			}
+		} )( 'a /* x */ b(' );
+
+		$this->assertSame( 'a b()', WP_CSS_Token_Serializer::serialize( $generator ) );
+	}
+
+	/**
+	 * Tests that serializing the corpus round-trips and is idempotent.
+	 *
+	 * The output must read as the input tokens, except that comments are dropped,
+	 * whitespace runs are collapsed, and blocks still open are closed.
+	 *
+	 * @ticket 65738
+	 * @dataProvider data_corpus
+	 *
+	 * @covers ::serialize
+	 */
+	public function test_corpus_round_trips( string $css ): void {
+		$serialized = WP_CSS_Token_Serializer::serialize( self::tokenize( $css ) );
+
+		$expected = self::significant_tokens( $css );
+		$actual   = self::significant_tokens( $serialized );
+		$closers  = array_splice( $actual, count( $expected ) );
+
+		$this->assertSame( $expected, $actual, 'The output must read as the same tokens.' );
+		foreach ( $closers as $closer ) {
+			$this->assertContains(
+				$closer[0],
+				array( WP_CSS_Token_Processor::TOKEN_RIGHT_PAREN, WP_CSS_Token_Processor::TOKEN_RIGHT_BRACKET, WP_CSS_Token_Processor::TOKEN_RIGHT_BRACE ),
+				'Only block closers may follow the input tokens.'
+			);
+		}
+		$this->assertSame( $serialized, WP_CSS_Token_Serializer::serialize( self::tokenize( $serialized ) ), 'Serialization must be idempotent.' );
+	}
+
+	/**
+	 * Data provider for test_corpus_round_trips().
+	 *
+	 * @return array[]
+	 */
+	public static function data_corpus(): array {
+		$cases = json_decode( file_get_contents( DIR_TESTDATA . '/css-api/css-test-cases.json' ), true );
+		return array_map(
+			static function ( array $test_case ): array {
+				return array( $test_case['css'] );
+			},
+			$cases
+		);
+	}
+
+	/**
+	 * Tokenizes CSS.
+	 *
+	 * @param string $css CSS text.
+	 * @return WP_CSS_Token[] Tokens.
+	 */
+	private static function tokenize( string $css ): array {
+		$processor = new WP_CSS_Token_Processor( $css );
+		$tokens    = array();
+		while ( $processor->next_token() ) {
+			$tokens[] = $processor->get_token();
+		}
+		return $tokens;
+	}
+
+	/**
+	 * Tokenizes CSS for comparison: comments are dropped, and each run of
+	 * whitespace and comments that includes whitespace is one whitespace token.
+	 *
+	 * @param string $css CSS text.
+	 * @return array[] Type, flag, value and unit of each token.
+	 */
+	private static function significant_tokens( string $css ): array {
+		$tokens = array();
+		foreach ( self::tokenize( $css ) as $token ) {
+			$type = $token->get_type();
+			if ( WP_CSS_Token_Processor::TOKEN_COMMENT === $type ) {
+				continue;
+			}
+			if ( WP_CSS_Token_Processor::TOKEN_WHITESPACE === $type ) {
+				if ( array( $type ) !== end( $tokens ) ) {
+					$tokens[] = array( $type );
+				}
+				continue;
+			}
+			$tokens[] = array( $type, $token->get_flag(), $token->get_value(), $token->get_unit() );
+		}
+		return $tokens;
+	}
+}