WP_HTML_Decoder::attribute_starts_with( string $haystack, string $search_text, string $case_sensitivity = 'case-sensitive' ): bool

37	public static function attribute_starts_with( $haystack, $search_text, $case_sensitivity = 'case-sensitive' ): bool {38		$search_length = strlen( $search_text );39		$loose_case    = 'ascii-case-insensitive' === $case_sensitivity;40		$haystack_end  = strlen( $haystack );41		$search_at     = 0;42		$haystack_at   = 0;43 44		while ( $search_at < $search_length && $haystack_at < $haystack_end ) {45			$chars_match = $loose_case46				? strtolower( $haystack[ $haystack_at ] ) === strtolower( $search_text[ $search_at ] )47				: $haystack[ $haystack_at ] === $search_text[ $search_at ];48 49			$is_introducer = '&' === $haystack[ $haystack_at ];50			$next_chunk    = $is_introducer51				? self::read_character_reference( 'attribute', $haystack, $haystack_at, $token_length )52				: null;53 54			// If there's no character reference and the characters don't match, the match fails.55			if ( null === $next_chunk && ! $chars_match ) {56				return false;57			}58 59			// If there's no character reference but the characters do match, then it could still match.60			if ( null === $next_chunk && $chars_match ) {61				++$haystack_at;62				++$search_at;63				continue;64			}65 66			/**67			 * The decoded character reference in `$next_chunk` must be compared with the68			 * corresponding `$search_text` bytes checking for matching prefixes. The remaining69			 * search text may be shorter than the decoded chunk, in which case a partial match70			 * satisfies the prefix. Otherwise, if the decoded chunk is fully matched, the71			 * comparison must continue after advancing the appropriate byte lengths: the character72			 * reference token length in the haystack and the decoded chunk length in the73			 * search text.74			 *75			 * For example, consider searches that have reached the character reference76			 * `&fjlig;` (7 bytes), decoded into the 2-byte chunk `fj`:77			 *78			 *                       $haystack_at79			 *                       │80			 *                       │      ┌─after matching `fj` continue here81			 *                       │      │ (advance by $token_length, 7 bytes)82			 *                       ↓      ↓83			 *     Haystack:    start&fjlig;ord84			 *                       ╰──┬──╯85			 *                          fj - the decoded chunk, tested against the search text.86			 *87			 *                       $search_at88			 *                       │89			 *                       │ ┌─after matching `fj` continue here90			 *                       │ │ (advance by $match_length, 2 bytes)91			 *                       ↓ ↓92			 *     Search A:    startfjord      Compare 2 bytes: `fj` matches,93			 *                                  continue matching at `o`.94			 *95			 *                       $search_at96			 *                       ↓97			 *     Search B:    startf          Compare 1 byte: `f` matches and the98			 *                                  search text is exhausted — prefix confirmed.99			 *100			 *                       $search_at101			 *                       ↓102			 *     Search C:    startfr         Compare 2 bytes: `fj` differs103			 *                                  from `fr`, no match is possible.104			 *105			 * The `min()` is required in both directions: Search A fails if the106			 * comparison length comes from the search text, Search B if it comes107			 * from the chunk.108			 *109			 * After a match each cursor must advance by the appropriate length, the haystack110			 * cursor by the character reference token length, and the search cursor by the111			 * matched length.112			 */113			$match_length = min( strlen( $next_chunk ), $search_length - $search_at );114			if ( 0 !== substr_compare( $search_text, $next_chunk, $search_at, $match_length, $loose_case ) ) {115				return false;116			}