12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220
// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.// Copyright Joyent, Inc. and other Node contributors.//// Permission is hereby granted, free of charge, to any person obtaining a// copy of this software and associated documentation files (the// "Software"), to deal in the Software without restriction, including// without limitation the rights to use, copy, modify, merge, publish,// distribute, sublicense, and/or sell copies of the Software, and to permit// persons to whom the Software is furnished to do so, subject to the// following conditions://// The above copyright notice and this permission notice shall be included// in all copies or substantial portions of the Software.//// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE// USE OR OTHER DEALINGS IN THE SOFTWARE.
// deno-lint-ignore-file camelcase no-inner-declarations no-this-alias
import { ERR_INVALID_ARG_VALUE } from "../errors.ts";import {  validateAbortSignal,  validateArray,  validateString,  validateUint32,} from "../validators.mjs";import {  //   inspect,  getStringWidth,  stripVTControlCharacters,} from "../util/inspect.mjs";import EventEmitter from "../../events.ts";import { emitKeypressEvents } from "./emitKeypressEvents.mjs";import {  charLengthAt,  charLengthLeft,  commonPrefix,  kSubstringSearch,} from "./utils.mjs";import { clearScreenDown, cursorTo, moveCursor } from "./callbacks.mjs";import { Readable } from "../../_stream.mjs";
import { StringDecoder } from "../../string_decoder.ts";import {  kAddHistory,  kDecoder,  kDeleteLeft,  kDeleteLineLeft,  kDeleteLineRight,  kDeleteRight,  kDeleteWordLeft,  kDeleteWordRight,  kGetDisplayPos,  kHistoryNext,  kHistoryPrev,  kInsertString,  kLine,  kLine_buffer,  kMoveCursor,  kNormalWrite,  kOldPrompt,  kOnLine,  kPreviousKey,  kPrompt,  kQuestionCallback,  kRefreshLine,  kSawKeyPress,  kSawReturnAt,  kSetRawMode,  kTabComplete,  kTabCompleter,  kTtyWrite,  kWordLeft,  kWordRight,  kWriteToOutput,} from "./symbols.mjs";
const kHistorySize = 30;const kMincrlfDelay = 100;// \r\n, \n, or \r followed by something other than \nconst lineEnding = /\r?\n|\r(?!\n)/;
const kLineObjectStream = Symbol("line object stream");export const kQuestionCancel = Symbol("kQuestionCancel");
// GNU readline library - keyseq-timeout is 500ms (default)const ESCAPE_CODE_TIMEOUT = 500;
export {  kAddHistory,  kDecoder,  kDeleteLeft,  kDeleteLineLeft,  kDeleteLineRight,  kDeleteRight,  kDeleteWordLeft,  kDeleteWordRight,  kGetDisplayPos,  kHistoryNext,  kHistoryPrev,  kInsertString,  kLine,  kLine_buffer,  kMoveCursor,  kNormalWrite,  kOldPrompt,  kOnLine,  kPreviousKey,  kPrompt,  kQuestionCallback,  kRefreshLine,  kSawKeyPress,  kSawReturnAt,  kSetRawMode,  kTabComplete,  kTabCompleter,  kTtyWrite,  kWordLeft,  kWordRight,  kWriteToOutput,};
export function InterfaceConstructor(input, output, completer, terminal) {  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;  Function.prototype.call(EventEmitter, this);
  let history;  let historySize;  let removeHistoryDuplicates = false;  let crlfDelay;  let prompt = "> ";  let signal;
  if (input?.input) {    // An options object was given    output = input.output;    completer = input.completer;    terminal = input.terminal;    history = input.history;    historySize = input.historySize;    signal = input.signal;    if (input.tabSize !== undefined) {      validateUint32(input.tabSize, "tabSize", true);      this.tabSize = input.tabSize;    }    removeHistoryDuplicates = input.removeHistoryDuplicates;    if (input.prompt !== undefined) {      prompt = input.prompt;    }    if (input.escapeCodeTimeout !== undefined) {      if (Number.isFinite(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;  }
  if (completer !== undefined && typeof completer !== "function") {    throw new ERR_INVALID_ARG_VALUE("completer", completer);  }
  if (history === undefined) {    history = [];  } else {    validateArray(history, "history");  }
  if (historySize === undefined) {    historySize = kHistorySize;  }
  if (    typeof historySize !== "number" ||    Number.isNaN(historySize) ||    historySize < 0  ) {    throw new ERR_INVALID_ARG_VALUE.RangeError("historySize", historySize);  }
  // 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[kSubstringSearch] = null;  this.output = output;  this.input = input;  this.history = history;  this.historySize = historySize;  this.removeHistoryDuplicates = !!removeHistoryDuplicates;  this.crlfDelay = crlfDelay    ? Math.max(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 && 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 = key.sequence.codePointAt(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(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;
    this.historyIndex = -1;
    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 {      signal.addEventListener("abort", onAborted, { once: true });      self.once("close", () => signal.removeEventListener("abort", onAborted));    }  }
  // Current line  this.line = "";
  input.resume();}
Object.setPrototypeOf(InterfaceConstructor.prototype, EventEmitter.prototype);Object.setPrototypeOf(InterfaceConstructor, EventEmitter);
export class Interface extends InterfaceConstructor {  // eslint-disable-next-line no-useless-constructor  constructor(input, output, completer, terminal) {    super(input, output, completer, terminal);  }  get columns() {    if (this.output && this.output.columns) return this.output.columns;    return Infinity;  }
  /**   * Sets the prompt written to the output.   * @param {string} prompt   * @returns {void}   */  setPrompt(prompt) {    this[kPrompt] = prompt;  }
  /**   * Returns the current prompt used by `rl.prompt()`.   * @returns {string}   */  getPrompt() {    return this[kPrompt];  }
  [kSetRawMode](mode) {    const wasInRawMode = this.input.isRaw;
    if (typeof this.input.setRawMode === "function") {      this.input.setRawMode(mode);    }
    return wasInRawMode;  }
  /**   * Writes the configured `prompt` to a new line in `output`.   * @param {boolean} [preserveCursor]   * @returns {void}   */  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]);    }  }
  question(query, cb) {    if (this[kQuestionCallback]) {      this.prompt();    } else {      this[kOldPrompt] = this[kPrompt];      this.setPrompt(query);      this[kQuestionCallback] = cb;      this.prompt();    }  }
  [kOnLine](line) {    if (this[kQuestionCallback]) {      const cb = this[kQuestionCallback];      this[kQuestionCallback] = null;      this.setPrompt(this[kOldPrompt]);      cb(line);    } else {      this.emit("line", line);    }  }
  [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]() {    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 (this.line.trim().length === 0) return this.line;
    if (this.history.length === 0 || this.history[0] !== this.line) {      if (this.removeHistoryDuplicates) {        // Remove older history line if identical to new one        const dupIndex = this.history.indexOf(this.line);        if (dupIndex !== -1) this.history.splice(dupIndex, 1);      }
      this.history.unshift(this.line);
      // Only store so many      if (this.history.length > this.historySize) {        this.history.pop();      }    }
    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.history[0];
    // Emit history event to notify listeners of update    this.emit("history", this.history);
    return line;  }
  [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);
    // 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;  }
  /**   * Closes the `readline.Interface` instance.   * @returns {void}   */  close() {    if (this.closed) return;    this.pause();    if (this.terminal) {      this[kSetRawMode](false);    }    this.closed = true;    this.emit("close");  }
  /**   * Pauses the `input` stream.   * @returns {void | Interface}   */  pause() {    if (this.paused) return;    this.input.pause();    this.paused = true;    this.emit("pause");    return this;  }
  /**   * Resumes the `input` stream if paused.   * @returns {void | Interface}   */  resume() {    if (!this.paused) return;    this.input.resume();    this.paused = false;    this.emit("resume");    return this;  }
  /**   * Writes either `data` or a `key` sequence identified by   * `key` to the `output`.   * @param {string} d   * @param {{   *   ctrl?: boolean;   *   meta?: boolean;   *   shift?: boolean;   *   name?: string;   *   }} [key]   * @returns {void}   */  write(d, key) {    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] &&      Date.now() - this[kSawReturnAt] <= this.crlfDelay    ) {      string = string.replace(/^\n/, "");      this[kSawReturnAt] = 0;    }
    // Run test() on the new string chunk, not on the entire line buffer.    const newPartContainsEnding = lineEnding.test(string);
    if (this[kLine_buffer]) {      string = this[kLine_buffer] + string;      this[kLine_buffer] = null;    }    if (newPartContainsEnding) {      this[kSawReturnAt] = string.endsWith("\r") ? Date.now() : 0;
      // Got one or more newlines; process into "line" events      const lines = string.split(lineEnding);      // Either '' or (conceivably) the unfinished portion of the next line      string = lines.pop();      this[kLine_buffer] = string;      for (let n = 0; n < lines.length; n++) this[kOnLine](lines[n]);    } else if (string) {      // No newlines this time, save what we have for next time      this[kLine_buffer] = string;    }  }
  [kInsertString](c) {    if (this.cursor < this.line.length) {      const beg = this.line.slice(0, this.cursor);      const end = this.line.slice(        this.cursor,        this.line.length,      );      this.line = beg + c + end;      this.cursor += c.length;      this[kRefreshLine]();    } else {      this.line += c;      this.cursor += c.length;
      if (this.getCursorPos().cols === 0) {        this[kRefreshLine]();      } else {        this[kWriteToOutput](c);      }    }  }
  async [kTabComplete](lastKeypressWasTab) {    this.pause();    const string = this.line.slice(0, this.cursor);    let value;    try {      value = await this.completer(string);    } catch (err) {      // TODO(bartlomieju): inspect is not ported yet      // this[kWriteToOutput](`Tab completion error: ${inspect(err)}`);      this[kWriteToOutput](`Tab completion error: ${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(      completions.filter((e) => e !== ""),    );    if (      prefix.startsWith(completeOn) &&      prefix.length > completeOn.length    ) {      this[kInsertString](prefix.slice(completeOn.length));      return;    } else if (!completeOn.startsWith(prefix)) {      this.line = this.line.slice(0, this.cursor - completeOn.length) +        prefix +        this.line.slice(this.cursor, this.line.length);      this.cursor = this.cursor - completeOn.length + prefix.length;      this._refreshLine();      return;    }
    if (!lastKeypressWasTab) {      return;    }
    // Apply/show completions.    const completionsWidth = completions.map(      (e) => getStringWidth(e),    );    const width = Math.max.apply(completionsWidth) + 2; // 2 space padding    let maxColumns = Math.floor(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 += " ".repeat(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 = this.line.slice(0, this.cursor);      const reversed = Array.from(leading).reverse().join("");      const match = reversed.match(/^\s*(?:[^\w\s]+|\w+)?/);      this[kMoveCursor](-match[0].length);    }  }
  [kWordRight]() {    if (this.cursor < this.line.length) {      const trailing = this.line.slice(this.cursor);      const match = trailing.match(/^(?:\s+|[^\w\s]+|\w+)\s*/);      this[kMoveCursor](match[0].length);    }  }
  [kDeleteLeft]() {    if (this.cursor > 0 && this.line.length > 0) {      // The number of UTF-16 units comprising the character to the left      const charSize = charLengthLeft(this.line, this.cursor);      this.line = this.line.slice(0, this.cursor - charSize) +        this.line.slice(this.cursor, this.line.length);
      this.cursor -= charSize;      this[kRefreshLine]();    }  }
  [kDeleteRight]() {    if (this.cursor < this.line.length) {      // The number of UTF-16 units comprising the character to the left      const charSize = charLengthAt(this.line, this.cursor);      this.line = this.line.slice(0, this.cursor) +        this.line.slice(          this.cursor + charSize,          this.line.length,        );      this[kRefreshLine]();    }  }
  [kDeleteWordLeft]() {    if (this.cursor > 0) {      // Reverse the string and match a word near beginning      // to avoid quadratic time complexity      let leading = this.line.slice(0, this.cursor);      const reversed = Array.from(leading).reverse().join("");      const match = reversed.match(/^\s*(?:[^\w\s]+|\w+)?/);      leading = leading.slice(        0,        leading.length - match[0].length,      );      this.line = leading +        this.line.slice(this.cursor, this.line.length);      this.cursor = leading.length;      this[kRefreshLine]();    }  }
  [kDeleteWordRight]() {    if (this.cursor < this.line.length) {      const trailing = this.line.slice(this.cursor);      const match = trailing.match(/^(?:\s+|\W+|\w+)\s*/);      this.line = this.line.slice(0, this.cursor) +        trailing.slice(match[0].length);      this[kRefreshLine]();    }  }
  [kDeleteLineLeft]() {    this.line = this.line.slice(this.cursor);    this.cursor = 0;    this[kRefreshLine]();  }
  [kDeleteLineRight]() {    this.line = this.line.slice(0, this.cursor);    this[kRefreshLine]();  }
  clearLine() {    this[kMoveCursor](+Infinity);    this[kWriteToOutput]("\r\n");    this.line = "";    this.cursor = 0;    this.prevRows = 0;  }
  [kLine]() {    const line = this[kAddHistory]();    this.clearLine();    this[kOnLine](line);  }
  // TODO(BridgeAR): Add underscores to the search part and a red background in  // case no match is found. This should only be the visual part and not the  // actual line content!  // TODO(BridgeAR): In case the substring based search is active and the end is  // reached, show a comment how to search the history as before. E.g., using  // <ctrl> + N. Only show this after two/three UPs or DOWNs, not on the first  // one.  [kHistoryNext]() {    if (this.historyIndex >= 0) {      const search = this[kSubstringSearch] || "";      let index = this.historyIndex - 1;      while (        index >= 0 &&        (!this.history[index].startsWith(search) ||          this.line === this.history[index])      ) {        index--;      }      if (index === -1) {        this.line = search;      } else {        this.line = this.history[index];      }      this.historyIndex = index;      this.cursor = this.line.length; // Set cursor to end of line.      this[kRefreshLine]();    }  }
  [kHistoryPrev]() {    if (this.historyIndex < this.history.length && this.history.length) {      const search = this[kSubstringSearch] || "";      let index = this.historyIndex + 1;      while (        index < this.history.length &&        (!this.history[index].startsWith(search) ||          this.line === this.history[index])      ) {        index++;      }      if (index === this.history.length) {        this.line = search;      } else {        this.line = this.history[index];      }      this.historyIndex = index;      this.cursor = this.line.length; // Set cursor to end of line.      this[kRefreshLine]();    }  }
  // Returns the last character's display position of the given string  [kGetDisplayPos](str) {    let offset = 0;    const col = this.columns;    let rows = 0;    str = stripVTControlCharacters(str);    for (const char of str[Symbol.iterator]()) {      if (char === "\n") {        // Rows must be incremented by 1 even if offset = 0 or col = +Infinity.        rows += Math.ceil(offset / col) || 1;        offset = 0;        continue;      }      // Tabs must be aligned by an offset of the tab size.      if (char === "\t") {        offset += this.tabSize - (offset % this.tabSize);        continue;      }      const width = getStringWidth(char);      if (width === 0 || width === 1) {        offset += width;      } else {        // width === 2        if ((offset + 1) % col === 0) {          offset++;        }        offset += 2;      }    }    const cols = offset % col;    rows += (offset - cols) / col;    return { cols, rows };  }
  /**   * Returns the real position of the cursor in relation   * to the input prompt + string.   * @returns {{   *   rows: number;   *   cols: number;   *   }}   */  getCursorPos() {    const strBeforeCursor = this[kPrompt] +      this.line.slice(0, this.cursor);    return this[kGetDisplayPos](strBeforeCursor);  }
  // This function moves cursor dx places to the right  // (-dx for left) and refreshes the line if it is needed.  [kMoveCursor](dx) {    if (dx === 0) {      return;    }    const oldPos = this.getCursorPos();    this.cursor += dx;
    // Bounds check    if (this.cursor < 0) {      this.cursor = 0;    } else if (this.cursor > this.line.length) {      this.cursor = this.line.length;    }
    const newPos = this.getCursorPos();
    // Check if cursor stayed on the line.    if (oldPos.rows === newPos.rows) {      const diffWidth = newPos.cols - oldPos.cols;      moveCursor(this.output, diffWidth, 0);    } else {      this[kRefreshLine]();    }  }
  // Handle a write from the tty  [kTtyWrite](s, key) {    const previousKey = this[kPreviousKey];    key = key || {};    this[kPreviousKey] = key;
    // Activate or deactivate substring search.    if (      (key.name === "up" || key.name === "down") &&      !key.ctrl &&      !key.meta &&      !key.shift    ) {      if (this[kSubstringSearch] === null) {        this[kSubstringSearch] = this.line.slice(          0,          this.cursor,        );      }    } else if (this[kSubstringSearch] !== null) {      this[kSubstringSearch] = null;      // Reset the index in case there's no match.      if (this.history.length === this.historyIndex) {        this.historyIndex = -1;      }    }
    // Ignore escape key, fixes    // https://github.com/nodejs/node-v0.x-archive/issues/2876.    if (key.name === "escape") return;
    if (key.ctrl && key.shift) {      /* Control and shift pressed */      switch (key.name) {        // TODO(BridgeAR): The transmitted escape sequence is `\b` and that is        // identical to <ctrl>-h. It should have a unique escape sequence.        case "backspace":          this[kDeleteLineLeft]();          break;
        case "delete":          this[kDeleteLineRight]();          break;      }    } else if (key.ctrl) {      /* Control key pressed */
      switch (key.name) {        case "c":          if (this.listenerCount("SIGINT") > 0) {            this.emit("SIGINT");          } else {            // This readline instance is finished            this.close();          }          break;
        case "h": // delete left          this[kDeleteLeft]();          break;
        case "d": // delete right or EOF          if (this.cursor === 0 && this.line.length === 0) {            // This readline instance is finished            this.close();          } else if (this.cursor < this.line.length) {            this[kDeleteRight]();          }          break;
        case "u": // Delete from current to start of line          this[kDeleteLineLeft]();          break;
        case "k": // Delete from current to end of line          this[kDeleteLineRight]();          break;
        case "a": // Go to the start of the line          this[kMoveCursor](-Infinity);          break;
        case "e": // Go to the end of the line          this[kMoveCursor](+Infinity);          break;
        case "b": // back one character          this[kMoveCursor](-charLengthLeft(this.line, this.cursor));          break;
        case "f": // Forward one character          this[kMoveCursor](+charLengthAt(this.line, this.cursor));          break;
        case "l": // Clear the whole screen          cursorTo(this.output, 0, 0);          clearScreenDown(this.output);          this[kRefreshLine]();          break;
        case "n": // next history item          this[kHistoryNext]();          break;
        case "p": // Previous history item          this[kHistoryPrev]();          break;
        case "z":          if (process.platform === "win32") break;          if (this.listenerCount("SIGTSTP") > 0) {            this.emit("SIGTSTP");          } else {            process.once("SIGCONT", () => {              // Don't raise events if stream has already been abandoned.              if (!this.paused) {                // Stream must be paused and resumed after SIGCONT to catch                // SIGINT, SIGTSTP, and EOF.                this.pause();                this.emit("SIGCONT");              }              // Explicitly re-enable "raw mode" and move the cursor to              // the correct position.              // See https://github.com/joyent/node/issues/3295.              this[kSetRawMode](true);              this[kRefreshLine]();            });            this[kSetRawMode](false);            process.kill(process.pid, "SIGTSTP");          }          break;
        case "w": // Delete backwards to a word boundary        // TODO(BridgeAR): The transmitted escape sequence is `\b` and that is        // identical to <ctrl>-h. It should have a unique escape sequence.        // Falls through        case "backspace":          this[kDeleteWordLeft]();          break;
        case "delete": // Delete forward to a word boundary          this[kDeleteWordRight]();          break;
        case "left":          this[kWordLeft]();          break;
        case "right":          this[kWordRight]();          break;      }    } else if (key.meta) {      /* Meta key pressed */
      switch (key.name) {        case "b": // backward word          this[kWordLeft]();          break;
        case "f": // forward word          this[kWordRight]();          break;
        case "d": // delete forward word        case "delete":          this[kDeleteWordRight]();          break;
        case "backspace": // Delete backwards to a word boundary          this[kDeleteWordLeft]();          break;      }    } else {      /* No modifier keys used */
      // \r bookkeeping is only relevant if a \n comes right after.      if (this[kSawReturnAt] && key.name !== "enter") this[kSawReturnAt] = 0;
      switch (key.name) {        case "return": // Carriage return, i.e. \r          this[kSawReturnAt] = Date.now();          this[kLine]();          break;
        case "enter":          // When key interval > crlfDelay          if (            this[kSawReturnAt] === 0 ||            Date.now() - this[kSawReturnAt] > this.crlfDelay          ) {            this[kLine]();          }          this[kSawReturnAt] = 0;          break;
        case "backspace":          this[kDeleteLeft]();          break;
        case "delete":          this[kDeleteRight]();          break;
        case "left":          // Obtain the code point to the left          this[kMoveCursor](-charLengthLeft(this.line, this.cursor));          break;
        case "right":          this[kMoveCursor](+charLengthAt(this.line, this.cursor));          break;
        case "home":          this[kMoveCursor](-Infinity);          break;
        case "end":          this[kMoveCursor](+Infinity);          break;
        case "up":          this[kHistoryPrev]();          break;
        case "down":          this[kHistoryNext]();          break;
        case "tab":          // If tab completion enabled, do that...          if (            typeof this.completer === "function" &&            this.isCompletionEnabled          ) {            const lastKeypressWasTab = previousKey &&              previousKey.name === "tab";            this[kTabComplete](lastKeypressWasTab);            break;          }        // falls through        default:          if (typeof s === "string" && s) {            const lines = s.split(/\r\n|\n|\r/);            for (let i = 0, len = lines.length; i < len; i++) {              if (i > 0) {                this[kLine]();              }              this[kInsertString](lines[i]);            }          }      }    }  }
  /**   * Creates an `AsyncIterator` object that iterates through   * each line in the input stream as a string.   * @typedef {{   *   [Symbol.asyncIterator]: () => InterfaceAsyncIterator,   *   next: () => Promise<string>   * }} InterfaceAsyncIterator   * @returns {InterfaceAsyncIterator}   */  [Symbol.asyncIterator]() {    if (this[kLineObjectStream] === undefined) {      const readable = new Readable({        objectMode: true,        read: () => {          this.resume();        },        destroy: (err, cb) => {          this.off("line", lineListener);          this.off("close", closeListener);          this.close();          cb(err);        },      });      const lineListener = (input) => {        if (!readable.push(input)) {          // TODO(rexagod): drain to resume flow          this.pause();        }      };      const closeListener = () => {        readable.push(null);      };      const errorListener = (err) => {        readable.destroy(err);      };      this.on("error", errorListener);      this.on("line", lineListener);      this.on("close", closeListener);      this[kLineObjectStream] = readable;    }
    return this[kLineObjectStream][Symbol.asyncIterator]();  }}