#[derive(Debug, Clone, PartialEq, Eq)]

#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]

    pub fn for_json(source: &'a str) -> Self {

        Self::new(source.as_bytes())

    }

    pub fn for_json_bytes(source: &'a [u8]) -> Self {

        Self::new(source)

    }

    fn new(source: &'a [u8]) -> Self {

        Self {

            source: ByteIterator::new(source),

        }

    }

    pub fn next_or_eof(&mut self) -> Result<Token<'a>, Error> {

        let (offset, byte) = self.source.read_non_ws().map_err(Error::into_fallable)?;

        self.read_peek(offset, byte)

    }

    fn read_peek(&mut self, offset: usize, first: &'a u8) -> Result<Token<'a>, Error> {

        match first {

            b'{' => Ok(Token::Object),

            b'}' => Ok(Token::ObjectEnd),

            b'[' => Ok(Token::Array),

            b']' => Ok(Token::ArrayEnd),

            b',' => Ok(Token::Comma),

            b':' => Ok(Token::Colon),

            b'"' => self.read_string_from_source(offset).map(Token::String),

            b'-' => self

                .read_number_from_source(InitialNumberState::Sign, offset)

                .map(Token::Number),

            b'0' => self

                .read_number_from_source(InitialNumberState::Zero, offset)

                .map(Token::Number),

            b'1'..=b'9' => self

                .read_number_from_source(InitialNumberState::Digit, offset)

                .map(Token::Number),

            b't' => self

                .read_literal_from_source(b"rue")

                .map(|()| Token::Bool(true)),

            b'f' => self

                .read_literal_from_source(b"alse")

                .map(|()| Token::Bool(false)),

            b'n' => self.read_literal_from_source(b"ull").map(|()| Token::Null),

            _ => Err(Error {

                offset,

                kind: ErrorKind::Unexpected(*first),

            }),

    }

    fn read_string_from_source(&mut self, start: usize) -> Result<JsonString<'a>, Error> {

        let safe_strings = if GUARANTEED_UTF8 {

            SAFE_STRING_BYTES

            SAFE_STRING_BYTES_VERIFY_UTF8

        let mut string_info = JsonStringInfo::NONE;

            let (offset, byte) = self.source.next().ok_or(Error {

                offset: self.source.offset,

                kind: ErrorKind::UnclosedString,

            })?;

            if safe_strings[usize::from(*byte)] {

                string_info.add_bytes(1);

            } else {

                match byte {

                        break Ok(JsonString {

                            source: StringContents::Json(

                                // SAFETY: the UTF8 has been manually verified by the parser.

                                AnyStr::Borrowed(unsafe {

                                    core::str::from_utf8_unchecked(

                                        &self.source.bytes[start + 1..offset],

                                    )

                                }),

                            ),

                            info: string_info,

                        });

                    b'\\' => self.read_string_escape(&mut string_info)?,

                    128..=255 => {

                        let utf8_start = offset;

                        while let Some(byte) = self.source.peek() {

                            if byte < &128 {

                                break;

                            }

                            self.source.next();

                        let unicode_end = self.source.offset;

                        string_info.add_bytes(unicode_end - utf8_start);

                        if core::str::from_utf8(&self.source.bytes[utf8_start..unicode_end])

                            .is_err()

                            return Err(Error {

                                offset,

                                kind: ErrorKind::Utf8,

                            });

                        }

                    0..=31 => {

                        return Err(Error {

                            offset,

                            kind: ErrorKind::Unexpected(*byte),

                        })

    }

        match self.source.read()? {

            (_, b'"' | b'\\' | b'/' | b'b' | b'f' | b'r' | b'n' | b't') => {

                string_info.add_bytes_from_escape(1);

            }

            (offset, b'u') => {

                // 4 hexadecimal digits.

                let mut decoded = 0_u32;

                for _ in 0..4 {

                    let (offset, digit) = self.source.read()?;

                    let nibble = HEX_OFFSET_TABLE[usize::from(*digit)];

                    if nibble == u8::MAX {

                        return Err(Error {

                            offset,

                            kind: ErrorKind::InvalidHexadecimal,

                        });

                    }

                    decoded = decoded << 4 | u32::from(nibble);

                let ch = if let Some(ch) = char::from_u32(decoded) {

                    ch

                    let mut decoded_is_surrogate_pair = false;

                    if (HIGH_SURROGATE_MIN..=HIGH_SURROGATE_MAX).contains(&decoded) {

                        if self.source.read()?.1 == &b'\\' && self.source.read()?.1 == &b'u' {

                            let mut second_codepoint = 0;

                            for _ in 0..4 {

                                let (offset, digit) = self.source.read()?;

                                let nibble = HEX_OFFSET_TABLE[usize::from(*digit)];

                                if nibble == u8::MAX {

                                    return Err(Error {

                                        offset,

                                        kind: ErrorKind::InvalidHexadecimal,

                                    });

                                }

                                second_codepoint = second_codepoint << 4 | u32::from(nibble);

                            if (LOW_SURROGATE_MIN..=LOW_SURROGATE_MAX).contains(&second_codepoint) {

                                // We have a valid surrogate pair

                                decoded = merge_surrogate_pair(decoded, second_codepoint);

                                decoded_is_surrogate_pair = true;

                            }

                        }

                    }

                    if decoded_is_surrogate_pair {

                        unsafe { char::from_u32_unchecked(decoded) }

                        return Err(Error {

                            offset,

                            kind: ErrorKind::Utf8,

                        });

                string_info.add_bytes_from_escape(ch.len_utf8());

            (offset, _) => {

                return Err(Error {

                    offset,

                    kind: ErrorKind::InvalidEscape,

                })

        Ok(())

    }

    fn read_number_from_source(

        &mut self,

        initial_state: InitialNumberState,

        start: usize,

    ) -> Result<JsonNumber<'a>, Error> {

        // Numbers are the "hardest" in that we have to peek the digits since

        // there is no terminal character. Every other type in JSON has a way to

        // know when the type ends.

        // First, if the number began with a sign, we must read an integer

        // digit. The JSON spec disallows numbers with leading 0s. If the first

        // digit is a 0, it must be a decimal with a 0 integer value.

        if initial_state != InitialNumberState::Zero {

            let mut read_integer_digit = initial_state == InitialNumberState::Digit;

            while let Some(byte) = self.source.peek() {

                match byte {

                    b'0' if !read_integer_digit => {

                        // 0 after a sign still counts as the complete Integer

                        // part.

                        self.source.read()?;

                        read_integer_digit = true;

                        break;

                    b'0'..=b'9' => {

                        self.source.read()?;

                        read_integer_digit = true;

                    _ => break,

            if !read_integer_digit {

                return Err(Error {

                    offset: self.source.offset,

                    kind: ErrorKind::ExpectedDigit,

                });

            }

        }

        if let Some(b'.') = self.source.peek() {

            self.source.next();

            // Read one or more decimal digits

            let mut read_decimal_digit = false;

            while let Some(byte) = self.source.peek() {

                if byte.is_ascii_digit() {

                    self.source.next();

                    read_decimal_digit = true;

                } else {

                    break;

            if !read_decimal_digit {

                return Err(Error {

                    offset: self.source.offset,

                    kind: ErrorKind::ExpectedDecimalDigit,

                });

            }

        }

        if let Some(b'e' | b'E') = self.source.peek() {

            self.source.next();

            // Next, we might have a sign

            if let Some(b'-' | b'+') = self.source.peek() {

                self.source.next();

            }

            let mut read_exponent_digit = false;

            while let Some(byte) = self.source.peek() {

                if byte.is_ascii_digit() {

                    self.source.next();

                    read_exponent_digit = true;

                } else {

                    break;

            if !read_exponent_digit {

                return Err(Error {

                    offset: self.source.offset,

                    kind: ErrorKind::ExpectedExponent,

                });

            }

        }

        Ok(JsonNumber {

            // SAFETY: To reach this point, we can only have read ascii

            // characters.

            source: AnyStr::Borrowed(unsafe {

                core::str::from_utf8_unchecked(&self.source.bytes[start..self.source.offset])

            }),

        })

    }

    fn read_literal_from_source(&mut self, remaining_bytes: &[u8]) -> Result<(), Error> {

        for expected in remaining_bytes {

            let (offset, received) = self.source.next().ok_or(Error {

                offset: self.source.offset,

                kind: ErrorKind::UnexpectedEof,

            })?;

            if received != expected {

                return Err(Error {

                    offset,

                    kind: ErrorKind::Unexpected(*received),

                });

            }

        Ok(())

    }

    pub fn peek(&mut self) -> Option<PeekableTokenKind> {

        self.source.skip_ws();

        let token = self.source.peek()?;

        let kind = match token {

            b'{' => PeekableTokenKind::Object,

            b'}' => PeekableTokenKind::ObjectEnd,

            b'[' => PeekableTokenKind::Array,

            b']' => PeekableTokenKind::ArrayEnd,

            b',' => PeekableTokenKind::Comma,

            b':' => PeekableTokenKind::Colon,

            b'"' => PeekableTokenKind::String,

            b'-' | b'0'..=b'9' => PeekableTokenKind::Number,

            b't' => PeekableTokenKind::True,

            b'f' => PeekableTokenKind::False,

            b'n' => PeekableTokenKind::Null,

            _ => PeekableTokenKind::Unrecognized,

        Some(kind)

    }

    pub const fn offset(&self) -> usize {

        self.source.offset

    }

    pub fn parse_json_bytes<D>(value: &'a [u8], delegate: D) -> Result<D::Value, Error<D::Error>>

    where

        D: ParseDelegate<'a>,

    {

        Self::parse_json_bytes_with_config(value, ParseConfig::default(), delegate)

    }

    pub fn parse_json_bytes_with_config<D>(

        value: &'a [u8],

        config: ParseConfig,

        delegate: D,

    ) -> Result<D::Value, Error<D::Error>>

    where

        D: ParseDelegate<'a>,

    {

        Self::parse_bytes(value, config, delegate)

    }

    pub fn validate_json_bytes(json: &'a [u8]) -> Result<JsonKind, Error> {

        Self::validate_json_bytes_with_config(json, ParseConfig::default())

    }

    pub fn validate_json_bytes_with_config(

        json: &'a [u8],

        config: ParseConfig,

    ) -> Result<JsonKind, Error> {

        Self::parse_bytes(json, config, ())

    }

    fn next(&mut self) -> Option<Self::Item> {

        let (offset, byte) = self.source.next_non_ws()?;

        Some(self.read_peek(offset, byte))

    }

    pub fn parse_json<D>(value: &'a str, delegate: D) -> Result<D::Value, Error<D::Error>>

    where

        D: ParseDelegate<'a>,

    {

        Self::parse_json_with_config(value, ParseConfig::default(), delegate)

    }

    pub fn parse_json_with_config<D>(

        value: &'a str,

        config: ParseConfig,

        delegate: D,

    ) -> Result<D::Value, Error<D::Error>>

    where

        D: ParseDelegate<'a>,

    {

        Self::parse_bytes(value.as_bytes(), config, delegate)

    }

    pub fn validate_json(json: &'a str) -> Result<JsonKind, Error> {

        Self::validate_json_with_config(json, ParseConfig::default())

    }

    pub fn validate_json_with_config(

        json: &'a str,

        config: ParseConfig,

    ) -> Result<JsonKind, Error> {

        Self::parse_json_with_config(json, config, ())

    }

    fn parse_bytes<D>(

        source: &'a [u8],

        config: ParseConfig,

        delegate: D,

    ) -> Result<D::Value, Error<D::Error>>

    where

        D: ParseDelegate<'a>,

    {

        let mut state = ParseState::new(config, delegate);

        let mut parser = Self {

            tokenizer: Tokenizer::new(source),

        };

        let value = parser.read_from_source(&mut state)?;

        if !state.config.allow_all_types_at_root

            && !matches!(

                state.delegate.kind_of(&value),

            return Err(Error {

                offset: 0,

                kind: ErrorKind::PayloadsShouldBeObjectOrArray,

            });

        }

        match parser.tokenizer.source.next_non_ws() {

            None => Ok(value),

            Some((offset, _)) => Err(Error {

                offset,

                kind: ErrorKind::TrailingNonWhitespace,

            }),

    }

    fn read_from_source<D>(

        &mut self,

        state: &mut ParseState<'a, D>,

    ) -> Result<D::Value, Error<D::Error>>

    where

        D: ParseDelegate<'a>,

    {

        self.read_tokens(state)

    }

    fn read_tokens<D>(&mut self, state: &mut ParseState<'a, D>) -> Result<D::Value, Error<D::Error>>

    where

        D: ParseDelegate<'a>,

    {

        let offset = self.tokenizer.offset();

        let token = self.tokenizer.next_or_eof().map_err(Error::into_fallable)?;

        let unexpected = |value: u8| {

            Err(Error {

                offset,

                kind: ErrorKind::Unexpected(value),

            })

        };

        let into_error = |error: D::Error| Error {

            offset,

            kind: ErrorKind::ErrorFromDelegate(error),

        };

        match token {

            Token::Null => state.delegate.null().map_err(into_error),

                state.begin_nest().map_err(|kind| Error { offset, kind })?;

                self.read_object(state).map_err(|mut error| {

                    if matches!(error.kind, ErrorKind::UnexpectedEof) {

                        error.kind = ErrorKind::UnclosedObject;

                    }

                    error

                })

                state.begin_nest().map_err(|kind| Error { offset, kind })?;

                self.read_array(state).map_err(|mut error| {

                    if matches!(error.kind, ErrorKind::UnexpectedEof) {

                        error.kind = ErrorKind::UnclosedArray;

                    }

                    error

                })

            Token::ObjectEnd => unexpected(b'}'),

            Token::ArrayEnd => unexpected(b']'),

            Token::Colon => unexpected(b':'),

            Token::Comma => unexpected(b','),

            Token::Bool(value) => state.delegate.boolean(value).map_err(into_error),

            Token::String(value) => state.delegate.string(value).map_err(into_error),

            Token::Number(value) => state.delegate.number(value).map_err(into_error),

    }

    fn read_object<D>(&mut self, state: &mut ParseState<'a, D>) -> Result<D::Value, Error<D::Error>>

    where

        D: ParseDelegate<'a>,

    {

        let offset = self.tokenizer.offset();

        let mut object = state.delegate.begin_object().map_err(|kind| Error {

            offset,

            kind: ErrorKind::ErrorFromDelegate(kind),

        })?;

        loop {

            let offset = self.tokenizer.offset();

            let token = self.tokenizer.next_or_eof().map_err(Error::into_fallable)?;

            let key = match token {

                    if state.config.allow_trailing_commas || state.delegate.object_is_empty(&object)

                        break;

                    }

                    return Err(Error {

                        offset,

                        kind: ErrorKind::IllegalTrailingComma,

                    });

                Token::String(value) => {

                    state

                        .delegate

                        .object_key(&mut object, value)

                        .map_err(|kind| Error {

                            offset,

                            kind: ErrorKind::ErrorFromDelegate(kind),

                        })?

                    return Err(Error {

                        offset,

                        kind: ErrorKind::ObjectKeysMustBeStrings,

                    });

                    return Err(Error {

                        offset,

                        kind: ErrorKind::ExpectedObjectKey,

                    })

            let offset = self.tokenizer.offset();

            let token = self.tokenizer.next_or_eof().map_err(|mut error| {

                error.kind = ErrorKind::ExpectedColon;

                error.into_fallable()

            })?;

            if token != Token::Colon {

                return Err(Error {

                    offset,

                    kind: ErrorKind::ExpectedColon,

                });

            }

            let offset = self.tokenizer.offset();

            let value = self.read_tokens(state)?;

            state

                .delegate

                .object_value(&mut object, key, value)

                .map_err(|kind| Error {

                    offset,

                    kind: ErrorKind::ErrorFromDelegate(kind),

                })?;

            let offset = self.tokenizer.offset();

            let token = self.tokenizer.next_or_eof().map_err(Error::into_fallable)?;

            if token == Token::ObjectEnd {

                break;

            } else if token != Token::Comma {

                return Err(Error {

                    offset,

                    kind: ErrorKind::ExpectedCommaOrEndOfObject,

                });

            }

        let object = state.delegate.end_object(object).map_err(|kind| Error {

            offset: self.tokenizer.offset(),

            kind: ErrorKind::ErrorFromDelegate(kind),

        })?;

        state.end_nest();

        Ok(object)

    }

    fn read_array<D>(&mut self, state: &mut ParseState<'a, D>) -> Result<D::Value, Error<D::Error>>

    where

        D: ParseDelegate<'a>,

    {

        let offset = self.tokenizer.offset();

        let mut array = state.delegate.begin_array().map_err(|kind| Error {

            offset: self.tokenizer.offset(),

            kind: ErrorKind::ErrorFromDelegate(kind),

        })?;

        loop {

            let offset = self.tokenizer.offset();

            // a bit of a cheat for the sake of ultimate performance, instead of using an Option<Token>

            // we look at the char itself to determine the of a token

            if self.tokenizer.peek() == Some(PeekableTokenKind::ArrayEnd) {

                self.tokenizer.source.offset += 1;

                if state.config.allow_trailing_commas || state.delegate.array_is_empty(&array) {

                    break;

                }

                return Err(Error {

                    offset,

                    kind: ErrorKind::IllegalTrailingComma,

                });

            }

            let value = self.read_tokens(state)?;

            state

                .delegate

                .array_value(&mut array, value)

                .map_err(|kind| Error {

                    offset: self.tokenizer.offset(),

                    kind: ErrorKind::ErrorFromDelegate(kind),

                })?;

            let offset = self.tokenizer.offset();

            let token = self.tokenizer.next_or_eof().map_err(Error::into_fallable)?;

            if token == Token::ArrayEnd {

                break;

            } else if token != Token::Comma {

                return Err(Error {

                    offset,

                    kind: ErrorKind::ExpectedCommaOrEndOfArray,

                });

            }

        let array = state.delegate.end_array(array).map_err(|kind| Error {

            offset,

            kind: ErrorKind::ErrorFromDelegate(kind),

        })?;

        state.end_nest();

        Ok(array)

    }

    fn next(&mut self) -> Option<Self::Item> {

        let token = self.bytes.get(self.offset);

        match token {

            None => None,

            Some(token) => {

                let offset = self.offset;

                self.offset += 1;

                Some((offset, token))

    }

    pub fn new(slice: &'a [u8]) -> Self {

        Self {

            bytes: slice,

            offset: 0,

        }

    }

    pub fn peek(&mut self) -> Option<&'a u8> {

        self.bytes.get(self.offset)

    }

    fn next_non_ws(&mut self) -> Option<(usize, &'a u8)> {

        self.skip_ws();

        self.next()

    }

    fn read_non_ws(&mut self) -> Result<(usize, &'a u8), Error> {

        self.skip_ws();

        self.read()

    }

    fn skip_ws(&mut self) {

        loop {

            match self.bytes.get(self.offset) {

                Some(b' ' | b'\n' | b'\t' | b'\r') => {

                    self.offset += 1;

                }

                    return;

                }

            }

        }

    }

    fn read(&mut self) -> Result<(usize, &'a u8), Error> {

        self.next().ok_or(Error {

            offset: self.offset,

            kind: ErrorKind::UnexpectedEof,

        })

    }

#[derive(Eq, PartialEq, Copy, Clone)]

#[derive(Debug, Clone, Copy, Eq, PartialEq)]

    fn default() -> Self {

        Self::new()

    }

    pub const fn new() -> Self {

        Self {

            allow_trailing_commas: false,

            recursion_limit: Some(128),

            allow_all_types_at_root: true,

        }

    }

    pub const fn strict() -> Self {

        Self {

            allow_trailing_commas: false,

            recursion_limit: Some(128),

            allow_all_types_at_root: false,

        }

    }

    pub const fn without_recursion_limit(mut self) -> Self {

        self.recursion_limit = None;

        self

    }

    pub const fn with_recursion_limit(mut self, limit: usize) -> Self {

        self.recursion_limit = Some(limit);

        self

    }

    pub const fn allowing_all_types_at_root(mut self, allow_all: bool) -> Self {

        self.allow_all_types_at_root = allow_all;

        self

    }

    pub const fn allowing_trailing_commas(mut self) -> Self {

        self.allow_trailing_commas = true;

        self

    }

#[test]

fn config_test() {

    // Flip all the values of the strict config, and verify it matches.

    assert_eq!(

        ParseConfig::strict()

            .allowing_trailing_commas()

            .without_recursion_limit()

            .allowing_all_types_at_root(true),

        ParseConfig {

            allow_trailing_commas: true,

            recursion_limit: None,

            allow_all_types_at_root: true

        }

    );

}

    pub fn begin_nest(&mut self) -> Result<(), ErrorKind<D::Error>> {

        if self.config.recursion_limit.is_some() {

            if self.remaining_depth > 0 {

                self.remaining_depth -= 1;

            } else {

                return Err(ErrorKind::RecursionLimitReached);

        Ok(())

    }

    pub fn end_nest(&mut self) {

        if self.config.recursion_limit.is_some() {

            self.remaining_depth += 1;

        }

    }

    fn new(config: ParseConfig, delegate: D) -> Self {

        Self {

            delegate,

            remaining_depth: config.recursion_limit.unwrap_or(usize::MAX),

            config,

            _phantom: PhantomData,

        }

    }

#[derive(Debug, Eq, PartialEq, Clone, Copy)]

    fn null(&mut self) -> Result<Self::Value, Self::Error> {

        Ok(JsonKind::Null)

    }

    fn boolean(&mut self, _value: bool) -> Result<Self::Value, Self::Error> {

        Ok(JsonKind::Boolean)

    }

    fn number(&mut self, _value: JsonNumber<'a>) -> Result<Self::Value, Self::Error> {

        Ok(JsonKind::Number)

    }

    fn string(&mut self, _value: JsonString<'a>) -> Result<Self::Value, Self::Error> {

        Ok(JsonKind::String)

    }

    fn begin_object(&mut self) -> Result<Self::Object, Self::Error> {

        Ok(0)

    }

    fn object_key(

        &mut self,

        _object: &mut Self::Object,

        _key: JsonString<'a>,

    ) -> Result<Self::Key, Self::Error> {

        Ok(())

    }

    fn object_value(

        &mut self,

        object: &mut Self::Object,

        _key: Self::Key,

        _value: Self::Value,

    ) -> Result<(), Self::Error> {

        *object += 1;

        Ok(())

    }

    fn object_is_empty(&self, object: &Self::Object) -> bool {

        *object == 0

    }

    fn end_object(&mut self, _object: Self::Object) -> Result<Self::Value, Self::Error> {

        Ok(JsonKind::Object)

    }

    fn begin_array(&mut self) -> Result<Self::Array, Self::Error> {

        Ok(0)

    }

    fn array_value(

        &mut self,

        array: &mut Self::Array,

        _value: Self::Value,

    ) -> Result<(), Self::Error> {

        *array += 1;

        Ok(())

    }

    fn array_is_empty(&self, array: &Self::Array) -> bool {

        *array == 0

    }

    fn end_array(&mut self, _array: Self::Array) -> Result<Self::Value, Self::Error> {

        Ok(JsonKind::Array)

    }

    fn kind_of(&self, value: &Self::Value) -> JsonKind {

        *value

    }

#[test]

fn validates() {

    assert_eq!(

        Parser::validate_json(r#"{"a":1,"b":true,"c":"hello","d":[],"e":{}}"#),

        Ok(JsonKind::Object)

    );

    assert_eq!(

        Parser::validate_json_bytes(br#"{"a":1,"b":true,"c":"hello","d":[],"e":{}}"#),

        Ok(JsonKind::Object)

    );

}

#[test]

fn tokenizes() {

    assert_eq!(

        Tokenizer::for_json("true")

            .collect::<Result<alloc::vec::Vec<_>, _>>()

            .unwrap(),

        &[Token::Bool(true)]

    );

    assert_eq!(

        Tokenizer::for_json_bytes(b"false")

            .collect::<Result<alloc::vec::Vec<_>, _>>()

            .unwrap(),

        &[Token::Bool(false)]

    );

}

#[test]

fn tokenizer_peek_tests() {

    let mut tokenizer = Tokenizer::for_json(r#"{"a": [1, true, false, null]} "#);

    for expected in [

        PeekableTokenKind::Object,

        PeekableTokenKind::String,

        PeekableTokenKind::Colon,

        PeekableTokenKind::Array,

        PeekableTokenKind::Number,

        PeekableTokenKind::Comma,

        PeekableTokenKind::True,

        PeekableTokenKind::Comma,

        PeekableTokenKind::False,

        PeekableTokenKind::Comma,

        PeekableTokenKind::Null,

        PeekableTokenKind::ArrayEnd,

        PeekableTokenKind::ObjectEnd,

        assert_eq!(tokenizer.peek(), Some(expected));

        tokenizer.next().expect("eof").expect("invalid tokens");

    assert_eq!(tokenizer.peek(), None);

    assert_eq!(tokenizer.next(), None);

    assert_eq!(

        Tokenizer::for_json("<").peek(),

        Some(PeekableTokenKind::Unrecognized)

    );

}