react-native-nitro-net 0.2.0 → 0.3.1

package/lib/index.js

@@ -1,822 +1,12 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tls = exports.connect = exports.Server = exports.Socket = exports.BlockList = exports.SocketAddress = void 0;
-exports.createConnection = createConnection;
-exports.createServer = createServer;
-exports.isIP = isIP;
-exports.isIPv4 = isIPv4;
-exports.isIPv6 = isIPv6;
-exports.getDefaultAutoSelectFamily = getDefaultAutoSelectFamily;
-exports.setDefaultAutoSelectFamily = setDefaultAutoSelectFamily;
-exports.setVerbose = setVerbose;
-exports.initWithConfig = initWithConfig;
-const readable_stream_1 = require("readable-stream");
-const eventemitter3_1 = require("eventemitter3");
-const Driver_1 = require("./Driver");
-const Net_nitro_1 = require("./Net.nitro");
-const react_native_nitro_buffer_1 = require("react-native-nitro-buffer");
-// -----------------------------------------------------------------------------
-// Utils
-// -----------------------------------------------------------------------------
-function isIP(input) {
-    // Simple regex check
-    if (/^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/.test(input))
-        return 4;
-    // Basic IPv6 check allowing double colons
-    if (/^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/.test(input))
-        return 6;
-    if (/^((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?)::((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?)$/.test(input))
-        return 6;
-    return 0;
-}
-function isIPv4(input) {
-    return isIP(input) === 4;
-}
-function isIPv6(input) {
-    return isIP(input) === 6;
-}
-// -----------------------------------------------------------------------------
-// Global Configuration
-// -----------------------------------------------------------------------------
-let _autoSelectFamilyDefault = 4; // Node default is usually 4/6 independent, but we mock it.
-let _isVerbose = false;
-let _isInitialized = false;
-function debugLog(message) {
-    if (_isVerbose) {
-        console.log(`[NET DEBUG] ${message}`);
-    }
-}
-function setVerbose(enabled) {
-    _isVerbose = enabled;
-}
-function getDefaultAutoSelectFamily() {
-    return _autoSelectFamilyDefault;
-}
-function setDefaultAutoSelectFamily(family) {
-    if (family !== 4 && family !== 6)
-        throw new Error('Family must be 4 or 6');
-    _autoSelectFamilyDefault = family;
-}
-/**
- * Ensures that the network module is initialized.
- * If initWithConfig hasn't been called, it will be called with default options.
- */
-function ensureInitialized() {
-    if (!_isInitialized) {
-        initWithConfig({});
-    }
-}
-/**
- * Initialize the network module with custom configuration.
- * Must be called before any socket/server operations, or the config will be ignored.
- *
- * @param config Configuration options
- * @param config.workerThreads Number of worker threads (0 = use CPU core count)
- *
- * @example
- * ```ts
- * import { initWithConfig } from 'react-native-nitro-net';
- *
- * // Initialize with 4 worker threads
- * initWithConfig({ workerThreads: 4 });
- * ```
- */
-function initWithConfig(config) {
-    _isInitialized = true;
-    Driver_1.Driver.initWithConfig(config);
-}
-// -----------------------------------------------------------------------------
-// SocketAddress
-// -----------------------------------------------------------------------------
-// SocketAddress
-// -----------------------------------------------------------------------------
-class SocketAddress {
-    constructor(options) {
-        this.address = options.address;
-        this.family = options.family || (isIPv6(options.address) ? 'ipv6' : 'ipv4');
-        this.port = options.port;
-        this.flowlabel = options.flowlabel || 0;
-    }
-}
-exports.SocketAddress = SocketAddress;
-// -----------------------------------------------------------------------------
-// BlockList
-// -----------------------------------------------------------------------------
-class BlockList {
-    constructor() {
-        this._rules = [];
-    }
-    addAddress(address, family) {
-        this._rules.push({ type: 'address', data: { address, family: family || (isIPv6(address) ? 'ipv6' : 'ipv4') } });
-    }
-    addRange(start, end, family) {
-        this._rules.push({ type: 'range', data: { start, end, family: family || (isIPv6(start) ? 'ipv6' : 'ipv4') } });
-    }
-    addSubnet(net, prefix, family) {
-        this._rules.push({ type: 'subnet', data: { net, prefix, family: family || (isIPv6(net) ? 'ipv6' : 'ipv4') } });
-    }
-    check(address, family) {
-        const addrFamily = family || (isIPv6(address) ? 'ipv6' : 'ipv4');
-        const addrNum = addrFamily === 'ipv4' ? ipv4ToLong(address) : null;
-        for (const rule of this._rules) {
-            if (rule.data.family !== addrFamily)
-                continue;
-            if (rule.type === 'address') {
-                if (rule.data.address === address)
-                    return true;
-            }
-            else if (rule.type === 'range' && addrNum !== null) {
-                const start = ipv4ToLong(rule.data.start);
-                const end = ipv4ToLong(rule.data.end);
-                if (addrNum >= start && addrNum <= end)
-                    return true;
-            }
-            else if (rule.type === 'subnet' && addrNum !== null) {
-                const net = ipv4ToLong(rule.data.net);
-                const mask = ~(Math.pow(2, 32 - rule.data.prefix) - 1);
-                if ((addrNum & mask) === (net & mask))
-                    return true;
-            }
-        }
-        return false;
-    }
-}
-exports.BlockList = BlockList;
-function ipv4ToLong(ip) {
-    return ip.split('.').reduce((acc, octet) => (acc << 8) + parseInt(octet, 10), 0) >>> 0;
-}
-class Socket extends readable_stream_1.Duplex {
-    get localFamily() {
-        return this.localAddress && this.localAddress.includes(':') ? 'IPv6' : 'IPv4';
-    }
-    get readyState() {
-        if (this.connecting)
-            return 'opening';
-        if (this._connected) {
-            // @ts-ignore
-            if (this.writable && this.readable)
-                return 'open';
-            // @ts-ignore
-            if (this.writable)
-                return 'writeOnly';
-            // @ts-ignore
-            if (this.readable)
-                return 'readOnly';
-        }
-        return 'closed';
-    }
-    get pending() {
-        return this.connecting;
-    }
-    constructor(options) {
-        super({
-            allowHalfOpen: options?.allowHalfOpen ?? false,
-            readable: options?.readable ?? true,
-            writable: options?.writable ?? true
-        });
-        this.connecting = false; // Changed from private _connecting
-        this._connected = false;
-        this._hadError = false; // Added
-        this.bytesRead = 0;
-        this.bytesWritten = 0;
-        this.autoSelectFamilyAttemptedAddresses = [];
-        this._autoSelectFamily = false;
-        if (options?.socketDriver) {
-            // Wrapping existing socket (from Server)
-            this._driver = options.socketDriver;
-            this._connected = true;
-            this._setupEvents();
-            // Resume the socket since it starts paused on server-accept
-            this.resume();
-            // Emit connect for server-side socket? No, it's already connected.
-        }
-        else {
-            // New client socket
-            ensureInitialized();
-            this._driver = Driver_1.Driver.createSocket();
-            this._setupEvents();
-            // Also resume client socket initially so it's ready to receive
-            this.resume();
-        }
-        this.on('finish', () => {
-            // Writable side finished
-        });
-    }
-    on(event, listener) {
-        if (event === 'connect' && this._connected) {
-            process.nextTick(listener);
-            return this;
-        }
-        const ret = super.on(event, listener);
-        if (event === 'data' && !this.isPaused() && this.readableFlowing !== true) {
-            debugLog(`Socket on('data'), flowing: ${this.readableFlowing}`);
-            this.resume();
-        }
-        return ret;
-    }
-    _setupEvents() {
-        if (!this._driver)
-            return;
-        const id = this._driver.id ?? this._driver._id;
-        this._driver.onEvent = (eventType, data) => {
-            this.emit('event', eventType, data);
-            if (eventType === 3) { // ERROR
-                const msg = new TextDecoder().decode(data);
-                debugLog(`Socket (id: ${id}) NATIVE ERROR: ${msg}`);
-            }
-            if (eventType === 9) { // SESSION/DEBUG
-                debugLog(`Socket (id: ${id}) NATIVE SESSION EVENT RECEIVED`);
-                this.emit('session', data);
-                return;
-            }
-            debugLog(`Socket (id: ${id}, localPort: ${this.localPort}) Event TYPE: ${eventType}, data len: ${data?.byteLength}`);
-            switch (eventType) {
-                case Net_nitro_1.NetSocketEvent.CONNECT:
-                    this.connecting = false;
-                    this._connected = true;
-                    this._updateAddresses();
-                    this.emit('connect');
-                    this.emit('ready');
-                    break;
-                case Net_nitro_1.NetSocketEvent.DATA:
-                    debugLog(`Socket onEvent(DATA), len: ${data?.byteLength}, flowing: ${this.readableFlowing}`);
-                    if (data && data.byteLength > 0) {
-                        const buffer = react_native_nitro_buffer_1.Buffer.from(data);
-                        this.bytesRead += buffer.length;
-                        if (!this.push(buffer)) {
-                            this.pause();
-                        }
-                    }
-                    break;
-                case Net_nitro_1.NetSocketEvent.ERROR: {
-                    this._hadError = true;
-                    const errorMsg = data ? react_native_nitro_buffer_1.Buffer.from(data).toString() : 'Unknown socket error';
-                    const error = new Error(errorMsg);
-                    if (this.connecting && this._autoSelectFamily) {
-                        // If we were connecting, this is a connection attempt failure
-                        // We attempt to get the last attempted address if available
-                        const lastAttempt = this.autoSelectFamilyAttemptedAddresses[this.autoSelectFamilyAttemptedAddresses.length - 1];
-                        if (lastAttempt) {
-                            const [ip, port] = lastAttempt.split(':'); // distinct if ipv6?
-                            // Simple parsing for event emission
-                            const family = ip.includes(':') ? 6 : 4;
-                            this.emit('connectionAttemptFailed', ip, parseInt(port || '0', 10), family, error);
-                        }
-                    }
-                    this.emit('error', error);
-                    this.destroy();
-                    break;
-                }
-                case Net_nitro_1.NetSocketEvent.CLOSE:
-                    this._connected = false;
-                    this.connecting = false;
-                    this.push(null); // EOF
-                    this.emit('close', this._hadError);
-                    break;
-                case Net_nitro_1.NetSocketEvent.DRAIN:
-                    this.emit('drain');
-                    break;
-                case Net_nitro_1.NetSocketEvent.TIMEOUT:
-                    if (this.connecting && this._autoSelectFamily) {
-                        const lastAttempt = this.autoSelectFamilyAttemptedAddresses[this.autoSelectFamilyAttemptedAddresses.length - 1];
-                        if (lastAttempt) {
-                            const [ip, port] = lastAttempt.split(':');
-                            const family = ip.includes(':') ? 6 : 4;
-                            this.emit('connectionAttemptTimeout', ip, parseInt(port || '0', 10), family);
-                        }
-                    }
-                    this.emit('timeout');
-                    break;
-                case Net_nitro_1.NetSocketEvent.LOOKUP: {
-                    if (data) {
-                        const lookupStr = react_native_nitro_buffer_1.Buffer.from(data).toString();
-                        const parts = lookupStr.split(',');
-                        if (parts.length >= 2) {
-                            const [ip, family] = parts;
-                            this.remoteAddress = ip;
-                            this.remoteFamily = family === '6' ? 'IPv6' : 'IPv4';
-                            // Emit connectionAttempt
-                            // We don't have the port in LOOKUP data usually, but we stored it in this.remotePort (dest)
-                            // actually remotePort might not be set yet if we used _connect with port arg.
-                            // But _connect sets this.remotePort = port.
-                            const port = this.remotePort || 0;
-                            const fam = family === '6' ? 6 : 4;
-                            if (this._autoSelectFamily) {
-                                this.emit('connectionAttempt', ip, port, fam);
-                            }
-                            this.autoSelectFamilyAttemptedAddresses.push(`${ip}:${port}`);
-                        }
-                        const host = parts.length > 2 ? parts[2] : undefined;
-                        this.emit('lookup', null, parts[0], parts[1] ? parseInt(parts[1], 10) : undefined, host);
-                    }
-                    break;
-                }
-            }
-        };
-    }
-    _updateAddresses() {
-        try {
-            const local = this._driver?.getLocalAddress();
-            if (local) {
-                const parts = local.split(':');
-                if (parts.length >= 2) {
-                    this.localPort = parseInt(parts[parts.length - 1], 10);
-                    this.localAddress = parts.slice(0, parts.length - 1).join(':').replace(/[\[\]]/g, '');
-                }
-            }
-            const remote = this._driver?.getRemoteAddress();
-            if (remote) {
-                const parts = remote.split(':');
-                if (parts.length >= 2) {
-                    this.remotePort = parseInt(parts[parts.length - 1], 10);
-                    this.remoteAddress = parts.slice(0, parts.length - 1).join(':').replace(/[\[\]]/g, '');
-                    this.remoteFamily = this.remoteAddress.includes(':') ? 'IPv6' : 'IPv4';
-                }
-            }
-        }
-        catch (e) {
-            // Ignore errors for now
-        }
-    }
-    address() {
-        if (!this.localAddress)
-            return null;
-        return {
-            port: this.localPort || 0,
-            family: this.localAddress.includes(':') ? 'IPv6' : 'IPv4',
-            address: this.localAddress
-        };
-    }
-    connect(options, connectionListener) {
-        if (typeof options === 'string') {
-            // Path?
-            if (isNaN(Number(options))) {
-                return this._connectUnix(options, connectionListener);
-            }
-        }
-        if (typeof options === 'number' || typeof options === 'string') {
-            const port = Number(options);
-            const host = (arguments.length > 1 && typeof arguments[1] === 'string') ? arguments[1] : 'localhost';
-            const cb = typeof arguments[1] === 'function' ? arguments[1] : connectionListener;
-            // Default: Node 20 defaults autoSelectFamily to true
-            this._autoSelectFamily = true;
-            return this._connect(port, host, cb || arguments[2]);
-        }
-        if (options.path) {
-            return this._connectUnix(options.path, connectionListener, options.signal);
-        }
-        const port = options.port;
-        const host = options.host || 'localhost';
-        // Handle autoSelectFamily option
-        if (typeof options.autoSelectFamily === 'boolean') {
-            this._autoSelectFamily = options.autoSelectFamily;
-        }
-        else {
-            this._autoSelectFamily = true;
-        }
-        return this._connect(port, host, connectionListener, options.signal);
-    }
-    _connect(port, host, listener, signal) {
-        this.remotePort = port; // Store intended remote port
-        if (this.connecting || this._connected)
-            return this;
-        if (signal?.aborted) {
-            process.nextTick(() => this.emit('error', new Error('The operation was aborted')));
-            return this;
-        }
-        this.connecting = true;
-        if (listener)
-            this.once('connect', listener);
-        if (signal) {
-            const abortHandler = () => {
-                this.destroy(new Error('The operation was aborted'));
-            };
-            signal.addEventListener('abort', abortHandler, { once: true });
-            this.once('connect', () => signal.removeEventListener('abort', abortHandler));
-            this.once('close', () => signal.removeEventListener('abort', abortHandler));
-        }
-        this._driver?.connect(host, port);
-        return this;
-    }
-    _connectUnix(path, listener, signal) {
-        if (this.connecting || this._connected)
-            return this;
-        if (signal?.aborted) {
-            process.nextTick(() => this.emit('error', new Error('The operation was aborted')));
-            return this;
-        }
-        this.connecting = true;
-        if (listener)
-            this.once('connect', listener);
-        if (signal) {
-            const abortHandler = () => {
-                this.destroy(new Error('The operation was aborted'));
-            };
-            signal.addEventListener('abort', abortHandler, { once: true });
-            this.once('connect', () => signal.removeEventListener('abort', abortHandler));
-            this.once('close', () => signal.removeEventListener('abort', abortHandler));
-        }
-        this._driver?.connectUnix(path);
-        return this;
-    }
-    end(chunk, encoding, cb) {
-        debugLog(`Socket (localPort: ${this.localPort}) .end() called`);
-        return super.end(chunk, encoding, cb);
-    }
-    _write(chunk, encoding, callback) {
-        if (!this._driver) {
-            return callback(new Error('Socket not connected'));
-        }
-        try {
-            const buffer = (chunk instanceof react_native_nitro_buffer_1.Buffer) ? chunk : react_native_nitro_buffer_1.Buffer.from(chunk, encoding);
-            this.bytesWritten += buffer.length;
-            const ab = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
-            debugLog(`Socket _write, len: ${ab.byteLength}`);
-            this._driver.write(ab);
-            callback(null);
-        }
-        catch (err) {
-            callback(err);
-        }
-    }
-    _read(size) {
-        if (this._driver)
-            this._driver.resume();
-    }
-    _final(callback) {
-        if (this._driver) {
-            this._driver.shutdown();
-        }
-        callback(null);
-    }
-    destroy(reason) {
-        debugLog(`Socket (localPort: ${this.localPort}) .destroy() called, reason: ${reason?.message}`);
-        return super.destroy(reason);
-    }
-    _destroy(err, callback) {
-        debugLog(`Socket (localPort: ${this.localPort}) ._destroy() called`);
-        this._connected = false;
-        this.connecting = false;
-        this.destroyed = true;
-        if (this._driver) {
-            this._driver.destroy();
-            this._driver = undefined;
-        }
-        callback(err);
-    }
-    // Standard net.Socket methods
-    setTimeout(msecs, callback) {
-        if (this._driver) {
-            this._driver.setTimeout(msecs);
-        }
-        if (callback)
-            this.once('timeout', callback);
-        return this;
-    }
-    /**
-     * Pause the reading of data. That is, 'data' events will not be emitted.
-     * Useful to throttle back an upload.
-     */
-    pause() {
-        super.pause();
-        if (this._driver) {
-            this._driver.pause();
-        }
-        return this;
-    }
-    /**
-     * Resume reading after a call to pause().
-     */
-    resume() {
-        const id = this._driver?.id;
-        debugLog(`Socket.resume() called, id: ${id}`);
-        super.resume();
-        if (this._driver) {
-            debugLog(`Socket.resume() calling driver.resume(), id: ${id}`);
-            this._driver.resume();
-        }
-        return this;
-    }
-    /**
-     * Enable/disable the use of Nagle's algorithm.
-     */
-    setNoDelay(noDelay) {
-        this._driver?.setNoDelay(noDelay !== false);
-        return this;
-    }
-    setKeepAlive(enable, initialDelay) {
-        this._driver?.setKeepAlive(enable !== false, initialDelay || 0);
-        return this;
-    }
-    ref() { return this; }
-    unref() { return this; }
-    /**
-     * Set the encoding for the socket as a Readable Stream.
-     * Use 'utf8', 'hex', etc.
-     */
-    setEncoding(encoding) {
-        super.setEncoding(encoding);
-        return this;
-    }
-    get timeout() {
-        return undefined; // Not tracked strictly as a property yet
-    }
-    get bufferSize() {
-        return 0; // Deprecated but often accessed
-    }
-    resetAndDestroy() {
-        if (this._driver) {
-            this._driver.resetAndDestroy();
-            this._driver = undefined;
-        }
-        this._connected = false;
-        this.connecting = false;
-        this.destroyed = true;
-        return this;
-    }
-}
-exports.Socket = Socket;
-// -----------------------------------------------------------------------------
-// Server
-// -----------------------------------------------------------------------------
-class Server extends eventemitter3_1.EventEmitter {
-    get maxConnections() {
-        return this._maxConnections;
-    }
-    set maxConnections(value) {
-        this._maxConnections = value;
-        // We handle maxConnections in JS to support 'drop' event.
-        // Disable native limit to ensure we receive the connection attempt.
-        this._driver.maxConnections = 0;
-    }
-    get dropMaxConnection() {
-        return this._dropMaxConnection;
-    }
-    set dropMaxConnection(value) {
-        this._dropMaxConnection = value;
-    }
-    get listening() {
-        // If we have a driver and we assume it's listening if it has been started?
-        // Actually, checking _driver state might be hard if not exposed.
-        // But typically 'listening' is true after 'listening' event.
-        // We can track it with a private flag or by checking address() which returns null if not listening.
-        return !!this.address();
-    }
-    constructor(options, connectionListener) {
-        super();
-        this._sockets = new Set();
-        this._connections = 0;
-        this._maxConnections = 0;
-        this._dropMaxConnection = false;
-        ensureInitialized();
-        this._driver = Driver_1.Driver.createServer();
-        if (typeof options === 'function') {
-            connectionListener = options;
-            options = {};
-        }
-        if (connectionListener) {
-            this.on('connection', connectionListener);
-        }
-        this._driver.onEvent = (eventType, data) => {
-            switch (eventType) {
-                case Net_nitro_1.NetServerEvent.CONNECTION: {
-                    const payload = data ? react_native_nitro_buffer_1.Buffer.from(data).toString() : '';
-                    if (payload === 'success') {
-                        this.emit('listening');
-                    }
-                    else {
-                        const clientId = payload;
-                        debugLog(`Server connection clientId: '${clientId}', current connections: ${this._connections}, max: ${this._maxConnections}`);
-                        if (clientId) {
-                            // Check maxConnections
-                            if (this._maxConnections > 0 && this._connections >= this._maxConnections) {
-                                debugLog(`Server maxConnections reached (${this._connections} >= ${this._maxConnections}). Dropping connection. clientId: ${clientId}`);
-                                const socketDriver = Driver_1.Driver.createSocket(clientId);
-                                const socket = new Socket({
-                                    socketDriver: socketDriver,
-                                    readable: true,
-                                    writable: true
-                                });
-                                // @ts-ignore
-                                socket._updateAddresses();
-                                this.emit('drop', {
-                                    localAddress: socket.localAddress,
-                                    localPort: socket.localPort,
-                                    localFamily: socket.localFamily,
-                                    remoteAddress: socket.remoteAddress,
-                                    remotePort: socket.remotePort,
-                                    remoteFamily: socket.remoteFamily
-                                });
-                                socket.destroy();
-                                return;
-                            }
-                            const socketDriver = Driver_1.Driver.createSocket(clientId);
-                            const socket = new Socket({
-                                socketDriver: socketDriver,
-                                readable: true,
-                                writable: true
-                            });
-                            // Initialize addresses immediately for server-side socket
-                            // @ts-ignore
-                            socket._updateAddresses();
-                            debugLog(`Socket initialized addresses: local=${socket.localAddress}:${socket.localPort}, remote=${socket.remoteAddress}:${socket.remotePort}`);
-                            // Keep reference to prevent GC
-                            this._sockets.add(socket);
-                            this._connections++;
-                            socket.on('close', () => {
-                                this._connections--;
-                                this._sockets.delete(socket);
-                            });
-                            this.emit('connection', socket);
-                        }
-                    }
-                    break;
-                }
-                case Net_nitro_1.NetServerEvent.ERROR:
-                    this.emit('error', new Error(data ? react_native_nitro_buffer_1.Buffer.from(data).toString() : 'Unknown server error'));
-                    break;
-                case Net_nitro_1.NetServerEvent.DEBUG: {
-                    debugLog(`Server NATIVE SESSION/DEBUG EVENT RECEIVED`);
-                    this.emit('session', data);
-                    break;
-                }
-                case Net_nitro_1.NetServerEvent.CLOSE:
-                    this.emit('close');
-                    break;
-            }
-        };
-    }
-    ref() { return this; }
-    unref() { return this; }
-    // @ts-ignore
-    [Symbol.asyncDispose]() {
-        return new Promise((resolve) => {
-            this.close(() => resolve());
-        });
-    }
-    listen(port, host, backlog, callback) {
-        let _port = 0;
-        let _host;
-        let _backlog;
-        let _path;
-        let _callback;
-        let signal;
-        let ipv6Only = false;
-        let reusePort = false;
-        let handle;
-        if (typeof port === 'object' && port !== null) {
-            // Check if it's a handle object with fd property
-            if (typeof port.fd === 'number') {
-                handle = port;
-                _backlog = port.backlog;
-                _callback = host; // listen(handle, cb)
-            }
-            else {
-                _port = port.port;
-                _host = port.host;
-                _backlog = port.backlog;
-                _path = port.path;
-                signal = port.signal;
-                ipv6Only = port.ipv6Only === true;
-                reusePort = port.reusePort === true;
-                _callback = host; // listen(options, cb)
-            }
-        }
-        else {
-            _port = typeof port === 'number' ? port : (typeof port === 'string' && !isNaN(Number(port)) ? Number(port) : 0);
-            if (typeof port === 'string' && isNaN(Number(port)))
-                _path = port;
-            if (typeof host === 'string')
-                _host = host;
-            else if (typeof host === 'function')
-                _callback = host;
-            if (typeof backlog === 'number')
-                _backlog = backlog;
-            else if (typeof backlog === 'function')
-                _callback = backlog;
-            if (typeof callback === 'function')
-                _callback = callback;
-        }
-        if (_callback)
-            this.once('listening', _callback);
-        if (signal?.aborted) {
-            process.nextTick(() => this.emit('error', new Error('The operation was aborted')));
-            return this;
-        }
-        if (signal) {
-            const abortHandler = () => {
-                this.close();
-                this.emit('error', new Error('The operation was aborted'));
-            };
-            signal.addEventListener('abort', abortHandler, { once: true });
-            this.once('listening', () => signal.removeEventListener('abort', abortHandler));
-            this.once('close', () => signal.removeEventListener('abort', abortHandler));
-        }
-        if (handle && typeof handle.fd === 'number') {
-            // Listen on an existing file descriptor (handle)
-            this._driver.listenHandle(handle.fd, _backlog);
-        }
-        else if (_path) {
-            this._driver.listenUnix(_path, _backlog);
-        }
-        else {
-            this._driver.listen(_port || 0, _backlog, ipv6Only, reusePort);
-        }
-        return this;
-    }
-    close(callback) {
-        // Destroy all active connections first
-        for (const socket of this._sockets) {
-            socket.destroy();
-        }
-        this._sockets.clear();
-        this._connections = 0;
-        this._driver.close();
-        if (callback)
-            this.once('close', callback);
-        return this;
-    }
-    address() {
-        try {
-            const addr = this._driver.getLocalAddress();
-            if (addr) {
-                const parts = addr.split(':');
-                if (parts.length >= 2) {
-                    const port = parseInt(parts[parts.length - 1], 10);
-                    const address = parts.slice(0, parts.length - 1).join(':').replace(/[\[\]]/g, '');
-                    const family = address.includes(':') ? 'IPv6' : 'IPv4';
-                    return { port, family, address };
-                }
-            }
-        }
-        catch (e) {
-            // Ignore
-        }
-        return null;
-    }
-    getConnections(cb) {
-        cb(null, this._connections);
-    }
-}
-exports.Server = Server;
-// -----------------------------------------------------------------------------
-// Exports
-// -----------------------------------------------------------------------------
-function createConnection(options, connectionListener) {
-    const socket = new Socket(options);
-    return socket.connect(options, connectionListener);
-}
-exports.connect = createConnection;
-function createServer(options, connectionListener) {
-    return new Server(options, connectionListener);
-}
-exports.tls = __importStar(require("./tls"));
-exports.default = {
-    Socket,
-    Server,
-    SocketAddress,
-    BlockList,
-    createConnection,
-    createServer,
-    connect: exports.connect,
-    isIP,
-    isIPv4,
-    isIPv6,
-    getDefaultAutoSelectFamily,
-    setDefaultAutoSelectFamily,
-    setVerbose,
-    initWithConfig,
+import * as net from './net';
+import * as tls from './tls';
+import * as http from './http';
+import * as https from './https';
+export * from './net';
+export { tls, http, https };
+export default {
+    ...net,
+    tls,
+    http,
+    https,
 };