atleg

test "RGB thing" {
    const std = @import("std");
    const print = std.debug.print;
    const stdout = std.io.getStdOut().writer();

    // formatting issue with zig tests
    print("\n", .{});

    // TODO: need a function for resetting all color :P
    var reset_attrib: Self = Self{};
    reset_attrib.fg = Self.Color.none;
    reset_attrib.bg = Self.Color.none;

    for (0..6) |r| {
        for (0..6) |g| {
            for (0..6) |b| {
                // calculate normalized RGB values
                const norm_r: u8 = @truncate((r * 255) / 5);
                const norm_g: u8 = @truncate((g * 255) / 5);
                const norm_b: u8 = @truncate((b * 255) / 5);

                var attrib: Self = Self{};
                attrib.bg = Self.Color{ .rgb = .{ norm_r, norm_g, norm_b } };

                try attrib.dump(stdout);
                print("H", .{});
            }
            try Self.dump(reset_attrib, stdout);
        }
        print("\n", .{});
    }
}

test "RGB thing" {
    const std = @import("std");
    const print = std.debug.print;
    const stdout = std.io.getStdOut().writer();

    // formatting issue with zig tests
    print("\n", .{});

    // TODO: need a function for resetting all color :P
    var reset_attrib: Self = Self{};
    reset_attrib.fg = Self.Color.none;
    reset_attrib.bg = Self.Color.none;

    for (0..6) |r| {
        for (0..6) |g| {
            for (0..6) |b| {
                // calculate normalized RGB values
                const norm_r: u8 = @truncate((r * 255) / 5);
                const norm_g: u8 = @truncate((g * 255) / 5);
                const norm_b: u8 = @truncate((b * 255) / 5);

                var attrib: Self = Self{};
                attrib.bg = Self.Color{ .rgb = .{ norm_r, norm_g, norm_b } };

                try attrib.dump(stdout);
                print("H", .{});
            }
            try Self.dump(reset_attrib, stdout);
        }
        print("\n", .{});
    }
}

test "grayscale ramp" {
    const std = @import("std");
    const print = std.debug.print;
    const stdout = std.io.getStdOut().writer();

    // formatting issue with zig tests
    print("\n", .{});

    // TODO: need a function for resetting all color :P
    var reset_attrib: Self = Self{};
    reset_attrib.fg = Self.Color.none;
    reset_attrib.bg = Self.Color.none;

    for (0..24) |i| {
        const gray_value: u8 = @truncate(i * 10 + 8);

        var attrib: Self = Self{};
        attrib.bg = Self.Color{ .rgb = .{ gray_value, gray_value, gray_value } };

        try attrib.dump(stdout);
        print("H", .{});
    }

    // cleanup
    try reset_attrib.dump(stdout);
    print("\n", .{});
}

test "grayscale ramp" {
    const std = @import("std");
    const print = std.debug.print;
    const stdout = std.io.getStdOut().writer();

    // formatting issue with zig tests
    print("\n", .{});

    // TODO: need a function for resetting all color :P
    var reset_attrib: Self = Self{};
    reset_attrib.fg = Self.Color.none;
    reset_attrib.bg = Self.Color.none;

    for (0..24) |i| {
        const gray_value: u8 = @truncate(i * 10 + 8);

        var attrib: Self = Self{};
        attrib.bg = Self.Color{ .rgb = .{ gray_value, gray_value, gray_value } };

        try attrib.dump(stdout);
        print("H", .{});
    }

    // cleanup
    try reset_attrib.dump(stdout);
    print("\n", .{});
}

try parseColorDescriptor("0xffffff");
// or
try parseColorDescriptor("0");
// or
try parseColorDescriptor("blue");
// or even HTML
try parseColorDescriptor("x11:cintcream");

try parseColorDescriptor("0xffffff");
// or
try parseColorDescriptor("0");
// or
try parseColorDescriptor("blue");
// or even HTML
try parseColorDescriptor("x11:cintcream");

+-----+------+-------+
| Alt | Ctrl | Super |
+=====+======+=======+
|  M  |   C  |   S   |
+-----+------+-------+
|  A  | Ctrl | Super |
+-----+------+-------+
| Alt |      |       |
+-----+------+-------+

+-----+------+-------+
| Alt | Ctrl | Super |
+=====+======+=======+
|  M  |   C  |   S   |
+-----+------+-------+
|  A  | Ctrl | Super |
+-----+------+-------+
| Alt |      |       |
+-----+------+-------+

