vibeman 0.0.13 → 0.0.16

package/dist/node_modules/node-pty/deps/winpty/configure

@@ -0,0 +1,167 @@
+#!/bin/bash
+#
+# Copyright (c) 2011-2015 Ryan Prichard
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+#
+# findTool(desc, commandList)
+#
+# Searches commandLine for the first command in the PATH and returns it.
+# Prints an error and aborts the script if no match is found.
+#
+FINDTOOL_OUT=""
+function findTool {
+    DESC=$1
+    OPTIONS=$2
+    for CMD in ${OPTIONS}; do
+        if (which $CMD &>/dev/null) then
+            echo "Found $DESC: $CMD"
+            FINDTOOL_OUT="$CMD"
+            return
+        fi
+    done
+    echo "Error: could not find $DESC.  One of these should be in your PATH:"
+    for CMD in ${OPTIONS}; do
+        echo " * $CMD"
+    done
+    exit 1
+}
+
+IS_CYGWIN=0
+IS_MSYS1=0
+IS_MSYS2=0
+
+# Link parts of the Cygwin binary statically to aid in redistribution?  The
+# binary still links dynamically against the main DLL.  The MinGW binaries are
+# also statically linked and therefore depend only on Windows DLLs.  I started
+# linking the Cygwin/MSYS binary statically, because G++ 4.7 changed the
+# Windows C++ ABI.
+UNIX_LDFLAGS_STATIC='-static -static-libgcc -static-libstdc++'
+
+# Detect the environment -- Cygwin or MSYS.
+case $(uname -s) in
+    CYGWIN*)
+        echo 'uname -s identifies a Cygwin environment.'
+        IS_CYGWIN=1
+	    case $(uname -m) in
+            i686)
+                echo 'uname -m identifies an i686 environment.'
+                UNIX_CXX=i686-pc-cygwin-g++
+                MINGW_CXX=i686-w64-mingw32-g++
+                ;;
+            x86_64)
+                echo 'uname -m identifies an x86_64 environment.'
+                UNIX_CXX=x86_64-pc-cygwin-g++
+                MINGW_CXX=x86_64-w64-mingw32-g++
+                ;;
+            *)
+                echo 'Error: uname -m did not match either i686 or x86_64.'
+                exit 1
+                ;;
+	    esac
+        ;;
+    MSYS*|MINGW*)
+        # MSYS2 notes:
+        #  - MSYS2 offers two shortcuts to open an environment:
+        #     - MinGW-w64 Win32 Shell.  This env reports a `uname -s` of
+        #       MINGW32_NT-6.1 on 32-bit Win7.  The MinGW-w64 compiler
+        #       (i686-w64-mingw32-g++.exe) is in the PATH.
+        #     - MSYS2 Shell.  `uname -s` instead reports MSYS_NT-6.1.
+        #       The i686-w64-mingw32-g++ compiler is not in the PATH.
+        #  - MSYS2 appears to use MinGW-w64, not the older mingw.org.
+        # MSYS notes:
+        #  - `uname -s` is always MINGW32_NT-6.1 on Win7.
+        echo 'uname -s identifies an MSYS/MSYS2 environment.'
+        case $(uname -m) in
+            i686)
+                echo 'uname -m identifies an i686 environment.'
+                UNIX_CXX=i686-pc-msys-g++
+                if echo "$(uname -r)" | grep '^1[.]' > /dev/null; then
+                    # The MSYS-targeting compiler for the original 32-bit-only
+                    # MSYS does not recognize the -static-libstdc++ flag, and
+                    # it does not work with -static, because it tries to link
+                    # statically with the core MSYS library and fails.
+                    #
+                    # Distinguish between the two using the major version
+                    # number of `uname -r`:
+                    #
+                    #   MSYS uname -r:  1.0.18(0.48/3/2)
+                    #   MSYS2 uname -r: 2.0.0(0.284/5/3)
+                    #
+                    # This is suboptimal because MSYS2 is not actually the
+                    # second version of MSYS--it's a brand-new fork of Cygwin.
+                    #
+                    IS_MSYS1=1
+                    UNIX_LDFLAGS_STATIC=
+                    MINGW_CXX=mingw32-g++
+                else
+                    IS_MSYS2=1
+                    MINGW_CXX=i686-w64-mingw32-g++.exe
+                fi
+                ;;
+            x86_64)
+                echo 'uname -m identifies an x86_64 environment.'
+                IS_MSYS2=1
+                UNIX_CXX=x86_64-pc-msys-g++
+                MINGW_CXX=x86_64-w64-mingw32-g++
+                ;;
+            *)
+                echo 'Error: uname -m did not match either i686 or x86_64.'
+                exit 1
+                ;;
+        esac
+        ;;
+    *)
+        echo 'Error: uname -s did not match either CYGWIN* or MINGW*.'
+        exit 1
+        ;;
+esac
+
+# Search the PATH and pick the first match.
+findTool "Cygwin/MSYS G++ compiler" "$UNIX_CXX"
+UNIX_CXX=$FINDTOOL_OUT
+findTool "MinGW G++ compiler" "$MINGW_CXX"
+MINGW_CXX=$FINDTOOL_OUT
+
+# Write config files.
+echo Writing config.mk
+echo UNIX_CXX=$UNIX_CXX > config.mk
+echo UNIX_LDFLAGS_STATIC=$UNIX_LDFLAGS_STATIC >> config.mk
+echo MINGW_CXX=$MINGW_CXX >> config.mk
+
+if test $IS_MSYS1 = 1; then
+    echo UNIX_CXXFLAGS += -DWINPTY_TARGET_MSYS1 >> config.mk
+    # The MSYS1 MinGW compiler has a bug that prevents inclusion of algorithm
+    # and math.h in normal C++11 mode.  The workaround is to enable the gnu++11
+    # mode instead.  The bug was fixed on 2015-07-31, but as of 2016-02-26, the
+    # fix apparently hasn't been released.  See
+    # http://ehc.ac/p/mingw/bugs/2250/.
+    echo MINGW_ENABLE_CXX11_FLAG := -std=gnu++11 >> config.mk
+fi
+
+if test -d .git -a -f .git/HEAD -a -f .git/index && git rev-parse HEAD >&/dev/null; then
+    echo "Commit info: git"
+    echo 'COMMIT_HASH = $(shell git rev-parse HEAD)' >> config.mk
+    echo 'COMMIT_HASH_DEP := config.mk .git/HEAD .git/index' >> config.mk
+else
+    echo "Commit info: none"
+    echo 'COMMIT_HASH := none' >> config.mk
+    echo 'COMMIT_HASH_DEP := config.mk' >> config.mk
+fi

