<?php
/**
 * @file
 * @license https://opensource.org/licenses/Apache-2.0 Apache-2.0
 */

namespace Wikimedia\CSS\Parser;

use Wikimedia\CSS\Objects\Token;

/**
 * Parse CSS into tokens
 *
 * This implements the tokenizer from the CSS Syntax Module Level 3 candidate recommendation.
 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/
 */
class DataSourceTokenizer implements Tokenizer {

	/** @var DataSource */
	protected $source;

	/** @var int position in the input */
	protected $line = 1, $pos = 0;

	/** @var string|null|object The most recently consumed character */
	protected $currentCharacter = null;

	/** @var string|null The next character to be consumed */
	protected $nextCharacter = null;

	/** @var array Parse errors. Each error is [ string $tag, int $line, int $pos ] */
	protected $parseErrors = [];

	/**
	 * @param DataSource $source
	 * @param array $options Configuration options.
	 *  (none currently defined)
	 */
	public function __construct( DataSource $source, array $options = [] ) {
		$this->source = $source;
	}

	/**
	 * Read a character from the data source
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#input-preprocessing
	 * @return string One UTF-8 character, or empty string on EOF
	 */
	protected function nextChar() {
		$char = $this->source->readCharacter();

		// Perform transformations per the spec

		// Any U+0000 becomes U+FFFD
		if ( $char === "\0" ) {
			return \UtfNormal\Constants::UTF8_REPLACEMENT;
		}

		// Any U+000D, U+000C, or pair of U+000D + U+000A becomes U+000A
		if ( $char === "\f" ) { // U+000C
			return "\n";
		}

		if ( $char === "\r" ) { // Either U+000D + U+000A or a lone U+000D
			$char2 = $this->source->readCharacter();
			if ( $char2 !== "\n" ) {
				$this->source->putBackCharacter( $char2 );
			}
			return "\n";
		}

		return $char;
	}

	/**
	 * Update the current and next character fields
	 */
	protected function consumeCharacter() {
		if ( $this->currentCharacter === "\n" ) {
			$this->line++;
			$this->pos = 1;
		} elseif ( $this->currentCharacter !== DataSource::EOF ) {
			$this->pos++;
		}

		$this->currentCharacter = $this->nextChar();
		$this->nextCharacter = $this->nextChar();
		$this->source->putBackCharacter( $this->nextCharacter );
	}

	/**
	 * Reconsume the next character
	 *
	 * In more normal terms, this pushes a character back onto the data source
	 * so it will be read again for the next call to self::consumeCharacter().
	 */
	protected function reconsumeCharacter() {
		// @codeCoverageIgnoreStart
		if ( !is_string( $this->currentCharacter ) ) {
			throw new \UnexpectedValueException( "[$this->line:$this->pos] Can't reconsume" );
		}
		// @codeCoverageIgnoreEnd

		if ( $this->currentCharacter === DataSource::EOF ) {
			// Huh?
			return;
		}

		$this->source->putBackCharacter( $this->currentCharacter );
		$this->nextCharacter = $this->currentCharacter;
		$this->currentCharacter = (object)[];
		$this->pos--;
	}

	/**
	 * Look ahead at the next three characters
	 * @return string[] Three characters
	 */
	protected function lookAhead() {
		$ret = [
			$this->nextChar(),
			$this->nextChar(),
			$this->nextChar(),
		];
		$this->source->putBackCharacter( $ret[2] );
		$this->source->putBackCharacter( $ret[1] );
		$this->source->putBackCharacter( $ret[0] );

		return $ret;
	}

	public function getParseErrors() {
		return $this->parseErrors;
	}

	public function clearParseErrors() {
		$this->parseErrors = [];
	}

	/**
	 * Record a parse error
	 * @param string $tag Error tag
	 * @param array|null $position Report the error as starting at this
	 *  position instead of at the current position.
	 * @param array $data Extra data about the error.
	 */
	protected function parseError( $tag, array $position = null, array $data = [] ) {
		if ( $position ) {
			if ( isset( $position['position'] ) ) {
				$position = $position['position'];
			}
			if ( count( $position ) !== 2 || !is_int( $position[0] ) || !is_int( $position[1] ) ) {
				// @codeCoverageIgnoreStart
				throw new InvalidArgumentException( 'Invalid position' );
				// @codeCoverageIgnoreEnd
			}
			$err = [ $tag, $position[0], $position[1] ];
		} else {
			$err = [ $tag, $this->line, $this->pos ];
		}
		$this->parseErrors[] = array_merge( $err, $data );
	}

