@fuman/net 0.0.1

package/LICENSE

@@ -0,0 +1,8 @@
+Copyright 2024 alina sireneva
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

package/errors.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class ConnectionClosedError extends Error {
+  constructor(message) {
+    super(`Connection closed${message != null ? `: ${message}` : ""}`);
+  }
+}
+class ListenerClosedError extends Error {
+  constructor() {
+    super("Listener closed");
+  }
+}
+exports.ConnectionClosedError = ConnectionClosedError;
+exports.ListenerClosedError = ListenerClosedError;

package/errors.d.ts

@@ -0,0 +1,6 @@
+export declare class ConnectionClosedError extends Error {
+    constructor(message?: string);
+}
+export declare class ListenerClosedError extends Error {
+    constructor();
+}

package/errors.js

@@ -0,0 +1,14 @@
+class ConnectionClosedError extends Error {
+  constructor(message) {
+    super(`Connection closed${message != null ? `: ${message}` : ""}`);
+  }
+}
+class ListenerClosedError extends Error {
+  constructor() {
+    super("Listener closed");
+  }
+}
+export {
+  ConnectionClosedError,
+  ListenerClosedError
+};

package/fake.cjs

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const io = require("@fuman/io");
+const utils = require("@fuman/utils");
+const errors = require("./errors.cjs");
+class FakeConnection {
+  constructor(address) {
+    this.address = address;
+  }
+  rx = io.Bytes.alloc();
+  tx = io.Bytes.alloc();
+  closed = false;
+  cv = new utils.ConditionVariable();
+  get localAddress() {
+    return this.address;
+  }
+  get remoteAddress() {
+    return this.address;
+  }
+  close() {
+    this.closed = true;
+    this.cv.notify();
+  }
+  async read(into) {
+    if (this.closed) throw new errors.ConnectionClosedError();
+    if (!this.rx.available) await this.cv.wait();
+    if (this.closed) throw new errors.ConnectionClosedError();
+    return this.rx.read(into);
+  }
+  async write(bytes) {
+    await this.tx.write(bytes);
+    this.cv.notify();
+  }
+  writeIntoRx(bytes) {
+    this.rx.writeSync(bytes.length).set(bytes);
+    this.cv.notify();
+  }
+  getTx() {
+    return this.tx.result();
+  }
+}
+exports.FakeConnection = FakeConnection;

package/fake.d.ts

@@ -0,0 +1,16 @@
+import { IConnection } from './types.js';
+export declare class FakeConnection<Address = string> implements IConnection<Address, Address> {
+    readonly address: Address;
+    constructor(address: Address);
+    private rx;
+    private tx;
+    private closed;
+    private cv;
+    get localAddress(): Address;
+    get remoteAddress(): Address;
+    close(): void;
+    read(into: Uint8Array): Promise<number>;
+    write(bytes: Uint8Array): Promise<void>;
+    writeIntoRx(bytes: Uint8Array): void;
+    getTx(): Uint8Array;
+}

package/fake.js

@@ -0,0 +1,42 @@
+import { Bytes } from "@fuman/io";
+import { ConditionVariable } from "@fuman/utils";
+import { ConnectionClosedError } from "./errors.js";
+class FakeConnection {
+  constructor(address) {
+    this.address = address;
+  }
+  rx = Bytes.alloc();
+  tx = Bytes.alloc();
+  closed = false;
+  cv = new ConditionVariable();
+  get localAddress() {
+    return this.address;
+  }
+  get remoteAddress() {
+    return this.address;
+  }
+  close() {
+    this.closed = true;
+    this.cv.notify();
+  }
+  async read(into) {
+    if (this.closed) throw new ConnectionClosedError();
+    if (!this.rx.available) await this.cv.wait();
+    if (this.closed) throw new ConnectionClosedError();
+    return this.rx.read(into);
+  }
+  async write(bytes) {
+    await this.tx.write(bytes);
+    this.cv.notify();
+  }
+  writeIntoRx(bytes) {
+    this.rx.writeSync(bytes.length).set(bytes);
+    this.cv.notify();
+  }
+  getTx() {
+    return this.tx.result();
+  }
+}
+export {
+  FakeConnection
+};

