text

type BlockReader interface {
	Reader
	// Reset resets current state and sets new segments to the reader.
	Reset(segs []Segment)
}

type Decoder interface {
	// Decode decodes the given byte slice and returns the decoded bytes.
	Decode(b []byte) []byte

	// DecodeTo decodes the given byte slice and writes the decoded bytes to w.
	DecodeTo(w io.Writer, b []byte) (int, error)
}

type DecoderOption func(*decoderConfig)

type DefaultDecoder struct {
	// contains filtered or unexported fields
}

type Index struct {
	Start int
	Stop  int
}

type Lines struct {
	// contains filtered or unexported fields
}

type LinesInput interface {
	string | []byte | []Segment | Lines
}

type MultiLineValue struct {
	// contains filtered or unexported fields
}

type MultiLineValueInput interface {
	string | []byte | Index | []Index
}

type Reader interface {
	io.RuneReader

	// Source returns a source of the reader.
	Source() []byte

	// ResetPosition resets positions.
	ResetPosition()

	// Peek returns a byte at current position without advancing the internal pointer.
	Peek() byte

	// PeekLine returns the current line without advancing the internal pointer.
	PeekLine() ([]byte, Segment)

	// PrecedingCharacter returns a character just before current internal pointer.
	PrecedingCharacter() rune

	// ValueBetween returns a MultiLineValue covering the given [start, stop)
	// byte range within the source.
	//
	// Value will be decoded using the Decoder bound to this reader.
	ValueBetween(start, stop int) MultiLineValue

	// Decoder returns the Decoder bound to this reader. Values constructed
	// from positions within this reader's source should be bound to this
	// Decoder.
	Decoder() Decoder

	// LineOffset returns a distance from the line head to current position.
	LineOffset() int

	// Position returns current line number and position.
	Position() (int, Segment)

	// SetPosition sets current line number and position.
	SetPosition(int, Segment)

	// SetPadding sets padding to the reader.
	SetPadding(int)

	// Advance advances the internal pointer.
	Advance(int)

	// AdvanceAndSetPadding advances the internal pointer and add padding to the
	// reader.
	AdvanceAndSetPadding(int, int)

	// AdvanceToEOL advances the internal pointer to the end of line.
	// If the line ends with a newline, it will be included in the segment.
	// If the line ends with EOF, it will not be included in the segment.
	AdvanceToEOL()

	// AdvanceLine advances the internal pointer to the next line head.
	AdvanceLine()

	// SkipSpaces skips space characters and returns a non-blank line.
	// If it reaches EOF, returns false.
	SkipSpaces() (Segment, int, bool)

	// SkipBlankLines skips blank lines and returns a non-blank line.
	// If it reaches EOF, returns false.
	SkipBlankLines() (Segment, int, bool)

	// Match performs regular expression matching to current line.
	Match(reg *regexp.Regexp) bool

	// Match performs regular expression searching to current line.
	FindSubMatch(reg *regexp.Regexp) [][]byte
}

type Segment struct {
	// Start is a start position of the segment.
	Start int

	// Stop is a stop position of the segment.
	// This value should be excluded.
	Stop int

	// Padding is a padding length of the segment.
	Padding int

	// ForceNewline is true if the segment should be ended with a newline.
	// Some elements(i.e. CodeBlock, FencedCodeBlock) does not trim trailing
	// newlines. Spec defines that EOF is treated as a newline, so we need to
	// add a newline to the end of the segment if it is not empty.
	//
	// i.e.:
	//
	//     “`go
	//     const test = "test"
	//
	// This code does not close the code block and ends with EOF. In this case,
	// we need to add a newline to the end of the last line like `const test = "test"\n`.
	ForceNewline bool
}

type SingleLineValue struct {
	// contains filtered or unexported fields
}

type SingleLineValueInput interface {
	string | []byte | Index
}

type Value interface {
	// Value returns the decoded string representation of this value.
	Value(source []byte) string

	// Bytes returns the source byte slice corresponding to this value.
	Bytes(source []byte) []byte

	// Str returns the string representation of this value.
	Str(source []byte) string

	// IsOwned returns true if this value is an owned string not derived from the source byte slice.
	IsOwned() bool

	// IsEmpty returns true if this value is empty, otherwise false.
	IsEmpty() bool

	// Index returns the source position of this value.
	//
	// The result is meaningful only when IsOwned() returns false.
	// If Value is backed by multiple source positions, Index returns the first position.
	Index() Index

	// Indices returns the slice of Index values in this value.
	//
	// The result is meaningful only when IsOwned() returns false.
	Indices() []Index

	// WriteTo writes the value to the given buffer, using the [Value].Value.
	WriteTo(w io.Writer, source []byte) (int, error)
}

type ValueBuilder struct {
	// contains filtered or unexported fields
}