	/**
	 * Read a token from the data source
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#consume-a-token
	 * @return Token
	 */
	public function consumeToken() {
		$this->consumeCharacter();
		$pos = [ 'position' => [ $this->line, $this->pos ] ];

		switch ( (string)$this->currentCharacter ) {
			case "\n":
			case "\t":
			case ' ':
				// Whitespace token
				while ( self::isWhitespace( $this->nextCharacter ) ) {
					$this->consumeCharacter();
				}
				return new Token( Token::T_WHITESPACE, $pos );

			case '"':
			case '\'':
				// String token
				return $this->consumeStringToken( $this->currentCharacter, $pos );

			case '#':
				list( $next, $next2, $next3 ) = $this->lookAhead();
				if ( self::isNameCharacter( $this->nextCharacter ) ||
					self::isValidEscape( $next, $next2 )
				) {
					return new Token( Token::T_HASH, $pos + [
						'typeFlag' => self::wouldStartIdentifier( $next, $next2, $next3 ) ? 'id' : 'unrestricted',
						'value' => $this->consumeName(),
					] );
				}

				return new Token( Token::T_DELIM, $pos + [ 'value' => $this->currentCharacter ] );

			case '$':
				if ( $this->nextCharacter === '=' ) {
					$this->consumeCharacter();
					return new Token( Token::T_SUFFIX_MATCH, $pos );
				}

				return new Token( Token::T_DELIM, $pos + [ 'value' => $this->currentCharacter ] );

			case '(':
				return new Token( Token::T_LEFT_PAREN, $pos );

			case ')':
				return new Token( Token::T_RIGHT_PAREN, $pos );

			case '*':
				if ( $this->nextCharacter === '=' ) {
					$this->consumeCharacter();
					return new Token( Token::T_SUBSTRING_MATCH, $pos );
				}

				return new Token( Token::T_DELIM, $pos + [ 'value' => $this->currentCharacter ] );

			case '+':
			case '.':
				list( $next, $next2, $next3 ) = $this->lookAhead();
				if ( self::wouldStartNumber( $this->currentCharacter, $next, $next2 ) ) {
					$this->reconsumeCharacter();
					return $this->consumeNumericToken( $pos );
				}

				return new Token( Token::T_DELIM, $pos + [ 'value' => $this->currentCharacter ] );

			case ',':
				return new Token( Token::T_COMMA, $pos );

			case '-':
				list( $next, $next2, $next3 ) = $this->lookAhead();
				if ( self::wouldStartNumber( $this->currentCharacter, $next, $next2 ) ) {
					$this->reconsumeCharacter();
					return $this->consumeNumericToken( $pos );
				}

				if ( $next === '-' && $next2 === '>' ) {
					$this->consumeCharacter();
					$this->consumeCharacter();
					return new Token( Token::T_CDC, $pos );
				}

				if ( self::wouldStartIdentifier( $this->currentCharacter, $next, $next2 ) ) {
					$this->reconsumeCharacter();
					return $this->consumeIdentLikeToken( $pos );
				}

				return new Token( Token::T_DELIM, $pos + [ 'value' => $this->currentCharacter ] );

			case '/':
				if ( $this->nextCharacter === '*' ) {
					$this->consumeCharacter();
					$this->consumeCharacter();
					while ( $this->currentCharacter !== DataSource::EOF &&
						!( $this->currentCharacter === '*' && $this->nextCharacter === '/' )
					) {
						$this->consumeCharacter();
					}
					if ( $this->currentCharacter === DataSource::EOF ) {
						// Parse error from the editor's draft as of 2017-01-06
						$this->parseError( 'unclosed-comment', $pos );
					}
					$this->consumeCharacter();
					return $this->consumeToken();
				}

				return new Token( Token::T_DELIM, $pos + [ 'value' => $this->currentCharacter ] );

			case ':':
				return new Token( Token::T_COLON, $pos );

			case ';':
				return new Token( Token::T_SEMICOLON, $pos );

			case '<':
				list( $next, $next2, $next3 ) = $this->lookAhead();
				if ( $next === '!' && $next2 === '-' && $next3 === '-' ) {
					$this->consumeCharacter();
					$this->consumeCharacter();
					$this->consumeCharacter();
					return new Token( Token::T_CDO, $pos );
				}

				return new Token( Token::T_DELIM, $pos + [ 'value' => $this->currentCharacter ] );

			case '@':
				list( $next, $next2, $next3 ) = $this->lookAhead();
				if ( self::wouldStartIdentifier( $next, $next2, $next3 ) ) {
					return new Token( Token::T_AT_KEYWORD, $pos + [ 'value' => $this->consumeName() ] );
				}

				return new Token( Token::T_DELIM, $pos + [ 'value' => $this->currentCharacter ] );

			case '[':
				return new Token( Token::T_LEFT_BRACKET, $pos );

			case '\\':
				if ( self::isValidEscape( $this->currentCharacter, $this->nextCharacter ) ) {
					$this->reconsumeCharacter();
					return $this->consumeIdentLikeToken( $pos );
				}

				$this->parseError( 'bad-escape' );
				return new Token( Token::T_DELIM, $pos + [ 'value' => $this->currentCharacter ] );

			case ']':
				return new Token( Token::T_RIGHT_BRACKET, $pos );

			case '^':
				if ( $this->nextCharacter === '=' ) {
					$this->consumeCharacter();
					return new Token( Token::T_PREFIX_MATCH, $pos );
				}

				return new Token( Token::T_DELIM, $pos + [ 'value' => $this->currentCharacter ] );

			case '{':
				return new Token( Token::T_LEFT_BRACE, $pos );

			case '}':
				return new Token( Token::T_RIGHT_BRACE, $pos );

			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
				$this->reconsumeCharacter();
				return $this->consumeNumericToken( $pos );

			case 'u':
			case 'U':
				if ( $this->nextCharacter === '+' ) {
					list( $next, $next2 ) = $this->lookAhead();
					if ( self::isHexDigit( $next2 ) || $next2 === '?' ) {
						$this->consumeCharacter();
						return $this->consumeUnicodeRangeToken( $pos );
					}
				}

				$this->reconsumeCharacter();
				return $this->consumeIdentLikeToken( $pos );

			case '|':
				if ( $this->nextCharacter === '=' ) {
					$this->consumeCharacter();
					return new Token( Token::T_DASH_MATCH, $pos );
				}

				if ( $this->nextCharacter === '|' ) {
					$this->consumeCharacter();
					return new Token( Token::T_COLUMN, $pos );
				}

				return new Token( Token::T_DELIM, $pos + [ 'value' => $this->currentCharacter ] );

			case '~':
				if ( $this->nextCharacter === '=' ) {
					$this->consumeCharacter();
					return new Token( Token::T_INCLUDE_MATCH, $pos );
				}

				return new Token( Token::T_DELIM, $pos + [ 'value' => $this->currentCharacter ] );

			case DataSource::EOF:
				return new Token( Token::T_EOF, $pos );

			default:
				if ( self::isNameStartCharacter( $this->currentCharacter ) ) {
					$this->reconsumeCharacter();
					return $this->consumeIdentLikeToken( $pos );
				}

				return new Token( Token::T_DELIM, $pos + [ 'value' => $this->currentCharacter ] );
		}
	}

