codexui-android 0.1.95 → 0.1.96

package/vendor/node_modules/node-pty/deps/winpty/src/agent/DefaultInputMap.cc

@@ -1,422 +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.
-
-#include "DefaultInputMap.h"
-
-#include <windows.h>
-#include <string.h>
-
-#include <algorithm>
-
-#include "../shared/StringBuilder.h"
-#include "../shared/WinptyAssert.h"
-#include "InputMap.h"
-
-#define ESC "\x1B"
-#define DIM(x) (sizeof(x) / sizeof((x)[0]))
-
-namespace {
-
-struct EscapeEncoding {
-    bool alt_prefix_allowed;
-    char prefix;
-    char id;
-    int modifiers;
-    InputMap::Key key;
-};
-
-// Modifiers.  A "modifier" is an integer from 2 to 8 that conveys the status
-// of Shift(1), Alt(2), and Ctrl(4).  The value is constructed by OR'ing the
-// appropriate value for each active modifier, then adding 1.
-//
-// Details:
-//  - kBare:    expands to: ESC <prefix> <suffix>
-//  - kSemiMod: expands to: ESC <prefix> <numid> ; <mod> <suffix>
-//  - kBareMod: expands to: ESC <prefix> <mod> <suffix>
-const int kBare        = 0x01;
-const int kSemiMod     = 0x02;
-const int kBareMod     = 0x04;
-
-// Numeric escape sequences suffixes:
-//  - with no flag: accept: ~
-//  - kSuffixCtrl:  accept: ~ ^
-//  - kSuffixShift: accept: ~ $
-//  - kSuffixBoth:  accept: ~ ^ $ @
-const int kSuffixCtrl  = 0x08;
-const int kSuffixShift = 0x10;
-const int kSuffixBoth  = kSuffixCtrl | kSuffixShift;
-
-static const EscapeEncoding escapeLetterEncodings[] = {
-    // Conventional arrow keys
-    // kBareMod: Ubuntu /etc/inputrc and IntelliJ/JediTerm use escapes like: ESC [ n ABCD
-    { true,  '[', 'A', kBare | kBareMod | kSemiMod, { VK_UP,      '\0', 0             } },
-    { true,  '[', 'B', kBare | kBareMod | kSemiMod, { VK_DOWN,    '\0', 0             } },
-    { true,  '[', 'C', kBare | kBareMod | kSemiMod, { VK_RIGHT,   '\0', 0             } },
-    { true,  '[', 'D', kBare | kBareMod | kSemiMod, { VK_LEFT,    '\0', 0             } },
-
-    // putty.  putty uses this sequence for Ctrl-Arrow, Shift-Arrow, and
-    // Ctrl-Shift-Arrow, but I can only decode to one choice, so I'm just
-    // leaving the modifier off altogether.
-    { true,  'O', 'A', kBare,                       { VK_UP,      '\0', 0             } },
-    { true,  'O', 'B', kBare,                       { VK_DOWN,    '\0', 0             } },
-    { true,  'O', 'C', kBare,                       { VK_RIGHT,   '\0', 0             } },
-    { true,  'O', 'D', kBare,                       { VK_LEFT,    '\0', 0             } },
-
-    // rxvt, rxvt-unicode
-    // Shift-Ctrl-Arrow can't be identified.  It's the same as Shift-Arrow.
-    { true,  '[', 'a', kBare,                       { VK_UP,      '\0', SHIFT_PRESSED       } },
-    { true,  '[', 'b', kBare,                       { VK_DOWN,    '\0', SHIFT_PRESSED       } },
-    { true,  '[', 'c', kBare,                       { VK_RIGHT,   '\0', SHIFT_PRESSED       } },
-    { true,  '[', 'd', kBare,                       { VK_LEFT,    '\0', SHIFT_PRESSED       } },
-    { true,  'O', 'a', kBare,                       { VK_UP,      '\0', LEFT_CTRL_PRESSED   } },
-    { true,  'O', 'b', kBare,                       { VK_DOWN,    '\0', LEFT_CTRL_PRESSED   } },
-    { true,  'O', 'c', kBare,                       { VK_RIGHT,   '\0', LEFT_CTRL_PRESSED   } },
-    { true,  'O', 'd', kBare,                       { VK_LEFT,    '\0', LEFT_CTRL_PRESSED   } },
-
-    // Numpad 5 with NumLock off
-    //  * xterm, mintty, and gnome-terminal use `ESC [ E`.
-    //  * putty, TERM=cygwin, TERM=linux all use `ESC [ G` for 5
-    //  * putty uses `ESC O G` for Ctrl-5 and Shift-5.  Omit the modifier
-    //    as with putty's arrow keys.
-    //  * I never saw modifiers inserted into these escapes, but I think
-    //    it should be completely OK with the CSI escapes.
-    { true,  '[', 'E', kBare | kSemiMod,            { VK_CLEAR,   '\0', 0             } },
-    { true,  '[', 'G', kBare | kSemiMod,            { VK_CLEAR,   '\0', 0             } },
-    { true,  'O', 'G', kBare,                       { VK_CLEAR,   '\0', 0             } },
-
-    // Home/End, letter version
-    //  * gnome-terminal uses `ESC O [HF]`.  I never saw it modified.
-    // kBareMod: IntelliJ/JediTerm uses escapes like: ESC [ n HF
-    { true,  '[', 'H', kBare | kBareMod | kSemiMod, { VK_HOME,    '\0', 0             } },
-    { true,  '[', 'F', kBare | kBareMod | kSemiMod, { VK_END,     '\0', 0             } },
-    { true,  'O', 'H', kBare,                       { VK_HOME,    '\0', 0             } },
-    { true,  'O', 'F', kBare,                       { VK_END,     '\0', 0             } },
-
-    // F1-F4, letter version (xterm, VTE, konsole)
-    { true,  '[', 'P', kSemiMod,                    { VK_F1,      '\0', 0             } },
-    { true,  '[', 'Q', kSemiMod,                    { VK_F2,      '\0', 0             } },
-    { true,  '[', 'R', kSemiMod,                    { VK_F3,      '\0', 0             } },
-    { true,  '[', 'S', kSemiMod,                    { VK_F4,      '\0', 0             } },
-
-    // GNOME VTE and Konsole have special encodings for modified F1-F4:
-    //  * [VTE]     ESC O 1 ; n [PQRS]
-    //  * [Konsole] ESC O     n [PQRS]
-    { false, 'O', 'P', kBare | kBareMod | kSemiMod, { VK_F1,      '\0', 0             } },
-    { false, 'O', 'Q', kBare | kBareMod | kSemiMod, { VK_F2,      '\0', 0             } },
-    { false, 'O', 'R', kBare | kBareMod | kSemiMod, { VK_F3,      '\0', 0             } },
-    { false, 'O', 'S', kBare | kBareMod | kSemiMod, { VK_F4,      '\0', 0             } },
-
-    // Handle the "application numpad" escape sequences.
-    //
-    // Terminals output these codes under various circumstances:
-    //  * rxvt-unicode: numpad, hold down SHIFT
-    //  * rxvt: numpad, by default
-    //  * xterm: numpad, after enabling app-mode using DECPAM (`ESC =`).  xterm
-    //    generates `ESC O <mod> <letter>` for modified numpad presses,
-    //    necessitating kBareMod.
-    //  * mintty: by combining Ctrl with various keys such as '1' or ','.
-    //    Handling those keys is difficult, because mintty is generating the
-    //    same sequence for Ctrl-1 and Ctrl-NumPadEnd -- should the virtualKey
-    //    be '1' or VK_HOME?
-
-    { true,  'O', 'M', kBare | kBareMod,            { VK_RETURN,   '\r',   0 } },
-    { true,  'O', 'j', kBare | kBareMod,            { VK_MULTIPLY, '*',    0 } },
-    { true,  'O', 'k', kBare | kBareMod,            { VK_ADD,      '+',    0 } },
-    { true,  'O', 'm', kBare | kBareMod,            { VK_SUBTRACT, '-',    0 } },
-    { true,  'O', 'n', kBare | kBareMod,            { VK_DELETE,   '\0',   0 } },
-    { true,  'O', 'o', kBare | kBareMod,            { VK_DIVIDE,   '/',    0 } },
-    { true,  'O', 'p', kBare | kBareMod,            { VK_INSERT,   '\0',   0 } },
-    { true,  'O', 'q', kBare | kBareMod,            { VK_END,      '\0',   0 } },
-    { true,  'O', 'r', kBare | kBareMod,            { VK_DOWN,     '\0',   0 } },
-    { true,  'O', 's', kBare | kBareMod,            { VK_NEXT,     '\0',   0 } },
-    { true,  'O', 't', kBare | kBareMod,            { VK_LEFT,     '\0',   0 } },
-    { true,  'O', 'u', kBare | kBareMod,            { VK_CLEAR,    '\0',   0 } },
-    { true,  'O', 'v', kBare | kBareMod,            { VK_RIGHT,    '\0',   0 } },
-    { true,  'O', 'w', kBare | kBareMod,            { VK_HOME,     '\0',   0 } },
-    { true,  'O', 'x', kBare | kBareMod,            { VK_UP,       '\0',   0 } },
-    { true,  'O', 'y', kBare | kBareMod,            { VK_PRIOR,    '\0',   0 } },
-
-    { true,  '[', 'M', kBare | kSemiMod,            { VK_RETURN,   '\r',   0 } },
-    { true,  '[', 'j', kBare | kSemiMod,            { VK_MULTIPLY, '*',    0 } },
-    { true,  '[', 'k', kBare | kSemiMod,            { VK_ADD,      '+',    0 } },
-    { true,  '[', 'm', kBare | kSemiMod,            { VK_SUBTRACT, '-',    0 } },
-    { true,  '[', 'n', kBare | kSemiMod,            { VK_DELETE,   '\0',   0 } },
-    { true,  '[', 'o', kBare | kSemiMod,            { VK_DIVIDE,   '/',    0 } },
-    { true,  '[', 'p', kBare | kSemiMod,            { VK_INSERT,   '\0',   0 } },
-    { true,  '[', 'q', kBare | kSemiMod,            { VK_END,      '\0',   0 } },
-    { true,  '[', 'r', kBare | kSemiMod,            { VK_DOWN,     '\0',   0 } },
-    { true,  '[', 's', kBare | kSemiMod,            { VK_NEXT,     '\0',   0 } },
-    { true,  '[', 't', kBare | kSemiMod,            { VK_LEFT,     '\0',   0 } },
-    { true,  '[', 'u', kBare | kSemiMod,            { VK_CLEAR,    '\0',   0 } },
-    { true,  '[', 'v', kBare | kSemiMod,            { VK_RIGHT,    '\0',   0 } },
-    { true,  '[', 'w', kBare | kSemiMod,            { VK_HOME,     '\0',   0 } },
-    { true,  '[', 'x', kBare | kSemiMod,            { VK_UP,       '\0',   0 } },
-    { true,  '[', 'y', kBare | kSemiMod,            { VK_PRIOR,    '\0',   0 } },
-
-    { false, '[', 'Z', kBare,                       { VK_TAB,     '\t', SHIFT_PRESSED } },
-};
-
-static const EscapeEncoding escapeNumericEncodings[] = {
-    { true,  '[',  1,  kBare | kSemiMod | kSuffixBoth,      { VK_HOME,    '\0', 0             } },
-    { true,  '[',  2,  kBare | kSemiMod | kSuffixBoth,      { VK_INSERT,  '\0', 0             } },
-    { true,  '[',  3,  kBare | kSemiMod | kSuffixBoth,      { VK_DELETE,  '\0', 0             } },
-    { true,  '[',  4,  kBare | kSemiMod | kSuffixBoth,      { VK_END,     '\0', 0             } },
-    { true,  '[',  5,  kBare | kSemiMod | kSuffixBoth,      { VK_PRIOR,   '\0', 0             } },
-    { true,  '[',  6,  kBare | kSemiMod | kSuffixBoth,      { VK_NEXT,    '\0', 0             } },
-    { true,  '[',  7,  kBare | kSemiMod | kSuffixBoth,      { VK_HOME,    '\0', 0             } },
-    { true,  '[',  8,  kBare | kSemiMod | kSuffixBoth,      { VK_END,     '\0', 0             } },
-    { true,  '[', 11,  kBare | kSemiMod | kSuffixBoth,      { VK_F1,      '\0', 0             } },
-    { true,  '[', 12,  kBare | kSemiMod | kSuffixBoth,      { VK_F2,      '\0', 0             } },
-    { true,  '[', 13,  kBare | kSemiMod | kSuffixBoth,      { VK_F3,      '\0', 0             } },
-    { true,  '[', 14,  kBare | kSemiMod | kSuffixBoth,      { VK_F4,      '\0', 0             } },
-    { true,  '[', 15,  kBare | kSemiMod | kSuffixBoth,      { VK_F5,      '\0', 0             } },
-    { true,  '[', 17,  kBare | kSemiMod | kSuffixBoth,      { VK_F6,      '\0', 0             } },
-    { true,  '[', 18,  kBare | kSemiMod | kSuffixBoth,      { VK_F7,      '\0', 0             } },
-    { true,  '[', 19,  kBare | kSemiMod | kSuffixBoth,      { VK_F8,      '\0', 0             } },
-    { true,  '[', 20,  kBare | kSemiMod | kSuffixBoth,      { VK_F9,      '\0', 0             } },
-    { true,  '[', 21,  kBare | kSemiMod | kSuffixBoth,      { VK_F10,     '\0', 0             } },
-    { true,  '[', 23,  kBare | kSemiMod | kSuffixBoth,      { VK_F11,     '\0', 0             } },
-    { true,  '[', 24,  kBare | kSemiMod | kSuffixBoth,      { VK_F12,     '\0', 0             } },
-    { true,  '[', 25,  kBare | kSemiMod | kSuffixBoth,      { VK_F3,      '\0', SHIFT_PRESSED } },
-    { true,  '[', 26,  kBare | kSemiMod | kSuffixBoth,      { VK_F4,      '\0', SHIFT_PRESSED } },
-    { true,  '[', 28,  kBare | kSemiMod | kSuffixBoth,      { VK_F5,      '\0', SHIFT_PRESSED } },
-    { true,  '[', 29,  kBare | kSemiMod | kSuffixBoth,      { VK_F6,      '\0', SHIFT_PRESSED } },
-    { true,  '[', 31,  kBare | kSemiMod | kSuffixBoth,      { VK_F7,      '\0', SHIFT_PRESSED } },
-    { true,  '[', 32,  kBare | kSemiMod | kSuffixBoth,      { VK_F8,      '\0', SHIFT_PRESSED } },
-    { true,  '[', 33,  kBare | kSemiMod | kSuffixBoth,      { VK_F9,      '\0', SHIFT_PRESSED } },
-    { true,  '[', 34,  kBare | kSemiMod | kSuffixBoth,      { VK_F10,     '\0', SHIFT_PRESSED } },
-};
-
-const int kCsiShiftModifier = 1;
-const int kCsiAltModifier   = 2;
-const int kCsiCtrlModifier  = 4;
-
-static inline bool useEnhancedForVirtualKey(uint16_t vk) {
-    switch (vk) {
-        case VK_UP:
-        case VK_DOWN:
-        case VK_LEFT:
-        case VK_RIGHT:
-        case VK_INSERT:
-        case VK_DELETE:
-        case VK_HOME:
-        case VK_END:
-        case VK_PRIOR:
-        case VK_NEXT:
-            return true;
-        default:
-            return false;
-    }
-}
-
-static void addSimpleEntries(InputMap &inputMap) {
-    struct SimpleEncoding {
-        const char *encoding;
-        InputMap::Key key;
-    };
-
-    static const SimpleEncoding simpleEncodings[] = {
-        // Ctrl-<letter/digit> seems to be handled OK by the default code path.
-
-        {   "\x7F",         { VK_BACK,  '\x08', 0,                                  } },
-        {   ESC "\x7F",     { VK_BACK,  '\x08', LEFT_ALT_PRESSED,                   } },
-        {   "\x03",         { 'C',      '\x03', LEFT_CTRL_PRESSED,                  } },
-
-        // Handle special F1-F5 for TERM=linux and TERM=cygwin.
-        {   ESC "[[A",      { VK_F1,    '\0',   0                                   } },
-        {   ESC "[[B",      { VK_F2,    '\0',   0                                   } },
-        {   ESC "[[C",      { VK_F3,    '\0',   0                                   } },
-        {   ESC "[[D",      { VK_F4,    '\0',   0                                   } },
-        {   ESC "[[E",      { VK_F5,    '\0',   0                                   } },
-
-        {   ESC ESC "[[A",  { VK_F1,    '\0',   LEFT_ALT_PRESSED                    } },
-        {   ESC ESC "[[B",  { VK_F2,    '\0',   LEFT_ALT_PRESSED                    } },
-        {   ESC ESC "[[C",  { VK_F3,    '\0',   LEFT_ALT_PRESSED                    } },
-        {   ESC ESC "[[D",  { VK_F4,    '\0',   LEFT_ALT_PRESSED                    } },
-        {   ESC ESC "[[E",  { VK_F5,    '\0',   LEFT_ALT_PRESSED                    } },
-    };
-
-    for (size_t i = 0; i < DIM(simpleEncodings); ++i) {
-        auto k = simpleEncodings[i].key;
-        if (useEnhancedForVirtualKey(k.virtualKey)) {
-            k.keyState |= ENHANCED_KEY;
-        }
-        inputMap.set(simpleEncodings[i].encoding,
-                     strlen(simpleEncodings[i].encoding),
-                     k);
-    }
-}
-
-struct ExpandContext {
-    InputMap &inputMap;
-    const EscapeEncoding &e;
-    char *buffer;
-    char *bufferEnd;
-};
-
-static inline void setEncoding(const ExpandContext &ctx, char *end,
-                               uint16_t extraKeyState) {
-    InputMap::Key k = ctx.e.key;
-    k.keyState |= extraKeyState;
-    if (k.keyState & LEFT_CTRL_PRESSED) {
-        switch (k.virtualKey) {
-            case VK_ADD:
-            case VK_DIVIDE:
-            case VK_MULTIPLY:
-            case VK_SUBTRACT:
-                k.unicodeChar = '\0';
-                break;
-            case VK_RETURN:
-                k.unicodeChar = '\n';
-                break;
-        }
-    }
-    if (useEnhancedForVirtualKey(k.virtualKey)) {
-        k.keyState |= ENHANCED_KEY;
-    }
-    ctx.inputMap.set(ctx.buffer, end - ctx.buffer, k);
-}
-
-static inline uint16_t keyStateForMod(int mod) {
-    int ret = 0;
-    if ((mod - 1) & kCsiShiftModifier)  ret |= SHIFT_PRESSED;
-    if ((mod - 1) & kCsiAltModifier)    ret |= LEFT_ALT_PRESSED;
-    if ((mod - 1) & kCsiCtrlModifier)   ret |= LEFT_CTRL_PRESSED;
-    return ret;
-}
-
-static void expandNumericEncodingSuffix(const ExpandContext &ctx, char *p,
-        uint16_t extraKeyState) {
-    ASSERT(p <= ctx.bufferEnd - 1);
-    {
-        char *q = p;
-        *q++ = '~';
-        setEncoding(ctx, q, extraKeyState);
-    }
-    if (ctx.e.modifiers & kSuffixShift) {
-        char *q = p;
-        *q++ = '$';
-        setEncoding(ctx, q, extraKeyState | SHIFT_PRESSED);
-    }
-    if (ctx.e.modifiers & kSuffixCtrl) {
-        char *q = p;
-        *q++ = '^';
-        setEncoding(ctx, q, extraKeyState | LEFT_CTRL_PRESSED);
-    }
-    if (ctx.e.modifiers & (kSuffixCtrl | kSuffixShift)) {
-        char *q = p;
-        *q++ = '@';
-        setEncoding(ctx, q, extraKeyState | SHIFT_PRESSED | LEFT_CTRL_PRESSED);
-    }
-}
-
-template <bool is_numeric>
-static inline void expandEncodingAfterAltPrefix(
-        const ExpandContext &ctx, char *p, uint16_t extraKeyState) {
-    auto appendId = [&](char *&ptr) {
-        const auto idstr = decOfInt(ctx.e.id);
-        ASSERT(ptr <= ctx.bufferEnd - idstr.size());
-        std::copy(idstr.data(), idstr.data() + idstr.size(), ptr);
-        ptr += idstr.size();
-    };
-    ASSERT(p <= ctx.bufferEnd - 2);
-    *p++ = '\x1b';
-    *p++ = ctx.e.prefix;
-    if (ctx.e.modifiers & kBare) {
-        char *q = p;
-        if (is_numeric) {
-            appendId(q);
-            expandNumericEncodingSuffix(ctx, q, extraKeyState);
-        } else {
-            ASSERT(q <= ctx.bufferEnd - 1);
-            *q++ = ctx.e.id;
-            setEncoding(ctx, q, extraKeyState);
-        }
-    }
-    if (ctx.e.modifiers & kBareMod) {
-        ASSERT(!is_numeric && "kBareMod is invalid with numeric sequences");
-        for (int mod = 2; mod <= 8; ++mod) {
-            char *q = p;
-            ASSERT(q <= ctx.bufferEnd - 2);
-            *q++ = '0' + mod;
-            *q++ = ctx.e.id;
-            setEncoding(ctx, q, extraKeyState | keyStateForMod(mod));
-        }
-    }
-    if (ctx.e.modifiers & kSemiMod) {
-        for (int mod = 2; mod <= 8; ++mod) {
-            char *q = p;
-            if (is_numeric) {
-                appendId(q);
-                ASSERT(q <= ctx.bufferEnd - 2);
-                *q++ = ';';
-                *q++ = '0' + mod;
-                expandNumericEncodingSuffix(
-                    ctx, q, extraKeyState | keyStateForMod(mod));
-            } else {
-                ASSERT(q <= ctx.bufferEnd - 4);
-                *q++ = '1';
-                *q++ = ';';
-                *q++ = '0' + mod;
-                *q++ = ctx.e.id;
-                setEncoding(ctx, q, extraKeyState | keyStateForMod(mod));
-            }
-        }
-    }
-}
-
-template <bool is_numeric>
-static inline void expandEncoding(const ExpandContext &ctx) {
-    if (ctx.e.alt_prefix_allowed) {
-        // For better or for worse, this code expands all of:
-        //  *     ESC [       <key>     -- <key>
-        //  * ESC ESC [       <key>     -- Alt-<key>
-        //  *     ESC [ 1 ; 3 <key>     -- Alt-<key>
-        //  * ESC ESC [ 1 ; 3 <key>     -- Alt-<key> specified twice
-        // I suspect no terminal actually emits the last one (i.e. specifying
-        // the Alt modifier using both methods), but I have seen a terminal
-        // that emitted a prefix ESC for Alt and a non-Alt modifier.
-        char *p = ctx.buffer;
-        ASSERT(p <= ctx.bufferEnd - 1);
-        *p++ = '\x1b';
-        expandEncodingAfterAltPrefix<is_numeric>(ctx, p, LEFT_ALT_PRESSED);
-    }
-    expandEncodingAfterAltPrefix<is_numeric>(ctx, ctx.buffer, 0);
-}
-
-template <bool is_numeric, size_t N>
-static void addEscapes(InputMap &inputMap, const EscapeEncoding (&encodings)[N]) {
-    char buffer[32];
-    for (size_t i = 0; i < DIM(encodings); ++i) {
-        ExpandContext ctx = {
-            inputMap, encodings[i],
-            buffer, buffer + sizeof(buffer)
-        };
-        expandEncoding<is_numeric>(ctx);
-    }
-}
-
-} // anonymous namespace
-
-void addDefaultEntriesToInputMap(InputMap &inputMap) {
-    addEscapes<false>(inputMap, escapeLetterEncodings);
-    addEscapes<true>(inputMap, escapeNumericEncodings);
-    addSimpleEntries(inputMap);
-}

