visaljs 0.0.7 → 0.0.8

package/node/prelude/internal/readline.js

@@ -0,0 +1,338 @@
+// 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.
+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";
+
+/* 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");
+
+export const kQuestion = Symbol("question");
+export const kQuestionCancel = Symbol("questionCancel");
+
+function validateSignal(signal, name) {
+  if (signal !== undefined && (signal === null || typeof signal !== "object" || !("aborted" in signal))) {
+    throw invalidArgType(name, "an instance of AbortSignal", signal);
+  }
+}
+
+/** 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 });
+  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);
+  EventEmitter.call(this);
+  let prompt = "> ";
+  let crlfDelay;
+  let signal;
+  if (input?.input) {
+    ({ output, completer, terminal, signal, crlfDelay } = input);
+    if (input.prompt !== undefined) prompt = input.prompt;
+    input = input.input;
+  }
+  if (completer !== undefined && typeof completer !== "function") throw invalidArgValue("completer", "must be a function", completer);
+  validateSignal(signal, "options.signal");
+  this.input = input;
+  this.output = output;
+  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);
+  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 (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));
+    }
+  }
+  input.resume();
+}
+Object.setPrototypeOf(Interface.prototype, EventEmitter.prototype);
+Object.setPrototypeOf(Interface, EventEmitter);
+
+Interface.prototype.setPrompt = function setPrompt(prompt) {
+  this._prompt = prompt;
+};
+
+Interface.prototype.getPrompt = function getPrompt() {
+  return this._prompt;
+};
+
+Interface.prototype._writeToOutput = function _writeToOutput(text) {
+  validateString(text, "stringToWrite");
+  if (this.output !== null && this.output !== undefined) this.output.write(text);
+};
+
+/** 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);
+};
+
+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();
+  }
+};
+
+/* 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;
+};
+
+/** 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;
+    }
+  }
+  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);
+      };
+    }
+    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;
+};
+
+Interface.prototype.resume = function resume() {
+  if (!this.paused) return;
+  this.input.resume();
+  this.paused = false;
+  this.emit("resume");
+  return this;
+};
+
+/** 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");
+};
+
+/** 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);
+};
+
+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);
+};
+
+/* 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;
+  }
+};
+
+/** 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]();
+};
+
+export function createInterface(input, output, completer, terminal) {
+  return new Interface(input, output, completer, terminal);
+}
+
+/* ---- the cursor: ANSI escapes ------------------------------------------------------------ */
+
+const CSI = "\x1b[";
+
+/* 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;
+  }
+  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";
+}
+
+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";
+}
+
+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;
+}
+
+export function clearLine(stream, dir, callback) {
+  return writeTo(stream, clearLineEscape(dir), callback);
+}
+
+export function clearScreenDown(stream, callback) {
+  return writeTo(stream, CSI + "0J", callback);
+}
+
+export function cursorTo(stream, x, y, callback) {
+  if (typeof y === "function") {
+    callback = y;
+    y = undefined;
+  }
+  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);
+}
+
+export function emitKeypressEvents() {
+  throw notSupported("readline.emitKeypressEvents");
+}

package/node/prelude/internal/socketaddress.js

@@ -1,6 +1,7 @@
 // net.SocketAddress and net.BlockList (Node's lib/internal/socketaddress.js and blocklist.js,
 // whose C++ side is here in JS): an address is its bytes, 4 or 16; an IPv4 address checked
 // against an IPv6 rule, or the reverse, compares as an IPv4-mapped IPv6 address (::ffff:a.b.c.d).
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import { codeError, invalidArgType, invalidArgValue, outOfRange, validateString } from "./errors.js";
 import { isIPv4, isIPv6 } from "./net.js";
 
@@ -184,7 +185,7 @@ const kRules = Symbol("kRules");
 
 export class BlockList {
   constructor() {
-    this[kRules] = [];  /* newest first, as Node lists them */
+    this[kRules] = [];  /* newest first, as Node lists them: addresses, then subnets, then ranges */
   }
 
   static isBlockList(value) {
@@ -200,7 +201,9 @@ export class BlockList {
   addAddress(address, family = "ipv4") {
     const sa = toSocketAddress(address, "address", family);
     const bytes = sa[kDetail].bytes;
-    this[kRules].unshift({ text: "Address: " + familyName(sa) + " " + sa.address, test: (b) => compare(b, bytes) === 0 });
+    const text = "Address: " + familyName(sa) + " " + sa.address;
+    if (this[kRules].some((rule) => rule.text === text)) return;  /* once each, as Node 24 keeps them */
+    this[kRules].unshift({ kind: 0, text, test: (b) => compare(b, bytes) === 0 });
   }
 
   addRange(start, end, family = "ipv4") {
@@ -209,6 +212,7 @@ export class BlockList {
     const a = from[kDetail].bytes, b = to[kDetail].bytes;
     if (compare(a, b) > 0) throw invalidArgValue("start", "must come before end", from);
     this[kRules].unshift({
+      kind: 2,
       text: "Range: " + familyName(from) + " " + from.address + "-" + to.address,
       test: (x) => compare(x, a) >= 0 && compare(x, b) <= 0,
     });
@@ -220,7 +224,7 @@ export class BlockList {
     if (typeof prefix !== "number") throw invalidArgType("prefix", "of type number", prefix);
     if (!Number.isInteger(prefix) || prefix < 0 || prefix > max) throw outOfRange("prefix", ">= 0 && <= " + max, prefix);
     const bytes = sa[kDetail].bytes;
-    this[kRules].unshift({ text: "Subnet: " + familyName(sa) + " " + sa.address + "/" + prefix, test: (x) => inNetwork(x, bytes, prefix) });
+    this[kRules].unshift({ kind: 1, text: "Subnet: " + familyName(sa) + " " + sa.address + "/" + prefix, test: (x) => inNetwork(x, bytes, prefix) });
   }
 
   check(address, family = "ipv4") {
@@ -240,7 +244,7 @@ export class BlockList {
   }
 
   get rules() {
-    return this[kRules].map((rule) => rule.text);
+    return this[kRules].toSorted((a, b) => a.kind - b.kind).map((rule) => rule.text);
   }
 
   toJSON() {

package/node/prelude/internal/source_map.js

@@ -0,0 +1,122 @@
+// module.SourceMap: a source map (version 3) read as Node's lib/internal/source_map/source_map.js
+// reads it: its mappings decoded (base64 VLQ), findEntry by generated position (0-based) and
+// findOrigin (1-based). Linked into programs that name SourceMap; module.js finds it by its symbol.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
+const kSourceMap = Symbol.for("visaljs.SourceMap");
+
+const base64 = new Map([..."ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"].map((c, i) => [c, i]));
+
+class SourceMap {
+  #payload;
+  #lineLengths;
+  #mappings = [];  /* [generatedLine, generatedColumn, source, originalLine, originalColumn, name?], sorted */
+
+  constructor(payload, { lineLengths } = {}) {
+    if (payload === null || typeof payload !== "object") {
+      const received = payload === null || payload === undefined ? `${payload}` : `type ${typeof payload} (${typeof payload === "string" ? `'${payload}'` : payload})`;
+      const e = new TypeError(`The "payload" argument must be of type object. Received ${received}`);
+      e.code = "ERR_INVALID_ARG_TYPE";
+      throw e;
+    }
+    this.#payload = JSON.parse(JSON.stringify(payload));
+    this.#lineLengths = lineLengths;
+    if (payload.sections) {
+      for (const section of payload.sections) {
+        const inner = new SourceMap(section.map);
+        for (const m of inner.#mappings) {
+          this.#mappings.push([m[0] + section.offset.line, m[0] === 0 ? m[1] + section.offset.column : m[1], ...m.slice(2)]);
+        }
+      }
+    } else {
+      this.#parse(payload);
+    }
+    this.#mappings.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  }
+
+  get payload() {
+    return this.#payload;
+  }
+
+  get lineLengths() {
+    return this.#lineLengths;
+  }
+
+  #parse(map) {
+    const sources = (map.sources ?? []).map((s) => (map.sourceRoot ? `${map.sourceRoot.replace(/\/?$/, "/")}${s}` : s));
+    const names = map.names ?? [];
+    const text = map.mappings ?? "";
+    let line = 0, column = 0, source = 0, originalLine = 0, originalColumn = 0, name = 0;
+    let nameValue;  /* a segment without a name keeps the last one's, as Node's parser does */
+    let i = 0;
+    const vlq = () => {
+      let result = 0, shift = 0, digit;
+      do {
+        digit = base64.get(text[i++]);
+        if (digit === undefined) throw new Error("Invalid source map: bad VLQ");
+        result += (digit & 31) * 2 ** shift;
+        shift += 5;
+      } while (digit & 32);
+      return result & 1 ? -(result - 1) / 2 : result / 2;
+    };
+    while (i < text.length) {
+      const c = text[i];
+      if (c === ";") {
+        line++;
+        column = 0;
+        i++;
+        continue;
+      }
+      if (c === ",") {
+        i++;
+        continue;
+      }
+      column += vlq();
+      if (i >= text.length || text[i] === "," || text[i] === ";") {
+        this.#mappings.push([line, column]);
+        continue;
+      }
+      source += vlq();
+      originalLine += vlq();
+      originalColumn += vlq();
+      if (i < text.length && text[i] !== "," && text[i] !== ";") {
+        name += vlq();
+        nameValue = names[name];
+      }
+      this.#mappings.push([line, column, sources[source], originalLine, originalColumn, nameValue]);
+    }
+  }
+
+  /* the last mapping at or before the position, on that line or an earlier one, as Node's */
+  #find(line, column) {
+    let lo = 0, hi = this.#mappings.length - 1, found = -1;
+    while (lo <= hi) {
+      const mid = (lo + hi) >> 1;
+      const m = this.#mappings[mid];
+      if (m[0] < line || (m[0] === line && m[1] <= column)) {
+        found = mid;
+        lo = mid + 1;
+      } else hi = mid - 1;
+    }
+    if (found === -1) return undefined;
+    const m = this.#mappings[found];
+    return m.length > 2 ? m : undefined;
+  }
+
+  /** findEntry(lineOffset, columnOffset): the mapping there (0-based), or {}. */
+  findEntry(lineOffset, columnOffset) {
+    const m = this.#find(lineOffset, columnOffset);
+    if (!m) return {};
+    const entry = { generatedLine: m[0], generatedColumn: m[1], originalSource: m[2], originalLine: m[3], originalColumn: m[4] };
+    if (m[5] !== undefined) entry.name = m[5];
+    return entry;
+  }
+
+  /** findOrigin(lineNumber, columnNumber): where a generated position (1-based) came from, or {}. */
+  findOrigin(lineNumber, columnNumber) {
+    const m = this.#find(lineNumber - 1, columnNumber - 1);
+    if (!m) return {};
+    return { name: m[5], fileName: m[2], lineNumber: m[3] + 1 + (lineNumber - 1 - m[0]), columnNumber: m[4] + 1 + (columnNumber - 1 - m[1]) };
+  }
+}
+
+globalThis[kSourceMap] = SourceMap;

package/node/prelude/internal/stream_compose.js

@@ -0,0 +1,74 @@
+// stream.compose, Duplex.from, readable.compose and stream.duplexPair: Node's
+// internal/streams/compose.js, duplexify.js and duplexpair.js, linked into programs that name
+// them (implicitModules in node/index.ts, internal/features.js).
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
+import { Duplex } from "../stream.js";
+import { features } from "./features.js";
+import compose from "./streams/compose.js";
+import duplexify from "./streams/duplexify.js";
+/* Duplex.from of web streams converts them */
+import "./stream_web_adapters.js";
+
+const kCallback = Symbol("Callback");
+const kInitOtherSide = Symbol("InitOtherSide");
+
+/* one end of a duplexPair: what's written to it comes out of the other end */
+class DuplexSide extends Duplex {
+  #otherSide = null;
+
+  constructor(options) {
+    super(options);
+    this[kCallback] = null;
+    this.#otherSide = null;
+  }
+
+  [kInitOtherSide](otherSide) {
+    if (this.#otherSide === null) this.#otherSide = otherSide;
+  }
+
+  _read() {
+    const callback = this[kCallback];
+    if (callback) {
+      this[kCallback] = null;
+      callback();
+    }
+  }
+
+  _write(chunk, encoding, callback) {
+    if (chunk.length === 0) {
+      process.nextTick(callback);
+    } else {
+      this.#otherSide.push(chunk);
+      this.#otherSide[kCallback] = callback;
+    }
+  }
+
+  _final(callback) {
+    this.#otherSide.on("end", callback);
+    this.#otherSide.push(null);
+  }
+
+  _destroy(err, callback) {
+    const otherSide = this.#otherSide;
+    if (otherSide !== null && !otherSide.destroyed) {
+      process.nextTick(() => {
+        if (otherSide.destroyed) return;
+        if (err) otherSide.destroy();
+        else otherSide.push(null);
+      });
+    }
+    callback(err);
+  }
+}
+
+function duplexPair(options) {
+  const side0 = new DuplexSide(options);
+  const side1 = new DuplexSide(options);
+  side0[kInitOtherSide](side1);
+  side1[kInitOtherSide](side0);
+  return [side0, side1];
+}
+
+features.compose = compose;
+features.duplexify = duplexify;
+features.duplexPair = duplexPair;

package/node/prelude/internal/stream_from.js

@@ -0,0 +1,6 @@
+// Readable.from, as Node's internal/streams/from.js: linked into programs that name it
+// (implicitModules in node/index.ts, internal/features.js).
+import { features } from "./features.js";
+import from from "./streams/from.js";
+
+features.readableFrom = from;

package/node/prelude/internal/stream_operators.js

@@ -0,0 +1,23 @@
+// The Readable operators (map, filter, flatMap, drop, take, every, forEach, reduce, toArray,
+// some, find): Node's internal/streams/operators.js, installed on Readable.prototype as
+// lib/stream.js does. Linked into programs that name one (implicitModules in node/index.ts).
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
+import { Readable } from "../stream.js";
+import { codes } from "./streams/errors.js";
+import "./stream_from.js";
+import { promiseReturningOperators, streamReturningOperators } from "./streams/operators.js";
+
+function install(operators, wrap) {
+  for (const key of Object.keys(operators)) {
+    const op = operators[key];
+    function fn(...args) {
+      if (new.target) throw new codes.ERR_ILLEGAL_CONSTRUCTOR();
+      return wrap(Reflect.apply(op, this, args));
+    }
+    Object.defineProperty(fn, "name", { __proto__: null, value: op.name });
+    Object.defineProperty(fn, "length", { __proto__: null, value: op.length });
+    Object.defineProperty(Readable.prototype, key, { __proto__: null, value: fn, enumerable: false, configurable: true, writable: true });
+  }
+}
+install(streamReturningOperators, (result) => Readable.from(result));
+install(promiseReturningOperators, (result) => result);

package/node/prelude/internal/stream_pipeline.js

@@ -0,0 +1,7 @@
+// stream.pipeline and stream/promises' pipeline, as Node's internal/streams/pipeline.js: linked
+// into programs that name pipeline (implicitModules in node/index.ts, internal/features.js).
+import { features } from "./features.js";
+import { pipeline, pipelineImpl } from "./streams/pipeline.js";
+
+features.pipeline = pipeline;
+features.pipelineImpl = pipelineImpl;

package/node/prelude/internal/stream_transform.js

@@ -0,0 +1,10 @@
+// stream.Transform and stream.PassThrough, as Node's internal/streams/transform.js and
+// passthrough.js: linked into programs that name them (implicitModules in node/index.ts,
+// internal/features.js). node:zlib and node:crypto import the class directly.
+import { PassThrough as PassThroughWrapper, Transform as TransformWrapper } from "../stream.js";
+import { provideClass } from "./features.js";
+import PassThrough from "./streams/passthrough.js";
+import Transform from "./streams/transform.js";
+
+provideClass(TransformWrapper, Transform);
+provideClass(PassThroughWrapper, PassThrough);