visaljs 0.0.9 → 0.0.11

package/node/prelude/readline.js

@@ -1,8 +1,117 @@
-// node:readline (internal/readline.js): Interface, createInterface, the cursor's escapes, and
-// node:readline/promises as promises.
+// node:readline (Node's lib/readline.js): Interface, with the callback question() and the old
+// underscored names of its methods, createInterface, the cursor functions, emitKeypressEvents
+// (with the terminal editor, internal/readline_editor.js), and readline/promises as promises.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
+import { features, lazyFunction } from "./internal/features.js";
+import {
+  abortError, addAbortListener, clearLine, clearScreenDown, cursorTo, Interface as BaseInterface, InterfaceConstructor, kAddHistory,
+  kDecoder, kDeleteLeft, kDeleteLineLeft, kDeleteLineRight, kDeleteRight, kDeleteWordLeft, kDeleteWordRight, kGetDisplayPos, kHistoryNext,
+  kHistoryPrev, kInsertString, kLine, kLine_buffer, kMoveCursor, kNormalWrite, kOldPrompt, kOnLine, kPreviousKey, kPrompt, kQuestion,
+  kQuestionCallback, kQuestionCancel, kRefreshLine, kSawKeyPress, kSawReturnAt, kSetRawMode, kTabComplete, kTtyWrite, kWordLeft,
+  kWordRight, kWriteToOutput, moveCursor, validateAbortSignal,
+} from "./internal/readline.js";
 import promises from "./readline_promises.js";
-import { Interface, clearLine, clearScreenDown, createInterface, cursorTo, emitKeypressEvents, moveCursor } from "./internal/readline.js";
 
-export { Interface, clearLine, clearScreenDown, createInterface, cursorTo, emitKeypressEvents, moveCursor, promises };
+const kEmptyObject = Object.freeze({ __proto__: null });
+const kPromisifyCustom = Symbol.for("nodejs.util.promisify.custom");
+
+export const emitKeypressEvents = lazyFunction("emitKeypressEvents", 2);
+
+/** Interface(input, output, completer, terminal), or with an options object; callable without new */
+export function Interface(input, output, completer, terminal) {
+  if (!(this instanceof Interface)) return new Interface(input, output, completer, terminal);
+  /* a completer of one argument: its result, given to the callback */
+  if (input?.input && typeof input.completer === "function" && input.completer.length !== 2) {
+    const { completer } = input;
+    input.completer = (v, cb) => cb(null, completer(v));
+  } else if (typeof completer === "function" && completer.length !== 2) {
+    const realCompleter = completer;
+    completer = (v, cb) => cb(null, realCompleter(v));
+  }
+  InterfaceConstructor.call(this, input, output, completer, terminal);
+  /* a terminal is the editor's (internal/readline_editor.js): a dumb one gets its plain writer */
+  if (this.terminal && process.env.TERM === "dumb") this._ttyWrite = features.ttyWriteDumb.bind(this);
+}
+
+Object.setPrototypeOf(Interface.prototype, BaseInterface.prototype);
+Object.setPrototypeOf(Interface, BaseInterface);
+
+Interface.prototype.question = function question(query, options, cb) {
+  cb = typeof options === "function" ? options : cb;
+  if (options === null || typeof options !== "object") options = kEmptyObject;
+  if (options.signal) {
+    validateAbortSignal(options.signal, "options.signal");
+    if (options.signal.aborted) return;
+    const onAbort = () => {
+      this[kQuestionCancel]();
+    };
+    const disposable = addAbortListener(options.signal, onAbort);
+    const originalCb = cb;
+    cb = typeof cb === "function" ? (answer) => {
+      disposable[Symbol.dispose]();
+      return originalCb(answer);
+    } : disposable[Symbol.dispose];
+  }
+  if (typeof cb === "function") this[kQuestion](query, cb);
+};
+
+Interface.prototype.question[kPromisifyCustom] = function question(query, options) {
+  if (options === null || typeof options !== "object") options = kEmptyObject;
+  if (options.signal?.aborted) return Promise.reject(abortError(undefined, { cause: options.signal.reason }));
+  return new Promise((resolve, reject) => {
+    let cb = resolve;
+    if (options.signal) {
+      const onAbort = () => {
+        reject(abortError(undefined, { cause: options.signal.reason }));
+      };
+      const disposable = addAbortListener(options.signal, onAbort);
+      cb = (answer) => {
+        disposable[Symbol.dispose]();
+        resolve(answer);
+      };
+    }
+    this.question(query, options, cb);
+  });
+};
+
+export function createInterface(input, output, completer, terminal) {
+  return new Interface(input, output, completer, terminal);
+}
+
+/* the methods' old names: each symbol reads the underscored method, which a program may replace */
+const underscored = [
+  [kSetRawMode, "_setRawMode"], [kOnLine, "_onLine"], [kWriteToOutput, "_writeToOutput"], [kAddHistory, "_addHistory"],
+  [kRefreshLine, "_refreshLine"], [kNormalWrite, "_normalWrite"], [kInsertString, "_insertString"], [kTabComplete, "_tabComplete"],
+  [kWordLeft, "_wordLeft"], [kWordRight, "_wordRight"], [kDeleteLeft, "_deleteLeft"], [kDeleteRight, "_deleteRight"],
+  [kDeleteWordLeft, "_deleteWordLeft"], [kDeleteWordRight, "_deleteWordRight"], [kDeleteLineLeft, "_deleteLineLeft"],
+  [kDeleteLineRight, "_deleteLineRight"], [kLine, "_line"], [kHistoryNext, "_historyNext"], [kHistoryPrev, "_historyPrev"],
+  [kGetDisplayPos, "_getDisplayPos"], [kMoveCursor, "_moveCursor"], [kTtyWrite, "_ttyWrite"],
+];
+for (const [symbol, name] of underscored) {
+  Object.defineProperty(Interface.prototype, symbol, { get() { return this[name]; }, configurable: true });
+}
+/* and the state's */
+const state = [[kDecoder, "_decoder"], [kLine_buffer, "_line_buffer"], [kOldPrompt, "_oldPrompt"], [kPreviousKey, "_previousKey"],
+  [kPrompt, "_prompt"], [kQuestionCallback, "_questionCallback"], [kSawKeyPress, "_sawKeyPress"], [kSawReturnAt, "_sawReturnAt"]];
+for (const [symbol, name] of state) {
+  Object.defineProperty(Interface.prototype, name, {
+    get() { return this[symbol]; },
+    set(value) { this[symbol] = value; },
+    configurable: true,
+  });
+}
+
+/* the editor's methods (the editor module gives the rest of the underscored names) */
+Interface.prototype._setRawMode = BaseInterface.prototype[kSetRawMode];
+Interface.prototype._onLine = BaseInterface.prototype[kOnLine];
+Interface.prototype._writeToOutput = BaseInterface.prototype[kWriteToOutput];
+Interface.prototype._addHistory = BaseInterface.prototype[kAddHistory];
+Interface.prototype._refreshLine = BaseInterface.prototype[kRefreshLine];
+Interface.prototype._normalWrite = BaseInterface.prototype[kNormalWrite];
+Interface.prototype._getDisplayPos = BaseInterface.prototype[kGetDisplayPos];
+Interface.prototype._getCursorPos = BaseInterface.prototype.getCursorPos;
+Interface.prototype._moveCursor = BaseInterface.prototype[kMoveCursor];
+
+export { clearLine, clearScreenDown, cursorTo, moveCursor, promises };
 
 export default { Interface, clearLine, clearScreenDown, createInterface, cursorTo, emitKeypressEvents, moveCursor, promises };

