+
+ 
+ 
+ 
+
+
+
+
+
+
+
+ 
+
+ 
+ 
+
+
+Charm热爱开源 • Charm loves open source • نحنُ نحب المصادر المفتوحة
diff --git a/vendor/github.com/charmbracelet/bubbletea/commands.go b/vendor/github.com/charmbracelet/bubbletea/commands.go
new file mode 100644
index 00000000000..bfa3b704555
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/commands.go
@@ -0,0 +1,216 @@
+package tea
+
+import (
+ "time"
+)
+
+// Batch performs a bunch of commands concurrently with no ordering guarantees
+// about the results. Use a Batch to return several commands.
+//
+// Example:
+//
+// func (m model) Init() Cmd {
+// return tea.Batch(someCommand, someOtherCommand)
+// }
+func Batch(cmds ...Cmd) Cmd {
+ var validCmds []Cmd //nolint:prealloc
+ for _, c := range cmds {
+ if c == nil {
+ continue
+ }
+ validCmds = append(validCmds, c)
+ }
+ switch len(validCmds) {
+ case 0:
+ return nil
+ case 1:
+ return validCmds[0]
+ default:
+ return func() Msg {
+ return BatchMsg(validCmds)
+ }
+ }
+}
+
+// BatchMsg is a message used to perform a bunch of commands concurrently with
+// no ordering guarantees. You can send a BatchMsg with Batch.
+type BatchMsg []Cmd
+
+// Sequence runs the given commands one at a time, in order. Contrast this with
+// Batch, which runs commands concurrently.
+func Sequence(cmds ...Cmd) Cmd {
+ return func() Msg {
+ return sequenceMsg(cmds)
+ }
+}
+
+// sequenceMsg is used internally to run the given commands in order.
+type sequenceMsg []Cmd
+
+// Every is a command that ticks in sync with the system clock. So, if you
+// wanted to tick with the system clock every second, minute or hour you
+// could use this. It's also handy for having different things tick in sync.
+//
+// Because we're ticking with the system clock the tick will likely not run for
+// the entire specified duration. For example, if we're ticking for one minute
+// and the clock is at 12:34:20 then the next tick will happen at 12:35:00, 40
+// seconds later.
+//
+// To produce the command, pass a duration and a function which returns
+// a message containing the time at which the tick occurred.
+//
+// type TickMsg time.Time
+//
+// cmd := Every(time.Second, func(t time.Time) Msg {
+// return TickMsg(t)
+// })
+//
+// Beginners' note: Every sends a single message and won't automatically
+// dispatch messages at an interval. To do that, you'll want to return another
+// Every command after receiving your tick message. For example:
+//
+// type TickMsg time.Time
+//
+// // Send a message every second.
+// func tickEvery() Cmd {
+// return Every(time.Second, func(t time.Time) Msg {
+// return TickMsg(t)
+// })
+// }
+//
+// func (m model) Init() Cmd {
+// // Start ticking.
+// return tickEvery()
+// }
+//
+// func (m model) Update(msg Msg) (Model, Cmd) {
+// switch msg.(type) {
+// case TickMsg:
+// // Return your Every command again to loop.
+// return m, tickEvery()
+// }
+// return m, nil
+// }
+//
+// Every is analogous to Tick in the Elm Architecture.
+func Every(duration time.Duration, fn func(time.Time) Msg) Cmd {
+ n := time.Now()
+ d := n.Truncate(duration).Add(duration).Sub(n)
+ t := time.NewTimer(d)
+ return func() Msg {
+ ts := <-t.C
+ t.Stop()
+ for len(t.C) > 0 {
+ <-t.C
+ }
+ return fn(ts)
+ }
+}
+
+// Tick produces a command at an interval independent of the system clock at
+// the given duration. That is, the timer begins precisely when invoked,
+// and runs for its entire duration.
+//
+// To produce the command, pass a duration and a function which returns
+// a message containing the time at which the tick occurred.
+//
+// type TickMsg time.Time
+//
+// cmd := Tick(time.Second, func(t time.Time) Msg {
+// return TickMsg(t)
+// })
+//
+// Beginners' note: Tick sends a single message and won't automatically
+// dispatch messages at an interval. To do that, you'll want to return another
+// Tick command after receiving your tick message. For example:
+//
+// type TickMsg time.Time
+//
+// func doTick() Cmd {
+// return Tick(time.Second, func(t time.Time) Msg {
+// return TickMsg(t)
+// })
+// }
+//
+// func (m model) Init() Cmd {
+// // Start ticking.
+// return doTick()
+// }
+//
+// func (m model) Update(msg Msg) (Model, Cmd) {
+// switch msg.(type) {
+// case TickMsg:
+// // Return your Tick command again to loop.
+// return m, doTick()
+// }
+// return m, nil
+// }
+func Tick(d time.Duration, fn func(time.Time) Msg) Cmd {
+ t := time.NewTimer(d)
+ return func() Msg {
+ ts := <-t.C
+ t.Stop()
+ for len(t.C) > 0 {
+ <-t.C
+ }
+ return fn(ts)
+ }
+}
+
+// Sequentially produces a command that sequentially executes the given
+// commands.
+// The Msg returned is the first non-nil message returned by a Cmd.
+//
+// func saveStateCmd() Msg {
+// if err := save(); err != nil {
+// return errMsg{err}
+// }
+// return nil
+// }
+//
+// cmd := Sequentially(saveStateCmd, Quit)
+//
+// Deprecated: use Sequence instead.
+func Sequentially(cmds ...Cmd) Cmd {
+ return func() Msg {
+ for _, cmd := range cmds {
+ if cmd == nil {
+ continue
+ }
+ if msg := cmd(); msg != nil {
+ return msg
+ }
+ }
+ return nil
+ }
+}
+
+// setWindowTitleMsg is an internal message used to set the window title.
+type setWindowTitleMsg string
+
+// SetWindowTitle produces a command that sets the terminal title.
+//
+// For example:
+//
+// func (m model) Init() Cmd {
+// // Set title.
+// return tea.SetWindowTitle("My App")
+// }
+func SetWindowTitle(title string) Cmd {
+ return func() Msg {
+ return setWindowTitleMsg(title)
+ }
+}
+
+type windowSizeMsg struct{}
+
+// WindowSize is a command that queries the terminal for its current size. It
+// delivers the results to Update via a [WindowSizeMsg]. Keep in mind that
+// WindowSizeMsgs will automatically be delivered to Update when the [Program]
+// starts and when the window dimensions change so in many cases you will not
+// need to explicitly invoke this command.
+func WindowSize() Cmd {
+ return func() Msg {
+ return windowSizeMsg{}
+ }
+}
diff --git a/vendor/github.com/charmbracelet/bubbletea/exec.go b/vendor/github.com/charmbracelet/bubbletea/exec.go
new file mode 100644
index 00000000000..7a14d2a7786
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/exec.go
@@ -0,0 +1,129 @@
+package tea
+
+import (
+ "io"
+ "os"
+ "os/exec"
+)
+
+// execMsg is used internally to run an ExecCommand sent with Exec.
+type execMsg struct {
+ cmd ExecCommand
+ fn ExecCallback
+}
+
+// Exec is used to perform arbitrary I/O in a blocking fashion, effectively
+// pausing the Program while execution is running and resuming it when
+// execution has completed.
+//
+// Most of the time you'll want to use ExecProcess, which runs an exec.Cmd.
+//
+// For non-interactive i/o you should use a Cmd (that is, a tea.Cmd).
+func Exec(c ExecCommand, fn ExecCallback) Cmd {
+ return func() Msg {
+ return execMsg{cmd: c, fn: fn}
+ }
+}
+
+// ExecProcess runs the given *exec.Cmd in a blocking fashion, effectively
+// pausing the Program while the command is running. After the *exec.Cmd exists
+// the Program resumes. It's useful for spawning other interactive applications
+// such as editors and shells from within a Program.
+//
+// To produce the command, pass an *exec.Cmd and a function which returns
+// a message containing the error which may have occurred when running the
+// ExecCommand.
+//
+// type VimFinishedMsg struct { err error }
+//
+// c := exec.Command("vim", "file.txt")
+//
+// cmd := ExecProcess(c, func(err error) Msg {
+// return VimFinishedMsg{err: err}
+// })
+//
+// Or, if you don't care about errors, you could simply:
+//
+// cmd := ExecProcess(exec.Command("vim", "file.txt"), nil)
+//
+// For non-interactive i/o you should use a Cmd (that is, a tea.Cmd).
+func ExecProcess(c *exec.Cmd, fn ExecCallback) Cmd {
+ return Exec(wrapExecCommand(c), fn)
+}
+
+// ExecCallback is used when executing an *exec.Command to return a message
+// with an error, which may or may not be nil.
+type ExecCallback func(error) Msg
+
+// ExecCommand can be implemented to execute things in a blocking fashion in
+// the current terminal.
+type ExecCommand interface {
+ Run() error
+ SetStdin(io.Reader)
+ SetStdout(io.Writer)
+ SetStderr(io.Writer)
+}
+
+// wrapExecCommand wraps an exec.Cmd so that it satisfies the ExecCommand
+// interface so it can be used with Exec.
+func wrapExecCommand(c *exec.Cmd) ExecCommand {
+ return &osExecCommand{Cmd: c}
+}
+
+// osExecCommand is a layer over an exec.Cmd that satisfies the ExecCommand
+// interface.
+type osExecCommand struct{ *exec.Cmd }
+
+// SetStdin sets stdin on underlying exec.Cmd to the given io.Reader.
+func (c *osExecCommand) SetStdin(r io.Reader) {
+ // If unset, have the command use the same input as the terminal.
+ if c.Stdin == nil {
+ c.Stdin = r
+ }
+}
+
+// SetStdout sets stdout on underlying exec.Cmd to the given io.Writer.
+func (c *osExecCommand) SetStdout(w io.Writer) {
+ // If unset, have the command use the same output as the terminal.
+ if c.Stdout == nil {
+ c.Stdout = w
+ }
+}
+
+// SetStderr sets stderr on the underlying exec.Cmd to the given io.Writer.
+func (c *osExecCommand) SetStderr(w io.Writer) {
+ // If unset, use stderr for the command's stderr
+ if c.Stderr == nil {
+ c.Stderr = w
+ }
+}
+
+// exec runs an ExecCommand and delivers the results to the program as a Msg.
+func (p *Program) exec(c ExecCommand, fn ExecCallback) {
+ if err := p.ReleaseTerminal(); err != nil {
+ // If we can't release input, abort.
+ if fn != nil {
+ go p.Send(fn(err))
+ }
+ return
+ }
+
+ c.SetStdin(p.input)
+ c.SetStdout(p.output)
+ c.SetStderr(os.Stderr)
+
+ // Execute system command.
+ if err := c.Run(); err != nil {
+ _ = p.RestoreTerminal() // also try to restore the terminal.
+ if fn != nil {
+ go p.Send(fn(err))
+ }
+ return
+ }
+
+ // Have the program re-capture input.
+ err := p.RestoreTerminal()
+ if fn != nil {
+ go p.Send(fn(err))
+ }
+}
diff --git a/vendor/github.com/charmbracelet/bubbletea/focus.go b/vendor/github.com/charmbracelet/bubbletea/focus.go
new file mode 100644
index 00000000000..4d34bea6f83
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/focus.go
@@ -0,0 +1,9 @@
+package tea
+
+// FocusMsg represents a terminal focus message.
+// This occurs when the terminal gains focus.
+type FocusMsg struct{}
+
+// BlurMsg represents a terminal blur message.
+// This occurs when the terminal loses focus.
+type BlurMsg struct{}
diff --git a/vendor/github.com/charmbracelet/bubbletea/inputreader_other.go b/vendor/github.com/charmbracelet/bubbletea/inputreader_other.go
new file mode 100644
index 00000000000..3426a177c7e
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/inputreader_other.go
@@ -0,0 +1,14 @@
+//go:build !windows
+// +build !windows
+
+package tea
+
+import (
+ "io"
+
+ "github.com/muesli/cancelreader"
+)
+
+func newInputReader(r io.Reader, _ bool) (cancelreader.CancelReader, error) {
+ return cancelreader.NewReader(r)
+}
diff --git a/vendor/github.com/charmbracelet/bubbletea/inputreader_windows.go b/vendor/github.com/charmbracelet/bubbletea/inputreader_windows.go
new file mode 100644
index 00000000000..9af89428d81
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/inputreader_windows.go
@@ -0,0 +1,127 @@
+//go:build windows
+// +build windows
+
+package tea
+
+import (
+ "fmt"
+ "io"
+ "os"
+ "sync"
+
+ "github.com/charmbracelet/x/term"
+ "github.com/erikgeiser/coninput"
+ "github.com/muesli/cancelreader"
+ "golang.org/x/sys/windows"
+)
+
+type conInputReader struct {
+ cancelMixin
+
+ conin windows.Handle
+
+ originalMode uint32
+}
+
+var _ cancelreader.CancelReader = &conInputReader{}
+
+func newInputReader(r io.Reader, enableMouse bool) (cancelreader.CancelReader, error) {
+ fallback := func(io.Reader) (cancelreader.CancelReader, error) {
+ return cancelreader.NewReader(r)
+ }
+ if f, ok := r.(term.File); !ok || f.Fd() != os.Stdin.Fd() {
+ return fallback(r)
+ }
+
+ conin, err := coninput.NewStdinHandle()
+ if err != nil {
+ return fallback(r)
+ }
+
+ modes := []uint32{
+ windows.ENABLE_WINDOW_INPUT,
+ windows.ENABLE_EXTENDED_FLAGS,
+ }
+
+ // Since we have options to enable mouse events, [WithMouseCellMotion],
+ // [WithMouseAllMotion], and [EnableMouseCellMotion],
+ // [EnableMouseAllMotion], and [DisableMouse], we need to check if the user
+ // has enabled mouse events and add the appropriate mode accordingly.
+ // Otherwise, mouse events will be enabled all the time.
+ if enableMouse {
+ modes = append(modes, windows.ENABLE_MOUSE_INPUT)
+ }
+
+ originalMode, err := prepareConsole(conin, modes...)
+ if err != nil {
+ return nil, fmt.Errorf("failed to prepare console input: %w", err)
+ }
+
+ return &conInputReader{
+ conin: conin,
+ originalMode: originalMode,
+ }, nil
+}
+
+// Cancel implements cancelreader.CancelReader.
+func (r *conInputReader) Cancel() bool {
+ r.setCanceled()
+
+ return windows.CancelIoEx(r.conin, nil) == nil || windows.CancelIo(r.conin) == nil
+}
+
+// Close implements cancelreader.CancelReader.
+func (r *conInputReader) Close() error {
+ if r.originalMode != 0 {
+ err := windows.SetConsoleMode(r.conin, r.originalMode)
+ if err != nil {
+ return fmt.Errorf("reset console mode: %w", err)
+ }
+ }
+
+ return nil
+}
+
+// Read implements cancelreader.CancelReader.
+func (r *conInputReader) Read(_ []byte) (n int, err error) {
+ if r.isCanceled() {
+ err = cancelreader.ErrCanceled
+ }
+ return
+}
+
+func prepareConsole(input windows.Handle, modes ...uint32) (originalMode uint32, err error) {
+ err = windows.GetConsoleMode(input, &originalMode)
+ if err != nil {
+ return 0, fmt.Errorf("get console mode: %w", err)
+ }
+
+ newMode := coninput.AddInputModes(0, modes...)
+
+ err = windows.SetConsoleMode(input, newMode)
+ if err != nil {
+ return 0, fmt.Errorf("set console mode: %w", err)
+ }
+
+ return originalMode, nil
+}
+
+// cancelMixin represents a goroutine-safe cancelation status.
+type cancelMixin struct {
+ unsafeCanceled bool
+ lock sync.Mutex
+}
+
+func (c *cancelMixin) setCanceled() {
+ c.lock.Lock()
+ defer c.lock.Unlock()
+
+ c.unsafeCanceled = true
+}
+
+func (c *cancelMixin) isCanceled() bool {
+ c.lock.Lock()
+ defer c.lock.Unlock()
+
+ return c.unsafeCanceled
+}
diff --git a/vendor/github.com/charmbracelet/bubbletea/key.go b/vendor/github.com/charmbracelet/bubbletea/key.go
new file mode 100644
index 00000000000..ab4792ac63e
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/key.go
@@ -0,0 +1,715 @@
+package tea
+
+import (
+ "context"
+ "fmt"
+ "io"
+ "regexp"
+ "strings"
+ "unicode/utf8"
+)
+
+// KeyMsg contains information about a keypress. KeyMsgs are always sent to
+// the program's update function. There are a couple general patterns you could
+// use to check for keypresses:
+//
+// // Switch on the string representation of the key (shorter)
+// switch msg := msg.(type) {
+// case KeyMsg:
+// switch msg.String() {
+// case "enter":
+// fmt.Println("you pressed enter!")
+// case "a":
+// fmt.Println("you pressed a!")
+// }
+// }
+//
+// // Switch on the key type (more foolproof)
+// switch msg := msg.(type) {
+// case KeyMsg:
+// switch msg.Type {
+// case KeyEnter:
+// fmt.Println("you pressed enter!")
+// case KeyRunes:
+// switch string(msg.Runes) {
+// case "a":
+// fmt.Println("you pressed a!")
+// }
+// }
+// }
+//
+// Note that Key.Runes will always contain at least one character, so you can
+// always safely call Key.Runes[0]. In most cases Key.Runes will only contain
+// one character, though certain input method editors (most notably Chinese
+// IMEs) can input multiple runes at once.
+type KeyMsg Key
+
+// String returns a string representation for a key message. It's safe (and
+// encouraged) for use in key comparison.
+func (k KeyMsg) String() (str string) {
+ return Key(k).String()
+}
+
+// Key contains information about a keypress.
+type Key struct {
+ Type KeyType
+ Runes []rune
+ Alt bool
+ Paste bool
+}
+
+// String returns a friendly string representation for a key. It's safe (and
+// encouraged) for use in key comparison.
+//
+// k := Key{Type: KeyEnter}
+// fmt.Println(k)
+// // Output: enter
+func (k Key) String() (str string) {
+ 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 ""
+}
+
+// KeyType indicates the key pressed, such as KeyEnter or KeyBreak or KeyCtrlC.
+// All other keys will be type KeyRunes. To get the rune value, check the Rune
+// method on a Key struct, or use the Key.String() method:
+//
+// k := Key{Type: KeyRunes, Runes: []rune{'a'}, Alt: true}
+// if k.Type == KeyRunes {
+//
+// fmt.Println(k.Runes)
+// // Output: a
+//
+// fmt.Println(k.String())
+// // Output: alt+a
+//
+// }
+type KeyType int
+
+func (k KeyType) String() (str string) {
+ if s, ok := keyNames[k]; ok {
+ return s
+ }
+ return ""
+}
+
+// Control keys. We could do this with an iota, but the values are very
+// specific, so we set the values explicitly to avoid any confusion.
+//
+// See also:
+// https://en.wikipedia.org/wiki/C0_and_C1_control_codes
+const (
+ keyNUL KeyType = 0 // null, \0
+ keySOH KeyType = 1 // start of heading
+ keySTX KeyType = 2 // start of text
+ keyETX KeyType = 3 // break, ctrl+c
+ keyEOT KeyType = 4 // end of transmission
+ keyENQ KeyType = 5 // enquiry
+ keyACK KeyType = 6 // acknowledge
+ keyBEL KeyType = 7 // bell, \a
+ keyBS KeyType = 8 // backspace
+ keyHT KeyType = 9 // horizontal tabulation, \t
+ keyLF KeyType = 10 // line feed, \n
+ keyVT KeyType = 11 // vertical tabulation \v
+ keyFF KeyType = 12 // form feed \f
+ keyCR KeyType = 13 // carriage return, \r
+ keySO KeyType = 14 // shift out
+ keySI KeyType = 15 // shift in
+ keyDLE KeyType = 16 // data link escape
+ keyDC1 KeyType = 17 // device control one
+ keyDC2 KeyType = 18 // device control two
+ keyDC3 KeyType = 19 // device control three
+ keyDC4 KeyType = 20 // device control four
+ keyNAK KeyType = 21 // negative acknowledge
+ keySYN KeyType = 22 // synchronous idle
+ keyETB KeyType = 23 // end of transmission block
+ keyCAN KeyType = 24 // cancel
+ keyEM KeyType = 25 // end of medium
+ keySUB KeyType = 26 // substitution
+ keyESC KeyType = 27 // escape, \e
+ keyFS KeyType = 28 // file separator
+ keyGS KeyType = 29 // group separator
+ keyRS KeyType = 30 // record separator
+ keyUS KeyType = 31 // unit separator
+ keyDEL KeyType = 127 // delete. on most systems this is mapped to backspace, I hear
+)
+
+// Control key aliases.
+const (
+ KeyNull KeyType = keyNUL
+ KeyBreak KeyType = keyETX
+ KeyEnter KeyType = keyCR
+ KeyBackspace KeyType = keyDEL
+ KeyTab KeyType = keyHT
+ KeyEsc KeyType = keyESC
+ KeyEscape KeyType = keyESC
+
+ KeyCtrlAt KeyType = keyNUL // ctrl+@
+ KeyCtrlA KeyType = keySOH
+ KeyCtrlB KeyType = keySTX
+ KeyCtrlC KeyType = keyETX
+ KeyCtrlD KeyType = keyEOT
+ KeyCtrlE KeyType = keyENQ
+ KeyCtrlF KeyType = keyACK
+ KeyCtrlG KeyType = keyBEL
+ KeyCtrlH KeyType = keyBS
+ KeyCtrlI KeyType = keyHT
+ KeyCtrlJ KeyType = keyLF
+ KeyCtrlK KeyType = keyVT
+ KeyCtrlL KeyType = keyFF
+ KeyCtrlM KeyType = keyCR
+ KeyCtrlN KeyType = keySO
+ KeyCtrlO KeyType = keySI
+ KeyCtrlP KeyType = keyDLE
+ KeyCtrlQ KeyType = keyDC1
+ KeyCtrlR KeyType = keyDC2
+ KeyCtrlS KeyType = keyDC3
+ KeyCtrlT KeyType = keyDC4
+ KeyCtrlU KeyType = keyNAK
+ KeyCtrlV KeyType = keySYN
+ KeyCtrlW KeyType = keyETB
+ KeyCtrlX KeyType = keyCAN
+ KeyCtrlY KeyType = keyEM
+ KeyCtrlZ KeyType = keySUB
+ KeyCtrlOpenBracket KeyType = keyESC // ctrl+[
+ KeyCtrlBackslash KeyType = keyFS // ctrl+\
+ KeyCtrlCloseBracket KeyType = keyGS // ctrl+]
+ KeyCtrlCaret KeyType = keyRS // ctrl+^
+ KeyCtrlUnderscore KeyType = keyUS // ctrl+_
+ KeyCtrlQuestionMark KeyType = keyDEL // ctrl+?
+)
+
+// Other keys.
+const (
+ KeyRunes KeyType = -(iota + 1)
+ KeyUp
+ KeyDown
+ KeyRight
+ KeyLeft
+ KeyShiftTab
+ KeyHome
+ KeyEnd
+ KeyPgUp
+ KeyPgDown
+ KeyCtrlPgUp
+ KeyCtrlPgDown
+ KeyDelete
+ KeyInsert
+ KeySpace
+ KeyCtrlUp
+ KeyCtrlDown
+ KeyCtrlRight
+ KeyCtrlLeft
+ KeyCtrlHome
+ KeyCtrlEnd
+ KeyShiftUp
+ KeyShiftDown
+ KeyShiftRight
+ KeyShiftLeft
+ KeyShiftHome
+ KeyShiftEnd
+ KeyCtrlShiftUp
+ KeyCtrlShiftDown
+ KeyCtrlShiftLeft
+ KeyCtrlShiftRight
+ KeyCtrlShiftHome
+ KeyCtrlShiftEnd
+ KeyF1
+ KeyF2
+ KeyF3
+ KeyF4
+ KeyF5
+ KeyF6
+ KeyF7
+ KeyF8
+ KeyF9
+ KeyF10
+ KeyF11
+ KeyF12
+ KeyF13
+ KeyF14
+ KeyF15
+ KeyF16
+ KeyF17
+ KeyF18
+ KeyF19
+ KeyF20
+)
+
+// Mappings for control keys and other special keys to friendly consts.
+var keyNames = map[KeyType]string{
+ // Control keys.
+ keyNUL: "ctrl+@", // also ctrl+` (that's ctrl+backtick)
+ keySOH: "ctrl+a",
+ keySTX: "ctrl+b",
+ keyETX: "ctrl+c",
+ keyEOT: "ctrl+d",
+ keyENQ: "ctrl+e",
+ keyACK: "ctrl+f",
+ keyBEL: "ctrl+g",
+ keyBS: "ctrl+h",
+ keyHT: "tab", // also ctrl+i
+ keyLF: "ctrl+j",
+ keyVT: "ctrl+k",
+ keyFF: "ctrl+l",
+ keyCR: "enter",
+ keySO: "ctrl+n",
+ keySI: "ctrl+o",
+ keyDLE: "ctrl+p",
+ keyDC1: "ctrl+q",
+ keyDC2: "ctrl+r",
+ keyDC3: "ctrl+s",
+ keyDC4: "ctrl+t",
+ keyNAK: "ctrl+u",
+ keySYN: "ctrl+v",
+ keyETB: "ctrl+w",
+ keyCAN: "ctrl+x",
+ keyEM: "ctrl+y",
+ keySUB: "ctrl+z",
+ keyESC: "esc",
+ keyFS: "ctrl+\\",
+ keyGS: "ctrl+]",
+ keyRS: "ctrl+^",
+ keyUS: "ctrl+_",
+ keyDEL: "backspace",
+
+ // Other keys.
+ KeyRunes: "runes",
+ KeyUp: "up",
+ KeyDown: "down",
+ KeyRight: "right",
+ KeySpace: " ", // for backwards compatibility
+ KeyLeft: "left",
+ KeyShiftTab: "shift+tab",
+ KeyHome: "home",
+ KeyEnd: "end",
+ KeyCtrlHome: "ctrl+home",
+ KeyCtrlEnd: "ctrl+end",
+ KeyShiftHome: "shift+home",
+ KeyShiftEnd: "shift+end",
+ KeyCtrlShiftHome: "ctrl+shift+home",
+ KeyCtrlShiftEnd: "ctrl+shift+end",
+ KeyPgUp: "pgup",
+ KeyPgDown: "pgdown",
+ KeyCtrlPgUp: "ctrl+pgup",
+ KeyCtrlPgDown: "ctrl+pgdown",
+ KeyDelete: "delete",
+ KeyInsert: "insert",
+ KeyCtrlUp: "ctrl+up",
+ KeyCtrlDown: "ctrl+down",
+ KeyCtrlRight: "ctrl+right",
+ KeyCtrlLeft: "ctrl+left",
+ KeyShiftUp: "shift+up",
+ KeyShiftDown: "shift+down",
+ KeyShiftRight: "shift+right",
+ KeyShiftLeft: "shift+left",
+ KeyCtrlShiftUp: "ctrl+shift+up",
+ KeyCtrlShiftDown: "ctrl+shift+down",
+ KeyCtrlShiftLeft: "ctrl+shift+left",
+ KeyCtrlShiftRight: "ctrl+shift+right",
+ KeyF1: "f1",
+ KeyF2: "f2",
+ KeyF3: "f3",
+ KeyF4: "f4",
+ KeyF5: "f5",
+ KeyF6: "f6",
+ KeyF7: "f7",
+ KeyF8: "f8",
+ KeyF9: "f9",
+ KeyF10: "f10",
+ KeyF11: "f11",
+ KeyF12: "f12",
+ KeyF13: "f13",
+ KeyF14: "f14",
+ KeyF15: "f15",
+ KeyF16: "f16",
+ KeyF17: "f17",
+ KeyF18: "f18",
+ KeyF19: "f19",
+ KeyF20: "f20",
+}
+
+// Sequence mappings.
+var sequences = map[string]Key{
+ // Arrow keys
+ "\x1b[A": {Type: KeyUp},
+ "\x1b[B": {Type: KeyDown},
+ "\x1b[C": {Type: KeyRight},
+ "\x1b[D": {Type: KeyLeft},
+ "\x1b[1;2A": {Type: KeyShiftUp},
+ "\x1b[1;2B": {Type: KeyShiftDown},
+ "\x1b[1;2C": {Type: KeyShiftRight},
+ "\x1b[1;2D": {Type: KeyShiftLeft},
+ "\x1b[OA": {Type: KeyShiftUp}, // DECCKM
+ "\x1b[OB": {Type: KeyShiftDown}, // DECCKM
+ "\x1b[OC": {Type: KeyShiftRight}, // DECCKM
+ "\x1b[OD": {Type: KeyShiftLeft}, // DECCKM
+ "\x1b[a": {Type: KeyShiftUp}, // urxvt
+ "\x1b[b": {Type: KeyShiftDown}, // urxvt
+ "\x1b[c": {Type: KeyShiftRight}, // urxvt
+ "\x1b[d": {Type: KeyShiftLeft}, // urxvt
+ "\x1b[1;3A": {Type: KeyUp, Alt: true},
+ "\x1b[1;3B": {Type: KeyDown, Alt: true},
+ "\x1b[1;3C": {Type: KeyRight, Alt: true},
+ "\x1b[1;3D": {Type: KeyLeft, Alt: true},
+
+ "\x1b[1;4A": {Type: KeyShiftUp, Alt: true},
+ "\x1b[1;4B": {Type: KeyShiftDown, Alt: true},
+ "\x1b[1;4C": {Type: KeyShiftRight, Alt: true},
+ "\x1b[1;4D": {Type: KeyShiftLeft, Alt: true},
+
+ "\x1b[1;5A": {Type: KeyCtrlUp},
+ "\x1b[1;5B": {Type: KeyCtrlDown},
+ "\x1b[1;5C": {Type: KeyCtrlRight},
+ "\x1b[1;5D": {Type: KeyCtrlLeft},
+ "\x1b[Oa": {Type: KeyCtrlUp, Alt: true}, // urxvt
+ "\x1b[Ob": {Type: KeyCtrlDown, Alt: true}, // urxvt
+ "\x1b[Oc": {Type: KeyCtrlRight, Alt: true}, // urxvt
+ "\x1b[Od": {Type: KeyCtrlLeft, Alt: true}, // urxvt
+ "\x1b[1;6A": {Type: KeyCtrlShiftUp},
+ "\x1b[1;6B": {Type: KeyCtrlShiftDown},
+ "\x1b[1;6C": {Type: KeyCtrlShiftRight},
+ "\x1b[1;6D": {Type: KeyCtrlShiftLeft},
+ "\x1b[1;7A": {Type: KeyCtrlUp, Alt: true},
+ "\x1b[1;7B": {Type: KeyCtrlDown, Alt: true},
+ "\x1b[1;7C": {Type: KeyCtrlRight, Alt: true},
+ "\x1b[1;7D": {Type: KeyCtrlLeft, Alt: true},
+ "\x1b[1;8A": {Type: KeyCtrlShiftUp, Alt: true},
+ "\x1b[1;8B": {Type: KeyCtrlShiftDown, Alt: true},
+ "\x1b[1;8C": {Type: KeyCtrlShiftRight, Alt: true},
+ "\x1b[1;8D": {Type: KeyCtrlShiftLeft, Alt: true},
+
+ // Miscellaneous keys
+ "\x1b[Z": {Type: KeyShiftTab},
+
+ "\x1b[2~": {Type: KeyInsert},
+ "\x1b[3;2~": {Type: KeyInsert, Alt: true},
+
+ "\x1b[3~": {Type: KeyDelete},
+ "\x1b[3;3~": {Type: KeyDelete, Alt: true},
+
+ "\x1b[5~": {Type: KeyPgUp},
+ "\x1b[5;3~": {Type: KeyPgUp, Alt: true},
+ "\x1b[5;5~": {Type: KeyCtrlPgUp},
+ "\x1b[5^": {Type: KeyCtrlPgUp}, // urxvt
+ "\x1b[5;7~": {Type: KeyCtrlPgUp, Alt: true},
+
+ "\x1b[6~": {Type: KeyPgDown},
+ "\x1b[6;3~": {Type: KeyPgDown, Alt: true},
+ "\x1b[6;5~": {Type: KeyCtrlPgDown},
+ "\x1b[6^": {Type: KeyCtrlPgDown}, // urxvt
+ "\x1b[6;7~": {Type: KeyCtrlPgDown, Alt: true},
+
+ "\x1b[1~": {Type: KeyHome},
+ "\x1b[H": {Type: KeyHome}, // xterm, lxterm
+ "\x1b[1;3H": {Type: KeyHome, Alt: true}, // xterm, lxterm
+ "\x1b[1;5H": {Type: KeyCtrlHome}, // xterm, lxterm
+ "\x1b[1;7H": {Type: KeyCtrlHome, Alt: true}, // xterm, lxterm
+ "\x1b[1;2H": {Type: KeyShiftHome}, // xterm, lxterm
+ "\x1b[1;4H": {Type: KeyShiftHome, Alt: true}, // xterm, lxterm
+ "\x1b[1;6H": {Type: KeyCtrlShiftHome}, // xterm, lxterm
+ "\x1b[1;8H": {Type: KeyCtrlShiftHome, Alt: true}, // xterm, lxterm
+
+ "\x1b[4~": {Type: KeyEnd},
+ "\x1b[F": {Type: KeyEnd}, // xterm, lxterm
+ "\x1b[1;3F": {Type: KeyEnd, Alt: true}, // xterm, lxterm
+ "\x1b[1;5F": {Type: KeyCtrlEnd}, // xterm, lxterm
+ "\x1b[1;7F": {Type: KeyCtrlEnd, Alt: true}, // xterm, lxterm
+ "\x1b[1;2F": {Type: KeyShiftEnd}, // xterm, lxterm
+ "\x1b[1;4F": {Type: KeyShiftEnd, Alt: true}, // xterm, lxterm
+ "\x1b[1;6F": {Type: KeyCtrlShiftEnd}, // xterm, lxterm
+ "\x1b[1;8F": {Type: KeyCtrlShiftEnd, Alt: true}, // xterm, lxterm
+
+ "\x1b[7~": {Type: KeyHome}, // urxvt
+ "\x1b[7^": {Type: KeyCtrlHome}, // urxvt
+ "\x1b[7$": {Type: KeyShiftHome}, // urxvt
+ "\x1b[7@": {Type: KeyCtrlShiftHome}, // urxvt
+
+ "\x1b[8~": {Type: KeyEnd}, // urxvt
+ "\x1b[8^": {Type: KeyCtrlEnd}, // urxvt
+ "\x1b[8$": {Type: KeyShiftEnd}, // urxvt
+ "\x1b[8@": {Type: KeyCtrlShiftEnd}, // urxvt
+
+ // Function keys, Linux console
+ "\x1b[[A": {Type: KeyF1}, // linux console
+ "\x1b[[B": {Type: KeyF2}, // linux console
+ "\x1b[[C": {Type: KeyF3}, // linux console
+ "\x1b[[D": {Type: KeyF4}, // linux console
+ "\x1b[[E": {Type: KeyF5}, // linux console
+
+ // Function keys, X11
+ "\x1bOP": {Type: KeyF1}, // vt100, xterm
+ "\x1bOQ": {Type: KeyF2}, // vt100, xterm
+ "\x1bOR": {Type: KeyF3}, // vt100, xterm
+ "\x1bOS": {Type: KeyF4}, // vt100, xterm
+
+ "\x1b[1;3P": {Type: KeyF1, Alt: true}, // vt100, xterm
+ "\x1b[1;3Q": {Type: KeyF2, Alt: true}, // vt100, xterm
+ "\x1b[1;3R": {Type: KeyF3, Alt: true}, // vt100, xterm
+ "\x1b[1;3S": {Type: KeyF4, Alt: true}, // vt100, xterm
+
+ "\x1b[11~": {Type: KeyF1}, // urxvt
+ "\x1b[12~": {Type: KeyF2}, // urxvt
+ "\x1b[13~": {Type: KeyF3}, // urxvt
+ "\x1b[14~": {Type: KeyF4}, // urxvt
+
+ "\x1b[15~": {Type: KeyF5}, // vt100, xterm, also urxvt
+
+ "\x1b[15;3~": {Type: KeyF5, Alt: true}, // vt100, xterm, also urxvt
+
+ "\x1b[17~": {Type: KeyF6}, // vt100, xterm, also urxvt
+ "\x1b[18~": {Type: KeyF7}, // vt100, xterm, also urxvt
+ "\x1b[19~": {Type: KeyF8}, // vt100, xterm, also urxvt
+ "\x1b[20~": {Type: KeyF9}, // vt100, xterm, also urxvt
+ "\x1b[21~": {Type: KeyF10}, // vt100, xterm, also urxvt
+
+ "\x1b[17;3~": {Type: KeyF6, Alt: true}, // vt100, xterm
+ "\x1b[18;3~": {Type: KeyF7, Alt: true}, // vt100, xterm
+ "\x1b[19;3~": {Type: KeyF8, Alt: true}, // vt100, xterm
+ "\x1b[20;3~": {Type: KeyF9, Alt: true}, // vt100, xterm
+ "\x1b[21;3~": {Type: KeyF10, Alt: true}, // vt100, xterm
+
+ "\x1b[23~": {Type: KeyF11}, // vt100, xterm, also urxvt
+ "\x1b[24~": {Type: KeyF12}, // vt100, xterm, also urxvt
+
+ "\x1b[23;3~": {Type: KeyF11, Alt: true}, // vt100, xterm
+ "\x1b[24;3~": {Type: KeyF12, Alt: true}, // vt100, xterm
+
+ "\x1b[1;2P": {Type: KeyF13},
+ "\x1b[1;2Q": {Type: KeyF14},
+
+ "\x1b[25~": {Type: KeyF13}, // vt100, xterm, also urxvt
+ "\x1b[26~": {Type: KeyF14}, // vt100, xterm, also urxvt
+
+ "\x1b[25;3~": {Type: KeyF13, Alt: true}, // vt100, xterm
+ "\x1b[26;3~": {Type: KeyF14, Alt: true}, // vt100, xterm
+
+ "\x1b[1;2R": {Type: KeyF15},
+ "\x1b[1;2S": {Type: KeyF16},
+
+ "\x1b[28~": {Type: KeyF15}, // vt100, xterm, also urxvt
+ "\x1b[29~": {Type: KeyF16}, // vt100, xterm, also urxvt
+
+ "\x1b[28;3~": {Type: KeyF15, Alt: true}, // vt100, xterm
+ "\x1b[29;3~": {Type: KeyF16, Alt: true}, // vt100, xterm
+
+ "\x1b[15;2~": {Type: KeyF17},
+ "\x1b[17;2~": {Type: KeyF18},
+ "\x1b[18;2~": {Type: KeyF19},
+ "\x1b[19;2~": {Type: KeyF20},
+
+ "\x1b[31~": {Type: KeyF17},
+ "\x1b[32~": {Type: KeyF18},
+ "\x1b[33~": {Type: KeyF19},
+ "\x1b[34~": {Type: KeyF20},
+
+ // Powershell sequences.
+ "\x1bOA": {Type: KeyUp, Alt: false},
+ "\x1bOB": {Type: KeyDown, Alt: false},
+ "\x1bOC": {Type: KeyRight, Alt: false},
+ "\x1bOD": {Type: KeyLeft, Alt: false},
+}
+
+// unknownInputByteMsg is reported by the input reader when an invalid
+// utf-8 byte is detected on the input. Currently, it is not handled
+// further by bubbletea. However, having this event makes it possible
+// to troubleshoot invalid inputs.
+type unknownInputByteMsg byte
+
+func (u unknownInputByteMsg) String() string {
+ return fmt.Sprintf("?%#02x?", int(u))
+}
+
+// unknownCSISequenceMsg is reported by the input reader when an
+// unrecognized CSI sequence is detected on the input. Currently, it
+// is not handled further by bubbletea. However, having this event
+// makes it possible to troubleshoot invalid inputs.
+type unknownCSISequenceMsg []byte
+
+func (u unknownCSISequenceMsg) String() string {
+ return fmt.Sprintf("?CSI%+v?", []byte(u)[2:])
+}
+
+var spaceRunes = []rune{' '}
+
+// readAnsiInputs reads keypress and mouse inputs from a TTY and produces messages
+// containing information about the key or mouse events accordingly.
+func readAnsiInputs(ctx context.Context, msgs chan<- Msg, input io.Reader) error {
+ 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
+ }
+}
+
+var (
+ unknownCSIRe = regexp.MustCompile(`^\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]`)
+ mouseSGRRegex = regexp.MustCompile(`(\d+);(\d+);(\d+)([Mm])`)
+)
+
+func detectOneMsg(b []byte, canHaveMoreData bool) (w int, msg Msg) {
+ // 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 focus events.
+ var foundRF bool
+ foundRF, w, msg = detectReportFocus(b)
+ if foundRF {
+ return w, msg
+ }
+
+ // 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])
+}
diff --git a/vendor/github.com/charmbracelet/bubbletea/key_other.go b/vendor/github.com/charmbracelet/bubbletea/key_other.go
new file mode 100644
index 00000000000..b8c46082f85
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/key_other.go
@@ -0,0 +1,13 @@
+//go:build !windows
+// +build !windows
+
+package tea
+
+import (
+ "context"
+ "io"
+)
+
+func readInputs(ctx context.Context, msgs chan<- Msg, input io.Reader) error {
+ return readAnsiInputs(ctx, msgs, input)
+}
diff --git a/vendor/github.com/charmbracelet/bubbletea/key_sequences.go b/vendor/github.com/charmbracelet/bubbletea/key_sequences.go
new file mode 100644
index 00000000000..15483ef528d
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/key_sequences.go
@@ -0,0 +1,131 @@
+package tea
+
+import (
+ "bytes"
+ "sort"
+ "unicode/utf8"
+)
+
+// extSequences is used by the map-based algorithm below. It contains
+// the sequences plus their alternatives with an escape character
+// prefixed, plus the control chars, plus the space.
+// It does not contain the NUL character, which is handled specially
+// by detectOneMsg.
+var extSequences = func() map[string]Key {
+ s := map[string]Key{}
+ for seq, key := range sequences {
+ key := key
+ s[seq] = key
+ if !key.Alt {
+ key.Alt = true
+ s["\x1b"+seq] = key
+ }
+ }
+ for i := keyNUL + 1; i <= keyDEL; i++ {
+ if i == keyESC {
+ continue
+ }
+ s[string([]byte{byte(i)})] = Key{Type: i}
+ s[string([]byte{'\x1b', byte(i)})] = Key{Type: i, Alt: true}
+ if i == keyUS {
+ i = keyDEL - 1
+ }
+ }
+ s[" "] = Key{Type: KeySpace, Runes: spaceRunes}
+ s["\x1b "] = Key{Type: KeySpace, Alt: true, Runes: spaceRunes}
+ s["\x1b\x1b"] = Key{Type: KeyEscape, Alt: true}
+ return s
+}()
+
+// seqLengths is the sizes of valid sequences, starting with the
+// largest size.
+var seqLengths = func() []int {
+ sizes := map[int]struct{}{}
+ for seq := range extSequences {
+ sizes[len(seq)] = struct{}{}
+ }
+ lsizes := make([]int, 0, len(sizes))
+ for sz := range sizes {
+ lsizes = append(lsizes, sz)
+ }
+ sort.Slice(lsizes, func(i, j int) bool { return lsizes[i] > lsizes[j] })
+ return lsizes
+}()
+
+// detectSequence uses a longest prefix match over the input
+// sequence and a hash map.
+func detectSequence(input []byte) (hasSeq bool, width int, msg Msg) {
+ seqs := extSequences
+ for _, sz := range seqLengths {
+ if sz > len(input) {
+ continue
+ }
+ prefix := input[:sz]
+ key, ok := seqs[string(prefix)]
+ if ok {
+ return true, sz, KeyMsg(key)
+ }
+ }
+ // Is this an unknown CSI sequence?
+ if loc := unknownCSIRe.FindIndex(input); loc != nil {
+ return true, loc[1], unknownCSISequenceMsg(input[:loc[1]])
+ }
+
+ return false, 0, nil
+}
+
+// detectBracketedPaste detects an input pasted while bracketed
+// paste mode was enabled.
+//
+// Note: this function is a no-op if bracketed paste was not enabled
+// on the terminal, since in that case we'd never see this
+// particular escape sequence.
+func detectBracketedPaste(input []byte) (hasBp bool, width int, msg Msg) {
+ // Detect the start sequence.
+ const bpStart = "\x1b[200~"
+ if len(input) < len(bpStart) || string(input[:len(bpStart)]) != bpStart {
+ return false, 0, nil
+ }
+
+ // Skip over the start sequence.
+ input = input[len(bpStart):]
+
+ // If we saw the start sequence, then we must have an end sequence
+ // as well. Find it.
+ const bpEnd = "\x1b[201~"
+ idx := bytes.Index(input, []byte(bpEnd))
+ inputLen := len(bpStart) + idx + len(bpEnd)
+ if idx == -1 {
+ // We have encountered the end of the input buffer without seeing
+ // the marker for the end of the bracketed paste.
+ // Tell the outer loop we have done a short read and we want more.
+ return true, 0, nil
+ }
+
+ // The paste is everything in-between.
+ paste := input[:idx]
+
+ // All there is in-between is runes, not to be interpreted further.
+ k := Key{Type: KeyRunes, Paste: true}
+ for len(paste) > 0 {
+ r, w := utf8.DecodeRune(paste)
+ if r != utf8.RuneError {
+ k.Runes = append(k.Runes, r)
+ }
+ paste = paste[w:]
+ }
+
+ return true, inputLen, KeyMsg(k)
+}
+
+// detectReportFocus detects a focus report sequence.
+// nolint: gomnd
+func detectReportFocus(input []byte) (hasRF bool, width int, msg Msg) {
+ switch {
+ case bytes.Equal(input, []byte("\x1b[I")):
+ return true, 3, FocusMsg{}
+ case bytes.Equal(input, []byte("\x1b[O")):
+ return true, 3, BlurMsg{}
+ }
+ return false, 0, nil
+}
diff --git a/vendor/github.com/charmbracelet/bubbletea/key_windows.go b/vendor/github.com/charmbracelet/bubbletea/key_windows.go
new file mode 100644
index 00000000000..d59ff1c4624
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/key_windows.go
@@ -0,0 +1,360 @@
+//go:build windows
+// +build windows
+
+package tea
+
+import (
+ "context"
+ "fmt"
+ "io"
+
+ "github.com/erikgeiser/coninput"
+ localereader "github.com/mattn/go-localereader"
+ "github.com/muesli/cancelreader"
+)
+
+func readInputs(ctx context.Context, msgs chan<- Msg, input io.Reader) error {
+ if coninReader, ok := input.(*conInputReader); ok {
+ return readConInputs(ctx, msgs, coninReader)
+ }
+
+ return readAnsiInputs(ctx, msgs, localereader.NewReader(input))
+}
+
+func readConInputs(ctx context.Context, msgsch chan<- Msg, con *conInputReader) error {
+ var ps coninput.ButtonState // keep track of previous mouse state
+ var ws coninput.WindowBufferSizeEventRecord // keep track of the last window size event
+ for {
+ events, err := coninput.ReadNConsoleInputs(con.conin, 16)
+ if err != nil {
+ if con.isCanceled() {
+ return cancelreader.ErrCanceled
+ }
+ return fmt.Errorf("read coninput events: %w", err)
+ }
+
+ for _, event := range events {
+ var msgs []Msg
+ switch e := event.Unwrap().(type) {
+ case coninput.KeyEventRecord:
+ if !e.KeyDown || e.VirtualKeyCode == coninput.VK_SHIFT {
+ continue
+ }
+
+ for i := 0; i < int(e.RepeatCount); i++ {
+ eventKeyType := keyType(e)
+ var runes []rune
+
+ // Add the character only if the key type is an actual character and not a control sequence.
+ // This mimics the behavior in readAnsiInputs where the character is also removed.
+ // We don't need to handle KeySpace here. See the comment in keyType().
+ if eventKeyType == KeyRunes {
+ runes = []rune{e.Char}
+ }
+
+ msgs = append(msgs, KeyMsg{
+ Type: eventKeyType,
+ Runes: runes,
+ Alt: e.ControlKeyState.Contains(coninput.LEFT_ALT_PRESSED | coninput.RIGHT_ALT_PRESSED),
+ })
+ }
+ case coninput.WindowBufferSizeEventRecord:
+ if e != ws {
+ ws = e
+ msgs = append(msgs, WindowSizeMsg{
+ Width: int(e.Size.X),
+ Height: int(e.Size.Y),
+ })
+ }
+ case coninput.MouseEventRecord:
+ event := mouseEvent(ps, e)
+ if event.Type != MouseUnknown {
+ msgs = append(msgs, event)
+ }
+ ps = e.ButtonState
+ case coninput.FocusEventRecord, coninput.MenuEventRecord:
+ // ignore
+ default: // unknown event
+ continue
+ }
+
+ // Send all messages to the channel
+ for _, msg := range msgs {
+ select {
+ case msgsch <- msg:
+ case <-ctx.Done():
+ err := ctx.Err()
+ if err != nil {
+ return fmt.Errorf("coninput context error: %w", err)
+ }
+ return err
+ }
+ }
+ }
+ }
+}
+
+func mouseEventButton(p, s coninput.ButtonState) (button MouseButton, action MouseAction) {
+ btn := p ^ s
+ action = MouseActionPress
+ if btn&s == 0 {
+ action = MouseActionRelease
+ }
+
+ if btn == 0 {
+ switch {
+ case s&coninput.FROM_LEFT_1ST_BUTTON_PRESSED > 0:
+ button = MouseButtonLeft
+ case s&coninput.FROM_LEFT_2ND_BUTTON_PRESSED > 0:
+ button = MouseButtonMiddle
+ case s&coninput.RIGHTMOST_BUTTON_PRESSED > 0:
+ button = MouseButtonRight
+ case s&coninput.FROM_LEFT_3RD_BUTTON_PRESSED > 0:
+ button = MouseButtonBackward
+ case s&coninput.FROM_LEFT_4TH_BUTTON_PRESSED > 0:
+ button = MouseButtonForward
+ }
+ return
+ }
+
+ switch {
+ case btn == coninput.FROM_LEFT_1ST_BUTTON_PRESSED: // left button
+ button = MouseButtonLeft
+ case btn == coninput.RIGHTMOST_BUTTON_PRESSED: // right button
+ button = MouseButtonRight
+ case btn == coninput.FROM_LEFT_2ND_BUTTON_PRESSED: // middle button
+ button = MouseButtonMiddle
+ case btn == coninput.FROM_LEFT_3RD_BUTTON_PRESSED: // unknown (possibly mouse backward)
+ button = MouseButtonBackward
+ case btn == coninput.FROM_LEFT_4TH_BUTTON_PRESSED: // unknown (possibly mouse forward)
+ button = MouseButtonForward
+ }
+
+ return button, action
+}
+
+func mouseEvent(p coninput.ButtonState, e coninput.MouseEventRecord) MouseMsg {
+ ev := MouseMsg{
+ X: int(e.MousePositon.X),
+ Y: int(e.MousePositon.Y),
+ Alt: e.ControlKeyState.Contains(coninput.LEFT_ALT_PRESSED | coninput.RIGHT_ALT_PRESSED),
+ Ctrl: e.ControlKeyState.Contains(coninput.LEFT_CTRL_PRESSED | coninput.RIGHT_CTRL_PRESSED),
+ Shift: e.ControlKeyState.Contains(coninput.SHIFT_PRESSED),
+ }
+ switch e.EventFlags {
+ case coninput.CLICK, coninput.DOUBLE_CLICK:
+ ev.Button, ev.Action = mouseEventButton(p, e.ButtonState)
+ if ev.Action == MouseActionRelease {
+ ev.Type = MouseRelease
+ }
+ switch ev.Button {
+ case MouseButtonLeft:
+ ev.Type = MouseLeft
+ case MouseButtonMiddle:
+ ev.Type = MouseMiddle
+ case MouseButtonRight:
+ ev.Type = MouseRight
+ case MouseButtonBackward:
+ ev.Type = MouseBackward
+ case MouseButtonForward:
+ ev.Type = MouseForward
+ }
+ case coninput.MOUSE_WHEELED:
+ if e.WheelDirection > 0 {
+ ev.Button = MouseButtonWheelUp
+ ev.Type = MouseWheelUp
+ } else {
+ ev.Button = MouseButtonWheelDown
+ ev.Type = MouseWheelDown
+ }
+ case coninput.MOUSE_HWHEELED:
+ if e.WheelDirection > 0 {
+ ev.Button = MouseButtonWheelRight
+ ev.Type = MouseWheelRight
+ } else {
+ ev.Button = MouseButtonWheelLeft
+ ev.Type = MouseWheelLeft
+ }
+ case coninput.MOUSE_MOVED:
+ ev.Button, _ = mouseEventButton(p, e.ButtonState)
+ ev.Action = MouseActionMotion
+ ev.Type = MouseMotion
+ }
+
+ return ev
+}
+
+func keyType(e coninput.KeyEventRecord) KeyType {
+ code := e.VirtualKeyCode
+
+ shiftPressed := e.ControlKeyState.Contains(coninput.SHIFT_PRESSED)
+ ctrlPressed := e.ControlKeyState.Contains(coninput.LEFT_CTRL_PRESSED | coninput.RIGHT_CTRL_PRESSED)
+
+ switch code {
+ case coninput.VK_RETURN:
+ return KeyEnter
+ case coninput.VK_BACK:
+ return KeyBackspace
+ case coninput.VK_TAB:
+ if shiftPressed {
+ return KeyShiftTab
+ }
+ return KeyTab
+ case coninput.VK_SPACE:
+ return KeyRunes // this could be KeySpace but on unix space also produces KeyRunes
+ case coninput.VK_ESCAPE:
+ return KeyEscape
+ case coninput.VK_UP:
+ switch {
+ case shiftPressed && ctrlPressed:
+ return KeyCtrlShiftUp
+ case shiftPressed:
+ return KeyShiftUp
+ case ctrlPressed:
+ return KeyCtrlUp
+ default:
+ return KeyUp
+ }
+ case coninput.VK_DOWN:
+ switch {
+ case shiftPressed && ctrlPressed:
+ return KeyCtrlShiftDown
+ case shiftPressed:
+ return KeyShiftDown
+ case ctrlPressed:
+ return KeyCtrlDown
+ default:
+ return KeyDown
+ }
+ case coninput.VK_RIGHT:
+ switch {
+ case shiftPressed && ctrlPressed:
+ return KeyCtrlShiftRight
+ case shiftPressed:
+ return KeyShiftRight
+ case ctrlPressed:
+ return KeyCtrlRight
+ default:
+ return KeyRight
+ }
+ case coninput.VK_LEFT:
+ switch {
+ case shiftPressed && ctrlPressed:
+ return KeyCtrlShiftLeft
+ case shiftPressed:
+ return KeyShiftLeft
+ case ctrlPressed:
+ return KeyCtrlLeft
+ default:
+ return KeyLeft
+ }
+ case coninput.VK_HOME:
+ switch {
+ case shiftPressed && ctrlPressed:
+ return KeyCtrlShiftHome
+ case shiftPressed:
+ return KeyShiftHome
+ case ctrlPressed:
+ return KeyCtrlHome
+ default:
+ return KeyHome
+ }
+ case coninput.VK_END:
+ switch {
+ case shiftPressed && ctrlPressed:
+ return KeyCtrlShiftEnd
+ case shiftPressed:
+ return KeyShiftEnd
+ case ctrlPressed:
+ return KeyCtrlEnd
+ default:
+ return KeyEnd
+ }
+ case coninput.VK_PRIOR:
+ return KeyPgUp
+ case coninput.VK_NEXT:
+ return KeyPgDown
+ case coninput.VK_DELETE:
+ return KeyDelete
+ default:
+ switch {
+ case e.ControlKeyState.Contains(coninput.LEFT_CTRL_PRESSED) && e.ControlKeyState.Contains(coninput.RIGHT_ALT_PRESSED):
+ // AltGr is pressed, then it's a rune.
+ fallthrough
+ case !e.ControlKeyState.Contains(coninput.LEFT_CTRL_PRESSED) && !e.ControlKeyState.Contains(coninput.RIGHT_CTRL_PRESSED):
+ return KeyRunes
+ }
+
+ switch e.Char {
+ case '@':
+ return KeyCtrlAt
+ case '\x01':
+ return KeyCtrlA
+ case '\x02':
+ return KeyCtrlB
+ case '\x03':
+ return KeyCtrlC
+ case '\x04':
+ return KeyCtrlD
+ case '\x05':
+ return KeyCtrlE
+ case '\x06':
+ return KeyCtrlF
+ case '\a':
+ return KeyCtrlG
+ case '\b':
+ return KeyCtrlH
+ case '\t':
+ return KeyCtrlI
+ case '\n':
+ return KeyCtrlJ
+ case '\v':
+ return KeyCtrlK
+ case '\f':
+ return KeyCtrlL
+ case '\r':
+ return KeyCtrlM
+ case '\x0e':
+ return KeyCtrlN
+ case '\x0f':
+ return KeyCtrlO
+ case '\x10':
+ return KeyCtrlP
+ case '\x11':
+ return KeyCtrlQ
+ case '\x12':
+ return KeyCtrlR
+ case '\x13':
+ return KeyCtrlS
+ case '\x14':
+ return KeyCtrlT
+ case '\x15':
+ return KeyCtrlU
+ case '\x16':
+ return KeyCtrlV
+ case '\x17':
+ return KeyCtrlW
+ case '\x18':
+ return KeyCtrlX
+ case '\x19':
+ return KeyCtrlY
+ case '\x1a':
+ return KeyCtrlZ
+ case '\x1b':
+ return KeyCtrlOpenBracket // KeyEscape
+ case '\x1c':
+ return KeyCtrlBackslash
+ case '\x1f':
+ return KeyCtrlUnderscore
+ }
+
+ switch code {
+ case coninput.VK_OEM_4:
+ return KeyCtrlOpenBracket
+ case coninput.VK_OEM_6:
+ return KeyCtrlCloseBracket
+ }
+
+ return KeyRunes
+ }
+}
diff --git a/vendor/github.com/charmbracelet/bubbletea/logging.go b/vendor/github.com/charmbracelet/bubbletea/logging.go
new file mode 100644
index 00000000000..a53118193c1
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/logging.go
@@ -0,0 +1,53 @@
+package tea
+
+import (
+ "fmt"
+ "io"
+ "log"
+ "os"
+ "unicode"
+)
+
+// LogToFile sets up default logging to log to a file. This is helpful as we
+// can't print to the terminal since our TUI is occupying it. If the file
+// doesn't exist it will be created.
+//
+// Don't forget to close the file when you're done with it.
+//
+// f, err := LogToFile("debug.log", "debug")
+// if err != nil {
+// fmt.Println("fatal:", err)
+// os.Exit(1)
+// }
+// defer f.Close()
+func LogToFile(path string, prefix string) (*os.File, error) {
+ return LogToFileWith(path, prefix, log.Default())
+}
+
+// LogOptionsSetter is an interface implemented by stdlib's log and charm's log
+// libraries.
+type LogOptionsSetter interface {
+ SetOutput(io.Writer)
+ SetPrefix(string)
+}
+
+// LogToFileWith does allows to call LogToFile with a custom LogOptionsSetter.
+func LogToFileWith(path string, prefix string, log LogOptionsSetter) (*os.File, error) {
+ f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0o600) //nolint:gomnd
+ if err != nil {
+ return nil, fmt.Errorf("error opening file for logging: %w", err)
+ }
+ log.SetOutput(f)
+
+ // Add a space after the prefix if a prefix is being specified and it
+ // doesn't already have a trailing space.
+ if len(prefix) > 0 {
+ finalChar := prefix[len(prefix)-1]
+ if !unicode.IsSpace(rune(finalChar)) {
+ prefix += " "
+ }
+ }
+ log.SetPrefix(prefix)
+
+ return f, nil
+}
diff --git a/vendor/github.com/charmbracelet/bubbletea/mouse.go b/vendor/github.com/charmbracelet/bubbletea/mouse.go
new file mode 100644
index 00000000000..6ec51cc0c0a
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/mouse.go
@@ -0,0 +1,308 @@
+package tea
+
+import "strconv"
+
+// MouseMsg contains information about a mouse event and are sent to a programs
+// update function when mouse activity occurs. Note that the mouse must first
+// be enabled in order for the mouse events to be received.
+type MouseMsg MouseEvent
+
+// String returns a string representation of a mouse event.
+func (m MouseMsg) String() string {
+ return MouseEvent(m).String()
+}
+
+// MouseEvent represents a mouse event, which could be a click, a scroll wheel
+// movement, a cursor movement, or a combination.
+type MouseEvent struct {
+ X int
+ Y int
+ Shift bool
+ Alt bool
+ Ctrl bool
+ Action MouseAction
+ Button MouseButton
+
+ // Deprecated: Use MouseAction & MouseButton instead.
+ Type MouseEventType
+}
+
+// IsWheel returns true if the mouse event is a wheel event.
+func (m MouseEvent) IsWheel() bool {
+ return m.Button == MouseButtonWheelUp || m.Button == MouseButtonWheelDown ||
+ m.Button == MouseButtonWheelLeft || m.Button == MouseButtonWheelRight
+}
+
+// String returns a string representation of a mouse event.
+func (m MouseEvent) String() (s string) {
+ if m.Ctrl {
+ s += "ctrl+"
+ }
+ if m.Alt {
+ s += "alt+"
+ }
+ if m.Shift {
+ s += "shift+"
+ }
+
+ if m.Button == MouseButtonNone { //nolint:nestif
+ if m.Action == MouseActionMotion || m.Action == MouseActionRelease {
+ s += mouseActions[m.Action]
+ } else {
+ s += "unknown"
+ }
+ } else if m.IsWheel() {
+ s += mouseButtons[m.Button]
+ } else {
+ btn := mouseButtons[m.Button]
+ if btn != "" {
+ s += btn
+ }
+ act := mouseActions[m.Action]
+ if act != "" {
+ s += " " + act
+ }
+ }
+
+ return s
+}
+
+// MouseAction represents the action that occurred during a mouse event.
+type MouseAction int
+
+// Mouse event actions.
+const (
+ MouseActionPress MouseAction = iota
+ MouseActionRelease
+ MouseActionMotion
+)
+
+var mouseActions = map[MouseAction]string{
+ MouseActionPress: "press",
+ MouseActionRelease: "release",
+ MouseActionMotion: "motion",
+}
+
+// MouseButton represents the button that was pressed during a mouse event.
+type MouseButton int
+
+// Mouse event buttons
+//
+// This is based on X11 mouse button codes.
+//
+// 1 = left button
+// 2 = middle button (pressing the scroll wheel)
+// 3 = right button
+// 4 = turn scroll wheel up
+// 5 = turn scroll wheel down
+// 6 = push scroll wheel left
+// 7 = push scroll wheel right
+// 8 = 4th button (aka browser backward button)
+// 9 = 5th button (aka browser forward button)
+// 10
+// 11
+//
+// Other buttons are not supported.
+const (
+ MouseButtonNone MouseButton = iota
+ MouseButtonLeft
+ MouseButtonMiddle
+ MouseButtonRight
+ MouseButtonWheelUp
+ MouseButtonWheelDown
+ MouseButtonWheelLeft
+ MouseButtonWheelRight
+ MouseButtonBackward
+ MouseButtonForward
+ MouseButton10
+ MouseButton11
+)
+
+var mouseButtons = map[MouseButton]string{
+ MouseButtonNone: "none",
+ MouseButtonLeft: "left",
+ MouseButtonMiddle: "middle",
+ MouseButtonRight: "right",
+ MouseButtonWheelUp: "wheel up",
+ MouseButtonWheelDown: "wheel down",
+ MouseButtonWheelLeft: "wheel left",
+ MouseButtonWheelRight: "wheel right",
+ MouseButtonBackward: "backward",
+ MouseButtonForward: "forward",
+ MouseButton10: "button 10",
+ MouseButton11: "button 11",
+}
+
+// MouseEventType indicates the type of mouse event occurring.
+//
+// Deprecated: Use MouseAction & MouseButton instead.
+type MouseEventType int
+
+// Mouse event types.
+//
+// Deprecated: Use MouseAction & MouseButton instead.
+const (
+ MouseUnknown MouseEventType = iota
+ MouseLeft
+ MouseRight
+ MouseMiddle
+ MouseRelease // mouse button release (X10 only)
+ MouseWheelUp
+ MouseWheelDown
+ MouseWheelLeft
+ MouseWheelRight
+ MouseBackward
+ MouseForward
+ MouseMotion
+)
+
+// Parse SGR-encoded mouse events; SGR extended mouse events. SGR mouse events
+// look like:
+//
+// ESC [ < Cb ; Cx ; Cy (M or m)
+//
+// where:
+//
+// Cb is the encoded button code
+// Cx is the x-coordinate of the mouse
+// Cy is the y-coordinate of the mouse
+// M is for button press, m is for button release
+//
+// https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Extended-coordinates
+func parseSGRMouseEvent(buf []byte) MouseEvent {
+ str := string(buf[3:])
+ matches := mouseSGRRegex.FindStringSubmatch(str)
+ if len(matches) != 5 { //nolint:gomnd
+ // Unreachable, we already checked the regex in `detectOneMsg`.
+ panic("invalid mouse event")
+ }
+
+ b, _ := strconv.Atoi(matches[1])
+ px := matches[2]
+ py := matches[3]
+ release := matches[4] == "m"
+ m := parseMouseButton(b, true)
+
+ // Wheel buttons don't have release events
+ // Motion can be reported as a release event in some terminals (Windows Terminal)
+ if m.Action != MouseActionMotion && !m.IsWheel() && release {
+ m.Action = MouseActionRelease
+ m.Type = MouseRelease
+ }
+
+ x, _ := strconv.Atoi(px)
+ y, _ := strconv.Atoi(py)
+
+ // (1,1) is the upper left. We subtract 1 to normalize it to (0,0).
+ m.X = x - 1
+ m.Y = y - 1
+
+ return m
+}
+
+const x10MouseByteOffset = 32
+
+// Parse X10-encoded mouse events; the simplest kind. The last release of X10
+// was December 1986, by the way. The original X10 mouse protocol limits the Cx
+// and Cy coordinates to 223 (=255-032).
+//
+// X10 mouse events look like:
+//
+// ESC [M Cb Cx Cy
+//
+// See: http://www.xfree86.org/current/ctlseqs.html#Mouse%20Tracking
+func parseX10MouseEvent(buf []byte) MouseEvent {
+ v := buf[3:6]
+ m := parseMouseButton(int(v[0]), false)
+
+ // (1,1) is the upper left. We subtract 1 to normalize it to (0,0).
+ m.X = int(v[1]) - x10MouseByteOffset - 1
+ m.Y = int(v[2]) - x10MouseByteOffset - 1
+
+ return m
+}
+
+// See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Extended-coordinates
+func parseMouseButton(b int, isSGR bool) MouseEvent {
+ var m MouseEvent
+ e := b
+ if !isSGR {
+ e -= x10MouseByteOffset
+ }
+
+ const (
+ bitShift = 0b0000_0100
+ bitAlt = 0b0000_1000
+ bitCtrl = 0b0001_0000
+ bitMotion = 0b0010_0000
+ bitWheel = 0b0100_0000
+ bitAdd = 0b1000_0000 // additional buttons 8-11
+
+ bitsMask = 0b0000_0011
+ )
+
+ if e&bitAdd != 0 {
+ m.Button = MouseButtonBackward + MouseButton(e&bitsMask)
+ } else if e&bitWheel != 0 {
+ m.Button = MouseButtonWheelUp + MouseButton(e&bitsMask)
+ } else {
+ m.Button = MouseButtonLeft + MouseButton(e&bitsMask)
+ // X10 reports a button release as 0b0000_0011 (3)
+ if e&bitsMask == bitsMask {
+ m.Action = MouseActionRelease
+ m.Button = MouseButtonNone
+ }
+ }
+
+ // Motion bit doesn't get reported for wheel events.
+ if e&bitMotion != 0 && !m.IsWheel() {
+ m.Action = MouseActionMotion
+ }
+
+ // Modifiers
+ m.Alt = e&bitAlt != 0
+ m.Ctrl = e&bitCtrl != 0
+ m.Shift = e&bitShift != 0
+
+ // backward compatibility
+ switch {
+ case m.Button == MouseButtonLeft && m.Action == MouseActionPress:
+ m.Type = MouseLeft
+ case m.Button == MouseButtonMiddle && m.Action == MouseActionPress:
+ m.Type = MouseMiddle
+ case m.Button == MouseButtonRight && m.Action == MouseActionPress:
+ m.Type = MouseRight
+ case m.Button == MouseButtonNone && m.Action == MouseActionRelease:
+ m.Type = MouseRelease
+ case m.Button == MouseButtonWheelUp && m.Action == MouseActionPress:
+ m.Type = MouseWheelUp
+ case m.Button == MouseButtonWheelDown && m.Action == MouseActionPress:
+ m.Type = MouseWheelDown
+ case m.Button == MouseButtonWheelLeft && m.Action == MouseActionPress:
+ m.Type = MouseWheelLeft
+ case m.Button == MouseButtonWheelRight && m.Action == MouseActionPress:
+ m.Type = MouseWheelRight
+ case m.Button == MouseButtonBackward && m.Action == MouseActionPress:
+ m.Type = MouseBackward
+ case m.Button == MouseButtonForward && m.Action == MouseActionPress:
+ m.Type = MouseForward
+ case m.Action == MouseActionMotion:
+ m.Type = MouseMotion
+ switch m.Button { //nolint:exhaustive
+ case MouseButtonLeft:
+ m.Type = MouseLeft
+ case MouseButtonMiddle:
+ m.Type = MouseMiddle
+ case MouseButtonRight:
+ m.Type = MouseRight
+ case MouseButtonBackward:
+ m.Type = MouseBackward
+ case MouseButtonForward:
+ m.Type = MouseForward
+ }
+ default:
+ m.Type = MouseUnknown
+ }
+
+ return m
+}
diff --git a/vendor/github.com/charmbracelet/bubbletea/nil_renderer.go b/vendor/github.com/charmbracelet/bubbletea/nil_renderer.go
new file mode 100644
index 00000000000..0bc4a17206b
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/nil_renderer.go
@@ -0,0 +1,28 @@
+package tea
+
+type nilRenderer struct{}
+
+func (n nilRenderer) start() {}
+func (n nilRenderer) stop() {}
+func (n nilRenderer) kill() {}
+func (n nilRenderer) write(_ string) {}
+func (n nilRenderer) repaint() {}
+func (n nilRenderer) clearScreen() {}
+func (n nilRenderer) altScreen() bool { return false }
+func (n nilRenderer) enterAltScreen() {}
+func (n nilRenderer) exitAltScreen() {}
+func (n nilRenderer) showCursor() {}
+func (n nilRenderer) hideCursor() {}
+func (n nilRenderer) enableMouseCellMotion() {}
+func (n nilRenderer) disableMouseCellMotion() {}
+func (n nilRenderer) enableMouseAllMotion() {}
+func (n nilRenderer) disableMouseAllMotion() {}
+func (n nilRenderer) enableBracketedPaste() {}
+func (n nilRenderer) disableBracketedPaste() {}
+func (n nilRenderer) enableMouseSGRMode() {}
+func (n nilRenderer) disableMouseSGRMode() {}
+func (n nilRenderer) bracketedPasteActive() bool { return false }
+func (n nilRenderer) setWindowTitle(_ string) {}
+func (n nilRenderer) reportFocus() bool { return false }
+func (n nilRenderer) enableReportFocus() {}
+func (n nilRenderer) disableReportFocus() {}
diff --git a/vendor/github.com/charmbracelet/bubbletea/options.go b/vendor/github.com/charmbracelet/bubbletea/options.go
new file mode 100644
index 00000000000..c509353b18d
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/options.go
@@ -0,0 +1,252 @@
+package tea
+
+import (
+ "context"
+ "io"
+ "sync/atomic"
+)
+
+// ProgramOption is used to set options when initializing a Program. Program can
+// accept a variable number of options.
+//
+// Example usage:
+//
+// p := NewProgram(model, WithInput(someInput), WithOutput(someOutput))
+type ProgramOption func(*Program)
+
+// WithContext lets you specify a context in which to run the Program. This is
+// useful if you want to cancel the execution from outside. When a Program gets
+// cancelled it will exit with an error ErrProgramKilled.
+func WithContext(ctx context.Context) ProgramOption {
+ return func(p *Program) {
+ p.ctx = ctx
+ }
+}
+
+// WithOutput sets the output which, by default, is stdout. In most cases you
+// won't need to use this.
+func WithOutput(output io.Writer) ProgramOption {
+ return func(p *Program) {
+ p.output = output
+ }
+}
+
+// WithInput sets the input which, by default, is stdin. In most cases you
+// won't need to use this. To disable input entirely pass nil.
+//
+// p := NewProgram(model, WithInput(nil))
+func WithInput(input io.Reader) ProgramOption {
+ return func(p *Program) {
+ p.input = input
+ p.inputType = customInput
+ }
+}
+
+// WithInputTTY opens a new TTY for input (or console input device on Windows).
+func WithInputTTY() ProgramOption {
+ return func(p *Program) {
+ p.inputType = ttyInput
+ }
+}
+
+// WithEnvironment sets the environment variables that the program will use.
+// This useful when the program is running in a remote session (e.g. SSH) and
+// you want to pass the environment variables from the remote session to the
+// program.
+//
+// Example:
+//
+// var sess ssh.Session // ssh.Session is a type from the github.com/charmbracelet/ssh package
+// pty, _, _ := sess.Pty()
+// environ := append(sess.Environ(), "TERM="+pty.Term)
+// p := tea.NewProgram(model, tea.WithEnvironment(environ)
+func WithEnvironment(env []string) ProgramOption {
+ return func(p *Program) {
+ p.environ = env
+ }
+}
+
+// WithoutSignalHandler disables the signal handler that Bubble Tea sets up for
+// Programs. This is useful if you want to handle signals yourself.
+func WithoutSignalHandler() ProgramOption {
+ return func(p *Program) {
+ p.startupOptions |= withoutSignalHandler
+ }
+}
+
+// WithoutCatchPanics disables the panic catching that Bubble Tea does by
+// default. If panic catching is disabled the terminal will be in a fairly
+// unusable state after a panic because Bubble Tea will not perform its usual
+// cleanup on exit.
+func WithoutCatchPanics() ProgramOption {
+ return func(p *Program) {
+ p.startupOptions |= withoutCatchPanics
+ }
+}
+
+// WithoutSignals will ignore OS signals.
+// This is mainly useful for testing.
+func WithoutSignals() ProgramOption {
+ return func(p *Program) {
+ atomic.StoreUint32(&p.ignoreSignals, 1)
+ }
+}
+
+// WithAltScreen starts the program with the alternate screen buffer enabled
+// (i.e. the program starts in full window mode). Note that the altscreen will
+// be automatically exited when the program quits.
+//
+// Example:
+//
+// p := tea.NewProgram(Model{}, tea.WithAltScreen())
+// if _, err := p.Run(); err != nil {
+// fmt.Println("Error running program:", err)
+// os.Exit(1)
+// }
+//
+// To enter the altscreen once the program has already started running use the
+// EnterAltScreen command.
+func WithAltScreen() ProgramOption {
+ return func(p *Program) {
+ p.startupOptions |= withAltScreen
+ }
+}
+
+// WithoutBracketedPaste starts the program with bracketed paste disabled.
+func WithoutBracketedPaste() ProgramOption {
+ return func(p *Program) {
+ p.startupOptions |= withoutBracketedPaste
+ }
+}
+
+// WithMouseCellMotion starts the program with the mouse enabled in "cell
+// motion" mode.
+//
+// Cell motion mode enables mouse click, release, and wheel events. Mouse
+// movement events are also captured if a mouse button is pressed (i.e., drag
+// events). Cell motion mode is better supported than all motion mode.
+//
+// This will try to enable the mouse in extended mode (SGR), if that is not
+// supported by the terminal it will fall back to normal mode (X10).
+//
+// To enable mouse cell motion once the program has already started running use
+// the EnableMouseCellMotion command. To disable the mouse when the program is
+// running use the DisableMouse command.
+//
+// The mouse will be automatically disabled when the program exits.
+func WithMouseCellMotion() ProgramOption {
+ return func(p *Program) {
+ p.startupOptions |= withMouseCellMotion // set
+ p.startupOptions &^= withMouseAllMotion // clear
+ }
+}
+
+// WithMouseAllMotion starts the program with the mouse enabled in "all motion"
+// mode.
+//
+// EnableMouseAllMotion is a special command that enables mouse click, release,
+// wheel, and motion events, which are delivered regardless of whether a mouse
+// button is pressed, effectively enabling support for hover interactions.
+//
+// This will try to enable the mouse in extended mode (SGR), if that is not
+// supported by the terminal it will fall back to normal mode (X10).
+//
+// Many modern terminals support this, but not all. If in doubt, use
+// EnableMouseCellMotion instead.
+//
+// To enable the mouse once the program has already started running use the
+// EnableMouseAllMotion command. To disable the mouse when the program is
+// running use the DisableMouse command.
+//
+// The mouse will be automatically disabled when the program exits.
+func WithMouseAllMotion() ProgramOption {
+ return func(p *Program) {
+ p.startupOptions |= withMouseAllMotion // set
+ p.startupOptions &^= withMouseCellMotion // clear
+ }
+}
+
+// WithoutRenderer disables the renderer. When this is set output and log
+// statements will be plainly sent to stdout (or another output if one is set)
+// without any rendering and redrawing logic. In other words, printing and
+// logging will behave the same way it would in a non-TUI commandline tool.
+// This can be useful if you want to use the Bubble Tea framework for a non-TUI
+// application, or to provide an additional non-TUI mode to your Bubble Tea
+// programs. For example, your program could behave like a daemon if output is
+// not a TTY.
+func WithoutRenderer() ProgramOption {
+ return func(p *Program) {
+ p.renderer = &nilRenderer{}
+ }
+}
+
+// WithANSICompressor removes redundant ANSI sequences to produce potentially
+// smaller output, at the cost of some processing overhead.
+//
+// This feature is provisional, and may be changed or removed in a future version
+// of this package.
+//
+// Deprecated: this incurs a noticeable performance hit. A future release will
+// optimize ANSI automatically without the performance penalty.
+func WithANSICompressor() ProgramOption {
+ return func(p *Program) {
+ p.startupOptions |= withANSICompressor
+ }
+}
+
+// WithFilter supplies an event filter that will be invoked before Bubble Tea
+// processes a tea.Msg. The event filter can return any tea.Msg which will then
+// get handled by Bubble Tea instead of the original event. If the event filter
+// returns nil, the event will be ignored and Bubble Tea will not process it.
+//
+// As an example, this could be used to prevent a program from shutting down if
+// there are unsaved changes.
+//
+// Example:
+//
+// func filter(m tea.Model, msg tea.Msg) tea.Msg {
+// if _, ok := msg.(tea.QuitMsg); !ok {
+// return msg
+// }
+//
+// model := m.(myModel)
+// if model.hasChanges {
+// return nil
+// }
+//
+// return msg
+// }
+//
+// p := tea.NewProgram(Model{}, tea.WithFilter(filter));
+//
+// if _,err := p.Run(); err != nil {
+// fmt.Println("Error running program:", err)
+// os.Exit(1)
+// }
+func WithFilter(filter func(Model, Msg) Msg) ProgramOption {
+ return func(p *Program) {
+ p.filter = filter
+ }
+}
+
+// WithFPS sets a custom maximum FPS at which the renderer should run. If
+// less than 1, the default value of 60 will be used. If over 120, the FPS
+// will be capped at 120.
+func WithFPS(fps int) ProgramOption {
+ return func(p *Program) {
+ p.fps = fps
+ }
+}
+
+// WithReportFocus enables reporting when the terminal gains and loses
+// focus. When this is enabled [FocusMsg] and [BlurMsg] messages will be sent
+// to your Update method.
+//
+// Note that while most terminals and multiplexers support focus reporting,
+// some do not. Also note that tmux needs to be configured to report focus
+// events.
+func WithReportFocus() ProgramOption {
+ return func(p *Program) {
+ p.startupOptions |= withReportFocus
+ }
+}
diff --git a/vendor/github.com/charmbracelet/bubbletea/renderer.go b/vendor/github.com/charmbracelet/bubbletea/renderer.go
new file mode 100644
index 00000000000..9eb7943bcfb
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/renderer.go
@@ -0,0 +1,85 @@
+package tea
+
+// renderer is the interface for Bubble Tea renderers.
+type renderer interface {
+ // Start the renderer.
+ start()
+
+ // Stop the renderer, but render the final frame in the buffer, if any.
+ stop()
+
+ // Stop the renderer without doing any final rendering.
+ kill()
+
+ // Write a frame to the renderer. The renderer can write this data to
+ // output at its discretion.
+ write(string)
+
+ // Request a full re-render. Note that this will not trigger a render
+ // immediately. Rather, this method causes the next render to be a full
+ // repaint. Because of this, it's safe to call this method multiple times
+ // in succession.
+ repaint()
+
+ // Clears the terminal.
+ clearScreen()
+
+ // Whether or not the alternate screen buffer is enabled.
+ altScreen() bool
+ // Enable the alternate screen buffer.
+ enterAltScreen()
+ // Disable the alternate screen buffer.
+ exitAltScreen()
+
+ // Show the cursor.
+ showCursor()
+ // Hide the cursor.
+ hideCursor()
+
+ // enableMouseCellMotion enables mouse click, release, wheel and motion
+ // events if a mouse button is pressed (i.e., drag events).
+ enableMouseCellMotion()
+
+ // disableMouseCellMotion disables Mouse Cell Motion tracking.
+ disableMouseCellMotion()
+
+ // enableMouseAllMotion enables mouse click, release, wheel and motion
+ // events, regardless of whether a mouse button is pressed. Many modern
+ // terminals support this, but not all.
+ enableMouseAllMotion()
+
+ // disableMouseAllMotion disables All Motion mouse tracking.
+ disableMouseAllMotion()
+
+ // enableMouseSGRMode enables mouse extended mode (SGR).
+ enableMouseSGRMode()
+
+ // disableMouseSGRMode disables mouse extended mode (SGR).
+ disableMouseSGRMode()
+
+ // enableBracketedPaste enables bracketed paste, where characters
+ // inside the input are not interpreted when pasted as a whole.
+ enableBracketedPaste()
+
+ // disableBracketedPaste disables bracketed paste.
+ disableBracketedPaste()
+
+ // bracketedPasteActive reports whether bracketed paste mode is
+ // currently enabled.
+ bracketedPasteActive() bool
+
+ // setWindowTitle sets the terminal window title.
+ setWindowTitle(string)
+
+ // reportFocus returns whether reporting focus events is enabled.
+ reportFocus() bool
+
+ // enableReportFocus reports focus events to the program.
+ enableReportFocus()
+
+ // disableReportFocus stops reporting focus events to the program.
+ disableReportFocus()
+}
+
+// repaintMsg forces a full repaint.
+type repaintMsg struct{}
diff --git a/vendor/github.com/charmbracelet/bubbletea/screen.go b/vendor/github.com/charmbracelet/bubbletea/screen.go
new file mode 100644
index 00000000000..dfec48f0b44
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/screen.go
@@ -0,0 +1,248 @@
+package tea
+
+// WindowSizeMsg is used to report the terminal size. It's sent to Update once
+// initially and then on every terminal resize. Note that Windows does not
+// have support for reporting when resizes occur as it does not support the
+// SIGWINCH signal.
+type WindowSizeMsg struct {
+ Width int
+ Height int
+}
+
+// ClearScreen is a special command that tells the program to clear the screen
+// before the next update. This can be used to move the cursor to the top left
+// of the screen and clear visual clutter when the alt screen is not in use.
+//
+// Note that it should never be necessary to call ClearScreen() for regular
+// redraws.
+func ClearScreen() Msg {
+ return clearScreenMsg{}
+}
+
+// clearScreenMsg is an internal message that signals to clear the screen.
+// You can send a clearScreenMsg with ClearScreen.
+type clearScreenMsg struct{}
+
+// EnterAltScreen is a special command that tells the Bubble Tea program to
+// enter the alternate screen buffer.
+//
+// Because commands run asynchronously, this command should not be used in your
+// model's Init function. To initialize your program with the altscreen enabled
+// use the WithAltScreen ProgramOption instead.
+func EnterAltScreen() Msg {
+ return enterAltScreenMsg{}
+}
+
+// enterAltScreenMsg in an internal message signals that the program should
+// enter alternate screen buffer. You can send a enterAltScreenMsg with
+// EnterAltScreen.
+type enterAltScreenMsg struct{}
+
+// ExitAltScreen is a special command that tells the Bubble Tea program to exit
+// the alternate screen buffer. This command should be used to exit the
+// alternate screen buffer while the program is running.
+//
+// Note that the alternate screen buffer will be automatically exited when the
+// program quits.
+func ExitAltScreen() Msg {
+ return exitAltScreenMsg{}
+}
+
+// exitAltScreenMsg in an internal message signals that the program should exit
+// alternate screen buffer. You can send a exitAltScreenMsg with ExitAltScreen.
+type exitAltScreenMsg struct{}
+
+// EnableMouseCellMotion is a special command that enables mouse click,
+// release, and wheel events. Mouse movement events are also captured if
+// a mouse button is pressed (i.e., drag events).
+//
+// Because commands run asynchronously, this command should not be used in your
+// model's Init function. Use the WithMouseCellMotion ProgramOption instead.
+func EnableMouseCellMotion() Msg {
+ return enableMouseCellMotionMsg{}
+}
+
+// enableMouseCellMotionMsg is a special command that signals to start
+// listening for "cell motion" type mouse events (ESC[?1002l). To send an
+// enableMouseCellMotionMsg, use the EnableMouseCellMotion command.
+type enableMouseCellMotionMsg struct{}
+
+// EnableMouseAllMotion is a special command that enables mouse click, release,
+// wheel, and motion events, which are delivered regardless of whether a mouse
+// button is pressed, effectively enabling support for hover interactions.
+//
+// Many modern terminals support this, but not all. If in doubt, use
+// EnableMouseCellMotion instead.
+//
+// Because commands run asynchronously, this command should not be used in your
+// model's Init function. Use the WithMouseAllMotion ProgramOption instead.
+func EnableMouseAllMotion() Msg {
+ return enableMouseAllMotionMsg{}
+}
+
+// enableMouseAllMotionMsg is a special command that signals to start listening
+// for "all motion" type mouse events (ESC[?1003l). To send an
+// enableMouseAllMotionMsg, use the EnableMouseAllMotion command.
+type enableMouseAllMotionMsg struct{}
+
+// DisableMouse is a special command that stops listening for mouse events.
+func DisableMouse() Msg {
+ return disableMouseMsg{}
+}
+
+// disableMouseMsg is an internal message that signals to stop listening
+// for mouse events. To send a disableMouseMsg, use the DisableMouse command.
+type disableMouseMsg struct{}
+
+// HideCursor is a special command for manually instructing Bubble Tea to hide
+// the cursor. In some rare cases, certain operations will cause the terminal
+// to show the cursor, which is normally hidden for the duration of a Bubble
+// Tea program's lifetime. You will most likely not need to use this command.
+func HideCursor() Msg {
+ return hideCursorMsg{}
+}
+
+// hideCursorMsg is an internal command used to hide the cursor. You can send
+// this message with HideCursor.
+type hideCursorMsg struct{}
+
+// ShowCursor is a special command for manually instructing Bubble Tea to show
+// the cursor.
+func ShowCursor() Msg {
+ return showCursorMsg{}
+}
+
+// showCursorMsg is an internal command used to show the cursor. You can send
+// this message with ShowCursor.
+type showCursorMsg struct{}
+
+// EnableBracketedPaste is a special command that tells the Bubble Tea program
+// to accept bracketed paste input.
+//
+// Note that bracketed paste will be automatically disabled when the
+// program quits.
+func EnableBracketedPaste() Msg {
+ return enableBracketedPasteMsg{}
+}
+
+// enableBracketedPasteMsg in an internal message signals that
+// bracketed paste should be enabled. You can send an
+// enableBracketedPasteMsg with EnableBracketedPaste.
+type enableBracketedPasteMsg struct{}
+
+// DisableBracketedPaste is a special command that tells the Bubble Tea program
+// to accept bracketed paste input.
+//
+// Note that bracketed paste will be automatically disabled when the
+// program quits.
+func DisableBracketedPaste() Msg {
+ return disableBracketedPasteMsg{}
+}
+
+// disableBracketedPasteMsg in an internal message signals that
+// bracketed paste should be disabled. You can send an
+// disableBracketedPasteMsg with DisableBracketedPaste.
+type disableBracketedPasteMsg struct{}
+
+// enableReportFocusMsg is an internal message that signals to enable focus
+// reporting. You can send an enableReportFocusMsg with EnableReportFocus.
+type enableReportFocusMsg struct{}
+
+// EnableReportFocus is a special command that tells the Bubble Tea program to
+// report focus events to the program.
+func EnableReportFocus() Msg {
+ return enableReportFocusMsg{}
+}
+
+// disableReportFocusMsg is an internal message that signals to disable focus
+// reporting. You can send an disableReportFocusMsg with DisableReportFocus.
+type disableReportFocusMsg struct{}
+
+// DisableReportFocus is a special command that tells the Bubble Tea program to
+// stop reporting focus events to the program.
+func DisableReportFocus() Msg {
+ return disableReportFocusMsg{}
+}
+
+// EnterAltScreen enters the alternate screen buffer, which consumes the entire
+// terminal window. ExitAltScreen will return the terminal to its former state.
+//
+// Deprecated: Use the WithAltScreen ProgramOption instead.
+func (p *Program) EnterAltScreen() {
+ if p.renderer != nil {
+ p.renderer.enterAltScreen()
+ } else {
+ p.startupOptions |= withAltScreen
+ }
+}
+
+// ExitAltScreen exits the alternate screen buffer.
+//
+// Deprecated: The altscreen will exited automatically when the program exits.
+func (p *Program) ExitAltScreen() {
+ if p.renderer != nil {
+ p.renderer.exitAltScreen()
+ } else {
+ p.startupOptions &^= withAltScreen
+ }
+}
+
+// EnableMouseCellMotion enables mouse click, release, wheel and motion events
+// if a mouse button is pressed (i.e., drag events).
+//
+// Deprecated: Use the WithMouseCellMotion ProgramOption instead.
+func (p *Program) EnableMouseCellMotion() {
+ if p.renderer != nil {
+ p.renderer.enableMouseCellMotion()
+ } else {
+ p.startupOptions |= withMouseCellMotion
+ }
+}
+
+// DisableMouseCellMotion disables Mouse Cell Motion tracking. This will be
+// called automatically when exiting a Bubble Tea program.
+//
+// Deprecated: The mouse will automatically be disabled when the program exits.
+func (p *Program) DisableMouseCellMotion() {
+ if p.renderer != nil {
+ p.renderer.disableMouseCellMotion()
+ } else {
+ p.startupOptions &^= withMouseCellMotion
+ }
+}
+
+// EnableMouseAllMotion enables mouse click, release, wheel and motion events,
+// regardless of whether a mouse button is pressed. Many modern terminals
+// support this, but not all.
+//
+// Deprecated: Use the WithMouseAllMotion ProgramOption instead.
+func (p *Program) EnableMouseAllMotion() {
+ if p.renderer != nil {
+ p.renderer.enableMouseAllMotion()
+ } else {
+ p.startupOptions |= withMouseAllMotion
+ }
+}
+
+// DisableMouseAllMotion disables All Motion mouse tracking. This will be
+// called automatically when exiting a Bubble Tea program.
+//
+// Deprecated: The mouse will automatically be disabled when the program exits.
+func (p *Program) DisableMouseAllMotion() {
+ if p.renderer != nil {
+ p.renderer.disableMouseAllMotion()
+ } else {
+ p.startupOptions &^= withMouseAllMotion
+ }
+}
+
+// SetWindowTitle sets the terminal window title.
+//
+// Deprecated: Use the SetWindowTitle command instead.
+func (p *Program) SetWindowTitle(title string) {
+ if p.renderer != nil {
+ p.renderer.setWindowTitle(title)
+ } else {
+ p.startupTitle = title
+ }
+}
diff --git a/vendor/github.com/charmbracelet/bubbletea/signals_unix.go b/vendor/github.com/charmbracelet/bubbletea/signals_unix.go
new file mode 100644
index 00000000000..409540385f8
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/signals_unix.go
@@ -0,0 +1,33 @@
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || aix || zos
+// +build darwin dragonfly freebsd linux netbsd openbsd solaris aix zos
+
+package tea
+
+import (
+ "os"
+ "os/signal"
+ "syscall"
+)
+
+// listenForResize sends messages (or errors) when the terminal resizes.
+// Argument output should be the file descriptor for the terminal; usually
+// os.Stdout.
+func (p *Program) listenForResize(done chan struct{}) {
+ sig := make(chan os.Signal, 1)
+ signal.Notify(sig, syscall.SIGWINCH)
+
+ defer func() {
+ signal.Stop(sig)
+ close(done)
+ }()
+
+ for {
+ select {
+ case <-p.ctx.Done():
+ return
+ case <-sig:
+ }
+
+ p.checkResize()
+ }
+}
diff --git a/vendor/github.com/charmbracelet/bubbletea/signals_windows.go b/vendor/github.com/charmbracelet/bubbletea/signals_windows.go
new file mode 100644
index 00000000000..2fc6f8ae793
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/signals_windows.go
@@ -0,0 +1,10 @@
+//go:build windows
+// +build windows
+
+package tea
+
+// listenForResize is not available on windows because windows does not
+// implement syscall.SIGWINCH.
+func (p *Program) listenForResize(done chan struct{}) {
+ close(done)
+}
diff --git a/vendor/github.com/charmbracelet/bubbletea/standard_renderer.go b/vendor/github.com/charmbracelet/bubbletea/standard_renderer.go
new file mode 100644
index 00000000000..45e8c82d299
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/standard_renderer.go
@@ -0,0 +1,786 @@
+package tea
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "strings"
+ "sync"
+ "time"
+
+ "github.com/charmbracelet/x/ansi"
+ "github.com/muesli/ansi/compressor"
+)
+
+const (
+ // defaultFramerate specifies the maximum interval at which we should
+ // update the view.
+ defaultFPS = 60
+ maxFPS = 120
+)
+
+// standardRenderer is a framerate-based terminal renderer, updating the view
+// at a given framerate to avoid overloading the terminal emulator.
+//
+// In cases where very high performance is needed the renderer can be told
+// to exclude ranges of lines, allowing them to be written to directly.
+type standardRenderer struct {
+ mtx *sync.Mutex
+ out io.Writer
+
+ buf bytes.Buffer
+ queuedMessageLines []string
+ framerate time.Duration
+ ticker *time.Ticker
+ done chan struct{}
+ lastRender string
+ lastRenderedLines []string
+ linesRendered int
+ altLinesRendered int
+ useANSICompressor bool
+ once sync.Once
+
+ // cursor visibility state
+ cursorHidden bool
+
+ // essentially whether or not we're using the full size of the terminal
+ altScreenActive bool
+
+ // whether or not we're currently using bracketed paste
+ bpActive bool
+
+ // reportingFocus whether reporting focus events is enabled
+ reportingFocus bool
+
+ // renderer dimensions; usually the size of the window
+ width int
+ height int
+
+ // lines explicitly set not to render
+ ignoreLines map[int]struct{}
+}
+
+// newRenderer creates a new renderer. Normally you'll want to initialize it
+// with os.Stdout as the first argument.
+func newRenderer(out io.Writer, useANSICompressor bool, fps int) renderer {
+ if fps < 1 {
+ fps = defaultFPS
+ } else if fps > maxFPS {
+ fps = maxFPS
+ }
+ r := &standardRenderer{
+ out: out,
+ mtx: &sync.Mutex{},
+ done: make(chan struct{}),
+ framerate: time.Second / time.Duration(fps),
+ useANSICompressor: useANSICompressor,
+ queuedMessageLines: []string{},
+ }
+ if r.useANSICompressor {
+ r.out = &compressor.Writer{Forward: out}
+ }
+ return r
+}
+
+// start starts the renderer.
+func (r *standardRenderer) start() {
+ if r.ticker == nil {
+ r.ticker = time.NewTicker(r.framerate)
+ } else {
+ // If the ticker already exists, it has been stopped and we need to
+ // reset it.
+ r.ticker.Reset(r.framerate)
+ }
+
+ // Since the renderer can be restarted after a stop, we need to reset
+ // the done channel and its corresponding sync.Once.
+ r.once = sync.Once{}
+
+ go r.listen()
+}
+
+// stop permanently halts the renderer, rendering the final frame.
+func (r *standardRenderer) stop() {
+ // Stop the renderer before acquiring the mutex to avoid a deadlock.
+ r.once.Do(func() {
+ r.done <- struct{}{}
+ })
+
+ // flush locks the mutex
+ r.flush()
+
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ r.execute(ansi.EraseEntireLine)
+ // Move the cursor back to the beginning of the line
+ r.execute("\r")
+
+ if r.useANSICompressor {
+ if w, ok := r.out.(io.WriteCloser); ok {
+ _ = w.Close()
+ }
+ }
+}
+
+// execute writes a sequence to the terminal.
+func (r *standardRenderer) execute(seq string) {
+ _, _ = io.WriteString(r.out, seq)
+}
+
+// kill halts the renderer. The final frame will not be rendered.
+func (r *standardRenderer) kill() {
+ // Stop the renderer before acquiring the mutex to avoid a deadlock.
+ r.once.Do(func() {
+ r.done <- struct{}{}
+ })
+
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ r.execute(ansi.EraseEntireLine)
+ // Move the cursor back to the beginning of the line
+ r.execute("\r")
+}
+
+// listen waits for ticks on the ticker, or a signal to stop the renderer.
+func (r *standardRenderer) listen() {
+ for {
+ select {
+ case <-r.done:
+ r.ticker.Stop()
+ return
+
+ case <-r.ticker.C:
+ r.flush()
+ }
+ }
+}
+
+// flush renders the buffer.
+func (r *standardRenderer) flush() {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ if r.buf.Len() == 0 || r.buf.String() == r.lastRender {
+ // Nothing to do.
+ return
+ }
+
+ // Output buffer.
+ buf := &bytes.Buffer{}
+
+ // Moving to the beginning of the section, that we rendered.
+ if r.altScreenActive {
+ buf.WriteString(ansi.CursorHomePosition)
+ } else if r.linesRendered > 1 {
+ buf.WriteString(ansi.CursorUp(r.linesRendered - 1))
+ }
+
+ newLines := strings.Split(r.buf.String(), "\n")
+
+ // If we know the output's height, we can use it to determine how many
+ // lines we can render. We drop lines from the top of the render buffer if
+ // necessary, as we can't navigate the cursor into the terminal's scrollback
+ // buffer.
+ if r.height > 0 && len(newLines) > r.height {
+ newLines = newLines[len(newLines)-r.height:]
+ }
+
+ flushQueuedMessages := len(r.queuedMessageLines) > 0 && !r.altScreenActive
+
+ if flushQueuedMessages {
+ // Dump the lines we've queued up for printing.
+ for _, line := range r.queuedMessageLines {
+ if ansi.StringWidth(line) < r.width {
+ // We only erase the rest of the line when the line is shorter than
+ // the width of the terminal. When the cursor reaches the end of
+ // the line, any escape sequences that follow will only affect the
+ // last cell of the line.
+
+ // Removing previously rendered content at the end of line.
+ line = line + ansi.EraseLineRight
+ }
+
+ _, _ = buf.WriteString(line)
+ _, _ = buf.WriteString("\r\n")
+ }
+ // Clear the queued message lines.
+ r.queuedMessageLines = []string{}
+ }
+
+ // Paint new lines.
+ for i := 0; i < len(newLines); i++ {
+ canSkip := !flushQueuedMessages && // Queuing messages triggers repaint -> we don't have access to previous frame content.
+ len(r.lastRenderedLines) > i && r.lastRenderedLines[i] == newLines[i] // Previously rendered line is the same.
+
+ if _, ignore := r.ignoreLines[i]; ignore || canSkip {
+ // Unless this is the last line, move the cursor down.
+ if i < len(newLines)-1 {
+ buf.WriteByte('\n')
+ }
+ continue
+ }
+
+ if i == 0 && r.lastRender == "" {
+ // On first render, reset the cursor to the start of the line
+ // before writing anything.
+ buf.WriteByte('\r')
+ }
+
+ line := newLines[i]
+
+ // Truncate lines wider than the width of the window to avoid
+ // wrapping, which will mess up rendering. If we don't have the
+ // width of the window this will be ignored.
+ //
+ // Note that on Windows we only get the width of the window on
+ // program initialization, so after a resize this won't perform
+ // correctly (signal SIGWINCH is not supported on Windows).
+ if r.width > 0 {
+ line = ansi.Truncate(line, r.width, "")
+ }
+
+ if ansi.StringWidth(line) < r.width {
+ // We only erase the rest of the line when the line is shorter than
+ // the width of the terminal. When the cursor reaches the end of
+ // the line, any escape sequences that follow will only affect the
+ // last cell of the line.
+
+ // Removing previously rendered content at the end of line.
+ line = line + ansi.EraseLineRight
+ }
+
+ _, _ = buf.WriteString(line)
+
+ if i < len(newLines)-1 {
+ _, _ = buf.WriteString("\r\n")
+ }
+ }
+
+ // Clearing left over content from last render.
+ if r.lastLinesRendered() > len(newLines) {
+ buf.WriteString(ansi.EraseScreenBelow)
+ }
+
+ if r.altScreenActive {
+ r.altLinesRendered = len(newLines)
+ } else {
+ r.linesRendered = len(newLines)
+ }
+
+ // Make sure the cursor is at the start of the last line to keep rendering
+ // behavior consistent.
+ if r.altScreenActive {
+ // This case fixes a bug in macOS terminal. In other terminals the
+ // other case seems to do the job regardless of whether or not we're
+ // using the full terminal window.
+ buf.WriteString(ansi.CursorPosition(0, len(newLines)))
+ } else {
+ buf.WriteString(ansi.CursorBackward(r.width))
+ }
+
+ _, _ = r.out.Write(buf.Bytes())
+ r.lastRender = r.buf.String()
+
+ // Save previously rendered lines for comparison in the next render. If we
+ // don't do this, we can't skip rendering lines that haven't changed.
+ // See https://github.com/charmbracelet/bubbletea/pull/1233
+ r.lastRenderedLines = newLines
+ r.buf.Reset()
+}
+
+// lastLinesRendered returns the number of lines rendered lastly.
+func (r *standardRenderer) lastLinesRendered() int {
+ if r.altScreenActive {
+ return r.altLinesRendered
+ }
+ return r.linesRendered
+}
+
+// write writes to the internal buffer. The buffer will be outputted via the
+// ticker which calls flush().
+func (r *standardRenderer) write(s string) {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+ r.buf.Reset()
+
+ // If an empty string was passed we should clear existing output and
+ // rendering nothing. Rather than introduce additional state to manage
+ // this, we render a single space as a simple (albeit less correct)
+ // solution.
+ if s == "" {
+ s = " "
+ }
+
+ _, _ = r.buf.WriteString(s)
+}
+
+func (r *standardRenderer) repaint() {
+ r.lastRender = ""
+ r.lastRenderedLines = nil
+}
+
+func (r *standardRenderer) clearScreen() {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ r.execute(ansi.EraseEntireScreen)
+ r.execute(ansi.CursorHomePosition)
+
+ r.repaint()
+}
+
+func (r *standardRenderer) altScreen() bool {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ return r.altScreenActive
+}
+
+func (r *standardRenderer) enterAltScreen() {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ if r.altScreenActive {
+ return
+ }
+
+ r.altScreenActive = true
+ r.execute(ansi.SetAltScreenSaveCursorMode)
+
+ // Ensure that the terminal is cleared, even when it doesn't support
+ // alt screen (or alt screen support is disabled, like GNU screen by
+ // default).
+ //
+ // Note: we can't use r.clearScreen() here because the mutex is already
+ // locked.
+ r.execute(ansi.EraseEntireScreen)
+ r.execute(ansi.CursorHomePosition)
+
+ // cmd.exe and other terminals keep separate cursor states for the AltScreen
+ // and the main buffer. We have to explicitly reset the cursor visibility
+ // whenever we enter AltScreen.
+ if r.cursorHidden {
+ r.execute(ansi.HideCursor)
+ } else {
+ r.execute(ansi.ShowCursor)
+ }
+
+ // Entering the alt screen resets the lines rendered count.
+ r.altLinesRendered = 0
+
+ r.repaint()
+}
+
+func (r *standardRenderer) exitAltScreen() {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ if !r.altScreenActive {
+ return
+ }
+
+ r.altScreenActive = false
+ r.execute(ansi.ResetAltScreenSaveCursorMode)
+
+ // cmd.exe and other terminals keep separate cursor states for the AltScreen
+ // and the main buffer. We have to explicitly reset the cursor visibility
+ // whenever we exit AltScreen.
+ if r.cursorHidden {
+ r.execute(ansi.HideCursor)
+ } else {
+ r.execute(ansi.ShowCursor)
+ }
+
+ r.repaint()
+}
+
+func (r *standardRenderer) showCursor() {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ r.cursorHidden = false
+ r.execute(ansi.ShowCursor)
+}
+
+func (r *standardRenderer) hideCursor() {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ r.cursorHidden = true
+ r.execute(ansi.HideCursor)
+}
+
+func (r *standardRenderer) enableMouseCellMotion() {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ r.execute(ansi.SetButtonEventMouseMode)
+}
+
+func (r *standardRenderer) disableMouseCellMotion() {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ r.execute(ansi.ResetButtonEventMouseMode)
+}
+
+func (r *standardRenderer) enableMouseAllMotion() {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ r.execute(ansi.SetAnyEventMouseMode)
+}
+
+func (r *standardRenderer) disableMouseAllMotion() {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ r.execute(ansi.ResetAnyEventMouseMode)
+}
+
+func (r *standardRenderer) enableMouseSGRMode() {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ r.execute(ansi.SetSgrExtMouseMode)
+}
+
+func (r *standardRenderer) disableMouseSGRMode() {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ r.execute(ansi.ResetSgrExtMouseMode)
+}
+
+func (r *standardRenderer) enableBracketedPaste() {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ r.execute(ansi.SetBracketedPasteMode)
+ r.bpActive = true
+}
+
+func (r *standardRenderer) disableBracketedPaste() {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ r.execute(ansi.ResetBracketedPasteMode)
+ r.bpActive = false
+}
+
+func (r *standardRenderer) bracketedPasteActive() bool {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ return r.bpActive
+}
+
+func (r *standardRenderer) enableReportFocus() {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ r.execute(ansi.SetFocusEventMode)
+ r.reportingFocus = true
+}
+
+func (r *standardRenderer) disableReportFocus() {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ r.execute(ansi.ResetFocusEventMode)
+ r.reportingFocus = false
+}
+
+func (r *standardRenderer) reportFocus() bool {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ return r.reportingFocus
+}
+
+// setWindowTitle sets the terminal window title.
+func (r *standardRenderer) setWindowTitle(title string) {
+ r.execute(ansi.SetWindowTitle(title))
+}
+
+// setIgnoredLines specifies lines not to be touched by the standard Bubble Tea
+// renderer.
+func (r *standardRenderer) setIgnoredLines(from int, to int) {
+ // Lock if we're going to be clearing some lines since we don't want
+ // anything jacking our cursor.
+ if r.lastLinesRendered() > 0 {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+ }
+
+ if r.ignoreLines == nil {
+ r.ignoreLines = make(map[int]struct{})
+ }
+ for i := from; i < to; i++ {
+ r.ignoreLines[i] = struct{}{}
+ }
+
+ // Erase ignored lines
+ lastLinesRendered := r.lastLinesRendered()
+ if lastLinesRendered > 0 {
+ buf := &bytes.Buffer{}
+
+ for i := lastLinesRendered - 1; i >= 0; i-- {
+ if _, exists := r.ignoreLines[i]; exists {
+ buf.WriteString(ansi.EraseEntireLine)
+ }
+ buf.WriteString(ansi.CUU1)
+ }
+ buf.WriteString(ansi.CursorPosition(0, lastLinesRendered)) // put cursor back
+ _, _ = r.out.Write(buf.Bytes())
+ }
+}
+
+// clearIgnoredLines returns control of any ignored lines to the standard
+// Bubble Tea renderer. That is, any lines previously set to be ignored can be
+// rendered to again.
+func (r *standardRenderer) clearIgnoredLines() {
+ r.ignoreLines = nil
+}
+
+// insertTop effectively scrolls up. It inserts lines at the top of a given
+// area designated to be a scrollable region, pushing everything else down.
+// This is roughly how ncurses does it.
+//
+// To call this function use command ScrollUp().
+//
+// For this to work renderer.ignoreLines must be set to ignore the scrollable
+// region since we are bypassing the normal Bubble Tea renderer here.
+//
+// Because this method relies on the terminal dimensions, it's only valid for
+// full-window applications (generally those that use the alternate screen
+// buffer).
+//
+// This method bypasses the normal rendering buffer and is philosophically
+// different than the normal way we approach rendering in Bubble Tea. It's for
+// use in high-performance rendering, such as a pager that could potentially
+// be rendering very complicated ansi. In cases where the content is simpler
+// standard Bubble Tea rendering should suffice.
+//
+// Deprecated: This option is deprecated and will be removed in a future
+// version of this package.
+func (r *standardRenderer) insertTop(lines []string, topBoundary, bottomBoundary int) {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ buf := &bytes.Buffer{}
+
+ buf.WriteString(ansi.SetTopBottomMargins(topBoundary, bottomBoundary))
+ buf.WriteString(ansi.CursorPosition(0, topBoundary))
+ buf.WriteString(ansi.InsertLine(len(lines)))
+ _, _ = buf.WriteString(strings.Join(lines, "\r\n"))
+ buf.WriteString(ansi.SetTopBottomMargins(0, r.height))
+
+ // Move cursor back to where the main rendering routine expects it to be
+ buf.WriteString(ansi.CursorPosition(0, r.lastLinesRendered()))
+
+ _, _ = r.out.Write(buf.Bytes())
+}
+
+// insertBottom effectively scrolls down. It inserts lines at the bottom of
+// a given area designated to be a scrollable region, pushing everything else
+// up. This is roughly how ncurses does it.
+//
+// To call this function use the command ScrollDown().
+//
+// See note in insertTop() for caveats, how this function only makes sense for
+// full-window applications, and how it differs from the normal way we do
+// rendering in Bubble Tea.
+//
+// Deprecated: This option is deprecated and will be removed in a future
+// version of this package.
+func (r *standardRenderer) insertBottom(lines []string, topBoundary, bottomBoundary int) {
+ r.mtx.Lock()
+ defer r.mtx.Unlock()
+
+ buf := &bytes.Buffer{}
+
+ buf.WriteString(ansi.SetTopBottomMargins(topBoundary, bottomBoundary))
+ buf.WriteString(ansi.CursorPosition(0, bottomBoundary))
+ _, _ = buf.WriteString("\r\n" + strings.Join(lines, "\r\n"))
+ buf.WriteString(ansi.SetTopBottomMargins(0, r.height))
+
+ // Move cursor back to where the main rendering routine expects it to be
+ buf.WriteString(ansi.CursorPosition(0, r.lastLinesRendered()))
+
+ _, _ = r.out.Write(buf.Bytes())
+}
+
+// handleMessages handles internal messages for the renderer.
+func (r *standardRenderer) handleMessages(msg Msg) {
+ switch msg := msg.(type) {
+ case repaintMsg:
+ // Force a repaint by clearing the render cache as we slide into a
+ // render.
+ r.mtx.Lock()
+ r.repaint()
+ r.mtx.Unlock()
+
+ case WindowSizeMsg:
+ r.mtx.Lock()
+ r.width = msg.Width
+ r.height = msg.Height
+ r.repaint()
+ r.mtx.Unlock()
+
+ case clearScrollAreaMsg:
+ r.clearIgnoredLines()
+
+ // Force a repaint on the area where the scrollable stuff was in this
+ // update cycle
+ r.mtx.Lock()
+ r.repaint()
+ r.mtx.Unlock()
+
+ case syncScrollAreaMsg:
+ // Re-render scrolling area
+ r.clearIgnoredLines()
+ r.setIgnoredLines(msg.topBoundary, msg.bottomBoundary)
+ r.insertTop(msg.lines, msg.topBoundary, msg.bottomBoundary)
+
+ // Force non-scrolling stuff to repaint in this update cycle
+ r.mtx.Lock()
+ r.repaint()
+ r.mtx.Unlock()
+
+ case scrollUpMsg:
+ r.insertTop(msg.lines, msg.topBoundary, msg.bottomBoundary)
+
+ case scrollDownMsg:
+ r.insertBottom(msg.lines, msg.topBoundary, msg.bottomBoundary)
+
+ case printLineMessage:
+ if !r.altScreenActive {
+ lines := strings.Split(msg.messageBody, "\n")
+ r.mtx.Lock()
+ r.queuedMessageLines = append(r.queuedMessageLines, lines...)
+ r.repaint()
+ r.mtx.Unlock()
+ }
+ }
+}
+
+// HIGH-PERFORMANCE RENDERING STUFF
+
+type syncScrollAreaMsg struct {
+ lines []string
+ topBoundary int
+ bottomBoundary int
+}
+
+// SyncScrollArea performs a paint of the entire region designated to be the
+// scrollable area. This is required to initialize the scrollable region and
+// should also be called on resize (WindowSizeMsg).
+//
+// For high-performance, scroll-based rendering only.
+//
+// Deprecated: This option will be removed in a future version of this package.
+func SyncScrollArea(lines []string, topBoundary int, bottomBoundary int) Cmd {
+ return func() Msg {
+ return syncScrollAreaMsg{
+ lines: lines,
+ topBoundary: topBoundary,
+ bottomBoundary: bottomBoundary,
+ }
+ }
+}
+
+type clearScrollAreaMsg struct{}
+
+// ClearScrollArea deallocates the scrollable region and returns the control of
+// those lines to the main rendering routine.
+//
+// For high-performance, scroll-based rendering only.
+//
+// Deprecated: This option will be removed in a future version of this package.
+func ClearScrollArea() Msg {
+ return clearScrollAreaMsg{}
+}
+
+type scrollUpMsg struct {
+ lines []string
+ topBoundary int
+ bottomBoundary int
+}
+
+// ScrollUp adds lines to the top of the scrollable region, pushing existing
+// lines below down. Lines that are pushed out the scrollable region disappear
+// from view.
+//
+// For high-performance, scroll-based rendering only.
+//
+// Deprecated: This option will be removed in a future version of this package.
+func ScrollUp(newLines []string, topBoundary, bottomBoundary int) Cmd {
+ return func() Msg {
+ return scrollUpMsg{
+ lines: newLines,
+ topBoundary: topBoundary,
+ bottomBoundary: bottomBoundary,
+ }
+ }
+}
+
+type scrollDownMsg struct {
+ lines []string
+ topBoundary int
+ bottomBoundary int
+}
+
+// ScrollDown adds lines to the bottom of the scrollable region, pushing
+// existing lines above up. Lines that are pushed out of the scrollable region
+// disappear from view.
+//
+// For high-performance, scroll-based rendering only.
+//
+// Deprecated: This option will be removed in a future version of this package.
+func ScrollDown(newLines []string, topBoundary, bottomBoundary int) Cmd {
+ return func() Msg {
+ return scrollDownMsg{
+ lines: newLines,
+ topBoundary: topBoundary,
+ bottomBoundary: bottomBoundary,
+ }
+ }
+}
+
+type printLineMessage struct {
+ messageBody string
+}
+
+// Println prints above the Program. This output is unmanaged by the program and
+// will persist across renders by the Program.
+//
+// Unlike fmt.Println (but similar to log.Println) the message will be print on
+// its own line.
+//
+// If the altscreen is active no output will be printed.
+func Println(args ...interface{}) Cmd {
+ return func() Msg {
+ return printLineMessage{
+ messageBody: fmt.Sprint(args...),
+ }
+ }
+}
+
+// Printf prints above the Program. It takes a format template followed by
+// values similar to fmt.Printf. This output is unmanaged by the program and
+// will persist across renders by the Program.
+//
+// Unlike fmt.Printf (but similar to log.Printf) the message will be print on
+// its own line.
+//
+// If the altscreen is active no output will be printed.
+func Printf(template string, args ...interface{}) Cmd {
+ return func() Msg {
+ return printLineMessage{
+ messageBody: fmt.Sprintf(template, args...),
+ }
+ }
+}
diff --git a/vendor/github.com/charmbracelet/bubbletea/tea.go b/vendor/github.com/charmbracelet/bubbletea/tea.go
new file mode 100644
index 00000000000..0bc915e5b3c
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/tea.go
@@ -0,0 +1,841 @@
+// Package tea provides a framework for building rich terminal user interfaces
+// based on the paradigms of The Elm Architecture. It's well-suited for simple
+// and complex terminal applications, either inline, full-window, or a mix of
+// both. It's been battle-tested in several large projects and is
+// production-ready.
+//
+// A tutorial is available at https://github.com/charmbracelet/bubbletea/tree/master/tutorials
+//
+// Example programs can be found at https://github.com/charmbracelet/bubbletea/tree/master/examples
+package tea
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "io"
+ "os"
+ "os/signal"
+ "runtime"
+ "runtime/debug"
+ "sync"
+ "sync/atomic"
+ "syscall"
+
+ "github.com/charmbracelet/x/term"
+ "github.com/muesli/cancelreader"
+ "golang.org/x/sync/errgroup"
+)
+
+// ErrProgramKilled is returned by [Program.Run] when the program gets killed.
+var ErrProgramKilled = errors.New("program was killed")
+
+// ErrInterrupted is returned by [Program.Run] when the program get a SIGINT
+// signal, or when it receives a [InterruptMsg].
+var ErrInterrupted = errors.New("program was interrupted")
+
+// Msg contain data from the result of a IO operation. Msgs trigger the update
+// function and, henceforth, the UI.
+type Msg interface{}
+
+// Model contains the program's state as well as its core functions.
+type Model interface {
+ // Init is the first function that will be called. It returns an optional
+ // initial command. To not perform an initial command return nil.
+ Init() Cmd
+
+ // Update is called when a message is received. Use it to inspect messages
+ // and, in response, update the model and/or send a command.
+ Update(Msg) (Model, Cmd)
+
+ // View renders the program's UI, which is just a string. The view is
+ // rendered after every Update.
+ View() string
+}
+
+// Cmd is an IO operation that returns a message when it's complete. If it's
+// nil it's considered a no-op. Use it for things like HTTP requests, timers,
+// saving and loading from disk, and so on.
+//
+// Note that there's almost never a reason to use a command to send a message
+// to another part of your program. That can almost always be done in the
+// update function.
+type Cmd func() Msg
+
+type inputType int
+
+const (
+ defaultInput inputType = iota
+ ttyInput
+ customInput
+)
+
+// String implements the stringer interface for [inputType]. It is inteded to
+// be used in testing.
+func (i inputType) String() string {
+ return [...]string{
+ "default input",
+ "tty input",
+ "custom input",
+ }[i]
+}
+
+// Options to customize the program during its initialization. These are
+// generally set with ProgramOptions.
+//
+// The options here are treated as bits.
+type startupOptions int16
+
+func (s startupOptions) has(option startupOptions) bool {
+ return s&option != 0
+}
+
+const (
+ withAltScreen startupOptions = 1 << iota
+ withMouseCellMotion
+ withMouseAllMotion
+ withANSICompressor
+ withoutSignalHandler
+ // Catching panics is incredibly useful for restoring the terminal to a
+ // usable state after a panic occurs. When this is set, Bubble Tea will
+ // recover from panics, print the stack trace, and disable raw mode. This
+ // feature is on by default.
+ withoutCatchPanics
+ withoutBracketedPaste
+ withReportFocus
+)
+
+// channelHandlers manages the series of channels returned by various processes.
+// It allows us to wait for those processes to terminate before exiting the
+// program.
+type channelHandlers []chan struct{}
+
+// Adds a channel to the list of handlers. We wait for all handlers to terminate
+// gracefully on shutdown.
+func (h *channelHandlers) add(ch chan struct{}) {
+ *h = append(*h, ch)
+}
+
+// shutdown waits for all handlers to terminate.
+func (h channelHandlers) shutdown() {
+ var wg sync.WaitGroup
+ for _, ch := range h {
+ wg.Add(1)
+ go func(ch chan struct{}) {
+ <-ch
+ wg.Done()
+ }(ch)
+ }
+ wg.Wait()
+}
+
+// Program is a terminal user interface.
+type Program struct {
+ initialModel Model
+
+ // handlers is a list of channels that need to be waited on before the
+ // program can exit.
+ handlers channelHandlers
+
+ // Configuration options that will set as the program is initializing,
+ // treated as bits. These options can be set via various ProgramOptions.
+ startupOptions startupOptions
+
+ // startupTitle is the title that will be set on the terminal when the
+ // program starts.
+ startupTitle string
+
+ inputType inputType
+
+ ctx context.Context
+ cancel context.CancelFunc
+
+ msgs chan Msg
+ errs chan error
+ finished chan struct{}
+
+ // where to send output, this will usually be os.Stdout.
+ output io.Writer
+ // ttyOutput is null if output is not a TTY.
+ ttyOutput term.File
+ previousOutputState *term.State
+ renderer renderer
+
+ // the environment variables for the program, defaults to os.Environ().
+ environ []string
+
+ // where to read inputs from, this will usually be os.Stdin.
+ input io.Reader
+ // ttyInput is null if input is not a TTY.
+ ttyInput term.File
+ previousTtyInputState *term.State
+ cancelReader cancelreader.CancelReader
+ readLoopDone chan struct{}
+
+ // was the altscreen active before releasing the terminal?
+ altScreenWasActive bool
+ ignoreSignals uint32
+
+ bpWasActive bool // was the bracketed paste mode active before releasing the terminal?
+ reportFocus bool // was focus reporting active before releasing the terminal?
+
+ filter func(Model, Msg) Msg
+
+ // fps is the frames per second we should set on the renderer, if
+ // applicable,
+ fps int
+
+ // mouseMode is true if the program should enable mouse mode on Windows.
+ mouseMode bool
+}
+
+// Quit is a special command that tells the Bubble Tea program to exit.
+func Quit() Msg {
+ return QuitMsg{}
+}
+
+// QuitMsg signals that the program should quit. You can send a [QuitMsg] with
+// [Quit].
+type QuitMsg struct{}
+
+// Suspend is a special command that tells the Bubble Tea program to suspend.
+func Suspend() Msg {
+ return SuspendMsg{}
+}
+
+// SuspendMsg signals the program should suspend.
+// This usually happens when ctrl+z is pressed on common programs, but since
+// bubbletea puts the terminal in raw mode, we need to handle it in a
+// per-program basis.
+//
+// You can send this message with [Suspend()].
+type SuspendMsg struct{}
+
+// ResumeMsg can be listen to to do something once a program is resumed back
+// from a suspend state.
+type ResumeMsg struct{}
+
+// InterruptMsg signals the program should suspend.
+// This usually happens when ctrl+c is pressed on common programs, but since
+// bubbletea puts the terminal in raw mode, we need to handle it in a
+// per-program basis.
+//
+// You can send this message with [Interrupt()].
+type InterruptMsg struct{}
+
+// Interrupt is a special command that tells the Bubble Tea program to
+// interrupt.
+func Interrupt() Msg {
+ return InterruptMsg{}
+}
+
+// NewProgram creates a new Program.
+func NewProgram(model Model, opts ...ProgramOption) *Program {
+ p := &Program{
+ initialModel: model,
+ msgs: make(chan Msg),
+ }
+
+ // Apply all options to the program.
+ for _, opt := range opts {
+ opt(p)
+ }
+
+ // A context can be provided with a ProgramOption, but if none was provided
+ // we'll use the default background context.
+ if p.ctx == nil {
+ p.ctx = context.Background()
+ }
+ // Initialize context and teardown channel.
+ p.ctx, p.cancel = context.WithCancel(p.ctx)
+
+ // if no output was set, set it to stdout
+ if p.output == nil {
+ p.output = os.Stdout
+ }
+
+ // if no environment was set, set it to os.Environ()
+ if p.environ == nil {
+ p.environ = os.Environ()
+ }
+
+ return p
+}
+
+func (p *Program) handleSignals() chan struct{} {
+ ch := make(chan struct{})
+
+ // Listen for SIGINT and SIGTERM.
+ //
+ // In most cases ^C will not send an interrupt because the terminal will be
+ // in raw mode and ^C will be captured as a keystroke and sent along to
+ // Program.Update as a KeyMsg. When input is not a TTY, however, ^C will be
+ // caught here.
+ //
+ // SIGTERM is sent by unix utilities (like kill) to terminate a process.
+ go func() {
+ sig := make(chan os.Signal, 1)
+ signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
+ defer func() {
+ signal.Stop(sig)
+ close(ch)
+ }()
+
+ for {
+ select {
+ case <-p.ctx.Done():
+ return
+
+ case s := <-sig:
+ if atomic.LoadUint32(&p.ignoreSignals) == 0 {
+ switch s {
+ case syscall.SIGINT:
+ p.msgs <- InterruptMsg{}
+ default:
+ p.msgs <- QuitMsg{}
+ }
+ return
+ }
+ }
+ }
+ }()
+
+ return ch
+}
+
+// handleResize handles terminal resize events.
+func (p *Program) handleResize() chan struct{} {
+ ch := make(chan struct{})
+
+ if p.ttyOutput != nil {
+ // Get the initial terminal size and send it to the program.
+ go p.checkResize()
+
+ // Listen for window resizes.
+ go p.listenForResize(ch)
+ } else {
+ close(ch)
+ }
+
+ return ch
+}
+
+// handleCommands runs commands in a goroutine and sends the result to the
+// program's message channel.
+func (p *Program) handleCommands(cmds chan Cmd) chan struct{} {
+ ch := make(chan struct{})
+
+ go func() {
+ defer close(ch)
+
+ for {
+ select {
+ case <-p.ctx.Done():
+ return
+
+ case cmd := <-cmds:
+ if cmd == nil {
+ continue
+ }
+
+ // Don't wait on these goroutines, otherwise the shutdown
+ // latency would get too large as a Cmd can run for some time
+ // (e.g. tick commands that sleep for half a second). It's not
+ // possible to cancel them so we'll have to leak the goroutine
+ // until Cmd returns.
+ go func() {
+ // Recover from panics.
+ if !p.startupOptions.has(withoutCatchPanics) {
+ defer p.recoverFromPanic()
+ }
+
+ msg := cmd() // this can be long.
+ p.Send(msg)
+ }()
+ }
+ }
+ }()
+
+ return ch
+}
+
+func (p *Program) disableMouse() {
+ p.renderer.disableMouseCellMotion()
+ p.renderer.disableMouseAllMotion()
+ p.renderer.disableMouseSGRMode()
+}
+
+// eventLoop is the central message loop. It receives and handles the default
+// Bubble Tea messages, update the model and triggers redraws.
+func (p *Program) eventLoop(model Model, cmds chan Cmd) (Model, error) {
+ for {
+ select {
+ case <-p.ctx.Done():
+ return model, nil
+
+ case err := <-p.errs:
+ return model, err
+
+ case msg := <-p.msgs:
+ // Filter messages.
+ if p.filter != nil {
+ msg = p.filter(model, msg)
+ }
+ if msg == nil {
+ continue
+ }
+
+ // Handle special internal messages.
+ switch msg := msg.(type) {
+ case QuitMsg:
+ return model, nil
+
+ case InterruptMsg:
+ return model, ErrInterrupted
+
+ case SuspendMsg:
+ if suspendSupported {
+ p.suspend()
+ }
+
+ case clearScreenMsg:
+ p.renderer.clearScreen()
+
+ case enterAltScreenMsg:
+ p.renderer.enterAltScreen()
+
+ case exitAltScreenMsg:
+ p.renderer.exitAltScreen()
+
+ case enableMouseCellMotionMsg, enableMouseAllMotionMsg:
+ switch msg.(type) {
+ case enableMouseCellMotionMsg:
+ p.renderer.enableMouseCellMotion()
+ case enableMouseAllMotionMsg:
+ p.renderer.enableMouseAllMotion()
+ }
+ // mouse mode (1006) is a no-op if the terminal doesn't support it.
+ p.renderer.enableMouseSGRMode()
+
+ // XXX: This is used to enable mouse mode on Windows. We need
+ // to reinitialize the cancel reader to get the mouse events to
+ // work.
+ if runtime.GOOS == "windows" && !p.mouseMode {
+ p.mouseMode = true
+ p.initCancelReader(true) //nolint:errcheck
+ }
+
+ case disableMouseMsg:
+ p.disableMouse()
+
+ // XXX: On Windows, mouse mode is enabled on the input reader
+ // level. We need to instruct the input reader to stop reading
+ // mouse events.
+ if runtime.GOOS == "windows" && p.mouseMode {
+ p.mouseMode = false
+ p.initCancelReader(true) //nolint:errcheck
+ }
+
+ case showCursorMsg:
+ p.renderer.showCursor()
+
+ case hideCursorMsg:
+ p.renderer.hideCursor()
+
+ case enableBracketedPasteMsg:
+ p.renderer.enableBracketedPaste()
+
+ case disableBracketedPasteMsg:
+ p.renderer.disableBracketedPaste()
+
+ case enableReportFocusMsg:
+ p.renderer.enableReportFocus()
+
+ case disableReportFocusMsg:
+ p.renderer.disableReportFocus()
+
+ case execMsg:
+ // NB: this blocks.
+ p.exec(msg.cmd, msg.fn)
+
+ case BatchMsg:
+ for _, cmd := range msg {
+ cmds <- cmd
+ }
+ continue
+
+ case sequenceMsg:
+ go func() {
+ // Execute commands one at a time, in order.
+ for _, cmd := range msg {
+ if cmd == nil {
+ continue
+ }
+
+ msg := cmd()
+ if batchMsg, ok := msg.(BatchMsg); ok {
+ g, _ := errgroup.WithContext(p.ctx)
+ for _, cmd := range batchMsg {
+ cmd := cmd
+ g.Go(func() error {
+ p.Send(cmd())
+ return nil
+ })
+ }
+
+ //nolint:errcheck
+ g.Wait() // wait for all commands from batch msg to finish
+ continue
+ }
+
+ p.Send(msg)
+ }
+ }()
+
+ case setWindowTitleMsg:
+ p.SetWindowTitle(string(msg))
+
+ case windowSizeMsg:
+ go p.checkResize()
+ }
+
+ // Process internal messages for the renderer.
+ if r, ok := p.renderer.(*standardRenderer); ok {
+ r.handleMessages(msg)
+ }
+
+ var cmd Cmd
+ model, cmd = model.Update(msg) // run update
+ cmds <- cmd // process command (if any)
+ p.renderer.write(model.View()) // send view to renderer
+ }
+ }
+}
+
+// Run initializes the program and runs its event loops, blocking until it gets
+// terminated by either [Program.Quit], [Program.Kill], or its signal handler.
+// Returns the final model.
+func (p *Program) Run() (Model, error) {
+ p.handlers = channelHandlers{}
+ cmds := make(chan Cmd)
+ p.errs = make(chan error)
+ p.finished = make(chan struct{}, 1)
+
+ defer p.cancel()
+
+ switch p.inputType {
+ case defaultInput:
+ p.input = os.Stdin
+
+ // The user has not set a custom input, so we need to check whether or
+ // not standard input is a terminal. If it's not, we open a new TTY for
+ // input. This will allow things to "just work" in cases where data was
+ // piped in or redirected to the application.
+ //
+ // To disable input entirely pass nil to the [WithInput] program option.
+ f, isFile := p.input.(term.File)
+ if !isFile {
+ break
+ }
+ if term.IsTerminal(f.Fd()) {
+ break
+ }
+
+ f, err := openInputTTY()
+ if err != nil {
+ return p.initialModel, err
+ }
+ defer f.Close() //nolint:errcheck
+ p.input = f
+
+ case ttyInput:
+ // Open a new TTY, by request
+ f, err := openInputTTY()
+ if err != nil {
+ return p.initialModel, err
+ }
+ defer f.Close() //nolint:errcheck
+ p.input = f
+
+ case customInput:
+ // (There is nothing extra to do.)
+ }
+
+ // Handle signals.
+ if !p.startupOptions.has(withoutSignalHandler) {
+ p.handlers.add(p.handleSignals())
+ }
+
+ // Recover from panics.
+ if !p.startupOptions.has(withoutCatchPanics) {
+ defer p.recoverFromPanic()
+ }
+
+ // If no renderer is set use the standard one.
+ if p.renderer == nil {
+ p.renderer = newRenderer(p.output, p.startupOptions.has(withANSICompressor), p.fps)
+ }
+
+ // Check if output is a TTY before entering raw mode, hiding the cursor and
+ // so on.
+ if err := p.initTerminal(); err != nil {
+ return p.initialModel, err
+ }
+
+ // Honor program startup options.
+ if p.startupTitle != "" {
+ p.renderer.setWindowTitle(p.startupTitle)
+ }
+ if p.startupOptions&withAltScreen != 0 {
+ p.renderer.enterAltScreen()
+ }
+ if p.startupOptions&withoutBracketedPaste == 0 {
+ p.renderer.enableBracketedPaste()
+ }
+ if p.startupOptions&withMouseCellMotion != 0 {
+ p.renderer.enableMouseCellMotion()
+ p.renderer.enableMouseSGRMode()
+ } else if p.startupOptions&withMouseAllMotion != 0 {
+ p.renderer.enableMouseAllMotion()
+ p.renderer.enableMouseSGRMode()
+ }
+
+ // XXX: Should we enable mouse mode on Windows?
+ // This needs to happen before initializing the cancel and input reader.
+ p.mouseMode = p.startupOptions&withMouseCellMotion != 0 || p.startupOptions&withMouseAllMotion != 0
+
+ if p.startupOptions&withReportFocus != 0 {
+ p.renderer.enableReportFocus()
+ }
+
+ // Start the renderer.
+ p.renderer.start()
+
+ // Initialize the program.
+ model := p.initialModel
+ if initCmd := model.Init(); initCmd != nil {
+ ch := make(chan struct{})
+ p.handlers.add(ch)
+
+ go func() {
+ defer close(ch)
+
+ select {
+ case cmds <- initCmd:
+ case <-p.ctx.Done():
+ }
+ }()
+ }
+
+ // Render the initial view.
+ p.renderer.write(model.View())
+
+ // Subscribe to user input.
+ if p.input != nil {
+ if err := p.initCancelReader(false); err != nil {
+ return model, err
+ }
+ }
+
+ // Handle resize events.
+ p.handlers.add(p.handleResize())
+
+ // Process commands.
+ p.handlers.add(p.handleCommands(cmds))
+
+ // Run event loop, handle updates and draw.
+ model, err := p.eventLoop(model, cmds)
+ killed := p.ctx.Err() != nil || err != nil
+ if killed && err == nil {
+ err = fmt.Errorf("%w: %s", ErrProgramKilled, p.ctx.Err())
+ }
+ if err == nil {
+ // Ensure we rendered the final state of the model.
+ p.renderer.write(model.View())
+ }
+
+ // Restore terminal state.
+ p.shutdown(killed)
+
+ return model, err
+}
+
+// StartReturningModel initializes the program and runs its event loops,
+// blocking until it gets terminated by either [Program.Quit], [Program.Kill],
+// or its signal handler. Returns the final model.
+//
+// Deprecated: please use [Program.Run] instead.
+func (p *Program) StartReturningModel() (Model, error) {
+ return p.Run()
+}
+
+// Start initializes the program and runs its event loops, blocking until it
+// gets terminated by either [Program.Quit], [Program.Kill], or its signal
+// handler.
+//
+// Deprecated: please use [Program.Run] instead.
+func (p *Program) Start() error {
+ _, err := p.Run()
+ return err
+}
+
+// Send sends a message to the main update function, effectively allowing
+// messages to be injected from outside the program for interoperability
+// purposes.
+//
+// If the program hasn't started yet this will be a blocking operation.
+// If the program has already been terminated this will be a no-op, so it's safe
+// to send messages after the program has exited.
+func (p *Program) Send(msg Msg) {
+ select {
+ case <-p.ctx.Done():
+ case p.msgs <- msg:
+ }
+}
+
+// Quit is a convenience function for quitting Bubble Tea programs. Use it
+// when you need to shut down a Bubble Tea program from the outside.
+//
+// If you wish to quit from within a Bubble Tea program use the Quit command.
+//
+// If the program is not running this will be a no-op, so it's safe to call
+// if the program is unstarted or has already exited.
+func (p *Program) Quit() {
+ p.Send(Quit())
+}
+
+// Kill stops the program immediately and restores the former terminal state.
+// The final render that you would normally see when quitting will be skipped.
+// [program.Run] returns a [ErrProgramKilled] error.
+func (p *Program) Kill() {
+ p.shutdown(true)
+}
+
+// Wait waits/blocks until the underlying Program finished shutting down.
+func (p *Program) Wait() {
+ <-p.finished
+}
+
+// shutdown performs operations to free up resources and restore the terminal
+// to its original state.
+func (p *Program) shutdown(kill bool) {
+ p.cancel()
+
+ // Wait for all handlers to finish.
+ p.handlers.shutdown()
+
+ // Check if the cancel reader has been setup before waiting and closing.
+ if p.cancelReader != nil {
+ // Wait for input loop to finish.
+ if p.cancelReader.Cancel() {
+ if !kill {
+ p.waitForReadLoop()
+ }
+ }
+ _ = p.cancelReader.Close()
+ }
+
+ if p.renderer != nil {
+ if kill {
+ p.renderer.kill()
+ } else {
+ p.renderer.stop()
+ }
+ }
+
+ _ = p.restoreTerminalState()
+ if !kill {
+ p.finished <- struct{}{}
+ }
+}
+
+// recoverFromPanic recovers from a panic, prints the stack trace, and restores
+// the terminal to a usable state.
+func (p *Program) recoverFromPanic() {
+ if r := recover(); r != nil {
+ p.shutdown(true)
+ fmt.Printf("Caught panic:\n\n%s\n\nRestoring terminal...\n\n", r)
+ debug.PrintStack()
+ }
+}
+
+// ReleaseTerminal restores the original terminal state and cancels the input
+// reader. You can return control to the Program with RestoreTerminal.
+func (p *Program) ReleaseTerminal() error {
+ atomic.StoreUint32(&p.ignoreSignals, 1)
+ if p.cancelReader != nil {
+ p.cancelReader.Cancel()
+ }
+
+ p.waitForReadLoop()
+
+ if p.renderer != nil {
+ p.renderer.stop()
+ p.altScreenWasActive = p.renderer.altScreen()
+ p.bpWasActive = p.renderer.bracketedPasteActive()
+ p.reportFocus = p.renderer.reportFocus()
+ }
+
+ return p.restoreTerminalState()
+}
+
+// RestoreTerminal reinitializes the Program's input reader, restores the
+// terminal to the former state when the program was running, and repaints.
+// Use it to reinitialize a Program after running ReleaseTerminal.
+func (p *Program) RestoreTerminal() error {
+ atomic.StoreUint32(&p.ignoreSignals, 0)
+
+ if err := p.initTerminal(); err != nil {
+ return err
+ }
+ if err := p.initCancelReader(false); err != nil {
+ return err
+ }
+ if p.altScreenWasActive {
+ p.renderer.enterAltScreen()
+ } else {
+ // entering alt screen already causes a repaint.
+ go p.Send(repaintMsg{})
+ }
+ if p.renderer != nil {
+ p.renderer.start()
+ }
+ if p.bpWasActive {
+ p.renderer.enableBracketedPaste()
+ }
+ if p.reportFocus {
+ p.renderer.enableReportFocus()
+ }
+
+ // If the output is a terminal, it may have been resized while another
+ // process was at the foreground, in which case we may not have received
+ // SIGWINCH. Detect any size change now and propagate the new size as
+ // needed.
+ go p.checkResize()
+
+ return nil
+}
+
+// Println prints above the Program. This output is unmanaged by the program
+// and will persist across renders by the Program.
+//
+// If the altscreen is active no output will be printed.
+func (p *Program) Println(args ...interface{}) {
+ p.msgs <- printLineMessage{
+ messageBody: fmt.Sprint(args...),
+ }
+}
+
+// Printf prints above the Program. It takes a format template followed by
+// values similar to fmt.Printf. This output is unmanaged by the program and
+// will persist across renders by the Program.
+//
+// Unlike fmt.Printf (but similar to log.Printf) the message will be print on
+// its own line.
+//
+// If the altscreen is active no output will be printed.
+func (p *Program) Printf(template string, args ...interface{}) {
+ p.msgs <- printLineMessage{
+ messageBody: fmt.Sprintf(template, args...),
+ }
+}
diff --git a/vendor/github.com/charmbracelet/bubbletea/tea_init.go b/vendor/github.com/charmbracelet/bubbletea/tea_init.go
new file mode 100644
index 00000000000..19b6cc394c6
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/tea_init.go
@@ -0,0 +1,22 @@
+package tea
+
+import (
+ "github.com/charmbracelet/lipgloss"
+)
+
+func init() {
+ // XXX: This is a workaround to make assure that Lip Gloss and Termenv
+ // query the terminal before any Bubble Tea Program runs and acquires the
+ // terminal. Without this, Programs that use Lip Gloss/Termenv might hang
+ // while waiting for a a [termenv.OSCTimeout] while querying the terminal
+ // for its background/foreground colors.
+ //
+ // This happens because Bubble Tea acquires the terminal before termenv
+ // reads any responses.
+ //
+ // Note that this will only affect programs running on the default IO i.e.
+ // [os.Stdout] and [os.Stdin].
+ //
+ // This workaround will be removed in v2.
+ _ = lipgloss.HasDarkBackground()
+}
diff --git a/vendor/github.com/charmbracelet/bubbletea/tty.go b/vendor/github.com/charmbracelet/bubbletea/tty.go
new file mode 100644
index 00000000000..9490facacb5
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/tty.go
@@ -0,0 +1,141 @@
+package tea
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "time"
+
+ "github.com/charmbracelet/x/term"
+ "github.com/muesli/cancelreader"
+)
+
+func (p *Program) suspend() {
+ if err := p.ReleaseTerminal(); err != nil {
+ // If we can't release input, abort.
+ return
+ }
+
+ suspendProcess()
+
+ _ = p.RestoreTerminal()
+ go p.Send(ResumeMsg{})
+}
+
+func (p *Program) initTerminal() error {
+ if _, ok := p.renderer.(*nilRenderer); ok {
+ // No need to initialize the terminal if we're not rendering
+ return nil
+ }
+
+ if err := p.initInput(); err != nil {
+ return err
+ }
+
+ p.renderer.hideCursor()
+ return nil
+}
+
+// restoreTerminalState restores the terminal to the state prior to running the
+// Bubble Tea program.
+func (p *Program) restoreTerminalState() error {
+ if p.renderer != nil {
+ p.renderer.disableBracketedPaste()
+ p.renderer.showCursor()
+ p.disableMouse()
+
+ if p.renderer.reportFocus() {
+ p.renderer.disableReportFocus()
+ }
+
+ if p.renderer.altScreen() {
+ p.renderer.exitAltScreen()
+
+ // give the terminal a moment to catch up
+ time.Sleep(time.Millisecond * 10) //nolint:gomnd
+ }
+ }
+
+ return p.restoreInput()
+}
+
+// restoreInput restores the tty input to its original state.
+func (p *Program) restoreInput() error {
+ if p.ttyInput != nil && p.previousTtyInputState != nil {
+ if err := term.Restore(p.ttyInput.Fd(), p.previousTtyInputState); err != nil {
+ return fmt.Errorf("error restoring console: %w", err)
+ }
+ }
+ if p.ttyOutput != nil && p.previousOutputState != nil {
+ if err := term.Restore(p.ttyOutput.Fd(), p.previousOutputState); err != nil {
+ return fmt.Errorf("error restoring console: %w", err)
+ }
+ }
+ return nil
+}
+
+// initCancelReader (re)commences reading inputs.
+func (p *Program) initCancelReader(cancel bool) error {
+ if cancel && p.cancelReader != nil {
+ p.cancelReader.Cancel()
+ p.waitForReadLoop()
+ }
+
+ var err error
+ p.cancelReader, err = newInputReader(p.input, p.mouseMode)
+ if err != nil {
+ return fmt.Errorf("error creating cancelreader: %w", err)
+ }
+
+ p.readLoopDone = make(chan struct{})
+ go p.readLoop()
+
+ return nil
+}
+
+func (p *Program) readLoop() {
+ defer close(p.readLoopDone)
+
+ err := readInputs(p.ctx, p.msgs, p.cancelReader)
+ if !errors.Is(err, io.EOF) && !errors.Is(err, cancelreader.ErrCanceled) {
+ select {
+ case <-p.ctx.Done():
+ case p.errs <- err:
+ }
+ }
+}
+
+// waitForReadLoop waits for the cancelReader to finish its read loop.
+func (p *Program) waitForReadLoop() {
+ select {
+ case <-p.readLoopDone:
+ case <-time.After(500 * time.Millisecond): //nolint:gomnd
+ // The read loop hangs, which means the input
+ // cancelReader's cancel function has returned true even
+ // though it was not able to cancel the read.
+ }
+}
+
+// checkResize detects the current size of the output and informs the program
+// via a WindowSizeMsg.
+func (p *Program) checkResize() {
+ if p.ttyOutput == nil {
+ // can't query window size
+ return
+ }
+
+ w, h, err := term.GetSize(p.ttyOutput.Fd())
+ if err != nil {
+ select {
+ case <-p.ctx.Done():
+ case p.errs <- err:
+ }
+
+ return
+ }
+
+ p.Send(WindowSizeMsg{
+ Width: w,
+ Height: h,
+ })
+}
diff --git a/vendor/github.com/charmbracelet/bubbletea/tty_unix.go b/vendor/github.com/charmbracelet/bubbletea/tty_unix.go
new file mode 100644
index 00000000000..5cbb4fe1556
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/tty_unix.go
@@ -0,0 +1,49 @@
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || aix || zos
+// +build darwin dragonfly freebsd linux netbsd openbsd solaris aix zos
+
+package tea
+
+import (
+ "fmt"
+ "os"
+ "os/signal"
+ "syscall"
+
+ "github.com/charmbracelet/x/term"
+)
+
+func (p *Program) initInput() (err error) {
+ // Check if input is a terminal
+ if f, ok := p.input.(term.File); ok && term.IsTerminal(f.Fd()) {
+ p.ttyInput = f
+ p.previousTtyInputState, err = term.MakeRaw(p.ttyInput.Fd())
+ if err != nil {
+ return fmt.Errorf("error entering raw mode: %w", err)
+ }
+ }
+
+ if f, ok := p.output.(term.File); ok && term.IsTerminal(f.Fd()) {
+ p.ttyOutput = f
+ }
+
+ return nil
+}
+
+func openInputTTY() (*os.File, error) {
+ f, err := os.Open("/dev/tty")
+ if err != nil {
+ return nil, fmt.Errorf("could not open a new TTY: %w", err)
+ }
+ return f, nil
+}
+
+const suspendSupported = true
+
+// Send SIGTSTP to the entire process group.
+func suspendProcess() {
+ c := make(chan os.Signal, 1)
+ signal.Notify(c, syscall.SIGCONT)
+ _ = syscall.Kill(0, syscall.SIGTSTP)
+ // blocks until a CONT happens...
+ <-c
+}
diff --git a/vendor/github.com/charmbracelet/bubbletea/tty_windows.go b/vendor/github.com/charmbracelet/bubbletea/tty_windows.go
new file mode 100644
index 00000000000..a3a2525bc6e
--- /dev/null
+++ b/vendor/github.com/charmbracelet/bubbletea/tty_windows.go
@@ -0,0 +1,68 @@
+//go:build windows
+// +build windows
+
+package tea
+
+import (
+ "fmt"
+ "os"
+
+ "github.com/charmbracelet/x/term"
+ "golang.org/x/sys/windows"
+)
+
+func (p *Program) initInput() (err error) {
+ // Save stdin state and enable VT input
+ // We also need to enable VT
+ // input here.
+ if f, ok := p.input.(term.File); ok && term.IsTerminal(f.Fd()) {
+ p.ttyInput = f
+ p.previousTtyInputState, err = term.MakeRaw(p.ttyInput.Fd())
+ if err != nil {
+ return err
+ }
+
+ // Enable VT input
+ var mode uint32
+ if err := windows.GetConsoleMode(windows.Handle(p.ttyInput.Fd()), &mode); err != nil {
+ return fmt.Errorf("error getting console mode: %w", err)
+ }
+
+ if err := windows.SetConsoleMode(windows.Handle(p.ttyInput.Fd()), mode|windows.ENABLE_VIRTUAL_TERMINAL_INPUT); err != nil {
+ return fmt.Errorf("error setting console mode: %w", err)
+ }
+ }
+
+ // Save output screen buffer state and enable VT processing.
+ if f, ok := p.output.(term.File); ok && term.IsTerminal(f.Fd()) {
+ p.ttyOutput = f
+ p.previousOutputState, err = term.GetState(f.Fd())
+ if err != nil {
+ return err
+ }
+
+ var mode uint32
+ if err := windows.GetConsoleMode(windows.Handle(p.ttyOutput.Fd()), &mode); err != nil {
+ return fmt.Errorf("error getting console mode: %w", err)
+ }
+
+ if err := windows.SetConsoleMode(windows.Handle(p.ttyOutput.Fd()), mode|windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING); err != nil {
+ return fmt.Errorf("error setting console mode: %w", err)
+ }
+ }
+
+ return
+}
+
+// Open the Windows equivalent of a TTY.
+func openInputTTY() (*os.File, error) {
+ f, err := os.OpenFile("CONIN$", os.O_RDWR, 0o644)
+ if err != nil {
+ return nil, err
+ }
+ return f, nil
+}
+
+const suspendSupported = false
+
+func suspendProcess() {}
diff --git a/vendor/github.com/erikgeiser/coninput/.gitignore b/vendor/github.com/erikgeiser/coninput/.gitignore
new file mode 100644
index 00000000000..66fd13c903c
--- /dev/null
+++ b/vendor/github.com/erikgeiser/coninput/.gitignore
@@ -0,0 +1,15 @@
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
diff --git a/vendor/github.com/erikgeiser/coninput/.golangci.yml b/vendor/github.com/erikgeiser/coninput/.golangci.yml
new file mode 100644
index 00000000000..d3ed7103bcf
--- /dev/null
+++ b/vendor/github.com/erikgeiser/coninput/.golangci.yml
@@ -0,0 +1,24 @@
+linters:
+ enable-all: true
+ disable:
+ - golint
+ - interfacer
+ - scopelint
+ - maligned
+ - rowserrcheck
+ - funlen
+ - depguard
+ - goerr113
+ - exhaustivestruct
+ - testpackage
+ - gochecknoglobals
+ - wrapcheck
+ - forbidigo
+ - ifshort
+ - cyclop
+ - gomoddirectives
+linters-settings:
+ exhaustive:
+ default-signifies-exhaustive: true
+issues:
+ exclude-use-default: false
diff --git a/vendor/github.com/erikgeiser/coninput/LICENSE b/vendor/github.com/erikgeiser/coninput/LICENSE
new file mode 100644
index 00000000000..83c244082a3
--- /dev/null
+++ b/vendor/github.com/erikgeiser/coninput/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Erik G.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/github.com/erikgeiser/coninput/README.md b/vendor/github.com/erikgeiser/coninput/README.md
new file mode 100644
index 00000000000..22619d13196
--- /dev/null
+++ b/vendor/github.com/erikgeiser/coninput/README.md
@@ -0,0 +1,2 @@
+# coninput
+Go library for input handling using Windows Console API
diff --git a/vendor/github.com/erikgeiser/coninput/keycodes.go b/vendor/github.com/erikgeiser/coninput/keycodes.go
new file mode 100644
index 00000000000..902ee1b7b9b
--- /dev/null
+++ b/vendor/github.com/erikgeiser/coninput/keycodes.go
@@ -0,0 +1,205 @@
+package coninput
+
+// VirtualKeyCode holds a virtual key code (see
+// https://docs.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes).
+type VirtualKeyCode uint16
+
+const (
+ VK_LBUTTON VirtualKeyCode = 0x01
+ VK_RBUTTON VirtualKeyCode = 0x02
+ VK_CANCEL VirtualKeyCode = 0x03
+ VK_MBUTTON VirtualKeyCode = 0x04
+ VK_XBUTTON1 VirtualKeyCode = 0x05
+ VK_XBUTTON2 VirtualKeyCode = 0x06
+ VK_BACK VirtualKeyCode = 0x08
+ VK_TAB VirtualKeyCode = 0x09
+ VK_CLEAR VirtualKeyCode = 0x0C
+ VK_RETURN VirtualKeyCode = 0x0D
+ VK_SHIFT VirtualKeyCode = 0x10
+ VK_CONTROL VirtualKeyCode = 0x11
+ VK_MENU VirtualKeyCode = 0x12
+ VK_PAUSE VirtualKeyCode = 0x13
+ VK_CAPITAL VirtualKeyCode = 0x14
+ VK_KANA VirtualKeyCode = 0x15
+ VK_HANGEUL VirtualKeyCode = 0x15
+ VK_HANGUL VirtualKeyCode = 0x15
+ VK_IME_ON VirtualKeyCode = 0x16
+ VK_JUNJA VirtualKeyCode = 0x17
+ VK_FINAL VirtualKeyCode = 0x18
+ VK_HANJA VirtualKeyCode = 0x19
+ VK_KANJI VirtualKeyCode = 0x19
+ VK_IME_OFF VirtualKeyCode = 0x1A
+ VK_ESCAPE VirtualKeyCode = 0x1B
+ VK_CONVERT VirtualKeyCode = 0x1C
+ VK_NONCONVERT VirtualKeyCode = 0x1D
+ VK_ACCEPT VirtualKeyCode = 0x1E
+ VK_MODECHANGE VirtualKeyCode = 0x1F
+ VK_SPACE VirtualKeyCode = 0x20
+ VK_PRIOR VirtualKeyCode = 0x21
+ VK_NEXT VirtualKeyCode = 0x22
+ VK_END VirtualKeyCode = 0x23
+ VK_HOME VirtualKeyCode = 0x24
+ VK_LEFT VirtualKeyCode = 0x25
+ VK_UP VirtualKeyCode = 0x26
+ VK_RIGHT VirtualKeyCode = 0x27
+ VK_DOWN VirtualKeyCode = 0x28
+ VK_SELECT VirtualKeyCode = 0x29
+ VK_PRINT VirtualKeyCode = 0x2A
+ VK_EXECUTE VirtualKeyCode = 0x2B
+ VK_SNAPSHOT VirtualKeyCode = 0x2C
+ VK_INSERT VirtualKeyCode = 0x2D
+ VK_DELETE VirtualKeyCode = 0x2E
+ VK_HELP VirtualKeyCode = 0x2F
+ VK_0 VirtualKeyCode = 0x30
+ VK_1 VirtualKeyCode = 0x31
+ VK_2 VirtualKeyCode = 0x32
+ VK_3 VirtualKeyCode = 0x33
+ VK_4 VirtualKeyCode = 0x34
+ VK_5 VirtualKeyCode = 0x35
+ VK_6 VirtualKeyCode = 0x36
+ VK_7 VirtualKeyCode = 0x37
+ VK_8 VirtualKeyCode = 0x38
+ VK_9 VirtualKeyCode = 0x39
+ VK_A VirtualKeyCode = 0x41
+ VK_B VirtualKeyCode = 0x42
+ VK_C VirtualKeyCode = 0x43
+ VK_D VirtualKeyCode = 0x44
+ VK_E VirtualKeyCode = 0x45
+ VK_F VirtualKeyCode = 0x46
+ VK_G VirtualKeyCode = 0x47
+ VK_H VirtualKeyCode = 0x48
+ VK_I VirtualKeyCode = 0x49
+ VK_J VirtualKeyCode = 0x4A
+ VK_K VirtualKeyCode = 0x4B
+ VK_L VirtualKeyCode = 0x4C
+ VK_M VirtualKeyCode = 0x4D
+ VK_N VirtualKeyCode = 0x4E
+ VK_O VirtualKeyCode = 0x4F
+ VK_P VirtualKeyCode = 0x50
+ VK_Q VirtualKeyCode = 0x51
+ VK_R VirtualKeyCode = 0x52
+ VK_S VirtualKeyCode = 0x53
+ VK_T VirtualKeyCode = 0x54
+ VK_U VirtualKeyCode = 0x55
+ VK_V VirtualKeyCode = 0x56
+ VK_W VirtualKeyCode = 0x57
+ VK_X VirtualKeyCode = 0x58
+ VK_Y VirtualKeyCode = 0x59
+ VK_Z VirtualKeyCode = 0x5A
+ VK_LWIN VirtualKeyCode = 0x5B
+ VK_RWIN VirtualKeyCode = 0x5C
+ VK_APPS VirtualKeyCode = 0x5D
+ VK_SLEEP VirtualKeyCode = 0x5F
+ VK_NUMPAD0 VirtualKeyCode = 0x60
+ VK_NUMPAD1 VirtualKeyCode = 0x61
+ VK_NUMPAD2 VirtualKeyCode = 0x62
+ VK_NUMPAD3 VirtualKeyCode = 0x63
+ VK_NUMPAD4 VirtualKeyCode = 0x64
+ VK_NUMPAD5 VirtualKeyCode = 0x65
+ VK_NUMPAD6 VirtualKeyCode = 0x66
+ VK_NUMPAD7 VirtualKeyCode = 0x67
+ VK_NUMPAD8 VirtualKeyCode = 0x68
+ VK_NUMPAD9 VirtualKeyCode = 0x69
+ VK_MULTIPLY VirtualKeyCode = 0x6A
+ VK_ADD VirtualKeyCode = 0x6B
+ VK_SEPARATOR VirtualKeyCode = 0x6C
+ VK_SUBTRACT VirtualKeyCode = 0x6D
+ VK_DECIMAL VirtualKeyCode = 0x6E
+ VK_DIVIDE VirtualKeyCode = 0x6F
+ VK_F1 VirtualKeyCode = 0x70
+ VK_F2 VirtualKeyCode = 0x71
+ VK_F3 VirtualKeyCode = 0x72
+ VK_F4 VirtualKeyCode = 0x73
+ VK_F5 VirtualKeyCode = 0x74
+ VK_F6 VirtualKeyCode = 0x75
+ VK_F7 VirtualKeyCode = 0x76
+ VK_F8 VirtualKeyCode = 0x77
+ VK_F9 VirtualKeyCode = 0x78
+ VK_F10 VirtualKeyCode = 0x79
+ VK_F11 VirtualKeyCode = 0x7A
+ VK_F12 VirtualKeyCode = 0x7B
+ VK_F13 VirtualKeyCode = 0x7C
+ VK_F14 VirtualKeyCode = 0x7D
+ VK_F15 VirtualKeyCode = 0x7E
+ VK_F16 VirtualKeyCode = 0x7F
+ VK_F17 VirtualKeyCode = 0x80
+ VK_F18 VirtualKeyCode = 0x81
+ VK_F19 VirtualKeyCode = 0x82
+ VK_F20 VirtualKeyCode = 0x83
+ VK_F21 VirtualKeyCode = 0x84
+ VK_F22 VirtualKeyCode = 0x85
+ VK_F23 VirtualKeyCode = 0x86
+ VK_F24 VirtualKeyCode = 0x87
+ VK_NUMLOCK VirtualKeyCode = 0x90
+ VK_SCROLL VirtualKeyCode = 0x91
+ VK_OEM_NEC_EQUAL VirtualKeyCode = 0x92
+ VK_OEM_FJ_JISHO VirtualKeyCode = 0x92
+ VK_OEM_FJ_MASSHOU VirtualKeyCode = 0x93
+ VK_OEM_FJ_TOUROKU VirtualKeyCode = 0x94
+ VK_OEM_FJ_LOYA VirtualKeyCode = 0x95
+ VK_OEM_FJ_ROYA VirtualKeyCode = 0x96
+ VK_LSHIFT VirtualKeyCode = 0xA0
+ VK_RSHIFT VirtualKeyCode = 0xA1
+ VK_LCONTROL VirtualKeyCode = 0xA2
+ VK_RCONTROL VirtualKeyCode = 0xA3
+ VK_LMENU VirtualKeyCode = 0xA4
+ VK_RMENU VirtualKeyCode = 0xA5
+ VK_BROWSER_BACK VirtualKeyCode = 0xA6
+ VK_BROWSER_FORWARD VirtualKeyCode = 0xA7
+ VK_BROWSER_REFRESH VirtualKeyCode = 0xA8
+ VK_BROWSER_STOP VirtualKeyCode = 0xA9
+ VK_BROWSER_SEARCH VirtualKeyCode = 0xAA
+ VK_BROWSER_FAVORITES VirtualKeyCode = 0xAB
+ VK_BROWSER_HOME VirtualKeyCode = 0xAC
+ VK_VOLUME_MUTE VirtualKeyCode = 0xAD
+ VK_VOLUME_DOWN VirtualKeyCode = 0xAE
+ VK_VOLUME_UP VirtualKeyCode = 0xAF
+ VK_MEDIA_NEXT_TRACK VirtualKeyCode = 0xB0
+ VK_MEDIA_PREV_TRACK VirtualKeyCode = 0xB1
+ VK_MEDIA_STOP VirtualKeyCode = 0xB2
+ VK_MEDIA_PLAY_PAUSE VirtualKeyCode = 0xB3
+ VK_LAUNCH_MAIL VirtualKeyCode = 0xB4
+ VK_LAUNCH_MEDIA_SELECT VirtualKeyCode = 0xB5
+ VK_LAUNCH_APP1 VirtualKeyCode = 0xB6
+ VK_LAUNCH_APP2 VirtualKeyCode = 0xB7
+ VK_OEM_1 VirtualKeyCode = 0xBA
+ VK_OEM_PLUS VirtualKeyCode = 0xBB
+ VK_OEM_COMMA VirtualKeyCode = 0xBC
+ VK_OEM_MINUS VirtualKeyCode = 0xBD
+ VK_OEM_PERIOD VirtualKeyCode = 0xBE
+ VK_OEM_2 VirtualKeyCode = 0xBF
+ VK_OEM_3 VirtualKeyCode = 0xC0
+ VK_OEM_4 VirtualKeyCode = 0xDB
+ VK_OEM_5 VirtualKeyCode = 0xDC
+ VK_OEM_6 VirtualKeyCode = 0xDD
+ VK_OEM_7 VirtualKeyCode = 0xDE
+ VK_OEM_8 VirtualKeyCode = 0xDF
+ VK_OEM_AX VirtualKeyCode = 0xE1
+ VK_OEM_102 VirtualKeyCode = 0xE2
+ VK_ICO_HELP VirtualKeyCode = 0xE3
+ VK_ICO_00 VirtualKeyCode = 0xE4
+ VK_PROCESSKEY VirtualKeyCode = 0xE5
+ VK_ICO_CLEAR VirtualKeyCode = 0xE6
+ VK_OEM_RESET VirtualKeyCode = 0xE9
+ VK_OEM_JUMP VirtualKeyCode = 0xEA
+ VK_OEM_PA1 VirtualKeyCode = 0xEB
+ VK_OEM_PA2 VirtualKeyCode = 0xEC
+ VK_OEM_PA3 VirtualKeyCode = 0xED
+ VK_OEM_WSCTRL VirtualKeyCode = 0xEE
+ VK_OEM_CUSEL VirtualKeyCode = 0xEF
+ VK_OEM_ATTN VirtualKeyCode = 0xF0
+ VK_OEM_FINISH VirtualKeyCode = 0xF1
+ VK_OEM_COPY VirtualKeyCode = 0xF2
+ VK_OEM_AUTO VirtualKeyCode = 0xF3
+ VK_OEM_ENLW VirtualKeyCode = 0xF4
+ VK_OEM_BACKTAB VirtualKeyCode = 0xF5
+ VK_ATTN VirtualKeyCode = 0xF6
+ VK_CRSEL VirtualKeyCode = 0xF7
+ VK_EXSEL VirtualKeyCode = 0xF8
+ VK_EREOF VirtualKeyCode = 0xF9
+ VK_PLAY VirtualKeyCode = 0xFA
+ VK_ZOOM VirtualKeyCode = 0xFB
+ VK_NONAME VirtualKeyCode = 0xFC
+ VK_PA1 VirtualKeyCode = 0xFD
+ VK_OEM_CLEAR VirtualKeyCode = 0xFE
+)
diff --git a/vendor/github.com/erikgeiser/coninput/mode.go b/vendor/github.com/erikgeiser/coninput/mode.go
new file mode 100644
index 00000000000..e6d8bf44e6c
--- /dev/null
+++ b/vendor/github.com/erikgeiser/coninput/mode.go
@@ -0,0 +1,82 @@
+//go:build windows
+// +build windows
+
+package coninput
+
+import (
+ "strings"
+
+ "golang.org/x/sys/windows"
+)
+
+// AddInputModes returns the given mode with one or more additional modes enabled.
+func AddInputModes(mode uint32, enableModes ...uint32) uint32 {
+ for _, enableMode := range enableModes {
+ mode |= enableMode
+ }
+
+ return mode
+}
+
+// RemoveInputModes returns the given mode with one or more additional modes disabled.
+func RemoveInputModes(mode uint32, disableModes ...uint32) uint32 {
+ for _, disableMode := range disableModes {
+ mode &^= disableMode
+ }
+
+ return mode
+}
+
+// ToggleInputModes returns the given mode with one or more additional modes toggeled.
+func ToggleInputModes(mode uint32, toggleModes ...uint32) uint32 {
+ for _, toggeMode := range toggleModes {
+ mode ^= toggeMode
+ }
+
+ return mode
+}
+
+var inputModes = []struct {
+ mode uint32
+ name string
+}{
+ {mode: windows.ENABLE_ECHO_INPUT, name: "ENABLE_ECHO_INPUT"},
+ {mode: windows.ENABLE_INSERT_MODE, name: "ENABLE_INSERT_MODE"},
+ {mode: windows.ENABLE_LINE_INPUT, name: "ENABLE_LINE_INPUT"},
+ {mode: windows.ENABLE_MOUSE_INPUT, name: "ENABLE_MOUSE_INPUT"},
+ {mode: windows.ENABLE_PROCESSED_INPUT, name: "ENABLE_PROCESSED_INPUT"},
+ {mode: windows.ENABLE_QUICK_EDIT_MODE, name: "ENABLE_QUICK_EDIT_MODE"},
+ {mode: windows.ENABLE_WINDOW_INPUT, name: "ENABLE_WINDOW_INPUT"},
+ {mode: windows.ENABLE_VIRTUAL_TERMINAL_INPUT, name: "ENABLE_VIRTUAL_TERMINAL_INPUT"},
+}
+
+// ListInputMode returnes the isolated enabled input modes as a list.
+func ListInputModes(mode uint32) []uint32 {
+ modes := []uint32{}
+
+ for _, inputMode := range inputModes {
+ if mode&inputMode.mode > 0 {
+ modes = append(modes, inputMode.mode)
+ }
+ }
+
+ return modes
+}
+
+// ListInputMode returnes the isolated enabled input mode names as a list.
+func ListInputModeNames(mode uint32) []string {
+ modes := []string{}
+
+ for _, inputMode := range inputModes {
+ if mode&inputMode.mode > 0 {
+ modes = append(modes, inputMode.name)
+ }
+ }
+
+ return modes
+}
+
+// DescribeInputMode returns a string containing the names of each enabled input mode.
+func DescribeInputMode(mode uint32) string {
+ return strings.Join(ListInputModeNames(mode), "|")
+}
diff --git a/vendor/github.com/erikgeiser/coninput/read.go b/vendor/github.com/erikgeiser/coninput/read.go
new file mode 100644
index 00000000000..b2dd82f1fb2
--- /dev/null
+++ b/vendor/github.com/erikgeiser/coninput/read.go
@@ -0,0 +1,154 @@
+//go:build windows
+// +build windows
+
+package coninput
+
+import (
+ "fmt"
+ "syscall"
+ "unsafe"
+
+ "golang.org/x/sys/windows"
+)
+
+var (
+ modkernel32 = windows.NewLazySystemDLL("kernel32.dll")
+ procReadConsoleInputW = modkernel32.NewProc("ReadConsoleInputW")
+ procPeekConsoleInputW = modkernel32.NewProc("PeekConsoleInputW")
+ procGetNumberOfConsoleInputEvents = modkernel32.NewProc("GetNumberOfConsoleInputEvents")
+ procFlushConsoleInputBuffer = modkernel32.NewProc("FlushConsoleInputBuffer")
+)
+
+// NewStdinHandle is a shortcut for windows.GetStdHandle(windows.STD_INPUT_HANDLE).
+func NewStdinHandle() (windows.Handle, error) {
+ return windows.GetStdHandle(windows.STD_INPUT_HANDLE)
+}
+
+// WinReadConsoleInput is a thin wrapper around the Windows console API function
+// ReadConsoleInput (see
+// https://docs.microsoft.com/en-us/windows/console/readconsoleinput). In most
+// cases it is more practical to either use ReadConsoleInput or
+// ReadNConsoleInputs.
+func WinReadConsoleInput(consoleInput windows.Handle, buffer *InputRecord,
+ length uint32, numberOfEventsRead *uint32) error {
+ r, _, e := syscall.Syscall6(procReadConsoleInputW.Addr(), 4,
+ uintptr(consoleInput), uintptr(unsafe.Pointer(buffer)), uintptr(length),
+ uintptr(unsafe.Pointer(numberOfEventsRead)), 0, 0)
+ if r == 0 {
+ return error(e)
+ }
+
+ return nil
+}
+
+// ReadNConsoleInputs is a wrapper around ReadConsoleInput (see
+// https://docs.microsoft.com/en-us/windows/console/readconsoleinput) that
+// automates the event buffer allocation in oder to provide io.Reader-like
+// sematics. maxEvents must be greater than zero.
+func ReadNConsoleInputs(console windows.Handle, maxEvents uint32) ([]InputRecord, error) {
+ if maxEvents == 0 {
+ return nil, fmt.Errorf("maxEvents cannot be zero")
+ }
+
+ var inputRecords = make([]InputRecord, maxEvents)
+ n, err := ReadConsoleInput(console, inputRecords)
+
+ return inputRecords[:n], err
+}
+
+// ReadConsoleInput provides an ideomatic interface to the Windows console API
+// function ReadConsoleInput (see
+// https://docs.microsoft.com/en-us/windows/console/readconsoleinput). The size
+// of inputRecords must be greater than zero.
+func ReadConsoleInput(console windows.Handle, inputRecords []InputRecord) (uint32, error) {
+ if len(inputRecords) == 0 {
+ return 0, fmt.Errorf("size of input record buffer cannot be zero")
+ }
+
+ var read uint32
+ err := WinReadConsoleInput(console, &inputRecords[0], uint32(len(inputRecords)), &read)
+
+ return read, err
+}
+
+// WinPeekConsoleInput is a thin wrapper around the Windows console API function
+// PeekConsoleInput (see
+// https://docs.microsoft.com/en-us/windows/console/peekconsoleinput). In most
+// cases it is more practical to either use PeekConsoleInput or
+// PeekNConsoleInputs.
+func WinPeekConsoleInput(consoleInput windows.Handle, buffer *InputRecord,
+ length uint32, numberOfEventsRead *uint32) error {
+ r, _, e := syscall.Syscall6(procPeekConsoleInputW.Addr(), 4,
+ uintptr(consoleInput), uintptr(unsafe.Pointer(buffer)), uintptr(length),
+ uintptr(unsafe.Pointer(numberOfEventsRead)), 0, 0)
+ if r == 0 {
+ return error(e)
+ }
+
+ return nil
+
+}
+
+// PeekNConsoleInputs is a wrapper around PeekConsoleInput (see
+// https://docs.microsoft.com/en-us/windows/console/peekconsoleinput) that
+// automates the event buffer allocation in oder to provide io.Reader-like
+// sematics. maxEvents must be greater than zero.
+func PeekNConsoleInputs(console windows.Handle, maxEvents uint32) ([]InputRecord, error) {
+ if maxEvents == 0 {
+ return nil, fmt.Errorf("maxEvents cannot be zero")
+ }
+
+ var inputRecords = make([]InputRecord, maxEvents)
+ n, err := PeekConsoleInput(console, inputRecords)
+
+ return inputRecords[:n], err
+}
+
+// PeekConsoleInput provides an ideomatic interface to the Windows console API
+// function PeekConsoleInput (see
+// https://docs.microsoft.com/en-us/windows/console/peekconsoleinput). The size
+// of inputRecords must be greater than zero.
+func PeekConsoleInput(console windows.Handle, inputRecords []InputRecord) (uint32, error) {
+ if len(inputRecords) == 0 {
+ return 0, fmt.Errorf("size of input record buffer cannot be zero")
+ }
+
+ var read uint32
+
+ err := WinPeekConsoleInput(console, &inputRecords[0], uint32(len(inputRecords)), &read)
+
+ return read, err
+}
+
+// WinGetNumberOfConsoleInputEvents provides an ideomatic interface to the
+// Windows console API function GetNumberOfConsoleInputEvents (see
+// https://docs.microsoft.com/en-us/windows/console/getnumberofconsoleinputevents).
+func WinGetNumberOfConsoleInputEvents(consoleInput windows.Handle, numberOfEvents *uint32) error {
+ r, _, e := syscall.Syscall6(procGetNumberOfConsoleInputEvents.Addr(), 2,
+ uintptr(consoleInput), uintptr(unsafe.Pointer(numberOfEvents)), 0,
+ 0, 0, 0)
+ if r == 0 {
+ return error(e)
+ }
+
+ return nil
+}
+
+// GetNumberOfConsoleInputEvents provides an ideomatic interface to the Windows
+// console API function GetNumberOfConsoleInputEvents (see
+// https://docs.microsoft.com/en-us/windows/console/getnumberofconsoleinputevents).
+func GetNumberOfConsoleInputEvents(console windows.Handle) (uint32, error) {
+ var nEvents uint32
+ err := WinGetNumberOfConsoleInputEvents(console, &nEvents)
+
+ return nEvents, err
+}
+
+func FlushConsoleInputBuffer(consoleInput windows.Handle) error {
+ r, _, e := syscall.Syscall(procFlushConsoleInputBuffer.Addr(), 1, uintptr(consoleInput), 0, 0)
+ if r == 0 {
+ return error(e)
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/erikgeiser/coninput/records.go b/vendor/github.com/erikgeiser/coninput/records.go
new file mode 100644
index 00000000000..cccf7fbf8bb
--- /dev/null
+++ b/vendor/github.com/erikgeiser/coninput/records.go
@@ -0,0 +1,486 @@
+package coninput
+
+import (
+ "encoding/binary"
+ "fmt"
+ "strconv"
+ "strings"
+)
+
+const (
+ maxEventSize = 16
+ wordPaddingBytes = 2
+)
+
+// EventType denots the type of an event
+type EventType uint16
+
+// EventUnion is the union data type that contains the data for any event.
+type EventUnion [maxEventSize]byte
+
+// InputRecord corresponds to the INPUT_RECORD structure from the Windows
+// console API (see
+// https://docs.microsoft.com/en-us/windows/console/input-record-str).
+type InputRecord struct {
+ // EventType specifies the type of event that helt in Event.
+ EventType EventType
+
+ // Padding of the 16-bit EventType to a whole 32-bit dword.
+ _ [wordPaddingBytes]byte
+
+ // Event holds the actual event data. Use Unrap to access it as its
+ // respective event type.
+ Event EventUnion
+}
+
+// String implements fmt.Stringer for InputRecord.
+func (ir InputRecord) String() string {
+ return ir.Unwrap().String()
+}
+
+// Unwrap parses the event data into an EventRecord of the respective event
+// type. The data in the returned EventRecord does not contain any references to
+// the passed InputRecord.
+func (ir InputRecord) Unwrap() EventRecord {
+ switch ir.EventType {
+ case FocusEventType:
+ return FocusEventRecord{SetFocus: ir.Event[0] > 0}
+ case KeyEventType:
+ return KeyEventRecord{
+ KeyDown: binary.LittleEndian.Uint32(ir.Event[0:4]) > 0,
+ RepeatCount: binary.LittleEndian.Uint16(ir.Event[4:6]),
+ VirtualKeyCode: VirtualKeyCode(binary.LittleEndian.Uint16(ir.Event[6:8])),
+ VirtualScanCode: VirtualKeyCode(binary.LittleEndian.Uint16(ir.Event[8:10])),
+ Char: rune(binary.LittleEndian.Uint16(ir.Event[10:12])),
+ ControlKeyState: ControlKeyState(binary.LittleEndian.Uint32(ir.Event[12:16])),
+ }
+ case MouseEventType:
+ m := MouseEventRecord{
+ MousePositon: Coord{
+ X: binary.LittleEndian.Uint16(ir.Event[0:2]),
+ Y: binary.LittleEndian.Uint16(ir.Event[2:4]),
+ },
+ ButtonState: ButtonState(binary.LittleEndian.Uint32(ir.Event[4:8])),
+ ControlKeyState: ControlKeyState(binary.LittleEndian.Uint32(ir.Event[8:12])),
+ EventFlags: EventFlags(binary.LittleEndian.Uint32(ir.Event[12:16])),
+ }
+
+ if (m.EventFlags&MOUSE_WHEELED > 0) || (m.EventFlags&MOUSE_HWHEELED > 0) {
+ if int16(highWord(uint32(m.ButtonState))) > 0 {
+ m.WheelDirection = 1
+ } else {
+ m.WheelDirection = -1
+ }
+ }
+
+ return m
+ case WindowBufferSizeEventType:
+ return WindowBufferSizeEventRecord{
+ Size: Coord{
+ X: binary.LittleEndian.Uint16(ir.Event[0:2]),
+ Y: binary.LittleEndian.Uint16(ir.Event[2:4]),
+ },
+ }
+ case MenuEventType:
+ return MenuEventRecord{
+ CommandID: binary.LittleEndian.Uint32(ir.Event[0:4]),
+ }
+ default:
+ return &UnknownEvent{InputRecord: ir}
+ }
+}
+
+// EventRecord represents one of the following event types:
+// TypeFocusEventRecord, TypeKeyEventRecord, TypeMouseEventRecord,
+// TypeWindowBufferSizeEvent, TypeMenuEventRecord and UnknownEvent.
+type EventRecord interface {
+ Type() string
+ fmt.Stringer
+}
+
+// FocusEventType is the event type for a FocusEventRecord (see
+// https://docs.microsoft.com/en-us/windows/console/input-record-str).
+const FocusEventType EventType = 0x0010
+
+// FocusEventRecord represent the FOCUS_EVENT_RECORD structure from the Windows
+// console API (see
+// https://docs.microsoft.com/en-us/windows/console/focus-event-record-str).
+// These events are used internally by the Windows console API and should be
+// ignored.
+type FocusEventRecord struct {
+ // SetFocus is reserved and should not be used.
+ SetFocus bool
+}
+
+// Ensure that FocusEventRecord satisfies EventRecord interface.
+var _ EventRecord = FocusEventRecord{}
+
+// Type ensures that FocusEventRecord satisfies EventRecord interface.
+func (e FocusEventRecord) Type() string { return "FocusEvent" }
+
+// String ensures that FocusEventRecord satisfies EventRecord and fmt.Stringer
+// interfaces.
+func (e FocusEventRecord) String() string { return fmt.Sprintf("%s[%v]", e.Type(), e.SetFocus) }
+
+// KeyEventType is the event type for a KeyEventRecord (see
+// https://docs.microsoft.com/en-us/windows/console/input-record-str).
+const KeyEventType EventType = 0x0001
+
+// KeyEventRecord represent the KEY_EVENT_RECORD structure from the Windows
+// console API (see
+// https://docs.microsoft.com/en-us/windows/console/key-event-record-str).
+type KeyEventRecord struct {
+ // KeyDown specified whether the key is pressed or released.
+ KeyDown bool
+
+ // RepeatCount indicates that a key is being held down. For example, when a
+ // key is held down, five events with RepeatCount equal to 1 may be
+ // generated, one event with RepeatCount equal to 5, or multiple events
+ // with RepeatCount greater than or equal to 1.
+ RepeatCount uint16
+
+ // VirtualKeyCode identifies the given key in a device-independent manner
+ // (see
+ // https://docs.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes).
+ VirtualKeyCode VirtualKeyCode
+
+ // VirtualScanCode represents the device-dependent value generated by the
+ // keyboard hardware.
+ VirtualScanCode VirtualKeyCode
+
+ // Char is the character that corresponds to the pressed key. Char can be
+ // zero for some keys.
+ Char rune
+
+ //ControlKeyState holds the state of the control keys.
+ ControlKeyState ControlKeyState
+}
+
+// Ensure that KeyEventRecord satisfies EventRecord interface.
+var _ EventRecord = KeyEventRecord{}
+
+// Type ensures that KeyEventRecord satisfies EventRecord interface.
+func (e KeyEventRecord) Type() string { return "KeyEvent" }
+
+// String ensures that KeyEventRecord satisfies EventRecord and fmt.Stringer
+// interfaces.
+func (e KeyEventRecord) String() string {
+ infos := []string{}
+
+ repeat := ""
+ if e.RepeatCount > 1 {
+ repeat = "x" + strconv.Itoa(int(e.RepeatCount))
+ }
+
+ infos = append(infos, fmt.Sprintf("%q%s", e.Char, repeat))
+
+ direction := "up"
+ if e.KeyDown {
+ direction = "down"
+ }
+
+ infos = append(infos, direction)
+
+ if e.ControlKeyState != NO_CONTROL_KEY {
+ infos = append(infos, e.ControlKeyState.String())
+ }
+
+ infos = append(infos, fmt.Sprintf("KeyCode: %d", e.VirtualKeyCode))
+ infos = append(infos, fmt.Sprintf("ScanCode: %d", e.VirtualScanCode))
+
+ return fmt.Sprintf("%s[%s]", e.Type(), strings.Join(infos, ", "))
+}
+
+// MenuEventType is the event type for a MenuEventRecord (see
+// https://docs.microsoft.com/en-us/windows/console/input-record-str).
+const MenuEventType EventType = 0x0008
+
+// MenuEventRecord represent the MENU_EVENT_RECORD structure from the Windows
+// console API (see
+// https://docs.microsoft.com/en-us/windows/console/menu-event-record-str).
+// These events are deprecated by the Windows console API and should be ignored.
+type MenuEventRecord struct {
+ CommandID uint32
+}
+
+// Ensure that MenuEventRecord satisfies EventRecord interface.
+var _ EventRecord = MenuEventRecord{}
+
+// Type ensures that MenuEventRecord satisfies EventRecord interface.
+func (e MenuEventRecord) Type() string { return "MenuEvent" }
+
+// String ensures that MenuEventRecord satisfies EventRecord and fmt.Stringer
+// interfaces.
+func (e MenuEventRecord) String() string { return fmt.Sprintf("MenuEvent[%d]", e.CommandID) }
+
+// MouseEventType is the event type for a MouseEventRecord (see
+// https://docs.microsoft.com/en-us/windows/console/input-record-str).
+const MouseEventType EventType = 0x0002
+
+// MouseEventRecord represent the MOUSE_EVENT_RECORD structure from the Windows
+// console API (see
+// https://docs.microsoft.com/en-us/windows/console/mouse-event-record-str).
+type MouseEventRecord struct {
+ // MousePosition contains the location of the cursor, in terms of the
+ // console screen buffer's character-cell coordinates.
+ MousePositon Coord
+
+ // ButtonState holds the status of the mouse buttons.
+ ButtonState ButtonState
+
+ // ControlKeyState holds the state of the control keys.
+ ControlKeyState ControlKeyState
+
+ // EventFlags specify tge type of mouse event.
+ EventFlags EventFlags
+
+ // WheelDirection specified the direction in which the mouse wheel is
+ // spinning when EventFlags contains MOUSE_HWHEELED or MOUSE_WHEELED. When
+ // the event flags specify MOUSE_WHEELED it is 1 if the wheel rotated
+ // forward (away from the user) or -1 when it rotates backwards. When
+ // MOUSE_HWHEELED is specified it is 1 when the wheel rotates right and -1
+ // when it rotates left. When the EventFlags do not indicate a mouse wheel
+ // event it is 0.
+ WheelDirection int
+}
+
+// Ensure that MouseEventRecord satisfies EventRecord interface.
+var _ EventRecord = MouseEventRecord{}
+
+func (e MouseEventRecord) WheelDirectionName() string {
+ if e.EventFlags&MOUSE_WHEELED > 0 {
+ if e.WheelDirection > 0 {
+ return "Forward"
+ }
+
+ return "Backward"
+ } else if e.EventFlags&MOUSE_HWHEELED > 0 {
+ if e.WheelDirection > 0 {
+ return "Right"
+ }
+
+ return "Left"
+ }
+
+ return ""
+}
+
+// Type ensures that MouseEventRecord satisfies EventRecord interface.
+func (e MouseEventRecord) Type() string { return "MouseEvent" }
+
+// String ensures that MouseEventRecord satisfies EventRecord and fmt.Stringer
+// interfaces.
+func (e MouseEventRecord) String() string {
+ infos := []string{e.MousePositon.String()}
+
+ if e.ButtonState&0xFF != 0 {
+ infos = append(infos, e.ButtonState.String())
+ }
+
+ eventDescription := e.EventFlags.String()
+
+ wheelDirection := e.WheelDirectionName()
+ if wheelDirection != "" {
+ eventDescription += "(" + wheelDirection + ")"
+ }
+
+ infos = append(infos, eventDescription)
+
+ if e.ControlKeyState != NO_CONTROL_KEY {
+ infos = append(infos, e.ControlKeyState.String())
+ }
+
+ return fmt.Sprintf("%s[%s]", e.Type(), strings.Join(infos, ", "))
+}
+
+// WindowBufferSizeEventType is the event type for a WindowBufferSizeEventRecord
+// (see https://docs.microsoft.com/en-us/windows/console/input-record-str).
+const WindowBufferSizeEventType EventType = 0x0004
+
+// WindowBufferSizeEventRecord represent the WINDOW_BUFFER_SIZE_RECORD structure
+// from the Windows console API (see
+// https://docs.microsoft.com/en-us/windows/console/window-buffer-size-record-str).
+type WindowBufferSizeEventRecord struct {
+ // Size contains the size of the console screen buffer, in character cell columns and rows.
+ Size Coord
+}
+
+// Ensure that WindowBufferSizeEventRecord satisfies EventRecord interface.
+var _ EventRecord = WindowBufferSizeEventRecord{}
+
+// Type ensures that WindowBufferSizeEventRecord satisfies EventRecord interface.
+func (e WindowBufferSizeEventRecord) Type() string { return "WindowBufferSizeEvent" }
+
+// String ensures that WindowBufferSizeEventRecord satisfies EventRecord and fmt.Stringer
+// interfaces.
+func (e WindowBufferSizeEventRecord) String() string {
+ return fmt.Sprintf("WindowBufferSizeEvent[%s]", e.Size)
+}
+
+// UnknownEvent is generated when the event type does not match one of the
+// following types: TypeFocusEventRecord, TypeKeyEventRecord,
+// TypeMouseEventRecord, TypeWindowBufferSizeEvent, TypeMenuEventRecord and
+// UnknownEvent.
+type UnknownEvent struct {
+ InputRecord
+}
+
+// Ensure that UnknownEvent satisfies EventRecord interface.
+var _ EventRecord = UnknownEvent{}
+
+// Type ensures that UnknownEvent satisfies EventRecord interface.
+func (e UnknownEvent) Type() string { return "UnknownEvent" }
+
+// String ensures that UnknownEvent satisfies EventRecord and fmt.Stringer
+// interfaces.
+func (e UnknownEvent) String() string {
+ return fmt.Sprintf("%s[Type: %d, Data: %v]", e.Type(), e.InputRecord.EventType, e.InputRecord.Event[:])
+}
+
+// Coord represent the COORD structure from the Windows
+// console API (see https://docs.microsoft.com/en-us/windows/console/coord-str).
+type Coord struct {
+ // X is the horizontal coordinate or column value. The units depend on the function call.
+ X uint16
+ // Y is the vertical coordinate or row value. The units depend on the function call.
+ Y uint16
+}
+
+// String ensures that Coord satisfies the fmt.Stringer interface.
+func (c Coord) String() string {
+ return fmt.Sprintf("(%d, %d)", c.X, c.Y)
+}
+
+// ButtonState holds the state of the mouse buttons (see
+// https://docs.microsoft.com/en-us/windows/console/mouse-event-record-str).
+type ButtonState uint32
+
+func (bs ButtonState) Contains(state ButtonState) bool {
+ return bs&state > 0
+}
+
+// String ensures that ButtonState satisfies the fmt.Stringer interface.
+func (bs ButtonState) String() string {
+ switch {
+ case bs&FROM_LEFT_1ST_BUTTON_PRESSED > 0:
+ return "Left"
+ case bs&FROM_LEFT_2ND_BUTTON_PRESSED > 0:
+ return "2"
+ case bs&FROM_LEFT_3RD_BUTTON_PRESSED > 0:
+ return "3"
+ case bs&FROM_LEFT_4TH_BUTTON_PRESSED > 0:
+ return "4"
+ case bs&RIGHTMOST_BUTTON_PRESSED > 0:
+ return "Right"
+ case bs&0xFF == 0:
+ return "No Button"
+ default:
+ return fmt.Sprintf("Unknown(%d)", bs)
+ }
+}
+
+func (bs ButtonState) IsReleased() bool {
+ return bs&0xff > 0
+}
+
+// Valid values for ButtonState.
+const (
+ FROM_LEFT_1ST_BUTTON_PRESSED ButtonState = 0x0001
+ RIGHTMOST_BUTTON_PRESSED ButtonState = 0x0002
+ FROM_LEFT_2ND_BUTTON_PRESSED ButtonState = 0x0004
+ FROM_LEFT_3RD_BUTTON_PRESSED ButtonState = 0x0008
+ FROM_LEFT_4TH_BUTTON_PRESSED ButtonState = 0x0010
+)
+
+// ControlKeyState holds the state of the control keys for key and mouse events
+// (see https://docs.microsoft.com/en-us/windows/console/key-event-record-str
+// and https://docs.microsoft.com/en-us/windows/console/mouse-event-record-str).
+type ControlKeyState uint32
+
+func (cks ControlKeyState) Contains(state ControlKeyState) bool {
+ return cks&state > 0
+}
+
+// Valid values for ControlKeyState.
+const (
+ CAPSLOCK_ON ControlKeyState = 0x0080
+ ENHANCED_KEY ControlKeyState = 0x0100
+ LEFT_ALT_PRESSED ControlKeyState = 0x0002
+ LEFT_CTRL_PRESSED ControlKeyState = 0x0008
+ NUMLOCK_ON ControlKeyState = 0x0020
+ RIGHT_ALT_PRESSED ControlKeyState = 0x0001
+ RIGHT_CTRL_PRESSED ControlKeyState = 0x0004
+ SCROLLLOCK_ON ControlKeyState = 0x0040
+ SHIFT_PRESSED ControlKeyState = 0x0010
+ NO_CONTROL_KEY ControlKeyState = 0x0000
+)
+
+// String ensures that ControlKeyState satisfies the fmt.Stringer interface.
+func (cks ControlKeyState) String() string {
+ controlKeys := []string{}
+
+ switch {
+ case cks&CAPSLOCK_ON > 0:
+ controlKeys = append(controlKeys, "CapsLock")
+ case cks&ENHANCED_KEY > 0:
+ controlKeys = append(controlKeys, "Enhanced")
+ case cks&LEFT_ALT_PRESSED > 0:
+ controlKeys = append(controlKeys, "Alt")
+ case cks&LEFT_CTRL_PRESSED > 0:
+ controlKeys = append(controlKeys, "CTRL")
+ case cks&NUMLOCK_ON > 0:
+ controlKeys = append(controlKeys, "NumLock")
+ case cks&RIGHT_ALT_PRESSED > 0:
+ controlKeys = append(controlKeys, "RightAlt")
+ case cks&RIGHT_CTRL_PRESSED > 0:
+ controlKeys = append(controlKeys, "RightCTRL")
+ case cks&SCROLLLOCK_ON > 0:
+ controlKeys = append(controlKeys, "ScrollLock")
+ case cks&SHIFT_PRESSED > 0:
+ controlKeys = append(controlKeys, "Shift")
+ case cks == NO_CONTROL_KEY:
+ default:
+ return fmt.Sprintf("Unknown(%d)", cks)
+ }
+
+ return strings.Join(controlKeys, ",")
+}
+
+// EventFlags specifies the type of a mouse event (see
+// https://docs.microsoft.com/en-us/windows/console/mouse-event-record-str).
+type EventFlags uint32
+
+// String ensures that EventFlags satisfies the fmt.Stringer interface.
+func (ef EventFlags) String() string {
+ switch {
+ case ef&DOUBLE_CLICK > 0:
+ return "DoubleClick"
+ case ef&MOUSE_WHEELED > 0:
+ return "Wheeled"
+ case ef&MOUSE_MOVED > 0:
+ return "Moved"
+ case ef&MOUSE_HWHEELED > 0:
+ return "HWheeld"
+ case ef == CLICK:
+ return "Click"
+ default:
+ return fmt.Sprintf("Unknown(%d)", ef)
+ }
+}
+
+func (ef EventFlags) Contains(flag EventFlags) bool {
+ return ef&flag > 0
+}
+
+// Valid values for EventFlags.
+const (
+ CLICK EventFlags = 0x0000
+ MOUSE_MOVED EventFlags = 0x0001
+ DOUBLE_CLICK EventFlags = 0x0002
+ MOUSE_WHEELED EventFlags = 0x0004
+ MOUSE_HWHEELED EventFlags = 0x0008
+)
+
+func highWord(data uint32) uint16 {
+ return uint16((data & 0xFFFF0000) >> 16)
+}
diff --git a/vendor/github.com/mattn/go-localereader/README.md b/vendor/github.com/mattn/go-localereader/README.md
new file mode 100644
index 00000000000..9e109532789
--- /dev/null
+++ b/vendor/github.com/mattn/go-localereader/README.md
@@ -0,0 +1,23 @@
+# go-localereader
+
+CodePage decoder for Windows
+
+## Usage
+
+```
+io.Copy(os.Stdout, localereader.NewAcpReader(bytes.Reader(bytesSjis)))
+```
+
+## Installation
+
+```
+$ go get github.com/mattn/go-localereader
+```
+
+## License
+
+MIT
+
+## Author
+
+Yasuhiro Matsumoto (a.k.a. mattn)
diff --git a/vendor/github.com/mattn/go-localereader/localereader.go b/vendor/github.com/mattn/go-localereader/localereader.go
new file mode 100644
index 00000000000..47a31375ee3
--- /dev/null
+++ b/vendor/github.com/mattn/go-localereader/localereader.go
@@ -0,0 +1,19 @@
+package localereader
+
+import (
+ "bytes"
+ "io"
+)
+
+func NewReader(r io.Reader) io.Reader {
+ return newReader(r)
+}
+
+func UTF8(b []byte) ([]byte, error) {
+ var buf bytes.Buffer
+ n, err := io.Copy(&buf, newReader(bytes.NewReader(b)))
+ if err != nil {
+ return nil, err
+ }
+ return buf.Bytes()[:n], nil
+}
diff --git a/vendor/github.com/mattn/go-localereader/localereader_unix.go b/vendor/github.com/mattn/go-localereader/localereader_unix.go
new file mode 100644
index 00000000000..d85e12e400c
--- /dev/null
+++ b/vendor/github.com/mattn/go-localereader/localereader_unix.go
@@ -0,0 +1,11 @@
+// +build !windows
+
+package localereader
+
+import (
+ "io"
+)
+
+func newReader(r io.Reader) io.Reader {
+ return r
+}
diff --git a/vendor/github.com/mattn/go-localereader/localereader_windows.go b/vendor/github.com/mattn/go-localereader/localereader_windows.go
new file mode 100644
index 00000000000..57c238fe806
--- /dev/null
+++ b/vendor/github.com/mattn/go-localereader/localereader_windows.go
@@ -0,0 +1,85 @@
+// +build windows
+
+package localereader
+
+import (
+ "io"
+ "syscall"
+ "unicode/utf8"
+ "unsafe"
+
+ "golang.org/x/text/transform"
+)
+
+const (
+ CP_ACP = 0
+ MB_ERR_INVALID_CHARS = 8
+)
+
+var (
+ modkernel32 = syscall.NewLazyDLL("kernel32.dll")
+ procMultiByteToWideChar = modkernel32.NewProc("MultiByteToWideChar")
+ procIsDBCSLeadByte = modkernel32.NewProc("IsDBCSLeadByte")
+)
+
+type codepageDecoder struct {
+ transform.NopResetter
+
+ cp int
+}
+
+func (codepageDecoder) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+ r, size := rune(0), 0
+loop:
+ for ; nSrc < len(src); nSrc += size {
+ switch c0 := src[nSrc]; {
+ case c0 < utf8.RuneSelf:
+ r, size = rune(c0), 1
+
+ default:
+ br, _, _ := procIsDBCSLeadByte.Call(uintptr(src[nSrc]))
+ if br == 0 {
+ r = rune(src[nSrc])
+ size = 1
+ break
+ }
+ if nSrc >= len(src)-1 {
+ r = rune(src[nSrc])
+ size = 1
+ break
+ }
+ n, _, _ := procMultiByteToWideChar.Call(CP_ACP, 0, uintptr(unsafe.Pointer(&src[nSrc])), uintptr(2), uintptr(0), 0)
+ if n <= 0 {
+ err = syscall.GetLastError()
+ break
+ }
+ var us [1]uint16
+ rc, _, _ := procMultiByteToWideChar.Call(CP_ACP, 0, uintptr(unsafe.Pointer(&src[nSrc])), uintptr(2), uintptr(unsafe.Pointer(&us[0])), 1)
+ if rc == 0 {
+ size = 1
+ break
+ }
+ r = rune(us[0])
+ size = 2
+ }
+ if nDst+utf8.RuneLen(r) > len(dst) {
+ err = transform.ErrShortDst
+ break loop
+ }
+ nDst += utf8.EncodeRune(dst[nDst:], r)
+ }
+ return nDst, nSrc, err
+
+}
+
+func newReader(r io.Reader) io.Reader {
+ return transform.NewReader(r, NewAcpDecoder())
+}
+
+func NewCodePageDecoder(cp int) transform.Transformer {
+ return &codepageDecoder{cp: cp}
+}
+
+func NewAcpDecoder() transform.Transformer {
+ return &codepageDecoder{cp: CP_ACP}
+}
diff --git a/vendor/github.com/muesli/ansi/.gitignore b/vendor/github.com/muesli/ansi/.gitignore
new file mode 100644
index 00000000000..66fd13c903c
--- /dev/null
+++ b/vendor/github.com/muesli/ansi/.gitignore
@@ -0,0 +1,15 @@
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
diff --git a/vendor/github.com/muesli/ansi/.golangci.yml b/vendor/github.com/muesli/ansi/.golangci.yml
new file mode 100644
index 00000000000..cd299e2bb71
--- /dev/null
+++ b/vendor/github.com/muesli/ansi/.golangci.yml
@@ -0,0 +1,27 @@
+run:
+ tests: false
+
+issues:
+ max-issues-per-linter: 0
+ max-same-issues: 0
+
+linters:
+ enable:
+ - bodyclose
+ - dupl
+ - exportloopref
+ - goconst
+ - godot
+ - godox
+ - goimports
+ - golint
+ - goprintffuncname
+ - gosec
+ - ifshort
+ - misspell
+ - prealloc
+ - rowserrcheck
+ - sqlclosecheck
+ - unconvert
+ - unparam
+ - whitespace
diff --git a/vendor/github.com/muesli/ansi/LICENSE b/vendor/github.com/muesli/ansi/LICENSE
new file mode 100644
index 00000000000..bd9cdc6f766
--- /dev/null
+++ b/vendor/github.com/muesli/ansi/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Christian Muehlhaeuser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/github.com/muesli/ansi/README.md b/vendor/github.com/muesli/ansi/README.md
new file mode 100644
index 00000000000..f9d0fe9aafe
--- /dev/null
+++ b/vendor/github.com/muesli/ansi/README.md
@@ -0,0 +1,31 @@
+# ansi
+
+[](https://github.com/muesli/ansi/releases)
+[](https://github.com/muesli/ansi/actions)
+[](https://coveralls.io/github/muesli/ansi?branch=master)
+[](https://goreportcard.com/report/muesli/ansi)
+[](https://pkg.go.dev/github.com/muesli/ansi)
+
+Raw ANSI sequence helpers
+
+## ANSI Writer
+
+```go
+import "github.com/muesli/ansi"
+
+w := ansi.Writer{Forward: os.Stdout}
+w.Write([]byte("\x1b[31mHello, world!\x1b[0m"))
+w.Close()
+```
+
+## Compressor
+
+The ANSI compressor eliminates unnecessary/redundant ANSI sequences.
+
+```go
+import "github.com/muesli/ansi/compressor"
+
+w := compressor.Writer{Forward: os.Stdout}
+w.Write([]byte("\x1b[31mHello, world!\x1b[0m"))
+w.Close()
+```
diff --git a/vendor/github.com/muesli/ansi/ansi.go b/vendor/github.com/muesli/ansi/ansi.go
new file mode 100644
index 00000000000..f3d0700af91
--- /dev/null
+++ b/vendor/github.com/muesli/ansi/ansi.go
@@ -0,0 +1,7 @@
+package ansi
+
+const Marker = '\x1B'
+
+func IsTerminator(c rune) bool {
+ return (c >= 0x40 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a)
+}
diff --git a/vendor/github.com/muesli/ansi/buffer.go b/vendor/github.com/muesli/ansi/buffer.go
new file mode 100644
index 00000000000..471bcaf7855
--- /dev/null
+++ b/vendor/github.com/muesli/ansi/buffer.go
@@ -0,0 +1,40 @@
+package ansi
+
+import (
+ "bytes"
+
+ "github.com/mattn/go-runewidth"
+)
+
+// Buffer is a buffer aware of ANSI escape sequences.
+type Buffer struct {
+ bytes.Buffer
+}
+
+// PrintableRuneWidth returns the cell width of all printable runes in the
+// buffer.
+func (w Buffer) PrintableRuneWidth() int {
+ return PrintableRuneWidth(w.String())
+}
+
+// PrintableRuneWidth returns the cell width of the given string.
+func PrintableRuneWidth(s string) int {
+ var n int
+ var ansi bool
+
+ for _, c := range s {
+ if c == Marker {
+ // ANSI escape sequence
+ ansi = true
+ } else if ansi {
+ if IsTerminator(c) {
+ // ANSI sequence terminated
+ ansi = false
+ }
+ } else {
+ n += runewidth.RuneWidth(c)
+ }
+ }
+
+ return n
+}
diff --git a/vendor/github.com/muesli/ansi/compressor/writer.go b/vendor/github.com/muesli/ansi/compressor/writer.go
new file mode 100644
index 00000000000..98c54829b27
--- /dev/null
+++ b/vendor/github.com/muesli/ansi/compressor/writer.go
@@ -0,0 +1,132 @@
+package compressor
+
+import (
+ "bytes"
+ "io"
+ "unicode/utf8"
+
+ "github.com/muesli/ansi"
+)
+
+type Writer struct {
+ Forward io.Writer
+
+ ansi bool
+ ansiseq bytes.Buffer
+ lastseq bytes.Buffer
+ prevlastseq bytes.Buffer
+ resetreq bool
+ runeBuf []byte
+ compressed int
+ uncompressed int
+}
+
+// Bytes is shorthand for declaring a new default compressor instance,
+// used to immediately compress a byte slice.
+func Bytes(b []byte) []byte {
+ var buf bytes.Buffer
+ f := Writer{
+ Forward: &buf,
+ }
+ _, _ = f.Write(b)
+ _ = f.Close()
+
+ return buf.Bytes()
+}
+
+// String is shorthand for declaring a new default compressor instance,
+// used to immediately compress a string.
+func String(s string) string {
+ return string(Bytes([]byte(s)))
+}
+
+// Write is used to write content to the ANSI buffer.
+func (w *Writer) Write(b []byte) (int, error) {
+ w.uncompressed += len(b)
+
+ for _, c := range string(b) {
+ if c == ansi.Marker {
+ // ANSI escape sequence
+ w.ansi = true
+ _, _ = w.ansiseq.WriteRune(c)
+ } else if w.ansi {
+ _, _ = w.ansiseq.WriteRune(c)
+ if ansi.IsTerminator(c) {
+ // ANSI sequence terminated
+ w.ansi = false
+
+ terminated := false
+ if bytes.HasSuffix(w.ansiseq.Bytes(), []byte("[0m")) {
+ // reset sequence
+ w.prevlastseq.Reset()
+ w.prevlastseq.Write(w.lastseq.Bytes())
+
+ w.lastseq.Reset()
+ terminated = true
+ w.resetreq = true
+ } else if c == 'm' {
+ // color code
+ _, _ = w.lastseq.Write(w.ansiseq.Bytes())
+ }
+
+ if !terminated {
+ // did we reset the sequence just to restore it again?
+ if bytes.Equal(w.ansiseq.Bytes(), w.prevlastseq.Bytes()) {
+ w.resetreq = false
+ w.ansiseq.Reset()
+ }
+
+ w.prevlastseq.Reset()
+
+ if w.resetreq {
+ w.ResetAnsi()
+ }
+
+ _, _ = w.Forward.Write(w.ansiseq.Bytes())
+ w.compressed += w.ansiseq.Len()
+ }
+
+ w.ansiseq.Reset()
+ }
+ } else {
+ if w.resetreq {
+ w.ResetAnsi()
+ }
+
+ _, err := w.writeRune(c)
+ if err != nil {
+ return 0, err
+ }
+ }
+ }
+
+ return len(b), nil
+}
+
+func (w *Writer) writeRune(r rune) (int, error) {
+ if w.runeBuf == nil {
+ w.runeBuf = make([]byte, utf8.UTFMax)
+ }
+ n := utf8.EncodeRune(w.runeBuf, r)
+ w.compressed += n
+ return w.Forward.Write(w.runeBuf[:n])
+}
+
+// Close finishes the compression operation. Always call it before trying to
+// retrieve the final result.
+func (w *Writer) Close() error {
+ if w.resetreq {
+ w.ResetAnsi()
+ }
+
+ // log.Println("Written uncompressed: ", w.uncompressed)
+ // log.Println("Written compressed: ", w.compressed)
+
+ return nil
+}
+
+func (w *Writer) ResetAnsi() {
+ w.prevlastseq.Reset()
+ _, _ = w.Forward.Write([]byte("\x1b[0m"))
+ w.resetreq = false
+}
diff --git a/vendor/github.com/muesli/ansi/writer.go b/vendor/github.com/muesli/ansi/writer.go
new file mode 100644
index 00000000000..a6aaa1ec677
--- /dev/null
+++ b/vendor/github.com/muesli/ansi/writer.go
@@ -0,0 +1,76 @@
+package ansi
+
+import (
+ "bytes"
+ "io"
+ "unicode/utf8"
+)
+
+type Writer struct {
+ Forward io.Writer
+
+ ansi bool
+ ansiseq bytes.Buffer
+ lastseq bytes.Buffer
+ seqchanged bool
+ runeBuf []byte
+}
+
+// Write is used to write content to the ANSI buffer.
+func (w *Writer) Write(b []byte) (int, error) {
+ for _, c := range string(b) {
+ if c == Marker {
+ // ANSI escape sequence
+ w.ansi = true
+ w.seqchanged = true
+ _, _ = w.ansiseq.WriteRune(c)
+ } else if w.ansi {
+ _, _ = w.ansiseq.WriteRune(c)
+ if IsTerminator(c) {
+ // ANSI sequence terminated
+ w.ansi = false
+
+ if bytes.HasSuffix(w.ansiseq.Bytes(), []byte("[0m")) {
+ // reset sequence
+ w.lastseq.Reset()
+ w.seqchanged = false
+ } else if c == 'm' {
+ // color code
+ _, _ = w.lastseq.Write(w.ansiseq.Bytes())
+ }
+
+ _, _ = w.ansiseq.WriteTo(w.Forward)
+ }
+ } else {
+ _, err := w.writeRune(c)
+ if err != nil {
+ return 0, err
+ }
+ }
+ }
+
+ return len(b), nil
+}
+
+func (w *Writer) writeRune(r rune) (int, error) {
+ if w.runeBuf == nil {
+ w.runeBuf = make([]byte, utf8.UTFMax)
+ }
+ n := utf8.EncodeRune(w.runeBuf, r)
+ return w.Forward.Write(w.runeBuf[:n])
+}
+
+func (w *Writer) LastSequence() string {
+ return w.lastseq.String()
+}
+
+func (w *Writer) ResetAnsi() {
+ if !w.seqchanged {
+ return
+ }
+ _, _ = w.Forward.Write([]byte("\x1b[0m"))
+}
+
+func (w *Writer) RestoreAnsi() {
+ _, _ = w.Forward.Write(w.lastseq.Bytes())
+}
diff --git a/vendor/github.com/muesli/cancelreader/.gitignore b/vendor/github.com/muesli/cancelreader/.gitignore
new file mode 100644
index 00000000000..66fd13c903c
--- /dev/null
+++ b/vendor/github.com/muesli/cancelreader/.gitignore
@@ -0,0 +1,15 @@
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
diff --git a/vendor/github.com/muesli/cancelreader/.golangci-soft.yml b/vendor/github.com/muesli/cancelreader/.golangci-soft.yml
new file mode 100644
index 00000000000..ef456e06059
--- /dev/null
+++ b/vendor/github.com/muesli/cancelreader/.golangci-soft.yml
@@ -0,0 +1,47 @@
+run:
+ tests: false
+
+issues:
+ include:
+ - EXC0001
+ - EXC0005
+ - EXC0011
+ - EXC0012
+ - EXC0013
+
+ max-issues-per-linter: 0
+ max-same-issues: 0
+
+linters:
+ enable:
+ # - dupl
+ - exhaustive
+ # - exhaustivestruct
+ - goconst
+ - godot
+ - godox
+ - gomnd
+ - gomoddirectives
+ - goprintffuncname
+ - ifshort
+ # - lll
+ - misspell
+ - nakedret
+ - nestif
+ - noctx
+ - nolintlint
+ - prealloc
+ - wrapcheck
+
+ # disable default linters, they are already enabled in .golangci.yml
+ disable:
+ - deadcode
+ - errcheck
+ - gosimple
+ - govet
+ - ineffassign
+ - staticcheck
+ - structcheck
+ - typecheck
+ - unused
+ - varcheck
diff --git a/vendor/github.com/muesli/cancelreader/.golangci.yml b/vendor/github.com/muesli/cancelreader/.golangci.yml
new file mode 100644
index 00000000000..a5a91d0d913
--- /dev/null
+++ b/vendor/github.com/muesli/cancelreader/.golangci.yml
@@ -0,0 +1,29 @@
+run:
+ tests: false
+
+issues:
+ include:
+ - EXC0001
+ - EXC0005
+ - EXC0011
+ - EXC0012
+ - EXC0013
+
+ max-issues-per-linter: 0
+ max-same-issues: 0
+
+linters:
+ enable:
+ - bodyclose
+ - exportloopref
+ - goimports
+ - gosec
+ - nilerr
+ - predeclared
+ - revive
+ - rowserrcheck
+ - sqlclosecheck
+ - tparallel
+ - unconvert
+ - unparam
+ - whitespace
diff --git a/vendor/github.com/muesli/cancelreader/LICENSE b/vendor/github.com/muesli/cancelreader/LICENSE
new file mode 100644
index 00000000000..4b19b92d51f
--- /dev/null
+++ b/vendor/github.com/muesli/cancelreader/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Erik Geiser and Christian Muehlhaeuser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/github.com/muesli/cancelreader/README.md b/vendor/github.com/muesli/cancelreader/README.md
new file mode 100644
index 00000000000..83609fbc722
--- /dev/null
+++ b/vendor/github.com/muesli/cancelreader/README.md
@@ -0,0 +1,64 @@
+# CancelReader
+
+[](https://github.com/muesli/cancelreader/releases)
+[](https://pkg.go.dev/github.com/muesli/cancelreader)
+[](/LICENSE)
+[](https://github.com/muesli/cancelreader/actions)
+[](https://goreportcard.com/report/muesli/cancelreader)
+
+A cancelable reader for Go
+
+This package is based on the fantastic work of [Erik Geiser](https://github.com/erikgeiser)
+in Charm's [Bubble Tea](https://github.com/charmbracelet/bubbletea) framework.
+
+## Usage
+
+`NewReader` returns a reader with a `Cancel` function. If the input reader is a
+`File`, the cancel function can be used to interrupt a blocking `Read` call.
+In this case, the cancel function returns true if the call was canceled
+successfully. If the input reader is not a `File`, the cancel function does
+nothing and always returns false.
+
+```go
+r, err := cancelreader.NewReader(file)
+if err != nil {
+ // handle error
+ ...
+}
+
+// cancel after five seconds
+go func() {
+ time.Sleep(5 * time.Second)
+ r.Cancel()
+}()
+
+// keep reading
+for {
+ var buf [1024]byte
+ _, err := r.Read(buf[:])
+
+ if errors.Is(err, cancelreader.ErrCanceled) {
+ fmt.Println("canceled!")
+ break
+ }
+ if err != nil {
+ // handle other errors
+ ...
+ }
+
+ // handle data
+ ...
+}
+```
+
+## Implementations
+
+- The Linux implementation is based on the epoll mechanism
+- The BSD and macOS implementation is based on the kqueue mechanism
+- The generic Unix implementation is based on the posix select syscall
+
+## Caution
+
+The Windows implementation is based on WaitForMultipleObject with overlapping
+reads from CONIN$. At this point it only supports canceling reads from
+`os.Stdin`.
diff --git a/vendor/github.com/muesli/cancelreader/cancelreader.go b/vendor/github.com/muesli/cancelreader/cancelreader.go
new file mode 100644
index 00000000000..18d38255318
--- /dev/null
+++ b/vendor/github.com/muesli/cancelreader/cancelreader.go
@@ -0,0 +1,93 @@
+package cancelreader
+
+import (
+ "fmt"
+ "io"
+ "sync"
+)
+
+// ErrCanceled gets returned when trying to read from a canceled reader.
+var ErrCanceled = fmt.Errorf("read canceled")
+
+// CancelReader is a io.Reader whose Read() calls can be canceled without data
+// being consumed. The cancelReader has to be closed.
+type CancelReader interface {
+ io.ReadCloser
+
+ // Cancel cancels ongoing and future reads an returns true if it succeeded.
+ Cancel() bool
+}
+
+// File represents an input/output resource with a file descriptor.
+type File interface {
+ io.ReadWriteCloser
+
+ // Fd returns its file descriptor
+ Fd() uintptr
+
+ // Name returns its file name.
+ Name() string
+}
+
+// fallbackCancelReader implements cancelReader but does not actually support
+// cancelation during an ongoing Read() call. Thus, Cancel() always returns
+// false. However, after calling Cancel(), new Read() calls immediately return
+// errCanceled and don't consume any data anymore.
+type fallbackCancelReader struct {
+ r io.Reader
+ cancelMixin
+}
+
+// newFallbackCancelReader is a fallback for NewReader that cannot actually
+// cancel an ongoing read but will immediately return on future reads if it has
+// been canceled.
+func newFallbackCancelReader(reader io.Reader) (CancelReader, error) {
+ return &fallbackCancelReader{r: reader}, nil
+}
+
+func (r *fallbackCancelReader) Read(data []byte) (int, error) {
+ if r.isCanceled() {
+ return 0, ErrCanceled
+ }
+
+ n, err := r.r.Read(data)
+ /*
+ If the underlying reader is a blocking reader (e.g. an open connection),
+ it might happen that 1 goroutine cancels the reader while its stuck in
+ the read call waiting for something.
+ If that happens, we should still cancel the read.
+ */
+ if r.isCanceled() {
+ return 0, ErrCanceled
+ }
+ return n, err // nolint: wrapcheck
+}
+
+func (r *fallbackCancelReader) Cancel() bool {
+ r.setCanceled()
+ return false
+}
+
+func (r *fallbackCancelReader) Close() error {
+ return nil
+}
+
+// cancelMixin represents a goroutine-safe cancelation status.
+type cancelMixin struct {
+ unsafeCanceled bool
+ lock sync.Mutex
+}
+
+func (c *cancelMixin) isCanceled() bool {
+ c.lock.Lock()
+ defer c.lock.Unlock()
+
+ return c.unsafeCanceled
+}
+
+func (c *cancelMixin) setCanceled() {
+ c.lock.Lock()
+ defer c.lock.Unlock()
+
+ c.unsafeCanceled = true
+}
diff --git a/vendor/github.com/muesli/cancelreader/cancelreader_bsd.go b/vendor/github.com/muesli/cancelreader/cancelreader_bsd.go
new file mode 100644
index 00000000000..3ddb6cff0b3
--- /dev/null
+++ b/vendor/github.com/muesli/cancelreader/cancelreader_bsd.go
@@ -0,0 +1,146 @@
+//go:build darwin || freebsd || netbsd || openbsd || dragonfly
+// +build darwin freebsd netbsd openbsd dragonfly
+
+package cancelreader
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "os"
+ "strings"
+
+ "golang.org/x/sys/unix"
+)
+
+// NewReader returns a reader and a cancel function. If the input reader is a
+// File, the cancel function can be used to interrupt a blocking read call.
+// In this case, the cancel function returns true if the call was canceled
+// successfully. If the input reader is not a File, the cancel function
+// does nothing and always returns false. The BSD and macOS implementation is
+// based on the kqueue mechanism.
+func NewReader(reader io.Reader) (CancelReader, error) {
+ file, ok := reader.(File)
+ if !ok {
+ return newFallbackCancelReader(reader)
+ }
+
+ // kqueue returns instantly when polling /dev/tty so fallback to select
+ if file.Name() == "/dev/tty" {
+ return newSelectCancelReader(reader)
+ }
+
+ kQueue, err := unix.Kqueue()
+ if err != nil {
+ return nil, fmt.Errorf("create kqueue: %w", err)
+ }
+
+ r := &kqueueCancelReader{
+ file: file,
+ kQueue: kQueue,
+ }
+
+ r.cancelSignalReader, r.cancelSignalWriter, err = os.Pipe()
+ if err != nil {
+ _ = unix.Close(kQueue)
+ return nil, err
+ }
+
+ unix.SetKevent(&r.kQueueEvents[0], int(file.Fd()), unix.EVFILT_READ, unix.EV_ADD)
+ unix.SetKevent(&r.kQueueEvents[1], int(r.cancelSignalReader.Fd()), unix.EVFILT_READ, unix.EV_ADD)
+
+ return r, nil
+}
+
+type kqueueCancelReader struct {
+ file File
+ cancelSignalReader File
+ cancelSignalWriter File
+ cancelMixin
+ kQueue int
+ kQueueEvents [2]unix.Kevent_t
+}
+
+func (r *kqueueCancelReader) Read(data []byte) (int, error) {
+ if r.isCanceled() {
+ return 0, ErrCanceled
+ }
+
+ err := r.wait()
+ if err != nil {
+ if errors.Is(err, ErrCanceled) {
+ // remove signal from pipe
+ var b [1]byte
+ _, errRead := r.cancelSignalReader.Read(b[:])
+ if errRead != nil {
+ return 0, fmt.Errorf("reading cancel signal: %w", errRead)
+ }
+ }
+
+ return 0, err
+ }
+
+ return r.file.Read(data)
+}
+
+func (r *kqueueCancelReader) Cancel() bool {
+ r.setCanceled()
+
+ // send cancel signal
+ _, err := r.cancelSignalWriter.Write([]byte{'c'})
+ return err == nil
+}
+
+func (r *kqueueCancelReader) Close() error {
+ var errMsgs []string
+
+ // close kqueue
+ err := unix.Close(r.kQueue)
+ if err != nil {
+ errMsgs = append(errMsgs, fmt.Sprintf("closing kqueue: %v", err))
+ }
+
+ // close pipe
+ err = r.cancelSignalWriter.Close()
+ if err != nil {
+ errMsgs = append(errMsgs, fmt.Sprintf("closing cancel signal writer: %v", err))
+ }
+
+ err = r.cancelSignalReader.Close()
+ if err != nil {
+ errMsgs = append(errMsgs, fmt.Sprintf("closing cancel signal reader: %v", err))
+ }
+
+ if len(errMsgs) > 0 {
+ return fmt.Errorf(strings.Join(errMsgs, ", "))
+ }
+
+ return nil
+}
+
+func (r *kqueueCancelReader) wait() error {
+ events := make([]unix.Kevent_t, 1)
+
+ for {
+ _, err := unix.Kevent(r.kQueue, r.kQueueEvents[:], events, nil)
+ if errors.Is(err, unix.EINTR) {
+ continue // try again if the syscall was interrupted
+ }
+
+ if err != nil {
+ return fmt.Errorf("kevent: %w", err)
+ }
+
+ break
+ }
+
+ ident := uint64(events[0].Ident)
+ switch ident {
+ case uint64(r.file.Fd()):
+ return nil
+ case uint64(r.cancelSignalReader.Fd()):
+ return ErrCanceled
+ }
+
+ return fmt.Errorf("unknown error")
+}
diff --git a/vendor/github.com/muesli/cancelreader/cancelreader_default.go b/vendor/github.com/muesli/cancelreader/cancelreader_default.go
new file mode 100644
index 00000000000..8e275fa4411
--- /dev/null
+++ b/vendor/github.com/muesli/cancelreader/cancelreader_default.go
@@ -0,0 +1,12 @@
+//go:build !darwin && !windows && !linux && !solaris && !freebsd && !netbsd && !openbsd && !dragonfly
+// +build !darwin,!windows,!linux,!solaris,!freebsd,!netbsd,!openbsd,!dragonfly
+
+package cancelreader
+
+import "io"
+
+// NewReader returns a fallbackCancelReader that satisfies the CancelReader but
+// does not actually support cancellation.
+func NewReader(reader io.Reader) (CancelReader, error) {
+ return newFallbackCancelReader(reader)
+}
diff --git a/vendor/github.com/muesli/cancelreader/cancelreader_linux.go b/vendor/github.com/muesli/cancelreader/cancelreader_linux.go
new file mode 100644
index 00000000000..09f7369f31a
--- /dev/null
+++ b/vendor/github.com/muesli/cancelreader/cancelreader_linux.go
@@ -0,0 +1,154 @@
+//go:build linux
+// +build linux
+
+package cancelreader
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "os"
+ "strings"
+
+ "golang.org/x/sys/unix"
+)
+
+// NewReader returns a reader and a cancel function. If the input reader is a
+// File, the cancel function can be used to interrupt a blocking read call.
+// In this case, the cancel function returns true if the call was canceled
+// successfully. If the input reader is not a File, the cancel function
+// does nothing and always returns false. The Linux implementation is based on
+// the epoll mechanism.
+func NewReader(reader io.Reader) (CancelReader, error) {
+ file, ok := reader.(File)
+ if !ok {
+ return newFallbackCancelReader(reader)
+ }
+
+ epoll, err := unix.EpollCreate1(0)
+ if err != nil {
+ return nil, fmt.Errorf("create epoll: %w", err)
+ }
+
+ r := &epollCancelReader{
+ file: file,
+ epoll: epoll,
+ }
+
+ r.cancelSignalReader, r.cancelSignalWriter, err = os.Pipe()
+ if err != nil {
+ _ = unix.Close(epoll)
+ return nil, err
+ }
+
+ err = unix.EpollCtl(epoll, unix.EPOLL_CTL_ADD, int(file.Fd()), &unix.EpollEvent{
+ Events: unix.EPOLLIN,
+ Fd: int32(file.Fd()),
+ })
+ if err != nil {
+ _ = unix.Close(epoll)
+ return nil, fmt.Errorf("add reader to epoll interest list")
+ }
+
+ err = unix.EpollCtl(epoll, unix.EPOLL_CTL_ADD, int(r.cancelSignalReader.Fd()), &unix.EpollEvent{
+ Events: unix.EPOLLIN,
+ Fd: int32(r.cancelSignalReader.Fd()),
+ })
+ if err != nil {
+ _ = unix.Close(epoll)
+ return nil, fmt.Errorf("add reader to epoll interest list")
+ }
+
+ return r, nil
+}
+
+type epollCancelReader struct {
+ file File
+ cancelSignalReader File
+ cancelSignalWriter File
+ cancelMixin
+ epoll int
+}
+
+func (r *epollCancelReader) Read(data []byte) (int, error) {
+ if r.isCanceled() {
+ return 0, ErrCanceled
+ }
+
+ err := r.wait()
+ if err != nil {
+ if errors.Is(err, ErrCanceled) {
+ // remove signal from pipe
+ var b [1]byte
+ _, readErr := r.cancelSignalReader.Read(b[:])
+ if readErr != nil {
+ return 0, fmt.Errorf("reading cancel signal: %w", readErr)
+ }
+ }
+
+ return 0, err
+ }
+
+ return r.file.Read(data)
+}
+
+func (r *epollCancelReader) Cancel() bool {
+ r.setCanceled()
+
+ // send cancel signal
+ _, err := r.cancelSignalWriter.Write([]byte{'c'})
+ return err == nil
+}
+
+func (r *epollCancelReader) Close() error {
+ var errMsgs []string
+
+ // close kqueue
+ err := unix.Close(r.epoll)
+ if err != nil {
+ errMsgs = append(errMsgs, fmt.Sprintf("closing epoll: %v", err))
+ }
+
+ // close pipe
+ err = r.cancelSignalWriter.Close()
+ if err != nil {
+ errMsgs = append(errMsgs, fmt.Sprintf("closing cancel signal writer: %v", err))
+ }
+
+ err = r.cancelSignalReader.Close()
+ if err != nil {
+ errMsgs = append(errMsgs, fmt.Sprintf("closing cancel signal reader: %v", err))
+ }
+
+ if len(errMsgs) > 0 {
+ return fmt.Errorf(strings.Join(errMsgs, ", "))
+ }
+
+ return nil
+}
+
+func (r *epollCancelReader) wait() error {
+ events := make([]unix.EpollEvent, 1)
+
+ for {
+ _, err := unix.EpollWait(r.epoll, events, -1)
+ if errors.Is(err, unix.EINTR) {
+ continue // try again if the syscall was interrupted
+ }
+
+ if err != nil {
+ return fmt.Errorf("kevent: %w", err)
+ }
+
+ break
+ }
+
+ switch events[0].Fd {
+ case int32(r.file.Fd()):
+ return nil
+ case int32(r.cancelSignalReader.Fd()):
+ return ErrCanceled
+ }
+
+ return fmt.Errorf("unknown error")
+}
diff --git a/vendor/github.com/muesli/cancelreader/cancelreader_select.go b/vendor/github.com/muesli/cancelreader/cancelreader_select.go
new file mode 100644
index 00000000000..03f2a3e1e95
--- /dev/null
+++ b/vendor/github.com/muesli/cancelreader/cancelreader_select.go
@@ -0,0 +1,136 @@
+//go:build solaris || darwin || freebsd || netbsd || openbsd || dragonfly
+// +build solaris darwin freebsd netbsd openbsd dragonfly
+
+package cancelreader
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "os"
+ "strings"
+
+ "golang.org/x/sys/unix"
+)
+
+// newSelectCancelReader returns a reader and a cancel function. If the input
+// reader is a File, the cancel function can be used to interrupt a
+// blocking call read call. In this case, the cancel function returns true if
+// the call was canceled successfully. If the input reader is not a File or
+// the file descriptor is 1024 or larger, the cancel function does nothing and
+// always returns false. The generic unix implementation is based on the posix
+// select syscall.
+func newSelectCancelReader(reader io.Reader) (CancelReader, error) {
+ file, ok := reader.(File)
+ if !ok || file.Fd() >= unix.FD_SETSIZE {
+ return newFallbackCancelReader(reader)
+ }
+ r := &selectCancelReader{file: file}
+
+ var err error
+
+ r.cancelSignalReader, r.cancelSignalWriter, err = os.Pipe()
+ if err != nil {
+ return nil, err
+ }
+
+ return r, nil
+}
+
+type selectCancelReader struct {
+ file File
+ cancelSignalReader File
+ cancelSignalWriter File
+ cancelMixin
+}
+
+func (r *selectCancelReader) Read(data []byte) (int, error) {
+ if r.isCanceled() {
+ return 0, ErrCanceled
+ }
+
+ for {
+ err := waitForRead(r.file, r.cancelSignalReader)
+ if err != nil {
+ if errors.Is(err, unix.EINTR) {
+ continue // try again if the syscall was interrupted
+ }
+
+ if errors.Is(err, ErrCanceled) {
+ // remove signal from pipe
+ var b [1]byte
+ _, readErr := r.cancelSignalReader.Read(b[:])
+ if readErr != nil {
+ return 0, fmt.Errorf("reading cancel signal: %w", readErr)
+ }
+ }
+
+ return 0, err
+ }
+
+ return r.file.Read(data)
+ }
+}
+
+func (r *selectCancelReader) Cancel() bool {
+ r.setCanceled()
+
+ // send cancel signal
+ _, err := r.cancelSignalWriter.Write([]byte{'c'})
+ return err == nil
+}
+
+func (r *selectCancelReader) Close() error {
+ var errMsgs []string
+
+ // close pipe
+ err := r.cancelSignalWriter.Close()
+ if err != nil {
+ errMsgs = append(errMsgs, fmt.Sprintf("closing cancel signal writer: %v", err))
+ }
+
+ err = r.cancelSignalReader.Close()
+ if err != nil {
+ errMsgs = append(errMsgs, fmt.Sprintf("closing cancel signal reader: %v", err))
+ }
+
+ if len(errMsgs) > 0 {
+ return fmt.Errorf(strings.Join(errMsgs, ", "))
+ }
+
+ return nil
+}
+
+func waitForRead(reader, abort File) error {
+ readerFd := int(reader.Fd())
+ abortFd := int(abort.Fd())
+
+ maxFd := readerFd
+ if abortFd > maxFd {
+ maxFd = abortFd
+ }
+
+ // this is a limitation of the select syscall
+ if maxFd >= unix.FD_SETSIZE {
+ return fmt.Errorf("cannot select on file descriptor %d which is larger than 1024", maxFd)
+ }
+
+ fdSet := &unix.FdSet{}
+ fdSet.Set(int(reader.Fd()))
+ fdSet.Set(int(abort.Fd()))
+
+ _, err := unix.Select(maxFd+1, fdSet, nil, nil, nil)
+ if err != nil {
+ return fmt.Errorf("select: %w", err)
+ }
+
+ if fdSet.IsSet(abortFd) {
+ return ErrCanceled
+ }
+
+ if fdSet.IsSet(readerFd) {
+ return nil
+ }
+
+ return fmt.Errorf("select returned without setting a file descriptor")
+}
diff --git a/vendor/github.com/muesli/cancelreader/cancelreader_unix.go b/vendor/github.com/muesli/cancelreader/cancelreader_unix.go
new file mode 100644
index 00000000000..3c10ee09e24
--- /dev/null
+++ b/vendor/github.com/muesli/cancelreader/cancelreader_unix.go
@@ -0,0 +1,18 @@
+//go:build solaris
+// +build solaris
+
+package cancelreader
+
+import (
+ "io"
+)
+
+// NewReader returns a reader and a cancel function. If the input reader is a
+// File, the cancel function can be used to interrupt a blocking read call.
+// In this case, the cancel function returns true if the call was canceled
+// successfully. If the input reader is not a File or the file descriptor
+// is 1024 or larger, the cancel function does nothing and always returns false.
+// The generic unix implementation is based on the posix select syscall.
+func NewReader(reader io.Reader) (CancelReader, error) {
+ return newSelectCancelReader(reader)
+}
diff --git a/vendor/github.com/muesli/cancelreader/cancelreader_windows.go b/vendor/github.com/muesli/cancelreader/cancelreader_windows.go
new file mode 100644
index 00000000000..c1dc8d500cc
--- /dev/null
+++ b/vendor/github.com/muesli/cancelreader/cancelreader_windows.go
@@ -0,0 +1,244 @@
+//go:build windows
+// +build windows
+
+package cancelreader
+
+import (
+ "fmt"
+ "io"
+ "os"
+ "syscall"
+ "time"
+ "unicode/utf16"
+
+ "golang.org/x/sys/windows"
+)
+
+var fileShareValidFlags uint32 = 0x00000007
+
+// NewReader returns a reader and a cancel function. If the input reader is a
+// File with the same file descriptor as os.Stdin, the cancel function can
+// be used to interrupt a blocking read call. In this case, the cancel function
+// returns true if the call was canceled successfully. If the input reader is
+// not a File with the same file descriptor as os.Stdin, the cancel
+// function does nothing and always returns false. The Windows implementation
+// is based on WaitForMultipleObject with overlapping reads from CONIN$.
+func NewReader(reader io.Reader) (CancelReader, error) {
+ if f, ok := reader.(File); !ok || f.Fd() != os.Stdin.Fd() {
+ return newFallbackCancelReader(reader)
+ }
+
+ // it is necessary to open CONIN$ (NOT windows.STD_INPUT_HANDLE) in
+ // overlapped mode to be able to use it with WaitForMultipleObjects.
+ conin, err := windows.CreateFile(
+ &(utf16.Encode([]rune("CONIN$\x00"))[0]), windows.GENERIC_READ|windows.GENERIC_WRITE,
+ fileShareValidFlags, nil, windows.OPEN_EXISTING, windows.FILE_FLAG_OVERLAPPED, 0)
+ if err != nil {
+ return nil, fmt.Errorf("open CONIN$ in overlapping mode: %w", err)
+ }
+
+ resetConsole, err := prepareConsole(conin)
+ if err != nil {
+ return nil, fmt.Errorf("prepare console: %w", err)
+ }
+
+ // flush input, otherwise it can contain events which trigger
+ // WaitForMultipleObjects but which ReadFile cannot read, resulting in an
+ // un-cancelable read
+ err = flushConsoleInputBuffer(conin)
+ if err != nil {
+ return nil, fmt.Errorf("flush console input buffer: %w", err)
+ }
+
+ cancelEvent, err := windows.CreateEvent(nil, 0, 0, nil)
+ if err != nil {
+ return nil, fmt.Errorf("create stop event: %w", err)
+ }
+
+ return &winCancelReader{
+ conin: conin,
+ cancelEvent: cancelEvent,
+ resetConsole: resetConsole,
+ blockingReadSignal: make(chan struct{}, 1),
+ }, nil
+}
+
+type winCancelReader struct {
+ conin windows.Handle
+ cancelEvent windows.Handle
+ cancelMixin
+
+ resetConsole func() error
+ blockingReadSignal chan struct{}
+}
+
+func (r *winCancelReader) Read(data []byte) (int, error) {
+ if r.isCanceled() {
+ return 0, ErrCanceled
+ }
+
+ err := r.wait()
+ if err != nil {
+ return 0, err
+ }
+
+ if r.isCanceled() {
+ return 0, ErrCanceled
+ }
+
+ // windows.Read does not work on overlapping windows.Handles
+ return r.readAsync(data)
+}
+
+// Cancel cancels ongoing and future Read() calls and returns true if the
+// cancelation of the ongoing Read() was successful. On Windows Terminal,
+// WaitForMultipleObjects sometimes immediately returns without input being
+// available. In this case, graceful cancelation is not possible and Cancel()
+// returns false.
+func (r *winCancelReader) Cancel() bool {
+ r.setCanceled()
+
+ select {
+ case r.blockingReadSignal <- struct{}{}:
+ err := windows.SetEvent(r.cancelEvent)
+ if err != nil {
+ return false
+ }
+ <-r.blockingReadSignal
+ case <-time.After(100 * time.Millisecond):
+ // Read() hangs in a GetOverlappedResult which is likely due to
+ // WaitForMultipleObjects returning without input being available
+ // so we cannot cancel this ongoing read.
+ return false
+ }
+
+ return true
+}
+
+func (r *winCancelReader) Close() error {
+ err := windows.CloseHandle(r.cancelEvent)
+ if err != nil {
+ return fmt.Errorf("closing cancel event handle: %w", err)
+ }
+
+ err = r.resetConsole()
+ if err != nil {
+ return err
+ }
+
+ err = windows.Close(r.conin)
+ if err != nil {
+ return fmt.Errorf("closing CONIN$")
+ }
+
+ return nil
+}
+
+func (r *winCancelReader) wait() error {
+ event, err := windows.WaitForMultipleObjects([]windows.Handle{r.conin, r.cancelEvent}, false, windows.INFINITE)
+ switch {
+ case windows.WAIT_OBJECT_0 <= event && event < windows.WAIT_OBJECT_0+2:
+ if event == windows.WAIT_OBJECT_0+1 {
+ return ErrCanceled
+ }
+
+ if event == windows.WAIT_OBJECT_0 {
+ return nil
+ }
+
+ return fmt.Errorf("unexpected wait object is ready: %d", event-windows.WAIT_OBJECT_0)
+ case windows.WAIT_ABANDONED <= event && event < windows.WAIT_ABANDONED+2:
+ return fmt.Errorf("abandoned")
+ case event == uint32(windows.WAIT_TIMEOUT):
+ return fmt.Errorf("timeout")
+ case event == windows.WAIT_FAILED:
+ return fmt.Errorf("failed")
+ default:
+ return fmt.Errorf("unexpected error: %w", error(err))
+ }
+}
+
+// readAsync is necessary to read from a windows.Handle in overlapping mode.
+func (r *winCancelReader) readAsync(data []byte) (int, error) {
+ hevent, err := windows.CreateEvent(nil, 0, 0, nil)
+ if err != nil {
+ return 0, fmt.Errorf("create event: %w", err)
+ }
+
+ overlapped := windows.Overlapped{
+ HEvent: hevent,
+ }
+
+ var n uint32
+
+ err = windows.ReadFile(r.conin, data, &n, &overlapped)
+ if err != nil && err != windows.ERROR_IO_PENDING {
+ return int(n), err
+ }
+
+ r.blockingReadSignal <- struct{}{}
+ err = windows.GetOverlappedResult(r.conin, &overlapped, &n, true)
+ if err != nil {
+ return int(n), nil
+ }
+ <-r.blockingReadSignal
+
+ return int(n), nil
+}
+
+func prepareConsole(input windows.Handle) (reset func() error, err error) {
+ var originalMode uint32
+
+ err = windows.GetConsoleMode(input, &originalMode)
+ if err != nil {
+ return nil, fmt.Errorf("get console mode: %w", err)
+ }
+
+ var newMode uint32
+ newMode &^= windows.ENABLE_ECHO_INPUT
+ newMode &^= windows.ENABLE_LINE_INPUT
+ newMode &^= windows.ENABLE_MOUSE_INPUT
+ newMode &^= windows.ENABLE_WINDOW_INPUT
+ newMode &^= windows.ENABLE_PROCESSED_INPUT
+
+ newMode |= windows.ENABLE_EXTENDED_FLAGS
+ newMode |= windows.ENABLE_INSERT_MODE
+ newMode |= windows.ENABLE_QUICK_EDIT_MODE
+
+ // Enabling virtual terminal input is necessary for processing certain
+ // types of input like X10 mouse events and arrows keys with the current
+ // bytes-based input reader. It does, however, prevent cancelReader from
+ // being able to cancel input. The planned solution for this is to read
+ // Windows events in a more native fashion, rather than the current simple
+ // bytes-based input reader which works well on unix systems.
+ newMode |= windows.ENABLE_VIRTUAL_TERMINAL_INPUT
+
+ err = windows.SetConsoleMode(input, newMode)
+ if err != nil {
+ return nil, fmt.Errorf("set console mode: %w", err)
+ }
+
+ return func() error {
+ err := windows.SetConsoleMode(input, originalMode)
+ if err != nil {
+ return fmt.Errorf("reset console mode: %w", err)
+ }
+
+ return nil
+ }, nil
+}
+
+var (
+ modkernel32 = windows.NewLazySystemDLL("kernel32.dll")
+ procFlushConsoleInputBuffer = modkernel32.NewProc("FlushConsoleInputBuffer")
+)
+
+func flushConsoleInputBuffer(consoleInput windows.Handle) error {
+ r, _, e := syscall.Syscall(procFlushConsoleInputBuffer.Addr(), 1,
+ uintptr(consoleInput), 0, 0)
+ if r == 0 {
+ return error(e)
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/muesli/reflow/LICENSE b/vendor/github.com/muesli/reflow/LICENSE
new file mode 100644
index 00000000000..8532c45c96f
--- /dev/null
+++ b/vendor/github.com/muesli/reflow/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Christian Muehlhaeuser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/github.com/muesli/reflow/ansi/ansi.go b/vendor/github.com/muesli/reflow/ansi/ansi.go
new file mode 100644
index 00000000000..f3d0700af91
--- /dev/null
+++ b/vendor/github.com/muesli/reflow/ansi/ansi.go
@@ -0,0 +1,7 @@
+package ansi
+
+const Marker = '\x1B'
+
+func IsTerminator(c rune) bool {
+ return (c >= 0x40 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a)
+}
diff --git a/vendor/github.com/muesli/reflow/ansi/buffer.go b/vendor/github.com/muesli/reflow/ansi/buffer.go
new file mode 100644
index 00000000000..471bcaf7855
--- /dev/null
+++ b/vendor/github.com/muesli/reflow/ansi/buffer.go
@@ -0,0 +1,40 @@
+package ansi
+
+import (
+ "bytes"
+
+ "github.com/mattn/go-runewidth"
+)
+
+// Buffer is a buffer aware of ANSI escape sequences.
+type Buffer struct {
+ bytes.Buffer
+}
+
+// PrintableRuneWidth returns the cell width of all printable runes in the
+// buffer.
+func (w Buffer) PrintableRuneWidth() int {
+ return PrintableRuneWidth(w.String())
+}
+
+// PrintableRuneWidth returns the cell width of the given string.
+func PrintableRuneWidth(s string) int {
+ var n int
+ var ansi bool
+
+ for _, c := range s {
+ if c == Marker {
+ // ANSI escape sequence
+ ansi = true
+ } else if ansi {
+ if IsTerminator(c) {
+ // ANSI sequence terminated
+ ansi = false
+ }
+ } else {
+ n += runewidth.RuneWidth(c)
+ }
+ }
+
+ return n
+}
diff --git a/vendor/github.com/muesli/reflow/ansi/writer.go b/vendor/github.com/muesli/reflow/ansi/writer.go
new file mode 100644
index 00000000000..a6aaa1ec677
--- /dev/null
+++ b/vendor/github.com/muesli/reflow/ansi/writer.go
@@ -0,0 +1,76 @@
+package ansi
+
+import (
+ "bytes"
+ "io"
+ "unicode/utf8"
+)
+
+type Writer struct {
+ Forward io.Writer
+
+ ansi bool
+ ansiseq bytes.Buffer
+ lastseq bytes.Buffer
+ seqchanged bool
+ runeBuf []byte
+}
+
+// Write is used to write content to the ANSI buffer.
+func (w *Writer) Write(b []byte) (int, error) {
+ for _, c := range string(b) {
+ if c == Marker {
+ // ANSI escape sequence
+ w.ansi = true
+ w.seqchanged = true
+ _, _ = w.ansiseq.WriteRune(c)
+ } else if w.ansi {
+ _, _ = w.ansiseq.WriteRune(c)
+ if IsTerminator(c) {
+ // ANSI sequence terminated
+ w.ansi = false
+
+ if bytes.HasSuffix(w.ansiseq.Bytes(), []byte("[0m")) {
+ // reset sequence
+ w.lastseq.Reset()
+ w.seqchanged = false
+ } else if c == 'm' {
+ // color code
+ _, _ = w.lastseq.Write(w.ansiseq.Bytes())
+ }
+
+ _, _ = w.ansiseq.WriteTo(w.Forward)
+ }
+ } else {
+ _, err := w.writeRune(c)
+ if err != nil {
+ return 0, err
+ }
+ }
+ }
+
+ return len(b), nil
+}
+
+func (w *Writer) writeRune(r rune) (int, error) {
+ if w.runeBuf == nil {
+ w.runeBuf = make([]byte, utf8.UTFMax)
+ }
+ n := utf8.EncodeRune(w.runeBuf, r)
+ return w.Forward.Write(w.runeBuf[:n])
+}
+
+func (w *Writer) LastSequence() string {
+ return w.lastseq.String()
+}
+
+func (w *Writer) ResetAnsi() {
+ if !w.seqchanged {
+ return
+ }
+ _, _ = w.Forward.Write([]byte("\x1b[0m"))
+}
+
+func (w *Writer) RestoreAnsi() {
+ _, _ = w.Forward.Write(w.lastseq.Bytes())
+}
diff --git a/vendor/github.com/muesli/reflow/wordwrap/wordwrap.go b/vendor/github.com/muesli/reflow/wordwrap/wordwrap.go
new file mode 100644
index 00000000000..488fb210046
--- /dev/null
+++ b/vendor/github.com/muesli/reflow/wordwrap/wordwrap.go
@@ -0,0 +1,167 @@
+package wordwrap
+
+import (
+ "bytes"
+ "strings"
+ "unicode"
+
+ "github.com/muesli/reflow/ansi"
+)
+
+var (
+ defaultBreakpoints = []rune{'-'}
+ defaultNewline = []rune{'\n'}
+)
+
+// WordWrap contains settings and state for customisable text reflowing with
+// support for ANSI escape sequences. This means you can style your terminal
+// output without affecting the word wrapping algorithm.
+type WordWrap struct {
+ Limit int
+ Breakpoints []rune
+ Newline []rune
+ KeepNewlines bool
+
+ buf bytes.Buffer
+ space bytes.Buffer
+ word ansi.Buffer
+
+ lineLen int
+ ansi bool
+}
+
+// NewWriter returns a new instance of a word-wrapping writer, initialized with
+// default settings.
+func NewWriter(limit int) *WordWrap {
+ return &WordWrap{
+ Limit: limit,
+ Breakpoints: defaultBreakpoints,
+ Newline: defaultNewline,
+ KeepNewlines: true,
+ }
+}
+
+// Bytes is shorthand for declaring a new default WordWrap instance,
+// used to immediately word-wrap a byte slice.
+func Bytes(b []byte, limit int) []byte {
+ f := NewWriter(limit)
+ _, _ = f.Write(b)
+ _ = f.Close()
+
+ return f.Bytes()
+}
+
+// String is shorthand for declaring a new default WordWrap instance,
+// used to immediately word-wrap a string.
+func String(s string, limit int) string {
+ return string(Bytes([]byte(s), limit))
+}
+
+func (w *WordWrap) addSpace() {
+ w.lineLen += w.space.Len()
+ _, _ = w.buf.Write(w.space.Bytes())
+ w.space.Reset()
+}
+
+func (w *WordWrap) addWord() {
+ if w.word.Len() > 0 {
+ w.addSpace()
+ w.lineLen += w.word.PrintableRuneWidth()
+ _, _ = w.buf.Write(w.word.Bytes())
+ w.word.Reset()
+ }
+}
+
+func (w *WordWrap) addNewLine() {
+ _, _ = w.buf.WriteRune('\n')
+ w.lineLen = 0
+ w.space.Reset()
+}
+
+func inGroup(a []rune, c rune) bool {
+ for _, v := range a {
+ if v == c {
+ return true
+ }
+ }
+ return false
+}
+
+// Write is used to write more content to the word-wrap buffer.
+func (w *WordWrap) Write(b []byte) (int, error) {
+ if w.Limit == 0 {
+ return w.buf.Write(b)
+ }
+
+ s := string(b)
+ if !w.KeepNewlines {
+ s = strings.Replace(strings.TrimSpace(s), "\n", " ", -1)
+ }
+
+ for _, c := range s {
+ if c == '\x1B' {
+ // ANSI escape sequence
+ _, _ = w.word.WriteRune(c)
+ w.ansi = true
+ } else if w.ansi {
+ _, _ = w.word.WriteRune(c)
+ if (c >= 0x40 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a) {
+ // ANSI sequence terminated
+ w.ansi = false
+ }
+ } else if inGroup(w.Newline, c) {
+ // end of current line
+ // see if we can add the content of the space buffer to the current line
+ if w.word.Len() == 0 {
+ if w.lineLen+w.space.Len() > w.Limit {
+ w.lineLen = 0
+ } else {
+ // preserve whitespace
+ _, _ = w.buf.Write(w.space.Bytes())
+ }
+ w.space.Reset()
+ }
+
+ w.addWord()
+ w.addNewLine()
+ } else if unicode.IsSpace(c) {
+ // end of current word
+ w.addWord()
+ _, _ = w.space.WriteRune(c)
+ } else if inGroup(w.Breakpoints, c) {
+ // valid breakpoint
+ w.addSpace()
+ w.addWord()
+ _, _ = w.buf.WriteRune(c)
+ } else {
+ // any other character
+ _, _ = w.word.WriteRune(c)
+
+ // add a line break if the current word would exceed the line's
+ // character limit
+ if w.lineLen+w.space.Len()+w.word.PrintableRuneWidth() > w.Limit &&
+ w.word.PrintableRuneWidth() < w.Limit {
+ w.addNewLine()
+ }
+ }
+ }
+
+ return len(b), nil
+}
+
+// Close will finish the word-wrap operation. Always call it before trying to
+// retrieve the final result.
+func (w *WordWrap) Close() error {
+ w.addWord()
+ return nil
+}
+
+// Bytes returns the word-wrapped result as a byte slice.
+func (w *WordWrap) Bytes() []byte {
+ return w.buf.Bytes()
+}
+
+// String returns the word-wrapped result as a string.
+func (w *WordWrap) String() string {
+ return w.buf.String()
+}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 5cd2177d236..c659ec22ee9 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -65,6 +65,9 @@ github.com/cenkalti/backoff/v4
# github.com/cespare/xxhash/v2 v2.3.0
## explicit; go 1.11
github.com/cespare/xxhash/v2
+# github.com/charmbracelet/bubbletea v1.3.4
+## explicit; go 1.18
+github.com/charmbracelet/bubbletea
# github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc
## explicit; go 1.18
github.com/charmbracelet/colorprofile
@@ -256,6 +259,9 @@ github.com/emirpasic/gods/lists/arraylist
github.com/emirpasic/gods/trees
github.com/emirpasic/gods/trees/binaryheap
github.com/emirpasic/gods/utils
+# github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f
+## explicit; go 1.16
+github.com/erikgeiser/coninput
# github.com/felixge/httpsnoop v1.0.4
## explicit; go 1.13
github.com/felixge/httpsnoop
@@ -407,6 +413,9 @@ github.com/mattn/go-colorable
# github.com/mattn/go-isatty v0.0.20
## explicit; go 1.15
github.com/mattn/go-isatty
+# github.com/mattn/go-localereader v0.0.1
+## explicit
+github.com/mattn/go-localereader
# github.com/mattn/go-runewidth v0.0.16
## explicit; go 1.9
github.com/mattn/go-runewidth
@@ -421,8 +430,6 @@ github.com/miekg/pkcs11
github.com/mitchellh/colorstring
# github.com/mitchellh/mapstructure v1.5.0
## explicit; go 1.14
-# github.com/mmcloughlin/avo v0.6.0
-## explicit; go 1.18
# github.com/moby/docker-image-spec v1.3.1
## explicit; go 1.18
github.com/moby/docker-image-spec/specs-go/v1
@@ -450,6 +457,17 @@ github.com/moby/term/windows
# github.com/morikuni/aec v1.0.0
## explicit
github.com/morikuni/aec
+# github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6
+## explicit; go 1.17
+github.com/muesli/ansi
+github.com/muesli/ansi/compressor
+# github.com/muesli/cancelreader v0.2.2
+## explicit; go 1.17
+github.com/muesli/cancelreader
+# github.com/muesli/reflow v0.3.0
+## explicit; go 1.13
+github.com/muesli/reflow/ansi
+github.com/muesli/reflow/wordwrap
# github.com/muesli/termenv v0.16.0
## explicit; go 1.17
github.com/muesli/termenv
@@ -664,8 +682,6 @@ golang.org/x/exp/slices
golang.org/x/exp/slog
golang.org/x/exp/slog/internal
golang.org/x/exp/slog/internal/buffer
-# golang.org/x/mod v0.24.0
-## explicit; go 1.23.0
# golang.org/x/net v0.37.0
## explicit; go 1.23.0
golang.org/x/net/context
@@ -708,8 +724,6 @@ golang.org/x/text/width
# golang.org/x/time v0.11.0
## explicit; go 1.23.0
golang.org/x/time/rate
-# golang.org/x/tools v0.31.0
-## explicit; go 1.23.0
# google.golang.org/genproto/googleapis/api v0.0.0-20250313205543-e70fdf4c4cb4
## explicit; go 1.23.0
google.golang.org/genproto/googleapis/api/httpbody