package/index.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const errors = require("./errors.cjs");
+const fake = require("./fake.cjs");
+const reconnection = require("./reconnection.cjs");
+const websocket = require("./websocket.cjs");
+const bundle = require("./ip/bundle.cjs");
+const connect = require("./proxy/http/connect.cjs");
+const types = require("./proxy/http/types.cjs");
+const index = require("./proxy/http/index.cjs");
+const connect$1 = require("./proxy/socks/connect.cjs");
+const types$1 = require("./proxy/socks/types.cjs");
+const index$1 = require("./proxy/socks/index.cjs");
+exports.ConnectionClosedError = errors.ConnectionClosedError;
+exports.ListenerClosedError = errors.ListenerClosedError;
+exports.FakeConnection = fake.FakeConnection;
+exports.PersistentConnection = reconnection.PersistentConnection;
+exports.defaultReconnectionStrategy = reconnection.defaultReconnectionStrategy;
+exports.WebSocketConnection = websocket.WebSocketConnection;
+exports.WebSocketConnectionClosedError = websocket.WebSocketConnectionClosedError;
+exports.WebSocketConnectionFramed = websocket.WebSocketConnectionFramed;
+exports.connectWs = websocket.connectWs;
+exports.connectWsFramed = websocket.connectWsFramed;
+exports.ip = bundle;
+exports.performHttpProxyHandshake = connect.performHttpProxyHandshake;
+exports.HttpProxyConnectionError = types.HttpProxyConnectionError;
+exports.withHttpProxy = index.withHttpProxy;
+exports.performSocksHandshake = connect$1.performSocksHandshake;
+exports.SocksProxyConnectionError = types$1.SocksProxyConnectionError;
+exports.withSocksProxy = index$1.withSocksProxy;

package/index.d.ts

@@ -0,0 +1,7 @@
+export * from './errors.js';
+export * from './fake.js';
+export * from './ip/index.js';
+export * from './proxy/index.js';
+export * from './reconnection.js';
+export * from './types.js';
+export * from './websocket.js';

package/index.js

@@ -0,0 +1,30 @@
+import { ConnectionClosedError, ListenerClosedError } from "./errors.js";
+import { FakeConnection } from "./fake.js";
+import { PersistentConnection, defaultReconnectionStrategy } from "./reconnection.js";
+import { WebSocketConnection, WebSocketConnectionClosedError, WebSocketConnectionFramed, connectWs, connectWsFramed } from "./websocket.js";
+import * as bundle from "./ip/bundle.js";
+import { performHttpProxyHandshake } from "./proxy/http/connect.js";
+import { HttpProxyConnectionError } from "./proxy/http/types.js";
+import { withHttpProxy } from "./proxy/http/index.js";
+import { performSocksHandshake } from "./proxy/socks/connect.js";
+import { SocksProxyConnectionError } from "./proxy/socks/types.js";
+import { withSocksProxy } from "./proxy/socks/index.js";
+export {
+  ConnectionClosedError,
+  FakeConnection,
+  HttpProxyConnectionError,
+  ListenerClosedError,
+  PersistentConnection,
+  SocksProxyConnectionError,
+  WebSocketConnection,
+  WebSocketConnectionClosedError,
+  WebSocketConnectionFramed,
+  connectWs,
+  connectWsFramed,
+  defaultReconnectionStrategy,
+  bundle as ip,
+  performHttpProxyHandshake,
+  performSocksHandshake,
+  withHttpProxy,
+  withSocksProxy
+};

package/ip/bundle.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const parse = require("./parse.cjs");
+const v4 = require("./v4.cjs");
+const v6 = require("./v6.cjs");
+exports.parse = parse.parse;
+exports.parseWithPort = parse.parseWithPort;
+exports.stringify = parse.stringify;
+exports.stringifyWithPort = parse.stringifyWithPort;
+exports.normalizeV4 = v4.normalizeV4;
+exports.parseV4 = v4.parseV4;
+exports.stringifyV4 = v4.stringifyV4;
+exports.expandV6 = v6.expandV6;
+exports.fromBytesV6 = v6.fromBytesV6;
+exports.parseV6 = v6.parseV6;
+exports.readV6 = v6.readV6;
+exports.stringifyV6 = v6.stringifyV6;
+exports.toBytesV6 = v6.toBytesV6;
+exports.writeV6 = v6.writeV6;

