Added interactive CLI

Added Interactive CLI

Pull Request resolved: #242

38 files changed, 9559 insertions, 0 deletions

diff --git a/contrib/restricted/CMakeLists.darwin-x86_64.txt b/contrib/restricted/CMakeLists.darwin-x86_64.txt
index 1b481947a0..14184a57bb 100644
--- a/contrib/restricted/CMakeLists.darwin-x86_64.txt
+++ b/contrib/restricted/CMakeLists.darwin-x86_64.txt
@@ -17,5 +17,6 @@ add_subdirectory(google)
 add_subdirectory(googletest)
 add_subdirectory(http-parser)
 add_subdirectory(nlohmann_json)
+add_subdirectory(patched)
 add_subdirectory(thrift)
 add_subdirectory(uriparser)
diff --git a/contrib/restricted/CMakeLists.linux-aarch64.txt b/contrib/restricted/CMakeLists.linux-aarch64.txt
index 1b481947a0..14184a57bb 100644
--- a/contrib/restricted/CMakeLists.linux-aarch64.txt
+++ b/contrib/restricted/CMakeLists.linux-aarch64.txt
@@ -17,5 +17,6 @@ add_subdirectory(google)
 add_subdirectory(googletest)
 add_subdirectory(http-parser)
 add_subdirectory(nlohmann_json)
+add_subdirectory(patched)
 add_subdirectory(thrift)
 add_subdirectory(uriparser)
diff --git a/contrib/restricted/CMakeLists.linux-x86_64.txt b/contrib/restricted/CMakeLists.linux-x86_64.txt
index 1b481947a0..14184a57bb 100644
--- a/contrib/restricted/CMakeLists.linux-x86_64.txt
+++ b/contrib/restricted/CMakeLists.linux-x86_64.txt
@@ -17,5 +17,6 @@ add_subdirectory(google)
 add_subdirectory(googletest)
 add_subdirectory(http-parser)
 add_subdirectory(nlohmann_json)
+add_subdirectory(patched)
 add_subdirectory(thrift)
 add_subdirectory(uriparser)
diff --git a/contrib/restricted/CMakeLists.windows-x86_64.txt b/contrib/restricted/CMakeLists.windows-x86_64.txt
index 6f1b871db7..76a979c13b 100644
--- a/contrib/restricted/CMakeLists.windows-x86_64.txt
+++ b/contrib/restricted/CMakeLists.windows-x86_64.txt
@@ -16,5 +16,6 @@ add_subdirectory(google)
 add_subdirectory(googletest)
 add_subdirectory(http-parser)
 add_subdirectory(nlohmann_json)
+add_subdirectory(patched)
 add_subdirectory(thrift)
 add_subdirectory(uriparser)
diff --git a/contrib/restricted/patched/CMakeLists.txt b/contrib/restricted/patched/CMakeLists.txt
new file mode 100644
index 0000000000..83ec4cc7b6
--- /dev/null
+++ b/contrib/restricted/patched/CMakeLists.txt
@@ -0,0 +1,9 @@
+
+# This file was generated by the build system used internally in the Yandex monorepo.
+# Only simple modifications are allowed (adding source-files to targets, adding simple properties
+# like target_include_directories). These modifications will be ported to original
+# ya.make files by maintainers. Any complex modifications which can't be ported back to the
+# original buildsystem will not be accepted.
+
+
+add_subdirectory(replxx)
diff --git a/contrib/restricted/patched/replxx/CMakeLists.darwin-x86_64.txt b/contrib/restricted/patched/replxx/CMakeLists.darwin-x86_64.txt
new file mode 100644
index 0000000000..a39729e6df
--- /dev/null
+++ b/contrib/restricted/patched/replxx/CMakeLists.darwin-x86_64.txt
@@ -0,0 +1,36 @@
+
+# This file was generated by the build system used internally in the Yandex monorepo.
+# Only simple modifications are allowed (adding source-files to targets, adding simple properties
+# like target_include_directories). These modifications will be ported to original
+# ya.make files by maintainers. Any complex modifications which can't be ported back to the
+# original buildsystem will not be accepted.
+
+
+
+add_library(restricted-patched-replxx)
+target_compile_options(restricted-patched-replxx PRIVATE
+  -DREPLXX_BUILDING_DLL
+  $<IF:$<CXX_COMPILER_ID:MSVC>,,-Wno-everything>
+)
+target_include_directories(restricted-patched-replxx PUBLIC
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/include
+)
+target_include_directories(restricted-patched-replxx PRIVATE
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src
+)
+target_link_libraries(restricted-patched-replxx PUBLIC
+  contrib-libs-cxxsupp
+)
+target_sources(restricted-patched-replxx PRIVATE
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/ConvertUTF.cpp
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/conversion.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/escape.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/history.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/prompt.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/replxx.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/replxx_impl.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/terminal.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/util.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/wcwidth.cpp
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/windows.cxx
+)
diff --git a/contrib/restricted/patched/replxx/CMakeLists.linux-aarch64.txt b/contrib/restricted/patched/replxx/CMakeLists.linux-aarch64.txt
new file mode 100644
index 0000000000..bbd8abd9d4
--- /dev/null
+++ b/contrib/restricted/patched/replxx/CMakeLists.linux-aarch64.txt
@@ -0,0 +1,37 @@
+
+# This file was generated by the build system used internally in the Yandex monorepo.
+# Only simple modifications are allowed (adding source-files to targets, adding simple properties
+# like target_include_directories). These modifications will be ported to original
+# ya.make files by maintainers. Any complex modifications which can't be ported back to the
+# original buildsystem will not be accepted.
+
+
+
+add_library(restricted-patched-replxx)
+target_compile_options(restricted-patched-replxx PRIVATE
+  -DREPLXX_BUILDING_DLL
+  $<IF:$<CXX_COMPILER_ID:MSVC>,,-Wno-everything>
+)
+target_include_directories(restricted-patched-replxx PUBLIC
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/include
+)
+target_include_directories(restricted-patched-replxx PRIVATE
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src
+)
+target_link_libraries(restricted-patched-replxx PUBLIC
+  contrib-libs-linux-headers
+  contrib-libs-cxxsupp
+)
+target_sources(restricted-patched-replxx PRIVATE
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/ConvertUTF.cpp
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/conversion.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/escape.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/history.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/prompt.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/replxx.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/replxx_impl.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/terminal.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/util.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/wcwidth.cpp
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/windows.cxx
+)
diff --git a/contrib/restricted/patched/replxx/CMakeLists.linux-x86_64.txt b/contrib/restricted/patched/replxx/CMakeLists.linux-x86_64.txt
new file mode 100644
index 0000000000..bbd8abd9d4
--- /dev/null
+++ b/contrib/restricted/patched/replxx/CMakeLists.linux-x86_64.txt
@@ -0,0 +1,37 @@
+
+# This file was generated by the build system used internally in the Yandex monorepo.
+# Only simple modifications are allowed (adding source-files to targets, adding simple properties
+# like target_include_directories). These modifications will be ported to original
+# ya.make files by maintainers. Any complex modifications which can't be ported back to the
+# original buildsystem will not be accepted.
+
+
+
+add_library(restricted-patched-replxx)
+target_compile_options(restricted-patched-replxx PRIVATE
+  -DREPLXX_BUILDING_DLL
+  $<IF:$<CXX_COMPILER_ID:MSVC>,,-Wno-everything>
+)
+target_include_directories(restricted-patched-replxx PUBLIC
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/include
+)
+target_include_directories(restricted-patched-replxx PRIVATE
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src
+)
+target_link_libraries(restricted-patched-replxx PUBLIC
+  contrib-libs-linux-headers
+  contrib-libs-cxxsupp
+)
+target_sources(restricted-patched-replxx PRIVATE
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/ConvertUTF.cpp
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/conversion.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/escape.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/history.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/prompt.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/replxx.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/replxx_impl.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/terminal.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/util.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/wcwidth.cpp
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/windows.cxx
+)
diff --git a/contrib/restricted/patched/replxx/CMakeLists.txt b/contrib/restricted/patched/replxx/CMakeLists.txt
new file mode 100644
index 0000000000..f8b31df0c1
--- /dev/null
+++ b/contrib/restricted/patched/replxx/CMakeLists.txt
@@ -0,0 +1,17 @@
+
+# This file was generated by the build system used internally in the Yandex monorepo.
+# Only simple modifications are allowed (adding source-files to targets, adding simple properties
+# like target_include_directories). These modifications will be ported to original
+# ya.make files by maintainers. Any complex modifications which can't be ported back to the
+# original buildsystem will not be accepted.
+
+
+if (CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64" AND NOT HAVE_CUDA)
+  include(CMakeLists.linux-aarch64.txt)
+elseif (CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
+  include(CMakeLists.darwin-x86_64.txt)
+elseif (WIN32 AND CMAKE_SYSTEM_PROCESSOR STREQUAL "AMD64" AND NOT HAVE_CUDA)
+  include(CMakeLists.windows-x86_64.txt)
+elseif (CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64" AND NOT HAVE_CUDA)
+  include(CMakeLists.linux-x86_64.txt)
+endif()
diff --git a/contrib/restricted/patched/replxx/CMakeLists.windows-x86_64.txt b/contrib/restricted/patched/replxx/CMakeLists.windows-x86_64.txt
new file mode 100644
index 0000000000..a39729e6df
--- /dev/null
+++ b/contrib/restricted/patched/replxx/CMakeLists.windows-x86_64.txt
@@ -0,0 +1,36 @@
+
+# This file was generated by the build system used internally in the Yandex monorepo.
+# Only simple modifications are allowed (adding source-files to targets, adding simple properties
+# like target_include_directories). These modifications will be ported to original
+# ya.make files by maintainers. Any complex modifications which can't be ported back to the
+# original buildsystem will not be accepted.
+
+
+
+add_library(restricted-patched-replxx)
+target_compile_options(restricted-patched-replxx PRIVATE
+  -DREPLXX_BUILDING_DLL
+  $<IF:$<CXX_COMPILER_ID:MSVC>,,-Wno-everything>
+)
+target_include_directories(restricted-patched-replxx PUBLIC
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/include
+)
+target_include_directories(restricted-patched-replxx PRIVATE
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src
+)
+target_link_libraries(restricted-patched-replxx PUBLIC
+  contrib-libs-cxxsupp
+)
+target_sources(restricted-patched-replxx PRIVATE
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/ConvertUTF.cpp
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/conversion.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/escape.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/history.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/prompt.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/replxx.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/replxx_impl.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/terminal.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/util.cxx
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/wcwidth.cpp
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/patched/replxx/src/windows.cxx
+)
diff --git a/contrib/restricted/patched/replxx/LICENSE.md b/contrib/restricted/patched/replxx/LICENSE.md
new file mode 100644
index 0000000000..c73c3f241e
--- /dev/null
+++ b/contrib/restricted/patched/replxx/LICENSE.md
@@ -0,0 +1,63 @@
+Copyright (c) 2017-2018, Marcin Konarski (amok at codestation.org)  
+Copyright (c) 2010, Salvatore Sanfilippo (antirez at gmail dot com)  
+Copyright (c) 2010, Pieter Noordhuis (pcnoordhuis at gmail dot com)
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+  * Neither the name of Redis nor the names of its contributors may be used
+    to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+
+wcwidth.cpp
+===========
+
+Markus Kuhn -- 2007-05-26 (Unicode 5.0)
+
+Permission to use, copy, modify, and distribute this software
+for any purpose and without fee is hereby granted. The author
+disclaims all warranties with regard to this software.
+
+
+ConvertUTF.cpp
+==============
+
+Copyright 2001-2004 Unicode, Inc.
+
+Disclaimer
+
+This source code is provided as is by Unicode, Inc. No claims are
+made as to fitness for any particular purpose. No warranties of any
+kind are expressed or implied. The recipient agrees to determine
+applicability of information provided. If this file has been
+purchased on magnetic or optical media from Unicode, Inc., the
+sole remedy for any claim will be exchange of defective media
+within 90 days of receipt.
+
+Limitations on Rights to Redistribute This Code
+
+Unicode, Inc. hereby grants the right to freely use the information
+supplied in this file in the creation of products supporting the
+Unicode Standard, and to make copies of this file in any form
+for internal or external distribution as long as this notice
+remains attached.
diff --git a/contrib/restricted/patched/replxx/README.md b/contrib/restricted/patched/replxx/README.md
new file mode 100644
index 0000000000..7e9e593041
--- /dev/null
+++ b/contrib/restricted/patched/replxx/README.md
@@ -0,0 +1,105 @@
+# Read Evaluate Print Loop ++
+
+![demo](https://codestation.org/download/replxx.gif)
+
+![Build Status](https://github.com/AmokHuginnsson/replxx/actions/workflows/ci.yml/badge.svg)
+
+A small, portable GNU readline replacement for Linux, Windows and
+MacOS which is capable of handling UTF-8 characters. Unlike GNU
+readline, which is GPL, this library uses a BSD license and can be
+used in any kind of program.
+
+## Origin
+
+This replxx implementation is based on the work by
+[ArangoDB Team](https://github.com/arangodb/linenoise-ng) and
+[Salvatore Sanfilippo](https://github.com/antirez/linenoise) and
+10gen Inc.  The goal is to create a zero-config, BSD
+licensed, readline replacement usable in Apache2 or BSD licensed
+programs.
+
+## Features
+
+* single-line and multi-line editing mode with the usual key bindings implemented
+* history handling
+* completion
+* syntax highlighting
+* hints
+* BSD license source code
+* Only uses a subset of VT100 escapes (ANSI.SYS compatible)
+* UTF8 aware
+* support for Linux, MacOS and Windows
+
+## Requirements
+
+To build this library, you will need a C++11-enabled compiler and
+some recent version of CMake.
+
+## Build instructions
+
+### *nix
+
+1. Create a build directory
+
+```bash
+mkdir -p build && cd build
+```
+
+2. Build the library
+
+```bash
+cmake -DCMAKE_BUILD_TYPE=Release .. && make
+```
+
+3. Install the library at the default target location
+
+```bash
+sudo make install
+```
+
+The default installation location can be adjusted by setting the `DESTDIR`
+variable when invoking `make install`:
+
+```bash
+make DESTDIR=/tmp install
+```
+
+### Windows
+
+1. Create a build directory in MS-DOS command prompt
+
+```
+md build
+cd build
+```
+
+2. Generate Visual Studio solution file with cmake
+
+* 32 bit: 
+```bash
+cmake -G "Visual Studio 12 2013" -DCMAKE_BUILD_TYPE=Release ..
+```
+* 64 bit:
+```bash
+cmake -G "Visual Studio 12 2013 Win64" -DCMAKE_BUILD_TYPE=Release ..
+```
+
+3. Open the generated file `replxx.sln` in the `build` subdirectory with Visual Studio.
+
+## Tested with...
+
+ * Linux text only console ($TERM = linux)
+ * Linux KDE terminal application ($TERM = xterm)
+ * Linux xterm ($TERM = xterm)
+ * Linux Buildroot ($TERM = vt100)
+ * Mac OS X iTerm ($TERM = xterm)
+ * Mac OS X default Terminal.app ($TERM = xterm)
+ * OpenBSD 4.5 through an OSX Terminal.app ($TERM = screen)
+ * IBM AIX 6.1
+ * FreeBSD xterm ($TERM = xterm)
+ * ANSI.SYS
+ * Emacs comint mode ($TERM = dumb)
+ * Windows
+
+Please test it everywhere you can and report back!
+
diff --git a/contrib/restricted/patched/replxx/include/replxx.h b/contrib/restricted/patched/replxx/include/replxx.h
new file mode 100644
index 0000000000..a9e2852b1c
--- /dev/null
+++ b/contrib/restricted/patched/replxx/include/replxx.h
@@ -0,0 +1,645 @@
+/* linenoise.h -- guerrilla line editing library against the idea that a
+ * line editing lib needs to be 20,000 lines of C code.
+ *
+ * See linenoise.c for more information.
+ *
+ * Copyright (c) 2010, Salvatore Sanfilippo <antirez at gmail dot com>
+ * Copyright (c) 2010, Pieter Noordhuis <pcnoordhuis at gmail dot com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __REPLXX_H
+#define __REPLXX_H
+
+#define REPLXX_VERSION "0.0.2"
+#define REPLXX_VERSION_MAJOR 0
+#define REPLXX_VERSION_MINOR 0
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * For use in Windows DLLs:
+ *
+ * If you are building replxx into a DLL,
+ * unless you are using supplied CMake based build,
+ * ensure that 'REPLXX_BUILDING_DLL' is defined when
+ * building the DLL so that proper symbols are exported.
+ */
+#if defined( _WIN32 ) && ! defined( REPLXX_STATIC )
+#	ifdef REPLXX_BUILDING_DLL
+#		define REPLXX_IMPEXP __declspec( dllexport )
+#	else
+#		define REPLXX_IMPEXP __declspec( dllimport )
+#	endif
+#else
+#	define REPLXX_IMPEXP /**/
+#endif
+
+/*! \brief Color definitions to use in highlighter callbacks.
+ */
+typedef enum {
+	REPLXX_COLOR_BLACK         = 0,
+	REPLXX_COLOR_RED           = 1,
+	REPLXX_COLOR_GREEN         = 2,
+	REPLXX_COLOR_BROWN         = 3,
+	REPLXX_COLOR_BLUE          = 4,
+	REPLXX_COLOR_MAGENTA       = 5,
+	REPLXX_COLOR_CYAN          = 6,
+	REPLXX_COLOR_LIGHTGRAY     = 7,
+	REPLXX_COLOR_GRAY          = 8,
+	REPLXX_COLOR_BRIGHTRED     = 9,
+	REPLXX_COLOR_BRIGHTGREEN   = 10,
+	REPLXX_COLOR_YELLOW        = 11,
+	REPLXX_COLOR_BRIGHTBLUE    = 12,
+	REPLXX_COLOR_BRIGHTMAGENTA = 13,
+	REPLXX_COLOR_BRIGHTCYAN    = 14,
+	REPLXX_COLOR_WHITE         = 15,
+	REPLXX_COLOR_DEFAULT       = 1u << 16u
+} ReplxxColor;
+
+enum { REPLXX_KEY_BASE         = 0x0010ffff + 1 };
+enum { REPLXX_KEY_BASE_SHIFT   = 0x01000000 };
+enum { REPLXX_KEY_BASE_CONTROL = 0x02000000 };
+enum { REPLXX_KEY_BASE_META    = 0x04000000 };
+enum { REPLXX_KEY_ESCAPE       = 27 };
+enum { REPLXX_KEY_PAGE_UP      = REPLXX_KEY_BASE      + 1 };
+enum { REPLXX_KEY_PAGE_DOWN    = REPLXX_KEY_PAGE_UP   + 1 };
+enum { REPLXX_KEY_DOWN         = REPLXX_KEY_PAGE_DOWN + 1 };
+enum { REPLXX_KEY_UP           = REPLXX_KEY_DOWN      + 1 };
+enum { REPLXX_KEY_LEFT         = REPLXX_KEY_UP        + 1 };
+enum { REPLXX_KEY_RIGHT        = REPLXX_KEY_LEFT      + 1 };
+enum { REPLXX_KEY_HOME         = REPLXX_KEY_RIGHT     + 1 };
+enum { REPLXX_KEY_END          = REPLXX_KEY_HOME      + 1 };
+enum { REPLXX_KEY_DELETE       = REPLXX_KEY_END       + 1 };
+enum { REPLXX_KEY_INSERT       = REPLXX_KEY_DELETE    + 1 };
+enum { REPLXX_KEY_F1           = REPLXX_KEY_INSERT    + 1 };
+enum { REPLXX_KEY_F2           = REPLXX_KEY_F1        + 1 };
+enum { REPLXX_KEY_F3           = REPLXX_KEY_F2        + 1 };
+enum { REPLXX_KEY_F4           = REPLXX_KEY_F3        + 1 };
+enum { REPLXX_KEY_F5           = REPLXX_KEY_F4        + 1 };
+enum { REPLXX_KEY_F6           = REPLXX_KEY_F5        + 1 };
+enum { REPLXX_KEY_F7           = REPLXX_KEY_F6        + 1 };
+enum { REPLXX_KEY_F8           = REPLXX_KEY_F7        + 1 };
+enum { REPLXX_KEY_F9           = REPLXX_KEY_F8        + 1 };
+enum { REPLXX_KEY_F10          = REPLXX_KEY_F9        + 1 };
+enum { REPLXX_KEY_F11          = REPLXX_KEY_F10       + 1 };
+enum { REPLXX_KEY_F12          = REPLXX_KEY_F11       + 1 };
+enum { REPLXX_KEY_F13          = REPLXX_KEY_F12       + 1 };
+enum { REPLXX_KEY_F14          = REPLXX_KEY_F13       + 1 };
+enum { REPLXX_KEY_F15          = REPLXX_KEY_F14       + 1 };
+enum { REPLXX_KEY_F16          = REPLXX_KEY_F15       + 1 };
+enum { REPLXX_KEY_F17          = REPLXX_KEY_F16       + 1 };
+enum { REPLXX_KEY_F18          = REPLXX_KEY_F17       + 1 };
+enum { REPLXX_KEY_F19          = REPLXX_KEY_F18       + 1 };
+enum { REPLXX_KEY_F20          = REPLXX_KEY_F19       + 1 };
+enum { REPLXX_KEY_F21          = REPLXX_KEY_F20       + 1 };
+enum { REPLXX_KEY_F22          = REPLXX_KEY_F21       + 1 };
+enum { REPLXX_KEY_F23          = REPLXX_KEY_F22       + 1 };
+enum { REPLXX_KEY_F24          = REPLXX_KEY_F23       + 1 };
+enum { REPLXX_KEY_MOUSE        = REPLXX_KEY_F24       + 1 };
+enum { REPLXX_KEY_PASTE_START  = REPLXX_KEY_MOUSE     + 1 };
+enum { REPLXX_KEY_PASTE_FINISH = REPLXX_KEY_PASTE_START + 1 };
+
+#define REPLXX_KEY_SHIFT( key )   ( ( key ) | REPLXX_KEY_BASE_SHIFT )
+#define REPLXX_KEY_CONTROL( key ) ( ( key ) | REPLXX_KEY_BASE_CONTROL )
+#define REPLXX_KEY_META( key )    ( ( key ) | REPLXX_KEY_BASE_META )
+
+enum { REPLXX_KEY_BACKSPACE    = REPLXX_KEY_CONTROL( 'H' ) };
+enum { REPLXX_KEY_TAB          = REPLXX_KEY_CONTROL( 'I' ) };
+enum { REPLXX_KEY_ENTER        = REPLXX_KEY_CONTROL( 'M' ) };
+enum { REPLXX_KEY_ABORT        = REPLXX_KEY_META( REPLXX_KEY_CONTROL( 'M' ) ) };
+
+/*! \brief List of built-in actions that act upon user input.
+ */
+typedef enum {
+	REPLXX_ACTION_INSERT_CHARACTER,
+	REPLXX_ACTION_NEW_LINE,
+	REPLXX_ACTION_DELETE_CHARACTER_UNDER_CURSOR,
+	REPLXX_ACTION_DELETE_CHARACTER_LEFT_OF_CURSOR,
+	REPLXX_ACTION_KILL_TO_END_OF_LINE,
+	REPLXX_ACTION_KILL_TO_BEGINING_OF_LINE,
+	REPLXX_ACTION_KILL_TO_END_OF_WORD,
+	REPLXX_ACTION_KILL_TO_BEGINING_OF_WORD,
+	REPLXX_ACTION_KILL_TO_END_OF_SUBWORD,
+	REPLXX_ACTION_KILL_TO_BEGINING_OF_SUBWORD,
+	REPLXX_ACTION_KILL_TO_WHITESPACE_ON_LEFT,
+	REPLXX_ACTION_YANK,
+	REPLXX_ACTION_YANK_CYCLE,
+	REPLXX_ACTION_YANK_LAST_ARG,
+	REPLXX_ACTION_MOVE_CURSOR_TO_BEGINING_OF_LINE,
+	REPLXX_ACTION_MOVE_CURSOR_TO_END_OF_LINE,
+	REPLXX_ACTION_MOVE_CURSOR_ONE_WORD_LEFT,
+	REPLXX_ACTION_MOVE_CURSOR_ONE_WORD_RIGHT,
+	REPLXX_ACTION_MOVE_CURSOR_ONE_SUBWORD_LEFT,
+	REPLXX_ACTION_MOVE_CURSOR_ONE_SUBWORD_RIGHT,
+	REPLXX_ACTION_MOVE_CURSOR_LEFT,
+	REPLXX_ACTION_MOVE_CURSOR_RIGHT,
+	REPLXX_ACTION_LINE_NEXT,
+	REPLXX_ACTION_LINE_PREVIOUS,
+	REPLXX_ACTION_HISTORY_MOVE_NEXT,
+	REPLXX_ACTION_HISTORY_MOVE_PREVIOUS,
+	REPLXX_ACTION_HISTORY_FIRST,
+	REPLXX_ACTION_HISTORY_LAST,
+	REPLXX_ACTION_HISTORY_RESTORE,
+	REPLXX_ACTION_HISTORY_RESTORE_CURRENT,
+	REPLXX_ACTION_HISTORY_INCREMENTAL_SEARCH,
+	REPLXX_ACTION_HISTORY_COMMON_PREFIX_SEARCH,
+	REPLXX_ACTION_HINT_NEXT,
+	REPLXX_ACTION_HINT_PREVIOUS,
+	REPLXX_ACTION_CAPITALIZE_WORD,
+	REPLXX_ACTION_LOWERCASE_WORD,
+	REPLXX_ACTION_UPPERCASE_WORD,
+	REPLXX_ACTION_CAPITALIZE_SUBWORD,
+	REPLXX_ACTION_LOWERCASE_SUBWORD,
+	REPLXX_ACTION_UPPERCASE_SUBWORD,
+	REPLXX_ACTION_TRANSPOSE_CHARACTERS,
+	REPLXX_ACTION_TOGGLE_OVERWRITE_MODE,
+#ifndef _WIN32
+	REPLXX_ACTION_VERBATIM_INSERT,
+	REPLXX_ACTION_SUSPEND,
+#endif
+	REPLXX_ACTION_BRACKETED_PASTE,
+	REPLXX_ACTION_CLEAR_SCREEN,
+	REPLXX_ACTION_CLEAR_SELF,
+	REPLXX_ACTION_REPAINT,
+	REPLXX_ACTION_COMPLETE_LINE,
+	REPLXX_ACTION_COMPLETE_NEXT,
+	REPLXX_ACTION_COMPLETE_PREVIOUS,
+	REPLXX_ACTION_COMMIT_LINE,
+	REPLXX_ACTION_ABORT_LINE,
+	REPLXX_ACTION_SEND_EOF
+} ReplxxAction;
+
+/*! \brief Possible results of key-press handler actions.
+ */
+typedef enum {
+	REPLXX_ACTION_RESULT_CONTINUE, /*!< Continue processing user input. */
+	REPLXX_ACTION_RESULT_RETURN,   /*!< Return user input entered so far. */
+	REPLXX_ACTION_RESULT_BAIL      /*!< Stop processing user input, returns nullptr from the \e input() call. */
+} ReplxxActionResult;
+
+typedef struct ReplxxStateTag {
+	char const* text;
+	int cursorPosition;
+} ReplxxState;
+
+typedef struct Replxx Replxx;
+typedef struct ReplxxHistoryScan ReplxxHistoryScan;
+typedef struct ReplxxHistoryEntryTag {
+	char const* timestamp;
+	char const* text;
+} ReplxxHistoryEntry;
+
+/*! \brief Create Replxx library resource holder.
+ *
+ * Use replxx_end() to free resources acquired with this function.
+ *
+ * \return Replxx library resource holder.
+ */
+REPLXX_IMPEXP Replxx* replxx_init( void );
+
+/*! \brief Cleanup resources used by Replxx library.
+ *
+ * \param replxx - a Replxx library resource holder.
+ */
+REPLXX_IMPEXP void replxx_end( Replxx* replxx );
+
+/*! \brief Line modification callback type definition.
+ *
+ * User can observe and modify line contents (and cursor position)
+ * in response to changes to both introduced by the user through
+ * normal interactions.
+ *
+ * When callback returns Replxx updates current line content
+ * and current cursor position to the ones updated by the callback.
+ *
+ * \param line[in,out] - a R/W reference to an UTF-8 encoded input entered by the user so far.
+ * \param cursorPosition[in,out] - a R/W reference to current cursor position.
+ * \param userData - pointer to opaque user data block.
+ */
+typedef void (replxx_modify_callback_t)(char** input, int* contextLen, void* userData);
+
+/*! \brief Register modify callback.
+ *
+ * \param fn - user defined callback function.
+ * \param userData - pointer to opaque user data block to be passed into each invocation of the callback.
+ */
+REPLXX_IMPEXP void replxx_set_modify_callback( Replxx*, replxx_modify_callback_t* fn, void* userData );
+
+/*! \brief Highlighter callback type definition.
+ *
+ * If user want to have colorful input she must simply install highlighter callback.
+ * The callback would be invoked by the library after each change to the input done by
+ * the user. After callback returns library uses data from colors buffer to colorize
+ * displayed user input.
+ *
+ * \e size of \e colors buffer is equal to number of code points in user \e input
+ * which will be different from simple `strlen( input )`!
+ *
+ * \param input - an UTF-8 encoded input entered by the user so far.
+ * \param colors - output buffer for color information.
+ * \param size - size of output buffer for color information.
+ * \param userData - pointer to opaque user data block.
+ */
+typedef void (replxx_highlighter_callback_t)(char const* input, ReplxxColor* colors, int size, void* userData);
+
+/*! \brief Register highlighter callback.
+ *
+ * \param fn - user defined callback function.
+ * \param userData - pointer to opaque user data block to be passed into each invocation of the callback.
+ */
+REPLXX_IMPEXP void replxx_set_highlighter_callback( Replxx*, replxx_highlighter_callback_t* fn, void* userData );
+
+typedef struct replxx_completions replxx_completions;
+
+/*! \brief Completions callback type definition.
+ *
+ * \e contextLen is counted in Unicode code points (not in bytes!).
+ *
+ * For user input:
+ * if ( obj.me
+ *
+ * input == "if ( obj.me"
+ * contextLen == 2 (depending on \e replxx_set_word_break_characters())
+ *
+ * Client application is free to update \e contextLen to be 6 (or any other non-negative
+ * number not greater than the number of code points in input) if it makes better sense
+ * for given client application semantics.
+ *
+ * \param input - UTF-8 encoded input entered by the user until current cursor position.
+ * \param completions - pointer to opaque list of user completions.
+ * \param contextLen[in,out] - length of the additional context to provide while displaying completions.
+ * \param userData - pointer to opaque user data block.
+ */
+typedef void(replxx_completion_callback_t)(const char* input, replxx_completions* completions, int* contextLen, void* userData);
+
+/*! \brief Register completion callback.
+ *
+ * \param fn - user defined callback function.
+ * \param userData - pointer to opaque user data block to be passed into each invocation of the callback.
+ */
+REPLXX_IMPEXP void replxx_set_completion_callback( Replxx*, replxx_completion_callback_t* fn, void* userData );
+
+/*! \brief Add another possible completion for current user input.
+ *
+ * \param completions - pointer to opaque list of user completions.
+ * \param str - UTF-8 encoded completion string.
+ */
+REPLXX_IMPEXP void replxx_add_completion( replxx_completions* completions, const char* str );
+
+/*! \brief Add another possible completion for current user input.
+ *
+ * \param completions - pointer to opaque list of user completions.
+ * \param str - UTF-8 encoded completion string.
+ * \param color - a color for the completion.
+ */
+REPLXX_IMPEXP void replxx_add_color_completion( replxx_completions* completions, const char* str, ReplxxColor color );
+
+typedef struct replxx_hints replxx_hints;
+
+/*! \brief Hints callback type definition.
+ *
+ * \e contextLen is counted in Unicode code points (not in bytes!).
+ *
+ * For user input:
+ * if ( obj.me
+ *
+ * input == "if ( obj.me"
+ * contextLen == 2 (depending on \e replxx_set_word_break_characters())
+ *
+ * Client application is free to update \e contextLen to be 6 (or any other non-negative
+ * number not greater than the number of code points in input) if it makes better sense
+ * for given client application semantics.
+ *
+ * \param input - UTF-8 encoded input entered by the user until current cursor position.
+ * \param hints - pointer to opaque list of possible hints.
+ * \param contextLen[in,out] - length of the additional context to provide while displaying hints.
+ * \param color - a color used for displaying hints.
+ * \param userData - pointer to opaque user data block.
+ */
+typedef void(replxx_hint_callback_t)(const char* input, replxx_hints* hints, int* contextLen, ReplxxColor* color, void* userData);
+
+/*! \brief Register hints callback.
+ *
+ * \param fn - user defined callback function.
+ * \param userData - pointer to opaque user data block to be passed into each invocation of the callback.
+ */
+REPLXX_IMPEXP void replxx_set_hint_callback( Replxx*, replxx_hint_callback_t* fn, void* userData );
+
+/*! \brief Key press handler type definition.
+ *
+ * \param code - the key code replxx got from terminal.
+ * \return Decision on how should input() behave after this key handler returns.
+ */
+typedef ReplxxActionResult (key_press_handler_t)( int code, void* userData );
+
+/*! \brief Add another possible hint for current user input.
+ *
+ * \param hints - pointer to opaque list of hints.
+ * \param str - UTF-8 encoded hint string.
+ */
+REPLXX_IMPEXP void replxx_add_hint( replxx_hints* hints, const char* str );
+
+/*! \brief Read line of user input.
+ *
+ * Returned pointer is managed by the library and is not to be freed in the client.
+ *
+ * \param prompt - prompt to be displayed before getting user input.
+ * \return An UTF-8 encoded input given by the user (or nullptr on EOF).
+ */
+REPLXX_IMPEXP char const* replxx_input( Replxx*, const char* prompt );
+
+/*! \brief Get current state data.
+ *
+ * This call is intended to be used in handlers.
+ *
+ * \param state - buffer for current state of the model.
+ */
+REPLXX_IMPEXP void replxx_get_state( Replxx*, ReplxxState* state );
+
+/*! \brief Set new state data.
+ *
+ * This call is intended to be used in handlers.
+ *
+ * \param state - new state of the model.
+ */
+REPLXX_IMPEXP void replxx_set_state( Replxx*, ReplxxState* state );
+
+/*! \brief Enable/disable case insensitive history search and completion.
+ *
+ * \param val - if set to non-zero then history search and completion will be case insensitive.
+ */
+REPLXX_IMPEXP void replxx_set_ignore_case( Replxx*, int val );
+
+/*! \brief Print formatted string to standard output.
+ *
+ * This function ensures proper handling of ANSI escape sequences
+ * contained in printed data, which is especially useful on Windows
+ * since Unixes handle them correctly out of the box.
+ *
+ * \param fmt - printf style format.
+ */
+REPLXX_IMPEXP int replxx_print( Replxx*, char const* fmt, ... );
+
+/*! \brief Prints a char array with the given length to standard output.
+ *
+ * \copydetails print
+ *
+ * \param str - The char array to print.
+ * \param length - The length of the array.
+ */
+REPLXX_IMPEXP int replxx_write( Replxx*, char const* str, int length );
+
+/*! \brief Asynchronously change the prompt while replxx_input() call is in efect.
+ *
+ * Can be used to change the prompt from callbacks or other threads.
+ *
+ * \param prompt - The prompt string to change to.
+ */
+REPLXX_IMPEXP void replxx_set_prompt( Replxx*, const char* prompt );
+
+/*! \brief Schedule an emulated key press event.
+ *
+ * \param code - key press code to be emulated.
+ */
+REPLXX_IMPEXP void replxx_emulate_key_press( Replxx*, int unsigned code );
+
+/*! \brief Invoke built-in action handler.
+ *
+ * \pre This function can be called only from key-press handler.
+ *
+ * \param action - a built-in action to invoke.
+ * \param code - a supplementary key-code to consume by built-in action handler.
+ * \return The action result informing the replxx what shall happen next.
+ */
+REPLXX_IMPEXP ReplxxActionResult replxx_invoke( Replxx*, ReplxxAction action, int unsigned code );
+
+/*! \brief Bind user defined action to handle given key-press event.
+ *
+ * \param code - handle this key-press event with following handler.
+ * \param handler - use this handler to handle key-press event.
+ * \param userData - supplementary user data passed to invoked handlers.
+ */
+REPLXX_IMPEXP void replxx_bind_key( Replxx*, int code, key_press_handler_t handler, void* userData );
+
+/*! \brief Bind internal `replxx` action (by name) to handle given key-press event.
+ *
+ * Action names are the same as unique part of names of ReplxxAction enumerations
+ * but in lower case, e.g.: an action for recalling previous history line
+ * is \e REPLXX_ACTION_LINE_PREVIOUS so action name to be used in this
+ * interface for the same effect is "line_previous".
+ *
+ * \param code - handle this key-press event with following handler.
+ * \param actionName - name of internal action to be invoked on key press.
+ * \return -1 if invalid action name was used, 0 otherwise.
+ */
+int replxx_bind_key_internal( Replxx*, int code, char const* actionName );
+
+REPLXX_IMPEXP void replxx_set_preload_buffer( Replxx*, const char* preloadText );
+
+REPLXX_IMPEXP void replxx_history_add( Replxx*, const char* line );
+REPLXX_IMPEXP int replxx_history_size( Replxx* );
+
+/*! \brief Set set of word break characters.
+ *
+ * This setting influences word based cursor movement and line editing capabilities.
+ *
+ * \param wordBreakers - 7-bit ASCII set of word breaking characters.
+ */
+REPLXX_IMPEXP void replxx_set_word_break_characters( Replxx*, char const* wordBreakers );
+
+/*! \brief How many completions should trigger pagination.
+ */
+REPLXX_IMPEXP void replxx_set_completion_count_cutoff( Replxx*, int count );
+
+/*! \brief Set maximum number of displayed hint rows.
+ */
+REPLXX_IMPEXP void replxx_set_max_hint_rows( Replxx*, int count );
+
+/*! \brief Set a delay before hint are shown after user stopped typing..
+ *
+ * \param milliseconds - a number of milliseconds to wait before showing hints.
+ */
+REPLXX_IMPEXP void replxx_set_hint_delay( Replxx*, int milliseconds );
+
+/*! \brief Set tab completion behavior.
+ *
+ * \param val - use double tab to invoke completions (if != 0).
+ */
+REPLXX_IMPEXP void replxx_set_double_tab_completion( Replxx*, int val );
+
+/*! \brief Set tab completion behavior.
+ *
+ * \param val - invoke completion even if user input is empty (if != 0).
+ */
+REPLXX_IMPEXP void replxx_set_complete_on_empty( Replxx*, int val );
+
+/*! \brief Set tab completion behavior.
+ *
+ * \param val - beep if completion is ambiguous (if != 0).
+ */
+REPLXX_IMPEXP void replxx_set_beep_on_ambiguous_completion( Replxx*, int val );
+
+/*! \brief Set complete next/complete previous behavior.
+ *
+ * COMPLETE_NEXT/COMPLETE_PREVIOUS actions have two modes of operations,
+ * in case when a partial completion is possible complete only partial part (`false` setting)
+ * or complete first proposed completion fully (`true` setting).
+ * The default is to complete fully (a `true` setting - complete immediately).
+ *
+ * \param val - complete immediately.
+ */
+REPLXX_IMPEXP void replxx_set_immediate_completion( Replxx*, int val );
+
+/*! \brief Set history duplicate entries behaviour.
+ *
+ * \param val - should history contain only unique entries?
+ */
+REPLXX_IMPEXP void replxx_set_unique_history( Replxx*, int val );
+
+/*! \brief Disable output coloring.
+ *
+ * \param val - if set to non-zero disable output colors.
+ */
+REPLXX_IMPEXP void replxx_set_no_color( Replxx*, int val );
+
+/*! \brief Enable/disable (prompt width) indent for multiline entry.
+ *
+ * \param val - if set to non-zero then multiline indent will be enabled.
+ */
+REPLXX_IMPEXP void replxx_set_indent_multiline( Replxx*, int val );
+
+/*! \brief Set maximum number of entries in history list.
+ */
+REPLXX_IMPEXP void replxx_set_max_history_size( Replxx*, int len );
+REPLXX_IMPEXP ReplxxHistoryScan* replxx_history_scan_start( Replxx* );
+REPLXX_IMPEXP void replxx_history_scan_stop( Replxx*, ReplxxHistoryScan* );
+REPLXX_IMPEXP int replxx_history_scan_next( Replxx*, ReplxxHistoryScan*, ReplxxHistoryEntry* );
+
+/*! \brief Synchronize REPL's history with given file.
+ *
+ * Synchronizing means loading existing history from given file,
+ * merging it with current history sorted by timestamps,
+ * saving merged version to given file,
+ * keeping merged version as current REPL's history.
+ *
+ * This call is an equivalent of calling:
+ * replxx_history_save( rx, "some-file" );
+ * replxx_history_load( rx, "some-file" );
+ *
+ * \param filename - a path to the file with which REPL's current history should be synchronized.
+ * \return 0 iff history file was successfully created, -1 otherwise.
+ */
+REPLXX_IMPEXP int replxx_history_sync( Replxx*, const char* filename );
+
+/*! \brief Save REPL's history into given file.
+ *
+ * Saving means loading existing history from given file,
+ * merging it with current history sorted by timestamps,
+ * saving merged version to given file,
+ * keeping original (NOT merged) version as current REPL's history.
+ *
+ * \param filename - a path to the file where REPL's history should be saved.
+ * \return 0 iff history file was successfully created, -1 otherwise.
+ */
+REPLXX_IMPEXP int replxx_history_save( Replxx*, const char* filename );
+
+/*! \brief Load REPL's history from given file.
+ *
+ * \param filename - a path to the file which contains REPL's history that should be loaded.
+ * \return 0 iff history file was successfully opened, -1 otherwise.
+ */
+REPLXX_IMPEXP int replxx_history_load( Replxx*, const char* filename );
+
+/*! \brief Clear REPL's in-memory history.
+ */
+REPLXX_IMPEXP void replxx_history_clear( Replxx* );
+REPLXX_IMPEXP void replxx_clear_screen( Replxx* );
+#ifdef __REPLXX_DEBUG__
+void replxx_debug_dump_print_codes(void);
+#endif
+/* the following is extension to the original linenoise API */
+REPLXX_IMPEXP int replxx_install_window_change_handler( Replxx* );
+REPLXX_IMPEXP void replxx_enable_bracketed_paste( Replxx* );
+REPLXX_IMPEXP void replxx_disable_bracketed_paste( Replxx* );
+
+/*! \brief Combine two color definitions to get encompassing color definition.
+ *
+ * To be used only for combining foreground and background colors.
+ *
+ * \param color1 - first input color.
+ * \param color2 - second input color.
+ * \return A new color definition that represent combined input colors.
+ */
+ReplxxColor replxx_color_combine( ReplxxColor color1, ReplxxColor color2 );
+
+/*! \brief Transform foreground color definition into a background color definition.
+ *
+ * \param color - an input foreground color definition.
+ * \return A background color definition that is a transformed input \e color.
+ */
+ReplxxColor replxx_color_bg( ReplxxColor color );
+
+/*! \brief Add `bold` attribute to color definition.
+ *
+ * \param color - an input color definition.
+ * \return A new color definition with bold attribute set.
+ */
+ReplxxColor replxx_color_bold( ReplxxColor color );
+
+/*! \brief Add `underline` attribute to color definition.
+ *
+ * \param color - an input color definition.
+ * \return A new color definition with underline attribute set.
+ */
+ReplxxColor replxx_color_underline( ReplxxColor color );
+
+/*! \brief Create a new grayscale color of given brightness level.
+ *
+ * \param level - a brightness level for new color, must be between 0 (darkest) and 23 (brightest).
+ * \return A new grayscale color of a given brightest \e level.
+ */
+ReplxxColor replxx_color_grayscale( int level );
+
+/*! \brief Create a new color in 6×6×6 RGB color space from base component levels.
+ *
+ * \param red - a red (of RGB) component level, must be 0 and 5.
+ * \param green - a green (of RGB) component level, must be 0 and 5.
+ * \param blue - a blue (of RGB) component level, must be 0 and 5.
+ * \return A new color in 6×6×6 RGB color space.
+ */
+ReplxxColor replxx_color_rgb666( int red, int green, int blue );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __REPLXX_H */
+
diff --git a/contrib/restricted/patched/replxx/include/replxx.hxx b/contrib/restricted/patched/replxx/include/replxx.hxx
new file mode 100644
index 0000000000..3317705967
--- /dev/null
+++ b/contrib/restricted/patched/replxx/include/replxx.hxx
@@ -0,0 +1,709 @@
+/*
+ * Copyright (c) 2017-2018, Marcin Konarski (amok at codestation.org)
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef HAVE_REPLXX_HXX_INCLUDED
+#define HAVE_REPLXX_HXX_INCLUDED 1
+
+#include <memory>
+#include <vector>
+#include <string>
+#include <functional>
+#include <iosfwd>
+
+/*
+ * For use in Windows DLLs:
+ *
+ * If you are building replxx into a DLL,
+ * unless you are using supplied CMake based build,
+ * ensure that 'REPLXX_BUILDING_DLL' is defined when
+ * building the DLL so that proper symbols are exported.
+ */
+#if defined( _WIN32 ) && ! defined( REPLXX_STATIC )
+#	ifdef REPLXX_BUILDING_DLL
+#		define REPLXX_IMPEXP __declspec( dllexport )
+#	else
+#		define REPLXX_IMPEXP __declspec( dllimport )
+#	endif
+#else
+#	define REPLXX_IMPEXP /**/
+#endif
+
+#ifdef ERROR
+enum { ERROR_BB1CA97EC761FC37101737BA0AA2E7C5 = ERROR };
+#undef ERROR
+enum { ERROR = ERROR_BB1CA97EC761FC37101737BA0AA2E7C5 };
+#endif
+#ifdef ABORT
+enum { ABORT_8D12A2CA7E5A64036D7251A3EDA51A38 = ABORT };
+#undef ABORT
+enum { ABORT = ABORT_8D12A2CA7E5A64036D7251A3EDA51A38 };
+#endif
+#ifdef DELETE
+enum { DELETE_32F68A60CEF40FAEDBC6AF20298C1A1E = DELETE };
+#undef DELETE
+enum { DELETE = DELETE_32F68A60CEF40FAEDBC6AF20298C1A1E };
+#endif
+
+namespace replxx {
+
+class REPLXX_IMPEXP Replxx {
+public:
+	enum class Color : int {
+		BLACK         = 0,
+		RED           = 1,
+		GREEN         = 2,
+		BROWN         = 3,
+		BLUE          = 4,
+		MAGENTA       = 5,
+		CYAN          = 6,
+		LIGHTGRAY     = 7,
+		GRAY          = 8,
+		BRIGHTRED     = 9,
+		BRIGHTGREEN   = 10,
+		YELLOW        = 11,
+		BRIGHTBLUE    = 12,
+		BRIGHTMAGENTA = 13,
+		BRIGHTCYAN    = 14,
+		WHITE         = 15,
+		DEFAULT       = 1u << 16u
+	};
+	struct KEY {
+		static char32_t const BASE         = 0x0010ffff + 1;
+		static char32_t const BASE_SHIFT   = 0x01000000;
+		static char32_t const BASE_CONTROL = 0x02000000;
+		static char32_t const BASE_META    = 0x04000000;
+		static char32_t const ESCAPE       = 27;
+		static char32_t const PAGE_UP      = BASE      + 1;
+		static char32_t const PAGE_DOWN    = PAGE_UP   + 1;
+		static char32_t const DOWN         = PAGE_DOWN + 1;
+		static char32_t const UP           = DOWN      + 1;
+		static char32_t const LEFT         = UP        + 1;
+		static char32_t const RIGHT        = LEFT      + 1;
+		static char32_t const HOME         = RIGHT     + 1;
+		static char32_t const END          = HOME      + 1;
+		static char32_t const DELETE       = END       + 1;
+		static char32_t const INSERT       = DELETE    + 1;
+		static char32_t const F1           = INSERT    + 1;
+		static char32_t const F2           = F1        + 1;
+		static char32_t const F3           = F2        + 1;
+		static char32_t const F4           = F3        + 1;
+		static char32_t const F5           = F4        + 1;
+		static char32_t const F6           = F5        + 1;
+		static char32_t const F7           = F6        + 1;
+		static char32_t const F8           = F7        + 1;
+		static char32_t const F9           = F8        + 1;
+		static char32_t const F10          = F9        + 1;
+		static char32_t const F11          = F10       + 1;
+		static char32_t const F12          = F11       + 1;
+		static char32_t const F13          = F12       + 1;
+		static char32_t const F14          = F13       + 1;
+		static char32_t const F15          = F14       + 1;
+		static char32_t const F16          = F15       + 1;
+		static char32_t const F17          = F16       + 1;
+		static char32_t const F18          = F17       + 1;
+		static char32_t const F19          = F18       + 1;
+		static char32_t const F20          = F19       + 1;
+		static char32_t const F21          = F20       + 1;
+		static char32_t const F22          = F21       + 1;
+		static char32_t const F23          = F22       + 1;
+		static char32_t const F24          = F23       + 1;
+		static char32_t const MOUSE        = F24       + 1;
+		static char32_t const PASTE_START  = MOUSE     + 1;
+		static char32_t const PASTE_FINISH = PASTE_START + 1;
+		static constexpr char32_t shift( char32_t key_ ) {
+			return ( key_ | BASE_SHIFT );
+		}
+		static constexpr char32_t control( char32_t key_ ) {
+			return ( key_ | BASE_CONTROL );
+		}
+		static constexpr char32_t meta( char32_t key_ ) {
+			return ( key_ | BASE_META );
+		}
+		static char32_t const BACKSPACE    = 'H' | BASE_CONTROL;
+		static char32_t const TAB          = 'I' | BASE_CONTROL;
+		static char32_t const ENTER        = 'M' | BASE_CONTROL;
+		static char32_t const ABORT        = 'C' | BASE_CONTROL | BASE_META;
+	};
+	/*! \brief List of built-in actions that act upon user input.
+	 */
+	enum class ACTION {
+		INSERT_CHARACTER,
+		NEW_LINE,
+		DELETE_CHARACTER_UNDER_CURSOR,
+		DELETE_CHARACTER_LEFT_OF_CURSOR,
+		KILL_TO_END_OF_LINE,
+		KILL_TO_BEGINING_OF_LINE,
+		KILL_TO_END_OF_WORD,
+		KILL_TO_BEGINING_OF_WORD,
+		KILL_TO_END_OF_SUBWORD,
+		KILL_TO_BEGINING_OF_SUBWORD,
+		KILL_TO_WHITESPACE_ON_LEFT,
+		YANK,
+		YANK_CYCLE,
+		YANK_LAST_ARG,
+		MOVE_CURSOR_TO_BEGINING_OF_LINE,
+		MOVE_CURSOR_TO_END_OF_LINE,
+		MOVE_CURSOR_ONE_WORD_LEFT,
+		MOVE_CURSOR_ONE_WORD_RIGHT,
+		MOVE_CURSOR_ONE_SUBWORD_LEFT,
+		MOVE_CURSOR_ONE_SUBWORD_RIGHT,
+		MOVE_CURSOR_LEFT,
+		MOVE_CURSOR_RIGHT,
+		LINE_NEXT,
+		LINE_PREVIOUS,
+		HISTORY_NEXT,
+		HISTORY_PREVIOUS,
+		HISTORY_FIRST,
+		HISTORY_LAST,
+		HISTORY_RESTORE,
+		HISTORY_RESTORE_CURRENT,
+		HISTORY_INCREMENTAL_SEARCH,
+		HISTORY_COMMON_PREFIX_SEARCH,
+		HINT_NEXT,
+		HINT_PREVIOUS,
+		CAPITALIZE_WORD,
+		LOWERCASE_WORD,
+		UPPERCASE_WORD,
+		CAPITALIZE_SUBWORD,
+		LOWERCASE_SUBWORD,
+		UPPERCASE_SUBWORD,
+		TRANSPOSE_CHARACTERS,
+		TOGGLE_OVERWRITE_MODE,
+#ifndef _WIN32
+		VERBATIM_INSERT,
+		SUSPEND,
+#endif
+		BRACKETED_PASTE,
+		CLEAR_SCREEN,
+		CLEAR_SELF,
+		REPAINT,
+		COMPLETE_LINE,
+		COMPLETE_NEXT,
+		COMPLETE_PREVIOUS,
+		COMMIT_LINE,
+		ABORT_LINE,
+		SEND_EOF
+	};
+	/*! \brief Possible results of key-press handler actions.
+	 */
+	enum class ACTION_RESULT {
+		CONTINUE, /*!< Continue processing user input. */
+		RETURN,   /*!< Return user input entered so far. */
+		BAIL      /*!< Stop processing user input, returns nullptr from the \e input() call. */
+	};
+	typedef std::vector<Color> colors_t;
+	class Completion {
+		std::string _text;
+		Color _color;
+	public:
+		Completion( char const* text_ )
+			: _text( text_ )
+			, _color( Color::DEFAULT ) {
+		}
+		Completion( std::string const& text_ )
+			: _text( text_ )
+			, _color( Color::DEFAULT ) {
+		}
+		Completion( std::string const& text_, Color color_ )
+			: _text( text_ )
+			, _color( color_ ) {
+		}
+		std::string const& text( void ) const {
+			return ( _text );
+		}
+		Color color( void ) const {
+			return ( _color );
+		}
+	};
+	typedef std::vector<Completion> completions_t;
+	class HistoryEntry {
+		std::string _timestamp;
+		std::string _text;
+	public:
+		HistoryEntry( std::string const& timestamp_, std::string const& text_ )
+			: _timestamp( timestamp_ )
+			, _text( text_ ) {
+		}
+		std::string const& timestamp( void ) const {
+			return ( _timestamp );
+		}
+		std::string const& text( void ) const {
+			return ( _text );
+		}
+	};
+	class HistoryScanImpl;
+	class HistoryScan {
+	public:
+		typedef std::unique_ptr<HistoryScanImpl, void (*)( HistoryScanImpl* )> impl_t;
+	private:
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+		impl_t _impl;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+	public:
+		HistoryScan( impl_t );
+		HistoryScan( HistoryScan&& ) = default;
+		HistoryScan& operator = ( HistoryScan&& ) = default;
+		bool next( void );
+		HistoryEntry const& get( void ) const;
+	private:
+		HistoryScan( HistoryScan const& ) = delete;
+		HistoryScan& operator = ( HistoryScan const& ) = delete;
+	};
+	typedef std::vector<std::string> hints_t;
+
+	/*! \brief Line modification callback type definition.
+	 *
+	 * User can observe and modify line contents (and cursor position)
+	 * in response to changes to both introduced by the user through
+	 * normal interactions.
+	 *
+	 * When callback returns Replxx updates current line content
+	 * and current cursor position to the ones updated by the callback.
+	 *
+	 * \param line[in,out] - a R/W reference to an UTF-8 encoded input entered by the user so far.
+	 * \param cursorPosition[in,out] - a R/W reference to current cursor position.
+	 */
+	typedef std::function<void ( std::string& line, int& cursorPosition )> modify_callback_t;
+
+	/*! \brief Completions callback type definition.
+	 *
+	 * \e contextLen is counted in Unicode code points (not in bytes!).
+	 *
+	 * For user input:
+	 * if ( obj.me
+	 *
+	 * input == "if ( obj.me"
+	 * contextLen == 2 (depending on \e set_word_break_characters())
+	 *
+	 * Client application is free to update \e contextLen to be 6 (or any other non-negative
+	 * number not greater than the number of code points in input) if it makes better sense
+	 * for given client application semantics.
+	 *
+	 * \param input - UTF-8 encoded input entered by the user until current cursor position.
+	 * \param[in,out] contextLen - length of the additional context to provide while displaying completions.
+	 * \return A list of user completions.
+	 */
+	typedef std::function<completions_t ( std::string const& input, int& contextLen )> completion_callback_t;
+
+	/*! \brief Highlighter callback type definition.
+	 *
+	 * If user want to have colorful input she must simply install highlighter callback.
+	 * The callback would be invoked by the library after each change to the input done by
+	 * the user. After callback returns library uses data from colors buffer to colorize
+	 * displayed user input.
+	 *
+	 * Size of \e colors buffer is equal to number of code points in user \e input
+	 * which will be different from simple `input.length()`!
+	 *
+	 * \param input - an UTF-8 encoded input entered by the user so far.
+	 * \param colors - output buffer for color information.
+	 */
+	typedef std::function<void ( std::string const& input, colors_t& colors )> highlighter_callback_t;
+
+	/*! \brief Hints callback type definition.
+	 *
+	 * \e contextLen is counted in Unicode code points (not in bytes!).
+	 *
+	 * For user input:
+	 * if ( obj.me
+	 *
+	 * input == "if ( obj.me"
+	 * contextLen == 2 (depending on \e set_word_break_characters())
+	 *
+	 * Client application is free to update \e contextLen to be 6 (or any other non-negative
+	 * number not greater than the number of code points in input) if it makes better sense
+	 * for given client application semantics.
+	 *
+	 * \param input - UTF-8 encoded input entered by the user until current cursor position.
+	 * \param contextLen[in,out] - length of the additional context to provide while displaying hints.
+	 * \param color - a color used for displaying hints.
+	 * \return A list of possible hints.
+	 */
+	typedef std::function<hints_t ( std::string const& input, int& contextLen, Color& color )> hint_callback_t;
+
+	/*! \brief Key press handler type definition.
+	 *
+	 * \param code - the key code replxx got from terminal.
+	 * \return Decision on how should input() behave after this key handler returns.
+	 */
+	typedef std::function<ACTION_RESULT ( char32_t code )> key_press_handler_t;
+
+	struct State {
+		char const* _text;
+		int _cursorPosition;
+		State( char const* text_, int cursorPosition_ = -1 )
+			: _text( text_ )
+			, _cursorPosition( cursorPosition_ ) {
+		}
+		State( State const& ) = default;
+		State& operator = ( State const& ) = default;
+		char const* text( void ) const {
+			return ( _text );
+		}
+		int cursor_position( void ) const {
+			return ( _cursorPosition );
+		}
+	};
+
+	class ReplxxImpl;
+private:
+	typedef std::unique_ptr<ReplxxImpl, void (*)( ReplxxImpl* )> impl_t;
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+	impl_t _impl;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+public:
+	Replxx( void );
+	Replxx( Replxx&& ) = default;
+	Replxx& operator = ( Replxx&& ) = default;
+
+	/*! \brief Register modify callback.
+	 *
+	 * \param fn - user defined callback function.
+	 */
+	void set_modify_callback( modify_callback_t const& fn );
+
+	/*! \brief Register completion callback.
+	 *
+	 * \param fn - user defined callback function.
+	 */
+	void set_completion_callback( completion_callback_t const& fn );
+
+	/*! \brief Register highlighter callback.
+	 *
+	 * \param fn - user defined callback function.
+	 */
+	void set_highlighter_callback( highlighter_callback_t const& fn );
+
+	/*! \brief Register hints callback.
+	 *
+	 * \param fn - user defined callback function.
+	 */
+	void set_hint_callback( hint_callback_t const& fn );
+
+	/*! \brief Read line of user input.
+	 *
+	 * Returned pointer is managed by the library and is not to be freed in the client.
+	 *
+	 * \param prompt - prompt to be displayed before getting user input.
+	 * \return An UTF-8 encoded input given by the user (or nullptr on EOF).
+	 */
+	char const* input( std::string const& prompt );
+
+	/*! \brief Get current state data.
+	 *
+	 * This call is intended to be used in handlers.
+	 *
+	 * \return Current state of the model.
+	 */
+	State get_state( void ) const;
+
+	/*! \brief Set new state data.
+	 *
+	 * This call is intended to be used in handlers.
+	 *
+	 * \param state - new state of the model.
+	 */
+	void set_state( State const& state );
+
+	/*! \brief Enable/disable case insensitive history search and completion.
+	 *
+	 * \param val - if set to non-zero then history search and completion will be case insensitive.
+	 */
+	void set_ignore_case( bool val );
+
+	/*! \brief Print formatted string to standard output.
+	 *
+	 * This function ensures proper handling of ANSI escape sequences
+	 * contained in printed data, which is especially useful on Windows
+	 * since Unixes handle them correctly out of the box.
+	 *
+	 * \param fmt - printf style format.
+	 */
+	void print( char const* fmt, ... );
+
+	/*! \brief Prints a char array with the given length to standard output.
+	 *
+	 * \copydetails print
+	 *
+	 * \param str - The char array to print.
+	 * \param length - The length of the array.
+	 */
+	void write( char const* str, int length );
+
+	/*! \brief Asynchronously change the prompt while replxx_input() call is in efect.
+	 *
+	 * Can be used to change the prompt from callbacks or other threads.
+	 *
+	 * \param prompt - The prompt string to change to.
+	 */
+	void set_prompt( std::string prompt );
+
+	/*! \brief Schedule an emulated key press event.
+	 *
+	 * \param code - key press code to be emulated.
+	 */
+	void emulate_key_press( char32_t code );
+
+	/*! \brief Invoke built-in action handler.
+	 *
+	 * \pre This method can be called only from key-press handler.
+	 *
+	 * \param action - a built-in action to invoke.
+	 * \param code - a supplementary key-code to consume by built-in action handler.
+	 * \return The action result informing the replxx what shall happen next.
+	 */
+	ACTION_RESULT invoke( ACTION action, char32_t code );
+
+	/*! \brief Bind user defined action to handle given key-press event.
+	 *
+	 * \param code - handle this key-press event with following handler.
+	 * \param handle - use this handler to handle key-press event.
+	 */
+	void bind_key( char32_t code, key_press_handler_t handler );
+
+	/*! \brief Bind internal `replxx` action (by name) to handle given key-press event.
+	 *
+	 * Action names are the same as names of Replxx::ACTION enumerations
+	 * but in lower case, e.g.: an action for recalling previous history line
+	 * is \e Replxx::ACTION::LINE_PREVIOUS so action name to be used in this
+	 * interface for the same effect is "line_previous".
+	 *
+	 * \param code - handle this key-press event with following handler.
+	 * \param actionName - name of internal action to be invoked on key press.
+	 */
+	void bind_key_internal( char32_t code, char const* actionName );
+
+	void history_add( std::string const& line );
+
+	/*! \brief Synchronize REPL's history with given file.
+	 *
+	 * Synchronizing means loading existing history from given file,
+	 * merging it with current history sorted by timestamps,
+	 * saving merged version to given file,
+	 * keeping merged version as current REPL's history.
+	 *
+	 * This call is an equivalent of calling:
+	 * history_save( "some-file" );
+	 * history_load( "some-file" );
+	 *
+	 * \param filename - a path to the file with which REPL's current history should be synchronized.
+	 * \return True iff history file was successfully created.
+	 */
+	bool history_sync( std::string const& filename );
+
+	/*! \brief Save REPL's history into given file.
+	 *
+	 * Saving means loading existing history from given file,
+	 * merging it with current history sorted by timestamps,
+	 * saving merged version to given file,
+	 * keeping original (NOT merged) version as current REPL's history.
+	 *
+	 * \param filename - a path to the file where REPL's history should be saved.
+	 * \return True iff history file was successfully created.
+	 */
+	bool history_save( std::string const& filename );
+
+	/*!
+	 * \copydoc history_save
+	 */
+	void history_save( std::ostream& out );
+
+	/*! \brief Load REPL's history from given file.
+	 *
+	 * \param filename - a path to the file which contains REPL's history that should be loaded.
+	 * \return True iff history file was successfully opened.
+	 */
+	bool history_load( std::string const& filename );
+
+	/*!
+	 * \copydoc history_load
+	 */
+	void history_load( std::istream& in );
+
+	/*! \brief Clear REPL's in-memory history.
+	 */
+	void history_clear( void );
+	int history_size( void ) const;
+	HistoryScan history_scan( void ) const;
+
+	void set_preload_buffer( std::string const& preloadText );
+
+	/*! \brief Set set of word break characters.
+	 *
+	 * This setting influences word based cursor movement and line editing capabilities.
+	 *
+	 * \param wordBreakers - 7-bit ASCII set of word breaking characters.
+	 */
+	void set_word_break_characters( char const* wordBreakers );
+
+	/*! \brief How many completions should trigger pagination.
+	 */
+	void set_completion_count_cutoff( int count );
+
+	/*! \brief Set maximum number of displayed hint rows.
+	 */
+	void set_max_hint_rows( int count );
+
+	/*! \brief Set a delay before hint are shown after user stopped typing..
+	 *
+	 * \param milliseconds - a number of milliseconds to wait before showing hints.
+	 */
+	void set_hint_delay( int milliseconds );
+
+	/*! \brief Set tab completion behavior.
+	 *
+	 * \param val - use double tab to invoke completions.
+	 */
+	void set_double_tab_completion( bool val );
+
+	/*! \brief Set tab completion behavior.
+	 *
+	 * \param val - invoke completion even if user input is empty.
+	 */
+	void set_complete_on_empty( bool val );
+
+	/*! \brief Set tab completion behavior.
+	 *
+	 * \param val - beep if completion is ambiguous.
+	 */
+	void set_beep_on_ambiguous_completion( bool val );
+
+	/*! \brief Set complete next/complete previous behavior.
+	 *
+	 * COMPLETE_NEXT/COMPLETE_PREVIOUS actions have two modes of operations,
+	 * in case when a partial completion is possible complete only partial part (`false` setting)
+	 * or complete first proposed completion fully (`true` setting).
+	 * The default is to complete fully (a `true` setting - complete immediately).
+	 *
+	 * \param val - complete immediately.
+	 */
+	void set_immediate_completion( bool val );
+
+	/*! \brief Set history duplicate entries behaviour.
+	 *
+	 * \param val - should history contain only unique entries?
+	 */
+	void set_unique_history( bool val );
+
+	/*! \brief Disable output coloring.
+	 *
+	 * \param val - if set to non-zero disable output colors.
+	 */
+	void set_no_color( bool val );
+
+	/*! \brief Enable/disable (prompt width) indent for multiline entry.
+	 *
+	 * \param val - if set to true then multiline indent will be enabled.
+	 */
+	void set_indent_multiline( bool val );
+
+	/*! \brief Set maximum number of entries in history list.
+	 */
+	void set_max_history_size( int len );
+	void clear_screen( void );
+	int install_window_change_handler( void );
+	void enable_bracketed_paste( void );
+	void disable_bracketed_paste( void );
+
+private:
+	Replxx( Replxx const& ) = delete;
+	Replxx& operator = ( Replxx const& ) = delete;
+};
+
+/*! \brief Color definition related helper function.
+ *
+ * To be used to leverage 256 color terminal capabilities.
+ */
+namespace color {
+
+/*! \brief Combine two color definitions to get encompassing color definition.
+ *
+ * To be used only for combining foreground and background colors.
+ *
+ * \param color1 - first input color.
+ * \param color2 - second input color.
+ * \return A new color definition that represent combined input colors.
+ */
+Replxx::Color operator | ( Replxx::Color color1, Replxx::Color color2 );
+
+/*! \brief Transform foreground color definition into a background color definition.
+ *
+ * \param color - an input foreground color definition.
+ * \return A background color definition that is a transformed input \e color.
+ */
+Replxx::Color bg( Replxx::Color color );
+
+/*! \brief Add `bold` attribute to color definition.
+ *
+ * \param color - an input color definition.
+ * \return A new color definition with bold attribute set.
+ */
+Replxx::Color bold( Replxx::Color color );
+
+/*! \brief Add `underline` attribute to color definition.
+ *
+ * \param color - an input color definition.
+ * \return A new color definition with underline attribute set.
+ */
+Replxx::Color underline( Replxx::Color color );
+
+/*! \brief Create a new grayscale color of given brightness level.
+ *
+ * \param level - a brightness level for new color, must be between 0 (darkest) and 23 (brightest).
+ * \return A new grayscale color of a given brightest \e level.
+ */
+Replxx::Color grayscale( int level );
+
+/*! \brief Create a new color in 6×6×6 RGB color space from base component levels.
+ *
+ * \param red - a red (of RGB) component level, must be 0 and 5.
+ * \param green - a green (of RGB) component level, must be 0 and 5.
+ * \param blue - a blue (of RGB) component level, must be 0 and 5.
+ * \return A new color in 6×6×6 RGB color space.
+ */
+Replxx::Color rgb666( int red, int green, int blue );
+
+}
+
+}
+
+#endif /* HAVE_REPLXX_HXX_INCLUDED */
+
diff --git a/contrib/restricted/patched/replxx/src/ConvertUTF.cpp b/contrib/restricted/patched/replxx/src/ConvertUTF.cpp
new file mode 100644
index 0000000000..3609c6249e
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/ConvertUTF.cpp
@@ -0,0 +1,271 @@
+/*
+ * Copyright 2001-2004 Unicode, Inc.
+ * 
+ * Disclaimer
+ * 
+ * This source code is provided as is by Unicode, Inc. No claims are
+ * made as to fitness for any particular purpose. No warranties of any
+ * kind are expressed or implied. The recipient agrees to determine
+ * applicability of information provided. If this file has been
+ * purchased on magnetic or optical media from Unicode, Inc., the
+ * sole remedy for any claim will be exchange of defective media
+ * within 90 days of receipt.
+ * 
+ * Limitations on Rights to Redistribute This Code
+ * 
+ * Unicode, Inc. hereby grants the right to freely use the information
+ * supplied in this file in the creation of products supporting the
+ * Unicode Standard, and to make copies of this file in any form
+ * for internal or external distribution as long as this notice
+ * remains attached.
+ */
+
+/* ---------------------------------------------------------------------
+
+		Conversions between UTF32, UTF-16, and UTF-8. Source code file.
+		Author: Mark E. Davis, 1994.
+		Rev History: Rick McGowan, fixes & updates May 2001.
+		Sept 2001: fixed const & error conditions per
+				mods suggested by S. Parent & A. Lillich.
+		June 2002: Tim Dodd added detection and handling of incomplete
+				source sequences, enhanced error detection, added casts
+				to eliminate compiler warnings.
+		July 2003: slight mods to back out aggressive FFFE detection.
+		Jan 2004: updated switches in from-UTF8 conversions.
+		Oct 2004: updated to use UNI_MAX_LEGAL_UTF32 in UTF-32 conversions.
+
+		See the header file "ConvertUTF.h" for complete documentation.
+
+------------------------------------------------------------------------ */
+
+#include "ConvertUTF.h"
+#ifdef CVTUTF_DEBUG
+#include <stdio.h>
+#endif
+
+namespace replxx {
+
+#define UNI_SUR_HIGH_START  (UTF32)0xD800
+#define UNI_SUR_LOW_END     (UTF32)0xDFFF
+
+/* --------------------------------------------------------------------- */
+
+/*
+ * Index into the table below with the first byte of a UTF-8 sequence to
+ * get the number of trailing bytes that are supposed to follow it.
+ * Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is
+ * left as-is for anyone who may want to do such conversion, which was
+ * allowed in earlier algorithms.
+ */
+static const char trailingBytesForUTF8[256] = {
+		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+		1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+		2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
+};
+
+/*
+ * Magic values subtracted from a buffer value during UTF8 conversion.
+ * This table contains as many values as there might be trailing bytes
+ * in a UTF-8 sequence.
+ */
+static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL, 
+										 0x03C82080UL, 0xFA082080UL, 0x82082080UL };
+
+/*
+ * Once the bits are split out into bytes of UTF-8, this is a mask OR-ed
+ * into the first byte, depending on how many bytes follow.	There are
+ * as many entries in this table as there are UTF-8 sequence types.
+ * (I.e., one byte sequence, two byte... etc.). Remember that sequencs
+ * for *legal* UTF-8 will be 4 or fewer bytes total.
+ */
+static const UTF8 firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
+
+/* --------------------------------------------------------------------- */
+
+/* The interface converts a whole buffer to avoid function-call overhead.
+ * Constants have been gathered. Loops & conditionals have been removed as
+ * much as possible for efficiency, in favor of drop-through switches.
+ * (See "Note A" at the bottom of the file for equivalent code.)
+ * If your compiler supports it, the "isLegalUTF8" call can be turned
+ * into an inline function.
+ */
+
+/* --------------------------------------------------------------------- */
+
+/*
+ * Utility routine to tell whether a sequence of bytes is legal UTF-8.
+ * This must be called with the length pre-determined by the first byte.
+ * If not calling this from ConvertUTF8to*, then the length can be set by:
+ *	length = trailingBytesForUTF8[*source]+1;
+ * and the sequence is illegal right away if there aren't that many bytes
+ * available.
+ * If presented with a length > 4, this returns false.	The Unicode
+ * definition of UTF-8 goes up to 4-byte sequences.
+ */
+
+static bool isLegalUTF8(const UTF8 *source, int length) {
+		UTF8 a;
+		const UTF8 *srcptr = source+length;
+		switch (length) {
+		default: return false;
+				/* Everything else falls through when "true"... */
+		case 4: { if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false; } /* fall through */
+		case 3: { if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false; } /* fall through */
+		case 2: {
+				if ((a = (*--srcptr)) > 0xBF) return false;
+
+				switch (*source) {
+						/* no fall-through in this inner switch */
+						case 0xE0: if (a < 0xA0) return false; break;
+						case 0xED: if (a > 0x9F) return false; break;
+						case 0xF0: if (a < 0x90) return false; break;
+						case 0xF4: if (a > 0x8F) return false; break;
+						default:	 if (a < 0x80) return false;
+				}
+		} /* fall through */
+		case 1: { if (*source >= 0x80 && *source < 0xC2) return false; } /* fall through */
+		}
+		if (*source > 0xF4) return false;
+		return true;
+}
+
+/* --------------------------------------------------------------------- */
+
+ConversionResult ConvertUTF32toUTF8 (
+				const UTF32** sourceStart, const UTF32* sourceEnd, 
+				UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
+		ConversionResult result = conversionOK;
+		const UTF32* source = *sourceStart;
+		UTF8* target = *targetStart;
+		while (source < sourceEnd) {
+				UTF32 ch;
+				unsigned short bytesToWrite = 0;
+				const UTF32 byteMask = 0xBF;
+				const UTF32 byteMark = 0x80; 
+				ch = *source++;
+				if (flags == strictConversion ) {
+						/* UTF-16 surrogate values are illegal in UTF-32 */
+						if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
+								--source; /* return to the illegal value itself */
+								result = sourceIllegal;
+								break;
+						}
+				}
+				/*
+				 * Figure out how many bytes the result will require. Turn any
+				 * illegally large UTF32 things (> Plane 17) into replacement chars.
+				 */
+				if (ch < (UTF32)0x80) {			bytesToWrite = 1;
+				} else if (ch < (UTF32)0x800) {		 bytesToWrite = 2;
+				} else if (ch < (UTF32)0x10000) {	 bytesToWrite = 3;
+				} else if (ch <= UNI_MAX_LEGAL_UTF32) {	bytesToWrite = 4;
+				} else {														bytesToWrite = 3;
+																						ch = UNI_REPLACEMENT_CHAR;
+																						result = sourceIllegal;
+				}
+				
+				target += bytesToWrite;
+				if (target > targetEnd) {
+						--source; /* Back up source pointer! */
+						target -= bytesToWrite; result = targetExhausted; break;
+				}
+				switch (bytesToWrite) { /* note: everything falls through. */
+						case 4: { *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; } /* fall through */
+						case 3: { *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; } /* fall through */
+						case 2: { *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; } /* fall through */
+						case 1: { *--target = (UTF8) (ch | firstByteMark[bytesToWrite]); } /* fall through */
+				}
+				target += bytesToWrite;
+		}
+		*sourceStart = source;
+		*targetStart = target;
+		return result;
+}
+
+/* --------------------------------------------------------------------- */
+
+ConversionResult ConvertUTF8toUTF32 (
+				const UTF8** sourceStart, const UTF8* sourceEnd, 
+				UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
+		ConversionResult result = conversionOK;
+		const UTF8* source = *sourceStart;
+		UTF32* target = *targetStart;
+		while (source < sourceEnd) {
+				UTF32 ch = 0;
+				unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
+				if (source + extraBytesToRead >= sourceEnd) {
+						result = sourceExhausted; break;
+				}
+				/* Do this check whether lenient or strict */
+				if (! isLegalUTF8(source, extraBytesToRead+1)) {
+						result = sourceIllegal;
+						break;
+				}
+				/*
+				 * The cases all fall through. See "Note A" below.
+				 */
+				switch (extraBytesToRead) {
+						case 5: { ch += *source++; ch <<= 6; } /* fall through */
+						case 4: { ch += *source++; ch <<= 6; } /* fall through */
+						case 3: { ch += *source++; ch <<= 6; } /* fall through */
+						case 2: { ch += *source++; ch <<= 6; } /* fall through */
+						case 1: { ch += *source++; ch <<= 6; } /* fall through */
+						case 0: { ch += *source++; } /* fall through */
+				}
+				ch -= offsetsFromUTF8[extraBytesToRead];
+
+				if (target >= targetEnd) {
+						source -= (extraBytesToRead+1); /* Back up the source pointer! */
+						result = targetExhausted; break;
+				}
+				if (ch <= UNI_MAX_LEGAL_UTF32) {
+						/*
+						 * UTF-16 surrogate values are illegal in UTF-32, and anything
+						 * over Plane 17 (> 0x10FFFF) is illegal.
+						 */
+						if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
+								if (flags == strictConversion) {
+										source -= (extraBytesToRead+1); /* return to the illegal value itself */
+										result = sourceIllegal;
+										break;
+								} else {
+										*target++ = UNI_REPLACEMENT_CHAR;
+								}
+						} else {
+								*target++ = ch;
+						}
+				} else { /* i.e., ch > UNI_MAX_LEGAL_UTF32 */
+						result = sourceIllegal;
+						*target++ = UNI_REPLACEMENT_CHAR;
+				}
+		}
+		*sourceStart = source;
+		*targetStart = target;
+		return result;
+}
+
+}
+
+/* ---------------------------------------------------------------------
+
+		Note A.
+		The fall-through switches in UTF-8 reading code save a
+		temp variable, some decrements & conditionals.	The switches
+		are equivalent to the following loop:
+				{
+						int tmpBytesToRead = extraBytesToRead+1;
+						do {
+								ch += *source++;
+								--tmpBytesToRead;
+								if (tmpBytesToRead) ch <<= 6;
+						} while (tmpBytesToRead > 0);
+				}
+		In UTF-8 writing code, the switches on "bytesToWrite" are
+		similarly unrolled loops.
+
+	 --------------------------------------------------------------------- */
diff --git a/contrib/restricted/patched/replxx/src/ConvertUTF.h b/contrib/restricted/patched/replxx/src/ConvertUTF.h
new file mode 100644
index 0000000000..f91d557324
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/ConvertUTF.h
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2001-2004 Unicode, Inc.
+ * 
+ * Disclaimer
+ * 
+ * This source code is provided as is by Unicode, Inc. No claims are
+ * made as to fitness for any particular purpose. No warranties of any
+ * kind are expressed or implied. The recipient agrees to determine
+ * applicability of information provided. If this file has been
+ * purchased on magnetic or optical media from Unicode, Inc., the
+ * sole remedy for any claim will be exchange of defective media
+ * within 90 days of receipt.
+ * 
+ * Limitations on Rights to Redistribute This Code
+ * 
+ * Unicode, Inc. hereby grants the right to freely use the information
+ * supplied in this file in the creation of products supporting the
+ * Unicode Standard, and to make copies of this file in any form
+ * for internal or external distribution as long as this notice
+ * remains attached.
+ */
+
+/* ---------------------------------------------------------------------
+
+		Conversions between UTF32, UTF-16, and UTF-8.	Header file.
+
+		Several funtions are included here, forming a complete set of
+		conversions between the three formats.	UTF-7 is not included
+		here, but is handled in a separate source file.
+
+		Each of these routines takes pointers to input buffers and output
+		buffers.	The input buffers are const.
+
+		Each routine converts the text between *sourceStart and sourceEnd,
+		putting the result into the buffer between *targetStart and
+		targetEnd. Note: the end pointers are *after* the last item: e.g. 
+		*(sourceEnd - 1) is the last item.
+
+		The return result indicates whether the conversion was successful,
+		and if not, whether the problem was in the source or target buffers.
+		(Only the first encountered problem is indicated.)
+
+		After the conversion, *sourceStart and *targetStart are both
+		updated to point to the end of last text successfully converted in
+		the respective buffers.
+
+		Input parameters:
+				sourceStart - pointer to a pointer to the source buffer.
+								The contents of this are modified on return so that
+								it points at the next thing to be converted.
+				targetStart - similarly, pointer to pointer to the target buffer.
+				sourceEnd, targetEnd - respectively pointers to the ends of the
+								two buffers, for overflow checking only.
+
+		These conversion functions take a ConversionFlags argument. When this
+		flag is set to strict, both irregular sequences and isolated surrogates
+		will cause an error.	When the flag is set to lenient, both irregular
+		sequences and isolated surrogates are converted.
+
+		Whether the flag is strict or lenient, all illegal sequences will cause
+		an error return. This includes sequences such as: <F4 90 80 80>, <C0 80>,
+		or <A0> in UTF-8, and values above 0x10FFFF in UTF-32. Conformant code
+		must check for illegal sequences.
+
+		When the flag is set to lenient, characters over 0x10FFFF are converted
+		to the replacement character; otherwise (when the flag is set to strict)
+		they constitute an error.
+
+		Output parameters:
+				The value "sourceIllegal" is returned from some routines if the input
+				sequence is malformed.	When "sourceIllegal" is returned, the source
+				value will point to the illegal value that caused the problem. E.g.,
+				in UTF-8 when a sequence is malformed, it points to the start of the
+				malformed sequence.	
+
+		Author: Mark E. Davis, 1994.
+		Rev History: Rick McGowan, fixes & updates May 2001.
+								 Fixes & updates, Sept 2001.
+
+------------------------------------------------------------------------ */
+
+/* ---------------------------------------------------------------------
+		The following 4 definitions are compiler-specific.
+		The C standard does not guarantee that wchar_t has at least
+		16 bits, so wchar_t is no less portable than unsigned short!
+		All should be unsigned values to avoid sign extension during
+		bit mask & shift operations.
+------------------------------------------------------------------------ */
+
+#ifndef REPLXX_CONVERT_UTF8_H_INCLUDED
+#define REPLXX_CONVERT_UTF8_H_INCLUDED 1
+
+#if 0
+typedef unsigned long	UTF32; /* at least 32 bits */
+typedef unsigned short UTF16; /* at least 16 bits */
+typedef unsigned char	UTF8;	/* typically 8 bits */
+#endif
+
+#include <stdint.h>
+#include <string>
+
+namespace replxx {
+
+typedef uint32_t      UTF32;
+typedef uint16_t      UTF16;
+typedef uint8_t       UTF8;
+
+/* Some fundamental constants */
+#define UNI_REPLACEMENT_CHAR (UTF32)0x0000FFFD
+#define UNI_MAX_BMP (UTF32)0x0000FFFF
+#define UNI_MAX_UTF16 (UTF32)0x0010FFFF
+#define UNI_MAX_UTF32 (UTF32)0x7FFFFFFF
+#define UNI_MAX_LEGAL_UTF32 (UTF32)0x0010FFFF
+
+typedef enum {
+				conversionOK,    /* conversion successful */
+				sourceExhausted, /* partial character in source, but hit end */
+				targetExhausted, /* insuff. room in target for conversion */
+				sourceIllegal    /* source sequence is illegal/malformed */
+} ConversionResult;
+
+typedef enum {
+				strictConversion = 0,
+				lenientConversion
+} ConversionFlags;
+
+ConversionResult ConvertUTF8toUTF32 (
+								const UTF8** sourceStart, const UTF8* sourceEnd,
+								UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
+
+ConversionResult ConvertUTF32toUTF8 (
+								const UTF32** sourceStart, const UTF32* sourceEnd,
+								UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
+
+}
+
+#endif /* REPLXX_CONVERT_UTF8_H_INCLUDED */
+
+/* --------------------------------------------------------------------- */
diff --git a/contrib/restricted/patched/replxx/src/conversion.cxx b/contrib/restricted/patched/replxx/src/conversion.cxx
new file mode 100644
index 0000000000..bcdbe048ec
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/conversion.cxx
@@ -0,0 +1,108 @@
+#include <algorithm>
+#include <string>
+#include <cstring>
+#include <cctype>
+#include <locale.h>
+
+#include "conversion.hxx"
+
+#ifdef _WIN32
+#define strdup _strdup
+#endif
+
+using namespace std;
+
+namespace replxx {
+
+namespace locale {
+
+void to_lower( std::string& s_ ) {
+	transform( s_.begin(), s_.end(), s_.begin(), static_cast<int(*)(int)>( &tolower ) );
+}
+
+bool is_8bit_encoding( void ) {
+	bool is8BitEncoding( false );
+	string origLC( setlocale( LC_CTYPE, nullptr ) );
+	string lc( origLC );
+	to_lower( lc );
+	if ( lc == "c" ) {
+		setlocale( LC_CTYPE, "" );
+	}
+	lc = setlocale( LC_CTYPE, nullptr );
+	setlocale( LC_CTYPE, origLC.c_str() );
+	to_lower( lc );
+	if ( lc.find( "8859" ) != std::string::npos ) {
+		is8BitEncoding = true;
+	}
+	return ( is8BitEncoding );
+}
+
+bool is8BitEncoding( is_8bit_encoding() );
+
+}
+
+ConversionResult copyString8to32(char32_t* dst, int dstSize, int& dstCount, const char* src) {
+	ConversionResult res = ConversionResult::conversionOK;
+	if ( ! locale::is8BitEncoding ) {
+		const UTF8* sourceStart = reinterpret_cast<const UTF8*>(src);
+		const UTF8* sourceEnd = sourceStart + strlen(src);
+		UTF32* targetStart = reinterpret_cast<UTF32*>(dst);
+		UTF32* targetEnd = targetStart + dstSize;
+
+		res = ConvertUTF8toUTF32(
+				&sourceStart, sourceEnd, &targetStart, targetEnd, lenientConversion);
+
+		if (res == conversionOK) {
+			dstCount = static_cast<int>( targetStart - reinterpret_cast<UTF32*>( dst ) );
+
+			if (dstCount < dstSize) {
+				*targetStart = 0;
+			}
+		}
+	} else {
+		for ( dstCount = 0; ( dstCount < dstSize ) && src[dstCount]; ++ dstCount ) {
+			dst[dstCount] = src[dstCount];
+		}
+	}
+	return res;
+}
+
+ConversionResult copyString8to32(char32_t* dst, int dstSize, int& dstCount, const char8_t* src) {
+	return copyString8to32(
+		dst, dstSize, dstCount, reinterpret_cast<const char*>(src)
+	);
+}
+
+int copyString32to8( char* dst, int dstSize, const char32_t* src, int srcSize ) {
+	int resCount( 0 );
+	if ( ! locale::is8BitEncoding ) {
+		const UTF32* sourceStart = reinterpret_cast<const UTF32*>(src);
+		const UTF32* sourceEnd = sourceStart + srcSize;
+		UTF8* targetStart = reinterpret_cast<UTF8*>(dst);
+		UTF8* targetEnd = targetStart + dstSize;
+
+		ConversionResult res = ConvertUTF32toUTF8(
+			&sourceStart, sourceEnd, &targetStart, targetEnd, lenientConversion
+		);
+
+		if ( res == conversionOK ) {
+			resCount = static_cast<int>( targetStart - reinterpret_cast<UTF8*>( dst ) );
+			if ( resCount < dstSize ) {
+				*targetStart = 0;
+			}
+		}
+	} else {
+		int i( 0 );
+		for ( i = 0; ( i < dstSize ) && ( i < srcSize ) && src[i]; ++ i ) {
+			dst[i] = static_cast<char>( src[i] );
+		}
+		resCount = i;
+		if ( i < dstSize ) {
+			dst[i] = 0;
+		}
+	}
+	return ( resCount );
+}
+
+}
+
diff --git a/contrib/restricted/patched/replxx/src/conversion.hxx b/contrib/restricted/patched/replxx/src/conversion.hxx
new file mode 100644
index 0000000000..6587ad0e2f
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/conversion.hxx
@@ -0,0 +1,30 @@
+#ifndef REPLXX_CONVERSION_HXX_INCLUDED
+#define REPLXX_CONVERSION_HXX_INCLUDED 1
+
+#include "ConvertUTF.h"
+
+#ifdef __has_include
+#if __has_include( <version> )
+#include <version>
+#endif
+#endif
+
+#if ! ( defined( __cpp_lib_char8_t ) || ( defined( __clang_major__ ) && ( __clang_major__ >= 8 ) && ( __cplusplus > 201703L ) ) )
+namespace replxx {
+typedef unsigned char char8_t;
+}
+#endif
+
+namespace replxx {
+
+ConversionResult copyString8to32( char32_t* dst, int dstSize, int& dstCount, char const* src );
+ConversionResult copyString8to32( char32_t* dst, int dstSize, int& dstCount, char8_t const* src );
+int copyString32to8( char* dst, int dstSize, char32_t const* src, int srcSize );
+
+namespace locale {
+extern bool is8BitEncoding;
+}
+
+}
+
+#endif
diff --git a/contrib/restricted/patched/replxx/src/escape.cxx b/contrib/restricted/patched/replxx/src/escape.cxx
new file mode 100644
index 0000000000..dda1ab0be0
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/escape.cxx
@@ -0,0 +1,890 @@
+#include "escape.hxx"
+#include "terminal.hxx"
+#include "replxx.hxx"
+
+#ifndef _WIN32
+
+namespace replxx {
+
+namespace EscapeSequenceProcessing { // move these out of global namespace
+
+// This chunk of code does parsing of the escape sequences sent by various Linux
+// terminals.
+//
+// It handles arrow keys, Home, End and Delete keys by interpreting the
+// sequences sent by
+// gnome terminal, xterm, rxvt, konsole, aterm and yakuake including the Alt and
+// Ctrl key
+// combinations that are understood by replxx.
+//
+// The parsing uses tables, a bunch of intermediate dispatch routines and a
+// doDispatch
+// loop that reads the tables and sends control to "deeper" routines to continue
+// the
+// parsing.	The starting call to doDispatch( c, initialDispatch ) will
+// eventually return
+// either a character (with optional CTRL and META bits set), or -1 if parsing
+// fails, or
+// zero if an attempt to read from the keyboard fails.
+//
+// This is rather sloppy escape sequence processing, since we're not paying
+// attention to what the
+// actual TERM is set to and are processing all key sequences for all terminals,
+// but it works with
+// the most common keystrokes on the most common terminals.	It's intricate, but
+// the nested 'if'
+// statements required to do it directly would be worse.	This way has the
+// advantage of allowing
+// changes and extensions without having to touch a lot of code.
+
+
+static char32_t thisKeyMetaCtrl = 0;	// holds pre-set Meta and/or Ctrl modifiers
+
+// This dispatch routine is given a dispatch table and then farms work out to
+// routines
+// listed in the table based on the character it is called with.	The dispatch
+// routines can
+// read more input characters to decide what should eventually be returned.
+// Eventually,
+// a called routine returns either a character or -1 to indicate parsing
+// failure.
+//
+char32_t doDispatch(char32_t c, CharacterDispatch& dispatchTable) {
+	for (unsigned int i = 0; i < dispatchTable.len; ++i) {
+		if (static_cast<unsigned char>(dispatchTable.chars[i]) == c) {
+			return dispatchTable.dispatch[i](c);
+		}
+	}
+	return dispatchTable.dispatch[dispatchTable.len](c);
+}
+
+// Final dispatch routines -- return something
+//
+static char32_t normalKeyRoutine(char32_t c) { return thisKeyMetaCtrl | c; }
+static char32_t upArrowKeyRoutine(char32_t) {
+	return thisKeyMetaCtrl | Replxx::KEY::UP;;
+}
+static char32_t downArrowKeyRoutine(char32_t) {
+	return thisKeyMetaCtrl | Replxx::KEY::DOWN;
+}
+static char32_t rightArrowKeyRoutine(char32_t) {
+	return thisKeyMetaCtrl | Replxx::KEY::RIGHT;
+}
+static char32_t leftArrowKeyRoutine(char32_t) {
+	return thisKeyMetaCtrl | Replxx::KEY::LEFT;
+}
+static char32_t homeKeyRoutine(char32_t) { return thisKeyMetaCtrl | Replxx::KEY::HOME; }
+static char32_t endKeyRoutine(char32_t) { return thisKeyMetaCtrl | Replxx::KEY::END; }
+static char32_t shiftTabRoutine(char32_t) { return Replxx::KEY::BASE_SHIFT | Replxx::KEY::TAB; }
+static char32_t f1KeyRoutine(char32_t) { return thisKeyMetaCtrl | Replxx::KEY::F1; }
+static char32_t f2KeyRoutine(char32_t) { return thisKeyMetaCtrl | Replxx::KEY::F2; }
+static char32_t f3KeyRoutine(char32_t) { return thisKeyMetaCtrl | Replxx::KEY::F3; }
+static char32_t f4KeyRoutine(char32_t) { return thisKeyMetaCtrl | Replxx::KEY::F4; }
+static char32_t f5KeyRoutine(char32_t) { return thisKeyMetaCtrl | Replxx::KEY::F5; }
+static char32_t f6KeyRoutine(char32_t) { return thisKeyMetaCtrl | Replxx::KEY::F6; }
+static char32_t f7KeyRoutine(char32_t) { return thisKeyMetaCtrl | Replxx::KEY::F7; }
+static char32_t f8KeyRoutine(char32_t) { return thisKeyMetaCtrl | Replxx::KEY::F8; }
+static char32_t f9KeyRoutine(char32_t) { return thisKeyMetaCtrl | Replxx::KEY::F9; }
+static char32_t f10KeyRoutine(char32_t) { return thisKeyMetaCtrl | Replxx::KEY::F10; }
+static char32_t f11KeyRoutine(char32_t) { return thisKeyMetaCtrl | Replxx::KEY::F11; }
+static char32_t f12KeyRoutine(char32_t) { return thisKeyMetaCtrl | Replxx::KEY::F12; }
+static char32_t pageUpKeyRoutine(char32_t) {
+	return thisKeyMetaCtrl | Replxx::KEY::PAGE_UP;
+}
+static char32_t pageDownKeyRoutine(char32_t) {
+	return thisKeyMetaCtrl | Replxx::KEY::PAGE_DOWN;
+}
+static char32_t deleteCharRoutine(char32_t) {
+	return thisKeyMetaCtrl | Replxx::KEY::BACKSPACE;
+}	// key labeled Backspace
+static char32_t insertKeyRoutine(char32_t) {
+	return thisKeyMetaCtrl | Replxx::KEY::INSERT;
+}	// key labeled Delete
+static char32_t deleteKeyRoutine(char32_t) {
+	return thisKeyMetaCtrl | Replxx::KEY::DELETE;
+}	// key labeled Delete
+static char32_t ctrlUpArrowKeyRoutine(char32_t) {
+	return thisKeyMetaCtrl | Replxx::KEY::BASE_CONTROL | Replxx::KEY::UP;
+}
+static char32_t ctrlDownArrowKeyRoutine(char32_t) {
+	return thisKeyMetaCtrl | Replxx::KEY::BASE_CONTROL | Replxx::KEY::DOWN;
+}
+static char32_t ctrlRightArrowKeyRoutine(char32_t) {
+	return thisKeyMetaCtrl | Replxx::KEY::BASE_CONTROL | Replxx::KEY::RIGHT;
+}
+static char32_t ctrlLeftArrowKeyRoutine(char32_t) {
+	return thisKeyMetaCtrl | Replxx::KEY::BASE_CONTROL | Replxx::KEY::LEFT;
+}
+static char32_t bracketPasteStartKeyRoutine(char32_t) {
+	return thisKeyMetaCtrl | Replxx::KEY::PASTE_START;
+}
+static char32_t bracketPasteFinishKeyRoutine(char32_t) {
+	return thisKeyMetaCtrl | Replxx::KEY::PASTE_FINISH;
+}
+static char32_t escFailureRoutine(char32_t) {
+	beep();
+	return -1;
+}
+
+// Handle ESC [ 1 ; 2 or 3 (or 5) <more stuff> escape sequences
+//
+static CharacterDispatchRoutine escLeftBracket1Semicolon2or3or5Routines[] = {
+	upArrowKeyRoutine,
+	downArrowKeyRoutine,
+	rightArrowKeyRoutine,
+	leftArrowKeyRoutine,
+	homeKeyRoutine,
+	endKeyRoutine,
+	f1KeyRoutine,
+	f2KeyRoutine,
+	f3KeyRoutine,
+	f4KeyRoutine,
+	escFailureRoutine
+};
+static CharacterDispatch escLeftBracket1Semicolon2or3or5Dispatch = {
+		10, "ABCDHFPQRS", escLeftBracket1Semicolon2or3or5Routines
+};
+
+// Handle ESC [ 1 ; <more stuff> escape sequences
+//
+static char32_t escLeftBracket1Semicolon2Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_SHIFT;
+	return doDispatch(c, escLeftBracket1Semicolon2or3or5Dispatch);
+}
+static char32_t escLeftBracket1Semicolon3Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_META;
+	return doDispatch(c, escLeftBracket1Semicolon2or3or5Dispatch);
+}
+static char32_t escLeftBracket1Semicolon5Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_CONTROL;
+	return doDispatch(c, escLeftBracket1Semicolon2or3or5Dispatch);
+}
+static CharacterDispatchRoutine escLeftBracket1SemicolonRoutines[] = {
+	escLeftBracket1Semicolon2Routine,
+	escLeftBracket1Semicolon3Routine,
+	escLeftBracket1Semicolon5Routine,
+	escFailureRoutine
+};
+static CharacterDispatch escLeftBracket1SemicolonDispatch = {
+	3, "235", escLeftBracket1SemicolonRoutines
+};
+
+// Handle ESC [ 1 ; <more stuff> escape sequences
+//
+static char32_t escLeftBracket1SemicolonRoutine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket1SemicolonDispatch);
+}
+
+// (S)-F5
+static CharacterDispatchRoutine escLeftBracket15Semicolon2Routines[] = {
+	f5KeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket15Semicolon2Dispatch = {
+	1, "~", escLeftBracket15Semicolon2Routines
+};
+static char32_t escLeftBracket15Semicolon2Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_SHIFT;
+	return doDispatch(c, escLeftBracket15Semicolon2Dispatch);
+}
+
+// (C)-F5
+static CharacterDispatchRoutine escLeftBracket15Semicolon5Routines[] = {
+	f5KeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket15Semicolon5Dispatch = {
+	1, "~", escLeftBracket15Semicolon5Routines
+};
+static char32_t escLeftBracket15Semicolon5Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_CONTROL;
+	return doDispatch(c, escLeftBracket15Semicolon5Dispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket15SemicolonRoutines[] = {
+	escLeftBracket15Semicolon2Routine, escLeftBracket15Semicolon5Routine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket15SemicolonDispatch = {
+	2, "25", escLeftBracket15SemicolonRoutines
+};
+static char32_t escLeftBracket15SemicolonRoutine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket15SemicolonDispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket15Routines[] = {
+	f5KeyRoutine, escLeftBracket15SemicolonRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket15Dispatch = {
+	2, "~;", escLeftBracket15Routines
+};
+static char32_t escLeftBracket15Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket15Dispatch);
+}
+
+// (S)-F6
+static CharacterDispatchRoutine escLeftBracket17Semicolon2Routines[] = {
+	f6KeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket17Semicolon2Dispatch = {
+	1, "~", escLeftBracket17Semicolon2Routines
+};
+static char32_t escLeftBracket17Semicolon2Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_SHIFT;
+	return doDispatch(c, escLeftBracket17Semicolon2Dispatch);
+}
+
+// (C)-F6
+static CharacterDispatchRoutine escLeftBracket17Semicolon5Routines[] = {
+	f6KeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket17Semicolon5Dispatch = {
+	1, "~", escLeftBracket17Semicolon5Routines
+};
+static char32_t escLeftBracket17Semicolon5Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_CONTROL;
+	return doDispatch(c, escLeftBracket17Semicolon5Dispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket17SemicolonRoutines[] = {
+	escLeftBracket17Semicolon2Routine, escLeftBracket17Semicolon5Routine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket17SemicolonDispatch = {
+	2, "25", escLeftBracket17SemicolonRoutines
+};
+static char32_t escLeftBracket17SemicolonRoutine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket17SemicolonDispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket17Routines[] = {
+	f6KeyRoutine, escLeftBracket17SemicolonRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket17Dispatch = {
+	2, "~;", escLeftBracket17Routines
+};
+static char32_t escLeftBracket17Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket17Dispatch);
+}
+
+// (S)-F7
+static CharacterDispatchRoutine escLeftBracket18Semicolon2Routines[] = {
+	f7KeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket18Semicolon2Dispatch = {
+	1, "~", escLeftBracket18Semicolon2Routines
+};
+static char32_t escLeftBracket18Semicolon2Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_SHIFT;
+	return doDispatch(c, escLeftBracket18Semicolon2Dispatch);
+}
+
+// (C)-F7
+static CharacterDispatchRoutine escLeftBracket18Semicolon5Routines[] = {
+	f7KeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket18Semicolon5Dispatch = {
+	1, "~", escLeftBracket18Semicolon5Routines
+};
+static char32_t escLeftBracket18Semicolon5Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_CONTROL;
+	return doDispatch(c, escLeftBracket18Semicolon5Dispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket18SemicolonRoutines[] = {
+	escLeftBracket18Semicolon2Routine, escLeftBracket18Semicolon5Routine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket18SemicolonDispatch = {
+	2, "25", escLeftBracket18SemicolonRoutines
+};
+static char32_t escLeftBracket18SemicolonRoutine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket18SemicolonDispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket18Routines[] = {
+	f7KeyRoutine, escLeftBracket18SemicolonRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket18Dispatch = {
+	2, "~;", escLeftBracket18Routines
+};
+static char32_t escLeftBracket18Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket18Dispatch);
+}
+
+// (S)-F8
+static CharacterDispatchRoutine escLeftBracket19Semicolon2Routines[] = {
+	f8KeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket19Semicolon2Dispatch = {
+	1, "~", escLeftBracket19Semicolon2Routines
+};
+static char32_t escLeftBracket19Semicolon2Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_SHIFT;
+	return doDispatch(c, escLeftBracket19Semicolon2Dispatch);
+}
+
+// (C)-F8
+static CharacterDispatchRoutine escLeftBracket19Semicolon5Routines[] = {
+	f8KeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket19Semicolon5Dispatch = {
+	1, "~", escLeftBracket19Semicolon5Routines
+};
+static char32_t escLeftBracket19Semicolon5Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_CONTROL;
+	return doDispatch(c, escLeftBracket19Semicolon5Dispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket19SemicolonRoutines[] = {
+	escLeftBracket19Semicolon2Routine, escLeftBracket19Semicolon5Routine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket19SemicolonDispatch = {
+	2, "25", escLeftBracket19SemicolonRoutines
+};
+static char32_t escLeftBracket19SemicolonRoutine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket19SemicolonDispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket19Routines[] = {
+	f8KeyRoutine, escLeftBracket19SemicolonRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket19Dispatch = {
+	2, "~;", escLeftBracket19Routines
+};
+static char32_t escLeftBracket19Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket19Dispatch);
+}
+
+// Handle ESC [ 1 <more stuff> escape sequences
+//
+static CharacterDispatchRoutine escLeftBracket1Routines[] = {
+	homeKeyRoutine, escLeftBracket1SemicolonRoutine,
+	escLeftBracket15Routine,
+	escLeftBracket17Routine,
+	escLeftBracket18Routine,
+	escLeftBracket19Routine,
+	escFailureRoutine
+};
+static CharacterDispatch escLeftBracket1Dispatch = {
+	6, "~;5789", escLeftBracket1Routines
+};
+
+// Handle ESC [ 2 <more stuff> escape sequences
+//
+
+// (S)-F9
+static CharacterDispatchRoutine escLeftBracket20Semicolon2Routines[] = {
+	f9KeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket20Semicolon2Dispatch = {
+	1, "~", escLeftBracket20Semicolon2Routines
+};
+static char32_t escLeftBracket20Semicolon2Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_SHIFT;
+	return doDispatch(c, escLeftBracket20Semicolon2Dispatch);
+}
+
+// (C)-F9
+static CharacterDispatchRoutine escLeftBracket20Semicolon5Routines[] = {
+	f9KeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket20Semicolon5Dispatch = {
+	1, "~", escLeftBracket20Semicolon5Routines
+};
+static char32_t escLeftBracket20Semicolon5Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_CONTROL;
+	return doDispatch(c, escLeftBracket20Semicolon5Dispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket20SemicolonRoutines[] = {
+	escLeftBracket20Semicolon2Routine, escLeftBracket20Semicolon5Routine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket20SemicolonDispatch = {
+	2, "25", escLeftBracket20SemicolonRoutines
+};
+static char32_t escLeftBracket20SemicolonRoutine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket20SemicolonDispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket200Routines[] = {
+	bracketPasteStartKeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket200Dispatch = {
+	1, "~", escLeftBracket200Routines
+};
+static char32_t escLeftBracket200Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket200Dispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket201Routines[] = {
+	bracketPasteFinishKeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket201Dispatch = {
+	1, "~", escLeftBracket201Routines
+};
+static char32_t escLeftBracket201Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket201Dispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket20Routines[] = {
+	f9KeyRoutine, escLeftBracket20SemicolonRoutine, escLeftBracket200Routine, escLeftBracket201Routine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket20Dispatch = {
+	4, "~;01", escLeftBracket20Routines
+};
+static char32_t escLeftBracket20Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket20Dispatch);
+}
+
+// (S)-F10
+static CharacterDispatchRoutine escLeftBracket21Semicolon2Routines[] = {
+	f10KeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket21Semicolon2Dispatch = {
+	1, "~", escLeftBracket21Semicolon2Routines
+};
+static char32_t escLeftBracket21Semicolon2Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_SHIFT;
+	return doDispatch(c, escLeftBracket21Semicolon2Dispatch);
+}
+
+// (C)-F10
+static CharacterDispatchRoutine escLeftBracket21Semicolon5Routines[] = {
+	f10KeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket21Semicolon5Dispatch = {
+	1, "~", escLeftBracket21Semicolon5Routines
+};
+static char32_t escLeftBracket21Semicolon5Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_CONTROL;
+	return doDispatch(c, escLeftBracket21Semicolon5Dispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket21SemicolonRoutines[] = {
+	escLeftBracket21Semicolon2Routine, escLeftBracket21Semicolon5Routine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket21SemicolonDispatch = {
+	2, "25", escLeftBracket21SemicolonRoutines
+};
+static char32_t escLeftBracket21SemicolonRoutine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket21SemicolonDispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket21Routines[] = {
+	f10KeyRoutine, escLeftBracket21SemicolonRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket21Dispatch = {
+	2, "~;", escLeftBracket21Routines
+};
+static char32_t escLeftBracket21Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket21Dispatch);
+}
+
+// (S)-F11
+static CharacterDispatchRoutine escLeftBracket23Semicolon2Routines[] = {
+	f11KeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket23Semicolon2Dispatch = {
+	1, "~", escLeftBracket23Semicolon2Routines
+};
+static char32_t escLeftBracket23Semicolon2Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_SHIFT;
+	return doDispatch(c, escLeftBracket23Semicolon2Dispatch);
+}
+
+// (C)-F11
+static CharacterDispatchRoutine escLeftBracket23Semicolon5Routines[] = {
+	f11KeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket23Semicolon5Dispatch = {
+	1, "~", escLeftBracket23Semicolon5Routines
+};
+static char32_t escLeftBracket23Semicolon5Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_CONTROL;
+	return doDispatch(c, escLeftBracket23Semicolon5Dispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket23SemicolonRoutines[] = {
+	escLeftBracket23Semicolon2Routine, escLeftBracket23Semicolon5Routine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket23SemicolonDispatch = {
+	2, "25", escLeftBracket23SemicolonRoutines
+};
+static char32_t escLeftBracket23SemicolonRoutine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket23SemicolonDispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket23Routines[] = {
+	f11KeyRoutine, escLeftBracket23SemicolonRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket23Dispatch = {
+	2, "~;", escLeftBracket23Routines
+};
+static char32_t escLeftBracket23Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket23Dispatch);
+}
+
+// (S)-F12
+static CharacterDispatchRoutine escLeftBracket24Semicolon2Routines[] = {
+	f12KeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket24Semicolon2Dispatch = {
+	1, "~", escLeftBracket24Semicolon2Routines
+};
+static char32_t escLeftBracket24Semicolon2Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_SHIFT;
+	return doDispatch(c, escLeftBracket24Semicolon2Dispatch);
+}
+
+// (C)-F12
+static CharacterDispatchRoutine escLeftBracket24Semicolon5Routines[] = {
+	f12KeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket24Semicolon5Dispatch = {
+	1, "~", escLeftBracket24Semicolon5Routines
+};
+static char32_t escLeftBracket24Semicolon5Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_CONTROL;
+	return doDispatch(c, escLeftBracket24Semicolon5Dispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket24SemicolonRoutines[] = {
+	escLeftBracket24Semicolon2Routine, escLeftBracket24Semicolon5Routine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket24SemicolonDispatch = {
+	2, "25", escLeftBracket24SemicolonRoutines
+};
+static char32_t escLeftBracket24SemicolonRoutine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket24SemicolonDispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket24Routines[] = {
+	f12KeyRoutine, escLeftBracket24SemicolonRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket24Dispatch = {
+	2, "~;", escLeftBracket24Routines
+};
+static char32_t escLeftBracket24Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket24Dispatch);
+}
+
+// Handle ESC [ 2 <more stuff> escape sequences
+//
+static CharacterDispatchRoutine escLeftBracket2Routines[] = {
+	insertKeyRoutine,
+	escLeftBracket20Routine,
+	escLeftBracket21Routine,
+	escLeftBracket23Routine,
+	escLeftBracket24Routine,
+	escFailureRoutine
+};
+static CharacterDispatch escLeftBracket2Dispatch = {
+	5, "~0134", escLeftBracket2Routines
+};
+
+// Handle ESC [ 3 <more stuff> escape sequences
+//
+static CharacterDispatchRoutine escLeftBracket3Routines[] = {
+	deleteKeyRoutine, escFailureRoutine
+};
+
+static CharacterDispatch escLeftBracket3Dispatch = {
+	1, "~", escLeftBracket3Routines
+};
+
+// Handle ESC [ 4 <more stuff> escape sequences
+//
+static CharacterDispatchRoutine escLeftBracket4Routines[] = {
+	endKeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket4Dispatch = {
+	1, "~", escLeftBracket4Routines
+};
+
+// Handle ESC [ 5 <more stuff> escape sequences
+//
+static CharacterDispatchRoutine escLeftBracket5Semicolon5Routines[] = {
+	pageUpKeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket5Semicolon5Dispatch = {
+	1, "~", escLeftBracket5Semicolon5Routines
+};
+static char32_t escLeftBracket5Semicolon5Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_CONTROL;
+	return doDispatch(c, escLeftBracket5Semicolon5Dispatch);
+}
+static CharacterDispatchRoutine escLeftBracket5SemicolonRoutines[] = {
+	escLeftBracket5Semicolon5Routine,
+	escFailureRoutine
+};
+static CharacterDispatch escLeftBracket5SemicolonDispatch = {
+	1, "5", escLeftBracket5SemicolonRoutines
+};
+static char32_t escLeftBracket5SemicolonRoutine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket5SemicolonDispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket5Routines[] = {
+	pageUpKeyRoutine, escLeftBracket5SemicolonRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket5Dispatch = {
+	2, "~;", escLeftBracket5Routines
+};
+
+// Handle ESC [ 6 <more stuff> escape sequences
+//
+static CharacterDispatchRoutine escLeftBracket6Semicolon5Routines[] = {
+	pageDownKeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket6Semicolon5Dispatch = {
+	1, "~", escLeftBracket6Semicolon5Routines
+};
+static char32_t escLeftBracket6Semicolon5Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	thisKeyMetaCtrl |= Replxx::KEY::BASE_CONTROL;
+	return doDispatch(c, escLeftBracket6Semicolon5Dispatch);
+}
+static CharacterDispatchRoutine escLeftBracket6SemicolonRoutines[] = {
+	escLeftBracket6Semicolon5Routine,
+	escFailureRoutine
+};
+static CharacterDispatch escLeftBracket6SemicolonDispatch = {
+	1, "5", escLeftBracket6SemicolonRoutines
+};
+static char32_t escLeftBracket6SemicolonRoutine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket6SemicolonDispatch);
+}
+
+static CharacterDispatchRoutine escLeftBracket6Routines[] = {
+	pageDownKeyRoutine, escLeftBracket6SemicolonRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket6Dispatch = {
+	2, "~;", escLeftBracket6Routines
+};
+
+// Handle ESC [ 7 <more stuff> escape sequences
+//
+static CharacterDispatchRoutine escLeftBracket7Routines[] = {
+	homeKeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket7Dispatch = {
+	1, "~", escLeftBracket7Routines
+};
+
+// Handle ESC [ 8 <more stuff> escape sequences
+//
+static CharacterDispatchRoutine escLeftBracket8Routines[] = {
+	endKeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracket8Dispatch = {
+	1, "~", escLeftBracket8Routines
+};
+
+// Handle ESC [ <digit> escape sequences
+//
+static char32_t escLeftBracket0Routine(char32_t c) {
+	return escFailureRoutine(c);
+}
+static char32_t escLeftBracket1Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket1Dispatch);
+}
+static char32_t escLeftBracket2Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket2Dispatch);
+}
+static char32_t escLeftBracket3Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket3Dispatch);
+}
+static char32_t escLeftBracket4Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket4Dispatch);
+}
+static char32_t escLeftBracket5Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket5Dispatch);
+}
+static char32_t escLeftBracket6Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket6Dispatch);
+}
+static char32_t escLeftBracket7Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket7Dispatch);
+}
+static char32_t escLeftBracket8Routine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracket8Dispatch);
+}
+static char32_t escLeftBracket9Routine(char32_t c) {
+	return escFailureRoutine(c);
+}
+
+// Handle ESC [ <more stuff> escape sequences
+//
+static CharacterDispatchRoutine escLeftBracketRoutines[] = {
+	upArrowKeyRoutine,      downArrowKeyRoutine,    rightArrowKeyRoutine,
+	leftArrowKeyRoutine,    homeKeyRoutine,         endKeyRoutine,
+	shiftTabRoutine,
+	escLeftBracket0Routine, escLeftBracket1Routine, escLeftBracket2Routine,
+	escLeftBracket3Routine, escLeftBracket4Routine, escLeftBracket5Routine,
+	escLeftBracket6Routine, escLeftBracket7Routine, escLeftBracket8Routine,
+	escLeftBracket9Routine, escFailureRoutine
+};
+static CharacterDispatch escLeftBracketDispatch = {17, "ABCDHFZ0123456789",
+																									 escLeftBracketRoutines};
+
+// Handle ESC O <char> escape sequences
+//
+static CharacterDispatchRoutine escORoutines[] = {
+	upArrowKeyRoutine,       downArrowKeyRoutine,     rightArrowKeyRoutine,
+	leftArrowKeyRoutine,     homeKeyRoutine,          endKeyRoutine,
+	f1KeyRoutine,            f2KeyRoutine,            f3KeyRoutine,
+	f4KeyRoutine,
+	ctrlUpArrowKeyRoutine,   ctrlDownArrowKeyRoutine, ctrlRightArrowKeyRoutine,
+	ctrlLeftArrowKeyRoutine, escFailureRoutine
+};
+static CharacterDispatch escODispatch = {14, "ABCDHFPQRSabcd", escORoutines};
+
+// Initial ESC dispatch -- could be a Meta prefix or the start of an escape
+// sequence
+//
+static char32_t escLeftBracketRoutine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escLeftBracketDispatch);
+}
+static char32_t escORoutine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escODispatch);
+}
+static char32_t setMetaRoutine(char32_t c);	// need forward reference
+static CharacterDispatchRoutine escRoutines[] = {
+	escLeftBracketRoutine, escORoutine, setMetaRoutine
+};
+static CharacterDispatch escDispatch = {2, "[O", escRoutines};
+
+// Initial dispatch -- we are not in the middle of anything yet
+//
+static char32_t escRoutine(char32_t c) {
+	c = read_unicode_character();
+	if (c == 0) return 0;
+	return doDispatch(c, escDispatch);
+}
+static CharacterDispatchRoutine initialRoutines[] = {
+	escRoutine, deleteCharRoutine, normalKeyRoutine
+};
+static CharacterDispatch initialDispatch = {2, "\x1B\x7F", initialRoutines};
+
+// Special handling for the ESC key because it does double duty
+//
+static char32_t setMetaRoutine(char32_t c) {
+	thisKeyMetaCtrl = Replxx::KEY::BASE_META;
+	if (c == 0x1B) {	// another ESC, stay in ESC processing mode
+		c = read_unicode_character();
+		if (c == 0) return 0;
+		return doDispatch(c, escDispatch);
+	}
+	return doDispatch(c, initialDispatch);
+}
+
+char32_t doDispatch(char32_t c) {
+	EscapeSequenceProcessing::thisKeyMetaCtrl = 0;	// no modifiers yet at initialDispatch
+	return doDispatch(c, initialDispatch);
+}
+
+}	// namespace EscapeSequenceProcessing // move these out of global namespace
+
+}
+
+#endif /* #ifndef _WIN32 */
+
diff --git a/contrib/restricted/patched/replxx/src/escape.hxx b/contrib/restricted/patched/replxx/src/escape.hxx
new file mode 100644
index 0000000000..6597395328
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/escape.hxx
@@ -0,0 +1,37 @@
+#ifndef REPLXX_ESCAPE_HXX_INCLUDED
+#define REPLXX_ESCAPE_HXX_INCLUDED 1
+
+namespace replxx {
+
+namespace EscapeSequenceProcessing {
+
+// This is a typedef for the routine called by doDispatch().	It takes the
+// current character
+// as input, does any required processing including reading more characters and
+// calling other
+// dispatch routines, then eventually returns the final (possibly extended or
+// special) character.
+//
+typedef char32_t (*CharacterDispatchRoutine)(char32_t);
+
+// This structure is used by doDispatch() to hold a list of characters to test
+// for and
+// a list of routines to call if the character matches.	The dispatch routine
+// list is one
+// longer than the character list; the final entry is used if no character
+// matches.
+//
+struct CharacterDispatch {
+	unsigned int len;                   // length of the chars list
+	const char* chars;                  // chars to test
+	CharacterDispatchRoutine* dispatch; // array of routines to call
+};
+
+char32_t doDispatch(char32_t c);
+
+}
+
+}
+
+#endif
+
diff --git a/contrib/restricted/patched/replxx/src/history.cxx b/contrib/restricted/patched/replxx/src/history.cxx
new file mode 100644
index 0000000000..76dbcb76af
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/history.cxx
@@ -0,0 +1,428 @@
+#include <algorithm>
+#include <memory>
+#include <fstream>
+#include <ostream>
+#include <istream>
+#include <cstring>
+
+#ifndef _WIN32
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+#endif /* _WIN32 */
+
+#include "replxx.hxx"
+#include "history.hxx"
+
+using namespace std;
+
+namespace replxx {
+
+namespace {
+void delete_ReplxxHistoryScanImpl( Replxx::HistoryScanImpl* impl_ ) {
+	delete impl_;
+}
+static int const ETB = 0x17;
+}
+
+static int const REPLXX_DEFAULT_HISTORY_MAX_LEN( 1000 );
+
+Replxx::HistoryScan::HistoryScan( impl_t impl_ )
+	: _impl( std::move( impl_ ) ) {
+}
+
+bool Replxx::HistoryScan::next( void ) {
+	return ( _impl->next() );
+}
+
+Replxx::HistoryScanImpl::HistoryScanImpl( History::entries_t const& entries_ )
+	: _entries( entries_ )
+	, _it( _entries.end() )
+	, _utf8Cache()
+	, _entryCache( std::string(), std::string() )
+	, _cacheValid( false ) {
+}
+
+Replxx::HistoryEntry const& Replxx::HistoryScan::get( void ) const {
+	return ( _impl->get() );
+}
+
+bool Replxx::HistoryScanImpl::next( void ) {
+	if ( _it == _entries.end() ) {
+		_it = _entries.begin();
+	} else {
+		++ _it;
+	}
+	_cacheValid = false;
+	return ( _it != _entries.end() );
+}
+
+Replxx::HistoryEntry const& Replxx::HistoryScanImpl::get( void ) const {
+	if ( _cacheValid ) {
+		return ( _entryCache );
+	}
+	_utf8Cache.assign( _it->text() );
+	_entryCache = Replxx::HistoryEntry( _it->timestamp(), _utf8Cache.get() );
+	_cacheValid = true;
+	return ( _entryCache );
+}
+
+Replxx::HistoryScan::impl_t History::scan( void ) const {
+	return ( Replxx::HistoryScan::impl_t( new Replxx::HistoryScanImpl( _entries ), delete_ReplxxHistoryScanImpl ) );
+}
+
+History::History( void )
+	: _entries()
+	, _maxSize( REPLXX_DEFAULT_HISTORY_MAX_LEN )
+	, _current( _entries.begin() )
+	, _yankPos( _entries.end() )
+	, _previous( _entries.begin() )
+	, _recallMostRecent( false )
+	, _unique( true ) {
+}
+
+void History::add( UnicodeString const& line, std::string const& when ) {
+	if ( _maxSize <= 0 ) {
+		return;
+	}
+	if ( ! _entries.empty() && ( line == _entries.back().text() ) ) {
+		_entries.back() = Entry( now_ms_str(), line );
+		return;
+	}
+	remove_duplicate( line );
+	trim_to_max_size();
+	_entries.emplace_back( when, line );
+	_locations.insert( make_pair( line, last() ) );
+	if ( _current == _entries.end() ) {
+		_current = last();
+	}
+	_yankPos = _entries.end();
+}
+
+#ifndef _WIN32
+class FileLock {
+	std::string _path;
+	int _lockFd;
+public:
+	FileLock( std::string const& name_ )
+		: _path( name_ + ".lock" )
+		, _lockFd( ::open( _path.c_str(), O_CREAT | O_RDWR, 0600 ) ) {
+		static_cast<void>( ::lockf( _lockFd, F_LOCK, 0 ) == 0 );
+	}
+	~FileLock( void ) {
+		static_cast<void>( ::lockf( _lockFd, F_ULOCK, 0 ) == 0 );
+		::close( _lockFd );
+		::unlink( _path.c_str() );
+		return;
+	}
+};
+#endif
+
+bool History::save( std::string const& filename, bool sync_ ) {
+#ifndef _WIN32
+	mode_t old_umask = umask( S_IXUSR | S_IRWXG | S_IRWXO );
+	FileLock fileLock( filename );
+#endif
+	entries_t entries;
+	locations_t locations;
+	if ( ! sync_ ) {
+		entries.swap( _entries );
+		locations.swap( _locations );
+		_entries = entries;
+		reset_iters();
+	}
+	/* scope for ifstream object auto-close */ {
+		ifstream histFile( filename );
+		if ( histFile ) {
+			do_load( histFile );
+		}
+	}
+	sort();
+	remove_duplicates();
+	trim_to_max_size();
+	ofstream histFile( filename );
+	if ( ! histFile ) {
+		return ( false );
+	}
+#ifndef _WIN32
+	umask( old_umask );
+	chmod( filename.c_str(), S_IRUSR | S_IWUSR );
+#endif
+	save( histFile );
+	if ( ! sync_ ) {
+		_entries = std::move( entries );
+		_locations = std::move( locations );
+	}
+	reset_iters();
+	return ( true );
+}
+
+void History::save( std::ostream& histFile ) {
+	Utf8String utf8;
+	UnicodeString us;
+	for ( Entry& h : _entries ) {
+		h.reset_scratch();
+		if ( ! h.text().is_empty() ) {
+			us.assign( h.text() );
+			std::replace( us.begin(), us.end(), char32_t( '\n' ), char32_t( ETB ) );
+			utf8.assign( us );
+			histFile << "### " << h.timestamp() << "\n" << utf8.get() << endl;
+		}
+	}
+}
+
+namespace {
+
+bool is_timestamp( std::string const& s ) {
+	static char const TIMESTAMP_PATTERN[] = "### dddd-dd-dd dd:dd:dd.ddd";
+	static int const TIMESTAMP_LENGTH( sizeof ( TIMESTAMP_PATTERN ) - 1 );
+	if ( s.length() != TIMESTAMP_LENGTH ) {
+		return ( false );
+	}
+	for ( int i( 0 ); i < TIMESTAMP_LENGTH; ++ i ) {
+		if ( TIMESTAMP_PATTERN[i] == 'd' ) {
+			if ( ! isdigit( s[i] ) ) {
+				return ( false );
+			}
+		} else if ( s[i] != TIMESTAMP_PATTERN[i] ) {
+			return ( false );
+		}
+	}
+	return ( true );
+}
+
+}
+
+void History::do_load( std::istream& histFile ) {
+	string line;
+	string when( "0000-00-00 00:00:00.000" );
+	UnicodeString us;
+	while ( getline( histFile, line ).good() ) {
+		string::size_type eol( line.find_first_of( "\r\n" ) );
+		if ( eol != string::npos ) {
+			line.erase( eol );
+		}
+		if ( is_timestamp( line ) ) {
+			when.assign( line, 4, std::string::npos );
+			continue;
+		}
+		if ( ! line.empty() ) {
+			us.assign( line );
+			std::replace( us.begin(), us.end(), char32_t( ETB ), char32_t( '\n' ) );
+			_entries.emplace_back( when, us );
+		}
+	}
+}
+
+bool History::load( std::string const& filename ) {
+	ifstream histFile( filename );
+	if ( ! histFile ) {
+		clear();
+		return false;
+	}
+	load(histFile);
+	return true;
+}
+
+void History::load( std::istream& histFile ) {
+	clear();
+	do_load( histFile );
+	sort();
+	remove_duplicates();
+	trim_to_max_size();
+	_previous = _current = last();
+	_yankPos = _entries.end();
+}
+
+void History::sort( void ) {
+	typedef std::vector<Entry> sortable_entries_t;
+	_locations.clear();
+	sortable_entries_t sortableEntries( _entries.begin(), _entries.end() );
+	std::stable_sort( sortableEntries.begin(), sortableEntries.end() );
+	_entries.clear();
+	_entries.insert( _entries.begin(), sortableEntries.begin(), sortableEntries.end() );
+}
+
+void History::clear( void ) {
+	_locations.clear();
+	_entries.clear();
+	_current = _entries.begin();
+	_recallMostRecent = false;
+}
+
+void History::set_max_size( int size_ ) {
+	if ( size_ >= 0 ) {
+		_maxSize = size_;
+		trim_to_max_size();
+	}
+}
+
+void History::reset_yank_iterator( void ) {
+	_yankPos = _entries.end();
+}
+
+bool History::next_yank_position( void ) {
+	bool resetYankSize( false );
+	if ( _yankPos == _entries.end() ) {
+		resetYankSize = true;
+	}
+	if ( ( _yankPos != _entries.begin() ) && ( _yankPos != _entries.end() ) ) {
+		-- _yankPos;
+	} else {
+		_yankPos = moved( _entries.end(), -2 );
+	}
+	return ( resetYankSize );
+}
+
+bool History::move( bool up_ ) {
+	bool doRecall( _recallMostRecent && ! up_ );
+	if ( doRecall ) {
+		_current = _previous; // emulate Windows down-arrow
+	}
+	_recallMostRecent = false;
+	return ( doRecall || move( _current, up_ ? -1 : 1 ) );
+}
+
+void History::jump( bool start_, bool reset_ ) {
+	if ( start_ ) {
+		_current = _entries.begin();
+	} else {
+		_current = last();
+	}
+	if ( reset_ ) {
+		_recallMostRecent = false;
+	}
+}
+
+void History::save_pos( void ) {
+	_previous = _current;
+}
+
+void History::restore_pos( void ) {
+	_current = _previous;
+}
+
+bool History::common_prefix_search( UnicodeString const& prefix_, int prefixSize_, bool back_, bool ignoreCase ) {
+	int step( back_ ? -1 : 1 );
+	entries_t::iterator it( moved( _current, step, true ) );
+	bool lowerCaseContext( std::none_of( prefix_.begin(), prefix_.end(), []( char32_t x ) { return iswupper( static_cast<wint_t>( x ) ); } ) );
+	while ( it != _current ) {
+		if ( it->text().starts_with( prefix_.begin(), prefix_.begin() + prefixSize_, ignoreCase && lowerCaseContext ? case_insensitive_equal : case_sensitive_equal ) ) {
+			_current = it;
+			commit_index();
+			return ( true );
+		}
+		move( it, step, true );
+	}
+	return ( false );
+}
+
+bool History::move( entries_t::iterator& it_, int by_, bool wrapped_ ) {
+	if ( by_ > 0 ) {
+		for ( int i( 0 ); i < by_; ++ i ) {
+			++ it_;
+			if ( it_ != _entries.end() ) {
+			} else if ( wrapped_ ) {
+				it_ = _entries.begin();
+			} else {
+				-- it_;
+				return ( false );
+			}
+		}
+	} else {
+		for ( int i( 0 ); i > by_; -- i ) {
+			if ( it_ != _entries.begin() ) {
+				-- it_;
+			} else if ( wrapped_ ) {
+				it_ = last();
+			} else {
+				return ( false );
+			}
+		}
+	}
+	return ( true );
+}
+
+History::entries_t::iterator History::moved( entries_t::iterator it_, int by_, bool wrapped_ ) {
+	move( it_, by_, wrapped_ );
+	return ( it_ );
+}
+
+void History::erase( entries_t::iterator it_ ) {
+	bool invalidated( it_ == _current );
+	_locations.erase( it_->text() );
+	it_ = _entries.erase( it_ );
+	if ( invalidated ) {
+		_current = it_;
+	}
+	if ( ( _current == _entries.end() ) && ! _entries.empty() ) {
+		-- _current;
+	}
+	_yankPos = _entries.end();
+	_previous = _current;
+}
+
+void History::trim_to_max_size( void ) {
+	while ( size() > _maxSize ) {
+		erase( _entries.begin() );
+	}
+}
+
+void History::remove_duplicate( UnicodeString const& line_ ) {
+	if ( ! _unique ) {
+		return;
+	}
+	locations_t::iterator it( _locations.find( line_ ) );
+	if ( it == _locations.end() ) {
+		return;
+	}
+	erase( it->second );
+}
+
+void History::remove_duplicates( void ) {
+	if ( ! _unique ) {
+		return;
+	}
+	_locations.clear();
+	typedef std::pair<locations_t::iterator, bool> locations_insertion_result_t;
+	for ( entries_t::iterator it( _entries.begin() ), end( _entries.end() ); it != end; ++ it ) {
+		it->reset_scratch();
+		locations_insertion_result_t locationsInsertionResult( _locations.insert( make_pair( it->text(), it ) ) );
+		if ( ! locationsInsertionResult.second ) {
+			_entries.erase( locationsInsertionResult.first->second );
+			locationsInsertionResult.first->second = it;
+		}
+	}
+}
+
+void History::update_last( UnicodeString const& line_ ) {
+	if ( _unique ) {
+		_locations.erase( _entries.back().text() );
+		remove_duplicate( line_ );
+		_locations.insert( make_pair( line_, last() ) );
+	}
+	_entries.back() = Entry( now_ms_str(), line_ );
+}
+
+void History::drop_last( void ) {
+	reset_current_scratch();
+	erase( last() );
+}
+
+bool History::is_last( void ) {
+	return ( _current == last() );
+}
+
+History::entries_t::iterator History::last( void ) {
+	return ( moved( _entries.end(), -1 ) );
+}
+
+void History::reset_iters( void ) {
+	_previous = _current = last();
+	_yankPos = _entries.end();
+}
+
+}
+
diff --git a/contrib/restricted/patched/replxx/src/history.hxx b/contrib/restricted/patched/replxx/src/history.hxx
new file mode 100644
index 0000000000..b6c20342a2
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/history.hxx
@@ -0,0 +1,162 @@
+#ifndef REPLXX_HISTORY_HXX_INCLUDED
+#define REPLXX_HISTORY_HXX_INCLUDED 1
+
+#include <list>
+#include <unordered_map>
+
+#include "unicodestring.hxx"
+#include "utf8string.hxx"
+#include "conversion.hxx"
+#include "util.hxx"
+
+namespace std {
+template<>
+struct hash<replxx::UnicodeString> {
+	std::size_t operator()( replxx::UnicodeString const& us_ ) const {
+		std::size_t h( 0 );
+		char32_t const* p( us_.get() );
+		char32_t const* e( p + us_.length() );
+		while ( p != e ) {
+			h *= 31;
+			h += *p;
+			++ p;
+		}
+		return ( h );
+	}
+};
+}
+
+namespace replxx {
+
+class History {
+public:
+	class Entry {
+		std::string _timestamp;
+		UnicodeString _text;
+		UnicodeString _scratch;
+	public:
+		Entry( std::string const& timestamp_, UnicodeString const& text_ )
+			: _timestamp( timestamp_ )
+			, _text( text_ )
+			, _scratch( text_ ) {
+		}
+		std::string const& timestamp( void ) const {
+			return ( _timestamp );
+		}
+		UnicodeString const& text( void ) const {
+			return ( _scratch );
+		}
+		void set_scratch( UnicodeString const& s ) {
+			_scratch = s;
+		}
+		void reset_scratch( void ) {
+			_scratch = _text;
+		}
+		bool operator < ( Entry const& other_ ) const {
+			return ( _timestamp < other_._timestamp );
+		}
+	};
+	typedef std::list<Entry> entries_t;
+	typedef std::unordered_map<UnicodeString, entries_t::iterator> locations_t;
+private:
+	entries_t _entries;
+	locations_t _locations;
+	int _maxSize;
+	entries_t::iterator _current;
+	entries_t::const_iterator _yankPos;
+	/*
+	 * _previous and _recallMostRecent are used to allow
+	 * HISTORY_NEXT action (a down-arrow key) to have a special meaning
+	 * if invoked after a line from history was accepted without
+	 * any modification.
+	 * Special meaning is: a down arrow shall jump to the line one
+	 * after previously accepted from history.
+	 */
+	entries_t::iterator _previous;
+	bool _recallMostRecent;
+	bool _unique;
+public:
+	History( void );
+	void add( UnicodeString const& line, std::string const& when = now_ms_str() );
+	bool save( std::string const& filename, bool );
+	void save( std::ostream& histFile );
+	bool load( std::string const& filename );
+	void load( std::istream& histFile );
+	void clear( void );
+	void set_max_size( int len );
+	void set_unique( bool unique_ ) {
+		_unique = unique_;
+		remove_duplicates();
+	}
+	void reset_yank_iterator();
+	bool next_yank_position( void );
+	void reset_recall_most_recent( void ) {
+		_recallMostRecent = false;
+	}
+	void commit_index( void ) {
+		_previous = _current;
+		_recallMostRecent = true;
+	}
+	bool is_empty( void ) const {
+		return ( _entries.empty() );
+	}
+	void update_last( UnicodeString const& );
+	void drop_last( void );
+	bool is_last( void );
+	bool move( bool );
+	void set_current_scratch( UnicodeString const& s ) {
+		_current->set_scratch( s );
+	}
+	void reset_scratches( void ) {
+		for ( Entry& entry : _entries ) {
+			entry.reset_scratch();
+		}
+	}
+	void reset_current_scratch( void ) {
+		_current->reset_scratch();
+	}
+	UnicodeString const& current( void ) const {
+		return ( _current->text() );
+	}
+	UnicodeString const& yank_line( void ) const {
+		return ( _yankPos->text() );
+	}
+	void jump( bool, bool = true );
+	bool common_prefix_search( UnicodeString const&, int, bool, bool );
+	int size( void ) const {
+		return ( static_cast<int>( _entries.size() ) );
+	}
+	Replxx::HistoryScan::impl_t scan( void ) const;
+	void save_pos( void );
+	void restore_pos( void );
+private:
+	History( History const& ) = delete;
+	History& operator = ( History const& ) = delete;
+	bool move( entries_t::iterator&, int, bool = false );
+	entries_t::iterator moved( entries_t::iterator, int, bool = false );
+	void erase( entries_t::iterator );
+	void trim_to_max_size( void );
+	void remove_duplicate( UnicodeString const& );
+	void remove_duplicates( void );
+	void do_load( std::istream& );
+	entries_t::iterator last( void );
+	void sort( void );
+	void reset_iters( void );
+};
+
+class Replxx::HistoryScanImpl {
+	History::entries_t const& _entries;
+	History::entries_t::const_iterator _it;
+	mutable Utf8String _utf8Cache;
+	mutable Replxx::HistoryEntry _entryCache;
+	mutable bool _cacheValid;
+public:
+	HistoryScanImpl( History::entries_t const& );
+	bool next( void );
+	Replxx::HistoryEntry const& get( void ) const;
+};
+
+}
+
+#endif
+
diff --git a/contrib/restricted/patched/replxx/src/killring.hxx b/contrib/restricted/patched/replxx/src/killring.hxx
new file mode 100644
index 0000000000..0baf108e73
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/killring.hxx
@@ -0,0 +1,78 @@
+#ifndef REPLXX_KILLRING_HXX_INCLUDED
+#define REPLXX_KILLRING_HXX_INCLUDED 1
+
+#include <vector>
+
+#include "unicodestring.hxx"
+
+namespace replxx {
+
+class KillRing {
+	static const int capacity = 10;
+	int size;
+	int index;
+	char indexToSlot[10];
+	std::vector<UnicodeString> theRing;
+
+public:
+	enum action { actionOther, actionKill, actionYank };
+	action lastAction;
+
+	KillRing()
+		: size(0)
+		, index(0)
+		, lastAction(actionOther) {
+		theRing.reserve(capacity);
+	}
+
+	void kill(const char32_t* text, int textLen, bool forward) {
+		if (textLen == 0) {
+			return;
+		}
+		UnicodeString killedText(text, textLen);
+		if (lastAction == actionKill && size > 0) {
+			int slot = indexToSlot[0];
+			int currentLen = static_cast<int>(theRing[slot].length());
+			UnicodeString temp;
+			if ( forward ) {
+				temp.append( theRing[slot].get(), currentLen ).append( killedText.get(), textLen );
+			} else {
+				temp.append( killedText.get(), textLen ).append( theRing[slot].get(), currentLen );
+			}
+			theRing[slot] = temp;
+		} else {
+			if (size < capacity) {
+				if (size > 0) {
+					memmove(&indexToSlot[1], &indexToSlot[0], size);
+				}
+				indexToSlot[0] = size;
+				size++;
+				theRing.push_back(killedText);
+			} else {
+				int slot = indexToSlot[capacity - 1];
+				theRing[slot] = killedText;
+				memmove(&indexToSlot[1], &indexToSlot[0], capacity - 1);
+				indexToSlot[0] = slot;
+			}
+			index = 0;
+		}
+	}
+
+	UnicodeString* yank() { return (size > 0) ? &theRing[indexToSlot[index]] : 0; }
+
+	UnicodeString* yankPop() {
+		if (size == 0) {
+			return 0;
+		}
+		++index;
+		if (index == size) {
+			index = 0;
+		}
+		return &theRing[indexToSlot[index]];
+	}
+};
+
+}
+
+#endif
+
diff --git a/contrib/restricted/patched/replxx/src/prompt.cxx b/contrib/restricted/patched/replxx/src/prompt.cxx
new file mode 100644
index 0000000000..c866a80d39
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/prompt.cxx
@@ -0,0 +1,90 @@
+#ifdef _WIN32
+
+#include <conio.h>
+#include <windows.h>
+#include <io.h>
+#if _MSC_VER < 1900 && defined (_MSC_VER)
+#define snprintf _snprintf	// Microsoft headers use underscores in some names
+#endif
+#define strcasecmp _stricmp
+#define strdup _strdup
+#define write _write
+#define STDIN_FILENO 0
+
+#else /* _WIN32 */
+
+#include <unistd.h>
+
+#endif /* _WIN32 */
+
+#include "prompt.hxx"
+#include "util.hxx"
+
+namespace replxx {
+
+Prompt::Prompt( Terminal& terminal_ )
+	: _extraLines( 0 )
+	, _lastLinePosition( 0 )
+	, _cursorRowOffset( 0 )
+	, _screenColumns( 0 )
+	, _terminal( terminal_ ) {
+}
+
+void Prompt::write() {
+	_terminal.write32( _text.get(), _text.length() );
+}
+
+void Prompt::update_screen_columns( void ) {
+	_screenColumns = _terminal.get_screen_columns();
+}
+
+void Prompt::set_text( UnicodeString const& text_ ) {
+	_text = text_;
+	update_state();
+}
+
+void Prompt::update_state() {
+	_cursorRowOffset -= _extraLines;
+	_extraLines = 0;
+	_lastLinePosition = 0;
+	_screenColumns = 0;
+	update_screen_columns();
+	// strip control characters from the prompt -- we do allow newline
+	UnicodeString::const_iterator in( _text.begin() );
+
+	int x = 0;
+	int renderedSize( 0 );
+	_characterCount = virtual_render( _text.get(), _text.length(), x, _extraLines, _screenColumns, 0, _text.get(), &renderedSize );
+	_lastLinePosition = _characterCount - x;
+	_text.erase( renderedSize, _text.length() - renderedSize );
+
+	_cursorRowOffset += _extraLines;
+}
+
+int Prompt::indentation() const {
+	return _characterCount - _lastLinePosition;
+}
+
+// Used with DynamicPrompt (history search)
+//
+const UnicodeString forwardSearchBasePrompt("(i-search)`");
+const UnicodeString reverseSearchBasePrompt("(reverse-i-search)`");
+const UnicodeString endSearchBasePrompt("': ");
+
+DynamicPrompt::DynamicPrompt( Terminal& terminal_, int initialDirection )
+	: Prompt( terminal_ )
+	, _searchText()
+	, _direction( initialDirection ) {
+	updateSearchPrompt();
+}
+
+void DynamicPrompt::updateSearchPrompt(void) {
+	update_screen_columns();
+	const UnicodeString* basePrompt =
+			(_direction > 0) ? &forwardSearchBasePrompt : &reverseSearchBasePrompt;
+	_text.assign( *basePrompt ).append( _searchText ).append( endSearchBasePrompt );
+	update_state();
+}
+
+}
+
diff --git a/contrib/restricted/patched/replxx/src/prompt.hxx b/contrib/restricted/patched/replxx/src/prompt.hxx
new file mode 100644
index 0000000000..3f580110c7
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/prompt.hxx
@@ -0,0 +1,46 @@
+#ifndef REPLXX_PROMPT_HXX_INCLUDED
+#define REPLXX_PROMPT_HXX_INCLUDED 1
+
+#include <cstdlib>
+
+#include "unicodestring.hxx"
+#include "terminal.hxx"
+
+namespace replxx {
+
+class Prompt {              // a convenience struct for grouping prompt info
+public:
+	UnicodeString _text;      // our copy of the prompt text, edited
+	int _characterCount{0};   // visible characters in _text
+	int _extraLines{0};       // extra lines (beyond 1) occupied by prompt
+	int _lastLinePosition{0}; // index into _text where last line begins
+	int _cursorRowOffset{0};  // where the cursor is relative to the start of the prompt
+
+private:
+	int _screenColumns{0};    // width of screen in columns [cache]
+	Terminal& _terminal;
+public:
+	Prompt( Terminal& );
+	void set_text( UnicodeString const& textPtr );
+	void update_state();
+	void update_screen_columns( void );
+	int screen_columns() const {
+		return ( _screenColumns );
+	}
+	void write();
+	int indentation() const;
+};
+
+// changing prompt for "(reverse-i-search)`text':" etc.
+//
+struct DynamicPrompt : public Prompt {
+	UnicodeString _searchText; // text we are searching for
+	int _direction;            // current search _direction, 1=forward, -1=reverse
+
+	DynamicPrompt( Terminal&, int initialDirection );
+	void updateSearchPrompt(void);
+};
+
+}
+
+#endif
diff --git a/contrib/restricted/patched/replxx/src/replxx.cxx b/contrib/restricted/patched/replxx/src/replxx.cxx
new file mode 100644
index 0000000000..972bebedaa
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/replxx.cxx
@@ -0,0 +1,743 @@
+/*
+ * Copyright (c) 2017-2018, Marcin Konarski (amok at codestation.org)
+ * Copyright (c) 2010, Salvatore Sanfilippo <antirez at gmail dot com>
+ * Copyright (c) 2010, Pieter Noordhuis <pcnoordhuis at gmail dot com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *	 * Redistributions of source code must retain the above copyright notice,
+ *		 this list of conditions and the following disclaimer.
+ *	 * Redistributions in binary form must reproduce the above copyright
+ *		 notice, this list of conditions and the following disclaimer in the
+ *		 documentation and/or other materials provided with the distribution.
+ *	 * Neither the name of Redis nor the names of its contributors may be used
+ *		 to endorse or promote products derived from this software without
+ *		 specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * line editing lib needs to be 20,000 lines of C code.
+ *
+ * You can find the latest source code at:
+ *
+ *	 http://github.com/antirez/linenoise
+ *
+ * Does a number of crazy assumptions that happen to be true in 99.9999% of
+ * the 2010 UNIX computers around.
+ *
+ * References:
+ * - http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
+ * - http://www.3waylabs.com/nw/WWW/products/wizcon/vt220.html
+ *
+ * Todo list:
+ * - Switch to gets() if $TERM is something we can't support.
+ * - Filter bogus Ctrl+<char> combinations.
+ * - Win32 support
+ *
+ * Bloat:
+ * - Completion?
+ * - History search like Ctrl+r in readline?
+ *
+ * List of escape sequences used by this program, we do everything just
+ * with three sequences. In order to be so cheap we may have some
+ * flickering effect with some slow terminal, but the lesser sequences
+ * the more compatible.
+ *
+ * CHA (Cursor Horizontal Absolute)
+ *		Sequence: ESC [ n G
+ *		Effect: moves cursor to column n (1 based)
+ *
+ * EL (Erase Line)
+ *		Sequence: ESC [ n K
+ *		Effect: if n is 0 or missing, clear from cursor to end of line
+ *		Effect: if n is 1, clear from beginning of line to cursor
+ *		Effect: if n is 2, clear entire line
+ *
+ * CUF (Cursor Forward)
+ *		Sequence: ESC [ n C
+ *		Effect: moves cursor forward of n chars
+ *
+ * The following are used to clear the screen: ESC [ H ESC [ 2 J
+ * This is actually composed of two sequences:
+ *
+ * cursorhome
+ *		Sequence: ESC [ H
+ *		Effect: moves the cursor to upper left corner
+ *
+ * ED2 (Clear entire screen)
+ *		Sequence: ESC [ 2 J
+ *		Effect: clear the whole screen
+ *
+ */
+
+#include <algorithm>
+#include <cstdarg>
+
+#ifdef _WIN32
+
+#include <io.h>
+#define STDIN_FILENO 0
+
+#else /* _WIN32 */
+
+#include <signal.h>
+#include <unistd.h>
+#include <sys/stat.h>
+
+#endif /* _WIN32 */
+
+#include "replxx.h"
+#include "replxx.hxx"
+#include "replxx_impl.hxx"
+#include "history.hxx"
+
+static_assert(
+	static_cast<int>( replxx::Replxx::ACTION::SEND_EOF ) == static_cast<int>( REPLXX_ACTION_SEND_EOF ),
+	"C and C++ `ACTION` APIs are missaligned!"
+);
+
+static_assert(
+	static_cast<int>( replxx::Replxx::KEY::PASTE_FINISH ) == static_cast<int>( REPLXX_KEY_PASTE_FINISH ),
+	"C and C++ `KEY` APIs are missaligned!"
+);
+
+using namespace std;
+using namespace std::placeholders;
+using namespace replxx;
+
+namespace replxx {
+
+namespace {
+void delete_ReplxxImpl( Replxx::ReplxxImpl* impl_ ) {
+	delete impl_;
+}
+}
+
+Replxx::Replxx( void )
+	: _impl( new Replxx::ReplxxImpl( nullptr, nullptr, nullptr ), delete_ReplxxImpl ) {
+}
+
+void Replxx::set_completion_callback( completion_callback_t const& fn ) {
+	_impl->set_completion_callback( fn );
+}
+
+void Replxx::set_modify_callback( modify_callback_t const& fn ) {
+	_impl->set_modify_callback( fn );
+}
+
+void Replxx::set_highlighter_callback( highlighter_callback_t const& fn ) {
+	_impl->set_highlighter_callback( fn );
+}
+
+void Replxx::set_hint_callback( hint_callback_t const& fn ) {
+	_impl->set_hint_callback( fn );
+}
+
+char const* Replxx::input( std::string const& prompt ) {
+	return ( _impl->input( prompt ) );
+}
+
+void Replxx::history_add( std::string const& line ) {
+	_impl->history_add( line );
+}
+
+bool Replxx::history_sync( std::string const& filename ) {
+	return ( _impl->history_sync( filename ) );
+}
+
+bool Replxx::history_save( std::string const& filename ) {
+	return ( _impl->history_save( filename ) );
+}
+
+void Replxx::history_save( std::ostream& out ) {
+	_impl->history_save( out );
+}
+
+bool Replxx::history_load( std::string const& filename ) {
+	return ( _impl->history_load( filename ) );
+}
+
+void Replxx::history_load( std::istream& in ) {
+	_impl->history_load( in );
+}
+
+void Replxx::history_clear( void ) {
+	_impl->history_clear();
+}
+
+int Replxx::history_size( void ) const {
+	return ( _impl->history_size() );
+}
+
+Replxx::HistoryScan Replxx::history_scan( void ) const {
+	return ( _impl->history_scan() );
+}
+
+void Replxx::set_preload_buffer( std::string const& preloadText ) {
+	_impl->set_preload_buffer( preloadText );
+}
+
+void Replxx::set_word_break_characters( char const* wordBreakers ) {
+	_impl->set_word_break_characters( wordBreakers );
+}
+
+void Replxx::set_max_hint_rows( int count ) {
+	_impl->set_max_hint_rows( count );
+}
+
+void Replxx::set_hint_delay( int milliseconds ) {
+	_impl->set_hint_delay( milliseconds );
+}
+
+void Replxx::set_completion_count_cutoff( int count ) {
+	_impl->set_completion_count_cutoff( count );
+}
+
+void Replxx::set_double_tab_completion( bool val ) {
+	_impl->set_double_tab_completion( val );
+}
+
+void Replxx::set_complete_on_empty( bool val ) {
+	_impl->set_complete_on_empty( val );
+}
+
+void Replxx::set_beep_on_ambiguous_completion( bool val ) {
+	_impl->set_beep_on_ambiguous_completion( val );
+}
+
+void Replxx::set_immediate_completion( bool val ) {
+	_impl->set_immediate_completion( val );
+}
+
+void Replxx::set_unique_history( bool val ) {
+	_impl->set_unique_history( val );
+}
+
+void Replxx::set_no_color( bool val ) {
+	_impl->set_no_color( val );
+}
+
+void Replxx::set_indent_multiline( bool val ) {
+	_impl->set_indent_multiline( val );
+}
+
+void Replxx::set_max_history_size( int len ) {
+	_impl->set_max_history_size( len );
+}
+
+void Replxx::clear_screen( void ) {
+	_impl->clear_screen( 0 );
+}
+
+void Replxx::emulate_key_press( char32_t keyPress_ ) {
+	_impl->emulate_key_press( keyPress_ );
+}
+
+Replxx::ACTION_RESULT Replxx::invoke( ACTION action_, char32_t keyPress_ ) {
+	return ( _impl->invoke( action_, keyPress_ ) );
+}
+
+void Replxx::bind_key( char32_t keyPress_, key_press_handler_t handler_ ) {
+	_impl->bind_key( keyPress_, handler_ );
+}
+
+void Replxx::bind_key_internal( char32_t keyPress_, char const* actionName_ ) {
+	_impl->bind_key_internal( keyPress_, actionName_ );
+}
+
+Replxx::State Replxx::get_state( void ) const {
+	return ( _impl->get_state() );
+}
+
+void Replxx::set_state( Replxx::State const& state_ ) {
+	_impl->set_state( state_ );
+}
+
+void Replxx::set_ignore_case( bool val ) {
+	_impl->set_ignore_case( val );
+}
+
+int Replxx::install_window_change_handler( void ) {
+	return ( _impl->install_window_change_handler() );
+}
+
+void Replxx::enable_bracketed_paste( void ) {
+	_impl->enable_bracketed_paste();
+}
+
+void Replxx::disable_bracketed_paste( void ) {
+	_impl->disable_bracketed_paste();
+}
+
+void Replxx::print( char const* format_, ... ) {
+	::std::va_list ap;
+	va_start( ap, format_ );
+	int size = static_cast<int>( vsnprintf( nullptr, 0, format_, ap ) );
+	va_end( ap );
+	va_start( ap, format_ );
+	unique_ptr<char[]> buf( new char[size + 1] );
+	vsnprintf( buf.get(), static_cast<size_t>( size + 1 ), format_, ap );
+	va_end( ap );
+	return ( _impl->print( buf.get(), size ) );
+}
+
+void Replxx::write( char const* str, int length ) {
+	return ( _impl->print( str, length ) );
+}
+
+void Replxx::set_prompt( std::string prompt ) {
+	return ( _impl->set_prompt( std::move( prompt ) ) );
+}
+
+namespace color {
+
+Replxx::Color operator | ( Replxx::Color color1_, Replxx::Color color2_ ) {
+	return static_cast<Replxx::Color>( static_cast<int unsigned>( color1_ ) | static_cast<int unsigned>( color2_ ) );
+}
+
+Replxx::Color bg( Replxx::Color color_ ) {
+	return static_cast<Replxx::Color>( ( ( static_cast<int unsigned>( color_ ) & 0xFFu ) << 8 ) | color::BACKGROUND_COLOR_SET );
+}
+
+Replxx::Color bold( Replxx::Color color_ ) {
+	return static_cast<Replxx::Color>( static_cast<int unsigned>( color_ ) | color::BOLD );
+}
+
+Replxx::Color underline( Replxx::Color color_ ) {
+	return static_cast<Replxx::Color>( static_cast<int unsigned>( color_ ) | color::UNDERLINE );
+}
+
+Replxx::Color grayscale( int level_ ) {
+	assert( ( level_ >= 0 ) && ( level_ < 24 ) );
+	return static_cast<Replxx::Color>( abs( level_ ) % 24 + static_cast<int unsigned>( color::GRAYSCALE ) );
+}
+
+Replxx::Color rgb666( int red_, int green_, int blue_ ) {
+	assert( ( red_ >= 0 ) && ( red_ < 6 ) && ( green_ >= 0 ) && ( green_ < 6 ) && ( blue_ >= 0 ) && ( blue_ < 6 ) );
+	return static_cast<Replxx::Color>(
+		( abs( red_ ) % 6 ) * 36
+		+ ( abs( green_ ) % 6 ) * 6
+		+ ( abs( blue_ ) % 6 )
+		+ static_cast<int unsigned>( color::RGB666 )
+	);
+}
+
+}
+
+}
+
+::Replxx* replxx_init() {
+	typedef ::Replxx* replxx_data_t;
+	return ( reinterpret_cast<replxx_data_t>( new replxx::Replxx::ReplxxImpl( nullptr, nullptr, nullptr ) ) );
+}
+
+void replxx_end( ::Replxx* replxx_ ) {
+	delete reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ );
+}
+
+void replxx_clear_screen( ::Replxx* replxx_ ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->clear_screen( 0 );
+}
+
+void replxx_emulate_key_press( ::Replxx* replxx_, int unsigned keyPress_ ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->emulate_key_press( keyPress_ );
+}
+
+ReplxxActionResult replxx_invoke( ::Replxx* replxx_, ReplxxAction action_, int unsigned keyPress_ ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	return ( static_cast<ReplxxActionResult>( replxx->invoke( static_cast<replxx::Replxx::ACTION>( action_ ), keyPress_ ) ) );
+}
+
+replxx::Replxx::ACTION_RESULT key_press_handler_forwarder( key_press_handler_t handler_, char32_t code_, void* userData_ ) {
+	return ( static_cast<replxx::Replxx::ACTION_RESULT>( handler_( code_, userData_ ) ) );
+}
+
+void replxx_bind_key( ::Replxx* replxx_, int code_, key_press_handler_t handler_, void* userData_ ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->bind_key( code_, std::bind( key_press_handler_forwarder, handler_, _1, userData_ ) );
+}
+
+int replxx_bind_key_internal( ::Replxx* replxx_, int code_, char const* actionName_ ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	try {
+		replxx->bind_key_internal( code_, actionName_ );
+	} catch ( ... ) {
+		return ( -1 );
+	}
+	return ( 0 );
+}
+
+void replxx_get_state( ::Replxx* replxx_, ReplxxState* state ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx::Replxx::State s( replxx->get_state() );
+	state->text = s.text();
+	state->cursorPosition = s.cursor_position();
+}
+
+void replxx_set_state( ::Replxx* replxx_, ReplxxState* state ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_state( replxx::Replxx::State( state->text, state->cursorPosition ) );
+}
+
+void replxx_set_ignore_case( ::Replxx* replxx_, int val ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_ignore_case( val );
+}
+
+/**
+ * replxx_set_preload_buffer provides text to be inserted into the command buffer
+ *
+ * the provided text will be processed to be usable and will be used to preload
+ * the input buffer on the next call to replxx_input()
+ *
+ * @param preloadText text to begin with on the next call to replxx_input()
+ */
+void replxx_set_preload_buffer(::Replxx* replxx_, const char* preloadText) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_preload_buffer( preloadText ? preloadText : "" );
+}
+
+/**
+ * replxx_input is a readline replacement.
+ *
+ * call it with a prompt to display and it will return a line of input from the
+ * user
+ *
+ * @param prompt text of prompt to display to the user
+ * @return the returned string is managed by replxx library
+ * and it must NOT be freed in the client.
+ */
+char const* replxx_input( ::Replxx* replxx_, const char* prompt ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	return ( replxx->input( prompt ) );
+}
+
+int replxx_print( ::Replxx* replxx_, char const* format_, ... ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	::std::va_list ap;
+	va_start( ap, format_ );
+	int size = static_cast<int>( vsnprintf( nullptr, 0, format_, ap ) );
+	va_end( ap );
+	va_start( ap, format_ );
+	unique_ptr<char[]> buf( new char[size + 1] );
+	vsnprintf( buf.get(), static_cast<size_t>( size + 1 ), format_, ap );
+	va_end( ap );
+	try {
+		replxx->print( buf.get(), size );
+	} catch ( ... ) {
+		return ( -1 );
+	}
+	return ( size );
+}
+
+int replxx_write( ::Replxx* replxx_, char const* str, int length ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	try {
+		replxx->print( str, length );
+	} catch ( ... ) {
+		return ( -1 );
+	}
+	return static_cast<int>( length );
+}
+
+void replxx_set_prompt( ::Replxx* replxx_, const char* prompt ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_prompt( prompt );
+}
+
+struct replxx_completions {
+	replxx::Replxx::completions_t data;
+};
+
+struct replxx_hints {
+	replxx::Replxx::hints_t data;
+};
+
+void modify_fwd( replxx_modify_callback_t fn, std::string& line_, int& cursorPosition_, void* userData_ ) {
+#ifdef _WIN32
+#define strdup _strdup
+#endif
+	char* s( strdup( line_.c_str() ) );
+#undef strdup
+	fn( &s, &cursorPosition_, userData_ );
+	line_ = s;
+	free( s );
+	return;
+}
+
+void replxx_set_modify_callback(::Replxx* replxx_, replxx_modify_callback_t* fn, void* userData) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_modify_callback( std::bind( &modify_fwd, fn, _1, _2, userData ) );
+}
+
+replxx::Replxx::completions_t completions_fwd( replxx_completion_callback_t fn, std::string const& input_, int& contextLen_, void* userData ) {
+	replxx_completions completions;
+	fn( input_.c_str(), &completions, &contextLen_, userData );
+	return ( completions.data );
+}
+
+/* Register a callback function to be called for tab-completion. */
+void replxx_set_completion_callback(::Replxx* replxx_, replxx_completion_callback_t* fn, void* userData) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_completion_callback( std::bind( &completions_fwd, fn, _1, _2, userData ) );
+}
+
+void highlighter_fwd( replxx_highlighter_callback_t fn, std::string const& input, replxx::Replxx::colors_t& colors, void* userData ) {
+	std::vector<ReplxxColor> colorsTmp( colors.size() );
+	std::transform(
+		colors.begin(),
+		colors.end(),
+		colorsTmp.begin(),
+		[]( replxx::Replxx::Color c ) {
+			return ( static_cast<ReplxxColor>( c ) );
+		}
+	);
+	fn( input.c_str(), colorsTmp.data(), static_cast<int>( colors.size() ), userData );
+	std::transform(
+		colorsTmp.begin(),
+		colorsTmp.end(),
+		colors.begin(),
+		[]( ReplxxColor c ) {
+			return ( static_cast<replxx::Replxx::Color>( c ) );
+		}
+	);
+}
+
+void replxx_set_highlighter_callback( ::Replxx* replxx_, replxx_highlighter_callback_t* fn, void* userData ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_highlighter_callback( std::bind( &highlighter_fwd, fn, _1, _2, userData ) );
+}
+
+replxx::Replxx::hints_t hints_fwd( replxx_hint_callback_t fn, std::string const& input_, int& contextLen_, replxx::Replxx::Color& color_, void* userData ) {
+	replxx_hints hints;
+	ReplxxColor c( static_cast<ReplxxColor>( color_ ) );
+	fn( input_.c_str(), &hints, &contextLen_, &c, userData );
+	return ( hints.data );
+}
+
+void replxx_set_hint_callback( ::Replxx* replxx_, replxx_hint_callback_t* fn, void* userData ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_hint_callback( std::bind( &hints_fwd, fn, _1, _2, _3, userData ) );
+}
+
+void replxx_add_hint(replxx_hints* lh, const char* str) {
+	lh->data.emplace_back(str);
+}
+
+void replxx_add_completion( replxx_completions* lc, const char* str ) {
+	lc->data.emplace_back( str );
+}
+
+void replxx_add_color_completion( replxx_completions* lc, const char* str, ReplxxColor color ) {
+	lc->data.emplace_back( str, static_cast<replxx::Replxx::Color>( color ) );
+}
+
+void replxx_history_add( ::Replxx* replxx_, const char* line ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->history_add( line );
+}
+
+void replxx_set_max_history_size( ::Replxx* replxx_, int len ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_max_history_size( len );
+}
+
+void replxx_set_max_hint_rows( ::Replxx* replxx_, int count ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_max_hint_rows( count );
+}
+
+void replxx_set_hint_delay( ::Replxx* replxx_, int milliseconds ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_hint_delay( milliseconds );
+}
+
+void replxx_set_completion_count_cutoff( ::Replxx* replxx_, int count ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_completion_count_cutoff( count );
+}
+
+void replxx_set_word_break_characters( ::Replxx* replxx_, char const* breakChars_ ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_word_break_characters( breakChars_ );
+}
+
+void replxx_set_double_tab_completion( ::Replxx* replxx_, int val ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_double_tab_completion( val ? true : false );
+}
+
+void replxx_set_complete_on_empty( ::Replxx* replxx_, int val ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_complete_on_empty( val ? true : false );
+}
+
+void replxx_set_no_color( ::Replxx* replxx_, int val ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_no_color( val ? true : false );
+}
+
+void replxx_set_indent_multiline( ::Replxx* replxx_, int val ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_indent_multiline( val ? true : false );
+}
+
+void replxx_set_beep_on_ambiguous_completion( ::Replxx* replxx_, int val ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_beep_on_ambiguous_completion( val ? true : false );
+}
+
+void replxx_set_immediate_completion( ::Replxx* replxx_, int val ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_immediate_completion( val ? true : false );
+}
+
+void replxx_set_unique_history( ::Replxx* replxx_, int val ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->set_unique_history( val ? true : false );
+}
+
+void replxx_enable_bracketed_paste( ::Replxx* replxx_ ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->enable_bracketed_paste();
+}
+
+void replxx_disable_bracketed_paste( ::Replxx* replxx_ ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->disable_bracketed_paste();
+}
+
+ReplxxHistoryScan* replxx_history_scan_start( ::Replxx* replxx_ ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	return ( reinterpret_cast<ReplxxHistoryScan*>( replxx->history_scan().release() ) );
+}
+
+void replxx_history_scan_stop( ::Replxx*, ReplxxHistoryScan* historyScan_ ) {
+	delete reinterpret_cast<replxx::Replxx::HistoryScanImpl*>( historyScan_ );
+}
+
+int replxx_history_scan_next( ::Replxx*, ReplxxHistoryScan* historyScan_, ReplxxHistoryEntry* historyEntry_ ) {
+	replxx::Replxx::HistoryScanImpl* historyScan( reinterpret_cast<replxx::Replxx::HistoryScanImpl*>( historyScan_ ) );
+	bool hasNext( historyScan->next() );
+	if ( hasNext ) {
+		replxx::Replxx::HistoryEntry const& historyEntry( historyScan->get() );
+		historyEntry_->timestamp = historyEntry.timestamp().c_str();
+		historyEntry_->text = historyEntry.text().c_str();
+	}
+	return ( hasNext ? 0 : -1 );
+}
+
+/* Save the history in the specified file. On success 0 is returned
+ * otherwise -1 is returned. */
+int replxx_history_sync( ::Replxx* replxx_, const char* filename ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	return ( replxx->history_sync( filename ) ? 0 : -1 );
+}
+
+/* Save the history in the specified file. On success 0 is returned
+ * otherwise -1 is returned. */
+int replxx_history_save( ::Replxx* replxx_, const char* filename ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	return ( replxx->history_save( filename ) ? 0 : -1 );
+}
+
+/* Load the history from the specified file. If the file does not exist
+ * zero is returned and no operation is performed.
+ *
+ * If the file exists and the operation succeeded 0 is returned, otherwise
+ * on error -1 is returned. */
+int replxx_history_load( ::Replxx* replxx_, const char* filename ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	return ( replxx->history_load( filename ) ? 0 : -1 );
+}
+
+void replxx_history_clear( ::Replxx* replxx_ ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	replxx->history_clear();
+}
+
+int replxx_history_size( ::Replxx* replxx_ ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	return ( replxx->history_size() );
+}
+
+/* This special mode is used by replxx in order to print scan codes
+ * on screen for debugging / development purposes. It is implemented
+ * by the replxx-c-api-example program using the --keycodes option. */
+#ifdef __REPLXX_DEBUG__
+void replxx_debug_dump_print_codes(void) {
+	char quit[4];
+
+	printf(
+			"replxx key codes debugging mode.\n"
+			"Press keys to see scan codes. Type 'quit' at any time to exit.\n");
+	if (enableRawMode() == -1) return;
+	memset(quit, ' ', 4);
+	while (1) {
+		char c;
+		int nread;
+
+#if _WIN32
+		nread = _read(STDIN_FILENO, &c, 1);
+#else
+		nread = read(STDIN_FILENO, &c, 1);
+#endif
+		if (nread <= 0) continue;
+		memmove(quit, quit + 1, sizeof(quit) - 1); /* shift string to left. */
+		quit[sizeof(quit) - 1] = c; /* Insert current char on the right. */
+		if (memcmp(quit, "quit", sizeof(quit)) == 0) break;
+
+		printf("'%c' %02x (%d) (type quit to exit)\n", isprint(c) ? c : '?', (int)c,
+					 (int)c);
+		printf("\r"); /* Go left edge manually, we are in raw mode. */
+		fflush(stdout);
+	}
+	disableRawMode();
+}
+#endif // __REPLXX_DEBUG__
+
+int replxx_install_window_change_handler( ::Replxx* replxx_ ) {
+	replxx::Replxx::ReplxxImpl* replxx( reinterpret_cast<replxx::Replxx::ReplxxImpl*>( replxx_ ) );
+	return ( replxx->install_window_change_handler() );
+}
+
+using namespace replxx::color;
+ReplxxColor replxx_color_combine( ReplxxColor color1_, ReplxxColor color2_ ) {
+	return static_cast<ReplxxColor>( static_cast<replxx::Replxx::Color>( color1_ ) | static_cast<replxx::Replxx::Color>( color2_ ) );
+}
+
+ReplxxColor replxx_color_bg( ReplxxColor color_ ) {
+	return static_cast<ReplxxColor>( color::bg( static_cast<replxx::Replxx::Color>( color_ ) ) );
+}
+
+ReplxxColor replxx_color_bold( ReplxxColor color_ ) {
+	return static_cast<ReplxxColor>( color::bold( static_cast<replxx::Replxx::Color>( color_ ) ) );
+}
+
+ReplxxColor replxx_color_underline( ReplxxColor color_ ) {
+	return static_cast<ReplxxColor>( color::underline( static_cast<replxx::Replxx::Color>( color_ ) ) );
+}
+
+ReplxxColor replxx_color_grayscale( int level_ ) {
+	return static_cast<ReplxxColor>( color::grayscale( level_ ) );
+}
+
+ReplxxColor replxx_color_rgb666( int r_, int g_, int b_ ) {
+	return static_cast<ReplxxColor>( color::rgb666( r_, g_, b_ ) );
+}
+
diff --git a/contrib/restricted/patched/replxx/src/replxx_impl.cxx b/contrib/restricted/patched/replxx/src/replxx_impl.cxx
new file mode 100644
index 0000000000..7379c99670
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/replxx_impl.cxx
@@ -0,0 +1,2591 @@
+#include <algorithm>
+#include <memory>
+#include <cerrno>
+#include <iostream>
+#include <chrono>
+#include <cassert>
+#include <map>
+
+#ifdef _WIN32
+
+#include <windows.h>
+#include <io.h>
+#if _MSC_VER < 1900
+#define snprintf _snprintf // Microsoft headers use underscores in some names
+#endif
+#define strcasecmp _stricmp
+#define write _write
+#define STDIN_FILENO 0
+
+#else /* _WIN32 */
+
+#include <unistd.h>
+#include <signal.h>
+
+#endif /* _WIN32 */
+
+#ifdef _WIN32
+#include "windows.hxx"
+#endif
+
+#include "replxx_impl.hxx"
+#include "utf8string.hxx"
+#include "prompt.hxx"
+#include "util.hxx"
+#include "terminal.hxx"
+#include "history.hxx"
+#include "replxx.hxx"
+
+using namespace std;
+using namespace replxx::color;
+
+namespace replxx {
+
+namespace {
+
+namespace action_names {
+
+char const INSERT_CHARACTER[]                = "insert_character";
+char const NEW_LINE[]                        = "new_line";
+char const MOVE_CURSOR_TO_BEGINING_OF_LINE[] = "move_cursor_to_begining_of_line";
+char const MOVE_CURSOR_TO_END_OF_LINE[]      = "move_cursor_to_end_of_line";
+char const MOVE_CURSOR_LEFT[]                = "move_cursor_left";
+char const MOVE_CURSOR_RIGHT[]               = "move_cursor_right";
+char const MOVE_CURSOR_ONE_WORD_LEFT[]       = "move_cursor_one_word_left";
+char const MOVE_CURSOR_ONE_WORD_RIGHT[]      = "move_cursor_one_word_right";
+char const MOVE_CURSOR_ONE_SUBWORD_LEFT[]    = "move_cursor_one_subword_left";
+char const MOVE_CURSOR_ONE_SUBWORD_RIGHT[]   = "move_cursor_one_subword_right";
+char const KILL_TO_WHITESPACE_ON_LEFT[]      = "kill_to_whitespace_on_left";
+char const KILL_TO_END_OF_WORD[]             = "kill_to_end_of_word";
+char const KILL_TO_END_OF_SUBWORD[]          = "kill_to_end_of_subword";
+char const KILL_TO_BEGINING_OF_WORD[]        = "kill_to_begining_of_word";
+char const KILL_TO_BEGINING_OF_SUBWORD[]     = "kill_to_begining_of_subword";
+char const KILL_TO_BEGINING_OF_LINE[]        = "kill_to_begining_of_line";
+char const KILL_TO_END_OF_LINE[]             = "kill_to_end_of_line";
+char const YANK[]                            = "yank";
+char const YANK_CYCLE[]                      = "yank_cycle";
+char const YANK_LAST_ARG[]                   = "yank_last_arg";
+char const CAPITALIZE_WORD[]                 = "capitalize_word";
+char const LOWERCASE_WORD[]                  = "lowercase_word";
+char const UPPERCASE_WORD[]                  = "uppercase_word";
+char const CAPITALIZE_SUBWORD[]              = "capitalize_subword";
+char const LOWERCASE_SUBWORD[]               = "lowercase_subword";
+char const UPPERCASE_SUBWORD[]               = "uppercase_subword";
+char const TRANSPOSE_CHARACTERS[]            = "transpose_characters";
+char const ABORT_LINE[]                      = "abort_line";
+char const SEND_EOF[]                        = "send_eof";
+char const TOGGLE_OVERWRITE_MODE[]           = "toggle_overwrite_mode";
+char const DELETE_CHARACTER_UNDER_CURSOR[]   = "delete_character_under_cursor";
+char const DELETE_CHARACTER_LEFT_OF_CURSOR[] = "delete_character_left_of_cursor";
+char const COMMIT_LINE[]                     = "commit_line";
+char const CLEAR_SCREEN[]                    = "clear_screen";
+char const COMPLETE_NEXT[]                   = "complete_next";
+char const COMPLETE_PREVIOUS[]               = "complete_previous";
+char const HISTORY_NEXT[]                    = "history_next";
+char const HISTORY_PREVIOUS[]                = "history_previous";
+char const LINE_NEXT[]                       = "line_next";
+char const LINE_PREVIOUS[]                   = "line_previous";
+char const HISTORY_LAST[]                    = "history_last";
+char const HISTORY_FIRST[]                   = "history_first";
+char const HISTORY_RESTORE[]                 = "history_restore";
+char const HISTORY_RESTORE_CURRENT[]         = "history_restore_current";
+char const HINT_PREVIOUS[]                   = "hint_previous";
+char const HINT_NEXT[]                       = "hint_next";
+char const VERBATIM_INSERT[]                 = "verbatim_insert";
+char const SUSPEND[]                         = "suspend";
+char const COMPLETE_LINE[]                   = "complete_line";
+char const HISTORY_INCREMENTAL_SEARCH[]      = "history_incremental_search";
+char const HISTORY_COMMON_PREFIX_SEARCH[]    = "history_common_prefix_search";
+}
+
+static int const REPLXX_MAX_HINT_ROWS( 4 );
+/*
+ * All whitespaces and all non-alphanumerical characters from ASCII range
+ * with an exception of an underscore ('_').
+ */
+char const defaultWordBreakChars[] = " \t\v\f\a\b\r\n`~!@#$%^&*()-=+[{]}\\|;:'\",<.>/?";
+/*
+ * All whitespaces and all non-alphanumerical characters from ASCII range
+ */
+char const defaultSubwordBreakChars[] = " \t\v\f\a\b\r\n`~!@#$%^&*()-=+[{]}\\|;:'\",<.>/?_";
+static const char* unsupported_term[] = {"dumb", "cons25", "emacs", NULL};
+
+static bool isUnsupportedTerm(void) {
+	char* term = getenv("TERM");
+	if (term == NULL) {
+		return false;
+	}
+	for (int j = 0; unsupported_term[j]; ++j) {
+		if (!strcasecmp(term, unsupported_term[j])) {
+			return true;
+		}
+	}
+	return false;
+}
+
+int long long RAPID_REFRESH_MS = 1;
+int long long RAPID_REFRESH_US = RAPID_REFRESH_MS * 1000;
+
+inline int long long now_us( void ) {
+	return ( std::chrono::duration_cast<std::chrono::microseconds>( std::chrono::high_resolution_clock::now().time_since_epoch() ).count() );
+}
+
+class IOModeGuard {
+	Terminal& _terminal;
+public:
+	IOModeGuard( Terminal& terminal_ )
+		: _terminal( terminal_ ) {
+	}
+	~IOModeGuard( void ) {
+		try {
+			_terminal.reset_raw_mode();
+		} catch ( ... ) {
+		}
+	}
+};
+
+}
+
+Replxx::ReplxxImpl::ReplxxImpl( FILE*, FILE*, FILE* )
+	: _utf8Buffer()
+	, _data()
+	, _pos( 0 )
+	, _display()
+	, _displayInputLength( 0 )
+	, _hint()
+	, _prefix( 0 )
+	, _hintSelection( -1 )
+	, _history()
+	, _killRing()
+	, _lastRefreshTime( now_us() )
+	, _refreshSkipped( false )
+	, _lastYankSize( 0 )
+	, _maxHintRows( REPLXX_MAX_HINT_ROWS )
+	, _hintDelay( 0 )
+	, _wordBreakChars( defaultWordBreakChars )
+	, _subwordBreakChars( defaultSubwordBreakChars )
+	, _completionCountCutoff( 100 )
+	, _overwrite( false )
+	, _doubleTabCompletion( false )
+	, _completeOnEmpty( true )
+	, _beepOnAmbiguousCompletion( false )
+	, _immediateCompletion( true )
+	, _bracketedPaste( false )
+	, _noColor( false )
+	, _indentMultiline( true )
+	, _namedActions()
+	, _keyPressHandlers()
+	, _terminal()
+	, _currentThread()
+	, _prompt( _terminal )
+	, _completionCallback( nullptr )
+	, _highlighterCallback( nullptr )
+	, _hintCallback( nullptr )
+	, _keyPresses()
+	, _messages()
+	, _asyncPrompt()
+	, _updatePrompt( false )
+	, _completions()
+	, _completionContextLength( 0 )
+	, _completionSelection( -1 )
+	, _preloadedBuffer()
+	, _errorMessage()
+	, _previousSearchText()
+	, _modifiedState( false )
+	, _hintColor( Replxx::Color::GRAY )
+	, _hintsCache()
+	, _hintContextLenght( -1 )
+	, _hintSeed()
+	, _hasNewlines( false )
+	, _oldPos( 0 )
+	, _moveCursor( false )
+	, _ignoreCase( false )
+	, _mutex() {
+	using namespace std::placeholders;
+	_namedActions[action_names::INSERT_CHARACTER]                = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::INSERT_CHARACTER,                _1 );
+	_namedActions[action_names::NEW_LINE]                        = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::NEW_LINE,                        _1 );
+	_namedActions[action_names::MOVE_CURSOR_TO_BEGINING_OF_LINE] = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::MOVE_CURSOR_TO_BEGINING_OF_LINE, _1 );
+	_namedActions[action_names::MOVE_CURSOR_TO_END_OF_LINE]      = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::MOVE_CURSOR_TO_END_OF_LINE,      _1 );
+	_namedActions[action_names::MOVE_CURSOR_LEFT]                = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::MOVE_CURSOR_LEFT,                _1 );
+	_namedActions[action_names::MOVE_CURSOR_RIGHT]               = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::MOVE_CURSOR_RIGHT,               _1 );
+	_namedActions[action_names::MOVE_CURSOR_ONE_WORD_LEFT]       = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::MOVE_CURSOR_ONE_WORD_LEFT,       _1 );
+	_namedActions[action_names::MOVE_CURSOR_ONE_WORD_RIGHT]      = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::MOVE_CURSOR_ONE_WORD_RIGHT,      _1 );
+	_namedActions[action_names::MOVE_CURSOR_ONE_SUBWORD_LEFT]    = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::MOVE_CURSOR_ONE_SUBWORD_LEFT,    _1 );
+	_namedActions[action_names::MOVE_CURSOR_ONE_SUBWORD_RIGHT]   = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::MOVE_CURSOR_ONE_SUBWORD_RIGHT,   _1 );
+	_namedActions[action_names::KILL_TO_WHITESPACE_ON_LEFT]      = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::KILL_TO_WHITESPACE_ON_LEFT,      _1 );
+	_namedActions[action_names::KILL_TO_END_OF_WORD]             = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::KILL_TO_END_OF_WORD,             _1 );
+	_namedActions[action_names::KILL_TO_BEGINING_OF_WORD]        = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::KILL_TO_BEGINING_OF_WORD,        _1 );
+	_namedActions[action_names::KILL_TO_END_OF_SUBWORD]          = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::KILL_TO_END_OF_SUBWORD,          _1 );
+	_namedActions[action_names::KILL_TO_BEGINING_OF_SUBWORD]     = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::KILL_TO_BEGINING_OF_SUBWORD,     _1 );
+	_namedActions[action_names::KILL_TO_BEGINING_OF_LINE]        = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::KILL_TO_BEGINING_OF_LINE,        _1 );
+	_namedActions[action_names::KILL_TO_END_OF_LINE]             = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::KILL_TO_END_OF_LINE,             _1 );
+	_namedActions[action_names::YANK]                            = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::YANK,                            _1 );
+	_namedActions[action_names::YANK_CYCLE]                      = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::YANK_CYCLE,                      _1 );
+	_namedActions[action_names::YANK_LAST_ARG]                   = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::YANK_LAST_ARG,                   _1 );
+	_namedActions[action_names::CAPITALIZE_WORD]                 = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::CAPITALIZE_WORD,                 _1 );
+	_namedActions[action_names::LOWERCASE_WORD]                  = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::LOWERCASE_WORD,                  _1 );
+	_namedActions[action_names::UPPERCASE_WORD]                  = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::UPPERCASE_WORD,                  _1 );
+	_namedActions[action_names::CAPITALIZE_SUBWORD]              = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::CAPITALIZE_SUBWORD,              _1 );
+	_namedActions[action_names::LOWERCASE_SUBWORD]               = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::LOWERCASE_SUBWORD,               _1 );
+	_namedActions[action_names::UPPERCASE_SUBWORD]               = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::UPPERCASE_SUBWORD,               _1 );
+	_namedActions[action_names::TRANSPOSE_CHARACTERS]            = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::TRANSPOSE_CHARACTERS,            _1 );
+	_namedActions[action_names::ABORT_LINE]                      = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::ABORT_LINE,                      _1 );
+	_namedActions[action_names::SEND_EOF]                        = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::SEND_EOF,                        _1 );
+	_namedActions[action_names::TOGGLE_OVERWRITE_MODE]           = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::TOGGLE_OVERWRITE_MODE,           _1 );
+	_namedActions[action_names::DELETE_CHARACTER_UNDER_CURSOR]   = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::DELETE_CHARACTER_UNDER_CURSOR,   _1 );
+	_namedActions[action_names::DELETE_CHARACTER_LEFT_OF_CURSOR] = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::DELETE_CHARACTER_LEFT_OF_CURSOR, _1 );
+	_namedActions[action_names::COMMIT_LINE]                     = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::COMMIT_LINE,                     _1 );
+	_namedActions[action_names::CLEAR_SCREEN]                    = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::CLEAR_SCREEN,                    _1 );
+	_namedActions[action_names::COMPLETE_NEXT]                   = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::COMPLETE_NEXT,                   _1 );
+	_namedActions[action_names::COMPLETE_PREVIOUS]               = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::COMPLETE_PREVIOUS,               _1 );
+	_namedActions[action_names::LINE_NEXT]                       = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::LINE_NEXT,                       _1 );
+	_namedActions[action_names::LINE_PREVIOUS]                   = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::LINE_PREVIOUS,                   _1 );
+	_namedActions[action_names::HISTORY_NEXT]                    = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::HISTORY_NEXT,               _1 );
+	_namedActions[action_names::HISTORY_PREVIOUS]                = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::HISTORY_PREVIOUS,           _1 );
+	_namedActions[action_names::HISTORY_LAST]                    = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::HISTORY_LAST,                    _1 );
+	_namedActions[action_names::HISTORY_FIRST]                   = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::HISTORY_FIRST,                   _1 );
+	_namedActions[action_names::HISTORY_RESTORE]                 = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::HISTORY_RESTORE,                 _1 );
+	_namedActions[action_names::HISTORY_RESTORE_CURRENT]         = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::HISTORY_RESTORE_CURRENT,         _1 );
+	_namedActions[action_names::HINT_PREVIOUS]                   = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::HINT_PREVIOUS,                   _1 );
+	_namedActions[action_names::HINT_NEXT]                       = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::HINT_NEXT,                       _1 );
+#ifndef _WIN32
+	_namedActions[action_names::VERBATIM_INSERT]                 = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::VERBATIM_INSERT,                 _1 );
+	_namedActions[action_names::SUSPEND]                         = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::SUSPEND,                         _1 );
+#else
+	_namedActions[action_names::VERBATIM_INSERT] = _namedActions[action_names::SUSPEND] = Replxx::key_press_handler_t();
+#endif
+	_namedActions[action_names::COMPLETE_LINE]                   = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::COMPLETE_LINE,                   _1 );
+	_namedActions[action_names::HISTORY_INCREMENTAL_SEARCH]      = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::HISTORY_INCREMENTAL_SEARCH,      _1 );
+	_namedActions[action_names::HISTORY_COMMON_PREFIX_SEARCH]    = std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::HISTORY_COMMON_PREFIX_SEARCH,    _1 );
+
+	bind_key( Replxx::KEY::control( 'A' ),                 _namedActions.at( action_names::MOVE_CURSOR_TO_BEGINING_OF_LINE ) );
+	bind_key( Replxx::KEY::HOME + 0,                       _namedActions.at( action_names::MOVE_CURSOR_TO_BEGINING_OF_LINE ) );
+	bind_key( Replxx::KEY::control( 'E' ),                 _namedActions.at( action_names::MOVE_CURSOR_TO_END_OF_LINE ) );
+	bind_key( Replxx::KEY::END + 0,                        _namedActions.at( action_names::MOVE_CURSOR_TO_END_OF_LINE ) );
+	bind_key( Replxx::KEY::control( 'B' ),                 _namedActions.at( action_names::MOVE_CURSOR_LEFT ) );
+	bind_key( Replxx::KEY::LEFT + 0,                       _namedActions.at( action_names::MOVE_CURSOR_LEFT ) );
+	bind_key( Replxx::KEY::control( 'F' ),                 _namedActions.at( action_names::MOVE_CURSOR_RIGHT ) );
+	bind_key( Replxx::KEY::RIGHT + 0,                      _namedActions.at( action_names::MOVE_CURSOR_RIGHT ) );
+	bind_key( Replxx::KEY::meta( 'b' ),                    _namedActions.at( action_names::MOVE_CURSOR_ONE_WORD_LEFT ) );
+	bind_key( Replxx::KEY::meta( 'B' ),                    _namedActions.at( action_names::MOVE_CURSOR_ONE_SUBWORD_LEFT ) );
+	bind_key( Replxx::KEY::control( Replxx::KEY::LEFT ),   _namedActions.at( action_names::MOVE_CURSOR_ONE_WORD_LEFT ) );
+	bind_key( Replxx::KEY::meta( Replxx::KEY::LEFT ),      _namedActions.at( action_names::MOVE_CURSOR_ONE_WORD_LEFT ) ); // Emacs allows Meta, readline don't
+	bind_key( Replxx::KEY::meta( 'f' ),                    _namedActions.at( action_names::MOVE_CURSOR_ONE_WORD_RIGHT ) );
+	bind_key( Replxx::KEY::meta( 'F' ),                    _namedActions.at( action_names::MOVE_CURSOR_ONE_SUBWORD_RIGHT ) );
+	bind_key( Replxx::KEY::control( Replxx::KEY::RIGHT ),  _namedActions.at( action_names::MOVE_CURSOR_ONE_WORD_RIGHT ) );
+	bind_key( Replxx::KEY::meta( Replxx::KEY::RIGHT ),     _namedActions.at( action_names::MOVE_CURSOR_ONE_WORD_RIGHT ) ); // Emacs allows Meta, readline don't
+	bind_key( Replxx::KEY::meta( Replxx::KEY::BACKSPACE ), _namedActions.at( action_names::KILL_TO_WHITESPACE_ON_LEFT ) );
+	bind_key( Replxx::KEY::meta( 'd' ),                    _namedActions.at( action_names::KILL_TO_END_OF_WORD ) );
+	bind_key( Replxx::KEY::meta( 'D' ),                    _namedActions.at( action_names::KILL_TO_END_OF_SUBWORD ) );
+	bind_key( Replxx::KEY::control( 'W' ),                 _namedActions.at( action_names::KILL_TO_BEGINING_OF_WORD ) );
+	bind_key( Replxx::KEY::meta( 'W' ),                    _namedActions.at( action_names::KILL_TO_BEGINING_OF_SUBWORD ) );
+	bind_key( Replxx::KEY::control( 'U' ),                 _namedActions.at( action_names::KILL_TO_BEGINING_OF_LINE ) );
+	bind_key( Replxx::KEY::control( 'K' ),                 _namedActions.at( action_names::KILL_TO_END_OF_LINE ) );
+	bind_key( Replxx::KEY::control( 'Y' ),                 _namedActions.at( action_names::YANK ) );
+	bind_key( Replxx::KEY::meta( 'y' ),                    _namedActions.at( action_names::YANK_CYCLE ) );
+	bind_key( Replxx::KEY::meta( 'Y' ),                    _namedActions.at( action_names::YANK_CYCLE ) );
+	bind_key( Replxx::KEY::meta( '.' ),                    _namedActions.at( action_names::YANK_LAST_ARG ) );
+	bind_key( Replxx::KEY::meta( 'c' ),                    _namedActions.at( action_names::CAPITALIZE_WORD ) );
+	bind_key( Replxx::KEY::meta( 'C' ),                    _namedActions.at( action_names::CAPITALIZE_SUBWORD ) );
+	bind_key( Replxx::KEY::meta( 'l' ),                    _namedActions.at( action_names::LOWERCASE_WORD ) );
+	bind_key( Replxx::KEY::meta( 'L' ),                    _namedActions.at( action_names::LOWERCASE_SUBWORD ) );
+	bind_key( Replxx::KEY::meta( 'u' ),                    _namedActions.at( action_names::UPPERCASE_WORD ) );
+	bind_key( Replxx::KEY::meta( 'U' ),                    _namedActions.at( action_names::UPPERCASE_SUBWORD ) );
+	bind_key( Replxx::KEY::control( 'T' ),                 _namedActions.at( action_names::TRANSPOSE_CHARACTERS ) );
+	bind_key( Replxx::KEY::control( 'C' ),                 _namedActions.at( action_names::ABORT_LINE ) );
+	bind_key( Replxx::KEY::ABORT,                          _namedActions.at( action_names::ABORT_LINE ) );
+	bind_key( Replxx::KEY::control( 'D' ),                 _namedActions.at( action_names::SEND_EOF ) );
+	bind_key( Replxx::KEY::INSERT + 0,                     _namedActions.at( action_names::TOGGLE_OVERWRITE_MODE ) );
+	bind_key( 127,                                         _namedActions.at( action_names::DELETE_CHARACTER_UNDER_CURSOR ) );
+	bind_key( Replxx::KEY::DELETE + 0,                     _namedActions.at( action_names::DELETE_CHARACTER_UNDER_CURSOR ) );
+	bind_key( Replxx::KEY::BACKSPACE + 0,                  _namedActions.at( action_names::DELETE_CHARACTER_LEFT_OF_CURSOR ) );
+	bind_key( Replxx::KEY::control( 'J' ),                 _namedActions.at( action_names::NEW_LINE ) );
+	bind_key( Replxx::KEY::meta( '\r' ),                   _namedActions.at( action_names::NEW_LINE ) );
+	bind_key( Replxx::KEY::ENTER + 0,                      _namedActions.at( action_names::COMMIT_LINE ) );
+	bind_key( Replxx::KEY::control( 'L' ),                 _namedActions.at( action_names::CLEAR_SCREEN ) );
+	bind_key( Replxx::KEY::control( 'N' ),                 _namedActions.at( action_names::COMPLETE_NEXT ) );
+	bind_key( Replxx::KEY::control( 'P' ),                 _namedActions.at( action_names::COMPLETE_PREVIOUS ) );
+	bind_key( Replxx::KEY::DOWN + 0,                       _namedActions.at( action_names::LINE_NEXT ) );
+	bind_key( Replxx::KEY::UP + 0,                         _namedActions.at( action_names::LINE_PREVIOUS ) );
+	bind_key( Replxx::KEY::meta( Replxx::KEY::DOWN ),      _namedActions.at( action_names::HISTORY_NEXT ) );
+	bind_key( Replxx::KEY::meta( Replxx::KEY::UP ),        _namedActions.at( action_names::HISTORY_PREVIOUS ) );
+	bind_key( Replxx::KEY::meta( '<' ),                    _namedActions.at( action_names::HISTORY_FIRST ) );
+	bind_key( Replxx::KEY::PAGE_UP + 0,                    _namedActions.at( action_names::HISTORY_FIRST ) );
+	bind_key( Replxx::KEY::meta( '>' ),                    _namedActions.at( action_names::HISTORY_LAST ) );
+	bind_key( Replxx::KEY::PAGE_DOWN + 0,                  _namedActions.at( action_names::HISTORY_LAST ) );
+	bind_key( Replxx::KEY::control( 'G' ),                 _namedActions.at( action_names::HISTORY_RESTORE_CURRENT ) );
+	bind_key( Replxx::KEY::meta( 'g' ),                    _namedActions.at( action_names::HISTORY_RESTORE ) );
+	bind_key( Replxx::KEY::control( Replxx::KEY::UP ),     _namedActions.at( action_names::HINT_PREVIOUS ) );
+	bind_key( Replxx::KEY::control( Replxx::KEY::DOWN ),   _namedActions.at( action_names::HINT_NEXT ) );
+#ifndef _WIN32
+	bind_key( Replxx::KEY::control( 'V' ),                 _namedActions.at( action_names::VERBATIM_INSERT ) );
+	bind_key( Replxx::KEY::control( 'Z' ),                 _namedActions.at( action_names::SUSPEND ) );
+#endif
+	bind_key( Replxx::KEY::TAB + 0,                        _namedActions.at( action_names::COMPLETE_LINE ) );
+	bind_key( Replxx::KEY::control( 'R' ),                 _namedActions.at( action_names::HISTORY_INCREMENTAL_SEARCH ) );
+	bind_key( Replxx::KEY::control( 'S' ),                 _namedActions.at( action_names::HISTORY_INCREMENTAL_SEARCH ) );
+	bind_key( Replxx::KEY::meta( 'p' ),                    _namedActions.at( action_names::HISTORY_COMMON_PREFIX_SEARCH ) );
+	bind_key( Replxx::KEY::meta( 'P' ),                    _namedActions.at( action_names::HISTORY_COMMON_PREFIX_SEARCH ) );
+	bind_key( Replxx::KEY::meta( 'n' ),                    _namedActions.at( action_names::HISTORY_COMMON_PREFIX_SEARCH ) );
+	bind_key( Replxx::KEY::meta( 'N' ),                    _namedActions.at( action_names::HISTORY_COMMON_PREFIX_SEARCH ) );
+	bind_key( Replxx::KEY::PASTE_START,                    std::bind( &ReplxxImpl::invoke, this, Replxx::ACTION::BRACKETED_PASTE, _1 ) );
+}
+
+Replxx::ReplxxImpl::~ReplxxImpl( void ) {
+	try {
+		disable_bracketed_paste();
+	} catch ( std::runtime_error const& ) {
+		// suppress "write failed" errors (see Terminal::write8()).
+		// in case of i.e. broken pipe.
+	}
+}
+
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::invoke( Replxx::ACTION action_, char32_t code ) {
+	switch ( action_ ) {
+		case ( Replxx::ACTION::INSERT_CHARACTER ):                return ( action( RESET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::insert_character, code ) );
+		case ( Replxx::ACTION::NEW_LINE ):                        return ( action( RESET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::new_line, code ) );
+		case ( Replxx::ACTION::DELETE_CHARACTER_UNDER_CURSOR ):   return ( action( RESET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::delete_character, code ) );
+		case ( Replxx::ACTION::DELETE_CHARACTER_LEFT_OF_CURSOR ): return ( action( RESET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::backspace_character, code ) );
+		case ( Replxx::ACTION::KILL_TO_END_OF_LINE ):             return ( action( WANT_REFRESH | SET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::kill_to_end_of_line, code ) );
+		case ( Replxx::ACTION::KILL_TO_BEGINING_OF_LINE ):        return ( action( SET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::kill_to_begining_of_line, code ) );
+		case ( Replxx::ACTION::KILL_TO_END_OF_WORD ):             return ( action( SET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::kill_word_to_right<false>, code ) );
+		case ( Replxx::ACTION::KILL_TO_BEGINING_OF_WORD ):        return ( action( SET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::kill_word_to_left<false>, code ) );
+		case ( Replxx::ACTION::KILL_TO_END_OF_SUBWORD ):          return ( action( SET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::kill_word_to_right<true>, code ) );
+		case ( Replxx::ACTION::KILL_TO_BEGINING_OF_SUBWORD ):     return ( action( SET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::kill_word_to_left<true>, code ) );
+		case ( Replxx::ACTION::KILL_TO_WHITESPACE_ON_LEFT ):      return ( action( SET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::kill_to_whitespace_to_left, code ) );
+		case ( Replxx::ACTION::YANK ):                            return ( action( HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::yank, code ) );
+		case ( Replxx::ACTION::YANK_CYCLE ):                      return ( action( HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::yank_cycle, code ) );
+		case ( Replxx::ACTION::YANK_LAST_ARG ):                   return ( action( HISTORY_RECALL_MOST_RECENT | DONT_RESET_HIST_YANK_INDEX, &Replxx::ReplxxImpl::yank_last_arg, code ) );
+		case ( Replxx::ACTION::MOVE_CURSOR_TO_BEGINING_OF_LINE ): return ( action( MOVE_CURSOR | RESET_KILL_ACTION, &Replxx::ReplxxImpl::go_to_begining_of_line, code ) );
+		case ( Replxx::ACTION::MOVE_CURSOR_TO_END_OF_LINE ):      return ( action( MOVE_CURSOR | RESET_KILL_ACTION, &Replxx::ReplxxImpl::go_to_end_of_line, code ) );
+		case ( Replxx::ACTION::MOVE_CURSOR_ONE_WORD_LEFT ):       return ( action( MOVE_CURSOR | RESET_KILL_ACTION, &Replxx::ReplxxImpl::move_one_word_left<false>, code ) );
+		case ( Replxx::ACTION::MOVE_CURSOR_ONE_WORD_RIGHT ):      return ( action( MOVE_CURSOR | RESET_KILL_ACTION, &Replxx::ReplxxImpl::move_one_word_right<false>, code ) );
+		case ( Replxx::ACTION::MOVE_CURSOR_ONE_SUBWORD_LEFT ):    return ( action( MOVE_CURSOR | RESET_KILL_ACTION, &Replxx::ReplxxImpl::move_one_word_left<true>, code ) );
+		case ( Replxx::ACTION::MOVE_CURSOR_ONE_SUBWORD_RIGHT ):   return ( action( MOVE_CURSOR | RESET_KILL_ACTION, &Replxx::ReplxxImpl::move_one_word_right<true>, code ) );
+		case ( Replxx::ACTION::MOVE_CURSOR_LEFT ):                return ( action( MOVE_CURSOR | RESET_KILL_ACTION, &Replxx::ReplxxImpl::move_one_char_left, code ) );
+		case ( Replxx::ACTION::MOVE_CURSOR_RIGHT ):               return ( action( MOVE_CURSOR | RESET_KILL_ACTION, &Replxx::ReplxxImpl::move_one_char_right, code ) );
+		case ( Replxx::ACTION::LINE_NEXT ):                       return ( action( MOVE_CURSOR | RESET_KILL_ACTION, &Replxx::ReplxxImpl::line_next, code ) );
+		case ( Replxx::ACTION::LINE_PREVIOUS ):                   return ( action( MOVE_CURSOR | RESET_KILL_ACTION, &Replxx::ReplxxImpl::line_previous, code ) );
+		case ( Replxx::ACTION::HISTORY_NEXT ):                    return ( action( MOVE_CURSOR | RESET_KILL_ACTION, &Replxx::ReplxxImpl::history_next, code ) );
+		case ( Replxx::ACTION::HISTORY_PREVIOUS ):                return ( action( MOVE_CURSOR | RESET_KILL_ACTION, &Replxx::ReplxxImpl::history_previous, code ) );
+		case ( Replxx::ACTION::HISTORY_FIRST ):                   return ( action( MOVE_CURSOR | RESET_KILL_ACTION, &Replxx::ReplxxImpl::history_first, code ) );
+		case ( Replxx::ACTION::HISTORY_LAST ):                    return ( action( MOVE_CURSOR | RESET_KILL_ACTION, &Replxx::ReplxxImpl::history_last, code ) );
+		case ( Replxx::ACTION::HISTORY_RESTORE_CURRENT ):         return ( action( MOVE_CURSOR | RESET_KILL_ACTION, &Replxx::ReplxxImpl::history_restore_current, code ) );
+		case ( Replxx::ACTION::HISTORY_RESTORE ):                 return ( action( MOVE_CURSOR | RESET_KILL_ACTION, &Replxx::ReplxxImpl::history_restore, code ) );
+		case ( Replxx::ACTION::HISTORY_INCREMENTAL_SEARCH ):      return ( action( NOOP, &Replxx::ReplxxImpl::incremental_history_search, code ) );
+		case ( Replxx::ACTION::HISTORY_COMMON_PREFIX_SEARCH ):    return ( action( RESET_KILL_ACTION | DONT_RESET_PREFIX, &Replxx::ReplxxImpl::common_prefix_search, code ) );
+		case ( Replxx::ACTION::HINT_NEXT ):                       return ( action( NOOP, &Replxx::ReplxxImpl::hint_next, code ) );
+		case ( Replxx::ACTION::HINT_PREVIOUS ):                   return ( action( NOOP, &Replxx::ReplxxImpl::hint_previous, code ) );
+		case ( Replxx::ACTION::CAPITALIZE_WORD ):                 return ( action( RESET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::capitalize_word<false>, code ) );
+		case ( Replxx::ACTION::LOWERCASE_WORD ):                  return ( action( RESET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::lowercase_word<false>, code ) );
+		case ( Replxx::ACTION::UPPERCASE_WORD ):                  return ( action( RESET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::uppercase_word<false>, code ) );
+		case ( Replxx::ACTION::CAPITALIZE_SUBWORD ):              return ( action( RESET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::capitalize_word<true>, code ) );
+		case ( Replxx::ACTION::LOWERCASE_SUBWORD ):               return ( action( RESET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::lowercase_word<true>, code ) );
+		case ( Replxx::ACTION::UPPERCASE_SUBWORD ):               return ( action( RESET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::uppercase_word<true>, code ) );
+		case ( Replxx::ACTION::TRANSPOSE_CHARACTERS ):            return ( action( RESET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::transpose_characters, code ) );
+		case ( Replxx::ACTION::TOGGLE_OVERWRITE_MODE ):           return ( action( NOOP, &Replxx::ReplxxImpl::toggle_overwrite_mode, code ) );
+#ifndef _WIN32
+		case ( Replxx::ACTION::VERBATIM_INSERT ):                 return ( action( WANT_REFRESH | RESET_KILL_ACTION, &Replxx::ReplxxImpl::verbatim_insert, code ) );
+		case ( Replxx::ACTION::SUSPEND ):                         return ( action( WANT_REFRESH, &Replxx::ReplxxImpl::suspend, code ) );
+#endif
+		case ( Replxx::ACTION::CLEAR_SCREEN ):                    return ( action( NOOP, &Replxx::ReplxxImpl::clear_screen, code ) );
+		case ( Replxx::ACTION::CLEAR_SELF ): clear_self_to_end_of_screen(); return ( Replxx::ACTION_RESULT::CONTINUE );
+		case ( Replxx::ACTION::REPAINT ):    repaint();           return ( Replxx::ACTION_RESULT::CONTINUE );
+		case ( Replxx::ACTION::COMPLETE_LINE ):                   return ( action( HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::complete_line, code ) );
+		case ( Replxx::ACTION::COMPLETE_NEXT ):                   return ( action( RESET_KILL_ACTION | DONT_RESET_COMPLETIONS | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::complete_next, code ) );
+		case ( Replxx::ACTION::COMPLETE_PREVIOUS ):               return ( action( RESET_KILL_ACTION | DONT_RESET_COMPLETIONS | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::complete_previous, code ) );
+		case ( Replxx::ACTION::COMMIT_LINE ):                     return ( action( RESET_KILL_ACTION, &Replxx::ReplxxImpl::commit_line, code ) );
+		case ( Replxx::ACTION::ABORT_LINE ):                      return ( action( RESET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::abort_line, code ) );
+		case ( Replxx::ACTION::SEND_EOF ):                        return ( action( HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::send_eof, code ) );
+		case ( Replxx::ACTION::BRACKETED_PASTE ):                 return ( action( WANT_REFRESH | RESET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::bracketed_paste, code ) );
+	}
+	return ( Replxx::ACTION_RESULT::BAIL );
+}
+
+void Replxx::ReplxxImpl::bind_key( char32_t code_, Replxx::key_press_handler_t handler_ ) {
+	_keyPressHandlers[code_] = handler_;
+}
+
+void Replxx::ReplxxImpl::bind_key_internal( char32_t code_, char const* actionName_ ) {
+	named_actions_t::const_iterator it( _namedActions.find( actionName_ ) );
+	if ( it == _namedActions.end() ) {
+		throw std::runtime_error( std::string( "replxx: Unknown action name: " ).append( actionName_ ) );
+	}
+	if ( !! it->second ) {
+		bind_key( code_, it->second );
+	}
+}
+
+Replxx::State Replxx::ReplxxImpl::get_state( void ) const {
+	_utf8Buffer.assign( _data );
+	return ( Replxx::State( _utf8Buffer.get(), _pos ) );
+}
+
+void Replxx::ReplxxImpl::set_state( Replxx::State const& state_ ) {
+	_data.assign( state_.text() );
+	if ( state_.cursor_position() >= 0 ) {
+		_pos = min( state_.cursor_position(), _data.length() );
+	}
+	_modifiedState = true;
+}
+
+void Replxx::ReplxxImpl::set_ignore_case( bool val ) {
+	_ignoreCase = val;
+}
+
+char32_t Replxx::ReplxxImpl::read_char( HINT_ACTION hintAction_ ) {
+	/* try scheduled key presses */ {
+		std::lock_guard<std::mutex> l( _mutex );
+		if ( !_keyPresses.empty() ) {
+			char32_t keyPress( _keyPresses.front() );
+			_keyPresses.pop_front();
+			return ( keyPress );
+		}
+	}
+	int hintDelay(
+		_refreshSkipped
+			? static_cast<int>( RAPID_REFRESH_MS * 2 )
+			: ( hintAction_ != HINT_ACTION::SKIP ? _hintDelay : 0 )
+	);
+	while ( true ) {
+		Terminal::EVENT_TYPE eventType( _terminal.wait_for_input( hintDelay ) );
+		if ( eventType == Terminal::EVENT_TYPE::TIMEOUT ) {
+			refresh_line( _refreshSkipped ? HINT_ACTION::REGENERATE : HINT_ACTION::REPAINT );
+			hintDelay = 0;
+			_refreshSkipped = false;
+			continue;
+		}
+		if ( eventType == Terminal::EVENT_TYPE::KEY_PRESS ) {
+			break;
+		}
+		if ( eventType == Terminal::EVENT_TYPE::RESIZE ) {
+			// caught a window resize event
+			// now redraw the prompt and line
+			_prompt.update_screen_columns();
+			// redraw the original prompt with current input
+			refresh_line( HINT_ACTION::REPAINT );
+			continue;
+		}
+
+		std::lock_guard<std::mutex> l( _mutex );
+		_terminal.set_cursor_visible( false );
+		clear_self_to_end_of_screen();
+
+		if ( _updatePrompt ) {
+			// Update the prompt after the screen has been cleared and before it is redrawn
+			_updatePrompt = false;
+			std::string const updated = std::move( _asyncPrompt );
+			_prompt.set_text( UnicodeString( updated ) );
+		}
+
+		while ( ! _messages.empty() ) {
+			string const& message( _messages.front() );
+			_terminal.write8( message.data(), static_cast<int>( message.length() ) );
+			_messages.pop_front();
+		}
+		_lastRefreshTime = 0;
+		repaint();
+	}
+	/* try scheduled key presses */ {
+		std::lock_guard<std::mutex> l( _mutex );
+		if ( !_keyPresses.empty() ) {
+			char32_t keyPress( _keyPresses.front() );
+			_keyPresses.pop_front();
+			return ( keyPress );
+		}
+	}
+	return ( _terminal.read_char() );
+}
+
+void Replxx::ReplxxImpl::clear( void ) {
+	_pos = 0;
+	_prefix = 0;
+	_completions.clear();
+	_completionContextLength = 0;
+	_completionSelection = -1;
+	_data.clear();
+	_hintSelection = -1;
+	_hint = UnicodeString();
+	_display.clear();
+	_displayInputLength = 0;
+}
+
+void Replxx::ReplxxImpl::call_modify_callback( void ) {
+	if ( ! _modifyCallback ) {
+		return;
+	}
+	_utf8Buffer.assign( _data );
+	std::string origLine( _utf8Buffer.get() );
+	int pos( _pos );
+	std::string line( origLine );
+	/* IOModeGuard scope */ {
+		IOModeGuard ioModeGuard( _terminal );
+		_modifyCallback( line, pos );
+	}
+	if ( ( pos != _pos ) || ( line != origLine ) ) {
+		_data.assign( line.c_str() );
+		_pos = min( pos, _data.length() );
+		_modifiedState = true;
+	}
+}
+
+Replxx::ReplxxImpl::completions_t Replxx::ReplxxImpl::call_completer( std::string const& input, int& contextLen_ ) const {
+	Replxx::completions_t completionsIntermediary(
+		!! _completionCallback
+			? _completionCallback( input, contextLen_ )
+			: Replxx::completions_t()
+	);
+	completions_t completions;
+	completions.reserve( completionsIntermediary.size() );
+	for ( Replxx::Completion const& c : completionsIntermediary ) {
+		completions.emplace_back( c );
+	}
+	return ( completions );
+}
+
+Replxx::ReplxxImpl::hints_t Replxx::ReplxxImpl::call_hinter( std::string const& input, int& contextLen, Replxx::Color& color ) const {
+	Replxx::hints_t hintsIntermediary(
+		!! _hintCallback
+			? _hintCallback( input, contextLen, color )
+			: Replxx::hints_t()
+	);
+	hints_t hints;
+	hints.reserve( hintsIntermediary.size() );
+	for ( std::string const& h : hintsIntermediary ) {
+		hints.emplace_back( h.c_str() );
+	}
+	return ( hints );
+}
+
+void Replxx::ReplxxImpl::set_preload_buffer( std::string const& preloadText ) {
+	_preloadedBuffer = preloadText;
+	// remove characters that won't display correctly
+	bool controlsStripped = false;
+	int whitespaceSeen( 0 );
+	for ( std::string::iterator it( _preloadedBuffer.begin() ); it != _preloadedBuffer.end(); ) {
+		unsigned char c = *it;
+		if ( '\r' == c ) { // silently skip CR
+			_preloadedBuffer.erase( it, it + 1 );
+			continue;
+		}
+		if ( ( '\n' == c ) || ( '\t' == c ) ) { // note newline or tab
+			++ whitespaceSeen;
+			++ it;
+			continue;
+		}
+		if ( whitespaceSeen > 0 ) {
+			it -= whitespaceSeen;
+			*it = ' ';
+			_preloadedBuffer.erase( it + 1, it + whitespaceSeen - 1 );
+		}
+		if ( is_control_code( c ) ) { // remove other control characters, flag for message
+			controlsStripped = true;
+			if ( whitespaceSeen > 0 ) {
+				_preloadedBuffer.erase( it, it + 1 );
+				-- it;
+			} else {
+				*it = ' ';
+			}
+		}
+		whitespaceSeen = 0;
+		++ it;
+	}
+	if ( whitespaceSeen > 0 ) {
+		std::string::iterator it = _preloadedBuffer.end() - whitespaceSeen;
+		*it = ' ';
+		if ( whitespaceSeen > 1 ) {
+			_preloadedBuffer.erase( it + 1, _preloadedBuffer.end() );
+		}
+	}
+	_errorMessage.clear();
+	if ( controlsStripped ) {
+		_errorMessage.assign( " [Edited line: control characters were converted to spaces]\n" );
+	}
+}
+
+char const* Replxx::ReplxxImpl::read_from_stdin( void ) {
+	if ( _preloadedBuffer.empty() ) {
+		getline( cin, _preloadedBuffer );
+		if ( ! cin.good() ) {
+			return nullptr;
+		}
+	}
+	while ( ! _preloadedBuffer.empty() && ( ( _preloadedBuffer.back() == '\r' ) || ( _preloadedBuffer.back() == '\n' ) ) ) {
+		_preloadedBuffer.pop_back();
+	}
+	_utf8Buffer.assign( _preloadedBuffer );
+	_preloadedBuffer.clear();
+	return _utf8Buffer.get();
+}
+
+void Replxx::ReplxxImpl::emulate_key_press( char32_t keyCode_ ) {
+	std::lock_guard<std::mutex> l( _mutex );
+	_keyPresses.push_back( keyCode_ );
+	if ( ( _currentThread != std::thread::id() ) && ( _currentThread != std::this_thread::get_id() ) ) {
+		_terminal.notify_event( Terminal::EVENT_TYPE::KEY_PRESS );
+	}
+}
+
+char const* Replxx::ReplxxImpl::input( std::string const& prompt ) {
+	try {
+		errno = 0;
+		if ( ! tty::in ) { // input not from a terminal, we should work with piped input, i.e. redirected stdin
+			return ( read_from_stdin() );
+		}
+		if ( ! _errorMessage.empty() ) {
+			printf( "%s", _errorMessage.c_str() );
+			fflush( stdout );
+			_errorMessage.clear();
+		}
+		if ( isUnsupportedTerm() ) {
+			fprintf( stdout, "%s", prompt.c_str() );
+			fflush( stdout );
+			return ( read_from_stdin() );
+		}
+		std::unique_lock<std::mutex> l( _mutex );
+		if ( _terminal.enable_raw_mode() == -1 ) {
+			return nullptr;
+		}
+
+		/// Always render from beginning of current line. It's to prevent garbage inputs during starting up.
+		_terminal.jump_cursor( 0, 0 );
+		_asyncPrompt.clear();
+		_updatePrompt = false;
+		_prompt.set_text( UnicodeString( prompt ) );
+		_currentThread = std::this_thread::get_id();
+		l.unlock();
+		clear();
+		if ( !_preloadedBuffer.empty() ) {
+			preload_puffer( _preloadedBuffer.c_str() );
+			_preloadedBuffer.clear();
+		}
+		if ( get_input_line() == -1 ) {
+			return ( finalize_input( nullptr ) );
+		}
+		_terminal.write8( "\n", 1 );
+		_utf8Buffer.assign( _data );
+		return ( finalize_input( _utf8Buffer.get() ) );
+	} catch ( std::exception const& ) {
+		return ( finalize_input( nullptr ) );
+	}
+}
+
+char const* Replxx::ReplxxImpl::finalize_input( char const* retVal_ ) {
+	std::unique_lock<std::mutex> l( _mutex );
+	while ( ! _messages.empty() ) {
+		string const& message( _messages.front() );
+		l.unlock();
+		_terminal.write8( message.data(), static_cast<int>( message.length() ) );
+		l.lock();
+		_messages.pop_front();
+	}
+	_currentThread = std::thread::id();
+	_terminal.disable_raw_mode();
+	return ( retVal_ );
+}
+
+int Replxx::ReplxxImpl::install_window_change_handler( void ) {
+#ifndef _WIN32
+	return ( _terminal.install_window_change_handler() );
+#else
+	return 0;
+#endif
+}
+
+void Replxx::ReplxxImpl::enable_bracketed_paste( void ) {
+	if ( _bracketedPaste ) {
+		return;
+	}
+	_terminal.enable_bracketed_paste();
+	_bracketedPaste = true;
+}
+
+void Replxx::ReplxxImpl::disable_bracketed_paste( void ) {
+	if ( ! _bracketedPaste ) {
+		return;
+	}
+	_terminal.disable_bracketed_paste();
+	_bracketedPaste = false;
+}
+
+void Replxx::ReplxxImpl::print( char const* str_, int size_ ) {
+	std::unique_lock<std::mutex> l( _mutex );
+	if ( ( _currentThread == std::thread::id() ) || ( _currentThread == std::this_thread::get_id() ) ) {
+#ifndef _WIN32
+		l.unlock();
+#endif
+		_terminal.write8( str_, size_ );
+	} else {
+		_messages.emplace_back( str_, size_ );
+		_terminal.notify_event( Terminal::EVENT_TYPE::MESSAGE );
+	}
+	return;
+}
+
+void Replxx::ReplxxImpl::set_prompt( std::string prompt ) {
+	std::unique_lock<std::mutex> l( _mutex );
+	if ( _currentThread == std::this_thread::get_id() ) {
+		_prompt.set_text( UnicodeString( prompt ) );
+		l.unlock();
+		clear_self_to_end_of_screen();
+		repaint();
+	} else if ( _currentThread != std::thread::id() ) {
+		_asyncPrompt = std::move( prompt );
+		_updatePrompt = true;
+		_terminal.notify_event( Terminal::EVENT_TYPE::MESSAGE );
+	}
+}
+
+void Replxx::ReplxxImpl::preload_puffer(const char* preloadText) {
+	_data.assign( preloadText );
+	_prefix = _pos = _data.length();
+}
+
+void Replxx::ReplxxImpl::set_color( Replxx::Color color_ ) {
+	char const* code( ansi_color( color_ ) );
+	while ( *code ) {
+		_display.push_back( *code );
+		++ code;
+	}
+}
+
+void Replxx::ReplxxImpl::indent( void ) {
+	if ( ! _indentMultiline ) {
+		return;
+	}
+	for ( int i( 0 ); i < _prompt.indentation(); ++ i ) {
+		_display.push_back( ' ' );
+	}
+}
+
+void Replxx::ReplxxImpl::render( char32_t ch ) {
+	if ( ch == Replxx::KEY::ESCAPE ) {
+		_display.push_back( '^' );
+		_display.push_back( '[' );
+	} else if ( is_control_code( ch ) && ( ch != '\n' ) ) {
+		_display.push_back( '^' );
+		_display.push_back( control_to_human( ch ) );
+	} else {
+		_display.push_back( ch );
+	}
+	if ( ch == '\n' ) {
+		_hasNewlines = true;
+		indent();
+	}
+	return;
+}
+
+void Replxx::ReplxxImpl::render( HINT_ACTION hintAction_ ) {
+	if ( hintAction_ == HINT_ACTION::TRIM ) {
+		_display.erase( _display.begin() + _displayInputLength, _display.end() );
+		_modifiedState = false;
+		return;
+	}
+	if ( hintAction_ == HINT_ACTION::SKIP ) {
+		return;
+	}
+	_hasNewlines = false;
+	_display.clear();
+	if ( _noColor ) {
+		for ( char32_t ch : _data ) {
+			render( ch );
+		}
+		_displayInputLength = static_cast<int>( _display.size() );
+		_modifiedState = false;
+		return;
+	}
+	Replxx::colors_t colors( _data.length(), Replxx::Color::DEFAULT );
+	_utf8Buffer.assign( _data );
+	if ( !! _highlighterCallback ) {
+		IOModeGuard ioModeGuard( _terminal );
+		_highlighterCallback( _utf8Buffer.get(), colors );
+	}
+	paren_info_t pi( matching_paren() );
+	Replxx::Color ERROR( Replxx::Color::RED | color::bg( Replxx::Color::BRIGHTRED ) );
+	if ( pi.index != -1 ) {
+		colors[pi.index] = pi.error ? ERROR : Replxx::Color::BRIGHTRED;
+	}
+	Replxx::Color c( Replxx::Color::DEFAULT );
+	for ( int i( 0 ); i < _data.length(); ++ i ) {
+		if ( colors[i] != c ) {
+			c = colors[i];
+			set_color( c );
+		}
+		render( _data[i] );
+	}
+	set_color( Replxx::Color::DEFAULT );
+	_displayInputLength = static_cast<int>( _display.size() );
+	_modifiedState = false;
+	return;
+}
+
+void Replxx::ReplxxImpl::handle_hints( HINT_ACTION hintAction_ ) {
+	if ( _noColor ) {
+		return;
+	}
+	if ( ! _hintCallback ) {
+		return;
+	}
+	if ( ( _hintDelay > 0 ) && ( hintAction_ != HINT_ACTION::REPAINT ) ) {
+		_hintSelection = -1;
+		return;
+	}
+	if ( ( hintAction_ == HINT_ACTION::SKIP ) || ( hintAction_ == HINT_ACTION::TRIM ) ) {
+		return;
+	}
+	if ( _pos != _data.length() ) {
+		return;
+	}
+	_hint = UnicodeString();
+	if ( hintAction_ == HINT_ACTION::REGENERATE ) {
+		_hintSelection = -1;
+	}
+	_utf8Buffer.assign( _data, _pos );
+	if ( ( _utf8Buffer != _hintSeed ) || ( _hintContextLenght < 0 ) ) {
+		_hintSeed.assign( _utf8Buffer );
+		_hintContextLenght = context_length();
+		_hintColor = Replxx::Color::GRAY;
+		IOModeGuard ioModeGuard( _terminal );
+		_hintsCache = call_hinter( _utf8Buffer.get(), _hintContextLenght, _hintColor );
+	}
+	int hintCount( static_cast<int>( _hintsCache.size() ) );
+	if ( hintCount == 1 ) {
+		_hint = _hintsCache.front();
+		int len( _hint.length() - _hintContextLenght );
+		if ( len > 0 ) {
+			set_color( _hintColor );
+			for ( int i( 0 ); i < len; ++ i ) {
+				_display.push_back( _hint[i + _hintContextLenght] );
+			}
+			set_color( Replxx::Color::DEFAULT );
+		}
+	} else if ( ( _maxHintRows > 0 ) && ( hintCount > 0 ) ) {
+		int posInLine( pos_in_line() );
+		int startCol( ( _indentMultiline || ( posInLine == _pos ) ? _prompt.indentation() : 0 ) + posInLine );
+		int maxCol( _prompt.screen_columns() );
+#ifdef _WIN32
+		-- maxCol;
+#endif
+		if ( _hintSelection < -1 ) {
+			_hintSelection = hintCount - 1;
+		} else if ( _hintSelection >= hintCount ) {
+			_hintSelection = -1;
+		}
+		if ( _hintSelection != -1 ) {
+			_hint = _hintsCache[_hintSelection];
+			int len( min<int>( _hint.length(), maxCol - ( startCol - _hintContextLenght ) ) );
+			if ( _hintContextLenght < len ) {
+				set_color( _hintColor );
+				for ( int i( _hintContextLenght ); i < len; ++ i ) {
+					_display.push_back( _hint[i] );
+				}
+				set_color( Replxx::Color::DEFAULT );
+			}
+		}
+		startCol -= _hintContextLenght;
+		for ( int hintRow( 0 ); hintRow < min( hintCount, _maxHintRows ); ++ hintRow ) {
+#ifdef _WIN32
+			_display.push_back( '\r' );
+#endif
+			_display.push_back( '\n' );
+			int col( 0 );
+			for ( int i( 0 ); ( i < startCol ) && ( col < maxCol ); ++ i, ++ col ) {
+				_display.push_back( ' ' );
+			}
+			set_color( _hintColor );
+			int hintNo( hintRow + _hintSelection + 1 );
+			if ( hintNo == hintCount ) {
+				for ( int i( _pos - _hintContextLenght ); ( i < _pos ) && ( col < maxCol ); ++ i, ++ col ) {
+					_display.push_back( _data[i] );
+				}
+				continue;
+			} else if ( hintNo > hintCount ) {
+				-- hintNo;
+			}
+			UnicodeString const& h( _hintsCache[hintNo % hintCount] );
+			for ( int i( 0 ); ( i < h.length() ) && ( col < maxCol ); ++ i, ++ col ) {
+				_display.push_back( h[i] );
+			}
+			set_color( Replxx::Color::DEFAULT );
+		}
+	}
+	return;
+}
+
+// check for a matching brace/bracket/paren, remember its position if found
+Replxx::ReplxxImpl::paren_info_t Replxx::ReplxxImpl::matching_paren( void ) {
+	if (_pos >= _data.length()) {
+		return ( paren_info_t{ -1, false } );
+	}
+	/* this scans for a brace matching _data[_pos] to highlight */
+	unsigned char part1, part2;
+	int scanDirection = 0;
+	if ( strchr( "}])", _data[_pos] ) ) {
+		scanDirection = -1; /* backwards */
+		if (_data[_pos] == '}') {
+			part1 = '}'; part2 = '{';
+		} else if (_data[_pos] == ']') {
+			part1 = ']'; part2 = '[';
+		} else {
+			part1 = ')'; part2 = '(';
+		}
+	} else if ( strchr( "{[(", _data[_pos] ) ) {
+		scanDirection = 1; /* forwards */
+		if (_data[_pos] == '{') {
+			//part1 = '{'; part2 = '}';
+			part1 = '}'; part2 = '{';
+		} else if (_data[_pos] == '[') {
+			//part1 = '['; part2 = ']';
+			part1 = ']'; part2 = '[';
+		} else {
+			//part1 = '('; part2 = ')';
+			part1 = ')'; part2 = '(';
+		}
+	} else {
+		return ( paren_info_t{ -1, false } );
+	}
+	int highlightIdx = -1;
+	bool indicateError = false;
+	int unmatched = scanDirection;
+	int unmatchedOther = 0;
+	for (int i = _pos + scanDirection; i >= 0 && i < _data.length(); i += scanDirection) {
+		/* TODO: the right thing when inside a string */
+		if (strchr("}])", _data[i])) {
+			if (_data[i] == part1) {
+				--unmatched;
+			} else {
+				--unmatchedOther;
+			}
+		} else if (strchr("{[(", _data[i])) {
+			if (_data[i] == part2) {
+				++unmatched;
+			} else {
+				++unmatchedOther;
+			}
+		}
+
+		if (unmatched == 0) {
+			highlightIdx = i;
+			indicateError = (unmatchedOther != 0);
+			break;
+		}
+	}
+	return ( paren_info_t{ highlightIdx, indicateError } );
+}
+
+int Replxx::ReplxxImpl::virtual_render( char32_t const* buffer_, int len_, int& xPos_, int& yPos_, Prompt const* prompt_ ) {
+	Prompt const& prompt( prompt_ ? *prompt_ : _prompt );
+	return ( replxx::virtual_render( buffer_, len_, xPos_, yPos_, prompt.screen_columns(), _indentMultiline ? prompt.indentation() : 0 ) );
+}
+
+/**
+ * Refresh the user's input line: the prompt is already onscreen and is not
+ * redrawn here screen position
+ */
+void Replxx::ReplxxImpl::refresh_line( HINT_ACTION hintAction_, bool refreshPrompt_ ) {
+	int long long now( now_us() );
+	int long long duration( now - _lastRefreshTime );
+	if ( duration < RAPID_REFRESH_US ) {
+		_lastRefreshTime = now;
+		_refreshSkipped = true;
+		return;
+	}
+	_refreshSkipped = false;
+	render( hintAction_ );
+	handle_hints( hintAction_ );
+	// calculate the desired position of the cursor
+	int xCursorPos( _prompt.indentation() );
+	int yCursorPos( 0 );
+	virtual_render( _data.get(), _pos, xCursorPos, yCursorPos );
+
+	// calculate the position of the end of the input line
+	int xEndOfInput( _prompt.indentation() );
+	int yEndOfInput( 0 );
+	// _data part of _display already contains the indent,
+	// also newlines belonging to hints part of display shall be ignored
+	// with respect to extra indent for multiline inputs
+	// in other words _display should not be re-indented
+	replxx::virtual_render( _display.data(), static_cast<int>( _display.size() ), xEndOfInput, yEndOfInput, _prompt.screen_columns(), 0 );
+
+	// position at the end of the prompt, clear to end of previous input
+	_terminal.set_cursor_visible( false );
+	if ( refreshPrompt_ ) {
+		_terminal.jump_cursor( 0, -_prompt._cursorRowOffset );
+		_prompt.write();
+		_prompt._cursorRowOffset = _prompt._extraLines;
+	} else {
+		_terminal.jump_cursor(
+			_prompt.indentation(), // 0-based on Win32
+			-( _prompt._cursorRowOffset - _prompt._extraLines )
+		);
+	}
+	// display the input line
+	if ( _hasNewlines ) {
+		_terminal.clear_screen( Terminal::CLEAR_SCREEN::TO_END );
+		_terminal.write32( _display.data(), static_cast<int>( _display.size() ) );
+	} else {
+		_terminal.write32( _display.data(), _displayInputLength );
+		_terminal.clear_screen( Terminal::CLEAR_SCREEN::TO_END );
+		_terminal.write32( _display.data() + _displayInputLength, static_cast<int>( _display.size() ) - _displayInputLength );
+	}
+#ifndef _WIN32
+	// we have to generate our own newline on line wrap
+	if ( ( xEndOfInput == 0 ) && ( yEndOfInput > 0 ) && ! _data.is_empty() && ( _data.back() != '\n' ) ) {
+		_terminal.write8( "\n", 1 );
+	}
+#endif
+	// position the cursor
+	_terminal.jump_cursor( xCursorPos, -( yEndOfInput - yCursorPos ) );
+	_terminal.set_cursor_visible( true );
+	_prompt._cursorRowOffset = _prompt._extraLines + yCursorPos; // remember row for next pass
+	_lastRefreshTime = now_us();
+	_oldPos = _pos;
+	_moveCursor = false;
+}
+
+void Replxx::ReplxxImpl::move_cursor( void ) {
+	// calculate the desired position of the cursor
+	int xCursorPos( _prompt.indentation() );
+	int yCursorPos( 0 );
+	virtual_render( _data.get(), _pos, xCursorPos, yCursorPos );
+	// position the cursor
+	_terminal.jump_cursor( xCursorPos, -( _prompt._cursorRowOffset - _prompt._extraLines - yCursorPos ) );
+	_prompt._cursorRowOffset = _prompt._extraLines + yCursorPos;
+	_oldPos = _pos;
+	_moveCursor = false;
+}
+
+int Replxx::ReplxxImpl::context_length() {
+	int prefixLength = _pos;
+	while ( prefixLength > 0 ) {
+		if ( is_word_break_character<false>( _data[prefixLength - 1] ) ) {
+			break;
+		}
+		-- prefixLength;
+	}
+	return ( _pos - prefixLength );
+}
+
+void Replxx::ReplxxImpl::repaint( void ) {
+	_prompt.write();
+	for ( int i( _prompt._extraLines ); i < _prompt._cursorRowOffset; ++ i ) {
+		_terminal.write8( "\n", 1 );
+	}
+	refresh_line( HINT_ACTION::SKIP );
+}
+
+void Replxx::ReplxxImpl::clear_self_to_end_of_screen( Prompt const* prompt_ ) {
+	// position at the start of the prompt, clear to end of previous input
+	_terminal.jump_cursor( 0, prompt_ ? -prompt_->_cursorRowOffset : -_prompt._cursorRowOffset );
+	_terminal.clear_screen( Terminal::CLEAR_SCREEN::TO_END );
+	return;
+}
+
+namespace {
+
+int longest_common_prefix( Replxx::ReplxxImpl::completions_t const& completions, bool ignoreCase ) {
+	int completionsCount( static_cast<int>( completions.size() ) );
+	if ( completionsCount < 1 ) {
+		return ( 0 );
+	}
+	int longestCommonPrefix( 0 );
+	UnicodeString const& sample( completions.front().text() );
+	while ( true ) {
+		if ( longestCommonPrefix >= sample.length() ) {
+			return ( longestCommonPrefix );
+		}
+		char32_t sc( sample[longestCommonPrefix] );
+		for ( int i( 1 ); i < completionsCount; ++ i ) {
+			UnicodeString const& candidate( completions[i].text() );
+			if ( longestCommonPrefix >= candidate.length() ) {
+				return ( longestCommonPrefix );
+			}
+			char32_t cc( candidate[longestCommonPrefix] );
+			if ( ignoreCase ) {
+				if ( !case_insensitive_equal( cc, sc ) ) {
+					return longestCommonPrefix;
+				}
+			} else if ( cc != sc ) {
+				return longestCommonPrefix;
+			}
+		}
+		++ longestCommonPrefix;
+	}
+}
+
+}
+
+/**
+ * Handle command completion, using a completionCallback() routine to provide
+ * possible substitutions
+ * This routine handles the mechanics of updating the user's input buffer with
+ * possible replacement of text as the user selects a proposed completion string,
+ * or cancels the completion attempt.
+ * @param pi - Prompt struct holding information about the prompt and our
+ * screen position
+ */
+char32_t Replxx::ReplxxImpl::do_complete_line( bool showCompletions_ ) {
+	char32_t c = 0;
+
+	// completionCallback() expects a parsable entity, so find the previous break
+	// character and
+	// extract a copy to parse.	we also handle the case where tab is hit while
+	// not at end-of-line.
+
+	_utf8Buffer.assign( _data, _pos );
+	// get a list of completions
+	_completionSelection = -1;
+	_completionContextLength = context_length();
+	/* IOModeGuard scope */ {
+		IOModeGuard ioModeGuard( _terminal );
+		_completions = call_completer( _utf8Buffer.get(), _completionContextLength );
+	}
+
+	// if no completions, we are done
+	if ( _completions.empty() ) {
+		beep();
+		return 0;
+	}
+
+	// at least one completion
+	int longestCommonPrefix = 0;
+	int completionsCount( static_cast<int>( _completions.size() ) );
+	int selectedCompletion( 0 );
+	if ( ( completionsCount > 1 ) && ( _hintSelection != -1 ) ) {
+		selectedCompletion = _hintSelection;
+		completionsCount = 1;
+	}
+	if ( completionsCount == 1 ) {
+		longestCommonPrefix = static_cast<int>( _completions[selectedCompletion].text().length() );
+	} else {
+		bool lowerCaseContext( std::none_of( _data.end() - _completionContextLength, _data.end(), []( char32_t x ) { return iswupper( static_cast<wint_t>( x ) ); } ) );
+		longestCommonPrefix = longest_common_prefix( _completions, _ignoreCase && lowerCaseContext );
+	}
+	if ( _beepOnAmbiguousCompletion && ( completionsCount != 1 ) ) { // beep if ambiguous
+		beep();
+	}
+
+	// if we can extend the item, extend it and return to main loop
+	if ( ( longestCommonPrefix > _completionContextLength ) || ( completionsCount == 1 ) ) {
+		UnicodeString const* cand( nullptr );
+		// If _ignoreCase is on, we need to decide what's the proper situation of extending current
+		// prefix. The rule is: 1. if all prefixes are the same, do the extension even though it
+		// might generate upper case characters which loses the convenience of case-insensitive
+		// completion afterwards; 2. if there is a prefix with all lower case characters, do the
+		// extension. User has to adjust the prefix only when there are candidates like `format` and
+		// `FORMAT`, which is reasonable.
+		if ( _ignoreCase && ( _hintSelection == -1 ) ) {
+			std::map<UnicodeString, int> candidate_prefixes;
+			for ( int i( 0 ); i < completionsCount; ++ i ) {
+				candidate_prefixes.emplace(
+					std::piecewise_construct,
+					std::forward_as_tuple( _completions[i].text().get(), longestCommonPrefix ),
+					std::forward_as_tuple( i ));
+				const auto & valid_prefix = candidate_prefixes.rbegin()->first;
+				bool prefix_all_lower(
+					std::none_of( valid_prefix.begin(), valid_prefix.end(), []( char32_t x ) { return iswupper(static_cast<wint_t>(x)); } ) );
+				if (candidate_prefixes.size() == 1 || prefix_all_lower) {
+					cand = &_completions[candidate_prefixes.rbegin()->second].text();
+				}
+			}
+		} else {
+			cand = &_completions[selectedCompletion].text();
+		}
+		if ( cand ) {
+			_pos -= _completionContextLength;
+			_data.erase( _pos, _completionContextLength );
+			_data.insert( _pos, *cand, 0, longestCommonPrefix );
+			_completionContextLength = longestCommonPrefix;
+			_pos += _completionContextLength;
+			refresh_line();
+			return 0;
+		}
+	}
+
+	if ( ! showCompletions_ ) {
+		return ( 0 );
+	}
+
+	if ( _doubleTabCompletion ) {
+		// we can't complete any further, wait for second tab
+		do {
+			c = read_char();
+		} while ( c == static_cast<char32_t>( -1 ) );
+
+		// if any character other than tab, pass it to the main loop
+		if ( c != Replxx::KEY::TAB ) {
+			return c;
+		}
+	}
+
+	// we got a second tab, maybe show list of possible completions
+	bool showCompletions = true;
+	bool onNewLine = false;
+	if ( static_cast<int>( _completions.size() ) > _completionCountCutoff ) {
+		int savePos = _pos; // move cursor to EOL to avoid overwriting the command line
+		_pos = _data.length();
+		refresh_line();
+		_pos = savePos;
+		printf( "\nDisplay all %u possibilities? (y or n)", static_cast<unsigned int>( _completions.size() ) );
+		fflush(stdout);
+		onNewLine = true;
+		while (c != 'y' && c != 'Y' && c != 'n' && c != 'N' && c != Replxx::KEY::control('C')) {
+			do {
+				c = read_char();
+			} while (c == static_cast<char32_t>(-1));
+		}
+		switch (c) {
+			case 'n':
+			case 'N':
+				showCompletions = false;
+				break;
+			case Replxx::KEY::control('C'):
+				showCompletions = false;
+				// Display the ^C we got
+				_terminal.write8( "^C", 2 );
+				c = 0;
+				break;
+		}
+	}
+
+	// if showing the list, do it the way readline does it
+	bool stopList( false );
+	if ( showCompletions ) {
+		int longestCompletion( 0 );
+		for ( size_t j( 0 ); j < _completions.size(); ++ j ) {
+			int itemLength( static_cast<int>( _completions[j].text().length() ) );
+			if ( itemLength > longestCompletion ) {
+				longestCompletion = itemLength;
+			}
+		}
+		longestCompletion += 2;
+		int columnCount = _prompt.screen_columns() / longestCompletion;
+		if ( columnCount < 1 ) {
+			columnCount = 1;
+		}
+		if ( ! onNewLine ) {  // skip this if we showed "Display all %d possibilities?"
+			int savePos = _pos; // move cursor to EOL to avoid overwriting the command line
+			_pos = _data.length();
+			refresh_line( HINT_ACTION::TRIM );
+			_pos = savePos;
+		} else {
+			_terminal.clear_screen( Terminal::CLEAR_SCREEN::TO_END );
+		}
+		size_t pauseRow = _terminal.get_screen_rows() - 1;
+		size_t rowCount = (_completions.size() + columnCount - 1) / columnCount;
+		for (size_t row = 0; row < rowCount; ++row) {
+			if (row == pauseRow) {
+				printf("\n--More--");
+				fflush(stdout);
+				c = 0;
+				bool doBeep = false;
+				while (c != ' ' && c != Replxx::KEY::ENTER && c != 'y' && c != 'Y' &&
+							 c != 'n' && c != 'N' && c != 'q' && c != 'Q' &&
+							 c != Replxx::KEY::control('C')) {
+					if (doBeep) {
+						beep();
+					}
+					doBeep = true;
+					do {
+						c = read_char();
+					} while (c == static_cast<char32_t>(-1));
+				}
+				switch (c) {
+					case ' ':
+					case 'y':
+					case 'Y':
+						printf("\r				\r");
+						pauseRow += _terminal.get_screen_rows() - 1;
+						break;
+					case Replxx::KEY::ENTER:
+						printf("\r				\r");
+						++pauseRow;
+						break;
+					case 'n':
+					case 'N':
+					case 'q':
+					case 'Q':
+						printf("\r				\r");
+						stopList = true;
+						break;
+					case Replxx::KEY::control('C'):
+						// Display the ^C we got
+						_terminal.write8( "^C", 2 );
+						stopList = true;
+						break;
+				}
+			} else {
+				_terminal.write8( "\n", 1 );
+			}
+			if (stopList) {
+				break;
+			}
+			static UnicodeString const res( ansi_color( Replxx::Color::DEFAULT ) );
+			for (int column = 0; column < columnCount; ++column) {
+				size_t index = (column * rowCount) + row;
+				if ( index < _completions.size() ) {
+					Completion const& c( _completions[index] );
+					int itemLength = static_cast<int>(c.text().length());
+					fflush(stdout);
+
+					if ( longestCommonPrefix > 0 ) {
+						static UnicodeString const col( ansi_color( Replxx::Color::BRIGHTMAGENTA ) );
+						if (!_noColor) {
+							_terminal.write32(col.get(), col.length());
+						}
+						_terminal.write32(c.text().get(), longestCommonPrefix);
+						if (!_noColor) {
+							_terminal.write32(res.get(), res.length());
+						}
+					}
+
+					if ( !_noColor && ( c.color() != Replxx::Color::DEFAULT ) ) {
+						UnicodeString ac( ansi_color( c.color() ) );
+						_terminal.write32( ac.get(), ac.length() );
+					}
+					_terminal.write32( c.text().get() + longestCommonPrefix, itemLength - longestCommonPrefix );
+					if ( !_noColor && ( c.color() != Replxx::Color::DEFAULT ) ) {
+						_terminal.write32( res.get(), res.length() );
+					}
+
+					if ( ((column + 1) * rowCount) + row < _completions.size() ) {
+						for ( int k( itemLength ); k < longestCompletion; ++k ) {
+							printf( " " );
+						}
+					}
+				}
+			}
+		}
+		fflush(stdout);
+	}
+
+	// display the prompt on a new line, then redisplay the input buffer
+	if (!stopList || c == Replxx::KEY::control('C')) {
+		_terminal.write8( "\n", 1 );
+	}
+	_prompt.write();
+	_prompt._cursorRowOffset = _prompt._extraLines;
+	refresh_line();
+	return 0;
+}
+
+int Replxx::ReplxxImpl::get_input_line( void ) {
+	// The latest history entry is always our current buffer
+	if ( _data.length() > 0 ) {
+		_history.add( _data );
+	} else {
+		_history.add( UnicodeString() );
+	}
+	_history.jump( false, false );
+
+	// display the prompt
+	_prompt.write();
+
+	// the cursor starts out at the end of the prompt
+	_prompt._cursorRowOffset = _prompt._extraLines;
+
+	// kill and yank start in "other" mode
+	_killRing.lastAction = KillRing::actionOther;
+
+	// if there is already text in the buffer, display it first
+	if (_data.length() > 0) {
+		refresh_line();
+	}
+
+	// loop collecting characters, respond to line editing characters
+	Replxx::ACTION_RESULT next( Replxx::ACTION_RESULT::CONTINUE );
+	while ( next == Replxx::ACTION_RESULT::CONTINUE ) {
+		int c( read_char( HINT_ACTION::REPAINT ) ); // get a new keystroke
+
+		if (c == 0) {
+			return _data.length();
+		}
+
+		if (c == -1) {
+			refresh_line();
+			continue;
+		}
+
+		if (c == -2) {
+			_prompt.write();
+			refresh_line();
+			continue;
+		}
+
+		key_press_handlers_t::iterator it( _keyPressHandlers.find( c ) );
+		if ( it != _keyPressHandlers.end() ) {
+			next = it->second( c );
+			if ( _modifiedState ) {
+				refresh_line();
+			} else if ( _moveCursor ) {
+				move_cursor();
+			}
+		} else {
+			next = action( RESET_KILL_ACTION | HISTORY_RECALL_MOST_RECENT, &Replxx::ReplxxImpl::insert_character, c );
+		}
+	}
+	return ( next == Replxx::ACTION_RESULT::RETURN ? _data.length() : -1 );
+}
+
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::action( action_trait_t actionTrait_, key_press_handler_raw_t const& handler_, char32_t code_ ) {
+	Replxx::ACTION_RESULT res( ( this->*handler_ )( code_ ) );
+	call_modify_callback();
+	if ( actionTrait_ & HISTORY_RECALL_MOST_RECENT ) {
+		_history.reset_recall_most_recent();
+	}
+	if ( actionTrait_ & RESET_KILL_ACTION ) {
+		_killRing.lastAction = KillRing::actionOther;
+	}
+	if ( actionTrait_ & SET_KILL_ACTION ) {
+		_killRing.lastAction = KillRing::actionKill;
+	}
+	if ( ! ( actionTrait_ & DONT_RESET_PREFIX ) ) {
+		_prefix = _pos;
+	}
+	if ( ! ( actionTrait_ & DONT_RESET_COMPLETIONS ) ) {
+		_completions.clear();
+		_completionSelection = -1;
+		_completionContextLength = 0;
+	}
+	if ( ! ( actionTrait_ & DONT_RESET_HIST_YANK_INDEX ) ) {
+		_history.reset_yank_iterator();
+	}
+	if ( actionTrait_ & WANT_REFRESH ) {
+		_modifiedState = true;
+	}
+	if ( actionTrait_ & MOVE_CURSOR ) {
+		_modifiedState = ( _pos != _oldPos ) && (
+			( _pos == _data.length() )
+			|| ( _oldPos == _data.length() )
+			|| ( ( _pos < _data.length() ) && strchr( "{}[]()", _data[_pos] ) )
+			|| ( ( _oldPos < _data.length() ) && strchr( "{}[]()", _data[_oldPos] ) )
+		);
+		_moveCursor = _pos != _oldPos;
+	}
+	return ( res );
+}
+
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::insert_character( char32_t c ) {
+	/*
+	 * beep on unknown Ctrl and/or Meta keys
+	 * don't insert control characters
+	 */
+	if ( ( c >= static_cast<int>( Replxx::KEY::BASE ) ) || ( is_control_code( c ) && ( c != '\n' ) ) ) {
+		beep();
+		return ( Replxx::ACTION_RESULT::CONTINUE );
+	}
+	if ( ! _overwrite || ( _pos >= _data.length() ) ) {
+		_data.insert( _pos, c );
+	} else {
+		_data[_pos] = c;
+	}
+	++ _pos;
+	call_modify_callback();
+	int long long now( now_us() );
+	int long long duration( now - _lastRefreshTime );
+	if ( duration < RAPID_REFRESH_US ) {
+		_lastRefreshTime = now;
+		_refreshSkipped = true;
+		return ( Replxx::ACTION_RESULT::CONTINUE );
+	}
+	int xCursorPos( _prompt.indentation() );
+	int yCursorPos( 0 );
+	virtual_render( _data.get(), _data.length(), xCursorPos, yCursorPos );
+	if (
+		( _pos == _data.length() )
+		&& ! _modifiedState
+		&& ( _noColor || ! ( !! _highlighterCallback || !! _hintCallback ) )
+		&& ( yCursorPos == 0 )
+	) {
+		/* Avoid a full assign of the line in the
+		 * trivial case. */
+		render( c );
+		_displayInputLength = static_cast<int>( _display.size() );
+		_terminal.write32( reinterpret_cast<char32_t*>( &c ), 1 );
+	} else {
+		refresh_line();
+	}
+	_lastRefreshTime = now_us();
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// ctrl-J/linefeed/newline
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::new_line( char32_t ) {
+	return ( insert_character( '\n' ) );
+}
+
+// ctrl-A, HOME: move cursor to start of line
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::go_to_begining_of_line( char32_t char_ ) {
+	if ( _hasNewlines ) {
+		bool onNewline( ( _pos > 0 ) && ( _pos < _data.length() ) && ( _data[_pos] == '\n' ) );
+		int startPos( onNewline ? _pos - 1 : _pos );
+		int newPos( prev_newline_position( startPos ) + 1 );
+		_pos = ( newPos == _pos ) && ( char_ == Replxx::KEY::control( 'A' ) ) ? 0 : newPos;
+	} else {
+		_pos = 0;
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::go_to_end_of_line( char32_t char_ ) {
+	if ( _hasNewlines ) {
+		int newPos( next_newline_position( _pos ) );
+		_pos = ( newPos < 0 ) || ( ( newPos == _pos ) && ( char_ == Replxx::KEY::control( 'E' ) ) ) ? _data.length() : newPos;
+	} else {
+		_pos = _data.length();
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// ctrl-B, move cursor left by one character
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::move_one_char_left( char32_t ) {
+	if (_pos > 0) {
+		--_pos;
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// ctrl-F, move cursor right by one character
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::move_one_char_right( char32_t ) {
+	if ( _pos < _data.length() ) {
+		++_pos;
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// meta-B, move cursor left by one word
+template <bool subword>
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::move_one_word_left( char32_t ) {
+	if (_pos > 0) {
+		while (_pos > 0 && is_word_break_character<subword>( _data[_pos - 1] ) ) {
+			--_pos;
+		}
+		while (_pos > 0 && !is_word_break_character<subword>( _data[_pos - 1] ) ) {
+			--_pos;
+		}
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// meta-f, move cursor right by one word
+template <bool subword>
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::move_one_word_right( char32_t ) {
+	if ( _pos < _data.length() ) {
+		while ( _pos < _data.length() && is_word_break_character<subword>( _data[_pos] ) ) {
+			++_pos;
+		}
+		while ( _pos < _data.length() && !is_word_break_character<subword>( _data[_pos] ) ) {
+			++_pos;
+		}
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// meta-Backspace, kill word to left of cursor
+template <bool subword>
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::kill_word_to_left( char32_t ) {
+	if ( _pos > 0 ) {
+		int startingPos = _pos;
+		while ( _pos > 0 && is_word_break_character<subword>( _data[_pos - 1] ) ) {
+			-- _pos;
+		}
+		while ( _pos > 0 && !is_word_break_character<subword>( _data[_pos - 1] ) ) {
+			-- _pos;
+		}
+		_killRing.kill( _data.get() + _pos, startingPos - _pos, false);
+		_data.erase( _pos, startingPos - _pos );
+		refresh_line();
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// meta-D, kill word to right of cursor
+template <bool subword>
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::kill_word_to_right( char32_t ) {
+	if ( _pos < _data.length() ) {
+		int endingPos = _pos;
+		while ( endingPos < _data.length() && is_word_break_character<subword>( _data[endingPos] ) ) {
+			++ endingPos;
+		}
+		while ( endingPos < _data.length() && !is_word_break_character<subword>( _data[endingPos] ) ) {
+			++ endingPos;
+		}
+		_killRing.kill( _data.get() + _pos, endingPos - _pos, true );
+		_data.erase( _pos, endingPos - _pos );
+		refresh_line();
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// ctrl-W, kill to whitespace (not word) to left of cursor
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::kill_to_whitespace_to_left( char32_t ) {
+	if ( _pos > 0 ) {
+		int startingPos = _pos;
+		while ( ( _pos > 0 ) && isspace( _data[_pos - 1] ) ) {
+			--_pos;
+		}
+		while ( ( _pos > 0 ) && ! isspace( _data[_pos - 1] ) ) {
+			-- _pos;
+		}
+		_killRing.kill( _data.get() + _pos, startingPos - _pos, false );
+		_data.erase( _pos, startingPos - _pos );
+		refresh_line();
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// ctrl-K, kill from cursor to end of line
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::kill_to_end_of_line( char32_t ) {
+	int to( _data.length() );
+	if ( _hasNewlines ) {
+		to = next_newline_position( _pos );
+		if ( ( to < 0 ) || ( to == _pos ) ) {
+			to = _data.length();
+		}
+	}
+
+	_killRing.kill( _data.get() + _pos, to - _pos, true );
+	_data.erase( _pos, to - _pos );
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// ctrl-U, kill all characters to the left of the cursor
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::kill_to_begining_of_line( char32_t ) {
+	if (_pos <= 0) {
+		return ( Replxx::ACTION_RESULT::CONTINUE );
+	}
+	int newPos( 0 );
+	if ( _hasNewlines ) {
+		bool onNewline( ( _pos > 0 ) && ( _pos < _data.length() ) && ( _data[_pos] == '\n' ) );
+		int startPos( onNewline ? _pos - 1 : _pos );
+		newPos = prev_newline_position( startPos ) + 1;
+		if ( newPos == _pos ) {
+			newPos = 0;
+		}
+	}
+	_killRing.kill( _data.get() + newPos, _pos - newPos, false );
+	_data.erase( newPos, _pos - newPos );
+	_pos = newPos;
+	refresh_line();
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// ctrl-Y, yank killed text
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::yank( char32_t ) {
+	UnicodeString* restoredText( _killRing.yank() );
+	if ( restoredText ) {
+		_data.insert( _pos, *restoredText, 0, restoredText->length() );
+		_pos += restoredText->length();
+		refresh_line();
+		_killRing.lastAction = KillRing::actionYank;
+		_lastYankSize = restoredText->length();
+	} else {
+		beep();
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// meta-Y, "yank-pop", rotate popped text
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::yank_cycle( char32_t ) {
+	if ( _killRing.lastAction != KillRing::actionYank ) {
+		beep();
+		return ( Replxx::ACTION_RESULT::CONTINUE );
+	}
+	UnicodeString* restoredText = _killRing.yankPop();
+	if ( !restoredText ) {
+		beep();
+		return ( Replxx::ACTION_RESULT::CONTINUE );
+	}
+	_pos -= _lastYankSize;
+	_data.erase( _pos, _lastYankSize );
+	_data.insert( _pos, *restoredText, 0, restoredText->length() );
+	_pos += restoredText->length();
+	_lastYankSize = restoredText->length();
+	refresh_line();
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// meta-., "yank-last-arg", on consecutive uses move back in history for popped text
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::yank_last_arg( char32_t ) {
+	if ( _history.size() < 2 ) {
+		return ( Replxx::ACTION_RESULT::CONTINUE );
+	}
+	if ( _history.next_yank_position() ) {
+		_lastYankSize = 0;
+	}
+	UnicodeString const& histLine( _history.yank_line() );
+	int endPos( histLine.length() );
+	while ( ( endPos > 0 ) && isspace( histLine[endPos - 1] ) ) {
+		-- endPos;
+	}
+	int startPos( endPos );
+	while ( ( startPos > 0 ) && ! isspace( histLine[startPos - 1] ) ) {
+		-- startPos;
+	}
+	_pos -= _lastYankSize;
+	_data.erase( _pos, _lastYankSize );
+	_lastYankSize = endPos - startPos;
+	_data.insert( _pos, histLine, startPos, _lastYankSize );
+	_pos += _lastYankSize;
+	refresh_line();
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// meta-C, give word initial Cap
+template <bool subword>
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::capitalize_word( char32_t ) {
+	if (_pos < _data.length()) {
+		while ( _pos < _data.length() && is_word_break_character<subword>( _data[_pos] ) ) {
+			++_pos;
+		}
+		if (_pos < _data.length() && !is_word_break_character<subword>( _data[_pos] ) ) {
+			if ( iswlower( static_cast<wint_t>( _data[_pos] ) ) ) {
+				_data[_pos] = static_cast<char32_t>( towupper( static_cast<wint_t>( _data[_pos] ) ) );
+			}
+			++_pos;
+		}
+		while (_pos < _data.length() && !is_word_break_character<subword>( _data[_pos] ) ) {
+			if ( iswupper( static_cast<wint_t>( _data[_pos] ) ) ) {
+				_data[_pos] = static_cast<char32_t>( towlower( static_cast<wint_t>( _data[_pos] ) ) );
+			}
+			++_pos;
+		}
+		refresh_line();
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// meta-L, lowercase word
+template <bool subword>
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::lowercase_word( char32_t ) {
+	if (_pos < _data.length()) {
+		while ( _pos < _data.length() && is_word_break_character<subword>( _data[_pos] ) ) {
+			++ _pos;
+		}
+		while (_pos < _data.length() && !is_word_break_character<subword>( _data[_pos] ) ) {
+			if ( iswupper( static_cast<wint_t>( _data[_pos] ) ) ) {
+				_data[_pos] = static_cast<char32_t>( towlower( static_cast<wint_t>( _data[_pos] ) ) );
+			}
+			++ _pos;
+		}
+		refresh_line();
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// meta-U, uppercase word
+template <bool subword>
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::uppercase_word( char32_t ) {
+	if (_pos < _data.length()) {
+		while ( _pos < _data.length() && is_word_break_character<subword>( _data[_pos] ) ) {
+			++ _pos;
+		}
+		while ( _pos < _data.length() && !is_word_break_character<subword>( _data[_pos] ) ) {
+			if ( iswlower( static_cast<wint_t>( _data[_pos] ) ) ) {
+				_data[_pos] = static_cast<char32_t>( towupper( static_cast<wint_t>( _data[_pos] ) ) );
+			}
+			++ _pos;
+		}
+		refresh_line();
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// ctrl-T, transpose characters
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::transpose_characters( char32_t ) {
+	if ( _pos > 0 && _data.length() > 1 ) {
+		size_t leftCharPos = ( _pos == _data.length() ) ? _pos - 2 : _pos - 1;
+		char32_t aux = _data[leftCharPos];
+		_data[leftCharPos] = _data[leftCharPos + 1];
+		_data[leftCharPos + 1] = aux;
+		if ( _pos != _data.length() ) {
+			++_pos;
+		}
+		refresh_line();
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// ctrl-C, abort this line
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::abort_line( char32_t keyCode_ ) {
+	errno = EAGAIN;
+	_history.drop_last();
+	// we need one last refresh with the cursor at the end of the line
+	// so we don't display the next prompt over the previous input line
+	_pos = _data.length(); // pass _data.length() as _pos for EOL
+	_lastRefreshTime = 0;
+	refresh_line( _refreshSkipped ? HINT_ACTION::REGENERATE : HINT_ACTION::TRIM );
+	if ( keyCode_ == Replxx::KEY::control( 'C' ) ) {
+		_terminal.write8( "^C\r\n", 4 );
+	}
+	return ( Replxx::ACTION_RESULT::BAIL );
+}
+
+// DEL, delete the character under the cursor
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::delete_character( char32_t ) {
+	if ( ( _data.length() > 0 ) && ( _pos < _data.length() ) ) {
+		_data.erase( _pos );
+		refresh_line();
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// ctrl-D, delete the character under the cursor
+// on an empty line, exit the shell
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::send_eof( char32_t key_ ) {
+	if ( _data.length() == 0 ) {
+		_history.drop_last();
+		return ( Replxx::ACTION_RESULT::BAIL );
+	}
+	return ( delete_character( key_ ) );
+}
+
+// backspace/ctrl-H, delete char to left of cursor
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::backspace_character( char32_t ) {
+	if ( _pos > 0 ) {
+		-- _pos;
+		_data.erase( _pos );
+		refresh_line();
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// ctrl-M/return/enter, accept line
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::commit_line( char32_t ) {
+	// we need one last refresh with the cursor at the end of the line
+	// so we don't display the next prompt over the previous input line
+	_pos = _data.length(); // pass _data.length() as _pos for EOL
+	_lastRefreshTime = 0;
+	refresh_line( _refreshSkipped ? HINT_ACTION::REGENERATE : HINT_ACTION::TRIM );
+	_history.commit_index();
+	_history.drop_last();
+	return ( Replxx::ACTION_RESULT::RETURN );
+}
+
+int Replxx::ReplxxImpl::prev_newline_position( int pos_ ) const {
+	assert( ( pos_ >= -1 ) && ( pos_ <= _data.length() ) );
+	if ( pos_ == _data.length() ) {
+		-- pos_;
+	}
+	while ( pos_ >= 0 ) {
+		if ( _data[pos_] == '\n' ) {
+			break;
+		}
+		-- pos_;
+	}
+	return ( pos_ );
+}
+
+int Replxx::ReplxxImpl::next_newline_position( int pos_ ) const {
+	assert( ( pos_ >= 0 ) && ( pos_ <= _data.length() ) );
+	int len( _data.length() );
+	while ( pos_ < len ) {
+		if ( _data[pos_] == '\n' ) {
+			break;
+		}
+		++ pos_;
+	}
+	return ( pos_ < len ? pos_ : -1 );
+}
+
+int Replxx::ReplxxImpl::pos_in_line( void ) const {
+	if ( ! _hasNewlines ) {
+		return ( _pos );
+	}
+	int lineStart( prev_newline_position( _pos ) + 1 );
+	return ( _pos - lineStart );
+}
+
+// Up, recall previous line in history
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::line_previous( char32_t ) {
+	assert( ( _pos >= 0 ) && ( _pos <= _data.length() ) );
+	do {
+		if ( ! _hasNewlines ) {
+			break;
+		}
+		int prevNewlinePosition( prev_newline_position( _pos ) );
+		if ( prevNewlinePosition == _pos ) {
+			prevNewlinePosition = prev_newline_position( _pos - 1 );
+		}
+		if ( prevNewlinePosition < 0 ) {
+			break;
+		}
+		int posInLine( _pos - prevNewlinePosition - 1 );
+		int prevLineStart( prevNewlinePosition > 0 ? prev_newline_position( prevNewlinePosition - 1 ) + 1 : 0 );
+		int prevLineLength( max( prevNewlinePosition - prevLineStart, 0 ) );
+		int shift( ! _indentMultiline && ( prevLineStart == 0 ) ? _prompt.indentation() : 0 );
+		posInLine = max( min( posInLine, prevLineLength + shift ) - shift, 0 );
+		_pos = prevLineStart + posInLine;
+		assert( ( _pos >= 0 ) && ( _pos <= _data.length() ) );
+		return ( Replxx::ACTION_RESULT::CONTINUE );
+	} while ( false );
+	return ( history_move( true ) );
+}
+
+// Down, recall next line in history
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::line_next( char32_t ) {
+	assert( ( _pos >= 0 ) && ( _pos <= _data.length() ) );
+	do {
+		if ( ! _hasNewlines ) {
+			break;
+		}
+		int nextNewlinePosition( next_newline_position( _pos ) );
+		if ( nextNewlinePosition < 0 ) {
+			break;
+		}
+		int nextLineStart( nextNewlinePosition + 1 );
+		int nextLineEnd( next_newline_position( nextLineStart ) );
+		if ( nextLineEnd < 0 ) {
+			nextLineEnd = _data.length();
+		}
+		int nextLineLength( nextLineEnd - nextLineStart );
+		int prevNewlinePosition( prev_newline_position( _pos ) );
+		if ( prevNewlinePosition == _pos ) {
+			prevNewlinePosition = _pos > 0 ? prev_newline_position( _pos - 1 ) : -1;
+		}
+		int lineStartPosition( prevNewlinePosition + 1 );
+		int posInLine( _pos - lineStartPosition );
+		int shift( ! _indentMultiline && ( lineStartPosition == 0 ) ? _prompt.indentation() : 0 );
+		posInLine = max( min( posInLine + shift, nextLineLength ), 0 );
+		_pos = nextLineStart + posInLine;
+		assert( ( _pos >= 0 ) && ( _pos <= _data.length() ) );
+		return ( Replxx::ACTION_RESULT::CONTINUE );
+	} while ( false );
+	return ( history_move( false ) );
+}
+
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::history_next( char32_t ) {
+	return ( history_move( false ) );
+}
+
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::history_previous( char32_t ) {
+	return ( history_move( true ) );
+}
+
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::history_move( bool previous_ ) {
+	// if not already recalling, add the current line to the history list so
+	// we don't have to special case it
+	if ( _history.is_last() ) {
+		_history.update_last( _data );
+	}
+	if ( _history.is_empty() ) {
+		return ( Replxx::ACTION_RESULT::CONTINUE );
+	}
+	_history.set_current_scratch( _data );
+	if ( ! _history.move( previous_ ) ) {
+		return ( Replxx::ACTION_RESULT::CONTINUE );
+	}
+	_data.assign( _history.current() );
+	_pos = _data.length();
+	refresh_line( HINT_ACTION::REGENERATE, true /* refreshPrompt */ );
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// meta-<, beginning of history
+// Page Up, beginning of history
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::history_first( char32_t ) {
+	do {
+		if ( ! _hasNewlines ) {
+			break;
+		}
+		if ( _pos == 0 ) {
+			break;
+		}
+		_pos = 0;
+		return ( Replxx::ACTION_RESULT::CONTINUE );
+	} while ( false );
+	return ( history_jump( true ) );
+}
+
+// meta->, end of history
+// Page Down, end of history
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::history_last( char32_t ) {
+	do {
+		if ( ! _hasNewlines ) {
+			break;
+		}
+		if ( _pos == _data.length() ) {
+			break;
+		}
+		_pos = _data.length();
+		return ( Replxx::ACTION_RESULT::CONTINUE );
+	} while ( false );
+	return ( history_jump( false ) );
+}
+
+// CTRL-g, restore current history entry
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::history_restore_current( char32_t ) {
+	// if not already recalling, there is nothing to restore.
+	if ( ! _history.is_last() ) {
+		_history.reset_current_scratch();
+		_data.assign( _history.current() );
+		_pos = _data.length();
+		refresh_line();
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// meta-g restore all history entries
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::history_restore( char32_t ) {
+	_history.reset_scratches();
+	// if not already recalling, there is nothing to restore.
+	if ( ! _history.is_last() ) {
+		_data.assign( _history.current() );
+		_pos = _data.length();
+		refresh_line();
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::history_jump( bool back_ ) {
+	// if not already recalling, add the current line to the history list so
+	// we don't
+	// have to special case it
+	if ( _history.is_last() ) {
+		_history.update_last( _data );
+	}
+	if ( ! _history.is_empty() ) {
+		_history.set_current_scratch( _data );
+		_history.jump( back_ );
+		_data.assign( _history.current() );
+		_pos = _data.length();
+		refresh_line( HINT_ACTION::REGENERATE, true /* refreshPrompt */ );
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::hint_next( char32_t ) {
+	return ( hint_move( false ) );
+}
+
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::hint_previous( char32_t ) {
+	return ( hint_move( true ) );
+}
+
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::hint_move( bool previous_ ) {
+	if ( ! _noColor ) {
+		_killRing.lastAction = KillRing::actionOther;
+		if ( previous_ ) {
+			-- _hintSelection;
+		} else {
+			++ _hintSelection;
+		}
+		refresh_line( HINT_ACTION::REPAINT );
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::toggle_overwrite_mode( char32_t ) {
+	_overwrite = ! _overwrite;
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+#ifndef _WIN32
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::verbatim_insert( char32_t ) {
+	static int const MAX_ESC_SEQ( 32 );
+	char32_t buf[MAX_ESC_SEQ];
+	int len( _terminal.read_verbatim( buf, MAX_ESC_SEQ ) );
+	_data.insert( _pos, UnicodeString( buf, len ), 0, len );
+	_pos += len;
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// ctrl-Z, job control
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::suspend( char32_t ) {
+	/* IOModeGuard scope */ {
+		IOModeGuard ioModeGuard( _terminal );
+		raise( SIGSTOP );   // Break out in mid-line
+	}
+	// Redraw prompt
+	_prompt.write();
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+#endif
+
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::complete_line( char32_t c ) {
+	if ( !! _completionCallback && ( _completeOnEmpty || ( _pos > 0 ) ) ) {
+		// complete_line does the actual completion and replacement
+		c = do_complete_line( c != 0 );
+
+		if ( static_cast<int>( c ) < 0 ) {
+			return ( Replxx::ACTION_RESULT::BAIL );
+		}
+		if ( c != 0 ) {
+			emulate_key_press( c );
+		}
+	} else {
+		insert_character( c );
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::complete( bool previous_ ) {
+	if ( _completions.empty() ) {
+		bool first( _completions.empty() );
+		int dataLen( _data.length() );
+		complete_line( 0 );
+		if ( ! _immediateCompletion && first && ( _data.length() > dataLen ) ) {
+			return ( Replxx::ACTION_RESULT::CONTINUE );
+		}
+	}
+	int newSelection( _completionSelection + ( previous_ ? -1 : 1 ) );
+	if ( newSelection >= static_cast<int>( _completions.size() ) ) {
+		newSelection = -1;
+	} else if ( newSelection == -2 ) {
+		newSelection = static_cast<int>( _completions.size() ) - 1;
+	}
+	if ( _completionSelection != -1 ) {
+		int oldCompletionLength( max( _completions[_completionSelection].text().length() - _completionContextLength, 0 ) );
+		_pos -= oldCompletionLength;
+		_data.erase( _pos, oldCompletionLength );
+	}
+	if ( newSelection != -1 ) {
+		int newCompletionLength( max( _completions[newSelection].text().length() - _completionContextLength, 0 ) );
+		_data.insert( _pos, _completions[newSelection].text(), _completionContextLength, newCompletionLength );
+		_pos += newCompletionLength;
+	}
+	_completionSelection = newSelection;
+	refresh_line();  // Refresh the line
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::complete_next( char32_t ) {
+	return ( complete( false ) );
+}
+
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::complete_previous( char32_t ) {
+	return ( complete( true ) );
+}
+
+// Alt-P, reverse history search for prefix
+// Alt-P, reverse history search for prefix
+// Alt-N, forward history search for prefix
+// Alt-N, forward history search for prefix
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::common_prefix_search( char32_t startChar ) {
+	if (
+		_history.common_prefix_search(
+			_data, _prefix, ( startChar == ( Replxx::KEY::meta( 'p' ) ) ) || ( startChar == ( Replxx::KEY::meta( 'P' ) ) ), _ignoreCase
+		)
+	) {
+		_data.assign( _history.current() );
+		_pos = _data.length();
+		refresh_line();
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// ctrl-R, reverse history search
+// ctrl-S, forward history search
+/**
+ * Incremental history search -- take over the prompt and keyboard as the user
+ * types a search string, deletes characters from it, changes _direction,
+ * and either accepts the found line (for execution orediting) or cancels.
+ * @param startChar - the character that began the search, used to set the initial
+ * _direction
+ */
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::incremental_history_search( char32_t startChar ) {
+	// if not already recalling, add the current line to the history list so we
+	// don't have to special case it
+	if ( _history.is_last() ) {
+		_history.update_last( _data );
+	}
+	_history.save_pos();
+	int historyLinePosition( _pos );
+	clear_self_to_end_of_screen();
+
+	DynamicPrompt dp( _terminal, (startChar == Replxx::KEY::control('R')) ? -1 : 1 );
+
+	// draw user's text with our prompt
+	dynamic_refresh(_prompt, dp, _data.get(), _data.length(), historyLinePosition);
+
+	// loop until we get an exit character
+	char32_t c( 0 );
+	bool keepLooping = true;
+	bool useSearchedLine = true;
+	bool searchAgain = false;
+	UnicodeString activeHistoryLine;
+	while ( keepLooping ) {
+		c = read_char();
+
+		switch (c) {
+			// these characters keep the selected text but do not execute it
+			case Replxx::KEY::control('A'): // ctrl-A, move cursor to start of line
+			case Replxx::KEY::HOME:
+			case Replxx::KEY::control('B'): // ctrl-B, move cursor left by one character
+			case Replxx::KEY::LEFT:
+			case Replxx::KEY::meta( 'b' ): // meta-B, move cursor left by one word
+			case Replxx::KEY::meta( 'B' ):
+			case Replxx::KEY::control( Replxx::KEY::LEFT ):
+			case Replxx::KEY::meta( Replxx::KEY::LEFT ): // Emacs allows Meta, bash & readline don't
+			case Replxx::KEY::control('D'):
+			case Replxx::KEY::meta( 'd' ): // meta-D, kill word to right of cursor
+			case Replxx::KEY::meta( 'D' ):
+			case Replxx::KEY::control('E'): // ctrl-E, move cursor to end of line
+			case Replxx::KEY::END:
+			case Replxx::KEY::control('F'): // ctrl-F, move cursor right by one character
+			case Replxx::KEY::RIGHT:
+			case Replxx::KEY::meta( 'f' ): // meta-F, move cursor right by one word
+			case Replxx::KEY::meta( 'F' ):
+			case Replxx::KEY::control( Replxx::KEY::RIGHT ):
+			case Replxx::KEY::meta( Replxx::KEY::RIGHT ): // Emacs allows Meta, bash & readline don't
+			case Replxx::KEY::meta( Replxx::KEY::BACKSPACE ):
+			case Replxx::KEY::control('J'):
+			case Replxx::KEY::control('K'): // ctrl-K, kill from cursor to end of line
+			case Replxx::KEY::ENTER:
+			case Replxx::KEY::control('N'): // ctrl-N, recall next line in history
+			case Replxx::KEY::control('P'): // ctrl-P, recall previous line in history
+			case Replxx::KEY::DOWN:
+			case Replxx::KEY::UP:
+			case Replxx::KEY::control('T'): // ctrl-T, transpose characters
+			case Replxx::KEY::control('U'): // ctrl-U, kill all characters to the left of the cursor
+			case Replxx::KEY::control('W'):
+			case Replxx::KEY::meta( 'y' ): // meta-Y, "yank-pop", rotate popped text
+			case Replxx::KEY::meta( 'Y' ):
+			case 127:
+			case Replxx::KEY::DELETE:
+			case Replxx::KEY::meta( '<' ): // start of history
+			case Replxx::KEY::PAGE_UP:
+			case Replxx::KEY::meta( '>' ): // end of history
+			case Replxx::KEY::PAGE_DOWN: {
+				keepLooping = false;
+			} break;
+
+			// these characters revert the input line to its previous state
+			case Replxx::KEY::control('C'): // ctrl-C, abort this line
+			case Replxx::KEY::control('G'):
+			case Replxx::KEY::control('L'): { // ctrl-L, clear screen and redisplay line
+				keepLooping = false;
+				useSearchedLine = false;
+				if (c != Replxx::KEY::control('L')) {
+					c = -1; // ctrl-C and ctrl-G just abort the search and do nothing else
+				}
+			} break;
+
+			// these characters stay in search mode and assign the display
+			case Replxx::KEY::control('S'):
+			case Replxx::KEY::control('R'): {
+				if ( dp._searchText.length() == 0 ) { // if no current search text, recall previous text
+					if ( _previousSearchText.length() > 0 ) {
+						dp._searchText = _previousSearchText;
+					}
+				}
+				if (
+					( ( dp._direction == 1 ) && ( c == Replxx::KEY::control( 'R' ) ) )
+					|| ( ( dp._direction == -1 ) && ( c == Replxx::KEY::control( 'S' ) ) )
+				) {
+					dp._direction = 0 - dp._direction; // reverse direction
+					dp.updateSearchPrompt();           // change the prompt
+				} else {
+					searchAgain = true; // same direction, search again
+				}
+			} break;
+
+// job control is its own thing
+#ifndef _WIN32
+			case Replxx::KEY::control('Z'): { // ctrl-Z, job control
+				/* IOModeGuard scope */ {
+					IOModeGuard ioModeGuard( _terminal );
+					// Returning to Linux (whatever) shell, leave raw mode
+					// Break out in mid-line
+					// Back from Linux shell, re-enter raw mode
+					raise( SIGSTOP );
+				}
+				dynamic_refresh( dp, dp, activeHistoryLine.get(), activeHistoryLine.length(), historyLinePosition );
+				continue;
+			} break;
+#endif
+
+			// these characters assign the search string, and hence the selected input line
+			case Replxx::KEY::BACKSPACE: { // backspace/ctrl-H, delete char to left of cursor
+				if ( dp._searchText.length() > 0 ) {
+					dp._searchText.erase( dp._searchText.length() - 1 );
+					dp.updateSearchPrompt();
+					_history.restore_pos();
+					historyLinePosition = _pos;
+				} else {
+					beep();
+				}
+			} break;
+
+			case Replxx::KEY::control('Y'): { // ctrl-Y, yank killed text
+			} break;
+
+			default: {
+				if ( ! is_control_code( c ) && ( c < static_cast<int>( Replxx::KEY::BASE ) ) ) { // not an action character
+					dp._searchText.insert( dp._searchText.length(), c );
+					dp.updateSearchPrompt();
+				} else {
+					beep();
+				}
+			}
+		} // switch
+
+		// if we are staying in search mode, search now
+		if ( ! keepLooping ) {
+			break;
+		}
+		activeHistoryLine.assign( _history.current() );
+		if ( dp._searchText.length() > 0 ) {
+			bool found = false;
+			int lineSearchPos = historyLinePosition;
+			if ( searchAgain ) {
+				lineSearchPos += dp._direction;
+			}
+			searchAgain = false;
+			bool lowerCaseContext( std::none_of( dp._searchText.begin(), dp._searchText.end(), []( char32_t x ) { return iswupper( static_cast<wint_t>( x ) ); } ) );
+			while ( true ) {
+				while (
+					dp._direction < 0
+						? ( lineSearchPos >= 0 )
+						: ( ( lineSearchPos + dp._searchText.length() ) <= activeHistoryLine.length() )
+				) {
+					if (
+						( lineSearchPos >= 0 )
+						&& ( ( lineSearchPos + dp._searchText.length() ) <= activeHistoryLine.length() )
+						&& std::equal(
+							dp._searchText.begin(), dp._searchText.end(), activeHistoryLine.begin() + lineSearchPos,
+							_ignoreCase && lowerCaseContext ? case_insensitive_equal : case_sensitive_equal
+						)
+					) {
+						found = true;
+						break;
+					}
+					lineSearchPos += dp._direction;
+				}
+				if ( found ) {
+					historyLinePosition = lineSearchPos;
+					break;
+				} else if ( _history.move( dp._direction < 0 ) ) {
+					activeHistoryLine.assign( _history.current() );
+					lineSearchPos = ( dp._direction > 0 ) ? 0 : ( activeHistoryLine.length() - dp._searchText.length() );
+				} else {
+					historyLinePosition = _pos;
+					beep();
+					break;
+				}
+			} // while
+			if ( ! found ) {
+				_history.restore_pos();
+			}
+		} else {
+			_history.restore_pos();
+			historyLinePosition = _pos;
+		}
+		activeHistoryLine.assign( _history.current() );
+		dynamic_refresh( dp, dp, activeHistoryLine.get(), activeHistoryLine.length(), historyLinePosition ); // draw user's text with our prompt
+	} // while
+
+	// leaving history search, restore previous prompt, maybe make searched line
+	// current
+	Prompt pb( _terminal );
+	UnicodeString tempUnicode( &_prompt._text[_prompt._lastLinePosition], _prompt._text.length() - _prompt._lastLinePosition );
+	pb.set_text( tempUnicode );
+	pb.update_screen_columns();
+	if ( useSearchedLine && ( activeHistoryLine.length() > 0 ) ) {
+		_history.commit_index();
+		_data.assign( activeHistoryLine );
+		_pos = historyLinePosition;
+		_modifiedState = true;
+	} else if ( ! useSearchedLine ) {
+		_history.restore_pos();
+	}
+	dynamic_refresh(pb, _prompt, _data.get(), _data.length(), _pos); // redraw the original prompt with current input
+	_previousSearchText = dp._searchText; // save search text for possible reuse on ctrl-R ctrl-R
+	emulate_key_press( c ); // pass a character or -1 back to main loop
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+// ctrl-L, clear screen and redisplay line
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::clear_screen( char32_t c ) {
+	_terminal.clear_screen( Terminal::CLEAR_SCREEN::WHOLE );
+	if ( c ) {
+		_prompt.write();
+		_prompt._cursorRowOffset = _prompt._extraLines;
+		refresh_line();
+	}
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+Replxx::ACTION_RESULT Replxx::ReplxxImpl::bracketed_paste( char32_t ) {
+	static const UnicodeString BRACK_PASTE_SUFF( "\033[201~" );
+	static const int BRACK_PASTE_SLEN( BRACK_PASTE_SUFF.length() );
+	UnicodeString buf;
+	while ( char32_t c = read_unicode_character() ) {
+		if ( ( c == '\r' ) || ( c == KEY::control( 'M' ) ) ) {
+			c = '\n';
+		}
+		else if ( c == KEY::control( 'I' ) ) {
+			c = '\t';
+		}
+		buf.push_back( c );
+		if ( ( c == '~' ) && buf.ends_with( BRACK_PASTE_SUFF.begin(), BRACK_PASTE_SUFF.end() ) ) {
+			buf.erase( buf.length() - BRACK_PASTE_SLEN, BRACK_PASTE_SLEN );
+			break;
+		}
+	}
+	_data.insert( _pos, buf, 0, buf.length() );
+	_pos += buf.length();
+	return ( Replxx::ACTION_RESULT::CONTINUE );
+}
+
+template <bool subword>
+bool Replxx::ReplxxImpl::is_word_break_character( char32_t char_ ) const {
+	bool wbc( false );
+	if ( char_ < 128 ) {
+		wbc = strchr( subword ? _subwordBreakChars.c_str() : _wordBreakChars.c_str(), static_cast<char>( char_ ) ) != nullptr;
+	}
+	return ( wbc );
+}
+
+void Replxx::ReplxxImpl::history_add( std::string const& line ) {
+	_history.add( UnicodeString( line ) );
+}
+
+bool Replxx::ReplxxImpl::history_save( std::string const& filename ) {
+	return ( _history.save( filename, false ) );
+}
+
+void Replxx::ReplxxImpl::history_save( std::ostream& out ) {
+	_history.save( out );
+}
+
+bool Replxx::ReplxxImpl::history_sync( std::string const& filename ) {
+	return ( _history.save( filename, true ) );
+}
+
+bool Replxx::ReplxxImpl::history_load( std::string const& filename ) {
+	return ( _history.load( filename ) );
+}
+
+void Replxx::ReplxxImpl::history_load( std::istream& in ) {
+	_history.load( in );
+}
+
+void Replxx::ReplxxImpl::history_clear( void ) {
+	_history.clear();
+}
+
+int Replxx::ReplxxImpl::history_size( void ) const {
+	return ( _history.size() );
+}
+
+Replxx::HistoryScan::impl_t Replxx::ReplxxImpl::history_scan( void ) const {
+	return ( _history.scan() );
+}
+
+void Replxx::ReplxxImpl::set_modify_callback( Replxx::modify_callback_t const& fn ) {
+	_modifyCallback = fn;
+}
+
+void Replxx::ReplxxImpl::set_completion_callback( Replxx::completion_callback_t const& fn ) {
+	_completionCallback = fn;
+}
+
+void Replxx::ReplxxImpl::set_highlighter_callback( Replxx::highlighter_callback_t const& fn ) {
+	_highlighterCallback = fn;
+}
+
+void Replxx::ReplxxImpl::set_hint_callback( Replxx::hint_callback_t const& fn ) {
+	_hintCallback = fn;
+}
+
+void Replxx::ReplxxImpl::set_max_history_size( int len ) {
+	_history.set_max_size( len );
+}
+
+void Replxx::ReplxxImpl::set_completion_count_cutoff( int count ) {
+	_completionCountCutoff = count;
+}
+
+void Replxx::ReplxxImpl::set_max_hint_rows( int count ) {
+	_maxHintRows = count;
+}
+
+void Replxx::ReplxxImpl::set_hint_delay( int hintDelay_ ) {
+	_hintDelay = hintDelay_;
+}
+
+void Replxx::ReplxxImpl::set_word_break_characters( char const* wordBreakers ) {
+	_wordBreakChars = wordBreakers;
+}
+
+void Replxx::ReplxxImpl::set_subword_break_characters( char const* subwordBreakers ) {
+	_subwordBreakChars = subwordBreakers;
+}
+
+void Replxx::ReplxxImpl::set_double_tab_completion( bool val ) {
+	_doubleTabCompletion = val;
+}
+
+void Replxx::ReplxxImpl::set_complete_on_empty( bool val ) {
+	_completeOnEmpty = val;
+}
+
+void Replxx::ReplxxImpl::set_beep_on_ambiguous_completion( bool val ) {
+	_beepOnAmbiguousCompletion = val;
+}
+
+void Replxx::ReplxxImpl::set_immediate_completion( bool val ) {
+	_immediateCompletion = val;
+}
+
+void Replxx::ReplxxImpl::set_unique_history( bool val ) {
+	_history.set_unique( val );
+}
+
+void Replxx::ReplxxImpl::set_no_color( bool val ) {
+	_noColor = val;
+}
+
+void Replxx::ReplxxImpl::set_indent_multiline( bool val ) {
+	_indentMultiline = val;
+}
+
+/**
+ * Display the dynamic incremental search prompt and the current user input
+ * line.
+ * @param pi    Prompt struct holding information about the prompt and our
+ * screen position
+ * @param buf32 input buffer to be displayed
+ * @param len   count of characters in the buffer
+ * @param pos   current cursor position within the buffer (0 <= pos <= len)
+ */
+void Replxx::ReplxxImpl::dynamic_refresh(Prompt& oldPrompt, Prompt& newPrompt, char32_t* buf32, int len, int pos) {
+	clear_self_to_end_of_screen( &oldPrompt );
+	// calculate the position of the end of the prompt
+	int xEndOfPrompt( 0 );
+	int yEndOfPrompt( 0 );
+	replxx::virtual_render( newPrompt._text.get(), newPrompt._text.length(), xEndOfPrompt, yEndOfPrompt, newPrompt.screen_columns(), 0 );
+
+	// calculate the desired position of the cursor
+	int xCursorPos( xEndOfPrompt );
+	int yCursorPos( yEndOfPrompt );
+	virtual_render( buf32, pos, xCursorPos, yCursorPos, &newPrompt );
+
+	// calculate the position of the end of the input line
+	int xEndOfInput( xCursorPos );
+	int yEndOfInput( yCursorPos );
+	virtual_render( buf32 + pos, len - pos, xEndOfInput, yEndOfInput, &newPrompt );
+
+	// display the prompt
+	newPrompt.write();
+
+	// display the input line
+	_terminal.write32( buf32, len );
+
+#ifndef _WIN32
+	// we have to generate our own newline on line wrap
+	if ( ( xEndOfInput == 0 ) && ( yEndOfInput > 0 ) && ( len > 0 ) && ( buf32[len - 1] != '\n' ) ) {
+		_terminal.write8( "\n", 1 );
+	}
+#endif
+	// position the cursor
+	_terminal.jump_cursor(
+		xCursorPos, // 0-based on Win32
+		-( yEndOfInput - yCursorPos )
+	);
+	newPrompt._cursorRowOffset = newPrompt._extraLines + yCursorPos; // remember row for next pass
+}
+
+}
+
diff --git a/contrib/restricted/patched/replxx/src/replxx_impl.hxx b/contrib/restricted/patched/replxx/src/replxx_impl.hxx
new file mode 100644
index 0000000000..aa7cfae89e
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/replxx_impl.hxx
@@ -0,0 +1,304 @@
+/*
+ * Copyright (c) 2017-2018, Marcin Konarski (amok at codestation.org)
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef HAVE_REPLXX_REPLXX_IMPL_HXX_INCLUDED
+#define HAVE_REPLXX_REPLXX_IMPL_HXX_INCLUDED 1
+
+#include <vector>
+#include <deque>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <thread>
+#include <mutex>
+#include <chrono>
+#include <iosfwd>
+
+#include "replxx.hxx"
+#include "history.hxx"
+#include "killring.hxx"
+#include "utf8string.hxx"
+#include "prompt.hxx"
+
+namespace replxx {
+
+class Replxx::ReplxxImpl {
+public:
+	class Completion {
+		UnicodeString _text;
+		Replxx::Color _color;
+	public:
+		Completion( UnicodeString const& text_, Replxx::Color color_ )
+			: _text( text_ )
+			, _color( color_ ) {
+		}
+		Completion( Replxx::Completion const& completion_ )
+			: _text( completion_.text() )
+			, _color( completion_.color() ) {
+		}
+		Completion( Completion const& ) = default;
+		Completion& operator = ( Completion const& ) = default;
+		Completion( Completion&& ) = default;
+		Completion& operator = ( Completion&& ) = default;
+		UnicodeString const& text( void ) const {
+			return ( _text );
+		}
+		Replxx::Color color( void ) const {
+			return ( _color );
+		}
+	};
+	typedef std::vector<Completion> completions_t;
+	typedef std::vector<UnicodeString> data_t;
+	typedef std::vector<UnicodeString> hints_t;
+	typedef std::unique_ptr<char[]> utf8_buffer_t;
+	typedef std::unique_ptr<char32_t[]> input_buffer_t;
+	typedef std::vector<char32_t> display_t;
+	typedef std::deque<char32_t> key_presses_t;
+	typedef std::deque<std::string> messages_t;
+	enum class HINT_ACTION {
+		REGENERATE,
+		REPAINT,
+		TRIM,
+		SKIP
+	};
+	typedef std::unordered_map<std::string, Replxx::key_press_handler_t> named_actions_t;
+	typedef Replxx::ACTION_RESULT ( ReplxxImpl::* key_press_handler_raw_t )( char32_t );
+	typedef std::unordered_map<int, Replxx::key_press_handler_t> key_press_handlers_t;
+private:
+	typedef int long long unsigned action_trait_t;
+	static action_trait_t const NOOP                       =   0;
+	static action_trait_t const WANT_REFRESH               =   1;
+	static action_trait_t const MOVE_CURSOR                =   2;
+	static action_trait_t const RESET_KILL_ACTION          =   4;
+	static action_trait_t const SET_KILL_ACTION            =   8;
+	static action_trait_t const DONT_RESET_PREFIX          =  16;
+	static action_trait_t const DONT_RESET_COMPLETIONS     =  32;
+	static action_trait_t const HISTORY_RECALL_MOST_RECENT =  64;
+	static action_trait_t const DONT_RESET_HIST_YANK_INDEX = 128;
+private:
+	mutable Utf8String     _utf8Buffer;
+	UnicodeString  _data;
+	int _pos;    // character position in buffer ( 0 <= _pos <= _data[_line].length() )
+	display_t      _display;
+	int _displayInputLength;
+	UnicodeString  _hint;
+	int _prefix; // prefix length used in common prefix search
+	int _hintSelection; // Currently selected hint.
+	History _history;
+	KillRing _killRing;
+	int long long _lastRefreshTime;
+	bool _refreshSkipped;
+	int _lastYankSize;
+	int _maxHintRows;
+	int _hintDelay;
+	std::string _wordBreakChars;
+	std::string _subwordBreakChars;
+	int _completionCountCutoff;
+	bool _overwrite;
+	bool _doubleTabCompletion;
+	bool _completeOnEmpty;
+	bool _beepOnAmbiguousCompletion;
+	bool _immediateCompletion;
+	bool _bracketedPaste;
+	bool _noColor;
+	bool _indentMultiline;
+	named_actions_t _namedActions;
+	key_press_handlers_t _keyPressHandlers;
+	Terminal _terminal;
+	std::thread::id _currentThread;
+	Prompt _prompt;
+	Replxx::modify_callback_t _modifyCallback;
+	Replxx::completion_callback_t _completionCallback;
+	Replxx::highlighter_callback_t _highlighterCallback;
+	Replxx::hint_callback_t _hintCallback;
+	key_presses_t _keyPresses;
+	messages_t _messages;
+	std::string _asyncPrompt;
+	bool _updatePrompt;
+	completions_t _completions;
+	int _completionContextLength;
+	int _completionSelection;
+	std::string _preloadedBuffer; // used with set_preload_buffer
+	std::string _errorMessage;
+	UnicodeString _previousSearchText; // remembered across invocations of replxx_input()
+	bool _modifiedState;
+	Replxx::Color _hintColor;
+	hints_t _hintsCache;
+	int _hintContextLenght;
+	Utf8String _hintSeed;
+	bool _hasNewlines;
+	int _oldPos;
+	bool _moveCursor;
+	bool _ignoreCase;
+	mutable std::mutex _mutex;
+public:
+	ReplxxImpl( FILE*, FILE*, FILE* );
+	virtual ~ReplxxImpl( void );
+	void set_modify_callback( Replxx::modify_callback_t const& fn );
+	void set_completion_callback( Replxx::completion_callback_t const& fn );
+	void set_highlighter_callback( Replxx::highlighter_callback_t const& fn );
+	void set_hint_callback( Replxx::hint_callback_t const& fn );
+	char const* input( std::string const& prompt );
+	void history_add( std::string const& line );
+	bool history_sync( std::string const& filename );
+	bool history_save( std::string const& filename );
+	void history_save( std::ostream& out );
+	bool history_load( std::string const& filename );
+	void history_load( std::istream& in );
+	void history_clear( void );
+	Replxx::HistoryScan::impl_t history_scan( void ) const;
+	int history_size( void ) const;
+	void set_preload_buffer(std::string const& preloadText);
+	void set_word_break_characters( char const* wordBreakers );
+	void set_subword_break_characters( char const* subwordBreakers );
+	void set_max_hint_rows( int count );
+	void set_hint_delay( int milliseconds );
+	void set_double_tab_completion( bool val );
+	void set_complete_on_empty( bool val );
+	void set_beep_on_ambiguous_completion( bool val );
+	void set_immediate_completion( bool val );
+	void set_unique_history( bool );
+	void set_no_color( bool val );
+	void set_indent_multiline( bool val );
+	void set_max_history_size( int len );
+	void set_completion_count_cutoff( int len );
+	int install_window_change_handler( void );
+	void enable_bracketed_paste( void );
+	void disable_bracketed_paste( void );
+	void print( char const*, int );
+	void set_prompt( std::string prompt );
+	Replxx::ACTION_RESULT clear_screen( char32_t );
+	void emulate_key_press( char32_t );
+	Replxx::ACTION_RESULT invoke( Replxx::ACTION, char32_t );
+	void bind_key( char32_t, Replxx::key_press_handler_t );
+	void bind_key_internal( char32_t, char const* );
+	Replxx::State get_state( void ) const;
+	void set_state( Replxx::State const& );
+	void set_ignore_case( bool val );
+private:
+	ReplxxImpl( ReplxxImpl const& ) = delete;
+	ReplxxImpl& operator = ( ReplxxImpl const& ) = delete;
+private:
+	void preload_puffer( char const* preloadText );
+	int get_input_line( void );
+	Replxx::ACTION_RESULT action( action_trait_t, key_press_handler_raw_t const&, char32_t );
+	Replxx::ACTION_RESULT insert_character( char32_t );
+	Replxx::ACTION_RESULT new_line( char32_t );
+	Replxx::ACTION_RESULT go_to_begining_of_line( char32_t );
+	Replxx::ACTION_RESULT go_to_end_of_line( char32_t );
+	Replxx::ACTION_RESULT move_one_char_left( char32_t );
+	Replxx::ACTION_RESULT move_one_char_right( char32_t );
+	template <bool subword>
+	Replxx::ACTION_RESULT move_one_word_left( char32_t );
+	template <bool subword>
+	Replxx::ACTION_RESULT move_one_word_right( char32_t );
+	template <bool subword>
+	Replxx::ACTION_RESULT kill_word_to_left( char32_t );
+	template <bool subword>
+	Replxx::ACTION_RESULT kill_word_to_right( char32_t );
+	Replxx::ACTION_RESULT kill_to_whitespace_to_left( char32_t );
+	Replxx::ACTION_RESULT kill_to_begining_of_line( char32_t );
+	Replxx::ACTION_RESULT kill_to_end_of_line( char32_t );
+	Replxx::ACTION_RESULT yank( char32_t );
+	Replxx::ACTION_RESULT yank_cycle( char32_t );
+	Replxx::ACTION_RESULT yank_last_arg( char32_t );
+	template <bool subword>
+	Replxx::ACTION_RESULT capitalize_word( char32_t );
+	template <bool subword>
+	Replxx::ACTION_RESULT lowercase_word( char32_t );
+	template <bool subword>
+	Replxx::ACTION_RESULT uppercase_word( char32_t );
+	Replxx::ACTION_RESULT transpose_characters( char32_t );
+	Replxx::ACTION_RESULT abort_line( char32_t );
+	Replxx::ACTION_RESULT send_eof( char32_t );
+	Replxx::ACTION_RESULT delete_character( char32_t );
+	Replxx::ACTION_RESULT backspace_character( char32_t );
+	Replxx::ACTION_RESULT commit_line( char32_t );
+	Replxx::ACTION_RESULT line_next( char32_t );
+	Replxx::ACTION_RESULT line_previous( char32_t );
+	Replxx::ACTION_RESULT history_next( char32_t );
+	Replxx::ACTION_RESULT history_previous( char32_t );
+	Replxx::ACTION_RESULT history_move( bool );
+	Replxx::ACTION_RESULT history_first( char32_t );
+	Replxx::ACTION_RESULT history_last( char32_t );
+	Replxx::ACTION_RESULT history_restore( char32_t );
+	Replxx::ACTION_RESULT history_restore_current( char32_t );
+	Replxx::ACTION_RESULT history_jump( bool );
+	Replxx::ACTION_RESULT hint_next( char32_t );
+	Replxx::ACTION_RESULT hint_previous( char32_t );
+	Replxx::ACTION_RESULT hint_move( bool );
+	Replxx::ACTION_RESULT toggle_overwrite_mode( char32_t );
+#ifndef _WIN32
+	Replxx::ACTION_RESULT verbatim_insert( char32_t );
+	Replxx::ACTION_RESULT suspend( char32_t );
+#endif
+	Replxx::ACTION_RESULT complete_line( char32_t );
+	Replxx::ACTION_RESULT complete_next( char32_t );
+	Replxx::ACTION_RESULT complete_previous( char32_t );
+	Replxx::ACTION_RESULT complete( bool );
+	Replxx::ACTION_RESULT incremental_history_search( char32_t startChar );
+	Replxx::ACTION_RESULT common_prefix_search( char32_t startChar );
+	Replxx::ACTION_RESULT bracketed_paste( char32_t startChar );
+	char32_t read_char( HINT_ACTION = HINT_ACTION::SKIP );
+	char const* read_from_stdin( void );
+	char32_t do_complete_line( bool );
+	void call_modify_callback( void );
+	completions_t call_completer( std::string const& input, int& ) const;
+	hints_t call_hinter( std::string const& input, int&, Replxx::Color& color ) const;
+	void refresh_line( HINT_ACTION = HINT_ACTION::REGENERATE, bool refreshPrompt_ = false );
+	void move_cursor( void );
+	void indent( void );
+	int virtual_render( char32_t const*, int, int&, int&, Prompt const* = nullptr );
+	void render( char32_t );
+	void render( HINT_ACTION );
+	void handle_hints( HINT_ACTION );
+	void set_color( Replxx::Color );
+	int context_length( void );
+	int prev_newline_position( int ) const;
+	int next_newline_position( int ) const;
+	int pos_in_line( void ) const;
+	void clear( void );
+	void repaint( void );
+	template <bool subword>
+	bool is_word_break_character( char32_t ) const;
+	void dynamic_refresh(Prompt& oldPrompt, Prompt& newPrompt, char32_t* buf32, int len, int pos);
+	char const* finalize_input( char const* );
+	void clear_self_to_end_of_screen( Prompt const* = nullptr );
+	typedef struct {
+		int index;
+		bool error;
+	} paren_info_t;
+	paren_info_t matching_paren( void );
+};
+
+}
+
+#endif
+
diff --git a/contrib/restricted/patched/replxx/src/terminal.cxx b/contrib/restricted/patched/replxx/src/terminal.cxx
new file mode 100644
index 0000000000..d737edf78d
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/terminal.cxx
@@ -0,0 +1,781 @@
+#include <memory>
+#include <cerrno>
+#include <cstdlib>
+#include <cstring>
+#include <array>
+#include <stdexcept>
+
+#ifdef _WIN32
+
+#include <conio.h>
+#include <windows.h>
+#include <io.h>
+#define isatty _isatty
+#define strcasecmp _stricmp
+#define strdup _strdup
+#define write _write
+#define STDIN_FILENO 0
+
+#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
+static DWORD const ENABLE_VIRTUAL_TERMINAL_PROCESSING = 4;
+#endif
+
+#include "windows.hxx"
+
+#else /* _WIN32 */
+
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/select.h>
+#include <fcntl.h>
+#include <signal.h>
+
+#endif /* _WIN32 */
+
+#include "terminal.hxx"
+#include "conversion.hxx"
+#include "escape.hxx"
+#include "replxx.hxx"
+#include "util.hxx"
+
+using namespace std;
+
+namespace replxx {
+
+namespace tty {
+
+bool is_a_tty( int fd_ ) {
+	bool aTTY( isatty( fd_ ) != 0 );
+#ifdef _WIN32
+	do {
+		if ( aTTY ) {
+			break;
+		}
+		HANDLE h( (HANDLE)_get_osfhandle( fd_ ) );
+		if ( h == INVALID_HANDLE_VALUE ) {
+			break;
+		}
+		DWORD st( 0 );
+		if ( ! GetConsoleMode( h, &st ) ) {
+			break;
+		}
+		aTTY = true;
+	} while ( false );
+#endif
+	return ( aTTY );
+}
+
+bool in( is_a_tty( 0 ) );
+bool out( is_a_tty( 1 ) );
+
+}
+
+#ifndef _WIN32
+Terminal* _terminal_ = nullptr;
+static void WindowSizeChanged( int ) {
+	if ( ! _terminal_ ) {
+		return;
+	}
+	_terminal_->notify_event( Terminal::EVENT_TYPE::RESIZE );
+}
+#endif
+
+
+Terminal::Terminal( void )
+#ifdef _WIN32
+	: _consoleOut( INVALID_HANDLE_VALUE )
+	, _consoleIn( INVALID_HANDLE_VALUE )
+	, _origOutMode()
+	, _origInMode()
+	, _oldDisplayAttribute()
+	, _inputCodePage( GetConsoleCP() )
+	, _outputCodePage( GetConsoleOutputCP() )
+	, _interrupt( INVALID_HANDLE_VALUE )
+	, _events()
+	, _empty()
+#else
+	: _origTermios()
+	, _rawModeTermios()
+	, _interrupt()
+#endif
+	, _rawMode( false )
+	, _utf8() {
+#ifdef _WIN32
+	_interrupt = CreateEvent( nullptr, true, false, TEXT( "replxx_interrupt_event" ) );
+#else
+	static_cast<void>( ::pipe( _interrupt ) == 0 );
+#endif
+}
+
+Terminal::~Terminal( void ) {
+	if ( _rawMode ) {
+		disable_raw_mode();
+	}
+#ifdef _WIN32
+	CloseHandle( _interrupt );
+#else
+	static_cast<void>( ::close( _interrupt[0] ) == 0 );
+	static_cast<void>( ::close( _interrupt[1] ) == 0 );
+#endif
+}
+
+void Terminal::write32( char32_t const* text32, int len32 ) {
+	_utf8.assign( text32, len32 );
+	write8( _utf8.get(), _utf8.size() );
+	return;
+}
+
+void Terminal::write8( char const* data_, int size_ ) {
+#ifdef _WIN32
+	bool temporarilyEnabled( false );
+	if ( _consoleOut == INVALID_HANDLE_VALUE ) {
+		enable_out();
+		temporarilyEnabled = true;
+	}
+	int nWritten( win_write( _consoleOut, _autoEscape, data_, size_ ) );
+	if ( temporarilyEnabled ) {
+		disable_out();
+	}
+#else
+	int nWritten( write( 1, data_, size_ ) );
+#endif
+	if ( nWritten != size_ ) {
+		throw std::runtime_error( "write failed" );
+	}
+	return;
+}
+
+int Terminal::get_screen_columns( void ) {
+	int cols( 0 );
+#ifdef _WIN32
+	CONSOLE_SCREEN_BUFFER_INFO inf;
+	GetConsoleScreenBufferInfo( _consoleOut, &inf );
+	cols = inf.dwSize.X;
+#else
+	struct winsize ws;
+	cols = ( ioctl( 1, TIOCGWINSZ, &ws ) == -1 ) ? 80 : ws.ws_col;
+#endif
+	// cols is 0 in certain circumstances like inside debugger, which creates
+	// further issues
+	return ( cols > 0 ) ? cols : 80;
+}
+
+int Terminal::get_screen_rows( void ) {
+	int rows;
+#ifdef _WIN32
+	CONSOLE_SCREEN_BUFFER_INFO inf;
+	GetConsoleScreenBufferInfo( _consoleOut, &inf );
+	rows = 1 + inf.srWindow.Bottom - inf.srWindow.Top;
+#else
+	struct winsize ws;
+	rows = (ioctl(1, TIOCGWINSZ, &ws) == -1) ? 24 : ws.ws_row;
+#endif
+	return (rows > 0) ? rows : 24;
+}
+
+namespace {
+inline int notty( void ) {
+	errno = ENOTTY;
+	return ( -1 );
+}
+}
+
+void Terminal::enable_out( void ) {
+#ifdef _WIN32
+	SetConsoleOutputCP( 65001 );
+	_consoleOut = GetStdHandle( STD_OUTPUT_HANDLE );
+	GetConsoleMode( _consoleOut, &_origOutMode );
+	_autoEscape = SetConsoleMode( _consoleOut, _origOutMode | ENABLE_VIRTUAL_TERMINAL_PROCESSING ) != 0;
+#endif
+}
+
+void Terminal::disable_out( void ) {
+#ifdef _WIN32
+	SetConsoleMode( _consoleOut, _origOutMode );
+	SetConsoleOutputCP( _outputCodePage );
+	_consoleOut = INVALID_HANDLE_VALUE;
+	_autoEscape = false;
+#endif
+}
+
+void Terminal::enable_bracketed_paste( void ) {
+	static char const  BRACK_PASTE_INIT[] = "\033[?2004h";
+	write8( BRACK_PASTE_INIT, sizeof ( BRACK_PASTE_INIT ) - 1 );
+}
+
+void Terminal::disable_bracketed_paste( void ) {
+	static char const  BRACK_PASTE_DISABLE[] = "\033[?2004l";
+	write8( BRACK_PASTE_DISABLE, sizeof ( BRACK_PASTE_DISABLE ) - 1 );
+}
+
+int Terminal::enable_raw_mode( void ) {
+	if ( _rawMode ) {
+		return ( 0 );
+	}
+#ifdef _WIN32
+	_consoleIn = GetStdHandle( STD_INPUT_HANDLE );
+	GetConsoleMode( _consoleIn, &_origInMode );
+#else
+
+	if ( ! tty::in ) {
+		return ( notty() );
+	}
+	if ( tcgetattr( 0, &_origTermios ) == -1 ) {
+		return ( notty() );
+	}
+
+	_rawModeTermios = _origTermios; /* modify the original mode */
+	/* input modes: no break, no CR to NL, no parity check, no strip char,
+	 * no start/stop output control. */
+	_rawModeTermios.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
+	/* output modes - disable post processing */
+	// this is wrong, we don't want _rawModeTermios output, it turns newlines into straight
+	// linefeeds
+	// _rawModeTermios.c_oflag &= ~(OPOST);
+	/* control modes - set 8 bit chars */
+	_rawModeTermios.c_cflag |= (CS8);
+	/* local modes - echoing off, canonical off, no extended functions,
+	 * no signal chars (^Z,^C) */
+	_rawModeTermios.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
+	/* control chars - set return condition: min number of bytes and timer.
+	 * We want read to return every single byte, without timeout. */
+	_rawModeTermios.c_cc[VMIN] = 1;
+	_rawModeTermios.c_cc[VTIME] = 0; /* 1 byte, no timer */
+
+#endif
+
+	_rawMode = true;
+	if ( reset_raw_mode() < 0 ) {
+		_rawMode = false;
+		return ( notty() );
+	}
+
+#ifndef _WIN32
+	_terminal_ = this;
+#endif
+	return ( 0 );
+}
+
+int Terminal::reset_raw_mode( void ) {
+	if ( ! _rawMode ) {
+		return ( -1 );
+	}
+#ifdef _WIN32
+	SetConsoleMode(
+		_consoleIn,
+		( _origInMode & ~( ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT | ENABLE_PROCESSED_INPUT ) ) | ENABLE_QUICK_EDIT_MODE 
+	);
+	SetConsoleCP( 65001 );
+	enable_out();
+	return ( 0 );
+#else
+	/* put terminal in raw mode after flushing */
+	return ( tcsetattr( 0, TCSADRAIN, &_rawModeTermios ) );
+#endif
+}
+
+void Terminal::disable_raw_mode(void) {
+	if ( ! _rawMode ) {
+		return;
+	}
+#ifdef _WIN32
+	disable_out();
+	SetConsoleMode( _consoleIn, _origInMode );
+	SetConsoleCP( _inputCodePage );
+	_consoleIn = INVALID_HANDLE_VALUE;
+#else
+	_terminal_ = nullptr;
+	if ( tcsetattr( 0, TCSADRAIN, &_origTermios ) == -1 ) {
+		return;
+	}
+#endif
+	_rawMode = false;
+	return;
+}
+
+#ifndef _WIN32
+
+/**
+ * Read a UTF-8 sequence from the non-Windows keyboard and return the Unicode
+ * (char32_t) character it encodes
+ *
+ * @return char32_t Unicode character
+ */
+char32_t read_unicode_character(void) {
+	static char8_t utf8String[5];
+	static size_t utf8Count = 0;
+	while (true) {
+		char8_t c;
+
+		/* Continue reading if interrupted by signal. */
+		ssize_t nread;
+		do {
+			nread = read( STDIN_FILENO, &c, 1 );
+		} while ((nread == -1) && (errno == EINTR));
+
+		if (nread <= 0) return 0;
+		if (c <= 0x7F || locale::is8BitEncoding) { // short circuit ASCII
+			utf8Count = 0;
+			return c;
+		} else if (utf8Count < sizeof(utf8String) - 1) {
+			utf8String[utf8Count++] = c;
+			utf8String[utf8Count] = 0;
+			char32_t unicodeChar[2];
+			int ucharCount( 0 );
+			ConversionResult res = copyString8to32(unicodeChar, 2, ucharCount, utf8String);
+			if (res == conversionOK && ucharCount) {
+				utf8Count = 0;
+				return unicodeChar[0];
+			}
+		} else {
+			utf8Count = 0; // this shouldn't happen: got four bytes but no UTF-8 character
+		}
+	}
+}
+
+#endif // #ifndef _WIN32
+
+void beep() {
+	fprintf(stderr, "\x7");	// ctrl-G == bell/beep
+	fflush(stderr);
+}
+
+// replxx_read_char -- read a keystroke or keychord from the keyboard, and translate it
+// into an encoded "keystroke".	When convenient, extended keys are translated into their
+// simpler Emacs keystrokes, so an unmodified "left arrow" becomes Ctrl-B.
+//
+// A return value of zero means "no input available", and a return value of -1
+// means "invalid key".
+//
+char32_t Terminal::read_char( void ) {
+	char32_t c( 0 );
+#ifdef _WIN32
+	INPUT_RECORD rec;
+	DWORD count;
+	char32_t modifierKeys = 0;
+	bool escSeen = false;
+	int highSurrogate( 0 );
+	while (true) {
+		ReadConsoleInputW( _consoleIn, &rec, 1, &count );
+#if __REPLXX_DEBUG__	// helper for debugging keystrokes, display info in the debug "Output"
+		// window in the debugger
+		{
+			if ( rec.EventType == KEY_EVENT ) {
+				//if ( rec.Event.KeyEvent.uChar.UnicodeChar ) {
+				char buf[1024];
+				sprintf(
+					buf,
+					"Unicode character 0x%04X, repeat count %d, virtual keycode 0x%04X, "
+					"virtual scancode 0x%04X, key %s%s%s%s%s\n",
+					rec.Event.KeyEvent.uChar.UnicodeChar,
+					rec.Event.KeyEvent.wRepeatCount,
+					rec.Event.KeyEvent.wVirtualKeyCode,
+					rec.Event.KeyEvent.wVirtualScanCode,
+					rec.Event.KeyEvent.bKeyDown ? "down" : "up",
+					(rec.Event.KeyEvent.dwControlKeyState & LEFT_CTRL_PRESSED) ? " L-Ctrl" : "",
+					(rec.Event.KeyEvent.dwControlKeyState & RIGHT_CTRL_PRESSED) ? " R-Ctrl" : "",
+					(rec.Event.KeyEvent.dwControlKeyState & LEFT_ALT_PRESSED) ? " L-Alt" : "",
+					(rec.Event.KeyEvent.dwControlKeyState & RIGHT_ALT_PRESSED) ? " R-Alt" : ""
+				);
+				OutputDebugStringA( buf );
+				//}
+			}
+		}
+#endif
+		if ( rec.EventType != KEY_EVENT ) {
+			continue;
+		}
+		// Windows provides for entry of characters that are not on your keyboard by sending the
+		// Unicode characters as a "key up" with virtual keycode 0x12 (VK_MENU == Alt key) ...
+		// accept these characters, otherwise only process characters on "key down"
+		if ( !rec.Event.KeyEvent.bKeyDown && ( rec.Event.KeyEvent.wVirtualKeyCode != VK_MENU ) ) {
+			continue;
+		}
+		modifierKeys = 0;
+		// AltGr is encoded as ( LEFT_CTRL_PRESSED | RIGHT_ALT_PRESSED ), so don't treat this
+		// combination as either CTRL or META we just turn off those two bits, so it is still
+		// possible to combine CTRL and/or META with an AltGr key by using right-Ctrl and/or
+		// left-Alt
+		DWORD const AltGr( LEFT_CTRL_PRESSED | RIGHT_ALT_PRESSED );
+		if ( ( rec.Event.KeyEvent.dwControlKeyState & AltGr ) == AltGr ) {
+			rec.Event.KeyEvent.dwControlKeyState &= ~( LEFT_CTRL_PRESSED | RIGHT_ALT_PRESSED );
+		}
+		if ( rec.Event.KeyEvent.dwControlKeyState & ( RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED ) ) {
+			modifierKeys |= Replxx::KEY::BASE_CONTROL;
+		}
+		if ( rec.Event.KeyEvent.dwControlKeyState & ( RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED ) ) {
+			modifierKeys |= Replxx::KEY::BASE_META;
+		}
+		if ( escSeen ) {
+			modifierKeys |= Replxx::KEY::BASE_META;
+		}
+		int key( rec.Event.KeyEvent.uChar.UnicodeChar );
+		if ( key == 0 ) {
+			if ( rec.Event.KeyEvent.dwControlKeyState & SHIFT_PRESSED ) {
+				modifierKeys |= Replxx::KEY::BASE_SHIFT;
+			}
+			switch ( rec.Event.KeyEvent.wVirtualKeyCode ) {
+				case VK_LEFT:
+					return modifierKeys | Replxx::KEY::LEFT;
+				case VK_RIGHT:
+					return modifierKeys | Replxx::KEY::RIGHT;
+				case VK_UP:
+					return modifierKeys | Replxx::KEY::UP;
+				case VK_DOWN:
+					return modifierKeys | Replxx::KEY::DOWN;
+				case VK_DELETE:
+					return modifierKeys | Replxx::KEY::DELETE;
+				case VK_HOME:
+					return modifierKeys | Replxx::KEY::HOME;
+				case VK_END:
+					return modifierKeys | Replxx::KEY::END;
+				case VK_PRIOR:
+					return modifierKeys | Replxx::KEY::PAGE_UP;
+				case VK_NEXT:
+					return modifierKeys | Replxx::KEY::PAGE_DOWN;
+				case VK_F1:
+					return modifierKeys | Replxx::KEY::F1;
+				case VK_F2:
+					return modifierKeys | Replxx::KEY::F2;
+				case VK_F3:
+					return modifierKeys | Replxx::KEY::F3;
+				case VK_F4:
+					return modifierKeys | Replxx::KEY::F4;
+				case VK_F5:
+					return modifierKeys | Replxx::KEY::F5;
+				case VK_F6:
+					return modifierKeys | Replxx::KEY::F6;
+				case VK_F7:
+					return modifierKeys | Replxx::KEY::F7;
+				case VK_F8:
+					return modifierKeys | Replxx::KEY::F8;
+				case VK_F9:
+					return modifierKeys | Replxx::KEY::F9;
+				case VK_F10:
+					return modifierKeys | Replxx::KEY::F10;
+				case VK_F11:
+					return modifierKeys | Replxx::KEY::F11;
+				case VK_F12:
+					return modifierKeys | Replxx::KEY::F12;
+				default:
+					continue; // in raw mode, ReadConsoleInput shows shift, ctrl - ignore them
+			}
+		} else if ( key == Replxx::KEY::ESCAPE ) { // ESC, set flag for later
+			escSeen = true;
+			continue;
+		} else if ( ( key >= 0xD800 ) && ( key <= 0xDBFF ) ) {
+			highSurrogate = key - 0xD800;
+			continue;
+		} else {
+			if ( ( key == 13 ) && ( rec.Event.KeyEvent.dwControlKeyState & SHIFT_PRESSED ) ) {
+				key = 10;
+			}
+			// we got a real character, return it
+			if ( ( key >= 0xDC00 ) && ( key <= 0xDFFF ) ) {
+				key -= 0xDC00;
+				key |= ( highSurrogate << 10 );
+				key += 0x10000;
+			}
+			if ( is_control_code( key ) ) {
+				key = control_to_human( key );
+				modifierKeys |= Replxx::KEY::BASE_CONTROL;
+			}
+			key |= modifierKeys;
+			highSurrogate = 0;
+			c = key;
+			break;
+		}
+	}
+
+#else
+	c = read_unicode_character();
+	if (c == 0) {
+		return 0;
+	}
+
+// If _DEBUG_LINUX_KEYBOARD is set, then ctrl-^ puts us into a keyboard
+// debugging mode
+// where we print out decimal and decoded values for whatever the "terminal"
+// program
+// gives us on different keystrokes.	Hit ctrl-C to exit this mode.
+//
+#ifdef __REPLXX_DEBUG__
+	if (c == ctrlChar('^')) {	// ctrl-^, special debug mode, prints all keys hit,
+														 // ctrl-C to get out
+		printf(
+				"\nEntering keyboard debugging mode (on ctrl-^), press ctrl-C to exit "
+				"this mode\n");
+		while (true) {
+			unsigned char keys[10];
+			int ret = read(0, keys, 10);
+
+			if (ret <= 0) {
+				printf("\nret: %d\n", ret);
+			}
+			for (int i = 0; i < ret; ++i) {
+				char32_t key = static_cast<char32_t>(keys[i]);
+				char* friendlyTextPtr;
+				char friendlyTextBuf[10];
+				const char* prefixText = (key < 0x80) ? "" : "0x80+";
+				char32_t keyCopy = (key < 0x80) ? key : key - 0x80;
+				if (keyCopy >= '!' && keyCopy <= '~') {	// printable
+					friendlyTextBuf[0] = '\'';
+					friendlyTextBuf[1] = keyCopy;
+					friendlyTextBuf[2] = '\'';
+					friendlyTextBuf[3] = 0;
+					friendlyTextPtr = friendlyTextBuf;
+				} else if (keyCopy == ' ') {
+					friendlyTextPtr = const_cast<char*>("space");
+				} else if (keyCopy == 27) {
+					friendlyTextPtr = const_cast<char*>("ESC");
+				} else if (keyCopy == 0) {
+					friendlyTextPtr = const_cast<char*>("NUL");
+				} else if (keyCopy == 127) {
+					friendlyTextPtr = const_cast<char*>("DEL");
+				} else {
+					friendlyTextBuf[0] = '^';
+					friendlyTextBuf[1] = control_to_human( keyCopy );
+					friendlyTextBuf[2] = 0;
+					friendlyTextPtr = friendlyTextBuf;
+				}
+				printf("%d x%02X (%s%s)	", key, key, prefixText, friendlyTextPtr);
+			}
+			printf("\x1b[1G\n");	// go to first column of new line
+
+			// drop out of this loop on ctrl-C
+			if (keys[0] == ctrlChar('C')) {
+				printf("Leaving keyboard debugging mode (on ctrl-C)\n");
+				fflush(stdout);
+				return -2;
+			}
+		}
+	}
+#endif // __REPLXX_DEBUG__
+
+	c = EscapeSequenceProcessing::doDispatch(c);
+	if ( is_control_code( c ) ) {
+		c = Replxx::KEY::control( control_to_human( c ) );
+	}
+#endif // #_WIN32
+	return ( c );
+}
+
+Terminal::EVENT_TYPE Terminal::wait_for_input( int long timeout_ ) {
+#ifdef _WIN32
+	std::array<HANDLE, 2> handles = { _consoleIn, _interrupt };
+	while ( true ) {
+		DWORD event( WaitForMultipleObjects( static_cast<DWORD>( handles.size() ), handles.data(), false, timeout_ > 0 ? timeout_ : INFINITE ) );
+		switch ( event ) {
+			case ( WAIT_OBJECT_0 + 0 ): {
+				// peek events that will be skipped
+				INPUT_RECORD rec;
+				DWORD count;
+				PeekConsoleInputW( _consoleIn, &rec, 1, &count );
+
+				if (
+					( rec.EventType != KEY_EVENT )
+					|| ( !rec.Event.KeyEvent.bKeyDown && ( rec.Event.KeyEvent.wVirtualKeyCode != VK_MENU ) )
+				) {
+					// read the event to unsignal the handle
+					ReadConsoleInputW( _consoleIn, &rec, 1, &count );
+					continue;
+				} else if ( rec.EventType == KEY_EVENT ) {
+					int key( rec.Event.KeyEvent.uChar.UnicodeChar );
+					if ( key == 0 ) {
+						switch ( rec.Event.KeyEvent.wVirtualKeyCode ) {
+							case VK_LEFT:
+							case VK_RIGHT:
+							case VK_UP:
+							case VK_DOWN:
+							case VK_DELETE:
+							case VK_HOME:
+							case VK_END:
+							case VK_PRIOR:
+							case VK_NEXT:
+							case VK_F1:
+							case VK_F2:
+							case VK_F3:
+							case VK_F4:
+							case VK_F5:
+							case VK_F6:
+							case VK_F7:
+							case VK_F8:
+							case VK_F9:
+							case VK_F10:
+							case VK_F11:
+							case VK_F12:
+							break;
+							default:
+								ReadConsoleInputW( _consoleIn, &rec, 1, &count );
+							continue; // in raw mode, ReadConsoleInput shows shift, ctrl - ignore them
+						}
+					}
+				}
+
+				return ( EVENT_TYPE::KEY_PRESS );
+			}
+			case ( WAIT_OBJECT_0 + 1 ): {
+				ResetEvent( _interrupt );
+				if ( _events.empty() ) {
+					continue;
+				}
+				EVENT_TYPE eventType( _events.front() );
+				_events.pop_front();
+				return ( eventType );
+			}
+			case ( WAIT_TIMEOUT ): {
+				return ( EVENT_TYPE::TIMEOUT );
+			}
+		}
+	}
+#else
+	fd_set fdSet;
+	int nfds( max( _interrupt[0], _interrupt[1] ) + 1 );
+	while ( true ) {
+		FD_ZERO( &fdSet );
+		FD_SET( 0, &fdSet );
+		FD_SET( _interrupt[0], &fdSet );
+		timeval tv{ timeout_ / 1000, static_cast<suseconds_t>( ( timeout_ % 1000 ) * 1000 ) };
+		int err( select( nfds, &fdSet, nullptr, nullptr, timeout_ > 0 ? &tv : nullptr ) );
+		if ( ( err == -1 ) && ( errno == EINTR ) ) {
+			continue;
+		}
+		if ( err == 0 ) {
+			return ( EVENT_TYPE::TIMEOUT );
+		}
+		if ( FD_ISSET( _interrupt[0], &fdSet ) ) {
+			char data( 0 );
+			static_cast<void>( read( _interrupt[0], &data, 1 ) == 1 );
+			if ( data == 'k' ) {
+				return ( EVENT_TYPE::KEY_PRESS );
+			}
+			if ( data == 'm' ) {
+				return ( EVENT_TYPE::MESSAGE );
+			}
+			if ( data == 'r' ) {
+				return ( EVENT_TYPE::RESIZE );
+			}
+		}
+		if ( FD_ISSET( 0, &fdSet ) ) {
+			return ( EVENT_TYPE::KEY_PRESS );
+		}
+	}
+#endif
+}
+
+void Terminal::notify_event( EVENT_TYPE eventType_ ) {
+#ifdef _WIN32
+	_events.push_back( eventType_ );
+	SetEvent( _interrupt );
+#else
+	char data( ( eventType_ == EVENT_TYPE::KEY_PRESS ) ? 'k' : ( eventType_ == EVENT_TYPE::MESSAGE ? 'm' : 'r' ) );
+	static_cast<void>( write( _interrupt[1], &data, 1 ) == 1 );
+#endif
+}
+
+/**
+ * Clear the screen ONLY (no redisplay of anything)
+ */
+void Terminal::clear_screen( CLEAR_SCREEN clearScreen_ ) {
+#ifdef _WIN32
+	if ( _autoEscape ) {
+#endif
+		if ( clearScreen_ == CLEAR_SCREEN::WHOLE ) {
+			char const clearCode[] = "\033c\033[H\033[2J\033[0m";
+			static_cast<void>( write(1, clearCode, sizeof ( clearCode ) - 1) >= 0 );
+		} else {
+			char const clearCode[] = "\033[J";
+			static_cast<void>( write(1, clearCode, sizeof ( clearCode ) - 1) >= 0 );
+		}
+		return;
+#ifdef _WIN32
+	}
+	COORD coord = { 0, 0 };
+	CONSOLE_SCREEN_BUFFER_INFO inf;
+	HANDLE consoleOut( _consoleOut != INVALID_HANDLE_VALUE ? _consoleOut : GetStdHandle( STD_OUTPUT_HANDLE ) );
+	GetConsoleScreenBufferInfo( consoleOut, &inf );
+	if ( clearScreen_ == CLEAR_SCREEN::TO_END ) {
+		coord = inf.dwCursorPosition;
+		DWORD nWritten( 0 );
+		SHORT height( inf.srWindow.Bottom - inf.srWindow.Top );
+		DWORD yPos( inf.dwCursorPosition.Y - inf.srWindow.Top );
+		DWORD toWrite( ( height + 1 - yPos ) * inf.dwSize.X - inf.dwCursorPosition.X );
+//		FillConsoleOutputCharacterA( consoleOut, ' ', toWrite, coord, &nWritten );
+		_empty.resize( toWrite - 1, ' ' );
+		WriteConsoleA( consoleOut, _empty.data(), toWrite - 1, &nWritten, nullptr );
+	} else {
+		COORD scrollTarget = { 0, static_cast<SHORT>( -inf.dwSize.Y ) };
+		CHAR_INFO fill{ TEXT( ' ' ), inf.wAttributes };
+		SMALL_RECT scrollRect = { 0, 0, inf.dwSize.X, inf.dwSize.Y };
+		ScrollConsoleScreenBuffer( consoleOut, &scrollRect, nullptr, scrollTarget, &fill );
+	}
+	SetConsoleCursorPosition( consoleOut, coord );
+#endif
+}
+
+void Terminal::jump_cursor( int xPos_, int yOffset_ ) {
+#ifdef _WIN32
+	CONSOLE_SCREEN_BUFFER_INFO inf;
+	GetConsoleScreenBufferInfo( _consoleOut, &inf );
+	inf.dwCursorPosition.X = xPos_;
+	inf.dwCursorPosition.Y += yOffset_;
+	SetConsoleCursorPosition( _consoleOut, inf.dwCursorPosition );
+#else
+	char seq[64];
+	if ( yOffset_ != 0 ) { // move the cursor up as required
+		snprintf( seq, sizeof seq, "\033[%d%c", abs( yOffset_ ), yOffset_ > 0 ? 'B' : 'A' );
+		write8( seq, strlen( seq ) );
+	}
+	// position at the end of the prompt, clear to end of screen
+	snprintf(
+		seq, sizeof seq, "\033[%dG",
+		xPos_ + 1 /* 1-based on VT100 */
+	);
+	write8( seq, strlen( seq ) );
+#endif
+}
+
+#ifdef _WIN32
+void Terminal::set_cursor_visible( bool visible_ ) {
+	CONSOLE_CURSOR_INFO     cursorInfo;
+	GetConsoleCursorInfo( _consoleOut, &cursorInfo );
+	cursorInfo.bVisible = visible_;
+	SetConsoleCursorInfo( _consoleOut, &cursorInfo );
+	return;
+}
+#else
+void Terminal::set_cursor_visible( bool ) {}
+#endif
+
+#ifndef _WIN32
+int Terminal::read_verbatim( char32_t* buffer_, int size_ ) {
+	int len( 0 );
+	buffer_[len ++] = read_unicode_character();
+	int statusFlags( ::fcntl( STDIN_FILENO, F_GETFL, 0 ) );
+	::fcntl( STDIN_FILENO, F_SETFL, statusFlags | O_NONBLOCK );
+	while ( len < size_ ) {
+		char32_t c( read_unicode_character() );
+		if ( c == 0 ) {
+			break;
+		}
+		buffer_[len ++] = c;
+	}
+	::fcntl( STDIN_FILENO, F_SETFL, statusFlags );
+	return ( len );
+}
+
+int Terminal::install_window_change_handler( void ) {
+	struct sigaction sa;
+	sigemptyset(&sa.sa_mask);
+	sa.sa_flags = 0;
+	sa.sa_handler = &WindowSizeChanged;
+
+	if (sigaction(SIGWINCH, &sa, nullptr) == -1) {
+		return errno;
+	}
+	return 0;
+}
+#endif
+
+}
+
diff --git a/contrib/restricted/patched/replxx/src/terminal.hxx b/contrib/restricted/patched/replxx/src/terminal.hxx
new file mode 100644
index 0000000000..90c3640b52
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/terminal.hxx
@@ -0,0 +1,96 @@
+#ifndef REPLXX_IO_HXX_INCLUDED
+#define REPLXX_IO_HXX_INCLUDED 1
+
+#include <deque>
+
+#ifdef _WIN32
+#include <vector>
+#include <windows.h>
+#else
+#include <termios.h>
+#endif
+
+#include "utf8string.hxx"
+
+namespace replxx {
+
+class Terminal {
+public:
+	enum class EVENT_TYPE {
+		KEY_PRESS,
+		MESSAGE,
+		TIMEOUT,
+		RESIZE
+	};
+private:
+#ifdef _WIN32
+	HANDLE _consoleOut;
+	HANDLE _consoleIn;
+	DWORD _origOutMode;
+	DWORD _origInMode;
+	bool _autoEscape;
+	WORD _oldDisplayAttribute;
+	UINT const _inputCodePage;
+	UINT const _outputCodePage;
+	HANDLE _interrupt;
+	typedef std::deque<EVENT_TYPE> events_t;
+	events_t _events;
+	std::vector<char> _empty;
+#else
+	struct termios _origTermios; /* in order to restore at exit */
+	struct termios _rawModeTermios; /* in order to reset raw mode after callbacks */
+	int _interrupt[2];
+#endif
+	bool _rawMode; /* for destructor to check if restore is needed */
+	Utf8String _utf8;
+public:
+	enum class CLEAR_SCREEN {
+		WHOLE,
+		TO_END
+	};
+public:
+	Terminal( void );
+	~Terminal( void );
+	void write32( char32_t const*, int );
+	void write8( char const*, int );
+	int get_screen_columns(void);
+	int get_screen_rows(void);
+	void enable_bracketed_paste( void );
+	void disable_bracketed_paste( void );
+	int enable_raw_mode(void);
+	int reset_raw_mode(void);
+	void disable_raw_mode(void);
+	char32_t read_char(void);
+	void clear_screen( CLEAR_SCREEN );
+	EVENT_TYPE wait_for_input( int long = 0 );
+	void notify_event( EVENT_TYPE );
+	void jump_cursor( int, int );
+	void set_cursor_visible( bool );
+#ifndef _WIN32
+	int read_verbatim( char32_t*, int );
+	int install_window_change_handler( void );
+#endif
+private:
+	void enable_out( void );
+	void disable_out( void );
+private:
+	Terminal( Terminal const& ) = delete;
+	Terminal& operator = ( Terminal const& ) = delete;
+	Terminal( Terminal&& ) = delete;
+	Terminal& operator = ( Terminal&& ) = delete;
+};
+
+void beep();
+char32_t read_unicode_character(void);
+
+namespace tty {
+
+extern bool in;
+extern bool out;
+
+}
+
+}
+
+#endif
+
diff --git a/contrib/restricted/patched/replxx/src/unicodestring.hxx b/contrib/restricted/patched/replxx/src/unicodestring.hxx
new file mode 100644
index 0000000000..db1238beec
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/unicodestring.hxx
@@ -0,0 +1,228 @@
+#ifndef REPLXX_UNICODESTRING_HXX_INCLUDED
+#define REPLXX_UNICODESTRING_HXX_INCLUDED
+
+#include <vector>
+#include <cstring>
+#include <cwctype>
+#include <cassert>
+
+#include "conversion.hxx"
+
+namespace replxx {
+
+inline bool case_sensitive_equal( char32_t l, char32_t r ) {
+	return l == r;
+}
+
+inline bool case_insensitive_equal( char32_t l, char32_t r ) {
+	return towlower( static_cast<wint_t>( l ) ) == towlower( static_cast<wint_t>( r ) );
+}
+
+class UnicodeString {
+public:
+	typedef std::vector<char32_t> data_buffer_t;
+	typedef data_buffer_t::const_iterator const_iterator;
+	typedef data_buffer_t::iterator iterator;
+private:
+	data_buffer_t _data;
+public:
+	UnicodeString()
+		: _data() {
+	}
+
+	explicit UnicodeString( std::string const& src )
+		: _data() {
+		assign( src );
+	}
+
+	explicit UnicodeString( UnicodeString const& other, int offset, int len = -1 )
+		: _data() {
+		_data.insert(
+			_data.end(),
+			other._data.begin() + offset,
+			len > 0 ? other._data.begin() + offset + len : other._data.end()
+		);
+	}
+
+	explicit UnicodeString( char const* src )
+		: _data() {
+		assign( src );
+	}
+
+	explicit UnicodeString( char8_t const* src )
+		: UnicodeString( reinterpret_cast<const char*>( src ) ) {
+	}
+
+	explicit UnicodeString( char32_t const* src )
+		: _data() {
+		int len( 0 );
+		while ( src[len] != 0 ) {
+			++ len;
+		}
+		_data.assign( src, src + len );
+	}
+
+	explicit UnicodeString( char32_t const* src, int len )
+		: _data() {
+		_data.assign( src, src + len );
+	}
+
+	explicit UnicodeString( int len )
+		: _data() {
+		_data.resize( len );
+	}
+
+	UnicodeString& assign( std::string const& str_ ) {
+		_data.resize( static_cast<int>( str_.length() ) );
+		int len( 0 );
+		copyString8to32( _data.data(), static_cast<int>( str_.length() ), len, str_.c_str() );
+		_data.resize( len );
+		return *this;
+	}
+
+	UnicodeString& assign( char const* str_ ) {
+		int byteCount( static_cast<int>( strlen( str_ ) ) );
+		_data.resize( byteCount );
+		int len( 0 );
+		copyString8to32( _data.data(), byteCount, len, str_ );
+		_data.resize( len );
+		return *this;
+	}
+
+	UnicodeString& assign( UnicodeString const& other_ ) {
+		_data = other_._data;
+		return *this;
+	}
+
+	explicit UnicodeString( UnicodeString const& ) = default;
+	UnicodeString& operator = ( UnicodeString const& ) = default;
+	UnicodeString( UnicodeString&& ) = default;
+	UnicodeString& operator = ( UnicodeString&& ) = default;
+	bool operator == ( UnicodeString const& other_ ) const {
+		return ( _data == other_._data );
+	}
+
+	bool operator != ( UnicodeString const& other_ ) const {
+		return ( _data != other_._data );
+	}
+
+	bool operator < ( UnicodeString const& other_ ) const {
+		return std::lexicographical_compare(begin(), end(), other_.begin(), other_.end());
+	}
+
+	UnicodeString& append( UnicodeString const& other ) {
+		_data.insert( _data.end(), other._data.begin(), other._data.end() );
+		return *this;
+	}
+
+	void push_back( char32_t c_ ) {
+		_data.push_back( c_ );
+	}
+
+	UnicodeString& append( char32_t const* src, int len ) {
+		_data.insert( _data.end(), src, src + len );
+		return *this;
+	}
+
+	UnicodeString& insert( int pos_, UnicodeString const& str_, int offset_, int len_ ) {
+		_data.insert( _data.begin() + pos_, str_._data.begin() + offset_, str_._data.begin() + offset_ + len_ );
+		return *this;
+	}
+
+	UnicodeString& insert( int pos_, char32_t c_ ) {
+		_data.insert( _data.begin() + pos_, c_ );
+		return *this;
+	}
+
+	UnicodeString& erase( int pos_ ) {
+		_data.erase( _data.begin() + pos_ );
+		return *this;
+	}
+
+	UnicodeString& erase( int pos_, int len_ ) {
+		_data.erase( _data.begin() + pos_, _data.begin() + pos_ + len_ );
+		return *this;
+	}
+
+	char32_t const* get() const {
+		return _data.data();
+	}
+
+	char32_t* get() {
+		return _data.data();
+	}
+
+	int length() const {
+		return static_cast<int>( _data.size() );
+	}
+
+	void clear( void ) {
+		_data.clear();
+	}
+
+	const char32_t& operator[]( int pos ) const {
+		assert( ( pos >= 0 ) && ( pos < static_cast<int>( _data.size() ) ) );
+		return _data[pos];
+	}
+
+	char32_t& operator[]( int pos ) {
+		assert( ( pos >= 0 ) && ( pos < static_cast<int>( _data.size() ) ) );
+		return _data[pos];
+	}
+
+	bool starts_with( data_buffer_t::const_iterator first_, data_buffer_t::const_iterator last_ ) const {
+		return (
+			( std::distance( first_, last_ ) <= length() )
+			&& ( std::equal( first_, last_, _data.begin() ) )
+		);
+	}
+
+	template <class BinaryPredicate>
+	bool starts_with( data_buffer_t::const_iterator first_, data_buffer_t::const_iterator last_, BinaryPredicate&& pred ) const {
+		return (
+			( std::distance( first_, last_ ) <= length() )
+			&& ( std::equal( first_, last_, _data.begin(), std::forward<BinaryPredicate>( pred ) ) )
+		);
+	}
+
+	bool ends_with( data_buffer_t::const_iterator first_, data_buffer_t::const_iterator last_ ) const {
+		int len( static_cast<int>( std::distance( first_, last_ ) ) );
+		return (
+			( len <= length() )
+			&& ( std::equal( first_, last_, _data.end() - len ) )
+		);
+	}
+
+	bool is_empty( void ) const {
+		return ( _data.size() == 0 );
+	}
+
+	void swap( UnicodeString& other_ ) {
+		_data.swap( other_._data );
+	}
+
+	const_iterator begin( void ) const {
+		return ( _data.begin() );
+	}
+
+	const_iterator end( void ) const {
+		return ( _data.end() );
+	}
+
+	iterator begin( void ) {
+		return ( _data.begin() );
+	}
+
+	iterator end( void ) {
+		return ( _data.end() );
+	}
+
+	char32_t back( void ) const {
+		return ( _data.back() );
+	}
+};
+
+}
+
+#endif
+
diff --git a/contrib/restricted/patched/replxx/src/utf8string.hxx b/contrib/restricted/patched/replxx/src/utf8string.hxx
new file mode 100644
index 0000000000..c7b1ea5b44
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/utf8string.hxx
@@ -0,0 +1,100 @@
+#ifndef REPLXX_UTF8STRING_HXX_INCLUDED
+#define REPLXX_UTF8STRING_HXX_INCLUDED
+
+#include <memory>
+
+#include "unicodestring.hxx"
+
+namespace replxx {
+
+class Utf8String {
+private:
+	typedef std::unique_ptr<char[]> buffer_t;
+	buffer_t _data;
+	int _bufSize;
+	int _len;
+public:
+	Utf8String( void )
+		: _data()
+		, _bufSize( 0 )
+		, _len( 0 ) {
+	}
+	explicit Utf8String( UnicodeString const& src )
+		: _data()
+		, _bufSize( 0 )
+		, _len( 0 ) {
+		assign( src, src.length() );
+	}
+
+	Utf8String( UnicodeString const& src_, int len_ )
+		: _data()
+		, _bufSize( 0 )
+		, _len( 0 ) {
+		assign( src_, len_ );
+	}
+
+	void assign( UnicodeString const& str_ ) {
+		assign( str_, str_.length() );
+	}
+
+	void assign( UnicodeString const& str_, int len_ ) {
+		assign( str_.get(), len_ );
+	}
+
+	void assign( char32_t const* str_, int len_ ) {
+		int len( len_ * 4 );
+		realloc( len );
+		_len = copyString32to8( _data.get(), len, str_, len_ );
+	}
+
+	void assign( std::string const& str_ ) {
+		realloc( static_cast<int>( str_.length() ) );
+		strncpy( _data.get(), str_.c_str(), str_.length() );
+		_len = static_cast<int>( str_.length() );
+	}
+
+	void assign( Utf8String const& other_ ) {
+		realloc( other_._len );
+		strncpy( _data.get(), other_._data.get(), other_._len );
+		_len = other_._len;
+	}
+
+	char const* get() const {
+		return _data.get();
+	}
+
+	int size( void ) const {
+		return ( _len );
+	}
+
+	bool operator != ( Utf8String const& other_ ) {
+		return (
+			( other_._len != _len )
+			|| (
+				(  _len != 0 )
+				&& ( memcmp( other_._data.get(), _data.get(), _len ) != 0 )
+			)
+		);
+	}
+
+private:
+	void realloc( int reqLen ) {
+		if ( ( reqLen + 1 ) > _bufSize ) {
+			_bufSize = 1;
+			while ( ( reqLen + 1 ) > _bufSize ) {
+				_bufSize *= 2;
+			}
+			_data.reset( new char[_bufSize] );
+			memset( _data.get(), 0, _bufSize );
+		}
+		_data[reqLen] = 0;
+		return;
+	}
+	Utf8String(const Utf8String&) = delete;
+	Utf8String& operator=(const Utf8String&) = delete;
+};
+
+}
+
+#endif
+
diff --git a/contrib/restricted/patched/replxx/src/util.cxx b/contrib/restricted/patched/replxx/src/util.cxx
new file mode 100644
index 0000000000..730a7531f5
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/util.cxx
@@ -0,0 +1,179 @@
+#include <chrono>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <wctype.h>
+
+#include "util.hxx"
+#include "terminal.hxx"
+
+#undef min
+
+namespace replxx {
+
+int mk_wcwidth( char32_t );
+
+int virtual_render( char32_t const* display_, int size_, int& x_, int& y_, int screenColumns_, int promptLen_, char32_t* rendered_, int* renderedSize_ ) {
+	char32_t* out( rendered_ );
+	int visibleCount( 0 );
+	auto render = [&rendered_, &renderedSize_, &out, &visibleCount]( char32_t c_, bool visible_, bool renderAttributes_ = true ) {
+		if ( rendered_ && renderedSize_ && renderAttributes_ ) {
+			*out = c_;
+			++ out;
+			if ( visible_ ) {
+				++ visibleCount;
+			}
+		}
+	};
+	bool wrapped( false );
+	auto advance_cursor = [&x_, &y_, &screenColumns_, &wrapped]( int by_ = 1 ) {
+		wrapped = false;
+		x_ += by_;
+		if ( x_ >= screenColumns_ ) {
+			x_ = 0;
+			++ y_;
+			wrapped = true;
+		}
+	};
+	bool const renderAttributes( !!tty::out );
+	int pos( 0 );
+	while ( pos < size_ ) {
+		char32_t c( display_[pos] );
+		if ( ( c == '\n' ) || ( c == '\r' ) ) {
+			render( c, true );
+			if ( ( c == '\n' ) && ! wrapped ) {
+				++ y_;
+			}
+			x_ = promptLen_;
+			++ pos;
+			continue;
+		}
+		if ( c == '\b' ) {
+			render( c, true );
+			-- x_;
+			if ( x_ < 0 ) {
+				x_ = screenColumns_ - 1;
+				-- y_;
+			}
+			++ pos;
+			continue;
+		}
+		if ( c == '\033' ) {
+			render( c, false, renderAttributes );
+			++ pos;
+			if ( pos >= size_ ) {
+				advance_cursor( 2 );
+				continue;
+			}
+			c = display_[pos];
+			if ( c != '[' ) {
+				advance_cursor( 2 );
+				continue;
+			}
+			render( c, false, renderAttributes );
+			++ pos;
+			if ( pos >= size_ ) {
+				advance_cursor( 3 );
+				continue;
+			}
+			int codeLen( 0 );
+			while ( pos < size_ ) {
+				c = display_[pos];
+				if ( ( c != ';' ) && ( ( c < '0' ) || ( c > '9' ) ) ) {
+					break;
+				}
+				render( c, false, renderAttributes );
+				++ codeLen;
+				++ pos;
+			}
+			if ( pos >= size_ ) {
+				continue;
+			}
+			c = display_[pos];
+			if ( c != 'm' ) {
+				advance_cursor( 3 + codeLen );
+				continue;
+			}
+			render( c, false, renderAttributes );
+			++ pos;
+			continue;
+		}
+		if ( is_control_code( c ) ) {
+			render( c, true );
+			advance_cursor( 2 );
+			++ pos;
+			continue;
+		}
+		int wcw( mk_wcwidth( c ) );
+		if ( wcw < 0 ) {
+			break;
+		}
+		render( c, true );
+		advance_cursor( wcw );
+		++ pos;
+	}
+	if ( rendered_ && renderedSize_ ) {
+		*renderedSize_ = out - rendered_;
+	}
+	return ( visibleCount );
+}
+
+char const* ansi_color( Replxx::Color color_ ) {
+	int unsigned code( static_cast<int unsigned>( color_ ) );
+	int unsigned fg( code & 0xFFu );
+	int unsigned bg( ( code >> 8 ) & 0xFFu );
+	char const* bold( ( code & color::BOLD ) != 0 ? ";1" : "" );
+	char const* underline = ( ( code & color::UNDERLINE ) != 0 ? ";4" : "" );
+	static int const MAX_COLOR_CODE_SIZE( 32 );
+	static char colorBuffer[MAX_COLOR_CODE_SIZE];
+	int pos( 0 );
+	if ( ( code & static_cast<int unsigned>( Replxx::Color::DEFAULT ) ) != 0 ) {
+		pos = snprintf( colorBuffer, MAX_COLOR_CODE_SIZE, "\033[0%s%sm", underline, bold );
+	} else if ( fg <= static_cast<int unsigned>( Replxx::Color::LIGHTGRAY ) ) {
+		pos = snprintf( colorBuffer, MAX_COLOR_CODE_SIZE, "\033[0;22;3%d%s%sm", fg, underline, bold );
+	} else if ( fg <= static_cast<int unsigned>( Replxx::Color::WHITE ) ) {
+#ifdef _WIN32
+		static bool const has256colorDefault( true );
+#else
+		static bool const has256colorDefault( false );
+#endif
+		static char const* TERM( getenv( "TERM" ) );
+		static bool const has256color( TERM ? ( strstr( TERM, "256" ) != nullptr ) : has256colorDefault );
+		static char const* ansiEscapeCodeTemplate = has256color ? "\033[0;9%d%s%sm" : "\033[0;1;3%d%s%sm";
+		pos = snprintf( colorBuffer, MAX_COLOR_CODE_SIZE, ansiEscapeCodeTemplate, fg - static_cast<int>( Replxx::Color::GRAY ), underline, bold );
+	} else {
+		pos = snprintf( colorBuffer, MAX_COLOR_CODE_SIZE, "\033[0;38;5;%d%s%sm", fg, underline, bold );
+	}
+	if ( ( code & color::BACKGROUND_COLOR_SET ) == 0 ) {
+		return colorBuffer;
+	}
+	if ( bg <= static_cast<int unsigned>( Replxx::Color::WHITE ) ) {
+		if ( bg <= static_cast<int unsigned>( Replxx::Color::LIGHTGRAY ) ) {
+			snprintf( colorBuffer + pos, MAX_COLOR_CODE_SIZE - pos, "\033[4%dm", bg );
+		} else {
+			snprintf( colorBuffer + pos, MAX_COLOR_CODE_SIZE - pos, "\033[10%dm", bg - static_cast<int>( Replxx::Color::GRAY ) );
+		}
+	} else {
+		snprintf( colorBuffer + pos, MAX_COLOR_CODE_SIZE - pos, "\033[48;5;%dm", bg );
+	}
+	return colorBuffer;
+}
+
+std::string now_ms_str( void ) {
+	std::chrono::milliseconds ms( std::chrono::duration_cast<std::chrono::milliseconds>( std::chrono::system_clock::now().time_since_epoch() ) );
+	time_t t( ms.count() / 1000 );
+	tm broken;
+#ifdef _WIN32
+#define localtime_r( t, b ) localtime_s( ( b ), ( t ) )
+#endif
+	localtime_r( &t, &broken );
+#undef localtime_r
+	static int const BUFF_SIZE( 32 );
+	char str[BUFF_SIZE];
+	strftime( str, BUFF_SIZE, "%Y-%m-%d %H:%M:%S.", &broken );
+	snprintf( str + sizeof ( "YYYY-mm-dd HH:MM:SS" ), 5, "%03d", static_cast<int>( ms.count() % 1000 ) );
+	return ( str );
+}
+
+}
+
diff --git a/contrib/restricted/patched/replxx/src/util.hxx b/contrib/restricted/patched/replxx/src/util.hxx
new file mode 100644
index 0000000000..e77c641d5f
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/util.hxx
@@ -0,0 +1,32 @@
+#ifndef REPLXX_UTIL_HXX_INCLUDED
+#define REPLXX_UTIL_HXX_INCLUDED 1
+
+#include "replxx.hxx"
+
+namespace replxx {
+
+namespace color {
+static int unsigned const RGB666 = 16u;
+static int unsigned const GRAYSCALE = 232u;
+static int unsigned const BOLD = 1u << 17u;
+static int unsigned const UNDERLINE = 1u << 18u;
+static int unsigned const BACKGROUND_COLOR_SET = 1u << 19u;
+}
+
+inline bool is_control_code(char32_t testChar) {
+	return (testChar < ' ') ||											// C0 controls
+				 (testChar >= 0x7F && testChar <= 0x9F);	// DEL and C1 controls
+}
+
+inline char32_t control_to_human( char32_t key ) {
+	return ( key < 27 ? ( key + 0x40 ) : ( key + 0x18 ) );
+}
+
+int virtual_render( char32_t const*, int, int&, int&, int, int, char32_t* = nullptr, int* = nullptr );
+char const* ansi_color( Replxx::Color );
+std::string now_ms_str( void );
+
+}
+
+#endif
+
diff --git a/contrib/restricted/patched/replxx/src/wcwidth.cpp b/contrib/restricted/patched/replxx/src/wcwidth.cpp
new file mode 100644
index 0000000000..c6c05fad65
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/wcwidth.cpp
@@ -0,0 +1,296 @@
+/*
+ * This is an implementation of wcwidth() and wcswidth() (defined in
+ * IEEE Std 1002.1-2001) for Unicode.
+ *
+ * http://www.opengroup.org/onlinepubs/007904975/functions/wcwidth.html
+ * http://www.opengroup.org/onlinepubs/007904975/functions/wcswidth.html
+ *
+ * In fixed-width output devices, Latin characters all occupy a single
+ * "cell" position of equal width, whereas ideographic CJK characters
+ * occupy two such cells. Interoperability between terminal-line
+ * applications and (teletype-style) character terminals using the
+ * UTF-8 encoding requires agreement on which character should advance
+ * the cursor by how many cell positions. No established formal
+ * standards exist at present on which Unicode character shall occupy
+ * how many cell positions on character terminals. These routines are
+ * a first attempt of defining such behavior based on simple rules
+ * applied to data provided by the Unicode Consortium.
+ *
+ * For some graphical characters, the Unicode standard explicitly
+ * defines a character-cell width via the definition of the East Asian
+ * FullWidth (F), Wide (W), Half-width (H), and Narrow (Na) classes.
+ * In all these cases, there is no ambiguity about which width a
+ * terminal shall use. For characters in the East Asian Ambiguous (A)
+ * class, the width choice depends purely on a preference of backward
+ * compatibility with either historic CJK or Western practice.
+ * Choosing single-width for these characters is easy to justify as
+ * the appropriate long-term solution, as the CJK practice of
+ * displaying these characters as double-width comes from historic
+ * implementation simplicity (8-bit encoded characters were displayed
+ * single-width and 16-bit ones double-width, even for Greek,
+ * Cyrillic, etc.) and not any typographic considerations.
+ *
+ * Much less clear is the choice of width for the Not East Asian
+ * (Neutral) class. Existing practice does not dictate a width for any
+ * of these characters. It would nevertheless make sense
+ * typographically to allocate two character cells to characters such
+ * as for instance EM SPACE or VOLUME INTEGRAL, which cannot be
+ * represented adequately with a single-width glyph. The following
+ * routines at present merely assign a single-cell width to all
+ * neutral characters, in the interest of simplicity. This is not
+ * entirely satisfactory and should be reconsidered before
+ * establishing a formal standard in this area. At the moment, the
+ * decision which Not East Asian (Neutral) characters should be
+ * represented by double-width glyphs cannot yet be answered by
+ * applying a simple rule from the Unicode database content. Setting
+ * up a proper standard for the behavior of UTF-8 character terminals
+ * will require a careful analysis not only of each Unicode character,
+ * but also of each presentation form, something the author of these
+ * routines has avoided to do so far.
+ *
+ * http://www.unicode.org/unicode/reports/tr11/
+ *
+ * Markus Kuhn -- 2007-05-26 (Unicode 5.0)
+ *
+ * Permission to use, copy, modify, and distribute this software
+ * for any purpose and without fee is hereby granted. The author
+ * disclaims all warranties with regard to this software.
+ *
+ * Latest version: http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
+ */
+
+#include <wchar.h>
+#include <string>
+#include <memory>
+
+namespace replxx {
+
+struct interval {
+	char32_t first;
+	char32_t last;
+};
+
+/* auxiliary function for binary search in interval table */
+static int bisearch(char32_t ucs, const struct interval *table, int max) {
+	int min = 0;
+	int mid;
+
+	if (ucs < table[0].first || ucs > table[max].last)
+		return 0;
+	while (max >= min) {
+		mid = (min + max) / 2;
+		if (ucs > table[mid].last)
+			min = mid + 1;
+		else if (ucs < table[mid].first)
+			max = mid - 1;
+		else
+			return 1;
+	}
+
+	return 0;
+}
+
+
+/* The following two functions define the column width of an ISO 10646
+ * character as follows:
+ *
+ *		- The null character (U+0000) has a column width of 0.
+ *
+ *		- Other C0/C1 control characters and DEL will lead to a return
+ *			value of -1.
+ *
+ *		- Non-spacing and enclosing combining characters (general
+ *			category code Mn or Me in the Unicode database) have a
+ *			column width of 0.
+ *
+ *		- SOFT HYPHEN (U+00AD) has a column width of 1.
+ *
+ *		- Other format characters (general category code Cf in the Unicode
+ *			database) and ZERO WIDTH SPACE (U+200B) have a column width of 0.
+ *
+ *		- Hangul Jamo medial vowels and final consonants (U+1160-U+11FF)
+ *			have a column width of 0.
+ *
+ *		- Spacing characters in the East Asian Wide (W) or East Asian
+ *			Full-width (F) category as defined in Unicode Technical
+ *			Report #11 have a column width of 2.
+ *
+ *		- All remaining characters (including all printable
+ *			ISO 8859-1 and WGL4 characters, Unicode control characters,
+ *			etc.) have a column width of 1.
+ *
+ * This implementation assumes that wchar_t characters are encoded
+ * in ISO 10646.
+ */
+
+int mk_is_wide_char(char32_t ucs) {
+  static const struct interval wide[] = {
+    {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, 0x2fdf},
+    {0x2ff0, 0x303e}, {0x3040, 0x3247}, {0x3250, 0x4dbf},
+    {0x4e00, 0xa4cf}, {0xa960, 0xa97f}, {0xac00, 0xd7a3},
+    {0xf900, 0xfaff}, {0xfe10, 0xfe19}, {0xfe30, 0xfe6f},
+    {0xff01, 0xff60}, {0xffe0, 0xffe6}, {0x16fe0, 0x16fe1},
+    {0x17000, 0x18aff}, {0x1b000, 0x1b12f}, {0x1b170, 0x1b2ff},
+    {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},
+    {0x1f6eb, 0x1f6ec}, {0x1f6f4, 0x1f6f8}, {0x1f910, 0x1f93e},
+    {0x1f940, 0x1f94c}, {0x1f950, 0x1f96b}, {0x1f980, 0x1f997},
+    {0x1f9c0, 0x1f9c0}, {0x1f9d0, 0x1f9e6}, {0x20000, 0x2fffd},
+    {0x30000, 0x3fffd},
+  };
+
+  if ( bisearch(ucs, wide, sizeof(wide) / sizeof(struct interval) - 1) ) {
+    return 1;
+	}
+
+  return 0;
+}
+
+int mk_wcwidth(char32_t ucs) {
+	/* sorted list of non-overlapping intervals of non-spacing characters */
+	/* generated by "uniset +cat=Me +cat=Mn +cat=Cf -00AD +1160-11FF +200B c" */
+	static const struct interval combining[] = {
+    {0x00ad, 0x00ad}, {0x0300, 0x036f}, {0x0483, 0x0489},
+    {0x0591, 0x05bd}, {0x05bf, 0x05bf}, {0x05c1, 0x05c2},
+    {0x05c4, 0x05c5}, {0x05c7, 0x05c7}, {0x0610, 0x061a},
+    {0x061c, 0x061c}, {0x064b, 0x065f}, {0x0670, 0x0670},
+    {0x06d6, 0x06dc}, {0x06df, 0x06e4}, {0x06e7, 0x06e8},
+    {0x06ea, 0x06ed}, {0x0711, 0x0711}, {0x0730, 0x074a},
+    {0x07a6, 0x07b0}, {0x07eb, 0x07f3}, {0x0816, 0x0819},
+    {0x081b, 0x0823}, {0x0825, 0x0827}, {0x0829, 0x082d},
+    {0x0859, 0x085b}, {0x08d4, 0x08e1}, {0x08e3, 0x0902},
+    {0x093a, 0x093a}, {0x093c, 0x093c}, {0x0941, 0x0948},
+    {0x094d, 0x094d}, {0x0951, 0x0957}, {0x0962, 0x0963},
+    {0x0981, 0x0981}, {0x09bc, 0x09bc}, {0x09c1, 0x09c4},
+    {0x09cd, 0x09cd}, {0x09e2, 0x09e3}, {0x0a01, 0x0a02},
+    {0x0a3c, 0x0a3c}, {0x0a41, 0x0a42}, {0x0a47, 0x0a48},
+    {0x0a4b, 0x0a4d}, {0x0a51, 0x0a51}, {0x0a70, 0x0a71},
+    {0x0a75, 0x0a75}, {0x0a81, 0x0a82}, {0x0abc, 0x0abc},
+    {0x0ac1, 0x0ac5}, {0x0ac7, 0x0ac8}, {0x0acd, 0x0acd},
+    {0x0ae2, 0x0ae3}, {0x0afa, 0x0aff}, {0x0b01, 0x0b01},
+    {0x0b3c, 0x0b3c}, {0x0b3f, 0x0b3f}, {0x0b41, 0x0b44},
+    {0x0b4d, 0x0b4d}, {0x0b56, 0x0b56}, {0x0b62, 0x0b63},
+    {0x0b82, 0x0b82}, {0x0bc0, 0x0bc0}, {0x0bcd, 0x0bcd},
+    {0x0c00, 0x0c00}, {0x0c3e, 0x0c40}, {0x0c46, 0x0c48},
+    {0x0c4a, 0x0c4d}, {0x0c55, 0x0c56}, {0x0c62, 0x0c63},
+    {0x0c81, 0x0c81}, {0x0cbc, 0x0cbc}, {0x0cbf, 0x0cbf},
+    {0x0cc6, 0x0cc6}, {0x0ccc, 0x0ccd}, {0x0ce2, 0x0ce3},
+    {0x0d00, 0x0d01}, {0x0d3b, 0x0d3c}, {0x0d41, 0x0d44},
+    {0x0d4d, 0x0d4d}, {0x0d62, 0x0d63}, {0x0dca, 0x0dca},
+    {0x0dd2, 0x0dd4}, {0x0dd6, 0x0dd6}, {0x0e31, 0x0e31},
+    {0x0e34, 0x0e3a}, {0x0e47, 0x0e4e}, {0x0eb1, 0x0eb1},
+    {0x0eb4, 0x0eb9}, {0x0ebb, 0x0ebc}, {0x0ec8, 0x0ecd},
+    {0x0f18, 0x0f19}, {0x0f35, 0x0f35}, {0x0f37, 0x0f37},
+    {0x0f39, 0x0f39}, {0x0f71, 0x0f7e}, {0x0f80, 0x0f84},
+    {0x0f86, 0x0f87}, {0x0f8d, 0x0f97}, {0x0f99, 0x0fbc},
+    {0x0fc6, 0x0fc6}, {0x102d, 0x1030}, {0x1032, 0x1037},
+    {0x1039, 0x103a}, {0x103d, 0x103e}, {0x1058, 0x1059},
+    {0x105e, 0x1060}, {0x1071, 0x1074}, {0x1082, 0x1082},
+    {0x1085, 0x1086}, {0x108d, 0x108d}, {0x109d, 0x109d},
+    {0x1160, 0x11ff}, {0x135d, 0x135f}, {0x1712, 0x1714},
+    {0x1732, 0x1734}, {0x1752, 0x1753}, {0x1772, 0x1773},
+    {0x17b4, 0x17b5}, {0x17b7, 0x17bd}, {0x17c6, 0x17c6},
+    {0x17c9, 0x17d3}, {0x17dd, 0x17dd}, {0x180b, 0x180e},
+    {0x1885, 0x1886}, {0x18a9, 0x18a9}, {0x1920, 0x1922},
+    {0x1927, 0x1928}, {0x1932, 0x1932}, {0x1939, 0x193b},
+    {0x1a17, 0x1a18}, {0x1a1b, 0x1a1b}, {0x1a56, 0x1a56},
+    {0x1a58, 0x1a5e}, {0x1a60, 0x1a60}, {0x1a62, 0x1a62},
+    {0x1a65, 0x1a6c}, {0x1a73, 0x1a7c}, {0x1a7f, 0x1a7f},
+    {0x1ab0, 0x1abe}, {0x1b00, 0x1b03}, {0x1b34, 0x1b34},
+    {0x1b36, 0x1b3a}, {0x1b3c, 0x1b3c}, {0x1b42, 0x1b42},
+    {0x1b6b, 0x1b73}, {0x1b80, 0x1b81}, {0x1ba2, 0x1ba5},
+    {0x1ba8, 0x1ba9}, {0x1bab, 0x1bad}, {0x1be6, 0x1be6},
+    {0x1be8, 0x1be9}, {0x1bed, 0x1bed}, {0x1bef, 0x1bf1},
+    {0x1c2c, 0x1c33}, {0x1c36, 0x1c37}, {0x1cd0, 0x1cd2},
+    {0x1cd4, 0x1ce0}, {0x1ce2, 0x1ce8}, {0x1ced, 0x1ced},
+    {0x1cf4, 0x1cf4}, {0x1cf8, 0x1cf9}, {0x1dc0, 0x1df9},
+    {0x1dfb, 0x1dff}, {0x200b, 0x200f}, {0x202a, 0x202e},
+    {0x2060, 0x2064}, {0x2066, 0x206f}, {0x20d0, 0x20f0},
+    {0x2cef, 0x2cf1}, {0x2d7f, 0x2d7f}, {0x2de0, 0x2dff},
+    {0x302a, 0x302d}, {0x3099, 0x309a}, {0xa66f, 0xa672},
+    {0xa674, 0xa67d}, {0xa69e, 0xa69f}, {0xa6f0, 0xa6f1},
+    {0xa802, 0xa802}, {0xa806, 0xa806}, {0xa80b, 0xa80b},
+    {0xa825, 0xa826}, {0xa8c4, 0xa8c5}, {0xa8e0, 0xa8f1},
+    {0xa926, 0xa92d}, {0xa947, 0xa951}, {0xa980, 0xa982},
+    {0xa9b3, 0xa9b3}, {0xa9b6, 0xa9b9}, {0xa9bc, 0xa9bc},
+    {0xa9e5, 0xa9e5}, {0xaa29, 0xaa2e}, {0xaa31, 0xaa32},
+    {0xaa35, 0xaa36}, {0xaa43, 0xaa43}, {0xaa4c, 0xaa4c},
+    {0xaa7c, 0xaa7c}, {0xaab0, 0xaab0}, {0xaab2, 0xaab4},
+    {0xaab7, 0xaab8}, {0xaabe, 0xaabf}, {0xaac1, 0xaac1},
+    {0xaaec, 0xaaed}, {0xaaf6, 0xaaf6}, {0xabe5, 0xabe5},
+    {0xabe8, 0xabe8}, {0xabed, 0xabed}, {0xfb1e, 0xfb1e},
+    {0xfe00, 0xfe0f}, {0xfe20, 0xfe2f}, {0xfeff, 0xfeff},
+    {0xfff9, 0xfffb}, {0x101fd, 0x101fd}, {0x102e0, 0x102e0},
+    {0x10376, 0x1037a}, {0x10a01, 0x10a03}, {0x10a05, 0x10a06},
+    {0x10a0c, 0x10a0f}, {0x10a38, 0x10a3a}, {0x10a3f, 0x10a3f},
+    {0x10ae5, 0x10ae6}, {0x11001, 0x11001}, {0x11038, 0x11046},
+    {0x1107f, 0x11081}, {0x110b3, 0x110b6}, {0x110b9, 0x110ba},
+    {0x11100, 0x11102}, {0x11127, 0x1112b}, {0x1112d, 0x11134},
+    {0x11173, 0x11173}, {0x11180, 0x11181}, {0x111b6, 0x111be},
+    {0x111ca, 0x111cc}, {0x1122f, 0x11231}, {0x11234, 0x11234},
+    {0x11236, 0x11237}, {0x1123e, 0x1123e}, {0x112df, 0x112df},
+    {0x112e3, 0x112ea}, {0x11300, 0x11301}, {0x1133c, 0x1133c},
+    {0x11340, 0x11340}, {0x11366, 0x1136c}, {0x11370, 0x11374},
+    {0x11438, 0x1143f}, {0x11442, 0x11444}, {0x11446, 0x11446},
+    {0x114b3, 0x114b8}, {0x114ba, 0x114ba}, {0x114bf, 0x114c0},
+    {0x114c2, 0x114c3}, {0x115b2, 0x115b5}, {0x115bc, 0x115bd},
+    {0x115bf, 0x115c0}, {0x115dc, 0x115dd}, {0x11633, 0x1163a},
+    {0x1163d, 0x1163d}, {0x1163f, 0x11640}, {0x116ab, 0x116ab},
+    {0x116ad, 0x116ad}, {0x116b0, 0x116b5}, {0x116b7, 0x116b7},
+    {0x1171d, 0x1171f}, {0x11722, 0x11725}, {0x11727, 0x1172b},
+    {0x11a01, 0x11a06}, {0x11a09, 0x11a0a}, {0x11a33, 0x11a38},
+    {0x11a3b, 0x11a3e}, {0x11a47, 0x11a47}, {0x11a51, 0x11a56},
+    {0x11a59, 0x11a5b}, {0x11a8a, 0x11a96}, {0x11a98, 0x11a99},
+    {0x11c30, 0x11c36}, {0x11c38, 0x11c3d}, {0x11c3f, 0x11c3f},
+    {0x11c92, 0x11ca7}, {0x11caa, 0x11cb0}, {0x11cb2, 0x11cb3},
+    {0x11cb5, 0x11cb6}, {0x11d31, 0x11d36}, {0x11d3a, 0x11d3a},
+    {0x11d3c, 0x11d3d}, {0x11d3f, 0x11d45}, {0x11d47, 0x11d47},
+    {0x16af0, 0x16af4}, {0x16b30, 0x16b36}, {0x16f8f, 0x16f92},
+    {0x1bc9d, 0x1bc9e}, {0x1bca0, 0x1bca3}, {0x1d167, 0x1d169},
+    {0x1d173, 0x1d182}, {0x1d185, 0x1d18b}, {0x1d1aa, 0x1d1ad},
+    {0x1d242, 0x1d244}, {0x1da00, 0x1da36}, {0x1da3b, 0x1da6c},
+    {0x1da75, 0x1da75}, {0x1da84, 0x1da84}, {0x1da9b, 0x1da9f},
+    {0x1daa1, 0x1daaf}, {0x1e000, 0x1e006}, {0x1e008, 0x1e018},
+    {0x1e01b, 0x1e021}, {0x1e023, 0x1e024}, {0x1e026, 0x1e02a},
+    {0x1e8d0, 0x1e8d6}, {0x1e944, 0x1e94a}, {0xe0001, 0xe0001},
+    {0xe0020, 0xe007f}, {0xe0100, 0xe01ef},
+	};
+
+	/* test for 8-bit control characters */
+	if ( ucs == 0 ) {
+		return 0;
+	}
+	if ( ( ucs < 32 ) || ( ( ucs >= 0x7f ) && ( ucs < 0xa0 ) ) ) {
+		return -1;
+	}
+
+	/* binary search in table of non-spacing characters */
+	if ( bisearch( ucs, combining, sizeof( combining ) / sizeof( struct interval ) - 1 ) ) {
+		return 0;
+	}
+
+	/* if we arrive here, ucs is not a combining or C0/C1 control character */
+  return ( mk_is_wide_char( ucs ) ? 2 : 1 );
+}
+
+}
+
diff --git a/contrib/restricted/patched/replxx/src/windows.cxx b/contrib/restricted/patched/replxx/src/windows.cxx
new file mode 100644
index 0000000000..6a0e425e48
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/windows.cxx
@@ -0,0 +1,144 @@
+#ifdef _WIN32
+
+#include <iostream>
+
+#include "windows.hxx"
+#include "conversion.hxx"
+#include "terminal.hxx"
+
+using namespace std;
+
+namespace replxx {
+
+WinAttributes WIN_ATTR;
+
+template<typename T>
+T* HandleEsc(HANDLE out_, T* p, T* end) {
+	if (*p == '[') {
+		int code = 0;
+
+		int thisBackground( WIN_ATTR._defaultBackground );
+		for (++p; p < end; ++p) {
+			char32_t c = *p;
+
+			if ('0' <= c && c <= '9') {
+				code = code * 10 + (c - '0');
+			} else if (c == 'm' || c == ';') {
+				switch (code) {
+					case 0:
+						WIN_ATTR._consoleAttribute = WIN_ATTR._defaultAttribute;
+						WIN_ATTR._consoleColor = WIN_ATTR._defaultColor | thisBackground;
+						break;
+					case 1:	// BOLD
+					case 5:	// BLINK
+						WIN_ATTR._consoleAttribute = (WIN_ATTR._defaultAttribute ^ FOREGROUND_INTENSITY) & INTENSITY;
+						break;
+					case 22:
+						WIN_ATTR._consoleAttribute = WIN_ATTR._defaultAttribute;
+						break;
+					case 30:
+					case 90:
+						WIN_ATTR._consoleColor = thisBackground;
+						break;
+					case 31:
+					case 91:
+						WIN_ATTR._consoleColor = FOREGROUND_RED | thisBackground;
+						break;
+					case 32:
+					case 92:
+						WIN_ATTR._consoleColor = FOREGROUND_GREEN | thisBackground;
+						break;
+					case 33:
+					case 93:
+						WIN_ATTR._consoleColor = FOREGROUND_RED | FOREGROUND_GREEN | thisBackground;
+						break;
+					case 34:
+					case 94:
+						WIN_ATTR._consoleColor = FOREGROUND_BLUE | thisBackground;
+						break;
+					case 35:
+					case 95:
+						WIN_ATTR._consoleColor = FOREGROUND_BLUE | FOREGROUND_RED | thisBackground;
+						break;
+					case 36:
+					case 96:
+						WIN_ATTR._consoleColor = FOREGROUND_BLUE | FOREGROUND_GREEN | thisBackground;
+						break;
+					case 37:
+					case 97:
+						WIN_ATTR._consoleColor = FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | thisBackground;
+						break;
+					case 101:
+						thisBackground = BACKGROUND_RED;
+						break;
+				}
+
+				if ( ( code >= 90 ) && ( code <= 97 ) ) {
+					WIN_ATTR._consoleAttribute = (WIN_ATTR._defaultAttribute ^ FOREGROUND_INTENSITY) & INTENSITY;
+				}
+
+				code = 0;
+			}
+
+			if (*p == 'm') {
+				++p;
+				break;
+			}
+		}
+	} else {
+		++p;
+	}
+
+	SetConsoleTextAttribute(
+		out_,
+		WIN_ATTR._consoleAttribute | WIN_ATTR._consoleColor
+	);
+
+	return p;
+}
+
+int win_write( HANDLE out_, bool autoEscape_, char const* str_, int size_ ) {
+	int count( 0 );
+	if ( tty::out ) {
+		DWORD nWritten( 0 );
+		if ( autoEscape_ ) {
+			WriteConsoleA( out_, str_, size_, &nWritten, nullptr );
+			count = nWritten;
+		} else {
+			char const* s( str_ );
+			char const* e( str_ + size_ );
+			while ( str_ < e ) {
+				if ( *str_ == 27 ) {
+					if ( s < str_ ) {
+						int toWrite( static_cast<int>( str_ - s ) );
+						WriteConsoleA( out_, s, static_cast<DWORD>( toWrite ), &nWritten, nullptr );
+						count += nWritten;
+						if ( static_cast<int>( nWritten ) != toWrite ) {
+							s = str_ = nullptr;
+							break;
+						}
+					}
+					s = HandleEsc( out_, str_ + 1, e );
+					int escaped( static_cast<int>( s - str_ ) );
+					count += escaped;
+					str_ = s;
+				} else {
+					++ str_;
+				}
+			}
+
+			if ( s < str_ ) {
+				WriteConsoleA( out_, s, static_cast<DWORD>( str_ - s ), &nWritten, nullptr );
+				count += nWritten;
+			}
+		}
+	} else {
+		count = _write( 1, str_, size_ );
+	}
+	return ( count );
+}
+
+}
+
+#endif
+
diff --git a/contrib/restricted/patched/replxx/src/windows.hxx b/contrib/restricted/patched/replxx/src/windows.hxx
new file mode 100644
index 0000000000..243f41cb7e
--- /dev/null
+++ b/contrib/restricted/patched/replxx/src/windows.hxx
@@ -0,0 +1,44 @@
+#ifndef REPLXX_WINDOWS_HXX_INCLUDED
+#define REPLXX_WINDOWS_HXX_INCLUDED 1
+
+#include <conio.h>
+#include <windows.h>
+#include <io.h>
+
+namespace replxx {
+
+static const int FOREGROUND_WHITE =
+		FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
+static const int BACKGROUND_WHITE =
+		BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE;
+static const int INTENSITY = FOREGROUND_INTENSITY | BACKGROUND_INTENSITY;
+
+class WinAttributes {
+ public:
+	WinAttributes() {
+		CONSOLE_SCREEN_BUFFER_INFO info;
+		GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);
+		_defaultAttribute = info.wAttributes & INTENSITY;
+		_defaultColor = info.wAttributes & FOREGROUND_WHITE;
+		_defaultBackground = info.wAttributes & BACKGROUND_WHITE;
+
+		_consoleAttribute = _defaultAttribute;
+		_consoleColor = _defaultColor | _defaultBackground;
+	}
+
+ public:
+	int _defaultAttribute;
+	int _defaultColor;
+	int _defaultBackground;
+
+	int _consoleAttribute;
+	int _consoleColor;
+};
+
+int win_write( HANDLE, bool, char const*, int );
+
+extern WinAttributes WIN_ATTR;
+
+}
+
+#endif
diff --git a/contrib/restricted/patched/replxx/ya.make b/contrib/restricted/patched/replxx/ya.make
new file mode 100644
index 0000000000..8969a14927
--- /dev/null
+++ b/contrib/restricted/patched/replxx/ya.make
@@ -0,0 +1,44 @@
+# Generated by devtools/yamaker from nixpkgs 22.05.
+
+LIBRARY()
+
+LICENSE(
+    BSD-3-Clause AND
+    Custom-wcwidth AND
+    Unicode-Mappings
+)
+
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
+
+VERSION(2022-09-09)
+
+ORIGINAL_SOURCE(https://github.com/ClickHouse/replxx/archive/5d04501f93a4fb7f0bb8b73b8f614bc986f9e25b.tar.gz)
+
+ADDINCL(
+    GLOBAL contrib/restricted/patched/replxx/include
+    contrib/restricted/patched/replxx/src
+)
+
+NO_COMPILER_WARNINGS()
+
+NO_UTIL()
+
+CFLAGS(
+    -DREPLXX_BUILDING_DLL
+)
+
+SRCS(
+    src/ConvertUTF.cpp
+    src/conversion.cxx
+    src/escape.cxx
+    src/history.cxx
+    src/prompt.cxx
+    src/replxx.cxx
+    src/replxx_impl.cxx
+    src/terminal.cxx
+    src/util.cxx
+    src/wcwidth.cpp
+    src/windows.cxx
+)
+
+END()