webpeerjs 0.0.10 → 0.1.0

package/dist/umd/webpeerjs.js

@@ -15,6 +15,7 @@
     const CONFIG_PEER_DISCOVERY_GLOBAL = '_peer-discovery._p2p._pubsub';
     const CONFIG_PEER_DISCOVERY_WEBPEERJS= prefix$1+'-peer-discovery';
     const CONFIG_PUBSUB_PEER_DISCOVERY = [CONFIG_PEER_DISCOVERY_GLOBAL, CONFIG_PEER_DISCOVERY_UNIVERSAL_CONNECTIVITY, CONFIG_PEER_DISCOVERY_WEBPEERJS];
+    const CONFIG_PUPSUB_PEER_DATA = ['_'+prefix$1+'-peer-data_'];
     const CONFIG_DELEGATED_API = 'https://delegated-ipfs.dev';
     const CONFIG_DNS_RESOLVER = 'https://dns.google/resolve';
     const CONFIG_KNOWN_BOOTSTRAP_DNS = '_dnsaddr.bootstrap.libp2p.io';
@@ -3417,6 +3418,7 @@
     }
     // Error codes
     const ERR_TIMEOUT = 'ERR_TIMEOUT';
+    const ERR_INVALID_MESSAGE = 'ERR_INVALID_MESSAGE';
 
     /** Noop for browser compatibility */
     function setMaxListeners$1() { }
@@ -3572,6 +3574,14 @@
      * value should be a string array of provided capabilities.
      */
     const serviceCapabilities = Symbol.for('@libp2p/service-capabilities');
+    /**
+     * This symbol is used by libp2p services to define the capabilities they
+     * require from other libp2p services.
+     *
+     * The service should define a property with this symbol as the key and the
+     * value should be a string array of required capabilities.
+     */
+    const serviceDependencies = Symbol.for('@libp2p/service-dependencies');
 
     /**
      * Returns true if the two passed Uint8Arrays have the same content
@@ -3946,7 +3956,7 @@
 
     const V = -1;
     const names = {};
-    const codes$3 = {};
+    const codes$4 = {};
     const table = [
         [4, 32, 'ip4'],
         [6, 16, 'tcp'],
@@ -3995,7 +4005,7 @@
     // populate tables
     table.forEach(row => {
         const proto = createProtocol(...row);
-        codes$3[proto.code] = proto;
+        codes$4[proto.code] = proto;
         names[proto.name] = proto;
     });
     function createProtocol(code, size, name, resolvable, path) {
@@ -4021,8 +4031,8 @@
      */
     function getProtocol(proto) {
         if (typeof proto === 'number') {
-            if (codes$3[proto] != null) {
-                return codes$3[proto];
+            if (codes$4[proto] != null) {
+                return codes$4[proto];
             }
             throw new Error(`no protocol with code: ${proto}`);
         }
@@ -6719,7 +6729,7 @@
     	}
     }
 
-    var browser = {exports: {}};
+    var browser$1 = {exports: {}};
 
     /**
      * Helpers.
@@ -7436,9 +7446,9 @@
     			return '[UnexpectedJSONParseError]: ' + error.message;
     		}
     	}; 
-    } (browser, browser.exports));
+    } (browser$1, browser$1.exports));
 
-    var browserExports = browser.exports;
+    var browserExports = browser$1.exports;
     var debug = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
 
     /**
@@ -19198,7 +19208,7 @@
     }
 
     const log$1 = logger('delegated-routing-v1-http-api-client');
-    const defaultValues$1 = {
+    const defaultValues$2 = {
         concurrentRequests: 4,
         timeout: 30e3
     };
@@ -19218,10 +19228,10 @@
             this.shutDownController = new AbortController();
             setMaxListeners(Infinity, this.shutDownController.signal);
             this.httpQueue = new PQueue({
-                concurrency: init.concurrentRequests ?? defaultValues$1.concurrentRequests
+                concurrency: init.concurrentRequests ?? defaultValues$2.concurrentRequests
             });
             this.clientUrl = url instanceof URL ? url : new URL(url);
-            this.timeout = init.timeout ?? defaultValues$1.timeout;
+            this.timeout = init.timeout ?? defaultValues$2.timeout;
             this.contentRouting = new DelegatedRoutingV1HttpApiClientContentRouting(this);
             this.peerRouting = new DelegatedRoutingV1HttpApiClientPeerRouting(this);
         }
@@ -19728,7 +19738,7 @@
         return peerIdFromKeys(marshalPublicKey(privateKey.public), marshalPrivateKey(privateKey));
     }
 
-    const codes$2 = {
+    const codes$3 = {
         ERR_SIGNATURE_NOT_VALID: 'ERR_SIGNATURE_NOT_VALID'
     };
 
@@ -19849,7 +19859,7 @@
             const envelope = await RecordEnvelope.createFromProtobuf(data);
             const valid = await envelope.validate(domain);
             if (!valid) {
-                throw new CodeError$2('envelope signature is not valid for the given domain', codes$2.ERR_SIGNATURE_NOT_VALID);
+                throw new CodeError$2('envelope signature is not valid for the given domain', codes$3.ERR_SIGNATURE_NOT_VALID);
             }
             return envelope;
         };
@@ -20538,7 +20548,7 @@
         return mutexes[opts.name];
     }
 
-    const codes$1 = {
+    const codes$2 = {
         ERR_INVALID_PARAMETERS: 'ERR_INVALID_PARAMETERS'
     };
 
@@ -20880,7 +20890,7 @@
     const NAMESPACE_COMMON = '/peers/';
     function peerIdToDatastoreKey(peerId) {
         if (!isPeerId(peerId) || peerId.type == null) {
-            throw new CodeError$2('Invalid PeerId', codes$1.ERR_INVALID_PARAMETERS);
+            throw new CodeError$2('Invalid PeerId', codes$2.ERR_INVALID_PARAMETERS);
         }
         const b32key = peerId.toCID().toString();
         return new Key(`${NAMESPACE_COMMON}${b32key}`);
@@ -20896,7 +20906,7 @@
                 addr.multiaddr = multiaddr(addr.multiaddr);
             }
             if (!isMultiaddr(addr.multiaddr)) {
-                throw new CodeError$2('Multiaddr was invalid', codes$1.ERR_INVALID_PARAMETERS);
+                throw new CodeError$2('Multiaddr was invalid', codes$2.ERR_INVALID_PARAMETERS);
             }
             if (!(await filter(peerId, addr.multiaddr))) {
                 continue;
@@ -20926,14 +20936,14 @@
 
     async function toPeerPB(peerId, data, strategy, options) {
         if (data == null) {
-            throw new CodeError$2('Invalid PeerData', codes$1.ERR_INVALID_PARAMETERS);
+            throw new CodeError$2('Invalid PeerData', codes$2.ERR_INVALID_PARAMETERS);
         }
         if (data.publicKey != null && peerId.publicKey != null && !equals(data.publicKey, peerId.publicKey)) {
-            throw new CodeError$2('publicKey bytes do not match peer id publicKey bytes', codes$1.ERR_INVALID_PARAMETERS);
+            throw new CodeError$2('publicKey bytes do not match peer id publicKey bytes', codes$2.ERR_INVALID_PARAMETERS);
         }
         const existingPeer = options.existingPeer;
         if (existingPeer != null && !peerId.equals(existingPeer.id)) {
-            throw new CodeError$2('peer id did not match existing peer id', codes$1.ERR_INVALID_PARAMETERS);
+            throw new CodeError$2('peer id did not match existing peer id', codes$2.ERR_INVALID_PARAMETERS);
         }
         let addresses = existingPeer?.addresses ?? [];
         let protocols = new Set(existingPeer?.protocols ?? []);
@@ -21061,30 +21071,30 @@
     }
     function validateMetadata(key, value) {
         if (typeof key !== 'string') {
-            throw new CodeError$2('Metadata key must be a string', codes$1.ERR_INVALID_PARAMETERS);
+            throw new CodeError$2('Metadata key must be a string', codes$2.ERR_INVALID_PARAMETERS);
         }
         if (!(value instanceof Uint8Array)) {
-            throw new CodeError$2('Metadata value must be a Uint8Array', codes$1.ERR_INVALID_PARAMETERS);
+            throw new CodeError$2('Metadata value must be a Uint8Array', codes$2.ERR_INVALID_PARAMETERS);
         }
     }
     function validateTag(key, tag) {
         if (typeof key !== 'string') {
-            throw new CodeError$2('Tag name must be a string', codes$1.ERR_INVALID_PARAMETERS);
+            throw new CodeError$2('Tag name must be a string', codes$2.ERR_INVALID_PARAMETERS);
         }
         if (tag.value != null) {
             if (parseInt(`${tag.value}`, 10) !== tag.value) {
-                throw new CodeError$2('Tag value must be an integer', codes$1.ERR_INVALID_PARAMETERS);
+                throw new CodeError$2('Tag value must be an integer', codes$2.ERR_INVALID_PARAMETERS);
             }
             if (tag.value < 0 || tag.value > 100) {
-                throw new CodeError$2('Tag value must be between 0-100', codes$1.ERR_INVALID_PARAMETERS);
+                throw new CodeError$2('Tag value must be between 0-100', codes$2.ERR_INVALID_PARAMETERS);
             }
         }
         if (tag.ttl != null) {
             if (parseInt(`${tag.ttl}`, 10) !== tag.ttl) {
-                throw new CodeError$2('Tag ttl must be an integer', codes$1.ERR_INVALID_PARAMETERS);
+                throw new CodeError$2('Tag ttl must be an integer', codes$2.ERR_INVALID_PARAMETERS);
             }
             if (tag.ttl < 0) {
-                throw new CodeError$2('Tag ttl must be between greater than 0', codes$1.ERR_INVALID_PARAMETERS);
+                throw new CodeError$2('Tag ttl must be between greater than 0', codes$2.ERR_INVALID_PARAMETERS);
             }
         }
     }
@@ -21148,7 +21158,7 @@
         }
         async delete(peerId) {
             if (this.peerId.equals(peerId)) {
-                throw new CodeError$2('Cannot delete self peer', codes$1.ERR_INVALID_PARAMETERS);
+                throw new CodeError$2('Cannot delete self peer', codes$2.ERR_INVALID_PARAMETERS);
             }
             await this.datastore.delete(peerIdToDatastoreKey(peerId));
         }
@@ -22568,7 +22578,7 @@
      * DNS.matches(multiaddr('/dns6/example.org')) // true
      * ```
      */
-    fmt(or$1(_DNS, _DNSADDR, _DNS4, _DNS6));
+    const DNS$2 = fmt(or$1(_DNS, _DNSADDR, _DNS4, _DNS6));
     const _IP4 = and$1(literal('ip4'), func(isIPv4));
     const _IP6 = and$1(literal('ip6'), func(isIPv6));
     const _IP = or$1(_IP4, _IP6);
@@ -22588,6 +22598,20 @@
      * ```
      */
     const IP_OR_DOMAIN = fmt(_IP_OR_DOMAIN);
+    /**
+     * Matches ip4 or ip6 addresses.
+     *
+     * @example
+     *
+     * ```ts
+     * import { multiaddr } from '@multiformats/multiaddr'
+     * import { IP } from '@multiformats/multiaddr-matcher'
+     *
+     * IP.matches(multiaddr('/ip4/123.123.123.123')) // true
+     * IP.matches(multiaddr('/ip6/fe80::1cc1:a3b8:322f:cf22')) // true
+     * ```
+     */
+    const IP$1 = fmt(_IP);
     const _TCP = and$1(_IP_OR_DOMAIN, literal('tcp'), number$1());
     const _UDP = and$1(_IP_OR_DOMAIN, literal('udp'), number$1());
     const TCP_OR_UDP = or$1(_TCP, _UDP);
@@ -22627,7 +22651,20 @@
      * ```
      */
     const Circuit$1 = fmt(_Circuit$1);
-    or$1(and$1(_P2P$1, literal('p2p-circuit'), literal('webrtc'), peerId()), and$1(_P2P$1, literal('webrtc'), optional(peerId())), literal('webrtc'));
+    const _WebRTC = or$1(and$1(_P2P$1, literal('p2p-circuit'), literal('webrtc'), peerId()), and$1(_P2P$1, literal('webrtc'), optional(peerId())), literal('webrtc'));
+    /**
+     * Matches WebRTC addresses
+     *
+     * @example
+     *
+     * ```ts
+     * import { multiaddr } from '@multiformats/multiaddr'
+     * import { WebRTC } from '@multiformats/multiaddr-matcher'
+     *
+     * WebRTC.matches(multiaddr('/ip4/123.123.123.123/tcp/1234/p2p/QmRelay/p2p-circuit/webrtc/p2p/QmTarget')) // true
+     * ```
+     */
+    const WebRTC = fmt(_WebRTC);
     or$1(and$1(_IP_OR_DOMAIN, literal('tcp'), number$1(), literal('http'), optional(peerId())), and$1(_IP_OR_DOMAIN, literal('http'), optional(peerId())));
     or$1(and$1(_IP_OR_DOMAIN, literal('tcp'), or$1(and$1(literal('443'), literal('http')), and$1(number$1(), literal('https'))), optional(peerId())), and$1(_IP_OR_DOMAIN, literal('tls'), literal('http'), optional(peerId())), and$1(_IP_OR_DOMAIN, literal('https'), optional(peerId())));
 
@@ -23360,7 +23397,7 @@
         messages["ERR_PROTECTOR_REQUIRED"] = "Private network is enforced, but no protector was provided";
         messages["NOT_FOUND"] = "Not found";
     })(messages || (messages = {}));