package/dist/node_modules/node-pty/deps/winpty/misc/BufferResizeTests.cc

@@ -0,0 +1,90 @@
+#include <windows.h>
+#include <cassert>
+
+#include "TestUtil.cc"
+
+void dumpInfoToTrace() {
+    CONSOLE_SCREEN_BUFFER_INFO info;
+    assert(GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info));
+    trace("win=(%d,%d,%d,%d)",
+        (int)info.srWindow.Left,
+        (int)info.srWindow.Top,
+        (int)info.srWindow.Right,
+        (int)info.srWindow.Bottom);
+    trace("buf=(%d,%d)",
+        (int)info.dwSize.X,
+        (int)info.dwSize.Y);
+    trace("cur=(%d,%d)",
+        (int)info.dwCursorPosition.X,
+        (int)info.dwCursorPosition.Y);
+}
+
+int main(int argc, char *argv[]) {
+    if (argc == 1) {
+        startChildProcess(L"CHILD");
+        return 0;
+    }
+
+    setWindowPos(0, 0, 1, 1);
+
+    if (false) {
+        // Reducing the buffer height can move the window up.
+        setBufferSize(80, 25);
+        setWindowPos(0, 20, 80, 5);
+        Sleep(2000);
+        setBufferSize(80, 10);
+    }
+
+    if (false) {
+        // Reducing the buffer height moves the window up and the buffer
+        // contents up too.
+        setBufferSize(80, 25);
+        setWindowPos(0, 20, 80, 5);
+        setCursorPos(0, 20);
+        printf("TEST1\nTEST2\nTEST3\nTEST4\n");
+        fflush(stdout);
+        Sleep(2000);
+        setBufferSize(80, 10);
+    }
+
+    if (false) {
+        // Reducing the buffer width can move the window left.
+        setBufferSize(80, 25);
+        setWindowPos(40, 0, 40, 25);
+        Sleep(2000);
+        setBufferSize(60, 25);
+    }
+
+    if (false) {
+        // Sometimes the buffer contents are shifted up; sometimes they're
+        // shifted down.  It seems to depend on the cursor position?
+
+        // setBufferSize(80, 25);
+        // setWindowPos(0, 20, 80, 5);
+        // setCursorPos(0, 20);
+        // printf("TESTa\nTESTb\nTESTc\nTESTd\nTESTe");
+        // fflush(stdout);
+        // setCursorPos(0, 0);
+        // printf("TEST1\nTEST2\nTEST3\nTEST4\nTEST5");
+        // fflush(stdout);
+        // setCursorPos(0, 24);
+        // Sleep(5000);
+        // setBufferSize(80, 24);
+
+        setBufferSize(80, 20);
+        setWindowPos(0, 10, 80, 10);
+        setCursorPos(0, 18);
+
+        printf("TEST1\nTEST2");
+        fflush(stdout);
+        setCursorPos(0, 18);
+
+        Sleep(2000);
+        setBufferSize(80, 18);
+    }
+
+    dumpInfoToTrace();
+    Sleep(30000);
+
+    return 0;
+}

