node-datachannel 0.12.0 → 0.20.0-alpha.2

package/package.json

@@ -1,52 +1,45 @@
 {
     "name": "node-datachannel",
-    "version": "0.12.0",
-    "description": "libdatachannel node bindings",
-    "type": "module",
-    "types": "./lib/index.d.ts",
+    "version": "0.20.0-alpha.2",
+    "description": "WebRTC For Node.js and Electron. libdatachannel node bindings.",
+    "main": "./dist/cjs/lib/index.cjs",
+    "module": "./dist/esm/lib/index.mjs",
+    "types": "./dist/types/lib/index.d.ts",
     "exports": {
         ".": {
-            "import": {
-                "types": "./lib/index.d.ts",
-                "default": "./lib/index.js"
-            },
-            "require": {
-                "types": "./lib/index.d.cts",
-                "default": "./lib/index.cjs"
-            }
+            "types": "./dist/types/lib/index.d.ts",
+            "require": "./dist/cjs/lib/index.cjs",
+            "import": "./dist/esm/lib/index.mjs",
+            "default": "./dist/lib/esm/index.mjs"
         },
         "./polyfill": {
-            "import": {
-                "types": "./polyfill/index.d.ts",
-                "default": "./polyfill/index.js"
-            },
-            "require": {
-                "types": "./polyfill/index.d.cts",
-                "default": "./polyfill/index.cjs"
-            }
+            "types": "./dist/types/polyfill/index.d.ts",
+            "require": "./dist/cjs/polyfill/index.cjs",
+            "import": "./dist/esm/polyfill/index.mjs",
+            "default": "./dist/polyfill/esm/index.mjs"
         }
     },
     "engines": {
         "node": ">=16.0.0"
     },
-    "directories": {
-        "lib": "lib",
-        "test": "test"
-    },
-    "_from": "node-datachannel@latest",
     "scripts": {
         "install": "prebuild-install -r napi || (npm install --ignore-scripts --production=false && npm run _prebuild)",
-        "install-nice": "npm run clean && npm install --ignore-scripts --production=false && cmake-js build --CDUSE_NICE=1",
-        "install-gnu-tls": "npm run clean && npm install --ignore-scripts --production=false && cmake-js build --CDUSE_GNUTLS=1",
-        "build": "cmake-js build",
-        "build:debug": "cmake-js build -D",
-        "_prebuild": "prebuild -r napi --backend cmake-js",
-        "clean": "cmake-js clean",
-        "lint": "eslint lib/**/* test/**/*",
+        "install:nice": "npm run clean && npm install --ignore-scripts --production=false && cmake-js build --CDUSE_NICE=1",
+        "install:gnu": "npm run clean && npm install --ignore-scripts --production=false && cmake-js build --CDUSE_GNUTLS=1",
+        "build": "npm run compile && npm run build:tsc",
+        "compile": "cmake-js build",
+        "compile:debug": "cmake-js build -D",
+        "build:tsc": "rimraf dist && rollup -c",
+        "build:tsc:watch": "rollup -c -w",
+        "clean": "rimraf dist build",
+        "lint": "eslint . --ext .ts --ext .mts",
         "test": "NODE_OPTIONS=--experimental-vm-modules jest",
-        "wpt-test": "node test/wpt.js",
-        "test-types": "tsc",
-        "prepublishOnly": "cp lib/index.d.ts lib/index.d.cts && cp polyfill/index.d.ts polyfill/index.d.cts && rollup lib/index.js --file lib/index.cjs --format cjs && rollup polyfill/index.js --file polyfill/index.cjs --format cjs"
+        "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch",
+        "test:wpt": "npm run run:wpt:server & (sleep 8 && (npm run run:wpt:test | tee test/wpt-tests/last-test-results.md) )",
+        "run:wpt:server": "cd test/wpt-tests/wpt && ./wpt serve",
+        "run:wpt:test": "ts-node test/wpt-tests/index.ts",
+        "_prebuild": "prebuild -r napi --backend cmake-js",
+        "prepack": "npm run build:tsc"
     },
     "binary": {
         "napi_versions": [
@@ -82,19 +75,30 @@
     },
     "homepage": "https://github.com/murat-dogan/node-datachannel#readme",
     "devDependencies": {
+        "@rollup/plugin-esm-shim": "^0.1.7",
+        "@types/jest": "^29.5.12",
         "@types/node": "^20.6.1",
-        "@typescript-eslint/eslint-plugin": "^5.62.0",
-        "@typescript-eslint/parser": "^5.62.0",
+        "@typescript-eslint/eslint-plugin": "^7.17.0",
+        "@typescript-eslint/parser": "^7.17.0",
         "cmake-js": "^6.3.2",
-        "eslint": "^8.49.0",
-        "eslint-config-prettier": "^8.10.0",
-        "eslint-plugin-prettier": "^4.2.1",
+        "eslint": "^8.57.0",
+        "eslint-config-prettier": "^9.1.0",
+        "eslint-plugin-jest": "^28.6.0",
+        "eslint-plugin-prettier": "^5.2.1",
         "jest": "^29.7.0",
+        "jsdom": "^24.1.1",
         "node-addon-api": "^7.0.0",
         "prebuild": "^12.0.0",
-        "prettier": "^2.8.8",
-        "rollup": "^4.14.1",
-        "typescript": "^5.3.2"
+        "prettier": "^3.3.3",
+        "puppeteer": "^22.14.0",
+        "rimraf": "^5.0.9",
+        "rollup": "^4.22.5",
+        "rollup-plugin-dts": "^6.1.1",
+        "rollup-plugin-esbuild": "^6.1.1",
+        "ts-api-utils": "^1.3.0",
+        "ts-jest": "^29.2.3",
+        "ts-node": "^10.9.2",
+        "typescript": "5.4"
     },
     "dependencies": {
         "node-domexception": "^2.0.1",

package/rollup.config.mjs

@@ -0,0 +1,63 @@
+import dts from 'rollup-plugin-dts';
+import esbuild from 'rollup-plugin-esbuild';
+import esmShim from '@rollup/plugin-esm-shim';
+
+const external = (id) => {
+  return !/^[./]/.test(id);
+};
+
+const bundle = (config) => ({
+  ...config,
+  input: 'src/index.ts',
+  external,
+});
+
+export default [
+  bundle({
+    plugins: [esmShim(), esbuild()],
+    output: [
+      {
+        dir: 'dist/esm',
+        format: 'es',
+        exports: 'named',
+        sourcemap: true,
+        entryFileNames: '[name].mjs',
+        preserveModules: true, // Keep directory structure and files
+      },
+      {
+        dir: 'dist/cjs',
+        format: 'cjs',
+        exports: 'named',
+        sourcemap: true,
+        entryFileNames: '[name].cjs',
+        preserveModules: true, // Keep directory structure and files
+      },
+    ],
+  }),
+  // types
+  {
+    plugins: [dts()],
+    input: 'src/lib/index.ts',
+    external,
+    output: {
+      dir: 'dist/types/lib',
+      format: 'cjs',
+      exports: 'named',
+      preserveModules: true, // Keep directory structure and files
+    },
+  },
+  {
+    plugins: [dts()],
+    input: 'src/polyfill/index.ts',
+    external: (id) => {
+      if (id.startsWith('../lib')) return true;
+      return !/^[./]/.test(id);
+    },
+    output: {
+      dir: 'dist/types/polyfill',
+      format: 'cjs',
+      exports: 'named',
+      preserveModules: true, // Keep directory structure and files
+    },
+  },
+];

package/src/index.ts

@@ -0,0 +1,10 @@
+// This file is created for builder process
+// So builder can find and compile all files and folders
+// Not intended to be imported directly
+
+import n from './lib/index';
+import p from './polyfill/index';
+
+
+export const nodeDataChannel = n;
+export const polyfill = p;

package/{lib/datachannel-stream.js → src/lib/datachannel-stream.ts}

@@ -1,4 +1,5 @@
-import stream from 'stream';
+import * as stream from 'stream';
+// import { DataChannel } from './node-datachannel.js';
 
 /**
  * Turns a node-datachannel DataChannel into a real Node.js stream, complete with buffering,
@@ -9,7 +10,11 @@ import stream from 'stream';
  * the protocol level, and is preserved here throughout.
  */
 export default class DataChannelStream extends stream.Duplex {
-    constructor(rawChannel, streamOptions) {
+    private _rawChannel: any;
+    private _readActive: boolean;
+
+
+    constructor(rawChannel: any, streamOptions?: Omit<stream.DuplexOptions, 'objectMode'>) {
         super({
             allowHalfOpen: false, // Default to autoclose on end().
             ...streamOptions,
@@ -19,7 +24,7 @@ export default class DataChannelStream extends stream.Duplex {
         this._rawChannel = rawChannel;
         this._readActive = true;
 
-        rawChannel.onMessage((msg) => {
+        rawChannel.onMessage((msg: any) => {
             if (!this._readActive) return; // If the buffer is full, drop messages.
 
             // If the push is rejected, we pause reading until the next call to _read().
@@ -32,7 +37,7 @@ export default class DataChannelStream extends stream.Duplex {
             this.destroy();
         });
 
-        rawChannel.onError((errMsg) => {
+        rawChannel.onError((errMsg: string) => {
             this.destroy(new Error(`DataChannel error: ${errMsg}`));
         });
 
@@ -43,12 +48,12 @@ export default class DataChannelStream extends stream.Duplex {
         }
     }
 
-    _read() {
+    _read(): void {
         // Stop dropping messages, if the buffer filling up meant we were doing so before.
         this._readActive = true;
     }
 
-    _write(chunk, encoding, callback) {
+    _write(chunk, _encoding, callback): void {
         let sentOk;
 
         try {
@@ -71,26 +76,26 @@ export default class DataChannelStream extends stream.Duplex {
         }
     }
 
-    _final(callback) {
+    _final(callback): void {
         if (!this.allowHalfOpen) this.destroy();
         callback(null);
     }
 
-    _destroy(maybeErr, callback) {
+    _destroy(maybeErr, callback): void {
         // When the stream is destroyed, we close the DataChannel.
         this._rawChannel.close();
         callback(maybeErr);
     }
 
-    get label() {
+    get label(): string {
         return this._rawChannel.getLabel();
     }
 
-    get id() {
+    get id(): number {
         return this._rawChannel.getId();
     }
 
-    get protocol() {
+    get protocol(): string {
         return this._rawChannel.getProtocol();
     }
 }

package/src/lib/index.ts

@@ -0,0 +1,180 @@
+import nodeDataChannel from './node-datachannel';
+import _DataChannelStream from './datachannel-stream';
+import { WebSocketServer } from './websocket-server';
+import { Channel, DataChannelInitConfig, DescriptionType, Direction, LogLevel, RtcConfig, RTCIceConnectionState, RTCIceGatheringState, RTCPeerConnectionState, RTCSdpType, RTCSignalingState, SctpSettings, SelectedCandidateInfo } from './types';
+import { WebSocket } from './websocket';
+
+export function preload(): void { nodeDataChannel.preload(); }
+export function initLogger(level: LogLevel): void { nodeDataChannel.initLogger(level); }
+export function cleanup(): void { nodeDataChannel.cleanup(); }
+export function setSctpSettings(settings: SctpSettings): void { nodeDataChannel.setSctpSettings(settings); }
+
+export interface Audio {
+    addAudioCodec(payloadType: number, codec: string, profile?: string): void;
+    addOpusCodec(payloadType: number, profile?: string): string;
+    direction(): Direction;
+    generateSdp(eol: string, addr: string, port: number): string;
+    mid(): string;
+    setDirection(dir: Direction): void;
+    description(): string;
+    removeFormat(fmt: string): void;
+    addSSRC(ssrc: number, name?: string, msid?: string, trackID?: string): void;
+    removeSSRC(ssrc: number): void;
+    replaceSSRC(oldSsrc: number, ssrc: number, name?: string, msid?: string, trackID?: string): void;
+    hasSSRC(ssrc: number): boolean;
+    getSSRCs(): number[];
+    getCNameForSsrc(ssrc: number): string;
+    setBitrate(bitRate: number): void;
+    getBitrate(): number;
+    hasPayloadType(payloadType: number): boolean;
+    addRTXCodec(payloadType: number, originalPayloadType: number, clockRate: number): void;
+    addRTPMap(): void;
+    parseSdpLine(line: string): void;
+}
+export const Audio: {
+    new(mid: string, dir: Direction): Audio
+} = nodeDataChannel.Audio
+
+
+export interface Video {
+    addVideoCodec(payloadType: number, codec: string, profile?: string): void;
+    addH264Codec(payloadType: number, profile?: string): void;
+    addVP8Codec(payloadType: number): void;
+    addVP9Codec(payloadType: number): void;
+    direction(): Direction;
+    generateSdp(eol: string, addr: string, port: number): string;
+    mid(): string;
+    setDirection(dir: Direction): void;
+    description(): string;
+    removeFormat(fmt: string): void;
+    addSSRC(ssrc: number, name?: string, msid?: string, trackID?: string): void;
+    removeSSRC(ssrc: number): void;
+    replaceSSRC(oldSsrc: number, ssrc: number, name?: string, msid?: string, trackID?: string): void;
+    hasSSRC(ssrc: number): boolean;
+    getSSRCs(): number[];
+    getCNameForSsrc(ssrc: number): string;
+    setBitrate(bitRate: number): void;
+    getBitrate(): number;
+    hasPayloadType(payloadType: number): boolean;
+    addRTXCodec(payloadType: number, originalPayloadType: number, clockRate: number): void;
+    addRTPMap(): void;
+    parseSdpLine(line: string): void;
+}
+export const Video: {
+    new(mid: string, dir: Direction): Video
+} = nodeDataChannel.Video
+
+export interface Track {
+    direction(): Direction;
+    mid(): string;
+    type(): string;
+    close(): void;
+    sendMessage(msg: string): boolean;
+    sendMessageBinary(buffer: Buffer): boolean;
+    isOpen(): boolean;
+    isClosed(): boolean;
+    bufferedAmount(): number;
+    maxMessageSize(): number;
+    requestBitrate(bitRate: number): boolean;
+    setBufferedAmountLowThreshold(newSize: number): void;
+    requestKeyframe(): boolean;
+    setMediaHandler(handler: RtcpReceivingSession): void;
+    onOpen(cb: () => void): void;
+    onClosed(cb: () => void): void;
+    onError(cb: (err: string) => void): void;
+    onMessage(cb: (msg: Buffer) => void): void;
+}
+export const Track: {
+    new(): Track
+} = nodeDataChannel.Track
+
+export interface DataChannel extends Channel {
+    getLabel(): string;
+    getId(): number;
+    getProtocol(): string;
+
+    // Channel implementation
+    close(): void;
+    sendMessage(msg: string): boolean;
+    sendMessageBinary(buffer: Uint8Array): boolean;
+    isOpen(): boolean;
+    bufferedAmount(): number;
+    maxMessageSize(): number;
+    setBufferedAmountLowThreshold(newSize: number): void;
+    onOpen(cb: () => void): void;
+    onClosed(cb: () => void): void;
+    onError(cb: (err: string) => void): void;
+    onBufferedAmountLow(cb: () => void): void;
+    onMessage(cb: (msg: string | Buffer) => void): void;
+}
+export const DataChannel: {
+    // DataChannel implementation
+} = nodeDataChannel.DataChannel
+
+export interface PeerConnection {
+    close(): void;
+    setLocalDescription(type?: DescriptionType): void;
+    setRemoteDescription(sdp: string, type: DescriptionType): void;
+    localDescription(): { type: DescriptionType; sdp: RTCSdpType } | null;
+    remoteDescription(): { type: DescriptionType; sdp: string } | null;
+    addRemoteCandidate(candidate: string, mid: string): void;
+    createDataChannel(label: string, config?: DataChannelInitConfig): DataChannel;
+    addTrack(media: Video | Audio): Track;
+    hasMedia(): boolean;
+    state(): RTCPeerConnectionState;
+    iceState(): RTCIceConnectionState;
+    signalingState(): RTCSignalingState;
+    gatheringState(): RTCIceGatheringState;
+    onLocalDescription(cb: (sdp: string, type: DescriptionType) => void): void;
+    onLocalCandidate(cb: (candidate: string, mid: string) => void): void;
+    onStateChange(cb: (state: string) => void): void;
+    onIceStateChange(cb: (state: string) => void): void;
+    onSignalingStateChange(cb: (state: string) => void): void;
+    onGatheringStateChange(cb: (state: string) => void): void;
+    onDataChannel(cb: (dc: DataChannel) => void): void;
+    onTrack(cb: (track: Track) => void): void;
+    bytesSent(): number;
+    bytesReceived(): number;
+    rtt(): number;
+    getSelectedCandidatePair(): { local: SelectedCandidateInfo; remote: SelectedCandidateInfo } | null;
+    maxDataChannelId(): number;
+    maxMessageSize(): number;
+}
+export const PeerConnection: {
+    new(peerName: string, config: RtcConfig): PeerConnection
+} = nodeDataChannel.PeerConnection
+
+export class RtcpReceivingSession {
+    //
+}
+
+/**export {
+    Channel, DataChannelInitConfig, DescriptionType,
+    Direction, LogLevel, RtcConfig, SctpSettings,
+    SelectedCandidateInfo, RTCIceConnectionState,
+    RTCIceGathererState, RTCIceGatheringState,
+    RTCIceTransportState, RTCPeerConnectionState,
+    RTCSdpType, RTCSignalingState, RelayType,
+    ProxyServerType, TransportPolicy,
+    WebSocketServerConfiguration, IceServer, ProxyServer
+} from './types';**/
+export { WebSocketServer } from './websocket-server';
+export { WebSocket } from './websocket';
+
+export const DataChannelStream = _DataChannelStream;
+
+export default {
+    initLogger,
+    cleanup,
+    preload,
+    setSctpSettings,
+    RtcpReceivingSession,
+    Track,
+    Video,
+    Audio,
+    DataChannel,
+    PeerConnection,
+    WebSocket,
+    WebSocketServer,
+    DataChannelStream
+};

package/src/lib/node-datachannel.ts

@@ -0,0 +1,13 @@
+let nodeDataChannel;
+
+try {
+    // from dist
+    nodeDataChannel = require('../../../build/Release/node_datachannel.node');
+}
+catch (e) {
+    // from src
+    nodeDataChannel = require('../../build/Release/node_datachannel.node');
+}
+
+export default nodeDataChannel;
+

package/src/lib/types.ts

@@ -0,0 +1,126 @@
+export interface Channel {
+    close(): void;
+    sendMessage(msg: string): boolean;
+    sendMessageBinary(buffer: Uint8Array): boolean;
+    isOpen(): boolean;
+    bufferedAmount(): number;
+    maxMessageSize(): number;
+    setBufferedAmountLowThreshold(newSize: number): void;
+    onOpen(cb: () => void): void;
+    onClosed(cb: () => void): void;
+    onError(cb: (err: string) => void): void;
+    onBufferedAmountLow(cb: () => void): void;
+    onMessage(cb: (msg: string | Buffer) => void): void;
+}
+
+export interface WebSocketServerConfiguration {
+    port?: number; // default 8080
+    enableTls?: boolean; // default = false;
+    certificatePemFile?: string;
+    keyPemFile?: string;
+    keyPemPass?: string;
+    bindAddress?: string;
+    connectionTimeout?: number; // milliseconds
+    maxMessageSize?: number;
+}
+
+// Enum in d.ts is tricky
+export type LogLevel = 'Verbose' | 'Debug' | 'Info' | 'Warning' | 'Error' | 'Fatal';
+
+// SCTP Settings
+export interface SctpSettings {
+    recvBufferSize?: number;
+    sendBufferSize?: number;
+    maxChunksOnQueue?: number;
+    initialCongestionWindow?: number;
+    congestionControlModule?: number;
+    delayedSackTime?: number;
+}
+
+// Proxy Server
+export type ProxyServerType = 'Socks5' | 'Http';
+export interface ProxyServer {
+    type: ProxyServerType;
+    ip: string;
+    port: number;
+    username?: string;
+    password?: string;
+}
+
+export const enum RelayType {
+    TurnUdp = 'TurnUdp',
+    TurnTcp = 'TurnTcp',
+    TurnTls = 'TurnTls',
+}
+
+export interface IceServer {
+    hostname: string;
+    port: number;
+    username?: string;
+    password?: string;
+    relayType?: RelayType;
+}
+
+export type TransportPolicy = 'all' | 'relay';
+
+export interface RtcConfig {
+    iceServers: (string | IceServer)[];
+    proxyServer?: ProxyServer;
+    bindAddress?: string;
+    enableIceTcp?: boolean;
+    enableIceUdpMux?: boolean;
+    disableAutoNegotiation?: boolean;
+    forceMediaTransport?: boolean;
+    portRangeBegin?: number;
+    portRangeEnd?: number;
+    maxMessageSize?: number;
+    mtu?: number;
+    iceTransportPolicy?: TransportPolicy;
+}
+
+// Lowercase to match the description type string from libdatachannel
+export enum DescriptionType {
+    Unspec = 'unspec',
+    Offer = 'offer',
+    Answer = 'answer',
+    Pranswer = 'pranswer',
+    Rollback = 'rollback',
+}
+
+export type RTCSdpType = 'answer' | 'offer' | 'pranswer' | 'rollback';
+
+export type RTCIceTransportState = "checking" | "closed" | "completed" | "connected" | "disconnected" | "failed" | "new";
+export type RTCPeerConnectionState = "closed" | "connected" | "connecting" | "disconnected" | "failed" | "new";
+export type RTCIceConnectionState = "checking" | "closed" | "completed" | "connected" | "disconnected" | "failed" | "new";
+export type RTCIceGathererState = "complete" | "gathering" | "new";
+export type RTCIceGatheringState = "complete" | "gathering" | "new";
+export type RTCSignalingState = "closed" | "have-local-offer" | "have-local-pranswer" | "have-remote-offer" | "have-remote-pranswer" | "stable";
+
+
+export interface DataChannelInitConfig {
+    protocol?: string;
+    negotiated?: boolean;
+    id?: number;
+    unordered?: boolean; // Reliability
+    maxPacketLifeTime?: number; // Reliability
+    maxRetransmits?: number; // Reliability
+}
+
+export interface SelectedCandidateInfo {
+    address: string;
+    port: number;
+    type: string;
+    transportType: string;
+    candidate: string;
+    mid: string;
+    priority: number;
+}
+
+// Must be same as rtc enum class Direction
+export const enum Direction {
+    SendOnly = 'SendOnly',
+    RecvOnly = 'RecvOnly',
+    SendRecv = 'SendRecv',
+    Inactive = 'Inactive',
+    Unknown = 'Unknown',
+}

package/{lib/websocket-server.js → src/lib/websocket-server.ts}

@@ -1,11 +1,13 @@
 import { EventEmitter } from 'events';
-import nodeDataChannel from './node-datachannel.js';
+import nodeDataChannel from './node-datachannel';
+import { WebSocketServerConfiguration } from './types';
+import { WebSocket } from './websocket';
 
-export default class WebSocketServer extends EventEmitter {
-    #server;
-    #clients = [];
+export class WebSocketServer extends EventEmitter {
+    #server: any;
+    #clients: WebSocket[] = [];
 
-    constructor(options) {
+    constructor(options: WebSocketServerConfiguration) {
         super();
         this.#server = new nodeDataChannel.WebSocketServer(options);
 
@@ -15,11 +17,11 @@ export default class WebSocketServer extends EventEmitter {
         });
     }
 
-    port() {
+    port(): number {
         return this.#server?.port() || 0;
     }
 
-    stop() {
+    stop(): void {
         this.#clients.forEach((client) => {
             client?.close();
         });
@@ -28,7 +30,7 @@ export default class WebSocketServer extends EventEmitter {
         this.removeAllListeners();
     }
 
-    onClient(cb) {
+    onClient(cb: (clientSocket: WebSocket) => void): void {
         if (this.#server) this.on('client', cb);
     }
 }

package/src/lib/websocket.ts

@@ -0,0 +1,26 @@
+import nodeDataChannel from './node-datachannel';
+import { Channel, WebSocketServerConfiguration } from './types';
+
+export interface WebSocket extends Channel {
+    open(url: string): void;
+    forceClose(): void;
+    remoteAddress(): string | undefined;
+    path(): string | undefined;
+
+    // Channel implementation
+    close(): void;
+    sendMessage(msg: string): boolean;
+    sendMessageBinary(buffer: Uint8Array): boolean;
+    isOpen(): boolean;
+    bufferedAmount(): number;
+    maxMessageSize(): number;
+    setBufferedAmountLowThreshold(newSize: number): void;
+    onOpen(cb: () => void): void;
+    onClosed(cb: () => void): void;
+    onError(cb: (err: string) => void): void;
+    onBufferedAmountLow(cb: () => void): void;
+    onMessage(cb: (msg: string | Buffer) => void): void;
+}
+export const WebSocket: {
+    new(config?: WebSocketServerConfiguration): WebSocket
+} = nodeDataChannel.WebSocket