visaljs 0.0.1 → 0.0.3

package/node/prelude/internal/http_agent.js

@@ -0,0 +1,249 @@
+// http.Agent (Node's lib/_http_agent.js): sockets pooled by origin ("host:port:localAddress"),
+// at most maxSockets each, the rest of the requests queued; with keepAlive, a socket whose
+// response is done goes to freeSockets (unref'd, so it doesn't keep the program running) for
+// the next request to the same origin, until the agent's timeout or the server's Keep-Alive hint.
+import { EventEmitter } from "../events.js";
+import { createConnection } from "../net.js";
+import { invalidArgType, invalidArgValue, outOfRange } from "./errors.js";
+
+function freeSocketErrorListener() {
+  this.destroy();
+  this.emit("agentRemove");
+}
+
+export function Agent(options) {
+  if (!(this instanceof Agent)) return new Agent(options);
+  EventEmitter.call(this);
+  this.defaultPort = 80;
+  this.protocol = "http:";
+  this.options = { __proto__: null, ...options };
+  if (this.options.noDelay === undefined) this.options.noDelay = true;
+  this.options.path = null;  /* not a pipe, to net */
+  this.requests = { __proto__: null };
+  this.sockets = { __proto__: null };
+  this.freeSockets = { __proto__: null };
+  this.keepAliveMsecs = this.options.keepAliveMsecs || 1000;
+  this.keepAlive = this.options.keepAlive || false;
+  this.maxSockets = this.options.maxSockets || Agent.defaultMaxSockets;
+  this.maxFreeSockets = this.options.maxFreeSockets || 256;
+  this.scheduling = this.options.scheduling || "lifo";
+  this.maxTotalSockets = this.options.maxTotalSockets;
+  this.totalSocketCount = 0;
+  if (this.scheduling !== "fifo" && this.scheduling !== "lifo") throw invalidArgValue("scheduling", "must be one of: 'fifo', 'lifo'", this.scheduling);
+  if (this.maxTotalSockets !== undefined) {
+    if (typeof this.maxTotalSockets !== "number") throw invalidArgType("maxTotalSockets", "of type number", this.maxTotalSockets);
+    if (!(this.maxTotalSockets >= 1)) throw outOfRange("maxTotalSockets", ">= 1", this.maxTotalSockets);
+  } else {
+    this.maxTotalSockets = Infinity;
+  }
+
+  /* a socket whose request is done: the next queued request's, kept alive, or destroyed */
+  this.on("free", (socket, options) => {
+    const name = this.getName(options);
+    if (!socket.writable) {
+      socket.destroy();
+      return;
+    }
+    const requests = this.requests[name];
+    if (requests?.length) {
+      const req = requests.shift();
+      setRequestSocket(this, req, socket);
+      if (requests.length === 0) delete this.requests[name];
+      return;
+    }
+    const req = socket._httpMessage;
+    if (!req || !req.shouldKeepAlive || !this.keepAlive) {
+      socket.destroy();
+      return;
+    }
+    const freeSockets = this.freeSockets[name] || [];
+    const freeLen = freeSockets.length;
+    let count = freeLen;
+    if (this.sockets[name]) count += this.sockets[name].length;
+    if (this.totalSocketCount > this.maxTotalSockets || count > this.maxSockets || freeLen >= this.maxFreeSockets || !this.keepSocketAlive(socket)) {
+      socket.destroy();
+      return;
+    }
+    this.freeSockets[name] = freeSockets;
+    socket._httpMessage = null;
+    this.removeSocket(socket, options);
+    socket.once("error", freeSocketErrorListener);
+    freeSockets.push(socket);
+  });
+}
+Object.setPrototypeOf(Agent.prototype, EventEmitter.prototype);
+Object.setPrototypeOf(Agent, EventEmitter);
+
+Agent.defaultMaxSockets = Infinity;
+
+Agent.prototype.createConnection = createConnection;
+
+/* the pool's key: "host:port:localAddress[:family][:socketPath]" */
+Agent.prototype.getName = function getName(options = {}) {
+  let name = options.host || "localhost";
+  name += ":";
+  if (options.port) name += options.port;
+  name += ":";
+  if (options.localAddress) name += options.localAddress;
+  if (options.family === 4 || options.family === 6) name += ":" + options.family;
+  if (options.socketPath) name += ":" + options.socketPath;
+  return name;
+};
+
+/* a request: a free socket, a new one (under maxSockets), or the queue */
+Agent.prototype.addRequest = function addRequest(req, options, port, localAddress) {
+  if (typeof options === "string") options = { __proto__: null, host: options, port, localAddress };
+  options = { __proto__: null, ...options, ...this.options };
+  if (options.socketPath) options.path = options.socketPath;
+  const name = this.getName(options);
+  this.sockets[name] ||= [];
+  const freeSockets = this.freeSockets[name];
+  let socket;
+  if (freeSockets) {
+    while (freeSockets.length && freeSockets[0].destroyed) freeSockets.shift();
+    socket = this.scheduling === "fifo" ? freeSockets.shift() : freeSockets.pop();
+    if (!freeSockets.length) delete this.freeSockets[name];
+  }
+  const freeLen = freeSockets ? freeSockets.length : 0;
+  const sockLen = freeLen + this.sockets[name].length;
+  if (socket) {
+    this.reuseSocket(socket, req);
+    setRequestSocket(this, req, socket);
+    this.sockets[name].push(socket);
+  } else if (sockLen < this.maxSockets && this.totalSocketCount < this.maxTotalSockets) {
+    this.createSocket(req, options, (err, socket) => {
+      if (err) req.onSocket(socket, err);
+      else setRequestSocket(this, req, socket);
+    });
+  } else {
+    this.requests[name] ||= [];
+    req._agentOptions = options;
+    this.requests[name].push(req);
+  }
+};
+
+Agent.prototype.createSocket = function createSocket(req, options, cb) {
+  options = { __proto__: null, ...options, ...this.options };
+  if (options.socketPath) options.path = options.socketPath;
+  const name = this.getName(options);
+  options._agentKey = name;
+  options.encoding = null;
+  let called = false;
+  const oncreate = (err, s) => {
+    if (called) return;
+    called = true;
+    if (err) return cb(err);
+    if (!this.sockets[name]) this.sockets[name] = [];
+    this.sockets[name].push(s);
+    this.totalSocketCount++;
+    installListeners(this, s, options);
+    cb(null, s);
+  };
+  if (this.keepAlive) {
+    options.keepAlive = this.keepAlive;
+    options.keepAliveInitialDelay = this.keepAliveMsecs;
+  }
+  const newSocket = this.createConnection(options, oncreate);
+  if (newSocket) oncreate(null, newSocket);
+};
+
+function installListeners(agent, s, options) {
+  function onFree() {
+    agent.emit("free", s, options);
+  }
+  s.on("free", onFree);
+  /* the one place sockets leave the agent: every error ends in 'close' */
+  function onClose() {
+    agent.totalSocketCount--;
+    agent.removeSocket(s, options);
+  }
+  s.on("close", onClose);
+  function onTimeout() {
+    const sockets = agent.freeSockets;
+    if (Object.keys(sockets).some((name) => sockets[name].includes(s))) s.destroy();
+  }
+  s.on("timeout", onTimeout);
+  /* an upgraded socket leaves the pool for good */
+  function onRemove() {
+    agent.totalSocketCount--;
+    agent.removeSocket(s, options);
+    s.removeListener("close", onClose);
+    s.removeListener("free", onFree);
+    s.removeListener("timeout", onTimeout);
+    s.removeListener("agentRemove", onRemove);
+  }
+  s.on("agentRemove", onRemove);
+}
+
+Agent.prototype.removeSocket = function removeSocket(s, options) {
+  const name = this.getName(options);
+  const sets = [this.sockets];
+  if (!s.writable) sets.push(this.freeSockets);  /* a destroyed socket leaves the free list too */
+  for (const sockets of sets) {
+    const list = sockets[name];
+    if (list) {
+      const index = list.indexOf(s);
+      if (index !== -1) {
+        list.splice(index, 1);
+        if (list.length === 0) delete sockets[name];
+      }
+    }
+  }
+  let req;
+  if (this.requests[name]?.length) {
+    req = this.requests[name][0];
+  } else {
+    for (const prop of Object.keys(this.requests)) {
+      if (this.sockets[prop]?.length) break;
+      req = this.requests[prop][0];
+      options = req._agentOptions;
+      break;
+    }
+  }
+  if (req && options) {  /* a socket went away with requests waiting: a new one for them */
+    req._agentOptions = undefined;
+    this.createSocket(req, options, (err, socket) => {
+      if (err) req.onSocket(socket, err);
+      else socket.emit("free");
+    });
+  }
+};
+
+/* a kept-alive socket: unref'd while free, timed out by the agent's timeout or the server's hint */
+Agent.prototype.keepSocketAlive = function keepSocketAlive(socket) {
+  socket.setKeepAlive(true, this.keepAliveMsecs);
+  socket.unref();
+  let agentTimeout = this.options.timeout || 0;
+  let canKeepSocketAlive = true;
+  const hint = socket._httpMessage?.res?.headers["keep-alive"];
+  const seconds = hint ? /^timeout=(\d+)/.exec(hint)?.[1] : undefined;
+  if (seconds) {
+    let serverHintTimeout = parseInt(seconds, 10) * 1000 - 1000;
+    serverHintTimeout = serverHintTimeout > 0 ? serverHintTimeout : 0;
+    if (serverHintTimeout === 0) canKeepSocketAlive = false;
+    else if (serverHintTimeout < agentTimeout) agentTimeout = serverHintTimeout;
+  }
+  if (socket.timeout !== agentTimeout) socket.setTimeout(agentTimeout);
+  return canKeepSocketAlive;
+};
+
+Agent.prototype.reuseSocket = function reuseSocket(socket, req) {
+  socket.removeListener("error", freeSocketErrorListener);
+  req.reusedSocket = true;
+  socket.ref();
+};
+
+Agent.prototype.destroy = function destroy() {
+  for (const set of [this.freeSockets, this.sockets]) {
+    for (const name of Object.keys(set)) for (const socket of [...set[name]]) socket.destroy();
+  }
+};
+
+function setRequestSocket(agent, req, socket) {
+  req.onSocket(socket);
+  const agentTimeout = agent.options.timeout || 0;
+  if (req.timeout === undefined || req.timeout === agentTimeout) return;
+  socket.setTimeout(req.timeout);
+}
+
+export const globalAgent = new Agent({ keepAlive: true, scheduling: "lifo", timeout: 5000 });

