@gmod/cram 3.0.6 → 4.0.0

package/src/cramFile/util.ts

@@ -1,5 +1,6 @@
-import md5 from 'md5'
 import Long from 'long'
+import md5 from 'md5'
+
 import { CramBufferOverrunError } from './codecs/getBits'
 
 export function itf8Size(v: number) {
@@ -60,7 +61,8 @@ export function parseItf8(buffer: Uint8Array, initialOffset: number) {
   return [result, offset - initialOffset] as const
 }
 
-export function parseLtf8(buffer: Buffer, initialOffset: number) {
+export function parseLtf8(buffer: Uint8Array, initialOffset: number) {
+  const dataView = new DataView(buffer.buffer)
   let offset = initialOffset
   const countFlags = buffer[offset]!
   let n: number | Long
@@ -76,7 +78,7 @@ export function parseLtf8(buffer: Buffer, initialOffset: number) {
         (buffer[offset + 1]! << 8) |
         buffer[offset + 2]!) &
       0x1fffff
-    n = ((countFlags & 63) << 16) | buffer.readUInt16LE(offset + 1)
+    n = ((countFlags & 63) << 16) | dataView.getUint16(offset + 1, true)
     offset += 3
   } else if (countFlags < 0xf0) {
     n =
@@ -142,8 +144,8 @@ export function parseLtf8(buffer: Buffer, initialOffset: number) {
 }
 
 export function parseItem<T>(
-  buffer: Buffer,
-  parser: (buffer: Buffer, offset: number) => { offset: number; value: T },
+  buffer: Uint8Array,
+  parser: (buffer: Uint8Array, offset: number) => { offset: number; value: T },
   startBufferPosition = 0,
   startFilePosition = 0,
 ) {
@@ -167,7 +169,6 @@ export function tinyMemoize(_class: any, methodName: any) {
       const res = method.call(this)
       this[memoAttrName] = res
       Promise.resolve(res).catch(() => {
-         
         delete this[memoAttrName]
       })
     }
@@ -178,3 +179,20 @@ 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

@@ -0,0 +1,344 @@
+/*
+ * 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.
+ */
+
+const RangeCoder = require('./arith_sh')
+const IOStream = require('./iostream')
+const ByteModel = require('./byte_model')
+const bzip2 = require('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
+}
+
+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
+
+module.exports = class RangeCoderGen {
+  decode(src) {
+    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
+
+    var 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) {
+    var output = new Uint8Array(n_out)
+
+    var max_sym = stream.ReadByte()
+    if (max_sym == 0) max_sym = 256
+
+    var byte_model = new ByteModel(max_sym)
+
+    var rc = new RangeCoder(stream)
+    rc.RangeStartDecode(stream)
+
+    for (var 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)
+
+    var 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)
+
+    var rc = new RangeCoder(stream)
+    rc.RangeStartDecode(stream)
+
+    var 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) {
+    const bits = bzip2.array(stream.buf.slice(stream.pos))
+    let size = bzip2.header(bits)
+    let chunk
+    const chunks = []
+    do {
+      chunk = bzip2.decompress(bits, size)
+      if (chunk !== -1) {
+        chunks.push(chunk)
+        size -= chunk.length
+      }
+    } while (chunk !== -1)
+    return concatUint8Array(chunks)
+  }
+
+  //----------------------------------------------------------------------
+  // Order-0 RLE codec
+  decodeRLE0(stream, n_out) {
+    var output = new Uint8Array(n_out)
+
+    var 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)
+
+    var 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
+      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]
+      i += run + 1
+    }
+
+    return output
+  }
+
+  //----------------------------------------------------------------------
+  // Order-1 RLE codec
+
+  decodeRLE1(stream, n_out) {
+    var output = new Uint8Array(n_out)
+
+    var 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)
+
+    var model_run = new Array(258)
+    for (var i = 0; i <= 257; i++) model_run[i] = new ByteModel(4)
+
+    var rc = new RangeCoder(stream)
+    rc.RangeStartDecode(stream)
+
+    var 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
+      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]
+      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()
+
+    var 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)
+
+    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) {
+    var stream = new IOStream('', 0, 1024)
+
+    // Count symbols
+    var 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) {
+    var 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()
+
+    // Decode streams
+    var 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)
+    for (var j = 0; j < N; j++) {
+      for (var i = 0; i < ulen[j]; i++) {
+        out[i * N + j] = T[j][i]
+      }
+    }
+
+    return out
+  }
+
+  //----------------------------------------------------------------------
+  // Cat method
+  decodeCat(stream, len) {
+    var out = new Uint8Array(len)
+    for (var i = 0; i < len; i++) out[i] = stream.ReadByte()
+
+    return out
+  }
+}

package/src/htscodecs/arith_sh.js

@@ -0,0 +1,138 @@
+/*
+ * 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
+module.exports = 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 (var 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) {
+    var 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 (var i = 0; i < 5; i++) this.RangeShiftLow(dst)
+  }
+}

package/src/htscodecs/byte_model.js

@@ -0,0 +1,126 @@
+/*
+ * 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
+
+module.exports = class ByteModel {
+  constructor(max_sym = 256) {
+    this.total_freq = max_sym
+    this.max_sym = max_sym - 1
+    this.S = new Array()
+    this.F = new Array()
+
+    for (var i = 0; i <= this.max_sym; i++) {
+      this.S[i] = i
+      this.F[i] = 1
+    }
+  }
+
+  ModelDecode(src, rc) {
+    // Find symbol
+    var freq = rc.RangeGetFrequency(this.total_freq)
+
+    // Linear scan to find cumulative frequency 'freq'
+    var acc = 0
+    var 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
+    var sym = this.S[x]
+    if (x > 0 && this.F[x] > this.F[x - 1]) {
+      var 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 (var 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
+    var 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]) {
+      var 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
+    }
+  }
+}