@libp2p/daemon-server 0.0.1 → 0.0.2

package/src/index.ts

@@ -1,13 +1,12 @@
 /* eslint max-depth: ["error", 6] */
 
 import { TCP } from '@libp2p/tcp'
-import { Multiaddr } from '@multiformats/multiaddr'
+import { Multiaddr, protocols } from '@multiformats/multiaddr'
 import { CID } from 'multiformats/cid'
 import * as lp from 'it-length-prefixed'
 import { pipe } from 'it-pipe'
-import { StreamHandler } from './stream-handler.js'
-import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { passThroughUpgrader } from './util/index.js'
+import { StreamHandler } from '@libp2p/daemon-protocol/stream-handler'
+import { passThroughUpgrader } from '@libp2p/daemon-protocol/upgrader'
 import {
   Request,
   DHTRequest,
@@ -30,15 +29,15 @@ import type { PubSub } from '@libp2p/interfaces/pubsub'
 import type { PeerStore } from '@libp2p/interfaces/peer-store'
 import { ErrorResponse, OkResponse } from './responses.js'
 import { DHTOperations } from './dht.js'
-import { peerIdFromBytes, peerIdFromString } from '@libp2p/peer-id'
+import { peerIdFromBytes } from '@libp2p/peer-id'
 import { PubSubOperations } from './pubsub.js'
 import { logger } from '@libp2p/logger'
 
 const LIMIT = 1 << 22 // 4MB
-const log = logger('libp2p:daemon')
+const log = logger('libp2p:daemon-server')
 
 export interface OpenStream {
-  streamInfo: IStreamInfo,
+  streamInfo: IStreamInfo
   connection: Stream
 }
 
@@ -58,24 +57,24 @@ export interface Libp2p {
 }
 
 export interface DaemonInit {
-  multiaddr: Multiaddr,
+  multiaddr: Multiaddr
   libp2pNode: any
 }
 
 export interface Libp2pServer {
   start: () => Promise<void>
   stop: () => Promise<void>
-  getMultiaddrs: () => Multiaddr[]
+  getMultiaddr: () => Multiaddr
 }
 
 export class Server implements Libp2pServer {
-  private multiaddr: Multiaddr
-  private libp2p: Libp2p
-  private tcp: TCP
-  private listener: Listener
-  private streamHandlers: Record<string, StreamHandler>
-  private dhtOperations?: DHTOperations
-  private pubsubOperations?: PubSubOperations
+  private readonly multiaddr: Multiaddr
+  private readonly libp2p: Libp2p
+  private readonly tcp: TCP
+  private readonly listener: Listener
+  private readonly streamHandlers: Record<string, StreamHandler>
+  private readonly dhtOperations?: DHTOperations
+  private readonly pubsubOperations?: PubSubOperations
 
   constructor (init: DaemonInit) {
     const { multiaddr, libp2pNode } = init
@@ -112,7 +111,7 @@ export class Server implements Libp2pServer {
     const peerId = peerIdFromBytes(peer)
 
     await this.libp2p.peerStore.addressBook.set(peerId, addrs)
-    return this.libp2p.dial(peerId)
+    return await this.libp2p.dial(peerId)
   }
 
   /**
@@ -125,7 +124,7 @@ export class Server implements Libp2pServer {
 
     const { peer, proto } = request.streamOpen
 
-    const peerId = peerIdFromString(uint8ArrayToString(peer, 'base58btc'))
+    const peerId = peerIdFromBytes(peer)
 
     const connection = await this.libp2p.dial(peerId)
     const { stream, protocol } = await connection.newStream(proto)
@@ -158,31 +157,34 @@ export class Server implements Libp2pServer {
     const addrString = addr.toString()
 
     // If we have a handler, end it
-    if (this.streamHandlers[addrString]) {
+    if (this.streamHandlers[addrString] != null) {
       this.streamHandlers[addrString].close()
-      delete this.streamHandlers[addrString]
+      delete this.streamHandlers[addrString] // eslint-disable-line @typescript-eslint/no-dynamic-delete
     }
 
-    protocols.forEach((proto) => {
-      // Connect the client socket with the libp2p connection
-      this.libp2p.handle(proto, ({ connection, stream, protocol }) => {
-        const message = StreamInfo.encode({
-          peer: connection.remotePeer.toBytes(),
-          addr: connection.remoteAddr.bytes,
-          proto: protocol
-        }).finish()
-        const encodedMessage = lp.encode.single(message)
-
-        // Tell the client about the new connection
-        // And then begin piping the client and peer connection
-
-        pipe(
-          [encodedMessage, stream.source],
-          clientConnection,
-          stream.sink
-        )
+    await Promise.all(
+      protocols.map(async (proto) => {
+        // Connect the client socket with the libp2p connection
+        await this.libp2p.handle(proto, ({ connection, stream, protocol }) => {
+          const message = StreamInfo.encode({
+            peer: connection.remotePeer.toBytes(),
+            addr: connection.remoteAddr.bytes,
+            proto: protocol
+          }).finish()
+          const encodedMessage = lp.encode.single(message)
+
+          // Tell the client about the new connection
+          // And then begin piping the client and peer connection
+          void pipe(
+            [encodedMessage, stream.source],
+            clientConnection,
+            stream.sink
+          ).catch(err => {
+            log.error(err)
+          })
+        })
       })
-    })
+    )
 
     const clientConnection = await this.tcp.dial(addr, {
       upgrader: passThroughUpgrader
@@ -203,7 +205,9 @@ export class Server implements Libp2pServer {
   }
 
   _onExit () {
-    this.stop({ exit: true })
+    void this.stop({ exit: true }).catch(err => {
+      log.error(err)
+    })
   }
 
   /**
@@ -215,8 +219,14 @@ export class Server implements Libp2pServer {
     await this.listener.listen(this.multiaddr)
   }
 
-  getMultiaddrs (): Multiaddr[] {
-    return this.listener.getAddrs()
+  getMultiaddr (): Multiaddr {
+    const addrs = this.listener.getAddrs()
+
+    if (addrs.length > 0) {
+      return addrs[0]
+    }
+
+    throw new Error('Not started')
   }
 
   /**
@@ -245,9 +255,9 @@ export class Server implements Libp2pServer {
             throw new Error('Invalid request')
           }
 
-          const peerId = peerIdFromBytes(request.id)
-          const peer = await this.libp2p.peerStore.get(peerId)
-          const protos = peer.protocols
+          const peerId = peerIdFromBytes(request.id) // eslint-disable-line no-case-declarations
+          const peer = await this.libp2p.peerStore.get(peerId) // eslint-disable-line no-case-declarations
+          const protos = peer.protocols // eslint-disable-line no-case-declarations
           yield OkResponse({ peerStore: { protos } })
           return
         case PeerstoreRequest.Type.GET_PEER_INFO:
@@ -256,6 +266,7 @@ export class Server implements Libp2pServer {
           throw new Error('ERR_INVALID_REQUEST_TYPE')
       }
     } catch (err: any) {
+      log.error(err)
       yield ErrorResponse(err)
     }
   }
@@ -265,7 +276,7 @@ export class Server implements Libp2pServer {
    */
   async * handlePubsubRequest (request: IPSRequest) {
     try {
-      if (this.libp2p.pubsub == null || !this.pubsubOperations) {
+      if (this.libp2p.pubsub == null || (this.pubsubOperations == null)) {
         throw new Error('PubSub not configured')
       }
 
@@ -291,6 +302,7 @@ export class Server implements Libp2pServer {
           throw new Error('ERR_INVALID_REQUEST_TYPE')
       }
     } catch (err: any) {
+      log.error(err)
       yield ErrorResponse(err)
     }
   }
@@ -300,7 +312,7 @@ export class Server implements Libp2pServer {
    */
   async * handleDHTRequest (request: IDHTRequest) {
     try {
-      if (this.libp2p.dht == null || !this.dhtOperations) {
+      if (this.libp2p.dht == null || (this.dhtOperations == null)) {
         throw new Error('DHT not configured')
       }
 
@@ -358,6 +370,7 @@ export class Server implements Libp2pServer {
           throw new Error('ERR_INVALID_REQUEST_TYPE')
       }
     } catch (err: any) {
+      log.error(err)
       yield ErrorResponse(err)
     }
   }
@@ -366,7 +379,7 @@ export class Server implements Libp2pServer {
    * Handles requests for the given connection
    */
   async handleConnection (connection: Connection) {
-    const daemon = this
+    const daemon = this // eslint-disable-line @typescript-eslint/no-this-alias
     // @ts-expect-error connection may actually be a maconn?
     const streamHandler = new StreamHandler({ stream: connection, maxLength: LIMIT })
 
@@ -375,119 +388,127 @@ export class Server implements Libp2pServer {
       source => (async function * () {
         let request: Request
 
-        for await (let buf of source) {
+        for await (const buf of source) {
           try {
             request = Request.decode(buf)
-          } catch (err) {
-            yield ErrorResponse(new Error('ERR_INVALID_MESSAGE'))
-            continue
-          }
 
-          switch (request.type) {
-            // Connect to another peer
-            case Request.Type.CONNECT: {
-              try {
-                await daemon.connect(request)
-              } catch (err: any) {
-                yield ErrorResponse(err)
+            switch (request.type) {
+              // Connect to another peer
+              case Request.Type.CONNECT: {
+                try {
+                  await daemon.connect(request)
+                } catch (err: any) {
+                  yield ErrorResponse(err)
+                  break
+                }
+                yield OkResponse()
                 break
               }
-              yield OkResponse()
-              break
-            }
-            // Get the daemon peer id and addresses
-            case Request.Type.IDENTIFY: {
-              yield OkResponse({
-                identify: {
-                  id: daemon.libp2p.peerId.toBytes(),
-                  addrs: daemon.libp2p.getMultiaddrs().map(m => m.bytes)
+              // Get the daemon peer id and addresses
+              case Request.Type.IDENTIFY: {
+                yield OkResponse({
+                  identify: {
+                    id: daemon.libp2p.peerId.toBytes(),
+                    addrs: daemon.libp2p.getMultiaddrs().map(ma => ma.decapsulateCode(protocols('p2p').code)).map(m => m.bytes)
+                  }
+                })
+                break
+              }
+              // Get a list of our current peers
+              case Request.Type.LIST_PEERS: {
+                const peers = []
+                const seen = new Set<string>()
+
+                for (const connection of daemon.libp2p.getConnections()) {
+                  const peerId = connection.remotePeer.toString()
+
+                  if (seen.has(peerId)) {
+                    continue
+                  }
+
+                  seen.add(peerId)
+
+                  peers.push({
+                    id: connection.remotePeer.toBytes(),
+                    addrs: [connection.remoteAddr.bytes]
+                  })
                 }
-              })
-              break
-            }
-            // Get a list of our current peers
-            case Request.Type.LIST_PEERS: {
-              const peers = []
 
-              for (const peerId of daemon.libp2p.getPeers()) {
-                const conn = daemon.libp2p.getConnections(peerId)[0]
+                yield OkResponse({ peers })
+                break
+              }
+              case Request.Type.STREAM_OPEN: {
+                let response
+                try {
+                  response = await daemon.openStream(request)
+                } catch (err: any) {
+                  yield ErrorResponse(err)
+                  break
+                }
 
-                peers.push({
-                  id: peerId.toBytes(),
-                  addrs: [conn.remoteAddr.bytes]
+                // write the response
+                yield OkResponse({
+                  streamInfo: response.streamInfo
                 })
-              }
 
-              yield OkResponse({ peers })
-              break
-            }
-            case Request.Type.STREAM_OPEN: {
-              let response
-              try {
-                response = await daemon.openStream(request)
-              } catch (err: any) {
-                yield ErrorResponse(err.message)
-                break
+                const stream = streamHandler.rest()
+                // then pipe the connection to the client
+                await pipe(
+                  stream,
+                  response.connection,
+                  stream
+                )
+                // Exit the iterator, no more requests can come through
+                return
               }
+              case Request.Type.STREAM_HANDLER: {
+                try {
+                  await daemon.registerStreamHandler(request)
+                } catch (err: any) {
+                  yield ErrorResponse(err)
+                  break
+                }
 
-              // write the response
-              yield OkResponse({
-                streamInfo: response.streamInfo
-              })
-
-              const stream = streamHandler.rest()
-              // then pipe the connection to the client
-              await pipe(
-                stream,
-                response.connection,
-                stream
-              )
-              // Exit the iterator, no more requests can come through
-              return
-            }
-            case Request.Type.STREAM_HANDLER: {
-              try {
-                await daemon.registerStreamHandler(request)
-              } catch (err: any) {
-                yield ErrorResponse(err)
+                // write the response
+                yield OkResponse()
                 break
               }
+              case Request.Type.PEERSTORE: {
+                if (request.peerStore == null) {
+                  yield ErrorResponse(new Error('ERR_INVALID_REQUEST'))
+                  break
+                }
 
-              // write the response
-              yield OkResponse()
-              break
-            }
-            case Request.Type.PEERSTORE: {
-              if (request.peerStore == null) {
-                yield ErrorResponse(new Error('ERR_INVALID_REQUEST'))
+                yield * daemon.handlePeerStoreRequest(request.peerStore)
                 break
               }
+              case Request.Type.PUBSUB: {
+                if (request.pubsub == null) {
+                  yield ErrorResponse(new Error('ERR_INVALID_REQUEST'))
+                  break
+                }
 
-              yield * daemon.handlePeerStoreRequest(request.peerStore)
-              break
-            }
-            case Request.Type.PUBSUB: {
-              if (request.pubsub == null) {
-                yield ErrorResponse(new Error('ERR_INVALID_REQUEST'))
+                yield * daemon.handlePubsubRequest(request.pubsub)
                 break
               }
+              case Request.Type.DHT: {
+                if (request.dht == null) {
+                  yield ErrorResponse(new Error('ERR_INVALID_REQUEST'))
+                  break
+                }
 
-              yield * daemon.handlePubsubRequest(request.pubsub)
-              break
-            }
-            case Request.Type.DHT: {
-              if (request.dht == null) {
-                yield ErrorResponse(new Error('ERR_INVALID_REQUEST'))
+                yield * daemon.handleDHTRequest(request.dht)
                 break
               }
-
-              yield * daemon.handleDHTRequest(request.dht)
-              break
+              // Not yet supported or doesn't exist
+              default:
+                yield ErrorResponse(new Error('ERR_INVALID_REQUEST_TYPE'))
+                break
             }
-            // Not yet supported or doesn't exist
-            default:
-              yield ErrorResponse(new Error('ERR_INVALID_REQUEST_TYPE'))
-              break
+          } catch (err: any) {
+            log.error(err)
+            yield ErrorResponse(err)
+            continue
           }
         }
       })(),
@@ -503,7 +524,7 @@ export class Server implements Libp2pServer {
 /**
  * Creates a daemon from the provided Daemon Options
  */
-export const createServer = async (multiaddr: Multiaddr, libp2pNode: Libp2p): Promise<Libp2pServer> => {
+export const createServer = (multiaddr: Multiaddr, libp2pNode: Libp2p): Libp2pServer => {
   const daemon = new Server({
     multiaddr,
     libp2pNode

package/src/pubsub.ts

@@ -3,17 +3,21 @@
 import {
   PSMessage
 } from '@libp2p/daemon-protocol'
-import { OkResponse } from './responses.js'
+import { ErrorResponse, OkResponse } from './responses.js'
 import type { PubSub } from '@libp2p/interfaces/pubsub'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { pushable } from 'it-pushable'
+import { CustomEvent } from '@libp2p/interfaces'
+import { logger } from '@libp2p/logger'
+
+const log = logger('libp2p:daemon-server:pubsub')
 
 export interface PubSubOperationsInit {
   pubsub: PubSub
 }
 
 export class PubSubOperations {
-  private pubsub: PubSub
+  private readonly pubsub: PubSub
 
   constructor (init: PubSubOperationsInit) {
     const { pubsub } = init
@@ -22,36 +26,50 @@ export class PubSubOperations {
   }
 
   async * getTopics () {
-    yield OkResponse({
-      pubsub: {
-        topics: this.pubsub.getTopics()
-      }
-    })
+    try {
+      yield OkResponse({
+        pubsub: {
+          topics: this.pubsub.getTopics()
+        }
+      })
+    } catch (err: any) {
+      log.error(err)
+      yield ErrorResponse(err)
+    }
   }
 
   async * subscribe (topic: string) {
-    const onMessage = pushable<Uint8Array>()
-
-    await this.pubsub.addEventListener(topic, (evt) => {
-      const msg = evt.detail
-
-      onMessage.push(PSMessage.encode({
-        from: msg.from.toBytes(),
-        data: msg.data,
-        seqno: msg.sequenceNumber == null ? undefined : uint8ArrayFromString(msg.sequenceNumber.toString(16).padStart(16, '0'), 'base16'),
-        topicIDs: [msg.topic],
-        signature: msg.signature,
-        key: msg.key
-      }).finish())
-    })
-
-    yield OkResponse()
-    yield * onMessage
+    try {
+      const onMessage = pushable<Uint8Array>()
+
+      await this.pubsub.addEventListener(topic, (evt) => {
+        const msg = evt.detail
+
+        onMessage.push(PSMessage.encode({
+          from: msg.from.toBytes(),
+          data: msg.data,
+          seqno: msg.sequenceNumber == null ? undefined : uint8ArrayFromString(msg.sequenceNumber.toString(16).padStart(16, '0'), 'base16'),
+          topicIDs: [msg.topic],
+          signature: msg.signature,
+          key: msg.key
+        }).finish())
+      })
+
+      yield OkResponse()
+      yield * onMessage
+    } catch (err: any) {
+      log.error(err)
+      yield ErrorResponse(err)
+    }
   }
 
   async * publish (topic: string, data: Uint8Array) {
-    this.pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
-    yield OkResponse()
+    try {
+      this.pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
+      yield OkResponse()
+    } catch (err: any) {
+      log.error(err)
+      yield ErrorResponse(err)
+    }
   }
-
 }

package/src/responses.ts

@@ -3,7 +3,7 @@ import { IResponse, Response } from '@libp2p/daemon-protocol'
 /**
  * Creates and encodes an OK response
  */
- export function OkResponse (data?: Partial<IResponse>): Uint8Array {
+export function OkResponse (data?: Partial<IResponse>): Uint8Array {
   return Response.encode({
     type: Response.Type.OK,
     ...data

package/dist/src/client.d.ts

@@ -1,26 +0,0 @@
-import type { Multiaddr } from '@multiformats/multiaddr';
-import type { Connection } from '@libp2p/interfaces/connection';
-import type { ConnectionHandler } from '@libp2p/interfaces/transport';
-export declare class Client {
-    private multiaddr;
-    private tcp;
-    private listener?;
-    constructor(addr: Multiaddr);
-    /**
-     * Connects to a daemon at the unix socket path the client
-     * was created with
-     */
-    connect(): Promise<Connection>;
-    /**
-     * Starts a server listening at `socketPath`. New connections
-     * will be sent to the `connectionHandler`.
-     */
-    start(addr: Multiaddr, handler: ConnectionHandler): Promise<void>;
-    /**
-     * Closes the socket
-     *
-     * @returns {Promise}
-     */
-    close(): Promise<void>;
-}
-//# sourceMappingURL=client.d.ts.map

package/dist/src/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,KAAK,EAAE,iBAAiB,EAAY,MAAM,8BAA8B,CAAA;AAE/E,qBAAa,MAAM;IACjB,OAAO,CAAC,SAAS,CAAW;IAC5B,OAAO,CAAC,GAAG,CAAK;IAChB,OAAO,CAAC,QAAQ,CAAC,CAAU;gBAEd,IAAI,EAAE,SAAS;IAK5B;;;OAGG;IACH,OAAO,IAAK,OAAO,CAAC,UAAU,CAAC;IAM/B;;;OAGG;IACG,KAAK,CAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAaxE;;;;OAIG;IACG,KAAK;CAOZ"}

package/dist/src/client.js

@@ -1,43 +0,0 @@
-import { TCP } from '@libp2p/tcp';
-import { passThroughUpgrader } from './util/index.js';
-export class Client {
-    constructor(addr) {
-        this.multiaddr = addr;
-        this.tcp = new TCP();
-    }
-    /**
-     * Connects to a daemon at the unix socket path the client
-     * was created with
-     */
-    connect() {
-        return this.tcp.dial(this.multiaddr, {
-            upgrader: passThroughUpgrader
-        });
-    }
-    /**
-     * Starts a server listening at `socketPath`. New connections
-     * will be sent to the `connectionHandler`.
-     */
-    async start(addr, handler) {
-        if (this.listener != null) {
-            await this.close();
-        }
-        this.listener = this.tcp.createListener({
-            handler,
-            upgrader: passThroughUpgrader
-        });
-        await this.listener.listen(addr);
-    }
-    /**
-     * Closes the socket
-     *
-     * @returns {Promise}
-     */
-    async close() {
-        if (this.listener != null) {
-            await this.listener.close();
-        }
-        this.listener = undefined;
-    }
-}
-//# sourceMappingURL=client.js.map

package/dist/src/client.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AACjC,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAKrD,MAAM,OAAO,MAAM;IAKjB,YAAa,IAAe;QAC1B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAA;QACrB,IAAI,CAAC,GAAG,GAAG,IAAI,GAAG,EAAE,CAAA;IACtB,CAAC;IAED;;;OAGG;IACH,OAAO;QACL,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACnC,QAAQ,EAAE,mBAAmB;SAC9B,CAAC,CAAA;IACJ,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,KAAK,CAAE,IAAe,EAAE,OAA0B;QACtD,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,EAAE;YACzB,MAAM,IAAI,CAAC,KAAK,EAAE,CAAA;SACnB;QAED,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC;YACtC,OAAO;YACP,QAAQ,EAAE,mBAAmB;SAC9B,CAAC,CAAA;QAEF,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAClC,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,KAAK;QACT,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,EAAE;YACzB,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAA;SAC5B;QAED,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAA;IAC3B,CAAC;CACF"}

package/dist/src/stream-handler.d.ts

@@ -1,28 +0,0 @@
-import type { Duplex, Source } from 'it-stream-types';
-export interface StreamHandlerOptions {
-    stream: Duplex<Uint8Array>;
-    maxLength?: number;
-}
-export declare class StreamHandler {
-    private stream;
-    private shake;
-    decoder: Source<Uint8Array>;
-    /**
-     * Create a stream handler for connection
-     */
-    constructor(opts: StreamHandlerOptions);
-    /**
-     * Read and decode message
-     */
-    read(): Promise<any>;
-    write(msg: Uint8Array): void;
-    /**
-     * Return the handshake rest stream and invalidate handler
-     */
-    rest(): Duplex<Uint8Array, Uint8Array, Promise<void>>;
-    /**
-     * Close the stream
-     */
-    close(): void;
-}
-//# sourceMappingURL=stream-handler.d.ts.map

package/dist/src/stream-handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream-handler.d.ts","sourceRoot":"","sources":["../../src/stream-handler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAKrD,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,CAAA;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,KAAK,CAAW;IACjB,OAAO,EAAE,MAAM,CAAC,UAAU,CAAC,CAAA;IAClC;;OAEG;gBACU,IAAI,EAAE,oBAAoB;IAQvC;;OAEG;IACG,IAAI;IAWV,KAAK,CAAE,GAAG,EAAE,UAAU;IAOtB;;OAEG;IACH,IAAI;IAKJ;;OAEG;IACH,KAAK;CAIN"}