build(deps): vendor libvterm at v0.3.3

Problem: Adding support for modern Nvim features (reflow, OSC 8, full
utf8/emoji support) requires coupling libvterm to Nvim internals
(e.g., utf8proc).

Solution: Vendor libvterm at v0.3.3.

22 files changed, 7120 insertions, 6 deletions

diff --git a/src/clint.py b/src/clint.py
index 67185a7340..cc144543a0 100755
--- a/src/clint.py
+++ b/src/clint.py
@@ -880,6 +880,7 @@ def CheckIncludes(filename, lines, error):
             "mpack/object.h",
             "nvim/func_attr.h",
             "termkey/termkey.h",
+            "vterm/vterm.h",
             ]
 
     for i in check_includes_ignore:
diff --git a/src/nvim/CMakeLists.txt b/src/nvim/CMakeLists.txt
index d153c9e3ef..87c9506709 100644
--- a/src/nvim/CMakeLists.txt
+++ b/src/nvim/CMakeLists.txt
@@ -30,7 +30,6 @@ target_link_libraries(main_lib INTERFACE ${LUV_LIBRARY})
 
 find_package(Iconv REQUIRED)
 find_package(Libuv 1.28.0 REQUIRED)
-find_package(Libvterm 0.3.3 REQUIRED)
 find_package(Lpeg REQUIRED)
 find_package(Treesitter 0.22.6 REQUIRED)
 find_package(Unibilium 2.0 REQUIRED)
