@gmod/cram 5.0.6 → 6.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmod/cram",
-  "version": "5.0.6",
+  "version": "6.0.0",
   "description": "read CRAM files with pure Javascript",
   "license": "MIT",
   "repository": "GMOD/cram-js",
@@ -52,26 +52,24 @@
     "crc": "^4.3.2",
     "generic-filehandle2": "^2.0.12",
     "md5": "^2.2.1",
-    "pako": "^1.0.4",
-    "quick-lru": "^4.0.1",
-    "xz-decompress": "^0.2.1"
+    "pako-esm2": "^1.0.15",
+    "quick-lru": "^4.0.1"
   },
   "devDependencies": {
     "@gmod/indexedfasta": "^4.0.6",
     "@types/md5": "^2.3.2",
-    "@types/pako": "^1.0.3",
-    "@vitest/coverage-v8": "^3.2.3",
+    "@vitest/coverage-v8": "^4.0.3",
     "buffer": "^6.0.3",
     "documentation": "^14.0.3",
     "eslint": "^9.29.0",
     "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-unicorn": "^60.0.0",
+    "eslint-plugin-unicorn": "^62.0.0",
     "mock-fs": "^5.2.0",
     "prettier": "^3.2.5",
     "rimraf": "^6.0.1",
     "typescript": "^5.7.0",
     "typescript-eslint": "^8.34.0",
-    "vitest": "^3.2.3",
+    "vitest": "^4.0.3",
     "webpack": "^5.99.9",
     "webpack-cli": "^6.0.1"
   },

package/src/cramFile/codecs/byteArrayLength.ts

@@ -35,11 +35,15 @@ export default class ByteArrayStopCodec extends CramCodec<
     const arrayLength =
       lengthCodec.decode(slice, coreDataBlock, blocksByContentId, cursors) || 0
 
-    const dataCodec = this._getDataCodec()
     const data = new Uint8Array(arrayLength)