package/dist/node_modules/node-pty/deps/winpty/misc/ChangeScreenBuffer.cc

@@ -0,0 +1,53 @@
+// A test program for CreateConsoleScreenBuffer / SetConsoleActiveScreenBuffer
+//
+
+#include <windows.h>
+#include <stdio.h>
+#include <conio.h>
+#include <io.h>
+#include <cassert>
+
+#include "TestUtil.cc"
+
+int main()
+{
+    HANDLE origBuffer = GetStdHandle(STD_OUTPUT_HANDLE);
+    HANDLE childBuffer = CreateConsoleScreenBuffer(
+            GENERIC_READ | GENERIC_WRITE,
+            FILE_SHARE_READ | FILE_SHARE_WRITE,
+            NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
+
+    SetConsoleActiveScreenBuffer(childBuffer);
+
+    while (true) {
+        char buf[1024];
+        CONSOLE_SCREEN_BUFFER_INFO info;
+
+        assert(GetConsoleScreenBufferInfo(origBuffer, &info));
+        trace("child.size=(%d,%d)", (int)info.dwSize.X, (int)info.dwSize.Y);
+        trace("child.cursor=(%d,%d)", (int)info.dwCursorPosition.X, (int)info.dwCursorPosition.Y);
+        trace("child.window=(%d,%d,%d,%d)",
+            (int)info.srWindow.Left, (int)info.srWindow.Top,
+            (int)info.srWindow.Right, (int)info.srWindow.Bottom);
+        trace("child.maxSize=(%d,%d)", (int)info.dwMaximumWindowSize.X, (int)info.dwMaximumWindowSize.Y);
+
+        int ch = getch();
+        sprintf(buf, "%02x\n", ch);
+        DWORD actual = 0;
+        WriteFile(childBuffer, buf, strlen(buf), &actual, NULL);
+        if (ch == 0x1b/*ESC*/ || ch == 0x03/*CTRL-C*/)
+            break;
+
+        if (ch == 'b') {
+            setBufferSize(origBuffer, 40, 25);
+        } else if (ch == 'w') {
+            setWindowPos(origBuffer, 1, 1, 38, 23);
+        } else if (ch == 'c') {
+            setCursorPos(origBuffer, 10, 10);
+        }
+    }
+
+    SetConsoleActiveScreenBuffer(origBuffer);
+
+    return 0;
+}

package/dist/node_modules/node-pty/deps/winpty/misc/ClearConsole.cc

@@ -0,0 +1,72 @@
+/*
+ * Demonstrates that console clearing sets each cell's character to SP, not
+ * NUL, and it sets the attribute of each cell to the current text attribute.
+ *
+ * This confirms the MSDN instruction in the "Clearing the Screen" article.
+ * https://msdn.microsoft.com/en-us/library/windows/desktop/ms682022(v=vs.85).aspx
+ * It advises using GetConsoleScreenBufferInfo to get the current text
+ * attribute, then FillConsoleOutputCharacter and FillConsoleOutputAttribute to
+ * write to the console buffer.
+ */
+
+#include <windows.h>
+
+#include <cassert>
+#include <cstdio>
+#include <cstdlib>
+
+#include "TestUtil.cc"
+
+int main(int argc, char *argv[]) {
+    if (argc == 1) {
+        startChildProcess(L"CHILD");
+        return 0;
+    }
+
+    const HANDLE conout = GetStdHandle(STD_OUTPUT_HANDLE);
+
+    SetConsoleTextAttribute(conout, 0x24);
+    system("cls");
+
+    setWindowPos(0, 0, 1, 1);
+    setBufferSize(80, 25);
+    setWindowPos(0, 0, 80, 25);
+
+    CHAR_INFO buf;
+    COORD bufSize = { 1, 1 };
+    COORD bufCoord = { 0, 0 };
+    SMALL_RECT rect = { 5, 5, 5, 5 };
+    BOOL ret;
+    DWORD actual;
+    COORD writeCoord = { 5, 5 };
+
+    // After cls, each cell's character is a space, and its attributes are the
+    // default text attributes.
+    ret = ReadConsoleOutputW(conout, &buf, bufSize, bufCoord, &rect);
+    assert(ret && buf.Char.UnicodeChar == L' ' && buf.Attributes == 0x24);
+
+    // Nevertheless, it is possible to change a cell to NUL.
+    ret = FillConsoleOutputCharacterW(conout, L'\0', 1, writeCoord, &actual);
+    assert(ret && actual == 1);
+    ret = ReadConsoleOutputW(conout, &buf, bufSize, bufCoord, &rect);
+    assert(ret && buf.Char.UnicodeChar == L'\0' && buf.Attributes == 0x24);
+
+    // As well as a 0 attribute.  (As one would expect, the cell is
+    // black-on-black.)
+    ret = FillConsoleOutputAttribute(conout, 0, 1, writeCoord, &actual);
+    assert(ret && actual == 1);
+    ret = ReadConsoleOutputW(conout, &buf, bufSize, bufCoord, &rect);
+    assert(ret && buf.Char.UnicodeChar == L'\0' && buf.Attributes == 0);
+    ret = FillConsoleOutputCharacterW(conout, L'X', 1, writeCoord, &actual);
+    assert(ret && actual == 1);
+    ret = ReadConsoleOutputW(conout, &buf, bufSize, bufCoord, &rect);
+    assert(ret && buf.Char.UnicodeChar == L'X' && buf.Attributes == 0);
+
+    // The 'X' is invisible.
+    countDown(3);
+
+    ret = FillConsoleOutputAttribute(conout, 0x42, 1, writeCoord, &actual);
+    assert(ret && actual == 1);
+
+    countDown(5);
+}

package/dist/node_modules/node-pty/deps/winpty/misc/ConinMode.cc

@@ -0,0 +1,117 @@
+#include <windows.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <string>
+#include <vector>
+
+static HANDLE getConin() {
+    HANDLE conin = GetStdHandle(STD_INPUT_HANDLE);
+    if (conin == INVALID_HANDLE_VALUE) {
+        fprintf(stderr, "error: cannot get stdin\n");
+        exit(1);
+    }
+    return conin;
+}
+
+static DWORD getConsoleMode() {
+    DWORD mode = 0;
+    if (!GetConsoleMode(getConin(), &mode)) {
+        fprintf(stderr, "error: GetConsoleMode failed (is stdin a console?)\n");
+        exit(1);
+    }
+    return mode;
+}
+
+static void setConsoleMode(DWORD mode) {
+    if (!SetConsoleMode(getConin(), mode)) {
+        fprintf(stderr, "error: SetConsoleMode failed (is stdin a console?)\n");
+        exit(1);
+    }
+}
+
+static long parseInt(const std::string &s) {
+    errno = 0;
+    char *endptr = nullptr;
+    long result = strtol(s.c_str(), &endptr, 0);
+    if (errno != 0 || !endptr || *endptr != '\0') {
+        fprintf(stderr, "error: could not parse integral argument '%s'\n", s.c_str());
+        exit(1);
+    }
+    return result;
+}
+
+static void usage() {
+    printf("Usage: ConinMode [verb] [options]\n");
+    printf("Verbs:\n");
+    printf("    [info]      Dumps info about mode flags.\n");
+    printf("    get         Prints the mode DWORD.\n");
+    printf("    set VALUE   Sets the mode to VALUE, which can be decimal, hex, or octal.\n");
+    printf("    set VALUE MASK\n");
+    printf("                Same as `set VALUE`, but only alters the bits in MASK.\n");
+    exit(1);
+}
+
+struct {
+    const char *name;
+    DWORD value;
+} kInputFlags[] = {
+    "ENABLE_PROCESSED_INPUT",           ENABLE_PROCESSED_INPUT,         // 0x0001
+    "ENABLE_LINE_INPUT",                ENABLE_LINE_INPUT,              // 0x0002
+    "ENABLE_ECHO_INPUT",                ENABLE_ECHO_INPUT,              // 0x0004
+    "ENABLE_WINDOW_INPUT",              ENABLE_WINDOW_INPUT,            // 0x0008
+    "ENABLE_MOUSE_INPUT",               ENABLE_MOUSE_INPUT,             // 0x0010
+    "ENABLE_INSERT_MODE",               ENABLE_INSERT_MODE,             // 0x0020
+    "ENABLE_QUICK_EDIT_MODE",           ENABLE_QUICK_EDIT_MODE,         // 0x0040
+    "ENABLE_EXTENDED_FLAGS",            ENABLE_EXTENDED_FLAGS,          // 0x0080
+    "ENABLE_VIRTUAL_TERMINAL_INPUT", 0x0200/*ENABLE_VIRTUAL_TERMINAL_INPUT*/, // 0x0200
+};
+
+int main(int argc, char *argv[]) {
+    std::vector<std::string> args;
+    for (size_t i = 1; i < argc; ++i) {
+        args.push_back(argv[i]);
+    }
+
+    if (args.empty() || args.size() == 1 && args[0] == "info") {
+        DWORD mode = getConsoleMode();
+        printf("mode: 0x%lx\n", mode);
+        for (const auto &flag : kInputFlags) {
+            printf("%-29s 0x%04lx %s\n", flag.name, flag.value, flag.value & mode ? "ON" : "off");
+            mode &= ~flag.value;
+        }
+        for (int i = 0; i < 32; ++i) {
+            if (mode & (1u << i)) {
+                printf("Unrecognized flag: %04x\n", (1u << i));
+            }
+        }
+        return 0;
+    }
+
+    const auto verb = args[0];
+
+    if (verb == "set") {
+        if (args.size() == 2) {
+            const DWORD newMode = parseInt(args[1]);
+            setConsoleMode(newMode);
+        } else if (args.size() == 3) {
+            const DWORD mode = parseInt(args[1]);
+            const DWORD mask = parseInt(args[2]);
+            const int newMode = (getConsoleMode() & ~mask) | (mode & mask);
+            setConsoleMode(newMode);
+        } else {
+            usage();
+        }
+    } else if (verb == "get") {
+        if (args.size() != 1) {
+            usage();
+        }
+        printf("0x%lx\n", getConsoleMode());
+    } else {
+        usage();
+    }
+
+    return 0;
+}

package/dist/node_modules/node-pty/deps/winpty/misc/ConinMode.ps1

@@ -0,0 +1,116 @@
+#
+# PowerShell script for controlling the console QuickEdit and InsertMode flags.
+#
+# Turn QuickEdit off to interact with mouse-driven console programs.
+#
+# Usage:
+#
+# powershell .\ConinMode.ps1 [Options]
+#
+# Options:
+#   -QuickEdit [on/off]
+#   -InsertMode [on/off]
+#   -Mode [integer]
+#
+
+param (
+    [ValidateSet("on", "off")][string] $QuickEdit,
+    [ValidateSet("on", "off")][string] $InsertMode,
+    [int] $Mode
+)
+
+$signature = @'
+[DllImport("kernel32.dll", SetLastError = true)]
+public static extern IntPtr GetStdHandle(int nStdHandle);
+
+[DllImport("kernel32.dll", SetLastError = true)]
+public static extern uint GetConsoleMode(
+    IntPtr hConsoleHandle,
+    out uint lpMode);
+
+[DllImport("kernel32.dll", SetLastError = true)]
+public static extern uint SetConsoleMode(
+    IntPtr hConsoleHandle,
+    uint dwMode);
+
+public const int STD_INPUT_HANDLE = -10;
+public const int ENABLE_INSERT_MODE = 0x0020;
+public const int ENABLE_QUICK_EDIT_MODE = 0x0040;
+public const int ENABLE_EXTENDED_FLAGS = 0x0080;
+'@
+
+$WinAPI = Add-Type -MemberDefinition $signature `
+    -Name WinAPI -Namespace ConinModeScript `
+    -PassThru
+
+function GetConIn {
+    $ret = $WinAPI::GetStdHandle($WinAPI::STD_INPUT_HANDLE)
+    if ($ret -eq -1) {
+        throw "error: cannot get stdin"
+    }
+    return $ret
+}
+
+function GetConsoleMode {
+    $conin = GetConIn
+    $mode = 0
+    $ret = $WinAPI::GetConsoleMode($conin, [ref]$mode)
+    if ($ret -eq 0) {
+        throw "GetConsoleMode failed (is stdin a console?)"
+    }
+    return $mode
+}
+
+function SetConsoleMode($mode) {
+    $conin = GetConIn
+    $ret = $WinAPI::SetConsoleMode($conin, $mode)
+    if ($ret -eq 0) {
+        throw "SetConsoleMode failed (is stdin a console?)"
+    }
+}
+
+$oldMode = GetConsoleMode
+$newMode = $oldMode
+$doingSomething = $false
+
+if ($PSBoundParameters.ContainsKey("Mode")) {
+    $newMode = $Mode
+    $doingSomething = $true
+}
+
+if ($QuickEdit + $InsertMode -ne "") {
+    if (!($newMode -band $WinAPI::ENABLE_EXTENDED_FLAGS)) {
+        # We can't enable an extended flag without overwriting the existing
+        # QuickEdit/InsertMode flags.  AFAICT, there is no way to query their
+        # existing values, so at least we can choose sensible defaults.
+        $newMode = $newMode -bor $WinAPI::ENABLE_EXTENDED_FLAGS
+        $newMode = $newMode -bor $WinAPI::ENABLE_QUICK_EDIT_MODE
+        $newMode = $newMode -bor $WinAPI::ENABLE_INSERT_MODE
+        $doingSomething = $true
+    }
+}
+
+if ($QuickEdit -eq "on") {
+    $newMode = $newMode -bor $WinAPI::ENABLE_QUICK_EDIT_MODE
+    $doingSomething = $true
+} elseif ($QuickEdit -eq "off") {
+    $newMode = $newMode -band (-bnot $WinAPI::ENABLE_QUICK_EDIT_MODE)
+    $doingSomething = $true
+}
+
+if ($InsertMode -eq "on") {
+    $newMode = $newMode -bor $WinAPI::ENABLE_INSERT_MODE
+    $doingSomething = $true
+} elseif ($InsertMode -eq "off") {
+    $newMode = $newMode -band (-bnot $WinAPI::ENABLE_INSERT_MODE)
+    $doingSomething = $true
+}
+
+if ($doingSomething) {
+    echo "old mode: $oldMode"
+    SetConsoleMode $newMode
+    $newMode = GetConsoleMode
+    echo "new mode: $newMode"
+} else {
+    echo "mode: $oldMode"
+}