@gmod/cram 4.0.3 → 4.0.4

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,
-}

package/src/htscodecs/iostream.ts

@@ -0,0 +1,159 @@
+// @ts-nocheck
+
+/*
+ * Copyright (c) 2019 Genome Research Ltd.
+ * Author(s): James Bonfield
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice,
+ *       this list of conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *
+ *    3. Neither the names Genome Research Ltd and Wellcome Trust Sanger
+ *       Institute nor the names of its contributors may be used to endorse
+ *       or promote products derived from this software without specific
+ *       prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY GENOME RESEARCH LTD AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GENOME RESEARCH
+ * LTD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// Turn a buffer into a fake stream with get / put commands.
+// This enables up to closely match the published pseudocode.
+export default class IOStream {
+  buf: Uint8Array
+  length: number
+  pos: number
+  dataView: DataView
+
+  constructor(buf: Uint8Array, start_pos = 0, size = 0) {
+    if (size !== 0) {
+      this.buf = new Uint8Array(size)
+      this.length = size
+    } else {
+      this.buf = buf
+      this.length = buf.length
+    }
+    this.dataView = new DataView(this.buf.buffer)
+    this.pos = start_pos
+  }
+
+  // ----------
+  // Reading
+  EOF() {
+    return this.pos >= this.length
+  }
+
+  ReadData(len: number) {
+    const A = this.buf.slice(this.pos, this.pos + len)
+    this.pos += len
+    return A
+  }
+
+  ReadByte() {
+    const b = this.buf[this.pos]!
+    this.pos++
+    return b
+  }
+
+  ReadChar() {
+    const b = this.buf[this.pos]!
+    this.pos++
+    return String.fromCharCode(b)
+  }
+
+  ReadUint16() {
+    let i = this.ReadByte()
+    i |= this.ReadByte() << 8
+    return i
+  }
+
+  ReadUint32() {
+    const i = this.dataView.getInt32(this.pos, true)
+    this.pos += 4
+    return i
+  }
+
+  // nul terminated string
+  ReadString() {
+    let s = ''
+    let b: number
+    do {
+      b = this.buf[this.pos++]!
+      if (b) {
+        s += String.fromCharCode(b)
+      }
+    } while (b)
+    return s
+  }
+
+  ReadUint7() {
+    // Variable sized unsigned integers
+    let i = 0
+    let c: number
+    do {
+      c = this.ReadByte()
+      i = (i << 7) | (c & 0x7f)
+    } while (c & 0x80)
+
+    return i
+  }
+
+  ReadITF8() {
+    let i = this.buf[this.pos]!
+    this.pos++
+
+    // process.stderr.write("i="+i+"\n");
+
+    if (i >= 0xf0) {
+      // 1111xxxx => +4 bytes
+      i = (i & 0x0f) << 28
+      i +=
+        (this.buf[this.pos + 0]! << 20) +
+        (this.buf[this.pos + 1]! << 12) +
+        (this.buf[this.pos + 2]! << 4) +
+        (this.buf[this.pos + 3]! >> 4)
+      this.pos += 4
+      // process.stderr.write("  4i="+i+"\n");
+    } else if (i >= 0xe0) {
+      // 1110xxxx => +3 bytes
+      i = (i & 0x0f) << 24
+      i +=
+        (this.buf[this.pos + 0]! << 16) +
+        (this.buf[this.pos + 1]! << 8) +
+        (this.buf[this.pos + 2]! << 0)
+      this.pos += 3
+      // process.stderr.write("  3i="+i+"\n");
+    } else if (i >= 0xc0) {
+      // 110xxxxx => +2 bytes
+      i = (i & 0x1f) << 16
+      i += (this.buf[this.pos + 0]! << 8) + (this.buf[this.pos + 1]! << 0)
+      this.pos += 2
+      // process.stderr.write("  2i="+i+"\n");
+    } else if (i >= 0x80) {
+      // 10xxxxxx => +1 bytes
+      i = (i & 0x3f) << 8
+      i += this.buf[this.pos]!
+      this.pos++
+    } else {
+      // 0xxxxxxx => +0 bytes
+    }
+
+    return i
+  }
+}