Gecko [ c.stage.kornherr.net ]

Name	Size	Permission	Date
fs	[ DIR ]	drwxr-xr-x	2021-01-22 18:49
ts3.4	[ DIR ]	drwxr-xr-x	2021-01-22 18:49
ts3.6	[ DIR ]	drwxr-xr-x	2021-01-22 18:49
README.md	2.7 KB	-rw-r--r--	2021-01-19 23:09
assert.d.ts	5.46 KB	-rw-r--r--	2021-01-19 23:09
async_hooks.d.ts	9.47 KB	-rw-r--r--	2021-01-19 23:09
base.d.ts	905 B	-rw-r--r--	2021-01-19 23:09
buffer.d.ts	708 B	-rw-r--r--	2021-01-19 23:09
child_process.d.ts	24.5 KB	-rw-r--r--	2021-01-19 23:09
cluster.d.ts	15.75 KB	-rw-r--r--	2021-01-19 23:09
console.d.ts	5.78 KB	-rw-r--r--	2021-01-19 23:09
constants.d.ts	459 B	-rw-r--r--	2021-01-19 23:09
crypto.d.ts	45.25 KB	-rw-r--r--	2021-01-19 23:09
dgram.d.ts	7.03 KB	-rw-r--r--	2021-01-19 23:09
dns.d.ts	15.93 KB	-rw-r--r--	2021-01-19 23:09
domain.d.ts	717 B	-rw-r--r--	2021-01-19 23:09
events.d.ts	3.29 KB	-rw-r--r--	2021-01-19 23:09
fs.d.ts	115.08 KB	-rw-r--r--	2021-01-19 23:09
globals.d.ts	23.15 KB	-rw-r--r--	2021-01-19 23:09
globals.global.d.ts	55 B	-rw-r--r--	2021-01-19 23:09
http.d.ts	18.43 KB	-rw-r--r--	2021-01-19 23:09
http2.d.ts	55.27 KB	-rw-r--r--	2021-01-19 23:09
https.d.ts	1.64 KB	-rw-r--r--	2021-01-19 23:09
index.d.ts	3.74 KB	-rw-r--r--	2021-01-19 23:09
inspector.d.ts	119.08 KB	-rw-r--r--	2021-01-19 23:09
module.d.ts	1.6 KB	-rw-r--r--	2021-01-19 23:09
net.d.ts	12.59 KB	-rw-r--r--	2021-01-19 23:09
os.d.ts	7.99 KB	-rw-r--r--	2021-01-19 23:09
package.json	5.46 KB	-rw-r--r--	2021-01-22 18:49
path.d.ts	6.16 KB	-rw-r--r--	2021-01-19 23:09
perf_hooks.d.ts	10.37 KB	-rw-r--r--	2021-01-19 23:09
process.d.ts	19.86 KB	-rw-r--r--	2021-01-19 23:09
punycode.d.ts	3.08 KB	-rw-r--r--	2021-01-19 23:09
querystring.d.ts	1.02 KB	-rw-r--r--	2021-01-19 23:09
readline.d.ts	7.16 KB	-rw-r--r--	2021-01-19 23:09
repl.d.ts	17.69 KB	-rw-r--r--	2021-01-19 23:09
stream.d.ts	18.92 KB	-rw-r--r--	2021-01-19 23:09
string_decoder.d.ts	193 B	-rw-r--r--	2021-01-19 23:09
timers.d.ts	826 B	-rw-r--r--	2021-01-19 23:09
tls.d.ts	36.88 KB	-rw-r--r--	2021-01-19 23:09
trace_events.d.ts	2.06 KB	-rw-r--r--	2021-01-19 23:09
tty.d.ts	2.38 KB	-rw-r--r--	2021-01-19 23:09
url.d.ts	4.11 KB	-rw-r--r--	2021-01-19 23:09
util.d.ts	12.45 KB	-rw-r--r--	2021-01-19 23:09
v8.d.ts	6.61 KB	-rw-r--r--	2021-01-19 23:09
vm.d.ts	5.76 KB	-rw-r--r--	2021-01-19 23:09
wasi.d.ts	3.3 KB	-rw-r--r--	2021-01-19 23:09
worker_threads.d.ts	11.18 KB	-rw-r--r--	2021-01-19 23:09
zlib.d.ts	13.99 KB	-rw-r--r--	2021-01-19 23:09

Rename

