this[kSawReturnAt] = 0;

// TODO(BridgeAR): Document this property. The name is not ideal, so we

// might want to expose an alias and document that instead.

this.isCompletionEnabled = true;

this[kSawKeyPress] = false;

this[kPreviousKey] = null;

this.escapeCodeTimeout = ESCAPE_CODE_TIMEOUT;

this.tabSize = 8;

FunctionPrototypeCall(EventEmitter, this);

let crlfDelay;

let prompt = '> ';

let signal;

if (input?.input) {

// An options object was given

output = input.output;

completer = input.completer;

terminal = input.terminal;

signal = input.signal;

// It is possible to configure the history through the input object

const historySize = input.historySize;

const history = input.history;

const removeHistoryDuplicates = input.removeHistoryDuplicates;

if (input.tabSize !== undefined) {

validateUint32(input.tabSize, 'tabSize', true);

this.tabSize = input.tabSize;

}

if (input.prompt !== undefined) {

prompt = input.prompt;

}

if (input.escapeCodeTimeout !== undefined) {

if (NumberIsFinite(input.escapeCodeTimeout)) {

this.escapeCodeTimeout = input.escapeCodeTimeout;

} else {

throw new ERR_INVALID_ARG_VALUE(

'input.escapeCodeTimeout',

this.escapeCodeTimeout,

);

}

}

if (signal) {

validateAbortSignal(signal, 'options.signal');

}

crlfDelay = input.crlfDelay;

input = input.input;

input.size = historySize;

input.history = history;

input.removeHistoryDuplicates = removeHistoryDuplicates;

}

this.setupHistoryManager(input);

if (completer !== undefined && typeof completer !== 'function') {

throw new ERR_INVALID_ARG_VALUE('completer', completer);

}

// Backwards compat; check the isTTY prop of the output stream

// when `terminal` was not specified

if (terminal === undefined && !(output === null || output === undefined)) {

terminal = !!output.isTTY;

}

const self = this;

this.line = '';

this[kIsMultiline] = false;

this[kSubstringSearch] = null;

this.output = output;

this.input = input;

this[kUndoStack] = [];

this[kRedoStack] = [];

this[kPreviousCursorCols] = -1;

// The kill ring is a global list of blocks of text that were previously

// killed (deleted). If its size exceeds kMaxLengthOfKillRing, the oldest

// element will be removed to make room for the latest deletion. With kill

// ring, users are able to recall (yank) or cycle (yank pop) among previously

// killed texts, quite similar to the behavior of Emacs.

this[kKillRing] = [];

this[kKillRingCursor] = 0;

this.crlfDelay = crlfDelay ?

MathMax(kMincrlfDelay, crlfDelay) :

kMincrlfDelay;

this.completer = completer;

this.setPrompt(prompt);

this.terminal = !!terminal;

function onerror(err) {

self.emit('error', err);

}

function ondata(data) {

self[kNormalWrite](data);

}

function onend() {

if (

typeof self[kLine_buffer] === 'string' &&

self[kLine_buffer].length > 0

) {

self.emit('line', self[kLine_buffer]);

}

self.close();

}

function ontermend() {

if (typeof self.line === 'string' && self.line.length > 0) {

self.emit('line', self.line);

}

self.close();

}

function onkeypress(s, key) {

self[kTtyWrite](s, key);

if (key?.sequence) {

// If the key.sequence is half of a surrogate pair

// (>= 0xd800 and <= 0xdfff), refresh the line so

// the character is displayed appropriately.

const ch = StringPrototypeCodePointAt(key.sequence, 0);

if (ch >= 0xd800 && ch <= 0xdfff) self[kRefreshLine]();

}

}

function onresize() {

self[kRefreshLine]();

}

this[kLineObjectStream] = undefined;

input.on('error', onerror);

if (!this.terminal) {

function onSelfCloseWithoutTerminal() {

input.removeListener('data', ondata);

input.removeListener('error', onerror);

input.removeListener('end', onend);

}

input.on('data', ondata);

input.on('end', onend);

self.once('close', onSelfCloseWithoutTerminal);

this[kDecoder] = new StringDecoder('utf8');

} else {

function onSelfCloseWithTerminal() {

input.removeListener('keypress', onkeypress);

input.removeListener('error', onerror);

input.removeListener('end', ontermend);

if (output !== null && output !== undefined) {

output.removeListener('resize', onresize);

}

}

emitKeypressEvents ??= require('internal/readline/emitKeypressEvents');

emitKeypressEvents(input, this);

// `input` usually refers to stdin

input.on('keypress', onkeypress);

input.on('end', ontermend);

this[kSetRawMode](true);

this.terminal = true;

// Cursor position on the line.

this.cursor = 0;

if (output !== null && output !== undefined)

output.on('resize', onresize);

self.once('close', onSelfCloseWithTerminal);

}

