bare-rpc 0.1.1 → 0.1.3

package/index.d.ts

@@ -0,0 +1,82 @@
+import Buffer, { BufferEncoding } from 'bare-buffer'
+import {
+  Readable,
+  ReadableOptions,
+  Writable,
+  WritableOptions,
+  PassThrough
+} from 'bare-stream'
+
+declare const constants: {
+  type: { REQUEST: 1; RESPONSE: 2; STREAM: 3 }
+  stream: {
+    OPEN: number
+    CLOSE: number
+    PAUSE: number
+    RESUME: number
+    DATA: number
+    END: number
+    DESTROY: number
+    ERROR: number
+    REQUEST: number
+    RESPONSE: number
+  }
+}
+
+interface RPCIncomingRequest {
+  rpc: RPC
+  id: number
+  command: string
+  data: Buffer
+  sent: boolean
+
+  reply(data: Buffer | string, encoding?: BufferEncoding): void
+
+  createResponseStream(opts?: WritableOptions): RPCOutgoingStream
+  createRequestStream(opts?: ReadableOptions): RPCIncomingStream
+}
+
+declare class RPCIncomingRequest {
+  constructor(rpc: RPC, id: number, command: string, data: Buffer)
+}
+
+interface RPCOutgoingRequest {
+  send(data: Buffer | string, encoding?: BufferEncoding): void
+
+  reply(encoding?: BufferEncoding): Promise<Buffer>
+
+  createRequestStream(opts?: WritableOptions): RPCOutgoingStream
+  createResponseStream(opts?: ReadableOptions): RPCIncomingStream
+}
+
+declare class RPCOutgoingRequest {
+  constructor(rpc: RPC, command: string)
+}
+
+declare class RPCIncomingStream extends Readable {
+  constructor(
+    rpc: RPC,
+    request: RPCIncomingRequest | RPCOutgoingRequest,
+    type: typeof constants.type.REQUEST | typeof constants.type.RESPONSE,
+    opts?: ReadableOptions
+  )
+}
+
+declare class RPCOutgoingStream extends Writable {
+  constructor(
+    rpc: RPC,
+    request: RPCIncomingRequest | RPCOutgoingRequest,
+    type: typeof constants.type.REQUEST | typeof constants.type.RESPONSE,
+    opts?: WritableOptions
+  )
+}
+
+interface RPC {
+  request(command: string): RPCOutgoingRequest
+}
+
+declare class RPC {
+  constructor(stream: PassThrough, onrequest: (req: RPCIncomingRequest) => void)
+}
+
+export = RPC

package/index.js

