wtt-connect 0.2.19 → 0.2.21

package/node_modules/node-pty/deps/winpty/src/shared/GenRandom.cc

@@ -1,138 +0,0 @@
-// Copyright (c) 2016 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.
-
-#include "GenRandom.h"
-
-#include <stdint.h>
-#include <string.h>
-
-#include "DebugClient.h"
-#include "StringBuilder.h"
-
-static volatile LONG g_pipeCounter;
-
-GenRandom::GenRandom() : m_advapi32(L"advapi32.dll") {
-    // First try to use the pseudo-documented RtlGenRandom function from
-    // advapi32.dll.  Creating a CryptoAPI context is slow, and RtlGenRandom
-    // avoids the overhead.  It's documented in this blog post[1] and on
-    // MSDN[2] with a disclaimer about future breakage.  This technique is
-    // apparently built-in into the MSVC CRT, though, for the rand_s function,
-    // so perhaps it is stable enough.
-    //
-    // [1] http://blogs.msdn.com/b/michael_howard/archive/2005/01/14/353379.aspx
-    // [2] https://msdn.microsoft.com/en-us/library/windows/desktop/aa387694(v=vs.85).aspx
-    //
-    // Both RtlGenRandom and the Crypto API functions exist in XP and up.
-    m_rtlGenRandom = reinterpret_cast<RtlGenRandom_t*>(
-        m_advapi32.proc("SystemFunction036"));
-    // The OsModule class logs an error message if the proc is nullptr.
-    if (m_rtlGenRandom != nullptr) {
-        return;
-    }
-
-    // Fall back to the crypto API.
-    m_cryptProvIsValid =
-        CryptAcquireContext(&m_cryptProv, nullptr, nullptr,
-                            PROV_RSA_FULL, CRYPT_VERIFYCONTEXT) != 0;
-    if (!m_cryptProvIsValid) {
-        trace("GenRandom: CryptAcquireContext failed: %u",
-            static_cast<unsigned>(GetLastError()));
-    }
-}
-
-GenRandom::~GenRandom() {
-    if (m_cryptProvIsValid) {
-        CryptReleaseContext(m_cryptProv, 0);
-    }
-}
-
-// Returns false if the context is invalid or the generation fails.
-bool GenRandom::fillBuffer(void *buffer, size_t size) {
-    memset(buffer, 0, size);
-    bool success = false;
-    if (m_rtlGenRandom != nullptr) {
-        success = m_rtlGenRandom(buffer, size) != 0;
-        if (!success) {
-            trace("GenRandom: RtlGenRandom/SystemFunction036 failed: %u",
-                static_cast<unsigned>(GetLastError()));
-        }
-    } else if (m_cryptProvIsValid) {
-        success =
-            CryptGenRandom(m_cryptProv, size,
-                           reinterpret_cast<BYTE*>(buffer)) != 0;
-        if (!success) {
-            trace("GenRandom: CryptGenRandom failed, size=%d, lasterror=%u",
-                static_cast<int>(size),
-                static_cast<unsigned>(GetLastError()));
-        }
-    }
-    return success;
-}
-
-// Returns an empty string if either of CryptAcquireContext or CryptGenRandom
-// fail.
-std::string GenRandom::randomBytes(size_t numBytes) {
-    std::string ret(numBytes, '\0');
-    if (!fillBuffer(&ret[0], numBytes)) {
-        return std::string();
-    }
-    return ret;
-}
-
-std::wstring GenRandom::randomHexString(size_t numBytes) {
-    const std::string bytes = randomBytes(numBytes);
-    std::wstring ret(bytes.size() * 2, L'\0');
-    for (size_t i = 0; i < bytes.size(); ++i) {
-        static const wchar_t hex[] = L"0123456789abcdef";
-        ret[i * 2]     = hex[static_cast<uint8_t>(bytes[i]) >> 4];
-        ret[i * 2 + 1] = hex[static_cast<uint8_t>(bytes[i]) & 0xF];
-    }
-    return ret;
-}
-
-// Returns a 64-bit value representing the number of 100-nanosecond intervals
-// since January 1, 1601.
-static uint64_t systemTimeAsUInt64() {
-    FILETIME monotonicTime = {};
-    GetSystemTimeAsFileTime(&monotonicTime);
-    return (static_cast<uint64_t>(monotonicTime.dwHighDateTime) << 32) |
-            static_cast<uint64_t>(monotonicTime.dwLowDateTime);
-}
-
-// Generates a unique and hard-to-guess case-insensitive string suitable for
-// use in a pipe filename or a Windows object name.
-std::wstring GenRandom::uniqueName() {
-    // First include enough information to avoid collisions assuming
-    // cooperative software.  This code assumes that a process won't die and
-    // be replaced with a recycled PID within a single GetSystemTimeAsFileTime
-    // interval.
-    WStringBuilder sb(64);
-    sb << GetCurrentProcessId()
-       << L'-' << InterlockedIncrement(&g_pipeCounter)
-       << L'-' << whexOfInt(systemTimeAsUInt64());
-    // It isn't clear to me how the crypto APIs would fail.  It *probably*
-    // doesn't matter that much anyway?  In principle, a predictable pipe name
-    // is subject to a local denial-of-service attack.
-    auto random = randomHexString(16);
-    if (!random.empty()) {
-        sb << L'-' << random;
-    }
-    return sb.str_moved();
-}