-    for (let i = 0; i < arrayLength; i += 1) {
-      data[i] =
-        dataCodec.decode(slice, coreDataBlock, blocksByContentId, cursors) || 0
+    if (arrayLength > 0) {
+      const dataCodec = this._getDataCodec()
+      // Call decode directly on codec to avoid repeated lookups
+      for (let i = 0; i < arrayLength; i += 1) {
+        data[i] =
+          dataCodec.decode(slice, coreDataBlock, blocksByContentId, cursors) ||
+          0
+      }
     }
 
     return data

package/src/cramFile/codecs/external.ts

@@ -1,4 +1,4 @@
-import CramCodec, { Cursor, Cursors } from './_base.ts'
+import CramCodec, { Cursors } from './_base.ts'
 import { CramUnimplementedError } from '../../errors.ts'
 import { CramFileBlock } from '../file.ts'
 import CramSlice from '../slice/index.ts'
@@ -10,21 +10,12 @@ export default class ExternalCodec extends CramCodec<
   'int' | 'byte',
   ExternalCramEncoding['parameters']
 > {
-  private readonly _decodeData: (
-    contentBlock: CramFileBlock,
-    cursor: Cursor,
-  ) => number
-
   constructor(
     parameters: ExternalCramEncoding['parameters'],
     dataType: 'int' | 'byte',
   ) {
     super(parameters, dataType)
-    if (this.dataType === 'int') {
-      this._decodeData = this._decodeInt
-    } else if (this.dataType === 'byte') {
-      this._decodeData = this._decodeByte
-    } else {
+    if (this.dataType !== 'int' && this.dataType !== 'byte') {
       throw new CramUnimplementedError(
         `${this.dataType} decoding not yet implemented by EXTERNAL codec`,
       )
@@ -39,29 +30,26 @@ export default class ExternalCodec extends CramCodec<
   ) {
     const { blockContentId } = this.parameters
     const contentBlock = blocksByContentId[blockContentId]
-    return contentBlock
-      ? this._decodeData(
-          contentBlock,
-          cursors.externalBlocks.getCursor(blockContentId),
-        )
-      : undefined
-  }
+    if (!contentBlock) {
+      return undefined
+    }
 
-  _decodeInt(contentBlock: CramFileBlock, cursor: Cursor) {
-    const [result, bytesRead] = parseItf8(
-      contentBlock.content,
-      cursor.bytePosition,
-    )
-    cursor.bytePosition = cursor.bytePosition + bytesRead
-    return result
-  }
+    const cursor = cursors.externalBlocks.getCursor(blockContentId)
 
-  _decodeByte(contentBlock: CramFileBlock, cursor: Cursor) {
-    if (cursor.bytePosition >= contentBlock.content.length) {
-      throw new CramBufferOverrunError(
-        'attempted to read beyond end of block. this file seems truncated.',
+    if (this.dataType === 'int') {
+      const [result, bytesRead] = parseItf8(
+        contentBlock.content,
+        cursor.bytePosition,
       )
+      cursor.bytePosition += bytesRead
+      return result
+    } else {
+      if (cursor.bytePosition >= contentBlock.content.length) {
+        throw new CramBufferOverrunError(
+          'attempted to read beyond end of block. this file seems truncated.',
+        )
+      }
+      return contentBlock.content[cursor.bytePosition++]!
     }
-    return contentBlock.content[cursor.bytePosition++]!
   }
 }

package/src/cramFile/container/compressionScheme.ts

@@ -100,7 +100,7 @@ export default class CramContainerCompressionScheme {
     // interpret some of the preservation map tags for convenient use
     this.readNamesIncluded = content.preservation.RN
     this.APdelta = content.preservation.AP
-     
+
     this.referenceRequired = !!content.preservation.RR
     this.tagIdsDictionary = content.preservation.TD
     this.substitutionMatrix = parseSubstitutionMatrix(content.preservation.SM)

package/src/cramFile/file.ts

@@ -1,12 +1,12 @@
 import crc32 from 'crc/calculators/crc32'
 import QuickLRU from 'quick-lru'
-import { XzReadableStream } from 'xz-decompress'
 
 import { CramMalformedError, CramUnimplementedError } from '../errors.ts'
 import * as htscodecs from '../htscodecs/index.ts'
 import { open } from '../io.ts'
 import ransuncompress from '../rans/index.ts'
 import { parseHeaderText } from '../sam.ts'
+import { parseItem, tinyMemoize } from './util.ts'
 import { decode } from '../seek-bzip/index.ts'
 import { unzip } from '../unzip.ts'
 import CramContainer from './container/index.ts'
@@ -17,19 +17,10 @@ import {
   cramFileDefinition,
   getSectionParsers,
 } from './sectionParsers.ts'
-import { parseItem, tinyMemoize } from './util.ts'
+import { xzDecompress } from '../xz-decompress/xz-decompress.ts'
 
 import type { GenericFilehandle } from 'generic-filehandle2'
 
-function bufferToStream(buf: Uint8Array) {
-  return new ReadableStream({
-    start(controller) {
-      controller.enqueue(buf)
-      controller.close()
-    },
-  })
-}
-
 // source: https://abdulapopoola.com/2019/01/20/check-endianness-with-javascript/
 function getEndianness() {
   const uInt32 = new Uint32Array([0x11223344])
@@ -80,6 +71,7 @@ export default class CramFile {
   }
   public featureCache: QuickLRU<string, Promise<CramRecord[]>>
   private header: string | undefined
+  private _sectionParsers?: ReturnType<typeof getSectionParsers>
 
   constructor(args: CramFileArgs) {
     this.file = open(args.url, args.path, args.filehandle)
@@ -148,9 +140,11 @@ export default class CramFile {
   }
 
   async getContainerById(containerNumber: number) {
-    const { majorVersion } = await this.getDefinition()
-    const sectionParsers = getSectionParsers(majorVersion)
-    let position = sectionParsers.cramFileDefinition.maxLength
+    if (!this._sectionParsers) {
+      const { majorVersion } = await this.getDefinition()
+      this._sectionParsers = getSectionParsers(majorVersion)
+    }
+    let position = this._sectionParsers.cramFileDefinition.maxLength
 
     // skip with a series of reads to the proper container
     let currentContainer: CramContainer | undefined
@@ -208,11 +202,13 @@ export default class CramFile {
    * length check, relies on a try catch to read return an error to break
    */
   async containerCount(): Promise<number | undefined> {
-    const { majorVersion } = await this.getDefinition()
-    const sectionParsers = getSectionParsers(majorVersion)
+    if (!this._sectionParsers) {
+      const { majorVersion } = await this.getDefinition()
+      this._sectionParsers = getSectionParsers(majorVersion)
+    }
 
     let containerCount = 0
-    let position = sectionParsers.cramFileDefinition.maxLength
+    let position = this._sectionParsers.cramFileDefinition.maxLength
     try {
       // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
       while (true) {
@@ -247,10 +243,14 @@ export default class CramFile {
     return new CramContainer(this, position)
   }
 
-  async readBlockHeader(position: number) {
-    const { majorVersion } = await this.getDefinition()
-    const sectionParsers = getSectionParsers(majorVersion)
-    const { cramBlockHeader } = sectionParsers
+  async readBlockHeader(
+    position: number,
+  ): Promise<BlockHeader & { _endPosition: number; _size: number }> {
+    if (!this._sectionParsers) {
+      const { majorVersion } = await this.getDefinition()
+      this._sectionParsers = getSectionParsers(majorVersion)
+    }
+    const { cramBlockHeader } = this._sectionParsers
 
     const buffer = await this.file.read(cramBlockHeader.maxLength, position)
     return parseItem(buffer, cramBlockHeader.parser, 0, position)
@@ -267,7 +267,7 @@ export default class CramFile {
     position: number,
     size = section.maxLength,
     preReadBuffer?: Uint8Array,
-  ) {
+  ): Promise<T & { _endPosition: number; _size: number }> {
     const buffer = preReadBuffer ?? (await this.file.read(size, position))
     const data = parseItem(buffer, section.parser, 0, position)
     if (data._size !== size) {
@@ -289,10 +289,7 @@ export default class CramFile {
     } else if (compressionMethod === 'bzip2') {
       return decode(inputBuffer)
     } else if (compressionMethod === 'lzma') {
-      const decompressedResponse = new Response(
-        new XzReadableStream(bufferToStream(inputBuffer)),
-      )
-      return new Uint8Array(await decompressedResponse.arrayBuffer())
+      return xzDecompress(inputBuffer)
     } else if (compressionMethod === 'rans') {
       const outputBuffer = new Uint8Array(uncompressedSize)
       ransuncompress(inputBuffer, outputBuffer)
@@ -332,7 +329,10 @@ export default class CramFile {
 
   async readBlock(position: number) {
     const { majorVersion } = await this.getDefinition()
-    const sectionParsers = getSectionParsers(majorVersion)
+    if (!this._sectionParsers) {
+      this._sectionParsers = getSectionParsers(majorVersion)
+    }
+    const sectionParsers = this._sectionParsers
     const blockHeader = await this.readBlockHeader(position)
     const blockContentPosition = blockHeader._endPosition
 

package/src/cramFile/slice/index.ts

@@ -392,16 +392,23 @@ export default class CramSlice {
       },
     }
 
+    // Pre-resolve all codecs to avoid repeated lookups
+    const codecCache = new Map<DataSeriesEncodingKey, any>()
+
     const decodeDataSeries: DataSeriesDecoder = <
       T extends DataSeriesEncodingKey,
     >(
       dataSeriesName: T,
     ): DataTypeMapping[DataSeriesTypes[T]] | undefined => {
-      const codec = compressionScheme.getCodecForDataSeries(dataSeriesName)
-      if (!codec) {
-        throw new CramMalformedError(
-          `no codec defined for ${dataSeriesName} data series`,
-        )
+      let codec = codecCache.get(dataSeriesName)
+      if (codec === undefined) {
+        codec = compressionScheme.getCodecForDataSeries(dataSeriesName)
+        if (!codec) {
+          throw new CramMalformedError(
+            `no codec defined for ${dataSeriesName} data series`,
+          )
+        }
+        codecCache.set(dataSeriesName, codec)
       }
       return codec.decode(this, coreDataBlock, blocksByContentId, cursors)
     }
@@ -431,10 +438,13 @@ export default class CramSlice {
         })
       } catch (e) {
         if (e instanceof CramBufferOverrunError) {
-          console.warn(
-            'read attempted beyond end of buffer, file seems truncated.',
+          const recordsDecoded = i
+          const recordsExpected = sliceHeader.parsedContent.numRecords
+          throw new CramMalformedError(
+            `Failed to decode all records in slice. Decoded ${recordsDecoded} of ${recordsExpected} expected records. ` +
+              `Buffer overrun suggests either: (1) file is truncated/corrupted, (2) compression scheme is incorrect, ` +
+              `or (3) there's a bug in the decoder. Original error: ${e.message}`,
           )
-          break
         } else {
           throw e
         }

package/src/cramFile/util.ts

@@ -183,14 +183,15 @@ export function tinyMemoize(_class: any, methodName: any) {
   const method = _class.prototype[methodName]
   const memoAttrName = `_memo_${methodName}`
   _class.prototype[methodName] = function _tinyMemoized() {
-    if (!(memoAttrName in this)) {
-      const res = method.call(this)
+    let res = this[memoAttrName]
+    if (res === undefined) {
+      res = method.call(this)
       this[memoAttrName] = res
       Promise.resolve(res).catch(() => {
         delete this[memoAttrName]
       })
     }
-    return this[memoAttrName]
+    return res
   }
 }
 

package/src/indexedCramFile.ts

@@ -104,14 +104,27 @@ export default class IndexedCramFile {
     // fetch all the slices and parse the feature data
     const sliceResults = await Promise.all(
       slices.map(slice =>
-        this.getRecordsInSlice(
-          slice,
-          feature =>
-            feature.sequenceId === seq &&
+        this.getRecordsInSlice(slice, feature => {
+          // Check if feature belongs to this sequence
+          if (feature.sequenceId !== seq) {
+            return false
+          }
+
+          // For unmapped reads (lengthOnRef is undefined), they are placed at their
+          // mate's position. Include them if that position is within the range.
+          if (feature.lengthOnRef === undefined) {
+            return (
+              feature.alignmentStart >= start && feature.alignmentStart <= end
+            )
+          }
+
+          // For mapped reads, check if they overlap the requested range
+          // Use > instead of >= for start boundary to match samtools behavior
+          return (
             feature.alignmentStart <= end &&
-            feature.lengthOnRef !== undefined &&
-            feature.alignmentStart + feature.lengthOnRef - 1 >= start,
-        ),
+            feature.alignmentStart + feature.lengthOnRef - 1 > start
+          )
+        }),
       ),
     )
 

package/src/rans/d04.ts

@@ -3,6 +3,10 @@ import { CramMalformedError } from '../errors.ts'
 import { TF_SHIFT } from './constants.ts'
 import Decoding from './decoding.ts'
 
+// Inline constants for performance
+const RANS_BYTE_L = 8388608 // 1 << 23
+const MASK = 4095 // (1 << 12) - 1
+
 export default function uncompress(
   /* ByteBuffer */ input,
   /* Decoding.AriDecoder */ D,
@@ -16,26 +20,51 @@ export default function uncompress(
 
   const /* int */ outputSize = out.remaining()
   const /* int */ outputEnd = outputSize & ~3
+  const D_R = D.R
+
   for (let i = 0; i < outputEnd; i += 4) {
-    const /* byte */ c0 = D.R[Decoding.get(rans0, TF_SHIFT)]
-    const /* byte */ c1 = D.R[Decoding.get(rans1, TF_SHIFT)]
-    const /* byte */ c2 = D.R[Decoding.get(rans2, TF_SHIFT)]
-    const /* byte */ c3 = D.R[Decoding.get(rans3, TF_SHIFT)]
-
-    out.putAt(i, c0)
-    out.putAt(i + 1, c1)
-    out.putAt(i + 2, c2)
-    out.putAt(i + 3, c3)
-
-    rans0 = Decoding.advanceSymbolStep(rans0, syms[0xff & c0], TF_SHIFT)
-    rans1 = Decoding.advanceSymbolStep(rans1, syms[0xff & c1], TF_SHIFT)
-    rans2 = Decoding.advanceSymbolStep(rans2, syms[0xff & c2], TF_SHIFT)
-    rans3 = Decoding.advanceSymbolStep(rans3, syms[0xff & c3], TF_SHIFT)
-
-    rans0 = Decoding.renormalize(rans0, input)
-    rans1 = Decoding.renormalize(rans1, input)
-    rans2 = Decoding.renormalize(rans2, input)
-    rans3 = Decoding.renormalize(rans3, input)
+    const /* byte */ c0 = D_R[rans0 & MASK]
+    const /* byte */ c1 = D_R[rans1 & MASK]
+    const /* byte */ c2 = D_R[rans2 & MASK]
+    const /* byte */ c3 = D_R[rans3 & MASK]
+
+    // Inline putAt to avoid function call overhead
+    out._buffer[i] = c0
+    out._buffer[i + 1] = c1
+    out._buffer[i + 2] = c2
+    out._buffer[i + 3] = c3
+
+    const sym0 = syms[0xff & c0]
+    const sym1 = syms[0xff & c1]
+    const sym2 = syms[0xff & c2]
+    const sym3 = syms[0xff & c3]
+
+    rans0 = sym0.freq * (rans0 >> TF_SHIFT) + (rans0 & MASK) - sym0.start
+    rans1 = sym1.freq * (rans1 >> TF_SHIFT) + (rans1 & MASK) - sym1.start
+    rans2 = sym2.freq * (rans2 >> TF_SHIFT) + (rans2 & MASK) - sym2.start
+    rans3 = sym3.freq * (rans3 >> TF_SHIFT) + (rans3 & MASK) - sym3.start
+
+    // Inline renormalize to avoid function call overhead
+    if (rans0 < RANS_BYTE_L) {
+      do {
+        rans0 = (rans0 << 8) | (0xff & input.get())
+      } while (rans0 < RANS_BYTE_L)
+    }
+    if (rans1 < RANS_BYTE_L) {
+      do {
+        rans1 = (rans1 << 8) | (0xff & input.get())
+      } while (rans1 < RANS_BYTE_L)
+    }
+    if (rans2 < RANS_BYTE_L) {
+      do {
+        rans2 = (rans2 << 8) | (0xff & input.get())
+      } while (rans2 < RANS_BYTE_L)
+    }
+    if (rans3 < RANS_BYTE_L) {
+      do {
+        rans3 = (rans3 << 8) | (0xff & input.get())
+      } while (rans3 < RANS_BYTE_L)
+    }
   }
 
   out.setPosition(outputEnd)

package/src/rans/d14.ts

@@ -1,6 +1,9 @@
 // @ts-nocheck
 import { TF_SHIFT } from './constants.ts'
-import Decoding from './decoding.ts'
+
+// Inline constants for performance
+const RANS_BYTE_L = 8388608 // 1 << 23
+const MASK = 4095 // (1 << 12) - 1
 
 export default function uncompress(
   /* ByteBuffer */ input,
@@ -23,26 +26,59 @@ export default function uncompress(
   let /* int */ l1 = 0
   let /* int */ l2 = 0
   let /* int */ l7 = 0
+
   for (; i0 < isz4; i0 += 1, i1 += 1, i2 += 1, i7 += 1) {
-    const /* int */ c0 = 0xff & D[l0].R[Decoding.get(rans0, TF_SHIFT)]
-    const /* int */ c1 = 0xff & D[l1].R[Decoding.get(rans1, TF_SHIFT)]
-    const /* int */ c2 = 0xff & D[l2].R[Decoding.get(rans2, TF_SHIFT)]
-    const /* int */ c7 = 0xff & D[l7].R[Decoding.get(rans7, TF_SHIFT)]
-
-    output.putAt(i0, c0)
-    output.putAt(i1, c1)
-    output.putAt(i2, c2)
-    output.putAt(i7, c7)
-
-    rans0 = Decoding.advanceSymbolStep(rans0, syms[l0][c0], TF_SHIFT)
-    rans1 = Decoding.advanceSymbolStep(rans1, syms[l1][c1], TF_SHIFT)
-    rans2 = Decoding.advanceSymbolStep(rans2, syms[l2][c2], TF_SHIFT)
-    rans7 = Decoding.advanceSymbolStep(rans7, syms[l7][c7], TF_SHIFT)
-
-    rans0 = Decoding.renormalize(rans0, input)
-    rans1 = Decoding.renormalize(rans1, input)
-    rans2 = Decoding.renormalize(rans2, input)
-    rans7 = Decoding.renormalize(rans7, input)
+    const D_l0_R = D[l0].R
+    const D_l1_R = D[l1].R
+    const D_l2_R = D[l2].R
+    const D_l7_R = D[l7].R
+
+    const /* int */ c0 = 0xff & D_l0_R[rans0 & MASK]
+    const /* int */ c1 = 0xff & D_l1_R[rans1 & MASK]
+    const /* int */ c2 = 0xff & D_l2_R[rans2 & MASK]
+    const /* int */ c7 = 0xff & D_l7_R[rans7 & MASK]
+
+    // Inline putAt to avoid function call overhead
+    output._buffer[i0] = c0
+    output._buffer[i1] = c1
+    output._buffer[i2] = c2
+    output._buffer[i7] = c7
+
+    const sym_l0_c0 = syms[l0][c0]
+    const sym_l1_c1 = syms[l1][c1]
+    const sym_l2_c2 = syms[l2][c2]
+    const sym_l7_c7 = syms[l7][c7]
+
+    rans0 =
+      sym_l0_c0.freq * (rans0 >> TF_SHIFT) + (rans0 & MASK) - sym_l0_c0.start
+    rans1 =
+      sym_l1_c1.freq * (rans1 >> TF_SHIFT) + (rans1 & MASK) - sym_l1_c1.start
+    rans2 =
+      sym_l2_c2.freq * (rans2 >> TF_SHIFT) + (rans2 & MASK) - sym_l2_c2.start
+    rans7 =
+      sym_l7_c7.freq * (rans7 >> TF_SHIFT) + (rans7 & MASK) - sym_l7_c7.start
+
+    // Inline renormalize to avoid function call overhead
+    if (rans0 < RANS_BYTE_L) {
+      do {
+        rans0 = (rans0 << 8) | (0xff & input.get())
+      } while (rans0 < RANS_BYTE_L)
+    }
+    if (rans1 < RANS_BYTE_L) {
+      do {
+        rans1 = (rans1 << 8) | (0xff & input.get())
+      } while (rans1 < RANS_BYTE_L)
+    }
+    if (rans2 < RANS_BYTE_L) {
+      do {
+        rans2 = (rans2 << 8) | (0xff & input.get())
+      } while (rans2 < RANS_BYTE_L)
+    }
+    if (rans7 < RANS_BYTE_L) {
+      do {
+        rans7 = (rans7 << 8) | (0xff & input.get())
+      } while (rans7 < RANS_BYTE_L)
+    }
 
     l0 = c0
     l1 = c1
@@ -52,9 +88,19 @@ export default function uncompress(
 
   // Remainder
   for (; i7 < outputSize; i7 += 1) {
-    const /* int */ c7 = 0xff & D[l7].R[Decoding.get(rans7, TF_SHIFT)]
-    output.putAt(i7, c7)
-    rans7 = Decoding.advanceSymbol(rans7, input, syms[l7][c7], TF_SHIFT)
+    const /* int */ c7 = 0xff & D[l7].R[rans7 & MASK]
+    // Inline putAt to avoid function call overhead
+    output._buffer[i7] = c7
+
+    // Inline advanceSymbol to avoid function call overhead
+    const sym = syms[l7][c7]
+    rans7 = sym.freq * (rans7 >> TF_SHIFT) + (rans7 & MASK) - sym.start
+    if (rans7 < RANS_BYTE_L) {
+      do {
+        rans7 = (rans7 << 8) | (0xff & input.get())
+      } while (rans7 < RANS_BYTE_L)
+    }
+
     l7 = c7
   }
 }

package/src/rans/decoding.ts

@@ -15,10 +15,9 @@ class AriDecoder {
   // byte[] R;
 
   constructor() {
-    this.fc = new Array(256)
-    for (let i = 0; i < this.fc.length; i += 1) {
-      this.fc[i] = new FC()
-    }
+    // Use two parallel arrays instead of array of objects for better cache efficiency
+    this.fcF = new Array(256)
+    this.fcC = new Array(256)
     this.R = null
   }
 }

package/src/rans/frequencies.ts

@@ -19,25 +19,22 @@ export function readStatsO0(
   let x = 0
   let j = cp.get() & 0xff
   do {
-    if (decoder.fc[j] == null) {
-      decoder.fc[j] = new Decoding.FC()
+    decoder.fcF[j] = cp.get() & 0xff
+    if (decoder.fcF[j] >= 128) {
+      decoder.fcF[j] &= ~128
+      decoder.fcF[j] = ((decoder.fcF[j] & 127) << 8) | (cp.get() & 0xff)
     }
-    decoder.fc[j].F = cp.get() & 0xff
-    if (decoder.fc[j].F >= 128) {
-      decoder.fc[j].F &= ~128
-      decoder.fc[j].F = ((decoder.fc[j].F & 127) << 8) | (cp.get() & 0xff)
-    }
-    decoder.fc[j].C = x
+    decoder.fcC[j] = x
 
-    Decoding.symbolInit(syms[j], decoder.fc[j].C, decoder.fc[j].F)
+    Decoding.symbolInit(syms[j], decoder.fcC[j], decoder.fcF[j])
 
     /* Build reverse lookup table */
     if (!decoder.R) {
       decoder.R = new Array(TOTFREQ)
     }
-    decoder.R.fill(j, x, x + decoder.fc[j].F)
+    decoder.R.fill(j, x, x + decoder.fcF[j])
 
-    x += decoder.fc[j].F
+    x += decoder.fcF[j]
 
     if (rle === 0 && j + 1 === (0xff & cp.getByteAt(cp.position()))) {
       j = cp.get() & 0xff
@@ -68,33 +65,30 @@ export function readStatsO1(
       D[i] = new Decoding.AriDecoder()
     }
     do {
-      if (D[i].fc[j] == null) {
-        D[i].fc[j] = new Decoding.FC()
-      }
-      D[i].fc[j].F = 0xff & cp.get()
-      if (D[i].fc[j].F >= 128) {
-        D[i].fc[j].F &= ~128
-        D[i].fc[j].F = ((D[i].fc[j].F & 127) << 8) | (0xff & cp.get())
+      D[i].fcF[j] = 0xff & cp.get()
+      if (D[i].fcF[j] >= 128) {
+        D[i].fcF[j] &= ~128
+        D[i].fcF[j] = ((D[i].fcF[j] & 127) << 8) | (0xff & cp.get())
       }
-      D[i].fc[j].C = x
+      D[i].fcC[j] = x
 
-      if (D[i].fc[j].F === 0) {
-        D[i].fc[j].F = TOTFREQ
+      if (D[i].fcF[j] === 0) {
+        D[i].fcF[j] = TOTFREQ
       }
 
       if (syms[i][j] == null) {
         syms[i][j] = new Decoding.RansDecSymbol()
       }
 
-      Decoding.symbolInit(syms[i][j], D[i].fc[j].C, D[i].fc[j].F)
+      Decoding.symbolInit(syms[i][j], D[i].fcC[j], D[i].fcF[j])
 
       /* Build reverse lookup table */
       if (D[i].R == null) {
         D[i].R = new Array(TOTFREQ)
       }
-      D[i].R.fill(j, x, x + D[i].fc[j].F)
+      D[i].R.fill(j, x, x + D[i].fcF[j])
 
-      x += D[i].fc[j].F
+      x += D[i].fcF[j]
       assert(x <= TOTFREQ)
 
       if (rlej === 0 && j + 1 === (0xff & cp.getByteAt(cp.position()))) {