Update tcell and include tcell database in debian package

Gopkg.lock

@@ -133,7 +133,7 @@
     ".",
     "terminfo"
   ]
-  revision = "f24463c4e27934fbad976fdd6c05b1d67c345f5d"
+  revision = "f32e44a866ab0475655e11ede91337d7b562956d"
 
 [[projects]]
   branch = "master"

scripts/ci

@@ -16,7 +16,14 @@ GOOS=darwin go build -o "target/$PROJECT_NAME-darwin-amd64"
 
 echo "Packaging for debian (linux/amd64)"
 mkdir -p deb/usr/bin/
+
 cp target/$PROJECT_NAME-linux-amd64 deb/usr/bin/gomuks
+
+go get -u maunium.net/go/tcell
+mkdir -p deb/usr/share/tcell/
+rm -rf deb/usr/share/tcell/database
+cp -r $GOPATH/src/maunium.net/go/tcell/terminfo/database deb/usr/share/tcell
+
 sed -i.bak -E 's/(Version: [0-9]+\.[0-9]+\.[0-9]+\-[0-9]+)/\1+'$SHORTHEAD'/' deb/DEBIAN/control
 dpkg-deb --build deb 'target/'$PROJECT_NAME'_linux_amd64.deb'
 mv -f deb/DEBIAN/control.bak deb/DEBIAN/control

scripts/package

@@ -1,6 +1,13 @@
 #!/bin/bash
 mkdir -p deb/usr/bin/
 mkdir -p target/
+
 go build -o deb/usr/bin/gomuks
+
+go get -u maunium.net/go/tcell
+mkdir -p deb/usr/share/tcell/
+rm -rf deb/usr/share/tcell/database
+cp -r $GOPATH/src/maunium.net/go/tcell/terminfo/database deb/usr/share/tcell
+
 version=$(cat deb/DEBIAN/control | grep Version | awk '{ print $2 }')
 dpkg-deb --build deb target/gomuks-$version.deb

ui/ui.go

@@ -20,6 +20,7 @@ import (
 	"maunium.net/go/gomuks/interface"
 	"maunium.net/go/tcell"
 	"maunium.net/go/tview"
+	"os"
 )
 
 type View string
