@fuman/net 0.0.1

package/proxy/http/types.d.ts

@@ -0,0 +1,32 @@
+/**
+ * An error has occurred while connecting to an HTTP(s) proxy
+ */
+export declare class HttpProxyConnectionError extends Error {
+    readonly proxy: HttpProxySettings;
+    constructor(proxy: HttpProxySettings, message: string);
+}
+/**
+ * HTTP(s) proxy settings
+ */
+export interface HttpProxySettings {
+    /**
+     * Host or IP of the proxy (e.g. `proxy.example.com`, `1.2.3.4`)
+     */
+    host: string;
+    /**
+     * Port of the proxy (e.g. `8888`)
+     */
+    port: number;
+    /**
+     * Proxy authorization username, if needed
+     */
+    user?: string;
+    /**
+     * Proxy authorization password, if needed
+     */
+    password?: string;
+    /**
+     * Proxy connection headers, if needed
+     */
+    headers?: Record<string, string>;
+}

package/proxy/http/types.js

@@ -0,0 +1,10 @@
+class HttpProxyConnectionError extends Error {
+  proxy;
+  constructor(proxy, message) {
+    super(`Error while connecting to ${proxy.host}:${proxy.port}: ${message}`);
+    this.proxy = proxy;
+  }
+}
+export {
+  HttpProxyConnectionError
+};

package/proxy/index.d.ts

@@ -0,0 +1,2 @@
+export * from './http/index.js';
+export * from './socks/index.js';

package/proxy/socks/_protocol.cjs

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const io = require("@fuman/io");
+const utils = require("@fuman/utils");
+const parse = require("../../ip/parse.cjs");
+const v6 = require("../../ip/v6.cjs");
+const SOCKS4_ERRORS = {
+  91: "Request rejected or failed",
+  92: "Request failed because client is not running identd",
+  93: "Request failed because client's identd could not confirm the user ID in the request"
+};
+const SOCKS5_ERRORS = {
+  1: "General failure",
+  2: "Connection not allowed by ruleset",
+  3: "Network unreachable",
+  4: "Host unreachable",
+  5: "Connection refused by destination host",
+  6: "TTL expired",
+  7: "Command not supported / protocol error",
+  8: "Address type not supported"
+};
+function buildSocks4Connect(dest, username = "") {
+  let addr;
+  try {
+    addr = parse.parse(dest.address);
+  } catch {
+  }
+  let isHostname = false;
+  if (!addr) {
+    isHostname = true;
+    addr = { type: "ipv4", parts: utils.u8.allocWith([0, 0, 0, 42]) };
+  } else if (addr.type !== "ipv4") {
+    throw new TypeError("SOCKS4 only supports IPv4");
+  }
+  const hostnameLength = isHostname ? utils.utf8.encodedLength(dest.address) + 1 : 0;
+  const userIdLength = utils.utf8.encodedLength(username);
+  const buf = io.Bytes.alloc(8 + userIdLength + hostnameLength);
+  io.write.uint8(buf, 4);
+  io.write.uint8(buf, 1);
+  io.write.uint16be(buf, dest.port);
+  io.write.bytes(buf, addr.parts);
+  io.write.cUtf8String(buf, username);
+  if (isHostname) {
+    io.write.cUtf8String(buf, dest.address);
+  }
+  return buf.result();
+}
+function buildSocks5Greeting(authAvailable) {
+  const buf = utils.u8.alloc(authAvailable ? 4 : 3);
+  buf[0] = 5;
+  if (authAvailable) {
+    buf[1] = 2;
+    buf[2] = 0;
+    buf[3] = 2;
+  } else {
+    buf[1] = 1;
+    buf[2] = 0;
+  }
+  return buf;
+}
+function buildSocks5Auth(username, password) {
+  const usernameLen = utils.utf8.encodedLength(username);
+  const passwordLen = utils.utf8.encodedLength(password);
+  if (usernameLen > 255) {
+    throw new TypeError(`Too long username (${usernameLen} > 255)`);
+  }
+  if (passwordLen > 255) {
+    throw new TypeError(`Too long password (${passwordLen} > 255)`);
+  }
+  const buf = utils.u8.alloc(3 + usernameLen + passwordLen);
+  buf[0] = 1;
+  buf[1] = usernameLen;
+  utils.utf8.encoder.encodeInto(username, buf.subarray(2));
+  buf[2 + usernameLen] = passwordLen;
+  utils.utf8.encoder.encodeInto(password, buf.subarray(3 + usernameLen));
+  return buf;
+}
+function buildSocks5Connect(dest) {
+  let addr;
+  try {
+    addr = parse.parse(dest.address);
+  } catch {
+  }
+  const buf = io.Bytes.alloc(32);
+  io.write.uint8(buf, 5);
+  io.write.uint8(buf, 1);
+  io.write.uint8(buf, 0);
+  if (!addr) {
+    const addrLen = utils.utf8.encodedLength(dest.address);
+    if (addrLen > 255) {
+      throw new TypeError(`Too long hostname (${addrLen} > 255)`);
+    }
+    io.write.uint8(buf, 3);
+    io.write.uint8(buf, addrLen);
+    io.write.utf8String(buf, dest.address);
+  } else if (addr.type === "ipv6") {
+    io.write.uint8(buf, 4);
+    v6.writeV6(addr, buf);
+  } else {
+    io.write.uint8(buf, 1);
+    io.write.bytes(buf, addr.parts);
+  }
+  io.write.uint16be(buf, dest.port);
+  return buf.result();
+}
+exports.SOCKS4_ERRORS = SOCKS4_ERRORS;
+exports.SOCKS5_ERRORS = SOCKS5_ERRORS;
+exports.buildSocks4Connect = buildSocks4Connect;
+exports.buildSocks5Auth = buildSocks5Auth;
+exports.buildSocks5Connect = buildSocks5Connect;
+exports.buildSocks5Greeting = buildSocks5Greeting;