@@ -38,7 +37,6 @@ find_package(UTF8proc REQUIRED)
 
 target_link_libraries(main_lib INTERFACE
   iconv
-  libvterm
   lpeg
   treesitter
   unibilium
@@ -366,8 +364,8 @@ file(MAKE_DIRECTORY ${TOUCHES_DIR} ${GENERATED_DIR} ${GENERATED_INCLUDES_DIR})
 
 file(GLOB NVIM_SOURCES CONFIGURE_DEPENDS *.c)
 file(GLOB NVIM_HEADERS CONFIGURE_DEPENDS *.h)
-file(GLOB EXTERNAL_SOURCES CONFIGURE_DEPENDS ../xdiff/*.c ../mpack/*.c ../cjson/*.c ../klib/*.c ../termkey/*.c)
-file(GLOB EXTERNAL_HEADERS CONFIGURE_DEPENDS ../xdiff/*.h ../mpack/*.h ../cjson/*.h ../klib/*.h ../termkey/*.h)
+file(GLOB EXTERNAL_SOURCES CONFIGURE_DEPENDS ../xdiff/*.c ../mpack/*.c ../cjson/*.c ../klib/*.c ../termkey/*.c ../vterm/*.c)
+file(GLOB EXTERNAL_HEADERS CONFIGURE_DEPENDS ../xdiff/*.h ../mpack/*.h ../cjson/*.h ../klib/*.h ../termkey/*.h ../vterm/*.h)
 
 file(GLOB NLUA0_SOURCES CONFIGURE_DEPENDS ../mpack/*.c)
 
diff --git a/src/nvim/os/win_defs.h b/src/nvim/os/win_defs.h
index 852059f78b..024719806c 100644
--- a/src/nvim/os/win_defs.h
+++ b/src/nvim/os/win_defs.h
@@ -16,6 +16,9 @@
 #include <sys/stat.h>
 #include <windows.h>
 
+// vterm.h defines an `unsigned int small` in a struct, triggering error C2632
+#undef small
+
 // Windows does not have S_IFLNK but libuv defines it
 // and sets the flag for us when calling uv_fs_stat.
 #include <uv.h>
diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c
index 507a9e3a2a..abc9b3534b 100644
--- a/src/nvim/terminal.c
+++ b/src/nvim/terminal.c
@@ -40,8 +40,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <vterm.h>
-#include <vterm_keycodes.h>
 
 #include "klib/kvec.h"
 #include "nvim/api/private/helpers.h"
@@ -94,6 +92,8 @@
 #include "nvim/ui.h"
 #include "nvim/vim_defs.h"
 #include "nvim/window.h"
+#include "vterm/vterm.h"
+#include "vterm/vterm_keycodes.h"
 
 typedef struct {
   VimState state;
diff --git a/src/vterm/LICENSE b/src/vterm/LICENSE
new file mode 100644
index 0000000000..0d051634b2
--- /dev/null
+++ b/src/vterm/LICENSE
@@ -0,0 +1,23 @@
+
+
+The MIT License
+
+Copyright (c) 2008 Paul Evans <leonerd@leonerd.org.uk>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/src/vterm/encoding.c b/src/vterm/encoding.c
new file mode 100644
index 0000000000..434ac3f99b
--- /dev/null
+++ b/src/vterm/encoding.c
@@ -0,0 +1,230 @@
+#include "vterm_internal.h"
+
+#define UNICODE_INVALID 0xFFFD
+
+#if defined(DEBUG) && DEBUG > 1
+# define DEBUG_PRINT_UTF8
+#endif
+
+struct UTF8DecoderData {
+  // number of bytes remaining in this codepoint
+  int bytes_remaining;
+
+  // number of bytes total in this codepoint once it's finished
+  // (for detecting overlongs)
+  int bytes_total;
+
+  int this_cp;
+};
+
+static void init_utf8(VTermEncoding *enc, void *data_)
+{
+  struct UTF8DecoderData *data = data_;
+
+  data->bytes_remaining = 0;
+  data->bytes_total     = 0;
+}
+
+static void decode_utf8(VTermEncoding *enc, void *data_,
+                        uint32_t cp[], int *cpi, int cplen,
+                        const char bytes[], size_t *pos, size_t bytelen)
+{
+  struct UTF8DecoderData *data = data_;
+
+#ifdef DEBUG_PRINT_UTF8
+  printf("BEGIN UTF-8\n");
+#endif
+
+  for(; *pos < bytelen && *cpi < cplen; (*pos)++) {
+    unsigned char c = bytes[*pos];
+
+#ifdef DEBUG_PRINT_UTF8
+    printf(" pos=%zd c=%02x rem=%d\n", *pos, c, data->bytes_remaining);
+#endif
+
+    if(c < 0x20) // C0
+      return;
+
+    else if(c >= 0x20 && c < 0x7f) {
+      if(data->bytes_remaining)
+        cp[(*cpi)++] = UNICODE_INVALID;
+
+      cp[(*cpi)++] = c;
+#ifdef DEBUG_PRINT_UTF8
+      printf(" UTF-8 char: U+%04x\n", c);
+#endif
+      data->bytes_remaining = 0;
+    }
+
+    else if(c == 0x7f) // DEL
+      return;
+
+    else if(c >= 0x80 && c < 0xc0) {
+      if(!data->bytes_remaining) {
+        cp[(*cpi)++] = UNICODE_INVALID;
+        continue;
+      }
+
+      data->this_cp <<= 6;
+      data->this_cp |= c & 0x3f;
+      data->bytes_remaining--;
+
+      if(!data->bytes_remaining) {
+#ifdef DEBUG_PRINT_UTF8
+        printf(" UTF-8 raw char U+%04x bytelen=%d ", data->this_cp, data->bytes_total);
+#endif
+        // Check for overlong sequences
+        switch(data->bytes_total) {
+        case 2:
+          if(data->this_cp <  0x0080) data->this_cp = UNICODE_INVALID;
+          break;
+        case 3:
+          if(data->this_cp <  0x0800) data->this_cp = UNICODE_INVALID;
+          break;
+        case 4:
+          if(data->this_cp < 0x10000) data->this_cp = UNICODE_INVALID;
+          break;
+        case 5:
+          if(data->this_cp < 0x200000) data->this_cp = UNICODE_INVALID;
+          break;
+        case 6:
+          if(data->this_cp < 0x4000000) data->this_cp = UNICODE_INVALID;
+          break;
+        }
+        // Now look for plain invalid ones
+        if((data->this_cp >= 0xD800 && data->this_cp <= 0xDFFF) ||
+           data->this_cp == 0xFFFE ||
+           data->this_cp == 0xFFFF)
+          data->this_cp = UNICODE_INVALID;
+#ifdef DEBUG_PRINT_UTF8
+        printf(" char: U+%04x\n", data->this_cp);
+#endif
+        cp[(*cpi)++] = data->this_cp;
+      }
+    }
+
+    else if(c >= 0xc0 && c < 0xe0) {
+      if(data->bytes_remaining)
+        cp[(*cpi)++] = UNICODE_INVALID;
+
+      data->this_cp = c & 0x1f;
+      data->bytes_total = 2;
+      data->bytes_remaining = 1;
+    }
+
+    else if(c >= 0xe0 && c < 0xf0) {
+      if(data->bytes_remaining)
+        cp[(*cpi)++] = UNICODE_INVALID;
+
+      data->this_cp = c & 0x0f;
+      data->bytes_total = 3;
+      data->bytes_remaining = 2;
+    }
+
+    else if(c >= 0xf0 && c < 0xf8) {
+      if(data->bytes_remaining)
+        cp[(*cpi)++] = UNICODE_INVALID;
+
+      data->this_cp = c & 0x07;
+      data->bytes_total = 4;
+      data->bytes_remaining = 3;
+    }
+
+    else if(c >= 0xf8 && c < 0xfc) {
+      if(data->bytes_remaining)
+        cp[(*cpi)++] = UNICODE_INVALID;
+
+      data->this_cp = c & 0x03;
+      data->bytes_total = 5;
+      data->bytes_remaining = 4;
+    }
+
+    else if(c >= 0xfc && c < 0xfe) {
+      if(data->bytes_remaining)
+        cp[(*cpi)++] = UNICODE_INVALID;
+
+      data->this_cp = c & 0x01;
+      data->bytes_total = 6;
+      data->bytes_remaining = 5;
+    }
+
+    else {
+      cp[(*cpi)++] = UNICODE_INVALID;
+    }
+  }
+}
+
+static VTermEncoding encoding_utf8 = {
+  .init   = &init_utf8,
+  .decode = &decode_utf8,
+};
+
+static void decode_usascii(VTermEncoding *enc, void *data,
+                           uint32_t cp[], int *cpi, int cplen,
+                           const char bytes[], size_t *pos, size_t bytelen)
+{
+  int is_gr = bytes[*pos] & 0x80;
+
+  for(; *pos < bytelen && *cpi < cplen; (*pos)++) {
+    unsigned char c = bytes[*pos] ^ is_gr;
+
+    if(c < 0x20 || c == 0x7f || c >= 0x80)
+      return;
+
+    cp[(*cpi)++] = c;
+  }
+}
+
+static VTermEncoding encoding_usascii = {
+  .decode = &decode_usascii,
+};
+
+struct StaticTableEncoding {
+  const VTermEncoding enc;
+  const uint32_t chars[128];
+};
+
+static void decode_table(VTermEncoding *enc, void *data,
+                         uint32_t cp[], int *cpi, int cplen,
+                         const char bytes[], size_t *pos, size_t bytelen)
+{
+  struct StaticTableEncoding *table = (struct StaticTableEncoding *)enc;
+  int is_gr = bytes[*pos] & 0x80;
+
+  for(; *pos < bytelen && *cpi < cplen; (*pos)++) {
+    unsigned char c = bytes[*pos] ^ is_gr;
+
+    if(c < 0x20 || c == 0x7f || c >= 0x80)
+      return;
+
+    if(table->chars[c])
+      cp[(*cpi)++] = table->chars[c];
+    else
+      cp[(*cpi)++] = c;
+  }
+}
+
+#include "encoding/DECdrawing.inc"
+#include "encoding/uk.inc"
+
+static struct {
+  VTermEncodingType type;
+  char designation;
+  VTermEncoding *enc;
+}
+encodings[] = {
+  { ENC_UTF8,      'u', &encoding_utf8 },
+  { ENC_SINGLE_94, '0', (VTermEncoding*)&encoding_DECdrawing },
+  { ENC_SINGLE_94, 'A', (VTermEncoding*)&encoding_uk },
+  { ENC_SINGLE_94, 'B', &encoding_usascii },
+  { 0 },
+};
+
+/* This ought to be INTERNAL but isn't because it's used by unit testing */
+VTermEncoding *vterm_lookup_encoding(VTermEncodingType type, char designation)
+{
+  for(int i = 0; encodings[i].designation; i++)
+    if(encodings[i].type == type && encodings[i].designation == designation)
+      return encodings[i].enc;
+  return NULL;
+}
diff --git a/src/vterm/encoding/DECdrawing.inc b/src/vterm/encoding/DECdrawing.inc
new file mode 100644
index 0000000000..627397bcc2
--- /dev/null
+++ b/src/vterm/encoding/DECdrawing.inc
@@ -0,0 +1,36 @@
+static const struct StaticTableEncoding encoding_DECdrawing = {
+  { .decode = &decode_table },
+  {
+    [0x60] = 0x25C6,  // BLACK DIAMOND
+    [0x61] = 0x2592,  // MEDIUM SHADE (checkerboard)
+    [0x62] = 0x2409,  // SYMBOL FOR HORIZONTAL TAB
+    [0x63] = 0x240C,  // SYMBOL FOR FORM FEED
+    [0x64] = 0x240D,  // SYMBOL FOR CARRIAGE RETURN
+    [0x65] = 0x240A,  // SYMBOL FOR LINE FEED
+    [0x66] = 0x00B0,  // DEGREE SIGN
+    [0x67] = 0x00B1,  // PLUS-MINUS SIGN (plus or minus)
+    [0x68] = 0x2424,  // SYMBOL FOR NEW LINE
+    [0x69] = 0x240B,  // SYMBOL FOR VERTICAL TAB
+    [0x6a] = 0x2518,  // BOX DRAWINGS LIGHT UP AND LEFT (bottom-right corner)
+    [0x6b] = 0x2510,  // BOX DRAWINGS LIGHT DOWN AND LEFT (top-right corner)
+    [0x6c] = 0x250C,  // BOX DRAWINGS LIGHT DOWN AND RIGHT (top-left corner)
+    [0x6d] = 0x2514,  // BOX DRAWINGS LIGHT UP AND RIGHT (bottom-left corner)
+    [0x6e] = 0x253C,  // BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL (crossing lines)
+    [0x6f] = 0x23BA,  // HORIZONTAL SCAN LINE-1
+    [0x70] = 0x23BB,  // HORIZONTAL SCAN LINE-3
+    [0x71] = 0x2500,  // BOX DRAWINGS LIGHT HORIZONTAL
+    [0x72] = 0x23BC,  // HORIZONTAL SCAN LINE-7
+    [0x73] = 0x23BD,  // HORIZONTAL SCAN LINE-9
+    [0x74] = 0x251C,  // BOX DRAWINGS LIGHT VERTICAL AND RIGHT
+    [0x75] = 0x2524,  // BOX DRAWINGS LIGHT VERTICAL AND LEFT
+    [0x76] = 0x2534,  // BOX DRAWINGS LIGHT UP AND HORIZONTAL
+    [0x77] = 0x252C,  // BOX DRAWINGS LIGHT DOWN AND HORIZONTAL
+    [0x78] = 0x2502,  // BOX DRAWINGS LIGHT VERTICAL
+    [0x79] = 0x2A7D,  // LESS-THAN OR SLANTED EQUAL-TO
+    [0x7a] = 0x2A7E,  // GREATER-THAN OR SLANTED EQUAL-TO
+    [0x7b] = 0x03C0,  // GREEK SMALL LETTER PI
+    [0x7c] = 0x2260,  // NOT EQUAL TO
+    [0x7d] = 0x00A3,  // POUND SIGN
+    [0x7e] = 0x00B7,  // MIDDLE DOT
+  }
+};
diff --git a/src/vterm/encoding/uk.inc b/src/vterm/encoding/uk.inc
new file mode 100644
index 0000000000..5c7700226b
--- /dev/null
+++ b/src/vterm/encoding/uk.inc
@@ -0,0 +1,6 @@
+static const struct StaticTableEncoding encoding_uk = {
+  { .decode = &decode_table },
+  {
+    [0x23] = 0x00a3,  // £
+  }
+};
diff --git a/src/vterm/fullwidth.inc b/src/vterm/fullwidth.inc
new file mode 100644
index 0000000000..a703529a76
--- /dev/null
+++ b/src/vterm/fullwidth.inc
@@ -0,0 +1,111 @@
+  { 0x1100, 0x115f },
+  { 0x231a, 0x231b },
+  { 0x2329, 0x232a },
+  { 0x23e9, 0x23ec },
+  { 0x23f0, 0x23f0 },
+  { 0x23f3, 0x23f3 },
+  { 0x25fd, 0x25fe },
+  { 0x2614, 0x2615 },
+  { 0x2648, 0x2653 },
+  { 0x267f, 0x267f },
+  { 0x2693, 0x2693 },
+  { 0x26a1, 0x26a1 },
+  { 0x26aa, 0x26ab },
+  { 0x26bd, 0x26be },
+  { 0x26c4, 0x26c5 },
+  { 0x26ce, 0x26ce },
+  { 0x26d4, 0x26d4 },
+  { 0x26ea, 0x26ea },
+  { 0x26f2, 0x26f3 },
+  { 0x26f5, 0x26f5 },
+  { 0x26fa, 0x26fa },
+  { 0x26fd, 0x26fd },
+  { 0x2705, 0x2705 },
+  { 0x270a, 0x270b },
+  { 0x2728, 0x2728 },
+  { 0x274c, 0x274c },
+  { 0x274e, 0x274e },
+  { 0x2753, 0x2755 },
+  { 0x2757, 0x2757 },
+  { 0x2795, 0x2797 },
+  { 0x27b0, 0x27b0 },
+  { 0x27bf, 0x27bf },
+  { 0x2b1b, 0x2b1c },
+  { 0x2b50, 0x2b50 },
+  { 0x2b55, 0x2b55 },
+  { 0x2e80, 0x2e99 },
+  { 0x2e9b, 0x2ef3 },
+  { 0x2f00, 0x2fd5 },
+  { 0x2ff0, 0x2ffb },
+  { 0x3000, 0x303e },
+  { 0x3041, 0x3096 },
+  { 0x3099, 0x30ff },
+  { 0x3105, 0x312f },
+  { 0x3131, 0x318e },
+  { 0x3190, 0x31ba },
+  { 0x31c0, 0x31e3 },
+  { 0x31f0, 0x321e },
+  { 0x3220, 0x3247 },
+  { 0x3250, 0x4dbf },
+  { 0x4e00, 0xa48c },
+  { 0xa490, 0xa4c6 },
+  { 0xa960, 0xa97c },
+  { 0xac00, 0xd7a3 },
+  { 0xf900, 0xfaff },
+  { 0xfe10, 0xfe19 },
+  { 0xfe30, 0xfe52 },
+  { 0xfe54, 0xfe66 },
+  { 0xfe68, 0xfe6b },
+  { 0xff01, 0xff60 },
+  { 0xffe0, 0xffe6 },
+  { 0x16fe0, 0x16fe3 },
+  { 0x17000, 0x187f7 },
+  { 0x18800, 0x18af2 },
+  { 0x1b000, 0x1b11e },
+  { 0x1b150, 0x1b152 },
+  { 0x1b164, 0x1b167 },
+  { 0x1b170, 0x1b2fb },
+  { 0x1f004, 0x1f004 },
+  { 0x1f0cf, 0x1f0cf },
+  { 0x1f18e, 0x1f18e },
+  { 0x1f191, 0x1f19a },
+  { 0x1f200, 0x1f202 },
+  { 0x1f210, 0x1f23b },
+  { 0x1f240, 0x1f248 },
+  { 0x1f250, 0x1f251 },
+  { 0x1f260, 0x1f265 },
+  { 0x1f300, 0x1f320 },
+  { 0x1f32d, 0x1f335 },
+  { 0x1f337, 0x1f37c },
+  { 0x1f37e, 0x1f393 },
+  { 0x1f3a0, 0x1f3ca },
+  { 0x1f3cf, 0x1f3d3 },
+  { 0x1f3e0, 0x1f3f0 },
+  { 0x1f3f4, 0x1f3f4 },
+  { 0x1f3f8, 0x1f43e },
+  { 0x1f440, 0x1f440 },
+  { 0x1f442, 0x1f4fc },
+  { 0x1f4ff, 0x1f53d },
+  { 0x1f54b, 0x1f54e },
+  { 0x1f550, 0x1f567 },
+  { 0x1f57a, 0x1f57a },
+  { 0x1f595, 0x1f596 },
+  { 0x1f5a4, 0x1f5a4 },
+  { 0x1f5fb, 0x1f64f },
+  { 0x1f680, 0x1f6c5 },
+  { 0x1f6cc, 0x1f6cc },
+  { 0x1f6d0, 0x1f6d2 },
+  { 0x1f6d5, 0x1f6d5 },
+  { 0x1f6eb, 0x1f6ec },
+  { 0x1f6f4, 0x1f6fa },
+  { 0x1f7e0, 0x1f7eb },
+  { 0x1f90d, 0x1f971 },
+  { 0x1f973, 0x1f976 },
+  { 0x1f97a, 0x1f9a2 },
+  { 0x1f9a5, 0x1f9aa },
+  { 0x1f9ae, 0x1f9ca },
+  { 0x1f9cd, 0x1f9ff },
+  { 0x1fa70, 0x1fa73 },
+  { 0x1fa78, 0x1fa7a },
+  { 0x1fa80, 0x1fa82 },
+  { 0x1fa90, 0x1fa95 },
diff --git a/src/vterm/keyboard.c b/src/vterm/keyboard.c
new file mode 100644
index 0000000000..d31c8be12d
--- /dev/null
+++ b/src/vterm/keyboard.c
@@ -0,0 +1,226 @@
+#include "vterm_internal.h"
+
+#include <stdio.h>
+
+#include "utf8.h"
+
+void vterm_keyboard_unichar(VTerm *vt, uint32_t c, VTermModifier mod)
+{
+  /* The shift modifier is never important for Unicode characters
+   * apart from Space
+   */
+  if(c != ' ')
+    mod &= ~VTERM_MOD_SHIFT;
+
+  if(mod == 0) {
+    // Normal text - ignore just shift
+    char str[6];
+    int seqlen = fill_utf8(c, str);
+    vterm_push_output_bytes(vt, str, seqlen);
+    return;
+  }
+
+  int needs_CSIu;
+  switch(c) {
+    /* Special Ctrl- letters that can't be represented elsewise */
+    case 'i': case 'j': case 'm': case '[':
+      needs_CSIu = 1;
+      break;
+    /* Ctrl-\ ] ^ _ don't need CSUu */
+    case '\\': case ']': case '^': case '_':
+      needs_CSIu = 0;
+      break;
+    /* Shift-space needs CSIu */
+    case ' ':
+      needs_CSIu = !!(mod & VTERM_MOD_SHIFT);
+      break;
+    /* All other characters needs CSIu except for letters a-z */
+    default:
+      needs_CSIu = (c < 'a' || c > 'z');
+  }
+
+  /* ALT we can just prefix with ESC; anything else requires CSI u */
+  if(needs_CSIu && (mod & ~VTERM_MOD_ALT)) {
+    vterm_push_output_sprintf_ctrl(vt, C1_CSI, "%d;%du", c, mod+1);
+    return;
+  }
+
+  if(mod & VTERM_MOD_CTRL)
+    c &= 0x1f;
+
+  vterm_push_output_sprintf(vt, "%s%c", mod & VTERM_MOD_ALT ? ESC_S : "", c);
+}
+
+typedef struct {
+  enum {
+    KEYCODE_NONE,
+    KEYCODE_LITERAL,
+    KEYCODE_TAB,
+    KEYCODE_ENTER,
+    KEYCODE_SS3,
+    KEYCODE_CSI,
+    KEYCODE_CSI_CURSOR,
+    KEYCODE_CSINUM,
+    KEYCODE_KEYPAD,
+  } type;
+  char literal;
+  int csinum;
+} keycodes_s;
+
+static keycodes_s keycodes[] = {
+  { KEYCODE_NONE }, // NONE
+
+  { KEYCODE_ENTER,   '\r'   }, // ENTER
+  { KEYCODE_TAB,     '\t'   }, // TAB
+  { KEYCODE_LITERAL, '\x7f' }, // BACKSPACE == ASCII DEL
+  { KEYCODE_LITERAL, '\x1b' }, // ESCAPE
+
+  { KEYCODE_CSI_CURSOR, 'A' }, // UP
+  { KEYCODE_CSI_CURSOR, 'B' }, // DOWN
+  { KEYCODE_CSI_CURSOR, 'D' }, // LEFT
+  { KEYCODE_CSI_CURSOR, 'C' }, // RIGHT
+
+  { KEYCODE_CSINUM, '~', 2 },  // INS
+  { KEYCODE_CSINUM, '~', 3 },  // DEL
+  { KEYCODE_CSI_CURSOR, 'H' }, // HOME
+  { KEYCODE_CSI_CURSOR, 'F' }, // END
+  { KEYCODE_CSINUM, '~', 5 },  // PAGEUP
+  { KEYCODE_CSINUM, '~', 6 },  // PAGEDOWN
+};
+
+static keycodes_s keycodes_fn[] = {
+  { KEYCODE_NONE },            // F0 - shouldn't happen
+  { KEYCODE_SS3,    'P' },     // F1
+  { KEYCODE_SS3,    'Q' },     // F2
+  { KEYCODE_SS3,    'R' },     // F3
+  { KEYCODE_SS3,    'S' },     // F4
+  { KEYCODE_CSINUM, '~', 15 }, // F5
+  { KEYCODE_CSINUM, '~', 17 }, // F6
+  { KEYCODE_CSINUM, '~', 18 }, // F7
+  { KEYCODE_CSINUM, '~', 19 }, // F8
+  { KEYCODE_CSINUM, '~', 20 }, // F9
+  { KEYCODE_CSINUM, '~', 21 }, // F10
+  { KEYCODE_CSINUM, '~', 23 }, // F11
+  { KEYCODE_CSINUM, '~', 24 }, // F12
+};
+
+static keycodes_s keycodes_kp[] = {
+  { KEYCODE_KEYPAD, '0', 'p' }, // KP_0
+  { KEYCODE_KEYPAD, '1', 'q' }, // KP_1
+  { KEYCODE_KEYPAD, '2', 'r' }, // KP_2
+  { KEYCODE_KEYPAD, '3', 's' }, // KP_3
+  { KEYCODE_KEYPAD, '4', 't' }, // KP_4
+  { KEYCODE_KEYPAD, '5', 'u' }, // KP_5
+  { KEYCODE_KEYPAD, '6', 'v' }, // KP_6
+  { KEYCODE_KEYPAD, '7', 'w' }, // KP_7
+  { KEYCODE_KEYPAD, '8', 'x' }, // KP_8
+  { KEYCODE_KEYPAD, '9', 'y' }, // KP_9
+  { KEYCODE_KEYPAD, '*', 'j' }, // KP_MULT
+  { KEYCODE_KEYPAD, '+', 'k' }, // KP_PLUS
+  { KEYCODE_KEYPAD, ',', 'l' }, // KP_COMMA
+  { KEYCODE_KEYPAD, '-', 'm' }, // KP_MINUS
+  { KEYCODE_KEYPAD, '.', 'n' }, // KP_PERIOD
+  { KEYCODE_KEYPAD, '/', 'o' }, // KP_DIVIDE
+  { KEYCODE_KEYPAD, '\n', 'M' }, // KP_ENTER
+  { KEYCODE_KEYPAD, '=', 'X' }, // KP_EQUAL
+};
+
+void vterm_keyboard_key(VTerm *vt, VTermKey key, VTermModifier mod)
+{
+  if(key == VTERM_KEY_NONE)
+    return;
+
+  keycodes_s k;
+  if(key < VTERM_KEY_FUNCTION_0) {
+    if(key >= sizeof(keycodes)/sizeof(keycodes[0]))
+      return;
+    k = keycodes[key];
+  }
+  else if(key >= VTERM_KEY_FUNCTION_0 && key <= VTERM_KEY_FUNCTION_MAX) {
+    if((key - VTERM_KEY_FUNCTION_0) >= sizeof(keycodes_fn)/sizeof(keycodes_fn[0]))
+      return;
+    k = keycodes_fn[key - VTERM_KEY_FUNCTION_0];
+  }
+  else if(key >= VTERM_KEY_KP_0) {
+    if((key - VTERM_KEY_KP_0) >= sizeof(keycodes_kp)/sizeof(keycodes_kp[0]))
+      return;
+    k = keycodes_kp[key - VTERM_KEY_KP_0];
+  }
+
+  switch(k.type) {
+  case KEYCODE_NONE:
+    break;
+
+  case KEYCODE_TAB:
+    /* Shift-Tab is CSI Z but plain Tab is 0x09 */
+    if(mod == VTERM_MOD_SHIFT)
+      vterm_push_output_sprintf_ctrl(vt, C1_CSI, "Z");
+    else if(mod & VTERM_MOD_SHIFT)
+      vterm_push_output_sprintf_ctrl(vt, C1_CSI, "1;%dZ", mod+1);
+    else
+      goto case_LITERAL;
+    break;
+
+  case KEYCODE_ENTER:
+    /* Enter is CRLF in newline mode, but just LF in linefeed */
+    if(vt->state->mode.newline)
+      vterm_push_output_sprintf(vt, "\r\n");
+    else
+      goto case_LITERAL;
+    break;
+
+  case KEYCODE_LITERAL: case_LITERAL:
+    if(mod & (VTERM_MOD_SHIFT|VTERM_MOD_CTRL))
+      vterm_push_output_sprintf_ctrl(vt, C1_CSI, "%d;%du", k.literal, mod+1);
+    else
+      vterm_push_output_sprintf(vt, mod & VTERM_MOD_ALT ? ESC_S "%c" : "%c", k.literal);
+    break;
+
+  case KEYCODE_SS3: case_SS3:
+    if(mod == 0)
+      vterm_push_output_sprintf_ctrl(vt, C1_SS3, "%c", k.literal);
+    else
+      goto case_CSI;
+    break;
+
+  case KEYCODE_CSI: case_CSI:
+    if(mod == 0)
+      vterm_push_output_sprintf_ctrl(vt, C1_CSI, "%c", k.literal);
+    else
+      vterm_push_output_sprintf_ctrl(vt, C1_CSI, "1;%d%c", mod + 1, k.literal);
+    break;
+
+  case KEYCODE_CSINUM:
+    if(mod == 0)
+      vterm_push_output_sprintf_ctrl(vt, C1_CSI, "%d%c", k.csinum, k.literal);
+    else
+      vterm_push_output_sprintf_ctrl(vt, C1_CSI, "%d;%d%c", k.csinum, mod + 1, k.literal);
+    break;
+
+  case KEYCODE_CSI_CURSOR:
+    if(vt->state->mode.cursor)
+      goto case_SS3;
+    else
+      goto case_CSI;
+
+  case KEYCODE_KEYPAD:
+    if(vt->state->mode.keypad) {
+      k.literal = k.csinum;
+      goto case_SS3;
+    }
+    else
+      goto case_LITERAL;
+  }
+}
+
+void vterm_keyboard_start_paste(VTerm *vt)
+{
+  if(vt->state->mode.bracketpaste)
+    vterm_push_output_sprintf_ctrl(vt, C1_CSI, "200~");
+}
+
+void vterm_keyboard_end_paste(VTerm *vt)
+{
+  if(vt->state->mode.bracketpaste)
+    vterm_push_output_sprintf_ctrl(vt, C1_CSI, "201~");
+}
diff --git a/src/vterm/mouse.c b/src/vterm/mouse.c
new file mode 100644
index 0000000000..f74abc3d9d
--- /dev/null
+++ b/src/vterm/mouse.c
@@ -0,0 +1,99 @@
+#include "vterm_internal.h"
+
+#include "utf8.h"
+
+static void output_mouse(VTermState *state, int code, int pressed, int modifiers, int col, int row)
+{
+  modifiers <<= 2;
+
+  switch(state->mouse_protocol) {
+  case MOUSE_X10:
+    if(col + 0x21 > 0xff)
+      col = 0xff - 0x21;
+    if(row + 0x21 > 0xff)
+      row = 0xff - 0x21;
+
+    if(!pressed)
+      code = 3;
+
+    vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "M%c%c%c",
+        (code | modifiers) + 0x20, col + 0x21, row + 0x21);
+    break;
+
+  case MOUSE_UTF8:
+    {
+      char utf8[18]; size_t len = 0;
+
+      if(!pressed)
+        code = 3;
+
+      len += fill_utf8((code | modifiers) + 0x20, utf8 + len);
+      len += fill_utf8(col + 0x21, utf8 + len);
+      len += fill_utf8(row + 0x21, utf8 + len);
+      utf8[len] = 0;
+
+      vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "M%s", utf8);
+    }
+    break;
+
+  case MOUSE_SGR:
+    vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "<%d;%d;%d%c",
+        code | modifiers, col + 1, row + 1, pressed ? 'M' : 'm');
+    break;
+
+  case MOUSE_RXVT:
+    if(!pressed)
+      code = 3;
+
+    vterm_push_output_sprintf_ctrl(state->vt, C1_CSI, "%d;%d;%dM",
+        code | modifiers, col + 1, row + 1);
+    break;
+  }
+}
+
+void vterm_mouse_move(VTerm *vt, int row, int col, VTermModifier mod)
+{
+  VTermState *state = vt->state;
+
+  if(col == state->mouse_col && row == state->mouse_row)
+    return;
+
+  state->mouse_col = col;
+  state->mouse_row = row;
+
+  if((state->mouse_flags & MOUSE_WANT_DRAG && state->mouse_buttons) ||
+     (state->mouse_flags & MOUSE_WANT_MOVE)) {
+    int button = state->mouse_buttons & 0x01 ? 1 :
+                 state->mouse_buttons & 0x02 ? 2 :
+                 state->mouse_buttons & 0x04 ? 3 : 4;
+    output_mouse(state, button-1 + 0x20, 1, mod, col, row);
+  }
+}
+
+void vterm_mouse_button(VTerm *vt, int button, bool pressed, VTermModifier mod)
+{
+  VTermState *state = vt->state;
+
+  int old_buttons = state->mouse_buttons;
+
+  if(button > 0 && button <= 3) {
+    if(pressed)
+      state->mouse_buttons |= (1 << (button-1));
+    else
+      state->mouse_buttons &= ~(1 << (button-1));
+  }
+
+  /* Most of the time we don't get button releases from 4/5 */
+  if(state->mouse_buttons == old_buttons && button < 4)
+    return;
+
+  if(!state->mouse_flags)
+    return;
+
+  if(button < 4) {
+    output_mouse(state, button-1, pressed, mod, state->mouse_col, state->mouse_row);
+  }
+  else if(button < 8) {
+    output_mouse(state, button-4 + 0x40, pressed, mod, state->mouse_col, state->mouse_row);
+  }
+}
diff --git a/src/vterm/parser.c b/src/vterm/parser.c
new file mode 100644
index 0000000000..b43a549cef
--- /dev/null
+++ b/src/vterm/parser.c
@@ -0,0 +1,402 @@
+#include "vterm_internal.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#undef DEBUG_PARSER
+
+static bool is_intermed(unsigned char c)
+{
+  return c >= 0x20 && c <= 0x2f;
+}
+
+static void do_control(VTerm *vt, unsigned char control)
+{
+  if(vt->parser.callbacks && vt->parser.callbacks->control)
+    if((*vt->parser.callbacks->control)(control, vt->parser.cbdata))
+      return;
+
+  DEBUG_LOG("libvterm: Unhandled control 0x%02x\n", control);
+}
+
+static void do_csi(VTerm *vt, char command)
+{
+#ifdef DEBUG_PARSER
+  printf("Parsed CSI args as:\n", arglen, args);
+  printf(" leader: %s\n", vt->parser.v.csi.leader);
+  for(int argi = 0; argi < vt->parser.v.csi.argi; argi++) {
+    printf(" %lu", CSI_ARG(vt->parser.v.csi.args[argi]));
+    if(!CSI_ARG_HAS_MORE(vt->parser.v.csi.args[argi]))
+      printf("\n");
+  printf(" intermed: %s\n", vt->parser.intermed);
+  }
+#endif
+
+  if(vt->parser.callbacks && vt->parser.callbacks->csi)
+    if((*vt->parser.callbacks->csi)(
+          vt->parser.v.csi.leaderlen ? vt->parser.v.csi.leader : NULL, 
+          vt->parser.v.csi.args,
+          vt->parser.v.csi.argi,
+          vt->parser.intermedlen ? vt->parser.intermed : NULL,
+          command,
+          vt->parser.cbdata))
+      return;
+
+  DEBUG_LOG("libvterm: Unhandled CSI %c\n", command);
+}
+
+static void do_escape(VTerm *vt, char command)
+{
+  char seq[INTERMED_MAX+1];
+
+  size_t len = vt->parser.intermedlen;
+  strncpy(seq, vt->parser.intermed, len);
+  seq[len++] = command;
+  seq[len]   = 0;
+
+  if(vt->parser.callbacks && vt->parser.callbacks->escape)
+    if((*vt->parser.callbacks->escape)(seq, len, vt->parser.cbdata))
+      return;
+
+  DEBUG_LOG("libvterm: Unhandled escape ESC 0x%02x\n", command);
+}
+
+static void string_fragment(VTerm *vt, const char *str, size_t len, bool final)
+{
+  VTermStringFragment frag = {
+    .str     = str,
+    .len     = len,
+    .initial = vt->parser.string_initial,
+    .final   = final,
+  };
+
+  switch(vt->parser.state) {
+    case OSC:
+      if(vt->parser.callbacks && vt->parser.callbacks->osc)
+        (*vt->parser.callbacks->osc)(vt->parser.v.osc.command, frag, vt->parser.cbdata);
+      break;
+
+    case DCS:
+      if(vt->parser.callbacks &