visaljs 0.0.7 → 0.0.9

package/node/prelude/http2.js

@@ -1,4 +1,4 @@
-// node:http2 (ADR 0012, layer 3): only what code that supports both HTTP versions touches when it
+// node:http2: only what code that supports both HTTP versions touches when it
 // runs on HTTP/1 — the request and response classes (for instanceof checks, which never match
 // here) and the constants. Servers and sessions aren't provided: creating one throws.
 import { notSupported } from "./internal/errors.js";

package/node/prelude/https.js

@@ -0,0 +1,159 @@
+// node:https (Node's lib/https.js): HTTP over TLS. Server is a tls.Server whose secure connections
+// get http.Server's requests (llhttp fed the decrypted bytes: http.js's fed connections); Agent is
+// http.Agent connecting with tls.connect, reusing TLS sessions by origin; request and get are
+// http's, with https's agent and port 443.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
+import { Agent as HttpAgent, ClientRequest, Server as HttpServer } from "./http.js";
+import { invalidArgType } from "./internal/errors.js";
+import { Server as TlsServer, connect as tlsConnect } from "./tls.js";
+import { urlToHttpOptions } from "./url.js";
+import { callableClass } from "./internal/features.js";
+
+/* ---- Server ------------------------------------------------------------------------------------- */
+
+class ServerClass extends TlsServer {
+  constructor(options, requestListener) {
+    if (typeof options === "function") {
+      requestListener = options;
+      options = {};
+    } else if (options === undefined || options === null) {
+      options = {};
+    } else if (typeof options !== "object") {
+      throw invalidArgType("options", "of type object", options);
+    }
+    super({ noDelay: true, ALPNProtocols: ["http/1.1"], ...options });
+    this._initHttp(options, requestListener, "secureConnection");
+    /* a handshake that fails is the client's error, as a request that does */
+    this.on("tlsClientError", (err, conn) => {
+      if (!this.emit("clientError", err, conn)) conn.destroy(err);
+    });
+  }
+}
+export const Server = callableClass(ServerClass, "Server");  /* Server(…) without new, as Node's */
+
+/* http.Server's methods: its requests, timeouts and connections */
+for (const key of Object.getOwnPropertyNames(HttpServer.prototype)) {
+  if (key === "constructor" || Object.hasOwn(Server.prototype, key)) continue;
+  Object.defineProperty(Server.prototype, key, Object.getOwnPropertyDescriptor(HttpServer.prototype, key));
+}
+
+export function createServer(options, requestListener) {
+  return new Server(options, requestListener);
+}
+
+/* ---- Agent -------------------------------------------------------------------------------------- */
+
+/* tls.connect with the agent's options, resuming the origin's last session */
+function createConnection(port, host, options) {
+  if (port !== null && typeof port === "object") options = port;
+  else if (host !== null && typeof host === "object") options = { ...host };
+  else if (options === null || typeof options !== "object") options = {};
+  else options = { ...options };
+  if (typeof port === "number") options.port = port;
+  if (typeof host === "string") options.host = host;
+  if (options._agentKey) {
+    const session = this._getSession(options._agentKey);
+    if (session) options = { session, ...options };
+  }
+  const socket = tlsConnect(options);
+  if (options._agentKey) {
+    socket.on("session", (session) => this._cacheSession(options._agentKey, session));
+    socket.once("close", (err) => {
+      if (err) this._evictSession(options._agentKey);
+    });
+  }
+  return socket;
+}
+
+/** http.Agent over TLS: port 443, and the TLS options in each origin's name. */
+export function Agent(options) {
+  if (!(this instanceof Agent)) return new Agent(options);
+  HttpAgent.call(this, options);
+  this.defaultPort = 443;
+  this.protocol = "https:";
+  this.maxCachedSessions = this.options.maxCachedSessions;
+  if (this.maxCachedSessions === undefined) this.maxCachedSessions = 100;
+  this._sessionCache = { map: {}, list: [] };
+}
+Object.setPrototypeOf(Agent.prototype, HttpAgent.prototype);
+Object.setPrototypeOf(Agent, HttpAgent);
+Agent.prototype.createConnection = createConnection;
+
+/* the origin with what makes its TLS connections differ: sockets aren't shared across them */
+const nameOptions = ["ca", "cert", "clientCertEngine", "ciphers", "key", "pfx", "rejectUnauthorized", "servername", "minVersion",
+  "maxVersion", "secureProtocol", "crl", "honorCipherOrder", "ecdhCurve", "dhparam", "secureOptions", "sessionIdContext", "sigalgs",
+  "privateKeyIdentifier", "privateKeyEngine"];
+
+Agent.prototype.getName = function getName(options = {}) {
+  let name = HttpAgent.prototype.getName.call(this, options);
+  for (const key of nameOptions) {
+    name += ":";
+    const value = options[key];
+    if (key === "rejectUnauthorized") {
+      if (value !== undefined) name += value;
+    } else if (key === "servername") {
+      if (value && value !== options.host) name += value;
+    } else if (value) {
+      name += value;
+    }
+  }
+  return name;
+};
+
+Agent.prototype._getSession = function _getSession(key) {
+  return this._sessionCache.map[key];
+};
+
+Agent.prototype._cacheSession = function _cacheSession(key, session) {
+  if (this.maxCachedSessions === 0) return;
+  if (this._sessionCache.map[key]) {
+    this._sessionCache.map[key] = session;
+    return;
+  }
+  if (this._sessionCache.list.length >= this.maxCachedSessions) {
+    const oldKey = this._sessionCache.list.shift();
+    delete this._sessionCache.map[oldKey];
+  }
+  this._sessionCache.list.push(key);
+  this._sessionCache.map[key] = session;
+};
+
+Agent.prototype._evictSession = function _evictSession(key) {
+  const index = this._sessionCache.list.indexOf(key);
+  if (index === -1) return;
+  this._sessionCache.list.splice(index, 1);
+  delete this._sessionCache.map[key];
+};
+
+export let globalAgent = new Agent({ keepAlive: true, scheduling: "lifo", timeout: 5000 });
+
+/* ---- request and get ---------------------------------------------------------------------------- */
+
+/** request(url[, options][, callback]) or request(options[, callback]): an http.ClientRequest
+ *  with https's agent. */
+export function request(...args) {
+  let options = {};
+  if (typeof args[0] === "string") options = urlToHttpOptions(new URL(args.shift()));
+  else if (args[0] instanceof URL) options = urlToHttpOptions(args.shift());
+  if (args[0] && typeof args[0] !== "function") Object.assign(options, args.shift());
+  options._defaultAgent = globalAgent;
+  args.unshift(options);
+  return new ClientRequest(...args);
+}
+
+export function get(input, options, cb) {
+  const req = request(input, options, cb);
+  req.end();
+  return req;
+}
+
+export default {
+  Agent, Server, createServer, get, request,
+  /* an accessor, as Node's: a program may replace the agent requests use by default */
+  get globalAgent() {
+    return globalAgent;
+  },
+  set globalAgent(value) {
+    globalAgent = value;
+  },
+};

