@lng2004/node-datachannel 0.32.0-20260202 → 0.32.3-20260813

package/src/lib/datachannel-stream.ts

@@ -1,100 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import * as stream from 'stream';
-
-/**
- * Turns a node-datachannel DataChannel into a real Node.js stream, complete with buffering,
- * backpressure (up to a point - if the buffer fills up, messages are dropped), and
- * support for piping data elsewhere.
- *
- * Read & written data may be either UTF-8 strings or Buffers - this difference exists at
- * the protocol level, and is preserved here throughout.
- */
-export default class DataChannelStream extends stream.Duplex {
-  private _rawChannel: any;
-  private _readActive: boolean;
-
-  constructor(rawChannel: any, streamOptions?: Omit<stream.DuplexOptions, 'objectMode'>) {
-    super({
-      allowHalfOpen: false, // Default to autoclose on end().
-      ...streamOptions,
-      objectMode: true, // Preserve the string/buffer distinction (WebRTC treats them differently)
-    });
-
-    this._rawChannel = rawChannel;
-    this._readActive = true;
-
-    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().
-      this._readActive = this.push(msg);
-    });
-
-    // When the DataChannel closes, the readable & writable ends close
-    rawChannel.onClosed(() => {
-      this.push(null);
-      this.destroy();
-    });
-
-    rawChannel.onError((errMsg: string) => {
-      this.destroy(new Error(`DataChannel error: ${errMsg}`));
-    });
-
-    // Buffer all writes until the DataChannel opens
-    if (!rawChannel.isOpen()) {
-      this.cork();
-      rawChannel.onOpen(() => this.uncork());
-    }
-  }
-
-  _read(): void {
-    // Stop dropping messages, if the buffer filling up meant we were doing so before.
-    this._readActive = true;
-  }
-
-  _write(chunk, _encoding, callback): void {
-    let sentOk;
-
-    try {
-      if (Buffer.isBuffer(chunk)) {
-        sentOk = this._rawChannel.sendMessageBinary(chunk);
-      } else if (typeof chunk === 'string') {
-        sentOk = this._rawChannel.sendMessage(chunk);
-      } else {
-        const typeName = chunk.constructor.name || typeof chunk;
-        throw new Error(`Cannot write ${typeName} to DataChannel stream`);
-      }
-    } catch (err) {
-      return callback(err);
-    }
-
-    if (sentOk) {
-      callback(null);
-    } else {
-      callback(new Error('Failed to write to DataChannel'));
-    }
-  }
-
-  _final(callback): void {
-    if (!this.allowHalfOpen) this.destroy();
-    callback(null);
-  }
-
-  _destroy(maybeErr, callback): void {
-    // When the stream is destroyed, we close the DataChannel.
-    this._rawChannel.close();
-    callback(maybeErr);
-  }
-
-  get label(): string {
-    return this._rawChannel.getLabel();
-  }
-
-  get id(): number {
-    return this._rawChannel.getId();
-  }
-
-  get protocol(): string {
-    return this._rawChannel.getProtocol();
-  }
-}

package/src/lib/index.ts