package/node/prelude/internal/net.js

@@ -0,0 +1,33 @@
+// IP address checks (Node's lib/internal/net.js regexes), shared by node:net and node:dns.
+
+// IPv4 Segment
+const v4Seg = "(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])";
+const v4Str = `(?:${v4Seg}\\.){3}${v4Seg}`;
+const IPv4Reg = new RegExp(`^${v4Str}$`);
+
+// IPv6 Segment
+const v6Seg = "(?:[0-9a-fA-F]{1,4})";
+const IPv6Reg = new RegExp("^(?:" +
+  `(?:${v6Seg}:){7}(?:${v6Seg}|:)|` +
+  `(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|` +
+  `(?:${v6Seg}:){5}(?::${v4Str}|(?::${v6Seg}){1,2}|:)|` +
+  `(?:${v6Seg}:){4}(?:(?::${v6Seg}){0,1}:${v4Str}|(?::${v6Seg}){1,3}|:)|` +
+  `(?:${v6Seg}:){3}(?:(?::${v6Seg}){0,2}:${v4Str}|(?::${v6Seg}){1,4}|:)|` +
+  `(?:${v6Seg}:){2}(?:(?::${v6Seg}){0,3}:${v4Str}|(?::${v6Seg}){1,5}|:)|` +
+  `(?:${v6Seg}:){1}(?:(?::${v6Seg}){0,4}:${v4Str}|(?::${v6Seg}){1,6}|:)|` +
+  `(?::(?:(?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:))` +
+")(?:%[0-9a-zA-Z-.:]{1,})?$");
+
+export function isIPv4(s) {
+  return IPv4Reg.test(s);
+}
+
+export function isIPv6(s) {
+  return IPv6Reg.test(s);
+}
+
+export function isIP(s) {
+  if (isIPv4(s)) return 4;
+  if (isIPv6(s)) return 6;
+  return 0;
+}

