@gmod/cram 6.0.0 → 7.0.0

package/esm/seek-bzip/toHex.js

@@ -1,33 +0,0 @@
-// from https://www.xaymar.com/articles/2020/12/08/fastest-uint8array-to-hex-string-conversion-in-javascript/
-// Pre-Init
-const LUT_HEX_4b = [
-    '0',
-    '1',
-    '2',
-    '3',
-    '4',
-    '5',
-    '6',
-    '7',
-    '8',
-    '9',
-    'A',
-    'B',
-    'C',
-    'D',
-    'E',
-    'F',
-];
-const LUT_HEX_8b = new Array(0x100);
-for (let n = 0; n < 0x100; n++) {
-    LUT_HEX_8b[n] = `${LUT_HEX_4b[(n >>> 4) & 0xf]}${LUT_HEX_4b[n & 0xf]}`;
-}
-// End Pre-Init
-export function toHex(buffer) {
-    let out = '';
-    for (let idx = 0, edx = buffer.length; idx < edx; idx++) {
-        out += LUT_HEX_8b[buffer[idx]];
-    }
-    return out;
-}
-//# sourceMappingURL=toHex.js.map

package/esm/seek-bzip/toHex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"toHex.js","sourceRoot":"","sources":["../../src/seek-bzip/toHex.ts"],"names":[],"mappings":"AAAA,6GAA6G;AAE7G,WAAW;AACX,MAAM,UAAU,GAAG;IACjB,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;CACJ,CAAA;AACD,MAAM,UAAU,GAAG,IAAI,KAAK,CAAC,KAAK,CAAC,CAAA;AACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;IAC/B,UAAU,CAAC,CAAC,CAAC,GAAG,GAAG,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,UAAU,CAAC,CAAC,GAAG,GAAG,CAAC,EAAE,CAAA;AACxE,CAAC;AACD,eAAe;AACf,MAAM,UAAU,KAAK,CAAC,MAAkB;IACtC,IAAI,GAAG,GAAG,EAAE,CAAA;IACZ,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC;QACxD,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,GAAG,CAAE,CAAC,CAAA;IACjC,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC"}

package/src/htscodecs/arith_gen.ts