package/node_modules/node-pty/deps/winpty/src/shared/GenRandom.h

@@ -1,55 +0,0 @@
-// Copyright (c) 2016 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.
-
-#ifndef WINPTY_GEN_RANDOM_H
-#define WINPTY_GEN_RANDOM_H
-
-// The original MinGW requires that we include wincrypt.h.  With MinGW-w64 and
-// MSVC, including windows.h is sufficient.
-#include <windows.h>
-#include <wincrypt.h>
-
-#include <string>
-
-#include "OsModule.h"
-
-class GenRandom {
-    typedef BOOLEAN WINAPI RtlGenRandom_t(PVOID, ULONG);
-
-    OsModule m_advapi32;
-    RtlGenRandom_t *m_rtlGenRandom = nullptr;
-    bool m_cryptProvIsValid = false;
-    HCRYPTPROV m_cryptProv = 0;
-
-public:
-    GenRandom();
-    ~GenRandom();
-    bool fillBuffer(void *buffer, size_t size);
-    std::string randomBytes(size_t numBytes);
-    std::wstring randomHexString(size_t numBytes);
-    std::wstring uniqueName();
-
-    // Return true if the crypto context was successfully initialized.
-    bool valid() const {
-        return m_rtlGenRandom != nullptr || m_cryptProvIsValid;
-    }
-};
-
-#endif // WINPTY_GEN_RANDOM_H

package/node_modules/node-pty/deps/winpty/src/shared/GetCommitHash.bat

@@ -1,13 +0,0 @@
-@echo off
-
-REM -- Echo the git commit hash.  If git isn't available for some reason,
-REM -- output nothing instead.
-
-git rev-parse HEAD >NUL 2>NUL && (
-    git rev-parse HEAD
-) || (
-    echo none
-)
-
-REM -- Set ERRORLEVEL to 0 using this cryptic syntax.
-(call )

package/node_modules/node-pty/deps/winpty/src/shared/Mutex.h

@@ -1,54 +0,0 @@
-// Copyright (c) 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.
-
-// Recent 4.x MinGW and MinGW-w64 gcc compilers lack std::mutex and
-// std::lock_guard.  I have a 5.2.0 MinGW-w64 compiler packaged through MSYS2
-// that *is* new enough, but that's one compiler against several deficient
-// ones.  Wrap CRITICAL_SECTION instead.
-
-#ifndef WINPTY_SHARED_MUTEX_H
-#define WINPTY_SHARED_MUTEX_H
-
-#include <windows.h>
-
-class Mutex {
-    CRITICAL_SECTION m_mutex;
-public:
-    Mutex()         { InitializeCriticalSection(&m_mutex);  }
-    ~Mutex()        { DeleteCriticalSection(&m_mutex);      }
-    void lock()     { EnterCriticalSection(&m_mutex);       }
-    void unlock()   { LeaveCriticalSection(&m_mutex);       }
-
-    Mutex(const Mutex &other) = delete;
-    Mutex &operator=(const Mutex &other) = delete;
-};
-
-template <typename T>
-class LockGuard {
-    T &m_lock;
-public:
-    LockGuard(T &lock) : m_lock(lock)  { m_lock.lock();    }
-    ~LockGuard()                       { m_lock.unlock();  }
-
-    LockGuard(const LockGuard &other) = delete;
-    LockGuard &operator=(const LockGuard &other) = delete;
-};
-
-#endif // WINPTY_SHARED_MUTEX_H

