@gmod/cram 4.0.3 → 4.0.5

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
 

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

@@ -1,3 +1,6 @@
+/* eslint-disable no-var */
+// @ts-nocheck
+
 /*
  * Copyright (c) 2019 Genome Research Ltd.
  * Author(s): James Bonfield
@@ -31,46 +34,50 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const IOStream = require('./iostream')
-const ByteModel = require('./byte_model')
-const RangeCoder = require('./arith_sh')
+import RangeCoder from './arith_sh'
+import ByteModel from './byte_model'
+import IOStream from './iostream'
 
-//----------------------------------------------------------------------
+// ----------------------------------------------------------------------
 // Main arithmetic entry function: decodes a compressed src and
 // returns the uncompressed buffer.
 
 function read_array(src, tab, size) {
-  var j = 0 // array value
-  var z = 0 // array index: tab[j]
-  var last = -1
+  let j = 0 // array value
+  let z = 0 // array index: tab[j]
+  let last = -1
 
   // Remove first level of run-length encoding
-  var R = new Array(1024) // runs
+  const R = new Array(1024) // runs
   while (z < size) {
-    var run = src.ReadByte()
+    const run = src.ReadByte()
     R[j++] = run
     z += run
 
     if (run == last) {
-      var copy = src.ReadByte()
+      let copy = src.ReadByte()
       z += run * copy
-      while (copy--) R[j++] = run
+      while (copy--) {
+        R[j++] = run
+      }
     }
     last = run
   }
 
   // Now expand runs in R to tab, noting 255 is max run
-  var i = 0
+  let i = 0
   j = 0
   z = 0
   while (z < size) {
-    var run_len = 0
+    let run_len = 0
     do {
       var part = R[j++]
       run_len += part
     } while (part == 255)
 
-    while (run_len--) tab[z++] = i
+    while (run_len--) {
+      tab[z++] = i
+    }
     i++
   }
 }
@@ -91,11 +98,13 @@ const GFLAG_DO_REV = 4
 
 // Compute a new context from our current state and qual q
 function fqz_update_ctx(params, state, q) {
-  var last = params.context
+  let last = params.context
   state.qctx = (state.qctx << params.qshift) + params.qtab[q] // >>> 0
   last += (state.qctx & ((1 << params.qbits) - 1)) << params.qloc // >>> 0
 
-  if (params.do_pos) last += params.ptab[Math.min(state.p, 1023)] << params.ploc
+  if (params.do_pos) {
+    last += params.ptab[Math.min(state.p, 1023)] << params.ploc
+  }
 
   if (params.do_delta) {
     last += params.dtab[Math.min(state.delta, 255)] << params.dloc
@@ -106,7 +115,9 @@ function fqz_update_ctx(params, state, q) {
     state.prevq = q
   }
 
-  if (params.do_sel) last += state.s << params.sloc
+  if (params.do_sel) {
+    last += state.s << params.sloc
+  }
 
   state.p--
 
@@ -114,7 +125,7 @@ function fqz_update_ctx(params, state, q) {
 }
 
 function decode_fqz_single_param(src) {
-  var p = {} // params
+  const p = {} // params
 
   // Load FQZ parameters
   p.context = src.ReadUint16()
@@ -130,7 +141,7 @@ function decode_fqz_single_param(src) {
 
   p.max_sym = src.ReadByte()
 
-  var x = src.ReadByte()
+  let x = src.ReadByte()
   p.qbits = x >> 4
   p.qshift = x & 15
   x = src.ReadByte()
@@ -143,10 +154,14 @@ function decode_fqz_single_param(src) {
   // Qual map, eg to "unbin" Illumina qualities
   p.qmap = new Array(256)
   if (p.pflags & FLAG_QMAP) {
-    for (var i = 0; i < p.max_sym; i++) p.qmap[i] = src.ReadByte()
+    for (var i = 0; i < p.max_sym; i++) {
+      p.qmap[i] = src.ReadByte()
+    }
   } else {
     // Useful optimisation to speed up main loop
-    for (var i = 0; i < 256; i++) p.qmap[i] = i // NOP
+    for (var i = 0; i < 256; i++) {
+      p.qmap[i] = i
+    } // NOP
   }
 
   // Read tables
@@ -155,70 +170,86 @@ function decode_fqz_single_param(src) {
     read_array(src, p.qtab, 256)
   } else {
     // Useful optimisation to speed up main loop
-    for (var i = 0; i < 256; i++) p.qtab[i] = i // NOP
+    for (var i = 0; i < 256; i++) {
+      p.qtab[i] = i
+    } // NOP
   }
 
   p.ptab = new Array(1024)
-  if (p.pflags & FLAG_PTAB) read_array(src, p.ptab, 1024)
+  if (p.pflags & FLAG_PTAB) {
+    read_array(src, p.ptab, 1024)
+  }
 
   p.dtab = new Array(256)
-  if (p.pflags & FLAG_DTAB) read_array(src, p.dtab, 256)
+  if (p.pflags & FLAG_DTAB) {
+    read_array(src, p.dtab, 256)
+  }
 
   return p
 }
 
 function decode_fqz_params(src) {
-  var gparams = {
+  const gparams = {
     max_sym: 0,
   }
 
   // Check fqz format version
-  var vers = src.ReadByte()
+  const vers = src.ReadByte()
   if (vers != 5) {
     console.error('Invalid FQZComp version number')
     return
   }
 
-  var gflags = src.ReadByte()
-  var nparam = gflags & GFLAG_MULTI_PARAM ? src.ReadByte() : 1
-  var max_sel = gflags.nparam > 1 ? gflags.nparam - 1 : 0 // Note max_sel, not num_sel
+  const gflags = src.ReadByte()
+  const nparam = gflags & GFLAG_MULTI_PARAM ? src.ReadByte() : 1
+  let max_sel = gflags.nparam > 1 ? gflags.nparam - 1 : 0 // Note max_sel, not num_sel
 
-  var stab = new Array(256)
+  const stab = new Array(256)
   if (gflags & GFLAG_HAVE_STAB) {
     max_sel = src.ReadByte()
     read_array(src, stab, 256)
   } else {
-    for (var i = 0; i < nparam; i++) stab[i] = i
-    for (; i < 256; i++) stab[i] = nparam - 1
+    for (var i = 0; i < nparam; i++) {
+      stab[i] = i
+    }
+    for (; i < 256; i++) {
+      stab[i] = nparam - 1
+    }
   }
   gparams.do_rev = gflags & GFLAG_DO_REV
   gparams.stab = stab
   gparams.max_sel = max_sel
 
   gparams.params = new Array(gparams.nparam)
-  for (var p = 0; p < nparam; p++) {
+  for (let p = 0; p < nparam; p++) {
     gparams.params[p] = decode_fqz_single_param(src)
-    if (gparams.max_sym < gparams.params[p].max_sym)
+    if (gparams.max_sym < gparams.params[p].max_sym) {
       gparams.max_sym = gparams.params[p].max_sym
+    }
   }
 
   return gparams
 }
 
 function fqz_create_models(gparams) {
-  var model = {}
+  const model = {}
 
   model.qual = new Array(1 << 16)
-  for (var i = 0; i < 1 << 16; i++)
-    model.qual[i] = new ByteModel(gparams.max_sym + 1) // +1 as max value not num. values
+  for (var i = 0; i < 1 << 16; i++) {
+    model.qual[i] = new ByteModel(gparams.max_sym + 1)
+  } // +1 as max value not num. values
 
   model.len = new Array(4)
-  for (var i = 0; i < 4; i++) model.len[i] = new ByteModel(256)
+  for (var i = 0; i < 4; i++) {
+    model.len[i] = new ByteModel(256)
+  }
 
   model.rev = new ByteModel(2)
   model.dup = new ByteModel(2)
 
-  if (gparams.max_sel > 0) model.sel = new ByteModel(gparams.max_sel + 1) // +1 as max value not num. values
+  if (gparams.max_sel > 0) {
+    model.sel = new ByteModel(gparams.max_sel + 1)
+  } // +1 as max value not num. values
 
   return model
 }
@@ -227,14 +258,10 @@ function fqz_create_models(gparams) {
 // Returns 1 if dup, otherwise 0
 function decode_fqz_new_record(src, rc, gparams, model, state, rev) {
   // Parameter selector
-  if (gparams.max_sel > 0) {
-    state.s = model.sel.ModelDecode(src, rc)
-  } else {
-    state.s = 0
-  }
+  state.s = gparams.max_sel > 0 ? model.sel.ModelDecode(src, rc) : 0
   state.x = gparams.stab[state.s]
 
-  var params = gparams.params[state.x]
+  const params = gparams.params[state.x]
 
   // Reset contexts at the start of each new record
   if (params.fixed_len >= 0) {
@@ -243,17 +270,23 @@ function decode_fqz_new_record(src, rc, gparams, model, state, rev) {
     len |= model.len[1].ModelDecode(src, rc) << 8
     len |= model.len[2].ModelDecode(src, rc) << 16
     len |= model.len[3].ModelDecode(src, rc) << 24
-    if (params.fixed_len > 0) params.fixed_len = -len
+    if (params.fixed_len > 0) {
+      params.fixed_len = -len
+    }
   } else {
     len = -params.fixed_len
   }
   state.len = len
 
-  if (gparams.do_rev) rev[state.rec] = model.rev.ModelDecode(src, rc)
+  if (gparams.do_rev) {
+    rev[state.rec] = model.rev.ModelDecode(src, rc)
+  }
 
   state.is_dup = 0
   if (params.pflags & FLAG_DEDUP) {
-    if (model.dup.ModelDecode(src, rc)) state.is_dup = 1
+    if (model.dup.ModelDecode(src, rc)) {
+      state.is_dup = 1
+    }
   }
 
   state.p = len // number of remaining bytes in this record
@@ -263,24 +296,26 @@ function decode_fqz_new_record(src, rc, gparams, model, state, rev) {
   state.rec++
 }
 
-function decode_fqz(src, q_lens) {
+function decode_fqz(src: IOStream, q_lens: number) {
   // Decode parameter block
-  var n_out = src.ReadUint7()
-  var gparams = decode_fqz_params(src)
-  if (!gparams) return
+  const n_out = src.ReadUint7()
+  const gparams = decode_fqz_params(src)
+  if (!gparams) {
+    return
+  }
   var params = gparams.params
-  var rev = new Array(q_lens.length)
+  const rev = new Array(q_lens.length)
 
   // Create initial models
-  var model = fqz_create_models(gparams)
+  const model = fqz_create_models(gparams)
 
   // Create our entropy encoder and output buffers
-  var rc = new RangeCoder(src)
+  const rc = new RangeCoder(src)
   rc.RangeStartDecode(src)
-  var output = new Uint8Array(n_out)
+  const output = new Uint8Array(n_out)
 
   // Internal FQZ state
-  var state = {
+  const state = {
     qctx: 0, // Qual-only sub-context
     prevq: 0, // Previous quality value
     delta: 0, // Running delta (q vs prevq)
@@ -293,15 +328,16 @@ function decode_fqz(src, q_lens) {
   }
 
   // The main decode loop itself
-  var i = 0 // position in output buffer
+  let i = 0 // position in output buffer
   while (i < n_out) {
     if (state.p == 0) {
       decode_fqz_new_record(src, rc, gparams, model, state, rev)
       if (state.is_dup > 0) {
         if (model.dup.ModelDecode(src, rc)) {
           // Duplicate of last line
-          for (var x = 0; x < len; x++)
+          for (let x = 0; x < len; x++) {
             output[i + x] = output[i + x - state.len]
+          }
           i += state.len
           state.p = 0
           continue
@@ -314,30 +350,32 @@ function decode_fqz(src, q_lens) {
     }
 
     // Decode the current quality (possibly mapped via qmap)
-    var Q = model.qual[last].ModelDecode(src, rc)
+    const Q = model.qual[last].ModelDecode(src, rc)
 
-    //if (params.do_qmap)
+    // if (params.do_qmap)
     //    output[i++] = params.qmap[Q];
-    //else
+    // else
     //    output[i++] = Q
     output[i++] = params.qmap[Q] // optimised version of above
     last = fqz_update_ctx(params, state, Q)
   }
 
-  if (gparams.do_rev) reverse_qualities(output, n_out, rev, q_lens)
+  if (gparams.do_rev) {
+    reverse_qualities(output, n_out, rev, q_lens)
+  }
 
   return output
 }
 
 function reverse_qualities(qual, qual_len, rev, len) {
-  var rec = 0
-  var i = 0
+  let rec = 0
+  let i = 0
   while (i < qual_len) {
     if (rev[rec]) {
-      var j = 0
-      var k = len[rec] - 1
+      let j = 0
+      let k = len[rec] - 1
       while (j < k) {
-        var tmp = qual[i + j]
+        const tmp = qual[i + j]
         qual[i + j] = qual[i + k]
         qual[i + k] = tmp
         j++
@@ -349,12 +387,8 @@ function reverse_qualities(qual, qual_len, rev, len) {
   }
 }
 
-function decode(src, q_lens) {
-  var stream = new IOStream(src)
-
-  //var n_out = stream.ReadUint32(); stream.ReadUint32(); // move to main
+export function decode(src: Uint8Array, q_lens) {
+  const stream = new IOStream(src)
 
   return decode_fqz(stream, q_lens)
 }
-
-module.exports = { decode }

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

@@ -1,3 +1,5 @@
+// @ts-nocheck
+//
 /*
  * Copyright (c) 2020 Genome Research Ltd.
  * Author(s): James Bonfield
@@ -37,41 +39,33 @@
 // This JavaScript file is not part of the reference implementation
 // and is simply and interface to get a consistent interface for cram-js.
 
-var r4x8 = require('./rans')
-var r4x16 = require('./rans4x16')
-var arith = require('./arith_gen')
-var fqzcomp = require('./fqzcomp')
-var tok3 = require('./tok3')
+import arith from './arith_gen'
+import * as fqzcomp from './fqzcomp'
+import * as r4x8 from './rans'
+import * as r4x16 from './rans4x16'
+import * as tok3 from './tok3'
 
-function r4x8_uncompress(inputBuffer, outputBuffer) {
+export function r4x8_uncompress(inputBuffer: Uint8Array) {
   return r4x8.decode(inputBuffer)
 }
 
-function r4x16_uncompress(inputBuffer) {
+export function r4x16_uncompress(inputBuffer: Uint8Array) {
   return r4x16.decode(inputBuffer)
 }
 
-function arith_uncompress(inputBuffer) {
+export function arith_uncompress(inputBuffer: Uint8Array) {
   // fix by @cmdcolin for CRAM 3.1
   // xref https://github.com/jkbonfield/htscodecs/pull/1/files
   return new arith().decode(inputBuffer)
 }
 
-function fqzcomp_uncompress(inputBuffer) {
-  var q_lens = new Array()
+export function fqzcomp_uncompress(inputBuffer: Uint8Array) {
+  const q_lens = []
   return fqzcomp.decode(inputBuffer, q_lens)
 }
 
-function tok3_uncompress(inputBuffer) {
+export function tok3_uncompress(inputBuffer: Uint8Array) {
   // Returns in string form instead of buffer
-  var out = tok3.decode(inputBuffer, 0, '\0')
+  const out = tok3.decode(inputBuffer, 0, '\0')
   return Uint8Array.from(Array.from(out).map(letter => letter.charCodeAt(0)))
 }
-
-module.exports = {
-  r4x8_uncompress: r4x8_uncompress,
-  r4x16_uncompress: r4x16_uncompress,
-  arith_uncompress: arith_uncompress,
-  fqzcomp_uncompress: fqzcomp_uncompress,
-  tok3_uncompress: tok3_uncompress,
-}