@@ -1,290 +0,0 @@
-import nodeDataChannel from './node-datachannel';
-import _DataChannelStream from './datachannel-stream';
-import { WebSocketServer } from './websocket-server';
-import {
-  Channel,
-  DataChannelInitConfig,
-  DescriptionType,
-  Direction,
-  LogLevel,
-  NalUnitSeparator,
-  ObuPacketization,
-  RtcConfig,
-  RTCIceConnectionState,
-  RTCIceGatheringState,
-  RTCPeerConnectionState,
-  RTCSignalingState,
-  SctpSettings,
-  SelectedCandidateInfo,
-} from './types';
-import { WebSocket } from './websocket';
-import type { CertificateFingerprint, IceUdpMuxRequest, LocalDescriptionInit } from './types';
-
-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 function getLibraryVersion(): string {
-  return nodeDataChannel.getLibraryVersion();
-}
-
-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;
-  addH265Codec(payloadType: number): void;
-  addVP8Codec(payloadType: number): void;
-  addVP9Codec(payloadType: number): void;
-  addAV1Codec(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: MediaHandler): 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: 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 | ArrayBuffer) => void): void;
-}
-export const DataChannel: {
-  // DataChannel implementation
-} = nodeDataChannel.DataChannel;
-
-export interface PeerConnection {
-  close(): void;
-  setLocalDescription(type?: DescriptionType, init?: LocalDescriptionInit): void;
-  setRemoteDescription(sdp: string, type: DescriptionType): void;
-  localDescription(): { type: DescriptionType; sdp: string } | null;
-  remoteDescription(): { type: DescriptionType; sdp: string } | null;
-  remoteFingerprint(): CertificateFingerprint;
-  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 interface IceUdpMuxListener {
-  address?: string;
-  port: number;
-  stop(): void;
-  onUnhandledStunRequest(cb: (req: IceUdpMuxRequest) => void): void;
-}
-export const IceUdpMuxListener: {
-  new (port: number, address?: string): IceUdpMuxListener;
-} = nodeDataChannel.IceUdpMuxListener;
-
-export interface RtpPacketizationConfig {
-  playoutDelayId: number,
-  playoutDelayMin: number,
-  playoutDelayMax: number,
-  timestamp: number,
-  get clockRate(): number
-}
-
-export const RtpPacketizationConfig: {
-  new(ssrc: number, cname: string, payloadType: number, clockRate: number, videoOrientationId?: number): RtpPacketizationConfig
-} = nodeDataChannel.RtpPacketizationConfig
-
-export interface MediaHandler {
-  addToChain(handler: MediaHandler): void
-}
-
-export interface PacingHandler extends MediaHandler {}
-
-export const PacingHandler: {
-  new (bitsPerSecond: number, sendInterval: number): PacingHandler;
-} = nodeDataChannel.PacingHandler;
-
-export interface RtcpReceivingSession extends MediaHandler {}
-
-export const RtcpReceivingSession: {
-  new (): RtcpReceivingSession;
-} = nodeDataChannel.RtcpReceivingSession;
-
-export interface RtcpNackResponder extends MediaHandler {}
-
-export const RtcpNackResponder: {
-  new (maxSize?: number): RtcpNackResponder
-} = nodeDataChannel.RtcpNackResponder;
-
-export interface RtcpSrReporter extends MediaHandler {
-  get rtpConfig(): RtpPacketizationConfig
-}
-
-export const RtcpSrReporter: {
-  new (rtpConfig: RtpPacketizationConfig): RtcpSrReporter
-} = nodeDataChannel.RtcpSrReporter;
-
-export interface RtpPacketizer extends MediaHandler {
-  get rtpConfig(): RtpPacketizationConfig
-}
-
-export const RtpPacketizer: {
-  new (rtpConfig: RtpPacketizationConfig): RtpPacketizer
-} = nodeDataChannel.RtpPacketizer;
-
-export interface H264RtpPacketizer extends RtpPacketizer {}
-
-export const H264RtpPacketizer: {
-  new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): H264RtpPacketizer
-} = nodeDataChannel.H264RtpPacketizer
-
-export interface H265RtpPacketizer extends RtpPacketizer {}
-
-export const H265RtpPacketizer: {
-  new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): H265RtpPacketizer
-} = nodeDataChannel.H265RtpPacketizer
-
-export interface AV1RtpPacketizer extends RtpPacketizer {}
-
-export const AV1RtpPacketizer: {
-  new (packetization: ObuPacketization, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): AV1RtpPacketizer
-} = nodeDataChannel.AV1RtpPacketizer
-
-export { WebSocketServer } from './websocket-server';
-export { WebSocket } from './websocket';
-
-export const DataChannelStream = _DataChannelStream;
-
-export default {
-  initLogger,
-  cleanup,
-  preload,
-  setSctpSettings,
-  getLibraryVersion,
-  PacingHandler,
-  RtcpReceivingSession,
-  RtcpNackResponder,
-  RtcpSrReporter,
-  RtpPacketizationConfig,
-  RtpPacketizer,
-  H264RtpPacketizer,
-  H265RtpPacketizer,
-  AV1RtpPacketizer,
-  Track,
-  Video,
-  Audio,
-  DataChannel,
-  PeerConnection,
-  WebSocket,
-  WebSocketServer,
-  DataChannelStream,
-  IceUdpMuxListener,
-};
-
-// Types
-// https://github.com/murat-dogan/node-datachannel/issues/300
-export * from './types';

package/src/lib/node-datachannel.ts

@@ -1,3 +0,0 @@
-// @ts-expect-error no types
-import nodeDataChannel = require('../../build/Release/node_datachannel.node');
-export default nodeDataChannel;

package/src/lib/types.ts

@@ -1,168 +0,0 @@
-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 | ArrayBuffer) => 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 type RelayType = 'TurnUdp' | 'TurnTcp' | '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;
-  disableFingerprintVerification?: boolean;
-  disableAutoGathering?: boolean;
-  certificatePemFile?: string;
-  keyPemFile?: string;
-  keyPemPass?: string;
-}
-
-// Lowercase to match the description type string from libdatachannel
-export type DescriptionType = 'unspec' | 'offer' | 'answer' | 'pranswer' | '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 LocalDescriptionInit {
-  iceUfrag?: string;
-  icePwd?: string;
-}
-
-export interface DataChannelInitConfig {
-  protocol?: string;
-  negotiated?: boolean;
-  id?: number;
-  unordered?: boolean; // Reliability
-  maxPacketLifeTime?: number; // Reliability
-  maxRetransmits?: number; // Reliability
-}
-
-export interface CertificateFingerprint {
-  /**
-   * @see https://developer.mozilla.org/en-US/docs/Web/API/RTCCertificate/getFingerprints#value
-   */
-  value: string;
-  /**
-   * @see https://developer.mozilla.org/en-US/docs/Web/API/RTCCertificate/getFingerprints#algorithm
-   */
-  algorithm: 'sha-1' | 'sha-224' | 'sha-256' | 'sha-384' | 'sha-512' | 'md5' | 'md2';
-}
-
-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 type Direction = 'SendOnly' | 'RecvOnly' | 'SendRecv' | 'Inactive' | 'Unknown';
-
-export interface IceUdpMuxRequest {
-  ufrag: string;
-  host: string;
-  port: number;
-}
-
-// Same as rtc::NalUnit::Separator
-export type NalUnitSeparator = 'Length' | 'ShortStartSequence' | 'LongStartSequence' | 'StartSequence';
-
-// Same as rtc::AV1RtpPacketizer::Packetization
-export type ObuPacketization = 'Obu' | 'TemporalUnit';