package/proxy/socks/_protocol.d.ts

@@ -0,0 +1,7 @@
+import { TcpEndpoint } from '../../types.js';
+export declare const SOCKS4_ERRORS: Record<number, string>;
+export declare const SOCKS5_ERRORS: Record<number, string>;
+export declare function buildSocks4Connect(dest: TcpEndpoint, username?: string): Uint8Array;
+export declare function buildSocks5Greeting(authAvailable: boolean): Uint8Array;
+export declare function buildSocks5Auth(username: string, password: string): Uint8Array;
+export declare function buildSocks5Connect(dest: TcpEndpoint): Uint8Array;

package/proxy/socks/_protocol.js

@@ -0,0 +1,111 @@
+import { Bytes, write } from "@fuman/io";
+import { u8, utf8 } from "@fuman/utils";
+import { parse } from "../../ip/parse.js";
+import { writeV6 } from "../../ip/v6.js";
+const SOCKS4_ERRORS = {
+  91: "Request rejected or failed",
+  92: "Request failed because client is not running identd",
+  93: "Request failed because client's identd could not confirm the user ID in the request"
+};
+const SOCKS5_ERRORS = {
+  1: "General failure",
+  2: "Connection not allowed by ruleset",
+  3: "Network unreachable",
+  4: "Host unreachable",
+  5: "Connection refused by destination host",
+  6: "TTL expired",
+  7: "Command not supported / protocol error",
+  8: "Address type not supported"
+};
+function buildSocks4Connect(dest, username = "") {
+  let addr;
+  try {
+    addr = parse(dest.address);
+  } catch {
+  }
+  let isHostname = false;
+  if (!addr) {
+    isHostname = true;
+    addr = { type: "ipv4", parts: u8.allocWith([0, 0, 0, 42]) };
+  } else if (addr.type !== "ipv4") {
+    throw new TypeError("SOCKS4 only supports IPv4");
+  }
+  const hostnameLength = isHostname ? utf8.encodedLength(dest.address) + 1 : 0;
+  const userIdLength = utf8.encodedLength(username);
+  const buf = Bytes.alloc(8 + userIdLength + hostnameLength);
+  write.uint8(buf, 4);
+  write.uint8(buf, 1);
+  write.uint16be(buf, dest.port);
+  write.bytes(buf, addr.parts);
+  write.cUtf8String(buf, username);
+  if (isHostname) {
+    write.cUtf8String(buf, dest.address);
+  }
+  return buf.result();
+}
+function buildSocks5Greeting(authAvailable) {
+  const buf = u8.alloc(authAvailable ? 4 : 3);
+  buf[0] = 5;
+  if (authAvailable) {
+    buf[1] = 2;
+    buf[2] = 0;
+    buf[3] = 2;
+  } else {
+    buf[1] = 1;
+    buf[2] = 0;
+  }
+  return buf;
+}
+function buildSocks5Auth(username, password) {
+  const usernameLen = utf8.encodedLength(username);
+  const passwordLen = utf8.encodedLength(password);
+  if (usernameLen > 255) {
+    throw new TypeError(`Too long username (${usernameLen} > 255)`);
+  }
+  if (passwordLen > 255) {
+    throw new TypeError(`Too long password (${passwordLen} > 255)`);
+  }
+  const buf = u8.alloc(3 + usernameLen + passwordLen);
+  buf[0] = 1;
+  buf[1] = usernameLen;
+  utf8.encoder.encodeInto(username, buf.subarray(2));
+  buf[2 + usernameLen] = passwordLen;
+  utf8.encoder.encodeInto(password, buf.subarray(3 + usernameLen));
+  return buf;
+}
+function buildSocks5Connect(dest) {
+  let addr;
+  try {
+    addr = parse(dest.address);
+  } catch {
+  }
+  const buf = Bytes.alloc(32);
+  write.uint8(buf, 5);
+  write.uint8(buf, 1);
+  write.uint8(buf, 0);
+  if (!addr) {
+    const addrLen = utf8.encodedLength(dest.address);
+    if (addrLen > 255) {
+      throw new TypeError(`Too long hostname (${addrLen} > 255)`);
+    }
+    write.uint8(buf, 3);
+    write.uint8(buf, addrLen);
+    write.utf8String(buf, dest.address);
+  } else if (addr.type === "ipv6") {
+    write.uint8(buf, 4);
+    writeV6(addr, buf);
+  } else {
+    write.uint8(buf, 1);
+    write.bytes(buf, addr.parts);
+  }
+  write.uint16be(buf, dest.port);
+  return buf.result();
+}
+export {
+  SOCKS4_ERRORS,
+  SOCKS5_ERRORS,
+  buildSocks4Connect,
+  buildSocks5Auth,
+  buildSocks5Connect,
+  buildSocks5Greeting
+};

