// license that can be found in the LICENSE file.

package strings

import (
	"errors"
	"io"
	"unicode/utf8"
)

// A Reader implements the [io.Reader], [io.ReaderAt], [io.ByteReader], [io.ByteScanner],
// [io.RuneReader], [io.RuneScanner], [io.Seeker], and [io.WriterTo] interfaces by reading
// from a string.
// The zero value for Reader operates like a Reader of an empty string.
type Reader struct {
	s        string

func (re *Regexp) doMatch(r io.RuneReader, b []byte, s string) bool {
	return re.doExecute(r, b, s, 0, 0, nil) != nil
}

// doExecute finds the leftmost match in the input, appends the position
// of its subexpressions to dstCap and returns dstCap.
//
// nil is returned if no matches are found and non-nil if matches are found.

//
// There is also a subset of the methods that can be applied to text read
// from a RuneReader:
//
//	MatchReader, FindReaderIndex, FindReaderSubmatchIndex
//
// This set may grow. Note that regular expression matches may need to
// examine text beyond the text returned by a match, so the methods that
// match text from a RuneReader may read arbitrarily far into the input
// before returning.
//

	"ReadFrom":      {[]string{"=io.Reader"}, []string{"int64", "error"}},              // io.ReaderFrom
	"ReadRune":      {[]string{}, []string{"rune", "int", "error"}},                    // io.RuneReader
	"Scan":          {[]string{"=fmt.ScanState", "rune"}, []string{"error"}},           // fmt.Scanner
	"Seek":          {[]string{"=int64", "int"}, []string{"int64", "error"}},           // io.Seeker

type ByteWriter interface {
	WriteByte(c byte) error
}

// RuneReader is the interface that wraps the ReadRune method.
//
// ReadRune reads a single encoded Unicode character
// and returns the rune and its size in bytes. If no character is
// available, err will be set.
type RuneReader interface {
	ReadRune() (r rune, size int, err error)
}

pkg io, type ReaderAt interface, ReadAt([]uint8, int64) (int, error)
pkg io, type ReaderFrom interface { ReadFrom }
pkg io, type ReaderFrom interface, ReadFrom(Reader) (int64, error)
pkg io, type RuneReader interface { ReadRune }
pkg io, type RuneReader interface, ReadRune() (int32, int, error)
pkg io, type RuneScanner interface { ReadRune, UnreadRune }
pkg io, type RuneScanner interface, ReadRune() (int32, int, error)

		{"ReadSeeker", Type, 0},
		{"ReadWriteCloser", Type, 0},
		{"ReadWriteSeeker", Type, 0},
		{"ReadWriter", Type, 0},
		{"Reader", Type, 0},
		{"ReaderAt", Type, 0},
		{"ReaderFrom", Type, 0},
		{"RuneReader", Type, 0},
		{"RuneScanner", Type, 0},
		{"SectionReader", Type, 0},
		{"SeekCurrent", Const, 7},
		{"SeekEnd", Const, 7},
		{"SeekStart", Const, 7},
		{"Seeker", Type, 0},