package/src/lib/websocket-server.ts

@@ -1,37 +0,0 @@
-import { EventEmitter } from 'events';
-import nodeDataChannel from './node-datachannel';
-import { WebSocketServerConfiguration } from './types';
-import { WebSocket } from './websocket';
-
-export class WebSocketServer extends EventEmitter {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  #server: any;
-  #clients: WebSocket[] = [];
-
-  constructor(options: WebSocketServerConfiguration) {
-    super();
-    this.#server = new nodeDataChannel.WebSocketServer(options);
-
-    this.#server.onClient((client) => {
-      this.emit('client', client);
-      this.#clients.push(client);
-    });
-  }
-
-  port(): number {
-    return this.#server?.port() || 0;
-  }
-
-  stop(): void {
-    this.#clients.forEach((client) => {
-      client?.close();
-    });
-    this.#server?.stop();
-    this.#server = null;
-    this.removeAllListeners();
-  }
-
-  onClient(cb: (clientSocket: WebSocket) => void): void {
-    if (this.#server) this.on('client', cb);
-  }
-}

package/src/lib/websocket.ts

@@ -1,26 +0,0 @@
-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;

package/src/polyfill/Events.ts

@@ -1,82 +0,0 @@
-import RTCDataChannel from './RTCDataChannel';
-import RTCError from './RTCError';
-
-export class RTCPeerConnectionIceEvent
-  extends Event
-  implements globalThis.RTCPeerConnectionIceEvent
-{
-  #candidate: globalThis.RTCIceCandidate;
-
-  constructor(candidate: globalThis.RTCIceCandidate) {
-    super('icecandidate');
-
-    this.#candidate = candidate;
-  }
-
-  get candidate(): globalThis.RTCIceCandidate {
-    return this.#candidate;
-  }
-
-  get url(): string {
-    return '';
-  }
-}
-
-export class RTCDataChannelEvent extends Event implements globalThis.RTCDataChannelEvent {
-  #channel: RTCDataChannel;
-
-  constructor(type: string = 'datachannel', eventInitDict: globalThis.RTCDataChannelEventInit) {
-    super(type);
-
-    if (arguments.length === 0)
-      throw new TypeError(
-        `Failed to construct 'RTCDataChannelEvent': 2 arguments required, but only ${arguments.length} present.`,
-      );
-    if (typeof eventInitDict !== 'object')
-      throw new TypeError(
-        "Failed to construct 'RTCDataChannelEvent': The provided value is not of type 'RTCDataChannelEventInit'.",
-      );
-    if (!eventInitDict.channel)
-      throw new TypeError(
-        "Failed to construct 'RTCDataChannelEvent': Failed to read the 'channel' property from 'RTCDataChannelEventInit': Required member is undefined.",
-      );
-    if (eventInitDict.channel.constructor !== RTCDataChannel)
-      throw new TypeError(
-        "Failed to construct 'RTCDataChannelEvent': Failed to read the 'channel' property from 'RTCDataChannelEventInit': Failed to convert value to 'RTCDataChannel'.",
-      );
-
-    this.#channel = eventInitDict?.channel;
-  }
-
-  get channel(): RTCDataChannel {
-    return this.#channel;
-  }
-}
-
-export class RTCErrorEvent extends Event implements globalThis.RTCErrorEvent {
-  #error: RTCError;
-  constructor(type: string, init: globalThis.RTCErrorEventInit) {
-    if (arguments.length < 2)
-      throw new TypeError(
-        `Failed to construct 'RTCErrorEvent': 2 arguments required, but only ${arguments.length} present.`,
-      );
-    if (typeof init !== 'object')
-      throw new TypeError(
-        "Failed to construct 'RTCErrorEvent': The provided value is not of type 'RTCErrorEventInit'.",
-      );
-    if (!init.error)
-      throw new TypeError(
-        "Failed to construct 'RTCErrorEvent': Failed to read the 'error' property from 'RTCErrorEventInit': Required member is undefined.",
-      );
-    if (init.error.constructor !== RTCError)
-      throw new TypeError(
-        "Failed to construct 'RTCErrorEvent': Failed to read the 'error' property from 'RTCErrorEventInit': Failed to convert value to 'RTCError'.",
-      );
-    super(type || 'error');
-    this.#error = init.error;
-  }
-
-  get error(): RTCError {
-    return this.#error;
-  }
-}