-    var codes;
+    var codes$1;
     (function (codes) {
         codes["ERR_PROTECTOR_REQUIRED"] = "ERR_PROTECTOR_REQUIRED";
         codes["ERR_PEER_DIAL_INTERCEPTED"] = "ERR_PEER_DIAL_INTERCEPTED";
@@ -23421,7 +23458,7 @@
         codes["ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS"] = "ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS";
         codes["ERR_CONNECTION_DENIED"] = "ERR_CONNECTION_DENIED";
         codes["ERR_TRANSFER_LIMIT_EXCEEDED"] = "ERR_TRANSFER_LIMIT_EXCEEDED";
-    })(codes || (codes = {}));
+    })(codes$1 || (codes$1 = {}));
 
     const DefaultConfig = {
         addresses: {
@@ -23443,10 +23480,10 @@
     async function validateConfig(opts) {
         const resultingOptions = mergeOptions$1(DefaultConfig, opts);
         if (resultingOptions.connectionProtector === null && globalThis.process?.env?.LIBP2P_FORCE_PNET != null) { // eslint-disable-line no-undef
-            throw new CodeError$2(messages.ERR_PROTECTOR_REQUIRED, codes.ERR_PROTECTOR_REQUIRED);
+            throw new CodeError$2(messages.ERR_PROTECTOR_REQUIRED, codes$1.ERR_PROTECTOR_REQUIRED);
         }
         if (!(await peerIdFromKeys(resultingOptions.privateKey.public.bytes, resultingOptions.privateKey.bytes)).equals(resultingOptions.peerId)) {
-            throw new CodeError$2('Private key doesn\'t match peer id', codes.ERR_INVALID_KEY);
+            throw new CodeError$2('Private key doesn\'t match peer id', codes$1.ERR_INVALID_KEY);
         }
         return resultingOptions;
     }
@@ -23710,18 +23747,18 @@
             // ensure PeerId is either not set or is consistent
             peer.forEach(ma => {
                 if (!isMultiaddr(ma)) {
-                    throw new CodeError$2('Invalid Multiaddr', codes.ERR_INVALID_MULTIADDR);
+                    throw new CodeError$2('Invalid Multiaddr', codes$1.ERR_INVALID_MULTIADDR);
                 }
                 const maPeerIdStr = ma.getPeerId();
                 if (maPeerIdStr == null) {
                     if (peerId != null) {
-                        throw new CodeError$2('Multiaddrs must all have the same peer id or have no peer id', codes.ERR_INVALID_PARAMETERS);
+                        throw new CodeError$2('Multiaddrs must all have the same peer id or have no peer id', codes$1.ERR_INVALID_PARAMETERS);
                     }
                 }
                 else {
                     const maPeerId = peerIdFromString(maPeerIdStr);
                     if (peerId == null || !peerId.equals(maPeerId)) {
-                        throw new CodeError$2('Multiaddrs must all have the same peer id or have no peer id', codes.ERR_INVALID_PARAMETERS);
+                        throw new CodeError$2('Multiaddrs must all have the same peer id or have no peer id', codes$1.ERR_INVALID_PARAMETERS);
                     }
                 }
             });
@@ -24911,7 +24948,7 @@
                     for (const address of addrsToDial) {
                         if (dialed === this.maxPeerAddrsToDial) {
                             this.log('dialed maxPeerAddrsToDial (%d) addresses for %p, not trying any others', dialed, peerId);
-                            throw new CodeError$2('Peer had more than maxPeerAddrsToDial', codes.ERR_TOO_MANY_ADDRESSES);
+                            throw new CodeError$2('Peer had more than maxPeerAddrsToDial', codes$1.ERR_TOO_MANY_ADDRESSES);
                         }
                         dialed++;
                         try {
@@ -24947,7 +24984,7 @@
                     if (errors.length === 1) {
                         throw errors[0];
                     }
-                    throw new AggregateCodeError(errors, 'All multiaddr dials failed', codes.ERR_TRANSPORT_DIAL_FAILED);
+                    throw new AggregateCodeError(errors, 'All multiaddr dials failed', codes$1.ERR_TRANSPORT_DIAL_FAILED);
                 }
                 finally {
                     // clean up abort signals/controllers
@@ -24980,10 +25017,10 @@
             // if a peer id or multiaddr(s) with a peer id, make sure it isn't our peer id and that we are allowed to dial it
             if (peerId != null) {
                 if (this.components.peerId.equals(peerId)) {
-                    throw new CodeError$2('Tried to dial self', codes.ERR_DIALED_SELF);
+                    throw new CodeError$2('Tried to dial self', codes$1.ERR_DIALED_SELF);
                 }
                 if ((await this.components.connectionGater.denyDialPeer?.(peerId)) === true) {
-                    throw new CodeError$2('The dial request is blocked by gater.allowDialPeer', codes.ERR_PEER_DIAL_INTERCEPTED);
+                    throw new CodeError$2('The dial request is blocked by gater.allowDialPeer', codes$1.ERR_PEER_DIAL_INTERCEPTED);
                 }
                 // if just a peer id was passed, load available multiaddrs for this peer
                 // from the peer store
@@ -24995,7 +25032,7 @@
                         this.log('loaded multiaddrs for %p', peerId, addrs.map(({ multiaddr }) => multiaddr.toString()));
                     }
                     catch (err) {
-                        if (err.code !== codes.ERR_NOT_FOUND) {
+                        if (err.code !== codes$1.ERR_NOT_FOUND) {
                             throw err;
                         }
                     }
@@ -25013,7 +25050,7 @@
                         })));
                     }
                     catch (err) {
-                        if (err.code !== codes.ERR_NO_ROUTERS_AVAILABLE) {
+                        if (err.code !== codes$1.ERR_NO_ROUTERS_AVAILABLE) {
                             this.log.error('looking up multiaddrs for %p in the peer routing failed', peerId, err);
                         }
                     }
@@ -25083,7 +25120,7 @@
             const dedupedMultiaddrs = [...dedupedAddrs.values()];
             // make sure we actually have some addresses to dial
             if (dedupedMultiaddrs.length === 0) {
-                throw new CodeError$2('The dial request has no valid addresses', codes.ERR_NO_VALID_ADDRESSES);
+                throw new CodeError$2('The dial request has no valid addresses', codes$1.ERR_NO_VALID_ADDRESSES);
             }
             const gatedAdrs = [];
             for (const addr of dedupedMultiaddrs) {
@@ -25095,7 +25132,7 @@
             const sortedGatedAddrs = gatedAdrs.sort(this.addressSorter);
             // make sure we actually have some addresses to dial
             if (sortedGatedAddrs.length === 0) {
-                throw new CodeError$2('The connection gater denied all addresses in the dial request', codes.ERR_NO_VALID_ADDRESSES);
+                throw new CodeError$2('The connection gater denied all addresses in the dial request', codes$1.ERR_NO_VALID_ADDRESSES);
             }
             this.log.trace('addresses for %p before filtering', peerId ?? 'unknown peer', resolvedAddresses.map(({ multiaddr }) => multiaddr.toString()));
             this.log.trace('addresses for %p after filtering', peerId ?? 'unknown peer', sortedGatedAddrs.map(({ multiaddr }) => multiaddr.toString()));
@@ -25157,7 +25194,7 @@
             this.maxConnections = init.maxConnections ?? defaultOptions.maxConnections;
             const minConnections = init.minConnections ?? defaultOptions.minConnections;
             if (this.maxConnections < minConnections) {
-                throw new CodeError$2('Connection Manager maxConnections must be greater than minConnections', codes.ERR_INVALID_PARAMETERS);
+                throw new CodeError$2('Connection Manager maxConnections must be greater than minConnections', codes$1.ERR_INVALID_PARAMETERS);
             }
             /**
              * Map of connections per peer
@@ -25410,7 +25447,7 @@
         }
         async openConnection(peerIdOrMultiaddr, options = {}) {
             if (!this.isStarted()) {
-                throw new CodeError$2('Not started', codes.ERR_NODE_NOT_STARTED);
+                throw new CodeError$2('Not started', codes$1.ERR_NODE_NOT_STARTED);
             }
             options.signal?.throwIfAborted();
             const { peerId } = getPeerAddress(peerIdOrMultiaddr);
@@ -25543,7 +25580,7 @@
          */
         async *findProviders(key, options = {}) {
             if (this.routers.length === 0) {
-                throw new CodeError$2('No content routers available', codes.ERR_NO_ROUTERS_AVAILABLE);
+                throw new CodeError$2('No content routers available', codes$1.ERR_NO_ROUTERS_AVAILABLE);
             }
             const self = this;
             const seen = new PeerSet();
@@ -25573,7 +25610,7 @@
          */
         async provide(key, options = {}) {
             if (this.routers.length === 0) {
-                throw new CodeError$2('No content routers available', codes.ERR_NO_ROUTERS_AVAILABLE);
+                throw new CodeError$2('No content routers available', codes$1.ERR_NO_ROUTERS_AVAILABLE);
             }
             await Promise.all(this.routers.map(async (router) => {
                 await router.provide(key, options);
@@ -25584,7 +25621,7 @@
          */
         async put(key, value, options) {
             if (!this.isStarted()) {
-                throw new CodeError$2(messages.NOT_STARTED_YET, codes.ERR_NODE_NOT_STARTED);
+                throw new CodeError$2(messages.NOT_STARTED_YET, codes$1.ERR_NODE_NOT_STARTED);
             }
             await Promise.all(this.routers.map(async (router) => {
                 await router.put(key, value, options);
@@ -25596,7 +25633,7 @@
          */
         async get(key, options) {
             if (!this.isStarted()) {
-                throw new CodeError$2(messages.NOT_STARTED_YET, codes.ERR_NODE_NOT_STARTED);
+                throw new CodeError$2(messages.NOT_STARTED_YET, codes$1.ERR_NODE_NOT_STARTED);
             }
             return Promise.any(this.routers.map(async (router) => {
                 return router.get(key, options);
@@ -25813,10 +25850,10 @@
          */
         async findPeer(id, options) {
             if (this.routers.length === 0) {
-                throw new CodeError$2('No peer routers available', codes.ERR_NO_ROUTERS_AVAILABLE);
+                throw new CodeError$2('No peer routers available', codes$1.ERR_NO_ROUTERS_AVAILABLE);
             }
             if (id.toString() === this.peerId.toString()) {
-                throw new CodeError$2('Should not try to find self', codes.ERR_FIND_SELF);
+                throw new CodeError$2('Should not try to find self', codes$1.ERR_FIND_SELF);
             }
             const self = this;
             const source = merge$1(...this.routers.map(router => (async function* () {
@@ -25839,14 +25876,14 @@
                 }
                 return peer;
             }
-            throw new CodeError$2(messages.NOT_FOUND, codes.ERR_NOT_FOUND);
+            throw new CodeError$2(messages.NOT_FOUND, codes$1.ERR_NOT_FOUND);
         }
         /**
          * Attempt to find the closest peers on the network to the given key
          */
         async *getClosestPeers(key, options = {}) {
             if (this.routers.length === 0) {
-                throw new CodeError$2('No peer routers available', codes.ERR_NO_ROUTERS_AVAILABLE);
+                throw new CodeError$2('No peer routers available', codes$1.ERR_NO_ROUTERS_AVAILABLE);
             }
             const self = this;
             const seen = new PeerSet();
@@ -26022,7 +26059,7 @@
         getHandler(protocol) {
             const handler = this.handlers.get(protocol);
             if (handler == null) {
-                throw new CodeError$2(`No handler registered for protocol ${protocol}`, codes.ERR_NO_HANDLER_FOR_PROTOCOL);
+                throw new CodeError$2(`No handler registered for protocol ${protocol}`, codes$1.ERR_NO_HANDLER_FOR_PROTOCOL);
             }
             return handler;
         }
@@ -26040,7 +26077,7 @@
          */
         async handle(protocol, handler, opts) {
             if (this.handlers.has(protocol)) {
-                throw new CodeError$2(`Handler already registered for protocol ${protocol}`, codes.ERR_PROTOCOL_HANDLER_ALREADY_REGISTERED);
+                throw new CodeError$2(`Handler already registered for protocol ${protocol}`, codes$1.ERR_PROTOCOL_HANDLER_ALREADY_REGISTERED);
             }
             const options = mergeOptions$1.bind({ ignoreUndefined: true })({
                 maxInboundStreams: DEFAULT_MAX_INBOUND_STREAMS$1,
@@ -26074,7 +26111,7 @@
          */
         async register(protocol, topology) {
             if (topology == null) {
-                throw new CodeError$2('invalid topology', codes.ERR_INVALID_PARAMETERS);
+                throw new CodeError$2('invalid topology', codes$1.ERR_INVALID_PARAMETERS);
             }
             // Create topology
             const id = `${(Math.random() * 1e9).toString(36)}${Date.now()}`;
@@ -26122,7 +26159,7 @@
                 }
             })
                 .catch(err => {
-                if (err.code === codes.ERR_NOT_FOUND) {
+                if (err.code === codes$1.ERR_NOT_FOUND) {
                     // peer has not completed identify so they are not in the peer store
                     return;
                 }
@@ -26241,10 +26278,10 @@
         add(transport) {
             const tag = transport[Symbol.toStringTag];
             if (tag == null) {
-                throw new CodeError$2('Transport must have a valid tag', codes.ERR_INVALID_KEY);
+                throw new CodeError$2('Transport must have a valid tag', codes$1.ERR_INVALID_KEY);
             }
             if (this.transports.has(tag)) {
-                throw new CodeError$2(`There is already a transport with the tag ${tag}`, codes.ERR_DUPLICATE_TRANSPORT);
+                throw new CodeError$2(`There is already a transport with the tag ${tag}`, codes$1.ERR_DUPLICATE_TRANSPORT);
             }
             this.log('adding transport %s', tag);
             this.transports.set(tag, transport);
@@ -26291,7 +26328,7 @@
         async dial(ma, options) {
             const transport = this.dialTransportForMultiaddr(ma);
             if (transport == null) {
-                throw new CodeError$2(`No transport available for address ${String(ma)}`, codes.ERR_TRANSPORT_UNAVAILABLE);
+                throw new CodeError$2(`No transport available for address ${String(ma)}`, codes$1.ERR_TRANSPORT_UNAVAILABLE);
             }
             try {
                 return await transport.dial(ma, {
@@ -26301,7 +26338,7 @@
             }
             catch (err) {
                 if (err.code == null) {
-                    err.code = codes.ERR_TRANSPORT_DIAL_FAILED;
+                    err.code = codes$1.ERR_TRANSPORT_DIAL_FAILED;
                 }
                 throw err;
             }
@@ -26357,7 +26394,7 @@
          */
         async listen(addrs) {
             if (!this.isStarted()) {
-                throw new CodeError$2('Not started', codes.ERR_NODE_NOT_STARTED);
+                throw new CodeError$2('Not started', codes$1.ERR_NODE_NOT_STARTED);
             }
             if (addrs == null || addrs.length === 0) {
                 this.log('no addresses were provided for listening, this node is dial only');
@@ -26408,7 +26445,7 @@
                 // just wait for any (`p-any`) listener to succeed on each transport before returning
                 const isListening = results.find(r => r.status === 'fulfilled');
                 if ((isListening == null) && this.faultTolerance !== FaultTolerance.NO_FATAL) {
-                    throw new CodeError$2(`Transport (${key}) could not listen on any available address`, codes.ERR_NO_VALID_ADDRESSES);
+                    throw new CodeError$2(`Transport (${key}) could not listen on any available address`, codes$1.ERR_NO_VALID_ADDRESSES);
                 }
             }
             // If no transports were able to listen, throw an error. This likely
@@ -26416,7 +26453,7 @@
             if (couldNotListen.length === this.transports.size) {
                 const message = `no valid addresses were provided for transports [${couldNotListen.join(', ')}]`;
                 if (this.faultTolerance === FaultTolerance.FATAL_ALL) {
-                    throw new CodeError$2(message, codes.ERR_NO_VALID_ADDRESSES);
+                    throw new CodeError$2(message, codes$1.ERR_NO_VALID_ADDRESSES);
                 }
                 this.log(`libp2p in dial mode only: ${message}`);
             }
@@ -27016,7 +27053,7 @@
             return options.maxInboundStreams;
         }
         catch (err) {
-            if (err.code !== codes.ERR_NO_HANDLER_FOR_PROTOCOL) {
+            if (err.code !== codes$1.ERR_NO_HANDLER_FOR_PROTOCOL) {
                 throw err;
             }
         }
@@ -27030,7 +27067,7 @@
             }
         }
         catch (err) {
-            if (err.code !== codes.ERR_NO_HANDLER_FOR_PROTOCOL) {
+            if (err.code !== codes$1.ERR_NO_HANDLER_FOR_PROTOCOL) {
                 throw err;
             }
         }
@@ -27068,7 +27105,7 @@
             const connectionGater = this.components.connectionGater[connectionType];
             if (connectionGater !== undefined) {
                 if (await connectionGater(remotePeer, maConn)) {
-                    throw new CodeError$2(`The multiaddr connection is blocked by gater.${connectionType}`, codes.ERR_CONNECTION_INTERCEPTED);
+                    throw new CodeError$2(`The multiaddr connection is blocked by gater.${connectionType}`, codes$1.ERR_CONNECTION_INTERCEPTED);
                 }
             }
         }
@@ -27078,7 +27115,7 @@
         async upgradeInbound(maConn, opts) {
             const accept = await this.components.connectionManager.acceptIncomingConnection(maConn);
             if (!accept) {
-                throw new CodeError$2('connection denied', codes.ERR_CONNECTION_DENIED);
+                throw new CodeError$2('connection denied', codes$1.ERR_CONNECTION_DENIED);
             }
             let encryptedConn;
             let remotePeer;
@@ -27093,7 +27130,7 @@
             setMaxListeners(Infinity, signal);
             try {
                 if ((await this.components.connectionGater.denyInboundConnection?.(maConn)) === true) {
-                    throw new CodeError$2('The multiaddr connection is blocked by gater.acceptConnection', codes.ERR_CONNECTION_INTERCEPTED);
+                    throw new CodeError$2('The multiaddr connection is blocked by gater.acceptConnection', codes$1.ERR_CONNECTION_INTERCEPTED);
                 }
                 this.components.metrics?.trackMultiaddrConnection(maConn);
                 maConn.log('starting the inbound connection upgrade');
@@ -27124,7 +27161,7 @@
                     else {
                         const idStr = maConn.remoteAddr.getPeerId();
                         if (idStr == null) {
-                            throw new CodeError$2('inbound connection that skipped encryption must have a peer id', codes.ERR_INVALID_MULTIADDR);
+                            throw new CodeError$2('inbound connection that skipped encryption must have a peer id', codes$1.ERR_INVALID_MULTIADDR);
                         }
                         const remotePeerId = peerIdFromString(idStr);
                         cryptoProtocol = 'native';
@@ -27209,7 +27246,7 @@
                 }
                 else {
                     if (remotePeerId == null) {
-                        throw new CodeError$2('Encryption was skipped but no peer id was passed', codes.ERR_INVALID_PEER);
+                        throw new CodeError$2('Encryption was skipped but no peer id was passed', codes$1.ERR_INVALID_PEER);
                     }
                     cryptoProtocol = 'native';
                     remotePeer = remotePeerId;
@@ -27276,7 +27313,7 @@
                             const incomingLimit = findIncomingStreamLimit(protocol, this.components.registrar);
                             const streamCount = countStreams(protocol, 'inbound', connection);
                             if (streamCount === incomingLimit) {
-                                const err = new CodeError$2(`Too many inbound protocol streams for protocol "${protocol}" - limit ${incomingLimit}`, codes.ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS);
+                                const err = new CodeError$2(`Too many inbound protocol streams for protocol "${protocol}" - limit ${incomingLimit}`, codes$1.ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS);
                                 muxedStream.abort(err);
                                 throw err;
                             }
@@ -27315,7 +27352,7 @@
                 });
                 newStream = async (protocols, options = {}) => {
                     if (muxer == null) {
-                        throw new CodeError$2('Stream is not multiplexed', codes.ERR_MUXER_UNAVAILABLE);
+                        throw new CodeError$2('Stream is not multiplexed', codes$1.ERR_MUXER_UNAVAILABLE);
                     }
                     connection.log('starting new stream for protocols %s', protocols);
                     const muxedStream = await muxer.newStream();
@@ -27340,7 +27377,7 @@
                         const outgoingLimit = findOutgoingStreamLimit(protocol, this.components.registrar, options);
                         const streamCount = countStreams(protocol, 'outbound', connection);
                         if (streamCount >= outgoingLimit) {
-                            const err = new CodeError$2(`Too many outbound protocol streams for protocol "${protocol}" - ${streamCount}/${outgoingLimit}`, codes.ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS);
+                            const err = new CodeError$2(`Too many outbound protocol streams for protocol "${protocol}" - ${streamCount}/${outgoingLimit}`, codes$1.ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS);
                             muxedStream.abort(err);
                             throw err;
                         }
@@ -27377,7 +27414,7 @@
                         if (err.code != null) {
                             throw err;
                         }
-                        throw new CodeError$2(String(err), codes.ERR_UNSUPPORTED_PROTOCOL);
+                        throw new CodeError$2(String(err), codes$1.ERR_UNSUPPORTED_PROTOCOL);
                     }
                 };
                 // Pipe all data through the muxer
@@ -27416,7 +27453,7 @@
             });
             maConn.timeline.upgraded = Date.now();
             const errConnectionNotMultiplexed = () => {
-                throw new CodeError$2('connection is not multiplexed', codes.ERR_CONNECTION_NOT_MULTIPLEXED);
+                throw new CodeError$2('connection is not multiplexed', codes$1.ERR_CONNECTION_NOT_MULTIPLEXED);
             };
             // Create the connection
             connection = createConnection({
@@ -27493,7 +27530,7 @@
             }
             catch (err) {
                 connection.log.error('encrypting inbound connection failed', err);
-                throw new CodeError$2(err.message, codes.ERR_ENCRYPTION_FAILED);
+                throw new CodeError$2(err.message, codes$1.ERR_ENCRYPTION_FAILED);
             }
         }
         /**
@@ -27521,7 +27558,7 @@
             }
             catch (err) {
                 connection.log.error('encrypting outbound connection to %p failed', remotePeerId, err);
-                throw new CodeError$2(err.message, codes.ERR_ENCRYPTION_FAILED);
+                throw new CodeError$2(err.message, codes$1.ERR_ENCRYPTION_FAILED);
             }
         }
         /**
@@ -27543,7 +27580,7 @@
             }
             catch (err) {
                 connection.log.error('error multiplexing outbound connection', err);
-                throw new CodeError$2(String(err), codes.ERR_MUXER_UNAVAILABLE);
+                throw new CodeError$2(String(err), codes$1.ERR_MUXER_UNAVAILABLE);
             }
         }
         /**
@@ -27562,7 +27599,7 @@
             }
             catch (err) {
                 connection.log.error('error multiplexing inbound connection', err);
-                throw new CodeError$2(String(err), codes.ERR_MUXER_UNAVAILABLE);
+                throw new CodeError$2(String(err), codes$1.ERR_MUXER_UNAVAILABLE);
             }
         }
     }
@@ -27769,11 +27806,11 @@
         }
         async dialProtocol(peer, protocols, options = {}) {
             if (protocols == null) {
-                throw new CodeError$2('no protocols were provided to open a stream', codes.ERR_INVALID_PROTOCOLS_FOR_STREAM);
+                throw new CodeError$2('no protocols were provided to open a stream', codes$1.ERR_INVALID_PROTOCOLS_FOR_STREAM);
             }
             protocols = Array.isArray(protocols) ? protocols : [protocols];
             if (protocols.length === 0) {
-                throw new CodeError$2('no protocols were provided to open a stream', codes.ERR_INVALID_PROTOCOLS_FOR_STREAM);
+                throw new CodeError$2('no protocols were provided to open a stream', codes$1.ERR_INVALID_PROTOCOLS_FOR_STREAM);
             }
             const connection = await this.dial(peer, options);
             return connection.newStream(protocols, options);
@@ -27805,7 +27842,7 @@
                 }
             }
             catch (err) {
-                if (err.code !== codes.ERR_NOT_FOUND) {
+                if (err.code !== codes$1.ERR_NOT_FOUND) {
                     throw err;
                 }
             }
@@ -27854,7 +27891,7 @@
         #onDiscoveryPeer(evt) {
             const { detail: peer } = evt;
             if (peer.id.toString() === this.peerId.toString()) {
-                this.log.error(new Error(codes.ERR_DISCOVERED_SELF));
+                this.log.error(new Error(codes$1.ERR_DISCOVERED_SELF));
                 return;
             }
             void this.components.peerStore.merge(peer.id, {
@@ -32067,484 +32104,2755 @@
         };
     }
 
-    // Protocol violation errors
-    const ERR_INVALID_FRAME = 'ERR_INVALID_FRAME';
-    const ERR_UNREQUESTED_PING = 'ERR_UNREQUESTED_PING';
-    const ERR_NOT_MATCHING_PING = 'ERR_NOT_MATCHING_PING';
-    const ERR_STREAM_ALREADY_EXISTS = 'ERR_STREAM_ALREADY_EXISTS';
-    const ERR_DECODE_INVALID_VERSION = 'ERR_DECODE_INVALID_VERSION';
-    const ERR_BOTH_CLIENTS = 'ERR_BOTH_CLIENTS';
-    const ERR_RECV_WINDOW_EXCEEDED = 'ERR_RECV_WINDOW_EXCEEDED';
-    const PROTOCOL_ERRORS = new Set([
-        ERR_INVALID_FRAME,
-        ERR_UNREQUESTED_PING,
-        ERR_NOT_MATCHING_PING,
-        ERR_STREAM_ALREADY_EXISTS,
-        ERR_DECODE_INVALID_VERSION,
-        ERR_BOTH_CLIENTS,
-        ERR_RECV_WINDOW_EXCEEDED
-    ]);
-    // local errors
-    const ERR_INVALID_CONFIG = 'ERR_INVALID_CONFIG';
-    const ERR_MUXER_LOCAL_CLOSED = 'ERR_MUXER_LOCAL_CLOSED';
-    const ERR_MUXER_REMOTE_CLOSED = 'ERR_MUXER_REMOTE_CLOSED';
-    const ERR_STREAM_ABORT = 'ERR_STREAM_ABORT';
-    const ERR_MAX_OUTBOUND_STREAMS_EXCEEDED = 'ERROR_MAX_OUTBOUND_STREAMS_EXCEEDED';
-    const ERR_DECODE_IN_PROGRESS = 'ERR_DECODE_IN_PROGRESS';
-    /**
-     * INITIAL_STREAM_WINDOW is the initial stream window size.
-     *
-     * Not an implementation choice, this is defined in the specification
-     */
-    const INITIAL_STREAM_WINDOW = 256 * 1024;
-    /**
-     * Default max stream window
-     */
-    const MAX_STREAM_WINDOW = 16 * 1024 * 1024;
+    var codes;
+    (function (codes) {
+        codes["ERR_ALREADY_ABORTED"] = "ERR_ALREADY_ABORTED";
+        codes["ERR_DATA_CHANNEL"] = "ERR_DATA_CHANNEL";
+        codes["ERR_CONNECTION_CLOSED"] = "ERR_CONNECTION_CLOSED";
+        codes["ERR_HASH_NOT_SUPPORTED"] = "ERR_HASH_NOT_SUPPORTED";
+        codes["ERR_INVALID_MULTIADDR"] = "ERR_INVALID_MULTIADDR";
+        codes["ERR_INVALID_FINGERPRINT"] = "ERR_INVALID_FINGERPRINT";
+        codes["ERR_INVALID_PARAMETERS"] = "ERR_INVALID_PARAMETERS";
+        codes["ERR_NOT_IMPLEMENTED"] = "ERR_NOT_IMPLEMENTED";
+        codes["ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS"] = "ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS";
+        codes["ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS"] = "ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS";
+    })(codes || (codes = {}));
 
-    const defaultConfig = {
-        enableKeepAlive: true,
-        keepAliveInterval: 30000,
-        maxInboundStreams: 1000,
-        maxOutboundStreams: 1000,
-        initialStreamWindowSize: INITIAL_STREAM_WINDOW,
-        maxStreamWindowSize: MAX_STREAM_WINDOW,
-        maxMessageSize: 64 * 1024
-    };
-    function verifyConfig(config) {
-        if (config.keepAliveInterval <= 0) {
-            throw new CodeError$2('keep-alive interval must be positive', ERR_INVALID_CONFIG);
-        }
-        if (config.maxInboundStreams < 0) {
-            throw new CodeError$2('max inbound streams must be larger or equal 0', ERR_INVALID_CONFIG);
+    var __spreadArray = (undefined && undefined.__spreadArray) || function (to, from, pack) {
+        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+            if (ar || !(i in from)) {
+                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+                ar[i] = from[i];
+            }
         }
-        if (config.maxOutboundStreams < 0) {
-            throw new CodeError$2('max outbound streams must be larger or equal 0', ERR_INVALID_CONFIG);
+        return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    var BrowserInfo = /** @class */ (function () {
+        function BrowserInfo(name, version, os) {
+            this.name = name;
+            this.version = version;
+            this.os = os;
+            this.type = 'browser';
         }
-        if (config.initialStreamWindowSize < INITIAL_STREAM_WINDOW) {
-            throw new CodeError$2('InitialStreamWindowSize must be larger or equal 256 kB', ERR_INVALID_CONFIG);
+        return BrowserInfo;
+    }());
+    var NodeInfo = /** @class */ (function () {
+        function NodeInfo(version) {
+            this.version = version;
+            this.type = 'node';
+            this.name = 'node';
+            this.os = process.platform;
+        }
+        return NodeInfo;
+    }());
+    var SearchBotDeviceInfo = /** @class */ (function () {
+        function SearchBotDeviceInfo(name, version, os, bot) {
+            this.name = name;
+            this.version = version;
+            this.os = os;
+            this.bot = bot;
+            this.type = 'bot-device';
+        }
+        return SearchBotDeviceInfo;
+    }());
+    var BotInfo = /** @class */ (function () {
+        function BotInfo() {
+            this.type = 'bot';
+            this.bot = true; // NOTE: deprecated test name instead
+            this.name = 'bot';
+            this.version = null;
+            this.os = null;
+        }
+        return BotInfo;
+    }());
+    var ReactNativeInfo = /** @class */ (function () {
+        function ReactNativeInfo() {
+            this.type = 'react-native';
+            this.name = 'react-native';
+            this.version = null;
+            this.os = null;
+        }
+        return ReactNativeInfo;
+    }());
+    // tslint:disable-next-line:max-line-length
+    var SEARCHBOX_UA_REGEX = /alexa|bot|crawl(er|ing)|facebookexternalhit|feedburner|google web preview|nagios|postrank|pingdom|slurp|spider|yahoo!|yandex/;
+    var SEARCHBOT_OS_REGEX = /(nuhk|curl|Googlebot|Yammybot|Openbot|Slurp|MSNBot|Ask\ Jeeves\/Teoma|ia_archiver)/;
+    var REQUIRED_VERSION_PARTS = 3;
+    var userAgentRules = [
+        ['aol', /AOLShield\/([0-9\._]+)/],
+        ['edge', /Edge\/([0-9\._]+)/],
+        ['edge-ios', /EdgiOS\/([0-9\._]+)/],
+        ['yandexbrowser', /YaBrowser\/([0-9\._]+)/],
+        ['kakaotalk', /KAKAOTALK\s([0-9\.]+)/],
+        ['samsung', /SamsungBrowser\/([0-9\.]+)/],
+        ['silk', /\bSilk\/([0-9._-]+)\b/],
+        ['miui', /MiuiBrowser\/([0-9\.]+)$/],
+        ['beaker', /BeakerBrowser\/([0-9\.]+)/],
+        ['edge-chromium', /EdgA?\/([0-9\.]+)/],
+        [
+            'chromium-webview',
+            /(?!Chrom.*OPR)wv\).*Chrom(?:e|ium)\/([0-9\.]+)(:?\s|$)/,
+        ],
+        ['chrome', /(?!Chrom.*OPR)Chrom(?:e|ium)\/([0-9\.]+)(:?\s|$)/],
+        ['phantomjs', /PhantomJS\/([0-9\.]+)(:?\s|$)/],
+        ['crios', /CriOS\/([0-9\.]+)(:?\s|$)/],
+        ['firefox', /Firefox\/([0-9\.]+)(?:\s|$)/],
+        ['fxios', /FxiOS\/([0-9\.]+)/],
+        ['opera-mini', /Opera Mini.*Version\/([0-9\.]+)/],
+        ['opera', /Opera\/([0-9\.]+)(?:\s|$)/],
+        ['opera', /OPR\/([0-9\.]+)(:?\s|$)/],
+        ['pie', /^Microsoft Pocket Internet Explorer\/(\d+\.\d+)$/],
+        ['pie', /^Mozilla\/\d\.\d+\s\(compatible;\s(?:MSP?IE|MSInternet Explorer) (\d+\.\d+);.*Windows CE.*\)$/],
+        ['netfront', /^Mozilla\/\d\.\d+.*NetFront\/(\d.\d)/],
+        ['ie', /Trident\/7\.0.*rv\:([0-9\.]+).*\).*Gecko$/],
+        ['ie', /MSIE\s([0-9\.]+);.*Trident\/[4-7].0/],
+        ['ie', /MSIE\s(7\.0)/],
+        ['bb10', /BB10;\sTouch.*Version\/([0-9\.]+)/],
+        ['android', /Android\s([0-9\.]+)/],
+        ['ios', /Version\/([0-9\._]+).*Mobile.*Safari.*/],
+        ['safari', /Version\/([0-9\._]+).*Safari/],
+        ['facebook', /FB[AS]V\/([0-9\.]+)/],
+        ['instagram', /Instagram\s([0-9\.]+)/],
+        ['ios-webview', /AppleWebKit\/([0-9\.]+).*Mobile/],
+        ['ios-webview', /AppleWebKit\/([0-9\.]+).*Gecko\)$/],
+        ['curl', /^curl\/([0-9\.]+)$/],
+        ['searchbot', SEARCHBOX_UA_REGEX],
+    ];
+    var operatingSystemRules = [
+        ['iOS', /iP(hone|od|ad)/],
+        ['Android OS', /Android/],
+        ['BlackBerry OS', /BlackBerry|BB10/],
+        ['Windows Mobile', /IEMobile/],
+        ['Amazon OS', /Kindle/],
+        ['Windows 3.11', /Win16/],
+        ['Windows 95', /(Windows 95)|(Win95)|(Windows_95)/],
+        ['Windows 98', /(Windows 98)|(Win98)/],
+        ['Windows 2000', /(Windows NT 5.0)|(Windows 2000)/],
+        ['Windows XP', /(Windows NT 5.1)|(Windows XP)/],
+        ['Windows Server 2003', /(Windows NT 5.2)/],
+        ['Windows Vista', /(Windows NT 6.0)/],
+        ['Windows 7', /(Windows NT 6.1)/],
+        ['Windows 8', /(Windows NT 6.2)/],
+        ['Windows 8.1', /(Windows NT 6.3)/],
+        ['Windows 10', /(Windows NT 10.0)/],
+        ['Windows ME', /Windows ME/],
+        ['Windows CE', /Windows CE|WinCE|Microsoft Pocket Internet Explorer/],
+        ['Open BSD', /OpenBSD/],
+        ['Sun OS', /SunOS/],
+        ['Chrome OS', /CrOS/],
+        ['Linux', /(Linux)|(X11)/],
+        ['Mac OS', /(Mac_PowerPC)|(Macintosh)/],
+        ['QNX', /QNX/],
+        ['BeOS', /BeOS/],
+        ['OS/2', /OS\/2/],
+    ];
+    function detect(userAgent) {
+        if (typeof document === 'undefined' &&
+            typeof navigator !== 'undefined' &&
+            navigator.product === 'ReactNative') {
+            return new ReactNativeInfo();
+        }
+        if (typeof navigator !== 'undefined') {
+            return parseUserAgent(navigator.userAgent);
+        }
+        return getNodeVersion();
+    }
+    function matchUserAgent(ua) {
+        // opted for using reduce here rather than Array#first with a regex.test call
+        // this is primarily because using the reduce we only perform the regex
+        // execution once rather than once for the test and for the exec again below
+        // probably something that needs to be benchmarked though
+        return (ua !== '' &&
+            userAgentRules.reduce(function (matched, _a) {
+                var browser = _a[0], regex = _a[1];
+                if (matched) {
+                    return matched;
+                }
+                var uaMatch = regex.exec(ua);
+                return !!uaMatch && [browser, uaMatch];
+            }, false));
+    }
+    function parseUserAgent(ua) {
+        var matchedRule = matchUserAgent(ua);
+        if (!matchedRule) {
+            return null;
         }
-        if (config.maxStreamWindowSize < config.initialStreamWindowSize) {
-            throw new CodeError$2('MaxStreamWindowSize must be larger than the InitialStreamWindowSize', ERR_INVALID_CONFIG);
+        var name = matchedRule[0], match = matchedRule[1];
+        if (name === 'searchbot') {
+            return new BotInfo();
         }
-        if (config.maxStreamWindowSize > 2 ** 32 - 1) {
-            throw new CodeError$2('MaxStreamWindowSize must be less than equal MAX_UINT32', ERR_INVALID_CONFIG);
+        // Do not use RegExp for split operation as some browser do not support it (See: http://blog.stevenlevithan.com/archives/cross-browser-split)
+        var versionParts = match[1] && match[1].split('.').join('_').split('_').slice(0, 3);
+        if (versionParts) {
+            if (versionParts.length < REQUIRED_VERSION_PARTS) {
+                versionParts = __spreadArray(__spreadArray([], versionParts, true), createVersionParts(REQUIRED_VERSION_PARTS - versionParts.length), true);
+            }
         }
-        if (config.maxMessageSize < 1024) {
-            throw new CodeError$2('MaxMessageSize must be greater than a kilobyte', ERR_INVALID_CONFIG);
+        else {
+            versionParts = [];
         }
-    }
-
-    var FrameType;
-    (function (FrameType) {
-        /** Used to transmit data. May transmit zero length payloads depending on the flags. */
-        FrameType[FrameType["Data"] = 0] = "Data";
-        /** Used to updated the senders receive window size. This is used to implement per-session flow control. */
-        FrameType[FrameType["WindowUpdate"] = 1] = "WindowUpdate";
-        /** Used to measure RTT. It can also be used to heart-beat and do keep-alives over TCP. */
-        FrameType[FrameType["Ping"] = 2] = "Ping";
-        /** Used to close a session. */
-        FrameType[FrameType["GoAway"] = 3] = "GoAway";
-    })(FrameType || (FrameType = {}));
-    var Flag;
-    (function (Flag) {
-        /** Signals the start of a new stream. May be sent with a data or window update message. Also sent with a ping to indicate outbound. */
-        Flag[Flag["SYN"] = 1] = "SYN";
-        /** Acknowledges the start of a new stream. May be sent with a data or window update message. Also sent with a ping to indicate response. */
-        Flag[Flag["ACK"] = 2] = "ACK";
-        /** Performs a half-close of a stream. May be sent with a data message or window update. */
-        Flag[Flag["FIN"] = 4] = "FIN";
-        /** Reset a stream immediately. May be sent with a data or window update message. */
-        Flag[Flag["RST"] = 8] = "RST";
-    })(Flag || (Flag = {}));
-    Object.values(Flag).filter((x) => typeof x !== 'string');
-    const YAMUX_VERSION = 0;
-    var GoAwayCode;
-    (function (GoAwayCode) {
-        GoAwayCode[GoAwayCode["NormalTermination"] = 0] = "NormalTermination";
-        GoAwayCode[GoAwayCode["ProtocolError"] = 1] = "ProtocolError";
-        GoAwayCode[GoAwayCode["InternalError"] = 2] = "InternalError";
-    })(GoAwayCode || (GoAwayCode = {}));
-    const HEADER_LENGTH = 12;
-
-    // used to bitshift in decoding
-    // native bitshift can overflow into a negative number, so we bitshift by multiplying by a power of 2
-    const twoPow24 = 2 ** 24;
-    /**
-     * Decode a header from the front of a buffer
-     *
-     * @param data - Assumed to have enough bytes for a header
-     */
-    function decodeHeader(data) {
-        if (data[0] !== YAMUX_VERSION) {
-            throw new CodeError$2('Invalid frame version', ERR_DECODE_INVALID_VERSION);
+        var version = versionParts.join('.');
+        var os = detectOS(ua);
+        var searchBotMatch = SEARCHBOT_OS_REGEX.exec(ua);
+        if (searchBotMatch && searchBotMatch[1]) {
+            return new SearchBotDeviceInfo(name, version, os, searchBotMatch[1]);
         }
-        return {
-            type: data[1],
-            flag: (data[2] << 8) + data[3],
-            streamID: (data[4] * twoPow24) + (data[5] << 16) + (data[6] << 8) + data[7],
-            length: (data[8] * twoPow24) + (data[9] << 16) + (data[10] << 8) + data[11]
-        };
+        return new BrowserInfo(name, version, os);
     }
-    /**
-     * Decodes yamux frames from a source
-     */
-    class Decoder {
-        source;
-        /** Buffer for in-progress frames */
-        buffer;
-        /** Used to sanity check against decoding while in an inconsistent state */
-        frameInProgress;
-        constructor(source) {
-            // Normally, when entering a for-await loop with an iterable/async iterable, the only ways to exit the loop are:
-            // 1. exhaust the iterable
-            // 2. throw an error - slow, undesirable if there's not actually an error
-            // 3. break or return - calls the iterable's `return` method, finalizing the iterable, no more iteration possible
-            //
-            // In this case, we want to enter (and exit) a for-await loop per chunked data frame and continue processing the iterable.
-            // To do this, we strip the `return` method from the iterator and can now `break` early and continue iterating.
-            // Exiting the main for-await is still possible via 1. and 2.
-            this.source = returnlessSource(source);
-            this.buffer = new Uint8ArrayList();
-            this.frameInProgress = false;
-        }
-        /**
-         * Emits frames from the decoder source.
-         *
-         * Note: If `readData` is emitted, it _must_ be called before the next iteration
-         * Otherwise an error is thrown
-         */
-        async *emitFrames() {
-            for await (const chunk of this.source) {
-                this.buffer.append(chunk);
-                // Loop to consume as many bytes from the buffer as possible
-                // Eg: when a single chunk contains several frames
-                while (true) {
-                    const header = this.readHeader();
-                    if (header === undefined) {
-                        break;
-                    }
-                    const { type, length } = header;
-                    if (type === FrameType.Data) {
-                        // This is a data frame, the frame body must still be read
-                        // `readData` must be called before the next iteration here
-                        this.frameInProgress = true;
-                        yield {
-                            header,
-                            readData: this.readBytes.bind(this, length)
-                        };
-                    }
-                    else {
-                        yield { header };
-                    }
-                }
-            }
-        }
-        readHeader() {
-            // Sanity check to ensure a header isn't read when another frame is partially decoded
-            // In practice this shouldn't happen
-            if (this.frameInProgress) {
-                throw new CodeError$2('decoding frame already in progress', ERR_DECODE_IN_PROGRESS);
-            }
-            if (this.buffer.length < HEADER_LENGTH) {
-                // not enough data yet
-                return;
-            }
-            const header = decodeHeader(this.buffer.subarray(0, HEADER_LENGTH));
-            this.buffer.consume(HEADER_LENGTH);
-            return header;
-        }
-        async readBytes(length) {
-            if (this.buffer.length < length) {
-                for await (const chunk of this.source) {
-                    this.buffer.append(chunk);
-                    if (this.buffer.length >= length) {
-                        // see note above, the iterator is not `return`ed here
-                        break;
-                    }
-                }
+    function detectOS(ua) {
+        for (var ii = 0, count = operatingSystemRules.length; ii < count; ii++) {
+            var _a = operatingSystemRules[ii], os = _a[0], regex = _a[1];
+            var match = regex.exec(ua);
+            if (match) {
+                return os;
             }
-            const out = this.buffer.sublist(0, length);
-            this.buffer.consume(length);
-            // The next frame can now be decoded
-            this.frameInProgress = false;
-            return out;
         }
+        return null;
     }
-    /**
-     * Strip the `return` method from a `Source`
-     */
-    function returnlessSource(source) {
-        if (source[Symbol.iterator] !== undefined) {
-            const iterator = source[Symbol.iterator]();
-            iterator.return = undefined;
-            return {
-                [Symbol.iterator]() { return iterator; }
-            };
-        }
-        else if (source[Symbol.asyncIterator] !== undefined) {
-            const iterator = source[Symbol.asyncIterator]();
-            iterator.return = undefined;
-            return {
-                [Symbol.asyncIterator]() { return iterator; }
-            };
-        }
-        else {
-            throw new Error('a source must be either an iterable or an async iterable');
-        }
+    function getNodeVersion() {
+        var isNode = typeof process !== 'undefined' && process.version;
+        return isNode ? new NodeInfo(process.version.slice(1)) : null;
     }
-
-    function encodeHeader(header) {
-        const frame = new Uint8Array(HEADER_LENGTH);
-        // always assume version 0
-        // frameView.setUint8(0, header.version)
-        frame[1] = header.type;
-        frame[2] = header.flag >>> 8;
-        frame[3] = header.flag;
-        frame[4] = header.streamID >>> 24;
-        frame[5] = header.streamID >>> 16;
-        frame[6] = header.streamID >>> 8;
-        frame[7] = header.streamID;
-        frame[8] = header.length >>> 24;
-        frame[9] = header.length >>> 16;
-        frame[10] = header.length >>> 8;
-        frame[11] = header.length;
-        return frame;
+    function createVersionParts(count) {
+        var output = [];
+        for (var ii = 0; ii < count; ii++) {
+            output.push('0');
+        }
+        return output;
     }
 
-    /**
-     * @packageDocumentation
-     *
-     * Calls a function for each value in an (async)iterable.
-     *
-     * The function can be sync or async.
-     *
-     * Async functions can be awaited on so may slow down processing of the (async)iterable.
-     *
-     * @example
-     *
-     * ```javascript
-     * import each from 'it-foreach'
-     * import drain from 'it-drain'
-     *
-     * // This can also be an iterator, generator, etc
-     * const values = [0, 1, 2, 3, 4]
-     *
-     * // prints [0, 0], [1, 1], [2, 2], [3, 3], [4, 4]
-     * const arr = drain(
-     *   each(values, console.info)
-     * )
-     * ```
-     *
-     * Async sources and callbacks must be awaited:
-     *
-     * ```javascript
-     * import each from 'it-foreach'
-     * import drain from 'it-drain'
-     *
-     * const values = async function * () {
-     *   yield * [0, 1, 2, 3, 4]
-     * }
-     *
-     * // prints [0, 0], [1, 1], [2, 2], [3, 3], [4, 4]
-     * const arr = await drain(
-     *   each(values(), console.info)
-     * )
-     * ```
-     */
-    function isAsyncIterable$1(thing) {
-        return thing[Symbol.asyncIterator] != null;
-    }
-    function isPromise$1(thing) {
-        return thing?.then != null;
-    }
-    function forEach(source, fn) {
-        let index = 0;
-        if (isAsyncIterable$1(source)) {
-            return (async function* () {
-                for await (const val of source) {
-                    const res = fn(val, index++);
-                    if (isPromise$1(res)) {
-                        await res;
-                    }
-                    yield val;
-                }
-            })();
-        }
-        // if fn function returns a promise we have to return an async generator
-        const peekable$1 = peekable(source);
-        const { value, done } = peekable$1.next();
-        if (done === true) {
-            return (function* () { }());
+    const browser = detect();
+    const isFirefox = ((browser != null) && browser.name === 'firefox');
+    const nopSource = async function* nop() { };
+    const nopSink = async (_) => { };
+    const DATA_CHANNEL_DRAIN_TIMEOUT = 30 * 1000;
+    function drainAndClose(channel, direction, drainTimeout = DATA_CHANNEL_DRAIN_TIMEOUT, options) {
+        if (channel.readyState !== 'open') {
+            return;
         }
-        const res = fn(value, index++);
-        if (typeof res?.then === 'function') {
-            return (async function* () {
-                yield value;
-                for await (const val of peekable$1) {
-                    const res = fn(val, index++);
-                    if (isPromise$1(res)) {
-                        await res;
+        void Promise.resolve()
+            .then(async () => {
+            // wait for bufferedAmount to become zero
+            if (channel.bufferedAmount > 0) {
+                options.log('%s drain channel with %d buffered bytes', direction, channel.bufferedAmount);
+                const deferred = pDefer();
+                let drained = false;
+                channel.bufferedAmountLowThreshold = 0;
+                const closeListener = () => {
+                    if (!drained) {
+                        options.log('%s drain channel closed before drain', direction);
+                        deferred.resolve();
                     }
-                    yield val;
-                }
-            })();
-        }
-        const func = fn;
-        return (function* () {
-            yield value;
-            for (const val of peekable$1) {
-                func(val, index++);
-                yield val;
+                };
+                channel.addEventListener('close', closeListener, {
+                    once: true
+                });
+                channel.addEventListener('bufferedamountlow', () => {
+                    drained = true;
+                    channel.removeEventListener('close', closeListener);
+                    deferred.resolve();
+                });
+                await pTimeout(deferred.promise, {
+                    milliseconds: drainTimeout
+                });
             }
-        })();
+        })
+            .then(async () => {
+            // only close if the channel is still open
+            if (channel.readyState === 'open') {
+                channel.close();
+            }
+        })
+            .catch(err => {
+            options.log.error('error closing outbound stream', err);
+        });
     }
 
-    var StreamState;
-    (function (StreamState) {
-        StreamState[StreamState["Init"] = 0] = "Init";
-        StreamState[StreamState["SYNSent"] = 1] = "SYNSent";
-        StreamState[StreamState["SYNReceived"] = 2] = "SYNReceived";
-        StreamState[StreamState["Established"] = 3] = "Established";
-        StreamState[StreamState["Finished"] = 4] = "Finished";
-    })(StreamState || (StreamState = {}));
-    /** YamuxStream is used to represent a logical stream within a session */
-    class YamuxStream extends AbstractStream {
-        name;
-        state;
-        config;
-        _id;
-        /** The number of available bytes to send */
-        sendWindowCapacity;
-        /** Callback to notify that the sendWindowCapacity has been updated */
-        sendWindowCapacityUpdate;
-        /** The number of bytes available to receive in a full window */
-        recvWindow;
-        /** The number of available bytes to receive */
-        recvWindowCapacity;
-        /**
-         * An 'epoch' is the time it takes to process and read data
-         *
-         * Used in conjunction with RTT to determine whether to increase the recvWindow
-         */
-        epochStart;
-        getRTT;
-        sendFrame;
-        constructor(init) {
-            super({
-                ...init,
-                onEnd: (err) => {
-                    this.state = StreamState.Finished;
-                    init.onEnd?.(err);
-                }
-            });
-            this.config = init.config;
-            this._id = parseInt(init.id, 10);
-            this.name = init.name;
-            this.state = init.state;
-            this.sendWindowCapacity = INITIAL_STREAM_WINDOW;
-            this.recvWindow = this.config.initialStreamWindowSize;
-            this.recvWindowCapacity = this.recvWindow;
-            this.epochStart = Date.now();
-            this.getRTT = init.getRTT;
-            this.sendFrame = init.sendFrame;
-            this.source = forEach(this.source, () => {
-                this.sendWindowUpdate();
-            });
-        }
+    class WebRTCMultiaddrConnection {
+        log;
         /**
-         * Send a message to the remote muxer informing them a new stream is being
-         * opened.
-         *
-         * This is a noop for Yamux because the first window update is sent when
-         * .newStream is called on the muxer which opens the stream on the remote.
+         * WebRTC Peer Connection
          */
-        async sendNewStream() {
-        }
+        peerConnection;
         /**
-         * Send a data message to the remote muxer
+         * The multiaddr address used to communicate with the remote peer
          */
-        async sendData(buf, options = {}) {
-            buf = buf.sublist();
-            // send in chunks, waiting for window updates
-            while (buf.byteLength !== 0) {
-                // wait for the send window to refill
-                if (this.sendWindowCapacity === 0) {
-                    this.log?.trace('wait for send window capacity, status %s', this.status);
-                    await this.waitForSendWindowCapacity(options);
-                    // check we didn't close while waiting for send window capacity
-                    if (this.status === 'closed' || this.status === 'aborted' || this.status === 'reset') {
-                        this.log?.trace('%s while waiting for send window capacity', this.status);
-                        return;
-                    }
-                }
-                // send as much as we can
-                const toSend = Math.min(this.sendWindowCapacity, this.config.maxMessageSize - HEADER_LENGTH, buf.length);
-                const flags = this.getSendFlags();
-                this.sendFrame({
-                    type: FrameType.Data,
-                    flag: flags,
-                    streamID: this._id,
-                    length: toSend
-                }, buf.sublist(0, toSend));
-                this.sendWindowCapacity -= toSend;
-                buf.consume(toSend);
-            }
-        }
+        remoteAddr;
         /**
-         * Send a reset message to the remote muxer
+         * Holds the lifecycle times of the connection
          */
-        async sendReset() {
-            this.sendFrame({
-                type: FrameType.WindowUpdate,
-                flag: Flag.RST,
-                streamID: this._id,
-                length: 0
-            });
-        }
+        timeline;
         /**
-         * Send a message to the remote muxer, informing them no more data messages
-         * will be sent by this end of the stream
+         * Optional metrics counter group for this connection
          */
-        async sendCloseWrite() {
-            const flags = this.getSendFlags() | Flag.FIN;
-            this.sendFrame({
-                type: FrameType.WindowUpdate,
-                flag: flags,
-                streamID: this._id,
-                length: 0
-            });
-        }
+        metrics;
         /**
-         * Send a message to the remote muxer, informing them no more data messages
-         * will be read by this end of the stream
+         * The stream source, a no-op as the transport natively supports multiplexing
          */
-        async sendCloseRead() {
-        }
+        source = nopSource();
         /**
-         * Wait for the send window to be non-zero
-         *
-         * Will throw with ERR_STREAM_ABORT if the stream gets aborted
+         * The stream destination, a no-op as the transport natively supports multiplexing
          */
-        async waitForSendWindowCapacity(options = {}) {
-            if (this.sendWindowCapacity > 0) {
-                return;
-            }
-            let resolve;
-            let reject;
-            const abort = () => {
-                if (this.status === 'open' || this.status === 'closing') {
-                    reject(new CodeError$2('stream aborted', ERR_STREAM_ABORT));
-                }
-                else {
-                    // the stream was closed already, ignore the failure to send
-                    resolve();
+        sink = nopSink;
+        constructor(components, init) {
+            this.log = components.logger.forComponent('libp2p:webrtc:maconn');
+            this.remoteAddr = init.remoteAddr;
+            this.timeline = init.timeline;
+            this.peerConnection = init.peerConnection;
+            const initialState = this.peerConnection.connectionState;
+            this.peerConnection.onconnectionstatechange = () => {
+                this.log.trace('peer connection state change', this.peerConnection.connectionState, 'initial state', initialState);
+                if (this.peerConnection.connectionState === 'disconnected' || this.peerConnection.connectionState === 'failed' || this.peerConnection.connectionState === 'closed') {
+                    // nothing else to do but close the connection
+                    this.timeline.close = Date.now();
                 }
             };
-            options.signal?.addEventListener('abort', abort);
-            try {
-                await new Promise((_resolve, _reject) => {
-                    this.sendWindowCapacityUpdate = () => {
+        }
+        async close(options) {
+            this.log.trace('closing connection');
+            this.peerConnection.close();
+            this.timeline.close = Date.now();
+            this.metrics?.increment({ close: true });
+        }
+        abort(err) {
+            this.log.error('closing connection due to error', err);
+            this.peerConnection.close();
+            this.timeline.close = Date.now();
+            this.metrics?.increment({ abort: true });
+        }
+    }
+
+    const normalizeEmitter = emitter => {
+    	const addListener = emitter.addEventListener || emitter.on || emitter.addListener;
+    	const removeListener = emitter.removeEventListener || emitter.off || emitter.removeListener;
+
+    	if (!addListener || !removeListener) {
+    		throw new TypeError('Emitter is not compatible');
+    	}
+
+    	return {
+    		addListener: addListener.bind(emitter),
+    		removeListener: removeListener.bind(emitter),
+    	};
+    };
+
+    function pEventMultiple(emitter, event, options) {
+    	let cancel;
+    	const returnValue = new Promise((resolve, reject) => {
+    		options = {
+    			rejectionEvents: ['error'],
+    			multiArgs: false,
+    			resolveImmediately: false,
+    			...options,
+    		};
+
+    		if (!(options.count >= 0 && (options.count === Number.POSITIVE_INFINITY || Number.isInteger(options.count)))) {
+    			throw new TypeError('The `count` option should be at least 0 or more');
+    		}
+
+    		options.signal?.throwIfAborted();
+
+    		// Allow multiple events
+    		const events = [event].flat();
+
+    		const items = [];
+    		const {addListener, removeListener} = normalizeEmitter(emitter);
+
+    		const onItem = (...arguments_) => {
+    			const value = options.multiArgs ? arguments_ : arguments_[0];
+
+    			// eslint-disable-next-line unicorn/no-array-callback-reference
+    			if (options.filter && !options.filter(value)) {
+    				return;
+    			}
+
+    			items.push(value);
+
+    			if (options.count === items.length) {
+    				cancel();
+    				resolve(items);
+    			}
+    		};
+
+    		const rejectHandler = error => {
+    			cancel();
+    			reject(error);
+    		};
+
+    		cancel = () => {
+    			for (const event of events) {
+    				removeListener(event, onItem);
+    			}
+
+    			for (const rejectionEvent of options.rejectionEvents) {
+    				removeListener(rejectionEvent, rejectHandler);
+    			}
+    		};
+
+    		for (const event of events) {
+    			addListener(event, onItem);
+    		}
+
+    		for (const rejectionEvent of options.rejectionEvents) {
+    			addListener(rejectionEvent, rejectHandler);
+    		}
+
+    		if (options.signal) {
+    			options.signal.addEventListener('abort', () => {
+    				rejectHandler(options.signal.reason);
+    			}, {once: true});
+    		}
+
+    		if (options.resolveImmediately) {
+    			resolve(items);
+    		}
+    	});
+
+    	returnValue.cancel = cancel;
+
+    	if (typeof options.timeout === 'number') {
+    		const timeout = pTimeout(returnValue, {milliseconds: options.timeout});
+    		timeout.cancel = cancel;
+    		return timeout;
+    	}
+
+    	return returnValue;
+    }
+
+    function pEvent(emitter, event, options) {
+    	if (typeof options === 'function') {
+    		options = {filter: options};
+    	}
+
+    	options = {
+    		...options,
+    		count: 1,
+    		resolveImmediately: false,
+    	};
+
+    	const arrayPromise = pEventMultiple(emitter, event, options);
+    	const promise = arrayPromise.then(array => array[0]);
+    	promise.cancel = arrayPromise.cancel;
+
+    	return promise;
+    }
+
+    /* eslint-disable import/export */
+    /* eslint-disable complexity */
+    /* eslint-disable @typescript-eslint/no-namespace */
+    /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+    /* eslint-disable @typescript-eslint/no-empty-interface */
+    var Message$2;
+    (function (Message) {
+        (function (Flag) {
+            Flag["FIN"] = "FIN";
+            Flag["STOP_SENDING"] = "STOP_SENDING";
+            Flag["RESET"] = "RESET";
+            Flag["FIN_ACK"] = "FIN_ACK";
+        })(Message.Flag || (Message.Flag = {}));
+        let __FlagValues;
+        (function (__FlagValues) {
+            __FlagValues[__FlagValues["FIN"] = 0] = "FIN";
+            __FlagValues[__FlagValues["STOP_SENDING"] = 1] = "STOP_SENDING";
+            __FlagValues[__FlagValues["RESET"] = 2] = "RESET";
+            __FlagValues[__FlagValues["FIN_ACK"] = 3] = "FIN_ACK";
+        })(__FlagValues || (__FlagValues = {}));
+        (function (Flag) {
+            Flag.codec = () => {
+                return enumeration(__FlagValues);
+            };
+        })(Message.Flag || (Message.Flag = {}));
+        let _codec;
+        Message.codec = () => {
+            if (_codec == null) {
+                _codec = message((obj, w, opts = {}) => {
+                    if (opts.lengthDelimited !== false) {
+                        w.fork();
+                    }
+                    if (obj.flag != null) {
+                        w.uint32(8);
+                        Message.Flag.codec().encode(obj.flag, w);
+                    }
+                    if (obj.message != null) {
+                        w.uint32(18);
+                        w.bytes(obj.message);
+                    }
+                    if (opts.lengthDelimited !== false) {
+                        w.ldelim();
+                    }
+                }, (reader, length) => {
+                    const obj = {};
+                    const end = length == null ? reader.len : reader.pos + length;
+                    while (reader.pos < end) {
+                        const tag = reader.uint32();
+                        switch (tag >>> 3) {
+                            case 1:
+                                obj.flag = Message.Flag.codec().decode(reader);
+                                break;
+                            case 2:
+                                obj.message = reader.bytes();
+                                break;
+                            default:
+                                reader.skipType(tag & 7);
+                                break;
+                        }
+                    }
+                    return obj;
+                });
+            }
+            return _codec;
+        };
+        Message.encode = (obj) => {
+            return encodeMessage(obj, Message.codec());
+        };
+        Message.decode = (buf) => {
+            return decodeMessage(buf, Message.codec());
+        };
+    })(Message$2 || (Message$2 = {}));
+
+    /**
+     * How much can be buffered to the DataChannel at once
+     */
+    const MAX_BUFFERED_AMOUNT = 16 * 1024 * 1024;
+    /**
+     * How long time we wait for the 'bufferedamountlow' event to be emitted
+     */
+    const BUFFERED_AMOUNT_LOW_TIMEOUT = 30 * 1000;
+    /**
+     * protobuf field definition overhead
+     */
+    const PROTOBUF_OVERHEAD = 5;
+    /**
+     * Length of varint, in bytes
+     */
+    const VARINT_LENGTH = 2;
+    /**
+     * Max message size that can be sent to the DataChannel
+     */
+    const MAX_MESSAGE_SIZE = 16 * 1024;
+    /**
+     * When closing streams we send a FIN then wait for the remote to
+     * reply with a FIN_ACK. If that does not happen within this timeout
+     * we close the stream anyway.
+     */
+    const FIN_ACK_TIMEOUT = 5000;
+    /**
+     * When sending data messages, if the channel is not in the "open" state, wait
+     * this long for the "open" event to fire.
+     */
+    const OPEN_TIMEOUT = 5000;
+    class WebRTCStream extends AbstractStream {
+        /**
+         * The data channel used to send and receive data
+         */
+        channel;
+        /**
+         * push data from the underlying datachannel to the length prefix decoder
+         * and then the protobuf decoder.
+         */
+        incomingData;
+        maxBufferedAmount;
+        bufferedAmountLowEventTimeout;
+        /**
+         * The maximum size of a message in bytes
+         */
+        maxMessageSize;
+        /**
+         * When this promise is resolved, the remote has sent us a FIN flag
+         */
+        receiveFinAck;
+        finAckTimeout;
+        openTimeout;
+        constructor(init) {
+            // override onEnd to send/receive FIN_ACK before closing the stream
+            const originalOnEnd = init.onEnd;
+            init.onEnd = (err) => {
+                this.log.trace('readable and writeable ends closed', this.status);
+                void Promise.resolve(async () => {
+                    if (this.timeline.abort != null || this.timeline.reset !== null) {
+                        return;
+                    }
+                    // wait for FIN_ACK if we haven't received it already
+                    try {
+                        await pTimeout(this.receiveFinAck.promise, {
+                            milliseconds: this.finAckTimeout
+                        });
+                    }
+                    catch (err) {
+                        this.log.error('error receiving FIN_ACK', err);
+                    }
+                })
+                    .then(() => {
+                    // stop processing incoming messages
+                    this.incomingData.end();
+                    // final cleanup
+                    originalOnEnd?.(err);
+                })
+                    .catch(err => {
+                    this.log.error('error ending stream', err);
+                });
+            };
+            super(init);
+            this.channel = init.channel;
+            this.channel.binaryType = 'arraybuffer';
+            this.incomingData = pushable$1();
+            this.bufferedAmountLowEventTimeout = init.bufferedAmountLowEventTimeout ?? BUFFERED_AMOUNT_LOW_TIMEOUT;
+            this.maxBufferedAmount = init.maxBufferedAmount ?? MAX_BUFFERED_AMOUNT;
+            this.maxMessageSize = (init.maxMessageSize ?? MAX_MESSAGE_SIZE) - PROTOBUF_OVERHEAD - VARINT_LENGTH;
+            this.receiveFinAck = pDefer();
+            this.finAckTimeout = init.closeTimeout ?? FIN_ACK_TIMEOUT;
+            this.openTimeout = init.openTimeout ?? OPEN_TIMEOUT;
+            // set up initial state
+            switch (this.channel.readyState) {
+                case 'open':
+                    this.timeline.open = new Date().getTime();
+                    break;
+                case 'closed':
+                case 'closing':
+                    if (this.timeline.close === undefined || this.timeline.close === 0) {
+                        this.timeline.close = Date.now();
+                    }
+                    break;
+                case 'connecting':
+                    // noop
+                    break;
+                default:
+                    this.log.error('unknown datachannel state %s', this.channel.readyState);
+                    throw new CodeError$2('Unknown datachannel state', 'ERR_INVALID_STATE');
+            }
+            // handle RTCDataChannel events
+            this.channel.onopen = (_evt) => {
+                this.timeline.open = new Date().getTime();
+            };
+            this.channel.onclose = (_evt) => {
+                // if the channel has closed we'll never receive a FIN_ACK so resolve the
+                // promise so we don't try to wait later
+                this.receiveFinAck.resolve();
+                void this.close().catch(err => {
+                    this.log.error('error closing stream after channel closed', err);
+                });
+            };
+            this.channel.onerror = (evt) => {
+                const err = evt.error;
+                this.abort(err);
+            };
+            this.channel.onmessage = async (event) => {
+                const { data } = event;
+                if (data === null || data.byteLength === 0) {
+                    return;
+                }
+                this.incomingData.push(new Uint8Array(data, 0, data.byteLength));
+            };
+            const self = this;
+            // pipe framed protobuf messages through a length prefixed decoder, and
+            // surface data from the `Message.message` field through a source.
+            Promise.resolve().then(async () => {
+                for await (const buf of decode$1(this.incomingData)) {
+                    const message = self.processIncomingProtobuf(buf);
+                    if (message != null) {
+                        self.sourcePush(new Uint8ArrayList(message));
+                    }
+                }
+            })
+                .catch(err => {
+                this.log.error('error processing incoming data channel messages', err);
+            });
+        }
+        sendNewStream() {
+            // opening new streams is handled by WebRTC so this is a noop
+        }
+        async _sendMessage(data, checkBuffer = true) {
+            if (checkBuffer && this.channel.bufferedAmount > this.maxBufferedAmount) {
+                try {
+                    this.log('channel buffer is %d, wait for "bufferedamountlow" event', this.channel.bufferedAmount);
+                    await pEvent(this.channel, 'bufferedamountlow', { timeout: this.bufferedAmountLowEventTimeout });
+                }
+                catch (err) {
+                    if (err instanceof TimeoutError) {
+                        throw new CodeError$2(`Timed out waiting for DataChannel buffer to clear after ${this.bufferedAmountLowEventTimeout}ms`, 'ERR_BUFFER_CLEAR_TIMEOUT');
+                    }
+                    throw err;
+                }
+            }
+            if (this.channel.readyState === 'closed' || this.channel.readyState === 'closing') {
+                throw new CodeError$2(`Invalid datachannel state - ${this.channel.readyState}`, 'ERR_INVALID_STATE');
+            }
+            if (this.channel.readyState !== 'open') {
+                this.log('channel state is "%s" and not "open", waiting for "open" event before sending data', this.channel.readyState);
+                await pEvent(this.channel, 'open', { timeout: this.openTimeout });
+                this.log('channel state is now "%s", sending data', this.channel.readyState);
+            }
+            // send message without copying data
+            this.channel.send(data.subarray());
+        }
+        async sendData(data) {
+            // sending messages is an async operation so use a copy of the list as it
+            // may be changed beneath us
+            data = data.sublist();
+            while (data.byteLength > 0) {
+                const toSend = Math.min(data.byteLength, this.maxMessageSize);
+                const buf = data.subarray(0, toSend);
+                const msgbuf = Message$2.encode({ message: buf });
+                const sendbuf = encode.single(msgbuf);
+                await this._sendMessage(sendbuf);
+                data.consume(toSend);
+            }
+        }
+        async sendReset() {
+            await this._sendFlag(Message$2.Flag.RESET);
+        }
+        async sendCloseWrite(options) {
+            const sent = await this._sendFlag(Message$2.Flag.FIN);
+            if (sent) {
+                this.log.trace('awaiting FIN_ACK');
+                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'
+                    });
+                }
+                catch (err) {
+                    this.log.error('failed to await FIN_ACK', err);
+                }
+            }
+            else {
+                this.log.trace('sending FIN failed, not awaiting FIN_ACK');
+            }
+            // if we've attempted to receive a FIN_ACK, do not try again
+            this.receiveFinAck.resolve();
+        }
+        async sendCloseRead() {
+            await this._sendFlag(Message$2.Flag.STOP_SENDING);
+        }
+        /**
+         * Handle incoming
+         */
+        processIncomingProtobuf(buffer) {
+            const message = Message$2.decode(buffer);
+            if (message.flag !== undefined) {
+                this.log.trace('incoming flag %s, write status "%s", read status "%s"', message.flag, this.writeStatus, this.readStatus);
+                if (message.flag === Message$2.Flag.FIN) {
+                    // We should expect no more data from the remote, stop reading
+                    this.remoteCloseWrite();
+                    this.log.trace('sending FIN_ACK');
+                    void this._sendFlag(Message$2.Flag.FIN_ACK)
+                        .catch(err => {
+                        this.log.error('error sending FIN_ACK immediately', err);
+                    });
+                }
+                if (message.flag === Message$2.Flag.RESET) {
+                    // Stop reading and writing to the stream immediately
+                    this.reset();
+                }
+                if (message.flag === Message$2.Flag.STOP_SENDING) {
+                    // The remote has stopped reading
+                    this.remoteCloseRead();
+                }
+                if (message.flag === Message$2.Flag.FIN_ACK) {
+                    this.log.trace('received FIN_ACK');
+                    this.receiveFinAck.resolve();
+                }
+            }
+            // ignore data messages if we've closed the readable end already
+            if (this.readStatus === 'ready') {
+                return message.message;
+            }
+        }
+        async _sendFlag(flag) {
+            if (this.channel.readyState !== 'open') {
+                // flags can be sent while we or the remote are closing the datachannel so
+                // if the channel isn't open, don't try to send it but return false to let
+                // the caller know and act if they need to
+                this.log.trace('not sending flag %s because channel is "%s" and not "open"', this.channel.readyState, flag.toString());
+                return false;
+            }
+            this.log.trace('sending flag %s', flag.toString());
+            const msgbuf = Message$2.encode({ flag });
+            const prefixedBuf = encode.single(msgbuf);
+            try {
+                await this._sendMessage(prefixedBuf, false);
+                return true;
+            }
+            catch (err) {
+                this.log.error('could not send flag %s', flag.toString(), err);
+            }
+            return false;
+        }
+    }
+    function createStream(options) {
+        const { channel, direction } = options;
+        return new WebRTCStream({
+            id: direction === 'inbound' ? (`i${channel.id}`) : `r${channel.id}`,
+            log: options.logger.forComponent(`libp2p:webrtc:stream:${direction}:${channel.id}`),
+            ...options
+        });
+    }
+
+    const PROTOCOL$1 = '/webrtc';
+    class DataChannelMuxerFactory {
+        protocol;
+        /**
+         * WebRTC Peer Connection
+         */
+        peerConnection;
+        bufferedStreams = [];
+        metrics;
+        dataChannelOptions;
+        components;
+        log;
+        constructor(components, init) {
+            this.components = components;
+            this.peerConnection = init.peerConnection;
+            this.metrics = init.metrics;
+            this.protocol = init.protocol ?? PROTOCOL$1;
+            this.dataChannelOptions = init.dataChannelOptions ?? {};
+            this.log = components.logger.forComponent('libp2p:webrtc:datachannelmuxerfactory');
+            // store any datachannels opened before upgrade has been completed
+            this.peerConnection.ondatachannel = ({ channel }) => {
+                this.log.trace('incoming early datachannel with channel id %d and label "%s"', channel.id);
+                // 'init' channel is only used during connection establishment
+                if (channel.label === 'init') {
+                    this.log.trace('closing early init channel');
+                    channel.close();
+                    return;
+                }
+                // @ts-expect-error fields are set below
+                const bufferedStream = {};
+                const stream = createStream({
+                    channel,
+                    direction: 'inbound',
+                    onEnd: (err) => {
+                        bufferedStream.onEnd(err);
+                    },
+                    logger: components.logger,
+                    ...this.dataChannelOptions
+                });
+                bufferedStream.stream = stream;
+                bufferedStream.channel = channel;
+                bufferedStream.onEnd = () => {
+                    this.bufferedStreams = this.bufferedStreams.filter(s => s.stream.id !== stream.id);
+                };
+                this.bufferedStreams.push(bufferedStream);
+            };
+        }
+        createStreamMuxer(init) {
+            return new DataChannelMuxer(this.components, {
+                ...init,
+                peerConnection: this.peerConnection,
+                dataChannelOptions: this.dataChannelOptions,
+                metrics: this.metrics,
+                streams: this.bufferedStreams,
+                protocol: this.protocol
+            });
+        }
+    }
+    /**
+     * A libp2p data channel stream muxer
+     */
+    class DataChannelMuxer {
+        init;
+        /**
+         * Array of streams in the data channel
+         */
+        streams;
+        protocol;
+        log;
+        peerConnection;
+        dataChannelOptions;
+        metrics;
+        logger;
+        constructor(components, init) {
+            this.init = init;
+            this.log = components.logger.forComponent('libp2p:webrtc:muxer');
+            this.logger = components.logger;
+            this.streams = init.streams.map(s => s.stream);
+            this.peerConnection = init.peerConnection;
+            this.protocol = init.protocol ?? PROTOCOL$1;
+            this.metrics = init.metrics;
+            this.dataChannelOptions = init.dataChannelOptions ?? {};
+            /**
+             * Fired when a data channel has been added to the connection has been
+             * added by the remote peer.
+             *
+             * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/datachannel_event}
+             */
+            this.peerConnection.ondatachannel = ({ channel }) => {
+                this.log.trace('incoming datachannel with channel id %d', channel.id);
+                // 'init' channel is only used during connection establishment
+                if (channel.label === 'init') {
+                    this.log.trace('closing init channel');
+                    channel.close();
+                    return;
+                }
+                const stream = createStream({
+                    channel,
+                    direction: 'inbound',
+                    onEnd: () => {
+                        this.log('incoming channel %s ended with state %s', channel.id, channel.readyState);
+                        this.#onStreamEnd(stream, channel);
+                    },
+                    logger: this.logger,
+                    ...this.dataChannelOptions
+                });
+                this.streams.push(stream);
+                this.metrics?.increment({ incoming_stream: true });
+                init?.onIncomingStream?.(stream);
+            };
+            // the DataChannelMuxer constructor is called during set up of the
+            // connection by the upgrader.
+            //
+            // If we invoke `init.onIncomingStream` immediately, the connection object
+            // will not be set up yet so add a tiny delay before letting the
+            // connection know about early streams
+            if (this.init.streams.length > 0) {
+                queueMicrotask(() => {
+                    this.init.streams.forEach(bufferedStream => {
+                        bufferedStream.onEnd = () => {
+                            this.log('incoming early channel %s ended with state %s', bufferedStream.channel.id, bufferedStream.channel.readyState);
+                            this.#onStreamEnd(bufferedStream.stream, bufferedStream.channel);
+                        };
+                        this.metrics?.increment({ incoming_stream: true });
+                        this.init?.onIncomingStream?.(bufferedStream.stream);
+                    });
+                });
+            }
+        }
+        #onStreamEnd(stream, channel) {
+            this.log.trace('stream %s %s %s onEnd', stream.direction, stream.id, stream.protocol);
+            drainAndClose(channel, `${stream.direction} ${stream.id} ${stream.protocol}`, this.dataChannelOptions.drainTimeout, {
+                log: this.log
+            });
+            this.streams = this.streams.filter(s => s.id !== stream.id);
+            this.metrics?.increment({ stream_end: true });
+            this.init?.onStreamEnd?.(stream);
+        }
+        /**
+         * Gracefully close all tracked streams and stop the muxer
+         */
+        async close(options) {
+            try {
+                await Promise.all(this.streams.map(async (stream) => stream.close(options)));
+            }
+            catch (err) {
+                this.abort(err);
+            }
+        }
+        /**
+         * Abort all tracked streams and stop the muxer
+         */
+        abort(err) {
+            for (const stream of this.streams) {
+                stream.abort(err);
+            }
+        }
+        /**
+         * The stream source, a no-op as the transport natively supports multiplexing
+         */
+        source = nopSource();
+        /**
+         * The stream destination, a no-op as the transport natively supports multiplexing
+         */
+        sink = nopSink;
+        newStream() {
+            // The spec says the label SHOULD be an empty string: https://github.com/libp2p/specs/blob/master/webrtc/README.md#rtcdatachannel-label
+            const channel = this.peerConnection.createDataChannel('');
+            this.log.trace('opened outgoing datachannel with channel id %s', channel.id);
+            const stream = createStream({
+                channel,
+                direction: 'outbound',
+                onEnd: () => {
+                    this.log('outgoing channel %s ended with state %s', channel.id, channel.readyState);
+                    this.#onStreamEnd(stream, channel);
+                },
+                logger: this.logger,
+                ...this.dataChannelOptions
+            });
+            this.streams.push(stream);
+            this.metrics?.increment({ outgoing_stream: true });
+            return stream;
+        }
+    }
+
+    const RTCPeerConnection = globalThis.RTCPeerConnection;
+    const RTCSessionDescription = globalThis.RTCSessionDescription;
+    const RTCIceCandidate = globalThis.RTCIceCandidate;
+
+    /**
+     * @packageDocumentation
+     *
+     * This module makes it easy to send and receive length-prefixed Protobuf encoded
+     * messages over streams.
+     *
+     * @example
+     *
+     * ```typescript
+     * import { pbStream } from 'it-protobuf-stream'
+     * import { MessageType } from './src/my-message-type.js'
+     *
+     * // RequestType and ResponseType have been generate from `.proto` files and have
+     * // `.encode` and `.decode` methods for serialization/deserialization
+     *
+     * const stream = pbStream(duplex)
+     *
+     * // write a message to the stream
+     * stream.write({
+     *   foo: 'bar'
+     * }, MessageType)
+     *
+     * // read a message from the stream
+     * const res = await stream.read(MessageType)
+     * ```
+     */
+    function pbStream(duplex, opts) {
+        const lp = lpStream(duplex, opts);
+        const W = {
+            read: async (proto, options) => {
+                // readLP, decode
+                const value = await lp.read(options);
+                return proto.decode(value);
+            },
+            write: async (message, proto, options) => {
+                // encode, writeLP
+                await lp.write(proto.encode(message), options);
+            },
+            writeV: async (messages, proto, options) => {
+                // encode, writeLP
+                await lp.writeV(messages.map(message => proto.encode(message)), options);
+            },
+            pb: (proto) => {
+                return {
+                    read: async (options) => W.read(proto, options),
+                    write: async (d, options) => W.write(d, proto, options),
+                    writeV: async (d, options) => W.writeV(d, proto, options),
+                    unwrap: () => W
+                };
+            },
+            unwrap: () => {
+                return lp.unwrap();
+            }
+        };
+        return W;
+    }
+
+    /* eslint-disable import/export */
+    /* eslint-disable complexity */
+    /* eslint-disable @typescript-eslint/no-namespace */
+    /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+    /* eslint-disable @typescript-eslint/no-empty-interface */
+    var Message$1;
+    (function (Message) {
+        (function (Type) {
+            Type["SDP_OFFER"] = "SDP_OFFER";
+            Type["SDP_ANSWER"] = "SDP_ANSWER";
+            Type["ICE_CANDIDATE"] = "ICE_CANDIDATE";
+        })(Message.Type || (Message.Type = {}));
+        let __TypeValues;
+        (function (__TypeValues) {
+            __TypeValues[__TypeValues["SDP_OFFER"] = 0] = "SDP_OFFER";
+            __TypeValues[__TypeValues["SDP_ANSWER"] = 1] = "SDP_ANSWER";
+            __TypeValues[__TypeValues["ICE_CANDIDATE"] = 2] = "ICE_CANDIDATE";
+        })(__TypeValues || (__TypeValues = {}));
+        (function (Type) {
+            Type.codec = () => {
+                return enumeration(__TypeValues);
+            };
+        })(Message.Type || (Message.Type = {}));
+        let _codec;
+        Message.codec = () => {
+            if (_codec == null) {
+                _codec = message((obj, w, opts = {}) => {
+                    if (opts.lengthDelimited !== false) {
+                        w.fork();
+                    }
+                    if (obj.type != null) {
+                        w.uint32(8);
+                        Message.Type.codec().encode(obj.type, w);
+                    }
+                    if (obj.data != null) {
+                        w.uint32(18);
+                        w.string(obj.data);
+                    }
+                    if (opts.lengthDelimited !== false) {
+                        w.ldelim();
+                    }
+                }, (reader, length) => {
+                    const obj = {};
+                    const end = length == null ? reader.len : reader.pos + length;
+                    while (reader.pos < end) {
+                        const tag = reader.uint32();
+                        switch (tag >>> 3) {
+                            case 1:
+                                obj.type = Message.Type.codec().decode(reader);
+                                break;
+                            case 2:
+                                obj.data = reader.string();
+                                break;
+                            default:
+                                reader.skipType(tag & 7);
+                                break;
+                        }
+                    }
+                    return obj;
+                });
+            }
+            return _codec;
+        };
+        Message.encode = (obj) => {
+            return encodeMessage(obj, Message.codec());
+        };
+        Message.decode = (buf) => {
+            return decodeMessage(buf, Message.codec());
+        };
+    })(Message$1 || (Message$1 = {}));
+
+    const readCandidatesUntilConnected = async (pc, stream, options) => {
+        try {
+            const connectedPromise = pDefer();
+            resolveOnConnected(pc, connectedPromise);
+            // read candidates until we are connected or we reach the end of the stream
+            while (true) {
+                // if we connect, stop trying to read from the stream
+                const message = await Promise.race([
+                    connectedPromise.promise,
+                    stream.read({
+                        signal: options.signal
+                    }).catch(() => { })
+                ]);
+                // stream ended or we became connected
+                if (message == null) {
+                    // throw if we timed out
+                    options.signal?.throwIfAborted();
+                    break;
+                }
+                if (message.type !== Message$1.Type.ICE_CANDIDATE) {
+                    throw new CodeError$2('ICE candidate message expected', 'ERR_NOT_ICE_CANDIDATE');
+                }
+                const candidateInit = JSON.parse(message.data ?? 'null');
+                // an empty string means this generation of candidates is complete, a null
+                // candidate means candidate gathering has finished
+                // see - https://www.w3.org/TR/webrtc/#rtcpeerconnectioniceevent
+                if (candidateInit === '' || candidateInit === null) {
+                    options.log.trace('end-of-candidates received');
+                    continue;
+                }
+                const candidate = new RTCIceCandidate(candidateInit);
+                options.log.trace('%s received new ICE candidate %o', options.direction, candidateInit);
+                try {
+                    await pc.addIceCandidate(candidate);
+                }
+                catch (err) {
+                    options.log.error('%s bad candidate received', options.direction, candidateInit, err);
+                }
+            }
+        }
+        catch (err) {
+            options.log.error('%s error parsing ICE candidate', options.direction, err);
+            if (options.signal?.aborted === true) {
+                throw err;
+            }
+        }
+    };
+    function getConnectionState(pc) {
+        return isFirefox ? pc.iceConnectionState : pc.connectionState;
+    }
+    function resolveOnConnected(pc, promise) {
+        pc[isFirefox ? 'oniceconnectionstatechange' : 'onconnectionstatechange'] = (_) => {
+            switch (getConnectionState(pc)) {
+                case 'connected':
+                    promise.resolve();
+                    break;
+                case 'failed':
+                case 'disconnected':
+                case 'closed':
+                    promise.reject(new CodeError$2('RTCPeerConnection was closed', 'ERR_CONNECTION_CLOSED_BEFORE_CONNECTED'));
+                    break;
+            }
+        };
+    }
+
+    async function initiateConnection({ rtcConfiguration, dataChannel, signal, metrics, multiaddr: ma, connectionManager, transportManager, log, logger }) {
+        const { baseAddr } = splitAddr(ma);
+        metrics?.dialerEvents.increment({ open: true });
+        log.trace('dialing base address: %a', baseAddr);
+        const relayPeer = baseAddr.getPeerId();
+        if (relayPeer == null) {
+            throw new CodeError$2('Relay peer was missing', 'ERR_INVALID_ADDRESS');
+        }
+        const connections = connectionManager.getConnections(peerIdFromString(relayPeer));
+        let connection;
+        let shouldCloseConnection = false;
+        if (connections.length === 0) {
+            // use the transport manager to open a connection. Initiating a WebRTC
+            // connection takes place in the context of a dial - if we use the
+            // connection manager instead we can end up joining our own dial context
+            connection = await transportManager.dial(baseAddr, {
+                signal
+            });
+            // this connection is unmanaged by the connection manager so we should
+            // close it when we are done
+            shouldCloseConnection = true;
+        }
+        else {
+            connection = connections[0];
+        }
+        try {
+            const stream = await connection.newStream(SIGNALING_PROTO_ID, {
+                signal,
+                runOnTransientConnection: true
+            });
+            const messageStream = pbStream(stream).pb(Message$1);
+            const peerConnection = new RTCPeerConnection(rtcConfiguration);
+            const muxerFactory = new DataChannelMuxerFactory({
+                logger
+            }, {
+                peerConnection,
+                dataChannelOptions: dataChannel
+            });
+            try {
+                // we create the channel so that the RTCPeerConnection has a component for
+                // which to collect candidates. The label is not relevant to connection
+                // initiation but can be useful for debugging
+                const channel = peerConnection.createDataChannel('init');
+                // setup callback to write ICE candidates to the remote peer
+                peerConnection.onicecandidate = ({ candidate }) => {
+                    // a null candidate means end-of-candidates, an empty string candidate
+                    // means end-of-candidates for this generation, otherwise this should
+                    // be a valid candidate object
+                    // see - https://www.w3.org/TR/webrtc/#rtcpeerconnectioniceevent
+                    const data = JSON.stringify(candidate?.toJSON() ?? null);
+                    log.trace('initiator sending ICE candidate %o', candidate);
+                    void messageStream.write({
+                        type: Message$1.Type.ICE_CANDIDATE,
+                        data
+                    }, {
+                        signal
+                    })
+                        .catch(err => {
+                        log.error('error sending ICE candidate', err);
+                    });
+                };
+                peerConnection.onicecandidateerror = (event) => {
+                    log.error('initiator ICE candidate error', event);
+                };
+                // create an offer
+                const offerSdp = await peerConnection.createOffer().catch(err => {
+                    log.error('could not execute createOffer', err);
+                    throw new CodeError$2('Failed to set createOffer', 'ERR_SDP_HANDSHAKE_FAILED');
+                });
+                log.trace('initiator send SDP offer %s', offerSdp.sdp);
+                // write the offer to the stream
+                await messageStream.write({ type: Message$1.Type.SDP_OFFER, data: offerSdp.sdp }, {
+                    signal
+                });
+                // set offer as local description
+                await peerConnection.setLocalDescription(offerSdp).catch(err => {
+                    log.error('could not execute setLocalDescription', err);
+                    throw new CodeError$2('Failed to set localDescription', 'ERR_SDP_HANDSHAKE_FAILED');
+                });
+                // read answer
+                const answerMessage = await messageStream.read({
+                    signal
+                });
+                if (answerMessage.type !== Message$1.Type.SDP_ANSWER) {
+                    throw new CodeError$2('Remote should send an SDP answer', 'ERR_SDP_HANDSHAKE_FAILED');
+                }
+                log.trace('initiator receive SDP answer %s', answerMessage.data);
+                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$2('Failed to set remoteDescription', 'ERR_SDP_HANDSHAKE_FAILED');
+                });
+                log.trace('initiator read candidates until connected');
+                await readCandidatesUntilConnected(peerConnection, messageStream, {
+                    direction: 'initiator',
+                    signal,
+                    log
+                });
+                log.trace('initiator connected, closing init channel');
+                channel.close();
+                log.trace('closing signalling channel');
+                await stream.close({
+                    signal
+                });
+                log.trace('initiator connected to remote address %s', ma);
+                return {
+                    remoteAddress: ma,
+                    peerConnection,
+                    muxerFactory
+                };
+            }
+            catch (err) {
+                log.error('outgoing signalling error', err);
+                peerConnection.close();
+                stream.abort(err);
+                throw err;
+            }
+            finally {
+                peerConnection.onicecandidate = null;
+                peerConnection.onicecandidateerror = null;
+            }
+        }
+        finally {
+            // if we had to open a connection to perform the SDP handshake
+            // close it because it's not tracked by the connection manager
+            if (shouldCloseConnection) {
+                try {
+                    await connection.close({
+                        signal
+                    });
+                }
+                catch (err) {
+                    connection.abort(err);
+                }
+            }
+        }
+    }
+
+    class WebRTCPeerListener extends TypedEventEmitter {
+        peerId;
+        transportManager;
+        shutdownController;
+        constructor(components, init) {
+            super();
+            this.peerId = components.peerId;
+            this.transportManager = components.transportManager;
+            this.shutdownController = init.shutdownController;
+        }
+        async listen() {
+            this.safeDispatchEvent('listening', {});
+        }
+        getAddrs() {
+            return this.transportManager
+                .getListeners()
+                .filter(l => l !== this)
+                .map(l => l.getAddrs()
+                .filter(ma => Circuit.matches(ma))
+                .map(ma => {
+                return ma.encapsulate(`/webrtc/p2p/${this.peerId}`);
+            }))
+                .flat();
+        }
+        async close() {
+            this.shutdownController.abort();
+            this.safeDispatchEvent('close', {});
+        }
+    }
+
+    async function handleIncomingStream({ peerConnection, stream, signal, connection, log }) {
+        log.trace('new inbound signaling stream');
+        const messageStream = pbStream(stream).pb(Message$1);
+        try {
+            // candidate callbacks
+            peerConnection.onicecandidate = ({ candidate }) => {
+                // a null candidate means end-of-candidates, an empty string candidate
+                // means end-of-candidates for this generation, otherwise this should
+                // be a valid candidate object
+                // see - https://www.w3.org/TR/webrtc/#rtcpeerconnectioniceevent
+                const data = JSON.stringify(candidate?.toJSON() ?? null);
+                log.trace('recipient sending ICE candidate %s', data);
+                messageStream.write({
+                    type: Message$1.Type.ICE_CANDIDATE,
+                    data
+                }, {
+                    signal
+                })
+                    .catch(err => {
+                    log.error('error sending ICE candidate', err);
+                });
+            };
+            // read an SDP offer
+            const pbOffer = await messageStream.read({
+                signal
+            });
+            if (pbOffer.type !== Message$1.Type.SDP_OFFER) {
+                throw new CodeError$2(`expected message type SDP_OFFER, received: ${pbOffer.type ?? 'undefined'} `, 'ERR_SDP_HANDSHAKE_FAILED');
+            }
+            log.trace('recipient receive SDP offer %s', pbOffer.data);
+            const offer = new RTCSessionDescription({
+                type: 'offer',
+                sdp: pbOffer.data
+            });
+            await peerConnection.setRemoteDescription(offer).catch(err => {
+                log.error('could not execute setRemoteDescription', err);
+                throw new CodeError$2('Failed to set remoteDescription', 'ERR_SDP_HANDSHAKE_FAILED');
+            });
+            // create and write an SDP answer
+            const answer = await peerConnection.createAnswer().catch(err => {
+                log.error('could not execute createAnswer', err);
+                throw new CodeError$2('Failed to create answer', 'ERR_SDP_HANDSHAKE_FAILED');
+            });
+            log.trace('recipient send SDP answer %s', answer.sdp);
+            // write the answer to the remote
+            await messageStream.write({ type: Message$1.Type.SDP_ANSWER, data: answer.sdp }, {
+                signal
+            });
+            await peerConnection.setLocalDescription(answer).catch(err => {
+                log.error('could not execute setLocalDescription', err);
+                throw new CodeError$2('Failed to set localDescription', 'ERR_SDP_HANDSHAKE_FAILED');
+            });
+            log.trace('recipient read candidates until connected');
+            // wait until candidates are connected
+            await readCandidatesUntilConnected(peerConnection, messageStream, {
+                direction: 'recipient',
+                signal,
+                log
+            });
+        }
+        catch (err) {
+            if (peerConnection.connectionState !== 'connected') {
+                log.error('error while handling signaling stream from peer %a', connection.remoteAddr, err);
+                peerConnection.close();
+                throw err;
+            }
+            else {
+                log('error while handling signaling stream from peer %a, ignoring as the RTCPeerConnection is already connected', connection.remoteAddr, err);
+            }
+        }
+        const remoteAddress = multiaddr(`/webrtc/p2p/${connection.remoteAddr.getPeerId()}`);
+        log.trace('recipient connected to remote address %s', remoteAddress);
+        return { remoteAddress };
+    }
+
+    const WEBRTC_TRANSPORT = '/webrtc';
+    const CIRCUIT_RELAY_TRANSPORT = '/p2p-circuit';
+    const SIGNALING_PROTO_ID = '/webrtc-signaling/0.0.1';
+    const INBOUND_CONNECTION_TIMEOUT = 30 * 1000;
+    class WebRTCTransport {
+        components;
+        init;
+        log;
+        _started = false;
+        metrics;
+        shutdownController;
+        constructor(components, init = {}) {
+            this.components = components;
+            this.init = init;
+            this.log = components.logger.forComponent('libp2p:webrtc');
+            this.shutdownController = new AbortController();
+            setMaxListeners(Infinity, this.shutdownController.signal);
+            if (components.metrics != null) {
+                this.metrics = {
+                    dialerEvents: components.metrics.registerCounterGroup('libp2p_webrtc_dialer_events_total', {
+                        label: 'event',
+                        help: 'Total count of WebRTC dialer events by type'
+                    }),
+                    listenerEvents: components.metrics.registerCounterGroup('libp2p_webrtc_listener_events_total', {
+                        label: 'event',
+                        help: 'Total count of WebRTC listener events by type'
+                    })
+                };
+            }
+        }
+        [transportSymbol] = true;
+        [Symbol.toStringTag] = '@libp2p/webrtc';
+        [serviceCapabilities] = [
+            '@libp2p/transport'
+        ];
+        [serviceDependencies] = [
+            '@libp2p/identify',
+            '@libp2p/circuit-relay-v2-transport'
+        ];
+        isStarted() {
+            return this._started;
+        }
+        async start() {
+            await this.components.registrar.handle(SIGNALING_PROTO_ID, (data) => {
+                this._onProtocol(data).catch(err => { this.log.error('failed to handle incoming connect from %p', data.connection.remotePeer, err); });
+            }, {
+                runOnTransientConnection: true
+            });
+            this._started = true;
+        }
+        async stop() {
+            await this.components.registrar.unhandle(SIGNALING_PROTO_ID);
+            this._started = false;
+        }
+        createListener(options) {
+            return new WebRTCPeerListener(this.components, {
+                shutdownController: this.shutdownController
+            });
+        }
+        /**
+         * Filter check for all Multiaddrs that this transport can listen on
+         */
+        listenFilter(multiaddrs) {
+            return multiaddrs.filter(WebRTC.exactMatch);
+        }
+        /**
+         * Filter check for all Multiaddrs that this transport can dial
+         */
+        dialFilter(multiaddrs) {
+            return this.listenFilter(multiaddrs);
+        }
+        /*
+         * dial connects to a remote via the circuit relay or any other protocol
+         * and proceeds to upgrade to a webrtc connection.
+         * multiaddr of the form: <multiaddr>/webrtc/p2p/<destination-peer>
+         * For a circuit relay, this will be of the form
+         * <relay address>/p2p/<relay-peer>/p2p-circuit/webrtc/p2p/<destination-peer>
+        */
+        async dial(ma, options) {
+            this.log.trace('dialing address: %a', ma);
+            const { remoteAddress, peerConnection, muxerFactory } = await initiateConnection({
+                rtcConfiguration: typeof this.init.rtcConfiguration === 'function' ? await this.init.rtcConfiguration() : this.init.rtcConfiguration,
+                dataChannel: this.init.dataChannel,
+                multiaddr: ma,
+                dataChannelOptions: this.init.dataChannel,
+                signal: options.signal,
+                connectionManager: this.components.connectionManager,
+                transportManager: this.components.transportManager,
+                log: this.log,
+                logger: this.components.logger
+            });
+            const webRTCConn = new WebRTCMultiaddrConnection(this.components, {
+                peerConnection,
+                timeline: { open: Date.now() },
+                remoteAddr: remoteAddress,
+                metrics: this.metrics?.dialerEvents
+            });
+            const connection = await options.upgrader.upgradeOutbound(webRTCConn, {
+                skipProtection: true,
+                skipEncryption: true,
+                muxerFactory
+            });
+            // close the connection on shut down
+            this._closeOnShutdown(peerConnection, webRTCConn);
+            return connection;
+        }
+        async _onProtocol({ connection, stream }) {
+            const signal = AbortSignal.timeout(this.init.inboundConnectionTimeout ?? INBOUND_CONNECTION_TIMEOUT);
+            const peerConnection = new RTCPeerConnection(typeof this.init.rtcConfiguration === 'function' ? await this.init.rtcConfiguration() : this.init.rtcConfiguration);
+            const muxerFactory = new DataChannelMuxerFactory(this.components, {
+                peerConnection,
+                dataChannelOptions: this.init.dataChannel
+            });
+            try {
+                const { remoteAddress } = await handleIncomingStream({
+                    peerConnection,
+                    connection,
+                    stream,
+                    signal,
+                    log: this.log
+                });
+                // close the stream if SDP messages have been exchanged successfully
+                await stream.close({
+                    signal
+                });
+                const webRTCConn = new WebRTCMultiaddrConnection(this.components, {
+                    peerConnection,
+                    timeline: { open: (new Date()).getTime() },
+                    remoteAddr: remoteAddress,
+                    metrics: this.metrics?.listenerEvents
+                });
+                await this.components.upgrader.upgradeInbound(webRTCConn, {
+                    skipEncryption: true,
+                    skipProtection: true,
+                    muxerFactory
+                });
+                // close the connection on shut down
+                this._closeOnShutdown(peerConnection, webRTCConn);
+            }
+            catch (err) {
+                this.log.error('incoming signalling error', err);
+                peerConnection.close();
+                stream.abort(err);
+                throw err;
+            }
+        }
+        _closeOnShutdown(pc, webRTCConn) {
+            // close the connection on shut down
+            const shutDownListener = () => {
+                webRTCConn.close()
+                    .catch(err => {
+                    this.log.error('could not close WebRTCMultiaddrConnection', err);
+                });
+            };
+            this.shutdownController.signal.addEventListener('abort', shutDownListener);
+            pc.addEventListener('close', () => {
+                this.shutdownController.signal.removeEventListener('abort', shutDownListener);
+            });
+        }
+    }
+    function splitAddr(ma) {
+        const addrs = ma.toString().split(WEBRTC_TRANSPORT + '/');
+        if (addrs.length !== 2) {
+            throw new CodeError$2('webrtc protocol was not present in multiaddr', codes.ERR_INVALID_MULTIADDR);
+        }
+        if (!addrs[0].includes(CIRCUIT_RELAY_TRANSPORT)) {
+            throw new CodeError$2('p2p-circuit protocol was not present in multiaddr', codes.ERR_INVALID_MULTIADDR);
+        }
+        // look for remote peerId
+        let remoteAddr = multiaddr(addrs[0]);
+        const destination = multiaddr('/' + addrs[1]);
+        const destinationIdString = destination.getPeerId();
+        if (destinationIdString == null) {
+            throw new CodeError$2('destination peer id was missing', codes.ERR_INVALID_MULTIADDR);
+        }
+        const lastProtoInRemote = remoteAddr.protos().pop();
+        if (lastProtoInRemote === undefined) {
+            throw new CodeError$2('invalid multiaddr', codes.ERR_INVALID_MULTIADDR);
+        }
+        if (lastProtoInRemote.name !== 'p2p') {
+            remoteAddr = remoteAddr.encapsulate(`/p2p/${destinationIdString}`);
+        }
+        return { baseAddr: remoteAddr, peerId: peerIdFromString(destinationIdString) };
+    }
+
+    /**
+     * @packageDocumentation
+     *
+     * A [libp2p transport](https://docs.libp2p.io/concepts/transports/overview/) based on [WebRTC datachannels](https://webrtc.org/).
+     *
+     * [WebRTC](https://www.w3.org/TR/webrtc/) is a specification that allows real-time communication between nodes - it's commonly used in browser video conferencing applications but it also provides a reliable data transport mechanism called [data channels](https://www.w3.org/TR/webrtc/#peer-to-peer-data-api) which libp2p uses to facilitate [protocol streams](https://docs.libp2p.io/concepts/multiplex/overview/) between peers.
+     *
+     * There are two transports exposed by this module, [webRTC](https://github.com/libp2p/specs/blob/master/webrtc/webrtc.md) and [webRTCDirect](https://github.com/libp2p/specs/blob/master/webrtc/webrtc-direct.md).
+     *
+     * ## WebRTC vs WebRTC Direct
+     *
+     * The connection establishment phase of WebRTC involves a handshake using [SDP](https://en.wikipedia.org/wiki/Session_Description_Protocol) during which two peers will exchange information such as open ports, network addresses and required capabilities.
+     *
+     * A third party is usually necessary to carry out this handshake, forwarding messages between the two peers until they can make a direct connection between themselves.
+     *
+     * The WebRTC transport uses libp2p [Circuit Relay](https://docs.libp2p.io/concepts/nat/circuit-relay/)s to forward SDP messages. Once a direct connection is formed the relay plays no further part in the exchange.
+     *
+     * WebRTC Direct uses a technique known as [SDP munging](https://webrtchacks.com/not-a-guide-to-sdp-munging/) to skip the handshake step, instead encoding enough information in the connection request that the responder can derive what would have been in the handshake messages and so requires no third parties to establish a connection.
+     *
+     * A WebRTC Direct multiaddr also includes a certhash of the target peer - this is used to allow opening a connection to the remote, which would otherwise be denied due to use of a self-signed certificate.
+     *
+     * In both cases, once the connection is established a [Noise handshake](https://noiseprotocol.org/noise.html) is carried out to ensure that the remote peer has the private key that corresponds to the public key that makes up their PeerId, giving you both encryption and authentication.
+     *
+     * ## Support
+     *
+     * WebRTC is supported in both Node.js and browsers.
+     *
+     * At the time of writing, WebRTC Direct is dial-only in browsers and not supported in Node.js at all.
+     *
+     * Support in Node.js is possible but PRs will need to be opened to [libdatachannel](https://github.com/paullouisageneau/libdatachannel) and the appropriate APIs exposed in [node-datachannel](https://github.com/murat-dogan/node-datachannel).
+     *
+     * WebRTC Direct support is available in rust-libp2p and arriving soon in go-libp2p.
+     *
+     * See the WebRTC section of https://connectivity.libp2p.io for more information.
+     *
+     * @example WebRTC
+     *
+     * WebRTC requires use of a relay to connect two nodes. The listener first discovers a relay server and makes a reservation, then the dialer can connect via the relayed address.
+     *
+     * ```TypeScript
+     * import { noise } from '@chainsafe/libp2p-noise'
+     * import { yamux } from '@chainsafe/libp2p-yamux'
+     * import { echo } from '@libp2p/echo'
+     * import { circuitRelayTransport, circuitRelayServer } from '@libp2p/circuit-relay-v2'
+     * import { identify } from '@libp2p/identify'
+     * import { webRTC } from '@libp2p/webrtc'
+     * import { webSockets } from '@libp2p/websockets'
+     * import * as filters from '@libp2p/websockets/filters'
+     * import { WebRTC } from '@multiformats/multiaddr-matcher'
+     * import delay from 'delay'
+     * import { pipe } from 'it-pipe'
+     * import { createLibp2p } from 'libp2p'
+     * import type { Multiaddr } from '@multiformats/multiaddr'
+     *
+     * // the relay server listens on a transport dialable by the listener and the
+     * // dialer, and has a relay service configured
+     * const relay = await createLibp2p({
+     *   addresses: {
+     *   listen: ['/ip4/127.0.0.1/tcp/0/ws']
+     *   },
+     *   transports: [
+     *     webSockets({filter: filters.all})
+     *   ],
+     *   connectionEncryption: [noise()],
+     *   streamMuxers: [yamux()],
+     *   services: {
+     *     identify: identify(),
+     *     relay: circuitRelayServer()
+     *   }
+     * })
+     *
+     * // the listener has a WebSocket transport to dial the relay, a Circuit Relay
+     * // transport to make a reservation, and a WebRTC transport to accept incoming
+     * // WebRTC connections
+     * const listener = await createLibp2p({
+     *   addresses: {
+     *   listen: ['/webrtc']
+     *   },
+     *   transports: [
+     *     webSockets({filter: filters.all}),
+     *     webRTC(),
+     *     circuitRelayTransport({
+     *       discoverRelays: 1
+     *     })
+     *   ],
+     *   connectionEncryption: [noise()],
+     *   streamMuxers: [yamux()],
+     *   services: {
+     *     identify: identify(),
+     *     echo: echo()
+     *   }
+     * })
+     *
+     * // the listener dials the relay (or discovers a public relay via some other
+     * // method)
+     * await listener.dial(relay.getMultiaddrs(), {
+     *   signal: AbortSignal.timeout(5000)
+     * })
+     *
+     * let webRTCMultiaddr: Multiaddr | undefined
+     *
+     * // wait for the listener to make a reservation on the relay
+     * while (true) {
+     *   webRTCMultiaddr = listener.getMultiaddrs().find(ma => WebRTC.matches(ma))
+     *
+     *   if (webRTCMultiaddr != null) {
+     *     break
+     *   }
+     *
+     *   // try again later
+     *   await delay(1000)
+     * }
+     *
+     * // the dialer has Circuit Relay, WebSocket and WebRTC transports to dial
+     * // the listener via the relay, complete the SDP handshake and establish a
+     * // direct WebRTC connection
+     * const dialer = await createLibp2p({
+     *   transports: [
+     *     webSockets({filter: filters.all}),
+     *     webRTC(),
+     *     circuitRelayTransport()
+     *   ],
+     *   connectionEncryption: [noise()],
+     *   streamMuxers: [yamux()],
+     *   services: {
+     *     identify: identify(),
+     *     echo: echo()
+     *   }
+     * })
+     *
+     * // dial the listener and open an echo protocol stream
+     * const stream = await dialer.dialProtocol(webRTCMultiaddr, dialer.services.echo.protocol, {
+     *   signal: AbortSignal.timeout(5000)
+     * })
+     *
+     * // we can now stop the relay
+     * await relay.stop()
+     *
+     * // send/receive some data from the remote peer via a direct connection
+     * await pipe(
+     *   [new TextEncoder().encode('hello world')],
+     *   stream,
+     *   async source => {
+     *     for await (const buf of source) {
+     *       console.info(new TextDecoder().decode(buf.subarray()))
+     *     }
+     *   }
+     * )
+     * ```
+     *
+     * @example WebRTC Direct
+     *
+     * At the time of writing WebRTC Direct is dial-only in browsers and unsupported in Node.js.
+     *
+     * The only implementation that supports a WebRTC Direct listener is go-libp2p and it's not yet enabled by default.
+     *
+     * ```TypeScript
+     * import { createLibp2p } from 'libp2p'
+     * import { noise } from '@chainsafe/libp2p-noise'
+     * import { multiaddr } from '@multiformats/multiaddr'
+     * import { pipe } from 'it-pipe'
+     * import { fromString, toString } from 'uint8arrays'
+     * import { webRTCDirect } from '@libp2p/webrtc'
+     *
+     * const node = await createLibp2p({
+     *   transports: [
+     *     webRTCDirect()
+     *   ],
+     *   connectionEncryption: [
+     *     noise()
+     *   ]
+     * })
+     *
+     * await node.start()
+     *
+     * // this multiaddr corresponds to a remote node running a WebRTC Direct listener
+     * const ma = multiaddr('/ip4/0.0.0.0/udp/56093/webrtc-direct/certhash/uEiByaEfNSLBexWBNFZy_QB1vAKEj7JAXDizRs4_SnTflsQ')
+     * const stream = await node.dialProtocol(ma, '/my-protocol/1.0.0', {
+     *   signal: AbortSignal.timeout(10_000)
+     * })
+     *
+     * await pipe(
+     *   [fromString(`Hello js-libp2p-webrtc\n`)],
+     *   stream,
+     *   async function (source) {
+     *     for await (const buf of source) {
+     *       console.info(toString(buf.subarray()))
+     *     }
+     *   }
+     * )
+     * ```
+     */
+    /**
+     * @param {WebRTCTransportInit} init - WebRTC transport configuration
+     * @param {RTCConfiguration} init.rtcConfiguration - RTCConfiguration
+     * @param init.dataChannel - DataChannel configurations
+     * @param {number} init.dataChannel.maxMessageSize - Max message size that can be sent through the DataChannel. Larger messages will be chunked into smaller messages below this size (default 16kb)
+     * @param {number} init.dataChannel.maxBufferedAmount - Max buffered amount a DataChannel can have (default 16mb)
+     * @param {number} init.dataChannel.bufferedAmountLowEventTimeout - If max buffered amount is reached, this is the max time that is waited before the buffer is cleared (default 30 seconds)
+     * @returns
+     */
+    function webRTC(init) {
+        return (components) => new WebRTCTransport(components, init);
+    }
+
+    /* eslint-disable import/export */
+    /* eslint-disable complexity */
+    /* eslint-disable @typescript-eslint/no-namespace */
+    /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+    /* eslint-disable @typescript-eslint/no-empty-interface */
+    var HolePunch;
+    (function (HolePunch) {
+        (function (Type) {
+            Type["UNUSED"] = "UNUSED";
+            Type["CONNECT"] = "CONNECT";
+            Type["SYNC"] = "SYNC";
+        })(HolePunch.Type || (HolePunch.Type = {}));
+        let __TypeValues;
+        (function (__TypeValues) {
+            __TypeValues[__TypeValues["UNUSED"] = 0] = "UNUSED";
+            __TypeValues[__TypeValues["CONNECT"] = 100] = "CONNECT";
+            __TypeValues[__TypeValues["SYNC"] = 300] = "SYNC";
+        })(__TypeValues || (__TypeValues = {}));
+        (function (Type) {
+            Type.codec = () => {
+                return enumeration(__TypeValues);
+            };
+        })(HolePunch.Type || (HolePunch.Type = {}));
+        let _codec;
+        HolePunch.codec = () => {
+            if (_codec == null) {
+                _codec = message((obj, w, opts = {}) => {
+                    if (opts.lengthDelimited !== false) {
+                        w.fork();
+                    }
+                    if (obj.type != null) {
+                        w.uint32(8);
+                        HolePunch.Type.codec().encode(obj.type, w);
+                    }
+                    if (obj.observedAddresses != null) {
+                        for (const value of obj.observedAddresses) {
+                            w.uint32(18);
+                            w.bytes(value);
+                        }
+                    }
+                    if (opts.lengthDelimited !== false) {
+                        w.ldelim();
+                    }
+                }, (reader, length) => {
+                    const obj = {
+                        observedAddresses: []
+                    };
+                    const end = length == null ? reader.len : reader.pos + length;
+                    while (reader.pos < end) {
+                        const tag = reader.uint32();
+                        switch (tag >>> 3) {
+                            case 1:
+                                obj.type = HolePunch.Type.codec().decode(reader);
+                                break;
+                            case 2:
+                                obj.observedAddresses.push(reader.bytes());
+                                break;
+                            default:
+                                reader.skipType(tag & 7);
+                                break;
+                        }
+                    }
+                    return obj;
+                });
+            }
+            return _codec;
+        };
+        HolePunch.encode = (obj) => {
+            return encodeMessage(obj, HolePunch.codec());
+        };
+        HolePunch.decode = (buf) => {
+            return decodeMessage(buf, HolePunch.codec());
+        };
+    })(HolePunch || (HolePunch = {}));
+
+    /**
+     * Returns true if the passed multiaddr is public, not relayed and we have a
+     * transport that can dial it
+     */
+    function isPublicAndDialable(ma, transportManager) {
+        // ignore circuit relay
+        if (Circuit$1.matches(ma)) {
+            return false;
+        }
+        const transport = transportManager.dialTransportForMultiaddr(ma);
+        if (transport == null) {
+            return false;
+        }
+        // dns addresses are probably public?
+        if (DNS$2.matches(ma)) {
+            return true;
+        }
+        // ensure we have only IPv4/IPv6 addresses
+        if (!IP$1.matches(ma)) {
+            return false;
+        }
+        return isPrivateIp(ma.toOptions().host) === false;
+    }
+
+    // https://github.com/libp2p/specs/blob/master/relay/DCUtR.md#rpc-messages
+    const MAX_DCUTR_MESSAGE_SIZE = 1024 * 4;
+    // ensure the dial has a high priority to jump to the head of the dial queue
+    const DCUTR_DIAL_PRIORITY = 100;
+    const defaultValues$1 = {
+        // https://github.com/libp2p/go-libp2p/blob/8d2e54e1637041d5cf4fac1e531287560bd1f4ac/p2p/protocol/holepunch/holepuncher.go#L27
+        timeout: 5000,
+        // https://github.com/libp2p/go-libp2p/blob/8d2e54e1637041d5cf4fac1e531287560bd1f4ac/p2p/protocol/holepunch/holepuncher.go#L28
+        retries: 3,
+        maxInboundStreams: 1,
+        maxOutboundStreams: 1
+    };
+    class DefaultDCUtRService {
+        started;
+        timeout;
+        retries;
+        maxInboundStreams;
+        maxOutboundStreams;
+        peerStore;
+        registrar;
+        connectionManager;
+        addressManager;
+        transportManager;
+        topologyId;
+        log;
+        constructor(components, init) {
+            this.log = components.logger.forComponent('libp2p:dcutr');
+            this.started = false;
+            this.peerStore = components.peerStore;
+            this.registrar = components.registrar;
+            this.addressManager = components.addressManager;
+            this.connectionManager = components.connectionManager;
+            this.transportManager = components.transportManager;
+            this.timeout = init.timeout ?? defaultValues$1.timeout;
+            this.retries = init.retries ?? defaultValues$1.retries;
+            this.maxInboundStreams = init.maxInboundStreams ?? defaultValues$1.maxInboundStreams;
+            this.maxOutboundStreams = init.maxOutboundStreams ?? defaultValues$1.maxOutboundStreams;
+        }
+        [Symbol.toStringTag] = '@libp2p/dcutr';
+        [serviceDependencies] = [
+            '@libp2p/identify'
+        ];
+        isStarted() {
+            return this.started;
+        }
+        async start() {
+            if (this.started) {
+                return;
+            }
+            // register for notifications of when peers that support DCUtR connect
+            // nb. requires the identify service to be enabled
+            this.topologyId = await this.registrar.register(multicodec, {
+                notifyOnTransient: true,
+                onConnect: (peerId, connection) => {
+                    if (!connection.transient) {
+                        // the connection is already direct, no upgrade is required
+                        return;
+                    }
+                    // the inbound peer starts the connection upgrade
+                    if (connection.direction !== 'inbound') {
+                        return;
+                    }
+                    this.upgradeInbound(connection)
+                        .catch(err => {
+                        this.log.error('error during outgoing DCUtR attempt', err);
+                    });
+                }
+            });
+            await this.registrar.handle(multicodec, (data) => {
+                void this.handleIncomingUpgrade(data.stream, data.connection).catch(err => {
+                    this.log.error('error during incoming DCUtR attempt', err);
+                    data.stream.abort(err);
+                });
+            }, {
+                maxInboundStreams: this.maxInboundStreams,
+                maxOutboundStreams: this.maxOutboundStreams,
+                runOnTransientConnection: true
+            });
+            this.started = true;
+        }
+        async stop() {
+            await this.registrar.unhandle(multicodec);
+            if (this.topologyId != null) {
+                this.registrar.unregister(this.topologyId);
+            }
+            this.started = false;
+        }
+        /**
+         * Perform the inbound connection upgrade as B
+         *
+         * @see https://github.com/libp2p/specs/blob/master/relay/DCUtR.md#the-protocol
+         */
+        async upgradeInbound(relayedConnection) {
+            // Upon observing the new connection, the inbound peer (here B) checks the
+            // addresses advertised by A via identify.
+            //
+            // If that set includes public addresses, then A may be reachable by a direct
+            // connection, in which case B attempts a unilateral connection upgrade by
+            // initiating a direct connection to A.
+            if (await this.attemptUnilateralConnectionUpgrade(relayedConnection)) {
+                return;
+            }
+            let stream;
+            for (let i = 0; i < this.retries; i++) {
+                const options = {
+                    signal: AbortSignal.timeout(this.timeout)
+                };
+                try {
+                    // 1. B opens a stream to A using the /libp2p/dcutr protocol.
+                    stream = await relayedConnection.newStream([multicodec], {
+                        signal: options.signal,
+                        runOnTransientConnection: true
+                    });
+                    const pb = pbStream(stream, {
+                        maxDataLength: MAX_DCUTR_MESSAGE_SIZE
+                    }).pb(HolePunch);
+                    // 2. B sends to A a Connect message containing its observed (and
+                    // possibly predicted) addresses from identify and starts a timer
+                    // to measure RTT of the relay connection.
+                    this.log('B sending connect to %p', relayedConnection.remotePeer);
+                    const connectTimer = Date.now();
+                    await pb.write({
+                        type: HolePunch.Type.CONNECT,
+                        observedAddresses: this.addressManager.getAddresses().map(ma => ma.bytes)
+                    }, options);
+                    this.log('B receiving connect from %p', relayedConnection.remotePeer);
+                    // 4. Upon receiving the Connect, B sends a Sync message
+                    const connect = await pb.read(options);
+                    if (connect.type !== HolePunch.Type.CONNECT) {
+                        this.log('A sent wrong message type');
+                        throw new CodeError$2('DCUtR message type was incorrect', ERR_INVALID_MESSAGE);
+                    }
+                    const multiaddrs = this.getDialableMultiaddrs(connect.observedAddresses);
+                    if (multiaddrs.length === 0) {
+                        this.log('A did not have any dialable multiaddrs');
+                        throw new CodeError$2('DCUtR connect message had no multiaddrs', ERR_INVALID_MESSAGE);
+                    }
+                    const rtt = Date.now() - connectTimer;
+                    this.log('A sending sync, rtt %dms', rtt);
+                    await pb.write({
+                        type: HolePunch.Type.SYNC,
+                        observedAddresses: []
+                    }, options);
+                    this.log('A waiting for half RTT');
+                    // ..and starts a timer for half the RTT measured from the time between
+                    // sending the initial Connect and receiving the response
+                    await delay(rtt / 2);
+                    // TODO: when we have a QUIC transport, the dial step is different - for
+                    // now we only have tcp support
+                    // https://github.com/libp2p/specs/blob/master/relay/DCUtR.md#the-protocol
+                    this.log('B dialing', multiaddrs);
+                    // Upon expiry of the timer, B dials the address to A.
+                    const conn = await this.connectionManager.openConnection(multiaddrs, {
+                        signal: options.signal,
+                        priority: DCUTR_DIAL_PRIORITY
+                    });
+                    this.log('DCUtR to %p succeeded to address %a, closing relayed connection', relayedConnection.remotePeer, conn.remoteAddr);
+                    await relayedConnection.close(options);
+                    break;
+                }
+                catch (err) {
+                    this.log.error('error while attempting DCUtR on attempt %d of %d', i + 1, this.retries, err);
+                    stream?.abort(err);
+                    if (i === this.retries) {
+                        throw err;
+                    }
+                }
+                finally {
+                    if (stream != null) {
+                        await stream.close(options);
+                    }
+                }
+            }
+        }
+        /**
+         * This is performed when A has dialed B via a relay but A also has a public
+         * address that B can dial directly
+         */
+        async attemptUnilateralConnectionUpgrade(relayedConnection) {
+            // Upon observing the new connection, the inbound peer (here B) checks the
+            // addresses advertised by A via identify.
+            const peerInfo = await this.peerStore.get(relayedConnection.remotePeer);
+            // If that set includes public addresses, then A may be reachable by a direct
+            // connection, in which case B attempts a unilateral connection upgrade by
+            // initiating a direct connection to A.
+            const publicAddresses = peerInfo.addresses
+                .map(address => {
+                const ma = address.multiaddr;
+                // ensure all multiaddrs have the peer id
+                if (ma.getPeerId() == null) {
+                    return ma.encapsulate(`/p2p/${relayedConnection.remotePeer}`);
+                }
+                return ma;
+            })
+                .filter(ma => {
+                return isPublicAndDialable(ma, this.transportManager);
+            });
+            if (publicAddresses.length > 0) {
+                const signal = AbortSignal.timeout(this.timeout);
+                try {
+                    this.log('attempting unilateral connection upgrade to %a', publicAddresses);
+                    // force-dial the multiaddr(s), otherwise `connectionManager.openConnection`
+                    // will return the existing relayed connection
+                    const connection = await this.connectionManager.openConnection(publicAddresses, {
+                        signal,
+                        force: true
+                    });
+                    if (connection.transient) {
+                        throw new Error('Could not open a new, non-transient, connection');
+                    }
+                    this.log('unilateral connection upgrade to %p succeeded via %a, closing relayed connection', relayedConnection.remotePeer, connection.remoteAddr);
+                    await relayedConnection.close({
+                        signal
+                    });
+                    return true;
+                }
+                catch (err) {
+                    this.log.error('unilateral connection upgrade to %p on addresses %a failed', relayedConnection.remotePeer, publicAddresses, err);
+                }
+            }
+            else {
+                this.log('peer %p has no public addresses, not attempting unilateral connection upgrade', relayedConnection.remotePeer);
+            }
+            // no public addresses or failed to dial public addresses
+            return false;
+        }
+        /**
+         * Perform the connection upgrade as A
+         *
+         * @see https://github.com/libp2p/specs/blob/master/relay/DCUtR.md#the-protocol
+         */
+        async handleIncomingUpgrade(stream, relayedConnection) {
+            const options = {
+                signal: AbortSignal.timeout(this.timeout)
+            };
+            try {
+                const pb = pbStream(stream, {
+                    maxDataLength: MAX_DCUTR_MESSAGE_SIZE
+                }).pb(HolePunch);
+                this.log('A receiving connect');
+                // 3. Upon receiving the Connect, A responds back with a Connect message
+                // containing its observed (and possibly predicted) addresses.
+                const connect = await pb.read(options);
+                if (connect.type !== HolePunch.Type.CONNECT) {
+                    this.log('B sent wrong message type');
+                    throw new CodeError$2('DCUtR message type was incorrect', ERR_INVALID_MESSAGE);
+                }
+                if (connect.observedAddresses.length === 0) {
+                    this.log('B sent no multiaddrs');
+                    throw new CodeError$2('DCUtR connect message had no multiaddrs', ERR_INVALID_MESSAGE);
+                }
+                const multiaddrs = this.getDialableMultiaddrs(connect.observedAddresses);
+                if (multiaddrs.length === 0) {
+                    this.log('B had no dialable multiaddrs');
+                    throw new CodeError$2('DCUtR connect message had no dialable multiaddrs', ERR_INVALID_MESSAGE);
+                }
+                this.log('A sending connect');
+                await pb.write({
+                    type: HolePunch.Type.CONNECT,
+                    observedAddresses: this.addressManager.getAddresses().map(ma => ma.bytes)
+                });
+                this.log('A receiving sync');
+                const sync = await pb.read(options);
+                if (sync.type !== HolePunch.Type.SYNC) {
+                    throw new CodeError$2('DCUtR message type was incorrect', ERR_INVALID_MESSAGE);
+                }
+                // TODO: when we have a QUIC transport, the dial step is different - for
+                // now we only have tcp support
+                // https://github.com/libp2p/specs/blob/master/relay/DCUtR.md#the-protocol
+                // Upon receiving the Sync, A immediately dials the address to B
+                this.log('A dialing', multiaddrs);
+                const connection = await this.connectionManager.openConnection(multiaddrs, {
+                    signal: options.signal,
+                    priority: DCUTR_DIAL_PRIORITY,
+                    force: true
+                });
+                this.log('DCUtR to %p succeeded via %a, closing relayed connection', relayedConnection.remotePeer, connection.remoteAddr);
+                await relayedConnection.close(options);
+            }
+            catch (err) {
+                this.log.error('incoming DCUtR from %p failed', relayedConnection.remotePeer, err);
+                stream.abort(err);
+            }
+            finally {
+                await stream.close(options);
+            }
+        }
+        /**
+         * Takes the `addr` and converts it to a Multiaddr if possible
+         */
+        getDialableMultiaddrs(addrs) {
+            const output = [];
+            for (const addr of addrs) {
+                if (addr == null || addr.length === 0) {
+                    continue;
+                }
+                try {
+                    const ma = multiaddr(addr);
+                    if (!isPublicAndDialable(ma, this.transportManager)) {
+                        continue;
+                    }
+                    output.push(ma);
+                }
+                catch { }
+            }
+            return output;
+        }
+    }
+
+    /**
+     * @packageDocumentation
+     *
+     * Direct Connection Upgrade through Relay (DCUtR) is a protocol that allows two
+     * nodes to connect to each other who would otherwise be prevented doing so due
+     * to being behind NATed connections or firewalls.
+     *
+     * The protocol involves making a relayed connection between the two peers and
+     * using the relay to synchronise connection timings so that they dial each other
+     * at precisely the same moment.
+     *
+     * @example
+     *
+     * ```TypeScript
+     * import { createLibp2p } from 'libp2p'
+     * import { circuitRelayTransport } from '@libp2p/circuit-relay-v2'
+     * import { tcp } from '@libp2p/tcp'
+     * import { identify } from '@libp2p/identify'
+     * import { dcutr } from '@libp2p/dcutr'
+     * import { multiaddr } from '@multiformats/multiaddr'
+     *
+     * const node = await createLibp2p({
+     *   transports: [
+     *     circuitRelayTransport(),
+     *     tcp()
+     *   ],
+     *   services: {
+     *     identify: identify(),
+     *     dcutr: dcutr()
+     *   }
+     * })
+     *
+     * // QmTarget is a peer that is behind a NAT, supports TCP and has a relay
+     * // reservation
+     * const ma = multiaddr('/ip4/.../p2p/QmRelay/p2p-circuit/p2p/QmTarget')
+     * await node.dial(ma)
+     *
+     * // after a while the connection should automatically get upgraded to a
+     * // direct connection (e.g. non-transient)
+     * while (true) {
+     *   const connections = node.getConnections()
+     *
+     *   if (connections.find(conn => conn.transient === false)) {
+     *     console.info('have direct connection')
+     *     break
+     *   } else {
+     *     console.info('have relayed connection')
+     *
+     *     // wait a few seconds to see if it's succeeded yet
+     *     await new Promise<void>((resolve) => {
+     *       setTimeout(() => resolve(), 5000)
+     *     })
+     *   }
+     * }
+     * ```
+     */
+    /**
+     * The DCUtR protocol
+     */
+    const multicodec = '/libp2p/dcutr';
+    function dcutr(init = {}) {
+        return (components) => new DefaultDCUtRService(components, init);
+    }
+
+    // Protocol violation errors
+    const ERR_INVALID_FRAME = 'ERR_INVALID_FRAME';
+    const ERR_UNREQUESTED_PING = 'ERR_UNREQUESTED_PING';
+    const ERR_NOT_MATCHING_PING = 'ERR_NOT_MATCHING_PING';
+    const ERR_STREAM_ALREADY_EXISTS = 'ERR_STREAM_ALREADY_EXISTS';
+    const ERR_DECODE_INVALID_VERSION = 'ERR_DECODE_INVALID_VERSION';
+    const ERR_BOTH_CLIENTS = 'ERR_BOTH_CLIENTS';
+    const ERR_RECV_WINDOW_EXCEEDED = 'ERR_RECV_WINDOW_EXCEEDED';
+    const PROTOCOL_ERRORS = new Set([
+        ERR_INVALID_FRAME,
+        ERR_UNREQUESTED_PING,
+        ERR_NOT_MATCHING_PING,
+        ERR_STREAM_ALREADY_EXISTS,
+        ERR_DECODE_INVALID_VERSION,
+        ERR_BOTH_CLIENTS,
+        ERR_RECV_WINDOW_EXCEEDED
+    ]);
+    // local errors
+    const ERR_INVALID_CONFIG = 'ERR_INVALID_CONFIG';
+    const ERR_MUXER_LOCAL_CLOSED = 'ERR_MUXER_LOCAL_CLOSED';
+    const ERR_MUXER_REMOTE_CLOSED = 'ERR_MUXER_REMOTE_CLOSED';
+    const ERR_STREAM_ABORT = 'ERR_STREAM_ABORT';
+    const ERR_MAX_OUTBOUND_STREAMS_EXCEEDED = 'ERROR_MAX_OUTBOUND_STREAMS_EXCEEDED';
+    const ERR_DECODE_IN_PROGRESS = 'ERR_DECODE_IN_PROGRESS';
+    /**
+     * INITIAL_STREAM_WINDOW is the initial stream window size.
+     *
+     * Not an implementation choice, this is defined in the specification
+     */
+    const INITIAL_STREAM_WINDOW = 256 * 1024;
+    /**
+     * Default max stream window
+     */
+    const MAX_STREAM_WINDOW = 16 * 1024 * 1024;
+
+    const defaultConfig = {
+        enableKeepAlive: true,
+        keepAliveInterval: 30000,
+        maxInboundStreams: 1000,
+        maxOutboundStreams: 1000,
+        initialStreamWindowSize: INITIAL_STREAM_WINDOW,
+        maxStreamWindowSize: MAX_STREAM_WINDOW,
+        maxMessageSize: 64 * 1024
+    };
+    function verifyConfig(config) {
+        if (config.keepAliveInterval <= 0) {
+            throw new CodeError$2('keep-alive interval must be positive', ERR_INVALID_CONFIG);
+        }
+        if (config.maxInboundStreams < 0) {
+            throw new CodeError$2('max inbound streams must be larger or equal 0', ERR_INVALID_CONFIG);
+        }
+        if (config.maxOutboundStreams < 0) {
+            throw new CodeError$2('max outbound streams must be larger or equal 0', ERR_INVALID_CONFIG);
+        }
+        if (config.initialStreamWindowSize < INITIAL_STREAM_WINDOW) {
+            throw new CodeError$2('InitialStreamWindowSize must be larger or equal 256 kB', ERR_INVALID_CONFIG);
+        }
+        if (config.maxStreamWindowSize < config.initialStreamWindowSize) {
+            throw new CodeError$2('MaxStreamWindowSize must be larger than the InitialStreamWindowSize', ERR_INVALID_CONFIG);
+        }
+        if (config.maxStreamWindowSize > 2 ** 32 - 1) {
+            throw new CodeError$2('MaxStreamWindowSize must be less than equal MAX_UINT32', ERR_INVALID_CONFIG);
+        }
+        if (config.maxMessageSize < 1024) {
+            throw new CodeError$2('MaxMessageSize must be greater than a kilobyte', ERR_INVALID_CONFIG);
+        }
+    }
+
+    var FrameType;
+    (function (FrameType) {
+        /** Used to transmit data. May transmit zero length payloads depending on the flags. */
+        FrameType[FrameType["Data"] = 0] = "Data";
+        /** Used to updated the senders receive window size. This is used to implement per-session flow control. */
+        FrameType[FrameType["WindowUpdate"] = 1] = "WindowUpdate";
+        /** Used to measure RTT. It can also be used to heart-beat and do keep-alives over TCP. */
+        FrameType[FrameType["Ping"] = 2] = "Ping";
+        /** Used to close a session. */
+        FrameType[FrameType["GoAway"] = 3] = "GoAway";
+    })(FrameType || (FrameType = {}));
+    var Flag;
+    (function (Flag) {
+        /** Signals the start of a new stream. May be sent with a data or window update message. Also sent with a ping to indicate outbound. */
+        Flag[Flag["SYN"] = 1] = "SYN";
+        /** Acknowledges the start of a new stream. May be sent with a data or window update message. Also sent with a ping to indicate response. */
+        Flag[Flag["ACK"] = 2] = "ACK";
+        /** Performs a half-close of a stream. May be sent with a data message or window update. */
+        Flag[Flag["FIN"] = 4] = "FIN";
+        /** Reset a stream immediately. May be sent with a data or window update message. */
+        Flag[Flag["RST"] = 8] = "RST";
+    })(Flag || (Flag = {}));
+    Object.values(Flag).filter((x) => typeof x !== 'string');
+    const YAMUX_VERSION = 0;
+    var GoAwayCode;
+    (function (GoAwayCode) {
+        GoAwayCode[GoAwayCode["NormalTermination"] = 0] = "NormalTermination";
+        GoAwayCode[GoAwayCode["ProtocolError"] = 1] = "ProtocolError";
+        GoAwayCode[GoAwayCode["InternalError"] = 2] = "InternalError";
+    })(GoAwayCode || (GoAwayCode = {}));
+    const HEADER_LENGTH = 12;
+
+    // used to bitshift in decoding
+    // native bitshift can overflow into a negative number, so we bitshift by multiplying by a power of 2
+    const twoPow24 = 2 ** 24;
+    /**
+     * Decode a header from the front of a buffer
+     *
+     * @param data - Assumed to have enough bytes for a header
+     */
+    function decodeHeader(data) {
+        if (data[0] !== YAMUX_VERSION) {
+            throw new CodeError$2('Invalid frame version', ERR_DECODE_INVALID_VERSION);
+        }
+        return {
+            type: data[1],
+            flag: (data[2] << 8) + data[3],
+            streamID: (data[4] * twoPow24) + (data[5] << 16) + (data[6] << 8) + data[7],
+            length: (data[8] * twoPow24) + (data[9] << 16) + (data[10] << 8) + data[11]
+        };
+    }
+    /**
+     * Decodes yamux frames from a source
+     */
+    class Decoder {
+        source;
+        /** Buffer for in-progress frames */
+        buffer;
+        /** Used to sanity check against decoding while in an inconsistent state */
+        frameInProgress;
+        constructor(source) {
+            // Normally, when entering a for-await loop with an iterable/async iterable, the only ways to exit the loop are:
+            // 1. exhaust the iterable
+            // 2. throw an error - slow, undesirable if there's not actually an error
+            // 3. break or return - calls the iterable's `return` method, finalizing the iterable, no more iteration possible
+            //
+            // In this case, we want to enter (and exit) a for-await loop per chunked data frame and continue processing the iterable.
+            // To do this, we strip the `return` method from the iterator and can now `break` early and continue iterating.
+            // Exiting the main for-await is still possible via 1. and 2.
+            this.source = returnlessSource(source);
+            this.buffer = new Uint8ArrayList();
+            this.frameInProgress = false;
+        }
+        /**
+         * Emits frames from the decoder source.
+         *
+         * Note: If `readData` is emitted, it _must_ be called before the next iteration
+         * Otherwise an error is thrown
+         */
+        async *emitFrames() {
+            for await (const chunk of this.source) {
+                this.buffer.append(chunk);
+                // Loop to consume as many bytes from the buffer as possible
+                // Eg: when a single chunk contains several frames
+                while (true) {
+                    const header = this.readHeader();
+                    if (header === undefined) {
+                        break;
+                    }
+                    const { type, length } = header;
+                    if (type === FrameType.Data) {
+                        // This is a data frame, the frame body must still be read
+                        // `readData` must be called before the next iteration here
+                        this.frameInProgress = true;
+                        yield {
+                            header,
+                            readData: this.readBytes.bind(this, length)
+                        };
+                    }
+                    else {
+                        yield { header };
+                    }
+                }
+            }
+        }
+        readHeader() {
+            // Sanity check to ensure a header isn't read when another frame is partially decoded
+            // In practice this shouldn't happen
+            if (this.frameInProgress) {
+                throw new CodeError$2('decoding frame already in progress', ERR_DECODE_IN_PROGRESS);
+            }
+            if (this.buffer.length < HEADER_LENGTH) {
+                // not enough data yet
+                return;
+            }
+            const header = decodeHeader(this.buffer.subarray(0, HEADER_LENGTH));
+            this.buffer.consume(HEADER_LENGTH);
+            return header;
+        }
+        async readBytes(length) {
+            if (this.buffer.length < length) {
+                for await (const chunk of this.source) {
+                    this.buffer.append(chunk);
+                    if (this.buffer.length >= length) {
+                        // see note above, the iterator is not `return`ed here
+                        break;
+                    }
+                }
+            }
+            const out = this.buffer.sublist(0, length);
+            this.buffer.consume(length);
+            // The next frame can now be decoded
+            this.frameInProgress = false;
+            return out;
+        }
+    }
+    /**
+     * Strip the `return` method from a `Source`
+     */
+    function returnlessSource(source) {
+        if (source[Symbol.iterator] !== undefined) {
+            const iterator = source[Symbol.iterator]();
+            iterator.return = undefined;
+            return {
+                [Symbol.iterator]() { return iterator; }
+            };
+        }
+        else if (source[Symbol.asyncIterator] !== undefined) {
+            const iterator = source[Symbol.asyncIterator]();
+            iterator.return = undefined;
+            return {
+                [Symbol.asyncIterator]() { return iterator; }
+            };
+        }
+        else {
+            throw new Error('a source must be either an iterable or an async iterable');
+        }
+    }
+
+    function encodeHeader(header) {
+        const frame = new Uint8Array(HEADER_LENGTH);
+        // always assume version 0
+        // frameView.setUint8(0, header.version)
+        frame[1] = header.type;
+        frame[2] = header.flag >>> 8;
+        frame[3] = header.flag;
+        frame[4] = header.streamID >>> 24;
+        frame[5] = header.streamID >>> 16;
+        frame[6] = header.streamID >>> 8;
+        frame[7] = header.streamID;
+        frame[8] = header.length >>> 24;
+        frame[9] = header.length >>> 16;
+        frame[10] = header.length >>> 8;
+        frame[11] = header.length;
+        return frame;
+    }
+
+    /**
+     * @packageDocumentation
+     *
+     * Calls a function for each value in an (async)iterable.
+     *
+     * The function can be sync or async.
+     *
+     * Async functions can be awaited on so may slow down processing of the (async)iterable.
+     *
+     * @example
+     *
+     * ```javascript
+     * import each from 'it-foreach'
+     * import drain from 'it-drain'
+     *
+     * // This can also be an iterator, generator, etc
+     * const values = [0, 1, 2, 3, 4]
+     *
+     * // prints [0, 0], [1, 1], [2, 2], [3, 3], [4, 4]
+     * const arr = drain(
+     *   each(values, console.info)
+     * )
+     * ```
+     *
+     * Async sources and callbacks must be awaited:
+     *
+     * ```javascript
+     * import each from 'it-foreach'
+     * import drain from 'it-drain'
+     *
+     * const values = async function * () {
+     *   yield * [0, 1, 2, 3, 4]
+     * }
+     *
+     * // prints [0, 0], [1, 1], [2, 2], [3, 3], [4, 4]
+     * const arr = await drain(
+     *   each(values(), console.info)
+     * )
+     * ```
+     */
+    function isAsyncIterable$1(thing) {
+        return thing[Symbol.asyncIterator] != null;
+    }
+    function isPromise$1(thing) {
+        return thing?.then != null;
+    }
+    function forEach(source, fn) {
+        let index = 0;
+        if (isAsyncIterable$1(source)) {
+            return (async function* () {
+                for await (const val of source) {
+                    const res = fn(val, index++);
+                    if (isPromise$1(res)) {
+                        await res;
+                    }
+                    yield val;
+                }
+            })();
+        }
+        // if fn function returns a promise we have to return an async generator
+        const peekable$1 = peekable(source);
+        const { value, done } = peekable$1.next();
+        if (done === true) {
+            return (function* () { }());
+        }
+        const res = fn(value, index++);
+        if (typeof res?.then === 'function') {
+            return (async function* () {
+                yield value;
+                for await (const val of peekable$1) {
+                    const res = fn(val, index++);
+                    if (isPromise$1(res)) {
+                        await res;
+                    }
+                    yield val;
+                }
+            })();
+        }
+        const func = fn;
+        return (function* () {
+            yield value;
+            for (const val of peekable$1) {
+                func(val, index++);
+                yield val;
+            }
+        })();
+    }
+
+    var StreamState;
+    (function (StreamState) {
+        StreamState[StreamState["Init"] = 0] = "Init";
+        StreamState[StreamState["SYNSent"] = 1] = "SYNSent";
+        StreamState[StreamState["SYNReceived"] = 2] = "SYNReceived";
+        StreamState[StreamState["Established"] = 3] = "Established";
+        StreamState[StreamState["Finished"] = 4] = "Finished";
+    })(StreamState || (StreamState = {}));
+    /** YamuxStream is used to represent a logical stream within a session */
+    class YamuxStream extends AbstractStream {
+        name;
+        state;
+        config;
+        _id;
+        /** The number of available bytes to send */
+        sendWindowCapacity;
+        /** Callback to notify that the sendWindowCapacity has been updated */
+        sendWindowCapacityUpdate;
+        /** The number of bytes available to receive in a full window */
+        recvWindow;
+        /** The number of available bytes to receive */
+        recvWindowCapacity;
+        /**
+         * An 'epoch' is the time it takes to process and read data
+         *
+         * Used in conjunction with RTT to determine whether to increase the recvWindow
+         */
+        epochStart;
+        getRTT;
+        sendFrame;
+        constructor(init) {
+            super({
+                ...init,
+                onEnd: (err) => {
+                    this.state = StreamState.Finished;
+                    init.onEnd?.(err);
+                }
+            });
+            this.config = init.config;
+            this._id = parseInt(init.id, 10);
+            this.name = init.name;
+            this.state = init.state;
+            this.sendWindowCapacity = INITIAL_STREAM_WINDOW;
+            this.recvWindow = this.config.initialStreamWindowSize;
+            this.recvWindowCapacity = this.recvWindow;
+            this.epochStart = Date.now();
+            this.getRTT = init.getRTT;
+            this.sendFrame = init.sendFrame;
+            this.source = forEach(this.source, () => {
+                this.sendWindowUpdate();
+            });
+        }
+        /**
+         * Send a message to the remote muxer informing them a new stream is being
+         * opened.
+         *
+         * This is a noop for Yamux because the first window update is sent when
+         * .newStream is called on the muxer which opens the stream on the remote.
+         */
+        async sendNewStream() {
+        }
+        /**
+         * Send a data message to the remote muxer
+         */
+        async sendData(buf, options = {}) {
+            buf = buf.sublist();
+            // send in chunks, waiting for window updates
+            while (buf.byteLength !== 0) {
+                // wait for the send window to refill
+                if (this.sendWindowCapacity === 0) {
+                    this.log?.trace('wait for send window capacity, status %s', this.status);
+                    await this.waitForSendWindowCapacity(options);
+                    // check we didn't close while waiting for send window capacity
+                    if (this.status === 'closed' || this.status === 'aborted' || this.status === 'reset') {
+                        this.log?.trace('%s while waiting for send window capacity', this.status);
+                        return;
+                    }
+                }
+                // send as much as we can
+                const toSend = Math.min(this.sendWindowCapacity, this.config.maxMessageSize - HEADER_LENGTH, buf.length);
+                const flags = this.getSendFlags();
+                this.sendFrame({
+                    type: FrameType.Data,
+                    flag: flags,
+                    streamID: this._id,
+                    length: toSend
+                }, buf.sublist(0, toSend));
+                this.sendWindowCapacity -= toSend;
+                buf.consume(toSend);
+            }
+        }
+        /**
+         * Send a reset message to the remote muxer
+         */
+        async sendReset() {
+            this.sendFrame({
+                type: FrameType.WindowUpdate,
+                flag: Flag.RST,
+                streamID: this._id,
+                length: 0
+            });
+        }
+        /**
+         * Send a message to the remote muxer, informing them no more data messages
+         * will be sent by this end of the stream
+         */
+        async sendCloseWrite() {
+            const flags = this.getSendFlags() | Flag.FIN;
+            this.sendFrame({
+                type: FrameType.WindowUpdate,
+                flag: flags,
+                streamID: this._id,
+                length: 0
+            });
+        }
+        /**
+         * Send a message to the remote muxer, informing them no more data messages
+         * will be read by this end of the stream
+         */
+        async sendCloseRead() {
+        }
+        /**
+         * Wait for the send window to be non-zero
+         *
+         * Will throw with ERR_STREAM_ABORT if the stream gets aborted
+         */
+        async waitForSendWindowCapacity(options = {}) {
+            if (this.sendWindowCapacity > 0) {
+                return;
+            }
+            let resolve;
+            let reject;
+            const abort = () => {
+                if (this.status === 'open' || this.status === 'closing') {
+                    reject(new CodeError$2('stream aborted', ERR_STREAM_ABORT));
+                }
+                else {
+                    // the stream was closed already, ignore the failure to send
+                    resolve();
+                }
+            };
+            options.signal?.addEventListener('abort', abort);
+            try {
+                await new Promise((_resolve, _reject) => {
+                    this.sendWindowCapacityUpdate = () => {
                         _resolve();
                     };
                     reject = _reject;
@@ -33558,63 +35866,6 @@
         return (components) => new PubSubPeerDiscovery(components, init);
     }
 
-    /**
-     * @packageDocumentation
-     *
-     * This module makes it easy to send and receive length-prefixed Protobuf encoded
-     * messages over streams.
-     *
-     * @example
-     *
-     * ```typescript
-     * import { pbStream } from 'it-protobuf-stream'
-     * import { MessageType } from './src/my-message-type.js'
-     *
-     * // RequestType and ResponseType have been generate from `.proto` files and have
-     * // `.encode` and `.decode` methods for serialization/deserialization
-     *
-     * const stream = pbStream(duplex)
-     *
-     * // write a message to the stream
-     * stream.write({
-     *   foo: 'bar'
-     * }, MessageType)
-     *
-     * // read a message from the stream
-     * const res = await stream.read(MessageType)
-     * ```
-     */
-    function pbStream(duplex, opts) {
-        const lp = lpStream(duplex, opts);
-        const W = {
-            read: async (proto, options) => {
-                // readLP, decode
-                const value = await lp.read(options);
-                return proto.decode(value);
-            },
-            write: async (message, proto, options) => {
-                // encode, writeLP
-                await lp.write(proto.encode(message), options);
-            },
-            writeV: async (messages, proto, options) => {
-                // encode, writeLP
-                await lp.writeV(messages.map(message => proto.encode(message)), options);
-            },
-            pb: (proto) => {
-                return {
-                    read: async (options) => W.read(proto, options),
-                    write: async (d, options) => W.write(d, proto, options),
-                    writeV: async (d, options) => W.writeV(d, proto, options),
-                    unwrap: () => W
-                };
-            },
-            unwrap: () => {
-                return lp.unwrap();
-            }
-        };
-        return W;
-    }
-
     /**
      * Multicodec code
      */
@@ -43902,121 +46153,6 @@
         }
     }
 
-    const normalizeEmitter = emitter => {
-    	const addListener = emitter.addEventListener || emitter.on || emitter.addListener;
-    	const removeListener = emitter.removeEventListener || emitter.off || emitter.removeListener;
-
-    	if (!addListener || !removeListener) {
-    		throw new TypeError('Emitter is not compatible');
-    	}
-
-    	return {
-    		addListener: addListener.bind(emitter),
-    		removeListener: removeListener.bind(emitter),
-    	};
-    };
-
-    function pEventMultiple(emitter, event, options) {
-    	let cancel;
-    	const returnValue = new Promise((resolve, reject) => {
-    		options = {
-    			rejectionEvents: ['error'],
-    			multiArgs: false,
-    			resolveImmediately: false,
-    			...options,
-    		};
-
-    		if (!(options.count >= 0 && (options.count === Number.POSITIVE_INFINITY || Number.isInteger(options.count)))) {
-    			throw new TypeError('The `count` option should be at least 0 or more');
-    		}
-
-    		options.signal?.throwIfAborted();
-
-    		// Allow multiple events
-    		const events = [event].flat();
-
-    		const items = [];
-    		const {addListener, removeListener} = normalizeEmitter(emitter);
-
-    		const onItem = (...arguments_) => {
-    			const value = options.multiArgs ? arguments_ : arguments_[0];
-
-    			// eslint-disable-next-line unicorn/no-array-callback-reference
-    			if (options.filter && !options.filter(value)) {
-    				return;
-    			}
-
-    			items.push(value);
-
-    			if (options.count === items.length) {
-    				cancel();
-    				resolve(items);
-    			}
-    		};
-
-    		const rejectHandler = error => {
-    			cancel();
-    			reject(error);
-    		};
-
-    		cancel = () => {
-    			for (const event of events) {
-    				removeListener(event, onItem);
-    			}
-
-    			for (const rejectionEvent of options.rejectionEvents) {
-    				removeListener(rejectionEvent, rejectHandler);
-    			}
-    		};
-
-    		for (const event of events) {
-    			addListener(event, onItem);
-    		}
-
-    		for (const rejectionEvent of options.rejectionEvents) {
-    			addListener(rejectionEvent, rejectHandler);
-    		}
-
-    		if (options.signal) {
-    			options.signal.addEventListener('abort', () => {
-    				rejectHandler(options.signal.reason);
-    			}, {once: true});
-    		}
-
-    		if (options.resolveImmediately) {
-    			resolve(items);
-    		}
-    	});
-
-    	returnValue.cancel = cancel;
-
-    	if (typeof options.timeout === 'number') {
-    		const timeout = pTimeout(returnValue, {milliseconds: options.timeout});
-    		timeout.cancel = cancel;
-    		return timeout;
-    	}
-
-    	return returnValue;
-    }
-
-    function pEvent(emitter, event, options) {
-    	if (typeof options === 'function') {
-    		options = {filter: options};
-    	}
-
-    	options = {
-    		...options,
-    		count: 1,
-    		resolveImmediately: false,
-    	};
-
-    	const arrayPromise = pEventMultiple(emitter, event, options);
-    	const promise = arrayPromise.then(array => array[0]);
-    	promise.cancel = arrayPromise.cancel;
-
-    	return promise;
-    }
-
     /**
      * Receives notifications of new peers joining the network that support the DHT protocol
      */
@@ -47108,6 +49244,10 @@
     		
     		this.id = this.#libp2p.peerId.toString();
     		
+    		for(const topic of CONFIG_PUPSUB_PEER_DATA){
+    			this.#libp2p.services.pubsub.subscribe(topic);
+    		}
+    		
     		
     		//listen to peer connect event
     		this.#libp2p.addEventListener("peer:connect",async (evt) => {
@@ -47174,9 +49314,9 @@
     			  return
     			}
     			{
-    				const topic = event.detail.topic;
+    				event.detail.topic;
     				const senderPeerId = event.detail.from.toString();
-    				if(CONFIG_PUBSUB_PEER_DISCOVERY.includes(topic)){
+    				
     					try{
     						
     						//if it is webpeer 
@@ -47212,15 +49352,17 @@
     									const addrs = this.#discoveredPeers.get(senderPeerId);
     									let mddrs = [];
     									for(const addr of addrs){
+    										if(!addr.includes('webrtc'))continue
     										const mddr = multiaddr(addr);
     										mddrs.push(mddr);
     									}
     									this.#dialMultiaddress(mddrs);
     								}
-    								else {
+    								else if(this.#connectedPeers.has(senderPeerId)){
     									const addrs = this.#connectedPeers.get(senderPeerId).addrs;
     									let mddrs = [];
     									for(const addr of addrs){
+    										if(!addr.includes('webrtc'))continue
     										const mddr = multiaddr(addr);
     										mddrs.push(mddr);
     									}
@@ -47269,8 +49411,10 @@
     									
     									//update room members
     									if(!this.#rooms[room].members.includes(id)){
-    										this.#rooms[room].members.push(id);
-    										this.#rooms[room].onMembers(this.#rooms[room].members);
+    										if(this.#connectedPeers.has(id)){
+    											this.#rooms[room].members.push(id);
+    											this.#rooms[room].onMembers(this.#rooms[room].members);
+    										}
     									}
 
     									//inbound message
@@ -47289,8 +49433,10 @@
     								for(const room of Object.keys(this.#rooms)){
     									//update room members
     									if(!this.#rooms[room].members.includes(id)){
-    										this.#rooms[room].members.push(id);
-    										this.#rooms[room].onMembers(this.#rooms[room].members);
+    										if(this.#connectedPeers.has(id)){
+    											this.#rooms[room].members.push(id);
+    											this.#rooms[room].onMembers(this.#rooms[room].members);
+    										}
     									}
     								}
     							}
@@ -47299,7 +49445,7 @@
     								
     								//repply announce with ping
     								if(signal == 'announce'){
-    									setTimeout(()=>{this.#ping('yes');},1000);
+    									setTimeout(()=>{this.#ping('');},1000);
     									//console.log('rooms',rooms)
     								}
     								
@@ -47312,12 +49458,7 @@
 
     					}catch(err){
     					}
-    				}else {
-    					const json = JSON.parse(topic);
-    					const room = json.room;
-    					const message = new TextDecoder().decode(event.detail.data);
-    					this.#rooms[room].onMessage(message);
-    				}
+    				
     			}
     			
     		});
@@ -47358,6 +49499,7 @@
     					if(!this.#connections.has(id)){
     						let mddrs = [];
     						for(const addr of addrs){
+    							if(!addr.includes('webrtc'))continue
     							const mddr = multiaddr(addr);
     							mddrs.push(mddr);
     						}
@@ -47445,7 +49587,7 @@
     			const mddrs = [];
     			peer.addresses.forEach((addr)=>{
     				const maddr = addr.multiaddr.toString()+'/p2p/'+id;
-    				if(maddr.includes('webtransport') && maddr.includes('certhash')){
+    				if(maddr.includes('webtransport') && maddr.includes('certhash') && maddr.includes('webrtc')){
     					mddrs.push(maddr);
     				}
     			});
@@ -47607,7 +49749,7 @@
     		//join room version 1 user pupsub via pupsub peer discovery
     		{
 
-    			const topics = CONFIG_PUBSUB_PEER_DISCOVERY;
+    			const topics = CONFIG_PUPSUB_PEER_DATA;
     			
     			this.#rooms[room] = {
     				onMessage : () => {},
@@ -47661,6 +49803,7 @@
     		else {
     			this.status = 'unconnected';
     		}
+    		this.#ping();
     	}
     	
     	async #registerProtocol(){
@@ -47753,7 +49896,7 @@
     		await this.#libp2p.handle(CONFIG_PROTOCOL, handler, {
     		  maxInboundStreams: 50,
     		  maxOutboundStreams: 50,
-    		  runOnTransientConnection:true
+    		  runOnTransientConnection:false
     		});
 
     		await this.#libp2p.register(CONFIG_PROTOCOL, {
@@ -47800,7 +49943,7 @@
 
     		try{
     			
-    			const stream = await this.#libp2p.dialProtocol(mddr, CONFIG_PROTOCOL,{runOnTransientConnection:true});
+    			const stream = await this.#libp2p.dialProtocol(mddr, CONFIG_PROTOCOL,{runOnTransientConnection:false});
     			
     			const output = await pipe(
     				message,
@@ -47817,7 +49960,7 @@
     				  return string
     				}
     			);
-    			
+    			//console.log(output)
     			const json = JSON.parse(output);
     			if(json.protocol == CONFIG_PROTOCOL){
     				const address = [addr];
@@ -48021,7 +50164,7 @@
 
     	//announce and ping via pupsub peer discovery
     	async #announce(){
-    			const topics = CONFIG_PUBSUB_PEER_DISCOVERY;
+    			const topics = CONFIG_PUPSUB_PEER_DATA;
     			const data = JSON.stringify({prefix:CONFIG_PREFIX,signal:'announce',id:this.#libp2p.peerId.toString(),address:this.address,rooms:this.#rooms});
     			const peer = {
     			  publicKey: this.#libp2p.peerId.publicKey,
@@ -48033,7 +50176,7 @@
     			}
     	}
     	async #ping(){
-    			const topics = CONFIG_PUBSUB_PEER_DISCOVERY;
+    			const topics = CONFIG_PUPSUB_PEER_DATA;
     			const data = JSON.stringify({prefix:CONFIG_PREFIX,signal:'ping',id:this.#libp2p.peerId.toString(),address:this.address,rooms:this.#rooms});
     			const peer = {
     			  publicKey: this.#libp2p.peerId.publicKey,
@@ -48573,11 +50716,13 @@
     		const libp2p = await createLibp2p({
     			addresses: {
     				listen: [
+    					'/webrtc'
     				],
     			},
     			transports:[
     				webTransport(),
     				webSockets(),
+    				webRTC(),
     				circuitRelayTransport({
     					discoverRelays: CONFIG_DISCOVER_RELAYS,
     					reservationConcurrency: 1,
@@ -48642,7 +50787,7 @@
     					allowPublishToZeroTopicPeers: true,
     					msgIdFn: msgIdFnStrictNoSign$1,
     					ignoreDuplicatePublishError: true,
-    					runOnTransientConnection:true,
+    					runOnTransientConnection:false,
     				}),
     				identify: identify(),
     				identifyPush: identifyPush(),
@@ -48651,7 +50796,7 @@
     					peerInfoMapper: removePrivateAddressesMapper,
     					clientMode: false
     				}),
-
+    				dcutr: dcutr()
     			},
     			peerStore: {
     				persistence: true,