.setAttribute(.{});

.setAttribute(.{});

.resetAttribute();

.resetAttribute();

fn render() !void {
    var rc = try term.getRenderContext();
    defer rc.done() catch {}; // calls rc.done at the end of the scopes life

    // we can clear the terminal
    try rc.clear();

    // move the cursor
    try rc.moveCursorTo(10, 10);

    // clear all color
    try rc.resetAttribute();

    // but nothing is actually displayed until rc.done() is called
}

fn render() !void {
    var rc = try term.getRenderContext();
    defer rc.done() catch {}; // calls rc.done at the end of the scopes life

    // we can clear the terminal
    try rc.clear();

    // move the cursor
    try rc.moveCursorTo(10, 10);

    // clear all color
    try rc.resetAttribute();

    // but nothing is actually displayed until rc.done() is called
}

/// Creates a control sequence.
/// Prepends provided sequence with the control sequence introducer `ESC [` (`\x1B[`).
///
/// Example:
///     csi("?1049h") -> "\x1B[?1049h"
pub inline fn csi(comptime s: []const u8) []const u8 {
    return "\x1B[" ++ s;
}

/// Creates an escape sequence.
/// Prepends provided sequence with the `ESC` (`\x1B`) character.
///
/// Example:
///     esc("7") -> "\x1B7"
pub inline fn esc(comptime s: []const u8) []const u8 {
    return "\x1B" ++ s;
}

/// Creates a select graphic rendition sequence.
/// Prepends provided sequence with the `ESC[` (`\x1B[`) character and appends `m` character.
///
/// Example:
///     sgr("0") -> "\x1B[0m"
pub inline fn sgr(comptime s: []const u8) []const u8 {
    return "\x1B[" ++ s ++ "m";
}

/// Creates a control sequence.
/// Prepends provided sequence with the control sequence introducer `ESC [` (`\x1B[`).
///
/// Example:
///     csi("?1049h") -> "\x1B[?1049h"
pub inline fn csi(comptime s: []const u8) []const u8 {
    return "\x1B[" ++ s;
}

/// Creates an escape sequence.
/// Prepends provided sequence with the `ESC` (`\x1B`) character.
///
/// Example:
///     esc("7") -> "\x1B7"
pub inline fn esc(comptime s: []const u8) []const u8 {
    return "\x1B" ++ s;
}