package/node_modules/node-pty/deps/winpty/src/shared/OsModule.h

@@ -1,63 +0,0 @@
-// Copyright (c) 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.
-
-#ifndef WINPTY_SHARED_OS_MODULE_H
-#define WINPTY_SHARED_OS_MODULE_H
-
-#include <windows.h>
-
-#include <string>
-
-#include "DebugClient.h"
-#include "WinptyAssert.h"
-#include "WinptyException.h"
-
-class OsModule {
-    HMODULE m_module;
-public:
-    enum class LoadErrorBehavior { Abort, Throw };
-    OsModule(const wchar_t *fileName,
-            LoadErrorBehavior behavior=LoadErrorBehavior::Abort) {
-        m_module = LoadLibraryW(fileName);
-        if (behavior == LoadErrorBehavior::Abort) {
-            ASSERT(m_module != NULL);
-        } else {
-            if (m_module == nullptr) {
-                const auto err = GetLastError();
-                throwWindowsError(
-                    (L"LoadLibraryW error: " + std::wstring(fileName)).c_str(),
-                    err);
-            }
-        }
-    }
-    ~OsModule() {
-        FreeLibrary(m_module);
-    }
-    HMODULE handle() const { return m_module; }
-    FARPROC proc(const char *funcName) {
-        FARPROC ret = GetProcAddress(m_module, funcName);
-        if (ret == NULL) {
-            trace("GetProcAddress: %s is missing", funcName);
-        }
-        return ret;
-    }
-};
-
-#endif // WINPTY_SHARED_OS_MODULE_H

package/node_modules/node-pty/deps/winpty/src/shared/OwnedHandle.cc

@@ -1,36 +0,0 @@
-// Copyright (c) 2016 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.
-
-#include "OwnedHandle.h"
-
-#include "DebugClient.h"
-#include "WinptyException.h"
-
-void OwnedHandle::dispose(bool nothrow) {
-    if (m_h != nullptr && m_h != INVALID_HANDLE_VALUE) {
-        if (!CloseHandle(m_h)) {
-            trace("CloseHandle(%p) failed", m_h);
-            if (!nothrow) {
-                throwWindowsError(L"CloseHandle failed");
-            }
-        }
-    }
-    m_h = nullptr;
-}

package/node_modules/node-pty/deps/winpty/src/shared/OwnedHandle.h

@@ -1,45 +0,0 @@
-// Copyright (c) 2016 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.
-
-#ifndef WINPTY_SHARED_OWNED_HANDLE_H
-#define WINPTY_SHARED_OWNED_HANDLE_H
-
-#include <windows.h>
-
-class OwnedHandle {
-    HANDLE m_h;
-public:
-    OwnedHandle() : m_h(nullptr) {}
-    explicit OwnedHandle(HANDLE h) : m_h(h) {}
-    ~OwnedHandle() { dispose(true); }
-    void dispose(bool nothrow=false);
-    HANDLE get() const { return m_h; }
-    HANDLE release() { HANDLE ret = m_h; m_h = nullptr; return ret; }
-    OwnedHandle(const OwnedHandle &other) = delete;
-    OwnedHandle(OwnedHandle &&other) : m_h(other.release()) {}
-    OwnedHandle &operator=(const OwnedHandle &other) = delete;
-    OwnedHandle &operator=(OwnedHandle &&other) {
-        dispose();
-        m_h = other.release();
-        return *this;
-    }
-};
-
-#endif // WINPTY_SHARED_OWNED_HANDLE_H

package/node_modules/node-pty/deps/winpty/src/shared/PrecompiledHeader.h

@@ -1,43 +0,0 @@
-// Copyright (c) 2016 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.
-
-#ifndef WINPTY_PRECOMPILED_HEADER_H
-#define WINPTY_PRECOMPILED_HEADER_H
-
-#include <windows.h>
-
-#include <stdarg.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <wchar.h>
-
-#include <array>
-#include <limits>
-#include <memory>
-#include <new>
-#include <string>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-#endif // WINPTY_PRECOMPILED_HEADER_H

package/node_modules/node-pty/deps/winpty/src/shared/StringBuilder.h

