libp2p 2.10.0 → 3.0.0-049bfa0fa

package/src/upgrader.ts

@@ -1,15 +1,16 @@
 import { InvalidMultiaddrError, InvalidPeerIdError } from '@libp2p/interface'
 import * as mss from '@libp2p/multistream-select'
 import { peerIdFromString } from '@libp2p/peer-id'
-import { trackedMap } from '@libp2p/utils/tracked-map'
+import { trackedMap } from '@libp2p/utils'
+import { CODE_P2P } from '@multiformats/multiaddr'
 import { anySignal } from 'any-signal'
 import { setMaxListeners } from 'main-event'
 import { CustomProgressEvent } from 'progress-events'
 import { raceSignal } from 'race-signal'
-import { PROTOCOL_NEGOTIATION_TIMEOUT, INBOUND_UPGRADE_TIMEOUT } from './connection-manager/constants.js'
+import { PROTOCOL_NEGOTIATION_TIMEOUT, INBOUND_UPGRADE_TIMEOUT, CONNECTION_CLOSE_TIMEOUT } from './connection-manager/constants.js'
 import { createConnection } from './connection.js'
 import { ConnectionDeniedError, ConnectionInterceptedError, EncryptionFailedError, MuxerUnavailableError } from './errors.js'
-import type { Libp2pEvents, AbortOptions, ComponentLogger, MultiaddrConnection, Connection, ConnectionProtector, ConnectionEncrypter, SecuredConnection, ConnectionGater, Metrics, PeerId, PeerStore, StreamMuxerFactory, Upgrader as UpgraderInterface, UpgraderOptions, ConnectionLimits, SecureConnectionOptions, CounterGroup, ClearableSignal } from '@libp2p/interface'
+import type { Libp2pEvents, AbortOptions, ComponentLogger, MultiaddrConnection, Connection, ConnectionProtector, ConnectionEncrypter, ConnectionGater, Metrics, PeerId, PeerStore, StreamMuxerFactory, Upgrader as UpgraderInterface, UpgraderOptions, ConnectionLimits, CounterGroup, ClearableSignal, MessageStream, SecuredConnection, StreamMuxer, UpgraderWithoutEncryptionOptions, SecureConnectionOptions } from '@libp2p/interface'
 import type { ConnectionManager, Registrar } from '@libp2p/interface-internal'
 import type { TypedEventTarget } from 'main-event'
 