/// Creates a select graphic rendition sequence.
/// Prepends provided sequence with the `ESC[` (`\x1B[`) character and appends `m` character.
///
/// Example:
///     sgr("0") -> "\x1B[0m"
pub inline fn sgr(comptime s: []const u8) []const u8 {
    return "\x1B[" ++ s ++ "m";
}

                // check if buffer is long enough
                if (self.bytes.?.len < advance)
                    return Input{ .content = .unknown };

                // check if buffer is long enough
                if (self.bytes.?.len < advance)
                    return Input{ .content = .unknown };

        // Pretty much all common escape sequences begin with '['. All of them
        // are at least three bytes long, so if we have less, this likely is
        // just a press of the escape key followed by a press of the '[' key.
        if (self.bytes.?[1] == '[' and self.bytes.?.len > 2) {
            // There are two types of '[' escape sequences.
            if (ascii.isDigit(self.bytes.?[2])) {
                return self.numericEscapeSequence();
            } else if (self.bytes.?[2] == 'M') {
                return self.legacyMouseEscapeSequence();
            } else {
                return self.singleLetterEscapeSequence();
            }
        }

        // Pretty much all common escape sequences begin with '['. All of them
        // are at least three bytes long, so if we have less, this likely is
        // just a press of the escape key followed by a press of the '[' key.
        if (self.bytes.?[1] == '[' and self.bytes.?.len > 2) {
            // There are two types of '[' escape sequences.
            if (ascii.isDigit(self.bytes.?[2])) {
                return self.numericEscapeSequence();
            } else if (self.bytes.?[2] == 'M') {
                return self.legacyMouseEscapeSequence();
            } else {
                return self.singleLetterEscapeSequence();
            }
        }

        // This may be either a M-[a-z] code, or we accidentally received an
        // escape key press and a letter key press together. There is literally
        // no way to differentiate. However the second case is less likely.
        if (ascii.isAlphabetic(self.bytes.?[1]) and ascii.isLower(self.bytes.?[1])) {
            defer self.advanceBufferBy("\x1Ba".len);
            return Input{ .content = .{ .codepoint = self.bytes.?[1] }, .mod_alt = true };
        }

        // This may be either a M-[a-z] code, or we accidentally received an
        // escape key press and a letter key press together. There is literally
        // no way to differentiate. However the second case is less likely.
        if (ascii.isAlphabetic(self.bytes.?[1]) and ascii.isLower(self.bytes.?[1])) {
            defer self.advanceBufferBy("\x1Ba".len);
            return Input{ .content = .{ .codepoint = self.bytes.?[1] }, .mod_alt = true };
        }

    fn singleLetterEscapeSequence(self: *Self) Input {
        const ev = singleLetterSpecialInput(self.bytes.?[2]) orelse {
            // Oh, turns out this is not an escape sequence. Well
            // this is awkward... Let's hope / pretend that the next
            // few bytes can be interpreted on their own. Well, it
            // might actually be an escape sequence after all, just
            // one that we don't know yet. Would be pretty nice to
            // just skip it. But we have literally no idea how long
            // this sequence is supposed to be, so it's safer to
            // just treat it as separate content pressed.
            self.advanceBufferBy(1);
            return Input{ .content = .escape };
        };
        self.advanceBufferBy("\x1B[A".len);
        return ev;
    }

    fn singleLetterEscapeSequence(self: *Self) Input {
        const ev = singleLetterSpecialInput(self.bytes.?[2]) orelse {
            // Oh, turns out this is not an escape sequence. Well
            // this is awkward... Let's hope / pretend that the next
            // few bytes can be interpreted on their own. Well, it
            // might actually be an escape sequence after all, just
            // one that we don't know yet. Would be pretty nice to
            // just skip it. But we have literally no idea how long
            // this sequence is supposed to be, so it's safer to
            // just treat it as separate content pressed.
            self.advanceBufferBy(1);
            return Input{ .content = .escape };
        };
        self.advanceBufferBy("\x1B[A".len);
        return ev;
    }

test "input parser: Legacy mouse sequences" {
    const testing = std.testing;
    var parser = inputParser("\x1B[M A3\x1B[M!()\x1B[M\"Na\x1B[M#xO\x1B[M0z;\x1B[M1[Y\x1B[M2fu\x1B[M3  \x1B[M@-@\x1B[MA=<");
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 32, .y = 18, .event = .{ .pressed = .left } } } },
        parser.next().?,
    );
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 7, .y = 8, .event = .{ .pressed = .middle } } } },
        parser.next().?,
    );
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 45, .y = 64, .event = .{ .pressed = .right } } } },
        parser.next().?,
    );
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 87, .y = 46, .event = .{ .released = .unknown } } } },
        parser.next().?,
    );
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 89, .y = 26, .event = .{ .pressed = .left } } }, .mod_ctrl = true },
        parser.next().?,
    );
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 58, .y = 56, .event = .{ .pressed = .middle } } }, .mod_ctrl = true },
        parser.next().?,
    );
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 69, .y = 84, .event = .{ .pressed = .right } } }, .mod_ctrl = true },
        parser.next().?,
    );
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 0, .y = 0, .event = .{ .released = .unknown } } }, .mod_ctrl = true },
        parser.next().?,
    );
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 12, .y = 31, .event = .{ .scrolled = .up } } } },
        parser.next().?,
    );
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 28, .y = 27, .event = .{ .scrolled = .down } } } },
        parser.next().?,
    );
    try testing.expect(parser.next() == null);

    std.debug.print("OK\n", .{});
}

test "input parser: Legacy mouse sequences" {
    const testing = std.testing;
    var parser = inputParser("\x1B[M A3\x1B[M!()\x1B[M\"Na\x1B[M#xO\x1B[M0z;\x1B[M1[Y\x1B[M2fu\x1B[M3  \x1B[M@-@\x1B[MA=<");
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 32, .y = 18, .event = .{ .pressed = .left } } } },
        parser.next().?,
    );
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 7, .y = 8, .event = .{ .pressed = .middle } } } },
        parser.next().?,
    );
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 45, .y = 64, .event = .{ .pressed = .right } } } },
        parser.next().?,
    );
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 87, .y = 46, .event = .{ .released = .unknown } } } },
        parser.next().?,
    );
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 89, .y = 26, .event = .{ .pressed = .left } } }, .mod_ctrl = true },
        parser.next().?,
    );
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 58, .y = 56, .event = .{ .pressed = .middle } } }, .mod_ctrl = true },
        parser.next().?,
    );
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 69, .y = 84, .event = .{ .pressed = .right } } }, .mod_ctrl = true },
        parser.next().?,
    );
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 0, .y = 0, .event = .{ .released = .unknown } } }, .mod_ctrl = true },
        parser.next().?,
    );
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 12, .y = 31, .event = .{ .scrolled = .up } } } },
        parser.next().?,
    );
    try testing.expectEqual(
        Input{ .content = .{ .mouse = .{ .x = 28, .y = 27, .event = .{ .scrolled = .down } } } },
        parser.next().?,
    );
    try testing.expect(parser.next() == null);

    std.debug.print("OK\n", .{});
}

