rezo 1.0.41 → 1.0.43

package/dist/internal/agents/https-proxy.cjs

@@ -0,0 +1,176 @@
+const net = require("node:net");
+const tls = require("node:tls");
+const { Agent } = require('./base.cjs');
+function omit(obj, ...keys) {
+  const ret = {};
+  for (const key in obj) {
+    if (!keys.includes(key)) {
+      ret[key] = obj[key];
+    }
+  }
+  return ret;
+}
+function setServernameFromNonIpHost(options) {
+  if (options.servername === undefined && options.host && !net.isIP(options.host)) {
+    return { ...options, servername: options.host };
+  }
+  return options;
+}
+function parseProxyResponse(socket) {
+  return new Promise((resolve, reject) => {
+    let buffersLength = 0;
+    const buffers = [];
+    function read() {
+      const b = socket.read();
+      if (b)
+        ondata(b);
+      else
+        socket.once("readable", read);
+    }
+    function cleanup() {
+      socket.removeListener("end", onend);
+      socket.removeListener("error", onerror);
+      socket.removeListener("readable", read);
+    }
+    function onend() {
+      cleanup();
+      reject(new Error("Proxy connection ended before receiving CONNECT response"));
+    }
+    function onerror(err) {
+      cleanup();
+      reject(err);
+    }
+    function ondata(b) {
+      buffers.push(b);
+      buffersLength += b.length;
+      const buffered = Buffer.concat(buffers, buffersLength);
+      const endOfHeaders = buffered.indexOf(`\r
+\r
+`);
+      if (endOfHeaders === -1) {
+        read();
+        return;
+      }
+      const headerParts = buffered.slice(0, endOfHeaders).toString("ascii").split(`\r
+`);
+      const firstLine = headerParts.shift();
+      if (!firstLine) {
+        socket.destroy();
+        return reject(new Error("No header received from proxy CONNECT response"));
+      }
+      const firstLineParts = firstLine.split(" ");
+      const statusCode = +firstLineParts[1];
+      const statusText = firstLineParts.slice(2).join(" ");
+      const headers = {};
+      for (const header of headerParts) {
+        if (!header)
+          continue;
+        const firstColon = header.indexOf(":");
+        if (firstColon === -1) {
+          socket.destroy();
+          return reject(new Error(`Invalid header from proxy CONNECT response: "${header}"`));
+        }
+        const key = header.slice(0, firstColon).toLowerCase();
+        const value = header.slice(firstColon + 1).trimStart();
+        const current = headers[key];
+        if (typeof current === "string") {
+          headers[key] = [current, value];
+        } else if (Array.isArray(current)) {
+          current.push(value);
+        } else {
+          headers[key] = value;
+        }
+      }
+      cleanup();
+      resolve({
+        connect: { statusCode, statusText, headers },
+        buffered
+      });
+    }
+    socket.on("error", onerror);
+    socket.on("end", onend);
+    read();
+  });
+}
+function resume(socket) {
+  socket.resume();
+}
+
+class HttpsProxyAgent extends Agent {
+  static protocols = ["http", "https"];
+  proxy;
+  proxyHeaders;
+  connectOpts;
+  constructor(proxy, opts) {
+    super(opts);
+    this.proxy = typeof proxy === "string" ? new URL(proxy) : proxy;
+    this.proxyHeaders = opts?.headers ?? {};
+    const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, "");
+    const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === "https:" ? 443 : 80;
+    this.connectOpts = {
+      ALPNProtocols: ["http/1.1"],
+      ...opts ? omit(opts, "headers") : {},
+      host,
+      port
+    };
+  }
+  async connect(req, opts) {
+    const { proxy } = this;
+    if (!opts.host) {
+      throw new TypeError('No "host" provided');
+    }
+    let socket;
+    if (proxy.protocol === "https:") {
+      socket = tls.connect(setServernameFromNonIpHost(this.connectOpts));
+    } else {
+      socket = net.connect(this.connectOpts);
+    }
+    const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : { ...this.proxyHeaders };
+    const host = net.isIPv6(opts.host) ? `[${opts.host}]` : opts.host;
+    let payload = `CONNECT ${host}:${opts.port} HTTP/1.1\r
+`;
+    if (proxy.username || proxy.password) {
+      const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
+      headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`;
+    }
+    headers["Host"] = `${host}:${opts.port}`;
+    if (!headers["Proxy-Connection"]) {
+      headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close";
+    }
+    for (const name of Object.keys(headers)) {
+      payload += `${name}: ${headers[name]}\r
+`;
+    }
+    const proxyResponsePromise = parseProxyResponse(socket);
+    socket.write(`${payload}\r
+`);
+    const { connect, buffered } = await proxyResponsePromise;
+    req.emit("proxyConnect", connect);
+    this.emit("proxyConnect", connect, req);
+    if (connect.statusCode === 200) {
+      req.once("socket", resume);
+      if (opts.secureEndpoint) {
+        const tlsOpts = {
+          ...omit(setServernameFromNonIpHost(opts), "host", "path", "port"),
+          socket
+        };
+        return tls.connect(tlsOpts);
+      }
+      return socket;
+    }
+    socket.destroy();
+    const fakeSocket = new net.Socket({ writable: false });
+    fakeSocket.readable = true;
+    req.once("socket", (s) => {
+      if (s.listenerCount("data") > 0) {
+        s.push(buffered);
+        s.push(null);
+      }
+    });
+    return fakeSocket;
+  }
+}
+
+exports.HttpsProxyAgent = HttpsProxyAgent;
+exports.default = HttpsProxyAgent;
+module.exports = Object.assign(HttpsProxyAgent, exports);

package/dist/internal/agents/https-proxy.js

@@ -0,0 +1,173 @@
+import * as net from "node:net";
+import * as tls from "node:tls";
+import { Agent } from './base.js';
+function omit(obj, ...keys) {
+  const ret = {};
+  for (const key in obj) {
+    if (!keys.includes(key)) {
+      ret[key] = obj[key];
+    }
+  }
+  return ret;
+}
+function setServernameFromNonIpHost(options) {
+  if (options.servername === undefined && options.host && !net.isIP(options.host)) {
+    return { ...options, servername: options.host };
+  }
+  return options;
+}
+function parseProxyResponse(socket) {
+  return new Promise((resolve, reject) => {
+    let buffersLength = 0;
+    const buffers = [];
+    function read() {
+      const b = socket.read();
+      if (b)
+        ondata(b);
+      else
+        socket.once("readable", read);
+    }
+    function cleanup() {
+      socket.removeListener("end", onend);
+      socket.removeListener("error", onerror);
+      socket.removeListener("readable", read);
+    }
+    function onend() {
+      cleanup();
+      reject(new Error("Proxy connection ended before receiving CONNECT response"));
+    }
+    function onerror(err) {
+      cleanup();
+      reject(err);
+    }
+    function ondata(b) {
+      buffers.push(b);
+      buffersLength += b.length;
+      const buffered = Buffer.concat(buffers, buffersLength);
+      const endOfHeaders = buffered.indexOf(`\r
+\r
+`);
+      if (endOfHeaders === -1) {
+        read();
+        return;
+      }
+      const headerParts = buffered.slice(0, endOfHeaders).toString("ascii").split(`\r
+`);
+      const firstLine = headerParts.shift();
+      if (!firstLine) {
+        socket.destroy();
+        return reject(new Error("No header received from proxy CONNECT response"));
+      }
+      const firstLineParts = firstLine.split(" ");
+      const statusCode = +firstLineParts[1];
+      const statusText = firstLineParts.slice(2).join(" ");
+      const headers = {};
+      for (const header of headerParts) {
+        if (!header)
+          continue;
+        const firstColon = header.indexOf(":");
+        if (firstColon === -1) {
+          socket.destroy();
+          return reject(new Error(`Invalid header from proxy CONNECT response: "${header}"`));
+        }
+        const key = header.slice(0, firstColon).toLowerCase();
+        const value = header.slice(firstColon + 1).trimStart();
+        const current = headers[key];
+        if (typeof current === "string") {
+          headers[key] = [current, value];
+        } else if (Array.isArray(current)) {
+          current.push(value);
+        } else {
+          headers[key] = value;
+        }
+      }
+      cleanup();
+      resolve({
+        connect: { statusCode, statusText, headers },
+        buffered
+      });
+    }
+    socket.on("error", onerror);
+    socket.on("end", onend);
+    read();
+  });
+}
+function resume(socket) {
+  socket.resume();
+}
+
+export class HttpsProxyAgent extends Agent {
+  static protocols = ["http", "https"];
+  proxy;
+  proxyHeaders;
+  connectOpts;
+  constructor(proxy, opts) {
+    super(opts);
+    this.proxy = typeof proxy === "string" ? new URL(proxy) : proxy;
+    this.proxyHeaders = opts?.headers ?? {};
+    const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, "");
+    const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === "https:" ? 443 : 80;
+    this.connectOpts = {
+      ALPNProtocols: ["http/1.1"],
+      ...opts ? omit(opts, "headers") : {},
+      host,
+      port
+    };
+  }
+  async connect(req, opts) {
+    const { proxy } = this;
+    if (!opts.host) {
+      throw new TypeError('No "host" provided');
+    }
+    let socket;
+    if (proxy.protocol === "https:") {
+      socket = tls.connect(setServernameFromNonIpHost(this.connectOpts));
+    } else {
+      socket = net.connect(this.connectOpts);
+    }
+    const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : { ...this.proxyHeaders };
+    const host = net.isIPv6(opts.host) ? `[${opts.host}]` : opts.host;
+    let payload = `CONNECT ${host}:${opts.port} HTTP/1.1\r
+`;
+    if (proxy.username || proxy.password) {
+      const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
+      headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`;
+    }
+    headers["Host"] = `${host}:${opts.port}`;
+    if (!headers["Proxy-Connection"]) {
+      headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close";
+    }
+    for (const name of Object.keys(headers)) {
+      payload += `${name}: ${headers[name]}\r
+`;
+    }
+    const proxyResponsePromise = parseProxyResponse(socket);
+    socket.write(`${payload}\r
+`);
+    const { connect, buffered } = await proxyResponsePromise;
+    req.emit("proxyConnect", connect);
+    this.emit("proxyConnect", connect, req);
+    if (connect.statusCode === 200) {
+      req.once("socket", resume);
+      if (opts.secureEndpoint) {
+        const tlsOpts = {
+          ...omit(setServernameFromNonIpHost(opts), "host", "path", "port"),
+          socket
+        };
+        return tls.connect(tlsOpts);
+      }
+      return socket;
+    }
+    socket.destroy();
+    const fakeSocket = new net.Socket({ writable: false });
+    fakeSocket.readable = true;
+    req.once("socket", (s) => {
+      if (s.listenerCount("data") > 0) {
+        s.push(buffered);
+        s.push(null);
+      }
+    });
+    return fakeSocket;
+  }
+}
+export default HttpsProxyAgent;

package/dist/internal/agents/index.cjs

@@ -0,0 +1,10 @@
+const _mod_7qp1aa = require('./base.cjs');
+exports.Agent = _mod_7qp1aa.Agent;;
+const _mod_p65m0p = require('./http-proxy.cjs');
+exports.HttpProxyAgent = _mod_p65m0p.HttpProxyAgent;;
+const _mod_vvhz9m = require('./https-proxy.cjs');
+exports.HttpsProxyAgent = _mod_vvhz9m.HttpsProxyAgent;;
+const _mod_jsl1v1 = require('./socks-proxy.cjs');
+exports.SocksProxyAgent = _mod_jsl1v1.SocksProxyAgent;;
+const _mod_xeq0c5 = require('./socks-client.cjs');
+exports.SocksClient = _mod_xeq0c5.SocksClient;;

package/dist/internal/agents/index.js

@@ -0,0 +1,5 @@
+export { Agent } from './base.js';
+export { HttpProxyAgent } from './http-proxy.js';
+export { HttpsProxyAgent } from './https-proxy.js';
+export { SocksProxyAgent } from './socks-proxy.js';
+export { SocksClient } from './socks-client.js';