@gmod/cram 4.0.3 → 4.0.5

package/src/cramFile/util.ts

@@ -1,7 +1,10 @@
-import Long from 'long'
 import md5 from 'md5'
 
-import { CramBufferOverrunError } from './codecs/getBits'
+export const TWO_PWR_16_DBL = 1 << 16
+export const TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL
+export const TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL
+export const TWO_PWR_24_DBL = 1 << 24
+export const TWO_PWR_56_DBL = TWO_PWR_24_DBL * TWO_PWR_32_DBL
 
 export function itf8Size(v: number) {
   if (!(v & ~0x7f)) {
@@ -23,124 +26,144 @@ export function parseItf8(buffer: Uint8Array, initialOffset: number) {
   let offset = initialOffset
   const countFlags = buffer[offset]!
   let result: number
+
+  // Single byte value (0xxxxxxx)
   if (countFlags < 0x80) {
     result = countFlags
-    offset = offset + 1
-  } else if (countFlags < 0xc0) {
-    result = ((countFlags << 8) | buffer[offset + 1]!) & 0x3fff
-    offset = offset + 2
-  } else if (countFlags < 0xe0) {
+    offset += 1
+  }
+  // Two byte value (10xxxxxx)
+  else if (countFlags < 0xc0) {
+    result = ((countFlags & 0x3f) << 8) | buffer[offset + 1]!
+    offset += 2
+  }
+  // Three byte value (110xxxxx)
+  else if (countFlags < 0xe0) {
     result =
-      ((countFlags << 16) | (buffer[offset + 1]! << 8) | buffer[offset + 2]!) &
-      0x1fffff
-    offset = offset + 3
-  } else if (countFlags < 0xf0) {
+      ((countFlags & 0x1f) << 16) |
+      (buffer[offset + 1]! << 8) |
+      buffer[offset + 2]!
+    offset += 3
+  }
+  // Four byte value (1110xxxx)
+  else if (countFlags < 0xf0) {
     result =
-      ((countFlags << 24) |
-        (buffer[offset + 1]! << 16) |
-        (buffer[offset + 2]! << 8) |
-        buffer[offset + 3]!) &
-      0x0fffffff
-    offset = offset + 4
-  } else {
+      ((countFlags & 0x0f) << 24) |
+      (buffer[offset + 1]! << 16) |
+      (buffer[offset + 2]! << 8) |
+      buffer[offset + 3]!
+    offset += 4
+  }
+  // Five byte value (11110xxx)
+  else {
     result =
       ((countFlags & 0x0f) << 28) |
       (buffer[offset + 1]! << 20) |
       (buffer[offset + 2]! << 12) |
       (buffer[offset + 3]! << 4) |
       (buffer[offset + 4]! & 0x0f)
-    // x=((0xff & 0x0f)<<28) | (0xff<<20) | (0xff<<12) | (0xff<<4) | (0x0f & 0x0f);
-    // TODO *val_p = uv < 0x80000000UL ? uv : -((int32_t) (0xffffffffUL - uv)) - 1;
-    offset = offset + 5
-  }
-  if (offset > buffer.length) {
-    throw new CramBufferOverrunError(
-      'Attempted to read beyond end of buffer; this file seems truncated.',
-    )
+    offset += 5
   }
+
   return [result, offset - initialOffset] as const
 }
 
 export function parseLtf8(buffer: Uint8Array, initialOffset: number) {
-  const dataView = new DataView(buffer.buffer)
   let offset = initialOffset
   const countFlags = buffer[offset]!
-  let n: number | Long
+  let value: number
+
+  // Single byte value < 0x80
   if (countFlags < 0x80) {
-    n = countFlags
+    value = countFlags
     offset += 1
-  } else if (countFlags < 0xc0) {
-    n = ((buffer[offset]! << 8) | buffer[offset + 1]!) & 0x3fff
+  }
+  // Two byte value < 0xC0
+  else if (countFlags < 0xc0) {
+    value = ((countFlags << 8) | buffer[offset + 1]!) & 0x3fff
     offset += 2
-  } else if (countFlags < 0xe0) {
-    n =
-      ((buffer[offset]! << 16) |
-        (buffer[offset + 1]! << 8) |
-        buffer[offset + 2]!) &
-      0x1fffff
-    n = ((countFlags & 63) << 16) | dataView.getUint16(offset + 1, true)
+  }
+  // Three byte value < 0xE0
+  else if (countFlags < 0xe0) {
+    value =
+      ((countFlags & 0x3f) << 16) |
+      (buffer[offset + 1]! << 8) |
+      buffer[offset + 2]!
     offset += 3
-  } else if (countFlags < 0xf0) {
-    n =
-      ((buffer[offset]! << 24) |
-        (buffer[offset + 1]! << 16) |
-        (buffer[offset + 2]! << 8) |
-        buffer[offset + 3]!) &
-      0x0fffffff
+  }
+  // Four byte value < 0xF0
+  else if (countFlags < 0xf0) {
+    value =
+      ((countFlags & 0x1f) << 24) |
+      (buffer[offset + 1]! << 16) |
+      (buffer[offset + 2]! << 8) |
+      buffer[offset + 3]!
     offset += 4
-  } else if (countFlags < 0xf8) {
-    n =
-      ((buffer[offset]! & 15) * 2 ** 32 + (buffer[offset + 1]! << 24)) |
-      ((buffer[offset + 2]! << 16) |
+  }
+  // Five byte value < 0xF8
+  else if (countFlags < 0xf8) {
+    value =
+      (buffer[offset]! & 0x0f) * TWO_PWR_32_DBL +
+      ((buffer[offset + 1]! << 24) |
+        (buffer[offset + 2]! << 16) |
         (buffer[offset + 3]! << 8) |
         buffer[offset + 4]!)
-    // TODO *val_p = uv < 0x80000000UL ? uv : -((int32_t) (0xffffffffUL - uv)) - 1;
     offset += 5
-  } else if (countFlags < 0xfc) {
-    n =
-      ((((buffer[offset]! & 7) << 8) | buffer[offset + 1]!) * 2 ** 32 +
-        (buffer[offset + 2]! << 24)) |
-      ((buffer[offset + 3]! << 16) |
+  }
+  // Six byte value < 0xFC
+  else if (countFlags < 0xfc) {
+    value =
+      (((buffer[offset]! & 0x07) << 8) | buffer[offset + 1]!) * TWO_PWR_32_DBL +
+      ((buffer[offset + 2]! << 24) |
+        (buffer[offset + 3]! << 16) |
         (buffer[offset + 4]! << 8) |
         buffer[offset + 5]!)
     offset += 6
-  } else if (countFlags < 0xfe) {
-    n =
-      ((((buffer[offset]! & 3) << 16) |
+  }
+  // Seven byte value < 0xFE
+  else if (countFlags < 0xfe) {
+    value =
+      (((buffer[offset]! & 0x03) << 16) |
         (buffer[offset + 1]! << 8) |
         buffer[offset + 2]!) *
-        2 ** 32 +
-        (buffer[offset + 3]! << 24)) |
-      ((buffer[offset + 4]! << 16) |
+        TWO_PWR_32_DBL +
+      ((buffer[offset + 3]! << 24) |
+        (buffer[offset + 4]! << 16) |
         (buffer[offset + 5]! << 8) |
         buffer[offset + 6]!)
     offset += 7
-  } else if (countFlags < 0xff) {
-    n = Long.fromBytesBE(
-      buffer.slice(offset + 1, offset + 8) as unknown as number[],
-    )
-    if (
-      n.greaterThan(Number.MAX_SAFE_INTEGER) ||
-      n.lessThan(Number.MIN_SAFE_INTEGER)
-    ) {
-      throw new Error('integer overflow')
-    }
-    n = n.toNumber()
+  }
+  // Eight byte value < 0xFF
+  else if (countFlags < 0xff) {
+    value =
+      ((buffer[offset + 1]! << 24) |
+        (buffer[offset + 2]! << 16) |
+        (buffer[offset + 3]! << 8) |
+        buffer[offset + 4]!) *
+        TWO_PWR_32_DBL +
+      ((buffer[offset + 5]! << 24) |
+        (buffer[offset + 6]! << 16) |
+        (buffer[offset + 7]! << 8) |
+        buffer[offset + 8]!)
     offset += 8
-  } else {
-    n = Long.fromBytesBE(
-      buffer.slice(offset + 1, offset + 9) as unknown as number[],
-    )
-    if (
-      n.greaterThan(Number.MAX_SAFE_INTEGER) ||
-      n.lessThan(Number.MIN_SAFE_INTEGER)
-    ) {
-      throw new Error('integer overflow')
-    }
-    n = n.toNumber()
+  }
+  // Nine byte value
+  else {
+    value =
+      buffer[offset + 1]! * TWO_PWR_56_DBL +
+      ((buffer[offset + 2]! << 24) |
+        (buffer[offset + 3]! << 16) |
+        (buffer[offset + 4]! << 8) |
+        buffer[offset + 5]!) *
+        TWO_PWR_32_DBL +
+      ((buffer[offset + 6]! << 24) |
+        (buffer[offset + 7]! << 16) |
+        (buffer[offset + 8]! << 8) |
+        buffer[offset + 9]!)
     offset += 9
   }
-  return [n, offset - initialOffset] as const
+
+  return [value, offset - initialOffset] as const
 }
 
 export function parseItem<T>(
@@ -156,11 +179,6 @@ export function parseItem<T>(
     _size: offset - startBufferPosition,
   }
 }
-
-// this would be nice as a decorator, but i'm a little worried about babel
-// support for it going away or changing. memoizes a method in the stupidest
-// possible way, with no regard for the arguments.  actually, this only works
-// on methods that take no arguments
 export function tinyMemoize(_class: any, methodName: any) {
   const method = _class.prototype[methodName]
   const memoAttrName = `_memo_${methodName}`
@@ -179,20 +197,3 @@ export function tinyMemoize(_class: any, methodName: any) {
 export function sequenceMD5(seq: string) {
   return md5(seq.toUpperCase().replaceAll(/[^\u0021-\u007e]/g, ''))
 }
-
-export function sum(array: Uint8Array[]) {
-  let sum = 0
-  for (const entry of array) {
-    sum += entry.length
-  }
-  return sum
-}
-export function concatUint8Array(args: Uint8Array[]) {
-  const mergedArray = new Uint8Array(sum(args))
-  let offset = 0
-  for (const entry of args) {
-    mergedArray.set(entry, offset)
-    offset += entry.length
-  }
-  return mergedArray
-}

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
   }