package/node/prelude/readline_promises.js

@@ -1,31 +1,31 @@
-// node:readline/promises: node:readline's Interface with question() as a promise, and Readline,
-// cursor moves queued and written by commit().
-import { codeError } from "./internal/errors.js";
+// node:readline/promises (Node's lib/readline/promises.js and internal/readline/promises.js):
+// Interface with question() as a promise, and Readline, cursor moves queued and written by commit().
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
+import { invalidArgType, outOfRange } from "./internal/errors.js";
 import {
-  Interface as BaseInterface, abortError, clearLineEscape, cursorToEscape, kQuestion, kQuestionCancel, moveCursorEscape,
+  abortError, addAbortListener, CSI, Interface as BaseInterface, kQuestion, kQuestionCancel, kQuestionReject, validateAbortSignal,
 } from "./internal/readline.js";
 
+const kEmptyObject = Object.freeze({ __proto__: null });
+
 export class Interface extends BaseInterface {
-  /** The next line, or an AbortError when the signal aborts first. */
-  question(query, options = {}) {
+  question(query, options = kEmptyObject) {
     return new Promise((resolve, reject) => {
       let cb = resolve;
-      const signal = options?.signal;
-      if (signal) {
-        if (signal === null || typeof signal !== "object" || !("aborted" in signal)) {
-          throw codeError(TypeError, "ERR_INVALID_ARG_TYPE", 'The "options.signal" property must be an instance of AbortSignal.');
-        }
-        if (signal.aborted) return reject(abortError(signal));
+      if (options?.signal) {
+        validateAbortSignal(options.signal, "options.signal");
+        if (options.signal.aborted) return reject(abortError(undefined, { cause: options.signal.reason }));
         const onAbort = () => {
           this[kQuestionCancel]();
-          reject(abortError(signal));
+          reject(abortError(undefined, { cause: options.signal.reason }));
         };
-        signal.addEventListener("abort", onAbort, { once: true });
+        const disposable = addAbortListener(options.signal, onAbort);
         cb = (answer) => {
-          signal.removeEventListener("abort", onAbort);
+          disposable[Symbol.dispose]();
           resolve(answer);
         };
       }
+      this[kQuestionReject] = reject;
       this[kQuestion](query, cb);
     });
   }
@@ -35,48 +35,72 @@ export function createInterface(input, output, completer, terminal) {
   return new Interface(input, output, completer, terminal);
 }
 
-/** Cursor moves on a stream, queued until commit() (or written at once with autoCommit). */
+function validateInteger(value, name, min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) {
+  if (typeof value !== "number") throw invalidArgType(name, "of type number", value);
+  if (!Number.isInteger(value)) throw outOfRange(name, "an integer", value);
+  if (value < min || value > max) throw outOfRange(name, `>= ${min} && <= ${max}`, value);
+}
+
+/* Node's isWritable: a stream that can still be written */
+const isWritable = (stream) => stream !== null && typeof stream === "object" && typeof stream.write === "function" &&
+  stream.writable !== false && !stream.writableEnded && !stream.destroyed;
+
 export class Readline {
+  #autoCommit = false;
   #stream;
   #todo = [];
-  #autoCommit;
 
   constructor(stream, options = undefined) {
-    if (stream === null || typeof stream !== "object" || typeof stream.write !== "function") {
-      throw codeError(TypeError, "ERR_INVALID_ARG_TYPE", 'The "stream" argument must be an instance of Writable.');
-    }
+    if (!isWritable(stream)) throw invalidArgType("stream", "an instance of Writable", stream);
     this.#stream = stream;
-    this.#autoCommit = Boolean(options?.autoCommit);
+    if (options?.autoCommit != null) {
+      if (typeof options.autoCommit !== "boolean") throw invalidArgType("options.autoCommit", "of type boolean", options.autoCommit);
+      this.#autoCommit = options.autoCommit;
+    }
   }
 
-  #add(data) {
+  #queue(data) {
     if (this.#autoCommit) process.nextTick(() => this.#stream.write(data));
     else this.#todo.push(data);
-    return this;
   }
 
   cursorTo(x, y = undefined) {
-    return this.#add(cursorToEscape(x, y));
+    validateInteger(x, "x");
+    if (y != null) validateInteger(y, "y");
+    this.#queue(y == null ? CSI`${x + 1}G` : CSI`${y + 1};${x + 1}H`);
+    return this;
   }
 
   moveCursor(dx, dy) {
-    if (!dx && !dy) return this;
-    return this.#add(moveCursorEscape(dx, dy));
+    if (dx || dy) {
+      validateInteger(dx, "dx");
+      validateInteger(dy, "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`;
+      this.#queue(data);
+    }
+    return this;
   }
 
   clearLine(dir) {
-    return this.#add(clearLineEscape(dir));
+    validateInteger(dir, "dir", -1, 1);
+    this.#queue(dir < 0 ? CSI.kClearToLineBeginning : dir > 0 ? CSI.kClearToLineEnd : CSI.kClearLine);
+    return this;
   }
 
   clearScreenDown() {
-    return this.#add("\x1b[0J");
+    this.#queue(CSI.kClearScreenDown);
+    return this;
   }
 
-  /** Writes what's queued: resolved once written. */
   commit() {
-    const data = this.#todo.join("");
-    this.#todo = [];
-    return new Promise((resolve) => this.#stream.write(data, resolve));
+    return new Promise((resolve) => {
+      this.#stream.write(this.#todo.join(""), resolve);
+      this.#todo = [];
+    });
   }
 
   rollback() {

package/node/prelude/tls.js

@@ -5,10 +5,10 @@
 // Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import { fsReadFile, tlsRootCertificates } from "visaljs:host";
 import { EventEmitter } from "./events.js";
-import { invalidArgType, invalidArgValue, validateString } from "./internal/errors.js";
+import { codeError, invalidArgType, invalidArgValue, validateString } from "./internal/errors.js";
 import { cipherNames, createSecureContext, defaults, extraCAs, SecureContext } from "./internal/tls/common.js";
 import { checkServerIdentity, connect, convertALPNProtocols, createServer, Server, TLSSocket } from "./internal/tls/wrap.js";
-import { toPem } from "./internal/tls/x509.js";
+import { certificatesOf, parseCertificate, toPem } from "./internal/tls/x509.js";
 import { Duplex } from "./stream.js";
 
 export { checkServerIdentity, connect, convertALPNProtocols, createSecureContext, createServer, SecureContext, Server, TLSSocket };
@@ -18,6 +18,10 @@ export const CLIENT_RENEG_WINDOW = 600;
 
 export const getCiphers = () => cipherNames();
 
+/* RFC 8879's: none (BoringSSL takes the algorithms from its user, and visaljs gives it none) */
+const compressionAlgorithms = [];
+export const getCertificateCompressionAlgorithms = () => compressionAlgorithms;
+
 let bundled;
 const bundledRoots = () => (bundled ??= Object.freeze(tlsRootCertificates()));
 
@@ -66,7 +70,20 @@ export function setDefaultCACertificates(certs) {
       throw invalidArgType(`certs[${i}]`, "of type string or an instance of ArrayBufferView", certs[i]);
     }
   }
-  defaults.defaultCA = certs.map((c) => (typeof c === "string" ? c : Buffer.from(c.buffer, c.byteOffset, c.byteLength).toString("latin1")));
+  /* as Node's store: each certificate once, re-encoded; one OpenSSL can't read, or none of those given, changes nothing */
+  const ders = new Map();
+  for (const cert of certs) {
+    for (const der of certificatesOf(cert)) {
+      try {
+        parseCertificate(der);
+      } catch {
+        throw codeError(Error, "ERR_OSSL_PEM_ASN1_LIB", "error:0480000D:PEM routines::ASN1 lib");
+      }
+      ders.set(der.toString("latin1"), der);
+    }
+  }
+  if (certs.length > 0 && ders.size === 0) throw codeError(Error, "ERR_CRYPTO_OPERATION_FAILED", "No valid certificates found in the provided array");
+  defaults.defaultCA = [...ders.values()].map((der) => toPem(der));
   defaultPems = undefined;
 }
 
@@ -127,7 +144,7 @@ const tls = {
   set DEFAULT_MIN_VERSION(v) { defaults.DEFAULT_MIN_VERSION = v; },
   get DEFAULT_MAX_VERSION() { return defaults.DEFAULT_MAX_VERSION; },
   set DEFAULT_MAX_VERSION(v) { defaults.DEFAULT_MAX_VERSION = v; },
-  getCiphers,
+  getCiphers, getCertificateCompressionAlgorithms,
   get rootCertificates() { return bundledRoots(); },
   getCACertificates, setDefaultCACertificates, convertALPNProtocols, checkServerIdentity, createSecureContext, SecureContext,
   TLSSocket, Server, createServer, connect, createSecurePair,

package/node/prelude/util.js

@@ -6,8 +6,9 @@
 // TextDecoder, the globals (the runtime's encoding component).
 import { utilFormat, utilFormatWithOptions, utilInspect } from "visaljs:host";
 import { isDeepStrictEqual } from "./internal/comparisons.js";
-import { validateFunction, validateString } from "./internal/errors.js";
+import { validateFunction } from "./internal/errors.js";
 import { lazyClass, lazyFunction } from "./internal/features.js";
+import { stripVTControlCharacters } from "./internal/string_width.js";
 import types, { isPromise } from "./util_types.js";
 
 export { types };
@@ -32,15 +33,7 @@ export const format = utilFormat;
 export const formatWithOptions = utilFormatWithOptions;
 export const TextEncoder = globalThis.TextEncoder;
 export const TextDecoder = globalThis.TextDecoder;
-
-/* ANSI escape codes, as Node's internal/util/inspect.js matches them: an OSC sequence (a terminal
-   hyperlink: ESC ] … BEL) whole, or a CSI sequence */
-const ansi = new RegExp(
-  "(?:\\u001B\\][\\s\\S]*?(?:\\u0007|\\u001B\\u005C|\\u009C))" +
-  "|[\\u001B\\u009B][[\\]()#;?]*" +
-  "(?:\\d{1,4}(?:[;:]\\d{0,4})*)?" +
-  "[\\dA-PR-TZcf-nq-uy=><~]", "g",
-);
+export { stripVTControlCharacters };
 
 const kCustomPromisifiedSymbol = Symbol.for("nodejs.util.promisify.custom");
 /* names to make an object of when the callback gets several values, e.g. ['bytesRead', 'buffer'] */
@@ -93,12 +86,6 @@ export function promisify(original) {
 
 promisify.custom = kCustomPromisifiedSymbol;
 
-/** The string without its ANSI escape codes (colors, cursor movements, …). */
-export function stripVTControlCharacters(str) {
-  validateString(str, "str");
-  if (!str.includes("\u001B") && !str.includes("\u009B")) return str;  /* no escape introducer */
-  return str.replace(ansi, "");
-}
 
 const codesWarned = new Set();