hypercore 11.16.1 → 11.17.0

package/lib/audit.js

@@ -3,9 +3,20 @@ const flat = require('flat-tree')
 const b4a = require('b4a')
 const { MerkleTree } = require('./merkle-tree')
 
-module.exports = async function auditCore (core, { tree = true, blocks = true, bitfield = true, dryRun = false } = {}) {
+module.exports = async function auditCore(
+  core,
+  { tree = true, blocks = true, bitfield = true, dryRun = false } = {}
+) {
   const length = core.state.length
-  const stats = { treeNodes: 0, blocks: 0, bits: 0, droppedTreeNodes: 0, droppedBlocks: 0, droppedBits: 0, corrupt: false }
+  const stats = {
+    treeNodes: 0,
+    blocks: 0,
+    bits: 0,
+    droppedTreeNodes: 0,
+    droppedBlocks: 0,
+    droppedBits: 0,
+    corrupt: false
+  }
 
   // audit the tree
   if (tree) {
@@ -113,7 +124,7 @@ module.exports = async function auditCore (core, { tree = true, blocks = true, b
 
         const page = core.bitfield.getBitfield(index)
         if (page.bitfield) tx.putBitfieldPage(page.index, page.bitfield)
-        else tx.deleteBitfieldPage(page.idnex)
+        else tx.deleteBitfieldPage(page.index)
         continue
       }
 
@@ -126,20 +137,20 @@ module.exports = async function auditCore (core, { tree = true, blocks = true, b
   return stats
 }
 
-function isBadBlock (node, block) {
+function isBadBlock(node, block) {
   if (!node) return true
   const hash = crypto.data(block)
   return !b4a.equals(hash, node.hash) || node.size !== block.byteLength
 }
 
-function isBadTree (parent, left, right) {
+function isBadTree(parent, left, right) {
   if (!left && !right) return false
   if (!left || !right) return true
   const hash = crypto.parent(left, right)
-  return !b4a.equals(hash, parent.hash) || parent.size !== (left.size + right.size)
+  return !b4a.equals(hash, parent.hash) || parent.size !== left.size + right.size
 }
 
-function * allBits (bitfield) {
+function* allBits(bitfield) {
   let i = 0
   if (bitfield.get(0)) yield 0
   while (true) {

package/lib/bit-interlude.js

@@ -2,11 +2,11 @@ const b4a = require('b4a')
 const quickbit = require('./compat').quickbit
 
 module.exports = class BitInterlude {
-  constructor () {
+  constructor() {
     this.ranges = []
   }
 
-  contiguousLength (from) {
+  contiguousLength(from) {
     for (const r of this.ranges) {
       if (r.start > from) break
       if (!r.value && r.start <= from) return r.start
@@ -17,7 +17,7 @@ module.exports = class BitInterlude {
     return from
   }
 
-  get (index) {
+  get(index) {
     let start = 0
     let end = this.ranges.length
 
@@ -42,7 +42,7 @@ module.exports = class BitInterlude {
     return false
   }
 
-  setRange (start, end, value) {
+  setRange(start, end, value) {
     if (start === end) return
 
     let r = null
@@ -75,8 +75,18 @@ module.exports = class BitInterlude {
       // we overran but our start is contained in this interval, move start back
       if (start >= r.start && start <= r.end) {
         if (r.value !== value) {
+          r.end = start // Crop current comparison
+
+          // If there's a next range
+          if (this.ranges.length - 1 > i) {
+            const next = this.ranges[i + 1]
+            // If the same, go next
+            if (next.value === value) continue
+            // Else we overlap so update next range
+            if (next.start < end) next.start = end
+          }
+
           this.ranges.splice(++i, 0, { start, end, value })
-          r.end = start
           return
         }
 
@@ -109,7 +119,7 @@ module.exports = class BitInterlude {
     this.ranges.push({ start, end, value })
   }
 
-  flush (tx, bitfield) {
+  flush(tx, bitfield) {
     if (!this.ranges.length) return []
 
     let index = this.ranges[0].start
@@ -159,7 +169,7 @@ module.exports = class BitInterlude {
   }
 }
 
-function mergeRanges (a, b) {
+function mergeRanges(a, b) {
   const ranges = []
   if (a.start < b.start) ranges.push({ start: a.start, end: b.start, value: a.value })
   ranges.push({ start: b.start, end: b.end, value: b.value })

package/lib/bitfield.js

@@ -13,7 +13,7 @@ const PAGES_PER_SEGMENT = BITS_PER_SEGMENT / BITS_PER_PAGE
 const SEGMENT_GROWTH_FACTOR = 4
 
 class BitfieldPage {
-  constructor (index, segment) {
+  constructor(index, segment) {
     this.index = index
     this.offset = index * BYTES_PER_PAGE - segment.offset
     this.bitfield = null
@@ -22,21 +22,21 @@ class BitfieldPage {
     segment.add(this)
   }
 
-  get tree () {
+  get tree() {
     return this.segment.tree
   }
 
-  get (index, dirty) {
+  get(index, dirty) {
     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)
@@ -45,15 +45,15 @@ class BitfieldPage {
     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)
   }
 
-  count (start, length, val) {
+  count(start, length, val) {
     const end = start + length
 
     let i = start
@@ -76,18 +76,18 @@ class BitfieldPage {
 }
 
 class BitfieldSegment {
-  constructor (index, bitfield) {
+  constructor(index, bitfield) {
     this.index = index
     this.offset = index * BYTES_PER_SEGMENT
     this.tree = quickbit.Index.from(bitfield, BYTES_PER_SEGMENT)
     this.pages = new Array(PAGES_PER_SEGMENT)
   }
 
-  get bitfield () {
+  get bitfield() {
     return this.tree.field
   }
 
-  add (page) {
+  add(page) {
     const i = page.index - this.index * PAGES_PER_SEGMENT
     this.pages[i] = page
 
@@ -99,7 +99,7 @@ class BitfieldSegment {
     page.bitfield = this.bitfield.subarray(start, end)
   }
 
-  reallocate (length) {
+  reallocate(length) {
     let target = this.bitfield.length
     while (target < length) target *= SEGMENT_GROWTH_FACTOR
 
@@ -119,7 +119,7 @@ class BitfieldSegment {
     }
   }
 
-  findFirst (val, position) {
+  findFirst(val, position) {
     position = this.tree.skipFirst(!val, position)
 
     let j = position & (BITS_PER_PAGE - 1)
@@ -144,7 +144,7 @@ class BitfieldSegment {
     return -1
   }
 
-  findLast (val, position) {
+  findLast(val, position) {
     position = this.tree.skipLast(!val, position)
 
     let j = position & (BITS_PER_PAGE - 1)
@@ -174,22 +174,18 @@ module.exports = class Bitfield {
   static BITS_PER_PAGE = BITS_PER_PAGE
   static BYTES_PER_PAGE = BYTES_PER_PAGE
 
-  constructor (buffer) {
+  constructor(buffer) {
     this.resumed = !!(buffer && buffer.byteLength >= 0)
 
     this._pages = new BigSparseArray()
     this._segments = new BigSparseArray()
 
     const view = this.resumed
-      ? new Uint32Array(
-        buffer.buffer,
-        buffer.byteOffset,
-        Math.floor(buffer.byteLength / 4)
-      )
+      ? new Uint32Array(buffer.buffer, buffer.byteOffset, Math.floor(buffer.byteLength / 4))
       : new Uint32Array(INITIAL_WORDS_PER_SEGMENT)
 
     for (let i = 0; i < view.length; i += WORDS_PER_SEGMENT) {
-      let bitfield = view.subarray(i, i + (WORDS_PER_SEGMENT))
+      let bitfield = view.subarray(i, i + WORDS_PER_SEGMENT)
       let length = WORDS_PER_SEGMENT
 
       if (i === 0) {
@@ -203,7 +199,7 @@ module.exports = class Bitfield {
         bitfield = copy
       }
 
-      const segment = new BitfieldSegment(i / (WORDS_PER_SEGMENT), bitfield)
+      const segment = new BitfieldSegment(i / WORDS_PER_SEGMENT, bitfield)
       this._segments.set(segment.index, segment)
 
       for (let j = 0; j < bitfield.length; j += WORDS_PER_PAGE) {
@@ -213,11 +209,11 @@ module.exports = class Bitfield {
     }
   }
 
-  static from (bitfield) {
+  static from(bitfield) {
     return new Bitfield(bitfield.toBuffer(bitfield._pages.maxLength * BITS_PER_PAGE))
   }
 
-  toBuffer (length) {
+  toBuffer(length) {
     const pages = Math.ceil(length / BITS_PER_PAGE)
     const buffer = b4a.allocUnsafe(pages * BYTES_PER_PAGE)
 
@@ -241,14 +237,14 @@ module.exports = class Bitfield {
     return buffer
   }
 
-  getBitfield (index) {
+  getBitfield(index) {
     const i = this.getPageIndex(index)
 
     const p = this._pages.get(i)
     return p || null
   }
 
-  merge (bitfield, length) {
+  merge(bitfield, length) {
     let i = 0
 
     while (i < length) {
@@ -265,7 +261,7 @@ module.exports = class Bitfield {
     }
   }
 
-  get (index) {
+  get(index) {
     const j = index & (BITS_PER_PAGE - 1)
     const i = (index - j) / BITS_PER_PAGE
 
@@ -274,16 +270,16 @@ module.exports = class Bitfield {
     return p ? p.get(j) : false
   }
 
-  getPageByteLength () {
+  getPageByteLength() {
     return BYTES_PER_PAGE
   }
 
-  getPageIndex (index) {
+  getPageIndex(index) {
     const j = index & (BITS_PER_PAGE - 1)
     return (index - j) / BITS_PER_PAGE
   }
 
-  getPage (index, create) {
+  getPage(index, create) {
     const i = this.getPageIndex(index)
 
     let p = this._pages.get(i)
@@ -293,14 +289,22 @@ module.exports = class Bitfield {
     if (!create) return null
 
     const k = Math.floor(i / PAGES_PER_SEGMENT)
-    const s = this._segments.get(k) || this._segments.set(k, new BitfieldSegment(k, new Uint32Array(k === 0 ? INITIAL_WORDS_PER_SEGMENT : WORDS_PER_SEGMENT)))
+    const s =
+      this._segments.get(k) ||
+      this._segments.set(
+        k,
+        new BitfieldSegment(
+          k,
+          new Uint32Array(k === 0 ? INITIAL_WORDS_PER_SEGMENT : WORDS_PER_SEGMENT)
+        )
+      )
 
     p = this._pages.set(i, new BitfieldPage(i, s))
 
     return p
   }
 
-  set (index, val) {
+  set(index, val) {
     const j = index & (BITS_PER_PAGE - 1)
     const i = (index - j) / BITS_PER_PAGE
 
@@ -308,7 +312,15 @@ module.exports = class Bitfield {
 
     if (!p && val) {
       const k = Math.floor(i / PAGES_PER_SEGMENT)
-      const s = this._segments.get(k) || this._segments.set(k, new BitfieldSegment(k, new Uint32Array(k === 0 ? INITIAL_WORDS_PER_SEGMENT : WORDS_PER_SEGMENT)))
+      const s =
+        this._segments.get(k) ||
+        this._segments.set(
+          k,
+          new BitfieldSegment(
+            k,
+            new Uint32Array(k === 0 ? INITIAL_WORDS_PER_SEGMENT : WORDS_PER_SEGMENT)
+          )
+        )
 
       p = this._pages.set(i, new BitfieldPage(i, s))
     }
@@ -316,7 +328,7 @@ module.exports = class Bitfield {
     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
 
@@ -325,7 +337,15 @@ module.exports = class Bitfield {
 
       if (!p && val) {
         const k = Math.floor(i / PAGES_PER_SEGMENT)
-        const s = this._segments.get(k) || this._segments.set(k, new BitfieldSegment(k, new Uint32Array(k === 0 ? INITIAL_WORDS_PER_SEGMENT : WORDS_PER_SEGMENT)))
+        const s =
+          this._segments.get(k) ||
+          this._segments.set(
+            k,
+            new BitfieldSegment(
+              k,
+              new Uint32Array(k === 0 ? INITIAL_WORDS_PER_SEGMENT : WORDS_PER_SEGMENT)
+            )
+          )
 
         p = this._pages.set(i, new BitfieldPage(i, s))
       }
@@ -342,7 +362,7 @@ module.exports = class Bitfield {
     }
   }
 
-  findFirst (val, position) {
+  findFirst(val, position) {
     let j = position & (BITS_PER_SEGMENT - 1)
     let i = (position - j) / BITS_PER_SEGMENT
 
@@ -363,15 +383,15 @@ module.exports = class Bitfield {
     return val ? -1 : this._segments.maxLength * 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
 
@@ -392,15 +412,15 @@ module.exports = class Bitfield {
     return -1
   }
 
-  lastSet (position) {
+  lastSet(position) {
     return this.findLast(true, position)
   }
 
-  lastUnset (position) {
+  lastUnset(position) {
     return this.findLast(false, position)
   }
 
-  hasSet (start, length) {
+  hasSet(start, length) {
     const end = start + length
 
     let j = start & (BITS_PER_SEGMENT - 1)
@@ -413,7 +433,7 @@ module.exports = class Bitfield {
 
       if (s) index = s.findFirst(true, j)
 
-      if (index !== -1) return (i * BITS_PER_SEGMENT + index) < end
+      if (index !== -1) return i * BITS_PER_SEGMENT + index < end
 
       j = 0
       i++
@@ -424,7 +444,7 @@ module.exports = class Bitfield {
     return false
   }
 
-  count (start, length, val) {
+  count(start, length, val) {
     let j = start & (BITS_PER_PAGE - 1)
     let i = (start - j) / BITS_PER_PAGE
     let c = 0
@@ -446,15 +466,15 @@ module.exports = class Bitfield {
     return c
   }
 
-  countSet (start, length) {
+  countSet(start, length) {
     return this.count(start, length, true)
   }
 
-  countUnset (start, length) {
+  countUnset(start, length) {
     return this.count(start, length, false)
   }
 
-  * want (start, length) {
+  *want(start, length) {
     const j = start & (BITS_PER_SEGMENT - 1)
     let i = (start - j) / BITS_PER_SEGMENT
 
@@ -477,22 +497,22 @@ module.exports = class Bitfield {
     }
   }
 
-  clear (tx) {
+  clear(tx) {
     return tx.deleteBitfieldPageRange(0, -1)
   }
 
-  onupdate (ranges) {
+  onupdate(ranges) {
     for (const { start, end, value } of ranges) {
       this.setRange(start, end, value)
     }
   }
 
-  static async open (storage, length) {
+  static async open(storage, length) {
     if (length === 0) return new Bitfield(storage, null)
 
     const pages = Math.ceil(length / BITS_PER_PAGE)
     const buffer = b4a.alloc(pages * BYTES_PER_PAGE)
-    const stream = storage.createBitfieldStream()
+    const stream = storage.createBitfieldStream({ lt: pages })
 
     for await (const { index, page } of stream) {
       buffer.set(page, index * BYTES_PER_PAGE)
@@ -502,11 +522,11 @@ module.exports = class Bitfield {
   }
 }
 
-function clamp (n, min, max) {
+function clamp(n, min, max) {
   return Math.min(Math.max(n, min), max)
 }
 
-function ceilTo (n, multiple = 1) {
+function ceilTo(n, multiple = 1) {
   const remainder = n % multiple
   if (remainder === 0) return n
   return n + multiple - remainder

package/lib/caps.js

@@ -21,7 +21,11 @@ exports.DEFAULT_ENCRYPTION = DEFAULT_ENCRYPTION
 
 exports.replicate = function (isInitiator, key, handshakeHash) {
   const out = b4a.allocUnsafe(32)
-  sodium.crypto_generichash_batch(out, [isInitiator ? REPLICATE_INITIATOR : REPLICATE_RESPONDER, key], handshakeHash)
+  sodium.crypto_generichash_batch(
+    out,
+    [isInitiator ? REPLICATE_INITIATOR : REPLICATE_RESPONDER, key],
+    handshakeHash
+  )
   return out
 }
 

package/lib/copy-prologue.js

@@ -11,7 +11,7 @@ const MIN_BATCH_USED = 512 * 1024
 
 module.exports = copyPrologue
 
-async function copyPrologue (src, dst) {
+async function copyPrologue(src, dst) {
   const prologue = dst.header.manifest.prologue
 
   if (src.length < prologue.length || prologue.length === 0) return
@@ -29,7 +29,11 @@ async function copyPrologue (src, dst) {
   let lastPage = -1
   let lastBlock = -1
 
-  for await (const data of src.storage.createBlockStream({ gte: 0, lt: prologue.length, reverse: true })) {
+  for await (const data of src.storage.createBlockStream({
+    gte: 0,
+    lt: prologue.length,
+    reverse: true
+  })) {
     if (walkTree(stack, data.index * 2, batch) === false) {
       throw new Error('Missing block or tree node for ' + data.index)
     }
@@ -44,7 +48,7 @@ async function copyPrologue (src, dst) {
     batch.used += Math.max(data.value.byteLength, 128) // 128 is just a sanity number to avoid mega batches
 
     // always safe to partially flush so we do that ondemand to reduce memory usage...
-    if ((batch.used >= MIN_BATCH_USED && page !== lastPage) || (batch.used >= MAX_BATCH_USED)) {
+    if ((batch.used >= MIN_BATCH_USED && page !== lastPage) || batch.used >= MAX_BATCH_USED) {
       await flushBatch(prologue, src, dst, batch)
     }
 
@@ -57,7 +61,7 @@ async function copyPrologue (src, dst) {
   await flushBatch(prologue, src, dst, batch)
 }
 
-async function flushBatch (prologue, src, dst, batch) {
+async function flushBatch(prologue, src, dst, batch) {
   const nodePromises = []
 
   const srcReader = src.storage.read()
@@ -183,7 +187,7 @@ async function flushBatch (prologue, src, dst, batch) {
   batch.used = 0
 }
 
-function signalReplicator (core, upgraded, start, length) {
+function signalReplicator(core, upgraded, start, length) {
   if (upgraded) {
     core.replicator.cork()
     core.replicator.onhave(start, length, false)
@@ -194,7 +198,7 @@ function signalReplicator (core, upgraded, start, length) {
   }
 }
 
-function prologueToTree (prologue) {
+function prologueToTree(prologue) {
   return {
     fork: 0,
     length: prologue.length,
@@ -203,15 +207,15 @@ function prologueToTree (prologue) {
   }
 }
 
-function getBitfieldPage (index) {
+function getBitfieldPage(index) {
   return Math.floor(index / Bitfield.BITS_PER_PAGE)
 }
 
-function getBitfieldOffset (index) {
+function getBitfieldOffset(index) {
   return index & (Bitfield.BITS_PER_PAGE - 1)
 }
 
-function walkTree (stack, target, batch) {
+function walkTree(stack, target, batch) {
   while (stack.length > 0) {
     const node = stack.pop()
 
@@ -239,4 +243,4 @@ function walkTree (stack, target, batch) {
   return false
 }
 
-function noop () {}
+function noop() {}