@@ -1,371 +0,0 @@
-/* eslint-disable no-var */
-// @ts-nocheck
-
-/*
- * Copyright (c) 2019,2020 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.
- */
-
-import { decode } from '../seek-bzip/index.ts'
-
-import RangeCoder from './arith_sh.ts'
-import ByteModel from './byte_model.ts'
-import IOStream from './iostream.ts'
-import { concatUint8Array } from '../util.ts'
-
-const ARITH_ORDER = 1
-const ARITH_EXT = 4
-const ARITH_STRIPE = 8
-const ARITH_NOSIZE = 16
-const ARITH_CAT = 32
-const ARITH_RLE = 64
-const ARITH_PACK = 128
-
-export default class RangeCoderGen {
-  stream: IOStream
-  decode(src: Uint8Array) {
-    this.stream = new IOStream(src)
-    return this.decodeStream(this.stream)
-  }
-
-  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
-
-    const order = flags & ARITH_ORDER
-
-    // 4-way recursion
-    if (flags & ARITH_STRIPE) {
-      return this.decodeStripe(this.stream, n_out)
-    }
-
-    // Meta data
-    if (flags & ARITH_PACK) {
-      var P
-      ;[P, e_len] = this.decodePackMeta(this.stream)
-    }
-
-    // NOP, useful for tiny blocks
-    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)
-    } else if (flags & ARITH_RLE) {
-      var data = order
-        ? this.decodeRLE1(this.stream, e_len)
-        : this.decodeRLE0(this.stream, e_len)
-    } else {
-      var data = order
-        ? this.decode1(this.stream, e_len)
-        : this.decode0(this.stream, e_len)
-    }
-
-    // Transforms
-    if (flags & ARITH_PACK) {
-      data = this.decodePack(data, P, n_out)
-    }
-
-    return data
-  }
-
-  // ----------------------------------------------------------------------
-  // Order-0 codec
-  decode0(stream, n_out) {
-    const output = new Uint8Array(n_out)
-
-    let max_sym = stream.ReadByte()
-    if (max_sym == 0) {
-      max_sym = 256
-    }
-
-    const byte_model = new ByteModel(max_sym)
-
-    const rc = new RangeCoder(stream)
-    rc.RangeStartDecode(stream)
-
-    for (let i = 0; i < n_out; i++) {
-      output[i] = byte_model.ModelDecode(stream, rc)
-    }
-
-    return output
-  }
-
-  // ----------------------------------------------------------------------
-  // Order-1 codec
-
-  decode1(stream, n_out) {
-    const output = new Uint8Array(n_out)
-
-    let max_sym = stream.ReadByte()
-    if (max_sym == 0) {
-      max_sym = 256
-    }
-
-    const byte_model = new Array(max_sym)
-    for (var i = 0; i < max_sym; i++) {
-      byte_model[i] = new ByteModel(max_sym)
-    }
-
-    const rc = new RangeCoder(stream)
-    rc.RangeStartDecode(stream)
-
-    let last = 0
-    for (var i = 0; i < n_out; i++) {
-      output[i] = byte_model[last].ModelDecode(stream, rc)
-      last = output[i]
-    }
-
-    return output
-  }
-
-  // ----------------------------------------------------------------------
-  // External codec
-  decodeExt(stream, n_out) {
-    return decode(stream.buf.slice(stream.pos))
-  }
-
-  // ----------------------------------------------------------------------
-  // Order-0 RLE codec
-  decodeRLE0(stream, n_out) {
-    const output = new Uint8Array(n_out)
-
-    let max_sym = stream.ReadByte()
-    if (max_sym == 0) {
-      max_sym = 256
-    }
-
-    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)
-    }
-
-    const rc = new RangeCoder(stream)
-    rc.RangeStartDecode(stream)
-
-    var i = 0
-    while (i < n_out) {
-      output[i] = model_lit.ModelDecode(stream, rc)
-      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 (let j = 1; j <= run; j++) {
-        output[i + j] = output[i]
-      }
-      i += run + 1
-    }
-
-    return output
-  }
-
-  // ----------------------------------------------------------------------
-  // Order-1 RLE codec
-
-  decodeRLE1(stream, n_out) {
-    const output = new Uint8Array(n_out)
-
-    let max_sym = stream.ReadByte()
-    if (max_sym == 0) {
-      max_sym = 256
-    }
-
-    const model_lit = new Array(max_sym)
-    for (var i = 0; i < max_sym; i++) {
-      model_lit[i] = new ByteModel(max_sym)
-    }
-
-    const model_run = new Array(258)
-    for (var i = 0; i <= 257; i++) {
-      model_run[i] = new ByteModel(4)
-    }
-
-    const rc = new RangeCoder(stream)
-    rc.RangeStartDecode(stream)
-
-    let last = 0
-    var i = 0
-    while (i < n_out) {
-      output[i] = model_lit[last].ModelDecode(stream, rc)
-      last = output[i]
-      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 (let j = 1; j <= run; j++) {
-        output[i + j] = output[i]
-      }
-      i += run + 1
-    }
-
-    return output
-  }
-
-  // ----------------------------------------------------------------------
-  // Pack method
-  decodePackMeta(stream) {
-    this.nsym = stream.ReadByte()
-
-    const M = new Array(this.nsym)
-    for (let i = 0; i < this.nsym; i++) {
-      M[i] = stream.ReadByte()
-    }
-
-    const e_len = stream.ReadUint7() // Could be derived data from nsym and n_out
-
-    return [M, e_len]
-  }
-
-  decodePack(data, M, len) {
-    const out = new Uint8Array(len)
-
-    if (this.nsym <= 1) {
-      // Constant value
-      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++]
-        }
-        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++]
-        }
-        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++]
-        }
-        out[i] = M[v & 15]
-        v >>= 4
-      }
-    } else {
-      // 8 bits per value: NOP
-      return data
-    }
-
-    return out
-  }
-
-  // Compute M array and return meta-data stream
-  packMeta(src) {
-    const stream = new IOStream('', 0, 1024)
-
-    // Count symbols
-    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
-    stream.WriteByte(nsym)
-
-    // FIXME: add check for nsym > 16?
-    // Or just accept it as an inefficient waste of time.
-    for (var i = 0; i < 256; i++) {
-      if (M[i]) {
-        stream.WriteByte(i) // adjust to 0..N-1
-        M[i]--
-      }
-    }
-
-    return [stream, M, nsym]
-  }
-
-  decodeStripe(stream, len) {
-    const N = stream.ReadByte()
-
-    // Retrieve lengths
-    const clen = new Array(N)
-    const ulen = new Array(N)
-    for (var j = 0; j < N; j++) {
-      clen[j] = stream.ReadUint7()
-    }
-
-    // Decode streams
-    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
-    const out = new Uint8Array(len)
-    for (var j = 0; j < N; j++) {
-      for (let i = 0; i < ulen[j]; i++) {
-        out[i * N + j] = T[j][i]
-      }
-    }
-
-    return out
-  }
-
-  // ----------------------------------------------------------------------
-  // Cat method
-  decodeCat(stream, len) {
-    const out = new Uint8Array(len)
-    for (let i = 0; i < len; i++) {
-      out[i] = stream.ReadByte()
-    }
-
-    return out
-  }
-}

