const {

ArrayFrom,

ArrayPrototypeFilter,

ArrayPrototypeIndexOf,

ArrayPrototypeJoin,

ArrayPrototypeMap,

ArrayPrototypePop,

ArrayPrototypePush,

ArrayPrototypeReverse,

ArrayPrototypeShift,

ArrayPrototypeSplice,

ArrayPrototypeUnshift,

DateNow,

FunctionPrototypeCall,

MathMax,

MathMaxApply,

NumberIsFinite,

ObjectDefineProperty,

ObjectSetPrototypeOf,

RegExpPrototypeExec,

SafeStringIterator,

StringPrototypeSlice,

StringPrototypeSplit,

StringPrototypeStartsWith,

StringPrototypeTrim,

Symbol,

SymbolAsyncIterator,

SymbolDispose,

const {

validateAbortSignal,

validateArray,

validateNumber,

validateString,

validateUint32,

} = require('internal/validators');

charLengthLeft,

commonPrefix,

kSubstringSearch,

reverseString,

} = require('internal/readline/utils');

let emitKeypressEvents;

let kFirstEventParam;

} = require('internal/readline/callbacks');

const { StringDecoder } = require('string_decoder');

const { ReplHistory } = require('internal/repl/history');

const kHistorySize = 30;

const kMaxUndoRedoStackSize = 2048;

const kMincrlfDelay = 100;

/**

const kYank = Symbol('_yank');

const kYanking = Symbol('_yanking');

const kYankPop = Symbol('_yankPop');

const kNormalizeHistoryLineEndings = Symbol('_normalizeHistoryLineEndings');

const kSavePreviousState = Symbol('_savePreviousState');

const kRestorePreviousState = Symbol('_restorePreviousState');

const kPreviousLine = Symbol('_previousLine');

FunctionPrototypeCall(EventEmitter, this);

let history;

let historySize;

let removeHistoryDuplicates = false;

let crlfDelay;

let prompt = '> ';

let signal;

output = input.output;

completer = input.completer;

terminal = input.terminal;

history = input.history;

historySize = input.historySize;

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;

}

removeHistoryDuplicates = input.removeHistoryDuplicates;

if (input.prompt !== undefined) {

prompt = input.prompt;

}

crlfDelay = input.crlfDelay;

input = input.input;

}

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

throw new ERR_INVALID_ARG_VALUE('completer', completer);

input.size = historySize;

input.history = history;

input.removeHistoryDuplicates = removeHistoryDuplicates;

}

if (history === undefined) {

history = [];

} else {

validateArray(history, 'history');

}

this.setupHistoryManager(input);

if (historySize === undefined) {

historySize = kHistorySize;

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

throw new ERR_INVALID_ARG_VALUE('completer', completer);

}

validateNumber(historySize, 'historySize', 0);

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

// when `terminal` was not specified

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

this.input = input;

this[kUndoStack] = [];

this[kRedoStack] = [];

this.history = history;

this.historySize = historySize;

this[kPreviousCursorCols] = -1;

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

this[kKillRing] = [];

this[kKillRingCursor] = 0;

this.removeHistoryDuplicates = !!removeHistoryDuplicates;

this.crlfDelay = crlfDelay ?

MathMax(kMincrlfDelay, crlfDelay) :

kMincrlfDelay;

this.terminal = !!terminal;

function onerror(err) {

self.emit('error', err);

}

// Cursor position on the line.

this.cursor = 0;

this.historyIndex = -1;

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

output.on('resize', onresize);

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;

}

}

// Convert newlines to a consistent format for history storage

[kNormalizeHistoryLineEndings](line, from, to, reverse = true) {

// Multiline history entries are saved reversed

// History is structured with the newest entries at the top

// and the oldest at the bottom. Multiline histories, however, only occupy

// one line in the history file. When loading multiline history with

// an old node binary, the history will be saved in the old format.

// This is why we need to reverse the multilines.

// Reversing the multilines is necessary when adding / editing and displaying them

if (reverse) {

// First reverse the lines for proper order, then convert separators

return reverseString(line, from, to);

}

// For normal cases (saving to history or non-multiline entries)

return StringPrototypeReplaceAll(line, from, to);

}

[kAddHistory]() {

if (this.line.length === 0) return '';

// If the history is disabled then return the line

if (this.historySize === 0) return this.line;

// If the trimmed line is empty then return the line

if (StringPrototypeTrim(this.line).length === 0) return this.line;

// This is necessary because each line would be saved in the history while creating

// A new multiline, and we don't want that.

if (this[kIsMultiline] && this.historyIndex === -1) {

ArrayPrototypeShift(this.history);

} else if (this[kLastCommandErrored]) {

// If the last command errored and we are trying to edit the history to fix it

// Remove the broken one from the history

ArrayPrototypeShift(this.history);

}

const normalizedLine = this[kNormalizeHistoryLineEndings](this.line, '\n', '\r', true);

if (this.history.length === 0 || this.history[0] !== normalizedLine) {

if (this.removeHistoryDuplicates) {

// Remove older history line if identical to new one

const dupIndex = ArrayPrototypeIndexOf(this.history, this.line);

if (dupIndex !== -1) ArrayPrototypeSplice(this.history, dupIndex, 1);

}

// Add the new line to the history

ArrayPrototypeUnshift(this.history, normalizedLine);

// Only store so many

if (this.history.length > this.historySize)

ArrayPrototypePop(this.history);

}

this.historyIndex = -1;

// The listener could change the history object, possibly

// to remove the last added entry if it is sensitive and should

// not be persisted in the history, like a password

const line = this[kIsMultiline] ? reverseString(this.history[0]) : this.history[0];

// Emit history event to notify listeners of update

this.emit('history', this.history);

return line;

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

}

[kRefreshLine]() {

// <ctrl> + N. Only show this after two/three UPs or DOWNs, not on the first

// one.

[kHistoryNext]() {

if (this.historyIndex >= 0) {

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

const search = this[kSubstringSearch] || '';

let index = this.historyIndex - 1;

while (

index >= 0 &&

(!StringPrototypeStartsWith(this.history[index], search) ||

this.line === this.history[index])

) {

index--;

}

if (index === -1) {

this[kSetLine](search);

} else {

this[kSetLine](this[kNormalizeHistoryLineEndings](this.history[index], '\r', '\n'));

}

this.historyIndex = index;

this.cursor = this.line.length; // Set cursor to end of line.

this[kRefreshLine]();

}

if (!this.historyManager.canNavigateToNext()) { return; }

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

this[kSetLine](this.historyManager.navigateToNext(this[kSubstringSearch]));

this.cursor = this.line.length; // Set cursor to end of line.

this[kRefreshLine]();

}

[kMoveUpOrHistoryPrev]() {

}

[kHistoryPrev]() {

if (this.historyIndex < this.history.length && this.history.length) {

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

const search = this[kSubstringSearch] || '';

let index = this.historyIndex + 1;

while (

index < this.history.length &&

(!StringPrototypeStartsWith(this.history[index], search) ||

this.line === this.history[index])

) {

index++;

}

if (index === this.history.length) {

this[kSetLine](search);

} else {

this[kSetLine](this[kNormalizeHistoryLineEndings](this.history[index], '\r', '\n'));

}

this.historyIndex = index;

this.cursor = this.line.length; // Set cursor to end of line.

this[kRefreshLine]();

}

if (!this.historyManager.canNavigateToPrevious()) { return; }

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

this[kSetLine](this.historyManager.navigateToPrevious(this[kSubstringSearch]));

this.cursor = this.line.length; // Set cursor to end of line.

this[kRefreshLine]();

}

// Returns the last character's display position of the given string