@@ -42,6 +43,11 @@ type GomuksUI struct {
 func init() {
 	tview.Styles.PrimitiveBackgroundColor = tcell.ColorDefault
 	tview.Styles.ContrastBackgroundColor = tcell.ColorDarkGreen
+	if tcellDB := os.Getenv("TCELLDB"); len(tcellDB) == 0 {
+		if info, err := os.Stat("/usr/share/tcell/database"); err == nil && info.IsDir() {
+			os.Setenv("TCELLDB", "/usr/share/tcell/database")
+		}
+	}
 }
 
 func NewGomuksUI(gmx ifc.Gomuks) ifc.GomuksUI {

vendor/maunium.net/go/tcell/terminfo/dyninfo.go

@@ -0,0 +1,475 @@
+// Copyright 2018 The TCell Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use file except in compliance with the License.
+// You may obtain a copy of the license at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This command is used to generate suitable configuration files in either
+// go syntax or in JSON.  It defaults to JSON output on stdout.  If no
+// term values are specified on the command line, then $TERM is used.
+//
+// Usage is like this:
+//
+// mkinfo [-init] [-go file.go] [-json file.json] [-quiet] [-nofatal] [<term>...]
+//
+// -all      scan terminfo to determine database entries to use
+// -db       generate database entries (database/*), implied for -all
+// -gzip     specifies output should be compressed (json only)
+// -go       specifies Go output into the named file.  Use - for stdout.
+// -json     specifies JSON output in the named file.  Use - for stdout
+// -nofatal  indicates that errors loading definitions should not be fatal
+//
+
+package terminfo
+
+import (
+	"bytes"
+	"errors"
+	"os"
+	"os/exec"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+type termcap struct {
+	name    string
+	desc    string
+	aliases []string
+	bools   map[string]bool
+	nums    map[string]int
+	strs    map[string]string
+}
+
+func (tc *termcap) getnum(s string) int {
+	return (tc.nums[s])
+}
+
+func (tc *termcap) getflag(s string) bool {
+	return (tc.bools[s])
+}
+
+func (tc *termcap) getstr(s string) string {
+	return (tc.strs[s])
+}
+
+const (
+	NONE = iota
+	CTRL
+	ESC
+)
+
+var notaddressable = errors.New("terminal not cursor addressable")
+
+func unescape(s string) string {
+	// Various escapes are in \x format.  Control codes are
+	// encoded as ^M (carat followed by ASCII equivalent).
+	// Escapes are: \e, \E - escape
+	//  \0 NULL, \n \l \r \t \b \f \s for equivalent C escape.
+	buf := &bytes.Buffer{}
+	esc := NONE
+
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		switch esc {
+		case NONE:
+			switch c {
+			case '\\':
+				esc = ESC
+			case '^':
+				esc = CTRL
+			default:
+				buf.WriteByte(c)
+			}
+		case CTRL:
+			buf.WriteByte(c - 0x40)
+			esc = NONE
+		case ESC:
+			switch c {
+			case 'E', 'e':
+				buf.WriteByte(0x1b)
+			case '0', '1', '2', '3', '4', '5', '6', '7':
+				if i+2 < len(s) && s[i+1] >= '0' && s[i+1] <= '7' && s[i+2] >= '0' && s[i+2] <= '7' {
+					buf.WriteByte(((c - '0') * 64) + ((s[i+1] - '0') * 8) + (s[i+2] - '0'))
+					i = i + 2
+				} else if c == '0' {
+					buf.WriteByte(0)
+				}
+			case 'n':
+				buf.WriteByte('\n')
+			case 'r':
+				buf.WriteByte('\r')
+			case 't':
+				buf.WriteByte('\t')
+			case 'b':
+				buf.WriteByte('\b')
+			case 'f':
+				buf.WriteByte('\f')
+			case 's':
+				buf.WriteByte(' ')
+			case 'l':
+				panic("WTF: weird format: " + s)
+			default:
+				buf.WriteByte(c)
+			}
+			esc = NONE
+		}
+	}
+	return (buf.String())
+}
+
+func (tc *termcap) setupterm(name string) error {
+	cmd := exec.Command("infocmp", "-1", name)
+	output := &bytes.Buffer{}
+	cmd.Stdout = output
+
+	tc.strs = make(map[string]string)
+	tc.bools = make(map[string]bool)
+	tc.nums = make(map[string]int)
+
+	err := cmd.Run()
+	if err != nil {
+		return err
+	}
+
+	// Now parse the output.
+	// We get comment lines (starting with "#"), followed by
+	// a header line that looks like "<name>|<alias>|...|<desc>"
+	// then capabilities, one per line, starting with a tab and ending
+	// with a comma and newline.
+	lines := strings.Split(output.String(), "\n")
+	for len(lines) > 0 && strings.HasPrefix(lines[0], "#") {
+		lines = lines[1:]
+	}
+
+	// Ditch trailing empty last line
+	if lines[len(lines)-1] == "" {
+		lines = lines[:len(lines)-1]
+	}
+	header := lines[0]
+	if strings.HasSuffix(header, ",") {
+		header = header[:len(header)-1]
+	}
+	names := strings.Split(header, "|")
+	tc.name = names[0]
+	names = names[1:]
+	if len(names) > 0 {
+		tc.desc = names[len(names)-1]
+		names = names[:len(names)-1]
+	}
+	tc.aliases = names
+	for _, val := range lines[1:] {
+		if (!strings.HasPrefix(val, "\t")) ||
+			(!strings.HasSuffix(val, ",")) {
+			return (errors.New("malformed infocmp: " + val))
+		}
+
+		val = val[1:]
+		val = val[:len(val)-1]
+
+		if k := strings.SplitN(val, "=", 2); len(k) == 2 {
+			tc.strs[k[0]] = unescape(k[1])
+		} else if k := strings.SplitN(val, "#", 2); len(k) == 2 {
+			if u, err := strconv.ParseUint(k[1], 0, 0); err != nil {
+				return (err)
+			} else {
+				tc.nums[k[0]] = int(u)
+			}
+		} else {
+			tc.bools[val] = true
+		}
+	}
+	return nil
+}
+
+// This program is used to collect data from the system's terminfo library,
+// and write it into Go source code.  That is, we maintain our terminfo
+// capabilities encoded in the program.  It should never need to be run by
+// an end user, but developers can use this to add codes for additional
+// terminal types.
+//
+// If a terminal name ending with -truecolor is given, and we cannot find
+// one, we will try to fabricate one from either the -256color (if present)
+// or the unadorned base name, adding the XTerm specific 24-bit color
+// escapes.  We believe that all 24-bit capable terminals use the same
+// escape sequences, and terminfo has yet to evolve to support this.
+func getinfo(name string) (*Terminfo, string, error) {
+	var tc termcap
+	addTrueColor := false
+	if err := tc.setupterm(name); err != nil {
+		if strings.HasSuffix(name, "-truecolor") {
+			base := name[:len(name)-len("-truecolor")]
+			// Probably -256color is closest to what we want
+			if err = tc.setupterm(base + "-256color"); err != nil {
+				err = tc.setupterm(base)
+			}
+			if err == nil {
+				addTrueColor = true
+			}
+			tc.name = name
+		}
+		if err != nil {
+			return nil, "", err
+		}
+	}
+	t := &Terminfo{}
+	// If this is an alias record, then just emit the alias
+	t.Name = tc.name
+	if t.Name != name {
+		return t, "", nil
+	}
+	t.Aliases = tc.aliases
+	t.Colors = tc.getnum("colors")
+	t.Columns = tc.getnum("cols")
+	t.Lines = tc.getnum("lines")
+	t.Bell = tc.getstr("bel")
+	t.Clear = tc.getstr("clear")
+	t.EnterCA = tc.getstr("smcup")
+	t.ExitCA = tc.getstr("rmcup")
+	t.ShowCursor = tc.getstr("cnorm")
+	t.HideCursor = tc.getstr("civis")
+	t.AttrOff = tc.getstr("sgr0")
+	t.Underline = tc.getstr("smul")
+	t.Bold = tc.getstr("bold")
+	t.Italic = tc.getstr("sitm")
+	if len(t.Italic) == 0 {
+		t.Italic = "\x1b[3m"
+	}
+	t.Strikethrough = "\x1b[9m"
+	t.Blink = tc.getstr("blink")
+	t.Dim = tc.getstr("dim")
+	t.Reverse = tc.getstr("rev")
+	t.EnterKeypad = tc.getstr("smkx")
+	t.ExitKeypad = tc.getstr("rmkx")
+	t.SetFg = tc.getstr("setaf")
+	t.SetBg = tc.getstr("setab")
+	t.SetCursor = tc.getstr("cup")
+	t.CursorBack1 = tc.getstr("cub1")
+	t.CursorUp1 = tc.getstr("cuu1")
+	t.KeyF1 = tc.getstr("kf1")
+	t.KeyF2 = tc.getstr("kf2")
+	t.KeyF3 = tc.getstr("kf3")
+	t.KeyF4 = tc.getstr("kf4")
+	t.KeyF5 = tc.getstr("kf5")
+	t.KeyF6 = tc.getstr("kf6")
+	t.KeyF7 = tc.getstr("kf7")
+	t.KeyF8 = tc.getstr("kf8")
+	t.KeyF9 = tc.getstr("kf9")
+	t.KeyF10 = tc.getstr("kf10")
+	t.KeyF11 = tc.getstr("kf11")
+	t.KeyF12 = tc.getstr("kf12")
+	t.KeyF13 = tc.getstr("kf13")
+	t.KeyF14 = tc.getstr("kf14")
+	t.KeyF15 = tc.getstr("kf15")
+	t.KeyF16 = tc.getstr("kf16")
+	t.KeyF17 = tc.getstr("kf17")
+	t.KeyF18 = tc.getstr("kf18")
+	t.KeyF19 = tc.getstr("kf19")
+	t.KeyF20 = tc.getstr("kf20")
+	t.KeyF21 = tc.getstr("kf21")
+	t.KeyF22 = tc.getstr("kf22")
+	t.KeyF23 = tc.getstr("kf23")
+	t.KeyF24 = tc.getstr("kf24")
+	t.KeyF25 = tc.getstr("kf25")
+	t.KeyF26 = tc.getstr("kf26")
+	t.KeyF27 = tc.getstr("kf27")
+	t.KeyF28 = tc.getstr("kf28")
+	t.KeyF29 = tc.getstr("kf29")
+	t.KeyF30 = tc.getstr("kf30")
+	t.KeyF31 = tc.getstr("kf31")
+	t.KeyF32 = tc.getstr("kf32")
+	t.KeyF33 = tc.getstr("kf33")
+	t.KeyF34 = tc.getstr("kf34")
+	t.KeyF35 = tc.getstr("kf35")
+	t.KeyF36 = tc.getstr("kf36")
+	t.KeyF37 = tc.getstr("kf37")
+	t.KeyF38 = tc.getstr("kf38")
+	t.KeyF39 = tc.getstr("kf39")
+	t.KeyF40 = tc.getstr("kf40")
+	t.KeyF41 = tc.getstr("kf41")
+	t.KeyF42 = tc.getstr("kf42")
+	t.KeyF43 = tc.getstr("kf43")
+	t.KeyF44 = tc.getstr("kf44")
+	t.KeyF45 = tc.getstr("kf45")
+	t.KeyF46 = tc.getstr("kf46")
+	t.KeyF47 = tc.getstr("kf47")
+	t.KeyF48 = tc.getstr("kf48")
+	t.KeyF49 = tc.getstr("kf49")
+	t.KeyF50 = tc.getstr("kf50")
+	t.KeyF51 = tc.getstr("kf51")
+	t.KeyF52 = tc.getstr("kf52")
+	t.KeyF53 = tc.getstr("kf53")
+	t.KeyF54 = tc.getstr("kf54")
+	t.KeyF55 = tc.getstr("kf55")
+	t.KeyF56 = tc.getstr("kf56")
+	t.KeyF57 = tc.getstr("kf57")
+	t.KeyF58 = tc.getstr("kf58")
+	t.KeyF59 = tc.getstr("kf59")
+	t.KeyF60 = tc.getstr("kf60")
+	t.KeyF61 = tc.getstr("kf61")
+	t.KeyF62 = tc.getstr("kf62")
+	t.KeyF63 = tc.getstr("kf63")
+	t.KeyF64 = tc.getstr("kf64")
+	t.KeyInsert = tc.getstr("kich1")
+	t.KeyDelete = tc.getstr("kdch1")
+	t.KeyBackspace = tc.getstr("kbs")
+	t.KeyHome = tc.getstr("khome")
+	t.KeyEnd = tc.getstr("kend")
+	t.KeyUp = tc.getstr("kcuu1")
+	t.KeyDown = tc.getstr("kcud1")
+	t.KeyRight = tc.getstr("kcuf1")
+	t.KeyLeft = tc.getstr("kcub1")
+	t.KeyPgDn = tc.getstr("knp")
+	t.KeyPgUp = tc.getstr("kpp")
+	t.KeyBacktab = tc.getstr("kcbt")
+	t.KeyExit = tc.getstr("kext")
+	t.KeyCancel = tc.getstr("kcan")
+	t.KeyPrint = tc.getstr("kprt")
+	t.KeyHelp = tc.getstr("khlp")
+	t.KeyClear = tc.getstr("kclr")
+	t.AltChars = tc.getstr("acsc")
+	t.EnterAcs = tc.getstr("smacs")
+	t.ExitAcs = tc.getstr("rmacs")
+	t.EnableAcs = tc.getstr("enacs")
+	t.Mouse = tc.getstr("kmous")
+	t.KeyShfRight = tc.getstr("kRIT")
+	t.KeyShfLeft = tc.getstr("kLFT")
+	t.KeyShfHome = tc.getstr("kHOM")
+	t.KeyShfEnd = tc.getstr("kEND")
+
+	// Terminfo lacks descriptions for a bunch of modified keys,
+	// but modern XTerm and emulators often have them.  Let's add them,
+	// if the shifted right and left arrows are defined.
+	if t.KeyShfRight == "\x1b[1;2C" && t.KeyShfLeft == "\x1b[1;2D" {
+		t.KeyShfUp = "\x1b[1;2A"
+		t.KeyShfDown = "\x1b[1;2B"
+		t.KeyMetaUp = "\x1b[1;9A"
+		t.KeyMetaDown = "\x1b[1;9B"
+		t.KeyMetaRight = "\x1b[1;9C"
+		t.KeyMetaLeft = "\x1b[1;9D"
+		t.KeyAltUp = "\x1b[1;3A"
+		t.KeyAltDown = "\x1b[1;3B"
+		t.KeyAltRight = "\x1b[1;3C"
+		t.KeyAltLeft = "\x1b[1;3D"
+		t.KeyCtrlUp = "\x1b[1;5A"
+		t.KeyCtrlDown = "\x1b[1;5B"
+		t.KeyCtrlRight = "\x1b[1;5C"
+		t.KeyCtrlLeft = "\x1b[1;5D"
+		t.KeyAltShfUp = "\x1b[1;4A"
+		t.KeyAltShfDown = "\x1b[1;4B"
+		t.KeyAltShfRight = "\x1b[1;4C"
+		t.KeyAltShfLeft = "\x1b[1;4D"
+
+		t.KeyMetaShfUp = "\x1b[1;10A"
+		t.KeyMetaShfDown = "\x1b[1;10B"
+		t.KeyMetaShfRight = "\x1b[1;10C"
+		t.KeyMetaShfLeft = "\x1b[1;10D"
+
+		t.KeyCtrlShfUp = "\x1b[1;6A"
+		t.KeyCtrlShfDown = "\x1b[1;6B"
+		t.KeyCtrlShfRight = "\x1b[1;6C"
+		t.KeyCtrlShfLeft = "\x1b[1;6D"
+	}
+	// And also for Home and End
+	if t.KeyShfHome == "\x1b[1;2H" && t.KeyShfEnd == "\x1b[1;2F" {
+		t.KeyCtrlHome = "\x1b[1;5H"
+		t.KeyCtrlEnd = "\x1b[1;5F"
+		t.KeyAltHome = "\x1b[1;9H"
+		t.KeyAltEnd = "\x1b[1;9F"
+		t.KeyCtrlShfHome = "\x1b[1;6H"
+		t.KeyCtrlShfEnd = "\x1b[1;6F"
+		t.KeyAltShfHome = "\x1b[1;4H"
+		t.KeyAltShfEnd = "\x1b[1;4F"
+		t.KeyMetaShfHome = "\x1b[1;10H"
+		t.KeyMetaShfEnd = "\x1b[1;10F"
+	}
+
+	// And the same thing for rxvt and workalikes (Eterm, aterm, etc.)
+	// It seems that urxvt at least send ESC as ALT prefix for these,
+	// although some places seem to indicate a separate ALT key sesquence.
+	if t.KeyShfRight == "\x1b[c" && t.KeyShfLeft == "\x1b[d" {
+		t.KeyShfUp = "\x1b[a"
+		t.KeyShfDown = "\x1b[b"
+		t.KeyCtrlUp = "\x1b[Oa"
+		t.KeyCtrlDown = "\x1b[Ob"
+		t.KeyCtrlRight = "\x1b[Oc"
+		t.KeyCtrlLeft = "\x1b[Od"
+	}
+	if t.KeyShfHome == "\x1b[7$" && t.KeyShfEnd == "\x1b[8$" {
+		t.KeyCtrlHome = "\x1b[7^"
+		t.KeyCtrlEnd = "\x1b[8^"
+	}
+
+	// If the kmous entry is present, then we need to record the
+	// the codes to enter and exit mouse mode.  Sadly, this is not
+	// part of the terminfo databases anywhere that I've found, but
+	// is an extension.  The escape codes are documented in the XTerm
+	// manual, and all terminals that have kmous are expected to
+	// use these same codes, unless explicitly configured otherwise
+	// vi XM.  Note that in any event, we only known how to parse either
+	// x11 or SGR mouse events -- if your terminal doesn't support one
+	// of these two forms, you maybe out of luck.
+	t.MouseMode = tc.getstr("XM")
+	if t.Mouse != "" && t.MouseMode == "" {
+		// we anticipate that all xterm mouse tracking compatible
+		// terminals understand mouse tracking (1000), but we hope
+		// that those that don't understand any-event tracking (1003)
+		// will at least ignore it.  Likewise we hope that terminals
+		// that don't understand SGR reporting (1006) just ignore it.
+		t.MouseMode = "%?%p1%{1}%=%t%'h'%Pa%e%'l'%Pa%;" +
+			"\x1b[?1000%ga%c\x1b[?1002%ga%c\x1b[?1003%ga%c\x1b[?1006%ga%c"
+	}
+
+	// We only support colors in ANSI 8 or 256 color mode.
+	if t.Colors < 8 || t.SetFg == "" {
+		t.Colors = 0
+	}
+	if t.SetCursor == "" {
+		return nil, "", notaddressable
+	}
+
+	// For padding, we lookup the pad char.  If that isn't present,
+	// and npc is *not* set, then we assume a null byte.
+	t.PadChar = tc.getstr("pad")
+	if t.PadChar == "" {
+		if !tc.getflag("npc") {
+			t.PadChar = "\u0000"
+		}
+	}
+
+	// For some terminals we fabricate a -truecolor entry, that may
+	// not exist in terminfo.
+	if addTrueColor {
+		t.SetFgRGB = "\x1b[38;2;%p1%d;%p2%d;%p3%dm"
+		t.SetBgRGB = "\x1b[48;2;%p1%d;%p2%d;%p3%dm"
+		t.SetFgBgRGB = "\x1b[38;2;%p1%d;%p2%d;%p3%d;" +
+			"48;2;%p4%d;%p5%d;%p6%dm"
+	}
+
+	// For terminals that use "standard" SGR sequences, lets combine the
+	// foreground and background together.
+	if strings.HasPrefix(t.SetFg, "\x1b[") &&
+		strings.HasPrefix(t.SetBg, "\x1b[") &&
+		strings.HasSuffix(t.SetFg, "m") &&
+		strings.HasSuffix(t.SetBg, "m") {
+		fg := t.SetFg[:len(t.SetFg)-1]
+		r := regexp.MustCompile("%p1")
+		bg := r.ReplaceAllString(t.SetBg[2:], "%p2")
+		t.SetFgBg = fg + ";" + bg
+	}
+
+	return t, tc.desc, nil
+}
+
+func GetDynamic() (term *Terminfo, err error) {
+	term, _, err = getinfo(os.Getenv("TERM"))
+	return
+}

vendor/maunium.net/go/tcell/terminfo/term_putty.go

@@ -1,73 +0,0 @@
-// Generated automatically.  DO NOT HAND-EDIT.
-
-package terminfo
-
-func init() {
-	// PuTTY terminal emulator
-	AddTerminfo(&Terminfo{
-		Name:          "putty",
-		Colors:        8,
-		Bell:          "\a",
-		Clear:         "\x1b[H\x1b[J",
-		EnterCA:       "\x1b[?47h",
-		ExitCA:        "\x1b[2J\x1b[?47l",
-		ShowCursor:    "\x1b[?25h",
-		HideCursor:    "\x1b[?25l",
-		AttrOff:       "\x1b[m\x0f",
-		Underline:     "\x1b[4m",
-		Bold:          "\x1b[1m",
-		Italic:        "\x1b[3m",
-		Strikethrough: "\x1b[9m",
-		Blink:         "\x1b[5m",
-		Reverse:       "\x1b[7m",
-		EnterKeypad:   "\x1b[?1h\x1b=",
-		ExitKeypad:    "\x1b[?1l\x1b>",
-		SetFg:         "\x1b[3%p1%dm",
-		SetBg:         "\x1b[4%p1%dm",
-		SetFgBg:       "\x1b[3%p1%d;4%p2%dm",
-		PadChar:       "\x00",
-		AltChars:      "``aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
-		EnterAcs:      "\x0e",
-		ExitAcs:       "\x0f",
-		EnableAcs:     "\x1b(B\x1b)0",
-		Mouse:         "\x1b[M",
-		MouseMode:     "%?%p1%{1}%=%t%'h'%Pa%e%'l'%Pa%;\x1b[?1000%ga%c\x1b[?1002%ga%c\x1b[?1003%ga%c\x1b[?1006%ga%c",
-		SetCursor:     "\x1b[%i%p1%d;%p2%dH",
-		CursorBack1:   "\b",
-		CursorUp1:     "\x1bM",
-		KeyUp:         "\x1bOA",
-		KeyDown:       "\x1bOB",
-		KeyRight:      "\x1bOC",
-		KeyLeft:       "\x1bOD",
-		KeyInsert:     "\x1b[2~",
-		KeyDelete:     "\x1b[3~",
-		KeyBackspace:  "\xff",
-		KeyHome:       "\x1b[1~",
-		KeyEnd:        "\x1b[4~",
-		KeyPgUp:       "\x1b[5~",
-		KeyPgDn:       "\x1b[6~",
-		KeyF1:         "\x1b[11~",
-		KeyF2:         "\x1b[12~",
-		KeyF3:         "\x1b[13~",
-		KeyF4:         "\x1b[14~",
-		KeyF5:         "\x1b[15~",
-		KeyF6:         "\x1b[17~",
-		KeyF7:         "\x1b[18~",
-		KeyF8:         "\x1b[19~",
-		KeyF9:         "\x1b[20~",
-		KeyF10:        "\x1b[21~",
-		KeyF11:        "\x1b[23~",
-		KeyF12:        "\x1b[24~",
-		KeyF13:        "\x1b[25~",
-		KeyF14:        "\x1b[26~",
-		KeyF15:        "\x1b[28~",
-		KeyF16:        "\x1b[29~",
-		KeyF17:        "\x1b[31~",
-		KeyF18:        "\x1b[32~",
-		KeyF19:        "\x1b[33~",
-		KeyF20:        "\x1b[34~",
-		KeyBacktab:    "\x1b[Z",
-		KeyShfLeft:    "\x1b[D",
-		KeyShfRight:   "\x1b[C",
-	})
-}

vendor/maunium.net/go/tcell/terminfo/term_xterm_termite.go

@@ -1,154 +0,0 @@
-// Generated automatically.  DO NOT HAND-EDIT.
-
-package terminfo
-
-func init() {
-	// VTE-based terminal
-	AddTerminfo(&Terminfo{
-		Name:            "xterm-termite",
-		Columns:         80,
-		Lines:           24,
-		Colors:          256,
-		Bell:            "\a",
-		Clear:           "\x1b[H\x1b[2J",
-		EnterCA:         "\x1b[?1049h",
-		ExitCA:          "\x1b[?1049l",
-		ShowCursor:      "\x1b[?12l\x1b[?25h",
-		HideCursor:      "\x1b[?25l",
-		AttrOff:         "\x1b(B\x1b[m",
-		Underline:       "\x1b[4m",
-		Bold:            "\x1b[1m",
-		Italic:          "\x1b[3m",
-		Strikethrough:   "\x1b[9m",
-		Dim:             "\x1b[2m",
-		Reverse:         "\x1b[7m",
-		EnterKeypad:     "\x1b[?1h\x1b=",
-		ExitKeypad:      "\x1b[?1l\x1b>",
-		SetFg:           "\x1b[%?%p1%{8}%<%t3%p1%d%e%p1%{16}%<%t9%p1%{8}%-%d%e38;5;%p1%d%;m",
-		SetBg:           "\x1b[%?%p1%{8}%<%t4%p1%d%e%p1%{16}%<%t10%p1%{8}%-%d%e48;5;%p1%d%;m",
-		SetFgBg:         "\x1b[%?%p1%{8}%<%t3%p1%d%e%p1%{16}%<%t9%p1%{8}%-%d%e38;5;%p1%d%;;%?%p2%{8}%<%t4%p2%d%e%p2%{16}%<%t10%p2%{8}%-%d%e48;5;%p2%d%;m",
-		AltChars:        "++,,--..00``aaffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
-		EnterAcs:        "\x1b(0",
-		ExitAcs:         "\x1b(B",
-		Mouse:           "\x1b[M",
-		MouseMode:       "%?%p1%{1}%=%t%'h'%Pa%e%'l'%Pa%;\x1b[?1000%ga%c\x1b[?1002%ga%c\x1b[?1003%ga%c\x1b[?1006%ga%c",
-		SetCursor:       "\x1b[%i%p1%d;%p2%dH",
-		CursorBack1:     "\b",
-		CursorUp1:       "\x1b[A",
-		KeyUp:           "\x1bOA",
-		KeyDown:         "\x1bOB",
-		KeyRight:        "\x1bOC",
-		KeyLeft:         "\x1bOD",
-		KeyInsert:       "\x1b[2~",
-		KeyDelete:       "\x1b[3~",
-		KeyBackspace:    "\xff",
-		KeyHome:         "\x1bOH",
-		KeyEnd:          "\x1bOF",
-		KeyPgUp:         "\x1b[5~",
-		KeyPgDn:         "\x1b[6~",
-		KeyF1:           "\x1bOP",
-		KeyF2:           "\x1bOQ",
-		KeyF3:           "\x1bOR",
-		KeyF4:           "\x1bOS",
-		KeyF5:           "\x1b[15~",
-		KeyF6:           "\x1b[17~",
-		KeyF7:           "\x1b[18~",
-		KeyF8:           "\x1b[19~",
-		KeyF9:           "\x1b[20~",
-		KeyF10:          "\x1b[21~",
-		KeyF11:          "\x1b[23~",
-		KeyF12:          "\x1b[24~",
-		KeyF13:          "\x1b[1;2P",
-		KeyF14:          "\x1b[1;2Q",
-		KeyF15:          "\x1b[1;2R",
-		KeyF16:          "\x1b[1;2S",
-		KeyF17:          "\x1b[15;2~",
-		KeyF18:          "\x1b[17;2~",
-		KeyF19:          "\x1b[18;2~",
-		KeyF20:          "\x1b[19;2~",
-		KeyF21:          "\x1b[20;2~",
-		KeyF22:          "\x1b[21;2~",
-		KeyF23:          "\x1b[23;2~",
-		KeyF24:          "\x1b[24;2~",
-		KeyF25:          "\x1b[1;5P",
-		KeyF26:          "\x1b[1;5Q",
-		KeyF27:          "\x1b[1;5R",
-		KeyF28:          "\x1b[1;5S",
-		KeyF29:          "\x1b[15;5~",
-		KeyF30:          "\x1b[17;5~",
-		KeyF31:          "\x1b[18;5~",
-		KeyF32:          "\x1b[19;5~",
-		KeyF33:          "\x1b[20;5~",
-		KeyF34:          "\x1b[21;5~",
-		KeyF35:          "\x1b[23;5~",
-		KeyF36:          "\x1b[24;5~",
-		KeyF37:          "\x1b[1;6P",
-		KeyF38:          "\x1b[1;6Q",
-		KeyF39:          "\x1b[1;6R",
-		KeyF40:          "\x1b[1;6S",
-		KeyF41:          "\x1b[15;6~",
-		KeyF42:          "\x1b[17;6~",
-		KeyF43:          "\x1b[18;6~",
-		KeyF44:          "\x1b[19;6~",
-		KeyF45:          "\x1b[20;6~",
-		KeyF46:          "\x1b[21;6~",
-		KeyF47:          "\x1b[23;6~",
-		KeyF48:          "\x1b[24;6~",
-		KeyF49:          "\x1b[1;3P",
-		KeyF50:          "\x1b[1;3Q",
-		KeyF51:          "\x1b[1;3R",
-		KeyF52:          "\x1b[1;3S",
-		KeyF53:          "\x1b[15;3~",
-		KeyF54:          "\x1b[17;3~",
-		KeyF55:          "\x1b[18;3~",
-		KeyF56:          "\x1b[19;3~",
-		KeyF57:          "\x1b[20;3~",
-		KeyF58:          "\x1b[21;3~",
-		KeyF59:          "\x1b[23;3~",
-		KeyF60:          "\x1b[24;3~",
-		KeyF61:          "\x1b[1;4P",
-		KeyF62:          "\x1b[1;4Q",
-		KeyF63:          "\x1b[1;4R",
-		KeyBacktab:      "\x1b[Z",
-		KeyShfLeft:      "\x1b[1;2D",
-		KeyShfRight:     "\x1b[1;2C",
-		KeyShfUp:        "\x1b[1;2A",
-		KeyShfDown:      "\x1b[1;2B",
-		KeyCtrlLeft:     "\x1b[1;5D",
-		KeyCtrlRight:    "\x1b[1;5C",
-		KeyCtrlUp:       "\x1b[1;5A",
-		KeyCtrlDown:     "\x1b[1;5B",
-		KeyMetaLeft:     "\x1b[1;9D",
-		KeyMetaRight:    "\x1b[1;9C",
-		KeyMetaUp:       "\x1b[1;9A",
-		KeyMetaDown:     "\x1b[1;9B",
-		KeyAltLeft:      "\x1b[1;3D",
-		KeyAltRight:     "\x1b[1;3C",
-		KeyAltUp:        "\x1b[1;3A",
-		KeyAltDown:      "\x1b[1;3B",
-		KeyAltShfLeft:   "\x1b[1;4D",
-		KeyAltShfRight:  "\x1b[1;4C",
-		KeyAltShfUp:     "\x1b[1;4A",
-		KeyAltShfDown:   "\x1b[1;4B",
-		KeyMetaShfLeft:  "\x1b[1;10D",
-		KeyMetaShfRight: "\x1b[1;10C",
-		KeyMetaShfUp:    "\x1b[1;10A",
-		KeyMetaShfDown:  "\x1b[1;10B",
-		KeyCtrlShfLeft:  "\x1b[1;6D",
-		KeyCtrlShfRight: "\x1b[1;6C",
-		KeyCtrlShfUp:    "\x1b[1;6A",
-		KeyCtrlShfDown:  "\x1b[1;6B",
-		KeyShfHome:      "\x1b[1;2H",
-		KeyShfEnd:       "\x1b[1;2F",
-		KeyCtrlHome:     "\x1b[1;5H",
-		KeyCtrlEnd:      "\x1b[1;5F",
-		KeyAltHome:      "\x1b[1;9H",
-		KeyAltEnd:       "\x1b[1;9F",
-		KeyCtrlShfHome:  "\x1b[1;6H",
-		KeyCtrlShfEnd:   "\x1b[1;6F",
-		KeyMetaShfHome:  "\x1b[1;10H",
-		KeyMetaShfEnd:   "\x1b[1;10F",
-		KeyAltShfHome:   "\x1b[1;4H",
-		KeyAltShfEnd:    "\x1b[1;4F",
-	})
-}

vendor/maunium.net/go/tcell/terminfo/terminfo.go

@@ -871,6 +871,9 @@ func LookupTerminfo(name string) (*Terminfo, error) {
 			dblock.Unlock()
 		}
 	}
+	if t == nil {
+		t, _ = GetDynamic()
+	}
 	if t == nil {
 		return nil, ErrTermNotFound
 	}