...
    mouse: struct { x: usize, y: usize, event: MouseEvent },
};

pub const MouseEvent = union(enum) {
    /// Pressed mouse button. Contains the button that was pressed.
    pressed: MouseButton,
    /// Released mouse button. Contains the button that was released.
    released: MouseButton,
    /// Moved the mouse cursor while pressing the contained mouse button.
    dragged: MouseButton,
    /// Moved the mouse cursor while not pressing a mouse button.
    moved: void,
    /// Scrolled mouse wheel either
    ///   - up (away from the user)
    ///   - down (towards the user)
    ///   - right (mostly on a laptop touchpad)
    ///   - left (mostly on a laptop touchpad)
    scrolled: enum { up, down, right, left },
};
pub const MouseButton = enum {
    /// Used during some CSI cases where legacy mouse tracking doesn't
    /// report the button. For example, cases where a button was released
    unknown,
    /// also known as btn1 or lmb
    left,
    /// also known as btn2 or mmb
    middle,
    /// also known as btn3 or rmb
    right,
};

...
    mouse: struct { x: usize, y: usize, event: MouseEvent },
};

pub const MouseEvent = union(enum) {
    /// Pressed mouse button. Contains the button that was pressed.
    pressed: MouseButton,
    /// Released mouse button. Contains the button that was released.
    released: MouseButton,
    /// Moved the mouse cursor while pressing the contained mouse button.
    dragged: MouseButton,
    /// Moved the mouse cursor while not pressing a mouse button.
    moved: void,
    /// Scrolled mouse wheel either
    ///   - up (away from the user)
    ///   - down (towards the user)
    ///   - right (mostly on a laptop touchpad)
    ///   - left (mostly on a laptop touchpad)
    scrolled: enum { up, down, right, left },
};
pub const MouseButton = enum {
    /// Used during some CSI cases where legacy mouse tracking doesn't
    /// report the button. For example, cases where a button was released
    unknown,
    /// also known as btn1 or lmb
    left,
    /// also known as btn2 or mmb
    middle,
    /// also known as btn3 or rmb
    right,
};

echo -e "\e[?1000h\e[?1002h\e[?1003h\e[?1015h\e[?1006h"
echo -e "\e[?1006l\e[?1015l\e[?1003l\e[?1002l\e[?1000l"

echo -e "\e[?1000h\e[?1002h\e[?1003h\e[?1015h\e[?1006h"
echo -e "\e[?1006l\e[?1015l\e[?1003l\e[?1002l\e[?1000l"

echo -e "\e[?1000h\e[?1002h\e[?1003h\e[?1015h"
echo -e "\e[?1015l\e[?1003l\e[?1002l\e[?1000l"

echo -e "\e[?1000h\e[?1002h\e[?1003h\e[?1015h"
echo -e "\e[?1015l\e[?1003l\e[?1002l\e[?1000l"

const std = @import("std");
const windows = std.os.windows;

pub extern "kernel32" fn SetConsoleMode(in_hConsoleHandle: windows.HANDLE, in_dwMode: windows.DWORD) callconv(windows.WINAPI) windows.BOOL;

const std = @import("std");
const windows = std.os.windows;

pub extern "kernel32" fn SetConsoleMode(in_hConsoleHandle: windows.HANDLE, in_dwMode: windows.DWORD) callconv(windows.WINAPI) windows.BOOL;

❯ stty
speed 38400 baud;
lflags: echoe echok echoke echoctl pendin
iflags: -ixon iutf8
oflags: -oxtabs
cflags: cs8 -parenb

