Type KeyType

Runes []rune

Alt bool

Paste bool

var buf strings.Builder

if k.Alt {

buf.WriteString("alt+")

}

if k.Type == KeyRunes {

if k.Paste {

// Note: bubbles/keys bindings currently do string compares to

// recognize shortcuts. Since pasted text should never activate

// shortcuts, we need to ensure that the binding code doesn't

// match Key events that result from pastes. We achieve this

// here by enclosing pastes in '[...]' so that the string

// comparison in Matches() fails in that case.

buf.WriteByte('[')

}

buf.WriteString(string(k.Runes))

if k.Paste {

buf.WriteByte(']')

}

return buf.String()

} else if s, ok := keyNames[k.Type]; ok {

buf.WriteString(s)

return buf.String()

}

return ""

if s, ok := keyNames[k]; ok {

return s

}

return ""

var buf [256]byte

var leftOverFromPrevIteration []byte

loop:

for {

// Read and block.

numBytes, err := input.Read(buf[:])

if err != nil {

return fmt.Errorf("error reading input: %w", err)

}

b := buf[:numBytes]

if leftOverFromPrevIteration != nil {

b = append(leftOverFromPrevIteration, b...)

}

// If we had a short read (numBytes < len(buf)), we're sure that

// the end of this read is an event boundary, so there is no doubt

// if we are encountering the end of the buffer while parsing a message.

// However, if we've succeeded in filling up the buffer, there may

// be more data in the OS buffer ready to be read in, to complete

// the last message in the input. In that case, we will retry with

// the left over data in the next iteration.

canHaveMoreData := numBytes == len(buf)

var i, w int

for i, w = 0, 0; i < len(b); i += w {

var msg Msg

w, msg = detectOneMsg(b[i:], canHaveMoreData)

if w == 0 {

// Expecting more bytes beyond the current buffer. Try waiting

// for more input.

leftOverFromPrevIteration = make([]byte, 0, len(b[i:])+len(buf))

leftOverFromPrevIteration = append(leftOverFromPrevIteration, b[i:]...)

continue loop

}

select {

case msgs <- msg:

case <-ctx.Done():

err := ctx.Err()

if err != nil {

err = fmt.Errorf("found context error while reading input: %w", err)

}

return err

}

}

leftOverFromPrevIteration = nil

}

// Detect mouse events.

// X10 mouse events have a length of 6 bytes

const mouseEventX10Len = 6

if len(b) >= mouseEventX10Len && b[0] == '\x1b' && b[1] == '[' {

switch b[2] {

case 'M':

return mouseEventX10Len, MouseMsg(parseX10MouseEvent(b))

case '<':

if matchIndices := mouseSGRRegex.FindSubmatchIndex(b[3:]); matchIndices != nil {

// SGR mouse events length is the length of the match plus the length of the escape sequence

mouseEventSGRLen := matchIndices[1] + 3 //nolint:gomnd

return mouseEventSGRLen, MouseMsg(parseSGRMouseEvent(b))

}

}

}

// Detect bracketed paste.

var foundbp bool

foundbp, w, msg = detectBracketedPaste(b)

if foundbp {

return w, msg

}

// Detect escape sequence and control characters other than NUL,

// possibly with an escape character in front to mark the Alt

// modifier.

var foundSeq bool

foundSeq, w, msg = detectSequence(b)

if foundSeq {

return w, msg

}

// No non-NUL control character or escape sequence.

// If we are seeing at least an escape character, remember it for later below.

alt := false

i := 0

if b[0] == '\x1b' {

alt = true

i++

}

// Are we seeing a standalone NUL? This is not handled by detectSequence().

if i < len(b) && b[i] == 0 {

return i + 1, KeyMsg{Type: keyNUL, Alt: alt}

}

// Find the longest sequence of runes that are not control

// characters from this point.

var runes []rune

for rw := 0; i < len(b); i += rw {

var r rune

r, rw = utf8.DecodeRune(b[i:])

if r == utf8.RuneError || r <= rune(keyUS) || r == rune(keyDEL) || r == ' ' {

// Rune errors are handled below; control characters and spaces will

// be handled by detectSequence in the next call to detectOneMsg.

break

}

runes = append(runes, r)

if alt {

// We only support a single rune after an escape alt modifier.

i += rw

break

}

}

if i >= len(b) && canHaveMoreData {

// We have encountered the end of the input buffer. Alas, we can't

// be sure whether the data in the remainder of the buffer is

// complete (maybe there was a short read). Instead of sending anything

// dumb to the message channel, do a short read. The outer loop will

// handle this case by extending the buffer as necessary.

return 0, nil

}

// If we found at least one rune, we report the bunch of them as

// a single KeyRunes or KeySpace event.

if len(runes) > 0 {

k := Key{Type: KeyRunes, Runes: runes, Alt: alt}

if len(runes) == 1 && runes[0] == ' ' {

k.Type = KeySpace

}

return i, KeyMsg(k)

}

// We didn't find an escape sequence, nor a valid rune. Was this a

// lone escape character at the end of the input?

if alt && len(b) == 1 {

return 1, KeyMsg(Key{Type: KeyEscape})

}

// The character at the current position is neither an escape

// sequence, a valid rune start or a sole escape character. Report

// it as an invalid byte.

return 1, unknownInputByteMsg(b[0])