@@ -17,15 +18,21 @@ interface CreateConnectionOptions {
   id: string
   cryptoProtocol: string
   direction: 'inbound' | 'outbound'
+
+  /**
+   * The raw underlying connection
+   */
   maConn: MultiaddrConnection
-  upgradedConn: MultiaddrConnection
+
+  /**
+   * The encrypted, multiplexed connection
+   */
+  stream: MessageStream
+
   remotePeer: PeerId
-  muxerFactory?: StreamMuxerFactory
+  muxer?: StreamMuxer
   limits?: ConnectionLimits
-}
-
-export interface CryptoResult extends SecuredConnection<MultiaddrConnection> {
-  protocol: string
+  closeTimeout?: number
 }
 
 export interface UpgraderInit {
@@ -54,6 +61,13 @@ export interface UpgraderInit {
    * @default 2000
    */
   outboundStreamProtocolNegotiationTimeout?: number
+
+  /**
+   * How long to wait before closing a connection
+   *
+   * @default 1_000
+   */
+  connectionCloseTimeout?: number
 }
 
 export interface UpgraderComponents {
@@ -68,6 +82,10 @@ export interface UpgraderComponents {
   logger: ComponentLogger
 }
 
+interface EncryptedConnection extends SecuredConnection {
+  protocol: string
+}
+
 type ConnectionDeniedType = keyof Pick<ConnectionGater, 'denyOutboundConnection' | 'denyInboundEncryptedConnection' | 'denyOutboundEncryptedConnection' | 'denyInboundUpgradedConnection' | 'denyOutboundUpgradedConnection'>
 
 export class Upgrader implements UpgraderInterface {
@@ -85,6 +103,8 @@ export class Upgrader implements UpgraderInterface {
     outboundErrors?: CounterGroup
   }
 
+  private readonly connectionCloseTimeout?: number
+
   constructor (components: UpgraderComponents, init: UpgraderInit) {
     this.components = components
     this.connectionEncrypters = trackedMap({
@@ -108,6 +128,7 @@ export class Upgrader implements UpgraderInterface {
     this.inboundUpgradeTimeout = init.inboundUpgradeTimeout ?? INBOUND_UPGRADE_TIMEOUT
     this.inboundStreamProtocolNegotiationTimeout = init.inboundStreamProtocolNegotiationTimeout ?? PROTOCOL_NEGOTIATION_TIMEOUT
     this.outboundStreamProtocolNegotiationTimeout = init.outboundStreamProtocolNegotiationTimeout ?? PROTOCOL_NEGOTIATION_TIMEOUT
+    this.connectionCloseTimeout = init.connectionCloseTimeout ?? CONNECTION_CLOSE_TIMEOUT
     this.events = components.events
     this.metrics = {
       dials: components.metrics?.registerCounterGroup('libp2p_connection_manager_dials_total'),
@@ -148,7 +169,9 @@ export class Upgrader implements UpgraderInterface {
   /**
    * Upgrades an inbound connection
    */
-  async upgradeInbound (maConn: MultiaddrConnection, opts: UpgraderOptions): Promise<void> {
+  async upgradeInbound (maConn: MultiaddrConnection, opts: UpgraderOptions): Promise<void>
+  async upgradeInbound (maConn: MultiaddrConnection, opts: UpgraderWithoutEncryptionOptions): Promise<void>
+  async upgradeInbound (maConn: MultiaddrConnection, opts: UpgraderOptions | UpgraderWithoutEncryptionOptions): Promise<void> {
     let accepted = false
 
     // always apply upgrade timeout for incoming upgrades
@@ -159,7 +182,7 @@ export class Upgrader implements UpgraderInterface {
         inbound: true
       })
 
-      accepted = await raceSignal(this.components.connectionManager.acceptIncomingConnection(maConn), signal)
+      accepted = this.components.connectionManager.acceptIncomingConnection(maConn)
 
       if (!accepted) {
         throw new ConnectionDeniedError('Connection denied')
@@ -192,13 +215,15 @@ export class Upgrader implements UpgraderInterface {
   /**
    * Upgrades an outbound connection
    */
-  async upgradeOutbound (maConn: MultiaddrConnection, opts: UpgraderOptions): Promise<Connection> {
+  async upgradeOutbound (maConn: MultiaddrConnection, opts: UpgraderOptions): Promise<Connection>
+  async upgradeOutbound (maConn: MultiaddrConnection, opts: UpgraderWithoutEncryptionOptions): Promise<Connection>
+  async upgradeOutbound (maConn: MultiaddrConnection, opts: UpgraderOptions | UpgraderWithoutEncryptionOptions): Promise<Connection> {
     try {
       this.metrics.dials?.increment({
         outbound: true
       })
 
-      const idStr = maConn.remoteAddr.getPeerId()
+      const idStr = maConn.remoteAddr.getComponents().findLast(c => c.code === CODE_P2P)?.value
       let remotePeerId: PeerId | undefined
 
       if (idStr != null) {
@@ -226,11 +251,11 @@ export class Upgrader implements UpgraderInterface {
     }
   }
 
-  private async _performUpgrade (maConn: MultiaddrConnection, direction: 'inbound' | 'outbound', opts: UpgraderOptions): Promise<Connection> {
-    let encryptedConn: MultiaddrConnection
+  private async _performUpgrade (maConn: MultiaddrConnection, direction: 'inbound' | 'outbound', opts: UpgraderOptions | UpgraderWithoutEncryptionOptions): Promise<Connection> {
+    let stream: MessageStream = maConn
     let remotePeer: PeerId
-    let upgradedConn: MultiaddrConnection
     let muxerFactory: StreamMuxerFactory | undefined
+    let muxer: StreamMuxer | undefined
     let cryptoProtocol
 
     const id = `${(parseInt(String(Math.random() * 1e9))).toString(36)}${Date.now()}`
@@ -241,50 +266,49 @@ export class Upgrader implements UpgraderInterface {
     maConn.log.trace('starting the %s connection upgrade', direction)
 
     // Protect
-    let protectedConn = maConn
-
     if (opts?.skipProtection !== true) {
       const protector = this.components.connectionProtector
 
       if (protector != null) {
         maConn.log('protecting the %s connection', direction)
-        protectedConn = await protector.protect(maConn, opts)
+        stream = await protector.protect(stream, opts)
       }
     }
 
     try {
       // Encrypt the connection
-      encryptedConn = protectedConn
-      if (opts?.skipEncryption !== true) {
+      if (isEncryptionSkipped(opts)) {
+        if (opts.remotePeer == null) {
+          throw new InvalidMultiaddrError(`${direction} connection that skipped encryption must have a peer id`)
+        }
+
+        cryptoProtocol = 'native'
+        remotePeer = opts.remotePeer
+      } else {
+        const peerIdString = maConn.remoteAddr.getComponents().findLast(c => c.code === CODE_P2P)?.value
+        let remotePeerFromMultiaddr: PeerId | undefined
+
+        if (peerIdString != null) {
+          remotePeerFromMultiaddr = peerIdFromString(peerIdString)
+        }
+
         opts?.onProgress?.(new CustomProgressEvent(`upgrader:encrypt-${direction}-connection`));
 
         ({
-          conn: encryptedConn,
+          connection: stream,
           remotePeer,
           protocol: cryptoProtocol,
           streamMuxer: muxerFactory
         } = await (direction === 'inbound'
-          ? this._encryptInbound(protectedConn, opts)
-          : this._encryptOutbound(protectedConn, opts)
+          ? this._encryptInbound(stream, {
+            ...opts,
+            remotePeer: remotePeerFromMultiaddr
+          })
+          : this._encryptOutbound(stream, {
+            ...opts,
+            remotePeer: remotePeerFromMultiaddr
+          })
         ))
-
-        const maConn: MultiaddrConnection = {
-          ...protectedConn,
-          ...encryptedConn
-        }
-
-        await this.shouldBlockConnection(direction === 'inbound' ? 'denyInboundEncryptedConnection' : 'denyOutboundEncryptedConnection', remotePeer, maConn)
-      } else {
-        const idStr = maConn.remoteAddr.getPeerId()
-
-        if (idStr == null) {
-          throw new InvalidMultiaddrError(`${direction} connection that skipped encryption must have a peer id`)
-        }
-
-        const remotePeerId = peerIdFromString(idStr)
-
-        cryptoProtocol = 'native'
-        remotePeer = remotePeerId
       }
 
       // this can happen if we dial a multiaddr without a peer id, we only find
@@ -295,30 +319,32 @@ export class Upgrader implements UpgraderInterface {
         throw err
       }
 
-      upgradedConn = encryptedConn
+      // stream.pause()
+      await this.shouldBlockConnection(direction === 'inbound' ? 'denyInboundEncryptedConnection' : 'denyOutboundEncryptedConnection', remotePeer, maConn)
+      // stream.resume()
+
       if (opts?.muxerFactory != null) {
         muxerFactory = opts.muxerFactory
       } else if (muxerFactory == null && this.streamMuxers.size > 0) {
         opts?.onProgress?.(new CustomProgressEvent(`upgrader:multiplex-${direction}-connection`))
 
         // Multiplex the connection
-        const multiplexed = await (direction === 'inbound'
-          ? this._multiplexInbound({
-            ...protectedConn,
-            ...encryptedConn
-          }, this.streamMuxers, opts)
-          : this._multiplexOutbound({
-            ...protectedConn,
-            ...encryptedConn
-          }, this.streamMuxers, opts))
-        muxerFactory = multiplexed.muxerFactory
-        upgradedConn = multiplexed.stream
+        muxerFactory = await (direction === 'inbound'
+          ? this._multiplexInbound(stream, this.streamMuxers, opts)
+          : this._multiplexOutbound(stream, this.streamMuxers, opts))
       }
     } catch (err: any) {
-      maConn.log.error('failed to upgrade inbound connection %s %a - %e', direction === 'inbound' ? 'from' : 'to', maConn.remoteAddr, err)
+      maConn.log.error('failed to upgrade %s connection %s %a - %e', direction, direction === 'inbound' ? 'from' : 'to', maConn.remoteAddr, err)
       throw err
     }
 
+    // create the connection muxer if one is configured
+    if (muxerFactory != null) {
+      maConn.log('create muxer %s', muxerFactory.protocol)
+      muxer = muxerFactory.createStreamMuxer(stream)
+    }
+
+    // stream.pause()
     await this.shouldBlockConnection(direction === 'inbound' ? 'denyInboundUpgradedConnection' : 'denyOutboundUpgradedConnection', remotePeer, maConn)
 
     const conn = this._createConnection({
@@ -326,13 +352,16 @@ export class Upgrader implements UpgraderInterface {
       cryptoProtocol,
       direction,
       maConn,
-      upgradedConn,
-      muxerFactory,
+      stream,
+      muxer,
       remotePeer,
-      limits: opts?.limits
+      limits: opts?.limits,
+      closeTimeout: this.connectionCloseTimeout
     })
 
-    conn.log('successfully upgraded %s connection', direction)
+    conn.log('successfully upgraded connection')
+
+    // stream.resume()
 
     return conn
   }
@@ -341,59 +370,19 @@ export class Upgrader implements UpgraderInterface {
    * A convenience method for generating a new `Connection`
    */
   _createConnection (opts: CreateConnectionOptions): Connection {
-    const {
-      id,
-      cryptoProtocol,
-      direction,
-      maConn,
-      upgradedConn,
-      remotePeer,
-      muxerFactory,
-      limits
-    } = opts
-
-    let connection: Connection // eslint-disable-line prefer-const
-
-    const _timeline = maConn.timeline
-    maConn.timeline = new Proxy(_timeline, {
-      set: (...args) => {
-        if (args[1] === 'close' && args[2] != null && _timeline.close == null) {
-          // Wait for close to finish before notifying of the closure
-          (async () => {
-            try {
-              if (connection.status === 'open') {
-                await connection.close()
-              }
-            } catch (err: any) {
-              connection.log.error('error closing connection after timeline close %e', err)
-            } finally {
-              this.events.safeDispatchEvent('connection:close', {
-                detail: connection
-              })
-            }
-          })().catch(err => {
-            connection.log.error('error thrown while dispatching connection:close event %e', err)
-          })
-        }
-
-        return Reflect.set(...args)
-      }
-    })
-    maConn.timeline.upgraded = Date.now()
-
     // Create the connection
-    connection = createConnection(this.components, {
-      id,
-      maConn: upgradedConn,
-      remotePeer,
-      direction,
-      muxerFactory,
-      encryption: cryptoProtocol,
-      limits,
+    const connection = createConnection(this.components, {
+      ...opts,
       outboundStreamProtocolNegotiationTimeout: this.outboundStreamProtocolNegotiationTimeout,
       inboundStreamProtocolNegotiationTimeout: this.inboundStreamProtocolNegotiationTimeout
     })
 
+    connection.addEventListener('close', () => {
+      this.events.safeDispatchEvent('connection:close', {
+        detail: connection
+      })
+    })
+
     this.events.safeDispatchEvent('connection:open', {
       detail: connection
     })
@@ -404,28 +393,24 @@ export class Upgrader implements UpgraderInterface {
   /**
    * Attempts to encrypt the incoming `connection` with the provided `cryptos`
    */
-  async _encryptInbound (connection: MultiaddrConnection, options?: AbortOptions): Promise<CryptoResult> {
+  async _encryptInbound (connection: MessageStream, options?: SecureConnectionOptions): Promise<EncryptedConnection> {
     const protocols = Array.from(this.connectionEncrypters.keys())
 
     try {
-      const { stream, protocol } = await mss.handle(connection, protocols, {
-        ...options,
-        log: connection.log
-      })
+      const protocol = await mss.handle(connection, protocols, options)
       const encrypter = this.connectionEncrypters.get(protocol)
 
       if (encrypter == null) {
         throw new EncryptionFailedError(`no crypto module found for ${protocol}`)
       }
 
-      connection.log('encrypting inbound connection to %a using %s', connection.remoteAddr, protocol)
+      connection.log('encrypting inbound connection using %s', protocol)
 
       return {
-        ...await encrypter.secureInbound(stream, options),
+        ...await encrypter.secureInbound(connection, options),
         protocol
       }
     } catch (err: any) {
-      connection.log.error('encrypting inbound connection from %a failed', connection.remoteAddr, err)
       throw new EncryptionFailedError(err.message)
     }
   }
@@ -434,31 +419,26 @@ export class Upgrader implements UpgraderInterface {
    * Attempts to encrypt the given `connection` with the provided connection encrypters.
    * The first `ConnectionEncrypter` module to succeed will be used
    */
-  async _encryptOutbound (connection: MultiaddrConnection, options: SecureConnectionOptions): Promise<CryptoResult> {
+  async _encryptOutbound (connection: MessageStream, options?: SecureConnectionOptions): Promise<EncryptedConnection> {
     const protocols = Array.from(this.connectionEncrypters.keys())
 
     try {
       connection.log.trace('selecting encrypter from %s', protocols)
 
-      const { stream, protocol } = await mss.select(connection, protocols, {
-        ...options,
-        log: connection.log,
-        yieldBytes: true
-      })
+      const protocol = await mss.select(connection, protocols, options)
       const encrypter = this.connectionEncrypters.get(protocol)
 
       if (encrypter == null) {
         throw new EncryptionFailedError(`no crypto module found for ${protocol}`)
       }
 
-      connection.log('encrypting outbound connection to %a using %s', connection.remoteAddr, protocol)
+      connection.log('encrypting outbound connection using %s', protocol)
 
       return {
-        ...await encrypter.secureOutbound(stream, options),
+        ...await encrypter.secureOutbound(connection, options),
         protocol
       }
     } catch (err: any) {
-      connection.log.error('encrypting outbound connection to %a failed', connection.remoteAddr, err)
       throw new EncryptionFailedError(err.message)
     }
   }
@@ -467,27 +447,23 @@ export class Upgrader implements UpgraderInterface {
    * Selects one of the given muxers via multistream-select. That
    * muxer will be used for all future streams on the connection.
    */
-  async _multiplexOutbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>, options: AbortOptions): Promise<{ stream: MultiaddrConnection, muxerFactory?: StreamMuxerFactory }> {
+  async _multiplexOutbound (maConn: MessageStream, muxers: Map<string, StreamMuxerFactory>, options: AbortOptions): Promise<StreamMuxerFactory> {
     const protocols = Array.from(muxers.keys())
-    connection.log('outbound selecting muxer %s', protocols)
-    try {
-      connection.log.trace('selecting stream muxer from %s', protocols)
+    maConn.log('outbound selecting muxer %s', protocols)
 
-      const {
-        stream,
-        protocol
-      } = await mss.select(connection, protocols, {
-        ...options,
-        log: connection.log,
-        yieldBytes: true
-      })
-
-      connection.log('selected %s as muxer protocol', protocol)
+    try {
+      maConn.log.trace('selecting stream muxer from %s', protocols)
+      const protocol = await mss.select(maConn, protocols, options)
       const muxerFactory = muxers.get(protocol)
 
-      return { stream, muxerFactory }
+      if (muxerFactory == null) {
+        throw new MuxerUnavailableError(`No muxer configured for protocol "${protocol}"`)
+      }
+
+      maConn.log('selected %s as muxer protocol', protocol)
+      return muxerFactory
     } catch (err: any) {
-      connection.log.error('error multiplexing outbound connection', err)
+      maConn.log.error('error multiplexing outbound connection', err)
       throw new MuxerUnavailableError(String(err))
     }
   }
@@ -496,20 +472,23 @@ export class Upgrader implements UpgraderInterface {
    * Registers support for one of the given muxers via multistream-select. The
    * selected muxer will be used for all future streams on the connection.
    */
-  async _multiplexInbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>, options: AbortOptions): Promise<{ stream: MultiaddrConnection, muxerFactory?: StreamMuxerFactory }> {
+  async _multiplexInbound (maConn: MessageStream, muxers: Map<string, StreamMuxerFactory>, options: AbortOptions): Promise<StreamMuxerFactory> {
     const protocols = Array.from(muxers.keys())
-    connection.log('inbound handling muxers %s', protocols)
+    maConn.log('inbound handling muxers %s', protocols)
     try {
-      const { stream, protocol } = await mss.handle(connection, protocols, {
-        ...options,
-        log: connection.log
-      })
+      maConn.log.trace('selecting stream muxer from %s', protocols)
+      const protocol = await mss.handle(maConn, protocols, options)
       const muxerFactory = muxers.get(protocol)
 
-      return { stream, muxerFactory }
+      if (muxerFactory == null) {
+        throw new MuxerUnavailableError(`No muxer configured for protocol "${protocol}"`)
+      }
+
+      maConn.log('selected %s as muxer protocol', protocol)
+      return muxerFactory
     } catch (err: any) {
-      connection.log.error('error multiplexing inbound connection', err)
-      throw new MuxerUnavailableError(String(err))
+      maConn.log.error('error multiplexing inbound connection', err)
+      throw err
     }
   }
 
@@ -521,3 +500,7 @@ export class Upgrader implements UpgraderInterface {
     return this.streamMuxers
   }
 }
+
+function isEncryptionSkipped (opts?: any): opts is UpgraderWithoutEncryptionOptions {
+  return opts.skipEncryption === true
+}

package/src/utils.ts

@@ -0,0 +1,31 @@
+import type { MessageStream } from '@libp2p/interface'
+
+export function redirect (channelA: MessageStream, channelB: MessageStream): void {
+  channelA.addEventListener('message', (evt) => {
+    const sendMore = channelB.send(evt.data)
+
+    if (sendMore === false) {
+      channelA.pause()
+
+      channelA.addEventListener('drain', () => {
+        channelA.resume()
+      }, {
+        once: true
+      })
+    }
+  })
+
+  channelB.addEventListener('message', (evt) => {
+    const sendMore = channelA.send(evt.data)
+
+    if (sendMore === false) {
+      channelB.pause()
+
+      channelB.addEventListener('drain', () => {
+        channelB.resume()
+      }, {
+        once: true
+      })
+    }
+  })
+}

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '2.10.0'
+export const version = '3.0.0-049bfa0fa'
 export const name = 'js-libp2p'

package/dist/typedoc-urls.json

@@ -1,24 +0,0 @@
-{
-  "AddressFilter": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.AddressFilter.html",
-  "AddressManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.AddressManagerInit.html",
-  "ConnectionManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.ConnectionManagerInit.html",
-  "ConnectionMonitorInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.ConnectionMonitorInit.html",
-  "Libp2pInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.Libp2pInit.html",
-  ".:Libp2pInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.Libp2pInit.html",
-  "TransportManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.TransportManagerInit.html",
-  "Libp2pOptions": "https://libp2p.github.io/js-libp2p/types/libp2p.index.Libp2pOptions.html",
-  ".:Libp2pOptions": "https://libp2p.github.io/js-libp2p/types/libp2p.index.Libp2pOptions.html",
-  "ServiceFactoryMap": "https://libp2p.github.io/js-libp2p/types/libp2p.index.ServiceFactoryMap.html",
-  ".:ServiceFactoryMap": "https://libp2p.github.io/js-libp2p/types/libp2p.index.ServiceFactoryMap.html",
-  "dnsaddrResolver": "https://libp2p.github.io/js-libp2p/variables/libp2p.index.dnsaddrResolver.html",
-  "createLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.createLibp2p.html",
-  ".:createLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.createLibp2p.html",
-  "isLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.isLibp2p.html",
-  ".:isLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.isLibp2p.html",
-  "userAgent": "https://libp2p.github.io/js-libp2p/functions/libp2p.user-agent.userAgent.html",
-  "./user-agent:userAgent": "https://libp2p.github.io/js-libp2p/functions/libp2p.user-agent.userAgent.html",
-  "name": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.name.html",
-  "./version:name": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.name.html",
-  "version": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.version.html",
-  "./version:version": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.version.html"
-}