hypercore 11.16.1 → 11.17.0

package/lib/multisig.js

@@ -13,19 +13,26 @@ module.exports = {
   signableLength
 }
 
-function inflatev0 (data) {
+function inflatev0(data) {
   return c.decode(multiSignaturev0, data)
 }
 
-function inflate (data) {
+function inflate(data) {
   return c.decode(multiSignature, data)
 }
 
-async function partialSignature (core, signer, from, to = core.state.length, signature = core.state.signature) {
+async function partialSignature(
+  core,
+  signer,
+  from,
+  to = core.state.length,
+  signature = core.state.signature
+) {
   if (from > core.state.length) return null
   const nodes = to <= from ? null : await upgradeNodes(core, from, to)
 
-  if (signature.byteLength !== 64) signature = c.decode(multiSignature, signature).proofs[0].signature
+  if (signature.byteLength !== 64)
+    signature = c.decode(multiSignature, signature).proofs[0].signature
 
   return {
     signer,
@@ -35,7 +42,7 @@ async function partialSignature (core, signer, from, to = core.state.length, sig
   }
 }
 
-async function upgradeNodes (core, from, to) {
+async function upgradeNodes(core, from, to) {
   const rx = core.state.storage.read()
   let p = null
   try {
@@ -48,18 +55,18 @@ async function upgradeNodes (core, from, to) {
   return (await p.settle()).upgrade.nodes
 }
 
-function signableLength (lengths, quorum) {
+function signableLength(lengths, quorum) {
   if (quorum <= 0) quorum = 1
   if (quorum > lengths.length) return 0
 
   return lengths.sort(cmp)[quorum - 1]
 }
 
-function cmp (a, b) {
+function cmp(a, b) {
   return b - a
 }
 
-function assemblev0 (inputs) {
+function assemblev0(inputs) {
   const proofs = []
   const patch = []
 
@@ -70,7 +77,7 @@ function assemblev0 (inputs) {
   return c.encode(multiSignaturev0, { proofs, patch })
 }
 
-function assemble (inputs) {
+function assemble(inputs) {
   const proofs = []
   const patch = []
   const seen = new Set()
@@ -94,13 +101,13 @@ function assemble (inputs) {
   return c.encode(multiSignature, { proofs, patch })
 }
 
-function compareNode (a, b) {
+function compareNode(a, b) {
   if (a.index !== b.index) return false
   if (a.size !== b.size) return false
   return b4a.equals(a.hash, b.hash)
 }
 
-function compressProof (proof, nodes) {
+function compressProof(proof, nodes) {
   return {
     signer: proof.signer,
     signature: proof.signature,
@@ -108,7 +115,7 @@ function compressProof (proof, nodes) {
   }
 }
 
-function compressUpgrade (p, nodes) {
+function compressUpgrade(p, nodes) {
   const u = {
     start: flat.rightSpan(p.nodes[p.nodes.length - 1].index) / 2 + 1,
     length: p.patch,

package/lib/mutex.js

@@ -1,5 +1,5 @@
 module.exports = class Mutex {
-  constructor () {
+  constructor() {
     this.locked = false
     this.destroyed = false
 
@@ -9,18 +9,19 @@ module.exports = class Mutex {
     this._enqueue = (resolve, reject) => this._queue.push([resolve, reject])
   }
 
-  idle () {
+  idle() {
     return this._queue.length === 0 && this.locked === false
   }
 
-  lock () {
-    if (this.destroyed) return Promise.reject(this._destroyError || new Error('Mutex has been destroyed'))
+  lock() {
+    if (this.destroyed)
+      return Promise.reject(this._destroyError || new Error('Mutex has been destroyed'))
     if (this.locked) return new Promise(this._enqueue)
     this.locked = true
     return Promise.resolve()
   }
 
-  unlock () {
+  unlock() {
     if (!this._queue.length) {
       this.locked = false
       return
@@ -28,8 +29,9 @@ module.exports = class Mutex {
     this._queue.shift()[0]()
   }
 
-  destroy (err) {
-    if (!this._destroying) this._destroying = this.locked ? this.lock().catch(() => {}) : Promise.resolve()
+  destroy(err) {
+    if (!this._destroying)
+      this._destroying = this.locked ? this.lock().catch(() => {}) : Promise.resolve()
 
     this.destroyed = true
     if (err) this._destroyError = err

package/lib/receiver-queue.js

@@ -1,14 +1,14 @@
 const FIFO = require('fast-fifo')
 
 module.exports = class ReceiverQueue {
-  constructor () {
+  constructor() {
     this.queue = new FIFO()
     this.priority = []
     this.requests = new Map()
     this.length = 0
   }
 
-  push (req) {
+  push(req) {
     // TODO: use a heap at some point if we wanna support multiple prios
     if (req.priority > 0) this.priority.push(req)
     else this.queue.push(req)
@@ -17,7 +17,7 @@ module.exports = class ReceiverQueue {
     this.length++
   }
 
-  shift () {
+  shift() {
     while (this.priority.length > 0) {
       const msg = this.priority.pop()
       const req = this._processRequest(msg)
@@ -33,7 +33,7 @@ module.exports = class ReceiverQueue {
     return null
   }
 
-  _processRequest (req) {
+  _processRequest(req) {
     if (req.block || req.hash || req.seek || req.upgrade || req.manifest) {
       this.requests.delete(req.id)
       this.length--
@@ -43,14 +43,14 @@ module.exports = class ReceiverQueue {
     return null
   }
 
-  clear () {
+  clear() {
     this.queue.clear()
     this.priority = []
     this.length = 0
     this.requests.clear()
   }
 
-  delete (id) {
+  delete(id) {
     const req = this.requests.get(id)
     if (!req) return
 

package/lib/remote-bitfield.js

@@ -9,7 +9,7 @@ const BYTES_PER_SEGMENT = BITS_PER_SEGMENT / 8
 const PAGES_PER_SEGMENT = BITS_PER_SEGMENT / BITS_PER_PAGE
 
 class RemoteBitfieldPage {
-  constructor (index, bitfield, segment) {
+  constructor(index, bitfield, segment) {
     this.index = index
     this.offset = index * BYTES_PER_PAGE - segment.offset
     this.bitfield = bitfield
@@ -18,21 +18,21 @@ class RemoteBitfieldPage {
     segment.add(this)
   }
 
-  get tree () {
+  get tree() {
     return this.segment.tree
   }
 
-  get (index) {
+  get(index) {
     return quickbit.get(this.bitfield, index)
   }
 
-  set (index, val) {
+  set(index, val) {
     if (quickbit.set(this.bitfield, index, val)) {
       this.tree.update(this.offset * 8 + index)
     }
   }
 
-  setRange (start, end, val) {
+  setRange(start, end, val) {
     quickbit.fill(this.bitfield, val, start, end)
 
     let i = Math.floor(start / 128)
@@ -41,26 +41,26 @@ class RemoteBitfieldPage {
     while (i <= n) this.tree.update(this.offset * 8 + i++ * 128)
   }
 
-  findFirst (val, position) {
+  findFirst(val, position) {
     return quickbit.findFirst(this.bitfield, val, position)
   }
 
-  findLast (val, position) {
+  findLast(val, position) {
     return quickbit.findLast(this.bitfield, val, position)
   }
 
-  insert (start, bitfield) {
+  insert(start, bitfield) {
     this.bitfield.set(bitfield, start / 32)
     this.segment.refresh()
   }
 
-  clear (start, bitfield) {
+  clear(start, bitfield) {
     quickbit.clear(this.bitfield, { field: bitfield, offset: start })
   }
 }
 
 class RemoteBitfieldSegment {
-  constructor (index) {
+  constructor(index) {
     this.index = index
     this.offset = index * BYTES_PER_SEGMENT
     this.tree = quickbit.Index.from([], BYTES_PER_SEGMENT)
@@ -68,15 +68,15 @@ class RemoteBitfieldSegment {
     this.pagesLength = 0
   }
 
-  get chunks () {
+  get chunks() {
     return this.tree.chunks
   }
 
-  refresh () {
+  refresh() {
     this.tree = quickbit.Index.from(this.tree.chunks, BYTES_PER_SEGMENT)
   }
 
-  add (page) {
+  add(page) {
     const pageIndex = page.index - this.index * PAGES_PER_SEGMENT
     if (pageIndex >= this.pagesLength) this.pagesLength = pageIndex + 1
 
@@ -94,7 +94,7 @@ class RemoteBitfieldSegment {
     }
   }
 
-  findFirst (val, position) {
+  findFirst(val, position) {
     position = this.tree.skipFirst(!val, position)
 
     let j = position & (BITS_PER_PAGE - 1)
@@ -116,10 +116,10 @@ class RemoteBitfieldSegment {
       i++
     }
 
-    return (val || this.pagesLength === PAGES_PER_SEGMENT) ? -1 : this.pagesLength * BITS_PER_PAGE
+    return val || this.pagesLength === PAGES_PER_SEGMENT ? -1 : this.pagesLength * BITS_PER_PAGE
   }
 
-  findLast (val, position) {
+  findLast(val, position) {
     position = this.tree.skipLast(!val, position)
 
     let j = position & (BITS_PER_PAGE - 1)
@@ -148,13 +148,13 @@ class RemoteBitfieldSegment {
 module.exports = class RemoteBitfield {
   static BITS_PER_PAGE = BITS_PER_PAGE
 
-  constructor () {
+  constructor() {
     this._pages = new BigSparseArray()
     this._segments = new BigSparseArray()
     this._maxSegments = 0
   }
 
-  getBitfield (index) {
+  getBitfield(index) {
     const j = index & (BITS_PER_PAGE - 1)
     const i = (index - j) / BITS_PER_PAGE
 
@@ -162,7 +162,7 @@ module.exports = class RemoteBitfield {
     return p || null
   }
 
-  get (index) {
+  get(index) {
     const j = index & (BITS_PER_PAGE - 1)
     const i = (index - j) / BITS_PER_PAGE
 
@@ -171,7 +171,7 @@ module.exports = class RemoteBitfield {
     return p ? p.get(j) : false
   }
 
-  set (index, val) {
+  set(index, val) {
     const j = index & (BITS_PER_PAGE - 1)
     const i = (index - j) / BITS_PER_PAGE
 
@@ -188,7 +188,7 @@ module.exports = class RemoteBitfield {
     if (p) p.set(j, val)
   }
 
-  setRange (start, end, val) {
+  setRange(start, end, val) {
     let j = start & (BITS_PER_PAGE - 1)
     let i = (start - j) / BITS_PER_PAGE
 
@@ -215,7 +215,7 @@ module.exports = class RemoteBitfield {
     }
   }
 
-  findFirst (val, position) {
+  findFirst(val, position) {
     let j = position & (BITS_PER_SEGMENT - 1)
     let i = (position - j) / BITS_PER_SEGMENT
 
@@ -235,20 +235,18 @@ module.exports = class RemoteBitfield {
 
     // For the val === false case, we always return at least
     // the 'position', also if nothing was found
-    return val
-      ? -1
-      : Math.max(position, this._maxSegments * BITS_PER_SEGMENT)
+    return val ? -1 : Math.max(position, this._maxSegments * BITS_PER_SEGMENT)
   }
 
-  firstSet (position) {
+  firstSet(position) {
     return this.findFirst(true, position)
   }
 
-  firstUnset (position) {
+  firstUnset(position) {
     return this.findFirst(false, position)
   }
 
-  findLast (val, position) {
+  findLast(val, position) {
     let j = position & (BITS_PER_SEGMENT - 1)
     let i = (position - j) / BITS_PER_SEGMENT
 
@@ -269,15 +267,15 @@ module.exports = class RemoteBitfield {
     return -1
   }
 
-  lastSet (position) {
+  lastSet(position) {
     return this.findLast(true, position)
   }
 
-  lastUnset (position) {
+  lastUnset(position) {
     return this.findLast(false, position)
   }
 
-  insert (start, bitfield) {
+  insert(start, bitfield) {
     if (start % 32 !== 0) return false
 
     let length = bitfield.byteLength * 8
@@ -311,7 +309,7 @@ module.exports = class RemoteBitfield {
     return true
   }
 
-  clear (start, bitfield) {
+  clear(start, bitfield) {
     if (start % 32 !== 0) return false
 
     let length = bitfield.byteLength * 8