declare module "net" {
    import * as stream from "stream";
    import * as events from "events";
    import * as dns from "dns";

type LookupFunction = (hostname: string, options: dns.LookupOneOptions, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void) => void;

interface AddressInfo {
        address: string;
        family: string;
        port: number;
    }

interface SocketConstructorOpts {
        fd?: number;
        allowHalfOpen?: boolean;
        readable?: boolean;
        writable?: boolean;
    }

interface OnReadOpts {
        buffer: Uint8Array | (() => Uint8Array);
        /**
         * This function is called for every chunk of incoming data.
         * Two arguments are passed to it: the number of bytes written to buffer and a reference to buffer.
         * Return false from this function to implicitly pause() the socket.
         */
        callback(bytesWritten: number, buf: Uint8Array): boolean;
    }

interface ConnectOpts {
        /**
         * If specified, incoming data is stored in a single buffer and passed to the supplied callback when data arrives on the socket.
         * Note: this will cause the streaming functionality to not provide any data, however events like 'error', 'end', and 'close' will
         * still be emitted as normal and methods like pause() and resume() will also behave as expected.
         */
        onread?: OnReadOpts;
    }

interface TcpSocketConnectOpts extends ConnectOpts {
        port: number;
        host?: string;
        localAddress?: string;
        localPort?: number;
        hints?: number;
        family?: number;
        lookup?: LookupFunction;
    }

interface IpcSocketConnectOpts extends ConnectOpts {
        path: string;
    }

type SocketConnectOpts = TcpSocketConnectOpts | IpcSocketConnectOpts;

class Socket extends stream.Duplex {
        constructor(options?: SocketConstructorOpts);

// Extended base methods
        write(buffer: Uint8Array | string, cb?: (err?: Error) => void): boolean;
        write(str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error) => void): boolean;

connect(options: SocketConnectOpts, connectionListener?: () => void): this;
        connect(port: number, host: string, connectionListener?: () => void): this;
        connect(port: number, connectionListener?: () => void): this;
        connect(path: string, connectionListener?: () => void): this;

setEncoding(encoding?: BufferEncoding): this;
        pause(): this;
        resume(): this;
        setTimeout(timeout: number, callback?: () => void): this;
        setNoDelay(noDelay?: boolean): this;
        setKeepAlive(enable?: boolean, initialDelay?: number): this;
        address(): AddressInfo | {};
        unref(): this;
        ref(): this;

/** @deprecated since v14.6.0 - Use `writableLength` instead. */
        readonly bufferSize: number;
        readonly bytesRead: number;
        readonly bytesWritten: number;
        readonly connecting: boolean;
        readonly destroyed: boolean;
        readonly localAddress: string;
        readonly localPort: number;
        readonly remoteAddress?: string;
        readonly remoteFamily?: string;
        readonly remotePort?: number;

// Extended base methods
        end(cb?: () => void): void;
        end(buffer: Uint8Array | string, cb?: () => void): void;
        end(str: Uint8Array | string, encoding?: BufferEncoding, cb?: () => void): void;

/**
         * events.EventEmitter
         *   1. close
         *   2. connect
         *   3. data
         *   4. drain
         *   5. end
         *   6. error
         *   7. lookup
         *   8. timeout
         */
        addListener(event: string, listener: (...args: any[]) => void): this;
        addListener(event: "close", listener: (had_error: boolean) => void): this;
        addListener(event: "connect", listener: () => void): this;
        addListener(event: "data", listener: (data: Buffer) => void): this;
        addListener(event: "drain", listener: () => void): this;
        addListener(event: "end", listener: () => void): this;
        addListener(event: "error", listener: (err: Error) => void): this;
        addListener(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
        addListener(event: "timeout", listener: () => void): this;

emit(event: string | symbol, ...args: any[]): boolean;
        emit(event: "close", had_error: boolean): boolean;
        emit(event: "connect"): boolean;
        emit(event: "data", data: Buffer): boolean;
        emit(event: "drain"): boolean;
        emit(event: "end"): boolean;
        emit(event: "error", err: Error): boolean;
        emit(event: "lookup", err: Error, address: string, family: string | number, host: string): boolean;
        emit(event: "timeout"): boolean;

on(event: string, listener: (...args: any[]) => void): this;
        on(event: "close", listener: (had_error: boolean) => void): this;
        on(event: "connect", listener: () => void): this;
        on(event: "data", listener: (data: Buffer) => void): this;
        on(event: "drain", listener: () => void): this;
        on(event: "end", listener: () => void): this;
        on(event: "error", listener: (err: Error) => void): this;
        on(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
        on(event: "timeout", listener: () => void): this;

once(event: string, listener: (...args: any[]) => void): this;
        once(event: "close", listener: (had_error: boolean) => void): this;
        once(event: "connect", listener: () => void): this;
        once(event: "data", listener: (data: Buffer) => void): this;
        once(event: "drain", listener: () => void): this;
        once(event: "end", listener: () => void): this;
        once(event: "error", listener: (err: Error) => void): this;
        once(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
        once(event: "timeout", listener: () => void): this;

prependListener(event: string, listener: (...args: any[]) => void): this;
        prependListener(event: "close", listener: (had_error: boolean) => void): this;
        prependListener(event: "connect", listener: () => void): this;
        prependListener(event: "data", listener: (data: Buffer) => void): this;
        prependListener(event: "drain", listener: () => void): this;
        prependListener(event: "end", listener: () => void): this;
        prependListener(event: "error", listener: (err: Error) => void): this;
        prependListener(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
        prependListener(event: "timeout", listener: () => void): this;

prependOnceListener(event: string, listener: (...args: any[]) => void): this;
        prependOnceListener(event: "close", listener: (had_error: boolean) => void): this;
        prependOnceListener(event: "connect", listener: () => void): this;
        prependOnceListener(event: "data", listener: (data: Buffer) => void): this;
        prependOnceListener(event: "drain", listener: () => void): this;
        prependOnceListener(event: "end", listener: () => void): this;
        prependOnceListener(event: "error", listener: (err: Error) => void): this;
        prependOnceListener(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
        prependOnceListener(event: "timeout", listener: () => void): this;
    }

interface ListenOptions {
        port?: number;
        host?: string;
        backlog?: number;
        path?: string;
        exclusive?: boolean;
        readableAll?: boolean;
        writableAll?: boolean;
        /**
         * @default false
         */
        ipv6Only?: boolean;
    }

// https://github.com/nodejs/node/blob/master/lib/net.js
    class Server extends events.EventEmitter {
        constructor(connectionListener?: (socket: Socket) => void);
        constructor(options?: { allowHalfOpen?: boolean, pauseOnConnect?: boolean }, connectionListener?: (socket: Socket) => void);

listen(port?: number, hostname?: string, backlog?: number, listeningListener?: () => void): this;
        listen(port?: number, hostname?: string, listeningListener?: () => void): this;
        listen(port?: number, backlog?: number, listeningListener?: () => void): this;
        listen(port?: number, listeningListener?: () => void): this;
        listen(path: string, backlog?: number, listeningListener?: () => void): this;
        listen(path: string, listeningListener?: () => void): this;
        listen(options: ListenOptions, listeningListener?: () => void): this;
        listen(handle: any, backlog?: number, listeningListener?: () => void): this;
        listen(handle: any, listeningListener?: () => void): this;
        close(callback?: (err?: Error) => void): this;
        address(): AddressInfo | string | null;
        getConnections(cb: (error: Error | null, count: number) => void): void;
        ref(): this;
        unref(): this;
        maxConnections: number;
        connections: number;
        listening: boolean;

/**
         * events.EventEmitter
         *   1. close
         *   2. connection
         *   3. error
         *   4. listening
         */
        addListener(event: string, listener: (...args: any[]) => void): this;
        addListener(event: "close", listener: () => void): this;
        addListener(event: "connection", listener: (socket: Socket) => void): this;
        addListener(event: "error", listener: (err: Error) => void): this;
        addListener(event: "listening", listener: () => void): this;

emit(event: string | symbol, ...args: any[]): boolean;
        emit(event: "close"): boolean;
        emit(event: "connection", socket: Socket): boolean;
        emit(event: "error", err: Error): boolean;
        emit(event: "listening"): boolean;

on(event: string, listener: (...args: any[]) => void): this;
        on(event: "close", listener: () => void): this;
        on(event: "connection", listener: (socket: Socket) => void): this;
        on(event: "error", listener: (err: Error) => void): this;
        on(event: "listening", listener: () => void): this;

once(event: string, listener: (...args: any[]) => void): this;
        once(event: "close", listener: () => void): this;
        once(event: "connection", listener: (socket: Socket) => void): this;
        once(event: "error", listener: (err: Error) => void): this;
        once(event: "listening", listener: () => void): this;

prependListener(event: string, listener: (...args: any[]) => void): this;
        prependListener(event: "close", listener: () => void): this;
        prependListener(event: "connection", listener: (socket: Socket) => void): this;
        prependListener(event: "error", listener: (err: Error) => void): this;
        prependListener(event: "listening", listener: () => void): this;

prependOnceListener(event: string, listener: (...args: any[]) => void): this;
        prependOnceListener(event: "close", listener: () => void): this;
        prependOnceListener(event: "connection", listener: (socket: Socket) => void): this;
        prependOnceListener(event: "error", listener: (err: Error) => void): this;
        prependOnceListener(event: "listening", listener: () => void): this;
    }

interface TcpNetConnectOpts extends TcpSocketConnectOpts, SocketConstructorOpts {
        timeout?: number;
    }

interface IpcNetConnectOpts extends IpcSocketConnectOpts, SocketConstructorOpts {
        timeout?: number;
    }

type NetConnectOpts = TcpNetConnectOpts | IpcNetConnectOpts;

function createServer(connectionListener?: (socket: Socket) => void): Server;
    function createServer(options?: { allowHalfOpen?: boolean, pauseOnConnect?: boolean }, connectionListener?: (socket: Socket) => void): Server;
    function connect(options: NetConnectOpts, connectionListener?: () => void): Socket;
    function connect(port: number, host?: string, connectionListener?: () => void): Socket;
    function connect(path: string, connectionListener?: () => void): Socket;
    function createConnection(options: NetConnectOpts, connectionListener?: () => void): Socket;
    function createConnection(port: number, host?: string, connectionListener?: () => void): Socket;
    function createConnection(path: string, connectionListener?: () => void): Socket;
    function isIP(input: string): number;
    function isIPv4(input: string): boolean;
    function isIPv6(input: string): boolean;
}