@gmod/cram 4.0.3 → 4.0.4

package/src/htscodecs/{arith_gen.js → arith_gen.ts}

@@ -1,3 +1,6 @@
+/* eslint-disable no-var */
+// @ts-nocheck
+
 /*
  * Copyright (c) 2019,2020 Genome Research Ltd.
  * Author(s): James Bonfield
@@ -31,27 +34,12 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const RangeCoder = require('./arith_sh')
-const IOStream = require('./iostream')
-const ByteModel = require('./byte_model')
-const bzip2 = require('bzip2')
+import bzip2 from 'bzip2'
 
-function sum(array) {
-  let sum = 0
-  for (const entry of array) {
-    sum += entry.length
-  }
-  return sum
-}
-function concatUint8Array(args) {
-  const mergedArray = new Uint8Array(sum(args))
-  let offset = 0
-  for (const entry of args) {
-    mergedArray.set(entry, offset)
-    offset += entry.length
-  }
-  return mergedArray
-}
+import RangeCoder from './arith_sh'
+import ByteModel from './byte_model'
+import IOStream from './iostream'
+import { concatUint8Array } from '../util'
 
 const ARITH_ORDER = 1
 const ARITH_EXT = 4
@@ -61,21 +49,26 @@ const ARITH_CAT = 32
 const ARITH_RLE = 64
 const ARITH_PACK = 128
 
-module.exports = class RangeCoderGen {
-  decode(src) {
+export default class RangeCoderGen {
+  stream: IOStream
+  decode(src: Uint8Array) {
     this.stream = new IOStream(src)
     return this.decodeStream(this.stream)
   }
 
-  decodeStream(stream, n_out = 0) {
-    var flags = this.stream.ReadByte()
-    if (!(flags & ARITH_NOSIZE)) n_out = this.stream.ReadUint7()
-    var e_len = n_out
+  decodeStream(stream: IOStream, n_out = 0) {
+    const flags = this.stream.ReadByte()
+    if (!(flags & ARITH_NOSIZE)) {
+      n_out = this.stream.ReadUint7()
+    }
+    let e_len = n_out
 
-    var order = flags & ARITH_ORDER
+    const order = flags & ARITH_ORDER
 
     // 4-way recursion
-    if (flags & ARITH_STRIPE) return this.decodeStripe(this.stream, n_out)
+    if (flags & ARITH_STRIPE) {
+      return this.decodeStripe(this.stream, n_out)
+    }
 
     // Meta data
     if (flags & ARITH_PACK) {
@@ -84,7 +77,9 @@ module.exports = class RangeCoderGen {
     }
 
     // NOP, useful for tiny blocks
-    if (flags & ARITH_CAT) var data = this.decodeCat(this.stream, e_len)
+    if (flags & ARITH_CAT) {
+      var data = this.decodeCat(this.stream, e_len)
+    }
     // Entropy decode
     else if (flags & ARITH_EXT) {
       var data = this.decodeExt(this.stream, e_len)
@@ -99,46 +94,55 @@ module.exports = class RangeCoderGen {
     }
 
     // Transforms
-    if (flags & ARITH_PACK) data = this.decodePack(data, P, n_out)
+    if (flags & ARITH_PACK) {
+      data = this.decodePack(data, P, n_out)
+    }
 
     return data
   }
 
-  //----------------------------------------------------------------------
+  // ----------------------------------------------------------------------
   // Order-0 codec
   decode0(stream, n_out) {
-    var output = new Uint8Array(n_out)
+    const output = new Uint8Array(n_out)
 
-    var max_sym = stream.ReadByte()
-    if (max_sym == 0) max_sym = 256
+    let max_sym = stream.ReadByte()
+    if (max_sym == 0) {
+      max_sym = 256
+    }
 
-    var byte_model = new ByteModel(max_sym)
+    const byte_model = new ByteModel(max_sym)
 
-    var rc = new RangeCoder(stream)
+    const rc = new RangeCoder(stream)
     rc.RangeStartDecode(stream)
 
-    for (var i = 0; i < n_out; i++)
+    for (let i = 0; i < n_out; i++) {
       output[i] = byte_model.ModelDecode(stream, rc)
+    }
 
     return output
   }
 
-  //----------------------------------------------------------------------
+  // ----------------------------------------------------------------------
   // Order-1 codec
 
   decode1(stream, n_out) {
-    var output = new Uint8Array(n_out)
+    const output = new Uint8Array(n_out)
 
-    var max_sym = stream.ReadByte()
-    if (max_sym == 0) max_sym = 256
+    let max_sym = stream.ReadByte()
+    if (max_sym == 0) {
+      max_sym = 256
+    }
 
-    var byte_model = new Array(max_sym)
-    for (var i = 0; i < max_sym; i++) byte_model[i] = new ByteModel(max_sym)
+    const byte_model = new Array(max_sym)
+    for (var i = 0; i < max_sym; i++) {
+      byte_model[i] = new ByteModel(max_sym)
+    }
 
-    var rc = new RangeCoder(stream)
+    const rc = new RangeCoder(stream)
     rc.RangeStartDecode(stream)
 
-    var last = 0
+    let last = 0
     for (var i = 0; i < n_out; i++) {
       output[i] = byte_model[last].ModelDecode(stream, rc)
       last = output[i]
@@ -147,7 +151,7 @@ module.exports = class RangeCoderGen {
     return output
   }
 
-  //----------------------------------------------------------------------
+  // ----------------------------------------------------------------------
   // External codec
   decodeExt(stream, n_out) {
     const bits = bzip2.array(stream.buf.slice(stream.pos))
@@ -164,114 +168,138 @@ module.exports = class RangeCoderGen {
     return concatUint8Array(chunks)
   }
 
-  //----------------------------------------------------------------------
+  // ----------------------------------------------------------------------
   // Order-0 RLE codec
   decodeRLE0(stream, n_out) {
-    var output = new Uint8Array(n_out)
+    const output = new Uint8Array(n_out)
 
-    var max_sym = stream.ReadByte()
-    if (max_sym == 0) max_sym = 256
+    let max_sym = stream.ReadByte()
+    if (max_sym == 0) {
+      max_sym = 256
+    }
 
-    var model_lit = new ByteModel(max_sym)
-    var model_run = new Array(258)
-    for (var i = 0; i <= 257; i++) model_run[i] = new ByteModel(4)
+    const model_lit = new ByteModel(max_sym)
+    const model_run = new Array(258)
+    for (var i = 0; i <= 257; i++) {
+      model_run[i] = new ByteModel(4)
+    }
 
-    var rc = new RangeCoder(stream)
+    const rc = new RangeCoder(stream)
     rc.RangeStartDecode(stream)
 
     var i = 0
     while (i < n_out) {
       output[i] = model_lit.ModelDecode(stream, rc)
-      var part = model_run[output[i]].ModelDecode(stream, rc)
-      var run = part
-      var rctx = 256
+      let part = model_run[output[i]].ModelDecode(stream, rc)
+      let run = part
+      let rctx = 256
       while (part == 3) {
         part = model_run[rctx].ModelDecode(stream, rc)
         rctx = 257
         run += part
       }
-      for (var j = 1; j <= run; j++) output[i + j] = output[i]
+      for (let j = 1; j <= run; j++) {
+        output[i + j] = output[i]
+      }
       i += run + 1
     }
 
     return output
   }
 
-  //----------------------------------------------------------------------
+  // ----------------------------------------------------------------------
   // Order-1 RLE codec
 
   decodeRLE1(stream, n_out) {
-    var output = new Uint8Array(n_out)
+    const output = new Uint8Array(n_out)
 
-    var max_sym = stream.ReadByte()
-    if (max_sym == 0) max_sym = 256
+    let max_sym = stream.ReadByte()
+    if (max_sym == 0) {
+      max_sym = 256
+    }
 
-    var model_lit = new Array(max_sym)
-    for (var i = 0; i < max_sym; i++) model_lit[i] = new ByteModel(max_sym)
+    const model_lit = new Array(max_sym)
+    for (var i = 0; i < max_sym; i++) {
+      model_lit[i] = new ByteModel(max_sym)
+    }
 
-    var model_run = new Array(258)
-    for (var i = 0; i <= 257; i++) model_run[i] = new ByteModel(4)
+    const model_run = new Array(258)
+    for (var i = 0; i <= 257; i++) {
+      model_run[i] = new ByteModel(4)
+    }
 
-    var rc = new RangeCoder(stream)
+    const rc = new RangeCoder(stream)
     rc.RangeStartDecode(stream)
 
-    var last = 0
+    let last = 0
     var i = 0
     while (i < n_out) {
       output[i] = model_lit[last].ModelDecode(stream, rc)
       last = output[i]
-      var part = model_run[output[i]].ModelDecode(stream, rc)
-      var run = part
-      var rctx = 256
+      let part = model_run[output[i]].ModelDecode(stream, rc)
+      let run = part
+      let rctx = 256
       while (part == 3) {
         part = model_run[rctx].ModelDecode(stream, rc)
         rctx = 257
         run += part
       }
-      for (var j = 1; j <= run; j++) output[i + j] = output[i]
+      for (let j = 1; j <= run; j++) {
+        output[i + j] = output[i]
+      }
       i += run + 1
     }
 
     return output
   }
 
-  //----------------------------------------------------------------------
+  // ----------------------------------------------------------------------
   // Pack method
   decodePackMeta(stream) {
     this.nsym = stream.ReadByte()
 
-    var M = new Array(this.nsym)
-    for (var i = 0; i < this.nsym; i++) M[i] = stream.ReadByte()
+    const M = new Array(this.nsym)
+    for (let i = 0; i < this.nsym; i++) {
+      M[i] = stream.ReadByte()
+    }
 
-    var e_len = stream.ReadUint7() // Could be derived data from nsym and n_out
+    const e_len = stream.ReadUint7() // Could be derived data from nsym and n_out
 
     return [M, e_len]
   }
 
   decodePack(data, M, len) {
-    var out = new Uint8Array(len)
+    const out = new Uint8Array(len)
 
     if (this.nsym <= 1) {
       // Constant value
-      for (var i = 0; i < len; i++) out[i] = M[0]
+      for (var i = 0; i < len; i++) {
+        out[i] = M[0]
+      }
     } else if (this.nsym <= 2) {
       // 1 bit per value
       for (var i = 0, j = 0; i < len; i++) {
-        if (i % 8 == 0) var v = data[j++]
+        if (i % 8 == 0) {
+          var v = data[j++]
+        }
         out[i] = M[v & 1]
         v >>= 1
       }
     } else if (this.nsym <= 4) {
       // 2 bits per value
       for (var i = 0, j = 0; i < len; i++) {
-        if (i % 4 == 0) var v = data[j++]
+        if (i % 4 == 0) {
+          var v = data[j++]
+        }
         out[i] = M[v & 3]
         v >>= 2
       }
     } else if (this.nsym <= 16) {
       // 4 bits per value
       for (var i = 0, j = 0; i < len; i++) {
-        if (i % 2 == 0) var v = data[j++]
+        if (i % 2 == 0) {
+          var v = data[j++]
+        }
         out[i] = M[v & 15]
         v >>= 4
       }
@@ -285,14 +313,20 @@ module.exports = class RangeCoderGen {
 
   // Compute M array and return meta-data stream
   packMeta(src) {
-    var stream = new IOStream('', 0, 1024)
+    const stream = new IOStream('', 0, 1024)
 
     // Count symbols
-    var M = new Array(256)
-    for (var i = 0; i < src.length; i++) M[src[i]] = 1
+    const M = new Array(256)
+    for (var i = 0; i < src.length; i++) {
+      M[src[i]] = 1
+    }
 
     // Write Map
-    for (var nsym = 0, i = 0; i < 256; i++) if (M[i]) M[i] = ++nsym // map to 1..N
+    for (var nsym = 0, i = 0; i < 256; i++) {
+      if (M[i]) {
+        M[i] = ++nsym
+      }
+    } // map to 1..N
     stream.WriteByte(nsym)
 
     // FIXME: add check for nsym > 16?
@@ -308,24 +342,26 @@ module.exports = class RangeCoderGen {
   }
 
   decodeStripe(stream, len) {
-    var N = stream.ReadByte()
+    const N = stream.ReadByte()
 
     // Retrieve lengths
-    var clen = new Array(N)
-    var ulen = new Array(N)
-    for (var j = 0; j < N; j++) clen[j] = stream.ReadUint7()
+    const clen = new Array(N)
+    const ulen = new Array(N)
+    for (var j = 0; j < N; j++) {
+      clen[j] = stream.ReadUint7()
+    }
 
     // Decode streams
-    var T = new Array(N)
+    const T = new Array(N)
     for (var j = 0; j < N; j++) {
       ulen[j] = Math.floor(len / N) + (len % N > j)
       T[j] = this.decodeStream(stream, ulen[j])
     }
 
     // Transpose
-    var out = new Uint8Array(len)
+    const out = new Uint8Array(len)
     for (var j = 0; j < N; j++) {
-      for (var i = 0; i < ulen[j]; i++) {
+      for (let i = 0; i < ulen[j]; i++) {
         out[i * N + j] = T[j][i]
       }
     }
@@ -333,11 +369,13 @@ module.exports = class RangeCoderGen {
     return out
   }
 
-  //----------------------------------------------------------------------
+  // ----------------------------------------------------------------------
   // Cat method
   decodeCat(stream, len) {
-    var out = new Uint8Array(len)
-    for (var i = 0; i < len; i++) out[i] = stream.ReadByte()
+    const out = new Uint8Array(len)
+    for (let i = 0; i < len; i++) {
+      out[i] = stream.ReadByte()
+    }
 
     return out
   }

package/src/htscodecs/{arith_sh.js → arith_sh.ts}

@@ -1,3 +1,5 @@
+// @ts-nocheck
+
 /*
  * Copyright (c) 2019 Genome Research Ltd.
  * Author(s): James Bonfield
@@ -39,9 +41,9 @@
 // Arith_sh.js     6.7s decode  (32-bit with carries)
 // Arith.js      317.0s decode  (64-bit no carries); int64 crippling it.
 
-//----------------------------------------------------------------------
+// ----------------------------------------------------------------------
 // Arithmetic (range) coder
-module.exports = class RangeCoder {
+export default class RangeCoder {
   constructor(src) {
     this.low = 0
     this.range = 0xffffffff
@@ -52,23 +54,25 @@ module.exports = class RangeCoder {
   }
 
   RangeStartDecode(src) {
-    for (var i = 0; i < 5; i++) this.code = (this.code << 8) + src.ReadByte()
+    for (let i = 0; i < 5; i++) {
+      this.code = (this.code << 8) + src.ReadByte()
+    }
     this.code &= 0xffffffff
     this.code >>>= 0 // force to be +ve int
   }
 
   RangeGetFrequency(tot_freq) {
     this.range = Math.floor(this.range / tot_freq)
-    //return this.code / this.range;
+    // return this.code / this.range;
     return Math.floor(this.code / this.range)
 
     // Conceptual scenario; return freq only and don't modify range yet
-    //return Math.floor(this.code / (Math.floor(this.range / tot_freq)));
+    // return Math.floor(this.code / (Math.floor(this.range / tot_freq)));
   }
 
   RangeDecode(src, sym_low, sym_freq, tot_freq) {
     // Conceptually we divide range here, but in practice we cached it earlier
-    //this.range = Math.floor(this.range / tot_freq);
+    // this.range = Math.floor(this.range / tot_freq);
 
     this.code -= sym_low * this.range
     this.range *= sym_freq
@@ -111,7 +115,7 @@ module.exports = class RangeCoder {
   }
 
   RangeEncode(dst, sym_low, sym_freq, tot_freq) {
-    var old_low = this.low
+    const old_low = this.low
     this.range = Math.floor(this.range / tot_freq)
     this.low += sym_low * this.range
     this.low >>>= 0 // Truncate to +ve int so we can spot overflow
@@ -121,7 +125,9 @@ module.exports = class RangeCoder {
     // NB: can this.low < old_low occur twice before range < (1<<24)?
     // We claim not, but prove it!
     if (this.low < old_low) {
-      if (this.carry != 0) console.log('ERROR: Multiple carry')
+      if (this.carry != 0) {
+        console.log('ERROR: Multiple carry')
+      }
       this.carry = 1
     }
 
@@ -133,6 +139,8 @@ module.exports = class RangeCoder {
   }
 
   RangeFinishEncode(dst) {
-    for (var i = 0; i < 5; i++) this.RangeShiftLow(dst)
+    for (let i = 0; i < 5; i++) {
+      this.RangeShiftLow(dst)
+    }
   }
 }

package/src/htscodecs/{byte_model.js → byte_model.ts}

@@ -1,3 +1,6 @@
+/* eslint-disable no-var */
+// @ts-nocheck
+
 /*
  * Copyright (c) 2019 Genome Research Ltd.
  * Author(s): James Bonfield
@@ -38,14 +41,14 @@
 const MAX_FREQ = (1 << 16) - 17
 const STEP = 16
 
-module.exports = class ByteModel {
+export default class ByteModel {
   constructor(max_sym = 256) {
     this.total_freq = max_sym
     this.max_sym = max_sym - 1
-    this.S = new Array()
-    this.F = new Array()
+    this.S = []
+    this.F = []
 
-    for (var i = 0; i <= this.max_sym; i++) {
+    for (let i = 0; i <= this.max_sym; i++) {
       this.S[i] = i
       this.F[i] = 1
     }
@@ -53,12 +56,14 @@ module.exports = class ByteModel {
 
   ModelDecode(src, rc) {
     // Find symbol
-    var freq = rc.RangeGetFrequency(this.total_freq)
+    const freq = rc.RangeGetFrequency(this.total_freq)
 
     // Linear scan to find cumulative frequency 'freq'
-    var acc = 0
-    var x = 0
-    while (acc + this.F[x] <= freq) acc += this.F[x++]
+    let acc = 0
+    let x = 0
+    while (acc + this.F[x] <= freq) {
+      acc += this.F[x++]
+    }
 
     //	for (var acc = 0; (acc += this.F[x]) <= freq; x++)
     //	    ;
@@ -70,12 +75,14 @@ module.exports = class ByteModel {
     // Update model
     this.F[x] += STEP
     this.total_freq += STEP
-    if (this.total_freq > MAX_FREQ) this.ModelRenormalise()
+    if (this.total_freq > MAX_FREQ) {
+      this.ModelRenormalise()
+    }
 
     // Keep symbols approximately frequency sorted
-    var sym = this.S[x]
+    const sym = this.S[x]
     if (x > 0 && this.F[x] > this.F[x - 1]) {
-      var tmp = this.F[x]
+      let tmp = this.F[x]
       this.F[x] = this.F[x - 1]
       this.F[x - 1] = tmp
 
@@ -90,7 +97,7 @@ module.exports = class ByteModel {
   ModelRenormalise() {
     // Halve all the frequencies, being careful not to hit zero
     this.total_freq = 0
-    for (var i = 0; i <= this.max_sym; i++) {
+    for (let i = 0; i <= this.max_sym; i++) {
       this.F[i] -= Math.floor(this.F[i] / 2)
       this.total_freq += this.F[i]
     }
@@ -98,8 +105,10 @@ module.exports = class ByteModel {
 
   ModelEncode(dst, rc, sym) {
     // Find cumulative frequency
-    var acc = 0
-    for (var x = 0; this.S[x] != sym; x++) acc += this.F[x]
+    let acc = 0
+    for (var x = 0; this.S[x] != sym; x++) {
+      acc += this.F[x]
+    }
 
     // Encode
     rc.RangeEncode(dst, acc, this.F[x], this.total_freq)
@@ -107,14 +116,15 @@ module.exports = class ByteModel {
     // Update model
     this.F[x] += STEP
     this.total_freq += STEP
-    if (this.total_freq > MAX_FREQ)
+    if (this.total_freq > MAX_FREQ) {
       // FIXME x2
       this.ModelRenormalise()
+    }
 
     // Keep symbols approximately frequency sorted
     var sym = this.S[x]
     if (x > 0 && this.F[x] > this.F[x - 1]) {
-      var tmp = this.F[x]
+      let tmp = this.F[x]
       this.F[x] = this.F[x - 1]
       this.F[x - 1] = tmp