visaljs 0.0.10 → 0.0.11

package/node/prelude/internal/readline.js

@@ -1,338 +1,712 @@
-// node:readline's Interface, which node:readline/promises extends: an input stream read a line at
-// a time, as Node's Interface reads one that isn't a terminal: 'line' for each line (ended by \n,
-// \r\n or \r), a question's answer to its callback, the prompt written to the output, and the lines
-// as an async iterator. A terminal is read in its normal mode, the terminal editing the line and
-// echoing it; Node's own editor in raw mode (keys, history, completion) isn't provided, nor is
-// emitKeypressEvents. The cursor functions write ANSI escapes.
+// node:readline's Interface (Node's lib/internal/readline/interface.js, utils.js, callbacks.js and
+// the in-memory part of internal/repl/history.js), which node:readline and readline/promises extend.
+// The terminal line editor (raw mode keys, editing, completion, the kill ring, undo, history
+// navigation, emitKeypressEvents) is a feature module, internal/readline_editor.js, linked into
+// programs that may read a terminal; without it an interface on a terminal reads lines as on a pipe.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import { EventEmitter } from "../events.js";
-import { codeError, invalidArgType, invalidArgValue, notSupported, validateFunction, validateString } from "./errors.js";
-import { Readable } from "../stream.js";
 import { StringDecoder } from "../string_decoder.js";
+import { getStringWidth, stripVTControlCharacters } from "./string_width.js";
+import { codeError, invalidArgType, invalidArgValue, outOfRange, validateFunction, validateString } from "./errors.js";
+import { feature, features } from "./features.js";
 
-/* what ends a line; a \r at a chunk's end may be a \r\n split across chunks: a \n first in the
- * next chunk, within crlfDelay, belongs to it */
-const lineEnding = /\r?\n|\r(?!\n)/g;
-const kMinCrlfDelay = 100;
-const kPromisifyCustom = Symbol.for("nodejs.util.promisify.custom");
+/* ---- utils (Node's internal/readline/utils.js) ---------------------------------------------- */
 
-export const kQuestion = Symbol("question");
-export const kQuestionCancel = Symbol("questionCancel");
+const kUTF16SurrogateThreshold = 0x10000;
+const kEscape = "\x1b";
+export const kSubstringSearch = Symbol("kSubstringSearch");
 
