Добавление зависимостей

libtui/v0/app/app.go

@@ -2,6 +2,10 @@
 package app
 
 import (
+	"fmt"
+
+	"github.com/gdamore/tcell"
+
 	"p78git.ddns.net/svi/libtui/screen"
 	"p78git.ddns.net/svi/libtui/types"
 )
@@ -9,6 +13,7 @@ import (
 // App -- объектприложения
 type App struct {
 	screen types.IScreen // Объект приложения
+	scr    tcell.Screen  // Библиотечный экран
 }
 
 // NewApp -- возвращает новый объект приложения
@@ -25,6 +30,22 @@ func (sf *App) Screen() types.IScreen {
 }
 
 // Run -- запускает объект приложения в работу
-func (sf *App) Run() {
+func (sf *App) Run() error {
+	if err := sf.run_init(); err != nil {
+		return fmt.Errorf("App.Run(): ininit screen, err=\n\t%w", err)
+	}
+	return fmt.Errorf("App.Run(): доделать")
+}
 
+// Включение экрана терминала
+func (sf *App) run_init() error {
+	var err error
+	sf.scr, err = tcell.NewScreen()
+	if err != nil {
+		return fmt.Errorf("App.run_init(): in create tcell.Screen, err=\n\t%w", err)
+	}
+	if err = sf.scr.Init(); err != nil {
+		return fmt.Errorf("App.run_init(): in init tcell.Screen, err=\n\t%w", err)
+	}
+	return nil
 }

libtui/v0/app/app_test.go

@@ -36,5 +36,8 @@ func (sf *tester) create() {
 	if scr == nil {
 		sf.t.Fatalf("create(): screen==nil")
 	}
-	sf.iapp.Run()
+	err := sf.iapp.Run()
+	if err != nil {
+		sf.t.Fatalf("create(): in run app, err=%v", err)
+	}
 }

libtui/v0/go.mod

@@ -1,3 +1,13 @@
 module p78git.ddns.net/svi/libtui
 
 go 1.20
+
+require github.com/gdamore/tcell v1.4.0
+
+require (
+	github.com/gdamore/encoding v1.0.0 // indirect
+	github.com/lucasb-eyer/go-colorful v1.0.3 // indirect
+	github.com/mattn/go-runewidth v0.0.7 // indirect
+	golang.org/x/sys v0.0.0-20190626150813-e07cf5db2756 // indirect
+	golang.org/x/text v0.3.0 // indirect
+)

libtui/v0/go.sum

@@ -0,0 +1,12 @@
+github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
+github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
+github.com/gdamore/tcell v1.4.0 h1:vUnHwJRvcPQa3tzi+0QI4U9JINXYJlOz9yiaiPQ2wMU=
+github.com/gdamore/tcell v1.4.0/go.mod h1:vxEiSDZdW3L+Uhjii9c3375IlDmR05bzxY404ZVSMo0=
+github.com/lucasb-eyer/go-colorful v1.0.3 h1:QIbQXiugsb+q10B+MI+7DI1oQLdmnep86tWFlaaUAac=
+github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/mattn/go-runewidth v0.0.7 h1:Ei8KR0497xHyKJPAv59M1dkC+rOZCMBJ+t3fZ+twI54=
+github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+golang.org/x/sys v0.0.0-20190626150813-e07cf5db2756 h1:9nuHUbU8dRnRRfj9KjWUVrJeoexdbeMjttk6Oh1rD10=
+golang.org/x/sys v0.0.0-20190626150813-e07cf5db2756/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=

libtui/v0/types/iapp.go

@@ -5,5 +5,5 @@ type IApp interface {
 	// Screen -- объект экрана
 	Screen() IScreen
 	// Run -- запускает объект приложения в работу
-	Run()
+	Run() error
 }

libtui/v0/vendor/github.com/gdamore/encoding/.appveyor.yml

@@ -0,0 +1,13 @@
+version: 1.0.{build}
+clone_folder: c:\gopath\src\github.com\gdamore\encoding
+environment:
+  GOPATH: c:\gopath
+build_script:
+- go version
+- go env
+- SET PATH=%LOCALAPPDATA%\atom\bin;%GOPATH%\bin;%PATH%
+- go get -t ./...
+- go build
+- go install ./...
+test_script:
+- go test ./...

libtui/v0/vendor/github.com/gdamore/encoding/.travis.yml

@@ -0,0 +1,7 @@
+language: go
+
+go:
+  - 1.9.x
+  - 1.10.x
+  - 1.11.x
+  - tip

libtui/v0/vendor/github.com/gdamore/encoding/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this 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.

libtui/v0/vendor/github.com/gdamore/encoding/README.md

@@ -0,0 +1,19 @@
+## encoding
+
+[![Linux Status](https://img.shields.io/travis/gdamore/encoding.svg?label=linux)](https://travis-ci.org/gdamore/encoding)
+[![Windows Status](https://img.shields.io/appveyor/ci/gdamore/encoding.svg?label=windows)](https://ci.appveyor.com/project/gdamore/encoding)
+[![Apache License](https://img.shields.io/badge/license-APACHE2-blue.svg)](https://github.com/gdamore/encoding/blob/master/LICENSE)
+[![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)](https://godoc.org/github.com/gdamore/encoding)
+[![Go Report Card](http://goreportcard.com/badge/gdamore/encoding)](http://goreportcard.com/report/gdamore/encoding)
+
+Package encoding provides a number of encodings that are missing from the
+standard Go [encoding]("https://godoc.org/golang.org/x/text/encoding") package.
+
+We hope that we can contribute these to the standard Go library someday.  It
+turns out that some of these are useful for dealing with I/O streams coming
+from non-UTF friendly sources.
+
+The UTF8 Encoder is also useful for situations where valid UTF-8 might be
+carried in streams that contain non-valid UTF; in particular I use it for
+helping me cope with terminals that embed escape sequences in otherwise
+valid UTF-8.

libtui/v0/vendor/github.com/gdamore/encoding/ascii.go

@@ -0,0 +1,36 @@
+// Copyright 2015 Garrett D'Amore
+//
+// 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.
+
+package encoding
+
+import (
+	"golang.org/x/text/encoding"
+)
+
+// ASCII represents the 7-bit US-ASCII scheme.  It decodes directly to
+// UTF-8 without change, as all ASCII values are legal UTF-8.
+// Unicode values less than 128 (i.e. 7 bits) map 1:1 with ASCII.
+// It encodes runes outside of that to 0x1A, the ASCII substitution character.
+var ASCII encoding.Encoding
+
+func init() {
+	amap := make(map[byte]rune)
+	for i := 128; i <= 255; i++ {
+		amap[byte(i)] = RuneError
+	}
+
+	cm := &Charmap{Map: amap}
+	cm.Init()
+	ASCII = cm
+}

libtui/v0/vendor/github.com/gdamore/encoding/charmap.go

@@ -0,0 +1,196 @@
+// Copyright 2015 Garrett D'Amore
+//
+// 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.
+
+package encoding
+
+import (
+	"sync"
+	"unicode/utf8"
+
+	"golang.org/x/text/encoding"
+	"golang.org/x/text/transform"
+)
+
+const (
+	// RuneError is an alias for the UTF-8 replacement rune, '\uFFFD'.
+	RuneError = '\uFFFD'
+
+	// RuneSelf is the rune below which UTF-8 and the Unicode values are
+	// identical.  Its also the limit for ASCII.
+	RuneSelf = 0x80
+
+	// ASCIISub is the ASCII substitution character.
+	ASCIISub = '\x1a'
+)
+
+// Charmap is a structure for setting up encodings for 8-bit character sets,
+// for transforming between UTF8 and that other character set.  It has some
+// ideas borrowed from golang.org/x/text/encoding/charmap, but it uses a
+// different implementation.  This implementation uses maps, and supports
+// user-defined maps.
+//
+// We do assume that a character map has a reasonable substitution character,
+// and that valid encodings are stable (exactly a 1:1 map) and stateless
+// (that is there is no shift character or anything like that.)  Hence this
+// approach will not work for many East Asian character sets.
+//
+// Measurement shows little or no measurable difference in the performance of
+// the two approaches.  The difference was down to a couple of nsec/op, and
+// no consistent pattern as to which ran faster.  With the conversion to
+// UTF-8 the code takes about 25 nsec/op.  The conversion in the reverse
+// direction takes about 100 nsec/op.  (The larger cost for conversion
+// from UTF-8 is most likely due to the need to convert the UTF-8 byte stream
+// to a rune before conversion.
+//
+type Charmap struct {
+	transform.NopResetter
+	bytes map[rune]byte
+	runes [256][]byte
+	once  sync.Once
+
+	// The map between bytes and runes.  To indicate that a specific
+	// byte value is invalid for a charcter set, use the rune
+	// utf8.RuneError.  Values that are absent from this map will
+	// be assumed to have the identity mapping -- that is the default
+	// is to assume ISO8859-1, where all 8-bit characters have the same
+	// numeric value as their Unicode runes.  (Not to be confused with
+	// the UTF-8 values, which *will* be different for non-ASCII runes.)
+	//
+	// If no values less than RuneSelf are changed (or have non-identity
+	// mappings), then the character set is assumed to be an ASCII
+	// superset, and certain assumptions and optimizations become
+	// available for ASCII bytes.
+	Map map[byte]rune
+
+	// The ReplacementChar is the byte value to use for substitution.
+	// It should normally be ASCIISub for ASCII encodings.  This may be
+	// unset (left to zero) for mappings that are strictly ASCII supersets.
+	// In that case ASCIISub will be assumed instead.
+	ReplacementChar byte
+}
+
+type cmapDecoder struct {
+	transform.NopResetter
+	runes [256][]byte
+}
+
+type cmapEncoder struct {
+	transform.NopResetter
+	bytes   map[rune]byte
+	replace byte
+}
+
+// Init initializes internal values of a character map.  This should
+// be done early, to minimize the cost of allocation of transforms
+// later.  It is not strictly necessary however, as the allocation
+// functions will arrange to call it if it has not already been done.
+func (c *Charmap) Init() {
+	c.once.Do(c.initialize)
+}
+
+func (c *Charmap) initialize() {
+	c.bytes = make(map[rune]byte)
+	ascii := true
+
+	for i := 0; i < 256; i++ {
+		r, ok := c.Map[byte(i)]
+		if !ok {
+			r = rune(i)
+		}
+		if r < 128 && r != rune(i) {
+			ascii = false
+		}
+		if r != RuneError {
+			c.bytes[r] = byte(i)
+		}
+		utf := make([]byte, utf8.RuneLen(r))
+		utf8.EncodeRune(utf, r)
+		c.runes[i] = utf
+	}
+	if ascii && c.ReplacementChar == '\x00' {
+		c.ReplacementChar = ASCIISub
+	}
+}
+
+// NewDecoder returns a Decoder the converts from the 8-bit
+// character set to UTF-8.  Unknown mappings, if any, are mapped
+// to '\uFFFD'.
+func (c *Charmap) NewDecoder() *encoding.Decoder {
+	c.Init()
+	return &encoding.Decoder{Transformer: &cmapDecoder{runes: c.runes}}
+}
+
+// NewEncoder returns a Transformer that converts from UTF8 to the
+// 8-bit character set.  Unknown mappings are mapped to 0x1A.
+func (c *Charmap) NewEncoder() *encoding.Encoder {
+	c.Init()
+	return &encoding.Encoder{
+		Transformer: &cmapEncoder{
+			bytes:   c.bytes,
+			replace: c.ReplacementChar,
+		},
+	}
+}
+
+func (d *cmapDecoder) Transform(dst, src []byte, atEOF bool) (int, int, error) {
+	var e error
+	var ndst, nsrc int
+
+	for _, c := range src {
+		b := d.runes[c]
+		l := len(b)
+
+		if ndst+l > len(dst) {
+			e = transform.ErrShortDst
+			break
+		}
+		for i := 0; i < l; i++ {
+			dst[ndst] = b[i]
+			ndst++
+		}
+		nsrc++
+	}
+	return ndst, nsrc, e
+}
+
+func (d *cmapEncoder) Transform(dst, src []byte, atEOF bool) (int, int, error) {
+	var e error
+	var ndst, nsrc int
+	for nsrc < len(src) {
+		if ndst >= len(dst) {
+			e = transform.ErrShortDst
+			break
+		}
+
+		r, sz := utf8.DecodeRune(src[nsrc:])
+		if r == utf8.RuneError && sz == 1 {
+			// If its inconclusive due to insufficient data in
+			// in the source, report it
+			if !atEOF && !utf8.FullRune(src[nsrc:]) {
+				e = transform.ErrShortSrc
+				break
+			}
+		}
+
+		if c, ok := d.bytes[r]; ok {
+			dst[ndst] = c
+		} else {
+			dst[ndst] = d.replace
+		}
+		nsrc += sz
+		ndst++
+	}
+
+	return ndst, nsrc, e
+}

libtui/v0/vendor/github.com/gdamore/encoding/doc.go

@@ -0,0 +1,17 @@
+// Copyright 2015 Garrett D'Amore
+//
+// 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.
+
+// Package encoding provides a few of the encoding structures that are
+// missing from the Go x/text/encoding tree.
+package encoding

libtui/v0/vendor/github.com/gdamore/encoding/ebcdic.go

@@ -0,0 +1,273 @@
+// Copyright 2015 Garrett D'Amore
+//
+// 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.
+
+package encoding
+
+import (
+	"golang.org/x/text/encoding"
+)
+
+// EBCDIC represents the 8-bit EBCDIC scheme, found in some mainframe
+// environments.  If you don't know what this is, consider yourself lucky.
+var EBCDIC encoding.Encoding
+
+func init() {
+	cm := &Charmap{
+		ReplacementChar: '\x3f',
+		Map: map[byte]rune{
+			// 0x00-0x03 match
+			0x04: RuneError,
+			0x05: '\t',
+			0x06: RuneError,
+			0x07: '\x7f',
+			0x08: RuneError,
+			0x09: RuneError,
+			0x0a: RuneError,
+			// 0x0b-0x13 match
+			0x14: RuneError,
+			0x15: '\x85', // Not in any ISO code
+			0x16: '\x08',
+			0x17: RuneError,
+			// 0x18-0x19 match
+			0x1a: RuneError,
+			0x1b: RuneError,
+			// 0x1c-0x1f match
+			0x20: RuneError,
+			0x21: RuneError,
+			0x22: RuneError,
+			0x23: RuneError,
+			0x24: RuneError,
+			0x25: '\n',
+			0x26: '\x17',
+			0x27: '\x1b',
+			0x28: RuneError,
+			0x29: RuneError,
+			0x2a: RuneError,
+			0x2b: RuneError,
+			0x2c: RuneError,
+			0x2d: '\x05',
+			0x2e: '\x06',
+			0x2f: '\x07',
+			0x30: RuneError,
+			0x31: RuneError,
+			0x32: '\x16',
+			0x33: RuneError,
+			0x34: RuneError,
+			0x35: RuneError,
+			0x36: RuneError,
+			0x37: '\x04',
+			0x38: RuneError,
+			0x39: RuneError,
+			0x3a: RuneError,
+			0x3b: RuneError,
+			0x3c: '\x14',
+			0x3d: '\x15',
+			0x3e: RuneError,
+			0x3f: '\x1a', // also replacement char
+			0x40: ' ',
+			0x41: '\xa0',
+			0x42: RuneError,
+			0x43: RuneError,
+			0x44: RuneError,
+			0x45: RuneError,
+			0x46: RuneError,
+			0x47: RuneError,
+			0x48: RuneError,
+			0x49: RuneError,
+			0x4a: RuneError,
+			0x4b: '.',
+			0x4c: '<',
+			0x4d: '(',
+			0x4e: '+',
+			0x4f: '|',
+			0x50: '&',
+			0x51: RuneError,
+			0x52: RuneError,
+			0x53: RuneError,
+			0x54: RuneError,
+			0x55: RuneError,
+			0x56: RuneError,
+			0x57: RuneError,
+			0x58: RuneError,
+			0x59: RuneError,
+			0x5a: '!',
+			0x5b: '$',
+			0x5c: '*',
+			0x5d: ')',
+			0x5e: ';',
+			0x5f: '¬',
+			0x60: '-',
+			0x61: '/',
+			0x62: RuneError,
+			0x63: RuneError,
+			0x64: RuneError,
+			0x65: RuneError,
+			0x66: RuneError,
+			0x67: RuneError,
+			0x68: RuneError,
+			0x69: RuneError,
+			0x6a: '¦',
+			0x6b: ',',
+			0x6c: '%',
+			0x6d: '_',
+			0x6e: '>',
+			0x6f: '?',
+			0x70: RuneError,
+			0x71: RuneError,
+			0x72: RuneError,
+			0x73: RuneError,
+			0x74: RuneError,
+			0x75: RuneError,
+			0x76: RuneError,
+			0x77: RuneError,
+			0x78: RuneError,
+			0x79: '`',
+			0x7a: ':',
+			0x7b: '#',
+			0x7c: '@',
+			0x7d: '\'',
+			0x7e: '=',
+			0x7f: '"',
+			0x80: RuneError,
+			0x81: 'a',
+			0x82: 'b',
+			0x83: 'c',
+			0x84: 'd',
+			0x85: 'e',
+			0x86: 'f',
+			0x87: 'g',
+			0x88: 'h',
+			0x89: 'i',
+			0x8a: RuneError,
+			0x8b: RuneError,
+			0x8c: RuneError,
+			0x8d: RuneError,
+			0x8e: RuneError,
+			0x8f: '±',
+			0x90: RuneError,
+			0x91: 'j',
+			0x92: 'k',
+			0x93: 'l',
+			0x94: 'm',
+			0x95: 'n',
+			0x96: 'o',
+			0x97: 'p',
+			0x98: 'q',
+			0x99: 'r',
+			0x9a: RuneError,
+			0x9b: RuneError,
+			0x9c: RuneError,
+			0x9d: RuneError,
+			0x9e: RuneError,
+			0x9f: RuneError,
+			0xa0: RuneError,
+			0xa1: '~',
+			0xa2: 's',
+			0xa3: 't',
+			0xa4: 'u',
+			0xa5: 'v',
+			0xa6: 'w',
+			0xa7: 'x',
+			0xa8: 'y',
+			0xa9: 'z',
+			0xaa: RuneError,
+			0xab: RuneError,
+			0xac: RuneError,
+			0xad: RuneError,
+			0xae: RuneError,
+			0xaf: RuneError,
+			0xb0: '^',
+			0xb1: RuneError,
+			0xb2: RuneError,
+			0xb3: RuneError,
+			0xb4: RuneError,
+			0xb5: RuneError,
+			0xb6: RuneError,
+			0xb7: RuneError,
+			0xb8: RuneError,
+			0xb9: RuneError,
+			0xba: '[',
+			0xbb: ']',
+			0xbc: RuneError,
+			0xbd: RuneError,
+			0xbe: RuneError,
+			0xbf: RuneError,
+			0xc0: '{',
+			0xc1: 'A',
+			0xc2: 'B',
+			0xc3: 'C',
+			0xc4: 'D',
+			0xc5: 'E',
+			0xc6: 'F',
+			0xc7: 'G',
+			0xc8: 'H',
+			0xc9: 'I',
+			0xca: '\xad', // NB: soft hyphen
+			0xcb: RuneError,
+			0xcc: RuneError,
+			0xcd: RuneError,
+			0xce: RuneError,
+			0xcf: RuneError,
+			0xd0: '}',
+			0xd1: 'J',
+			0xd2: 'K',
+			0xd3: 'L',
+			0xd4: 'M',
+			0xd5: 'N',
+			0xd6: 'O',
+			0xd7: 'P',
+			0xd8: 'Q',
+			0xd9: 'R',
+			0xda: RuneError,
+			0xdb: RuneError,
+			0xdc: RuneError,
+			0xdd: RuneError,
+			0xde: RuneError,
+			0xdf: RuneError,
+			0xe0: '\\',
+			0xe1: '\u2007', // Non-breaking space
+			0xe2: 'S',
+			0xe3: 'T',
+			0xe4: 'U',
+			0xe5: 'V',
+			0xe6: 'W',
+			0xe7: 'X',
+			0xe8: 'Y',
+			0xe9: 'Z',
+			0xea: RuneError,
+			0xeb: RuneError,
+			0xec: RuneError,
+			0xed: RuneError,
+			0xee: RuneError,
+			0xef: RuneError,
+			0xf0: '0',
+			0xf1: '1',
+			0xf2: '2',
+			0xf3: '3',
+			0xf4: '4',
+			0xf5: '5',
+			0xf6: '6',
+			0xf7: '7',
+			0xf8: '8',
+			0xf9: '9',
+			0xfa: RuneError,
+			0xfb: RuneError,
+			0xfc: RuneError,
+			0xfd: RuneError,
+			0xfe: RuneError,
+			0xff: RuneError,
+		}}
+	cm.Init()
+	EBCDIC = cm
+}

libtui/v0/vendor/github.com/gdamore/encoding/latin1.go

@@ -0,0 +1,33 @@
+// Copyright 2015 Garrett D'Amore
+//
+// 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.
+
+package encoding
+
+import (
+	"golang.org/x/text/encoding"
+)
+
+// ISO8859_1 represents the 8-bit ISO8859-1 scheme.  It decodes directly to
+// UTF-8 without change, as all ISO8859-1 values are legal UTF-8.
+// Unicode values less than 256 (i.e. 8 bits) map 1:1 with 8859-1.
+// It encodes runes outside of that to 0x1A, the ASCII substitution character.
+var ISO8859_1 encoding.Encoding
+
+func init() {
+	cm := &Charmap{}
+	cm.Init()
+
+	// 8859-1 is the 8-bit identity map for Unicode.
+	ISO8859_1 = cm
+}

libtui/v0/vendor/github.com/gdamore/encoding/latin5.go

@@ -0,0 +1,35 @@
+// Copyright 2015 Garrett D'Amore
+//
+// 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.
+
+package encoding
+
+import (
+	"golang.org/x/text/encoding"
+)
+
+// ISO8859_9 represents the 8-bit ISO8859-9 scheme.
+var ISO8859_9 encoding.Encoding
+
+func init() {
+	cm := &Charmap{Map: map[byte]rune{
+		0xD0: 'Ğ',
+		0xDD: 'İ',
+		0xDE: 'Ş',
+		0xF0: 'ğ',
+		0xFD: 'ı',
+		0xFE: 'ş',
+	}}
+	cm.Init()
+	ISO8859_9 = cm
+}

libtui/v0/vendor/github.com/gdamore/encoding/utf8.go

@@ -0,0 +1,35 @@
+// Copyright 2015 Garrett D'Amore
+//
+// 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.
+
+package encoding
+
+import (
+	"golang.org/x/text/encoding"
+)
+
+type validUtf8 struct{}
+
+// UTF8 is an encoding for UTF-8.  All it does is verify that the UTF-8
+// in is valid.  The main reason for its existence is that it will detect
+// and report ErrSrcShort or ErrDstShort, whereas the Nop encoding just
+// passes every byte, blithely.
+var UTF8 encoding.Encoding = validUtf8{}
+
+func (validUtf8) NewDecoder() *encoding.Decoder {
+	return &encoding.Decoder{Transformer: encoding.UTF8Validator}
+}
+
+func (validUtf8) NewEncoder() *encoding.Encoder {
+	return &encoding.Encoder{Transformer: encoding.UTF8Validator}
+}

libtui/v0/vendor/github.com/gdamore/tcell/.appveyor.yml

@@ -0,0 +1,13 @@
+version: 1.0.{build}
+clone_folder: c:\gopath\src\github.com\gdamore\tcell
+environment:
+  GOPATH: c:\gopath
+build_script:
+- go version
+- go env
+- SET PATH=%LOCALAPPDATA%\atom\bin;%GOPATH%\bin;%PATH%
+- go get -t ./...
+- go build
+- go install ./...
+test_script:
+- go test ./...

libtui/v0/vendor/github.com/gdamore/tcell/.gitignore

@@ -0,0 +1 @@
+coverage.txt

libtui/v0/vendor/github.com/gdamore/tcell/.travis.yml

@@ -0,0 +1,15 @@
+language: go
+
+go:
+  - 1.10.x
+  - 1.11.x
+  - master
+
+before_install:
+  - go get -t -v ./...
+
+script:
+  - go test -race -coverprofile=coverage.txt -covermode=atomic
+
+after_success:
+  - bash <(curl -s https://codecov.io/bash)

libtui/v0/vendor/github.com/gdamore/tcell/AUTHORS

@@ -0,0 +1,4 @@
+Garrett D'Amore <garrett@damore.org>
+Zachary Yedidia <zyedidia@gmail.com>
+Junegunn Choi <junegunn.c@gmail.com>
+Staysail Systems, Inc. <info@staysail.tech>

libtui/v0/vendor/github.com/gdamore/tcell/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this 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.

libtui/v0/vendor/github.com/gdamore/tcell/README.adoc

@@ -0,0 +1,279 @@
+= tcell
+
+
+image:https://img.shields.io/travis/gdamore/tcell.svg?label=linux[Linux Status,link="https://travis-ci.org/gdamore/tcell"]
+image:https://img.shields.io/appveyor/ci/gdamore/tcell.svg?label=windows[Windows Status,link="https://ci.appveyor.com/project/gdamore/tcell"]
+image:https://img.shields.io/badge/license-APACHE2-blue.svg[Apache License,link="https://github.com/gdamore/tcell/blob/master/LICENSE"]
+image:https://img.shields.io/badge/godoc-reference-blue.svg[GoDoc,link="https://godoc.org/github.com/gdamore/tcell"]
+image:http://goreportcard.com/badge/gdamore/tcell[Go Report Card,link="http://goreportcard.com/report/gdamore/tcell"]
+image:https://img.shields.io/discord/639503822733180969?label=discord[Discord,link="https://discord.gg/urTTxDN"]
+image:https://codecov.io/gh/gdamore/tcell/branch/master/graph/badge.svg[codecov,link="https://codecov.io/gh/gdamore/tcell"]
+
+[cols="2",grid="none"]
+|===
+|_Tcell_ is a _Go_ package that provides a cell based view for text terminals, like _xterm_.
+It was inspired by _termbox_, but includes many additional improvements.
+a|[.right]
+image::logos/tcell.png[float="right"]
+|===
+
+## Examples
+
+* https://github.com/gdamore/proxima5[proxima5] - space shooter (https://youtu.be/jNxKTCmY_bQ[video])
+* https://github.com/gdamore/govisor[govisor] - service management UI (http://2.bp.blogspot.com/--OsvnfzSNow/Vf7aqMw3zXI/AAAAAAAAARo/uOMtOvw4Sbg/s1600/Screen%2BShot%2B2015-09-20%2Bat%2B9.08.41%2BAM.png[screenshot])
+* mouse demo - included mouse test (http://2.bp.blogspot.com/-fWvW5opT0es/VhIdItdKqJI/AAAAAAAAATE/7Ojc0L1SpB0/s1600/Screen%2BShot%2B2015-10-04%2Bat%2B11.47.13%2BPM.png[screenshot])
+* https://github.com/gdamore/gomatrix[gomatrix] - converted from Termbox
+* https://github.com/zyedidia/micro/[micro] - lightweight text editor with syntax-highlighting and themes
+* https://github.com/viktomas/godu[godu] - simple golang utility helping to discover large files/folders.
+* https://github.com/rivo/tview[tview] - rich interactive widgets for terminal UIs
+* https://github.com/marcusolsson/tui-go[tui-go] - UI library for terminal apps (_deprecated_)
+* https://github.com/rgm3/gomandelbrot[gomandelbrot] - Mandelbrot!
+* https://github.com/senorprogrammer/wtf[WTF]- Personal information dashboard for your terminal
+* https://github.com/browsh-org/browsh[browsh] - A fully-modern text-based browser, rendering to TTY and browsers (https://www.youtube.com/watch?v=HZq86XfBoRo[video])
+* https://github.com/sachaos/go-life[go-life] - Conway's Game of Life.
+* https://github.com/gcla/gowid[gowid] - compositional widgets for terminal UIs, inspired by urwid
+* https://termshark.io[termshark] - a terminal UI for tshark, inspired by Wireshark, built on gowid
+* https://github.com/MichaelS11/go-tetris[go-tetris] - Go Tetris with AI option
+* https://github.com/junegunn/fzf[fzf] - A command-line fuzzy finder
+* https://github.com/esimov/ascii-fluid[ascii-fluid] - A terminal based ASCII fluid simulation controlled by webcam
+* https://gitlab.com/tslocum/cbind[cbind] - Provides key event encoding, decoding and handling
+* https://github.com/spinzed/tpong[tpong] - The old-school Pong remade in terminal
+
+## Pure Go Terminfo Database
+
+_Tcell_ includes a full parser and expander for terminfo capability strings,
+so that it can avoid hard coding escape strings for formatting.  It also favors
+portability, and includes support for all POSIX systems.
+
+The database is also flexible & extensible, and can modified by either running
+a program to build the entire database, or an entry for just a single terminal.
+
+## More Portable
+
+_Tcell_ is portable to a wide variety of systems.
+_Tcell_ is believed
+to work with all of the systems officially supported by golang with
+the exception of nacl (which lacks any kind of a terminal interface).
+(Plan9 is not supported by _Tcell_, but it is experimental status only
+in golang.)  _Tcell_ is pure Go, without any need for CGO.
+
+## No Async IO
+
+_Tcell_ is able to operate without requiring `SIGIO` signals (unlike _termbox_),
+or asynchronous I/O, and can instead use standard Go file
+objects and Go routines.
+This means it should be safe, especially for
+use with programs that use exec, or otherwise need to manipulate the
+tty streams.
+This model is also much closer to idiomatic Go, leading
+to fewer surprises.
+
+## Rich Unicode & non-Unicode support
+
+_Tcell_ includes enhanced support for Unicode, including wide characters and
+combining characters, provided your terminal can support them.
+Note that
+Windows terminals generally don't support the full Unicode repertoire.
+
+It will also convert to and from Unicode locales, so that the program
+can work with UTF-8 internally, and get reasonable output in other locales.
+_Tcell_ tries hard to convert to native characters on both input and output, and
+on output _Tcell_ even makes use of the alternate character set to facilitate
+drawing certain characters.
+
+## More Function Keys
+
+_Tcell_ also has richer support for a larger number of special keys that some terminals can send.
+
+## Better Color Handling
+
+_Tcell_ will respect your terminal's color space as specified within your terminfo
+entries, so that for example attempts to emit color sequences on VT100 terminals
+won't result in unintended consequences.
+
+In legacy Windows mode, _Tcell_ supports 16 colors, bold, dim, and reverse,
+instead of just termbox's 8 colors with reverse.  (Note that there is some
+conflation with bold/dim and colors.)
+Modern Windows 10 can benefit from much richer colors however.
+
+_Tcell_ maps 16 colors down to 8, for terminals that need it.
+(The upper 8 colors are just brighter versions of the lower 8.)
+
+## Better Mouse Support
+
+_Tcell_ supports enhanced mouse tracking mode, so your application can receive
+regular mouse motion events, and wheel events, if your terminal supports it.
+
+(Note: The Windows 10 Terminal application suffers from a flaw in this regard,
+and does not support mouse interaction.  The stock Windows 10 console host
+fired up with cmd.exe or PowerShell works fine however.)
+
+## _Termbox_ Compatibility
+
+A compatibility layer for _termbox_ is provided in the `compat` directory.
+To use it, try importing `github.com/gdamore/tcell/termbox` instead.
+Most _termbox-go_ programs will probably work without further modification.
+
+## Working With Unicode
+
+Internally Tcell uses UTF-8, just like Go.
+However, Tcell understands how to
+convert to and from other character sets, using the capabilities of
+the `golang.org/x/text/encoding packages`.
+Your application must supply
+them, as the full set of the most common ones bloats the program by about 2MB.
+If you're lazy, and want them all anyway, see the `encoding` sub-directory.
+
+## Wide & Combining Characters
+
+The `SetContent()` API takes a primary rune, and an optional list of combining runes.
+If any of the runes is a wide (East Asian) rune occupying two cells,
+then the library will skip output from the following cell, but care must be
+taken in the application to avoid explicitly attempting to set content in the
+next cell, otherwise the results are undefined.  (Normally wide character
+is displayed, and the other character is not; do not depend on that behavior.)
+
+Experience has shown that the vanilla Windows 8 console application does not
+support any of these characters properly, but at least some options like
+_ConEmu_ do support Wide characters.
+
+## Colors
+
+_Tcell_ assumes the ANSI/XTerm color model, including the 256 color map that
+XTerm uses when it supports 256 colors.  The terminfo guidance will be
+honored, with respect to the number of colors supported.  Also, only
+terminals which expose ANSI style `setaf` and `setab` will support color;
+if you have a color terminal that only has `setf` and `setb`, please let me
+know; it wouldn't be hard to add that if there is need.
+
+## 24-bit Color
+
+_Tcell_ _supports true color_!  (That is, if your terminal can support it,
+_Tcell_ can accurately display 24-bit color.)
+
+To use 24-bit color, you need to use a terminal that supports it.  Modern
+xterm and similar teminal emulators can support this.  As terminfo lacks any
+way to describe this capability, we fabricate the capability for
+terminals with names ending in `*-truecolor`.  The stock distribution ships
+with a database that defines `xterm-truecolor`.
+To try it out, set your
+`TERM` variable to `xterm-truecolor`.
+
+When using TrueColor, programs will display the colors that the programmer
+intended, overriding any "`themes`" you may have set in your terminal
+emulator.  (For some cases, accurate color fidelity is more important
+than respecting themes.  For other cases, such as typical text apps that
+only use a few colors, its more desirable to respect the themes that
+the user has established.)
+
+If you find this undesirable, you can either use a `TERM` variable
+that lacks the `TRUECOLOR` setting, or set `TCELL_TRUECOLOR=disable` in your
+environment.
+
+## Performance
+
+Reasonable attempts have been made to minimize sending data to terminals,
+avoiding repeated sequences or drawing the same cell on refresh updates.
+
+## Terminfo
+
+(Not relevent for Windows users.)
+
+The Terminfo implementation operates with two forms of database.  The first
+is the built-in go database, which contains a number of real database entries
+that are compiled into the program directly.  This should minimize calling
+out to database file searches.
+
+The second is in the form of JSON files, that contain the same information,
+which can be located either by the `$TCELLDB` environment file, `$HOME/.tcelldb`,
+or is located in the Go source directory as `database.json`.
+
+These files (both the Go and the JSON files) can be generated using the
+mkinfo.go program.  If you need to regnerate the entire set for some reason,
+run the mkdatabase.sh file.  The generation uses the infocmp(1) program on
+the system to collect the necessary information.
+
+The `mkinfo.go` program can also be used to generate specific database entries
+for named terminals, in case your favorite terminal is missing.  (If you
+find that this is the case, please let me know and I'll try to add it!)
+
+_Tcell_ requires that the terminal support the `cup` mode of cursor addressing.
+Terminals without absolute cursor addressability are not supported.
+This is unlikely to be a problem; such terminals have not been mass produced
+since the early 1970s.
+
+## Mouse Support
+
+Mouse support is detected via the `kmous` terminfo variable, however,
+enablement/disablement and decoding mouse events is done using hard coded
+sequences based on the XTerm X11 model.  As of this writing all popular
+terminals with mouse tracking support this model.  (Full terminfo support
+is not possible as terminfo sequences are not defined.)
+
+On Windows, the mouse works normally.
+
+Mouse wheel buttons on various terminals are known to work, but the support
+in terminal emulators, as well as support for various buttons and
+live mouse tracking, varies widely.  Modern _xterm_, macOS _Terminal_, and _iTerm_ all work well.
+
+## Testablity
+
+There is a `SimulationScreen`, that can be used to simulate a real screen
+for automated testing.  The supplied tests do this.  The simulation contains
+event delivery, screen resizing support, and capabilities to inject events
+and examine "`physical`" screen contents.
+
+## Platforms
+
+### POSIX (Linux, FreeBSD, macOS, Solaris, etc.)
+
+For mainstream systems with a suitably well defined system call interface
+to tty settings, everything works using pure Go.
+
+For the remainder (right now means only Solaris/illumos) we use POSIX function
+calls to manage termios, which implies that CGO is required on those platforms.
+
+### Windows
+
+Windows console mode applications are supported.  Unfortunately _mintty_
+and other _cygwin_ style applications are not supported.
+
+Modern console applications like ConEmu, as well as the Windows 10
+console itself, support all the good features (resize, mouse tracking, etc.)
+
+I haven't figured out how to cleanly resolve the dichotomy between cygwin
+style termios and the Windows Console API; it seems that perhaps nobody else
+has either.  If anyone has suggestions, let me know!  Really, if you're
+using a Windows application, you should use the native Windows console or a
+fully compatible console implementation.
+
+### Plan9 and Native Client (Nacl)
+
+The nacl and plan9 platforms won't work, but compilation stubs are supplied
+for folks that want to include parts of this in software targetting those
+platforms.  The Simulation screen works, but as Tcell doesn't know how to
+allocate a real screen object on those platforms, `NewScreen()` will fail.
+
+If anyone has wisdom about how to improve support for either of these,
+please let me know.  PRs are especially welcome.
+
+### Commercial Support
+
+_Tcell_ is absolutely free, but if you want to obtain commercial, professional support, there are options.
+
+[cols="2",align="center",frame="none", grid="none"]
+|===
+^.^|
+image:logos/tidelift.png[100,100]
+a|
+https://tidelift.com/[Tidelift] subscriptions include support for _Tcell_, as well as many other open source packages.
+
+^.^|
+image:logos/staysail.png[100,100]
+a|
+mailto:info@staysail.tech[Staysail Systems, Inc.] offers direct support, and custom development around _Tcell_ on an hourly basis.
+
+^.^|
+image:logos/patreon.png[100,100]
+a|I also welcome donations at https://www.patreon.com/gedamore/[Patreon], if you just want to make a contribution.
+|===

libtui/v0/vendor/github.com/gdamore/tcell/attr.go

@@ -0,0 +1,33 @@
+// Copyright 2015 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.
+
+package tcell
+
+// AttrMask represents a mask of text attributes, apart from color.
+// Note that support for attributes may vary widely across terminals.
+type AttrMask int
+
+// Attributes are not colors, but affect the display of text.  They can
+// be combined.
+const (
+	AttrBold AttrMask = 1 << (25 + iota)
+	AttrBlink
+	AttrReverse
+	AttrUnderline
+	AttrDim
+	AttrItalic
+	AttrNone AttrMask = 0 // Just normal text.
+)
+
+const attrAll = AttrBold | AttrBlink | AttrReverse | AttrUnderline | AttrDim | AttrItalic

libtui/v0/vendor/github.com/gdamore/tcell/cell.go

@@ -0,0 +1,177 @@
+// Copyright 2019 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.
+
+package tcell
+
+import (
+	runewidth "github.com/mattn/go-runewidth"
+)
+
+type cell struct {
+	currMain  rune
+	currComb  []rune
+	currStyle Style
+	lastMain  rune
+	lastStyle Style
+	lastComb  []rune
+	width     int
+}
+
+// CellBuffer represents a two dimensional array of character cells.
+// This is primarily intended for use by Screen implementors; it
+// contains much of the common code they need.  To create one, just
+// declare a variable of its type; no explicit initialization is necessary.
+//
+// CellBuffer is not thread safe.
+type CellBuffer struct {
+	w     int
+	h     int
+	cells []cell
+}
+
+// SetContent sets the contents (primary rune, combining runes,
+// and style) for a cell at a given location.
+func (cb *CellBuffer) SetContent(x int, y int,
+	mainc rune, combc []rune, style Style) {
+
+	if x >= 0 && y >= 0 && x < cb.w && y < cb.h {
+		c := &cb.cells[(y*cb.w)+x]
+
+		c.currComb = append([]rune{}, combc...)
+
+		if c.currMain != mainc {
+			c.width = runewidth.RuneWidth(mainc)
+		}
+		c.currMain = mainc
+		c.currStyle = style
+	}
+}
+
+// GetContent returns the contents of a character cell, including the
+// primary rune, any combining character runes (which will usually be
+// nil), the style, and the display width in cells.  (The width can be
+// either 1, normally, or 2 for East Asian full-width characters.)
+func (cb *CellBuffer) GetContent(x, y int) (rune, []rune, Style, int) {
+	var mainc rune
+	var combc []rune
+	var style Style
+	var width int
+	if x >= 0 && y >= 0 && x < cb.w && y < cb.h {
+		c := &cb.cells[(y*cb.w)+x]
+		mainc, combc, style = c.currMain, c.currComb, c.currStyle
+		if width = c.width; width == 0 || mainc < ' ' {
+			width = 1
+			mainc = ' '
+		}
+	}
+	return mainc, combc, style, width
+}
+
+// Size returns the (width, height) in cells of the buffer.
+func (cb *CellBuffer) Size() (int, int) {
+	return cb.w, cb.h
+}
+
+// Invalidate marks all characters within the buffer as dirty.
+func (cb *CellBuffer) Invalidate() {
+	for i := range cb.cells {
+		cb.cells[i].lastMain = rune(0)
+	}
+}
+
+// Dirty checks if a character at the given location needs an
+// to be refreshed on the physical display.  This returns true
+// if the cell content is different since the last time it was
+// marked clean.
+func (cb *CellBuffer) Dirty(x, y int) bool {
+	if x >= 0 && y >= 0 && x < cb.w && y < cb.h {
+		c := &cb.cells[(y*cb.w)+x]
+		if c.lastMain == rune(0) {
+			return true
+		}
+		if c.lastMain != c.currMain {
+			return true
+		}
+		if c.lastStyle != c.currStyle {
+			return true
+		}
+		if len(c.lastComb) != len(c.currComb) {
+			return true
+		}
+		for i := range c.lastComb {
+			if c.lastComb[i] != c.currComb[i] {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// SetDirty is normally used to indicate that a cell has
+// been displayed (in which case dirty is false), or to manually
+// force a cell to be marked dirty.
+func (cb *CellBuffer) SetDirty(x, y int, dirty bool) {
+	if x >= 0 && y >= 0 && x < cb.w && y < cb.h {
+		c := &cb.cells[(y*cb.w)+x]
+		if dirty {
+			c.lastMain = rune(0)
+		} else {
+			if c.currMain == rune(0) {
+				c.currMain = ' '
+			}
+			c.lastMain = c.currMain
+			c.lastComb = c.currComb
+			c.lastStyle = c.currStyle
+		}
+	}
+}
+
+// Resize is used to resize the cells array, with different dimensions,
+// while preserving the original contents.  The cells will be invalidated
+// so that they can be redrawn.
+func (cb *CellBuffer) Resize(w, h int) {
+
+	if cb.h == h && cb.w == w {
+		return
+	}
+
+	newc := make([]cell, w*h)
+	for y := 0; y < h && y < cb.h; y++ {
+		for x := 0; x < w && x < cb.w; x++ {
+			oc := &cb.cells[(y*cb.w)+x]
+			nc := &newc[(y*w)+x]
+			nc.currMain = oc.currMain
+			nc.currComb = oc.currComb
+			nc.currStyle = oc.currStyle
+			nc.width = oc.width
+			nc.lastMain = rune(0)
+		}
+	}
+	cb.cells = newc
+	cb.h = h
+	cb.w = w
+}
+
+// Fill fills the entire cell buffer array with the specified character
+// and style.  Normally choose ' ' to clear the screen.  This API doesn't
+// support combining characters, or characters with a width larger than one.
+func (cb *CellBuffer) Fill(r rune, style Style) {
+	for i := range cb.cells {
+		c := &cb.cells[i]
+		c.currMain = r
+		c.currComb = nil
+		c.currStyle = style
+		c.width = 1
+	}
+}

libtui/v0/vendor/github.com/gdamore/tcell/charset_stub.go

@@ -0,0 +1,21 @@
+// +build plan9 nacl
+
+// Copyright 2015 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.
+
+package tcell
+
+func getCharset() string {
+	return ""
+}

libtui/v0/vendor/github.com/gdamore/tcell/charset_unix.go

@@ -0,0 +1,49 @@
+// +build !windows,!nacl,!plan9
+
+// Copyright 2016 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.
+
+package tcell
+
+import (
+	"os"
+	"strings"
+)
+
+func getCharset() string {
+	// Determine the character set.  This can help us later.
+	// Per POSIX, we search for LC_ALL first, then LC_CTYPE, and
+	// finally LANG.  First one set wins.
+	locale := ""
+	if locale = os.Getenv("LC_ALL"); locale == "" {
+		if locale = os.Getenv("LC_CTYPE"); locale == "" {
+			locale = os.Getenv("LANG")
+		}
+	}
+	if locale == "POSIX" || locale == "C" {
+		return "US-ASCII"
+	}
+	if i := strings.IndexRune(locale, '@'); i >= 0 {
+		locale = locale[:i]
+	}
+	if i := strings.IndexRune(locale, '.'); i >= 0 {
+		locale = locale[i+1:]
+	} else {
+		// Default assumption, and on Linux we can see LC_ALL
+		// without a character set, which we assume implies UTF-8.
+		return "UTF-8"
+	}
+	// XXX: add support for aliases
+	return locale
+}

libtui/v0/vendor/github.com/gdamore/tcell/charset_windows.go

@@ -0,0 +1,21 @@
+// +build windows
+
+// Copyright 2015 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.
+
+package tcell
+
+func getCharset() string {
+	return "UTF-16"
+}

libtui/v0/vendor/github.com/gdamore/tcell/color.go

@@ -0,0 +1,1019 @@
+// Copyright 2015 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.
+
+package tcell
+
+import "strconv"
+
+// Color represents a color.  The low numeric values are the same as used
+// by ECMA-48, and beyond that XTerm.  A 24-bit RGB value may be used by
+// adding in the ColorIsRGB flag.  For Color names we use the W3C approved
+// color names.
+//
+// Note that on various terminals colors may be approximated however, or
+// not supported at all.  If no suitable representation for a color is known,
+// the library will simply not set any color, deferring to whatever default
+// attributes the terminal uses.
+type Color int32
+
+const (
+	// ColorDefault is used to leave the Color unchanged from whatever
+	// system or teminal default may exist.
+	ColorDefault Color = -1
+
+	// ColorIsRGB is used to indicate that the numeric value is not
+	// a known color constant, but rather an RGB value.  The lower
+	// order 3 bytes are RGB.
+	ColorIsRGB Color = 1 << 24
+)
+
+// Note that the order of these options is important -- it follows the
+// definitions used by ECMA and XTerm.  Hence any further named colors
+// must begin at a value not less than 256.
+const (
+	ColorBlack Color = iota
+	ColorMaroon
+	ColorGreen
+	ColorOlive
+	ColorNavy
+	ColorPurple
+	ColorTeal
+	ColorSilver
+	ColorGray
+	ColorRed
+	ColorLime
+	ColorYellow
+	ColorBlue
+	ColorFuchsia
+	ColorAqua
+	ColorWhite
+	Color16
+	Color17
+	Color18
+	Color19
+	Color20
+	Color21
+	Color22
+	Color23
+	Color24
+	Color25
+	Color26
+	Color27
+	Color28
+	Color29
+	Color30
+	Color31
+	Color32
+	Color33
+	Color34
+	Color35
+	Color36
+	Color37
+	Color38
+	Color39
+	Color40
+	Color41
+	Color42
+	Color43
+	Color44
+	Color45
+	Color46
+	Color47
+	Color48
+	Color49
+	Color50
+	Color51
+	Color52
+	Color53
+	Color54
+	Color55
+	Color56
+	Color57
+	Color58
+	Color59
+	Color60
+	Color61
+	Color62
+	Color63
+	Color64
+	Color65
+	Color66
+	Color67
+	Color68
+	Color69
+	Color70
+	Color71
+	Color72
+	Color73
+	Color74
+	Color75
+	Color76
+	Color77
+	Color78
+	Color79
+	Color80
+	Color81
+	Color82
+	Color83
+	Color84
+	Color85
+	Color86
+	Color87
+	Color88
+	Color89
+	Color90
+	Color91
+	Color92
+	Color93
+	Color94
+	Color95
+	Color96
+	Color97
+	Color98
+	Color99
+	Color100
+	Color101
+	Color102
+	Color103
+	Color104
+	Color105
+	Color106
+	Color107
+	Color108
+	Color109
+	Color110
+	Color111
+	Color112
+	Color113
+	Color114
+	Color115
+	Color116
+	Color117
+	Color118
+	Color119
+	Color120
+	Color121
+	Color122
+	Color123
+	Color124
+	Color125
+	Color126
+	Color127
+	Color128
+	Color129
+	Color130
+	Color131
+	Color132
+	Color133
+	Color134
+	Color135
+	Color136
+	Color137
+	Color138
+	Color139
+	Color140
+	Color141
+	Color142
+	Color143
+	Color144
+	Color145
+	Color146
+	Color147
+	Color148
+	Color149
+	Color150
+	Color151
+	Color152
+	Color153
+	Color154
+	Color155
+	Color156
+	Color157
+	Color158
+	Color159
+	Color160
+	Color161
+	Color162
+	Color163
+	Color164
+	Color165
+	Color166
+	Color167
+	Color168
+	Color169
+	Color170
+	Color171
+	Color172
+	Color173
+	Color174
+	Color175
+	Color176
+	Color177
+	Color178
+	Color179
+	Color180
+	Color181
+	Color182
+	Color183
+	Color184
+	Color185
+	Color186
+	Color187
+	Color188
+	Color189
+	Color190
+	Color191
+	Color192
+	Color193
+	Color194
+	Color195
+	Color196
+	Color197
+	Color198
+	Color199
+	Color200
+	Color201
+	Color202
+	Color203
+	Color204
+	Color205
+	Color206
+	Color207
+	Color208
+	Color209
+	Color210
+	Color211
+	Color212
+	Color213
+	Color214
+	Color215
+	Color216
+	Color217
+	Color218
+	Color219
+	Color220
+	Color221
+	Color222
+	Color223
+	Color224
+	Color225
+	Color226
+	Color227
+	Color228
+	Color229
+	Color230
+	Color231
+	Color232
+	Color233
+	Color234
+	Color235
+	Color236
+	Color237
+	Color238
+	Color239
+	Color240
+	Color241
+	Color242
+	Color243
+	Color244
+	Color245
+	Color246
+	Color247
+	Color248
+	Color249
+	Color250
+	Color251
+	Color252
+	Color253
+	Color254
+	Color255
+	ColorAliceBlue
+	ColorAntiqueWhite
+	ColorAquaMarine
+	ColorAzure
+	ColorBeige
+	ColorBisque
+	ColorBlanchedAlmond
+	ColorBlueViolet
+	ColorBrown
+	ColorBurlyWood
+	ColorCadetBlue
+	ColorChartreuse
+	ColorChocolate
+	ColorCoral
+	ColorCornflowerBlue
+	ColorCornsilk
+	ColorCrimson
+	ColorDarkBlue
+	ColorDarkCyan
+	ColorDarkGoldenrod
+	ColorDarkGray
+	ColorDarkGreen
+	ColorDarkKhaki
+	ColorDarkMagenta
+	ColorDarkOliveGreen
+	ColorDarkOrange
+	ColorDarkOrchid
+	ColorDarkRed
+	ColorDarkSalmon
+	ColorDarkSeaGreen
+	ColorDarkSlateBlue
+	ColorDarkSlateGray
+	ColorDarkTurquoise
+	ColorDarkViolet
+	ColorDeepPink
+	ColorDeepSkyBlue
+	ColorDimGray
+	ColorDodgerBlue
+	ColorFireBrick
+	ColorFloralWhite
+	ColorForestGreen
+	ColorGainsboro
+	ColorGhostWhite
+	ColorGold
+	ColorGoldenrod
+	ColorGreenYellow
+	ColorHoneydew
+	ColorHotPink
+	ColorIndianRed
+	ColorIndigo
+	ColorIvory
+	ColorKhaki
+	ColorLavender
+	ColorLavenderBlush
+	ColorLawnGreen
+	ColorLemonChiffon
+	ColorLightBlue
+	ColorLightCoral
+	ColorLightCyan
+	ColorLightGoldenrodYellow
+	ColorLightGray
+	ColorLightGreen
+	ColorLightPink
+	ColorLightSalmon
+	ColorLightSeaGreen
+	ColorLightSkyBlue
+	ColorLightSlateGray
+	ColorLightSteelBlue
+	ColorLightYellow
+	ColorLimeGreen
+	ColorLinen
+	ColorMediumAquamarine
+	ColorMediumBlue
+	ColorMediumOrchid
+	ColorMediumPurple
+	ColorMediumSeaGreen
+	ColorMediumSlateBlue
+	ColorMediumSpringGreen
+	ColorMediumTurquoise
+	ColorMediumVioletRed
+	ColorMidnightBlue
+	ColorMintCream
+	ColorMistyRose
+	ColorMoccasin
+	ColorNavajoWhite
+	ColorOldLace
+	ColorOliveDrab
+	ColorOrange
+	ColorOrangeRed
+	ColorOrchid
+	ColorPaleGoldenrod
+	ColorPaleGreen
+	ColorPaleTurquoise
+	ColorPaleVioletRed
+	ColorPapayaWhip
+	ColorPeachPuff
+	ColorPeru
+	ColorPink
+	ColorPlum
+	ColorPowderBlue
+	ColorRebeccaPurple
+	ColorRosyBrown
+	ColorRoyalBlue
+	ColorSaddleBrown
+	ColorSalmon
+	ColorSandyBrown
+	ColorSeaGreen
+	ColorSeashell
+	ColorSienna
+	ColorSkyblue
+	ColorSlateBlue
+	ColorSlateGray
+	ColorSnow
+	ColorSpringGreen
+	ColorSteelBlue
+	ColorTan
+	ColorThistle
+	ColorTomato
+	ColorTurquoise
+	ColorViolet
+	ColorWheat
+	ColorWhiteSmoke
+	ColorYellowGreen
+)
+
+// These are aliases for the color gray, because some of us spell
+// it as grey.
+const (
+	ColorGrey           = ColorGray
+	ColorDimGrey        = ColorDimGray
+	ColorDarkGrey       = ColorDarkGray
+	ColorDarkSlateGrey  = ColorDarkSlateGray
+	ColorLightGrey      = ColorLightGray
+	ColorLightSlateGrey = ColorLightSlateGray
+	ColorSlateGrey      = ColorSlateGray
+)
+
+// ColorValues maps color constants to their RGB values.
+var ColorValues = map[Color]int32{
+	ColorBlack:                0x000000,
+	ColorMaroon:               0x800000,
+	ColorGreen:                0x008000,
+	ColorOlive:                0x808000,
+	ColorNavy:                 0x000080,
+	ColorPurple:               0x800080,
+	ColorTeal:                 0x008080,
+	ColorSilver:               0xC0C0C0,
+	ColorGray:                 0x808080,
+	ColorRed:                  0xFF0000,
+	ColorLime:                 0x00FF00,
+	ColorYellow:               0xFFFF00,
+	ColorBlue:                 0x0000FF,
+	ColorFuchsia:              0xFF00FF,
+	ColorAqua:                 0x00FFFF,
+	ColorWhite:                0xFFFFFF,
+	Color16:                   0x000000, // black
+	Color17:                   0x00005F,
+	Color18:                   0x000087,
+	Color19:                   0x0000AF,
+	Color20:                   0x0000D7,
+	Color21:                   0x0000FF, // blue
+	Color22:                   0x005F00,
+	Color23:                   0x005F5F,
+	Color24:                   0x005F87,
+	Color25:                   0x005FAF,
+	Color26:                   0x005FD7,
+	Color27:                   0x005FFF,
+	Color28:                   0x008700,
+	Color29:                   0x00875F,
+	Color30:                   0x008787,
+	Color31:                   0x0087Af,
+	Color32:                   0x0087D7,
+	Color33:                   0x0087FF,
+	Color34:                   0x00AF00,
+	Color35:                   0x00AF5F,
+	Color36:                   0x00AF87,
+	Color37:                   0x00AFAF,
+	Color38:                   0x00AFD7,
+	Color39:                   0x00AFFF,
+	Color40:                   0x00D700,
+	Color41:                   0x00D75F,
+	Color42:                   0x00D787,
+	Color43:                   0x00D7AF,
+	Color44:                   0x00D7D7,
+	Color45:                   0x00D7FF,
+	Color46:                   0x00FF00, // lime
+	Color47:                   0x00FF5F,
+	Color48:                   0x00FF87,
+	Color49:                   0x00FFAF,
+	Color50:                   0x00FFd7,
+	Color51:                   0x00FFFF, // aqua
+	Color52:                   0x5F0000,
+	Color53:                   0x5F005F,
+	Color54:                   0x5F0087,
+	Color55:                   0x5F00AF,
+	Color56:                   0x5F00D7,
+	Color57:                   0x5F00FF,
+	Color58:                   0x5F5F00,
+	Color59:                   0x5F5F5F,
+	Color60:                   0x5F5F87,
+	Color61:                   0x5F5FAF,
+	Color62:                   0x5F5FD7,
+	Color63:                   0x5F5FFF,
+	Color64:                   0x5F8700,
+	Color65:                   0x5F875F,
+	Color66:                   0x5F8787,
+	Color67:                   0x5F87AF,
+	Color68:                   0x5F87D7,
+	Color69:                   0x5F87FF,
+	Color70:                   0x5FAF00,
+	Color71:                   0x5FAF5F,
+	Color72:                   0x5FAF87,
+	Color73:                   0x5FAFAF,
+	Color74:                   0x5FAFD7,
+	Color75:                   0x5FAFFF,
+	Color76:                   0x5FD700,
+	Color77:                   0x5FD75F,
+	Color78:                   0x5FD787,
+	Color79:                   0x5FD7AF,
+	Color80:                   0x5FD7D7,
+	Color81:                   0x5FD7FF,
+	Color82:                   0x5FFF00,
+	Color83:                   0x5FFF5F,
+	Color84:                   0x5FFF87,
+	Color85:                   0x5FFFAF,
+	Color86:                   0x5FFFD7,
+	Color87:                   0x5FFFFF,
+	Color88:                   0x870000,
+	Color89:                   0x87005F,
+	Color90:                   0x870087,
+	Color91:                   0x8700AF,
+	Color92:                   0x8700D7,
+	Color93:                   0x8700FF,
+	Color94:                   0x875F00,
+	Color95:                   0x875F5F,
+	Color96:                   0x875F87,
+	Color97:                   0x875FAF,
+	Color98:                   0x875FD7,
+	Color99:                   0x875FFF,
+	Color100:                  0x878700,
+	Color101:                  0x87875F,
+	Color102:                  0x878787,
+	Color103:                  0x8787AF,
+	Color104:                  0x8787D7,
+	Color105:                  0x8787FF,
+	Color106:                  0x87AF00,
+	Color107:                  0x87AF5F,
+	Color108:                  0x87AF87,
+	Color109:                  0x87AFAF,
+	Color110:                  0x87AFD7,
+	Color111:                  0x87AFFF,
+	Color112:                  0x87D700,
+	Color113:                  0x87D75F,
+	Color114:                  0x87D787,
+	Color115:                  0x87D7AF,
+	Color116:                  0x87D7D7,
+	Color117:                  0x87D7FF,
+	Color118:                  0x87FF00,
+	Color119:                  0x87FF5F,
+	Color120:                  0x87FF87,
+	Color121:                  0x87FFAF,
+	Color122:                  0x87FFD7,
+	Color123:                  0x87FFFF,
+	Color124:                  0xAF0000,
+	Color125:                  0xAF005F,
+	Color126:                  0xAF0087,
+	Color127:                  0xAF00AF,
+	Color128:                  0xAF00D7,
+	Color129:                  0xAF00FF,
+	Color130:                  0xAF5F00,
+	Color131:                  0xAF5F5F,
+	Color132:                  0xAF5F87,
+	Color133:                  0xAF5FAF,
+	Color134:                  0xAF5FD7,
+	Color135:                  0xAF5FFF,
+	Color136:                  0xAF8700,
+	Color137:                  0xAF875F,
+	Color138:                  0xAF8787,
+	Color139:                  0xAF87AF,
+	Color140:                  0xAF87D7,
+	Color141:                  0xAF87FF,
+	Color142:                  0xAFAF00,
+	Color143:                  0xAFAF5F,
+	Color144:                  0xAFAF87,
+	Color145:                  0xAFAFAF,
+	Color146:                  0xAFAFD7,
+	Color147:                  0xAFAFFF,
+	Color148:                  0xAFD700,
+	Color149:                  0xAFD75F,
+	Color150:                  0xAFD787,
+	Color151:                  0xAFD7AF,
+	Color152:                  0xAFD7D7,
+	Color153:                  0xAFD7FF,
+	Color154:                  0xAFFF00,
+	Color155:                  0xAFFF5F,
+	Color156:                  0xAFFF87,
+	Color157:                  0xAFFFAF,
+	Color158:                  0xAFFFD7,
+	Color159:                  0xAFFFFF,
+	Color160:                  0xD70000,
+	Color161:                  0xD7005F,
+	Color162:                  0xD70087,
+	Color163:                  0xD700AF,
+	Color164:                  0xD700D7,
+	Color165:                  0xD700FF,
+	Color166:                  0xD75F00,
+	Color167:                  0xD75F5F,
+	Color168:                  0xD75F87,
+	Color169:                  0xD75FAF,
+	Color170:                  0xD75FD7,
+	Color171:                  0xD75FFF,
+	Color172:                  0xD78700,
+	Color173:                  0xD7875F,
+	Color174:                  0xD78787,
+	Color175:                  0xD787AF,
+	Color176:                  0xD787D7,
+	Color177:                  0xD787FF,
+	Color178:                  0xD7AF00,
+	Color179:                  0xD7AF5F,
+	Color180:                  0xD7AF87,
+	Color181:                  0xD7AFAF,
+	Color182:                  0xD7AFD7,
+	Color183:                  0xD7AFFF,
+	Color184:                  0xD7D700,
+	Color185:                  0xD7D75F,
+	Color186:                  0xD7D787,
+	Color187:                  0xD7D7AF,
+	Color188:                  0xD7D7D7,
+	Color189:                  0xD7D7FF,
+	Color190:                  0xD7FF00,
+	Color191:                  0xD7FF5F,
+	Color192:                  0xD7FF87,
+	Color193:                  0xD7FFAF,
+	Color194:                  0xD7FFD7,
+	Color195:                  0xD7FFFF,
+	Color196:                  0xFF0000, // red
+	Color197:                  0xFF005F,
+	Color198:                  0xFF0087,
+	Color199:                  0xFF00AF,
+	Color200:                  0xFF00D7,
+	Color201:                  0xFF00FF, // fuchsia
+	Color202:                  0xFF5F00,
+	Color203:                  0xFF5F5F,
+	Color204:                  0xFF5F87,
+	Color205:                  0xFF5FAF,
+	Color206:                  0xFF5FD7,
+	Color207:                  0xFF5FFF,
+	Color208:                  0xFF8700,
+	Color209:                  0xFF875F,
+	Color210:                  0xFF8787,
+	Color211:                  0xFF87AF,
+	Color212:                  0xFF87D7,
+	Color213:                  0xFF87FF,
+	Color214:                  0xFFAF00,
+	Color215:                  0xFFAF5F,
+	Color216:                  0xFFAF87,
+	Color217:                  0xFFAFAF,
+	Color218:                  0xFFAFD7,
+	Color219:                  0xFFAFFF,
+	Color220:                  0xFFD700,
+	Color221:                  0xFFD75F,
+	Color222:                  0xFFD787,
+	Color223:                  0xFFD7AF,
+	Color224:                  0xFFD7D7,
+	Color225:                  0xFFD7FF,
+	Color226:                  0xFFFF00, // yellow
+	Color227:                  0xFFFF5F,
+	Color228:                  0xFFFF87,
+	Color229:                  0xFFFFAF,
+	Color230:                  0xFFFFD7,
+	Color231:                  0xFFFFFF, // white
+	Color232:                  0x080808,
+	Color233:                  0x121212,
+	Color234:                  0x1C1C1C,
+	Color235:                  0x262626,
+	Color236:                  0x303030,
+	Color237:                  0x3A3A3A,
+	Color238:                  0x444444,
+	Color239:                  0x4E4E4E,
+	Color240:                  0x585858,
+	Color241:                  0x626262,
+	Color242:                  0x6C6C6C,
+	Color243:                  0x767676,
+	Color244:                  0x808080, // grey
+	Color245:                  0x8A8A8A,
+	Color246:                  0x949494,
+	Color247:                  0x9E9E9E,
+	Color248:                  0xA8A8A8,
+	Color249:                  0xB2B2B2,
+	Color250:                  0xBCBCBC,
+	Color251:                  0xC6C6C6,
+	Color252:                  0xD0D0D0,
+	Color253:                  0xDADADA,
+	Color254:                  0xE4E4E4,
+	Color255:                  0xEEEEEE,
+	ColorAliceBlue:            0xF0F8FF,
+	ColorAntiqueWhite:         0xFAEBD7,
+	ColorAquaMarine:           0x7FFFD4,
+	ColorAzure:                0xF0FFFF,
+	ColorBeige:                0xF5F5DC,
+	ColorBisque:               0xFFE4C4,
+	ColorBlanchedAlmond:       0xFFEBCD,
+	ColorBlueViolet:           0x8A2BE2,
+	ColorBrown:                0xA52A2A,
+	ColorBurlyWood:            0xDEB887,
+	ColorCadetBlue:            0x5F9EA0,
+	ColorChartreuse:           0x7FFF00,
+	ColorChocolate:            0xD2691E,
+	ColorCoral:                0xFF7F50,
+	ColorCornflowerBlue:       0x6495ED,
+	ColorCornsilk:             0xFFF8DC,
+	ColorCrimson:              0xDC143C,
+	ColorDarkBlue:             0x00008B,
+	ColorDarkCyan:             0x008B8B,
+	ColorDarkGoldenrod:        0xB8860B,
+	ColorDarkGray:             0xA9A9A9,
+	ColorDarkGreen:            0x006400,
+	ColorDarkKhaki:            0xBDB76B,
+	ColorDarkMagenta:          0x8B008B,
+	ColorDarkOliveGreen:       0x556B2F,
+	ColorDarkOrange:           0xFF8C00,
+	ColorDarkOrchid:           0x9932CC,
+	ColorDarkRed:              0x8B0000,
+	ColorDarkSalmon:           0xE9967A,
+	ColorDarkSeaGreen:         0x8FBC8F,
+	ColorDarkSlateBlue:        0x483D8B,
+	ColorDarkSlateGray:        0x2F4F4F,
+	ColorDarkTurquoise:        0x00CED1,
+	ColorDarkViolet:           0x9400D3,
+	ColorDeepPink:             0xFF1493,
+	ColorDeepSkyBlue:          0x00BFFF,
+	ColorDimGray:              0x696969,
+	ColorDodgerBlue:           0x1E90FF,
+	ColorFireBrick:            0xB22222,
+	ColorFloralWhite:          0xFFFAF0,
+	ColorForestGreen:          0x228B22,
+	ColorGainsboro:            0xDCDCDC,
+	ColorGhostWhite:           0xF8F8FF,
+	ColorGold:                 0xFFD700,
+	ColorGoldenrod:            0xDAA520,
+	ColorGreenYellow:          0xADFF2F,
+	ColorHoneydew:             0xF0FFF0,
+	ColorHotPink:              0xFF69B4,
+	ColorIndianRed:            0xCD5C5C,
+	ColorIndigo:               0x4B0082,
+	ColorIvory:                0xFFFFF0,
+	ColorKhaki:                0xF0E68C,
+	ColorLavender:             0xE6E6FA,
+	ColorLavenderBlush:        0xFFF0F5,
+	ColorLawnGreen:            0x7CFC00,
+	ColorLemonChiffon:         0xFFFACD,
+	ColorLightBlue:            0xADD8E6,
+	ColorLightCoral:           0xF08080,
+	ColorLightCyan:            0xE0FFFF,
+	ColorLightGoldenrodYellow: 0xFAFAD2,
+	ColorLightGray:            0xD3D3D3,
+	ColorLightGreen:           0x90EE90,
+	ColorLightPink:            0xFFB6C1,
+	ColorLightSalmon:          0xFFA07A,
+	ColorLightSeaGreen:        0x20B2AA,
+	ColorLightSkyBlue:         0x87CEFA,
+	ColorLightSlateGray:       0x778899,
+	ColorLightSteelBlue:       0xB0C4DE,
+	ColorLightYellow:          0xFFFFE0,
+	ColorLimeGreen:            0x32CD32,
+	ColorLinen:                0xFAF0E6,
+	ColorMediumAquamarine:     0x66CDAA,
+	ColorMediumBlue:           0x0000CD,
+	ColorMediumOrchid:         0xBA55D3,
+	ColorMediumPurple:         0x9370DB,
+	ColorMediumSeaGreen:       0x3CB371,
+	ColorMediumSlateBlue:      0x7B68EE,
+	ColorMediumSpringGreen:    0x00FA9A,
+	ColorMediumTurquoise:      0x48D1CC,
+	ColorMediumVioletRed:      0xC71585,
+	ColorMidnightBlue:         0x191970,
+	ColorMintCream:            0xF5FFFA,
+	ColorMistyRose:            0xFFE4E1,
+	ColorMoccasin:             0xFFE4B5,
+	ColorNavajoWhite:          0xFFDEAD,
+	ColorOldLace:              0xFDF5E6,
+	ColorOliveDrab:            0x6B8E23,
+	ColorOrange:               0xFFA500,
+	ColorOrangeRed:            0xFF4500,
+	ColorOrchid:               0xDA70D6,
+	ColorPaleGoldenrod:        0xEEE8AA,
+	ColorPaleGreen:            0x98FB98,
+	ColorPaleTurquoise:        0xAFEEEE,
+	ColorPaleVioletRed:        0xDB7093,
+	ColorPapayaWhip:           0xFFEFD5,
+	ColorPeachPuff:            0xFFDAB9,
+	ColorPeru:                 0xCD853F,
+	ColorPink:                 0xFFC0CB,
+	ColorPlum:                 0xDDA0DD,
+	ColorPowderBlue:           0xB0E0E6,
+	ColorRebeccaPurple:        0x663399,
+	ColorRosyBrown:            0xBC8F8F,
+	ColorRoyalBlue:            0x4169E1,
+	ColorSaddleBrown:          0x8B4513,
+	ColorSalmon:               0xFA8072,
+	ColorSandyBrown:           0xF4A460,
+	ColorSeaGreen:             0x2E8B57,
+	ColorSeashell:             0xFFF5EE,
+	ColorSienna:               0xA0522D,
+	ColorSkyblue:              0x87CEEB,
+	ColorSlateBlue:            0x6A5ACD,
+	ColorSlateGray:            0x708090,
+	ColorSnow:                 0xFFFAFA,
+	ColorSpringGreen:          0x00FF7F,
+	ColorSteelBlue:            0x4682B4,
+	ColorTan:                  0xD2B48C,
+	ColorThistle:              0xD8BFD8,
+	ColorTomato:               0xFF6347,
+	ColorTurquoise:            0x40E0D0,
+	ColorViolet:               0xEE82EE,
+	ColorWheat:                0xF5DEB3,
+	ColorWhiteSmoke:           0xF5F5F5,
+	ColorYellowGreen:          0x9ACD32,
+}
+
+// ColorNames holds the written names of colors. Useful to present a list of
+// recognized named colors.
+var ColorNames = map[string]Color{
+	"black":                ColorBlack,
+	"maroon":               ColorMaroon,
+	"green":                ColorGreen,
+	"olive":                ColorOlive,
+	"navy":                 ColorNavy,
+	"purple":               ColorPurple,
+	"teal":                 ColorTeal,
+	"silver":               ColorSilver,
+	"gray":                 ColorGray,
+	"red":                  ColorRed,
+	"lime":                 ColorLime,
+	"yellow":               ColorYellow,
+	"blue":                 ColorBlue,
+	"fuchsia":              ColorFuchsia,
+	"aqua":                 ColorAqua,
+	"white":                ColorWhite,
+	"aliceblue":            ColorAliceBlue,
+	"antiquewhite":         ColorAntiqueWhite,
+	"aquamarine":           ColorAquaMarine,
+	"azure":                ColorAzure,
+	"beige":                ColorBeige,
+	"bisque":               ColorBisque,
+	"blanchedalmond":       ColorBlanchedAlmond,
+	"blueviolet":           ColorBlueViolet,
+	"brown":                ColorBrown,
+	"burlywood":            ColorBurlyWood,
+	"cadetblue":            ColorCadetBlue,
+	"chartreuse":           ColorChartreuse,
+	"chocolate":            ColorChocolate,
+	"coral":                ColorCoral,
+	"cornflowerblue":       ColorCornflowerBlue,
+	"cornsilk":             ColorCornsilk,
+	"crimson":              ColorCrimson,
+	"darkblue":             ColorDarkBlue,
+	"darkcyan":             ColorDarkCyan,
+	"darkgoldenrod":        ColorDarkGoldenrod,
+	"darkgray":             ColorDarkGray,
+	"darkgreen":            ColorDarkGreen,
+	"darkkhaki":            ColorDarkKhaki,
+	"darkmagenta":          ColorDarkMagenta,
+	"darkolivegreen":       ColorDarkOliveGreen,
+	"darkorange":           ColorDarkOrange,
+	"darkorchid":           ColorDarkOrchid,
+	"darkred":              ColorDarkRed,
+	"darksalmon":           ColorDarkSalmon,
+	"darkseagreen":         ColorDarkSeaGreen,
+	"darkslateblue":        ColorDarkSlateBlue,
+	"darkslategray":        ColorDarkSlateGray,
+	"darkturquoise":        ColorDarkTurquoise,
+	"darkviolet":           ColorDarkViolet,
+	"deeppink":             ColorDeepPink,
+	"deepskyblue":          ColorDeepSkyBlue,
+	"dimgray":              ColorDimGray,
+	"dodgerblue":           ColorDodgerBlue,
+	"firebrick":            ColorFireBrick,
+	"floralwhite":          ColorFloralWhite,
+	"forestgreen":          ColorForestGreen,
+	"gainsboro":            ColorGainsboro,
+	"ghostwhite":           ColorGhostWhite,
+	"gold":                 ColorGold,
+	"goldenrod":            ColorGoldenrod,
+	"greenyellow":          ColorGreenYellow,
+	"honeydew":             ColorHoneydew,
+	"hotpink":              ColorHotPink,
+	"indianred":            ColorIndianRed,
+	"indigo":               ColorIndigo,
+	"ivory":                ColorIvory,
+	"khaki":                ColorKhaki,
+	"lavender":             ColorLavender,
+	"lavenderblush":        ColorLavenderBlush,
+	"lawngreen":            ColorLawnGreen,
+	"lemonchiffon":         ColorLemonChiffon,
+	"lightblue":            ColorLightBlue,
+	"lightcoral":           ColorLightCoral,
+	"lightcyan":            ColorLightCyan,
+	"lightgoldenrodyellow": ColorLightGoldenrodYellow,
+	"lightgray":            ColorLightGray,
+	"lightgreen":           ColorLightGreen,
+	"lightpink":            ColorLightPink,
+	"lightsalmon":          ColorLightSalmon,
+	"lightseagreen":        ColorLightSeaGreen,
+	"lightskyblue":         ColorLightSkyBlue,
+	"lightslategray":       ColorLightSlateGray,
+	"lightsteelblue":       ColorLightSteelBlue,
+	"lightyellow":          ColorLightYellow,
+	"limegreen":            ColorLimeGreen,
+	"linen":                ColorLinen,
+	"mediumaquamarine":     ColorMediumAquamarine,
+	"mediumblue":           ColorMediumBlue,
+	"mediumorchid":         ColorMediumOrchid,
+	"mediumpurple":         ColorMediumPurple,
+	"mediumseagreen":       ColorMediumSeaGreen,
+	"mediumslateblue":      ColorMediumSlateBlue,
+	"mediumspringgreen":    ColorMediumSpringGreen,
+	"mediumturquoise":      ColorMediumTurquoise,
+	"mediumvioletred":      ColorMediumVioletRed,
+	"midnightblue":         ColorMidnightBlue,
+	"mintcream":            ColorMintCream,
+	"mistyrose":            ColorMistyRose,
+	"moccasin":             ColorMoccasin,
+	"navajowhite":          ColorNavajoWhite,
+	"oldlace":              ColorOldLace,
+	"olivedrab":            ColorOliveDrab,
+	"orange":               ColorOrange,
+	"orangered":            ColorOrangeRed,
+	"orchid":               ColorOrchid,
+	"palegoldenrod":        ColorPaleGoldenrod,
+	"palegreen":            ColorPaleGreen,
+	"paleturquoise":        ColorPaleTurquoise,
+	"palevioletred":        ColorPaleVioletRed,
+	"papayawhip":           ColorPapayaWhip,
+	"peachpuff":            ColorPeachPuff,
+	"peru":                 ColorPeru,
+	"pink":                 ColorPink,
+	"plum":                 ColorPlum,
+	"powderblue":           ColorPowderBlue,
+	"rebeccapurple":        ColorRebeccaPurple,
+	"rosybrown":            ColorRosyBrown,
+	"royalblue":            ColorRoyalBlue,
+	"saddlebrown":          ColorSaddleBrown,
+	"salmon":               ColorSalmon,
+	"sandybrown":           ColorSandyBrown,
+	"seagreen":             ColorSeaGreen,
+	"seashell":             ColorSeashell,
+	"sienna":               ColorSienna,
+	"skyblue":              ColorSkyblue,
+	"slateblue":            ColorSlateBlue,
+	"slategray":            ColorSlateGray,
+	"snow":                 ColorSnow,
+	"springgreen":          ColorSpringGreen,
+	"steelblue":            ColorSteelBlue,
+	"tan":                  ColorTan,
+	"thistle":              ColorThistle,
+	"tomato":               ColorTomato,
+	"turquoise":            ColorTurquoise,
+	"violet":               ColorViolet,
+	"wheat":                ColorWheat,
+	"whitesmoke":           ColorWhiteSmoke,
+	"yellowgreen":          ColorYellowGreen,
+	"grey":                 ColorGray,
+	"dimgrey":              ColorDimGray,
+	"darkgrey":             ColorDarkGray,
+	"darkslategrey":        ColorDarkSlateGray,
+	"lightgrey":            ColorLightGray,
+	"lightslategrey":       ColorLightSlateGray,
+	"slategrey":            ColorSlateGray,
+}
+
+// Hex returns the color's hexadecimal RGB 24-bit value with each component
+// consisting of a single byte, ala R << 16 | G << 8 | B.  If the color
+// is unknown or unset, -1 is returned.
+func (c Color) Hex() int32 {
+	if c&ColorIsRGB != 0 {
+		return (int32(c) & 0xffffff)
+	}
+	if v, ok := ColorValues[c]; ok {
+		return v
+	}
+	return -1
+}
+
+// RGB returns the red, green, and blue components of the color, with
+// each component represented as a value 0-255.  In the event that the
+// color cannot be broken up (not set usually), -1 is returned for each value.
+func (c Color) RGB() (int32, int32, int32) {
+	v := c.Hex()
+	if v < 0 {
+		return -1, -1, -1
+	}
+	return (v >> 16) & 0xff, (v >> 8) & 0xff, v & 0xff
+}
+
+// NewRGBColor returns a new color with the given red, green, and blue values.
+// Each value must be represented in the range 0-255.
+func NewRGBColor(r, g, b int32) Color {
+	return NewHexColor(((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff))
+}
+
+// NewHexColor returns a color using the given 24-bit RGB value.
+func NewHexColor(v int32) Color {
+	return ColorIsRGB | Color(v)
+}
+
+// GetColor creates a Color from a color name (W3C name). A hex value may
+// be supplied as a string in the format "#ffffff".
+func GetColor(name string) Color {
+	if c, ok := ColorNames[name]; ok {
+		return c
+	}
+	if len(name) == 7 && name[0] == '#' {
+		if v, e := strconv.ParseInt(name[1:], 16, 32); e == nil {
+			return NewHexColor(int32(v))
+		}
+	}
+	return ColorDefault
+}

libtui/v0/vendor/github.com/gdamore/tcell/colorfit.go

@@ -0,0 +1,52 @@
+// Copyright 2016 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.
+
+package tcell
+
+import (
+	"github.com/lucasb-eyer/go-colorful"
+	"math"
+)
+
+// FindColor attempts to find a given color, or the best match possible for it,
+// from the palette given.  This is an expensive operation, so results should
+// be cached by the caller.
+func FindColor(c Color, palette []Color) Color {
+	match := ColorDefault
+	dist := float64(0)
+	r, g, b := c.RGB()
+	c1 := colorful.Color{
+		R: float64(r) / 255.0,
+		G: float64(g) / 255.0,
+		B: float64(b) / 255.0,
+	}
+	for _, d := range palette {
+		r, g, b = d.RGB()
+		c2 := colorful.Color{
+			R: float64(r) / 255.0,
+			G: float64(g) / 255.0,
+			B: float64(b) / 255.0,
+		}
+		// CIE94 is more accurate, but really really expensive.
+		nd := c1.DistanceCIE76(c2)
+		if math.IsNaN(nd) {
+			nd = math.Inf(1)
+		}
+		if match == ColorDefault || nd < dist {
+			match = d
+			dist = nd
+		}
+	}
+	return match
+}

libtui/v0/vendor/github.com/gdamore/tcell/console_stub.go

@@ -0,0 +1,23 @@
+// +build !windows
+
+// Copyright 2015 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.
+
+package tcell
+
+// NewConsoleScreen returns a console based screen.  This platform
+// doesn't have support for any, so it returns nil and a suitable error.
+func NewConsoleScreen() (Screen, error) {
+	return nil, ErrNoScreen
+}

libtui/v0/vendor/github.com/gdamore/tcell/console_win.go

@@ -0,0 +1,1170 @@
+// +build windows
+
+// Copyright 2019 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.
+
+package tcell
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+	"sync"
+	"syscall"
+	"unicode/utf16"
+	"unsafe"
+)
+
+type cScreen struct {
+	in         syscall.Handle
+	out        syscall.Handle
+	cancelflag syscall.Handle
+	scandone   chan struct{}
+	evch       chan Event
+	quit       chan struct{}
+	curx       int
+	cury       int
+	style      Style
+	clear      bool
+	fini       bool
+	vten       bool
+	truecolor  bool
+
+	w int
+	h int
+
+	oscreen consoleInfo
+	ocursor cursorInfo
+	oimode  uint32
+	oomode  uint32
+	cells   CellBuffer
+
+	sync.Mutex
+}
+
+var winLock sync.Mutex
+
+var winPalette = []Color{
+	ColorBlack,
+	ColorMaroon,
+	ColorGreen,
+	ColorNavy,
+	ColorOlive,
+	ColorPurple,
+	ColorTeal,
+	ColorSilver,
+	ColorGray,
+	ColorRed,
+	ColorLime,
+	ColorBlue,
+	ColorYellow,
+	ColorFuchsia,
+	ColorAqua,
+	ColorWhite,
+}
+
+var winColors = map[Color]Color{
+	ColorBlack:   ColorBlack,
+	ColorMaroon:  ColorMaroon,
+	ColorGreen:   ColorGreen,
+	ColorNavy:    ColorNavy,
+	ColorOlive:   ColorOlive,
+	ColorPurple:  ColorPurple,
+	ColorTeal:    ColorTeal,
+	ColorSilver:  ColorSilver,
+	ColorGray:    ColorGray,
+	ColorRed:     ColorRed,
+	ColorLime:    ColorLime,
+	ColorBlue:    ColorBlue,
+	ColorYellow:  ColorYellow,
+	ColorFuchsia: ColorFuchsia,
+	ColorAqua:    ColorAqua,
+	ColorWhite:   ColorWhite,
+}
+
+var (
+	k32 = syscall.NewLazyDLL("kernel32.dll")
+	u32 = syscall.NewLazyDLL("user32.dll")
+)
+
+// We have to bring in the kernel32 and user32 DLLs directly, so we can get
+// access to some system calls that the core Go API lacks.
+//
+// Note that Windows appends some functions with W to indicate that wide
+// characters (Unicode) are in use.  The documentation refers to them
+// without this suffix, as the resolution is made via preprocessor.
+var (
+	procReadConsoleInput           = k32.NewProc("ReadConsoleInputW")
+	procWaitForMultipleObjects     = k32.NewProc("WaitForMultipleObjects")
+	procCreateEvent                = k32.NewProc("CreateEventW")
+	procSetEvent                   = k32.NewProc("SetEvent")
+	procGetConsoleCursorInfo       = k32.NewProc("GetConsoleCursorInfo")
+	procSetConsoleCursorInfo       = k32.NewProc("SetConsoleCursorInfo")
+	procSetConsoleCursorPosition   = k32.NewProc("SetConsoleCursorPosition")
+	procSetConsoleMode             = k32.NewProc("SetConsoleMode")
+	procGetConsoleMode             = k32.NewProc("GetConsoleMode")
+	procGetConsoleScreenBufferInfo = k32.NewProc("GetConsoleScreenBufferInfo")
+	procFillConsoleOutputAttribute = k32.NewProc("FillConsoleOutputAttribute")
+	procFillConsoleOutputCharacter = k32.NewProc("FillConsoleOutputCharacterW")
+	procSetConsoleWindowInfo       = k32.NewProc("SetConsoleWindowInfo")
+	procSetConsoleScreenBufferSize = k32.NewProc("SetConsoleScreenBufferSize")
+	procSetConsoleTextAttribute    = k32.NewProc("SetConsoleTextAttribute")
+	procMessageBeep                = u32.NewProc("MessageBeep")
+)
+
+const (
+	w32Infinite    = ^uintptr(0)
+	w32WaitObject0 = uintptr(0)
+)
+
+const (
+	// VT100/XTerm escapes understood by the console
+	vtShowCursor = "\x1b[?25h"
+	vtHideCursor = "\x1b[?25l"
+	vtCursorPos  = "\x1b[%d;%dH" // Note that it is Y then X
+	vtSgr0       = "\x1b[0m"
+	vtBold       = "\x1b[1m"
+	vtUnderline  = "\x1b[4m"
+	vtBlink      = "\x1b[5m" // Not sure this is processed
+	vtReverse    = "\x1b[7m"
+	vtSetFg      = "\x1b[38;2;%d;%d;%dm" // RGB
+	vtSetBg      = "\x1b[48;2;%d;%d;%dm" // RGB
+)
+
+// NewConsoleScreen returns a Screen for the Windows console associated
+// with the current process.  The Screen makes use of the Windows Console
+// API to display content and read events.
+func NewConsoleScreen() (Screen, error) {
+	return &cScreen{}, nil
+}
+
+func (s *cScreen) Init() error {
+	s.evch = make(chan Event, 10)
+	s.quit = make(chan struct{})
+	s.scandone = make(chan struct{})
+
+	in, e := syscall.Open("CONIN$", syscall.O_RDWR, 0)
+	if e != nil {
+		return e
+	}
+	s.in = in
+	out, e := syscall.Open("CONOUT$", syscall.O_RDWR, 0)
+	if e != nil {
+		syscall.Close(s.in)
+		return e
+	}
+	s.out = out
+
+	s.truecolor = true
+
+	// ConEmu handling of colors and scrolling when in terminal
+	// mode is extremely problematic at the best.  The color
+	// palette will scroll even though characters do not, when
+	// emiting stuff for the last character.  In the future we
+	// might change this to look at specific versions of ConEmu
+	// if they fix the bug.
+	if os.Getenv("ConEmuPID") != "" {
+		s.truecolor = false
+	}
+	switch os.Getenv("TCELL_TRUECOLOR") {
+	case "disable":
+		s.truecolor = false
+	case "enable":
+		s.truecolor = true
+	}
+
+	cf, _, e := procCreateEvent.Call(
+		uintptr(0),
+		uintptr(1),
+		uintptr(0),
+		uintptr(0))
+	if cf == uintptr(0) {
+		return e
+	}
+	s.cancelflag = syscall.Handle(cf)
+
+	s.Lock()
+
+	s.curx = -1
+	s.cury = -1
+	s.style = StyleDefault
+	s.getCursorInfo(&s.ocursor)
+	s.getConsoleInfo(&s.oscreen)
+	s.getOutMode(&s.oomode)
+	s.getInMode(&s.oimode)
+	s.resize()
+
+	s.fini = false
+	s.setInMode(modeResizeEn | modeExtndFlg)
+
+	// 24-bit color is opt-in for now, because we can't figure out
+	// to make it work consistently.
+	if s.truecolor {
+		s.setOutMode(modeVtOutput | modeNoAutoNL | modeCookedOut)
+		var omode uint32
+		s.getOutMode(&omode)
+		if omode&modeVtOutput == modeVtOutput {
+			s.vten = true
+		} else {
+			s.truecolor = false
+		}
+	} else {
+		s.setOutMode(0)
+	}
+
+	s.clearScreen(s.style)
+	s.hideCursor()
+	s.Unlock()
+	go s.scanInput()
+
+	return nil
+}
+
+func (s *cScreen) CharacterSet() string {
+	// We are always UTF-16LE on Windows
+	return "UTF-16LE"
+}
+
+func (s *cScreen) EnableMouse() {
+	s.setInMode(modeResizeEn | modeMouseEn | modeExtndFlg)
+}
+
+func (s *cScreen) DisableMouse() {
+	s.setInMode(modeResizeEn | modeExtndFlg)
+}
+
+func (s *cScreen) Fini() {
+	s.Lock()
+	s.style = StyleDefault
+	s.curx = -1
+	s.cury = -1
+	s.fini = true
+	s.vten = false
+	s.Unlock()
+
+	s.setCursorInfo(&s.ocursor)
+	s.setInMode(s.oimode)
+	s.setOutMode(s.oomode)
+	s.setBufferSize(int(s.oscreen.size.x), int(s.oscreen.size.y))
+	s.clearScreen(StyleDefault)
+	s.setCursorPos(0, 0)
+	procSetConsoleTextAttribute.Call(
+		uintptr(s.out),
+		uintptr(s.mapStyle(StyleDefault)))
+
+	close(s.quit)
+	procSetEvent.Call(uintptr(s.cancelflag))
+	// Block until scanInput returns; this prevents a race condition on Win 8+
+	// which causes syscall.Close to block until another keypress is read.
+	<-s.scandone
+	syscall.Close(s.in)
+	syscall.Close(s.out)
+}
+
+func (s *cScreen) PostEventWait(ev Event) {
+	s.evch <- ev
+}
+
+func (s *cScreen) PostEvent(ev Event) error {
+	select {
+	case s.evch <- ev:
+		return nil
+	default:
+		return ErrEventQFull
+	}
+}
+
+func (s *cScreen) PollEvent() Event {
+	select {
+	case <-s.quit:
+		return nil
+	case ev := <-s.evch:
+		return ev
+	}
+}
+
+type cursorInfo struct {
+	size    uint32
+	visible uint32
+}
+
+type coord struct {
+	x int16
+	y int16
+}
+
+func (c coord) uintptr() uintptr {
+	// little endian, put x first
+	return uintptr(c.x) | (uintptr(c.y) << 16)
+}
+
+type rect struct {
+	left   int16
+	top    int16
+	right  int16
+	bottom int16
+}
+
+func (s *cScreen) emitVtString(vs string) {
+	esc := utf16.Encode([]rune(vs))
+	syscall.WriteConsole(s.out, &esc[0], uint32(len(esc)), nil, nil)
+}
+
+func (s *cScreen) showCursor() {
+	if s.vten {
+		s.emitVtString(vtShowCursor)
+	} else {
+		s.setCursorInfo(&cursorInfo{size: 100, visible: 1})
+	}
+}
+
+func (s *cScreen) hideCursor() {
+	if s.vten {
+		s.emitVtString(vtHideCursor)
+	} else {
+		s.setCursorInfo(&cursorInfo{size: 1, visible: 0})
+	}
+}
+
+func (s *cScreen) ShowCursor(x, y int) {
+	s.Lock()
+	if !s.fini {
+		s.curx = x
+		s.cury = y
+	}
+	s.doCursor()
+	s.Unlock()
+}
+
+func (s *cScreen) doCursor() {
+	x, y := s.curx, s.cury
+
+	if x < 0 || y < 0 || x >= s.w || y >= s.h {
+		s.hideCursor()
+	} else {
+		s.setCursorPos(x, y)
+		s.showCursor()
+	}
+}
+
+func (s *cScreen) HideCursor() {
+	s.ShowCursor(-1, -1)
+}
+
+type inputRecord struct {
+	typ  uint16
+	_    uint16
+	data [16]byte
+}
+
+const (
+	keyEvent    uint16 = 1
+	mouseEvent  uint16 = 2
+	resizeEvent uint16 = 4
+	menuEvent   uint16 = 8  // don't use
+	focusEvent  uint16 = 16 // don't use
+)
+
+type mouseRecord struct {
+	x     int16
+	y     int16
+	btns  uint32
+	mod   uint32
+	flags uint32
+}
+
+const (
+	mouseDoubleClick uint32 = 0x2
+	mouseHWheeled    uint32 = 0x8
+	mouseVWheeled    uint32 = 0x4
+	mouseMoved       uint32 = 0x1
+)
+
+type resizeRecord struct {
+	x int16
+	y int16
+}
+
+type keyRecord struct {
+	isdown int32
+	repeat uint16
+	kcode  uint16
+	scode  uint16
+	ch     uint16
+	mod    uint32
+}
+
+const (
+	// Constants per Microsoft.  We don't put the modifiers
+	// here.
+	vkCancel = 0x03
+	vkBack   = 0x08 // Backspace
+	vkTab    = 0x09
+	vkClear  = 0x0c
+	vkReturn = 0x0d
+	vkPause  = 0x13
+	vkEscape = 0x1b
+	vkSpace  = 0x20
+	vkPrior  = 0x21 // PgUp
+	vkNext   = 0x22 // PgDn
+	vkEnd    = 0x23
+	vkHome   = 0x24
+	vkLeft   = 0x25
+	vkUp     = 0x26
+	vkRight  = 0x27
+	vkDown   = 0x28
+	vkPrint  = 0x2a
+	vkPrtScr = 0x2c
+	vkInsert = 0x2d
+	vkDelete = 0x2e
+	vkHelp   = 0x2f
+	vkF1     = 0x70
+	vkF2     = 0x71
+	vkF3     = 0x72
+	vkF4     = 0x73
+	vkF5     = 0x74
+	vkF6     = 0x75
+	vkF7     = 0x76
+	vkF8     = 0x77
+	vkF9     = 0x78
+	vkF10    = 0x79
+	vkF11    = 0x7a
+	vkF12    = 0x7b
+	vkF13    = 0x7c
+	vkF14    = 0x7d
+	vkF15    = 0x7e
+	vkF16    = 0x7f
+	vkF17    = 0x80
+	vkF18    = 0x81
+	vkF19    = 0x82
+	vkF20    = 0x83
+	vkF21    = 0x84
+	vkF22    = 0x85
+	vkF23    = 0x86
+	vkF24    = 0x87
+)
+
+var vkKeys = map[uint16]Key{
+	vkCancel: KeyCancel,
+	vkBack:   KeyBackspace,
+	vkTab:    KeyTab,
+	vkClear:  KeyClear,
+	vkPause:  KeyPause,
+	vkPrint:  KeyPrint,
+	vkPrtScr: KeyPrint,
+	vkPrior:  KeyPgUp,
+	vkNext:   KeyPgDn,
+	vkReturn: KeyEnter,
+	vkEnd:    KeyEnd,
+	vkHome:   KeyHome,
+	vkLeft:   KeyLeft,
+	vkUp:     KeyUp,
+	vkRight:  KeyRight,
+	vkDown:   KeyDown,
+	vkInsert: KeyInsert,
+	vkDelete: KeyDelete,
+	vkHelp:   KeyHelp,
+	vkF1:     KeyF1,
+	vkF2:     KeyF2,
+	vkF3:     KeyF3,
+	vkF4:     KeyF4,
+	vkF5:     KeyF5,
+	vkF6:     KeyF6,
+	vkF7:     KeyF7,
+	vkF8:     KeyF8,
+	vkF9:     KeyF9,
+	vkF10:    KeyF10,
+	vkF11:    KeyF11,
+	vkF12:    KeyF12,
+	vkF13:    KeyF13,
+	vkF14:    KeyF14,
+	vkF15:    KeyF15,
+	vkF16:    KeyF16,
+	vkF17:    KeyF17,
+	vkF18:    KeyF18,
+	vkF19:    KeyF19,
+	vkF20:    KeyF20,
+	vkF21:    KeyF21,
+	vkF22:    KeyF22,
+	vkF23:    KeyF23,
+	vkF24:    KeyF24,
+}
+
+// NB: All Windows platforms are little endian.  We assume this
+// never, ever change.  The following code is endian safe. and does
+// not use unsafe pointers.
+func getu32(v []byte) uint32 {
+	return uint32(v[0]) + (uint32(v[1]) << 8) + (uint32(v[2]) << 16) + (uint32(v[3]) << 24)
+}
+func geti32(v []byte) int32 {
+	return int32(getu32(v))
+}
+func getu16(v []byte) uint16 {
+	return uint16(v[0]) + (uint16(v[1]) << 8)
+}
+func geti16(v []byte) int16 {
+	return int16(getu16(v))
+}
+
+// Convert windows dwControlKeyState to modifier mask
+func mod2mask(cks uint32) ModMask {
+	mm := ModNone
+	// Left or right control
+	if (cks & (0x0008 | 0x0004)) != 0 {
+		mm |= ModCtrl
+	}
+	// Left or right alt
+	if (cks & (0x0002 | 0x0001)) != 0 {
+		mm |= ModAlt
+	}
+	// Any shift
+	if (cks & 0x0010) != 0 {
+		mm |= ModShift
+	}
+	return mm
+}
+
+func mrec2btns(mbtns, flags uint32) ButtonMask {
+	btns := ButtonNone
+	if mbtns&0x1 != 0 {
+		btns |= Button1
+	}
+	if mbtns&0x2 != 0 {
+		btns |= Button2
+	}
+	if mbtns&0x4 != 0 {
+		btns |= Button3
+	}
+	if mbtns&0x8 != 0 {
+		btns |= Button4
+	}
+	if mbtns&0x10 != 0 {
+		btns |= Button5
+	}
+	if mbtns&0x20 != 0 {
+		btns |= Button6
+	}
+	if mbtns&0x40 != 0 {
+		btns |= Button7
+	}
+	if mbtns&0x80 != 0 {
+		btns |= Button8
+	}
+
+	if flags&mouseVWheeled != 0 {
+		if mbtns&0x80000000 == 0 {
+			btns |= WheelUp
+		} else {
+			btns |= WheelDown
+		}
+	}
+	if flags&mouseHWheeled != 0 {
+		if mbtns&0x80000000 == 0 {
+			btns |= WheelRight
+		} else {
+			btns |= WheelLeft
+		}
+	}
+	return btns
+}
+
+func (s *cScreen) getConsoleInput() error {
+	// cancelFlag comes first as WaitForMultipleObjects returns the lowest index
+	// in the event that both events are signalled.
+	waitObjects := []syscall.Handle{s.cancelflag, s.in}
+	// As arrays are contiguous in memory, a pointer to the first object is the
+	// same as a pointer to the array itself.
+	pWaitObjects := unsafe.Pointer(&waitObjects[0])
+
+	rv, _, er := procWaitForMultipleObjects.Call(
+		uintptr(len(waitObjects)),
+		uintptr(pWaitObjects),
+		uintptr(0),
+		w32Infinite)
+	// WaitForMultipleObjects returns WAIT_OBJECT_0 + the index.
+	switch rv {
+	case w32WaitObject0: // s.cancelFlag
+		return errors.New("cancelled")
+	case w32WaitObject0 + 1: // s.in
+		rec := &inputRecord{}
+		var nrec int32
+		rv, _, er := procReadConsoleInput.Call(
+			uintptr(s.in),
+			uintptr(unsafe.Pointer(rec)),
+			uintptr(1),
+			uintptr(unsafe.Pointer(&nrec)))
+		if rv == 0 {
+			return er
+		}
+		if nrec != 1 {
+			return nil
+		}
+		switch rec.typ {
+		case keyEvent:
+			krec := &keyRecord{}
+			krec.isdown = geti32(rec.data[0:])
+			krec.repeat = getu16(rec.data[4:])
+			krec.kcode = getu16(rec.data[6:])
+			krec.scode = getu16(rec.data[8:])
+			krec.ch = getu16(rec.data[10:])
+			krec.mod = getu32(rec.data[12:])
+
+			if krec.isdown == 0 || krec.repeat < 1 {
+				// its a key release event, ignore it
+				return nil
+			}
+			if krec.ch != 0 {
+				// synthesized key code
+				for krec.repeat > 0 {
+					// convert shift+tab to backtab
+					if mod2mask(krec.mod) == ModShift && krec.ch == vkTab {
+						s.PostEvent(NewEventKey(KeyBacktab, 0,
+							ModNone))
+					} else {
+						s.PostEvent(NewEventKey(KeyRune, rune(krec.ch),
+							mod2mask(krec.mod)))
+					}
+					krec.repeat--
+				}
+				return nil
+			}
+			key := KeyNUL // impossible on Windows
+			ok := false
+			if key, ok = vkKeys[krec.kcode]; !ok {
+				return nil
+			}
+			for krec.repeat > 0 {
+				s.PostEvent(NewEventKey(key, rune(krec.ch),
+					mod2mask(krec.mod)))
+				krec.repeat--
+			}
+
+		case mouseEvent:
+			var mrec mouseRecord
+			mrec.x = geti16(rec.data[0:])
+			mrec.y = geti16(rec.data[2:])
+			mrec.btns = getu32(rec.data[4:])
+			mrec.mod = getu32(rec.data[8:])
+			mrec.flags = getu32(rec.data[12:])
+			btns := mrec2btns(mrec.btns, mrec.flags)
+			// we ignore double click, events are delivered normally
+			s.PostEvent(NewEventMouse(int(mrec.x), int(mrec.y), btns,
+				mod2mask(mrec.mod)))
+
+		case resizeEvent:
+			var rrec resizeRecord
+			rrec.x = geti16(rec.data[0:])
+			rrec.y = geti16(rec.data[2:])
+			s.PostEvent(NewEventResize(int(rrec.x), int(rrec.y)))
+
+		default:
+		}
+	default:
+		return er
+	}
+
+	return nil
+}
+
+func (s *cScreen) scanInput() {
+	for {
+		if e := s.getConsoleInput(); e != nil {
+			close(s.scandone)
+			return
+		}
+	}
+}
+
+// Windows console can display 8 characters, in either low or high intensity
+func (s *cScreen) Colors() int {
+	if s.vten {
+		return 1 << 24
+	}
+	return 16
+}
+
+var vgaColors = map[Color]uint16{
+	ColorBlack:   0,
+	ColorMaroon:  0x4,
+	ColorGreen:   0x2,
+	ColorNavy:    0x1,
+	ColorOlive:   0x6,
+	ColorPurple:  0x5,
+	ColorTeal:    0x3,
+	ColorSilver:  0x7,
+	ColorGrey:    0x8,
+	ColorRed:     0xc,
+	ColorLime:    0xa,
+	ColorBlue:    0x9,
+	ColorYellow:  0xe,
+	ColorFuchsia: 0xd,
+	ColorAqua:    0xb,
+	ColorWhite:   0xf,
+}
+
+// Windows uses RGB signals
+func mapColor2RGB(c Color) uint16 {
+	winLock.Lock()
+	if v, ok := winColors[c]; ok {
+		c = v
+	} else {
+		v = FindColor(c, winPalette)
+		winColors[c] = v
+		c = v
+	}
+	winLock.Unlock()
+
+	if vc, ok := vgaColors[c]; ok {
+		return vc
+	}
+	return 0
+}
+
+// Map a tcell style to Windows attributes
+func (s *cScreen) mapStyle(style Style) uint16 {
+	f, b, a := style.Decompose()
+	fa := s.oscreen.attrs & 0xf
+	ba := (s.oscreen.attrs) >> 4 & 0xf
+	if f != ColorDefault {
+		fa = mapColor2RGB(f)
+	}
+	if b != ColorDefault {
+		ba = mapColor2RGB(b)
+	}
+	var attr uint16
+	// We simulate reverse by doing the color swap ourselves.
+	// Apparently windows cannot really do this except in DBCS
+	// views.
+	if a&AttrReverse != 0 {
+		attr = ba
+		attr |= (fa << 4)
+	} else {
+		attr = fa
+		attr |= (ba << 4)
+	}
+	if a&AttrBold != 0 {
+		attr |= 0x8
+	}
+	if a&AttrDim != 0 {
+		attr &^= 0x8
+	}
+	if a&AttrUnderline != 0 {
+		// Best effort -- doesn't seem to work though.
+		attr |= 0x8000
+	}
+	// Blink is unsupported
+	return attr
+}
+
+func (s *cScreen) SetCell(x, y int, style Style, ch ...rune) {
+	if len(ch) > 0 {
+		s.SetContent(x, y, ch[0], ch[1:], style)
+	} else {
+		s.SetContent(x, y, ' ', nil, style)
+	}
+}
+
+func (s *cScreen) SetContent(x, y int, mainc rune, combc []rune, style Style) {
+	s.Lock()
+	if !s.fini {
+		s.cells.SetContent(x, y, mainc, combc, style)
+	}
+	s.Unlock()
+}
+
+func (s *cScreen) GetContent(x, y int) (rune, []rune, Style, int) {
+	s.Lock()
+	mainc, combc, style, width := s.cells.GetContent(x, y)
+	s.Unlock()
+	return mainc, combc, style, width
+}
+
+func (s *cScreen) sendVtStyle(style Style) {
+	esc := &strings.Builder{}
+
+	fg, bg, attrs := style.Decompose()
+
+	esc.WriteString(vtSgr0)
+
+	if attrs&(AttrBold|AttrDim) == AttrBold {
+		esc.WriteString(vtBold)
+	}
+	if attrs&AttrBlink != 0 {
+		esc.WriteString(vtBlink)
+	}
+	if attrs&AttrUnderline != 0 {
+		esc.WriteString(vtUnderline)
+	}
+	if attrs&AttrReverse != 0 {
+		esc.WriteString(vtReverse)
+	}
+	if fg != ColorDefault {
+		r, g, b := fg.RGB()
+		fmt.Fprintf(esc, vtSetFg, r, g, b)
+	}
+	if bg != ColorDefault {
+		r, g, b := bg.RGB()
+		fmt.Fprintf(esc, vtSetBg, r, g, b)
+	}
+	s.emitVtString(esc.String())
+}
+
+func (s *cScreen) writeString(x, y int, style Style, ch []uint16) {
+	// we assume the caller has hidden the cursor
+	if len(ch) == 0 {
+		return
+	}
+	s.setCursorPos(x, y)
+
+	if s.vten {
+		s.sendVtStyle(style)
+	} else {
+		procSetConsoleTextAttribute.Call(
+			uintptr(s.out),
+			uintptr(s.mapStyle(style)))
+	}
+	syscall.WriteConsole(s.out, &ch[0], uint32(len(ch)), nil, nil)
+}
+
+func (s *cScreen) draw() {
+	// allocate a scratch line bit enough for no combining chars.
+	// if you have combining characters, you may pay for extra allocs.
+	if s.clear {
+		s.clearScreen(s.style)
+		s.clear = false
+		s.cells.Invalidate()
+	}
+	buf := make([]uint16, 0, s.w)
+	wcs := buf[:]
+	lstyle := Style(-1) // invalid attribute
+
+	lx, ly := -1, -1
+	ra := make([]rune, 1)
+
+	for y := 0; y < int(s.h); y++ {
+		for x := 0; x < int(s.w); x++ {
+			mainc, combc, style, width := s.cells.GetContent(x, y)
+			dirty := s.cells.Dirty(x, y)
+			if style == StyleDefault {
+				style = s.style
+			}
+
+			if !dirty || style != lstyle {
+				// write out any data queued thus far
+				// because we are going to skip over some
+				// cells, or because we need to change styles
+				s.writeString(lx, ly, lstyle, wcs)
+				wcs = buf[0:0]
+				lstyle = Style(-1)
+				if !dirty {
+					continue
+				}
+			}
+			if x > s.w-width {
+				mainc = ' '
+				combc = nil
+				width = 1
+			}
+			if len(wcs) == 0 {
+				lstyle = style
+				lx = x
+				ly = y
+			}
+			ra[0] = mainc
+			wcs = append(wcs, utf16.Encode(ra)...)
+			if len(combc) != 0 {
+				wcs = append(wcs, utf16.Encode(combc)...)
+			}
+			for dx := 0; dx < width; dx++ {
+				s.cells.SetDirty(x+dx, y, false)
+			}
+			x += width - 1
+		}
+		s.writeString(lx, ly, lstyle, wcs)
+		wcs = buf[0:0]
+		lstyle = Style(-1)
+	}
+}
+
+func (s *cScreen) Show() {
+	s.Lock()
+	if !s.fini {
+		s.hideCursor()
+		s.resize()
+		s.draw()
+		s.doCursor()
+	}
+	s.Unlock()
+}
+
+func (s *cScreen) Sync() {
+	s.Lock()
+	if !s.fini {
+		s.cells.Invalidate()
+		s.hideCursor()
+		s.resize()
+		s.draw()
+		s.doCursor()
+	}
+	s.Unlock()
+}
+
+type consoleInfo struct {
+	size  coord
+	pos   coord
+	attrs uint16
+	win   rect
+	maxsz coord
+}
+
+func (s *cScreen) getConsoleInfo(info *consoleInfo) {
+	procGetConsoleScreenBufferInfo.Call(
+		uintptr(s.out),
+		uintptr(unsafe.Pointer(info)))
+}
+
+func (s *cScreen) getCursorInfo(info *cursorInfo) {
+	procGetConsoleCursorInfo.Call(
+		uintptr(s.out),
+		uintptr(unsafe.Pointer(info)))
+}
+
+func (s *cScreen) setCursorInfo(info *cursorInfo) {
+	procSetConsoleCursorInfo.Call(
+		uintptr(s.out),
+		uintptr(unsafe.Pointer(info)))
+
+}
+
+func (s *cScreen) setCursorPos(x, y int) {
+	if s.vten {
+		// Note that the string is Y first.  Origin is 1,1.
+		s.emitVtString(fmt.Sprintf(vtCursorPos, y+1, x+1))
+	} else {
+		procSetConsoleCursorPosition.Call(
+			uintptr(s.out),
+			coord{int16(x), int16(y)}.uintptr())
+	}
+}
+
+func (s *cScreen) setBufferSize(x, y int) {
+	procSetConsoleScreenBufferSize.Call(
+		uintptr(s.out),
+		coord{int16(x), int16(y)}.uintptr())
+}
+
+func (s *cScreen) Size() (int, int) {
+	s.Lock()
+	w, h := s.w, s.h
+	s.Unlock()
+
+	return w, h
+}
+
+func (s *cScreen) resize() {
+	info := consoleInfo{}
+	s.getConsoleInfo(&info)
+
+	w := int((info.win.right - info.win.left) + 1)
+	h := int((info.win.bottom - info.win.top) + 1)
+
+	if s.w == w && s.h == h {
+		return
+	}
+
+	s.cells.Resize(w, h)
+	s.w = w
+	s.h = h
+
+	s.setBufferSize(w, h)
+
+	r := rect{0, 0, int16(w - 1), int16(h - 1)}
+	procSetConsoleWindowInfo.Call(
+		uintptr(s.out),
+		uintptr(1),
+		uintptr(unsafe.Pointer(&r)))
+	s.PostEvent(NewEventResize(w, h))
+}
+
+func (s *cScreen) Clear() {
+	s.Fill(' ', s.style)
+}
+
+func (s *cScreen) Fill(r rune, style Style) {
+	s.Lock()
+	if !s.fini {
+		s.cells.Fill(r, style)
+		s.clear = true
+	}
+	s.Unlock()
+}
+
+func (s *cScreen) clearScreen(style Style) {
+	if s.vten {
+		s.sendVtStyle(style)
+		row := strings.Repeat(" ", s.w)
+		for y := 0; y < s.h; y++ {
+			s.setCursorPos(0, y)
+			s.emitVtString(row)
+		}
+		s.setCursorPos(0, 0)
+
+	} else {
+		pos := coord{0, 0}
+		attr := s.mapStyle(style)
+		x, y := s.w, s.h
+		scratch := uint32(0)
+		count := uint32(x * y)
+
+		procFillConsoleOutputAttribute.Call(
+			uintptr(s.out),
+			uintptr(attr),
+			uintptr(count),
+			pos.uintptr(),
+			uintptr(unsafe.Pointer(&scratch)))
+		procFillConsoleOutputCharacter.Call(
+			uintptr(s.out),
+			uintptr(' '),
+			uintptr(count),
+			pos.uintptr(),
+			uintptr(unsafe.Pointer(&scratch)))
+	}
+}
+
+const (
+	// Input modes
+	modeExtndFlg uint32 = 0x0080
+	modeMouseEn         = 0x0010
+	modeResizeEn        = 0x0008
+	modeCooked          = 0x0001
+	modeVtInput         = 0x0200
+
+	// Output modes
+	modeCookedOut uint32 = 0x0001
+	modeWrapEOL          = 0x0002
+	modeVtOutput         = 0x0004
+	modeNoAutoNL         = 0x0008
+)
+
+func (s *cScreen) setInMode(mode uint32) error {
+	rv, _, err := procSetConsoleMode.Call(
+		uintptr(s.in),
+		uintptr(mode))
+	if rv == 0 {
+		return err
+	}
+	return nil
+}
+
+func (s *cScreen) setOutMode(mode uint32) error {
+	rv, _, err := procSetConsoleMode.Call(
+		uintptr(s.out),
+		uintptr(mode))
+	if rv == 0 {
+		return err
+	}
+	return nil
+}
+
+func (s *cScreen) getInMode(v *uint32) {
+	procGetConsoleMode.Call(
+		uintptr(s.in),
+		uintptr(unsafe.Pointer(v)))
+}
+
+func (s *cScreen) getOutMode(v *uint32) {
+	procGetConsoleMode.Call(
+		uintptr(s.out),
+		uintptr(unsafe.Pointer(v)))
+}
+
+func (s *cScreen) SetStyle(style Style) {
+	s.Lock()
+	s.style = style
+	s.Unlock()
+}
+
+// No fallback rune support, since we have Unicode.  Yay!
+
+func (s *cScreen) RegisterRuneFallback(r rune, subst string) {
+}
+
+func (s *cScreen) UnregisterRuneFallback(r rune) {
+}
+
+func (s *cScreen) CanDisplay(r rune, checkFallbacks bool) bool {
+	// We presume we can display anything -- we're Unicode.
+	// (Sadly this not precisely true.  Combinings are especially
+	// poorly supported under Windows.)
+	return true
+}
+
+func (s *cScreen) HasMouse() bool {
+	return true
+}
+
+func (s *cScreen) Resize(int, int, int, int) {}
+
+func (s *cScreen) HasKey(k Key) bool {
+	// Microsoft has codes for some keys, but they are unusual,
+	// so we don't include them.  We include all the typical
+	// 101, 105 key layout keys.
+	valid := map[Key]bool{
+		KeyBackspace: true,
+		KeyTab:       true,
+		KeyEscape:    true,
+		KeyPause:     true,
+		KeyPrint:     true,
+		KeyPgUp:      true,
+		KeyPgDn:      true,
+		KeyEnter:     true,
+		KeyEnd:       true,
+		KeyHome:      true,
+		KeyLeft:      true,
+		KeyUp:        true,
+		KeyRight:     true,
+		KeyDown:      true,
+		KeyInsert:    true,
+		KeyDelete:    true,
+		KeyF1:        true,
+		KeyF2:        true,
+		KeyF3:        true,
+		KeyF4:        true,
+		KeyF5:        true,
+		KeyF6:        true,
+		KeyF7:        true,
+		KeyF8:        true,
+		KeyF9:        true,
+		KeyF10:       true,
+		KeyF11:       true,
+		KeyF12:       true,
+		KeyRune:      true,
+	}
+
+	return valid[k]
+}
+
+func (s *cScreen) Beep() error {
+	// A simple beep. If the sound card is not available, the sound is generated
+	// using the speaker.
+	//
+	// Reference:
+	// https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-messagebeep
+	const simpleBeep = 0xffffffff
+	if rv, _, err := procMessageBeep.Call(simpleBeep); rv == 0 {
+		return err
+	}
+	return nil
+}

libtui/v0/vendor/github.com/gdamore/tcell/doc.go

@@ -0,0 +1,48 @@
+// 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.
+
+// Package tcell provides a lower-level, portable API for building
+// programs that interact with terminals or consoles.  It works with
+// both common (and many uncommon!) terminals or terminal emulators,
+// and Windows console implementations.
+//
+// It provides support for up to 256 colors, text attributes, and box drawing
+// elements.  A database of terminals built from a real terminfo database
+// is provided, along with code to generate new database entries.
+//
+// Tcell offers very rich support for mice, dependent upon the terminal
+// of course.  (Windows, XTerm, and iTerm 2 are known to work very well.)
+//
+// If the environment is not Unicode by default, such as an ISO8859 based
+// locale or GB18030, Tcell can convert input and output, so that your
+// terminal can operate in whatever locale is most convenient, while the
+// application program can just assume "everything is UTF-8".  Reasonable
+// defaults are used for updating characters to something suitable for
+// display.  Unicode box drawing characters will be converted to use the
+// alternate character set of your terminal, if native conversions are
+// not available.  If no ACS is available, then some ASCII fallbacks will
+// be used.
+//
+// Note that support for non-UTF-8 locales (other than C)  must be enabled
+// by the application using RegisterEncoding() -- we don't have them all
+// enabled by default to avoid bloating the application unneccessarily.
+// (These days UTF-8 is good enough for almost everyone, and nobody should
+// be using legacy locales anymore.)  Also, actual glyphs for various code
+// point will only be displayed if your terminal or emulator (or the font
+// the emulator is using) supports them.
+//
+// A rich set of keycodes is supported, with support for up to 65 function
+// keys, and various other special keys.
+//
+package tcell

libtui/v0/vendor/github.com/gdamore/tcell/encoding.go

@@ -0,0 +1,139 @@
+// Copyright 2015 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.
+
+package tcell
+
+import (
+	"strings"
+	"sync"
+
+	"golang.org/x/text/encoding"
+
+	gencoding "github.com/gdamore/encoding"
+)
+
+var encodings map[string]encoding.Encoding
+var encodingLk sync.Mutex
+var encodingFallback EncodingFallback = EncodingFallbackFail
+
+// RegisterEncoding may be called by the application to register an encoding.
+// The presence of additional encodings will facilitate application usage with
+// terminal environments where the I/O subsystem does not support Unicode.
+//
+// Windows systems use Unicode natively, and do not need any of the encoding
+// subsystem when using Windows Console screens.
+//
+// Please see the Go documentation for golang.org/x/text/encoding -- most of
+// the common ones exist already as stock variables.  For example, ISO8859-15
+// can be registered using the following code:
+//
+//   import "golang.org/x/text/encoding/charmap"
+//
+//     ...
+//     RegisterEncoding("ISO8859-15", charmap.ISO8859_15)
+//
+// Aliases can be registered as well, for example "8859-15" could be an alias
+// for "ISO8859-15".
+//
+// For POSIX systems, the tcell package will check the environment variables
+// LC_ALL, LC_CTYPE,  and LANG (in that order) to determine the character set.
+// These are expected to have the following pattern:
+//
+//	 $language[.$codeset[@$variant]
+//
+// We extract only the $codeset part, which will usually be something like
+// UTF-8 or ISO8859-15 or KOI8-R.  Note that if the locale is either "POSIX"
+// or "C", then we assume US-ASCII (the POSIX 'portable character set'
+// and assume all other characters are somehow invalid.)
+//
+// Modern POSIX systems and terminal emulators may use UTF-8, and for those
+// systems, this API is also unnecessary.  For example, Darwin (MacOS X) and
+// modern Linux running modern xterm generally will out of the box without
+// any of this.  Use of UTF-8 is recommended when possible, as it saves
+// quite a lot processing overhead.
+//
+// Note that some encodings are quite large (for example GB18030 which is a
+// superset of Unicode) and so the application size can be expected ot
+// increase quite a bit as each encoding is added.  The East Asian encodings
+// have been seen to add 100-200K per encoding to the application size.
+//
+func RegisterEncoding(charset string, enc encoding.Encoding) {
+	encodingLk.Lock()
+	charset = strings.ToLower(charset)
+	encodings[charset] = enc
+	encodingLk.Unlock()
+}
+
+// EncodingFallback describes how the system behavees when the locale
+// requires a character set that we do not support.  The system always
+// supports UTF-8 and US-ASCII. On Windows consoles, UTF-16LE is also
+// supported automatically.  Other character sets must be added using the
+// RegisterEncoding API.  (A large group of nearly all of them can be
+// added using the RegisterAll function in the encoding sub package.)
+type EncodingFallback int
+
+const (
+	// EncodingFallbackFail behavior causes GetEncoding to fail
+	// when it cannot find an encoding.
+	EncodingFallbackFail = iota
+
+	// EncodingFallbackASCII behaviore causes GetEncoding to fall back
+	// to a 7-bit ASCII encoding, if no other encoding can be found.
+	EncodingFallbackASCII
+
+	// EncodingFallbackUTF8 behavior causes GetEncoding to assume
+	// UTF8 can pass unmodified upon failure.  Note that this behavior
+	// is not recommended, unless you are sure your terminal can cope
+	// with real UTF8 sequences.
+	EncodingFallbackUTF8
+)
+
+// SetEncodingFallback changes the behavior of GetEncoding when a suitable
+// encoding is not found.  The default is EncodingFallbackFail, which
+// causes GetEncoding to simply return nil.
+func SetEncodingFallback(fb EncodingFallback) {
+	encodingLk.Lock()
+	encodingFallback = fb
+	encodingLk.Unlock()
+}
+
+// GetEncoding is used by Screen implementors who want to locate an encoding
+// for the given character set name.  Note that this will return nil for
+// either the Unicode (UTF-8) or ASCII encodings, since we don't use
+// encodings for them but instead have our own native methods.
+func GetEncoding(charset string) encoding.Encoding {
+	charset = strings.ToLower(charset)
+	encodingLk.Lock()
+	defer encodingLk.Unlock()
+	if enc, ok := encodings[charset]; ok {
+		return enc
+	}
+	switch encodingFallback {
+	case EncodingFallbackASCII:
+		return gencoding.ASCII
+	case EncodingFallbackUTF8:
+		return encoding.Nop
+	}
+	return nil
+}
+
+func init() {
+	// We always support UTF-8 and ASCII.
+	encodings = make(map[string]encoding.Encoding)
+	encodings["utf-8"] = gencoding.UTF8
+	encodings["utf8"] = gencoding.UTF8
+	encodings["us-ascii"] = gencoding.ASCII
+	encodings["ascii"] = gencoding.ASCII
+	encodings["iso646"] = gencoding.ASCII
+}

libtui/v0/vendor/github.com/gdamore/tcell/errors.go

@@ -0,0 +1,73 @@
+// Copyright 2015 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.
+
+package tcell
+
+import (
+	"errors"
+	"time"
+
+	"github.com/gdamore/tcell/terminfo"
+)
+
+var (
+	// ErrTermNotFound indicates that a suitable terminal entry could
+	// not be found.  This can result from either not having TERM set,
+	// or from the TERM failing to support certain minimal functionality,
+	// in particular absolute cursor addressability (the cup capability)
+	// is required.  For example, legacy "adm3" lacks this capability,
+	// whereas the slightly newer "adm3a" supports it.  This failure
+	// occurs most often with "dumb".
+	ErrTermNotFound = terminfo.ErrTermNotFound
+
+	// ErrNoScreen indicates that no suitable screen could be found.
+	// This may result from attempting to run on a platform where there
+	// is no support for either termios or console I/O (such as nacl),
+	// or from running in an environment where there is no access to
+	// a suitable console/terminal device.  (For example, running on
+	// without a controlling TTY or with no /dev/tty on POSIX platforms.)
+	ErrNoScreen = errors.New("no suitable screen available")
+
+	// ErrNoCharset indicates that the locale environment the
+	// program is not supported by the program, because no suitable
+	// encoding was found for it.  This problem never occurs if
+	// the environment is UTF-8 or UTF-16.
+	ErrNoCharset = errors.New("character set not supported")
+
+	// ErrEventQFull indicates that the event queue is full, and
+	// cannot accept more events.
+	ErrEventQFull = errors.New("event queue full")
+)
+
+// An EventError is an event representing some sort of error, and carries
+// an error payload.
+type EventError struct {
+	t   time.Time
+	err error
+}
+
+// When returns the time when the event was created.
+func (ev *EventError) When() time.Time {
+	return ev.t
+}
+
+// Error implements the error.
+func (ev *EventError) Error() string {
+	return ev.err.Error()
+}
+
+// NewEventError creates an ErrorEvent with the given error payload.
+func NewEventError(err error) *EventError {
+	return &EventError{t: time.Now(), err: err}
+}

libtui/v0/vendor/github.com/gdamore/tcell/event.go

@@ -0,0 +1,53 @@
+// Copyright 2015 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.
+
+package tcell
+
+import (
+	"time"
+)
+
+// Event is a generic interface used for passing around Events.
+// Concrete types follow.
+type Event interface {
+	// When reports the time when the event was generated.
+	When() time.Time
+}
+
+// EventTime is a simple base event class, suitable for easy reuse.
+// It can be used to deliver actual timer events as well.
+type EventTime struct {
+	when time.Time
+}
+
+// When returns the time stamp when the event occurred.
+func (e *EventTime) When() time.Time {
+	return e.when
+}
+
+// SetEventTime sets the time of occurrence for the event.
+func (e *EventTime) SetEventTime(t time.Time) {
+	e.when = t
+}
+
+// SetEventNow sets the time of occurrence for the event to the current time.
+func (e *EventTime) SetEventNow() {
+	e.SetEventTime(time.Now())
+}
+
+// EventHandler is anything that handles events.  If the handler has
+// consumed the event, it should return true.  False otherwise.
+type EventHandler interface {
+	HandleEvent(Event) bool
+}

libtui/v0/vendor/github.com/gdamore/tcell/interrupt.go

@@ -0,0 +1,41 @@
+// Copyright 2015 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.
+
+package tcell
+
+import (
+	"time"
+)
+
+// EventInterrupt is a generic wakeup event.  Its can be used to
+// to request a redraw.  It can carry an arbitrary payload, as well.
+type EventInterrupt struct {
+	t time.Time
+	v interface{}
+}
+
+// When returns the time when this event was created.
+func (ev *EventInterrupt) When() time.Time {
+	return ev.t
+}
+
+// Data is used to obtain the opaque event payload.
+func (ev *EventInterrupt) Data() interface{} {
+	return ev.v
+}
+
+// NewEventInterrupt creates an EventInterrupt with the given payload.
+func NewEventInterrupt(data interface{}) *EventInterrupt {
+	return &EventInterrupt{t: time.Now(), v: data}
+}

libtui/v0/vendor/github.com/gdamore/tcell/key.go

@@ -0,0 +1,464 @@
+// Copyright 2016 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.
+
+package tcell
+
+import (
+	"fmt"
+	"strings"
+	"time"
+)
+
+// EventKey represents a key press.  Usually this is a key press followed
+// by a key release, but since terminal programs don't have a way to report
+// key release events, we usually get just one event.  If a key is held down
+// then the terminal may synthesize repeated key presses at some predefined
+// rate.  We have no control over that, nor visibility into it.
+//
+// In some cases, we can have a modifier key, such as ModAlt, that can be
+// generated with a key press.  (This usually is represented by having the
+// high bit set, or in some cases, by sending an ESC prior to the rune.)
+//
+// If the value of Key() is KeyRune, then the actual key value will be
+// available with the Rune() method.  This will be the case for most keys.
+// In most situations, the modifiers will not be set.  For example, if the
+// rune is 'A', this will be reported without the ModShift bit set, since
+// really can't tell if the Shift key was pressed (it might have been CAPSLOCK,
+// or a terminal that only can send capitals, or keyboard with separate
+// capital letters from lower case letters).
+//
+// Generally, terminal applications have far less visibility into keyboard
+// activity than graphical applications.  Hence, they should avoid depending
+// overly much on availability of modifiers, or the availability of any
+// specific keys.
+type EventKey struct {
+	t   time.Time
+	mod ModMask
+	key Key
+	ch  rune
+}
+
+// When returns the time when this Event was created, which should closely
+// match the time when the key was pressed.
+func (ev *EventKey) When() time.Time {
+	return ev.t
+}
+
+// Rune returns the rune corresponding to the key press, if it makes sense.
+// The result is only defined if the value of Key() is KeyRune.
+func (ev *EventKey) Rune() rune {
+	return ev.ch
+}
+
+// Key returns a virtual key code.  We use this to identify specific key
+// codes, such as KeyEnter, etc.  Most control and function keys are reported
+// with unique Key values.  Normal alphanumeric and punctuation keys will
+// generally return KeyRune here; the specific key can be further decoded
+// using the Rune() function.
+func (ev *EventKey) Key() Key {
+	return ev.key
+}
+
+// Modifiers returns the modifiers that were present with the key press.  Note
+// that not all platforms and terminals support this equally well, and some
+// cases we will not not know for sure.  Hence, applications should avoid
+// using this in most circumstances.
+func (ev *EventKey) Modifiers() ModMask {
+	return ev.mod
+}
+
+// KeyNames holds the written names of special keys. Useful to echo back a key
+// name, or to look up a key from a string value.
+var KeyNames = map[Key]string{
+	KeyEnter:          "Enter",
+	KeyBackspace:      "Backspace",
+	KeyTab:            "Tab",
+	KeyBacktab:        "Backtab",
+	KeyEsc:            "Esc",
+	KeyBackspace2:     "Backspace2",
+	KeyDelete:         "Delete",
+	KeyInsert:         "Insert",
+	KeyUp:             "Up",
+	KeyDown:           "Down",
+	KeyLeft:           "Left",
+	KeyRight:          "Right",
+	KeyHome:           "Home",
+	KeyEnd:            "End",
+	KeyUpLeft:         "UpLeft",
+	KeyUpRight:        "UpRight",
+	KeyDownLeft:       "DownLeft",
+	KeyDownRight:      "DownRight",
+	KeyCenter:         "Center",
+	KeyPgDn:           "PgDn",
+	KeyPgUp:           "PgUp",
+	KeyClear:          "Clear",
+	KeyExit:           "Exit",
+	KeyCancel:         "Cancel",
+	KeyPause:          "Pause",
+	KeyPrint:          "Print",
+	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",
+	KeyF21:            "F21",
+	KeyF22:            "F22",
+	KeyF23:            "F23",
+	KeyF24:            "F24",
+	KeyF25:            "F25",
+	KeyF26:            "F26",
+	KeyF27:            "F27",
+	KeyF28:            "F28",
+	KeyF29:            "F29",
+	KeyF30:            "F30",
+	KeyF31:            "F31",
+	KeyF32:            "F32",
+	KeyF33:            "F33",
+	KeyF34:            "F34",
+	KeyF35:            "F35",
+	KeyF36:            "F36",
+	KeyF37:            "F37",
+	KeyF38:            "F38",
+	KeyF39:            "F39",
+	KeyF40:            "F40",
+	KeyF41:            "F41",
+	KeyF42:            "F42",
+	KeyF43:            "F43",
+	KeyF44:            "F44",
+	KeyF45:            "F45",
+	KeyF46:            "F46",
+	KeyF47:            "F47",
+	KeyF48:            "F48",
+	KeyF49:            "F49",
+	KeyF50:            "F50",
+	KeyF51:            "F51",
+	KeyF52:            "F52",
+	KeyF53:            "F53",
+	KeyF54:            "F54",
+	KeyF55:            "F55",
+	KeyF56:            "F56",
+	KeyF57:            "F57",
+	KeyF58:            "F58",
+	KeyF59:            "F59",
+	KeyF60:            "F60",
+	KeyF61:            "F61",
+	KeyF62:            "F62",
+	KeyF63:            "F63",
+	KeyF64:            "F64",
+	KeyCtrlA:          "Ctrl-A",
+	KeyCtrlB:          "Ctrl-B",
+	KeyCtrlC:          "Ctrl-C",
+	KeyCtrlD:          "Ctrl-D",
+	KeyCtrlE:          "Ctrl-E",
+	KeyCtrlF:          "Ctrl-F",
+	KeyCtrlG:          "Ctrl-G",
+	KeyCtrlJ:          "Ctrl-J",
+	KeyCtrlK:          "Ctrl-K",
+	KeyCtrlL:          "Ctrl-L",
+	KeyCtrlN:          "Ctrl-N",
+	KeyCtrlO:          "Ctrl-O",
+	KeyCtrlP:          "Ctrl-P",
+	KeyCtrlQ:          "Ctrl-Q",
+	KeyCtrlR:          "Ctrl-R",
+	KeyCtrlS:          "Ctrl-S",
+	KeyCtrlT:          "Ctrl-T",
+	KeyCtrlU:          "Ctrl-U",
+	KeyCtrlV:          "Ctrl-V",
+	KeyCtrlW:          "Ctrl-W",
+	KeyCtrlX:          "Ctrl-X",
+	KeyCtrlY:          "Ctrl-Y",
+	KeyCtrlZ:          "Ctrl-Z",
+	KeyCtrlSpace:      "Ctrl-Space",
+	KeyCtrlUnderscore: "Ctrl-_",
+	KeyCtrlRightSq:    "Ctrl-]",
+	KeyCtrlBackslash:  "Ctrl-\\",
+	KeyCtrlCarat:      "Ctrl-^",
+}
+
+// Name returns a printable value or the key stroke.  This can be used
+// when printing the event, for example.
+func (ev *EventKey) Name() string {
+	s := ""
+	m := []string{}
+	if ev.mod&ModShift != 0 {
+		m = append(m, "Shift")
+	}
+	if ev.mod&ModAlt != 0 {
+		m = append(m, "Alt")
+	}
+	if ev.mod&ModMeta != 0 {
+		m = append(m, "Meta")
+	}
+	if ev.mod&ModCtrl != 0 {
+		m = append(m, "Ctrl")
+	}
+
+	ok := false
+	if s, ok = KeyNames[ev.key]; !ok {
+		if ev.key == KeyRune {
+			s = "Rune[" + string(ev.ch) + "]"
+		} else {
+			s = fmt.Sprintf("Key[%d,%d]", ev.key, int(ev.ch))
+		}
+	}
+	if len(m) != 0 {
+		if ev.mod&ModCtrl != 0 && strings.HasPrefix(s, "Ctrl-") {
+			s = s[5:]
+		}
+		return fmt.Sprintf("%s+%s", strings.Join(m, "+"), s)
+	}
+	return s
+}
+
+// NewEventKey attempts to create a suitable event.  It parses the various
+// ASCII control sequences if KeyRune is passed for Key, but if the caller
+// has more precise information it should set that specifically.  Callers
+// that aren't sure about modifier state (most) should just pass ModNone.
+func NewEventKey(k Key, ch rune, mod ModMask) *EventKey {
+	if k == KeyRune && (ch < ' ' || ch == 0x7f) {
+		// Turn specials into proper key codes.  This is for
+		// control characters and the DEL.
+		k = Key(ch)
+		if mod == ModNone && ch < ' ' {
+			switch Key(ch) {
+			case KeyBackspace, KeyTab, KeyEsc, KeyEnter:
+				// these keys are directly typeable without CTRL
+			default:
+				// most likely entered with a CTRL keypress
+				mod = ModCtrl
+			}
+		}
+	}
+	return &EventKey{t: time.Now(), key: k, ch: ch, mod: mod}
+}
+
+// ModMask is a mask of modifier keys.  Note that it will not always be
+// possible to report modifier keys.
+type ModMask int16
+
+// These are the modifiers keys that can be sent either with a key press,
+// or a mouse event.  Note that as of now, due to the confusion associated
+// with Meta, and the lack of support for it on many/most platforms, the
+// current implementations never use it.  Instead, they use ModAlt, even for
+// events that could possibly have been distinguished from ModAlt.
+const (
+	ModShift ModMask = 1 << iota
+	ModCtrl
+	ModAlt
+	ModMeta
+	ModNone ModMask = 0
+)
+
+// Key is a generic value for representing keys, and especially special
+// keys (function keys, cursor movement keys, etc.)  For normal keys, like
+// ASCII letters, we use KeyRune, and then expect the application to
+// inspect the Rune() member of the EventKey.
+type Key int16
+
+// This is the list of named keys.  KeyRune is special however, in that it is
+// a place holder key indicating that a printable character was sent.  The
+// actual value of the rune will be transported in the Rune of the associated
+// EventKey.
+const (
+	KeyRune Key = iota + 256
+	KeyUp
+	KeyDown
+	KeyRight
+	KeyLeft
+	KeyUpLeft
+	KeyUpRight
+	KeyDownLeft
+	KeyDownRight
+	KeyCenter
+	KeyPgUp
+	KeyPgDn
+	KeyHome
+	KeyEnd
+	KeyInsert
+	KeyDelete
+	KeyHelp
+	KeyExit
+	KeyClear
+	KeyCancel
+	KeyPrint
+	KeyPause
+	KeyBacktab
+	KeyF1
+	KeyF2
+	KeyF3
+	KeyF4
+	KeyF5
+	KeyF6
+	KeyF7
+	KeyF8
+	KeyF9
+	KeyF10
+	KeyF11
+	KeyF12
+	KeyF13
+	KeyF14
+	KeyF15
+	KeyF16
+	KeyF17
+	KeyF18
+	KeyF19
+	KeyF20
+	KeyF21
+	KeyF22
+	KeyF23
+	KeyF24
+	KeyF25
+	KeyF26
+	KeyF27
+	KeyF28
+	KeyF29
+	KeyF30
+	KeyF31
+	KeyF32
+	KeyF33
+	KeyF34
+	KeyF35
+	KeyF36
+	KeyF37
+	KeyF38
+	KeyF39
+	KeyF40
+	KeyF41
+	KeyF42
+	KeyF43
+	KeyF44
+	KeyF45
+	KeyF46
+	KeyF47
+	KeyF48
+	KeyF49
+	KeyF50
+	KeyF51
+	KeyF52
+	KeyF53
+	KeyF54
+	KeyF55
+	KeyF56
+	KeyF57
+	KeyF58
+	KeyF59
+	KeyF60
+	KeyF61
+	KeyF62
+	KeyF63
+	KeyF64
+)
+
+// These are the control keys.  Note that they overlap with other keys,
+// perhaps.  For example, KeyCtrlH is the same as KeyBackspace.
+const (
+	KeyCtrlSpace Key = iota
+	KeyCtrlA
+	KeyCtrlB
+	KeyCtrlC
+	KeyCtrlD
+	KeyCtrlE
+	KeyCtrlF
+	KeyCtrlG
+	KeyCtrlH
+	KeyCtrlI
+	KeyCtrlJ
+	KeyCtrlK
+	KeyCtrlL
+	KeyCtrlM
+	KeyCtrlN
+	KeyCtrlO
+	KeyCtrlP
+	KeyCtrlQ
+	KeyCtrlR
+	KeyCtrlS
+	KeyCtrlT
+	KeyCtrlU
+	KeyCtrlV
+	KeyCtrlW
+	KeyCtrlX
+	KeyCtrlY
+	KeyCtrlZ
+	KeyCtrlLeftSq // Escape
+	KeyCtrlBackslash
+	KeyCtrlRightSq
+	KeyCtrlCarat
+	KeyCtrlUnderscore
+)
+
+// Special values - these are fixed in an attempt to make it more likely
+// that aliases will encode the same way.
+
+// These are the defined ASCII values for key codes.  They generally match
+// with KeyCtrl values.
+const (
+	KeyNUL Key = iota
+	KeySOH
+	KeySTX
+	KeyETX
+	KeyEOT
+	KeyENQ
+	KeyACK
+	KeyBEL
+	KeyBS
+	KeyTAB
+	KeyLF
+	KeyVT
+	KeyFF
+	KeyCR
+	KeySO
+	KeySI
+	KeyDLE
+	KeyDC1
+	KeyDC2
+	KeyDC3
+	KeyDC4
+	KeyNAK
+	KeySYN
+	KeyETB
+	KeyCAN
+	KeyEM
+	KeySUB
+	KeyESC
+	KeyFS
+	KeyGS
+	KeyRS
+	KeyUS
+	KeyDEL Key = 0x7F
+)
+
+// These keys are aliases for other names.
+const (
+	KeyBackspace  = KeyBS
+	KeyTab        = KeyTAB
+	KeyEsc        = KeyESC
+	KeyEscape     = KeyESC
+	KeyEnter      = KeyCR
+	KeyBackspace2 = KeyDEL
+)

libtui/v0/vendor/github.com/gdamore/tcell/mouse.go

@@ -0,0 +1,97 @@
+// Copyright 2015 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.
+
+package tcell
+
+import (
+	"time"
+)
+
+// EventMouse is a mouse event.  It is sent on either mouse up or mouse down
+// events.  It is also sent on mouse motion events - if the terminal supports
+// it.  We make every effort to ensure that mouse release events are delivered.
+// Hence, click drag can be identified by a motion event with the mouse down,
+// without any intervening button release.  On some terminals only the initiating
+// press and terminating release event will be delivered.
+//
+// Mouse wheel events, when reported, may appear on their own as individual
+// impulses; that is, there will normally not be a release event delivered
+// for mouse wheel movements.
+//
+// Most terminals cannot report the state of more than one button at a time --
+// and some cannot report motion events unless a button is pressed.
+//
+// Applications can inspect the time between events to resolve double or
+// triple clicks.
+type EventMouse struct {
+	t   time.Time
+	btn ButtonMask
+	mod ModMask
+	x   int
+	y   int
+}
+
+// When returns the time when this EventMouse was created.
+func (ev *EventMouse) When() time.Time {
+	return ev.t
+}
+
+// Buttons returns the list of buttons that were pressed or wheel motions.
+func (ev *EventMouse) Buttons() ButtonMask {
+	return ev.btn
+}
+
+// Modifiers returns a list of keyboard modifiers that were pressed
+// with the mouse button(s).
+func (ev *EventMouse) Modifiers() ModMask {
+	return ev.mod
+}
+
+// Position returns the mouse position in character cells.  The origin
+// 0, 0 is at the upper left corner.
+func (ev *EventMouse) Position() (int, int) {
+	return ev.x, ev.y
+}
+
+// NewEventMouse is used to create a new mouse event.  Applications
+// shouldn't need to use this; its mostly for screen implementors.
+func NewEventMouse(x, y int, btn ButtonMask, mod ModMask) *EventMouse {
+	return &EventMouse{t: time.Now(), x: x, y: y, btn: btn, mod: mod}
+}
+
+// ButtonMask is a mask of mouse buttons and wheel events.  Mouse button presses
+// are normally delivered as both press and release events.  Mouse wheel events
+// are normally just single impulse events.  Windows supports up to eight
+// separate buttons plus all four wheel directions, but XTerm can only support
+// mouse buttons 1-3 and wheel up/down.  Its not unheard of for terminals
+// to support only one or two buttons (think Macs).  Old terminals, and true
+// emulations (such as vt100) won't support mice at all, of course.
+type ButtonMask int16
+
+// These are the actual button values.
+const (
+	Button1 ButtonMask = 1 << iota // Usually left mouse button.
+	Button2                        // Usually the middle mouse button.
+	Button3                        // Usually the right mouse button.
+	Button4                        // Often a side button (thumb/next).
+	Button5                        // Often a side button (thumb/prev).
+	Button6
+	Button7
+	Button8
+	WheelUp                   // Wheel motion up/away from user.
+	WheelDown                 // Wheel motion down/towards user.
+	WheelLeft                 // Wheel motion to left.
+	WheelRight                // Wheel motion to right.
+	ButtonNone ButtonMask = 0 // No button or wheel events.
+)

libtui/v0/vendor/github.com/gdamore/tcell/resize.go

@@ -0,0 +1,42 @@
+// Copyright 2015 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.
+
+package tcell
+
+import (
+	"time"
+)
+
+// EventResize is sent when the window size changes.
+type EventResize struct {
+	t time.Time
+	w int
+	h int
+}
+
+// NewEventResize creates an EventResize with the new updated window size,
+// which is given in character cells.
+func NewEventResize(width, height int) *EventResize {
+	return &EventResize{t: time.Now(), w: width, h: height}
+}
+
+// When returns the time when the Event was created.
+func (ev *EventResize) When() time.Time {
+	return ev.t
+}
+
+// Size returns the new window size as width, height in character cells.
+func (ev *EventResize) Size() (int, int) {
+	return ev.w, ev.h
+}

libtui/v0/vendor/github.com/gdamore/tcell/runes.go

@@ -0,0 +1,111 @@
+// Copyright 2015 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.
+
+package tcell
+
+// The names of these constants are chosen to match Terminfo names,
+// modulo case, and changing the prefix from ACS_ to Rune.  These are
+// the runes we provide extra special handling for, with ASCII fallbacks
+// for terminals that lack them.
+const (
+	RuneSterling = '£'
+	RuneDArrow   = '↓'
+	RuneLArrow   = '←'
+	RuneRArrow   = '→'
+	RuneUArrow   = '↑'
+	RuneBullet   = '·'
+	RuneBoard    = '░'
+	RuneCkBoard  = '▒'
+	RuneDegree   = '°'
+	RuneDiamond  = '◆'
+	RuneGEqual   = '≥'
+	RunePi       = 'π'
+	RuneHLine    = '─'
+	RuneLantern  = '§'
+	RunePlus     = '┼'
+	RuneLEqual   = '≤'
+	RuneLLCorner = '└'
+	RuneLRCorner = '┘'
+	RuneNEqual   = '≠'
+	RunePlMinus  = '±'
+	RuneS1       = '⎺'
+	RuneS3       = '⎻'
+	RuneS7       = '⎼'
+	RuneS9       = '⎽'
+	RuneBlock    = '█'
+	RuneTTee     = '┬'
+	RuneRTee     = '┤'
+	RuneLTee     = '├'
+	RuneBTee     = '┴'
+	RuneULCorner = '┌'
+	RuneURCorner = '┐'
+	RuneVLine    = '│'
+)
+
+// RuneFallbacks is the default map of fallback strings that will be
+// used to replace a rune when no other more appropriate transformation
+// is available, and the rune cannot be displayed directly.
+//
+// New entries may be added to this map over time, as it becomes clear
+// that such is desirable.  Characters that represent either letters or
+// numbers should not be added to this list unless it is certain that
+// the meaning will still convey unambiguously.
+//
+// As an example, it would be appropriate to add an ASCII mapping for
+// the full width form of the letter 'A', but it would not be appropriate
+// to do so a glyph representing the country China.
+//
+// Programs that desire richer fallbacks may register additional ones,
+// or change or even remove these mappings with Screen.RegisterRuneFallback
+// Screen.UnregisterRuneFallback methods.
+//
+// Note that Unicode is presumed to be able to display all glyphs.
+// This is a pretty poor assumption, but there is no easy way to
+// figure out which glyphs are supported in a given font.  Hence,
+// some care in selecting the characters you support in your application
+// is still appropriate.
+var RuneFallbacks = map[rune]string{
+	RuneSterling: "f",
+	RuneDArrow:   "v",
+	RuneLArrow:   "<",
+	RuneRArrow:   ">",
+	RuneUArrow:   "^",
+	RuneBullet:   "o",
+	RuneBoard:    "#",
+	RuneCkBoard:  ":",
+	RuneDegree:   "\\",
+	RuneDiamond:  "+",
+	RuneGEqual:   ">",
+	RunePi:       "*",
+	RuneHLine:    "-",
+	RuneLantern:  "#",
+	RunePlus:     "+",
+	RuneLEqual:   "<",
+	RuneLLCorner: "+",
+	RuneLRCorner: "+",
+	RuneNEqual:   "!",
+	RunePlMinus:  "#",
+	RuneS1:       "~",
+	RuneS3:       "-",
+	RuneS7:       "-",
+	RuneS9:       "_",
+	RuneBlock:    "#",
+	RuneTTee:     "+",
+	RuneRTee:     "+",
+	RuneLTee:     "+",
+	RuneBTee:     "+",
+	RuneULCorner: "+",
+	RuneURCorner: "+",
+	RuneVLine:    "|",
+}

libtui/v0/vendor/github.com/gdamore/tcell/screen.go

@@ -0,0 +1,213 @@
+// Copyright 2019 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.
+
+package tcell
+
+// Screen represents the physical (or emulated) screen.
+// This can be a terminal window or a physical console.  Platforms implement
+// this differerently.
+type Screen interface {
+	// Init initializes the screen for use.
+	Init() error
+
+	// Fini finalizes the screen also releasing resources.
+	Fini()
+
+	// Clear erases the screen.  The contents of any screen buffers
+	// will also be cleared.  This has the logical effect of
+	// filling the screen with spaces, using the global default style.
+	Clear()
+
+	// Fill fills the screen with the given character and style.
+	Fill(rune, Style)
+
+	// SetCell is an older API, and will be removed.  Please use
+	// SetContent instead; SetCell is implemented in terms of SetContent.
+	SetCell(x int, y int, style Style, ch ...rune)
+
+	// GetContent returns the contents at the given location.  If the
+	// coordinates are out of range, then the values will be 0, nil,
+	// StyleDefault.  Note that the contents returned are logical contents
+	// and may not actually be what is displayed, but rather are what will
+	// be displayed if Show() or Sync() is called.  The width is the width
+	// in screen cells; most often this will be 1, but some East Asian
+	// characters require two cells.
+	GetContent(x, y int) (mainc rune, combc []rune, style Style, width int)
+
+	// SetContent sets the contents of the given cell location.  If
+	// the coordinates are out of range, then the operation is ignored.
+	//
+	// The first rune is the primary non-zero width rune.  The array
+	// that follows is a possible list of combining characters to append,
+	// and will usually be nil (no combining characters.)
+	//
+	// The results are not displayd until Show() or Sync() is called.
+	//
+	// Note that wide (East Asian full width) runes occupy two cells,
+	// and attempts to place character at next cell to the right will have
+	// undefined effects.  Wide runes that are printed in the
+	// last column will be replaced with a single width space on output.
+	SetContent(x int, y int, mainc rune, combc []rune, style Style)
+
+	// SetStyle sets the default style to use when clearing the screen
+	// or when StyleDefault is specified.  If it is also StyleDefault,
+	// then whatever system/terminal default is relevant will be used.
+	SetStyle(style Style)
+
+	// ShowCursor is used to display the cursor at a given location.
+	// If the coordinates -1, -1 are given or are otherwise outside the
+	// dimensions of the screen, the cursor will be hidden.
+	ShowCursor(x int, y int)
+
+	// HideCursor is used to hide the cursor.  Its an alias for
+	// ShowCursor(-1, -1).
+	HideCursor()
+
+	// Size returns the screen size as width, height.  This changes in
+	// response to a call to Clear or Flush.
+	Size() (int, int)
+
+	// PollEvent waits for events to arrive.  Main application loops
+	// must spin on this to prevent the application from stalling.
+	// Furthermore, this will return nil if the Screen is finalized.
+	PollEvent() Event
+
+	// PostEvent tries to post an event into the event stream.  This
+	// can fail if the event queue is full.  In that case, the event
+	// is dropped, and ErrEventQFull is returned.
+	PostEvent(ev Event) error
+
+	// PostEventWait is like PostEvent, but if the queue is full, it
+	// blocks until there is space in the queue, making delivery
+	// reliable.  However, it is VERY important that this function
+	// never be called from within whatever event loop is polling
+	// with PollEvent(), otherwise a deadlock may arise.
+	//
+	// For this reason, when using this function, the use of a
+	// Goroutine is recommended to ensure no deadlock can occur.
+	PostEventWait(ev Event)
+
+	// EnableMouse enables the mouse.  (If your terminal supports it.)
+	EnableMouse()
+
+	// DisableMouse disables the mouse.
+	DisableMouse()
+
+	// HasMouse returns true if the terminal (apparently) supports a
+	// mouse.  Note that the a return value of true doesn't guarantee that
+	// a mouse/pointing device is present; a false return definitely
+	// indicates no mouse support is available.
+	HasMouse() bool
+
+	// Colors returns the number of colors.  All colors are assumed to
+	// use the ANSI color map.  If a terminal is monochrome, it will
+	// return 0.
+	Colors() int
+
+	// Show makes all the content changes made using SetContent() visible
+	// on the display.
+	//
+	// It does so in the most efficient and least visually disruptive
+	// manner possible.
+	Show()
+
+	// Sync works like Show(), but it updates every visible cell on the
+	// physical display, assuming that it is not synchronized with any
+	// internal model.  This may be both expensive and visually jarring,
+	// so it should only be used when believed to actually be necessary.
+	//
+	// Typically this is called as a result of a user-requested redraw
+	// (e.g. to clear up on screen corruption caused by some other program),
+	// or during a resize event.
+	Sync()
+
+	// CharacterSet returns information about the character set.
+	// This isn't the full locale, but it does give us the input/output
+	// character set.  Note that this is just for diagnostic purposes,
+	// we normally translate input/output to/from UTF-8, regardless of
+	// what the user's environment is.
+	CharacterSet() string
+
+	// RegisterRuneFallback adds a fallback for runes that are not
+	// part of the character set -- for example one coudld register
+	// o as a fallback for ø.  This should be done cautiously for
+	// characters that might be displayed ordinarily in language
+	// specific text -- characters that could change the meaning of
+	// of written text would be dangerous.  The intention here is to
+	// facilitate fallback characters in pseudo-graphical applications.
+	//
+	// If the terminal has fallbacks already in place via an alternate
+	// character set, those are used in preference.  Also, standard
+	// fallbacks for graphical characters in the ACSC terminfo string
+	// are registered implicitly.
+
+	// The display string should be the same width as original rune.
+	// This makes it possible to register two character replacements
+	// for full width East Asian characters, for example.
+	//
+	// It is recommended that replacement strings consist only of
+	// 7-bit ASCII, since other characters may not display everywhere.
+	RegisterRuneFallback(r rune, subst string)
+
+	// UnregisterRuneFallback unmaps a replacement.  It will unmap
+	// the implicit ASCII replacements for alternate characters as well.
+	// When an unmapped char needs to be displayed, but no suitable
+	// glyph is available, '?' is emitted instead.  It is not possible
+	// to "disable" the use of alternate characters that are supported
+	// by your terminal except by changing the terminal database.
+	UnregisterRuneFallback(r rune)
+
+	// CanDisplay returns true if the given rune can be displayed on
+	// this screen.  Note that this is a best guess effort -- whether
+	// your fonts support the character or not may be questionable.
+	// Mostly this is for folks who work outside of Unicode.
+	//
+	// If checkFallbacks is true, then if any (possibly imperfect)
+	// fallbacks are registered, this will return true.  This will
+	// also return true if the terminal can replace the glyph with
+	// one that is visually indistinguishable from the one requested.
+	CanDisplay(r rune, checkFallbacks bool) bool
+
+	// Resize does nothing, since its generally not possible to
+	// ask a screen to resize, but it allows the Screen to implement
+	// the View interface.
+	Resize(int, int, int, int)
+
+	// HasKey returns true if the keyboard is believed to have the
+	// key.  In some cases a keyboard may have keys with this name
+	// but no support for them, while in others a key may be reported
+	// as supported but not actually be usable (such as some emulators
+	// that hijack certain keys).  Its best not to depend to strictly
+	// on this function, but it can be used for hinting when building
+	// menus, displayed hot-keys, etc.  Note that KeyRune (literal
+	// runes) is always true.
+	HasKey(Key) bool
+
+	// Beep attempts to sound an OS-dependent audible alert and returns an error
+	// when unsuccessful.
+	Beep() error
+}
+
+// NewScreen returns a default Screen suitable for the user's terminal
+// environment.
+func NewScreen() (Screen, error) {
+	// Windows is happier if we try for a console screen first.
+	if s, _ := NewConsoleScreen(); s != nil {
+		return s, nil
+	} else if s, e := NewTerminfoScreen(); s != nil {
+		return s, nil
+	} else {
+		return nil, e
+	}
+}

libtui/v0/vendor/github.com/gdamore/tcell/simulation.go

@@ -0,0 +1,512 @@
+// Copyright 2016 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.
+
+package tcell
+
+import (
+	"sync"
+	"unicode/utf8"
+
+	"golang.org/x/text/transform"
+)
+
+// NewSimulationScreen returns a SimulationScreen.  Note that
+// SimulationScreen is also a Screen.
+func NewSimulationScreen(charset string) SimulationScreen {
+	if charset == "" {
+		charset = "UTF-8"
+	}
+	s := &simscreen{charset: charset}
+	return s
+}
+
+// SimulationScreen represents a screen simulation.  This is intended to
+// be a superset of normal Screens, but also adds some important interfaces
+// for testing.
+type SimulationScreen interface {
+	// InjectKeyBytes injects a stream of bytes corresponding to
+	// the native encoding (see charset).  It turns true if the entire
+	// set of bytes were processed and delivered as KeyEvents, false
+	// if any bytes were not fully understood.  Any bytes that are not
+	// fully converted are discarded.
+	InjectKeyBytes(buf []byte) bool
+
+	// InjectKey injects a key event.  The rune is a UTF-8 rune, post
+	// any translation.
+	InjectKey(key Key, r rune, mod ModMask)
+
+	// InjectMouse injects a mouse event.
+	InjectMouse(x, y int, buttons ButtonMask, mod ModMask)
+
+	// SetSize resizes the underlying physical screen.  It also causes
+	// a resize event to be injected during the next Show() or Sync().
+	// A new physical contents array will be allocated (with data from
+	// the old copied), so any prior value obtained with GetContents
+	// won't be used anymore
+	SetSize(width, height int)
+
+	// GetContents returns screen contents as an array of
+	// cells, along with the physical width & height.   Note that the
+	// physical contents will be used until the next time SetSize()
+	// is called.
+	GetContents() (cells []SimCell, width int, height int)
+
+	// GetCursor returns the cursor details.
+	GetCursor() (x int, y int, visible bool)
+
+	Screen
+}
+
+// SimCell represents a simulated screen cell.  The purpose of this
+// is to track on screen content.
+type SimCell struct {
+	// Bytes is the actual character bytes.  Normally this is
+	// rune data, but it could be be data in another encoding system.
+	Bytes []byte
+
+	// Style is the style used to display the data.
+	Style Style
+
+	// Runes is the list of runes, unadulterated, in UTF-8.
+	Runes []rune
+}
+
+type simscreen struct {
+	physw int
+	physh int
+	fini  bool
+	style Style
+	evch  chan Event
+	quit  chan struct{}
+
+	front     []SimCell
+	back      CellBuffer
+	clear     bool
+	cursorx   int
+	cursory   int
+	cursorvis bool
+	mouse     bool
+	charset   string
+	encoder   transform.Transformer
+	decoder   transform.Transformer
+	fillchar  rune
+	fillstyle Style
+	fallback  map[rune]string
+
+	sync.Mutex
+}
+
+func (s *simscreen) Init() error {
+	s.evch = make(chan Event, 10)
+	s.quit = make(chan struct{})
+	s.fillchar = 'X'
+	s.fillstyle = StyleDefault
+	s.mouse = false
+	s.physw = 80
+	s.physh = 25
+	s.cursorx = -1
+	s.cursory = -1
+	s.style = StyleDefault
+
+	if enc := GetEncoding(s.charset); enc != nil {
+		s.encoder = enc.NewEncoder()
+		s.decoder = enc.NewDecoder()
+	} else {
+		return ErrNoCharset
+	}
+
+	s.front = make([]SimCell, s.physw*s.physh)
+	s.back.Resize(80, 25)
+
+	// default fallbacks
+	s.fallback = make(map[rune]string)
+	for k, v := range RuneFallbacks {
+		s.fallback[k] = v
+	}
+	return nil
+}
+
+func (s *simscreen) Fini() {
+	s.Lock()
+	s.fini = true
+	s.back.Resize(0, 0)
+	s.Unlock()
+	if s.quit != nil {
+		close(s.quit)
+	}
+	s.physw = 0
+	s.physh = 0
+	s.front = nil
+}
+
+func (s *simscreen) SetStyle(style Style) {
+	s.Lock()
+	s.style = style
+	s.Unlock()
+}
+
+func (s *simscreen) Clear() {
+	s.Fill(' ', s.style)
+}
+
+func (s *simscreen) Fill(r rune, style Style) {
+	s.Lock()
+	s.back.Fill(r, style)
+	s.Unlock()
+}
+
+func (s *simscreen) SetCell(x, y int, style Style, ch ...rune) {
+
+	if len(ch) > 0 {
+		s.SetContent(x, y, ch[0], ch[1:], style)
+	} else {
+		s.SetContent(x, y, ' ', nil, style)
+	}
+}
+
+func (s *simscreen) SetContent(x, y int, mainc rune, combc []rune, st Style) {
+
+	s.Lock()
+	s.back.SetContent(x, y, mainc, combc, st)
+	s.Unlock()
+}
+
+func (s *simscreen) GetContent(x, y int) (rune, []rune, Style, int) {
+	var mainc rune
+	var combc []rune
+	var style Style
+	var width int
+	s.Lock()
+	mainc, combc, style, width = s.back.GetContent(x, y)
+	s.Unlock()
+	return mainc, combc, style, width
+}
+
+func (s *simscreen) drawCell(x, y int) int {
+
+	mainc, combc, style, width := s.back.GetContent(x, y)
+	if !s.back.Dirty(x, y) {
+		return width
+	}
+	if x >= s.physw || y >= s.physh || x < 0 || y < 0 {
+		return width
+	}
+	simc := &s.front[(y*s.physw)+x]
+
+	if style == StyleDefault {
+		style = s.style
+	}
+	simc.Style = style
+	simc.Runes = append([]rune{mainc}, combc...)
+
+	// now emit runes - taking care to not overrun width with a
+	// wide character, and to ensure that we emit exactly one regular
+	// character followed up by any residual combing characters
+
+	simc.Bytes = nil
+
+	if x > s.physw-width {
+		simc.Runes = []rune{' '}
+		simc.Bytes = []byte{' '}
+		return width
+	}
+
+	lbuf := make([]byte, 12)
+	ubuf := make([]byte, 12)
+	nout := 0
+
+	for _, r := range simc.Runes {
+
+		l := utf8.EncodeRune(ubuf, r)
+
+		nout, _, _ = s.encoder.Transform(lbuf, ubuf[:l], true)
+
+		if nout == 0 || lbuf[0] == '\x1a' {
+
+			// skip combining
+
+			if subst, ok := s.fallback[r]; ok {
+				simc.Bytes = append(simc.Bytes,
+					[]byte(subst)...)
+
+			} else if r >= ' ' && r <= '~' {
+				simc.Bytes = append(simc.Bytes, byte(r))
+
+			} else if simc.Bytes == nil {
+				simc.Bytes = append(simc.Bytes, '?')
+			}
+		} else {
+			simc.Bytes = append(simc.Bytes, lbuf[:nout]...)
+		}
+	}
+	s.back.SetDirty(x, y, false)
+	return width
+}
+
+func (s *simscreen) ShowCursor(x, y int) {
+	s.Lock()
+	s.cursorx, s.cursory = x, y
+	s.showCursor()
+	s.Unlock()
+}
+
+func (s *simscreen) HideCursor() {
+	s.ShowCursor(-1, -1)
+}
+
+func (s *simscreen) showCursor() {
+
+	x, y := s.cursorx, s.cursory
+	if x < 0 || y < 0 || x >= s.physw || y >= s.physh {
+		s.cursorvis = false
+	} else {
+		s.cursorvis = true
+	}
+}
+
+func (s *simscreen) hideCursor() {
+	// does not update cursor position
+	s.cursorvis = false
+}
+
+func (s *simscreen) Show() {
+	s.Lock()
+	s.resize()
+	s.draw()
+	s.Unlock()
+}
+
+func (s *simscreen) clearScreen() {
+	// We emulate a hardware clear by filling with a specific pattern
+	for i := range s.front {
+		s.front[i].Style = s.fillstyle
+		s.front[i].Runes = []rune{s.fillchar}
+		s.front[i].Bytes = []byte{byte(s.fillchar)}
+	}
+	s.clear = false
+}
+
+func (s *simscreen) draw() {
+	s.hideCursor()
+	if s.clear {
+		s.clearScreen()
+	}
+
+	w, h := s.back.Size()
+	for y := 0; y < h; y++ {
+		for x := 0; x < w; x++ {
+			width := s.drawCell(x, y)
+			x += width - 1
+		}
+	}
+	s.showCursor()
+}
+
+func (s *simscreen) EnableMouse() {
+	s.mouse = true
+}
+
+func (s *simscreen) DisableMouse() {
+	s.mouse = false
+}
+
+func (s *simscreen) Size() (int, int) {
+	s.Lock()
+	w, h := s.back.Size()
+	s.Unlock()
+	return w, h
+}
+
+func (s *simscreen) resize() {
+	w, h := s.physw, s.physh
+	ow, oh := s.back.Size()
+	if w != ow || h != oh {
+		s.back.Resize(w, h)
+		ev := NewEventResize(w, h)
+		s.PostEvent(ev)
+	}
+}
+
+func (s *simscreen) Colors() int {
+	return 256
+}
+
+func (s *simscreen) PollEvent() Event {
+	select {
+	case <-s.quit:
+		return nil
+	case ev := <-s.evch:
+		return ev
+	}
+}
+
+func (s *simscreen) PostEventWait(ev Event) {
+	s.evch <- ev
+}
+
+func (s *simscreen) PostEvent(ev Event) error {
+	select {
+	case s.evch <- ev:
+		return nil
+	default:
+		return ErrEventQFull
+	}
+}
+
+func (s *simscreen) InjectMouse(x, y int, buttons ButtonMask, mod ModMask) {
+	ev := NewEventMouse(x, y, buttons, mod)
+	s.PostEvent(ev)
+}
+
+func (s *simscreen) InjectKey(key Key, r rune, mod ModMask) {
+	ev := NewEventKey(key, r, mod)
+	s.PostEvent(ev)
+}
+
+func (s *simscreen) InjectKeyBytes(b []byte) bool {
+	failed := false
+
+outer:
+	for len(b) > 0 {
+		if b[0] >= ' ' && b[0] <= 0x7F {
+			// printable ASCII easy to deal with -- no encodings
+			ev := NewEventKey(KeyRune, rune(b[0]), ModNone)
+			s.PostEvent(ev)
+			b = b[1:]
+			continue
+		}
+
+		if b[0] < 0x80 {
+			mod := ModNone
+			// No encodings start with low numbered values
+			if Key(b[0]) >= KeyCtrlA && Key(b[0]) <= KeyCtrlZ {
+				mod = ModCtrl
+			}
+			ev := NewEventKey(Key(b[0]), 0, mod)
+			s.PostEvent(ev)
+			continue
+		}
+
+		utfb := make([]byte, len(b)*4) // worst case
+		for l := 1; l < len(b); l++ {
+			s.decoder.Reset()
+			nout, nin, _ := s.decoder.Transform(utfb, b[:l], true)
+
+			if nout != 0 {
+				r, _ := utf8.DecodeRune(utfb[:nout])
+				if r != utf8.RuneError {
+					ev := NewEventKey(KeyRune, r, ModNone)
+					s.PostEvent(ev)
+				}
+				b = b[nin:]
+				continue outer
+			}
+		}
+		failed = true
+		b = b[1:]
+		continue
+	}
+
+	return !failed
+}
+
+func (s *simscreen) Sync() {
+	s.Lock()
+	s.clear = true
+	s.resize()
+	s.back.Invalidate()
+	s.draw()
+	s.Unlock()
+}
+
+func (s *simscreen) CharacterSet() string {
+	return s.charset
+}
+
+func (s *simscreen) SetSize(w, h int) {
+	s.Lock()
+	newc := make([]SimCell, w*h)
+	for row := 0; row < h && row < s.physh; row++ {
+		for col := 0; col < w && col < s.physw; col++ {
+			newc[(row*w)+col] = s.front[(row*s.physw)+col]
+		}
+	}
+	s.cursorx, s.cursory = -1, -1
+	s.physw, s.physh = w, h
+	s.front = newc
+	s.back.Resize(w, h)
+	s.Unlock()
+}
+
+func (s *simscreen) GetContents() ([]SimCell, int, int) {
+	s.Lock()
+	cells, w, h := s.front, s.physw, s.physh
+	s.Unlock()
+	return cells, w, h
+}
+
+func (s *simscreen) GetCursor() (int, int, bool) {
+	s.Lock()
+	x, y, vis := s.cursorx, s.cursory, s.cursorvis
+	s.Unlock()
+	return x, y, vis
+}
+
+func (s *simscreen) RegisterRuneFallback(r rune, subst string) {
+	s.Lock()
+	s.fallback[r] = subst
+	s.Unlock()
+}
+
+func (s *simscreen) UnregisterRuneFallback(r rune) {
+	s.Lock()
+	delete(s.fallback, r)
+	s.Unlock()
+}
+
+func (s *simscreen) CanDisplay(r rune, checkFallbacks bool) bool {
+
+	if enc := s.encoder; enc != nil {
+		nb := make([]byte, 6)
+		ob := make([]byte, 6)
+		num := utf8.EncodeRune(ob, r)
+
+		enc.Reset()
+		dst, _, err := enc.Transform(nb, ob[:num], true)
+		if dst != 0 && err == nil && nb[0] != '\x1A' {
+			return true
+		}
+	}
+	if !checkFallbacks {
+		return false
+	}
+	if _, ok := s.fallback[r]; ok {
+		return true
+	}
+	return false
+}
+
+func (s *simscreen) HasMouse() bool {
+	return false
+}
+
+func (s *simscreen) Resize(int, int, int, int) {}
+
+func (s *simscreen) HasKey(Key) bool {
+	return true
+}
+
+func (s *simscreen) Beep() error {
+	return nil
+}

libtui/v0/vendor/github.com/gdamore/tcell/style.go

@@ -0,0 +1,132 @@
+// Copyright 2015 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.
+
+package tcell
+
+// Style represents a complete text style, including both foreground
+// and background color.  We encode it in a 64-bit int for efficiency.
+// The coding is (MSB): <7b flags><1b><24b fgcolor><7b attr><1b><24b bgcolor>.
+// The <1b> is set true to indicate that the color is an RGB color, rather
+// than a named index.
+//
+// This gives 24bit color options, if it ever becomes truly necessary.
+// However, applications must not rely on this encoding.
+//
+// Note that not all terminals can display all colors or attributes, and
+// many might have specific incompatibilities between specific attributes
+// and color combinations.
+//
+// The intention is to extend styles to support paletting, in which case
+// some flag bit(s) would be set, and the foreground and background colors
+// would be replaced with a palette number and palette index.
+//
+// To use Style, just declare a variable of its type.
+type Style int64
+
+// StyleDefault represents a default style, based upon the context.
+// It is the zero value.
+const StyleDefault Style = 0
+
+// styleFlags -- used internally for now.
+const (
+	styleBgSet = 1 << (iota + 57)
+	styleFgSet
+	stylePalette
+)
+
+// Foreground returns a new style based on s, with the foreground color set
+// as requested.  ColorDefault can be used to select the global default.
+func (s Style) Foreground(c Color) Style {
+	if c == ColorDefault {
+		return (s &^ (0x1ffffff00000000 | styleFgSet))
+	}
+	return (s &^ Style(0x1ffffff00000000)) |
+		((Style(c) & 0x1ffffff) << 32) | styleFgSet
+}
+
+// Background returns a new style based on s, with the background color set
+// as requested.  ColorDefault can be used to select the global default.
+func (s Style) Background(c Color) Style {
+	if c == ColorDefault {
+		return (s &^ (0x1ffffff | styleBgSet))
+	}
+	return (s &^ (0x1ffffff)) | (Style(c) & 0x1ffffff) | styleBgSet
+}
+
+// Decompose breaks a style up, returning the foreground, background,
+// and other attributes.
+func (s Style) Decompose() (fg Color, bg Color, attr AttrMask) {
+	if s&styleFgSet != 0 {
+		fg = Color(s>>32) & 0x1ffffff
+	} else {
+		fg = ColorDefault
+	}
+	if s&styleBgSet != 0 {
+		bg = Color(s & 0x1ffffff)
+	} else {
+		bg = ColorDefault
+	}
+	attr = AttrMask(s) & attrAll
+
+	return fg, bg, attr
+}
+
+func (s Style) setAttrs(attrs Style, on bool) Style {
+	if on {
+		return s | attrs
+	}
+	return s &^ attrs
+}
+
+// Normal returns the style with all attributes disabled.
+func (s Style) Normal() Style {
+	return s &^ Style(attrAll)
+}
+
+// Bold returns a new style based on s, with the bold attribute set
+// as requested.
+func (s Style) Bold(on bool) Style {
+	return s.setAttrs(Style(AttrBold), on)
+}
+
+// Blink returns a new style based on s, with the blink attribute set
+// as requested.
+func (s Style) Blink(on bool) Style {
+	return s.setAttrs(Style(AttrBlink), on)
+}
+
+// Dim returns a new style based on s, with the dim attribute set
+// as requested.
+func (s Style) Dim(on bool) Style {
+	return s.setAttrs(Style(AttrDim), on)
+}
+
+// Italic returns a new style based on s, with the italic attribute set
+// as requested.
+func (s Style) Italic(on bool) Style {
+	return s.setAttrs(Style(AttrItalic), on)
+}
+
+// Reverse returns a new style based on s, with the reverse attribute set
+// as requested.  (Reverse usually changes the foreground and background
+// colors.)
+func (s Style) Reverse(on bool) Style {
+	return s.setAttrs(Style(AttrReverse), on)
+}
+
+// Underline returns a new style based on s, with the underline attribute set
+// as requested.
+func (s Style) Underline(on bool) Style {
+	return s.setAttrs(Style(AttrUnderline), on)
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/.gitignore

@@ -0,0 +1 @@
+mkinfo

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/README.md

@@ -0,0 +1,25 @@
+This package represents the parent for all terminals.
+
+In older versions of tcell we had (a couple of) different
+external file formats for the terminal database.  Those are
+now removed.  All terminal definitions are supplied by
+one of two methods:
+
+1. Compiled Go code
+
+2. For systems with terminfo and infocmp, dynamically
+   generated at runtime.
+
+The Go code can be generated using the mkinfo utility in
+this directory.  The database entry should be generated
+into a package in a directory named as the first character
+of the package name.  (This permits us to group them all
+without having a huge directory of little packages.)
+
+It may be desirable to add new packages to the extended
+package, or -- rarely -- the base package.
+
+Applications which want to have the large set of terminal
+descriptions built into the binary can simply import the
+extended package.  Otherwise a smaller reasonable default
+set (the base package) will be included instead.

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/TERMINALS.md

@@ -0,0 +1,7 @@
+TERMINALS
+=========
+
+The best way to populate terminals on Debian is to install ncurses,
+ncurses-term, screen, tmux, rxvt-unicode, and dvtm.  This populates the
+the terminfo database so that we can have a reasonable set of starting
+terminals.

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/a/adm3a/term.go

@@ -0,0 +1,25 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package adm3a
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// lsi adm3a
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:        "adm3a",
+		Columns:     80,
+		Lines:       24,
+		Bell:        "\a",
+		Clear:       "\x1a$<1/>",
+		PadChar:     "\x00",
+		SetCursor:   "\x1b=%p1%' '%+%c%p2%' '%+%c",
+		CursorBack1: "\b",
+		CursorUp1:   "\v",
+		KeyUp:       "\v",
+		KeyDown:     "\n",
+		KeyRight:    "\f",
+		KeyLeft:     "\b",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/a/aixterm/term.go

@@ -0,0 +1,81 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package aixterm
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// IBM Aixterm Terminal Emulator
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "aixterm",
+		Columns:      80,
+		Lines:        25,
+		Colors:       8,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[J",
+		AttrOff:      "\x1b[0;10m\x1b(B",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Reverse:      "\x1b[7m",
+		SetFg:        "\x1b[3%p1%dm",
+		SetBg:        "\x1b[4%p1%dm",
+		SetFgBg:      "\x1b[3%p1%d;4%p2%dm",
+		PadChar:      "\x00",
+		AltChars:     "jjkkllmmnnqqttuuvvwwxx",
+		EnterAcs:     "\x1b(0",
+		ExitAcs:      "\x1b(B",
+		SetCursor:    "\x1b[%i%p1%d;%p2%dH",
+		CursorBack1:  "\b",
+		CursorUp1:    "\x1b[A",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[139q",
+		KeyDelete:    "\x1b[P",
+		KeyBackspace: "\b",
+		KeyHome:      "\x1b[H",
+		KeyEnd:       "\x1b[146q",
+		KeyPgUp:      "\x1b[150q",
+		KeyPgDn:      "\x1b[154q",
+		KeyF1:        "\x1b[001q",
+		KeyF2:        "\x1b[002q",
+		KeyF3:        "\x1b[003q",
+		KeyF4:        "\x1b[004q",
+		KeyF5:        "\x1b[005q",
+		KeyF6:        "\x1b[006q",
+		KeyF7:        "\x1b[007q",
+		KeyF8:        "\x1b[008q",
+		KeyF9:        "\x1b[009q",
+		KeyF10:       "\x1b[010q",
+		KeyF11:       "\x1b[011q",
+		KeyF12:       "\x1b[012q",
+		KeyF13:       "\x1b[013q",
+		KeyF14:       "\x1b[014q",
+		KeyF15:       "\x1b[015q",
+		KeyF16:       "\x1b[016q",
+		KeyF17:       "\x1b[017q",
+		KeyF18:       "\x1b[018q",
+		KeyF19:       "\x1b[019q",
+		KeyF20:       "\x1b[020q",
+		KeyF21:       "\x1b[021q",
+		KeyF22:       "\x1b[022q",
+		KeyF23:       "\x1b[023q",
+		KeyF24:       "\x1b[024q",
+		KeyF25:       "\x1b[025q",
+		KeyF26:       "\x1b[026q",
+		KeyF27:       "\x1b[027q",
+		KeyF28:       "\x1b[028q",
+		KeyF29:       "\x1b[029q",
+		KeyF30:       "\x1b[030q",
+		KeyF31:       "\x1b[031q",
+		KeyF32:       "\x1b[032q",
+		KeyF33:       "\x1b[033q",
+		KeyF34:       "\x1b[034q",
+		KeyF35:       "\x1b[035q",
+		KeyF36:       "\x1b[036q",
+		KeyClear:     "\x1b[144q",
+		KeyBacktab:   "\x1b[Z",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/a/alacritty/term.go

@@ -0,0 +1,158 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package alacritty
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// alacritty terminal emulator
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:            "alacritty",
+		Columns:         80,
+		Lines:           24,
+		Colors:          256,
+		Bell:            "\a",
+		Clear:           "\x1b[H\x1b[2J",
+		EnterCA:         "\x1b[?1049h\x1b[22;0;0t",
+		ExitCA:          "\x1b[?1049l\x1b[23;0;0t",
+		ShowCursor:      "\x1b[?12l\x1b[?25h",
+		HideCursor:      "\x1b[?25l",
+		AttrOff:         "\x1b(B\x1b[m",
+		Underline:       "\x1b[4m",
+		Bold:            "\x1b[1m",
+		Dim:             "\x1b[2m",
+		Blink:           "\x1b[5m",
+		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:        "``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		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:    "\b",
+		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",
+		KeyShfPgUp:      "\x1b[5;2~",
+		KeyShfPgDn:      "\x1b[6;2~",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/a/ansi/term.go

@@ -0,0 +1,41 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package ansi
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// ansi/pc-term compatible with color
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "ansi",
+		Columns:      80,
+		Lines:        24,
+		Colors:       8,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[J",
+		AttrOff:      "\x1b[0;10m",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		SetFg:        "\x1b[3%p1%dm",
+		SetBg:        "\x1b[4%p1%dm",
+		SetFgBg:      "\x1b[3%p1%d;4%p2%dm",
+		PadChar:      "\x00",
+		AltChars:     "+\x10,\x11-\x18.\x190\xdb`\x04a\xb1f\xf8g\xf1h\xb0j\xd9k\xbfl\xdam\xc0n\xc5o~p\xc4q\xc4r\xc4s_t\xc3u\xb4v\xc1w\xc2x\xb3y\xf3z\xf2{\xe3|\xd8}\x9c~\xfe",
+		EnterAcs:     "\x1b[11m",
+		ExitAcs:      "\x1b[10m",
+		SetCursor:    "\x1b[%i%p1%d;%p2%dH",
+		CursorBack1:  "\x1b[D",
+		CursorUp1:    "\x1b[A",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[L",
+		KeyBackspace: "\b",
+		KeyHome:      "\x1b[H",
+		KeyBacktab:   "\x1b[Z",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/a/aterm/term.go

@@ -0,0 +1,110 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package aterm
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// AfterStep terminal
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "aterm",
+		Columns:      80,
+		Lines:        24,
+		Colors:       8,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[2J",
+		EnterCA:      "\x1b7\x1b[?47h",
+		ExitCA:       "\x1b[2J\x1b[?47l\x1b8",
+		ShowCursor:   "\x1b[?25h",
+		HideCursor:   "\x1b[?25l",
+		AttrOff:      "\x1b[m\x0f",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		EnterKeypad:  "\x1b=",
+		ExitKeypad:   "\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:    "\x1b[A",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[2~",
+		KeyDelete:    "\x1b[3~",
+		KeyBackspace: "\u007f",
+		KeyHome:      "\x1b[7~",
+		KeyEnd:       "\x1b[8~",
+		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[25~",
+		KeyF14:       "\x1b[26~",
+		KeyF15:       "\x1b[28~",
+		KeyF16:       "\x1b[29~",
+		KeyF17:       "\x1b[31~",
+		KeyF18:       "\x1b[32~",
+		KeyF19:       "\x1b[33~",
+		KeyF20:       "\x1b[34~",
+		KeyF21:       "\x1b[23$",
+		KeyF22:       "\x1b[24$",
+		KeyF23:       "\x1b[11^",
+		KeyF24:       "\x1b[12^",
+		KeyF25:       "\x1b[13^",
+		KeyF26:       "\x1b[14^",
+		KeyF27:       "\x1b[15^",
+		KeyF28:       "\x1b[17^",
+		KeyF29:       "\x1b[18^",
+		KeyF30:       "\x1b[19^",
+		KeyF31:       "\x1b[20^",
+		KeyF32:       "\x1b[21^",
+		KeyF33:       "\x1b[23^",
+		KeyF34:       "\x1b[24^",
+		KeyF35:       "\x1b[25^",
+		KeyF36:       "\x1b[26^",
+		KeyF37:       "\x1b[28^",
+		KeyF38:       "\x1b[29^",
+		KeyF39:       "\x1b[31^",
+		KeyF40:       "\x1b[32^",
+		KeyF41:       "\x1b[33^",
+		KeyF42:       "\x1b[34^",
+		KeyF43:       "\x1b[23@",
+		KeyF44:       "\x1b[24@",
+		KeyBacktab:   "\x1b[Z",
+		KeyShfLeft:   "\x1b[d",
+		KeyShfRight:  "\x1b[c",
+		KeyShfUp:     "\x1b[a",
+		KeyShfDown:   "\x1b[b",
+		KeyCtrlLeft:  "\x1b[Od",
+		KeyCtrlRight: "\x1b[Oc",
+		KeyCtrlUp:    "\x1b[Oa",
+		KeyCtrlDown:  "\x1b[Ob",
+		KeyShfHome:   "\x1b[7$",
+		KeyShfEnd:    "\x1b[8$",
+		KeyCtrlHome:  "\x1b[7^",
+		KeyCtrlEnd:   "\x1b[8^",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/b/beterm/term.go

@@ -0,0 +1,54 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package beterm
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// BeOS Terminal
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "beterm",
+		Columns:      80,
+		Lines:        25,
+		Colors:       8,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[J",
+		AttrOff:      "\x1b[0;10m",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Reverse:      "\x1b[7m",
+		EnterKeypad:  "\x1b[?4h",
+		ExitKeypad:   "\x1b[?4l",
+		SetFg:        "\x1b[3%p1%dm",
+		SetBg:        "\x1b[4%p1%dm",
+		SetFgBg:      "\x1b[3%p1%d;4%p2%dm",
+		PadChar:      "\x00",
+		SetCursor:    "\x1b[%i%p1%d;%p2%dH",
+		CursorBack1:  "\b",
+		CursorUp1:    "\x1b[A",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[2~",
+		KeyDelete:    "\x1b[3~",
+		KeyBackspace: "\b",
+		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[16~",
+		KeyF7:        "\x1b[17~",
+		KeyF8:        "\x1b[18~",
+		KeyF9:        "\x1b[19~",
+		KeyF10:       "\x1b[20~",
+		KeyF11:       "\x1b[21~",
+		KeyF12:       "\x1b[22~",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/b/bsdos_pc/term.go

@@ -0,0 +1,42 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package bsdos_pc
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// IBM PC BSD/OS Console
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "bsdos-pc",
+		Columns:      80,
+		Lines:        25,
+		Colors:       8,
+		Bell:         "\a",
+		Clear:        "\x1bc",
+		AttrOff:      "\x1b[0;10m",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		SetFg:        "\x1b[3%p1%dm",
+		SetBg:        "\x1b[4%p1%dm",
+		SetFgBg:      "\x1b[3%p1%d;4%p2%dm",
+		PadChar:      "\x00",
+		AltChars:     "+\x10,\x11-\x18.\x190\xdb`\x04a\xb1f\xf8g\xf1h\xb0j\xd9k\xbfl\xdam\xc0n\xc5o~p\xc4q\xc4r\xc4s_t\xc3u\xb4v\xc1w\xc2x\xb3y\xf3z\xf2{\xe3|\xd8}\x9c~\xfe",
+		EnterAcs:     "\x1b[11m",
+		ExitAcs:      "\x1b[10m",
+		SetCursor:    "\x1b[%i%p1%d;%p2%dH",
+		CursorBack1:  "\b",
+		CursorUp1:    "\x1b[A",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[L",
+		KeyBackspace: "\b",
+		KeyHome:      "\x1b[H",
+		KeyPgUp:      "\x1b[I",
+		KeyPgDn:      "\x1b[G",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/base/base.go

@@ -0,0 +1,32 @@
+// Copyright 2019 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 is just a "minimalist" set of the base terminal descriptions.
+// It should be sufficient for most applications.
+
+// Package base contains the base terminal descriptions that are likely
+// to be needed by any stock application.  It is imported by default in the
+// terminfo package, so terminal types listed here will be available to any
+// tcell application.
+package base
+
+import (
+	// The following imports just register themselves --
+	// thse are the terminal types we aggregate in this package.
+	_ "github.com/gdamore/tcell/terminfo/a/ansi"
+	_ "github.com/gdamore/tcell/terminfo/v/vt100"
+	_ "github.com/gdamore/tcell/terminfo/v/vt102"
+	_ "github.com/gdamore/tcell/terminfo/v/vt220"
+	_ "github.com/gdamore/tcell/terminfo/x/xterm"
+)

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/c/cygwin/term.go

@@ -0,0 +1,63 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package cygwin
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// ANSI emulation for Cygwin
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "cygwin",
+		Colors:       8,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[J",
+		EnterCA:      "\x1b7\x1b[?47h",
+		ExitCA:       "\x1b[2J\x1b[?47l\x1b8",
+		AttrOff:      "\x1b[0;10m",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Reverse:      "\x1b[7m",
+		SetFg:        "\x1b[3%p1%dm",
+		SetBg:        "\x1b[4%p1%dm",
+		SetFgBg:      "\x1b[3%p1%d;4%p2%dm",
+		PadChar:      "\x00",
+		AltChars:     "+\x10,\x11-\x18.\x190\xdb`\x04a\xb1f\xf8g\xf1h\xb0j\xd9k\xbfl\xdam\xc0n\xc5o~p\xc4q\xc4r\xc4s_t\xc3u\xb4v\xc1w\xc2x\xb3y\xf3z\xf2{\xe3|\xd8}\x9c~\xfe",
+		EnterAcs:     "\x1b[11m",
+		ExitAcs:      "\x1b[10m",
+		SetCursor:    "\x1b[%i%p1%d;%p2%dH",
+		CursorBack1:  "\b",
+		CursorUp1:    "\x1b[A",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[2~",
+		KeyDelete:    "\x1b[3~",
+		KeyBackspace: "\b",
+		KeyHome:      "\x1b[1~",
+		KeyEnd:       "\x1b[4~",
+		KeyPgUp:      "\x1b[5~",
+		KeyPgDn:      "\x1b[6~",
+		KeyF1:        "\x1b[[A",
+		KeyF2:        "\x1b[[B",
+		KeyF3:        "\x1b[[C",
+		KeyF4:        "\x1b[[D",
+		KeyF5:        "\x1b[[E",
+		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~",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/d/d200/term.go

@@ -0,0 +1,97 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package d200
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// Data General DASHER D200
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:        "d200",
+		Aliases:     []string{"d200-dg"},
+		Columns:     80,
+		Lines:       24,
+		Bell:        "\a",
+		Clear:       "\f",
+		AttrOff:     "\x0f\x15\x1d\x1eE",
+		Underline:   "\x14",
+		Bold:        "\x1eD\x14",
+		Dim:         "\x1c",
+		Blink:       "\x0e",
+		Reverse:     "\x1eD",
+		PadChar:     "\x00",
+		SetCursor:   "\x10%p2%c%p1%c",
+		CursorBack1: "\x19",
+		CursorUp1:   "\x17",
+		KeyUp:       "\x17",
+		KeyDown:     "\x1a",
+		KeyRight:    "\x18",
+		KeyLeft:     "\x19",
+		KeyHome:     "\b",
+		KeyF1:       "\x1eq",
+		KeyF2:       "\x1er",
+		KeyF3:       "\x1es",
+		KeyF4:       "\x1et",
+		KeyF5:       "\x1eu",
+		KeyF6:       "\x1ev",
+		KeyF7:       "\x1ew",
+		KeyF8:       "\x1ex",
+		KeyF9:       "\x1ey",
+		KeyF10:      "\x1ez",
+		KeyF11:      "\x1e{",
+		KeyF12:      "\x1e|",
+		KeyF13:      "\x1e}",
+		KeyF14:      "\x1e~",
+		KeyF15:      "\x1ep",
+		KeyF16:      "\x1ea",
+		KeyF17:      "\x1eb",
+		KeyF18:      "\x1ec",
+		KeyF19:      "\x1ed",
+		KeyF20:      "\x1ee",
+		KeyF21:      "\x1ef",
+		KeyF22:      "\x1eg",
+		KeyF23:      "\x1eh",
+		KeyF24:      "\x1ei",
+		KeyF25:      "\x1ej",
+		KeyF26:      "\x1ek",
+		KeyF27:      "\x1el",
+		KeyF28:      "\x1em",
+		KeyF29:      "\x1en",
+		KeyF30:      "\x1e`",
+		KeyF31:      "\x1e1",
+		KeyF32:      "\x1e2",
+		KeyF33:      "\x1e3",
+		KeyF34:      "\x1e4",
+		KeyF35:      "\x1e5",
+		KeyF36:      "\x1e6",
+		KeyF37:      "\x1e7",
+		KeyF38:      "\x1e8",
+		KeyF39:      "\x1e9",
+		KeyF40:      "\x1e:",
+		KeyF41:      "\x1e;",
+		KeyF42:      "\x1e<",
+		KeyF43:      "\x1e=",
+		KeyF44:      "\x1e>",
+		KeyF45:      "\x1e0",
+		KeyF46:      "\x1e!",
+		KeyF47:      "\x1e\"",
+		KeyF48:      "\x1e#",
+		KeyF49:      "\x1e$",
+		KeyF50:      "\x1e%%",
+		KeyF51:      "\x1e&",
+		KeyF52:      "\x1e'",
+		KeyF53:      "\x1e(",
+		KeyF54:      "\x1e)",
+		KeyF55:      "\x1e*",
+		KeyF56:      "\x1e+",
+		KeyF57:      "\x1e,",
+		KeyF58:      "\x1e-",
+		KeyF59:      "\x1e.",
+		KeyF60:      "\x1e ",
+		KeyClear:    "\f",
+		KeyShfLeft:  "\x1e\x19",
+		KeyShfRight: "\x1e\x18",
+		KeyShfHome:  "\x1e\b",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/d/d210/term.go

@@ -0,0 +1,95 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package d210
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// Data General DASHER D210 series
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:        "d210",
+		Aliases:     []string{"d214"},
+		Columns:     80,
+		Lines:       24,
+		Bell:        "\a",
+		Clear:       "\x1b[2J",
+		AttrOff:     "\x1b[m",
+		Underline:   "\x1b[4m",
+		Bold:        "\x1b[4;7m",
+		Dim:         "\x1b[2m",
+		Blink:       "\x1b[5m",
+		Reverse:     "\x1b[7m",
+		PadChar:     "\x00",
+		SetCursor:   "\x1b[%i%p1%d;%p2%dH",
+		CursorBack1: "\b",
+		CursorUp1:   "\x1b[A",
+		KeyUp:       "\x1b[A",
+		KeyDown:     "\x1b[B",
+		KeyRight:    "\x1b[C",
+		KeyLeft:     "\x1b[D",
+		KeyHome:     "\x1b[H",
+		KeyF1:       "\x1b[001z",
+		KeyF2:       "\x1b[002z",
+		KeyF3:       "\x1b[003z",
+		KeyF4:       "\x1b[004z",
+		KeyF5:       "\x1b[005z",
+		KeyF6:       "\x1b[006z",
+		KeyF7:       "\x1b[007z",
+		KeyF8:       "\x1b[008z",
+		KeyF9:       "\x1b[009z",
+		KeyF10:      "\x1b[010z",
+		KeyF11:      "\x1b[011z",
+		KeyF12:      "\x1b[012z",
+		KeyF13:      "\x1b[013z",
+		KeyF14:      "\x1b[014z",
+		KeyF15:      "\x1b[000z",
+		KeyF16:      "\x1b[101z",
+		KeyF17:      "\x1b[102z",
+		KeyF18:      "\x1b[103z",
+		KeyF19:      "\x1b[104z",
+		KeyF20:      "\x1b[105z",
+		KeyF21:      "\x1b[106z",
+		KeyF22:      "\x1b[107z",
+		KeyF23:      "\x1b[108z",
+		KeyF24:      "\x1b[109z",
+		KeyF25:      "\x1b[110z",
+		KeyF26:      "\x1b[111z",
+		KeyF27:      "\x1b[112z",
+		KeyF28:      "\x1b[113z",
+		KeyF29:      "\x1b[114z",
+		KeyF30:      "\x1b[100z",
+		KeyF31:      "\x1b[201z",
+		KeyF32:      "\x1b[202z",
+		KeyF33:      "\x1b[203z",
+		KeyF34:      "\x1b[204z",
+		KeyF35:      "\x1b[205z",
+		KeyF36:      "\x1b[206z",
+		KeyF37:      "\x1b[207z",
+		KeyF38:      "\x1b[208z",
+		KeyF39:      "\x1b[209z",
+		KeyF40:      "\x1b[210z",
+		KeyF41:      "\x1b[211z",
+		KeyF42:      "\x1b[212z",
+		KeyF43:      "\x1b[213z",
+		KeyF44:      "\x1b[214z",
+		KeyF45:      "\x1b[200z",
+		KeyF46:      "\x1b[301z",
+		KeyF47:      "\x1b[302z",
+		KeyF48:      "\x1b[303z",
+		KeyF49:      "\x1b[304z",
+		KeyF50:      "\x1b[305z",
+		KeyF51:      "\x1b[306z",
+		KeyF52:      "\x1b[307z",
+		KeyF53:      "\x1b[308z",
+		KeyF54:      "\x1b[309z",
+		KeyF55:      "\x1b[310z",
+		KeyF56:      "\x1b[311z",
+		KeyF57:      "\x1b[312z",
+		KeyF58:      "\x1b[313z",
+		KeyF59:      "\x1b[314z",
+		KeyF60:      "\x1b[300z",
+		KeyPrint:    "\x1b[i",
+		KeyClear:    "\x1b[2J",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/d/dtterm/term.go

@@ -0,0 +1,67 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package dtterm
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// CDE desktop terminal
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "dtterm",
+		Columns:      80,
+		Lines:        24,
+		Colors:       8,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[J",
+		ShowCursor:   "\x1b[?25h",
+		HideCursor:   "\x1b[?25l",
+		AttrOff:      "\x1b[m\x0f",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Dim:          "\x1b[2m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		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",
+		SetCursor:    "\x1b[%i%p1%d;%p2%dH",
+		CursorBack1:  "\b",
+		CursorUp1:    "\x1b[A",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[2~",
+		KeyDelete:    "\x1b[3~",
+		KeyBackspace: "\b",
+		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~",
+		KeyHelp:      "\x1b[28~",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/dynamic/dynamic.go

@@ -0,0 +1,429 @@
+// Copyright 2019 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.
+
+// The dynamic package is used to generate a terminal description dynamically,
+// using infocmp.  This is really a method of last resort, as the performance
+// will be slow, and it requires a working infocmp.  But, the hope is that it
+// will assist folks who have to deal with a terminal description that isn't
+// already built in.  This requires infocmp to be in the user's path, and to
+// support reasonably the -1 option.
+
+package dynamic
+
+import (
+	"bytes"
+	"errors"
+	"os/exec"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/gdamore/tcell/terminfo"
+)
+
+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
+	control
+	escaped
+)
+
+var errNotAddressable = 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 = escaped
+			case '^':
+				esc = control
+			default:
+				buf.WriteByte(c)
+			}
+		case control:
+			buf.WriteByte(c ^ 1<<6)
+			esc = none
+		case escaped:
+			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(' ')
+			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)
+
+	if err := cmd.Run(); 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 {
+			u, err := strconv.ParseUint(k[1], 0, 0)
+			if err != nil {
+				return (err)
+			}
+			tc.nums[k[0]] = int(u)
+		} else {
+			tc.bools[val] = true
+		}
+	}
+	return nil
+}
+
+// LoadTerminfo creates a Terminfo by for named terminal by attempting to parse
+// the output from infocmp.  This returns the terminfo entry, a description of
+// the terminal, and either nil or an error.
+func LoadTerminfo(name string) (*terminfo.Terminfo, string, error) {
+	var tc termcap
+	if err := tc.setupterm(name); err != nil {
+		if err != nil {
+			return nil, "", err
+		}
+	}
+	t := &terminfo.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.Blink = tc.getstr("blink")
+	t.Dim = tc.getstr("dim")
+	t.Italic = tc.getstr("sitm")
+	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"
+
+		t.KeyShfPgUp = "\x1b[5;2~"
+		t.KeyShfPgDn = "\x1b[6;2~"
+	}
+	// 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 escaped 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 escapedape 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, "", errNotAddressable
+	}
+
+	// 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 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
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/e/emacs/term.go

@@ -0,0 +1,60 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package emacs
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// gnu emacs term.el terminal emulation
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:        "eterm",
+		Columns:     80,
+		Lines:       24,
+		Bell:        "\a",
+		Clear:       "\x1b[H\x1b[J",
+		EnterCA:     "\x1b7\x1b[?47h",
+		ExitCA:      "\x1b[2J\x1b[?47l\x1b8",
+		AttrOff:     "\x1b[m",
+		Underline:   "\x1b[4m",
+		Bold:        "\x1b[1m",
+		Reverse:     "\x1b[7m",
+		PadChar:     "\x00",
+		SetCursor:   "\x1b[%i%p1%d;%p2%dH",
+		CursorBack1: "\b",
+		CursorUp1:   "\x1b[A",
+	})
+
+	// Emacs term.el terminal emulator term-protocol-version 0.96
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "eterm-color",
+		Columns:      80,
+		Lines:        24,
+		Colors:       8,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[J",
+		AttrOff:      "\x1b[m",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		SetFg:        "\x1b[%p1%{30}%+%dm",
+		SetBg:        "\x1b[%p1%'('%+%dm",
+		SetFgBg:      "\x1b[%p1%{30}%+%d;%p2%'('%+%dm",
+		PadChar:      "\x00",
+		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: "\u007f",
+		KeyHome:      "\x1b[1~",
+		KeyEnd:       "\x1b[4~",
+		KeyPgUp:      "\x1b[5~",
+		KeyPgDn:      "\x1b[6~",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/e/eterm/term.go

@@ -0,0 +1,309 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package eterm
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// Eterm with xterm-style color support (X Window System)
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "Eterm",
+		Aliases:      []string{"Eterm-color"},
+		Columns:      80,
+		Lines:        24,
+		Colors:       8,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[2J",
+		EnterCA:      "\x1b7\x1b[?47h",
+		ExitCA:       "\x1b[2J\x1b[?47l\x1b8",
+		ShowCursor:   "\x1b[?25h",
+		HideCursor:   "\x1b[?25l",
+		AttrOff:      "\x1b[m\x0f",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		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)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:    "\x1b[A",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[2~",
+		KeyDelete:    "\x1b[3~",
+		KeyBackspace: "\u007f",
+		KeyHome:      "\x1b[7~",
+		KeyEnd:       "\x1b[8~",
+		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~",
+		KeyF21:       "\x1b[23$",
+		KeyF22:       "\x1b[24$",
+		KeyF23:       "\x1b[11^",
+		KeyF24:       "\x1b[12^",
+		KeyF25:       "\x1b[13^",
+		KeyF26:       "\x1b[14^",
+		KeyF27:       "\x1b[15^",
+		KeyF28:       "\x1b[17^",
+		KeyF29:       "\x1b[18^",
+		KeyF30:       "\x1b[19^",
+		KeyF31:       "\x1b[20^",
+		KeyF32:       "\x1b[21^",
+		KeyF33:       "\x1b[23^",
+		KeyF34:       "\x1b[24^",
+		KeyF35:       "\x1b[25^",
+		KeyF36:       "\x1b[26^",
+		KeyF37:       "\x1b[28^",
+		KeyF38:       "\x1b[29^",
+		KeyF39:       "\x1b[31^",
+		KeyF40:       "\x1b[32^",
+		KeyF41:       "\x1b[33^",
+		KeyF42:       "\x1b[34^",
+		KeyF43:       "\x1b[23@",
+		KeyF44:       "\x1b[24@",
+		KeyHelp:      "\x1b[28~",
+		KeyShfLeft:   "\x1b[d",
+		KeyShfRight:  "\x1b[c",
+		KeyShfUp:     "\x1b[a",
+		KeyShfDown:   "\x1b[b",
+		KeyCtrlLeft:  "\x1b[Od",
+		KeyCtrlRight: "\x1b[Oc",
+		KeyCtrlUp:    "\x1b[Oa",
+		KeyCtrlDown:  "\x1b[Ob",
+		KeyShfHome:   "\x1b[7$",
+		KeyShfEnd:    "\x1b[8$",
+		KeyCtrlHome:  "\x1b[7^",
+		KeyCtrlEnd:   "\x1b[8^",
+	})
+
+	// Eterm with 88 colors
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "Eterm-88color",
+		Columns:      80,
+		Lines:        24,
+		Colors:       88,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[2J",
+		EnterCA:      "\x1b7\x1b[?47h",
+		ExitCA:       "\x1b[2J\x1b[?47l\x1b8",
+		ShowCursor:   "\x1b[?25h",
+		HideCursor:   "\x1b[?25l",
+		AttrOff:      "\x1b[m\x0f",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		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",
+		PadChar:      "\x00",
+		AltChars:     "``aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		EnterAcs:     "\x0e",
+		ExitAcs:      "\x0f",
+		EnableAcs:    "\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:    "\x1b[A",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[2~",
+		KeyDelete:    "\x1b[3~",
+		KeyBackspace: "\u007f",
+		KeyHome:      "\x1b[7~",
+		KeyEnd:       "\x1b[8~",
+		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~",
+		KeyF21:       "\x1b[23$",
+		KeyF22:       "\x1b[24$",
+		KeyF23:       "\x1b[11^",
+		KeyF24:       "\x1b[12^",
+		KeyF25:       "\x1b[13^",
+		KeyF26:       "\x1b[14^",
+		KeyF27:       "\x1b[15^",
+		KeyF28:       "\x1b[17^",
+		KeyF29:       "\x1b[18^",
+		KeyF30:       "\x1b[19^",
+		KeyF31:       "\x1b[20^",
+		KeyF32:       "\x1b[21^",
+		KeyF33:       "\x1b[23^",
+		KeyF34:       "\x1b[24^",
+		KeyF35:       "\x1b[25^",
+		KeyF36:       "\x1b[26^",
+		KeyF37:       "\x1b[28^",
+		KeyF38:       "\x1b[29^",
+		KeyF39:       "\x1b[31^",
+		KeyF40:       "\x1b[32^",
+		KeyF41:       "\x1b[33^",
+		KeyF42:       "\x1b[34^",
+		KeyF43:       "\x1b[23@",
+		KeyF44:       "\x1b[24@",
+		KeyHelp:      "\x1b[28~",
+		KeyShfLeft:   "\x1b[d",
+		KeyShfRight:  "\x1b[c",
+		KeyShfUp:     "\x1b[a",
+		KeyShfDown:   "\x1b[b",
+		KeyCtrlLeft:  "\x1b[Od",
+		KeyCtrlRight: "\x1b[Oc",
+		KeyCtrlUp:    "\x1b[Oa",
+		KeyCtrlDown:  "\x1b[Ob",
+		KeyShfHome:   "\x1b[7$",
+		KeyShfEnd:    "\x1b[8$",
+		KeyCtrlHome:  "\x1b[7^",
+		KeyCtrlEnd:   "\x1b[8^",
+	})
+
+	// Eterm with xterm 256-colors
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "Eterm-256color",
+		Columns:      80,
+		Lines:        24,
+		Colors:       256,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[2J",
+		EnterCA:      "\x1b7\x1b[?47h",
+		ExitCA:       "\x1b[2J\x1b[?47l\x1b8",
+		ShowCursor:   "\x1b[?25h",
+		HideCursor:   "\x1b[?25l",
+		AttrOff:      "\x1b[m\x0f",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		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",
+		PadChar:      "\x00",
+		AltChars:     "``aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		EnterAcs:     "\x0e",
+		ExitAcs:      "\x0f",
+		EnableAcs:    "\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:    "\x1b[A",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[2~",
+		KeyDelete:    "\x1b[3~",
+		KeyBackspace: "\u007f",
+		KeyHome:      "\x1b[7~",
+		KeyEnd:       "\x1b[8~",
+		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~",
+		KeyF21:       "\x1b[23$",
+		KeyF22:       "\x1b[24$",
+		KeyF23:       "\x1b[11^",
+		KeyF24:       "\x1b[12^",
+		KeyF25:       "\x1b[13^",
+		KeyF26:       "\x1b[14^",
+		KeyF27:       "\x1b[15^",
+		KeyF28:       "\x1b[17^",
+		KeyF29:       "\x1b[18^",
+		KeyF30:       "\x1b[19^",
+		KeyF31:       "\x1b[20^",
+		KeyF32:       "\x1b[21^",
+		KeyF33:       "\x1b[23^",
+		KeyF34:       "\x1b[24^",
+		KeyF35:       "\x1b[25^",
+		KeyF36:       "\x1b[26^",
+		KeyF37:       "\x1b[28^",
+		KeyF38:       "\x1b[29^",
+		KeyF39:       "\x1b[31^",
+		KeyF40:       "\x1b[32^",
+		KeyF41:       "\x1b[33^",
+		KeyF42:       "\x1b[34^",
+		KeyF43:       "\x1b[23@",
+		KeyF44:       "\x1b[24@",
+		KeyHelp:      "\x1b[28~",
+		KeyShfLeft:   "\x1b[d",
+		KeyShfRight:  "\x1b[c",
+		KeyShfUp:     "\x1b[a",
+		KeyShfDown:   "\x1b[b",
+		KeyCtrlLeft:  "\x1b[Od",
+		KeyCtrlRight: "\x1b[Oc",
+		KeyCtrlUp:    "\x1b[Oa",
+		KeyCtrlDown:  "\x1b[Ob",
+		KeyShfHome:   "\x1b[7$",
+		KeyShfEnd:    "\x1b[8$",
+		KeyCtrlHome:  "\x1b[7^",
+		KeyCtrlEnd:   "\x1b[8^",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/extended/extended.go

@@ -0,0 +1,69 @@
+// Copyright 2019 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.
+
+// Package extended contains an extended set of terminal descriptions.
+// Applications desiring to have a better chance of Just Working by
+// default should include this package.  This will significantly increase
+// the size of the program.
+package extended
+
+import (
+	// The following imports just register themselves --
+	// these are the terminal types we aggregate in this package.
+	_ "github.com/gdamore/tcell/terminfo/a/adm3a"
+	_ "github.com/gdamore/tcell/terminfo/a/aixterm"
+	_ "github.com/gdamore/tcell/terminfo/a/alacritty"
+	_ "github.com/gdamore/tcell/terminfo/a/ansi"
+	_ "github.com/gdamore/tcell/terminfo/a/aterm"
+	_ "github.com/gdamore/tcell/terminfo/b/beterm"
+	_ "github.com/gdamore/tcell/terminfo/b/bsdos_pc"
+	_ "github.com/gdamore/tcell/terminfo/c/cygwin"
+	_ "github.com/gdamore/tcell/terminfo/d/d200"
+	_ "github.com/gdamore/tcell/terminfo/d/d210"
+	_ "github.com/gdamore/tcell/terminfo/d/dtterm"
+	_ "github.com/gdamore/tcell/terminfo/e/emacs"
+	_ "github.com/gdamore/tcell/terminfo/e/eterm"
+	_ "github.com/gdamore/tcell/terminfo/g/gnome"
+	_ "github.com/gdamore/tcell/terminfo/h/hpterm"
+	_ "github.com/gdamore/tcell/terminfo/h/hz1500"
+	_ "github.com/gdamore/tcell/terminfo/k/konsole"
+	_ "github.com/gdamore/tcell/terminfo/k/kterm"
+	_ "github.com/gdamore/tcell/terminfo/l/linux"
+	_ "github.com/gdamore/tcell/terminfo/p/pcansi"
+	_ "github.com/gdamore/tcell/terminfo/r/rxvt"
+	_ "github.com/gdamore/tcell/terminfo/s/screen"
+	_ "github.com/gdamore/tcell/terminfo/s/simpleterm"
+	_ "github.com/gdamore/tcell/terminfo/s/sun"
+	_ "github.com/gdamore/tcell/terminfo/t/termite"
+	_ "github.com/gdamore/tcell/terminfo/t/tvi910"
+	_ "github.com/gdamore/tcell/terminfo/t/tvi912"
+	_ "github.com/gdamore/tcell/terminfo/t/tvi921"
+	_ "github.com/gdamore/tcell/terminfo/t/tvi925"
+	_ "github.com/gdamore/tcell/terminfo/t/tvi950"
+	_ "github.com/gdamore/tcell/terminfo/t/tvi970"
+	_ "github.com/gdamore/tcell/terminfo/v/vt100"
+	_ "github.com/gdamore/tcell/terminfo/v/vt102"
+	_ "github.com/gdamore/tcell/terminfo/v/vt220"
+	_ "github.com/gdamore/tcell/terminfo/v/vt320"
+	_ "github.com/gdamore/tcell/terminfo/v/vt400"
+	_ "github.com/gdamore/tcell/terminfo/v/vt420"
+	_ "github.com/gdamore/tcell/terminfo/v/vt52"
+	_ "github.com/gdamore/tcell/terminfo/w/wy50"
+	_ "github.com/gdamore/tcell/terminfo/w/wy60"
+	_ "github.com/gdamore/tcell/terminfo/w/wy99_ansi"
+	_ "github.com/gdamore/tcell/terminfo/x/xfce"
+	_ "github.com/gdamore/tcell/terminfo/x/xnuppc"
+	_ "github.com/gdamore/tcell/terminfo/x/xterm"
+	_ "github.com/gdamore/tcell/terminfo/x/xterm_kitty"
+)

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/g/gnome/term.go

@@ -0,0 +1,312 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package gnome
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// GNOME Terminal
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:            "gnome",
+		Columns:         80,
+		Lines:           24,
+		Colors:          8,
+		Bell:            "\a",
+		Clear:           "\x1b[H\x1b[2J",
+		EnterCA:         "\x1b7\x1b[?47h",
+		ExitCA:          "\x1b[2J\x1b[?47l\x1b8",
+		ShowCursor:      "\x1b[?25h",
+		HideCursor:      "\x1b[?25l",
+		AttrOff:         "\x1b[0m\x0f",
+		Underline:       "\x1b[4m",
+		Bold:            "\x1b[1m",
+		Dim:             "\x1b[2m",
+		Italic:          "\x1b[3m",
+		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:        "``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		EnterAcs:        "\x0e",
+		ExitAcs:         "\x0f",
+		EnableAcs:       "\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:       "\x1b[A",
+		KeyUp:           "\x1bOA",
+		KeyDown:         "\x1bOB",
+		KeyRight:        "\x1bOC",
+		KeyLeft:         "\x1bOD",
+		KeyInsert:       "\x1b[2~",
+		KeyDelete:       "\x1b[3~",
+		KeyBackspace:    "\u007f",
+		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:          "\x1bO1;2P",
+		KeyF14:          "\x1bO1;2Q",
+		KeyF15:          "\x1bO1;2R",
+		KeyF16:          "\x1bO1;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:          "\x1bO1;5P",
+		KeyF26:          "\x1bO1;5Q",
+		KeyF27:          "\x1bO1;5R",
+		KeyF28:          "\x1bO1;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:          "\x1bO1;6P",
+		KeyF38:          "\x1bO1;6Q",
+		KeyF39:          "\x1bO1;6R",
+		KeyF40:          "\x1bO1;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:          "\x1bO1;3P",
+		KeyF50:          "\x1bO1;3Q",
+		KeyF51:          "\x1bO1;3R",
+		KeyF52:          "\x1bO1;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:          "\x1bO1;4P",
+		KeyF62:          "\x1bO1;4Q",
+		KeyF63:          "\x1bO1;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",
+		KeyShfPgUp:      "\x1b[5;2~",
+		KeyShfPgDn:      "\x1b[6;2~",
+	})
+
+	// GNOME Terminal with xterm 256-colors
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:            "gnome-256color",
+		Columns:         80,
+		Lines:           24,
+		Colors:          256,
+		Bell:            "\a",
+		Clear:           "\x1b[H\x1b[2J",
+		EnterCA:         "\x1b7\x1b[?47h",
+		ExitCA:          "\x1b[2J\x1b[?47l\x1b8",
+		ShowCursor:      "\x1b[?25h",
+		HideCursor:      "\x1b[?25l",
+		AttrOff:         "\x1b[0m\x0f",
+		Underline:       "\x1b[4m",
+		Bold:            "\x1b[1m",
+		Dim:             "\x1b[2m",
+		Italic:          "\x1b[3m",
+		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",
+		PadChar:         "\x00",
+		AltChars:        "``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		EnterAcs:        "\x0e",
+		ExitAcs:         "\x0f",
+		EnableAcs:       "\x1b)0",
+		Mouse:           "\x1b[<",
+		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:    "\u007f",
+		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",
+		KeyShfPgUp:      "\x1b[5;2~",
+		KeyShfPgDn:      "\x1b[6;2~",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/gen.sh

@@ -0,0 +1,18 @@
+while read line
+do
+        case "$line" in
+        *'|'*)
+                alias=${line#*|}
+                line=${line%|*}
+                ;;
+        *)
+                alias=${line%%,*}
+                ;;
+        esac
+
+        alias=${alias//-/_}
+        direc=${alias:0:1}
+
+        mkdir -p ${direc}/${alias}
+        go run mkinfo.go -P ${alias} -go ${direc}/${alias}/term.go ${line//,/ }
+done < models.txt

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/h/hpterm/term.go

@@ -0,0 +1,50 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package hpterm
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// hp X11 terminal emulator
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "hpterm",
+		Aliases:      []string{"X-hpterm"},
+		Columns:      80,
+		Lines:        24,
+		Bell:         "\a",
+		Clear:        "\x1b&a0y0C\x1bJ",
+		AttrOff:      "\x1b&d@\x0f",
+		Underline:    "\x1b&dD",
+		Bold:         "\x1b&dB",
+		Dim:          "\x1b&dH",
+		Reverse:      "\x1b&dB",
+		EnterKeypad:  "\x1b&s1A",
+		ExitKeypad:   "\x1b&s0A",
+		PadChar:      "\x00",
+		EnterAcs:     "\x0e",
+		ExitAcs:      "\x0f",
+		SetCursor:    "\x1b&a%p1%dy%p2%dC",
+		CursorBack1:  "\b",
+		CursorUp1:    "\x1bA",
+		KeyUp:        "\x1bA",
+		KeyDown:      "\x1bB",
+		KeyRight:     "\x1bC",
+		KeyLeft:      "\x1bD",
+		KeyInsert:    "\x1bQ",
+		KeyDelete:    "\x1bP",
+		KeyBackspace: "\b",
+		KeyHome:      "\x1bh",
+		KeyPgUp:      "\x1bV",
+		KeyPgDn:      "\x1bU",
+		KeyF1:        "\x1bp",
+		KeyF2:        "\x1bq",
+		KeyF3:        "\x1br",
+		KeyF4:        "\x1bs",
+		KeyF5:        "\x1bt",
+		KeyF6:        "\x1bu",
+		KeyF7:        "\x1bv",
+		KeyF8:        "\x1bw",
+		KeyClear:     "\x1bJ",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/h/hz1500/term.go

@@ -0,0 +1,26 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package hz1500
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// hazeltine 1500
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:        "hz1500",
+		Columns:     80,
+		Lines:       24,
+		Bell:        "\a",
+		Clear:       "~\x1c",
+		PadChar:     "\x00",
+		SetCursor:   "~\x11%p2%p2%?%{30}%>%t%' '%+%;%'`'%+%c%p1%'`'%+%c",
+		CursorBack1: "\b",
+		CursorUp1:   "~\f",
+		KeyUp:       "~\f",
+		KeyDown:     "\n",
+		KeyRight:    "\x10",
+		KeyLeft:     "\b",
+		KeyHome:     "~\x12",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/k/konsole/term.go

@@ -0,0 +1,310 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package konsole
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// KDE console window
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:            "konsole",
+		Columns:         80,
+		Lines:           24,
+		Colors:          8,
+		Clear:           "\x1b[H\x1b[2J",
+		EnterCA:         "\x1b7\x1b[?47h",
+		ExitCA:          "\x1b[2J\x1b[?47l\x1b8",
+		ShowCursor:      "\x1b[?25h",
+		HideCursor:      "\x1b[?25l",
+		AttrOff:         "\x1b[0m\x0f",
+		Underline:       "\x1b[4m",
+		Bold:            "\x1b[1m",
+		Dim:             "\x1b[2m",
+		Italic:          "\x1b[3m",
+		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",
+		AltChars:        "``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		EnterAcs:        "\x0e",
+		ExitAcs:         "\x0f",
+		EnableAcs:       "\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:       "\x1b[A",
+		KeyUp:           "\x1bOA",
+		KeyDown:         "\x1bOB",
+		KeyRight:        "\x1bOC",
+		KeyLeft:         "\x1bOD",
+		KeyInsert:       "\x1b[2~",
+		KeyDelete:       "\x1b[3~",
+		KeyBackspace:    "\u007f",
+		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:          "\x1bO2P",
+		KeyF14:          "\x1bO2Q",
+		KeyF15:          "\x1bO2R",
+		KeyF16:          "\x1bO2S",
+		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:          "\x1bO5P",
+		KeyF26:          "\x1bO5Q",
+		KeyF27:          "\x1bO5R",
+		KeyF28:          "\x1bO5S",
+		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:          "\x1bO6P",
+		KeyF38:          "\x1bO6Q",
+		KeyF39:          "\x1bO6R",
+		KeyF40:          "\x1bO6S",
+		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:          "\x1bO3P",
+		KeyF50:          "\x1bO3Q",
+		KeyF51:          "\x1bO3R",
+		KeyF52:          "\x1bO3S",
+		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:          "\x1bO4P",
+		KeyF62:          "\x1bO4Q",
+		KeyF63:          "\x1bO4R",
+		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",
+		KeyShfPgUp:      "\x1b[5;2~",
+		KeyShfPgDn:      "\x1b[6;2~",
+	})
+
+	// KDE console window with xterm 256-colors
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:            "konsole-256color",
+		Columns:         80,
+		Lines:           24,
+		Colors:          256,
+		Clear:           "\x1b[H\x1b[2J",
+		EnterCA:         "\x1b7\x1b[?47h",
+		ExitCA:          "\x1b[2J\x1b[?47l\x1b8",
+		ShowCursor:      "\x1b[?25h",
+		HideCursor:      "\x1b[?25l",
+		AttrOff:         "\x1b[0m\x0f",
+		Underline:       "\x1b[4m",
+		Bold:            "\x1b[1m",
+		Dim:             "\x1b[2m",
+		Italic:          "\x1b[3m",
+		Blink:           "\x1b[5m",
+		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:        "``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		EnterAcs:        "\x0e",
+		ExitAcs:         "\x0f",
+		EnableAcs:       "\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:       "\x1b[A",
+		KeyUp:           "\x1bOA",
+		KeyDown:         "\x1bOB",
+		KeyRight:        "\x1bOC",
+		KeyLeft:         "\x1bOD",
+		KeyInsert:       "\x1b[2~",
+		KeyDelete:       "\x1b[3~",
+		KeyBackspace:    "\u007f",
+		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:          "\x1bO2P",
+		KeyF14:          "\x1bO2Q",
+		KeyF15:          "\x1bO2R",
+		KeyF16:          "\x1bO2S",
+		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:          "\x1bO5P",
+		KeyF26:          "\x1bO5Q",
+		KeyF27:          "\x1bO5R",
+		KeyF28:          "\x1bO5S",
+		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:          "\x1bO6P",
+		KeyF38:          "\x1bO6Q",
+		KeyF39:          "\x1bO6R",
+		KeyF40:          "\x1bO6S",
+		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:          "\x1bO3P",
+		KeyF50:          "\x1bO3Q",
+		KeyF51:          "\x1bO3R",
+		KeyF52:          "\x1bO3S",
+		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:          "\x1bO4P",
+		KeyF62:          "\x1bO4Q",
+		KeyF63:          "\x1bO4R",
+		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",
+		KeyShfPgUp:      "\x1b[5;2~",
+		KeyShfPgDn:      "\x1b[6;2~",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/k/kterm/term.go

@@ -0,0 +1,67 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package kterm
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// kterm kanji terminal emulator (X window system)
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "kterm",
+		Columns:      80,
+		Lines:        24,
+		Colors:       8,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[2J",
+		EnterCA:      "\x1b7\x1b[?47h",
+		ExitCA:       "\x1b[2J\x1b[?47l\x1b8",
+		AttrOff:      "\x1b[m\x1b(B",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		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:     "``aajjkkllmmnnooppqqrrssttuuvvwwxx~~",
+		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: "\u007f",
+		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~",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/l/linux/term.go

@@ -0,0 +1,69 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package linux
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// linux console
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "linux",
+		Colors:       8,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[J",
+		ShowCursor:   "\x1b[?25h\x1b[?0c",
+		HideCursor:   "\x1b[?25l\x1b[?1c",
+		AttrOff:      "\x1b[m\x0f",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Dim:          "\x1b[2m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		SetFg:        "\x1b[3%p1%dm",
+		SetBg:        "\x1b[4%p1%dm",
+		SetFgBg:      "\x1b[3%p1%d;4%p2%dm",
+		PadChar:      "\x00",
+		AltChars:     "++,,--..00__``aaffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}c~~",
+		EnterAcs:     "\x0e",
+		ExitAcs:      "\x0f",
+		EnableAcs:    "\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:    "\x1b[A",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[2~",
+		KeyDelete:    "\x1b[3~",
+		KeyBackspace: "\u007f",
+		KeyHome:      "\x1b[1~",
+		KeyEnd:       "\x1b[4~",
+		KeyPgUp:      "\x1b[5~",
+		KeyPgDn:      "\x1b[6~",
+		KeyF1:        "\x1b[[A",
+		KeyF2:        "\x1b[[B",
+		KeyF3:        "\x1b[[C",
+		KeyF4:        "\x1b[[D",
+		KeyF5:        "\x1b[[E",
+		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",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/models.txt

@@ -0,0 +1,43 @@
+adm3a
+aixterm
+ansi
+aterm
+beterm
+bsdos-pc
+cygwin
+d200
+d210
+dtterm
+eterm,eterm-color|emacs
+Eterm,Eterm-88color,Eterm-256color|eterm
+gnome,gnome-256color
+hpterm
+hz1500
+konsole,konsole-256color
+kterm
+linux
+pcansi
+rxvt,rxvt-256color,rxvt-88color,rxvt-unicode,rxvt-unicode-256color
+screen,screen-256color
+st,st-256color|simpleterm
+sun,sun-color
+termite
+tvi910
+tvi912
+tvi921
+tvi925
+tvi950
+tvi970
+vt52
+vt100
+vt102
+vt220
+vt320
+vt400
+vt420
+wy50
+wy60
+wy99-ansi,wy99a-ansi
+xfce
+xnuppc
+xterm,xterm-88color,xterm-256color

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/p/pcansi/term.go

@@ -0,0 +1,39 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package pcansi
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// ibm-pc terminal programs claiming to be ansi
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "pcansi",
+		Columns:      80,
+		Lines:        24,
+		Colors:       8,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[J",
+		AttrOff:      "\x1b[0;10m",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		SetFg:        "\x1b[3%p1%dm",
+		SetBg:        "\x1b[4%p1%dm",
+		SetFgBg:      "\x1b[3%p1%d;4%p2%dm",
+		PadChar:      "\x00",
+		AltChars:     "+\x10,\x11-\x18.\x190\xdb`\x04a\xb1f\xf8g\xf1h\xb0j\xd9k\xbfl\xdam\xc0n\xc5o~p\xc4q\xc4r\xc4s_t\xc3u\xb4v\xc1w\xc2x\xb3y\xf3z\xf2{\xe3|\xd8}\x9c~\xfe",
+		EnterAcs:     "\x1b[12m",
+		ExitAcs:      "\x1b[10m",
+		SetCursor:    "\x1b[%i%p1%d;%p2%dH",
+		CursorBack1:  "\x1b[D",
+		CursorUp1:    "\x1b[A",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyBackspace: "\b",
+		KeyHome:      "\x1b[H",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/r/rxvt/term.go

@@ -0,0 +1,468 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package rxvt
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// rxvt terminal emulator (X Window System)
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "rxvt",
+		Columns:      80,
+		Lines:        24,
+		Colors:       8,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[2J",
+		EnterCA:      "\x1b7\x1b[?47h",
+		ExitCA:       "\x1b[2J\x1b[?47l\x1b8",
+		ShowCursor:   "\x1b[?25h",
+		HideCursor:   "\x1b[?25l",
+		AttrOff:      "\x1b[m\x0f",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		EnterKeypad:  "\x1b=",
+		ExitKeypad:   "\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:    "\x1b[A",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[2~",
+		KeyDelete:    "\x1b[3~",
+		KeyBackspace: "\u007f",
+		KeyHome:      "\x1b[7~",
+		KeyEnd:       "\x1b[8~",
+		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~",
+		KeyF21:       "\x1b[23$",
+		KeyF22:       "\x1b[24$",
+		KeyF23:       "\x1b[11^",
+		KeyF24:       "\x1b[12^",
+		KeyF25:       "\x1b[13^",
+		KeyF26:       "\x1b[14^",
+		KeyF27:       "\x1b[15^",
+		KeyF28:       "\x1b[17^",
+		KeyF29:       "\x1b[18^",
+		KeyF30:       "\x1b[19^",
+		KeyF31:       "\x1b[20^",
+		KeyF32:       "\x1b[21^",
+		KeyF33:       "\x1b[23^",
+		KeyF34:       "\x1b[24^",
+		KeyF35:       "\x1b[25^",
+		KeyF36:       "\x1b[26^",
+		KeyF37:       "\x1b[28^",
+		KeyF38:       "\x1b[29^",
+		KeyF39:       "\x1b[31^",
+		KeyF40:       "\x1b[32^",
+		KeyF41:       "\x1b[33^",
+		KeyF42:       "\x1b[34^",
+		KeyF43:       "\x1b[23@",
+		KeyF44:       "\x1b[24@",
+		KeyBacktab:   "\x1b[Z",
+		KeyShfLeft:   "\x1b[d",
+		KeyShfRight:  "\x1b[c",
+		KeyShfUp:     "\x1b[a",
+		KeyShfDown:   "\x1b[b",
+		KeyCtrlLeft:  "\x1b[Od",
+		KeyCtrlRight: "\x1b[Oc",
+		KeyCtrlUp:    "\x1b[Oa",
+		KeyCtrlDown:  "\x1b[Ob",
+		KeyShfHome:   "\x1b[7$",
+		KeyShfEnd:    "\x1b[8$",
+		KeyCtrlHome:  "\x1b[7^",
+		KeyCtrlEnd:   "\x1b[8^",
+	})
+
+	// rxvt 2.7.9 with xterm 256-colors
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "rxvt-256color",
+		Columns:      80,
+		Lines:        24,
+		Colors:       256,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[2J",
+		EnterCA:      "\x1b7\x1b[?47h",
+		ExitCA:       "\x1b[2J\x1b[?47l\x1b8",
+		ShowCursor:   "\x1b[?25h",
+		HideCursor:   "\x1b[?25l",
+		AttrOff:      "\x1b[m\x0f",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		EnterKeypad:  "\x1b=",
+		ExitKeypad:   "\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",
+		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:    "\x1b[A",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[2~",
+		KeyDelete:    "\x1b[3~",
+		KeyBackspace: "\u007f",
+		KeyHome:      "\x1b[7~",
+		KeyEnd:       "\x1b[8~",
+		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~",
+		KeyF21:       "\x1b[23$",
+		KeyF22:       "\x1b[24$",
+		KeyF23:       "\x1b[11^",
+		KeyF24:       "\x1b[12^",
+		KeyF25:       "\x1b[13^",
+		KeyF26:       "\x1b[14^",
+		KeyF27:       "\x1b[15^",
+		KeyF28:       "\x1b[17^",
+		KeyF29:       "\x1b[18^",
+		KeyF30:       "\x1b[19^",
+		KeyF31:       "\x1b[20^",
+		KeyF32:       "\x1b[21^",
+		KeyF33:       "\x1b[23^",
+		KeyF34:       "\x1b[24^",
+		KeyF35:       "\x1b[25^",
+		KeyF36:       "\x1b[26^",
+		KeyF37:       "\x1b[28^",
+		KeyF38:       "\x1b[29^",
+		KeyF39:       "\x1b[31^",
+		KeyF40:       "\x1b[32^",
+		KeyF41:       "\x1b[33^",
+		KeyF42:       "\x1b[34^",
+		KeyF43:       "\x1b[23@",
+		KeyF44:       "\x1b[24@",
+		KeyBacktab:   "\x1b[Z",
+		KeyShfLeft:   "\x1b[d",
+		KeyShfRight:  "\x1b[c",
+		KeyShfUp:     "\x1b[a",
+		KeyShfDown:   "\x1b[b",
+		KeyCtrlLeft:  "\x1b[Od",
+		KeyCtrlRight: "\x1b[Oc",
+		KeyCtrlUp:    "\x1b[Oa",
+		KeyCtrlDown:  "\x1b[Ob",
+		KeyShfHome:   "\x1b[7$",
+		KeyShfEnd:    "\x1b[8$",
+		KeyCtrlHome:  "\x1b[7^",
+		KeyCtrlEnd:   "\x1b[8^",
+	})
+
+	// rxvt 2.7.9 with xterm 88-colors
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "rxvt-88color",
+		Columns:      80,
+		Lines:        24,
+		Colors:       88,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[2J",
+		EnterCA:      "\x1b7\x1b[?47h",
+		ExitCA:       "\x1b[2J\x1b[?47l\x1b8",
+		ShowCursor:   "\x1b[?25h",
+		HideCursor:   "\x1b[?25l",
+		AttrOff:      "\x1b[m\x0f",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		EnterKeypad:  "\x1b=",
+		ExitKeypad:   "\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",
+		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:    "\x1b[A",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[2~",
+		KeyDelete:    "\x1b[3~",
+		KeyBackspace: "\u007f",
+		KeyHome:      "\x1b[7~",
+		KeyEnd:       "\x1b[8~",
+		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~",
+		KeyF21:       "\x1b[23$",
+		KeyF22:       "\x1b[24$",
+		KeyF23:       "\x1b[11^",
+		KeyF24:       "\x1b[12^",
+		KeyF25:       "\x1b[13^",
+		KeyF26:       "\x1b[14^",
+		KeyF27:       "\x1b[15^",
+		KeyF28:       "\x1b[17^",
+		KeyF29:       "\x1b[18^",
+		KeyF30:       "\x1b[19^",
+		KeyF31:       "\x1b[20^",
+		KeyF32:       "\x1b[21^",
+		KeyF33:       "\x1b[23^",
+		KeyF34:       "\x1b[24^",
+		KeyF35:       "\x1b[25^",
+		KeyF36:       "\x1b[26^",
+		KeyF37:       "\x1b[28^",
+		KeyF38:       "\x1b[29^",
+		KeyF39:       "\x1b[31^",
+		KeyF40:       "\x1b[32^",
+		KeyF41:       "\x1b[33^",
+		KeyF42:       "\x1b[34^",
+		KeyF43:       "\x1b[23@",
+		KeyF44:       "\x1b[24@",
+		KeyBacktab:   "\x1b[Z",
+		KeyShfLeft:   "\x1b[d",
+		KeyShfRight:  "\x1b[c",
+		KeyShfUp:     "\x1b[a",
+		KeyShfDown:   "\x1b[b",
+		KeyCtrlLeft:  "\x1b[Od",
+		KeyCtrlRight: "\x1b[Oc",
+		KeyCtrlUp:    "\x1b[Oa",
+		KeyCtrlDown:  "\x1b[Ob",
+		KeyShfHome:   "\x1b[7$",
+		KeyShfEnd:    "\x1b[8$",
+		KeyCtrlHome:  "\x1b[7^",
+		KeyCtrlEnd:   "\x1b[8^",
+	})
+
+	// rxvt-unicode terminal (X Window System)
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "rxvt-unicode",
+		Columns:      80,
+		Lines:        24,
+		Colors:       88,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[2J",
+		EnterCA:      "\x1b[?1049h",
+		ExitCA:       "\x1b[r\x1b[?1049l",
+		ShowCursor:   "\x1b[?12l\x1b[?25h",
+		HideCursor:   "\x1b[?25l",
+		AttrOff:      "\x1b[m\x1b(B",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Italic:       "\x1b[3m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		EnterKeypad:  "\x1b=",
+		ExitKeypad:   "\x1b>",
+		SetFg:        "\x1b[38;5;%p1%dm",
+		SetBg:        "\x1b[48;5;%p1%dm",
+		SetFgBg:      "\x1b[38;5;%p1%d;48;5;%p2%dm",
+		AltChars:     "+C,D-A.B0E``aaffgghFiGjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		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:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[2~",
+		KeyDelete:    "\x1b[3~",
+		KeyBackspace: "\u007f",
+		KeyHome:      "\x1b[7~",
+		KeyEnd:       "\x1b[8~",
+		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",
+		KeyShfUp:     "\x1b[a",
+		KeyShfDown:   "\x1b[b",
+		KeyCtrlLeft:  "\x1b[Od",
+		KeyCtrlRight: "\x1b[Oc",
+		KeyCtrlUp:    "\x1b[Oa",
+		KeyCtrlDown:  "\x1b[Ob",
+		KeyShfHome:   "\x1b[7$",
+		KeyShfEnd:    "\x1b[8$",
+		KeyCtrlHome:  "\x1b[7^",
+		KeyCtrlEnd:   "\x1b[8^",
+	})
+
+	// rxvt-unicode terminal with 256 colors (X Window System)
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "rxvt-unicode-256color",
+		Columns:      80,
+		Lines:        24,
+		Colors:       256,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[2J",
+		EnterCA:      "\x1b[?1049h",
+		ExitCA:       "\x1b[r\x1b[?1049l",
+		ShowCursor:   "\x1b[?12l\x1b[?25h",
+		HideCursor:   "\x1b[?25l",
+		AttrOff:      "\x1b[m\x1b(B",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Italic:       "\x1b[3m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		EnterKeypad:  "\x1b=",
+		ExitKeypad:   "\x1b>",
+		SetFg:        "\x1b[38;5;%p1%dm",
+		SetBg:        "\x1b[48;5;%p1%dm",
+		SetFgBg:      "\x1b[38;5;%p1%d;48;5;%p2%dm",
+		AltChars:     "+C,D-A.B0E``aaffgghFiGjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		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:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[2~",
+		KeyDelete:    "\x1b[3~",
+		KeyBackspace: "\u007f",
+		KeyHome:      "\x1b[7~",
+		KeyEnd:       "\x1b[8~",
+		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",
+		KeyShfUp:     "\x1b[a",
+		KeyShfDown:   "\x1b[b",
+		KeyCtrlLeft:  "\x1b[Od",
+		KeyCtrlRight: "\x1b[Oc",
+		KeyCtrlUp:    "\x1b[Oa",
+		KeyCtrlDown:  "\x1b[Ob",
+		KeyShfHome:   "\x1b[7$",
+		KeyShfEnd:    "\x1b[8$",
+		KeyCtrlHome:  "\x1b[7^",
+		KeyCtrlEnd:   "\x1b[8^",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/s/screen/term.go

@@ -0,0 +1,126 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package screen
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// VT 100/ANSI X3.64 virtual terminal
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "screen",
+		Columns:      80,
+		Lines:        24,
+		Colors:       8,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[J",
+		EnterCA:      "\x1b[?1049h",
+		ExitCA:       "\x1b[?1049l",
+		ShowCursor:   "\x1b[34h\x1b[?25h",
+		HideCursor:   "\x1b[?25l",
+		AttrOff:      "\x1b[m\x0f",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Dim:          "\x1b[2m",
+		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:     "++,,--..00``aaffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		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: "\u007f",
+		KeyHome:      "\x1b[1~",
+		KeyEnd:       "\x1b[4~",
+		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~",
+		KeyBacktab:   "\x1b[Z",
+	})
+
+	// GNU Screen with 256 colors
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "screen-256color",
+		Columns:      80,
+		Lines:        24,
+		Colors:       256,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[J",
+		EnterCA:      "\x1b[?1049h",
+		ExitCA:       "\x1b[?1049l",
+		ShowCursor:   "\x1b[34h\x1b[?25h",
+		HideCursor:   "\x1b[?25l",
+		AttrOff:      "\x1b[m\x0f",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Dim:          "\x1b[2m",
+		Blink:        "\x1b[5m",
+		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",
+		PadChar:      "\x00",
+		AltChars:     "++,,--..00``aaffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		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: "\u007f",
+		KeyHome:      "\x1b[1~",
+		KeyEnd:       "\x1b[4~",
+		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~",
+		KeyBacktab:   "\x1b[Z",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/s/simpleterm/term.go

@@ -0,0 +1,314 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package simpleterm
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	//  simpleterm
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:            "st",
+		Aliases:         []string{"stterm"},
+		Columns:         80,
+		Lines:           24,
+		Colors:          8,
+		Bell:            "\a",
+		Clear:           "\x1b[H\x1b[2J",
+		EnterCA:         "\x1b[?1049h",
+		ExitCA:          "\x1b[?1049l",
+		ShowCursor:      "\x1b[?12l\x1b[?25h",
+		HideCursor:      "\x1b[?25l",
+		AttrOff:         "\x1b[0m",
+		Underline:       "\x1b[4m",
+		Bold:            "\x1b[1m",
+		Dim:             "\x1b[2m",
+		Italic:          "\x1b[3m",
+		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",
+		AltChars:        "+C,D-A.B0E``aaffgghFiGjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		EnterAcs:        "\x1b(0",
+		ExitAcs:         "\x1b(B",
+		EnableAcs:       "\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:       "\x1b[A",
+		KeyUp:           "\x1bOA",
+		KeyDown:         "\x1bOB",
+		KeyRight:        "\x1bOC",
+		KeyLeft:         "\x1bOD",
+		KeyInsert:       "\x1b[2~",
+		KeyDelete:       "\x1b[3~",
+		KeyBackspace:    "\u007f",
+		KeyHome:         "\x1b[1~",
+		KeyEnd:          "\x1b[4~",
+		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",
+		KeyClear:        "\x1b[3;5~",
+		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",
+		KeyShfPgUp:      "\x1b[5;2~",
+		KeyShfPgDn:      "\x1b[6;2~",
+	})
+
+	// simpleterm with 256 colors
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:            "st-256color",
+		Aliases:         []string{"stterm-256color"},
+		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[0m",
+		Underline:       "\x1b[4m",
+		Bold:            "\x1b[1m",
+		Dim:             "\x1b[2m",
+		Italic:          "\x1b[3m",
+		Blink:           "\x1b[5m",
+		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:        "+C,D-A.B0E``aaffgghFiGjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		EnterAcs:        "\x1b(0",
+		ExitAcs:         "\x1b(B",
+		EnableAcs:       "\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:       "\x1b[A",
+		KeyUp:           "\x1bOA",
+		KeyDown:         "\x1bOB",
+		KeyRight:        "\x1bOC",
+		KeyLeft:         "\x1bOD",
+		KeyInsert:       "\x1b[2~",
+		KeyDelete:       "\x1b[3~",
+		KeyBackspace:    "\u007f",
+		KeyHome:         "\x1b[1~",
+		KeyEnd:          "\x1b[4~",
+		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",
+		KeyClear:        "\x1b[3;5~",
+		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",
+		KeyShfPgUp:      "\x1b[5;2~",
+		KeyShfPgDn:      "\x1b[6;2~",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/s/sun/term.go

@@ -0,0 +1,90 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package sun
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// Sun Microsystems Inc. workstation console
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "sun",
+		Aliases:      []string{"sun1", "sun2"},
+		Columns:      80,
+		Lines:        34,
+		Bell:         "\a",
+		Clear:        "\f",
+		AttrOff:      "\x1b[m",
+		Reverse:      "\x1b[7m",
+		PadChar:      "\x00",
+		SetCursor:    "\x1b[%i%p1%d;%p2%dH",
+		CursorBack1:  "\b",
+		CursorUp1:    "\x1b[A",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[247z",
+		KeyDelete:    "\u007f",
+		KeyBackspace: "\b",
+		KeyHome:      "\x1b[214z",
+		KeyEnd:       "\x1b[220z",
+		KeyPgUp:      "\x1b[216z",
+		KeyPgDn:      "\x1b[222z",
+		KeyF1:        "\x1b[224z",
+		KeyF2:        "\x1b[225z",
+		KeyF3:        "\x1b[226z",
+		KeyF4:        "\x1b[227z",
+		KeyF5:        "\x1b[228z",
+		KeyF6:        "\x1b[229z",
+		KeyF7:        "\x1b[230z",
+		KeyF8:        "\x1b[231z",
+		KeyF9:        "\x1b[232z",
+		KeyF10:       "\x1b[233z",
+		KeyF11:       "\x1b[234z",
+		KeyF12:       "\x1b[235z",
+	})
+
+	// Sun Microsystems Workstation console with color support (IA systems)
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "sun-color",
+		Columns:      80,
+		Lines:        34,
+		Colors:       8,
+		Bell:         "\a",
+		Clear:        "\f",
+		AttrOff:      "\x1b[m",
+		Bold:         "\x1b[1m",
+		Reverse:      "\x1b[7m",
+		SetFg:        "\x1b[3%p1%dm",
+		SetBg:        "\x1b[4%p1%dm",
+		SetFgBg:      "\x1b[3%p1%d;4%p2%dm",
+		PadChar:      "\x00",
+		SetCursor:    "\x1b[%i%p1%d;%p2%dH",
+		CursorBack1:  "\b",
+		CursorUp1:    "\x1b[A",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[247z",
+		KeyDelete:    "\u007f",
+		KeyBackspace: "\b",
+		KeyHome:      "\x1b[214z",
+		KeyEnd:       "\x1b[220z",
+		KeyPgUp:      "\x1b[216z",
+		KeyPgDn:      "\x1b[222z",
+		KeyF1:        "\x1b[224z",
+		KeyF2:        "\x1b[225z",
+		KeyF3:        "\x1b[226z",
+		KeyF4:        "\x1b[227z",
+		KeyF5:        "\x1b[228z",
+		KeyF6:        "\x1b[229z",
+		KeyF7:        "\x1b[230z",
+		KeyF8:        "\x1b[231z",
+		KeyF9:        "\x1b[232z",
+		KeyF10:       "\x1b[233z",
+		KeyF11:       "\x1b[234z",
+		KeyF12:       "\x1b[235z",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/t/termite/term.go

@@ -0,0 +1,157 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package termite
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// VTE-based terminal
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:            "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",
+		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:    "\u007f",
+		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",
+		KeyShfPgUp:      "\x1b[5;2~",
+		KeyShfPgDn:      "\x1b[6;2~",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/t/tvi910/term.go

@@ -0,0 +1,39 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package tvi910
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// televideo model 910
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "tvi910",
+		Columns:      80,
+		Lines:        24,
+		Bell:         "\a",
+		Clear:        "\x1a",
+		AttrOff:      "\x1bG0",
+		Underline:    "\x1bG8",
+		Reverse:      "\x1bG4",
+		PadChar:      "\x00",
+		SetCursor:    "\x1b=%p1%' '%+%c%p2%' '%+%c",
+		CursorBack1:  "\b",
+		CursorUp1:    "\v",
+		KeyUp:        "\v",
+		KeyDown:      "\n",
+		KeyRight:     "\f",
+		KeyLeft:      "\b",
+		KeyBackspace: "\b",
+		KeyHome:      "\x1e",
+		KeyF1:        "\x01@\r",
+		KeyF2:        "\x01A\r",
+		KeyF3:        "\x01B\r",
+		KeyF4:        "\x01C\r",
+		KeyF5:        "\x01D\r",
+		KeyF6:        "\x01E\r",
+		KeyF7:        "\x01F\r",
+		KeyF8:        "\x01G\r",
+		KeyF9:        "\x01H\r",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/t/tvi912/term.go

@@ -0,0 +1,38 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package tvi912
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// old televideo 912/914/920
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "tvi912",
+		Aliases:      []string{"tvi914", "tvi920"},
+		Columns:      80,
+		Lines:        24,
+		Bell:         "\a",
+		Clear:        "\x1a",
+		Underline:    "\x1bl",
+		PadChar:      "\x00",
+		SetCursor:    "\x1b=%p1%' '%+%c%p2%' '%+%c",
+		CursorBack1:  "\b",
+		CursorUp1:    "\v",
+		KeyUp:        "\v",
+		KeyDown:      "\n",
+		KeyRight:     "\f",
+		KeyLeft:      "\b",
+		KeyBackspace: "\b",
+		KeyHome:      "\x1e",
+		KeyF1:        "\x01@\r",
+		KeyF2:        "\x01A\r",
+		KeyF3:        "\x01B\r",
+		KeyF4:        "\x01C\r",
+		KeyF5:        "\x01D\r",
+		KeyF6:        "\x01E\r",
+		KeyF7:        "\x01F\r",
+		KeyF8:        "\x01G\r",
+		KeyF9:        "\x01H\r",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/t/tvi921/term.go

@@ -0,0 +1,34 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package tvi921
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// televideo model 921 with sysline same as page & real vi function
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "tvi921",
+		Columns:      80,
+		Lines:        24,
+		Clear:        "\x1a",
+		ShowCursor:   "\x1b.3",
+		AttrOff:      "\x1bG0",
+		Underline:    "\x1bG8",
+		Reverse:      "\x1bG4",
+		PadChar:      "\x00",
+		EnterAcs:     "\x1b$",
+		ExitAcs:      "\x1b%%",
+		SetCursor:    "\x1b=%p1%' '%+%c%p2%' '%+%c$<3/>",
+		CursorBack1:  "\b",
+		CursorUp1:    "\v",
+		KeyUp:        "\v",
+		KeyDown:      "\x16",
+		KeyRight:     "\f",
+		KeyLeft:      "\b",
+		KeyInsert:    "\x1bQ",
+		KeyDelete:    "\x1bW",
+		KeyBackspace: "\b",
+		KeyClear:     "\x1a",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/t/tvi925/term.go

@@ -0,0 +1,43 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package tvi925
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// televideo 925
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "tvi925",
+		Columns:      80,
+		Lines:        24,
+		Bell:         "\a",
+		Clear:        "\x1a",
+		ShowCursor:   "\x1b.4",
+		AttrOff:      "\x1bG0",
+		Underline:    "\x1bG8",
+		Reverse:      "\x1bG4",
+		PadChar:      "\x00",
+		SetCursor:    "\x1b=%p1%' '%+%c%p2%' '%+%c",
+		CursorBack1:  "\b",
+		CursorUp1:    "\v",
+		KeyUp:        "\v",
+		KeyDown:      "\x16",
+		KeyRight:     "\f",
+		KeyLeft:      "\b",
+		KeyInsert:    "\x1bQ",
+		KeyDelete:    "\x1bW",
+		KeyBackspace: "\b",
+		KeyHome:      "\x1e",
+		KeyF1:        "\x01@\r",
+		KeyF2:        "\x01A\r",
+		KeyF3:        "\x01B\r",
+		KeyF4:        "\x01C\r",
+		KeyF5:        "\x01D\r",
+		KeyF6:        "\x01E\r",
+		KeyF7:        "\x01F\r",
+		KeyF8:        "\x01G\r",
+		KeyF9:        "\x01H\r",
+		KeyClear:     "\x1a",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/t/tvi950/term.go

@@ -0,0 +1,46 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package tvi950
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// televideo 950
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "tvi950",
+		Columns:      80,
+		Lines:        24,
+		Bell:         "\a",
+		Clear:        "\x1b*",
+		AttrOff:      "\x1bG0",
+		Underline:    "\x1bG8",
+		Reverse:      "\x1bG4",
+		PadChar:      "\x00",
+		AltChars:     "b\tc\fd\re\ni\v",
+		EnterAcs:     "\x15",
+		ExitAcs:      "\x18",
+		SetCursor:    "\x1b=%p1%' '%+%c%p2%' '%+%c",
+		CursorBack1:  "\b",
+		CursorUp1:    "\v",
+		KeyUp:        "\v",
+		KeyDown:      "\x16",
+		KeyRight:     "\f",
+		KeyLeft:      "\b",
+		KeyInsert:    "\x1bQ",
+		KeyDelete:    "\x1bW",
+		KeyBackspace: "\b",
+		KeyHome:      "\x1e",
+		KeyF1:        "\x01@\r",
+		KeyF2:        "\x01A\r",
+		KeyF3:        "\x01B\r",
+		KeyF4:        "\x01C\r",
+		KeyF5:        "\x01D\r",
+		KeyF6:        "\x01E\r",
+		KeyF7:        "\x01F\r",
+		KeyF8:        "\x01G\r",
+		KeyF9:        "\x01H\r",
+		KeyClear:     "\x1b*",
+		KeyBacktab:   "\x1bI",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/t/tvi970/term.go

@@ -0,0 +1,40 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package tvi970
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// televideo 970
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "tvi970",
+		Columns:      80,
+		Lines:        24,
+		Clear:        "\x1b[H\x1b[2J",
+		EnterCA:      "\x1b[?20l\x1b[?7h\x1b[1Q",
+		AttrOff:      "\x1b[m",
+		Underline:    "\x1b[4m",
+		PadChar:      "\x00",
+		EnterAcs:     "\x1b(B",
+		ExitAcs:      "\x1b(B",
+		SetCursor:    "\x1b[%i%p1%d;%p2%df",
+		CursorBack1:  "\b",
+		CursorUp1:    "\x1bM",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyBackspace: "\b",
+		KeyHome:      "\x1b[H",
+		KeyF1:        "\x1b?a",
+		KeyF2:        "\x1b?b",
+		KeyF3:        "\x1b?c",
+		KeyF4:        "\x1b?d",
+		KeyF5:        "\x1b?e",
+		KeyF6:        "\x1b?f",
+		KeyF7:        "\x1b?g",
+		KeyF8:        "\x1b?h",
+		KeyF9:        "\x1b?i",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/terminfo.go

@@ -0,0 +1,784 @@
+// Copyright 2019 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.
+
+package terminfo
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+var (
+	// ErrTermNotFound indicates that a suitable terminal entry could
+	// not be found.  This can result from either not having TERM set,
+	// or from the TERM failing to support certain minimal functionality,
+	// in particular absolute cursor addressability (the cup capability)
+	// is required.  For example, legacy "adm3" lacks this capability,
+	// whereas the slightly newer "adm3a" supports it.  This failure
+	// occurs most often with "dumb".
+	ErrTermNotFound = errors.New("terminal entry not found")
+)
+
+// Terminfo represents a terminfo entry.  Note that we use friendly names
+// in Go, but when we write out JSON, we use the same names as terminfo.
+// The name, aliases and smous, rmous fields do not come from terminfo directly.
+type Terminfo struct {
+	Name         string
+	Aliases      []string
+	Columns      int    // cols
+	Lines        int    // lines
+	Colors       int    // colors
+	Bell         string // bell
+	Clear        string // clear
+	EnterCA      string // smcup
+	ExitCA       string // rmcup
+	ShowCursor   string // cnorm
+	HideCursor   string // civis
+	AttrOff      string // sgr0
+	Underline    string // smul
+	Bold         string // bold
+	Blink        string // blink
+	Reverse      string // rev
+	Dim          string // dim
+	Italic       string // sitm
+	EnterKeypad  string // smkx
+	ExitKeypad   string // rmkx
+	SetFg        string // setaf
+	SetBg        string // setab
+	SetCursor    string // cup
+	CursorBack1  string // cub1
+	CursorUp1    string // cuu1
+	PadChar      string // pad
+	KeyBackspace string // kbs
+	KeyF1        string // kf1
+	KeyF2        string // kf2
+	KeyF3        string // kf3
+	KeyF4        string // kf4
+	KeyF5        string // kf5
+	KeyF6        string // kf6
+	KeyF7        string // kf7
+	KeyF8        string // kf8
+	KeyF9        string // kf9
+	KeyF10       string // kf10
+	KeyF11       string // kf11
+	KeyF12       string // kf12
+	KeyF13       string // kf13
+	KeyF14       string // kf14
+	KeyF15       string // kf15
+	KeyF16       string // kf16
+	KeyF17       string // kf17
+	KeyF18       string // kf18
+	KeyF19       string // kf19
+	KeyF20       string // kf20
+	KeyF21       string // kf21
+	KeyF22       string // kf22
+	KeyF23       string // kf23
+	KeyF24       string // kf24
+	KeyF25       string // kf25
+	KeyF26       string // kf26
+	KeyF27       string // kf27
+	KeyF28       string // kf28
+	KeyF29       string // kf29
+	KeyF30       string // kf30
+	KeyF31       string // kf31
+	KeyF32       string // kf32
+	KeyF33       string // kf33
+	KeyF34       string // kf34
+	KeyF35       string // kf35
+	KeyF36       string // kf36
+	KeyF37       string // kf37
+	KeyF38       string // kf38
+	KeyF39       string // kf39
+	KeyF40       string // kf40
+	KeyF41       string // kf41
+	KeyF42       string // kf42
+	KeyF43       string // kf43
+	KeyF44       string // kf44
+	KeyF45       string // kf45
+	KeyF46       string // kf46
+	KeyF47       string // kf47
+	KeyF48       string // kf48
+	KeyF49       string // kf49
+	KeyF50       string // kf50
+	KeyF51       string // kf51
+	KeyF52       string // kf52
+	KeyF53       string // kf53
+	KeyF54       string // kf54
+	KeyF55       string // kf55
+	KeyF56       string // kf56
+	KeyF57       string // kf57
+	KeyF58       string // kf58
+	KeyF59       string // kf59
+	KeyF60       string // kf60
+	KeyF61       string // kf61
+	KeyF62       string // kf62
+	KeyF63       string // kf63
+	KeyF64       string // kf64
+	KeyInsert    string // kich1
+	KeyDelete    string // kdch1
+	KeyHome      string // khome
+	KeyEnd       string // kend
+	KeyHelp      string // khlp
+	KeyPgUp      string // kpp
+	KeyPgDn      string // knp
+	KeyUp        string // kcuu1
+	KeyDown      string // kcud1
+	KeyLeft      string // kcub1
+	KeyRight     string // kcuf1
+	KeyBacktab   string // kcbt
+	KeyExit      string // kext
+	KeyClear     string // kclr
+	KeyPrint     string // kprt
+	KeyCancel    string // kcan
+	Mouse        string // kmous
+	MouseMode    string // XM
+	AltChars     string // acsc
+	EnterAcs     string // smacs
+	ExitAcs      string // rmacs
+	EnableAcs    string // enacs
+	KeyShfRight  string // kRIT
+	KeyShfLeft   string // kLFT
+	KeyShfHome   string // kHOM
+	KeyShfEnd    string // kEND
+
+	// These are non-standard extensions to terminfo.  This includes
+	// true color support, and some additional keys.  Its kind of bizarre
+	// that shifted variants of left and right exist, but not up and down.
+	// Terminal support for these are going to vary amongst XTerm
+	// emulations, so don't depend too much on them in your application.
+
+	SetFgBg         string // setfgbg
+	SetFgBgRGB      string // setfgbgrgb
+	SetFgRGB        string // setfrgb
+	SetBgRGB        string // setbrgb
+	KeyShfUp        string // shift-up
+	KeyShfDown      string // shift-down
+	KeyShfPgUp      string // shift-kpp
+	KeyShfPgDn      string // shift-knp
+	KeyCtrlUp       string // ctrl-up
+	KeyCtrlDown     string // ctrl-left
+	KeyCtrlRight    string // ctrl-right
+	KeyCtrlLeft     string // ctrl-left
+	KeyMetaUp       string // meta-up
+	KeyMetaDown     string // meta-left
+	KeyMetaRight    string // meta-right
+	KeyMetaLeft     string // meta-left
+	KeyAltUp        string // alt-up
+	KeyAltDown      string // alt-left
+	KeyAltRight     string // alt-right
+	KeyAltLeft      string // alt-left
+	KeyCtrlHome     string
+	KeyCtrlEnd      string
+	KeyMetaHome     string
+	KeyMetaEnd      string
+	KeyAltHome      string
+	KeyAltEnd       string
+	KeyAltShfUp     string
+	KeyAltShfDown   string
+	KeyAltShfLeft   string
+	KeyAltShfRight  string
+	KeyMetaShfUp    string
+	KeyMetaShfDown  string
+	KeyMetaShfLeft  string
+	KeyMetaShfRight string
+	KeyCtrlShfUp    string
+	KeyCtrlShfDown  string
+	KeyCtrlShfLeft  string
+	KeyCtrlShfRight string
+	KeyCtrlShfHome  string
+	KeyCtrlShfEnd   string
+	KeyAltShfHome   string
+	KeyAltShfEnd    string
+	KeyMetaShfHome  string
+	KeyMetaShfEnd   string
+}
+
+type stackElem struct {
+	s     string
+	i     int
+	isStr bool
+	isInt bool
+}
+
+type stack []stackElem
+
+func (st stack) Push(v string) stack {
+	e := stackElem{
+		s:     v,
+		isStr: true,
+	}
+	return append(st, e)
+}
+
+func (st stack) Pop() (string, stack) {
+	v := ""
+	if len(st) > 0 {
+		e := st[len(st)-1]
+		st = st[:len(st)-1]
+		if e.isStr {
+			v = e.s
+		} else {
+			v = strconv.Itoa(e.i)
+		}
+	}
+	return v, st
+}
+
+func (st stack) PopInt() (int, stack) {
+	if len(st) > 0 {
+		e := st[len(st)-1]
+		st = st[:len(st)-1]
+		if e.isInt {
+			return e.i, st
+		} else if e.isStr {
+			i, _ := strconv.Atoi(e.s)
+			return i, st
+		}
+	}
+	return 0, st
+}
+
+func (st stack) PopBool() (bool, stack) {
+	if len(st) > 0 {
+		e := st[len(st)-1]
+		st = st[:len(st)-1]
+		if e.isStr {
+			if e.s == "1" {
+				return true, st
+			}
+			return false, st
+		} else if e.i == 1 {
+			return true, st
+		} else {
+			return false, st
+		}
+	}
+	return false, st
+}
+
+func (st stack) PushInt(i int) stack {
+	e := stackElem{
+		i:     i,
+		isInt: true,
+	}
+	return append(st, e)
+}
+
+func (st stack) PushBool(i bool) stack {
+	if i {
+		return st.PushInt(1)
+	}
+	return st.PushInt(0)
+}
+
+func nextch(s string, index int) (byte, int) {
+	if index < len(s) {
+		return s[index], index + 1
+	}
+	return 0, index
+}
+
+// static vars
+var svars [26]string
+
+// paramsBuffer handles some persistent state for TParam.  Technically we
+// could probably dispense with this, but caching buffer arrays gives us
+// a nice little performance boost.  Furthermore, we know that TParam is
+// rarely (never?) called re-entrantly, so we can just reuse the same
+// buffers, making it thread-safe by stashing a lock.
+type paramsBuffer struct {
+	out bytes.Buffer
+	buf bytes.Buffer
+	lk  sync.Mutex
+}
+
+// Start initializes the params buffer with the initial string data.
+// It also locks the paramsBuffer.  The caller must call End() when
+// finished.
+func (pb *paramsBuffer) Start(s string) {
+	pb.lk.Lock()
+	pb.out.Reset()
+	pb.buf.Reset()
+	pb.buf.WriteString(s)
+}
+
+// End returns the final output from TParam, but it also releases the lock.
+func (pb *paramsBuffer) End() string {
+	s := pb.out.String()
+	pb.lk.Unlock()
+	return s
+}
+
+// NextCh returns the next input character to the expander.
+func (pb *paramsBuffer) NextCh() (byte, error) {
+	return pb.buf.ReadByte()
+}
+
+// PutCh "emits" (rather schedules for output) a single byte character.
+func (pb *paramsBuffer) PutCh(ch byte) {
+	pb.out.WriteByte(ch)
+}
+
+// PutString schedules a string for output.
+func (pb *paramsBuffer) PutString(s string) {
+	pb.out.WriteString(s)
+}
+
+var pb = &paramsBuffer{}
+
+// TParm takes a terminfo parameterized string, such as setaf or cup, and
+// evaluates the string, and returns the result with the parameter
+// applied.
+func (t *Terminfo) TParm(s string, p ...int) string {
+	var stk stack
+	var a, b string
+	var ai, bi int
+	var ab bool
+	var dvars [26]string
+	var params [9]int
+
+	pb.Start(s)
+
+	// make sure we always have 9 parameters -- makes it easier
+	// later to skip checks
+	for i := 0; i < len(params) && i < len(p); i++ {
+		params[i] = p[i]
+	}
+
+	nest := 0
+
+	for {
+
+		ch, err := pb.NextCh()
+		if err != nil {
+			break
+		}
+
+		if ch != '%' {
+			pb.PutCh(ch)
+			continue
+		}
+
+		ch, err = pb.NextCh()
+		if err != nil {
+			// XXX Error
+			break
+		}
+
+		switch ch {
+		case '%': // quoted %
+			pb.PutCh(ch)
+
+		case 'i': // increment both parameters (ANSI cup support)
+			params[0]++
+			params[1]++
+
+		case 'c', 's':
+			// NB: these, and 'd' below are special cased for
+			// efficiency.  They could be handled by the richer
+			// format support below, less efficiently.
+			a, stk = stk.Pop()
+			pb.PutString(a)
+
+		case 'd':
+			ai, stk = stk.PopInt()
+			pb.PutString(strconv.Itoa(ai))
+
+		case '0', '1', '2', '3', '4', 'x', 'X', 'o', ':':
+			// This is pretty suboptimal, but this is rarely used.
+			// None of the mainstream terminals use any of this,
+			// and it would surprise me if this code is ever
+			// executed outside of test cases.
+			f := "%"
+			if ch == ':' {
+				ch, _ = pb.NextCh()
+			}
+			f += string(ch)
+			for ch == '+' || ch == '-' || ch == '#' || ch == ' ' {
+				ch, _ = pb.NextCh()
+				f += string(ch)
+			}
+			for (ch >= '0' && ch <= '9') || ch == '.' {
+				ch, _ = pb.NextCh()
+				f += string(ch)
+			}
+			switch ch {
+			case 'd', 'x', 'X', 'o':
+				ai, stk = stk.PopInt()
+				pb.PutString(fmt.Sprintf(f, ai))
+			case 'c', 's':
+				a, stk = stk.Pop()
+				pb.PutString(fmt.Sprintf(f, a))
+			}
+
+		case 'p': // push parameter
+			ch, _ = pb.NextCh()
+			ai = int(ch - '1')
+			if ai >= 0 && ai < len(params) {
+				stk = stk.PushInt(params[ai])
+			} else {
+				stk = stk.PushInt(0)
+			}
+
+		case 'P': // pop & store variable
+			ch, _ = pb.NextCh()
+			if ch >= 'A' && ch <= 'Z' {
+				svars[int(ch-'A')], stk = stk.Pop()
+			} else if ch >= 'a' && ch <= 'z' {
+				dvars[int(ch-'a')], stk = stk.Pop()
+			}
+
+		case 'g': // recall & push variable
+			ch, _ = pb.NextCh()
+			if ch >= 'A' && ch <= 'Z' {
+				stk = stk.Push(svars[int(ch-'A')])
+			} else if ch >= 'a' && ch <= 'z' {
+				stk = stk.Push(dvars[int(ch-'a')])
+			}
+
+		case '\'': // push(char)
+			ch, _ = pb.NextCh()
+			pb.NextCh() // must be ' but we don't check
+			stk = stk.Push(string(ch))
+
+		case '{': // push(int)
+			ai = 0
+			ch, _ = pb.NextCh()
+			for ch >= '0' && ch <= '9' {
+				ai *= 10
+				ai += int(ch - '0')
+				ch, _ = pb.NextCh()
+			}
+			// ch must be '}' but no verification
+			stk = stk.PushInt(ai)
+
+		case 'l': // push(strlen(pop))
+			a, stk = stk.Pop()
+			stk = stk.PushInt(len(a))
+
+		case '+':
+			bi, stk = stk.PopInt()
+			ai, stk = stk.PopInt()
+			stk = stk.PushInt(ai + bi)
+
+		case '-':
+			bi, stk = stk.PopInt()
+			ai, stk = stk.PopInt()
+			stk = stk.PushInt(ai - bi)
+
+		case '*':
+			bi, stk = stk.PopInt()
+			ai, stk = stk.PopInt()
+			stk = stk.PushInt(ai * bi)
+
+		case '/':
+			bi, stk = stk.PopInt()
+			ai, stk = stk.PopInt()
+			if bi != 0 {
+				stk = stk.PushInt(ai / bi)
+			} else {
+				stk = stk.PushInt(0)
+			}
+
+		case 'm': // push(pop mod pop)
+			bi, stk = stk.PopInt()
+			ai, stk = stk.PopInt()
+			if bi != 0 {
+				stk = stk.PushInt(ai % bi)
+			} else {
+				stk = stk.PushInt(0)
+			}
+
+		case '&': // AND
+			bi, stk = stk.PopInt()
+			ai, stk = stk.PopInt()
+			stk = stk.PushInt(ai & bi)
+
+		case '|': // OR
+			bi, stk = stk.PopInt()
+			ai, stk = stk.PopInt()
+			stk = stk.PushInt(ai | bi)
+
+		case '^': // XOR
+			bi, stk = stk.PopInt()
+			ai, stk = stk.PopInt()
+			stk = stk.PushInt(ai ^ bi)
+
+		case '~': // bit complement
+			ai, stk = stk.PopInt()
+			stk = stk.PushInt(ai ^ -1)
+
+		case '!': // logical NOT
+			ai, stk = stk.PopInt()
+			stk = stk.PushBool(ai != 0)
+
+		case '=': // numeric compare or string compare
+			b, stk = stk.Pop()
+			a, stk = stk.Pop()
+			stk = stk.PushBool(a == b)
+
+		case '>': // greater than, numeric
+			bi, stk = stk.PopInt()
+			ai, stk = stk.PopInt()
+			stk = stk.PushBool(ai > bi)
+
+		case '<': // less than, numeric
+			bi, stk = stk.PopInt()
+			ai, stk = stk.PopInt()
+			stk = stk.PushBool(ai < bi)
+
+		case '?': // start conditional
+
+		case 't':
+			ab, stk = stk.PopBool()
+			if ab {
+				// just keep going
+				break
+			}
+			nest = 0
+		ifloop:
+			// this loop consumes everything until we hit our else,
+			// or the end of the conditional
+			for {
+				ch, err = pb.NextCh()
+				if err != nil {
+					break
+				}
+				if ch != '%' {
+					continue
+				}
+				ch, _ = pb.NextCh()
+				switch ch {
+				case ';':
+					if nest == 0 {
+						break ifloop
+					}
+					nest--
+				case '?':
+					nest++
+				case 'e':
+					if nest == 0 {
+						break ifloop
+					}
+				}
+			}
+
+		case 'e':
+			// if we got here, it means we didn't use the else
+			// in the 't' case above, and we should skip until
+			// the end of the conditional
+			nest = 0
+		elloop:
+			for {
+				ch, err = pb.NextCh()
+				if err != nil {
+					break
+				}
+				if ch != '%' {
+					continue
+				}
+				ch, _ = pb.NextCh()
+				switch ch {
+				case ';':
+					if nest == 0 {
+						break elloop
+					}
+					nest--
+				case '?':
+					nest++
+				}
+			}
+
+		case ';': // endif
+
+		}
+	}
+
+	return pb.End()
+}
+
+// TPuts emits the string to the writer, but expands inline padding
+// indications (of the form $<[delay]> where [delay] is msec) to
+// a suitable time (unless the terminfo string indicates this isn't needed
+// by specifying npc - no padding).  All Terminfo based strings should be
+// emitted using this function.
+func (t *Terminfo) TPuts(w io.Writer, s string) {
+	for {
+		beg := strings.Index(s, "$<")
+		if beg < 0 {
+			// Most strings don't need padding, which is good news!
+			io.WriteString(w, s)
+			return
+		}
+		io.WriteString(w, s[:beg])
+		s = s[beg+2:]
+		end := strings.Index(s, ">")
+		if end < 0 {
+			// unterminated.. just emit bytes unadulterated
+			io.WriteString(w, "$<"+s)
+			return
+		}
+		val := s[:end]
+		s = s[end+1:]
+		padus := 0
+		unit := time.Millisecond
+		dot := false
+	loop:
+		for i := range val {
+			switch val[i] {
+			case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+				padus *= 10
+				padus += int(val[i] - '0')
+				if dot {
+					unit /= 10
+				}
+			case '.':
+				if !dot {
+					dot = true
+				} else {
+					break loop
+				}
+			default:
+				break loop
+			}
+		}
+
+		// Curses historically uses padding to achieve "fine grained"
+		// delays. We have much better clocks these days, and so we
+		// do not rely on padding but simply sleep a bit.
+		if len(t.PadChar) > 0 {
+			time.Sleep(unit * time.Duration(padus))
+		}
+	}
+}
+
+// TGoto returns a string suitable for addressing the cursor at the given
+// row and column.  The origin 0, 0 is in the upper left corner of the screen.
+func (t *Terminfo) TGoto(col, row int) string {
+	return t.TParm(t.SetCursor, row, col)
+}
+
+// TColor returns a string corresponding to the given foreground and background
+// colors.  Either fg or bg can be set to -1 to elide.
+func (t *Terminfo) TColor(fi, bi int) string {
+	rv := ""
+	// As a special case, we map bright colors to lower versions if the
+	// color table only holds 8.  For the remaining 240 colors, the user
+	// is out of luck.  Someday we could create a mapping table, but its
+	// not worth it.
+	if t.Colors == 8 {
+		if fi > 7 && fi < 16 {
+			fi -= 8
+		}
+		if bi > 7 && bi < 16 {
+			bi -= 8
+		}
+	}
+	if t.Colors > fi && fi >= 0 {
+		rv += t.TParm(t.SetFg, fi)
+	}
+	if t.Colors > bi && bi >= 0 {
+		rv += t.TParm(t.SetBg, bi)
+	}
+	return rv
+}
+
+var (
+	dblock    sync.Mutex
+	terminfos = make(map[string]*Terminfo)
+	aliases   = make(map[string]string)
+)
+
+// AddTerminfo can be called to register a new Terminfo entry.
+func AddTerminfo(t *Terminfo) {
+	dblock.Lock()
+	terminfos[t.Name] = t
+	for _, x := range t.Aliases {
+		terminfos[x] = t
+	}
+	dblock.Unlock()
+}
+
+// LookupTerminfo attempts to find a definition for the named $TERM.
+func LookupTerminfo(name string) (*Terminfo, error) {
+	if name == "" {
+		// else on windows: index out of bounds
+		// on the name[0] reference below
+		return nil, ErrTermNotFound
+	}
+
+	addtruecolor := false
+	switch os.Getenv("COLORTERM") {
+	case "truecolor", "24bit", "24-bit":
+		addtruecolor = true
+	}
+	dblock.Lock()
+	t := terminfos[name]
+	dblock.Unlock()
+
+	// If the name ends in -truecolor, then fabricate an entry
+	// from the corresponding -256color, -color, or bare terminal.
+	if t == nil && strings.HasSuffix(name, "-truecolor") {
+
+		suffixes := []string{
+			"-256color",
+			"-88color",
+			"-color",
+			"",
+		}
+		base := name[:len(name)-len("-truecolor")]
+		for _, s := range suffixes {
+			if t, _ = LookupTerminfo(base + s); t != nil {
+				addtruecolor = true
+				break
+			}
+		}
+	}
+
+	if t == nil {
+		return nil, ErrTermNotFound
+	}
+
+	switch os.Getenv("TCELL_TRUECOLOR") {
+	case "":
+	case "disable":
+		addtruecolor = false
+	default:
+		addtruecolor = true
+	}
+
+	// If the user has requested 24-bit color with $COLORTERM, then
+	// amend the value (unless already present).  This means we don't
+	// need to have a value present.
+	if addtruecolor &&
+		t.SetFgBgRGB == "" &&
+		t.SetFgRGB == "" &&
+		t.SetBgRGB == "" {
+
+		// Supply vanilla ISO 8613-6:1994 24-bit color sequences.
+		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"
+	}
+
+	return t, nil
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/v/vt100/term.go

@@ -0,0 +1,48 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package vt100
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// dec vt100 (w/advanced video)
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "vt100",
+		Aliases:      []string{"vt100-am"},
+		Columns:      80,
+		Lines:        24,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[J$<50>",
+		AttrOff:      "\x1b[m\x0f$<2>",
+		Underline:    "\x1b[4m$<2>",
+		Bold:         "\x1b[1m$<2>",
+		Blink:        "\x1b[5m$<2>",
+		Reverse:      "\x1b[7m$<2>",
+		EnterKeypad:  "\x1b[?1h\x1b=",
+		ExitKeypad:   "\x1b[?1l\x1b>",
+		PadChar:      "\x00",
+		AltChars:     "``aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		EnterAcs:     "\x0e",
+		ExitAcs:      "\x0f",
+		EnableAcs:    "\x1b(B\x1b)0",
+		SetCursor:    "\x1b[%i%p1%d;%p2%dH$<5>",
+		CursorBack1:  "\b",
+		CursorUp1:    "\x1b[A$<2>",
+		KeyUp:        "\x1bOA",
+		KeyDown:      "\x1bOB",
+		KeyRight:     "\x1bOC",
+		KeyLeft:      "\x1bOD",
+		KeyBackspace: "\b",
+		KeyF1:        "\x1bOP",
+		KeyF2:        "\x1bOQ",
+		KeyF3:        "\x1bOR",
+		KeyF4:        "\x1bOS",
+		KeyF5:        "\x1bOt",
+		KeyF6:        "\x1bOu",
+		KeyF7:        "\x1bOv",
+		KeyF8:        "\x1bOl",
+		KeyF9:        "\x1bOw",
+		KeyF10:       "\x1bOx",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/v/vt102/term.go

@@ -0,0 +1,47 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package vt102
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// dec vt102
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "vt102",
+		Columns:      80,
+		Lines:        24,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[J$<50>",
+		AttrOff:      "\x1b[m\x0f$<2>",
+		Underline:    "\x1b[4m$<2>",
+		Bold:         "\x1b[1m$<2>",
+		Blink:        "\x1b[5m$<2>",
+		Reverse:      "\x1b[7m$<2>",
+		EnterKeypad:  "\x1b[?1h\x1b=",
+		ExitKeypad:   "\x1b[?1l\x1b>",
+		PadChar:      "\x00",
+		AltChars:     "``aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		EnterAcs:     "\x0e",
+		ExitAcs:      "\x0f",
+		EnableAcs:    "\x1b(B\x1b)0",
+		SetCursor:    "\x1b[%i%p1%d;%p2%dH$<5>",
+		CursorBack1:  "\b",
+		CursorUp1:    "\x1b[A$<2>",
+		KeyUp:        "\x1bOA",
+		KeyDown:      "\x1bOB",
+		KeyRight:     "\x1bOC",
+		KeyLeft:      "\x1bOD",
+		KeyBackspace: "\b",
+		KeyF1:        "\x1bOP",
+		KeyF2:        "\x1bOQ",
+		KeyF3:        "\x1bOR",
+		KeyF4:        "\x1bOS",
+		KeyF5:        "\x1bOt",
+		KeyF6:        "\x1bOu",
+		KeyF7:        "\x1bOv",
+		KeyF8:        "\x1bOl",
+		KeyF9:        "\x1bOw",
+		KeyF10:       "\x1bOx",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/v/vt220/term.go

@@ -0,0 +1,58 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package vt220
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// dec vt220
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "vt220",
+		Aliases:      []string{"vt200"},
+		Columns:      80,
+		Lines:        24,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[J",
+		AttrOff:      "\x1b[m\x1b(B",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		PadChar:      "\x00",
+		AltChars:     "``aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		EnterAcs:     "\x1b(0$<2>",
+		ExitAcs:      "\x1b(B$<4>",
+		EnableAcs:    "\x1b)0",
+		SetCursor:    "\x1b[%i%p1%d;%p2%dH",
+		CursorBack1:  "\b",
+		CursorUp1:    "\x1b[A",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[2~",
+		KeyDelete:    "\x1b[3~",
+		KeyBackspace: "\b",
+		KeyPgUp:      "\x1b[5~",
+		KeyPgDn:      "\x1b[6~",
+		KeyF1:        "\x1bOP",
+		KeyF2:        "\x1bOQ",
+		KeyF3:        "\x1bOR",
+		KeyF4:        "\x1bOS",
+		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~",
+		KeyF17:       "\x1b[31~",
+		KeyF18:       "\x1b[32~",
+		KeyF19:       "\x1b[33~",
+		KeyF20:       "\x1b[34~",
+		KeyHelp:      "\x1b[28~",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/v/vt320/term.go

@@ -0,0 +1,63 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package vt320
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// dec vt320 7 bit terminal
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "vt320",
+		Aliases:      []string{"vt300"},
+		Columns:      80,
+		Lines:        24,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[2J",
+		ShowCursor:   "\x1b[?25h",
+		HideCursor:   "\x1b[?25l",
+		AttrOff:      "\x1b[m\x1b(B",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		EnterKeypad:  "\x1b[?1h\x1b=",
+		ExitKeypad:   "\x1b[?1l\x1b>",
+		PadChar:      "\x00",
+		AltChars:     "``aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		EnterAcs:     "\x1b(0",
+		ExitAcs:      "\x1b(B",
+		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: "\u007f",
+		KeyHome:      "\x1b[1~",
+		KeyPgUp:      "\x1b[5~",
+		KeyPgDn:      "\x1b[6~",
+		KeyF1:        "\x1bOP",
+		KeyF2:        "\x1bOQ",
+		KeyF3:        "\x1bOR",
+		KeyF4:        "\x1bOS",
+		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~",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/v/vt400/term.go

@@ -0,0 +1,46 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package vt400
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// dec vt400 24x80 column autowrap
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "vt400",
+		Aliases:      []string{"vt400-24", "dec-vt400"},
+		Columns:      80,
+		Lines:        24,
+		Clear:        "\x1b[H\x1b[J$<10/>",
+		ShowCursor:   "\x1b[?25h",
+		HideCursor:   "\x1b[?25l",
+		AttrOff:      "\x1b[m\x1b(B",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		EnterKeypad:  "\x1b[?1h\x1b=",
+		ExitKeypad:   "\x1b[?1l\x1b>",
+		PadChar:      "\x00",
+		AltChars:     "``aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		EnterAcs:     "\x1b(0",
+		ExitAcs:      "\x1b(B",
+		SetCursor:    "\x1b[%i%p1%d;%p2%dH",
+		CursorBack1:  "\b",
+		CursorUp1:    "\x1b[A",
+		KeyUp:        "\x1bOA",
+		KeyDown:      "\x1bOB",
+		KeyRight:     "\x1bOC",
+		KeyLeft:      "\x1bOD",
+		KeyBackspace: "\b",
+		KeyF1:        "\x1bOP",
+		KeyF2:        "\x1bOQ",
+		KeyF3:        "\x1bOR",
+		KeyF4:        "\x1bOS",
+		KeyF6:        "\x1b[17~",
+		KeyF7:        "\x1b[18~",
+		KeyF8:        "\x1b[19~",
+		KeyF9:        "\x1b[20~",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/v/vt420/term.go

@@ -0,0 +1,53 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package vt420
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// DEC VT420
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "vt420",
+		Columns:      80,
+		Lines:        24,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[2J$<50>",
+		ShowCursor:   "\x1b[?25h",
+		HideCursor:   "\x1b[?25l",
+		AttrOff:      "\x1b[m\x1b(B$<2>",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m$<2>",
+		Blink:        "\x1b[5m$<2>",
+		Reverse:      "\x1b[7m$<2>",
+		EnterKeypad:  "\x1b=",
+		ExitKeypad:   "\x1b>",
+		PadChar:      "\x00",
+		AltChars:     "``aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		EnterAcs:     "\x1b(0$<2>",
+		ExitAcs:      "\x1b(B$<4>",
+		EnableAcs:    "\x1b)0",
+		SetCursor:    "\x1b[%i%p1%d;%p2%dH$<10>",
+		CursorBack1:  "\b",
+		CursorUp1:    "\x1b[A",
+		KeyUp:        "\x1b[A",
+		KeyDown:      "\x1b[B",
+		KeyRight:     "\x1b[C",
+		KeyLeft:      "\x1b[D",
+		KeyInsert:    "\x1b[2~",
+		KeyDelete:    "\x1b[3~",
+		KeyBackspace: "\b",
+		KeyPgUp:      "\x1b[5~",
+		KeyPgDn:      "\x1b[6~",
+		KeyF1:        "\x1bOP",
+		KeyF2:        "\x1bOQ",
+		KeyF3:        "\x1bOR",
+		KeyF4:        "\x1bOS",
+		KeyF5:        "\x1b[17~",
+		KeyF6:        "\x1b[18~",
+		KeyF7:        "\x1b[19~",
+		KeyF8:        "\x1b[20~",
+		KeyF9:        "\x1b[21~",
+		KeyF10:       "\x1b[29~",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/v/vt52/term.go

@@ -0,0 +1,29 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package vt52
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// dec vt52
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "vt52",
+		Columns:      80,
+		Lines:        24,
+		Bell:         "\a",
+		Clear:        "\x1bH\x1bJ",
+		PadChar:      "\x00",
+		AltChars:     "+h.k0affggolpnqprrss",
+		EnterAcs:     "\x1bF",
+		ExitAcs:      "\x1bG",
+		SetCursor:    "\x1bY%p1%' '%+%c%p2%' '%+%c",
+		CursorBack1:  "\x1bD",
+		CursorUp1:    "\x1bA",
+		KeyUp:        "\x1bA",
+		KeyDown:      "\x1bB",
+		KeyRight:     "\x1bC",
+		KeyLeft:      "\x1bD",
+		KeyBackspace: "\b",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/w/wy50/term.go

@@ -0,0 +1,59 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package wy50
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// Wyse 50
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "wy50",
+		Aliases:      []string{"wyse50"},
+		Columns:      80,
+		Lines:        24,
+		Bell:         "\a",
+		Clear:        "\x1b+$<20>",
+		ShowCursor:   "\x1b`1",
+		HideCursor:   "\x1b`0",
+		AttrOff:      "\x1b(\x1bH\x03",
+		Dim:          "\x1b`7\x1b)",
+		Reverse:      "\x1b`6\x1b)",
+		PadChar:      "\x00",
+		AltChars:     "0wa_h[jukslrmqnxqzttuyv]wpxv",
+		EnterAcs:     "\x1bH\x02",
+		ExitAcs:      "\x1bH\x03",
+		SetCursor:    "\x1b=%p1%' '%+%c%p2%' '%+%c",
+		CursorBack1:  "\b",
+		CursorUp1:    "\v",
+		KeyUp:        "\v",
+		KeyDown:      "\n",
+		KeyRight:     "\f",
+		KeyLeft:      "\b",
+		KeyInsert:    "\x1bQ",
+		KeyDelete:    "\x1bW",
+		KeyBackspace: "\b",
+		KeyHome:      "\x1e",
+		KeyPgUp:      "\x1bJ",
+		KeyPgDn:      "\x1bK",
+		KeyF1:        "\x01@\r",
+		KeyF2:        "\x01A\r",
+		KeyF3:        "\x01B\r",
+		KeyF4:        "\x01C\r",
+		KeyF5:        "\x01D\r",
+		KeyF6:        "\x01E\r",
+		KeyF7:        "\x01F\r",
+		KeyF8:        "\x01G\r",
+		KeyF9:        "\x01H\r",
+		KeyF10:       "\x01I\r",
+		KeyF11:       "\x01J\r",
+		KeyF12:       "\x01K\r",
+		KeyF13:       "\x01L\r",
+		KeyF14:       "\x01M\r",
+		KeyF15:       "\x01N\r",
+		KeyF16:       "\x01O\r",
+		KeyPrint:     "\x1bP",
+		KeyBacktab:   "\x1bI",
+		KeyShfHome:   "\x1b{",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/w/wy60/term.go

@@ -0,0 +1,63 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package wy60
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// Wyse 60
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "wy60",
+		Aliases:      []string{"wyse60"},
+		Columns:      80,
+		Lines:        24,
+		Bell:         "\a",
+		Clear:        "\x1b+$<100>",
+		EnterCA:      "\x1bw0",
+		ExitCA:       "\x1bw1",
+		ShowCursor:   "\x1b`1",
+		HideCursor:   "\x1b`0",
+		AttrOff:      "\x1b(\x1bH\x03\x1bG0\x1bcD",
+		Underline:    "\x1bG8",
+		Dim:          "\x1bGp",
+		Blink:        "\x1bG2",
+		Reverse:      "\x1bG4",
+		PadChar:      "\x00",
+		AltChars:     "+/,.0[a2fxgqh1ihjYk?lZm@nEqDtCu4vAwBx3yszr{c~~",
+		EnterAcs:     "\x1bcE",
+		ExitAcs:      "\x1bcD",
+		SetCursor:    "\x1b=%p1%' '%+%c%p2%' '%+%c",
+		CursorBack1:  "\b",
+		CursorUp1:    "\v",
+		KeyUp:        "\v",
+		KeyDown:      "\n",
+		KeyRight:     "\f",
+		KeyLeft:      "\b",
+		KeyInsert:    "\x1bQ",
+		KeyDelete:    "\x1bW",
+		KeyBackspace: "\b",
+		KeyHome:      "\x1e",
+		KeyPgUp:      "\x1bJ",
+		KeyPgDn:      "\x1bK",
+		KeyF1:        "\x01@\r",
+		KeyF2:        "\x01A\r",
+		KeyF3:        "\x01B\r",
+		KeyF4:        "\x01C\r",
+		KeyF5:        "\x01D\r",
+		KeyF6:        "\x01E\r",
+		KeyF7:        "\x01F\r",
+		KeyF8:        "\x01G\r",
+		KeyF9:        "\x01H\r",
+		KeyF10:       "\x01I\r",
+		KeyF11:       "\x01J\r",
+		KeyF12:       "\x01K\r",
+		KeyF13:       "\x01L\r",
+		KeyF14:       "\x01M\r",
+		KeyF15:       "\x01N\r",
+		KeyF16:       "\x01O\r",
+		KeyPrint:     "\x1bP",
+		KeyBacktab:   "\x1bI",
+		KeyShfHome:   "\x1b{",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/w/wy99_ansi/term.go

@@ -0,0 +1,114 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package wy99_ansi
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// Wyse WY-99GT in ansi mode (int'l PC keyboard)
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "wy99-ansi",
+		Columns:      80,
+		Lines:        25,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[J$<200>",
+		ShowCursor:   "\x1b[34h\x1b[?25h",
+		HideCursor:   "\x1b[?25l",
+		AttrOff:      "\x1b[m\x0f\x1b[\"q",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Dim:          "\x1b[2m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		EnterKeypad:  "\x1b[?1h",
+		ExitKeypad:   "\x1b[?1l",
+		PadChar:      "\x00",
+		AltChars:     "``aaffggjjkkllmmnnooqqssttuuvvwwxx{{||}}~~",
+		EnterAcs:     "\x0e",
+		ExitAcs:      "\x0f",
+		EnableAcs:    "\x1b)0",
+		SetCursor:    "\x1b[%i%p1%d;%p2%dH",
+		CursorBack1:  "\b$<1>",
+		CursorUp1:    "\x1bM",
+		KeyUp:        "\x1bOA",
+		KeyDown:      "\x1bOB",
+		KeyRight:     "\x1bOC",
+		KeyLeft:      "\x1bOD",
+		KeyBackspace: "\b",
+		KeyF1:        "\x1bOP",
+		KeyF2:        "\x1bOQ",
+		KeyF3:        "\x1bOR",
+		KeyF4:        "\x1bOS",
+		KeyF5:        "\x1b[M",
+		KeyF6:        "\x1b[17~",
+		KeyF7:        "\x1b[18~",
+		KeyF8:        "\x1b[19~",
+		KeyF9:        "\x1b[20~",
+		KeyF10:       "\x1b[21~",
+		KeyF11:       "\x1b[23~",
+		KeyF12:       "\x1b[24~",
+		KeyF17:       "\x1b[K",
+		KeyF18:       "\x1b[31~",
+		KeyF19:       "\x1b[32~",
+		KeyF20:       "\x1b[33~",
+		KeyF21:       "\x1b[34~",
+		KeyF22:       "\x1b[35~",
+		KeyF23:       "\x1b[1~",
+		KeyF24:       "\x1b[2~",
+		KeyBacktab:   "\x1b[z",
+	})
+
+	// Wyse WY-99GT in ansi mode (US PC keyboard)
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "wy99a-ansi",
+		Columns:      80,
+		Lines:        25,
+		Bell:         "\a",
+		Clear:        "\x1b[H\x1b[J$<200>",
+		ShowCursor:   "\x1b[34h\x1b[?25h",
+		HideCursor:   "\x1b[?25l",
+		AttrOff:      "\x1b[m\x0f\x1b[\"q",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		Dim:          "\x1b[2m",
+		Blink:        "\x1b[5m",
+		Reverse:      "\x1b[7m",
+		EnterKeypad:  "\x1b[?1h",
+		ExitKeypad:   "\x1b[?1l",
+		PadChar:      "\x00",
+		AltChars:     "``aaffggjjkkllmmnnooqqssttuuvvwwxx{{||}}~~",
+		EnterAcs:     "\x0e",
+		ExitAcs:      "\x0f",
+		EnableAcs:    "\x1b)0",
+		SetCursor:    "\x1b[%i%p1%d;%p2%dH",
+		CursorBack1:  "\b$<1>",
+		CursorUp1:    "\x1bM",
+		KeyUp:        "\x1bOA",
+		KeyDown:      "\x1bOB",
+		KeyRight:     "\x1bOC",
+		KeyLeft:      "\x1bOD",
+		KeyBackspace: "\b",
+		KeyF1:        "\x1bOP",
+		KeyF2:        "\x1bOQ",
+		KeyF3:        "\x1bOR",
+		KeyF4:        "\x1bOS",
+		KeyF5:        "\x1b[M",
+		KeyF6:        "\x1b[17~",
+		KeyF7:        "\x1b[18~",
+		KeyF8:        "\x1b[19~",
+		KeyF9:        "\x1b[20~",
+		KeyF10:       "\x1b[21~",
+		KeyF11:       "\x1b[23~",
+		KeyF12:       "\x1b[24~",
+		KeyF17:       "\x1b[K",
+		KeyF18:       "\x1b[31~",
+		KeyF19:       "\x1b[32~",
+		KeyF20:       "\x1b[33~",
+		KeyF21:       "\x1b[34~",
+		KeyF22:       "\x1b[35~",
+		KeyF23:       "\x1b[1~",
+		KeyF24:       "\x1b[2~",
+		KeyBacktab:   "\x1b[z",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/x/xfce/term.go

@@ -0,0 +1,158 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package xfce
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// Xfce Terminal
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:            "xfce",
+		Columns:         80,
+		Lines:           24,
+		Colors:          8,
+		Bell:            "\a",
+		Clear:           "\x1b[H\x1b[2J",
+		EnterCA:         "\x1b7\x1b[?47h",
+		ExitCA:          "\x1b[2J\x1b[?47l\x1b8",
+		ShowCursor:      "\x1b[?25h",
+		HideCursor:      "\x1b[?25l",
+		AttrOff:         "\x1b[0m\x0f",
+		Underline:       "\x1b[4m",
+		Bold:            "\x1b[1m",
+		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:        "``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		EnterAcs:        "\x0e",
+		ExitAcs:         "\x0f",
+		EnableAcs:       "\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:       "\x1b[A",
+		KeyUp:           "\x1bOA",
+		KeyDown:         "\x1bOB",
+		KeyRight:        "\x1bOC",
+		KeyLeft:         "\x1bOD",
+		KeyInsert:       "\x1b[2~",
+		KeyDelete:       "\x1b[3~",
+		KeyBackspace:    "\u007f",
+		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:          "\x1bO1;2P",
+		KeyF14:          "\x1bO1;2Q",
+		KeyF15:          "\x1bO1;2R",
+		KeyF16:          "\x1bO1;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:          "\x1bO1;5P",
+		KeyF26:          "\x1bO1;5Q",
+		KeyF27:          "\x1bO1;5R",
+		KeyF28:          "\x1bO1;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:          "\x1bO1;6P",
+		KeyF38:          "\x1bO1;6Q",
+		KeyF39:          "\x1bO1;6R",
+		KeyF40:          "\x1bO1;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:          "\x1bO1;3P",
+		KeyF50:          "\x1bO1;3Q",
+		KeyF51:          "\x1bO1;3R",
+		KeyF52:          "\x1bO1;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:          "\x1bO1;4P",
+		KeyF62:          "\x1bO1;4Q",
+		KeyF63:          "\x1bO1;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",
+		KeyShfPgUp:      "\x1b[5;2~",
+		KeyShfPgDn:      "\x1b[6;2~",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/x/xnuppc/term.go

@@ -0,0 +1,34 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package xnuppc
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// Darwin PowerPC Console (color)
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:         "xnuppc",
+		Aliases:      []string{"darwin"},
+		Colors:       8,
+		Clear:        "\x1b[H\x1b[J",
+		AttrOff:      "\x1b[m",
+		Underline:    "\x1b[4m",
+		Bold:         "\x1b[1m",
+		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",
+		SetCursor:    "\x1b[%i%p1%d;%p2%dH",
+		CursorBack1:  "\x1b[D",
+		CursorUp1:    "\x1b[A",
+		KeyUp:        "\x1bOA",
+		KeyDown:      "\x1bOB",
+		KeyRight:     "\x1bOC",
+		KeyLeft:      "\x1bOD",
+		KeyBackspace: "\u007f",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/x/xterm/term.go

@@ -0,0 +1,462 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package xterm
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// X11 terminal emulator
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:            "xterm",
+		Aliases:         []string{"xterm-debian"},
+		Columns:         80,
+		Lines:           24,
+		Colors:          8,
+		Bell:            "\a",
+		Clear:           "\x1b[H\x1b[2J",
+		EnterCA:         "\x1b[?1049h\x1b[22;0;0t",
+		ExitCA:          "\x1b[?1049l\x1b[23;0;0t",
+		ShowCursor:      "\x1b[?12l\x1b[?25h",
+		HideCursor:      "\x1b[?25l",
+		AttrOff:         "\x1b(B\x1b[m",
+		Underline:       "\x1b[4m",
+		Bold:            "\x1b[1m",
+		Dim:             "\x1b[2m",
+		Italic:          "\x1b[3m",
+		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",
+		AltChars:        "``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		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:    "\u007f",
+		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",
+		KeyShfPgUp:      "\x1b[5;2~",
+		KeyShfPgDn:      "\x1b[6;2~",
+	})
+
+	// xterm with 88 colors
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:            "xterm-88color",
+		Columns:         80,
+		Lines:           24,
+		Colors:          88,
+		Bell:            "\a",
+		Clear:           "\x1b[H\x1b[2J",
+		EnterCA:         "\x1b[?1049h\x1b[22;0;0t",
+		ExitCA:          "\x1b[?1049l\x1b[23;0;0t",
+		ShowCursor:      "\x1b[?12l\x1b[?25h",
+		HideCursor:      "\x1b[?25l",
+		AttrOff:         "\x1b(B\x1b[m",
+		Underline:       "\x1b[4m",
+		Bold:            "\x1b[1m",
+		Dim:             "\x1b[2m",
+		Italic:          "\x1b[3m",
+		Blink:           "\x1b[5m",
+		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:        "``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		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:    "\u007f",
+		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",
+		KeyShfPgUp:      "\x1b[5;2~",
+		KeyShfPgDn:      "\x1b[6;2~",
+	})
+
+	// xterm with 256 colors
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:            "xterm-256color",
+		Columns:         80,
+		Lines:           24,
+		Colors:          256,
+		Bell:            "\a",
+		Clear:           "\x1b[H\x1b[2J",
+		EnterCA:         "\x1b[?1049h\x1b[22;0;0t",
+		ExitCA:          "\x1b[?1049l\x1b[23;0;0t",
+		ShowCursor:      "\x1b[?12l\x1b[?25h",
+		HideCursor:      "\x1b[?25l",
+		AttrOff:         "\x1b(B\x1b[m",
+		Underline:       "\x1b[4m",
+		Bold:            "\x1b[1m",
+		Dim:             "\x1b[2m",
+		Italic:          "\x1b[3m",
+		Blink:           "\x1b[5m",
+		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:        "``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
+		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:    "\u007f",
+		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",
+		KeyShfPgUp:      "\x1b[5;2~",
+		KeyShfPgDn:      "\x1b[6;2~",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terminfo/x/xterm_kitty/term.go

@@ -0,0 +1,157 @@
+// Generated automatically.  DO NOT HAND-EDIT.
+
+package xterm_kitty
+
+import "github.com/gdamore/tcell/terminfo"
+
+func init() {
+
+	// KovIdTTY
+	terminfo.AddTerminfo(&terminfo.Terminfo{
+		Name:            "xterm-kitty",
+		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",
+		Dim:             "\x1b[2m",
+		Reverse:         "\x1b[7m",
+		EnterKeypad:     "\x1b[?1h",
+		ExitKeypad:      "\x1b[?1l",
+		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",
+		KeyShfPgUp:      "\x1b[5;2~",
+		KeyShfPgDn:      "\x1b[6;2~",
+	})
+}

libtui/v0/vendor/github.com/gdamore/tcell/terms_default.go

@@ -0,0 +1,23 @@
+// +build !tcell_minimal
+
+// Copyright 2019 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.
+
+package tcell
+
+import (
+	// This imports the default terminal entries.  To disable, use the
+	// tcell_minimal build tag.
+	_ "github.com/gdamore/tcell/terminfo/extended"
+)

libtui/v0/vendor/github.com/gdamore/tcell/terms_dynamic.go

@@ -0,0 +1,37 @@
+// +build !tcell_minimal,!nacl,!js,!zos,!plan9,!windows,!android
+
+// Copyright 2019 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.
+
+package tcell
+
+import (
+	// This imports a dynamic version of the terminal database, which
+	// is built using infocmp.  This relies on a working installation
+	// of infocmp (typically supplied with ncurses).  We only do this
+	// for systems likely to have that -- i.e. UNIX based hosts.  We
+	// also don't support Android here, because you really don't want
+	// to run external programs there.  Generally the android terminals
+	// will be automatically included anyway.
+	"github.com/gdamore/tcell/terminfo"
+	"github.com/gdamore/tcell/terminfo/dynamic"
+)
+
+func loadDynamicTerminfo(term string) (*terminfo.Terminfo, error) {
+	ti, _, e := dynamic.LoadTerminfo(term)
+	if e != nil {
+		return nil, e
+	}
+	return ti, nil
+}

libtui/v0/vendor/github.com/gdamore/tcell/terms_static.go

@@ -0,0 +1,27 @@
+// +build tcell_minimal nacl js zos plan9 windows android
+
+// Copyright 2019 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.
+
+package tcell
+
+import (
+	"errors"
+
+	"github.com/gdamore/tcell/terminfo"
+)
+
+func loadDynamicTerminfo(term string) (*terminfo.Terminfo, error) {
+	return nil, errors.New("terminal type unsupported")
+}