@libp2p/webrtc 4.1.9 → 4.1.10-df330695a

package/src/pb/message.ts

@@ -4,8 +4,7 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
 
-import { enumeration, encodeMessage, decodeMessage, message } from 'protons-runtime'
-import type { Codec } from 'protons-runtime'
+import { type Codec, decodeMessage, type DecodeOptions, encodeMessage, enumeration, message } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface Message {
@@ -56,7 +55,7 @@ export namespace Message {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {}
 
         const end = length == null ? reader.len : reader.pos + length
@@ -65,15 +64,18 @@ export namespace Message {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
+            case 1: {
               obj.flag = Message.Flag.codec().decode(reader)
               break
-            case 2:
+            }
+            case 2: {
               obj.message = reader.bytes()
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -88,7 +90,7 @@ export namespace Message {
     return encodeMessage(obj, Message.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): Message => {
-    return decodeMessage(buf, Message.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Message>): Message => {
+    return decodeMessage(buf, Message.codec(), opts)
   }
 }

package/src/private-to-private/initiate-connection.ts

@@ -1,7 +1,8 @@
-import { CodeError } from '@libp2p/interface'
+import { InvalidParametersError } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { pbStream } from 'it-protobuf-stream'
 import { CustomProgressEvent } from 'progress-events'
+import { SDPHandshakeFailedError } from '../error.js'
 import { DataChannelMuxerFactory } from '../muxer.js'
 import { RTCPeerConnection, RTCSessionDescription } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
@@ -41,7 +42,7 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
   const relayPeer = baseAddr.getPeerId()
 
   if (relayPeer == null) {
-    throw new CodeError('Relay peer was missing', 'ERR_INVALID_ADDRESS')
+    throw new InvalidParametersError('Relay peer was missing')
   }
 
   const connections = connectionManager.getConnections(peerIdFromString(relayPeer))
@@ -72,7 +73,7 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
 
     const stream = await connection.newStream(SIGNALING_PROTO_ID, {
       signal,
-      runOnTransientConnection: true
+      runOnLimitedConnection: true
     })
 
     const messageStream = pbStream(stream).pb(Message)
@@ -117,7 +118,7 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
       // create an offer
       const offerSdp = await peerConnection.createOffer().catch(err => {
         log.error('could not execute createOffer', err)
-        throw new CodeError('Failed to set createOffer', 'ERR_SDP_HANDSHAKE_FAILED')
+        throw new SDPHandshakeFailedError('Failed to set createOffer')
       })
 
       log.trace('initiator send SDP offer %s', offerSdp.sdp)
@@ -132,7 +133,7 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
       // set offer as local description
       await peerConnection.setLocalDescription(offerSdp).catch(err => {
         log.error('could not execute setLocalDescription', err)
-        throw new CodeError('Failed to set localDescription', 'ERR_SDP_HANDSHAKE_FAILED')
+        throw new SDPHandshakeFailedError('Failed to set localDescription')
       })
 
       onProgress?.(new CustomProgressEvent('webrtc:read-sdp-answer'))
@@ -143,7 +144,7 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
       })
 
       if (answerMessage.type !== Message.Type.SDP_ANSWER) {
-        throw new CodeError('Remote should send an SDP answer', 'ERR_SDP_HANDSHAKE_FAILED')
+        throw new SDPHandshakeFailedError('Remote should send an SDP answer')
       }
 
       log.trace('initiator receive SDP answer %s', answerMessage.data)
@@ -151,7 +152,7 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
       const answerSdp = new RTCSessionDescription({ type: 'answer', sdp: answerMessage.data })
       await peerConnection.setRemoteDescription(answerSdp).catch(err => {
         log.error('could not execute setRemoteDescription', err)
-        throw new CodeError('Failed to set remoteDescription', 'ERR_SDP_HANDSHAKE_FAILED')
+        throw new SDPHandshakeFailedError('Failed to set remoteDescription')
       })
 
       log.trace('initiator read candidates until connected')

package/src/private-to-private/pb/message.ts

@@ -4,8 +4,7 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
 
-import { enumeration, encodeMessage, decodeMessage, message } from 'protons-runtime'
-import type { Codec } from 'protons-runtime'
+import { type Codec, decodeMessage, type DecodeOptions, encodeMessage, enumeration, message } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface Message {
@@ -54,7 +53,7 @@ export namespace Message {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {}
 
         const end = length == null ? reader.len : reader.pos + length
@@ -63,15 +62,18 @@ export namespace Message {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
+            case 1: {
               obj.type = Message.Type.codec().decode(reader)
               break
-            case 2:
+            }
+            case 2: {
               obj.data = reader.string()
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -86,7 +88,7 @@ export namespace Message {
     return encodeMessage(obj, Message.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): Message => {
-    return decodeMessage(buf, Message.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Message>): Message => {
+    return decodeMessage(buf, Message.codec(), opts)
   }
 }

package/src/private-to-private/signaling-stream-handler.ts

@@ -1,6 +1,6 @@
-import { CodeError } from '@libp2p/interface'
 import { multiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { pbStream } from 'it-protobuf-stream'
+import { SDPHandshakeFailedError } from '../error.js'
 import { type RTCPeerConnection, RTCSessionDescription } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
 import { readCandidatesUntilConnected } from './util.js'
@@ -46,7 +46,7 @@ export async function handleIncomingStream ({ peerConnection, stream, signal, co
     })
 
     if (pbOffer.type !== Message.Type.SDP_OFFER) {
-      throw new CodeError(`expected message type SDP_OFFER, received: ${pbOffer.type ?? 'undefined'} `, 'ERR_SDP_HANDSHAKE_FAILED')
+      throw new SDPHandshakeFailedError(`expected message type SDP_OFFER, received: ${pbOffer.type ?? 'undefined'} `)
     }
 
     log.trace('recipient receive SDP offer %s', pbOffer.data)
@@ -58,13 +58,13 @@ export async function handleIncomingStream ({ peerConnection, stream, signal, co
 
     await peerConnection.setRemoteDescription(offer).catch(err => {
       log.error('could not execute setRemoteDescription', err)
-      throw new CodeError('Failed to set remoteDescription', 'ERR_SDP_HANDSHAKE_FAILED')
+      throw new SDPHandshakeFailedError('Failed to set remoteDescription')
     })
 
     // create and write an SDP answer
     const answer = await peerConnection.createAnswer().catch(err => {
       log.error('could not execute createAnswer', err)
-      throw new CodeError('Failed to create answer', 'ERR_SDP_HANDSHAKE_FAILED')
+      throw new SDPHandshakeFailedError('Failed to create answer')
     })
 
     log.trace('recipient send SDP answer %s', answer.sdp)
@@ -76,7 +76,7 @@ export async function handleIncomingStream ({ peerConnection, stream, signal, co
 
     await peerConnection.setLocalDescription(answer).catch(err => {
       log.error('could not execute setLocalDescription', err)
-      throw new CodeError('Failed to set localDescription', 'ERR_SDP_HANDSHAKE_FAILED')
+      throw new SDPHandshakeFailedError('Failed to set localDescription')
     })
 
     log.trace('recipient read candidates until connected')

package/src/private-to-private/transport.ts

@@ -1,8 +1,7 @@
-import { CodeError, serviceCapabilities, serviceDependencies, setMaxListeners, transportSymbol } from '@libp2p/interface'
+import { InvalidParametersError, serviceCapabilities, serviceDependencies, setMaxListeners, transportSymbol } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { multiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { WebRTC } from '@multiformats/multiaddr-matcher'
-import { codes } from '../error.js'
 import { WebRTCMultiaddrConnection } from '../maconn.js'
 import { DataChannelMuxerFactory } from '../muxer.js'
 import { getRtcConfiguration } from '../util.js'
@@ -108,7 +107,7 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
     await this.components.registrar.handle(SIGNALING_PROTO_ID, (data: IncomingStreamData) => {
       this._onProtocol(data).catch(err => { this.log.error('failed to handle incoming connect from %p', data.connection.remotePeer, err) })
     }, {
-      runOnTransientConnection: true
+      runOnLimitedConnection: true
     })
     this._started = true
   }
@@ -247,11 +246,11 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
 export function splitAddr (ma: Multiaddr): { baseAddr: Multiaddr, peerId: PeerId } {
   const addrs = ma.toString().split(WEBRTC_TRANSPORT + '/')
   if (addrs.length !== 2) {
-    throw new CodeError('webrtc protocol was not present in multiaddr', codes.ERR_INVALID_MULTIADDR)
+    throw new InvalidParametersError('webrtc protocol was not present in multiaddr')
   }
 
   if (!addrs[0].includes(CIRCUIT_RELAY_TRANSPORT)) {
-    throw new CodeError('p2p-circuit protocol was not present in multiaddr', codes.ERR_INVALID_MULTIADDR)
+    throw new InvalidParametersError('p2p-circuit protocol was not present in multiaddr')
   }
 
   // look for remote peerId
@@ -260,12 +259,12 @@ export function splitAddr (ma: Multiaddr): { baseAddr: Multiaddr, peerId: PeerId
 
   const destinationIdString = destination.getPeerId()
   if (destinationIdString == null) {
-    throw new CodeError('destination peer id was missing', codes.ERR_INVALID_MULTIADDR)
+    throw new InvalidParametersError('destination peer id was missing')
   }
 
   const lastProtoInRemote = remoteAddr.protos().pop()
   if (lastProtoInRemote === undefined) {
-    throw new CodeError('invalid multiaddr', codes.ERR_INVALID_MULTIADDR)
+    throw new InvalidParametersError('invalid multiaddr')
   }
   if (lastProtoInRemote.name !== 'p2p') {
     remoteAddr = remoteAddr.encapsulate(`/p2p/${destinationIdString}`)

package/src/private-to-private/util.ts

@@ -1,4 +1,4 @@
-import { CodeError } from '@libp2p/interface'
+import { ConnectionFailedError, InvalidMessageError } from '@libp2p/interface'
 import pDefer from 'p-defer'
 import { CustomProgressEvent } from 'progress-events'
 import { isFirefox } from '../util.js'
@@ -38,7 +38,7 @@ export const readCandidatesUntilConnected = async (pc: RTCPeerConnection, stream
       }
 
       if (message.type !== Message.Type.ICE_CANDIDATE) {
-        throw new CodeError('ICE candidate message expected', 'ERR_NOT_ICE_CANDIDATE')
+        throw new InvalidMessageError('ICE candidate message expected')
       }
 
       const candidateInit = JSON.parse(message.data ?? 'null')
@@ -86,7 +86,7 @@ function resolveOnConnected (pc: RTCPeerConnection, promise: DeferredPromise<voi
       case 'failed':
       case 'disconnected':
       case 'closed':
-        promise.reject(new CodeError('RTCPeerConnection was closed', 'ERR_CONNECTION_CLOSED_BEFORE_CONNECTED'))
+        promise.reject(new ConnectionFailedError('RTCPeerConnection was closed'))
         break
       default:
         break

package/src/private-to-public/sdp.ts

@@ -1,6 +1,7 @@
+import { InvalidParametersError } from '@libp2p/interface'
 import { type Multiaddr } from '@multiformats/multiaddr'
 import { bases, digest } from 'multiformats/basics'
-import { inappropriateMultiaddr, invalidArgument, invalidFingerprint, unsupportedHashAlgorithmCode } from '../error.js'
+import { InvalidFingerprintError, UnsupportedHashAlgorithmError } from '../error.js'
 import { MAX_MESSAGE_SIZE } from '../stream.js'
 import { CERTHASH_CODE } from './transport.js'
 import type { LoggerOptions } from '@libp2p/interface'
@@ -32,7 +33,7 @@ export function getLocalFingerprint (pc: RTCPeerConnection, options: LoggerOptio
 
   const fingerprint = localCert.getFingerprints()[0].value
   if (fingerprint == null) {
-    throw invalidFingerprint('', 'no fingerprint on local certificate')
+    throw new InvalidFingerprintError('', 'no fingerprint on local certificate')
   }
 
   return fingerprint
@@ -63,7 +64,7 @@ export function certhash (ma: Multiaddr): string {
   const certhash = tups.filter((tup) => tup[0] === CERTHASH_CODE).map((tup) => tup[1])[0]
 
   if (certhash === undefined || certhash === '') {
-    throw inappropriateMultiaddr(`Couldn't find a certhash component of multiaddr: ${ma.toString()}`)
+    throw new InvalidParametersError(`Couldn't find a certhash component of multiaddr: ${ma.toString()}`)
   }
 
   return certhash
@@ -86,7 +87,7 @@ export function ma2Fingerprint (ma: Multiaddr): string[] {
   const sdp = fingerprint.match(/.{1,2}/g)
 
   if (sdp == null) {
-    throw invalidFingerprint(fingerprint, ma.toString())
+    throw new InvalidFingerprintError(fingerprint, ma.toString())
   }
 
   return [`${prefix} ${sdp.join(':').toUpperCase()}`, fingerprint]
@@ -104,7 +105,7 @@ export function toSupportedHashFunction (code: number): 'SHA-1' | 'SHA-256' | 'S
     case 0x13:
       return 'SHA-512'
     default:
-      throw unsupportedHashAlgorithmCode(code)
+      throw new UnsupportedHashAlgorithmError(code)
   }
 }
 
@@ -148,7 +149,7 @@ export function fromMultiAddr (ma: Multiaddr, ufrag: string): RTCSessionDescript
  */
 export function munge (desc: RTCSessionDescriptionInit, ufrag: string): RTCSessionDescriptionInit {
   if (desc.sdp === undefined) {
-    throw invalidArgument("Can't munge a missing SDP")
+    throw new InvalidParametersError("Can't munge a missing SDP")
   }
 
   desc.sdp = desc.sdp

package/src/private-to-public/transport.ts

@@ -1,12 +1,12 @@
 import { noise } from '@chainsafe/libp2p-noise'
-import { transportSymbol, serviceCapabilities } from '@libp2p/interface'
+import { transportSymbol, serviceCapabilities, InvalidParametersError } from '@libp2p/interface'
 import * as p from '@libp2p/peer-id'
 import { protocols } from '@multiformats/multiaddr'
 import { WebRTCDirect } from '@multiformats/multiaddr-matcher'
 import * as Digest from 'multiformats/hashes/digest'
 import { concat } from 'uint8arrays/concat'
 import { fromString as uint8arrayFromString } from 'uint8arrays/from-string'
-import { dataChannelError, inappropriateMultiaddr, unimplemented, invalidArgument } from '../error.js'
+import { DataChannelError, InappropriateMultiaddrError, UnimplementedError } from '../error.js'
 import { WebRTCMultiaddrConnection } from '../maconn.js'
 import { DataChannelMuxerFactory } from '../muxer.js'
 import { createStream } from '../stream.js'
@@ -16,7 +16,7 @@ import * as sdp from './sdp.js'
 import { genUfrag } from './util.js'
 import type { WebRTCDialOptions } from './options.js'
 import type { DataChannelOptions } from '../index.js'
-import type { CreateListenerOptions, Transport, Listener, ComponentLogger, Logger, Connection, CounterGroup, Metrics, PeerId } from '@libp2p/interface'
+import type { CreateListenerOptions, Transport, Listener, ComponentLogger, Logger, Connection, CounterGroup, Metrics, PeerId, PrivateKey } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 /**
@@ -43,6 +43,7 @@ export const CERTHASH_CODE: number = protocols('certhash').code
  */
 export interface WebRTCDirectTransportComponents {
   peerId: PeerId
+  privateKey: PrivateKey
   metrics?: Metrics
   logger: ComponentLogger
 }
@@ -96,7 +97,7 @@ export class WebRTCDirectTransport implements Transport {
    * Create transport listeners no supported by browsers
    */
   createListener (options: CreateListenerOptions): Listener {
-    throw unimplemented('WebRTCTransport.createListener')
+    throw new UnimplementedError('WebRTCTransport.createListener')
   }
 
   /**
@@ -122,7 +123,7 @@ export class WebRTCDirectTransport implements Transport {
 
     const remotePeerString = ma.getPeerId()
     if (remotePeerString === null) {
-      throw inappropriateMultiaddr("we need to have the remote's PeerId")
+      throw new InappropriateMultiaddrError("we need to have the remote's PeerId")
     }
     const theirPeerId = p.peerIdFromString(remotePeerString)
 
@@ -153,7 +154,7 @@ export class WebRTCDirectTransport implements Transport {
           const error = `Data channel was never opened: state: ${handshakeDataChannel.readyState}`
           this.log.error(error)
           this.metrics?.dialerEvents.increment({ open_error: true })
-          reject(dataChannelError('data', error))
+          reject(new DataChannelError('data', error))
         }, HANDSHAKE_TIMEOUT_MS)
 
         handshakeDataChannel.onopen = (_) => {
@@ -169,7 +170,7 @@ export class WebRTCDirectTransport implements Transport {
           this.log.error(error)
           // NOTE: We use unknown error here but this could potentially be considered a reset by some standards.
           this.metrics?.dialerEvents.increment({ unknown_error: true })
-          reject(dataChannelError('data', error))
+          reject(new DataChannelError('data', error))
         }
       })
 
@@ -190,8 +191,6 @@ export class WebRTCDirectTransport implements Transport {
       // wait for peerconnection.onopen to fire, or for the datachannel to open
       const handshakeDataChannel = await dataChannelOpenPromise
 
-      const myPeerId = this.components.peerId
-
       // Do noise handshake.
       // Set the Noise Prologue to libp2p-webrtc-noise:<FINGERPRINTS> before starting the actual Noise handshake.
       // <FINGERPRINTS> is the concatenation of the of the two TLS fingerprints of A and B in their multihash byte representation, sorted in ascending order.
@@ -260,7 +259,10 @@ export class WebRTCDirectTransport implements Transport {
 
       // For outbound connections, the remote is expected to start the noise handshake.
       // Therefore, we need to secure an inbound noise connection from the remote.
-      await connectionEncrypter.secureInbound(myPeerId, wrappedDuplex, theirPeerId)
+      await connectionEncrypter.secureInbound(wrappedDuplex, {
+        signal,
+        remotePeer: theirPeerId
+      })
 
       return await options.upgrader.upgradeOutbound(maConn, { skipProtection: true, skipEncryption: true, muxerFactory })
     } catch (err) {
@@ -275,14 +277,14 @@ export class WebRTCDirectTransport implements Transport {
    */
   private generateNoisePrologue (pc: RTCPeerConnection, hashCode: number, ma: Multiaddr): Uint8Array {
     if (pc.getConfiguration().certificates?.length === 0) {
-      throw invalidArgument('no local certificate')
+      throw new InvalidParametersError('no local certificate')
     }
 
     const localFingerprint = sdp.getLocalFingerprint(pc, {
       log: this.log
     })
     if (localFingerprint == null) {
-      throw invalidArgument('no local fingerprint found')
+      throw new InvalidParametersError('no local fingerprint found')
     }
 
     const localFpString = localFingerprint.trim().toLowerCase().replaceAll(':', '')

package/src/stream.ts

@@ -1,9 +1,9 @@
-import { CodeError } from '@libp2p/interface'
+import { StreamStateError, TimeoutError } from '@libp2p/interface'
 import { AbstractStream, type AbstractStreamInit } from '@libp2p/utils/abstract-stream'
 import * as lengthPrefixed from 'it-length-prefixed'
 import { type Pushable, pushable } from 'it-pushable'
 import pDefer from 'p-defer'
-import { pEvent, TimeoutError } from 'p-event'
+import { pEvent } from 'p-event'
 import pTimeout from 'p-timeout'
 import { raceSignal } from 'race-signal'
 import { encodingLength } from 'uint8-varint'
@@ -174,7 +174,7 @@ export class WebRTCStream extends AbstractStream {
 
       default:
         this.log.error('unknown datachannel state %s', this.channel.readyState)
-        throw new CodeError('Unknown datachannel state', 'ERR_INVALID_STATE')
+        throw new StreamStateError('Unknown datachannel state')
     }
 
     // handle RTCDataChannel events
@@ -236,7 +236,7 @@ export class WebRTCStream extends AbstractStream {
         await pEvent(this.channel, 'bufferedamountlow', { timeout: this.bufferedAmountLowEventTimeout })
       } catch (err: any) {
         if (err instanceof TimeoutError) {
-          throw new CodeError(`Timed out waiting for DataChannel buffer to clear after ${this.bufferedAmountLowEventTimeout}ms`, 'ERR_BUFFER_CLEAR_TIMEOUT')
+          throw new TimeoutError(`Timed out waiting for DataChannel buffer to clear after ${this.bufferedAmountLowEventTimeout}ms`)
         }
 
         throw err
@@ -244,7 +244,7 @@ export class WebRTCStream extends AbstractStream {
     }
 
     if (this.channel.readyState === 'closed' || this.channel.readyState === 'closing') {
-      throw new CodeError(`Invalid datachannel state - ${this.channel.readyState}`, 'ERR_INVALID_STATE')
+      throw new StreamStateError(`Invalid datachannel state - ${this.channel.readyState}`)
     }
 
     if (this.channel.readyState !== 'open') {
@@ -285,7 +285,7 @@ export class WebRTCStream extends AbstractStream {
       try {
         await raceSignal(this.receiveFinAck.promise, options?.signal, {
           errorMessage: 'sending close-write was aborted before FIN_ACK was received',
-          errorCode: 'ERR_FIN_ACK_NOT_RECEIVED'
+          errorName: 'FinAckNotReceivedError'
         })
       } catch (err) {
         this.log.error('failed to await FIN_ACK', err)

package/dist/typedoc-urls.json

@@ -1,8 +0,0 @@
-{
-  "DataChannelOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.DataChannelOptions.html",
-  ".:DataChannelOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.DataChannelOptions.html",
-  "webRTC": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTC.html",
-  ".:webRTC": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTC.html",
-  "webRTCDirect": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTCDirect.html",
-  ".:webRTCDirect": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTCDirect.html"
-}