package/node/prelude/inspector.js

@@ -0,0 +1,27 @@
+// node:inspector: a compiled program has no V8 inspector to connect to. It loads as in a Node
+// process no debugger is attached to: url() is undefined, close() does nothing, console is the
+// global console. What needs the inspector throws when called: open, waitForDebugger and a Session.
+// Code that loads it only to ask whether a debugger is attached (Next.js's server) runs; code that
+// profiles or debugs on request fails when asked (TypeScript's --generateCpuProfile).
+import { notSupported } from "./internal/errors.js";
+
+export function open() {
+  throw notSupported("inspector.open() (a compiled program has no V8 inspector)");
+}
+export function close() {}
+export function url() {
+  return undefined;
+}
+export function waitForDebugger() {
+  throw notSupported("inspector.waitForDebugger() (a compiled program has no V8 inspector)");
+}
+export const console = globalThis.console;
+export class Session {
+  constructor() {
+    throw notSupported("inspector.Session (a compiled program has no V8 inspector)");
+  }
+}
+export const Network = {};
+export const NetworkResources = {};
+
+export default { open, close, url, waitForDebugger, console, Session, Network, NetworkResources };

package/node/prelude/inspector_promises.js

@@ -0,0 +1,4 @@
+// node:inspector/promises: as node:inspector, a compiled program has no V8 inspector: it loads,
+// with no debugger attached, and what needs one throws when called.
+export * from "./inspector.js";
+export { default } from "./inspector.js";

package/node/prelude/internal/async_context.js

@@ -1,4 +1,4 @@
-// The async context (ADR 0020): the value the runtime carries through jobs, timers and promise
+// The async context: the value the runtime carries through jobs, timers and promise
 // reactions, which node:async_hooks' AsyncLocalStorage keeps its stores in (a frame: a Map from
 // each storage to its store, never changed once current). I/O callbacks run under none: the
 // prelude binds each to the context it was registered in, as Node runs a handle's callbacks in

package/node/prelude/internal/buffer_transcode.js

@@ -0,0 +1,44 @@
+// buffer.transcode: bytes in one encoding as bytes in another. Linked into programs that name it
+// (internal/features.js).
+import { features } from "./features.js";
+
+/* transcode's encodings, by Buffer's names for them */
+const transcodable = { ascii: "ascii", latin1: "latin1", binary: "latin1", ucs2: "utf16le", "ucs-2": "utf16le", utf16le: "utf16le", "utf-16le": "utf16le", utf8: "utf8", "utf-8": "utf8" };
+
+/** The bytes in one encoding as bytes in another: ascii, latin1, ucs2 or utf8. A character the
+ *  target can't hold becomes "?", as Node's (ICU's) transcode makes it. */
+function transcode(source, fromEncoding, toEncoding) {
+  if (!(source instanceof Uint8Array)) {
+    const e = new TypeError(`The "source" argument must be an instance of Buffer or Uint8Array.${received(source)}`);
+    e.code = "ERR_INVALID_ARG_TYPE";
+    throw e;
+  }
+  if (source.length === 0) return Buffer.alloc(0);
+  const from = transcodable[String(fromEncoding).toLowerCase()];
+  const to = transcodable[String(toEncoding).toLowerCase()];
+  if (from === undefined || to === undefined) {
+    const e = new Error("Unable to transcode Buffer [U_ILLEGAL_ARGUMENT_ERROR]");
+    e.code = "U_ILLEGAL_ARGUMENT_ERROR";
+    e.errno = 1;
+    throw e;
+  }
+  let text = Buffer.from(source.buffer, source.byteOffset, source.byteLength).toString(from);
+  const max = to === "ascii" ? 0x7f : to === "latin1" ? 0xff : -1;
+  if (max >= 0) {
+    let out = "";
+    for (const ch of text) out += ch.codePointAt(0) > max ? "?" : ch;
+    text = out;
+  }
+  return Buffer.from(text, to);
+}
+
+/* Node's "Received …" for the message */
+function received(value) {
+  if (value === null || value === undefined) return ` Received ${value}`;
+  if (typeof value === "function") return ` Received function ${value.name}`;
+  if (typeof value === "object") return ` Received an instance of ${value.constructor?.name ?? "Object"}`;
+  const shown = typeof value === "string" ? `'${value.length > 25 ? value.slice(0, 25) + "..." : value}'` : String(value);
+  return ` Received type ${typeof value} (${shown})`;
+}
+
+features.transcode = transcode;