if (signal) {

const onAborted = () => self.close();

if (signal.aborted) {

process.nextTick(onAborted);

} else {

const disposable = addAbortListener(signal, onAborted);

self.once('close', disposable[SymbolDispose]);

}

}

// Current line

this[kSetLine]('');

input.resume();

// eslint-disable-next-line no-useless-constructor

constructor(input, output, completer, terminal) {

super(input, output, completer, terminal);

}

get columns() {

if (this.output?.columns) return this.output.columns;

return Infinity;

}

/**

setPrompt(prompt) {

this[kPrompt] = prompt;

}

/**

getPrompt() {

return this[kPrompt];

}

setupHistoryManager(options) {

this.historyManager = new ReplHistory(this, options);

if (options.onHistoryFileLoaded) {

this.historyManager.initialize(options.onHistoryFileLoaded);

}

ObjectDefineProperty(this, 'history', {

__proto__: null, configurable: true, enumerable: true,

get() { return this.historyManager.history; },

set(newHistory) { return this.historyManager.history = newHistory; },

});

ObjectDefineProperty(this, 'historyIndex', {

__proto__: null, configurable: true, enumerable: true,

get() { return this.historyManager.index; },

set(historyIndex) { return this.historyManager.index = historyIndex; },

});

ObjectDefineProperty(this, 'historySize', {

__proto__: null, configurable: true, enumerable: true,

get() { return this.historyManager.size; },

});

ObjectDefineProperty(this, 'isFlushing', {

__proto__: null, configurable: true, enumerable: true,

get() { return this.historyManager.isFlushing; },

});

}

[kSetRawMode](mode) {

const wasInRawMode = this.input.isRaw;

if (typeof this.input.setRawMode === 'function') {

this.input.setRawMode(mode);

}

return wasInRawMode;

}

/**

prompt(preserveCursor) {

if (this.paused) this.resume();

if (this.terminal && process.env.TERM !== 'dumb') {

if (!preserveCursor) this.cursor = 0;

this[kRefreshLine]();

} else {

this[kWriteToOutput](this[kPrompt]);

}

}

[kQuestion](query, cb) {

if (this.closed) {

throw new ERR_USE_AFTER_CLOSE('readline');

}

if (this[kQuestionCallback]) {

this.prompt();

} else {

this[kOldPrompt] = this[kPrompt];

this.setPrompt(query);

this[kQuestionCallback] = cb;

this.prompt();

}

}

[kSetLine](line = '') {

this.line = line;

this[kIsMultiline] = StringPrototypeIncludes(line, '\n');

}

[kOnLine](line) {

if (this[kQuestionCallback]) {

const cb = this[kQuestionCallback];

this[kQuestionCallback] = null;

this.setPrompt(this[kOldPrompt]);

cb(line);

} else {

this.emit('line', line);

}

}

[kBeforeEdit](oldText, oldCursor) {

this[kPushToUndoStack](oldText, oldCursor);

}

[kQuestionCancel]() {

if (this[kQuestionCallback]) {

this[kQuestionCallback] = null;

this.setPrompt(this[kOldPrompt]);

this.clearLine();

}

}

[kWriteToOutput](stringToWrite) {

validateString(stringToWrite, 'stringToWrite');

if (this.output !== null && this.output !== undefined) {

this.output.write(stringToWrite);

}

}

[kAddHistory]() {

return this.historyManager.addHistory(this[kIsMultiline], this[kLastCommandErrored]);

}

[kRefreshLine]() {

// line length

const line = this[kPrompt] + this.line;

const dispPos = this[kGetDisplayPos](line);

const lineCols = dispPos.cols;

const lineRows = dispPos.rows;

// cursor position

const cursorPos = this.getCursorPos();

// First move to the bottom of the current line, based on cursor pos

const prevRows = this.prevRows || 0;

if (prevRows > 0) {

moveCursor(this.output, 0, -prevRows);

}

// Cursor to left edge.

cursorTo(this.output, 0);

// erase data

clearScreenDown(this.output);

if (this[kIsMultiline]) {

const lines = StringPrototypeSplit(this.line, '\n');

// Write first line with normal prompt

this[kWriteToOutput](this[kPrompt] + lines[0]);

// For continuation lines, add the "|" prefix

for (let i = 1; i < lines.length; i++) {

this[kWriteToOutput](`\n${kMultilinePrompt.description}` + lines[i]);

}

} else {

// Write the prompt and the current buffer content.

this[kWriteToOutput](line);

}

// Force terminal to allocate a new line

if (lineCols === 0) {

this[kWriteToOutput](' ');

}

// Move cursor to original position.

cursorTo(this.output, cursorPos.cols);

const diff = lineRows - cursorPos.rows;

if (diff > 0) {

moveCursor(this.output, 0, -diff);

}

this.prevRows = cursorPos.rows;

}

/**

close() {

if (this.closed) return;

this.pause();

if (this.terminal) {

this[kSetRawMode](false);

}

this.closed = true;

this.emit('close');

}

/**

pause() {

if (this.closed) {

throw new ERR_USE_AFTER_CLOSE('readline');

}

if (this.paused) return;

this.input.pause();

this.paused = true;

this.emit('pause');

return this;

}

/**

resume() {

if (this.closed) {

throw new ERR_USE_AFTER_CLOSE('readline');

}

if (!this.paused) return;

this.input.resume();

this.paused = false;

this.emit('resume');

return this;

}

/**

write(d, key) {

if (this.closed) {

throw new ERR_USE_AFTER_CLOSE('readline');

}

if (this.paused) this.resume();

if (this.terminal) {

this[kTtyWrite](d, key);

} else {

this[kNormalWrite](d);

}

}

[kNormalWrite](b) {

if (b === undefined) {

return;

}

let string = this[kDecoder].write(b);

if (

this[kSawReturnAt] &&

DateNow() - this[kSawReturnAt] <= this.crlfDelay

) {

if (StringPrototypeCodePointAt(string) === 10) string = StringPrototypeSlice(string, 1);

this[kSawReturnAt] = 0;

}

// Run test() on the new string chunk, not on the entire line buffer.

let newPartContainsEnding = RegExpPrototypeExec(lineEnding, string);

if (newPartContainsEnding !== null) {

if (this[kLine_buffer]) {

string = this[kLine_buffer] + string;

this[kLine_buffer] = null;

lineEnding.lastIndex = 0; // Start the search from the beginning of the string.

newPartContainsEnding = RegExpPrototypeExec(lineEnding, string);

}

this[kSawReturnAt] = StringPrototypeEndsWith(string, '\r') ?

DateNow() :

0;

const indexes = [0, newPartContainsEnding.index, lineEnding.lastIndex];

let nextMatch;

while ((nextMatch = RegExpPrototypeExec(lineEnding, string)) !== null) {

ArrayPrototypePush(indexes, nextMatch.index, lineEnding.lastIndex);

}

const lastIndex = indexes.length - 1;

// Either '' or (conceivably) the unfinished portion of the next line

this[kLine_buffer] = StringPrototypeSlice(string, indexes[lastIndex]);

for (let i = 1; i < lastIndex; i += 2) {

this[kOnLine](StringPrototypeSlice(string, indexes[i - 1], indexes[i]));

}

} else if (string) {

// No newlines this time, save what we have for next time

if (this[kLine_buffer]) {

this[kLine_buffer] += string;

} else {

this[kLine_buffer] = string;

}

}

}

[kInsertString](c) {

this[kBeforeEdit](this.line, this.cursor);

if (this.cursor < this.line.length) {

const beg = StringPrototypeSlice(this.line, 0, this.cursor);

const end = StringPrototypeSlice(

this.line,

this.cursor,

this.line.length,

);

this[kSetLine](beg + c + end);

this.cursor += c.length;

this[kRefreshLine]();

} else {

const oldPos = this.getCursorPos();

this.line += c;

this.cursor += c.length;

const newPos = this.getCursorPos();

if (oldPos.rows < newPos.rows) {

this[kRefreshLine]();

} else {

this[kWriteToOutput](c);

}

}

}

async [kTabComplete](lastKeypressWasTab) {

this.pause();

const string = StringPrototypeSlice(this.line, 0, this.cursor);

let value;

try {

value = await this.completer(string);

} catch (err) {

this[kWriteToOutput](`Tab completion error: ${inspect(err)}`);

return;

} finally {

this.resume();

}

this[kTabCompleter](lastKeypressWasTab, value);

}

[kTabCompleter](lastKeypressWasTab, { 0: completions, 1: completeOn }) {

// Result and the text that was completed.

if (!completions || completions.length === 0) {

return;

}

// If there is a common prefix to all matches, then apply that portion.

const prefix = commonPrefix(

ArrayPrototypeFilter(completions, (e) => e !== ''),

);

if (StringPrototypeStartsWith(prefix, completeOn) &&

prefix.length > completeOn.length) {

this[kInsertString](StringPrototypeSlice(prefix, completeOn.length));

return;

} else if (!StringPrototypeStartsWith(completeOn, prefix)) {

this[kSetLine](StringPrototypeSlice(this.line,

0,

this.cursor - completeOn.length) +

prefix +

StringPrototypeSlice(this.line,

this.cursor,

this.line.length));

this.cursor = this.cursor - completeOn.length + prefix.length;

this[kRefreshLine]();

return;

}

if (!lastKeypressWasTab) {

return;

}

this[kBeforeEdit](this.line, this.cursor);

// Apply/show completions.

const completionsWidth = ArrayPrototypeMap(completions, (e) =>

getStringWidth(e),

);

const width = MathMaxApply(completionsWidth) + 2; // 2 space padding

let maxColumns = MathFloor(this.columns / width) || 1;

if (maxColumns === Infinity) {

maxColumns = 1;

}

let output = '\r\n';

let lineIndex = 0;

let whitespace = 0;

for (let i = 0; i < completions.length; i++) {

const completion = completions[i];

if (completion === '' || lineIndex === maxColumns) {

output += '\r\n';

lineIndex = 0;

whitespace = 0;

} else {

output += StringPrototypeRepeat(' ', whitespace);

}

if (completion !== '') {

output += completion;

whitespace = width - completionsWidth[i];

lineIndex++;

} else {

output += '\r\n';

}

}

if (lineIndex !== 0) {

output += '\r\n\r\n';

}

this[kWriteToOutput](output);

this[kRefreshLine]();

}

[kWordLeft]() {

if (this.cursor > 0) {

// Reverse the string and match a word near beginning

// to avoid quadratic time complexity

const leading = StringPrototypeSlice(this.line, 0, this.cursor);

const reversed = ArrayPrototypeJoin(

ArrayPrototypeReverse(ArrayFrom(leading)),

'',

);

const match = RegExpPrototypeExec(/^\s*(?:[^\w\s]+|\w+)?/, reversed);

this[kMoveCursor](-match[0].length);

}

}

[kWordRight]() {

if (this.cursor < this.line.length) {

const trailing = StringPrototypeSlice(this.line, this.cursor);

const match = RegExpPrototypeExec(/^(?:\s+|[^\w\s]+|\w+)\s*/, trailing);

this[kMoveCursor](match[0].length);

}

}

[kDeleteLeft]() {

if (this.cursor > 0 && this.line.length > 0) {

this[kBeforeEdit](this.line, this.cursor);

// The number of UTF-16 units comprising the character to the left

const charSize = charLengthLeft(this.line, this.cursor);

this.line =

StringPrototypeSlice(this.line, 0, this.cursor - charSize) +

StringPrototypeSlice(this.line, this.cursor, this.line.length);

this.cursor -= charSize;

this[kRefreshLine]();

}

}

[kDeleteRight]() {

if (this.cursor < this.line.length) {

this[kBeforeEdit](this.line, this.cursor);

// The number of UTF-16 units comprising the character to the left

const charSize = charLengthAt(this.line, this.cursor);

this.line =

StringPrototypeSlice(this.line, 0, this.cursor) +

StringPrototypeSlice(

this.line,

this.cursor + charSize,

this.line.length,

);

this[kRefreshLine]();

}

}

[kDeleteWordLeft]() {

if (this.cursor > 0) {

this[kBeforeEdit](this.line, this.cursor);

// Reverse the string and match a word near beginning

// to avoid quadratic time complexity

let leading = StringPrototypeSlice(this.line, 0, this.cursor);