	/**
	 * Consume a numeric token
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#consume-a-numeric-token
	 * @param array $data Data for the new token (typically contains just 'position')
	 * @return Token
	 */
	protected function consumeNumericToken( array $data ) {
		list( $data['representation'], $data['value'], $data['typeFlag'] ) = $this->consumeNumber();

		list( $next, $next2, $next3 ) = $this->lookAhead();
		if ( self::wouldStartIdentifier( $next, $next2, $next3 ) ) {
			return new Token( Token::T_DIMENSION, $data + [ 'unit' => $this->consumeName() ] );
		} elseif ( $this->nextCharacter === '%' ) {
			$this->consumeCharacter();
			return new Token( Token::T_PERCENTAGE, $data );
		} else {
			return new Token( Token::T_NUMBER, $data );
		}
	}

	/**
	 * Consume an ident-like token
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#consume-an-ident-like-token
	 * @note Per the draft as of January 2017, quoted URLs are parsed as
	 *  functions named 'url'. This is needed in order to implement the `<url>`
	 *  type in the [Values specification](https://www.w3.org/TR/2016/CR-css-values-3-20160929/#urls).
	 * @param array $data Data for the new token (typically contains just 'position')
	 * @return Token
	 */
	protected function consumeIdentLikeToken( array $data ) {
		$name = $this->consumeName();

		if ( $this->nextCharacter === '(' ) {
			$this->consumeCharacter();

			if ( !strcasecmp( $name, 'url' ) ) {
				while ( true ) {
					list( $next, $next2 ) = $this->lookAhead();
					if ( !self::isWhitespace( $next ) || !self::isWhitespace( $next2 ) ) {
						break;
					}
					$this->consumeCharacter();
				}
				if ( $next !== '"' && $next !== '\'' &&
					!( self::isWhitespace( $next ) && ( $next2 === '"' || $next2=== '\'' ) )
				) {
					return $this->consumeUrlToken( $data );
				}
			}

			return new Token( Token::T_FUNCTION, $data + [ 'value' => $name ] );
		}

		return new Token( Token::T_IDENT, $data + [ 'value' => $name ] );
	}

