@gmod/cram 4.0.1 → 4.0.4

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 }