package/node/prelude/internal/socketaddress.js

@@ -0,0 +1,249 @@
+// 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).
+import { codeError, invalidArgType, invalidArgValue, outOfRange, validateString } from "./errors.js";
+import { isIPv4, isIPv6 } from "./net.js";
+
+const kInspect = Symbol.for("nodejs.util.inspect.custom");
+
+/* "1.2.3.4" → 4 bytes */
+function parseIPv4(s) {
+  return s.split(".").map(Number);
+}
+
+/* "2001:db8::1" (an IPv4 tail, a zone id ignored) → 16 bytes */
+function parseIPv6(s) {
+  const zone = s.indexOf("%");
+  if (zone !== -1) s = s.slice(0, zone);
+  let tail = [];
+  const lastColon = s.lastIndexOf(":");
+  if (s.indexOf(".", lastColon) !== -1) {
+    const v4 = parseIPv4(s.slice(lastColon + 1));
+    tail = [(v4[0] << 8) | v4[1], (v4[2] << 8) | v4[3]];
+    s = s.slice(0, lastColon + 1);  /* "::ffff:" → "::ffff", "::" stays */
+    if (!s.endsWith("::")) s = s.slice(0, -1);
+  }
+  const halves = s.split("::");
+  const groups = (part) => (part === "" ? [] : part.split(":").map((g) => parseInt(g, 16)));
+  let words;
+  if (halves.length === 2) {
+    const head = groups(halves[0]);
+    const rest = groups(halves[1]).concat(tail);
+    words = head.concat(new Array(8 - head.length - rest.length).fill(0), rest);
+  } else {
+    words = groups(halves[0]).concat(tail);
+  }
+  const bytes = [];
+  for (const w of words) bytes.push(w >> 8, w & 0xff);
+  return bytes;
+}
+
+/* 16 bytes → RFC 5952 text: lower case, the longest run of zero groups (two or more) as "::" */
+function formatIPv6(bytes) {
+  const words = [];
+  for (let i = 0; i < 16; i += 2) words.push((bytes[i] << 8) | bytes[i + 1]);
+  let best = -1, bestLen = 0;
+  for (let i = 0; i < 8;) {
+    if (words[i] !== 0) {
+      i++;
+      continue;
+    }
+    let j = i;
+    while (j < 8 && words[j] === 0) j++;
+    if (j - i > bestLen && j - i > 1) {
+      best = i;
+      bestLen = j - i;
+    }
+    i = j;
+  }
+  /* ::ffff:a.b.c.d and ::a.b.c.d keep their IPv4 tail, as inet_ntop writes them */
+  if (best === 0 && (bestLen === 6 || (bestLen === 5 && words[5] === 0xffff))) {
+    const v4 = bytes.slice(12).join(".");
+    return bestLen === 6 ? "::" + v4 : "::ffff:" + v4;
+  }
+  const hex = (from, to) => words.slice(from, to).map((w) => w.toString(16)).join(":");
+  if (best === -1) return hex(0, 8);
+  return hex(0, best) + "::" + hex(best + bestLen, 8);
+}
+
+/* the bytes of an address of the given family, or null when it isn't one */
+function addressBytes(address, family) {
+  if (family === "ipv4") return isIPv4(address) ? parseIPv4(address) : null;
+  return isIPv6(address) ? parseIPv6(address) : null;
+}
+
+const v4Mapped = (bytes) => (bytes.length === 16 ? bytes : [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff].concat(bytes));
+
+function compare(a, b) {
+  if (a.length !== b.length) {
+    a = v4Mapped(a);
+    b = v4Mapped(b);
+  }
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return a[i] - b[i];
+  return 0;
+}
+
+function inNetwork(bytes, network, prefix) {
+  if (bytes.length !== network.length) {
+    if (network.length === 4) prefix += 96;
+    bytes = v4Mapped(bytes);
+    network = v4Mapped(network);
+  }
+  for (let i = 0; i < bytes.length && prefix > 0; i++, prefix -= 8) {
+    const mask = prefix >= 8 ? 0xff : (0xff << (8 - prefix)) & 0xff;
+    if ((bytes[i] & mask) !== (network[i] & mask)) return false;
+  }
+  return true;
+}
+
+function validatePort(port, name) {
+  if ((typeof port !== "number" && typeof port !== "string") || (typeof port === "string" && port.trim().length === 0) ||
+    +port !== (+port >>> 0) || port > 0xffff) {
+    throw codeError(RangeError, "ERR_SOCKET_BAD_PORT", name + " should be >= 0 and < 65536. Received " +
+      (typeof port === "string" ? "type string ('" + port + "')" : typeof port === "number" ? "type number (" + port + ")" : String(port)) + ".");
+  }
+}
+
+const kDetail = Symbol("kDetail");
+
+export class SocketAddress {
+  static isSocketAddress(value) {
+    return value?.[kDetail] !== undefined;
+  }
+
+  constructor(options = {}) {
+    if (options === null || typeof options !== "object") throw invalidArgType("options", "of type object", options);
+    let { family = "ipv4" } = options;
+    const { address = family === "ipv4" ? "127.0.0.1" : "::", port = 0, flowlabel = 0 } = options;
+    if (typeof family?.toLowerCase === "function") family = family.toLowerCase();
+    if (family !== "ipv4" && family !== "ipv6") throw invalidArgValue("options.family", "is invalid", options.family);
+    validateString(address, "options.address");
+    validatePort(port, "options.port");
+    if (typeof flowlabel !== "number") throw invalidArgType("options.flowlabel", "of type number", flowlabel);
+    if (!Number.isInteger(flowlabel) || flowlabel < 0 || flowlabel > 4294967295) throw outOfRange("options.flowlabel", ">= 0 && <= 4294967295", flowlabel);
+    const bytes = addressBytes(address, family);
+    if (bytes === null) throw codeError(Error, "ERR_INVALID_ADDRESS", "Invalid socket address");
+    this[kDetail] = {
+      bytes,
+      address: family === "ipv4" ? bytes.join(".") : formatIPv6(bytes),
+      port: port | 0,
+      family,
+      flowlabel: family === "ipv6" ? flowlabel | 0 : 0,
+    };
+  }
+
+  get address() {
+    return this[kDetail].address;
+  }
+
+  get port() {
+    return this[kDetail].port;
+  }
+
+  get family() {
+    return this[kDetail].family;
+  }
+
+  get flowlabel() {
+    return this[kDetail].flowlabel;
+  }
+
+  [kInspect](depth, options, inspect) {
+    if (depth < 0) return this;
+    const opts = { ...options, depth: options.depth == null ? null : options.depth - 1 };
+    return "SocketAddress " + inspect(this.toJSON(), opts);
+  }
+
+  toJSON() {
+    return { address: this.address, port: this.port, family: this.family, flowlabel: this.flowlabel };
+  }
+
+  /* "1.2.3.4:80", "[::1]:80" → a SocketAddress, or undefined */
+  static parse(input) {
+    validateString(input, "input");
+    try {
+      const { hostname: address, port } = new URL("http://" + input);
+      if (address.startsWith("[") && address.endsWith("]")) return new SocketAddress({ address: address.slice(1, -1), port: port | 0, family: "ipv6" });
+      return new SocketAddress({ address, port: port | 0 });
+    } catch {
+      return undefined;
+    }
+  }
+}
+
+const familyName = (sa) => (sa.family === "ipv4" ? "IPv4" : "IPv6");
+
+function toSocketAddress(value, name, family) {
+  if (SocketAddress.isSocketAddress(value)) return value;
+  validateString(value, name);
+  validateString(family, "family");
+  return new SocketAddress({ address: value, family });
+}
+
+const kRules = Symbol("kRules");
+
+export class BlockList {
+  constructor() {
+    this[kRules] = [];  /* newest first, as Node lists them */
+  }
+
+  static isBlockList(value) {
+    return value?.[kRules] !== undefined;
+  }
+
+  [kInspect](depth, options, inspect) {
+    if (depth < 0) return this;
+    const opts = { ...options, depth: options.depth == null ? null : options.depth - 1 };
+    return "BlockList " + inspect({ rules: this.rules }, opts);
+  }
+
+  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 });
+  }
+
+  addRange(start, end, family = "ipv4") {
+    const from = toSocketAddress(start, "start", family);
+    const to = toSocketAddress(end, "end", family);
+    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({
+      text: "Range: " + familyName(from) + " " + from.address + "-" + to.address,
+      test: (x) => compare(x, a) >= 0 && compare(x, b) <= 0,
+    });
+  }
+
+  addSubnet(network, prefix, family = "ipv4") {
+    const sa = toSocketAddress(network, "network", family);
+    const max = sa.family === "ipv4" ? 32 : 128;
+    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) });
+  }
+
+  check(address, family = "ipv4") {
+    let sa;
+    if (SocketAddress.isSocketAddress(address)) sa = address;
+    else {
+      validateString(address, "address");
+      validateString(family, "family");
+      try {
+        sa = new SocketAddress({ address, family });
+      } catch {
+        return false;
+      }
+    }
+    const bytes = sa[kDetail].bytes;
+    return this[kRules].some((rule) => rule.test(bytes));
+  }
+
+  get rules() {
+    return this[kRules].map((rule) => rule.text);
+  }
+
+  toJSON() {
+    return this.rules;
+  }
+}