package/proxy/socks/connect.cjs

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const io = require("@fuman/io");
+const _protocol = require("./_protocol.cjs");
+const types = require("./types.cjs");
+async function connectV4(reader, writer, proxy, destination) {
+  await writer.write(_protocol.buildSocks4Connect(destination, proxy.user));
+  const response = await io.read.async.exactly(reader, 8);
+  if (response[0] !== 0) {
+    throw new types.SocksProxyConnectionError(proxy, `Unexpected response first byte: ${response[0]}`);
+  }
+  if (response[1] !== 90) {
+    const code = response[1];
+    throw new types.SocksProxyConnectionError(proxy, code in _protocol.SOCKS4_ERRORS ? _protocol.SOCKS4_ERRORS[code] : `Unknown error code: ${code}`);
+  }
+}
+async function connectV5(reader, writer, proxy, destination) {
+  await writer.write(_protocol.buildSocks5Greeting(proxy.user != null));
+  const greetingRes = await io.read.async.exactly(reader, 2);
+  if (greetingRes[0] !== 5) {
+    throw new types.SocksProxyConnectionError(proxy, `Unexpected response first byte: ${greetingRes[0]}`);
+  }
+  if (greetingRes[1] !== 0) {
+    if (greetingRes[1] === 2) {
+      if (proxy.user == null || proxy.password == null) {
+        throw new types.SocksProxyConnectionError(proxy, "Authentication is required, but not provided");
+      }
+      await writer.write(_protocol.buildSocks5Auth(proxy.user, proxy.password));
+      const authRes = await io.read.async.exactly(reader, 2);
+      if (authRes[0] !== 1) {
+        throw new types.SocksProxyConnectionError(proxy, `Invalid SOCKS auth version: ${authRes[0]}`);
+      }
+      if (authRes[1] !== 0) {
+        throw new types.SocksProxyConnectionError(proxy, `Unexpected SOCKS auth response, invalid auth? Code: ${authRes[1]}`);
+      }
+    } else {
+      throw new types.SocksProxyConnectionError(proxy, `Unsupported authentication method: ${greetingRes[1]}`);
+    }
+  }
+  await writer.write(_protocol.buildSocks5Connect(destination));
+  const response = await io.read.async.exactly(reader, 4);
+  if (response[0] !== 5) {
+    throw new types.SocksProxyConnectionError(proxy, `Unexpected response first byte: ${response[0]}`);
+  }
+  if (response[1] !== 0) {
+    const code = response[1];
+    throw new types.SocksProxyConnectionError(proxy, code in _protocol.SOCKS5_ERRORS ? _protocol.SOCKS5_ERRORS[code] : `Unknown error code: ${code}`);
+  }
+  switch (response[3]) {
+    case 0: {
+      await io.read.async.exactly(reader, 2);
+      break;
+    }
+    case 1: {
+      await io.read.async.exactly(reader, 6);
+      break;
+    }
+    case 4: {
+      await io.read.async.exactly(reader, 18);
+      break;
+    }
+    default:
+      throw new types.SocksProxyConnectionError(proxy, `Invalid BNDADDR type: ${response[3]}`);
+  }
+}
+async function performSocksHandshake(reader, writer, proxy, destination) {
+  if (proxy.version != null && proxy.version !== 4 && proxy.version !== 5) {
+    throw new types.SocksProxyConnectionError(
+      proxy,
+      `Invalid SOCKS version: ${proxy.version}`
+    );
+  }
+  if (proxy.version === 4) {
+    return connectV4(reader, writer, proxy, destination);
+  }
+  return connectV5(reader, writer, proxy, destination);
+}
+exports.performSocksHandshake = performSocksHandshake;