	/**
	 * Consume a string token
	 *
	 * This assumes the leading quote or apostrophe has already been consumed.
	 *
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#consume-a-string-token
	 * @param string $endChar Ending character of the string
	 * @param array $data Data for the new token (typically contains just 'position')
	 * @return Token
	 */
	protected function consumeStringToken( $endChar, array $data ) {
		$data['value'] = '';

		while ( true ) {
			$this->consumeCharacter();
			switch ( $this->currentCharacter ) {
				case DataSource::EOF:
					// Parse error from the editor's draft as of 2017-01-06
					$this->parseError( 'unclosed-string', $data );
					break 2;

				case $endChar:
					break 2;

				case "\n":
					$this->parseError( 'newline-in-string' );
					$this->reconsumeCharacter();
					return new Token( Token::T_BAD_STRING, [ 'value' => '' ] + $data );

				case '\\':
					if ( $this->nextCharacter === DataSource::EOF ) {
						// Do nothing
						// Parse error from the editor's draft as of 2017-01-06
						$this->parseError( 'bad-escape' );
					} elseif ( $this->nextCharacter === "\n" ) {
						// Consume it
						$this->consumeCharacter();
					} elseif ( self::isValidEscape( $this->currentCharacter, $this->nextCharacter ) ) {
						$data['value'] .= $this->consumeEscape();
					} else {
						// @codeCoverageIgnoreStart
						throw new \UnexpectedValueException( "[$this->line:$this->pos] Unexpected state" );
						// @codeCoverageIgnoreEnd
					}
					break;

				default:
					$data['value'] .= $this->currentCharacter;
					break;
			}
		}

		return new Token( Token::T_STRING, $data );
	}

	/**
	 * Consume a URL token
	 *
	 * This assumes the leading "url(" has already been consumed.
	 *
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#consume-a-url-token
	 * @note Per the draft as of January 2017, this does not handle quoted URL tokens.
	 * @param array $data Data for the new token (typically contains just 'position')
	 * @return Token
	 */
	protected function consumeUrlToken( array $data ) {
		// 1.
		$data['value'] = '';

		// 2.
		while ( self::isWhitespace( $this->nextCharacter ) ) {
			$this->consumeCharacter();
		}

		// 3.
		if ( $this->nextCharacter === DataSource::EOF ) {
			// Parse error from the editor's draft as of 2017-01-06
			$this->parseError( 'unclosed-url', $data );
			return new Token( Token::T_URL, $data );
		}

		// 4. (removed in draft, this was formerly the parsing for a quoted URL token)

		// 5. (renumbered as 4 in the draft)
		while ( true ) {
			$this->consumeCharacter();
			switch ( $this->currentCharacter ) {
				case DataSource::EOF:
					// Parse error from the editor's draft as of 2017-01-06
					$this->parseError( 'unclosed-url', $data );
					break 2;

				case ')':
					break 2;

				case "\n":
				case "\t":
				case ' ':
					while ( self::isWhitespace( $this->nextCharacter ) ) {
						$this->consumeCharacter();
					}
					if ( $this->nextCharacter === ')' ) {
						$this->consumeCharacter();
						break 2;
					} elseif ( $this->nextCharacter === DataSource::EOF ) {
						// Parse error from the editor's draft as of 2017-01-06
						$this->consumeCharacter();
						$this->parseError( 'unclosed-url', $data );
						break 2;
					} else {
						$this->consumeBadUrlRemnants();
						return new Token( Token::T_BAD_URL, [ 'value' => '' ] + $data );
					}
					break;

				case '"':
				case '\'':
				case '(':
					$this->parseError( 'bad-character-in-url' );
					$this->consumeBadUrlRemnants();
					return new Token( Token::T_BAD_URL, [ 'value' => '' ] + $data );

				case '\\':
					if ( self::isValidEscape( $this->currentCharacter, $this->nextCharacter ) ) {
						$data['value'] .= $this->consumeEscape();
					} else {
						$this->parseError( 'bad-escape' );
						$this->consumeBadUrlRemnants();
						return new Token( Token::T_BAD_URL, [ 'value' => '' ] + $data );
					}
					break;

				default:
					if ( self::isNonPrintable( $this->currentCharacter ) ) {
						$this->parseError( 'bad-character-in-url' );
						$this->consumeBadUrlRemnants();
						return new Token( Token::T_BAD_URL, [ 'value' => '' ] + $data );
					}

					$data['value'] .= $this->currentCharacter;
					break;
			}
		}

		return new Token( Token::T_URL, $data );
	}