package/src/htscodecs/arith_sh.ts

@@ -1,146 +0,0 @@
-// @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.
- */
-
-// An arithmetic coder, based on Eugene Shelwien's reimplementation of
-// Michael Schindler range coder.
-//
-// Order-0 byte stream of ~/scratch/data/q40b
-// C:              3.1s decode  (approx same vs 32-bit and 64-bit)
-// Arith_sh.js     6.7s decode  (32-bit with carries)
-// Arith.js      317.0s decode  (64-bit no carries); int64 crippling it.
-
-// ----------------------------------------------------------------------
-// Arithmetic (range) coder
-export default class RangeCoder {
-  constructor(src) {
-    this.low = 0
-    this.range = 0xffffffff
-    this.code = 0
-    this.FFnum = 0
-    this.carry = 0
-    this.cache = 0
-  }
-
-  RangeStartDecode(src) {
-    for (let i = 0; i < 5; i++) {
-      this.code = (this.code << 8) + src.ReadByte()
-    }
-    this.code &= 0xffffffff
-    this.code >>>= 0 // force to be +ve int
-  }
-
-  RangeGetFrequency(tot_freq) {
-    this.range = Math.floor(this.range / tot_freq)
-    // return this.code / this.range;
-    return Math.floor(this.code / this.range)
-
-    // Conceptual scenario; return freq only and don't modify range yet
-    // return Math.floor(this.code / (Math.floor(this.range / tot_freq)));
-  }
-
-  RangeDecode(src, sym_low, sym_freq, tot_freq) {
-    // Conceptually we divide range here, but in practice we cached it earlier
-    // this.range = Math.floor(this.range / tot_freq);
-
-    this.code -= sym_low * this.range
-    this.range *= sym_freq
-
-    while (this.range < 1 << 24) {
-      this.range *= 256
-      this.code = this.code * 256 + src.ReadByte()
-    }
-  }
-
-  RangeShiftLow(dst) {
-    // We know range is < (1<<24) as we got here.  We already have a
-    // cached copy of 8 bits from low.  Is this correct, or does it need
-    // fixing?  Possible scenarios.
-    // 1. Low < 0xff000000 thus low+range < 0xffffffff and cache
-    //    cannot possibly change.  Output cache and as many ffs as needed.
-    // 2. We already detected an overflow in RangeEncode, setting carry.
-    //    In this case output cached byte + 1 and any 00s needed.
-    // 3. Neither case - range is low but we haven't yet detected if we're
-    //    XXffffff or XY000000 scenario.  Increase counter for ff/00s.
-
-    if ((this.low < 0xff000000) | this.carry) {
-      // cached byte if no overflow, byte+1 otherwise
-      dst.WriteByte(this.cache + this.carry)
-
-      // Flush any tracked FFs (no carry) or 00s (carry).
-      while (this.FFnum) {
-        dst.WriteByte(this.carry - 1)
-        this.FFnum--
-      }
-
-      // Take a copy of top byte ready for next flush
-      this.cache = this.low >>> 24
-      this.carry = 0
-    } else {
-      this.FFnum++ // keep track of number of trailing ff/00 bytes to write
-    }
-    this.low <<= 8
-    this.low >>>= 0 // force to be +ve int
-  }
-
-  RangeEncode(dst, sym_low, sym_freq, tot_freq) {
-    const old_low = this.low
-    this.range = Math.floor(this.range / tot_freq)
-    this.low += sym_low * this.range
-    this.low >>>= 0 // Truncate to +ve int so we can spot overflow
-    this.range *= sym_freq
-
-    // "low + sym*range < old_low" means we overflow; set carry.
-    // NB: can this.low < old_low occur twice before range < (1<<24)?
-    // We claim not, but prove it!
-    if (this.low < old_low) {
-      if (this.carry != 0) {
-        console.log('ERROR: Multiple carry')
-      }
-      this.carry = 1
-    }
-
-    // Renormalise if range gets too small
-    while (this.range < 1 << 24) {
-      this.range *= 256
-      this.RangeShiftLow(dst)
-    }
-  }
-
-  RangeFinishEncode(dst) {
-    for (let i = 0; i < 5; i++) {
-      this.RangeShiftLow(dst)
-    }
-  }
-}