-function validateSignal(signal, name) {
-  if (signal !== undefined && (signal === null || typeof signal !== "object" || !("aborted" in signal))) {
-    throw invalidArgType(name, "an instance of AbortSignal", signal);
+export function CSI(strings, ...args) {
+  let ret = `${kEscape}[`;
+  for (let n = 0; n < strings.length; n++) {
+    ret += strings[n];
+    if (n < args.length) ret += args[n];
+  }
+  return ret;
+}
+CSI.kEscape = kEscape;
+CSI.kClearToLineBeginning = CSI`1K`;
+CSI.kClearToLineEnd = CSI`0K`;
+CSI.kClearLine = CSI`2K`;
+CSI.kClearScreenDown = CSI`0J`;
+
+export function charLengthLeft(str, i) {
+  if (i <= 0) return 0;
+  if ((i > 1 && str.codePointAt(i - 2) >= kUTF16SurrogateThreshold) || str.codePointAt(i - 1) >= kUTF16SurrogateThreshold) return 2;
+  return 1;
+}
+
+export function charLengthAt(str, i) {
+  if (str.length <= i) {
+    /* pretend there's a character at the end, so the cursor can move past the line */
+    return 1;
   }
+  return str.codePointAt(i) >= kUTF16SurrogateThreshold ? 2 : 1;
 }
 
-/** Node's AbortError: name and code, the signal's reason as its cause. */
-export function abortError(signal) {
-  const error = new Error("The operation was aborted", { cause: signal?.reason });
+/* the line's parts in reverse: history keeps a multiline entry's lines last to first */
+function reverseString(line, from = "\r", to = "\r") {
+  const parts = line.split(from);
+  let result = "";
+  for (let i = parts.length - 1; i > 0; i--) result += parts[i] + to;
+  result += parts[0];
+  return result;
+}
+
+/* ---- errors and validation ------------------------------------------------------------------- */
+
+const useAfterClose = () => codeError(Error, "ERR_USE_AFTER_CLOSE", "readline was closed");
+
+/* Node's AbortError: name and code, the signal's reason as its cause */
+export function abortError(message = "The operation was aborted", options = undefined) {
+  const error = new Error(message, options);
   error.code = "ABORT_ERR";
   error.name = "AbortError";
   return error;
 }
 
-/** Interface(input, output, completer, terminal), or Interface({ input, output, … }). A function,
- *  as Node's is: callable without new. */
-export function Interface(input, output, completer, terminal) {
-  if (!(this instanceof Interface)) return new Interface(input, output, completer, terminal);
+export function validateAbortSignal(signal, name) {
+  if (signal !== undefined && (signal === null || typeof signal !== "object" || !("aborted" in signal))) {
+    throw invalidArgType(name, "an instance of AbortSignal", signal);
+  }
+}
+
+/* Node's addAbortListener: the listener once, and a disposable that removes it */
+export function addAbortListener(signal, listener) {
+  if (signal.aborted) {
+    queueMicrotask(() => listener());
+    return { [Symbol.dispose]() {} };
+  }
+  signal.addEventListener("abort", listener, { once: true });
+  return { [Symbol.dispose]: () => signal.removeEventListener("abort", listener) };
+}
+
+function validateUint32(value, name, positive) {
+  if (typeof value !== "number") throw invalidArgType(name, "of type number", value);
+  if (!Number.isInteger(value)) throw outOfRange(name, "an integer", value);
+  const min = positive ? 1 : 0;
+  if (value < min || value > 4294967295) throw outOfRange(name, `>= ${min} && <= 4294967295`, value);
+}
+
+/* ---- the cursor functions (Node's internal/readline/callbacks.js) ---------------------------- */
+
+const done = (callback) => {
+  if (typeof callback === "function") process.nextTick(callback, null);
+  return true;
+};
+
+export function cursorTo(stream, x, y, callback) {
+  if (callback !== undefined) validateFunction(callback, "callback");
+  if (typeof y === "function") {
+    callback = y;
+    y = undefined;
+  }
+  if (Number.isNaN(x)) throw invalidArgValue("x", "is invalid", x);
+  if (Number.isNaN(y)) throw invalidArgValue("y", "is invalid", y);
+  if (stream == null || (typeof x !== "number" && typeof y !== "number")) return done(callback);
+  if (typeof x !== "number") throw codeError(TypeError, "ERR_INVALID_CURSOR_POS", "Cannot set cursor row without setting its column");
+  const data = typeof y !== "number" ? CSI`${x + 1}G` : CSI`${y + 1};${x + 1}H`;
+  return stream.write(data, callback);
+}
+
+export function moveCursor(stream, dx, dy, callback) {
+  if (callback !== undefined) validateFunction(callback, "callback");
+  if (stream == null || !(dx || dy)) return done(callback);
+  let data = "";
+  if (dx < 0) data += CSI`${-dx}D`;
+  else if (dx > 0) data += CSI`${dx}C`;
+  if (dy < 0) data += CSI`${-dy}A`;
+  else if (dy > 0) data += CSI`${dy}B`;
+  return stream.write(data, callback);
+}
+
+export function clearLine(stream, dir, callback) {
+  if (callback !== undefined) validateFunction(callback, "callback");
+  if (stream === null || stream === undefined) return done(callback);
+  const type = dir < 0 ? CSI.kClearToLineBeginning : dir > 0 ? CSI.kClearToLineEnd : CSI.kClearLine;
+  return stream.write(type, callback);
+}
+
+export function clearScreenDown(stream, callback) {
+  if (callback !== undefined) validateFunction(callback, "callback");
+  if (stream === null || stream === undefined) return done(callback);
+  return stream.write(CSI.kClearScreenDown, callback);
+}
+
+/* ---- history (Node's ReplHistory, without the REPL's file) ----------------------------------- */
+
+const kHistorySize = 30;
+
+class ReplHistory {
+  #context;
+  #removeHistoryDuplicates;
+  #size;
+  #history;
+  #index = -1;
+
+  constructor(context, options) {
+    if (options.history !== undefined && !Array.isArray(options.history)) throw invalidArgType("history", "an instance of Array", options.history);
+    if (options.size !== undefined) {
+      if (typeof options.size !== "number") throw invalidArgType("size", "of type number", options.size);
+      if (options.size < 0 || Number.isNaN(options.size)) throw outOfRange("size", ">= 0", options.size);
+    }
+    this.#context = context;
+    this.#removeHistoryDuplicates = options.removeHistoryDuplicates || false;
+    this.#size = options.size ?? context.historySize ?? kHistorySize;
+    this.#history = options.history ?? [];
+  }
+
+  addHistory(isMultiline, lastCommandErrored) {
+    const line = this.#context.line;
+    if (line.length === 0) return "";
+    if (this.#size === 0) return line;
+    if (line.trim().length === 0) return line;
+    /* a multiline entry replaces the line it continues; a failed command isn't kept */
+    if ((isMultiline && this.#index === -1) || lastCommandErrored) this.#history.shift();
+    const normalizedLine = reverseString(line, "\n", "\r");
+    if (this.#history.length === 0 || this.#history[0] !== normalizedLine) {
+      if (this.#removeHistoryDuplicates) {
+        const dupIndex = this.#history.indexOf(normalizedLine);
+        if (dupIndex !== -1) this.#history.splice(dupIndex, 1);
+      }
+      this.#history.unshift(normalizedLine);
+      if (this.#history.length > this.#size) this.#history.pop();
+    }
+    this.#index = -1;
+    const finalLine = isMultiline ? reverseString(this.#history[0]) : this.#history[0];
+    this.#context.emit("history", this.#history);
+    return finalLine;
+  }
+
+  canNavigateToNext() {
+    return this.#index > -1 && this.#history.length > 0;
+  }
+
+  navigateToNext(substringSearch) {
+    if (!this.canNavigateToNext()) return null;
+    const search = substringSearch || "";
+    let index = this.#index - 1;
+    while (index >= 0 && (!this.#history[index].startsWith(search) || this.#context.line === this.#history[index])) index--;
+    this.#index = index;
+    if (index === -1) return search;
+    return reverseString(this.#history[index], "\r", "\n");
+  }
+
+  canNavigateToPrevious() {
+    return this.#history.length !== this.#index && this.#history.length > 0;
+  }
+
+  navigateToPrevious(substringSearch = "") {
+    if (!this.canNavigateToPrevious()) return null;
+    const search = substringSearch || "";
+    let index = this.#index + 1;
+    while (index < this.#history.length && (!this.#history[index].startsWith(search) || this.#context.line === this.#history[index])) index++;
+    this.#index = index;
+    if (index === this.#history.length) return search;
+    return reverseString(this.#history[index], "\r", "\n");
+  }
+
+  get size() { return this.#size; }
+  get isFlushing() { return false; }
+  get history() { return this.#history; }
+  set history(value) { this.#history = value; }
+  get index() { return this.#index; }
+  set index(value) { this.#index = value; }
+}
+
+/* ---- Interface ------------------------------------------------------------------------------- */
+
+const kMincrlfDelay = 100;
+/* \r\n, \n, \r (not one that a \n may follow in the next chunk), and the Unicode line separators */
+const lineEnding = /\r?\n|\r(?!\n)|\u2028|\u2029/g;
+const ESCAPE_CODE_TIMEOUT = 500;
+/* events.on's option (internal/events_on.js) */
+const kFirstEventParam = Symbol.for("visaljs.events.kFirstEventParam");
+
+export const kLineObjectStream = Symbol("line object stream");
+export const kQuestionCancel = Symbol("kQuestionCancel");
+export const kQuestion = Symbol("kQuestion");
+export const kMultilinePrompt = Symbol("| ");
+
+export const kAddHistory = Symbol("_addHistory");
+export const kBeforeEdit = Symbol("_beforeEdit");
+export const kDecoder = Symbol("_decoder");
+export const kDeleteLeft = Symbol("_deleteLeft");
+export const kDeleteLineLeft = Symbol("_deleteLineLeft");
+export const kDeleteLineRight = Symbol("_deleteLineRight");
+export const kDeleteRight = Symbol("_deleteRight");
+export const kDeleteWordLeft = Symbol("_deleteWordLeft");
+export const kDeleteWordRight = Symbol("_deleteWordRight");
+export const kGetDisplayPos = Symbol("_getDisplayPos");
+export const kHistoryNext = Symbol("_historyNext");
+export const kMoveDownOrHistoryNext = Symbol("_moveDownOrHistoryNext");
+export const kHistoryPrev = Symbol("_historyPrev");
+export const kMoveUpOrHistoryPrev = Symbol("_moveUpOrHistoryPrev");
+export const kInsertString = Symbol("_insertString");
+export const kLine = Symbol("_line");
+export const kLine_buffer = Symbol("_line_buffer");
+export const kKillRing = Symbol("_killRing");
+export const kKillRingCursor = Symbol("_killRingCursor");
+export const kMoveCursor = Symbol("_moveCursor");
+export const kNormalWrite = Symbol("_normalWrite");
+export const kOldPrompt = Symbol("_oldPrompt");
+export const kOnLine = Symbol("_onLine");
+export const kSetLine = Symbol("_setLine");
+export const kPreviousKey = Symbol("_previousKey");
+export const kPrompt = Symbol("_prompt");
+export const kPushToKillRing = Symbol("_pushToKillRing");
+export const kPushToUndoStack = Symbol("_pushToUndoStack");
+export const kQuestionCallback = Symbol("_questionCallback");
+export const kLastCommandErrored = Symbol("_lastCommandErrored");
+export const kQuestionReject = Symbol("_questionReject");
+export const kRedo = Symbol("_redo");
+export const kRedoStack = Symbol("_redoStack");
+export const kRefreshLine = Symbol("_refreshLine");
+export const kSawKeyPress = Symbol("_sawKeyPress");
+export const kSawReturnAt = Symbol("_sawReturnAt");
+export const kSetRawMode = Symbol("_setRawMode");
+export const kTabComplete = Symbol("_tabComplete");
+export const kTabCompleter = Symbol("_tabCompleter");
+export const kTtyWrite = Symbol("_ttyWrite");
+export const kUndo = Symbol("_undo");
+export const kUndoStack = Symbol("_undoStack");
+export const kIsMultiline = Symbol("_isMultiline");
+export const kWordLeft = Symbol("_wordLeft");
+export const kWordRight = Symbol("_wordRight");
+export const kWriteToOutput = Symbol("_writeToOutput");
+export const kYank = Symbol("_yank");
+export const kYanking = Symbol("_yanking");
+export const kYankPop = Symbol("_yankPop");
+export const kSavePreviousState = Symbol("_savePreviousState");
+export const kRestorePreviousState = Symbol("_restorePreviousState");
+export const kPreviousLine = Symbol("_previousLine");
+export const kPreviousCursor = Symbol("_previousCursor");
+export const kPreviousCursorCols = Symbol("_previousCursorCols");
+export const kMultilineMove = Symbol("_multilineMove");
+export const kPreviousPrevRows = Symbol("_previousPrevRows");
+export const kAddNewLineOnTTY = Symbol("_addNewLineOnTTY");
+
+export function InterfaceConstructor(input, output, completer, terminal) {
+  this[kSawReturnAt] = 0;
+  this.isCompletionEnabled = true;
+  this[kSawKeyPress] = false;
+  this[kPreviousKey] = null;
+  this.escapeCodeTimeout = ESCAPE_CODE_TIMEOUT;
+  this.tabSize = 8;
+
   EventEmitter.call(this);
-  let prompt = "> ";
+
   let crlfDelay;
+  let prompt = "> ";
   let signal;
+  let historyOptions;
+
   if (input?.input) {
-    ({ output, completer, terminal, signal, crlfDelay } = input);
+    /* an options object */
+    output = input.output;
+    completer = input.completer;
+    terminal = input.terminal;
+    signal = input.signal;
+    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 (Number.isFinite(input.escapeCodeTimeout)) this.escapeCodeTimeout = input.escapeCodeTimeout;
+      else throw invalidArgValue("input.escapeCodeTimeout", "is invalid", this.escapeCodeTimeout);
+    }
+    if (signal) validateAbortSignal(signal, "options.signal");
+    crlfDelay = input.crlfDelay;
     input = input.input;
+    historyOptions = { __proto__: null, size: historySize, history, removeHistoryDuplicates };
   }
-  if (completer !== undefined && typeof completer !== "function") throw invalidArgValue("completer", "must be a function", completer);
-  validateSignal(signal, "options.signal");
-  this.input = input;
+
+  this.setupHistoryManager(historyOptions ?? input);
+
+  if (completer !== undefined && typeof completer !== "function") throw invalidArgValue("completer", "is invalid", completer);
+
+  /* the output's isTTY, when terminal isn't given (Node's backwards compatibility) */
+  if (terminal === undefined && !(output === null || output === undefined)) terminal = !!output.isTTY;
+
+  // eslint-disable-next-line @typescript-eslint/no-this-alias
+  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: what was deleted, the latest first, yanked back (Emacs's) */
+  this[kKillRing] = [];
+  this[kKillRingCursor] = 0;
+
+  this.crlfDelay = crlfDelay ? Math.max(kMincrlfDelay, crlfDelay) : kMincrlfDelay;
   this.completer = completer;
-  this.terminal = terminal === undefined ? Boolean(output?.isTTY) : Boolean(terminal);
-  this.crlfDelay = crlfDelay ? Math.max(kMinCrlfDelay, crlfDelay) : kMinCrlfDelay;
-  this.line = "";
-  this.cursor = 0;
-  this.history = [];
-  this.closed = false;
-  this.paused = false;
-  this._prompt = prompt;
-  this._oldPrompt = prompt;
-  this._questionCallback = null;
-  this._lineBuffer = null;
-  this._sawReturnAt = 0;
-  this._decoder = new StringDecoder("utf8");
-  this._lines = undefined;
-
-  const ondata = (data) => this._normalWrite(data);
-  const onend = () => {
-    if (typeof this._lineBuffer === "string" && this._lineBuffer.length > 0) this.emit("line", this._lineBuffer);
-    this.close();
-  };
-  const onerror = (err) => this.emit("error", err);
+
+  this.setPrompt(prompt);
+
+  /* a terminal needs the line editor: a program that doesn't link it reads lines as from a pipe */
+  this.terminal = !!terminal && features.readlineEditor !== undefined;
+
+  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) {
+      /* half a surrogate pair: refreshed, so the character shows once it's whole */
+      const ch = key.sequence.codePointAt(0);
+      if (ch >= 0xd800 && ch <= 0xdfff) self[kRefreshLine]();
+    }
+  }
+
+  function onresize() {
+    self[kRefreshLine]();
+  }
+
+  this[kLineObjectStream] = undefined;
+
   input.on("error", onerror);
-  input.on("data", ondata);
-  input.on("end", onend);
-  this.once("close", () => {
-    input.removeListener("error", onerror);
-    input.removeListener("data", ondata);
-    input.removeListener("end", onend);
-  });
+
+  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);
+    }
+    features.emitKeypressEvents(input, this);
+    input.on("keypress", onkeypress);
+    input.on("end", ontermend);
+    this[kSetRawMode](true);
+    this.terminal = true;
+    this.cursor = 0;
+    if (output !== null && output !== undefined) output.on("resize", onresize);
+    self.once("close", onSelfCloseWithTerminal);
+  }
+
   if (signal) {
-    const onAbort = () => this.close();
-    if (signal.aborted) process.nextTick(onAbort);
-    else {
-      signal.addEventListener("abort", onAbort, { once: true });
-      this.once("close", () => signal.removeEventListener("abort", onAbort));
+    const onAborted = () => self.close();
+    if (signal.aborted) {
+      process.nextTick(onAborted);
+    } else {
+      const disposable = addAbortListener(signal, onAborted);
+      self.once("close", disposable[Symbol.dispose]);
     }
   }
+
+  this[kSetLine]("");
+
   input.resume();
 }
-Object.setPrototypeOf(Interface.prototype, EventEmitter.prototype);
-Object.setPrototypeOf(Interface, EventEmitter);
 
-Interface.prototype.setPrompt = function setPrompt(prompt) {
-  this._prompt = prompt;
+Object.setPrototypeOf(InterfaceConstructor.prototype, EventEmitter.prototype);
+Object.setPrototypeOf(InterfaceConstructor, EventEmitter);
+
+/* the history accessors each instance gets */
+const kHistoryAccessorDescriptors = {
+  __proto__: null,
+  history: {
+    __proto__: null, configurable: true, enumerable: true,
+    get() { return this.historyManager.history; },
+    set(newHistory) { return this.historyManager.history = newHistory; },
+  },
+  historyIndex: {
+    __proto__: null, configurable: true, enumerable: true,
+    get() { return this.historyManager.index; },
+    set(historyIndex) { return this.historyManager.index = historyIndex; },
+  },
+  historySize: {
+    __proto__: null, configurable: true, enumerable: true,
+    get() { return this.historyManager.size; },
+  },
+  isFlushing: {
+    __proto__: null, configurable: true, enumerable: true,
+    get() { return this.historyManager.isFlushing; },
+  },
 };
 
-Interface.prototype.getPrompt = function getPrompt() {
-  return this._prompt;
-};
+export class Interface extends InterfaceConstructor {
+  get columns() {
+    if (this.output?.columns) return this.output.columns;
+    return Infinity;
+  }
 
-Interface.prototype._writeToOutput = function _writeToOutput(text) {
-  validateString(text, "stringToWrite");
-  if (this.output !== null && this.output !== undefined) this.output.write(text);
-};
+  setPrompt(prompt) {
+    this[kPrompt] = prompt;
+  }
 
-/** Writes the prompt, and reads again if paused. */
-Interface.prototype.prompt = function prompt() {
-  if (this.paused) this.resume();
-  if (this.closed) throw codeError(Error, "ERR_USE_AFTER_CLOSE", "readline was closed");
-  this._writeToOutput(this._prompt);
-};
+  getPrompt() {
+    return this[kPrompt];
+  }
 
-Interface.prototype[kQuestion] = function question(query, cb) {
-  if (this.closed) throw codeError(Error, "ERR_USE_AFTER_CLOSE", "readline was closed");
-  if (this._questionCallback) this.prompt();
-  else {
-    this._oldPrompt = this._prompt;
-    this.setPrompt(query);
-    this._questionCallback = cb;
-    this.prompt();
+  setupHistoryManager(options) {
+    this.historyManager = new ReplHistory(this, options);
+    Object.defineProperties(this, kHistoryAccessorDescriptors);
   }
-};
 
-/* a question given up: its prompt goes, and the line is cleared, as Node's clearLine */
-Interface.prototype[kQuestionCancel] = function questionCancel() {
-  if (!this._questionCallback) return;
-  this._questionCallback = null;
-  this.setPrompt(this._oldPrompt);
-  this._writeToOutput("\r\n");
-  this.line = "";
-  this.cursor = 0;
-};
+  [kSetRawMode](mode) {
+    const wasInRawMode = this.input.isRaw;
+    if (typeof this.input.setRawMode === "function") this.input.setRawMode(mode);
+    return wasInRawMode;
+  }
 
-/** question(query[, { signal }], cb): writes the query, and gives the next line to cb instead of
- *  'line'. */
-Interface.prototype.question = function question(query, options, cb) {
-  cb = typeof options === "function" ? options : cb;
-  if (options !== null && typeof options === "object") {
-    const { signal } = options;
-    if (signal) {
-      validateSignal(signal, "options.signal");
-      if (signal.aborted) return;
-      const onAbort = () => this[kQuestionCancel]();
-      signal.addEventListener("abort", onAbort, { once: true });
-      const cleanup = () => signal.removeEventListener("abort", onAbort);
-      const original = cb;
-      cb = typeof cb === "function" ? (answer) => {
-        cleanup();
-        return original(answer);
-      } : cleanup;
+  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]);
     }
   }
-  if (typeof cb === "function") this[kQuestion](query, cb);
-};
 
-/* util.promisify(rl.question): the answer, or an AbortError */
-Interface.prototype.question[kPromisifyCustom] = function question(query, options) {
-  if (options === null || typeof options !== "object") options = {};
-  return new Promise((resolve, reject) => {
-    let cb = resolve;
-    const { signal } = options;
-    if (signal) {
-      validateSignal(signal, "options.signal");
-      if (signal.aborted) return reject(abortError(signal));
-      const onAbort = () => reject(abortError(signal));
-      signal.addEventListener("abort", onAbort, { once: true });
-      cb = (answer) => {
-        signal.removeEventListener("abort", onAbort);
-        resolve(answer);
-      };
+  [kQuestion](query, cb) {
+    if (this.closed) throw useAfterClose();
+    if (this[kQuestionCallback]) {
+      this.prompt();
+    } else {
+      this[kOldPrompt] = this[kPrompt];
+      this.setPrompt(query);
+      this[kQuestionCallback] = cb;
+      this.prompt();
     }
-    this.question(query, options, cb);
-  });
-};
+  }
 
-Interface.prototype.pause = function pause() {
-  if (this.paused) return;
-  this.input.pause();
-  this.paused = true;
-  this.emit("pause");
-  return this;
-};
+  [kSetLine](line = "") {
+    this.line = line;
+    this[kIsMultiline] = line.includes("\n");
+  }
 
-Interface.prototype.resume = function resume() {
-  if (!this.paused) return;
-  this.input.resume();
-  this.paused = false;
-  this.emit("resume");
-  return this;
-};
+  [kOnLine](line) {
+    if (this[kQuestionCallback]) {
+      const cb = this[kQuestionCallback];
+      this[kQuestionCallback] = null;
+      this.setPrompt(this[kOldPrompt]);
+      cb(line);
+    } else {
+      this.emit("line", line);
+    }
+  }
 
-/** Ends reading: the input is paused and 'close' emitted, once. */
-Interface.prototype.close = function close() {
-  if (this.closed) return;
-  this.pause();
-  this.closed = true;
-  this.emit("close");
-};
+  [kBeforeEdit](oldText, oldCursor) {
+    this[kPushToUndoStack](oldText, oldCursor);
+  }
 
-/** Data as if it had come from the input. */
-Interface.prototype.write = function write(data) {
-  if (this.closed) throw codeError(Error, "ERR_USE_AFTER_CLOSE", "readline was closed");
-  if (this.paused) this.resume();
-  this._normalWrite(data);
-};
+  [kQuestionCancel]() {
+    if (this[kQuestionCallback]) {
+      this[kQuestionCallback] = null;
+      this.setPrompt(this[kOldPrompt]);
+      this.clearLine();
+    }
+  }
 
-Interface.prototype._onLine = function _onLine(line) {
-  if (this._questionCallback) {
-    const cb = this._questionCallback;
-    this._questionCallback = null;
-    this.setPrompt(this._oldPrompt);
-    cb(line);
-  } else this.emit("line", line);
-};
+  [kWriteToOutput](stringToWrite) {
+    validateString(stringToWrite, "stringToWrite");
+    if (this.output !== null && this.output !== undefined) this.output.write(stringToWrite);
+  }
 
-/* Node's _normalWrite: the chunk decoded, split into lines; what follows the last ending waits */
-Interface.prototype._normalWrite = function _normalWrite(chunk) {
-  if (chunk === undefined) return;
-  let string = this._decoder.write(chunk);
-  if (this._sawReturnAt && Date.now() - this._sawReturnAt <= this.crlfDelay) {
-    if (string.codePointAt(0) === 10) string = string.slice(1);
-    this._sawReturnAt = 0;
-  }
-  lineEnding.lastIndex = 0;
-  let match = lineEnding.exec(string);
-  if (match === null) {
-    if (string) this._lineBuffer = this._lineBuffer ? this._lineBuffer + string : string;
-    return;
-  }
-  if (this._lineBuffer) {
-    string = this._lineBuffer + string;
-    this._lineBuffer = null;
-    lineEnding.lastIndex = 0;
-    match = lineEnding.exec(string);
-  }
-  this._sawReturnAt = string.endsWith("\r") ? Date.now() : 0;
-  const indexes = [0, match.index, lineEnding.lastIndex];
-  while ((match = lineEnding.exec(string)) !== null) indexes.push(match.index, lineEnding.lastIndex);
-  const last = indexes.length - 1;
-  this._lineBuffer = string.slice(indexes[last]);
-  for (let i = 1; i < last; i += 2) {
-    this._onLine(string.slice(indexes[i - 1], indexes[i]));
-    if (this.closed) break;
+  [kAddHistory]() {
+    return this.historyManager.addHistory(this[kIsMultiline], this[kLastCommandErrored]);
   }
-};
 
-/** The lines, as an async iterator; reading pauses while the iterator's buffer is full. */
-Interface.prototype[Symbol.asyncIterator] = function asyncIterator() {
-  if (this._lines === undefined) {
-    const onLine = (line) => {
-      if (!readable.push(line)) this.pause();
-    };
-    const onClose = () => readable.push(null);
-    const onError = (err) => readable.destroy(err);
-    const readable = new Readable({
-      objectMode: true,
-      read: () => this.resume(),
-      destroy: (err, cb) => {
-        this.off("line", onLine);
-        this.off("close", onClose);
-        this.off("error", onError);
-        this.close();
-        cb(err);
-      },
-    });
-    this.on("error", onError);
-    this.on("line", onLine);
-    this.on("close", onClose);
-    this._lines = readable;
-  }
-  return this._lines[Symbol.asyncIterator]();
-};
+  [kRefreshLine]() {
+    const line = this[kPrompt] + this.line;
+    const dispPos = this[kGetDisplayPos](line);
+    const lineCols = dispPos.cols;
+    const lineRows = dispPos.rows;
+    const cursorPos = this.getCursorPos();
+    /* to the bottom of the line, from the cursor; to its left edge; cleared */
+    const prevRows = this.prevRows || 0;
+    if (prevRows > 0) moveCursor(this.output, 0, -prevRows);
+    cursorTo(this.output, 0);
+    clearScreenDown(this.output);
+    if (this[kIsMultiline]) {
+      const lines = this.line.split("\n");
+      this[kWriteToOutput](this[kPrompt] + lines[0]);
+      for (let i = 1; i < lines.length; i++) this[kWriteToOutput](`\n${kMultilinePrompt.description}` + lines[i]);
+    } else {
+      this[kWriteToOutput](line);
+    }
+    /* the terminal makes a new line once something is on it */
+    if (lineCols === 0) this[kWriteToOutput](" ");
+    cursorTo(this.output, cursorPos.cols);
+    const diff = lineRows - cursorPos.rows;
+    if (diff > 0) moveCursor(this.output, 0, -diff);
+    this.prevRows = cursorPos.rows;
+  }
 
-export function createInterface(input, output, completer, terminal) {
-  return new Interface(input, output, completer, terminal);
-}
+  close() {
+    if (this.closed) return;
+    this.pause();
+    if (this.terminal) this[kSetRawMode](false);
+    this.closed = true;
+    this.emit("close");
+  }
 
-/* ---- the cursor: ANSI escapes ------------------------------------------------------------ */
+  pause() {
+    if (this.closed) throw useAfterClose();
+    if (this.paused) return;
+    this.input.pause();
+    this.paused = true;
+    this.emit("pause");
+    return this;
+  }
 
-const CSI = "\x1b[";
+  resume() {
+    if (this.closed) throw useAfterClose();
+    if (!this.paused) return;
+    this.input.resume();
+    this.paused = false;
+    this.emit("resume");
+    return this;
+  }
 
-/* a write, or with no stream the callback on a later tick */
-function writeTo(stream, data, callback) {
-  if (callback !== undefined) validateFunction(callback, "callback");
-  if (stream === null || stream === undefined || data === "") {
-    if (typeof callback === "function") process.nextTick(callback, null);
-    return true;
+  write(d, key) {
+    if (this.closed) throw useAfterClose();
+    if (this.paused) this.resume();
+    if (this.terminal) this[kTtyWrite](d, key);
+    else this[kNormalWrite](d);
   }
-  return stream.write(data, callback);
-}
 
-/** The escape that clears the line: to its start (dir < 0), its end (dir > 0) or all of it. */
-export function clearLineEscape(dir) {
-  return dir < 0 ? CSI + "1K" : dir > 0 ? CSI + "0K" : CSI + "2K";
-}
+  [kNormalWrite](b) {
+    if (b === undefined) return;
+    let string = this[kDecoder].write(b);
+    if (this[kSawReturnAt] && Date.now() - this[kSawReturnAt] <= this.crlfDelay) {
+      if (string.codePointAt() === 10) string = string.slice(1);
+      this[kSawReturnAt] = 0;
+    }
+    if (!string) return;
+    /* the new chunk split, not the whole buffer: a plain split when it has none of the rarer endings */
+    const lines = string.includes("\r") || string.includes("\u2028") || string.includes("\u2029") ? string.split(lineEnding) : string.split("\n");
+    const lastIndex = lines.length - 1;
+    if (lastIndex === 0) {
+      if (this[kLine_buffer]) this[kLine_buffer] += string;
+      else this[kLine_buffer] = string;
+      return;
+    }
+    this[kSawReturnAt] = string.endsWith("\r") ? Date.now() : 0;
+    let first = lines[0];
+    if (this[kLine_buffer]) first = this[kLine_buffer] + first;
+    /* '' or the next line's start */
+    this[kLine_buffer] = lines[lastIndex];
+    this[kOnLine](first);
+    for (let i = 1; i < lastIndex; i++) this[kOnLine](lines[i]);
+  }
 
-export function cursorToEscape(x, y) {
-  if (Number.isNaN(x)) throw codeError(TypeError, "ERR_INVALID_ARG_VALUE", "The argument 'x' is invalid. Received NaN");
-  if (Number.isNaN(y)) throw codeError(TypeError, "ERR_INVALID_ARG_VALUE", "The argument 'y' is invalid. Received NaN");
-  if (typeof x !== "number") throw codeError(TypeError, "ERR_INVALID_CURSOR_POS", "Cannot set cursor row without setting its column");
-  return typeof y !== "number" ? CSI + (x + 1) + "G" : CSI + (y + 1) + ";" + (x + 1) + "H";
-}
+  [kSavePreviousState]() {
+    this[kPreviousLine] = this.line;
+    this[kPreviousCursor] = this.cursor;
+    this[kPreviousPrevRows] = this.prevRows;
+  }
 
-export function moveCursorEscape(dx, dy) {
-  let data = "";
-  if (dx < 0) data += CSI + -dx + "D";
-  else if (dx > 0) data += CSI + dx + "C";
-  if (dy < 0) data += CSI + -dy + "A";
-  else if (dy > 0) data += CSI + dy + "B";
-  return data;
-}
+  [kRestorePreviousState]() {
+    this[kSetLine](this[kPreviousLine]);
+    this.cursor = this[kPreviousCursor];
+    this.prevRows = this[kPreviousPrevRows];
+  }
 
-export function clearLine(stream, dir, callback) {
-  return writeTo(stream, clearLineEscape(dir), callback);
-}
+  clearLine() {
+    this[kMoveCursor](+Infinity);
+    this[kWriteToOutput]("\r\n");
+    this[kSetLine]("");
+    this.cursor = 0;
+    this.prevRows = 0;
+  }
 
-export function clearScreenDown(stream, callback) {
-  return writeTo(stream, CSI + "0J", callback);
-}
+  [kPushToUndoStack](text, cursor) {
+    if (this[kUndoStack].push({ text, cursor }) > 2048) this[kUndoStack].shift();
+  }
 
-export function cursorTo(stream, x, y, callback) {
-  if (typeof y === "function") {
-    callback = y;
-    y = undefined;
+  /* where `str` ends on the screen: its rows and the column on the last */
+  [kGetDisplayPos](str) {
+    let offset = 0;
+    const col = this.columns;
+    let rows = 0;
+    str = stripVTControlCharacters(str);
+    for (const char of str) {
+      if (char === "\n") {
+        rows += Math.ceil(offset / col) || 1;
+        offset = this[kIsMultiline] ? kMultilinePrompt.description.length : 0;
+        continue;
+      }
+      if (char === "\t") {
+        offset += this.tabSize - (offset % this.tabSize);
+        continue;
+      }
+      const width = getStringWidth(char, false);
+      if (width === 0 || width === 1) {
+        offset += width;
+      } else {
+        /* a wide character doesn't fit in the last column: it starts the next row */
+        if ((offset + 1) % col === 0) offset++;
+        offset += 2;
+      }
+    }
+    const cols = offset % col;
+    rows += (offset - cols) / col;
+    return { cols, rows };
   }
-  if (stream === null || stream === undefined || (typeof x !== "number" && typeof y !== "number")) return writeTo(null, "", callback);
-  return writeTo(stream, cursorToEscape(x, y), callback);
-}
 
-export function moveCursor(stream, dx, dy, callback) {
-  return writeTo(stream, moveCursorEscape(dx, dy), callback);
-}
+  getCursorPos() {
+    const strBeforeCursor = this[kPrompt] + this.line.slice(0, this.cursor);
+    return this[kGetDisplayPos](strBeforeCursor);
+  }
+
+  [kMoveCursor](dx) {
+    if (dx === 0) return;
+    const oldPos = this.getCursorPos();
+    this.cursor += dx;
+    if (this.cursor < 0) this.cursor = 0;
+    else if (this.cursor > this.line.length) this.cursor = this.line.length;
+    const newPos = this.getCursorPos();
+    /* on the same row: moved; across rows: the line redrawn */
+    if (oldPos.rows === newPos.rows) moveCursor(this.output, newPos.cols - oldPos.cols, 0);
+    else this[kRefreshLine]();
+  }
 
-export function emitKeypressEvents() {
-  throw notSupported("readline.emitKeypressEvents");
+  /* events.on (internal/events_on.js, linked into readline programs that iterate) */
+  [Symbol.asyncIterator]() {
+    if (this[kLineObjectStream] === undefined) {
+      this[kLineObjectStream] = feature("on")(this, "line", { close: ["close"], highWaterMark: 1024, [kFirstEventParam]: true });
+    }
+    return this[kLineObjectStream];
+  }
 }
+
+Interface.prototype[Symbol.dispose] = function () {
+  this.close();
+};
+Object.defineProperty(Interface.prototype[Symbol.dispose], "name", { value: "[Symbol.dispose]" });