package/proxy/socks/connect.d.ts

@@ -0,0 +1,4 @@
+import { IReadable, IWritable } from '@fuman/io';
+import { TcpEndpoint } from '../../types.js';
+import { SocksProxySettings } from './types.js';
+export declare function performSocksHandshake(reader: IReadable, writer: IWritable, proxy: SocksProxySettings, destination: TcpEndpoint): Promise<void>;

package/proxy/socks/connect.js

@@ -0,0 +1,78 @@
+import { read } from "@fuman/io";
+import { buildSocks4Connect, SOCKS4_ERRORS, buildSocks5Greeting, buildSocks5Auth, buildSocks5Connect, SOCKS5_ERRORS } from "./_protocol.js";
+import { SocksProxyConnectionError } from "./types.js";
+async function connectV4(reader, writer, proxy, destination) {
+  await writer.write(buildSocks4Connect(destination, proxy.user));
+  const response = await read.async.exactly(reader, 8);
+  if (response[0] !== 0) {
+    throw new SocksProxyConnectionError(proxy, `Unexpected response first byte: ${response[0]}`);
+  }
+  if (response[1] !== 90) {
+    const code = response[1];
+    throw new SocksProxyConnectionError(proxy, code in SOCKS4_ERRORS ? SOCKS4_ERRORS[code] : `Unknown error code: ${code}`);
+  }
+}
+async function connectV5(reader, writer, proxy, destination) {
+  await writer.write(buildSocks5Greeting(proxy.user != null));
+  const greetingRes = await read.async.exactly(reader, 2);
+  if (greetingRes[0] !== 5) {
+    throw new SocksProxyConnectionError(proxy, `Unexpected response first byte: ${greetingRes[0]}`);
+  }
+  if (greetingRes[1] !== 0) {
+    if (greetingRes[1] === 2) {
+      if (proxy.user == null || proxy.password == null) {
+        throw new SocksProxyConnectionError(proxy, "Authentication is required, but not provided");
+      }
+      await writer.write(buildSocks5Auth(proxy.user, proxy.password));
+      const authRes = await read.async.exactly(reader, 2);
+      if (authRes[0] !== 1) {
+        throw new SocksProxyConnectionError(proxy, `Invalid SOCKS auth version: ${authRes[0]}`);
+      }
+      if (authRes[1] !== 0) {
+        throw new SocksProxyConnectionError(proxy, `Unexpected SOCKS auth response, invalid auth? Code: ${authRes[1]}`);
+      }
+    } else {
+      throw new SocksProxyConnectionError(proxy, `Unsupported authentication method: ${greetingRes[1]}`);
+    }
+  }
+  await writer.write(buildSocks5Connect(destination));
+  const response = await read.async.exactly(reader, 4);
+  if (response[0] !== 5) {
+    throw new SocksProxyConnectionError(proxy, `Unexpected response first byte: ${response[0]}`);
+  }
+  if (response[1] !== 0) {
+    const code = response[1];
+    throw new SocksProxyConnectionError(proxy, code in SOCKS5_ERRORS ? SOCKS5_ERRORS[code] : `Unknown error code: ${code}`);
+  }
+  switch (response[3]) {
+    case 0: {
+      await read.async.exactly(reader, 2);
+      break;
+    }
+    case 1: {
+      await read.async.exactly(reader, 6);
+      break;
+    }
+    case 4: {
+      await read.async.exactly(reader, 18);
+      break;
+    }
+    default:
+      throw new SocksProxyConnectionError(proxy, `Invalid BNDADDR type: ${response[3]}`);
+  }
+}
+async function performSocksHandshake(reader, writer, proxy, destination) {
+  if (proxy.version != null && proxy.version !== 4 && proxy.version !== 5) {
+    throw new SocksProxyConnectionError(
+      proxy,
+      `Invalid SOCKS version: ${proxy.version}`
+    );
+  }
+  if (proxy.version === 4) {
+    return connectV4(reader, writer, proxy, destination);
+  }
+  return connectV5(reader, writer, proxy, destination);
+}
+export {
+  performSocksHandshake
+};