package/ip/bundle.d.ts

@@ -0,0 +1,3 @@
+export * from './parse.js';
+export * from './v4.js';
+export * from './v6.js';

package/ip/bundle.js

@@ -0,0 +1,19 @@
+import { parse, parseWithPort, stringify, stringifyWithPort } from "./parse.js";
+import { normalizeV4, parseV4, stringifyV4 } from "./v4.js";
+import { expandV6, fromBytesV6, parseV6, readV6, stringifyV6, toBytesV6, writeV6 } from "./v6.js";
+export {
+  expandV6,
+  fromBytesV6,
+  normalizeV4,
+  parse,
+  parseV4,
+  parseV6,
+  parseWithPort,
+  readV6,
+  stringify,
+  stringifyV4,
+  stringifyV6,
+  stringifyWithPort,
+  toBytesV6,
+  writeV6
+};

package/ip/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Utilities for parsing and manipulating IP addresses.
+ *
+ * @module
+ */
+import * as ip from './bundle.js';
+export * from './types.js';
+export { ip };

package/ip/parse.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const v4 = require("./v4.cjs");
+const v6 = require("./v6.cjs");
+function parse(ip) {
+  if (ip.includes(":")) {
+    return v6.parseV6(ip);
+  } else {
+    return v4.parseV4(ip);
+  }
+}
+function parseWithPort(ip) {
+  const lastColon = ip.lastIndexOf(":");
+  const addr = ip.slice(0, lastColon);
+  const port = Number(ip.slice(lastColon + 1));
+  if (Number.isNaN(port) || port < 0 || port > 65535) {
+    throw new Error(`Invalid port: ${ip} (in ${ip})`);
+  }
+  return [parse(addr), port];
+}
+function stringify(parsed) {
+  if (parsed.type === "ipv4") {
+    return v4.stringifyV4(parsed);
+  } else {
+    return v6.stringifyV6(parsed);
+  }
+}
+function stringifyWithPort(parsed, port) {
+  return `${stringify(parsed)}:${port}`;
+}
+exports.parse = parse;
+exports.parseWithPort = parseWithPort;
+exports.stringify = stringify;
+exports.stringifyWithPort = stringifyWithPort;

package/ip/parse.d.ts

@@ -0,0 +1,5 @@
+import { Ipv4Address, Ipv6Address } from './types.js';
+export declare function parse(ip: string): Ipv4Address | Ipv6Address;
+export declare function parseWithPort(ip: string): [Ipv4Address | Ipv6Address, number];
+export declare function stringify(parsed: Ipv4Address | Ipv6Address): string;
+export declare function stringifyWithPort(parsed: Ipv4Address | Ipv6Address, port: number): string;

package/ip/parse.js

@@ -0,0 +1,34 @@
+import { parseV4, stringifyV4 } from "./v4.js";
+import { parseV6, stringifyV6 } from "./v6.js";
+function parse(ip) {
+  if (ip.includes(":")) {
+    return parseV6(ip);
+  } else {
+    return parseV4(ip);
+  }
+}
+function parseWithPort(ip) {
+  const lastColon = ip.lastIndexOf(":");
+  const addr = ip.slice(0, lastColon);
+  const port = Number(ip.slice(lastColon + 1));
+  if (Number.isNaN(port) || port < 0 || port > 65535) {
+    throw new Error(`Invalid port: ${ip} (in ${ip})`);
+  }
+  return [parse(addr), port];
+}
+function stringify(parsed) {
+  if (parsed.type === "ipv4") {
+    return stringifyV4(parsed);
+  } else {
+    return stringifyV6(parsed);
+  }
+}
+function stringifyWithPort(parsed, port) {
+  return `${stringify(parsed)}:${port}`;
+}
+export {
+  parse,
+  parseWithPort,
+  stringify,
+  stringifyWithPort
+};

package/ip/types.d.ts