	/**
	 * Clean up after finding an error in a URL
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#consume-the-remnants-of-a-bad-url
	 */
	protected function consumeBadUrlRemnants() {
		while ( true ) {
			$this->consumeCharacter();
			if ( $this->currentCharacter === ')' || $this->currentCharacter === DataSource::EOF ) {
				break;
			}
			if ( self::isValidEscape( $this->currentCharacter, $this->nextCharacter ) ) {
				$this->consumeEscape();
			}
		}
	}

	/**
	 * Consume a unicode-range token
	 *
	 * This assumes the initial "u" has been consumed (currentCharacter is the '+'),
	 * and the next codepoint is verfied to be a hex digit or "?".
	 *
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#consume-a-unicode-range-token
	 * @param array $data Data for the new token (typically contains just 'position')
	 * @return Token
	 */
	protected function consumeUnicodeRangeToken( array $data ) {
		// 1.
		$v = '';
		while ( strlen( $v ) < 6 && self::isHexDigit( $this->nextCharacter ) ) {
			$this->consumeCharacter();
			$v .= $this->currentCharacter;
		}
		$anyQ = false;
		while ( strlen( $v ) < 6 && $this->nextCharacter === '?' ) {
			$anyQ = true;
			$this->consumeCharacter();
			$v .= $this->currentCharacter;
		}

		if ( $anyQ ) {
			return new Token( Token::T_UNICODE_RANGE, $data + [
				'start' => intval( str_replace( '?', '0', $v ), 16 ),
				'end' => intval( str_replace( '?', 'F', $v ), 16 ),
			] );
		}

		$data['start'] = intval( $v, 16 );

		// 2.
		list( $next, $next2 ) = $this->lookAhead();
		if ( $next === '-' && self::isHexDigit( $next2 ) ) {
			$this->consumeCharacter();
			$v = '';
			while ( strlen( $v ) < 6 && self::isHexDigit( $this->nextCharacter ) ) {
				$this->consumeCharacter();
				$v .= $this->currentCharacter;
			}
			$data['end'] = intval( $v, 16 );
		} else {
			// 3.
			$data['end'] = $data['start'];
		}

		// 4.
		return new Token( Token::T_UNICODE_RANGE, $data );
	}

	/**
	 * Indicate if a character is whitespace
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#whitespace
	 * @param string $char A single UTF-8 character
	 * @return bool
	 */
	protected static function isWhitespace( $char ) {
		return $char === "\n" || $char === "\t" || $char === " ";
	}

	/**
	 * Indicate if a character is a name-start code point
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#name-start-code-point
	 * @param string $char A single UTF-8 character
	 * @return bool
	 */
	protected static function isNameStartCharacter( $char ) {
		// Every non-ASCII character is a name start character, so we can just
		// check the first byte.
		$char = ord( $char );
		return $char >= 0x41 && $char <= 0x5a ||
			$char >= 0x61 && $char <= 0x7a ||
			$char >= 0x80 || $char === 0x5f;
	}

