gtsocial-umbx

parser.go (26946B)

---

 package unstable
 
 import (
 	"bytes"
 	"fmt"
 	"unicode"
 
 	"github.com/pelletier/go-toml/v2/internal/characters"
 	"github.com/pelletier/go-toml/v2/internal/danger"
 )
 
 // ParserError describes an error relative to the content of the document.
 //
 // It cannot outlive the instance of Parser it refers to, and may cause panics
 // if the parser is reset.
 type ParserError struct {
 	Highlight []byte
 	Message   string
 	Key       []string // optional
 }
 
 // Error is the implementation of the error interface.
 func (e *ParserError) Error() string {
 	return e.Message
 }
 
 // NewParserError is a convenience function to create a ParserError
 //
 // Warning: Highlight needs to be a subslice of Parser.data, so only slices
 // returned by Parser.Raw are valid candidates.
 func NewParserError(highlight []byte, format string, args ...interface{}) error {
 	return &ParserError{
 		Highlight: highlight,
 		Message:   fmt.Errorf(format, args...).Error(),
 	}
 }
 
 // Parser scans over a TOML-encoded document and generates an iterative AST.
 //
 // To prime the Parser, first reset it with the contents of a TOML document.
 // Then, process all top-level expressions sequentially. See Example.
 //
 // Don't forget to check Error() after you're done parsing.
 //
 // Each top-level expression needs to be fully processed before calling
 // NextExpression() again. Otherwise, calls to various Node methods may panic if
 // the parser has moved on the next expression.
 //
 // For performance reasons, go-toml doesn't make a copy of the input bytes to
 // the parser. Make sure to copy all the bytes you need to outlive the slice
 // given to the parser.
 type Parser struct {
 	data    []byte
 	builder builder
 	ref     reference
 	left    []byte
 	err     error
 	first   bool
 
 	KeepComments bool
 }
 
 // Data returns the slice provided to the last call to Reset.
 func (p *Parser) Data() []byte {
 	return p.data
 }
 
 // Range returns a range description that corresponds to a given slice of the
 // input. If the argument is not a subslice of the parser input, this function
 // panics.
 func (p *Parser) Range(b []byte) Range {
 	return Range{
 		Offset: uint32(danger.SubsliceOffset(p.data, b)),
 		Length: uint32(len(b)),
 	}
 }
 
 // Raw returns the slice corresponding to the bytes in the given range.
 func (p *Parser) Raw(raw Range) []byte {
 	return p.data[raw.Offset : raw.Offset+raw.Length]
 }
 
 // Reset brings the parser to its initial state for a given input. It wipes an
 // reuses internal storage to reduce allocation.
 func (p *Parser) Reset(b []byte) {
 	p.builder.Reset()
 	p.ref = invalidReference
 	p.data = b
 	p.left = b
 	p.err = nil
 	p.first = true
 }
 
 // NextExpression parses the next top-level expression. If an expression was
 // successfully parsed, it returns true. If the parser is at the end of the
 // document or an error occurred, it returns false.
 //
 // Retrieve the parsed expression with Expression().
 func (p *Parser) NextExpression() bool {
 	if len(p.left) == 0 || p.err != nil {
 		return false
 	}
 
 	p.builder.Reset()
 	p.ref = invalidReference
 
 	for {
 		if len(p.left) == 0 || p.err != nil {
 			return false
 		}
 
 		if !p.first {
 			p.left, p.err = p.parseNewline(p.left)
 		}
 
 		if len(p.left) == 0 || p.err != nil {
 			return false
 		}
 
 		p.ref, p.left, p.err = p.parseExpression(p.left)
 
 		if p.err != nil {
 			return false
 		}
 
 		p.first = false
 
 		if p.ref.Valid() {
 			return true
 		}
 	}
 }
 
 // Expression returns a pointer to the node representing the last successfully
 // parsed expression.
 func (p *Parser) Expression() *Node {
 	return p.builder.NodeAt(p.ref)
 }
 
 // Error returns any error that has occurred during parsing.
 func (p *Parser) Error() error {
 	return p.err
 }
 
 // Position describes a position in the input.
 type Position struct {
 	// Number of bytes from the beginning of the input.
 	Offset int
 	// Line number, starting at 1.
 	Line int
 	// Column number, starting at 1.
 	Column int
 }
 
 // Shape describes the position of a range in the input.
 type Shape struct {
 	Start Position
 	End   Position
 }
 
 func (p *Parser) position(b []byte) Position {
 	offset := danger.SubsliceOffset(p.data, b)
 
 	lead := p.data[:offset]
 
 	return Position{
 		Offset: offset,
 		Line:   bytes.Count(lead, []byte{'\n'}) + 1,
 		Column: len(lead) - bytes.LastIndex(lead, []byte{'\n'}),
 	}
 }
 
 // Shape returns the shape of the given range in the input.  Will
 // panic if the range is not a subslice of the input.
 func (p *Parser) Shape(r Range) Shape {
 	raw := p.Raw(r)
 	return Shape{
 		Start: p.position(raw),
 		End:   p.position(raw[r.Length:]),
 	}
 }
 
 func (p *Parser) parseNewline(b []byte) ([]byte, error) {
 	if b[0] == '\n' {
 		return b[1:], nil
 	}
 
 	if b[0] == '\r' {
 		_, rest, err := scanWindowsNewline(b)
 		return rest, err
 	}
 
 	return nil, NewParserError(b[0:1], "expected newline but got %#U", b[0])
 }
 
 func (p *Parser) parseComment(b []byte) (reference, []byte, error) {
 	ref := invalidReference
 	data, rest, err := scanComment(b)
 	if p.KeepComments && err == nil {
 		ref = p.builder.Push(Node{
 			Kind: Comment,
 			Raw:  p.Range(data),
 			Data: data,
 		})
 	}
 	return ref, rest, err
 }
 
 func (p *Parser) parseExpression(b []byte) (reference, []byte, error) {
 	// expression =  ws [ comment ]
 	// expression =/ ws keyval ws [ comment ]
 	// expression =/ ws table ws [ comment ]
 	ref := invalidReference
 
 	b = p.parseWhitespace(b)
 
 	if len(b) == 0 {
 		return ref, b, nil
 	}
 
 	if b[0] == '#' {
 		ref, rest, err := p.parseComment(b)
 		return ref, rest, err
 	}
 
 	if b[0] == '\n' || b[0] == '\r' {
 		return ref, b, nil
 	}
 
 	var err error
 	if b[0] == '[' {
 		ref, b, err = p.parseTable(b)
 	} else {
 		ref, b, err = p.parseKeyval(b)
 	}
 
 	if err != nil {
 		return ref, nil, err
 	}
 
 	b = p.parseWhitespace(b)
 
 	if len(b) > 0 && b[0] == '#' {
 		cref, rest, err := p.parseComment(b)
 		if cref != invalidReference {
 			p.builder.Chain(ref, cref)
 		}
 		return ref, rest, err
 	}
 
 	return ref, b, nil
 }
 
 func (p *Parser) parseTable(b []byte) (reference, []byte, error) {
 	// table = std-table / array-table
 	if len(b) > 1 && b[1] == '[' {
 		return p.parseArrayTable(b)
 	}
 
 	return p.parseStdTable(b)
 }
 
 func (p *Parser) parseArrayTable(b []byte) (reference, []byte, error) {
 	// array-table = array-table-open key array-table-close
 	// array-table-open  = %x5B.5B ws  ; [[ Double left square bracket
 	// array-table-close = ws %x5D.5D  ; ]] Double right square bracket
 	ref := p.builder.Push(Node{
 		Kind: ArrayTable,
 	})
 
 	b = b[2:]
 	b = p.parseWhitespace(b)
 
 	k, b, err := p.parseKey(b)
 	if err != nil {
 		return ref, nil, err
 	}
 
 	p.builder.AttachChild(ref, k)
 	b = p.parseWhitespace(b)
 
 	b, err = expect(']', b)
 	if err != nil {
 		return ref, nil, err
 	}
 
 	b, err = expect(']', b)
 
 	return ref, b, err
 }
 
 func (p *Parser) parseStdTable(b []byte) (reference, []byte, error) {
 	// std-table = std-table-open key std-table-close
 	// std-table-open  = %x5B ws     ; [ Left square bracket
 	// std-table-close = ws %x5D     ; ] Right square bracket
 	ref := p.builder.Push(Node{
 		Kind: Table,
 	})
 
 	b = b[1:]
 	b = p.parseWhitespace(b)
 
 	key, b, err := p.parseKey(b)
 	if err != nil {
 		return ref, nil, err
 	}
 
 	p.builder.AttachChild(ref, key)
 
 	b = p.parseWhitespace(b)
 
 	b, err = expect(']', b)
 
 	return ref, b, err
 }
 
 func (p *Parser) parseKeyval(b []byte) (reference, []byte, error) {
 	// keyval = key keyval-sep val
 	ref := p.builder.Push(Node{
 		Kind: KeyValue,
 	})
 
 	key, b, err := p.parseKey(b)
 	if err != nil {
 		return invalidReference, nil, err
 	}
 
 	// keyval-sep = ws %x3D ws ; =
 
 	b = p.parseWhitespace(b)
 
 	if len(b) == 0 {
 		return invalidReference, nil, NewParserError(b, "expected = after a key, but the document ends there")
 	}
 
 	b, err = expect('=', b)
 	if err != nil {
 		return invalidReference, nil, err
 	}
 
 	b = p.parseWhitespace(b)
 
 	valRef, b, err := p.parseVal(b)
 	if err != nil {
 		return ref, b, err
 	}
 
 	p.builder.Chain(valRef, key)
 	p.builder.AttachChild(ref, valRef)
 
 	return ref, b, err
 }
 
 //nolint:cyclop,funlen
 func (p *Parser) parseVal(b []byte) (reference, []byte, error) {
 	// val = string / boolean / array / inline-table / date-time / float / integer
 	ref := invalidReference
 
 	if len(b) == 0 {
 		return ref, nil, NewParserError(b, "expected value, not eof")
 	}
 
 	var err error
 	c := b[0]
 
 	switch c {
 	case '"':
 		var raw []byte
 		var v []byte
 		if scanFollowsMultilineBasicStringDelimiter(b) {
 			raw, v, b, err = p.parseMultilineBasicString(b)
 		} else {
 			raw, v, b, err = p.parseBasicString(b)
 		}
 
 		if err == nil {
 			ref = p.builder.Push(Node{
 				Kind: String,
 				Raw:  p.Range(raw),
 				Data: v,
 			})
 		}
 
 		return ref, b, err
 	case '\'':
 		var raw []byte
 		var v []byte
 		if scanFollowsMultilineLiteralStringDelimiter(b) {
 			raw, v, b, err = p.parseMultilineLiteralString(b)
 		} else {
 			raw, v, b, err = p.parseLiteralString(b)
 		}
 
 		if err == nil {
 			ref = p.builder.Push(Node{
 				Kind: String,
 				Raw:  p.Range(raw),
 				Data: v,
 			})
 		}
 
 		return ref, b, err
 	case 't':
 		if !scanFollowsTrue(b) {
 			return ref, nil, NewParserError(atmost(b, 4), "expected 'true'")
 		}
 
 		ref = p.builder.Push(Node{
 			Kind: Bool,
 			Data: b[:4],
 		})
 
 		return ref, b[4:], nil
 	case 'f':
 		if !scanFollowsFalse(b) {
 			return ref, nil, NewParserError(atmost(b, 5), "expected 'false'")
 		}
 
 		ref = p.builder.Push(Node{
 			Kind: Bool,
 			Data: b[:5],
 		})
 
 		return ref, b[5:], nil
 	case '[':
 		return p.parseValArray(b)
 	case '{':
 		return p.parseInlineTable(b)
 	default:
 		return p.parseIntOrFloatOrDateTime(b)
 	}
 }
 
 func atmost(b []byte, n int) []byte {
 	if n >= len(b) {
 		return b
 	}
 
 	return b[:n]
 }
 
 func (p *Parser) parseLiteralString(b []byte) ([]byte, []byte, []byte, error) {
 	v, rest, err := scanLiteralString(b)
 	if err != nil {
 		return nil, nil, nil, err
 	}
 
 	return v, v[1 : len(v)-1], rest, nil
 }
 
 func (p *Parser) parseInlineTable(b []byte) (reference, []byte, error) {
 	// inline-table = inline-table-open [ inline-table-keyvals ] inline-table-close
 	// inline-table-open  = %x7B ws     ; {
 	// inline-table-close = ws %x7D     ; }
 	// inline-table-sep   = ws %x2C ws  ; , Comma
 	// inline-table-keyvals = keyval [ inline-table-sep inline-table-keyvals ]
 	parent := p.builder.Push(Node{
 		Kind: InlineTable,
 		Raw:  p.Range(b[:1]),
 	})
 
 	first := true
 
 	var child reference
 
 	b = b[1:]
 
 	var err error
 
 	for len(b) > 0 {
 		previousB := b
 		b = p.parseWhitespace(b)
 
 		if len(b) == 0 {
 			return parent, nil, NewParserError(previousB[:1], "inline table is incomplete")
 		}
 
 		if b[0] == '}' {
 			break
 		}
 
 		if !first {
 			b, err = expect(',', b)
 			if err != nil {
 				return parent, nil, err
 			}
 			b = p.parseWhitespace(b)
 		}
 
 		var kv reference
 
 		kv, b, err = p.parseKeyval(b)
 		if err != nil {
 			return parent, nil, err
 		}
 
 		if first {
 			p.builder.AttachChild(parent, kv)
 		} else {
 			p.builder.Chain(child, kv)
 		}
 		child = kv
 
 		first = false
 	}
 
 	rest, err := expect('}', b)
 
 	return parent, rest, err
 }
 
 //nolint:funlen,cyclop
 func (p *Parser) parseValArray(b []byte) (reference, []byte, error) {
 	// array = array-open [ array-values ] ws-comment-newline array-close
 	// array-open =  %x5B ; [
 	// array-close = %x5D ; ]
 	// array-values =  ws-comment-newline val ws-comment-newline array-sep array-values
 	// array-values =/ ws-comment-newline val ws-comment-newline [ array-sep ]
 	// array-sep = %x2C  ; , Comma
 	// ws-comment-newline = *( wschar / [ comment ] newline )
 	arrayStart := b
 	b = b[1:]
 
 	parent := p.builder.Push(Node{
 		Kind: Array,
 	})
 
 	// First indicates whether the parser is looking for the first element
 	// (non-comment) of the array.
 	first := true
 
 	lastChild := invalidReference
 
 	addChild := func(valueRef reference) {
 		if lastChild == invalidReference {
 			p.builder.AttachChild(parent, valueRef)
 		} else {
 			p.builder.Chain(lastChild, valueRef)
 		}
 		lastChild = valueRef
 	}
 
 	var err error
 	for len(b) > 0 {
 		cref := invalidReference
 		cref, b, err = p.parseOptionalWhitespaceCommentNewline(b)
 		if err != nil {
 			return parent, nil, err
 		}
 
 		if cref != invalidReference {
 			addChild(cref)
 		}
 
 		if len(b) == 0 {
 			return parent, nil, NewParserError(arrayStart[:1], "array is incomplete")
 		}
 
 		if b[0] == ']' {
 			break
 		}
 
 		if b[0] == ',' {
 			if first {
 				return parent, nil, NewParserError(b[0:1], "array cannot start with comma")
 			}
 			b = b[1:]
 
 			cref, b, err = p.parseOptionalWhitespaceCommentNewline(b)
 			if err != nil {
 				return parent, nil, err
 			}
 			if cref != invalidReference {
 				addChild(cref)
 			}
 		} else if !first {
 			return parent, nil, NewParserError(b[0:1], "array elements must be separated by commas")
 		}
 
 		// TOML allows trailing commas in arrays.
 		if len(b) > 0 && b[0] == ']' {
 			break
 		}
 
 		var valueRef reference
 		valueRef, b, err = p.parseVal(b)
 		if err != nil {
 			return parent, nil, err
 		}
 
 		addChild(valueRef)
 
 		cref, b, err = p.parseOptionalWhitespaceCommentNewline(b)
 		if err != nil {
 			return parent, nil, err
 		}
 		if cref != invalidReference {
 			addChild(cref)
 		}
 
 		first = false
 	}
 
 	rest, err := expect(']', b)
 
 	return parent, rest, err
 }
 
 func (p *Parser) parseOptionalWhitespaceCommentNewline(b []byte) (reference, []byte, error) {
 	rootCommentRef := invalidReference
 	latestCommentRef := invalidReference
 
 	addComment := func(ref reference) {
 		if rootCommentRef == invalidReference {
 			rootCommentRef = ref
 		} else if latestCommentRef == invalidReference {
 			p.builder.AttachChild(rootCommentRef, ref)
 			latestCommentRef = ref
 		} else {
 			p.builder.Chain(latestCommentRef, ref)
 			latestCommentRef = ref
 		}
 	}
 
 	for len(b) > 0 {
 		var err error
 		b = p.parseWhitespace(b)
 
 		if len(b) > 0 && b[0] == '#' {
 			var ref reference
 			ref, b, err = p.parseComment(b)
 			if err != nil {
 				return invalidReference, nil, err
 			}
 			if ref != invalidReference {
 				addComment(ref)
 			}
 		}
 
 		if len(b) == 0 {
 			break
 		}
 
 		if b[0] == '\n' || b[0] == '\r' {
 			b, err = p.parseNewline(b)
 			if err != nil {
 				return invalidReference, nil, err
 			}
 		} else {
 			break
 		}
 	}
 
 	return rootCommentRef, b, nil
 }
 
 func (p *Parser) parseMultilineLiteralString(b []byte) ([]byte, []byte, []byte, error) {
 	token, rest, err := scanMultilineLiteralString(b)
 	if err != nil {
 		return nil, nil, nil, err
 	}
 
 	i := 3
 
 	// skip the immediate new line
 	if token[i] == '\n' {
 		i++
 	} else if token[i] == '\r' && token[i+1] == '\n' {
 		i += 2
 	}
 
 	return token, token[i : len(token)-3], rest, err
 }
 
 //nolint:funlen,gocognit,cyclop
 func (p *Parser) parseMultilineBasicString(b []byte) ([]byte, []byte, []byte, error) {
 	// ml-basic-string = ml-basic-string-delim [ newline ] ml-basic-body
 	// ml-basic-string-delim
 	// ml-basic-string-delim = 3quotation-mark
 	// ml-basic-body = *mlb-content *( mlb-quotes 1*mlb-content ) [ mlb-quotes ]
 	//
 	// mlb-content = mlb-char / newline / mlb-escaped-nl
 	// mlb-char = mlb-unescaped / escaped
 	// mlb-quotes = 1*2quotation-mark
 	// mlb-unescaped = wschar / %x21 / %x23-5B / %x5D-7E / non-ascii
 	// mlb-escaped-nl = escape ws newline *( wschar / newline )
 	token, escaped, rest, err := scanMultilineBasicString(b)
 	if err != nil {
 		return nil, nil, nil, err
 	}
 
 	i := 3
 
 	// skip the immediate new line
 	if token[i] == '\n' {
 		i++
 	} else if token[i] == '\r' && token[i+1] == '\n' {
 		i += 2
 	}
 
 	// fast path
 	startIdx := i
 	endIdx := len(token) - len(`"""`)
 
 	if !escaped {
 		str := token[startIdx:endIdx]
 		verr := characters.Utf8TomlValidAlreadyEscaped(str)
 		if verr.Zero() {
 			return token, str, rest, nil
 		}
 		return nil, nil, nil, NewParserError(str[verr.Index:verr.Index+verr.Size], "invalid UTF-8")
 	}
 
 	var builder bytes.Buffer
 
 	// The scanner ensures that the token starts and ends with quotes and that
 	// escapes are balanced.
 	for i < len(token)-3 {
 		c := token[i]
 
 		//nolint:nestif
 		if c == '\\' {
 			// When the last non-whitespace character on a line is an unescaped \,
 			// it will be trimmed along with all whitespace (including newlines) up
 			// to the next non-whitespace character or closing delimiter.
 
 			isLastNonWhitespaceOnLine := false
 			j := 1
 		findEOLLoop:
 			for ; j < len(token)-3-i; j++ {
 				switch token[i+j] {
 				case ' ', '\t':
 					continue
 				case '\r':
 					if token[i+j+1] == '\n' {
 						continue
 					}
 				case '\n':
 					isLastNonWhitespaceOnLine = true
 				}
 				break findEOLLoop
 			}
 			if isLastNonWhitespaceOnLine {
 				i += j
 				for ; i < len(token)-3; i++ {
 					c := token[i]
 					if !(c == '\n' || c == '\r' || c == ' ' || c == '\t') {
 						i--
 						break
 					}
 				}
 				i++
 				continue
 			}
 
 			// handle escaping
 			i++
 			c = token[i]
 
 			switch c {
 			case '"', '\\':
 				builder.WriteByte(c)
 			case 'b':
 				builder.WriteByte('\b')
 			case 'f':
 				builder.WriteByte('\f')
 			case 'n':
 				builder.WriteByte('\n')
 			case 'r':
 				builder.WriteByte('\r')
 			case 't':
 				builder.WriteByte('\t')
 			case 'e':
 				builder.WriteByte(0x1B)
 			case 'u':
 				x, err := hexToRune(atmost(token[i+1:], 4), 4)
 				if err != nil {
 					return nil, nil, nil, err
 				}
 				builder.WriteRune(x)
 				i += 4
 			case 'U':
 				x, err := hexToRune(atmost(token[i+1:], 8), 8)
 				if err != nil {
 					return nil, nil, nil, err
 				}
 
 				builder.WriteRune(x)
 				i += 8
 			default:
 				return nil, nil, nil, NewParserError(token[i:i+1], "invalid escaped character %#U", c)
 			}
 			i++
 		} else {
 			size := characters.Utf8ValidNext(token[i:])
 			if size == 0 {
 				return nil, nil, nil, NewParserError(token[i:i+1], "invalid character %#U", c)
 			}
 			builder.Write(token[i : i+size])
 			i += size
 		}
 	}
 
 	return token, builder.Bytes(), rest, nil
 }
 
 func (p *Parser) parseKey(b []byte) (reference, []byte, error) {
 	// key = simple-key / dotted-key
 	// simple-key = quoted-key / unquoted-key
 	//
 	// unquoted-key = 1*( ALPHA / DIGIT / %x2D / %x5F ) ; A-Z / a-z / 0-9 / - / _
 	// quoted-key = basic-string / literal-string
 	// dotted-key = simple-key 1*( dot-sep simple-key )
 	//
 	// dot-sep   = ws %x2E ws  ; . Period
 	raw, key, b, err := p.parseSimpleKey(b)
 	if err != nil {
 		return invalidReference, nil, err
 	}
 
 	ref := p.builder.Push(Node{
 		Kind: Key,
 		Raw:  p.Range(raw),
 		Data: key,
 	})
 
 	for {
 		b = p.parseWhitespace(b)
 		if len(b) > 0 && b[0] == '.' {
 			b = p.parseWhitespace(b[1:])
 
 			raw, key, b, err = p.parseSimpleKey(b)
 			if err != nil {
 				return ref, nil, err
 			}
 
 			p.builder.PushAndChain(Node{
 				Kind: Key,
 				Raw:  p.Range(raw),
 				Data: key,
 			})
 		} else {
 			break
 		}
 	}
 
 	return ref, b, nil
 }
 
 func (p *Parser) parseSimpleKey(b []byte) (raw, key, rest []byte, err error) {
 	if len(b) == 0 {
 		return nil, nil, nil, NewParserError(b, "expected key but found none")
 	}
 
 	// simple-key = quoted-key / unquoted-key
 	// unquoted-key = 1*( ALPHA / DIGIT / %x2D / %x5F ) ; A-Z / a-z / 0-9 / - / _
 	// quoted-key = basic-string / literal-string
 	switch {
 	case b[0] == '\'':
 		return p.parseLiteralString(b)
 	case b[0] == '"':
 		return p.parseBasicString(b)
 	case isUnquotedKeyChar(b[0]):
 		key, rest = scanUnquotedKey(b)
 		return key, key, rest, nil
 	default:
 		return nil, nil, nil, NewParserError(b[0:1], "invalid character at start of key: %c", b[0])
 	}
 }
 
 //nolint:funlen,cyclop
 func (p *Parser) parseBasicString(b []byte) ([]byte, []byte, []byte, error) {
 	// basic-string = quotation-mark *basic-char quotation-mark
 	// quotation-mark = %x22            ; "
 	// basic-char = basic-unescaped / escaped
 	// basic-unescaped = wschar / %x21 / %x23-5B / %x5D-7E / non-ascii
 	// escaped = escape escape-seq-char
 	// escape-seq-char =  %x22         ; "    quotation mark  U+0022
 	// escape-seq-char =/ %x5C         ; \    reverse solidus U+005C
 	// escape-seq-char =/ %x62         ; b    backspace       U+0008
 	// escape-seq-char =/ %x66         ; f    form feed       U+000C
 	// escape-seq-char =/ %x6E         ; n    line feed       U+000A
 	// escape-seq-char =/ %x72         ; r    carriage return U+000D
 	// escape-seq-char =/ %x74         ; t    tab             U+0009
 	// escape-seq-char =/ %x75 4HEXDIG ; uXXXX                U+XXXX
 	// escape-seq-char =/ %x55 8HEXDIG ; UXXXXXXXX            U+XXXXXXXX
 	token, escaped, rest, err := scanBasicString(b)
 	if err != nil {
 		return nil, nil, nil, err
 	}
 
 	startIdx := len(`"`)
 	endIdx := len(token) - len(`"`)
 
 	// Fast path. If there is no escape sequence, the string should just be
 	// an UTF-8 encoded string, which is the same as Go. In that case,
 	// validate the string and return a direct reference to the buffer.
 	if !escaped {
 		str := token[startIdx:endIdx]
 		verr := characters.Utf8TomlValidAlreadyEscaped(str)
 		if verr.Zero() {
 			return token, str, rest, nil
 		}
 		return nil, nil, nil, NewParserError(str[verr.Index:verr.Index+verr.Size], "invalid UTF-8")
 	}
 
 	i := startIdx
 
 	var builder bytes.Buffer
 
 	// The scanner ensures that the token starts and ends with quotes and that
 	// escapes are balanced.
 	for i < len(token)-1 {
 		c := token[i]
 		if c == '\\' {
 			i++
 			c = token[i]
 
 			switch c {
 			case '"', '\\':
 				builder.WriteByte(c)
 			case 'b':
 				builder.WriteByte('\b')
 			case 'f':
 				builder.WriteByte('\f')
 			case 'n':
 				builder.WriteByte('\n')
 			case 'r':
 				builder.WriteByte('\r')
 			case 't':
 				builder.WriteByte('\t')
 			case 'e':
 				builder.WriteByte(0x1B)
 			case 'u':
 				x, err := hexToRune(token[i+1:len(token)-1], 4)
 				if err != nil {
 					return nil, nil, nil, err
 				}
 
 				builder.WriteRune(x)
 				i += 4
 			case 'U':
 				x, err := hexToRune(token[i+1:len(token)-1], 8)
 				if err != nil {
 					return nil, nil, nil, err
 				}
 
 				builder.WriteRune(x)
 				i += 8
 			default:
 				return nil, nil, nil, NewParserError(token[i:i+1], "invalid escaped character %#U", c)
 			}
 			i++
 		} else {
 			size := characters.Utf8ValidNext(token[i:])
 			if size == 0 {
 				return nil, nil, nil, NewParserError(token[i:i+1], "invalid character %#U", c)
 			}
 			builder.Write(token[i : i+size])
 			i += size
 		}
 	}
 
 	return token, builder.Bytes(), rest, nil
 }
 
 func hexToRune(b []byte, length int) (rune, error) {
 	if len(b) < length {
 		return -1, NewParserError(b, "unicode point needs %d character, not %d", length, len(b))
 	}
 	b = b[:length]
 
 	var r uint32
 	for i, c := range b {
 		d := uint32(0)
 		switch {
 		case '0' <= c && c <= '9':
 			d = uint32(c - '0')
 		case 'a' <= c && c <= 'f':
 			d = uint32(c - 'a' + 10)
 		case 'A' <= c && c <= 'F':
 			d = uint32(c - 'A' + 10)
 		default:
 			return -1, NewParserError(b[i:i+1], "non-hex character")
 		}
 		r = r*16 + d
 	}
 
 	if r > unicode.MaxRune || 0xD800 <= r && r < 0xE000 {
 		return -1, NewParserError(b, "escape sequence is invalid Unicode code point")
 	}
 
 	return rune(r), nil
 }
 
 func (p *Parser) parseWhitespace(b []byte) []byte {
 	// ws = *wschar
 	// wschar =  %x20  ; Space
 	// wschar =/ %x09  ; Horizontal tab
 	_, rest := scanWhitespace(b)
 
 	return rest
 }
 
 //nolint:cyclop
 func (p *Parser) parseIntOrFloatOrDateTime(b []byte) (reference, []byte, error) {
 	switch b[0] {
 	case 'i':
 		if !scanFollowsInf(b) {
 			return invalidReference, nil, NewParserError(atmost(b, 3), "expected 'inf'")
 		}
 
 		return p.builder.Push(Node{
 			Kind: Float,
 			Data: b[:3],
 		}), b[3:], nil
 	case 'n':
 		if !scanFollowsNan(b) {
 			return invalidReference, nil, NewParserError(atmost(b, 3), "expected 'nan'")
 		}
 
 		return p.builder.Push(Node{
 			Kind: Float,
 			Data: b[:3],
 		}), b[3:], nil
 	case '+', '-':
 		return p.scanIntOrFloat(b)
 	}
 
 	if len(b) < 3 {
 		return p.scanIntOrFloat(b)
 	}
 
 	s := 5
 	if len(b) < s {
 		s = len(b)
 	}
 
 	for idx, c := range b[:s] {
 		if isDigit(c) {
 			continue
 		}
 
 		if idx == 2 && c == ':' || (idx == 4 && c == '-') {
 			return p.scanDateTime(b)
 		}
 
 		break
 	}
 
 	return p.scanIntOrFloat(b)
 }
 
 func (p *Parser) scanDateTime(b []byte) (reference, []byte, error) {
 	// scans for contiguous characters in [0-9T:Z.+-], and up to one space if
 	// followed by a digit.
 	hasDate := false
 	hasTime := false
 	hasTz := false
 	seenSpace := false
 
 	i := 0
 byteLoop:
 	for ; i < len(b); i++ {
 		c := b[i]
 
 		switch {
 		case isDigit(c):
 		case c == '-':
 			hasDate = true
 			const minOffsetOfTz = 8
 			if i >= minOffsetOfTz {
 				hasTz = true
 			}
 		case c == 'T' || c == 't' || c == ':' || c == '.':
 			hasTime = true
 		case c == '+' || c == '-' || c == 'Z' || c == 'z':
 			hasTz = true
 		case c == ' ':
 			if !seenSpace && i+1 < len(b) && isDigit(b[i+1]) {
 				i += 2
 				// Avoid reaching past the end of the document in case the time
 				// is malformed. See TestIssue585.
 				if i >= len(b) {
 					i--
 				}
 				seenSpace = true
 				hasTime = true
 			} else {
 				break byteLoop
 			}
 		default:
 			break byteLoop
 		}
 	}
 
 	var kind Kind
 
 	if hasTime {
 		if hasDate {
 			if hasTz {
 				kind = DateTime
 			} else {
 				kind = LocalDateTime
 			}
 		} else {
 			kind = LocalTime
 		}
 	} else {
 		kind = LocalDate
 	}
 
 	return p.builder.Push(Node{
 		Kind: kind,
 		Data: b[:i],
 	}), b[i:], nil
 }
 
 //nolint:funlen,gocognit,cyclop
 func (p *Parser) scanIntOrFloat(b []byte) (reference, []byte, error) {
 	i := 0
 
 	if len(b) > 2 && b[0] == '0' && b[1] != '.' && b[1] != 'e' && b[1] != 'E' {
 		var isValidRune validRuneFn
 
 		switch b[1] {
 		case 'x':
 			isValidRune = isValidHexRune
 		case 'o':
 			isValidRune = isValidOctalRune
 		case 'b':
 			isValidRune = isValidBinaryRune
 		default:
 			i++
 		}
 
 		if isValidRune != nil {
 			i += 2
 			for ; i < len(b); i++ {
 				if !isValidRune(b[i]) {
 					break
 				}
 			}
 		}
 
 		return p.builder.Push(Node{
 			Kind: Integer,
 			Data: b[:i],
 		}), b[i:], nil
 	}
 
 	isFloat := false
 
 	for ; i < len(b); i++ {
 		c := b[i]
 
 		if c >= '0' && c <= '9' || c == '+' || c == '-' || c == '_' {
 			continue
 		}
 
 		if c == '.' || c == 'e' || c == 'E' {
 			isFloat = true
 
 			continue
 		}
 
 		if c == 'i' {
 			if scanFollowsInf(b[i:]) {
 				return p.builder.Push(Node{
 					Kind: Float,
 					Data: b[:i+3],
 				}), b[i+3:], nil
 			}
 
 			return invalidReference, nil, NewParserError(b[i:i+1], "unexpected character 'i' while scanning for a number")
 		}
 
 		if c == 'n' {
 			if scanFollowsNan(b[i:]) {
 				return p.builder.Push(Node{
 					Kind: Float,
 					Data: b[:i+3],
 				}), b[i+3:], nil
 			}
 
 			return invalidReference, nil, NewParserError(b[i:i+1], "unexpected character 'n' while scanning for a number")
 		}
 
 		break
 	}
 
 	if i == 0 {
 		return invalidReference, b, NewParserError(b, "incomplete number")
 	}
 
 	kind := Integer
 
 	if isFloat {
 		kind = Float
 	}
 
 	return p.builder.Push(Node{
 		Kind: kind,
 		Data: b[:i],
 	}), b[i:], nil
 }
 
 func isDigit(r byte) bool {
 	return r >= '0' && r <= '9'
 }
 
 type validRuneFn func(r byte) bool
 
 func isValidHexRune(r byte) bool {
 	return r >= 'a' && r <= 'f' ||
 		r >= 'A' && r <= 'F' ||
 		r >= '0' && r <= '9' ||
 		r == '_'
 }
 
 func isValidOctalRune(r byte) bool {
 	return r >= '0' && r <= '7' || r == '_'
 }
 
 func isValidBinaryRune(r byte) bool {
 	return r == '0' || r == '1' || r == '_'
 }
 
 func expect(x byte, b []byte) ([]byte, error) {
 	if len(b) == 0 {
 		return nil, NewParserError(b, "expected character %c but the document ended here", x)
 	}
 
 	if b[0] != x {
 		return nil, NewParserError(b[0:1], "expected character %c", x)
 	}
 
 	return b[1:], nil
 }