@@ -0,0 +1,10 @@
+export interface Ipv4Address {
+    type: 'ipv4';
+    parts: Uint8Array;
+}
+export interface Ipv6Address {
+    type: 'ipv6';
+    parts: Uint16Array;
+    zoneId?: string;
+}
+export type IpAddress = Ipv4Address | Ipv6Address;

package/ip/v4.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/ip/v4.cjs

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+function parseV4(input) {
+  const parts = utils.u8.alloc(4);
+  const octets = input.split(".");
+  const octetsCount = octets.length;
+  if (octetsCount === 1) {
+    const num = Number(octets[0]);
+    if (Number.isNaN(num) || num < 0 || num > 4294967295) {
+      throw new Error(`Invalid IPv4 address: ${input}`);
+    }
+    parts[0] = num >> 24 & 255;
+    parts[1] = num >> 16 & 255;
+    parts[2] = num >> 8 & 255;
+    parts[3] = num & 255;
+    return {
+      type: "ipv4",
+      parts
+    };
+  }
+  if (octetsCount > 4) {
+    throw new Error(`Invalid IPv4 address: ${input}`);
+  }
+  let pos = 0;
+  for (let i = 0; i < octetsCount; i++) {
+    const part = Number(octets[i]);
+    if (Number.isNaN(part) || part < 0 || part > 255) {
+      throw new Error(`Invalid IPv4 address: ${input}`);
+    }
+    parts[pos] = part;
+    if (octetsCount === 2 && pos === 0) {
+      pos += 2;
+    } else if (octetsCount === 3 && pos === 1) {
+      pos += 1;
+    }
+    pos += 1;
+  }
+  return {
+    type: "ipv4",
+    parts
+  };
+}
+function stringifyV4(ip) {
+  if (ip.parts.length !== 4) {
+    throw new Error("Invalid IPv4 address");
+  }
+  return ip.parts.join(".");
+}
+function normalizeV4(input) {
+  return stringifyV4(parseV4(input));
+}
+exports.normalizeV4 = normalizeV4;
+exports.parseV4 = parseV4;
+exports.stringifyV4 = stringifyV4;

package/ip/v4.d.ts

@@ -0,0 +1,4 @@
+import { Ipv4Address } from './types.js';
+export declare function parseV4(input: string): Ipv4Address;
+export declare function stringifyV4(ip: Ipv4Address): string;
+export declare function normalizeV4(input: string): string;

package/ip/v4.js

@@ -0,0 +1,55 @@
+import { u8 } from "@fuman/utils";
+function parseV4(input) {
+  const parts = u8.alloc(4);
+  const octets = input.split(".");
+  const octetsCount = octets.length;
+  if (octetsCount === 1) {
+    const num = Number(octets[0]);
+    if (Number.isNaN(num) || num < 0 || num > 4294967295) {
+      throw new Error(`Invalid IPv4 address: ${input}`);
+    }
+    parts[0] = num >> 24 & 255;
+    parts[1] = num >> 16 & 255;
+    parts[2] = num >> 8 & 255;
+    parts[3] = num & 255;
+    return {
+      type: "ipv4",
+      parts
+    };
+  }
+  if (octetsCount > 4) {
+    throw new Error(`Invalid IPv4 address: ${input}`);
+  }
+  let pos = 0;
+  for (let i = 0; i < octetsCount; i++) {
+    const part = Number(octets[i]);
+    if (Number.isNaN(part) || part < 0 || part > 255) {
+      throw new Error(`Invalid IPv4 address: ${input}`);
+    }
+    parts[pos] = part;
+    if (octetsCount === 2 && pos === 0) {
+      pos += 2;
+    } else if (octetsCount === 3 && pos === 1) {
+      pos += 1;
+    }
+    pos += 1;
+  }
+  return {
+    type: "ipv4",
+    parts
+  };
+}
+function stringifyV4(ip) {
+  if (ip.parts.length !== 4) {
+    throw new Error("Invalid IPv4 address");
+  }
+  return ip.parts.join(".");
+}
+function normalizeV4(input) {
+  return stringifyV4(parseV4(input));
+}
+export {
+  normalizeV4,
+  parseV4,
+  stringifyV4
+};

package/ip/v6.bench.d.ts

@@ -0,0 +1 @@
+export {};