	/**
	 * Indicate if a character is a name code point
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#name-code-point
	 * @param string $char A single UTF-8 character
	 * @return bool
	 */
	protected static function isNameCharacter( $char ) {
		// Every non-ASCII character is a name character, so we can just check
		// the first byte.
		$char = ord( $char );
		return $char >= 0x41 && $char <= 0x5a ||
			$char >= 0x61 && $char <= 0x7a ||
			$char >= 0x30 && $char <= 0x39 ||
			$char >= 0x80 || $char === 0x5f || $char === 0x2d;
	}

	/**
	 * Indicate if a character is non-printable
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#non-printable-code-point
	 * @param string $char A single UTF-8 character
	 * @return bool
	 */
	protected static function isNonPrintable( $char ) {
		// No non-ASCII character is non-printable, so we can just check the
		// first byte.
		$char = ord( $char );
		return $char >= 0x00 && $char <= 0x08 ||
			$char === 0x0b ||
			$char >= 0x0e && $char <= 0x1f ||
			$char === 0x7f;
	}

	/**
	 * Indicate if a character is a digit
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#digit
	 * @param string $char A single UTF-8 character
	 * @return bool
	 */
	protected static function isDigit( $char ) {
		// No non-ASCII character is a digit, so we can just check the first
		// byte.
		$char = ord( $char );
		return $char >= 0x30 && $char <= 0x39;
	}

	/**
	 * Indicate if a character is a hex digit
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#hex-digit
	 * @param string $char A single UTF-8 character
	 * @return bool
	 */
	protected static function isHexDigit( $char ) {
		// No non-ASCII character is a hex digit, so we can just check the
		// first byte.
		$char = ord( $char );
		return $char >= 0x30 && $char <= 0x39 ||
			$char >= 0x41 && $char <= 0x46 ||
			$char >= 0x61 && $char <= 0x66;
	}

	/**
	 * Determine if two characters constitute a valid escape
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#starts-with-a-valid-escape
	 * @param string $char1
	 * @param string $char2
	 * @return bool
	 */
	protected static function isValidEscape( $char1, $char2 ) {
		return $char1 === '\\' && $char2 !== "\n";
	}

	/**
	 * Determine if three characters would start an identifier
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#would-start-an-identifier
	 * @param string $char1
	 * @param string $char2
	 * @param string $char3
	 * @return bool
	 */
	protected static function wouldStartIdentifier( $char1, $char2, $char3 ) {
		if ( $char1 === '-' ) {
			// Added the possibility for an itentifier beginning with "--" per the draft.
			return self::isNameStartCharacter( $char2 ) || $char2 === '-' ||
				self::isValidEscape( $char2, $char3 );
		} elseif ( self::isNameStartCharacter( $char1 ) ) {
			return true;
		} elseif ( $char1 === '\\' ) {
			return self::isValidEscape( $char1, $char2 );
		} else {
			return false;
		}
	}

	/**
	 * Determine if three characters would start a number
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#starts-with-a-number
	 * @param string $char1
	 * @param string $char2
	 * @param string $char3
	 * @return bool
	 */
	protected static function wouldStartNumber( $char1, $char2, $char3 ) {
		if ( $char1 === '+' || $char1 === '-' ) {
			return self::isDigit( $char2 ) ||
				$char2 === '.' && self::isDigit( $char3 );
		} elseif ( $char1 === '.' ) {
			return self::isDigit( $char2 );
		// @codeCoverageIgnoreStart
		// Nothing reaches this code
		} else {
			return self::isDigit( $char1 );
		}
		// @codeCoverageIgnoreEnd
	}