@@ -1,227 +0,0 @@
-// Copyright (c) 2016 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.
-
-// Efficient integer->string conversion and string concatenation.  The
-// hexadecimal conversion may optionally have leading zeros.  Other ways to
-// convert integers to strings in C++ suffer these drawbacks:
-//
-//  * std::stringstream: Inefficient, even more so than stdio.
-//
-//  * std::to_string: No hexadecimal output, tends to use heap allocation, not
-//    supported on Cygwin.
-//
-//  * stdio routines: Requires parsing a format string (inefficient).  The
-//    caller *must* know how large the content is for correctness.  The
-//    string-printf functions are extremely inconsistent on Windows.  In
-//    particular, 64-bit integers, wide strings, and return values are
-//    problem areas.
-//
-// StringBuilderTest.cc is a standalone program that tests this header.
-
-#ifndef WINPTY_STRING_BUILDER_H
-#define WINPTY_STRING_BUILDER_H
-
-#include <array>
-#include <string>
-#include <type_traits>
-
-#ifdef STRING_BUILDER_TESTING
-#include <assert.h>
-#define STRING_BUILDER_CHECK(cond) assert(cond)
-#else
-#define STRING_BUILDER_CHECK(cond)
-#endif // STRING_BUILDER_TESTING
-
-#include "WinptyAssert.h"
-
-template <typename C, size_t sz>
-struct ValueString {
-    std::array<C, sz> m_array;
-    size_t m_offset;
-    size_t m_size;
-
-    const C *c_str() const { return m_array.data() + m_offset; }
-    const C *data() const { return m_array.data() + m_offset; }
-    size_t size() const { return m_size; }
-    std::basic_string<C> str() const {
-        return std::basic_string<C>(data(), m_size);
-    }
-};
-
-#ifdef _MSC_VER
-// Disable an MSVC /SDL error that forbids unsigned negation.  Signed negation
-// invokes undefined behavior for INTxx_MIN, so unsigned negation is simpler to
-// reason about.  (We assume twos-complement in any case.)
-#define STRING_BUILDER_ALLOW_UNSIGNED_NEGATE(x) \
-    (                                           \
-        __pragma(warning(push))                 \
-        __pragma(warning(disable:4146))         \
-        (x)                                     \
-        __pragma(warning(pop))                  \
-    )
-#else
-#define STRING_BUILDER_ALLOW_UNSIGNED_NEGATE(x) (x)
-#endif
-
-// Formats an integer as decimal without leading zeros.
-template <typename C, typename I>
-ValueString<C, sizeof(I) * 3 + 1 + 1> gdecOfInt(const I value) {
-    typedef typename std::make_unsigned<I>::type U;
-    auto unsValue = static_cast<U>(value);
-    const bool isNegative = (value < 0);
-    if (isNegative) {
-        unsValue = STRING_BUILDER_ALLOW_UNSIGNED_NEGATE(-unsValue);
-    }
-    decltype(gdecOfInt<C, I>(value)) out;
-    auto &arr = out.m_array;
-    C *const endp = arr.data() + arr.size();
-    C *outp = endp;
-    *(--outp) = '\0';
-    STRING_BUILDER_CHECK(outp >= arr.data());
-    do {
-        const int digit = unsValue % 10;
-        unsValue /= 10;
-        *(--outp) = '0' + digit;
-        STRING_BUILDER_CHECK(outp >= arr.data());
-    } while (unsValue != 0);
-    if (isNegative) {
-        *(--outp) = '-';
-        STRING_BUILDER_CHECK(outp >= arr.data());
-    }
-    out.m_offset = outp - arr.data();
-    out.m_size = endp - outp - 1;
-    return out;
-}
-
-template <typename I> decltype(gdecOfInt<char, I>(0)) decOfInt(I i) {
-    return gdecOfInt<char>(i);
-}
-
-template <typename I> decltype(gdecOfInt<wchar_t, I>(0)) wdecOfInt(I i) {
-    return gdecOfInt<wchar_t>(i);
-}
-
-// Formats an integer as hexadecimal, with or without leading zeros.
-template <typename C, bool leadingZeros=false, typename I>
-ValueString<C, sizeof(I) * 2 + 1> ghexOfInt(const I value) {
-    typedef typename std::make_unsigned<I>::type U;
-    const auto unsValue = static_cast<U>(value);
-    static const C hex[16] = {'0','1','2','3','4','5','6','7',
-                              '8','9','a','b','c','d','e','f'};
-    decltype(ghexOfInt<C, leadingZeros, I>(value)) out;
-    auto &arr = out.m_array;
-    C *outp = arr.data();
-    int inIndex = 0;
-    int shift = sizeof(I) * 8 - 4;
-    const int len = sizeof(I) * 2;
-    if (!leadingZeros) {
-        for (; inIndex < len - 1; ++inIndex, shift -= 4) {
-            STRING_BUILDER_CHECK(shift >= 0 && shift < sizeof(unsValue) * 8);
-            const int digit = (unsValue >> shift) & 0xF;
-            if (digit != 0) {
-                break;
-            }
-        }
-    }
-    for (; inIndex < len; ++inIndex, shift -= 4) {
-        const int digit = (unsValue >> shift) & 0xF;
-        *(outp++) = hex[digit];
-        STRING_BUILDER_CHECK(outp <= arr.data() + arr.size());
-    }
-    *(outp++) = '\0';
-    STRING_BUILDER_CHECK(outp <= arr.data() + arr.size());
-    out.m_offset = 0;
-    out.m_size = outp - arr.data() - 1;
-    return out;
-}
-
-template <bool leadingZeros=false, typename I>
-decltype(ghexOfInt<char, leadingZeros, I>(0)) hexOfInt(I i) {
-    return ghexOfInt<char, leadingZeros, I>(i);
-}
-
-template <bool leadingZeros=false, typename I>
-decltype(ghexOfInt<wchar_t, leadingZeros, I>(0)) whexOfInt(I i) {
-    return ghexOfInt<wchar_t, leadingZeros, I>(i);
-}
-
-template <typename C>
-class GStringBuilder {
-public:
-    typedef std::basic_string<C> StringType;
-
-    GStringBuilder() {}
-    GStringBuilder(size_t capacity) {
-        m_out.reserve(capacity);
-    }
-
-    GStringBuilder &operator<<(C ch) { m_out.push_back(ch); return *this; }
-    GStringBuilder &operator<<(const C *str) { m_out.append(str); return *this; }
-    GStringBuilder &operator<<(const StringType &str) { m_out.append(str); return *this; }
-
-    template <size_t sz>
-    GStringBuilder &operator<<(const ValueString<C, sz> &str) {
-        m_out.append(str.data(), str.size());
-        return *this;
-    }
-
-private:
-    // Forbid output of char/wchar_t for GStringBuilder if the type doesn't
-    // exactly match the builder element type.  The code still allows
-    // signed char and unsigned char, but I'm a little worried about what
-    // happens if a user tries to output int8_t or uint8_t.
-    template <typename P>
-    typename std::enable_if<
-        (std::is_same<P, char>::value || std::is_same<P, wchar_t>::value) &&
-        !std::is_same<C, P>::value, GStringBuilder&>::type
-    operator<<(P ch) {
-        ASSERT(false && "Method was not supposed to be reachable.");
-        return *this;
-    }
-
-public:
-    GStringBuilder &operator<<(short i)              { return *this << gdecOfInt<C>(i); }
-    GStringBuilder &operator<<(unsigned short i)     { return *this << gdecOfInt<C>(i); }
-    GStringBuilder &operator<<(int i)                { return *this << gdecOfInt<C>(i); }
-    GStringBuilder &operator<<(unsigned int i)       { return *this << gdecOfInt<C>(i); }
-    GStringBuilder &operator<<(long i)               { return *this << gdecOfInt<C>(i); }
-    GStringBuilder &operator<<(unsigned long i)      { return *this << gdecOfInt<C>(i); }
-    GStringBuilder &operator<<(long long i)          { return *this << gdecOfInt<C>(i); }
-    GStringBuilder &operator<<(unsigned long long i) { return *this << gdecOfInt<C>(i); }
-
-    GStringBuilder &operator<<(const void *p) {
-        m_out.push_back(static_cast<C>('0'));
-        m_out.push_back(static_cast<C>('x'));
-        *this << ghexOfInt<C>(reinterpret_cast<uintptr_t>(p));
-        return *this;
-    }
-
-    StringType str() { return m_out; }
-    StringType str_moved() { return std::move(m_out); }
-    const C *c_str() const { return m_out.c_str(); }
-
-private:
-    StringType m_out;
-};
-
-typedef GStringBuilder<char> StringBuilder;
-typedef GStringBuilder<wchar_t> WStringBuilder;
-
-#endif // WINPTY_STRING_BUILDER_H