package/proxy/socks/index.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const connect = require("./connect.cjs");
+function withSocksProxy(connect$1, proxy) {
+  return async (endpoint) => {
+    const conn = await connect$1({
+      address: proxy.host,
+      port: proxy.port
+    });
+    await connect.performSocksHandshake(conn, conn, proxy, endpoint);
+    return conn;
+  };
+}
+exports.performSocksHandshake = connect.performSocksHandshake;
+exports.withSocksProxy = withSocksProxy;

package/proxy/socks/index.d.ts

@@ -0,0 +1,5 @@
+import { ConnectFunction, ITcpConnection, TcpEndpoint } from '../../types.js';
+import { SocksProxySettings } from './types.js';
+export * from './connect.js';
+export * from './types.js';
+export declare function withSocksProxy<Connection extends ITcpConnection, Connect extends ConnectFunction<TcpEndpoint, Connection>>(connect: Connect, proxy: SocksProxySettings): Connect;

package/proxy/socks/index.js

@@ -0,0 +1,15 @@
+import { performSocksHandshake } from "./connect.js";
+function withSocksProxy(connect, proxy) {
+  return async (endpoint) => {
+    const conn = await connect({
+      address: proxy.host,
+      port: proxy.port
+    });
+    await performSocksHandshake(conn, conn, proxy, endpoint);
+    return conn;
+  };
+}
+export {
+  performSocksHandshake,
+  withSocksProxy
+};

package/proxy/socks/types.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class SocksProxyConnectionError extends Error {
+  proxy;
+  constructor(proxy, message) {
+    super(`Error while connecting to ${proxy.host}:${proxy.port}: ${message}`);
+    this.proxy = proxy;
+  }
+}
+exports.SocksProxyConnectionError = SocksProxyConnectionError;

package/proxy/socks/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Settings for a SOCKS4/5 proxy
+ */
+export interface SocksProxySettings {
+    /**
+     * Host or IP of the proxy (e.g. `proxy.example.com`, `1.2.3.4`)
+     */
+    host: string;
+    /**
+     * Port of the proxy (e.g. `8888`)
+     */
+    port: number;
+    /**
+     * Proxy authorization username, if needed
+     */
+    user?: string;
+    /**
+     * Proxy authorization password, if needed
+     */
+    password?: string;
+    /**
+     * Version of the SOCKS proxy (4 or 5)
+     *
+     * @default `5`
+     */
+    version?: 4 | 5;
+}
+/**
+ * An error has occurred while connecting to an SOCKS proxy
+ */
+export declare class SocksProxyConnectionError extends Error {
+    readonly proxy: SocksProxySettings;
+    constructor(proxy: SocksProxySettings, message: string);
+}

package/proxy/socks/types.js

@@ -0,0 +1,10 @@
+class SocksProxyConnectionError extends Error {
+  proxy;
+  constructor(proxy, message) {
+    super(`Error while connecting to ${proxy.host}:${proxy.port}: ${message}`);
+    this.proxy = proxy;
+  }
+}
+export {
+  SocksProxyConnectionError
+};

