_In_ INPUT_READ_HANDLE_DATA* const pInputReadHandleData,

SCREEN_INFORMATION& screenInfo,

_In_ size_t UserBufferSize,

_In_ char* UserBuffer,

_In_ ULONG CtrlWakeupMask,

_In_ const std::wstring_view exeName,

_In_ const std::wstring_view initialData,

_In_ ConsoleProcessHandle* const pClientProcess) :

ReadData(pInputBuffer, pInputReadHandleData),

_screenInfo{ screenInfo },

_userBuffer{ UserBuffer, UserBufferSize },

_exeName{ exeName },

_processHandle{ pClientProcess },

_history{ CommandHistory::s_Find(pClientProcess) },

_ctrlWakeupMask{ CtrlWakeupMask },

_insertMode{ ServiceLocator::LocateGlobals().getConsoleInformation().GetInsertMode() }

{

#ifndef UNIT_TESTING

// The screen buffer instance is basically a reference counted HANDLE given out to the user.

// We need to ensure that it stays alive for the duration of the read.

// Coincidentally this serves another important purpose: It checks whether we're allowed to read from

// the given buffer in the first place. If it's missing the FILE_SHARE_READ flag, we can't read from it.

//

// GH#16158: It's important that we hold a handle to the main instead of the alt buffer

// even if this cooked read targets the latter, because alt buffers are fake

// SCREEN_INFORMATION objects that are owned by the main buffer.

THROW_IF_FAILED(_screenInfo.GetMainBuffer().AllocateIoHandle(ConsoleHandleData::HandleType::Output, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, _tempHandle));

#endif

if (!initialData.empty())

{

// The console API around `nInitialChars` in `CONSOLE_READCONSOLE_CONTROL` is pretty weird.

// The way it works is that cmd.exe does a ReadConsole() with a `dwCtrlWakeupMask` that includes \t,

// so when you press tab it can autocomplete the prompt based on the available file names.

// The weird part is that it's not us who then prints the autocompletion. It's cmd.exe which calls WriteConsoleW().

// It then initiates another ReadConsole() where the `nInitialChars` is the amount of chars it wrote via WriteConsoleW().

//

// In other words, `nInitialChars` is a "trust me bro, I just wrote that in the buffer" API.

// This unfortunately means that the API is inherently broken: ReadConsole() visualizes control

// characters like Ctrl+X as "^X" and WriteConsoleW() doesn't and so the column counts don't match.

// Solving these issues is technically possible, but it's also quite difficult to do so correctly.

//

// But unfortunately (or fortunately) the initial implementation (from the 1990s up to 2023) looked something like that:

// cursor = cursor.GetPosition();

// cursor.x -= initialData.size();

// while (cursor.x < 0)

// {

// cursor.x += textBuffer.Width();

// cursor.y -= 1;

// }

//

// In other words, it assumed that the number of code units in the initial data corresponds 1:1 to

// the column count. This meant that the API never supported tabs for instance (nor wide glyphs).

//

//

// The new implementation is a lot more complex to be a little more correct.

// It replicates part of the _redisplay() logic to layout the text at various

// starting positions until it finds one that matches the current cursor position.

const auto cursorPos = _getViewportCursorPosition();

const auto size = _screenInfo.GetVtPageArea().Dimensions();

// Guess the initial cursor position based on the string length, assuming that 1 char = 1 column.

const auto columnRemainder = gsl::narrow_cast<til::CoordType>((initialData.size() % size.width));

const auto bestGuessColumn = (cursorPos.x - columnRemainder + size.width) % size.width;

std::wstring line;

LayoutResult res;

til::CoordType bestDistance = til::CoordTypeMax;

til::CoordType bestColumnBegin = 0;

til::CoordType bestNewlineCount = 0;

line.reserve(size.width);

// We're given an "end position" and a string and we need to find its starting position.

// The problem is that a wide glyph that doesn't fit into the last column of a row gets padded with a whitespace

// and then written on the next line. Because of this, multiple starting positions can result in the same end

// position and this prevents us from simply laying out the text backwards from the end position.

// To solve this, we do a brute force search for the best starting position that ends at the end position.

// The search is centered around `bestGuessColumn` with offsets 0, 1, -1, 2, -2, 3, -3, ...

for (til::CoordType i = 0, attempts = 2 * size.width; i <= attempts; i++)

{

// Hilarious bit-trickery that no one can read. But it works. Check it out in a debugger.

// The idea is to use bits 1:31 as the value (i >> 1) and bit 0 (i & 1) as a trigger to bit-flip the value.

// A bit-flipped positive number is negative, but offset by 1, so we add 1 at the end. Fun!

const auto offset = ((i >> 1) ^ ((i & 1) - 1)) + 1;

const auto columnBegin = bestGuessColumn + offset;

if (columnBegin < 0 || columnBegin >= size.width)

{

continue;

}

til::CoordType newlineCount = 0;

res.column = columnBegin;

for (size_t beg = 0; beg < initialData.size();)

{

line.clear();

res = _layoutLine(line, initialData, beg, res.column, size.width);

beg = res.offset;

if (res.column >= size.width)

{

res.column = 0;

newlineCount += 1;

}

}

const auto distance = abs(res.column - cursorPos.x);

if (distance < bestDistance)

{

bestDistance = distance;

bestColumnBegin = columnBegin;

bestNewlineCount = newlineCount;

}

if (distance == 0)

{

break;

}

}

auto originInViewport = cursorPos;

originInViewport.x = bestColumnBegin;

originInViewport.y = originInViewport.y - bestNewlineCount;

if (originInViewport.y < 0)

{

originInViewport = {};

}

// We can't mark the buffer as dirty because this messes up the cursor position for cmd

// somehow when the prompt is longer than the viewport height. I haven't investigated

// why that happens, but it works decently well enough that it's not too important.

_buffer.assign(initialData);

_bufferDirtyBeg = _buffer.size();

_bufferCursor = _buffer.size();

_originInViewport = originInViewport;

_pagerPromptEnd = cursorPos;

_pagerHeight = std::min(size.height, bestNewlineCount + 1);

}

{

// See the comment in WaitBlock.cpp for more information.

if (_userBuffer.data() == oldBuffer)

{

_userBuffer = { static_cast<char*>(newBuffer), _userBuffer.size() };

}

{

controlKeyState = 0;

_readCharInputLoop();

// NOTE: Don't call _flushBuffer in a wil::scope_exit/defer.

// It may throw and throwing during an ongoing exception is a bad idea.

_redisplay();

if (_state == State::Accumulating)

{

return false;

}

_handlePostCharInputLoop(isUnicode, numBytes, controlKeyState);

return true;

{

// If we've already erased the buffer, we don't need to do it again.

if (_redrawPending)

{

return;

}

// If we don't have an origin, we've never had user input, and consequently there's nothing to erase.

if (!_originInViewport)

{

return;

}

_redrawPending = true;

// Position the cursor the start of the prompt before reflow.

// Then, after reflow, we'll be able to ask the buffer where it went (the new origin).

// This uses the buffer APIs directly, so that we don't emit unnecessary VT into ConPTY's output.

auto& textBuffer = _screenInfo.GetTextBuffer();

auto& cursor = textBuffer.GetCursor();

auto cursorPos = *_originInViewport;

_screenInfo.GetVtPageArea().ConvertFromOrigin(&cursorPos);

cursor.SetPosition(cursorPos);

{

if (!_redrawPending)

{

return;

}

_redrawPending = false;

// Get the new cursor position after the reflow, since it may have changed.

if (_originInViewport)

{

_originInViewport = _getViewportCursorPosition();

}

// Ensure that we don't use any scroll sequences or try to clear previous pager contents.

// They have all been erased with the CSI J above.

_pagerHeight = 0;

// Ensure that the entire buffer content is rewritten after the above CSI J.

_bufferDirtyBeg = 0;

_dirty = !_buffer.empty();

// Let _redisplay() know to inject a CSI J at the start of the output.

// This ensures we fully erase the previous contents, that are now in disarray.

_clearPending = true;

_redisplay();

{

const auto viewport = _screenInfo.GetViewport();

const auto virtualViewport = _screenInfo.GetVtPageArea();

static constexpr til::point min;

const til::point max{ viewport.RightInclusive(), viewport.BottomInclusive() };

// Convert from VT-viewport-relative coordinate space back to the console one.

auto beg = _getOriginInViewport();

virtualViewport.ConvertFromOrigin(&beg);

// Since the pager may be longer than the viewport is tall, we need to clamp the coordinates to still remain within

// the current viewport (the pager doesn't write outside of the viewport, since that's not supported by VT).

auto end = _pagerPromptEnd;

end.y -= _pagerContentTop;

end = std::clamp(end, min, max);

end.y += beg.y;

return { beg, end };

{

if (position != 0)

{

--position;

while (position != 0 && chars[position] == L' ')

{

--position;

}

const auto dc = DelimiterClass(chars[position]);

while (position != 0 && DelimiterClass(chars[position - 1]) == dc)

{

--position;

}

}

return position;

{

if (position < chars.size())

{

++position;

const auto dc = DelimiterClass(chars[position - 1]);

while (position != chars.size() && dc == DelimiterClass(chars[position]))

{

++position;

}

while (position != chars.size() && chars[position] == L' ')

{

++position;

}

}

return position;

{

while (_state == State::Accumulating)

{

const auto hasPopup = !_popups.empty();

auto charOrVkey = UNICODE_NULL;

auto commandLineEditingKeys = false;

auto popupKeys = false;

const auto pCommandLineEditingKeys = hasPopup ? nullptr : &commandLineEditingKeys;

const auto pPopupKeys = hasPopup ? &popupKeys : nullptr;

DWORD modifiers = 0;

const auto status = GetChar(_pInputBuffer, &charOrVkey, true, pCommandLineEditingKeys, pPopupKeys, &modifiers);

if (status == CONSOLE_STATUS_WAIT)

{

break;

}

THROW_IF_NTSTATUS_FAILED(status);

if (hasPopup)

{

const auto wch = static_cast<wchar_t>(popupKeys ? 0 : charOrVkey);

const auto vkey = static_cast<uint16_t>(popupKeys ? charOrVkey : 0);

_popupHandleInput(wch, vkey, modifiers);

}

else

{

if (commandLineEditingKeys)

{

_handleVkey(charOrVkey, modifiers);

}

else

{

_handleChar(charOrVkey, modifiers);

}

}

}

{

// All paths in this function modify the buffer.

if (_ctrlWakeupMask != 0 && wch < L' ' && (_ctrlWakeupMask & (1 << wch)))

{

// The old implementation (all the way since the 90s) overwrote the character at the current cursor position with the given wch.

// But simultaneously it incremented the buffer length, which would have only worked if it was written at the end of the buffer.

// Press tab past the "f" in the string "foo" and you'd get "f\to " (a trailing whitespace; the initial contents of the buffer back then).

// It's unclear whether the original intention was to write at the end of the buffer at all times or to implement an insert mode.

// I went with insert mode.

//

// The old implementation also failed to clear the end of the prompt if you pressed tab in the middle of it.

// You can reproduce this issue by launching cmd in an old conhost build and writing "<command that doesn't exist> foo",

// moving your cursor to the space past the <command> and pressing tab. Nothing will happen but the "foo" will be inaccessible.

// I've now fixed this behavior by adding an additional Replace() before the _flushBuffer() call that removes the tail end.

//

// It is important that we don't actually print that character out though, as it's only for the calling application to see.

// That's why we flush the contents before the insertion and then ensure that the _flushBuffer() call in Read() exits early.

_replace(_bufferCursor, npos, nullptr, 0);

_redisplay();

_replace(_bufferCursor, 0, &wch, 1);

_dirty = false;

_controlKeyState = modifiers;

_transitionState(State::DoneWithWakeupMask);

return;

}

switch (wch)

{

case UNICODE_CARRIAGERETURN:

{

// NOTE: Don't append newlines to the buffer just yet! See _handlePostCharInputLoop for more information.

_setCursorPosition(npos);

_transitionState(State::DoneWithCarriageReturn);

return;

}

case EXTKEY_ERASE_PREV_WORD: // Ctrl+Backspace

case UNICODE_BACKSPACE:

if (WI_IsFlagSet(_pInputBuffer->InputMode, ENABLE_PROCESSED_INPUT))

{

const auto cursor = _bufferCursor;

const auto pos = wch == EXTKEY_ERASE_PREV_WORD ? _wordPrev(_buffer, cursor) : TextBuffer::GraphemePrev(_buffer, cursor);

_replace(pos, cursor - pos, nullptr, 0);

return;

}

// If processed mode is disabled, control characters like backspace are treated like any other character.

break;

default:

break;

}

size_t remove = 0;

if (!_insertMode)

{

// TODO GH#15875: If the input grapheme is >1 char, then this will replace >1 grapheme

// --> We should accumulate input text as much as possible and then call _processInput with wstring_view.

const auto cursor = _bufferCursor;

remove = TextBuffer::GraphemeNext(_buffer, cursor) - cursor;

}

_replace(_bufferCursor, remove, &wch, 1);

{

const auto ctrlPressed = WI_IsAnyFlagSet(modifiers, LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED);

const auto altPressed = WI_IsAnyFlagSet(modifiers, LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED);

switch (vkey)

{

case VK_ESCAPE:

if (!_buffer.empty())

{

_replace(0, npos, nullptr, 0);

}

break;

case VK_HOME:

if (_bufferCursor > 0)

{

if (ctrlPressed)

{

_replace(0, _bufferCursor, nullptr, 0);

}

_setCursorPosition(0);

}

break;

case VK_END:

if (_bufferCursor < _buffer.size())

{

if (ctrlPressed)

{

_replace(_bufferCursor, npos, nullptr, 0);

}

_setCursorPosition(npos);

}

break;

case VK_LEFT:

if (_bufferCursor != 0)

{

if (ctrlPressed)

{

_setCursorPosition(_wordPrev(_buffer, _bufferCursor));

}

else

{

_setCursorPosition(TextBuffer::GraphemePrev(_buffer, _bufferCursor));

}

}

break;

case VK_F1:

case VK_RIGHT:

if (_bufferCursor != _buffer.size())

{

if (ctrlPressed && vkey == VK_RIGHT)

{

_setCursorPosition(_wordNext(_buffer, _bufferCursor));

}

else

{

_setCursorPosition(TextBuffer::GraphemeNext(_buffer, _bufferCursor));

}

}

else if (_history)

{

// Traditionally pressing right at the end of an input line would paste characters from the previous command.

const auto cmd = _history->GetLastCommand();

const auto bufferSize = _buffer.size();

const auto cmdSize = cmd.size();

size_t bufferBeg = 0;

size_t cmdBeg = 0;

// We cannot just check if the cmd is longer than the _buffer, because we want to copy graphemes,

// not characters and there's no correlation between the number of graphemes and their byte length.

while (cmdBeg < cmdSize)

{

const auto cmdEnd = TextBuffer::GraphemeNext(cmd, cmdBeg);

if (bufferBeg >= bufferSize)

{

_replace(npos, 0, cmd.data() + cmdBeg, cmdEnd - cmdBeg);

break;

}

bufferBeg = TextBuffer::GraphemeNext(_buffer, bufferBeg);

cmdBeg = cmdEnd;

}

}

break;

case VK_INSERT:

_insertMode = !_insertMode;

_screenInfo.SetCursorDBMode(_insertMode != ServiceLocator::LocateGlobals().getConsoleInformation().GetInsertMode());

break;

case VK_DELETE:

if (_bufferCursor < _buffer.size())

{

const auto beg = _bufferCursor;

const auto end = TextBuffer::GraphemeNext(_buffer, beg);

_replace(beg, end - beg, nullptr, 0);

}

break;

case VK_UP:

case VK_F5:

if (_history && !_history->AtFirstCommand())

{

_replace(_history->Retrieve(CommandHistory::SearchDirection::Previous));

}

break;

case VK_DOWN:

if (_history && !_history->AtLastCommand())

{

_replace(_history->Retrieve(CommandHistory::SearchDirection::Next));

}

break;

case VK_PRIOR:

if (_history && !_history->AtFirstCommand())

{

_replace(_history->RetrieveNth(0));

}

break;

case VK_NEXT:

if (_history && !_history->AtLastCommand())

{

_replace(_history->RetrieveNth(INT_MAX));

}

break;

case VK_F2:

if (_history)

{

_popupPush(PopupKind::CopyToChar);

}

break;

case VK_F3:

if (_history)

{

const auto last = _history->GetLastCommand();

if (last.size() > _bufferCursor)

{

const auto count = last.size() - _bufferCursor;

_replace(_bufferCursor, npos, last.data() + _bufferCursor, count);

}

}

break;

case VK_F4:

// Historically the CopyFromChar popup was constrained to only work when a history exists,

// but I don't see why that should be. It doesn't depend on _history at all.

_popupPush(PopupKind::CopyFromChar);

break;

case VK_F6:

// Don't ask me why but F6 is an alias for ^Z.

_handleChar(0x1a, modifiers);

break;

case VK_F7:

if (!ctrlPressed && !altPressed)

{

if (_history && _history->GetNumberOfCommands())

{

_popupPush(PopupKind::CommandList);

}

}

else if (altPressed)

{

if (_history)

{

_history->Empty();

_history->Flags |= CommandHistory::CLE_ALLOCATED;

}

}

break;

case VK_F8:

if (_history)

{

CommandHistory::Index index = 0;

const auto cursorPos = _bufferCursor;

const auto prefix = std::wstring_view{ _buffer }.substr(0, cursorPos);

if (_history->FindMatchingCommand(prefix, _history->LastDisplayed, index, CommandHistory::MatchOptions::None))

{

_replace(_history->RetrieveNth(index));

_setCursorPosition(cursorPos);

}

}

break;

case VK_F9:

if (_history && _history->GetNumberOfCommands())

{

_popupPush(PopupKind::CommandNumber);

}

break;

case VK_F10:

// Alt+F10 clears the aliases for specifically cmd.exe.

if (altPressed)

{

Alias::s_ClearCmdExeAliases();

}

break;

default:

assert(false); // Unrecognized VK. Fix or don't call this function?

break;

}

{

auto writer = _userBuffer;

auto buffer = std::move(_buffer);

std::wstring_view input{ buffer };

size_t lineCount = 1;

if (_state == State::DoneWithCarriageReturn)

{

static constexpr std::wstring_view cr{ L"\r" };

static constexpr std::wstring_view crlf{ L"\r\n" };

const auto newlineSuffix = WI_IsFlagSet(_pInputBuffer->InputMode, ENABLE_PROCESSED_INPUT) ? crlf : cr;

std::wstring alias;

// Here's why we can't easily use _flushBuffer() to handle newlines:

//

// A carriage return (enter key) will increase the _distanceEnd by up to viewport-width many columns,

// since it increases the Y distance between the start and end by 1 (it's a newline after all).

// This will make _flushBuffer() think that the new _buffer is way longer than the old one and so

// _erase() ends up not erasing the tail end of the prompt, even if the new prompt is actually shorter.

//

// If you were to break this (remove this code and then append \r\n in _handleChar())

// you can reproduce the issue easily if you do this:

// * Run cmd.exe

// * Write "echo hello" and press Enter

// * Write "foobar foo bar" (don't press Enter)

// * Press F7, select "echo hello" and press Enter

//

// It'll print "hello" but the previous prompt will say "echo hello bar" because the _distanceEnd

// ended up being well over 14 leading it to believe that "bar" got overwritten during WriteCharsLegacy().

WriteCharsLegacy(_screenInfo, newlineSuffix, nullptr);

if (WI_IsFlagSet(_pInputBuffer->InputMode, ENABLE_ECHO_INPUT))

{

if (_history)

{

auto& gci = ServiceLocator::LocateGlobals().getConsoleInformation();

LOG_IF_FAILED(_history->Add(input, WI_IsFlagSet(gci.Flags, CONSOLE_HISTORY_NODUP)));

}

Tracing::s_TraceCookedRead(_processHandle, input);

alias = Alias::s_MatchAndCopyAlias(input, _exeName, lineCount);

}

if (!alias.empty())

{

buffer = std::move(alias);

}

else

{

buffer.append(newlineSuffix);

}

input = std::wstring_view{ buffer };

// doskey aliases may result in multiple lines of output (for instance `doskey test=echo foo$Techo bar$Techo baz`).

// We need to emit them as multiple cooked reads as well, so that each read completes at a \r\n.

if (lineCount > 1)

{

// ProcessAliases() is supposed to end each line with \r\n. If it doesn't we might as well fail-fast.

const auto firstLineEnd = input.find(UNICODE_LINEFEED) + 1;

input = input.substr(0, std::min(input.size(), firstLineEnd));

}

}

const auto inputSizeBefore = input.size();

_pInputBuffer->Consume(isUnicode, input, writer);

if (lineCount > 1)

{

// This is a continuation of the above identical if condition.

// We've truncated the `input` slice and now we need to restore it.

const auto inputSizeAfter = input.size();

const auto amountConsumed = inputSizeBefore - inputSizeAfter;

input = std::wstring_view{ buffer };

input = input.substr(std::min(input.size(), amountConsumed));

GetInputReadHandleData()->SaveMultilinePendingInput(input);

}

else if (!input.empty())

{

GetInputReadHandleData()->SavePendingInput(input);

}

auto& gci = ServiceLocator::LocateGlobals().getConsoleInformation();

gci.Flags |= CONSOLE_IGNORE_NEXT_KEYUP;

// If we previously called SetCursorDBMode() with true,

// this will ensure that the cursor returns to its normal look.

_screenInfo.SetCursorDBMode(false);

numBytes = _userBuffer.size() - writer.size();

controlKeyState = _controlKeyState;

{

assert(_state == State::Accumulating);

_state = state;

{

const auto& textBuffer = _screenInfo.GetTextBuffer();

const auto& cursor = textBuffer.GetCursor();

auto cursorPos = cursor.GetPosition();

_screenInfo.GetVtPageArea().ConvertToOrigin(&cursorPos);

cursorPos.x = std::max(0, cursorPos.x);

cursorPos.y = std::max(0, cursorPos.y);

return cursorPos;

{

if (!_originInViewport)

{

_originInViewport.emplace(_getViewportCursorPosition());

}

return *_originInViewport;

{

const auto size = _buffer.size();

offset = std::min(offset, size);

remove = std::min(remove, size - offset);

// Nothing to do. Avoid marking it as dirty.

if (remove == 0 && count == 0)

{

return;

}

_buffer.replace(offset, remove, input, count);

_bufferCursor = offset + count;

_bufferDirtyBeg = std::min(_bufferDirtyBeg, offset);

_dirty = true;

{

_buffer.assign(str);

_bufferCursor = _buffer.size();

_bufferDirtyBeg = 0;

_dirty = true;

{

_bufferCursor = std::min(position, _buffer.size());

_dirty = true;

{

to = std::min(to, _buffer.size());

from = std::min(from, to);

return std::wstring_view{ _buffer.data() + from, to - from };

{

if (!_dirty || WI_IsFlagClear(_pInputBuffer->InputMode, ENABLE_ECHO_INPUT))

{

return;

}

const auto size = _screenInfo.GetVtPageArea().Dimensions();

auto originInViewport = _getOriginInViewport();

auto originInViewportFinal = originInViewport;

til::point cursorPositionFinal;

til::point pagerPromptEnd;

std::vector<Line> lines;

// FYI: This loop does not loop. It exists because goto is considered evil

// and if MSVC says that then that must be true.

for (;;)

{

cursorPositionFinal = { originInViewport.x, 0 };

// Construct the first line manually so that it starts at the correct horizontal position.

LayoutResult res{ .column = cursorPositionFinal.x };

lines.emplace_back(std::wstring{}, 0, cursorPositionFinal.x, cursorPositionFinal.x);

// Split the buffer into 3 segments, so that we can find the row/column coordinates of

// the cursor within the buffer, as well as the start of the dirty parts of the buffer.

const size_t offsets[]{

0,

std::min(_bufferDirtyBeg, _bufferCursor),

std::max(_bufferDirtyBeg, _bufferCursor),

npos,

};

for (int i = 0; i < 3; i++)

{

const auto& segment = til::safe_slice_abs(_buffer, offsets[i], offsets[i + 1]);

if (segment.empty())

{

continue;

}

const auto dirty = offsets[i] >= _bufferDirtyBeg;

// Layout the _buffer contents into lines.

for (size_t beg = 0; beg < segment.size();)

{

if (res.column >= size.width)

{

lines.emplace_back();

}

auto& line = lines.back();

res = _layoutLine(line.text, segment, beg, line.columns, size.width);

line.columns = res.column;

if (!dirty)

{

line.dirtyBegOffset = line.text.size();

line.dirtyBegColumn = res.column;

}

beg = res.offset;

}

// If this segment ended at the cursor offset, we got our cursor position in rows/columns.

if (offsets[i + 1] == _bufferCursor)

{

cursorPositionFinal = { res.column, gsl::narrow_cast<til::CoordType>(lines.size() - 1) };

}

}

pagerPromptEnd = { res.column, gsl::narrow_cast<til::CoordType>(lines.size() - 1) };

// If the content got a little shorter than it was before, we need to erase the tail end.

// If the last character on a line got removed, we'll skip this code because `remaining`

// will be negative, and instead we'll erase it later when we append " \r" to the lines.

// If entire lines got removed, then we'll fix this later when comparing against _pagerContentEnd.y.

if (pagerPromptEnd.y <= _pagerPromptEnd.y)

{

const auto endX = _pagerPromptEnd.y == pagerPromptEnd.y ? _pagerPromptEnd.x : size.width;

const auto remaining = endX - pagerPromptEnd.x;

if (remaining > 0)

{

auto& line = lines.back();

// CSI K may be expensive, so use spaces if we can.

if (remaining <= 16)

{

line.text.append(remaining, L' ');

line.columns += remaining;

}

else

{