@gmod/cram 4.0.3 → 4.0.5

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

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

@@ -1,3 +1,6 @@
+/* eslint-disable no-var */
+// @ts-nocheck
+
 /*
  * Copyright (c) 2019-2020 Genome Research Ltd.
  * Author(s): James Bonfield
@@ -31,9 +34,9 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const IOStream = require('./iostream')
+import IOStream from './iostream'
 
-//----------------------------------------------------------------------
+// ----------------------------------------------------------------------
 // rANS primitives itself
 //
 // RansGet* is decoder side
@@ -46,17 +49,21 @@ function RansGetSymbolFromFreq(C, f) {
   // NOTE: Inefficient.
   // In practice we would implement this via a precomputed
   // lookup table C2S[f]; see RansBuildC2S below.
-  var s = 0
-  while (f >= C[s + 1]) s++
+  let s = 0
+  while (f >= C[s + 1]) {
+    s++
+  }
 
   return s
 }
 
 function RansBuildC2S(C) {
-  var C2S = new Array(0x1000)
-  var s = 0
-  for (var f = 0; f < 0x1000; f++) {
-    while (f >= C[s + 1]) s++
+  const C2S = new Array(0x1000)
+  let s = 0
+  for (let f = 0; f < 0x1000; f++) {
+    while (f >= C[s + 1]) {
+      s++
+    }
     C2S[f] = s
   }
   return C2S
@@ -67,77 +74,83 @@ function RansAdvanceStep(R, c, f) {
 }
 
 function RansRenorm(src, R) {
-  while (R < 1 << 23) R = (R << 8) + src.ReadByte()
+  while (R < 1 << 23) {
+    R = (R << 8) + src.ReadByte()
+  }
 
   return R
 }
-//----------------------------------------------------------------------
+// ----------------------------------------------------------------------
 // Main rANS entry function: decodes a compressed src and
 // returns the uncompressed buffer.
-function decode(src) {
-  var stream = new IOStream(src)
-  var order = stream.ReadByte()
-  var n_in = stream.ReadUint32()
-  var n_out = stream.ReadUint32()
-
-  if (order == 0) {
-    return RansDecode0(stream, n_out)
-  } else {
-    return RansDecode1(stream, n_out)
-  }
+export function decode(src) {
+  const stream = new IOStream(src)
+  const order = stream.ReadByte()
+  const n_in = stream.ReadUint32()
+  const n_out = stream.ReadUint32()
+
+  return order == 0 ? RansDecode0(stream, n_out) : RansDecode1(stream, n_out)
 }
 
-//----------------------------------------------------------------------
+// ----------------------------------------------------------------------
 // Order-0 decoder
 
 // Decode a single table of order-0 frequences,
 // filling out the F and C arrays.
 function ReadFrequencies0(src, F, C) {
   // Initialise; not in the specification - implicit?
-  for (var i = 0; i < 256; i++) F[i] = 0
+  for (var i = 0; i < 256; i++) {
+    F[i] = 0
+  }
 
-  var sym = src.ReadByte()
-  var last_sym = sym
-  var rle = 0
+  let sym = src.ReadByte()
+  let last_sym = sym
+  let rle = 0
 
   // Read F[]
   do {
-    var f = src.ReadITF8()
+    const f = src.ReadITF8()
     F[sym] = f
     if (rle > 0) {
       rle--
       sym++
     } else {
       sym = src.ReadByte()
-      if (sym == last_sym + 1) rle = src.ReadByte()
+      if (sym == last_sym + 1) {
+        rle = src.ReadByte()
+      }
     }
     last_sym = sym
   } while (sym != 0)
 
   // Compute C[] from F[]
   C[0] = 0
-  for (var i = 0; i <= 255; i++) C[i + 1] = C[i] + F[i]
+  for (var i = 0; i <= 255; i++) {
+    C[i + 1] = C[i] + F[i]
+  }
 }
 
 function RansDecode0(src, nbytes) {
   // Decode frequencies
-  var F = new Array(256)
-  var C = new Array(256)
+  const F = new Array(256)
+  const C = new Array(256)
   ReadFrequencies0(src, F, C)
 
   // Fast lookup to avoid slow RansGetSymbolFromFreq
-  var C2S = RansBuildC2S(C)
+  const C2S = RansBuildC2S(C)
 
   // Initialise rANS state
-  var R = new Array(4)
-  for (var i = 0; i < 4; i++) R[i] = src.ReadUint32()
+  const R = new Array(4)
+  for (var i = 0; i < 4; i++) {
+    R[i] = src.ReadUint32()
+  }
 
   // Main decode loop
-  var output = new Uint8Array(nbytes)
+  const output = new Uint8Array(nbytes)
   for (var i = 0; i < nbytes; i++) {
-    var i4 = i % 4
-    var f = RansGetCumulativeFreq(R[i4])
-    var s = C2S[f] // Equiv to RansGetSymbolFromFreq(C, f);
+    const i4 = i % 4
+    const f = RansGetCumulativeFreq(R[i4])
+    const s = C2S[f] // Equiv to RansGetSymbolFromFreq(C, f);
 
     output[i] = s
     R[i4] = RansAdvanceStep(R[i4], C[s], F[s])
@@ -147,22 +160,24 @@ function RansDecode0(src, nbytes) {
   return output
 }
 
-//----------------------------------------------------------------------
+// ----------------------------------------------------------------------
 // Order-1 decoder
 
 // Decode a table of order-1 frequences,
 // filling out the F and C arrays.
 function ReadFrequencies1(src, F, C) {
   // Initialise; not in the specification - implicit?
-  for (var i = 0; i < 256; i++) {
+  for (let i = 0; i < 256; i++) {
     F[i] = new Array(256)
     C[i] = new Array(256)
-    for (var j = 0; j < 256; j++) F[i][j] = 0
+    for (let j = 0; j < 256; j++) {
+      F[i][j] = 0
+    }
   }
 
-  var sym = src.ReadByte()
-  var last_sym = sym
-  var rle = 0
+  let sym = src.ReadByte()
+  let last_sym = sym
+  let rle = 0
 
   // Read F[]
   do {
@@ -173,7 +188,9 @@ function ReadFrequencies1(src, F, C) {
       sym++
     } else {
       sym = src.ReadByte()
-      if (sym == last_sym + 1) rle = src.ReadByte()
+      if (sym == last_sym + 1) {
+        rle = src.ReadByte()
+      }
     }
     last_sym = sym
   } while (sym != 0)
@@ -181,30 +198,32 @@ function ReadFrequencies1(src, F, C) {
 
 function RansDecode1(src, nbytes) {
   // Decode frequencies
-  var F = new Array(256)
-  var C = new Array(256)
+  const F = new Array(256)
+  const C = new Array(256)
   ReadFrequencies1(src, F, C)
 
   // Fast lookup to avoid slow RansGetSymbolFromFreq
-  var C2S = new Array(256)
-  for (var i = 0; i < 256; i++) C2S[i] = RansBuildC2S(C[i])
+  const C2S = new Array(256)
+  for (var i = 0; i < 256; i++) {
+    C2S[i] = RansBuildC2S(C[i])
+  }
 
   // Initialise rANS state
-  var R = new Array(4)
-  var L = new Array(4)
+  const R = new Array(4)
+  const L = new Array(4)
   for (var j = 0; j < 4; j++) {
     R[j] = src.ReadUint32()
     L[j] = 0
   }
 
   // Main decode loop
-  var output = new Uint8Array(nbytes)
-  var nbytes4 = Math.floor(nbytes / 4)
+  const output = new Uint8Array(nbytes)
+  const nbytes4 = Math.floor(nbytes / 4)
   for (var i = 0; i < nbytes4; i++) {
     for (var j = 0; j < 4; j++) {
       var f = RansGetCumulativeFreq(R[j])
 
-      //var s = RansGetSymbolFromFreq(C[L[j]], f);
+      // var s = RansGetSymbolFromFreq(C[L[j]], f);
       var s = C2S[L[j]][f] // Precomputed version of above
 
       output[i + j * nbytes4] = s
@@ -229,5 +248,3 @@ function RansDecode1(src, nbytes) {
 
   return output
 }
-
-module.exports = { decode }