package/vendor/node_modules/node-pty/deps/winpty/src/agent/DefaultInputMap.h

@@ -1,28 +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 DEFAULT_INPUT_MAP_H
-#define DEFAULT_INPUT_MAP_H
-
-class InputMap;
-
-void addDefaultEntriesToInputMap(InputMap &inputMap);
-
-#endif // DEFAULT_INPUT_MAP_H

package/vendor/node_modules/node-pty/deps/winpty/src/agent/DsrSender.h

@@ -1,30 +0,0 @@
-// Copyright (c) 2011-2012 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 DSRSENDER_H
-#define DSRSENDER_H
-
-class DsrSender
-{
-public:
-    virtual void sendDsr() = 0;
-};
-
-#endif // DSRSENDER_H

package/vendor/node_modules/node-pty/deps/winpty/src/agent/EventLoop.cc

@@ -1,99 +0,0 @@
-// Copyright (c) 2011-2012 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 "EventLoop.h"
-
-#include <algorithm>
-
-#include "NamedPipe.h"
-#include "../shared/DebugClient.h"
-#include "../shared/WinptyAssert.h"
-
-EventLoop::~EventLoop() {
-    for (NamedPipe *pipe : m_pipes) {
-        delete pipe;
-    }
-    m_pipes.clear();
-}
-
-// Enter the event loop.  Runs until the I/O or timeout handler calls exit().
-void EventLoop::run()
-{
-    std::vector<HANDLE> waitHandles;
-    DWORD lastTime = GetTickCount();
-    while (!m_exiting) {
-        bool didSomething = false;
-
-        // Attempt to make progress with the pipes.
-        waitHandles.clear();
-        for (size_t i = 0; i < m_pipes.size(); ++i) {
-            if (m_pipes[i]->serviceIo(&waitHandles)) {
-                onPipeIo(*m_pipes[i]);
-                didSomething = true;
-            }
-        }
-
-        // Call the timeout if enough time has elapsed.
-        if (m_pollInterval > 0) {
-            int elapsed = GetTickCount() - lastTime;
-            if (elapsed >= m_pollInterval) {
-                onPollTimeout();
-                lastTime = GetTickCount();
-                didSomething = true;
-            }
-        }
-
-        if (didSomething)
-            continue;
-
-        // If there's nothing to do, wait.
-        DWORD timeout = INFINITE;
-        if (m_pollInterval > 0)
-            timeout = std::max(0, (int)(lastTime + m_pollInterval - GetTickCount()));
-        if (waitHandles.size() == 0) {
-            ASSERT(timeout != INFINITE);
-            if (timeout > 0)
-                Sleep(timeout);
-        } else {
-            DWORD result = WaitForMultipleObjects(waitHandles.size(),
-                                                  waitHandles.data(),
-                                                  FALSE,
-                                                  timeout);
-            ASSERT(result != WAIT_FAILED);
-        }
-    }
-}
-
-NamedPipe &EventLoop::createNamedPipe()
-{
-    NamedPipe *ret = new NamedPipe();
-    m_pipes.push_back(ret);
-    return *ret;
-}
-
-void EventLoop::setPollInterval(int ms)
-{
-    m_pollInterval = ms;
-}
-
-void EventLoop::shutdown()
-{
-    m_exiting = true;
-}

package/vendor/node_modules/node-pty/deps/winpty/src/agent/EventLoop.h

@@ -1,47 +0,0 @@
-// Copyright (c) 2011-2012 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 EVENTLOOP_H
-#define EVENTLOOP_H
-
-#include <vector>
-
-class NamedPipe;
-
-class EventLoop
-{
-public:
-    virtual ~EventLoop();
-    void run();
-
-protected:
-    NamedPipe &createNamedPipe();
-    void setPollInterval(int ms);
-    void shutdown();
-    virtual void onPollTimeout()                    {}
-    virtual void onPipeIo(NamedPipe &namedPipe)     {}
-
-private:
-    bool m_exiting = false;
-    std::vector<NamedPipe*> m_pipes;
-    int m_pollInterval = 0;
-};
-
-#endif // EVENTLOOP_H