@gmod/cram 2.0.4 → 3.0.1

package/src/cramFile/slice/decodeRecord.ts

@@ -74,7 +74,7 @@ function parseTagValueArray(buffer: Buffer) {
       array[i] = arr[i]
     }
   } else {
-    throw new Error('unknown type: ' + arrayType)
+    throw new Error(`unknown type: ${arrayType}`)
   }
 
   return array
@@ -249,20 +249,27 @@ export default function decodeRecord(
   cursors.lastAlignmentStart = alignmentStart
   const readGroupId = decodeDataSeries('RG')
 
-  let readName
+  let readName: string | undefined
   if (compressionScheme.readNamesIncluded) {
     readName = readNullTerminatedString(decodeDataSeries('RN'))
   }
 
-  let mateToUse
-  let templateSize
-  let mateRecordNumber
+  let mateToUse:
+    | {
+        mateFlags: number
+        mateSequenceId: number
+        mateAlignmentStart: number
+        mateReadName: string | undefined
+      }
+    | undefined
+  let templateSize: number | undefined
+  let mateRecordNumber: number | undefined
   // mate record
   if (CramFlagsDecoder.isDetached(cramFlags)) {
-    // note: the MF is a byte in 1.0, int32 in 2+, but once again this doesn't matter for javascript
-    // const mate: any = {}
+    // note: the MF is a byte in 1.0, int32 in 2+, but once again this doesn't
+    // matter for javascript
     const mateFlags = decodeDataSeries('MF')
-    let mateReadName
+    let mateReadName: string | undefined
     if (!compressionScheme.readNamesIncluded) {
       mateReadName = readNullTerminatedString(decodeDataSeries('RN'))
       readName = mateReadName
@@ -327,9 +334,9 @@ export default function decodeRecord(
     tags[tagName] = parseTagData(tagType, tagData)
   }
 
-  let readFeatures
-  let lengthOnRef
-  let mappingQuality
+  let readFeatures: ReadFeature[] | undefined
+  let lengthOnRef: number | undefined
+  let mappingQuality: number | undefined
   let qualityScores: number[] | undefined | null
   let readBases = undefined
   if (!BamFlagsDecoder.isSegmentUnmapped(flags)) {
@@ -345,7 +352,8 @@ export default function decodeRecord(
       )
     }
 
-    // compute the read's true span on the reference sequence, and the end coordinate of the alignment on the reference
+    // compute the read's true span on the reference sequence, and the end
+    // coordinate of the alignment on the reference
     lengthOnRef = readLength
     if (readFeatures) {
       for (const { code, data } of readFeatures) {

package/src/cramFile/slice/index.ts

@@ -7,6 +7,7 @@ import CramRecord from '../record'
 import CramContainer from '../container'
 import CramFile, { CramFileBlock } from '../file'
 import {
+  getSectionParsers,
   isMappedSliceHeader,
   MappedSliceHeader,
   UnmappedSliceHeader,
@@ -176,7 +177,7 @@ function associateIntraSliceMate(
 
   // delete this last because it's used by the
   // complicated template length estimation
-  delete thisRecord.mateRecordNumber
+  thisRecord.mateRecordNumber = undefined
 }
 
 export default class CramSlice {
@@ -191,10 +192,15 @@ export default class CramSlice {
   }
 
   // memoize
-  async getHeader(): Promise<SliceHeader> {
+  async getHeader() {
     // fetch and parse the slice header
-    const sectionParsers = await this.file.getSectionParsers()
+    const { majorVersion } = await this.file.getDefinition()
+    const sectionParsers = getSectionParsers(majorVersion)
     const containerHeader = await this.container.getHeader()
+    if (!containerHeader) {
+      throw new Error('no container header detected')
+    }
+
     const header = await this.file.readBlock(
       containerHeader._endPosition + this.containerPosition,
     )
@@ -230,7 +236,7 @@ export default class CramSlice {
     // read all the blocks into memory and store them
     let blockPosition = header._endPosition
     const blocks: CramFileBlock[] = new Array(header.parsedContent.numBlocks)
-    for (let i = 0; i < blocks.length; i += 1) {
+    for (let i = 0; i < blocks.length; i++) {
       const block = await this.file.readBlock(blockPosition)
       if (block === undefined) {
         throw new Error('block undefined')
@@ -363,14 +369,14 @@ export default class CramSlice {
       this.file.options.checkSequenceMD5 &&
       isMappedSliceHeader(sliceHeader.parsedContent) &&
       sliceHeader.parsedContent.refSeqId >= 0 &&
-      sliceHeader.parsedContent.md5.join('') !== '0000000000000000'
+      sliceHeader.parsedContent.md5?.join('') !== '0000000000000000'
     ) {
       const refRegion = await this.getReferenceRegion()
       if (refRegion) {
         const { seq, start, end } = refRegion
         const seqMd5 = sequenceMD5(seq)
         const storedMd5 = sliceHeader.parsedContent.md5
-          .map(byte => (byte < 16 ? '0' : '') + byte.toString(16))
+          ?.map(byte => (byte < 16 ? '0' : '') + byte.toString(16))
           .join('')
         if (seqMd5 !== storedMd5) {
           throw new CramMalformedError(
@@ -518,7 +524,7 @@ export default class CramSlice {
             refRegion = {
               id: seqId,
               start: record.alignmentStart,
-              end: -Infinity,
+              end: Number.NEGATIVE_INFINITY,
               seq: null,
             }
             refRegions[seqId] = refRegion

package/src/cramFile/util.ts

@@ -1,5 +1,5 @@
 import md5 from 'md5'
-import { Parser } from '@gmod/binary-parser'
+import Long from 'long'
 import { CramBufferOverrunError } from './codecs/getBits'
 
 export function itf8Size(v: number) {
@@ -18,13 +18,10 @@ export function itf8Size(v: number) {
   return 5
 }
 
-export function parseItf8(
-  buffer: Uint8Array,
-  initialOffset: number,
-): [number, number] {
+export function parseItf8(buffer: Uint8Array, initialOffset: number) {
   let offset = initialOffset
   const countFlags = buffer[offset]
-  let result
+  let result: number
   if (countFlags < 0x80) {
     result = countFlags
     offset = offset + 1
@@ -60,106 +57,108 @@ export function parseItf8(
       'Attempted to read beyond end of buffer; this file seems truncated.',
     )
   }
-  return [result, offset - initialOffset]
+  return [result, offset - initialOffset] as const
 }
 
-// parseLtf8(buffer, initialOffset) {
-//   let offset = initialOffset
-//   const countFlags = buffer[offset]
-//   let result
-//   if (countFlags < 0x80) {
-//     result = countFlags
-//     offset += 1
-//   } else if (countFlags < 0xc0) {
-//     result = ((buffer[offset] << 8) | buffer[offset + 1]) & 0x3fff
-//     offset += 2
-//   } else if (countFlags < 0xe0) {
-//     result =
-//       ((buffer[offset] << 16) |
-//         (buffer[offset + 1] << 8) |
-//         buffer[offset + 2]) &
-//       0x1fffff
-//     offset += 3
-//   } else if (countFlags < 0xf0) {
-//     result =
-//       ((buffer[offset] << 24) |
-//         (buffer[offset + 1] << 16) |
-//         (buffer[offset + 2] << 8) |
-//         buffer[offset + 3]) &
-//       0x0fffffff
-//     offset += 4
-//   } else if (countFlags < 0xf8) {
-//     result =
-//       ((buffer[offset] & 15) * Math.pow(2,32) + (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) {
-//     result =
-//       ((((buffer[offset] & 7) << 8) | buffer[offset + 1]) * Math.pow(2,32) +
-//         (buffer[offset + 2] << 24)) |
-//       ((buffer[offset + 3] << 16) |
-//         (buffer[offset + 4] << 8) |
-//         buffer[offset + 5])
-//     offset += 6
-//   } else if (countFlags < 0xfe) {
-//     result =
-//       ((((buffer[offset] & 3) << 16) |
-//         (buffer[offset + 1] << 8) |
-//         buffer[offset + 2]) *
-//         Math.pow(2,32) +
-//         (buffer[offset + 3] << 24)) |
-//       ((buffer[offset + 4] << 16) |
-//         (buffer[offset + 5] << 8) |
-//         buffer[offset + 6])
-//     offset += 7
-//   } else if (countFlags < 0xff) {
-//     result = Long.fromBytesBE(buffer.slice(offset + 1, offset + 8))
-//     if (
-//       result.greaterThan(Number.MAX_SAFE_INTEGER) ||
-//       result.lessThan(Number.MIN_SAFE_INTEGER)
-//     )
-//       throw new CramUnimplementedError('integer overflow')
-//     result = result.toNumber()
-//     offset += 8
-//   } else {
-//     result = Long.fromBytesBE(buffer.slice(offset + 1, offset + 9))
-//     if (
-//       result.greaterThan(Number.MAX_SAFE_INTEGER) ||
-//       result.lessThan(Number.MIN_SAFE_INTEGER)
-//     )
-//       throw new CramUnimplementedError('integer overflow')
-//     result = result.toNumber()
-//     offset += 9
-//   }
-//   return [result, offset - initialOffset]
-// },
-
-export type ParsedItem<T> = T & {
-  _endPosition: number
-  _size: number
+export function parseLtf8(buffer: Buffer, initialOffset: number) {
+  let offset = initialOffset
+  const countFlags = buffer[offset]
+  let n: number | Long
+  if (countFlags < 0x80) {
+    n = countFlags
+    offset += 1
+  } else if (countFlags < 0xc0) {
+    n = ((buffer[offset] << 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) | buffer.readUInt16LE(offset + 1)
+    offset += 3
+  } else if (countFlags < 0xf0) {
+    n =
+      ((buffer[offset] << 24) |
+        (buffer[offset + 1] << 16) |
+        (buffer[offset + 2] << 8) |
+        buffer[offset + 3]) &
+      0x0fffffff
+    offset += 4
+  } else if (countFlags < 0xf8) {
+    n =
+      ((buffer[offset] & 15) * 2 ** 32 + (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) |
+        (buffer[offset + 4] << 8) |
+        buffer[offset + 5])
+    offset += 6
+  } else if (countFlags < 0xfe) {
+    n =
+      ((((buffer[offset] & 3) << 16) |
+        (buffer[offset + 1] << 8) |
+        buffer[offset + 2]) *
+        2 ** 32 +
+        (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()
+    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()
+    offset += 9
+  }
+  return [n, offset - initialOffset] as const
 }
 
 export function parseItem<T>(
   buffer: Buffer,
-  parser: Parser<T>,
+  parser: (buffer: Buffer, offset: number) => { offset: number; value: T },
   startBufferPosition = 0,
   startFilePosition = 0,
-): ParsedItem<T> {
-  const { offset, result } = parser.parse(buffer)
+) {
+  const { offset, value } = parser(buffer, startBufferPosition)
   return {
-    ...result,
+    ...value,
     _endPosition: offset + startFilePosition,
     _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
+// 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}`

package/src/rans/d04.ts

@@ -40,7 +40,7 @@ export default function uncompress(
   }
 
   out.setPosition(outputEnd)
-  let /* byte */ c
+  let /* byte */ c: number
   switch (outputSize & 3) {
     case 0:
       break

package/src/rans/decoding.ts

@@ -24,7 +24,7 @@ class AriDecoder {
   }
 }
 
-class Symbol {
+class DecodingSymbol {
   // int start; // Start of range.
   // int freq; // Symbol frequency.
   constructor() {
@@ -36,10 +36,10 @@ class Symbol {
 // Initialize a decoder symbol to start "start" and frequency "freq"
 function symbolInit(sym, start, freq) {
   if (!(start <= 1 << 16)) {
-    throw new CramMalformedError(`assertion failed: start <= 1<<16`)
+    throw new CramMalformedError('assertion failed: start <= 1<<16')
   }
   if (!(freq <= (1 << 16) - start)) {
-    throw new CramMalformedError(`assertion failed: freq <= 1<<16`)
+    throw new CramMalformedError('assertion failed: freq <= 1<<16')
   }
   sym.start = start
   sym.freq = freq
@@ -127,10 +127,10 @@ function symbolInit(sym, start, freq) {
   return r
 }
 
-const Decode = {
+export default {
   FC,
   AriDecoder,
-  Symbol,
+  DecodingSymbol,
   symbolInit,
   advanceStep,
   advanceSymbolStep,
@@ -138,5 +138,3 @@ const Decode = {
   advanceSymbol,
   renormalize,
 }
-
-export default Decode

package/src/rans/index.ts

@@ -1,4 +1,5 @@
 //@ts-nocheck
+import { Buffer } from 'buffer'
 import { CramMalformedError } from '../errors'
 
 import Decoding from './decoding'
@@ -118,7 +119,7 @@ function /* static ByteBuffer */ uncompressOrder0Way4(
   const D = new Decoding.AriDecoder()
   const syms = new Array(256)
   for (let i = 0; i < syms.length; i += 1) {
-    syms[i] = new Decoding.Symbol()
+    syms[i] = new Decoding.DecodingSymbol()
   }
 
   readStatsO0(input, D, syms)
@@ -140,7 +141,7 @@ function /* static ByteBuffer */ uncompressOrder1Way4(
   for (let i = 0; i < syms.length; i += 1) {
     syms[i] = new Array(256)
     for (let j = 0; j < syms[i].length; j += 1) {
-      syms[i][j] = new Decoding.Symbol()
+      syms[i][j] = new Decoding.DecodingSymbol()
     }
   }
   readStatsO1(input, D, syms)

package/src/typings/binary-parser.d.ts

@@ -1,44 +0,0 @@
-declare module '@gmod/binary-parser' {
-  export interface Options {
-    stripNull?: boolean
-    formatter?: (item: any) => any
-    length?: number | string | ((this: { $parent: unknown }) => void)
-  }
-
-  export class Parser<T = unknown> {
-    public static start<TStart>(): Parser<TStart>
-
-    public uint8(name?: string | null, options?: Options): Parser
-
-    public itf8(name?: string | null, options?: Options): Parser
-
-    public ltf8(name?: string | null, options?: Options): Parser
-
-    public uint32(name?: string | null, options?: Options): Parser
-
-    public int32(name?: string | null, options?: Options): Parser
-
-    public buffer(name?: string | null, options?: Options): Parser
-
-    public string(name?: string | null, options?: Options): Parser
-
-    public namely(name: string): Parser
-
-    public nest(
-      name?: string | null,
-      options?: { type: Parser | string } & Options,
-    ): Parser
-
-    public choice(
-      name?: string | null,
-      options?: { tag: string; choices: any } & Options,
-    ): Parser
-
-    public array(
-      name?: string | null,
-      options?: { type: string | Parser } & Options,
-    ): Parser
-
-    parse(bytes: Buffer): { result: T; offset: number }
-  }
-}