❯ stty -a
speed 38400 baud; 25 rows; 80 columns;
lflags: icanon isig iexten echo echoe echok echoke -echonl echoctl
    -echoprt -altwerase -noflsh -tostop -flusho pendin -nokerninfo
    -extproc
iflags: -istrip icrnl -inlcr -igncr -ixon -ixoff ixany imaxbel iutf8
    -ignbrk brkint -inpck -ignpar -parmrk
oflags: opost onlcr -oxtabs -onocr -onlret
cflags: cread cs8 -parenb -parodd hupcl -clocal -cstopb -crtscts -dsrflow
    -dtrflow -mdmbuf
cchars: discard = ^O; dsusp = ^Y; eof = ^D; eol = <undef>;
    eol2 = <undef>; erase = ^?; intr = ^C; kill = ^U; lnext = ^V;
    min = 1; quit = ^\; reprint = ^R; start = ^Q; status = ^T;
    stop = ^S; susp = ^Z; time = 0; werase = ^W;

❯ stty
speed 38400 baud;
lflags: echoe echok echoke echoctl pendin
iflags: -ixon iutf8
oflags: -oxtabs
cflags: cs8 -parenb

❯ stty -a
speed 38400 baud; 25 rows; 80 columns;
lflags: icanon isig iexten echo echoe echok echoke -echonl echoctl
    -echoprt -altwerase -noflsh -tostop -flusho pendin -nokerninfo
    -extproc
iflags: -istrip icrnl -inlcr -igncr -ixon -ixoff ixany imaxbel iutf8
    -ignbrk brkint -inpck -ignpar -parmrk
oflags: opost onlcr -oxtabs -onocr -onlret
cflags: cread cs8 -parenb -parodd hupcl -clocal -cstopb -crtscts -dsrflow
    -dtrflow -mdmbuf
cchars: discard = ^O; dsusp = ^Y; eof = ^D; eol = <undef>;
    eol2 = <undef>; erase = ^?; intr = ^C; kill = ^U; lnext = ^V;
    min = 1; quit = ^\; reprint = ^R; start = ^Q; status = ^T;
    stop = ^S; susp = ^Z; time = 0; werase = ^W;

❯ stty
speed 38400 baud;
lflags: echoe echok echoke echoctl pendin
iflags: -ixon iutf8
oflags: -oxtabs
cflags: cs8 -parenb

❯ stty -a
speed 38400 baud; 25 rows; 80 columns;
lflags: icanon isig iexten echo echoe echok echoke -echonl echoctl
    -echoprt -altwerase -noflsh -tostop -flusho pendin -nokerninfo
    -extproc
iflags: -istrip icrnl -inlcr -igncr -ixon -ixoff ixany imaxbel iutf8
    -ignbrk brkint -inpck -ignpar -parmrk
oflags: opost onlcr -oxtabs -onocr -onlret
cflags: cread cs8 -parenb -parodd hupcl -clocal -cstopb -crtscts -dsrflow
    -dtrflow -mdmbuf
cchars: discard = ^O; dsusp = ^Y; eof = ^D; eol = <undef>;
    eol2 = <undef>; erase = ^?; intr = ^C; kill = ^U; lnext = ^V;
    min = 1; quit = ^\; reprint = ^R; start = ^Q; status = ^T;
    stop = ^S; susp = ^Z; time = 0; werase = ^W;

❯ stty
speed 38400 baud;
lflags: echoe echok echoke echoctl pendin
iflags: -ixon iutf8
oflags: -oxtabs
cflags: cs8 -parenb

❯ stty -a
speed 38400 baud; 25 rows; 80 columns;
lflags: icanon isig iexten echo echoe echok echoke -echonl echoctl
    -echoprt -altwerase -noflsh -tostop -flusho pendin -nokerninfo
    -extproc
iflags: -istrip icrnl -inlcr -igncr -ixon -ixoff ixany imaxbel iutf8
    -ignbrk brkint -inpck -ignpar -parmrk
oflags: opost onlcr -oxtabs -onocr -onlret
cflags: cread cs8 -parenb -parodd hupcl -clocal -cstopb -crtscts -dsrflow
    -dtrflow -mdmbuf
cchars: discard = ^O; dsusp = ^Y; eof = ^D; eol = <undef>;
    eol2 = <undef>; erase = ^?; intr = ^C; kill = ^U; lnext = ^V;
    min = 1; quit = ^\; reprint = ^R; start = ^Q; status = ^T;
    stop = ^S; susp = ^Z; time = 0; werase = ^W;