@@ -9,62 +9,73 @@ const OutgoingRequest = require('./lib/outgoing-request')
 const OutgoingStream = require('./lib/outgoing-stream')
 
 module.exports = class RPC {
-  constructor (stream, onrequest) {
+  constructor(stream, onrequest) {
     this._stream = stream
 
     this._id = 0
-    this._requests = new Map()
-    this._responses = new Map()
-    this._incoming = new Map()
+
+    this._outgoingRequests = new Map()
+    this._outgoingResponses = new Map()
+    this._incomingRequests = new Map()
+    this._incomingResponses = new Map()
+    this._pendingRequests = new Set()
+    this._pendingResponses = new Set()
 
     this._buffer = null
 
     this._onrequest = onrequest.bind(this)
     this._ondata = this._ondata.bind(this)
 
-    this._stream
-      .on('data', this._ondata)
+    this._stream.on('data', this._ondata)
   }
 
-  request (command) {
-    return new OutgoingRequest(this, command)
+  request(command) {
+    return new OutgoingRequest(++this._id, this, command)
   }
 
-  _sendMessage (message) {
+  _sendMessage(message) {
     this._stream.write(c.encode(m.message, message))
   }
 
-  _sendRequest (request, data = null) {
-    const id = request.id = ++this._id
-
-    this._requests.set(id, request)
+  _sendRequest(request, data = null) {
+    this._outgoingRequests.set(request.id, request)
 
     this._sendMessage({
       type: t.REQUEST,
-      id,
+      id: request.id,
       command: request.command,
       stream: 0,
       data
     })
   }
 
-  _createRequestStream (request, isInitiator, opts) {
+  _createRequestStream(request, isInitiator, opts) {
     if (isInitiator) {
-      const id = request.id = ++this._id
-
-      this._requests.set(id, request)
-
-      request._requestStream = new OutgoingStream(this, request, t.REQUEST, opts)
+      this._outgoingRequests.set(request.id, request)
+
+      request._requestStream = new OutgoingStream(
+        this,
+        request,
+        t.REQUEST,
+        opts
+      )
     } else {
-      this._incoming.set(request.id, request)
-
-      const stream = request._requestStream = new IncomingStream(this, request, t.REQUEST, opts)
-
-      stream.on('close', () => this._incoming.delete(request.id))
+      this._incomingRequests.set(request.id, request)
+
+      request._requestStream = new IncomingStream(
+        this,
+        request,
+        t.REQUEST,
+        opts
+      )
+
+      request._requestStream.on('close', () =>
+        this._incomingRequests.delete(request.id)
+      )
     }
   }
 
-  _sendResponse (request, data) {
+  _sendResponse(request, data) {
     this._sendMessage({
       type: t.RESPONSE,
       id: request.id,
@@ -74,21 +85,33 @@ module.exports = class RPC {
     })
   }
 
-  _createResponseStream (request, isInitiator, opts) {
+  _createResponseStream(request, isInitiator, opts) {
     if (isInitiator) {
-      this._responses.set(request.id, request)
-
-      request._responseStream = new OutgoingStream(this, request, t.RESPONSE, opts)
+      this._outgoingResponses.set(request.id, request)
+
+      request._responseStream = new OutgoingStream(
+        this,
+        request,
+        t.RESPONSE,
+        opts
+      )
     } else {
-      this._incoming.set(request.id, request)
-
-      const stream = request._responseStream = new IncomingStream(this, request, t.RESPONSE, opts)
-
-      stream.on('close', () => this._incoming.delete(request.id))
+      this._incomingResponses.set(request.id, request)
+
+      request._responseStream = new IncomingStream(
+        this,
+        request,
+        t.RESPONSE,
+        opts
+      )
+
+      request._responseStream.on('close', () =>
+        this._incomingResponses.delete(request.id)
+      )
     }
   }
 
-  _sendError (request, err) {
+  _sendError(request, err) {
     this._sendMessage({
       type: t.RESPONSE,
       id: request.id,
@@ -98,7 +121,7 @@ module.exports = class RPC {
     })
   }
 
-  _ondata (data) {
+  _ondata(data) {
     if (this._buffer === null) this._buffer = data
     else this._buffer = b4a.concat([this._buffer, data])
 
@@ -118,7 +141,12 @@ module.exports = class RPC {
 
       switch (message.type) {
         case t.REQUEST: {
-          const request = new IncomingRequest(this, message.id, message.command, message.data)
+          const request = new IncomingRequest(
+            this,
+            message.id,
+            message.command,
+            message.data
+          )
 
           try {
             this._onrequest(request)
@@ -144,14 +172,15 @@ module.exports = class RPC {
           }
       }
 
-      this._buffer = state.start === state.end ? null : this._buffer.subarray(state.start)
+      this._buffer =
+        state.start === state.end ? null : this._buffer.subarray(state.start)
     }
   }
 
-  _onresponse (message) {
+  _onresponse(message) {
     if (message.id === 0) return
 
-    const request = this._requests.get(message.id)
+    const request = this._outgoingRequests.get(message.id)
     if (request === undefined) return
 
     if (message.error) {
@@ -161,7 +190,7 @@ module.exports = class RPC {
     }
   }
 
-  _onstream (message) {
+  _onstream(message) {
     if (message.id === 0) return
 
     if (message.stream & s.OPEN) this._onstreamopen(message)
@@ -173,17 +202,23 @@ module.exports = class RPC {
     else if (message.stream & s.DESTROY) this._onstreamdestroy(message)
   }
 
-  _onstreamopen (message) {
+  _onstreamopen(message) {
     let stream
 
     if (message.stream & s.REQUEST) {
-      const request = this._requests.get(message.id)
-      if (request === undefined) return
+      const request = this._outgoingRequests.get(message.id)
+      if (request === undefined) {
+        this._pendingRequests.add(message.id)
+        return
+      }
 
       stream = request._requestStream
     } else if (message.stream & s.RESPONSE) {
-      const request = this._responses.get(message.id)
-      if (request === undefined) return
+      const request = this._outgoingResponses.get(message.id)
+      if (request === undefined) {
+        this._pendingResponses.add(message.id)
+        return
+      }
 
       stream = request._responseStream
     } else {
@@ -193,15 +228,18 @@ module.exports = class RPC {
     stream._continueOpen()
   }
 
-  _onstreamclose (message) {
-    const request = this._incoming.get(message.id)
-    if (request === undefined) return
-
+  _onstreamclose(message) {
     let stream
 
     if (message.stream & s.REQUEST) {
+      const request = this._incomingRequests.get(message.id)
+      if (request === undefined) return
+
       stream = request._requestStream
     } else if (message.stream & s.RESPONSE) {
+      const request = this._incomingResponses.get(message.id)
+      if (request === undefined) return
+
       stream = request._responseStream
     } else {
       return
@@ -211,16 +249,16 @@ module.exports = class RPC {
     else stream.push(null)
   }
 
-  _onstreampause (message) {
+  _onstreampause(message) {
     let stream
 
     if (message.stream & s.REQUEST) {
-      const request = this._requests.get(message.id)
+      const request = this._outgoingRequests.get(message.id)
       if (request === undefined) return
 
       stream = request._requestStream
     } else if (message.stream & s.RESPONSE) {
-      const request = this._responses.get(message.id)
+      const request = this._outgoingResponses.get(message.id)
       if (request === undefined) return
 
       stream = request._responseStream
@@ -231,16 +269,16 @@ module.exports = class RPC {
     stream.cork()
   }
 
-  _onstreamresume (message) {
+  _onstreamresume(message) {
     let stream
 
     if (message.stream & s.REQUEST) {
-      const request = this._requests.get(message.id)
+      const request = this._outgoingRequests.get(message.id)
       if (request === undefined) return
 
       stream = request._requestStream
     } else if (message.stream & s.RESPONSE) {
-      const request = this._responses.get(message.id)
+      const request = this._outgoingResponses.get(message.id)
       if (request === undefined) return
 
       stream = request._responseStream
@@ -251,15 +289,18 @@ module.exports = class RPC {
     stream.uncork()
   }
 
-  _onstreamdata (message) {
-    const request = this._incoming.get(message.id)
-    if (request === undefined) return
-
+  _onstreamdata(message) {
     let stream
 
     if (message.stream & s.REQUEST) {
+      const request = this._incomingRequests.get(message.id)
+      if (request === undefined) return
+
       stream = request._requestStream
     } else if (message.stream & s.RESPONSE) {
+      const request = this._incomingResponses.get(message.id)
+      if (request === undefined) return
+
       stream = request._responseStream
     } else {
       return
@@ -276,15 +317,18 @@ module.exports = class RPC {
     }
   }
 
-  _onstreamend (message) {
-    const request = this._incoming.get(message.id)
-    if (request === undefined) return
-
+  _onstreamend(message) {
     let stream
 
     if (message.stream & s.REQUEST) {
+      const request = this._incomingRequests.get(message.id)
+      if (request === undefined) return
+
       stream = request._requestStream
     } else if (message.stream & s.RESPONSE) {
+      const request = this._incomingResponses.get(message.id)
+      if (request === undefined) return
+
       stream = request._responseStream
     } else {
       return
@@ -293,16 +337,16 @@ module.exports = class RPC {
     stream.push(null)
   }
 
-  _onstreamdestroy (message) {
+  _onstreamdestroy(message) {
     let stream
 
     if (message.stream & s.REQUEST) {
-      const request = this._requests.get(message.id)
+      const request = this._outgoingRequests.get(message.id)
       if (request === undefined) return
 
       stream = request._requestStream
     } else if (message.stream & s.RESPONSE) {
-      const request = this._responses.get(message.id)
+      const request = this._outgoingResponses.get(message.id)
       if (request === undefined) return
 
       stream = request._responseStream

package/lib/errors.d.ts

@@ -0,0 +1,6 @@
+declare class RPCError extends Error {
+  static UNKNOWN_MESSAGE(msg: string): RPCError
+  static ALREADY_SENT(msg: string): RPCError
+}
+
+export = RPCError

package/lib/errors.js

@@ -1,5 +1,5 @@
 module.exports = class RPCError extends Error {
-  constructor (msg, code, fn = RPCError) {
+  constructor(msg, code, fn = RPCError) {
     super(`${code}: ${msg}`)
     this.code = code
 
@@ -8,15 +8,15 @@ module.exports = class RPCError extends Error {
     }
   }
 
-  get name () {
+  get name() {
     return 'RPCError'
   }
 
-  static UNKNOWN_MESSAGE (msg) {
+  static UNKNOWN_MESSAGE(msg) {
     return new RPCError(msg, 'UNKNOWN_MESSAGE', RPCError.UNKNOWN_MESSAGE)
   }
 
-  static ALREADY_SENT (msg) {
+  static ALREADY_SENT(msg) {
     return new RPCError(msg, 'ALREADY_SENT', RPCError.ALREADY_SENT)
   }
 }

package/lib/incoming-request.js

@@ -2,7 +2,7 @@ const b4a = require('b4a')
 const errors = require('./errors')
 
 module.exports = class RPCIncomingRequest {
-  constructor (rpc, id, command, data) {
+  constructor(rpc, id, command, data) {
     this.rpc = rpc
     this.id = id
     this.command = command
@@ -13,21 +13,26 @@ module.exports = class RPCIncomingRequest {
     this._responseStream = null
   }
 
-  reply (data) {
+  reply(data, encoding) {
     if (this.sent) throw errors.ALREADY_SENT('Response has already been sent')
     this.sent = true
 
-    this.rpc._sendResponse(this, typeof data === 'string' ? b4a.from(data) : data)
+    this.rpc._sendResponse(
+      this,
+      typeof data === 'string' ? b4a.from(data, encoding) : data
+    )
   }
 
-  createResponseStream (opts = {}) {
-    if (this._responseStream === null) this.rpc._createResponseStream(this, true, opts)
+  createResponseStream(opts = {}) {
+    if (this._responseStream === null)
+      this.rpc._createResponseStream(this, true, opts)
 
     return this._responseStream
   }
 
-  createRequestStream (opts = {}) {
-    if (this._requestStream === null) this.rpc._createRequestStream(this, false, opts)
+  createRequestStream(opts = {}) {
+    if (this._requestStream === null)
+      this.rpc._createRequestStream(this, false, opts)
 
     return this._requestStream
   }

package/lib/incoming-stream.js

@@ -2,7 +2,7 @@ const { Readable } = require('bare-stream')
 const { type: t, stream: s } = require('./constants')
 
 module.exports = class RPCIncomingStream extends Readable {
-  constructor (rpc, request, type, opts) {
+  constructor(rpc, request, type, opts) {
     super({ ...opts, eagerOpen: true })
 
     this._rpc = rpc
@@ -13,7 +13,7 @@ module.exports = class RPCIncomingStream extends Readable {
     this._pendingOpen = null
   }
 
-  _open (cb) {
+  _open(cb) {
     this._rpc._sendMessage({
       type: t.STREAM,
       id: this._request.id,
@@ -25,7 +25,7 @@ module.exports = class RPCIncomingStream extends Readable {
     cb(null)
   }
 
-  _read () {
+  _read() {
     this._rpc._sendMessage({
       type: t.STREAM,
       id: this._request.id,
@@ -35,7 +35,7 @@ module.exports = class RPCIncomingStream extends Readable {
     })
   }
 
-  _destroy (err, cb) {
+  _destroy(err, cb) {
     if (err) {
       this._rpc._sendMessage({
         type: t.STREAM,

package/lib/messages.js

@@ -3,17 +3,17 @@ const { type: t, stream: s } = require('./constants')
 const errors = require('./errors')
 
 const request = {
-  preencode (state, m) {
+  preencode(state, m) {
     c.utf8.preencode(state, m.command)
     c.uint.preencode(state, m.stream)
     if (m.stream === 0) c.buffer.preencode(state, m.data)
   },
-  encode (state, m) {
+  encode(state, m) {
     c.utf8.encode(state, m.command)
     c.uint.encode(state, m.stream)
     if (m.stream === 0) c.buffer.encode(state, m.data)
   },
-  decode (state, id) {
+  decode(state, id) {
     const command = c.utf8.decode(state)
     const stream = c.uint.decode(state)
     const data = stream === 0 ? c.buffer.decode(state) : null
@@ -23,17 +23,17 @@ const request = {
 }
 
 const error = {
-  preencode (state, m) {
+  preencode(state, m) {
     c.utf8.preencode(state, m.message)
     c.utf8.preencode(state, m.code || '')
     c.int.preencode(state, m.errno || 0)
   },
-  encode (state, m) {
+  encode(state, m) {
     c.utf8.encode(state, m.message)
     c.utf8.encode(state, m.code || '')
     c.int.encode(state, m.errno || 0)
   },
-  decode (state) {
+  decode(state) {
     const err = new Error(`${c.utf8.decode(state)}`)
     err.code = c.utf8.decode(state)
     err.errno = c.int.decode(state)
@@ -42,56 +42,59 @@ const error = {
 }
 
 const response = {
-  preencode (state, m) {
+  preencode(state, m) {
     c.bool.preencode(state, !!m.error)
     c.uint.preencode(state, m.stream)
 
     if (m.error) error.preencode(state, m.error)
     else if (m.stream === 0) c.buffer.preencode(state, m.data)
   },
-  encode (state, m) {
+  encode(state, m) {
     c.bool.encode(state, !!m.error)
     c.uint.encode(state, m.stream)
 
     if (m.error) error.encode(state, m)
     else if (m.stream === 0) c.buffer.encode(state, m.data)
   },
-  decode (state) {
+  decode(state) {
     const error = c.bool.decode(state)
     const stream = c.uint.decode(state)
 
     if (error) return { stream, error: error.decode(state), data: null }
-    if (stream === 0) return { stream, error: null, data: c.buffer.decode(state) }
+    if (stream === 0)
+      return { stream, error: null, data: c.buffer.decode(state) }
 
     return { stream, error: null, data: null }
   }
 }
 
 const stream = {
-  preencode (state, m) {
+  preencode(state, m) {
     c.uint.preencode(state, m.stream)
 
     if (m.stream & s.ERROR) error.preencode(state, m.error)
     else if (m.stream & s.DATA) c.buffer.preencode(state, m.data)
   },
-  encode (state, m) {
+  encode(state, m) {
     c.uint.encode(state, m.stream)
 
     if (m.stream & s.ERROR) error.encode(state, m.error)
     else if (m.stream & s.DATA) c.buffer.encode(state, m.data)
   },
-  decode (state) {
+  decode(state) {
     const stream = c.uint.decode(state)
 
-    if (stream & s.ERROR) return { stream, error: error.decode(state), data: null }
-    if (stream & s.DATA) return { stream, error: null, data: c.buffer.decode(state) }
+    if (stream & s.ERROR)
+      return { stream, error: error.decode(state), data: null }
+    if (stream & s.DATA)
+      return { stream, error: null, data: c.buffer.decode(state) }
 
     return { stream, error: null, data: null }
   }
 }
 
 exports.message = {
-  preencode (state, m) {
+  preencode(state, m) {
     c.uint32.preencode(state, 0) // Frame
     c.uint.preencode(state, m.type)
     c.uint.preencode(state, m.id)
@@ -108,7 +111,7 @@ exports.message = {
         break
     }
   },
-  encode (state, m) {
+  encode(state, m) {
     const frame = state.start
 
     c.uint32.encode(state, 0) // Frame
@@ -138,7 +141,7 @@ exports.message = {
 
     state.start = end
   },
-  decode (state) {
+  decode(state) {
     if (state.end - state.start < 4) return null
 
     const frame = c.uint32.decode(state)

package/lib/outgoing-request.js

@@ -2,9 +2,9 @@ const b4a = require('b4a')
 const errors = require('./errors')
 
 module.exports = class RPCOutgoingRequest {
-  constructor (rpc, command) {
+  constructor(id, rpc, command) {
+    this.id = id
     this.rpc = rpc
-    this.id = -1
     this.command = command
     this.sent = false
 
@@ -17,25 +17,34 @@ module.exports = class RPCOutgoingRequest {
     this._responseStream = null
   }
 
-  send (data) {
+  send(data, encoding) {
     if (this.sent) throw errors.ALREADY_SENT('Request has already been sent')
     this.sent = true
 
-    this.rpc._sendRequest(this, typeof data === 'string' ? b4a.from(data) : data)
+    this.rpc._sendRequest(
+      this,
+      typeof data === 'string' ? b4a.from(data, encoding) : data
+    )
   }
 
-  reply () {
-    return this._promise
+  reply(encoding) {
+    return encoding && encoding !== 'buffer'
+      ? this._promise.then((data) => b4a.toString(data, encoding))
+      : this._promise
   }
 
-  createRequestStream (opts = {}) {
-    if (this._requestStream === null) this.rpc._createRequestStream(this, true, opts)
+  createRequestStream(opts = {}) {
+    if (this._requestStream === null) {
+      this.rpc._createRequestStream(this, true, opts)
+    }
 
     return this._requestStream
   }
 
-  createResponseStream (opts = {}) {
-    if (this._requestStream === null) this.rpc._createResponseStream(this, false, opts)
+  createResponseStream(opts = {}) {
+    if (this._requestStream === null) {
+      this.rpc._createResponseStream(this, false, opts)
+    }
 
     return this._responseStream
   }

package/lib/outgoing-stream.js

@@ -2,7 +2,7 @@ const { Writable } = require('bare-stream')
 const { type: t, stream: s } = require('./constants')
 
 module.exports = class RPCOutgoingStream extends Writable {
-  constructor (rpc, request, type, opts) {
+  constructor(rpc, request, type, opts) {
     super({ ...opts, eagerOpen: true })
 
     this._rpc = rpc
@@ -13,11 +13,13 @@ module.exports = class RPCOutgoingStream extends Writable {
     this._pendingOpen = null
   }
 
-  _open (cb) {
-    this._pendingOpen = cb
+  _open(cb) {
+    let pending
 
     switch (this._type) {
       case t.REQUEST:
+        pending = this._rpc._pendingRequests
+
         this._rpc._sendMessage({
           type: t.REQUEST,
           id: this._request.id,
@@ -28,6 +30,8 @@ module.exports = class RPCOutgoingStream extends Writable {
         break
 
       case t.RESPONSE:
+        pending = this._rpc._pendingResponses
+
         this._rpc._sendMessage({
           type: t.RESPONSE,
           id: this._request.id,
@@ -37,16 +41,24 @@ module.exports = class RPCOutgoingStream extends Writable {
         })
         break
     }
+
+    if (pending.has(this._request.id)) {
+      pending.delete(this._request.id)
+
+      cb(null)
+    } else {
+      this._pendingOpen = cb
+    }
   }
 
-  _continueOpen () {
+  _continueOpen() {
     if (this._pendingOpen === null) return
     const cb = this._pendingOpen
     this._pendingOpen = null
     cb()
   }
 
-  _write (data, encoding, cb) {
+  _write(data, encoding, cb) {
     this._rpc._sendMessage({
       type: t.STREAM,
       id: this._request.id,
@@ -58,7 +70,7 @@ module.exports = class RPCOutgoingStream extends Writable {
     cb(null)
   }
 
-  _final (cb) {
+  _final(cb) {
     this._rpc._sendMessage({
       type: t.STREAM,
       id: this._request.id,
@@ -70,7 +82,7 @@ module.exports = class RPCOutgoingStream extends Writable {
     cb(null)
   }
 
-  _destroy (err, cb) {
+  _destroy(err, cb) {
     if (err) {
       this._rpc._sendMessage({
         type: t.STREAM,

package/package.json

@@ -1,18 +1,25 @@
 {
   "name": "bare-rpc",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "librpc ABI compatible RPC for Bare",
   "exports": {
-    ".": "./index.js",
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
     "./package": "./package.json",
-    "./errors": "./lib/errors.js"
+    "./errors": {
+      "types": "./lib/errors.d.ts",
+      "default": "./lib/errors.js"
+    }
   },
   "files": [
     "index.js",
+    "index.d.ts",
     "lib"
   ],
   "scripts": {
-    "test": "standard && bare test.js"
+    "test": "prettier . --check && bare test.js"
   },
   "repository": {
     "type": "git",
@@ -31,7 +38,17 @@
     "safety-catch": "^1.0.2"
   },
   "devDependencies": {
+    "bare-buffer": "^3.0.1",
     "brittle": "^3.2.1",
-    "standard": "^17.0.0"
+    "prettier": "^3.4.2",
+    "prettier-config-standard": "^7.0.0"
+  },
+  "peerDependencies": {
+    "bare-buffer": "*"
+  },
+  "peerDependenciesMeta": {
+    "bare-buffer": {
+      "optional": true
+    }
   }
 }