package/src/htscodecs/byte_model.ts

@@ -1,136 +0,0 @@
-/* eslint-disable no-var */
-// @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.
- */
-
-// An adaptive probability model for encoding and decoding of symbols
-// within a given alphabet, using the range coder to get/put the
-// compressed data.
-
-const MAX_FREQ = (1 << 16) - 17
-const STEP = 16
-
-export default class ByteModel {
-  constructor(max_sym = 256) {
-    this.total_freq = max_sym
-    this.max_sym = max_sym - 1
-    this.S = []
-    this.F = []
-
-    for (let i = 0; i <= this.max_sym; i++) {
-      this.S[i] = i
-      this.F[i] = 1
-    }
-  }
-
-  ModelDecode(src, rc) {
-    // Find symbol
-    const freq = rc.RangeGetFrequency(this.total_freq)
-
-    // Linear scan to find cumulative frequency 'freq'
-    let acc = 0
-    let x = 0
-    while (acc + this.F[x] <= freq) {
-      acc += this.F[x++]
-    }
-
-    //	for (var acc = 0; (acc += this.F[x]) <= freq; x++)
-    //	    ;
-    //	acc -= this.F[x];
-
-    // Update range coder
-    rc.RangeDecode(src, acc, this.F[x], this.total_freq)
-
-    // Update model
-    this.F[x] += STEP
-    this.total_freq += STEP
-    if (this.total_freq > MAX_FREQ) {
-      this.ModelRenormalise()
-    }
-
-    // Keep symbols approximately frequency sorted
-    const sym = this.S[x]
-    if (x > 0 && this.F[x] > this.F[x - 1]) {
-      let tmp = this.F[x]
-      this.F[x] = this.F[x - 1]
-      this.F[x - 1] = tmp
-
-      tmp = this.S[x]
-      this.S[x] = this.S[x - 1]
-      this.S[x - 1] = tmp
-    }
-
-    return sym
-  }
-
-  ModelRenormalise() {
-    // Halve all the frequencies, being careful not to hit zero
-    this.total_freq = 0
-    for (let i = 0; i <= this.max_sym; i++) {
-      this.F[i] -= Math.floor(this.F[i] / 2)
-      this.total_freq += this.F[i]
-    }
-  }
-
-  ModelEncode(dst, rc, sym) {
-    // Find cumulative frequency
-    let acc = 0
-    for (var x = 0; this.S[x] != sym; x++) {
-      acc += this.F[x]
-    }
-
-    // Encode
-    rc.RangeEncode(dst, acc, this.F[x], this.total_freq)
-
-    // Update model
-    this.F[x] += STEP
-    this.total_freq += STEP
-    if (this.total_freq > MAX_FREQ) {
-      // FIXME x2
-      this.ModelRenormalise()
-    }
-
-    // Keep symbols approximately frequency sorted
-    var sym = this.S[x]
-    if (x > 0 && this.F[x] > this.F[x - 1]) {
-      let tmp = this.F[x]
-      this.F[x] = this.F[x - 1]
-      this.F[x - 1] = tmp
-
-      tmp = this.S[x]
-      this.S[x] = this.S[x - 1]
-      this.S[x - 1] = tmp
-    }
-  }
-}