❯ stty
speed 9600 baud;
lflags: echoe echoke echoctl pendin
iflags: -ixon iutf8
oflags: -oxtabs
cflags: cs8 -parenb

❯ stty
speed 9600 baud;
lflags: echoe echoke echoctl pendin
iflags: -ixon iutf8
oflags: -oxtabs
cflags: cs8 -parenb

speed 38400 baud; line = 0;
-brkint -imaxbel iutf8

speed 38400 baud; line = 0;
-brkint -imaxbel iutf8

speed 38400 baud; rows 37; columns 100; line = 0;
intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = ^D; eol = <undef>; eol2 = <undef>;
swtch = <undef>; start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R; werase = ^W; lnext = ^V;
discard = ^O; min = 1; time = 0;
-parenb -parodd -cmspar cs8 -hupcl -cstopb cread -clocal -crtscts
-ignbrk -brkint -ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl ixon -ixoff -iuclc -ixany
-imaxbel iutf8
opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0
isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt echoctl echoke -flusho
-extproc

speed 38400 baud; rows 37; columns 100; line = 0;
intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = ^D; eol = <undef>; eol2 = <undef>;
swtch = <undef>; start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R; werase = ^W; lnext = ^V;
discard = ^O; min = 1; time = 0;
-parenb -parodd -cmspar cs8 -hupcl -cstopb cread -clocal -crtscts
-ignbrk -brkint -ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl ixon -ixoff -iuclc -ixany
-imaxbel iutf8
opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0
isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt echoctl echoke -flusho
-extproc

speed 38400 baud; rows 37; columns 100; line = 0;
intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = ^D; eol = <undef>; eol2 = <undef>;
swtch = <undef>; start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R; werase = ^W; lnext = ^V;
discard = ^O; min = 1; time = 0;
-parenb -parodd -cmspar cs8 -hupcl -cstopb cread -clocal -crtscts
-ignbrk brkint ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl ixon -ixoff -iuclc -ixany imaxbel
iutf8
opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0
isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt echoctl echoke -flusho
-extproc

speed 38400 baud; rows 37; columns 100; line = 0;
intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = ^D; eol = <undef>; eol2 = <undef>;
swtch = <undef>; start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R; werase = ^W; lnext = ^V;
discard = ^O; min = 1; time = 0;
-parenb -parodd -cmspar cs8 -hupcl -cstopb cread -clocal -crtscts
-ignbrk brkint ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl ixon -ixoff -iuclc -ixany imaxbel
iutf8
opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0
isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt echoctl echoke -flusho
-extproc

--- <unnamed>
+++ <unnamed>
@@ -3,8 +3,8 @@
 swtch = <undef>; start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R; werase = ^W; lnext = ^V;
 discard = ^O; min = 1; time = 0;
 -parenb -parodd -cmspar cs8 -hupcl -cstopb cread -clocal -crtscts
--ignbrk -brkint -ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl ixon -ixoff -iuclc -ixany
--imaxbel iutf8
+-ignbrk brkint ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl ixon -ixoff -iuclc -ixany imaxbel
+iutf8
 opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0
 isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt echoctl echoke -flusho
 -extproc

--- <unnamed>
+++ <unnamed>
@@ -3,8 +3,8 @@
 swtch = <undef>; start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R; werase = ^W; lnext = ^V;
 discard = ^O; min = 1; time = 0;
 -parenb -parodd -cmspar cs8 -hupcl -cstopb cread -clocal -crtscts
--ignbrk -brkint -ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl ixon -ixoff -iuclc -ixany
--imaxbel iutf8
+-ignbrk brkint ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl ixon -ixoff -iuclc -ixany imaxbel
+iutf8
 opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0
 isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt echoctl echoke -flusho
 -extproc

// Why not shift? Because it is not always trivial to detect and because it is
// not entirely clear how some things should be handled. Should 'A' be parsed
// into a lowercase 'a' with the Shift modifier or an uppercase 'A' with the
// Shift modifier or an uppercase 'A' without Shift? No idea. So let's just
// avoid it for now.

// Why not shift? Because it is not always trivial to detect and because it is
// not entirely clear how some things should be handled. Should 'A' be parsed
// into a lowercase 'a' with the Shift modifier or an uppercase 'A' with the
// Shift modifier or an uppercase 'A' without Shift? No idea. So let's just
// avoid it for now.