	/**
	 * Consume a valid escape
	 *
	 * This assumes the leading backslash is consumed.
	 *
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#consume-an-escaped-code-point
	 * @return string Escaped character
	 */
	protected function consumeEscape() {
		$position = [ 'position' => [ $this->line, $this->pos ] ];

		$this->consumeCharacter();

		// @codeCoverageIgnoreStart
		if ( $this->currentCharacter === "\n" ) {
			throw new \UnexpectedValueException( "[$this->line:$this->pos] Unexpected newline" );
		}
		// @codeCoverageIgnoreEnd

		// 1-6 hexits, plus one optional whitespace character
		if ( self::isHexDigit( $this->currentCharacter ) ) {
			$num = $this->currentCharacter;
			while ( strlen( $num ) < 6 && self::isHexDigit( $this->nextCharacter ) ) {
				$this->consumeCharacter();
				$num .= $this->currentCharacter;
			}
			if ( self::isWhitespace( $this->nextCharacter ) ) {
				$this->consumeCharacter();
			}

			$num = intval( $num, 16 );
			if ( $num === 0 || $num >= 0xd800 && $num <= 0xdfff || $num > 0x10ffff ) {
				return \UtfNormal\Constants::UTF8_REPLACEMENT;
			}
			return \UtfNormal\Utils::codepointToUtf8( $num );
		}

		if ( $this->currentCharacter === DataSource::EOF ) {
			// Parse error from the editor's draft as of 2017-01-06
			$this->parseError( 'bad-escape', $position );
			return \UtfNormal\Constants::UTF8_REPLACEMENT;
		}

		return $this->currentCharacter;
	}

	/**
	 * Consume a name
	 *
	 * Note this does not do validation on the input stream. Call
	 * self::wouldStartIdentifier() or the like before calling the method if
	 * necessary.
	 *
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#consume-a-name
	 * @return string Name
	 */
	protected function consumeName() {
		$name = '';

		while ( true ) {
			$this->consumeCharacter();

			if ( self::isNameCharacter( $this->currentCharacter ) ) {
				$name .= $this->currentCharacter;
			} elseif ( self::isValidEscape( $this->currentCharacter, $this->nextCharacter ) ) {
				$name .= $this->consumeEscape();
			} else {
				$this->reconsumeCharacter(); // Doesn't say to, but breaks otherwise
				return $name;
			}
		}
		// @codeCoverageIgnoreStart
	}
	// @codeCoverageIgnoreEnd

	/**
	 * Consume a number
	 *
	 * Note this does not do validation on the input stream. Call
	 * self::wouldStartNumber() before calling the method if necessary.
	 *
	 * @see https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#consume-a-number
	 * @return array [ string $value, int|float $number, string $type ('integer' or 'number') ]
	 */
	protected function consumeNumber() {
		// 1.
		$repr = '';
		$type = 'integer';

		// 2.
		if ( $this->nextCharacter === '+' || $this->nextCharacter === '-' ) {
			$this->consumeCharacter();
			$repr .= $this->currentCharacter;
		}

		// 3.
		while ( self::isDigit( $this->nextCharacter ) ) {
			$this->consumeCharacter();
			$repr .= $this->currentCharacter;
		}

		// 4.
		if ( $this->nextCharacter === '.' ) {
			list( $next, $next2, $next3 ) = $this->lookAhead();
			if ( self::isDigit( $next2 ) ) {
				// 4.1.
				$this->consumeCharacter();
				$this->consumeCharacter();
				// 4.2.
				$repr .= $next . $next2;
				// 4.3.
				$type = 'number';
				// 4.4.
				while ( self::isDigit( $this->nextCharacter ) ) {
					$this->consumeCharacter();
					$repr .= $this->currentCharacter;
				}
			}
		}

		// 5.
		if ( $this->nextCharacter === 'e' || $this->nextCharacter === 'E' ) {
			list( $next, $next2, $next3 ) = $this->lookAhead();
			$ok = false;
			if ( ( $next2 === '+' || $next2 === '-' ) && self::isDigit( $next3 ) ) {
				$ok = true;
				// 5.1.
				$this->consumeCharacter();
				$this->consumeCharacter();
				$this->consumeCharacter();
				// 5.2.
				$repr .= $next . $next2 . $next3;
			} elseif ( self::isDigit( $next2 ) ) {
				$ok = true;
				// 5.1.
				$this->consumeCharacter();
				$this->consumeCharacter();
				// 5.2.
				$repr .= $next . $next2;
			}
			if ( $ok ) {
				// 5.3.
				$type = 'number';
				// 5.4.
				while ( self::isDigit( $this->nextCharacter ) ) {
					$this->consumeCharacter();
					$repr .= $this->currentCharacter;
				}
			}
		}

		// 6. We assume PHP's casting follows the same rules as
		// https://www.w3.org/TR/2014/CR-css-syntax-3-20140220/#convert-a-string-to-a-number
		$value = $type === 'integer' ? (int)$repr : (float)$repr;

		// 7.
		return [ $repr, $value, $type ];
	}
}