package/reconnection.cjs

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+const errors = require("./errors.cjs");
+const defaultReconnectionStrategy = ({ previousWait }) => {
+  if (previousWait === null) return 0;
+  if (previousWait === 0) return 1e3;
+  if (previousWait >= 5e3) return 5e3;
+  return Math.min(5e3, previousWait + 1e3);
+};
+function defaultOnError(err) {
+  return err instanceof errors.ConnectionClosedError ? "reconnect" : "close";
+}
+class PersistentConnection {
+  constructor(params) {
+    this.params = params;
+    this.#strategy = params.strategy ?? defaultReconnectionStrategy;
+    this.#connect = params.connect;
+    this.#onError = params.onError ?? defaultOnError;
+  }
+  #state = {
+    previousWait: null,
+    lastError: null,
+    consequentFails: 0
+  };
+  #connect;
+  #lastAddress;
+  #connection;
+  #connecting = false;
+  #strategy;
+  #onError;
+  // boolean represents whether the timer is clean
+  // true - resolved because timer is up
+  // false - resolved because .close()/.reconnect() was called
+  #sleep;
+  #closed;
+  get isConnected() {
+    return this.#connection !== void 0;
+  }
+  get isConnecting() {
+    return this.#connection === void 0 && this.#connecting;
+  }
+  get isWaiting() {
+    return this.#connection === void 0 && this.#lastAddress !== void 0 && !this.#connecting;
+  }
+  get connection() {
+    return this.#connection ?? null;
+  }
+  get state() {
+    return this.#state;
+  }
+  #resetState() {
+    this.#state.previousWait = null;
+    this.#state.lastError = null;
+    this.#state.consequentFails = 0;
+    this.#connecting = false;
+  }
+  async #loop() {
+    while (true) {
+      try {
+        this.#connecting = true;
+        this.#connection = await this.#connect(this.#lastAddress);
+        if (this.#closed) {
+          this.#closed.resolve();
+          break;
+        }
+        this.#resetState();
+        await this.params.onOpen?.(this.#connection);
+        this.#connection.close();
+        this.#connection = void 0;
+        break;
+      } catch (err) {
+        const oldConnection = this.#connection;
+        this.#connection = void 0;
+        await this.params.onClose?.();
+        if (this.#closed) {
+          this.#closed.resolve();
+          break;
+        }
+        const action = await this.#onError(err, oldConnection ?? null, this.#state);
+        if (action === "close") {
+          break;
+        }
+        const wait = action === "reconnect-now" ? 0 : this.#strategy(this.#state);
+        if (wait === false) {
+          break;
+        }
+        this.params.onWait?.(wait);
+        if (wait !== 0) {
+          this.#sleep = new utils.Deferred();
+          const timer = utils.timers.setTimeout(this.#sleep.resolve, wait, true);
+          const sleepResult = await this.#sleep.promise;
+          this.#sleep = void 0;
+          if (!sleepResult) {
+            utils.timers.clearTimeout(timer);
+            if (this.#closed != null) {
+              this.#closed.resolve();
+              break;
+            } else {
+              continue;
+            }
+          }
+        }
+        this.#state.previousWait = wait;
+        this.#state.consequentFails = 1;
+        continue;
+      }
+    }
+    this.#lastAddress = void 0;
+    this.#resetState();
+  }
+  connect(address) {
+    if (this.#lastAddress !== void 0 && this.#lastAddress !== address) {
+      throw new Error("Connection is already open to another address");
+    }
+    this.#closed = void 0;
+    this.#lastAddress = address;
+    void this.#loop();
+  }
+  /**
+   * @param force  Whether to close the existing connection if there is one
+   */
+  reconnect(force) {
+    if (this.#sleep) {
+      this.#sleep.resolve(false);
+    } else if (this.#connection && force) {
+      this.#connection.close();
+    }
+  }
+  async close() {
+    if (this.#closed) return this.#closed.promise;
+    if (this.#lastAddress == null) return;
+    this.#closed = new utils.Deferred();
+    if (this.#sleep) {
+      this.#sleep.resolve(false);
+    } else if (this.#connection) {
+      this.#connection.close();
+    } else if (this.#connecting) ;
+    return this.#closed.promise;
+  }
+  async changeTransport(connect) {
+    this.#connect = connect;
+    const addr = this.#lastAddress;
+    await this.close();
+    if (addr != null) {
+      this.connect(addr);
+    }
+  }
+}
+exports.PersistentConnection = PersistentConnection;
+exports.defaultReconnectionStrategy = defaultReconnectionStrategy;