@datagrok-libraries/bio 6.0.3 → 6.0.6

package/dist/src/ntseq/ntseq.js

@@ -0,0 +1,1349 @@
+var Nt = function () {
+
+  'use strict';
+
+  function makeArray(length, val) {
+    if (val === undefined) {
+      val = 0 | 0;
+    }
+    if (val < 0) {
+      val = 0;
+    }
+    length |= 0;
+    var max = 0;
+    for (var i = length; i !== 0; i >>>= 1) {
+      max++;
+    }
+    var n = Array(max);
+    n[0] = [val];
+    for (i = 1; i < max; i++) {
+      n[i] = n[i - 1].concat(n[i - 1]);
+    }
+    var a = [];
+    for (var i = 0, l = length; l !== 0; l >>>= 1, i++) {
+      if (l & 1) {
+        a = a.concat(n[i]);
+      }
+    }
+    return a;
+  };
+
+  var __bitCount = (function () {
+    var a = new Uint8Array(256);
+    var bin;
+    for (var i = 0; i < 256; i++) {
+      bin = i;
+      bin = bin - ((bin >> 1) & 0x55555555);
+      bin = (bin & 0x33333333) + ((bin >> 2) & 0x33333333);
+      a[i] = (((bin + (bin >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
+    }
+    return a;
+  })();
+
+  var __nucleotideTo4Bit = Object.create(null);
+  __nucleotideTo4Bit['A'] = 8; 			// 0b1000
+  __nucleotideTo4Bit['T'] = 4; 			// 0b0100
+  __nucleotideTo4Bit['G'] = 2; 			// 0b0010
+  __nucleotideTo4Bit['C'] = 1; 			// 0b0001
+
+  function setNucleotide() {
+    var n = arguments[0];
+    __nucleotideTo4Bit[n] = 0;
+    for (var i = 1; i < arguments.length; i++) {
+      __nucleotideTo4Bit[n] |= __nucleotideTo4Bit[arguments[i]];
+    }
+  };
+
+  setNucleotide('-');
+  setNucleotide('W', 'A', 'T');
+  setNucleotide('S', 'G', 'C');
+  setNucleotide('M', 'A', 'C');
+  setNucleotide('K', 'G', 'T');
+  setNucleotide('R', 'A', 'G');
+  setNucleotide('Y', 'C', 'T');
+  setNucleotide('B', 'C', 'G', 'T');
+  setNucleotide('D', 'A', 'G', 'T');
+  setNucleotide('H', 'A', 'C', 'T');
+  setNucleotide('V', 'A', 'C', 'G');
+  setNucleotide('N', 'A', 'T', 'G', 'C');
+
+  var __4BitToNucleotide = (
+    function () {
+      var a = makeArray(16);
+      var keys = Object.keys(__nucleotideTo4Bit);
+      for (var i = 0, len = keys.length; i < len; i++) {
+        a[__nucleotideTo4Bit[keys[i]]] = keys[i];
+      }
+      return a;
+    }
+  )();
+
+  var __nucleotideList = Object.keys(__nucleotideTo4Bit);
+
+  var __complementNucleotide = (
+    function () {
+      var a = Object.create(null);
+      a['A'] = 'T';
+      a['G'] = 'C';
+      a['B'] = 'V';
+      a['H'] = 'D';
+      a['M'] = 'K';
+      a['R'] = 'Y';
+      // S, W, N, - not included
+      var keys = Object.keys(a);
+      for (var i = 0, len = keys.length; i < len; i++) {
+        a[a[keys[i]]] = keys[i];
+      }
+      a['S'] = 'S';
+      a['W'] = 'W';
+      a['N'] = 'N';
+      a['-'] = '-';
+      return a;
+    }
+  )();
+
+  var __complement4Bit = (
+    function () {
+      var a = new Uint8Array(16);
+      for (var i = 0, len = a.length; i < len; i++) {
+        a[i] = __nucleotideTo4Bit[__complementNucleotide[__4BitToNucleotide[i]]];
+      }
+      return a;
+    }
+  )();
+
+  function nucleotideToBin(s) {
+    return __nucleotideTo4Bit[s] | 0;
+  }
+
+  function binToNucleotide(b) {
+    return __4BitToNucleotide[b] || '-';
+  }
+
+  function complementNucleotide(s) {
+    return __complementNucleotide[s] || '-';
+  }
+
+  function complementBin(b) {
+    return __complement4Bit[b] | 0;
+  }
+
+  /* Double up to form bytes */
+  var __byteComplement;
+  var __nucleotidesToByte;
+  var __byteToNucleotides;
+  var __byteNucleotideContent;
+
+  void function () {
+
+    var a = Object.create(null);
+    var b = new Uint8Array(256);
+    var c = new makeArray(256);
+    var d = new makeArray(256);
+
+    var keys = Object.keys(__nucleotideTo4Bit);
+    var len = keys.length;
+    var ki;
+    var kj;
+    var byte;
+
+    for (var i = 0; i < len; i++) {
+      ki = keys[i];
+      for (var j = 0; j < len; j++) {
+        kj = keys[j];
+        byte = __nucleotideTo4Bit[ki] | (__nucleotideTo4Bit[kj] << 4);
+        a[ki + kj] = byte;
+        b[byte] = __nucleotideTo4Bit[complementNucleotide(kj)] | (__nucleotideTo4Bit[complementNucleotide(ki)] << 4);
+        c[byte] = ki + kj;
+        d[byte] = [ki, kj];
+      }
+    }
+
+    __nucleotidesToByte = a;
+    __byteComplement = b;
+    __byteToNucleotides = c;
+    __byteNucleotideContent = d;
+
+  }();
+
+  function nucleotidesToByte(ss) {
+    return __nucleotidesToByte[ss] | 0;
+  }
+
+  /* amino acids */
+
+  var __codonToAminoAcid = Object.create(null);
+  __codonToAminoAcid['AAA'] = 'K';
+  __codonToAminoAcid['AAT'] = 'N';
+  __codonToAminoAcid['AAG'] = 'K';
+  __codonToAminoAcid['AAC'] = 'N';
+  __codonToAminoAcid['ATA'] = 'I';
+  __codonToAminoAcid['ATT'] = 'I';
+  __codonToAminoAcid['ATG'] = 'M';
+  __codonToAminoAcid['ATC'] = 'I';
+  __codonToAminoAcid['AGA'] = 'R';
+  __codonToAminoAcid['AGT'] = 'S';
+  __codonToAminoAcid['AGG'] = 'R';
+  __codonToAminoAcid['AGC'] = 'S';
+  __codonToAminoAcid['ACA'] = 'T';
+  __codonToAminoAcid['ACT'] = 'T';
+  __codonToAminoAcid['ACG'] = 'T';
+  __codonToAminoAcid['ACC'] = 'T';
+  __codonToAminoAcid['TAA'] = '*';
+  __codonToAminoAcid['TAT'] = 'Y';
+  __codonToAminoAcid['TAG'] = '&';
+  __codonToAminoAcid['TAC'] = 'Y';
+  __codonToAminoAcid['TTA'] = 'L';
+  __codonToAminoAcid['TTT'] = 'F';
+  __codonToAminoAcid['TTG'] = 'L';
+  __codonToAminoAcid['TTC'] = 'F';
+  __codonToAminoAcid['TGA'] = '$';
+  __codonToAminoAcid['TGT'] = 'C';
+  __codonToAminoAcid['TGG'] = 'W';
+  __codonToAminoAcid['TGC'] = 'C';
+  __codonToAminoAcid['TCA'] = 'S';
+  __codonToAminoAcid['TCT'] = 'S';
+  __codonToAminoAcid['TCG'] = 'S';
+  __codonToAminoAcid['TCC'] = 'S';
+  __codonToAminoAcid['GAA'] = 'E';
+  __codonToAminoAcid['GAT'] = 'D';
+  __codonToAminoAcid['GAG'] = 'E';
+  __codonToAminoAcid['GAC'] = 'D';
+  __codonToAminoAcid['GTA'] = 'V';
+  __codonToAminoAcid['GTT'] = 'V';
+  __codonToAminoAcid['GTG'] = 'V';
+  __codonToAminoAcid['GTC'] = 'V';
+  __codonToAminoAcid['GGA'] = 'G';
+  __codonToAminoAcid['GGT'] = 'G';
+  __codonToAminoAcid['GGG'] = 'G';
+  __codonToAminoAcid['GGC'] = 'G';
+  __codonToAminoAcid['GCA'] = 'A';
+  __codonToAminoAcid['GCT'] = 'A';
+  __codonToAminoAcid['GCG'] = 'A';
+  __codonToAminoAcid['GCC'] = 'A';
+  __codonToAminoAcid['CAA'] = 'Q';
+  __codonToAminoAcid['CAT'] = 'H';
+  __codonToAminoAcid['CAG'] = 'Q';
+  __codonToAminoAcid['CAC'] = 'H';
+  __codonToAminoAcid['CTA'] = 'L';
+  __codonToAminoAcid['CTT'] = 'L';
+  __codonToAminoAcid['CTG'] = 'L';
+  __codonToAminoAcid['CTC'] = 'L';
+  __codonToAminoAcid['CGA'] = 'R';
+  __codonToAminoAcid['CGT'] = 'R';
+  __codonToAminoAcid['CGG'] = 'R';
+  __codonToAminoAcid['CGC'] = 'R';
+  __codonToAminoAcid['CCA'] = 'P';
+  __codonToAminoAcid['CCT'] = 'P';
+  __codonToAminoAcid['CCG'] = 'P';
+  __codonToAminoAcid['CCC'] = 'P';
+
+  var __12BitToAminoAcid = (function () {
+
+    var a = makeArray(4096, '?');
+    var codons = Object.keys(__codonToAminoAcid);
+    var codon;
+    for (var i = 0, len = codons.length; i < len; i++) {
+      codon = codons[i];
+      a[
+      (nucleotideToBin(codon[2]) << 8) |
+      (nucleotideToBin(codon[1]) << 4) |
+      nucleotideToBin(codon[0])
+        ] = __codonToAminoAcid[codon];
+    }
+
+    return a;
+
+  })();
+
+  function Seq(type) {
+
+    if (type === undefined) {
+      type = 'DNA';
+    }
+
+    if (!{'RNA': true, 'DNA': true}[type]) {
+      throw new Error('Sequence type ' + type + ' not supported');
+    }
+
+    this.__type = type;
+    this.__isRNA = (type === 'RNA');
+
+    this.__endPadding = 0;
+
+    this.__buffer = new ArrayBuffer(4);
+
+    this.__complement = null;
+
+    this.__content = null;
+    this.__fractionalContent = null;
+    this.__contentATGC = null;
+    this.__fractionalContent = null;
+
+  };
+
+  Seq.prototype.read = function (strData) {
+
+    var ntToByte = nucleotidesToByte;
+
+    var nucleotideString = strData.toUpperCase()
+      .replace(/\s/g, '')
+      .replace('U', 'T')
+      .replace(/[^ATGCBVHDMKRYSWN\-]/g, '-');
+
+    var length = nucleotideString.length | 0;
+    var max = length >>> 1;
+    var odd = length & 1;
+
+    var endPadding = (4 - (max + odd) % 4) % 4;
+    this.__endPadding = endPadding;
+
+    var buffer = new ArrayBuffer(max + odd + endPadding + 4);
+    var dataArray = new Int8Array(buffer, 4);
+
+    var n;
+    var byte;
+    var content;
+
+    for (var i = 0; i < max; i++) {
+
+      n = i << 1;
+      dataArray[i] = ntToByte(nucleotideString[n] + nucleotideString[++n]);
+
+    }
+
+    if (odd) {
+
+      dataArray[i] = __nucleotideTo4Bit[nucleotideString[i << 1]];
+
+    }
+
+    this.__buffer = buffer;
+    this.__length = length;
+    (new Uint32Array(buffer, 0, 1))[0] = length;
+
+    this.__complement = null;
+
+    this.__content = null;
+    this.__fractionalContent = null;
+    this.__contentATGC = null;
+    this.__fractionalContent = null;
+
+    return this;
+
+  };
+
+  Seq.prototype.readFASTA = function (strFASTA) {
+
+    var data = strFASTA.split(/\n\r?/gi);
+
+    while (data.length && data[0][0] === '>') {
+      data.shift();
+    }
+
+    return this.read(data.join(''));
+
+  };
+
+  Seq.prototype.readBuffer = function (buffer) {
+
+    this.__buffer = buffer;
+
+    var length = (new Uint32Array(buffer, 0, 1))[0];
+
+    var max = length >>> 1;
+    var odd = length & 1;
+
+    var endPadding = (4 - (max + odd) % 4) % 4;
+    this.__endPadding = endPadding;
+
+    this.__length = length;
+
+    this.__complement = null;
+
+    this.__content = null;
+    this.__fractionalContent = null;
+    this.__contentATGC = null;
+    this.__fractionalContent = null;
+
+    return this;
+
+  };
+
+  Seq.prototype.__byteComplement = function () {
+
+    var bComp = __byteComplement;
+
+    var fwdBuffer = this.__buffer;
+    var len = fwdBuffer.byteLength;
+
+    var n, i;
+
+    var copyBuffer, fromArray, copyArray;
+
+    var isOdd = this.__length & 1;
+
+    if (isOdd) {
+
+      copyBuffer = new ArrayBuffer(len);
+      copyArray = new Uint32Array(copyBuffer, 4);
+      fromArray = new Uint32Array(fwdBuffer, 4);
+
+      n = (len - 4) >>> 2;
+      while (n--) {
+        copyArray[n] = (fromArray[n] << 4) | ((fromArray[n - 1]) >>> 28);
+      }
+
+    } else {
+
+      copyBuffer = fwdBuffer;
+
+    }
+
+    var fwdArray = new Uint8Array(copyBuffer, 4);
+
+    var buffer = new ArrayBuffer(len);
+    var dataArray = new Uint8Array(buffer, 4);
+
+    n = (len - 4) - this.__endPadding;
+    i = 0;
+    while (n--) {
+      dataArray[i++] = bComp[fwdArray[n]];
+    }
+
+    (new Uint32Array(buffer, 0, 1))[0] = this.__length;
+
+    return buffer;
+
+  };
+
+  Seq.prototype.size = function () {
+    return this.__length;
+  };
+
+  Seq.prototype.sequence = function () {
+
+    var byteToNt = __byteToNucleotides;
+    var buffer = this.__buffer;
+
+    if (buffer.byteLength < 4) {
+      return '';
+    }
+
+    var dataArray = new Uint8Array(buffer, 4);
+    var len = (buffer.byteLength - 4) - this.__endPadding;
+
+    var nts = makeArray(len);
+
+    for (var i = 0; i < len; i++) {
+      nts[i] = byteToNt[dataArray[i]];
+    }
+
+    var returnString;
+
+    i = nts.length - 1;
+    if (this.__length & 1) {
+      nts[i] = nts[i][0];
+    }
+
+    returnString = nts.join('');
+
+    if (this.__isRNA) {
+      returnString = returnString.replace(/T/gi, 'U');
+    }
+
+    return returnString;
+
+  };
+
+  Seq.prototype.complement = function () {
+
+    if (!this.__complement) {
+      this.__complement = this.__byteComplement();
+    }
+
+    var complement = new Seq(this.__type).readBuffer(this.__complement.slice(0));
+
+    complement.__complement = this.__buffer.slice(0);
+
+    return complement;
+
+  };
+
+  Seq.prototype.equivalent = function (seq) {
+
+    if (!(seq instanceof Seq)) {
+      throw new Error('Can only check for equivalence between sequences');
+    }
+
+    if (this.__type !== seq.__type) {
+      return false;
+    }
+
+    var checkInts = new Uint32Array(this.__buffer);
+    var compareInts = new Uint32Array(seq.__buffer);
+
+    for (var i = 0, len = checkInts.length; i < len; i++) {
+      if (checkInts[i] !== compareInts[i]) {
+        return false;
+      }
+    }
+
+    return true;
+
+  };
+
+  Seq.prototype.replicate = function (start, length) {
+
+    start |= 0;
+
+    if (start < 0) {
+      start = this.__length + start;
+    }
+
+    if (length === undefined) {
+
+      if (start === 0) {
+
+        return this.__clone();
+
+      }
+
+      length = this.__length - start;
+
+    } else {
+
+      length |= 0;
+      length = Math.min(length, this.__length - start);
+
+    }
+
+    length = Math.min(length, this.__length - start);
+
+    if (length <= 0) {
+
+      return this.__nullSeq();
+
+    }
+
+    return this.__slice(start, length);
+
+  };
+
+  Seq.prototype.polymerize = function (seq) {
+
+    var seqLen = seq.__length;
+
+    if (!(seq instanceof Seq)) {
+      throw new Error('.polymerize requires valid sequence');
+    }
+
+    if (!this.__length) {
+      return seq.__clone();
+    }
+
+    var offset = this.__length;
+    var length = this.__length + seqLen;
+
+    var max = length >>> 1;
+    var odd = length & 1;
+
+    var endPadding = (4 - (max + odd) % 4) % 4;
+    var newBuffer = new ArrayBuffer(max + odd + endPadding + 4);
+    var newArray = new Uint32Array(newBuffer, 4);
+
+    var copyBuffer = this.__buffer;
+    var copyArray = new Uint32Array(copyBuffer, 4);
+
+    var seqBuffer = seq.__buffer;
+    var seqArray = new Uint32Array(seqBuffer, 4);
+
+    var copyPos = 0;
+    var shift = (this.__length % 8) * 4;
+    var shiftSeq = 32 - shift;
+
+    for (var len = copyArray.length; copyPos < len; copyPos++) {
+      newArray[copyPos] = copyArray[copyPos];
+    }
+
+    if (shift) {
+
+      newArray[--copyPos] |= seqArray[0] << shift;
+
+      for (var i = 0, len = seqArray.length; i < len; i++) {
+        newArray[++copyPos] = (seqArray[i] >>> shiftSeq) | (seqArray[i + 1] << shift);
+      }
+
+    } else {
+
+      for (var i = 0, len = seqArray.length; i < len; i++) {
+        newArray[copyPos++] = seqArray[i];
+      }
+
+    }
+
+    (new Uint32Array(newBuffer, 0, 1))[0] = length;
+
+    return new Seq(this.__type).readBuffer(newBuffer);
+
+  };
+
+  Seq.prototype.insertion = function (seq, offset) {
+
+    if (!(seq instanceof Seq)) {
+      throw new Error('Insertion requires valid sequence');
+    }
+
+    offset |= 0;
+
+    if (offset < 0) {
+      offset = this.__length + offset;
+    }
+
+    offset = Math.min(offset, this.__length);
+
+    return this.replicate(0, offset).polymerize(seq).polymerize(this.replicate(offset));
+
+  };
+
+  Seq.prototype.deletion = function (offset, count) {
+
+    if (offset === undefined || count === undefined) {
+      throw new Error('Must give valid offset and count for deletion');
+    }
+
+    offset |= 0;
+    count |= 0;
+
+    if (count === 0) {
+      return this.__clone();
+    }
+
+    if (count < 0) {
+      throw new Error('Invalid count for deletion');
+    }
+
+    if (offset < 0) {
+      offset = this.__length + offset;
+    }
+
+    offset = Math.min(offset, this.__length);
+
+    return this.replicate(0, offset).polymerize(this.replicate(offset + count));
+
+  };
+
+  Seq.prototype.repeat = function (count) {
+
+    count |= 0;
+
+    var copy = this.replicate();
+    var base = new Seq(this.__type);
+
+    if (count <= 0) {
+      return base;
+    }
+
+    while (true) {
+      if (count & 1) {
+        base = base.polymerize(copy);
+      }
+      count >>>= 1;
+      if (!count) {
+        break;
+      }
+      copy = copy.polymerize(copy);
+    }
+
+    return base;
+
+  };
+
+  Seq.prototype.mask = function (seq) {
+
+    if (!(seq instanceof Seq)) {
+      throw new Error('Can only mask with valid sequence');
+    }
+
+    var newBuffer = this.__buffer.slice(0);
+    var newArray = new Uint32Array(newBuffer, 4);
+    var compareArray = new Uint32Array(seq.__buffer, 4);
+
+    for (var i = 0, len = newArray.length; i < len; i++) {
+      newArray[i] &= compareArray[i];
+    }
+
+    return new Seq(this.__type).readBuffer(newBuffer);
+
+  };
+
+  Seq.prototype.cover = function (seq) {
+
+    if (!(seq instanceof Seq)) {
+      throw new Error('Can only cover with valid sequence');
+    }
+
+    var newBuffer = this.__buffer.slice(0);
+    var newArray = new Uint32Array(newBuffer, 4);
+    var compareArray = new Uint32Array(seq.__buffer, 4);
+
+    for (var i = 0, len = newArray.length; i < len; i++) {
+      newArray[i] |= compareArray[i];
+    }
+
+    return new Seq(this.__type).readBuffer(newBuffer);
+
+  };
+
+  Seq.prototype.__nullSeq = function () {
+
+    return new Seq(this.__type).readBuffer(new ArrayBuffer(4));
+
+  };
+
+  Seq.prototype.__clone = function () {
+
+    return new Seq(this.__type).readBuffer(this.__buffer.slice(0));
+
+  };
+
+  Seq.prototype.__slice = function (start, length) {
+
+    var max = length >>> 1;
+    var odd = length & 1;
+
+    var endPadding = (4 - (max + odd) % 4) % 4;
+    var newBuffer = new ArrayBuffer(max + odd + endPadding + 4);
+    var newArray = new Uint32Array(newBuffer, 4);
+
+    var subBuffer = this.__buffer.slice(4 + (start >>> 1), 4 + (start >>> 1) + newBuffer.byteLength);
+    var subInt32Length = subBuffer.byteLength >>> 2;
+    var subArray = new Uint32Array(subBuffer, 0, subInt32Length);
+
+    if (start & 1) {
+
+      for (var i = 0, len = subArray.length; i < len; i++) {
+        newArray[i] = (subArray[i] >>> 4) | (subArray[i + 1] << 28);
+      }
+
+      var remainder = subBuffer.byteLength - subArray.byteLength;
+      if (remainder) {
+        var remainderArray = new Uint8Array(newBuffer, 4 + (i << 2));
+        var subRemainderArray = new Uint8Array(subBuffer, i << 2);
+        if (newArray.length > 0) {
+          newArray[i - 1] |= subRemainderArray[0] << 28;
+        }
+        for (var i = 0, len = subRemainderArray.length; i < len; i++) {
+          remainderArray[i] = (subRemainderArray[i] >>> 4) | (subRemainderArray[i + 1] << 4);
+        }
+      }
+
+    } else {
+
+      for (var i = 0, len = subArray.length; i < len; i++) {
+        newArray[i] = subArray[i];
+      }
+
+      var remainder = subArray.byteLength - subBuffer.byteLength;
+      if (remainder) {
+        var remainderArray = new Uint8Array(newBuffer, 4 + (i << 2));
+        var subRemainderArray = new Uint8Array(subBuffer, i << 2);
+        for (var i = 0, len = subRemainderArray.length; i < len; i++) {
+          remainderArray[i] = subRemainderArray[i];
+        }
+      }
+
+    }
+
+    var clearShift = ((endPadding * 2) + odd) * 4;
+
+    var clearOut = new Uint32Array(newBuffer, newBuffer.byteLength - 4);
+    clearOut[0] = (clearOut[0] << clearShift) >>> clearShift;
+
+    (new Uint32Array(newBuffer, 0, 1))[0] = length;
+
+    return new Seq(this.__type).readBuffer(newBuffer);
+
+  };
+
+  Seq.prototype.content = function () {
+
+    if (!this.__content) {
+
+      var ntContentByte = makeArray(256);
+
+      var buffer = this.__buffer;
+      var dataArray = new Uint8Array(buffer);
+
+      for (var i = 4; i < buffer.byteLength - this.__endPadding; i++) {
+        ntContentByte[dataArray[i]]++;
+      }
+
+      var binToNt = binToNucleotide;
+      var ntList = __nucleotideList;
+
+      var ntContent = Object.create(null);
+      for (var i = 0, len = ntList.length; i < len; i++) {
+        ntContent[ntList[i]] = 0;
+      }
+
+      for (var i = 0, len = ntContentByte.length; i < len; i++) {
+        if (ntContentByte[i]) {
+          ntContent[binToNt(i & 0xF)] += ntContentByte[i];
+          ntContent[binToNt(i >>> 4)] += ntContentByte[i];
+        }
+      }
+
+      if (this.__length & 1) {
+        ntContent['-']--;
+      }
+
+      if (this.__isRNA) {
+        ntContent['U'] = ntContent['T'];
+        delete ntContent['T'];
+      }
+
+      this.__content = ntContent;
+
+    }
+
+    var returnContent = Object.create(null);
+    var keys = Object.keys(this.__content);
+    for (var i = 0, len = keys.length; i < len; i++) {
+      returnContent[keys[i]] = this.__content[keys[i]];
+    }
+
+    return returnContent;
+
+  };
+
+  Seq.prototype.fractionalContent = function () {
+
+    if (!this.__fractionalContent) {
+
+      var content = this.content();
+      var nts = Object.keys(content);
+      for (var i = 0, len = nts.length; i < len; i++) {
+        content[nts[i]] = content[nts[i]] / this.__length;
+      }
+
+      this.__fractionalContent = content;
+
+    }
+
+    var returnContent = Object.create(null);
+    var keys = Object.keys(this.__fractionalContent);
+    for (var i = 0, len = keys.length; i < len; i++) {
+      returnContent[keys[i]] = this.__fractionalContent[keys[i]];
+    }
+
+    return returnContent;
+
+  };
+
+  Seq.prototype.contentATGC = function () {
+
+    if (!this.__contentATGC) {
+
+      var ntToBin = nucleotideToBin;
+
+      var content = this.content();
+      var nts = Object.keys(content);
+      var contentATGC = Object.create(null);
+      contentATGC['A'] = 0;
+      contentATGC['T'] = 0;
+      contentATGC['G'] = 0;
+      contentATGC['C'] = 0;
+
+      var bits = 0;
+      var nt;
+      var ntBin;
+      var n;
+      var curContent;
+
+      for (var i = 0, len = nts.length; i < len; i++) {
+        nt = nts[i];
+        n = ntToBin(nt);
+        for (bits = 0; n; bits++) {
+          n &= n - 1;
+        }
+
+        ntBin = ntToBin(nt);
+        curContent = content[nts[i]] * (1 / bits);
+
+        contentATGC['A'] += (((ntToBin('A') & ntBin) | 0) && curContent);
+        contentATGC['T'] += (((ntToBin('T') & ntBin) | 0) && curContent);
+        contentATGC['G'] += (((ntToBin('G') & ntBin) | 0) && curContent);
+        contentATGC['C'] += (((ntToBin('C') & ntBin) | 0) && curContent);
+
+      }
+
+      if (this.__isRNA) {
+        contentATGC['U'] = contentATGC['T'];
+        delete contentATGC['T'];
+      }
+
+      this.__contentATGC = contentATGC;
+
+    }
+
+    var returnContent = Object.create(null);
+    var keys = Object.keys(this.__contentATGC);
+    for (var i = 0, len = keys.length; i < len; i++) {
+      returnContent[keys[i]] = this.__contentATGC[keys[i]];
+    }
+
+    return returnContent;
+
+  };
+
+  Seq.prototype.fractionalContentATGC = function () {
+
+    if (!this.__fractionalContentATGC) {
+
+      var content = this.contentATGC();
+      var nts = Object.keys(content);
+      for (var i = 0, len = nts.length; i < len; i++) {
+        content[nts[i]] = content[nts[i]] / this.__length;
+      }
+
+      this.__fractionalContentATGC = content;
+
+    }
+
+    var returnContent = Object.create(null);
+    var keys = Object.keys(this.__fractionalContentATGC);
+    for (var i = 0, len = keys.length; i < len; i++) {
+      returnContent[keys[i]] = this.__fractionalContentATGC[keys[i]];
+    }
+
+    return returnContent;
+
+  };
+
+  Seq.prototype.translate = function (ntOffset, ntCount) {
+
+    var binToAA = __12BitToAminoAcid;
+
+    ntOffset |= 0;
+
+    if (ntCount === undefined) {
+      ntCount = this.__length - ntOffset;
+    }
+
+    ntCount |= 0;
+    ntCount -= (ntCount % 3);
+
+    var offset = (ntOffset >>> 1) + 4;
+    var max = offset + (ntCount >>> 1) + (ntCount & 1);
+
+    var dataArray = new Uint8Array(this.__buffer);
+
+    var aminoAcids = makeArray(ntCount / 3);
+    /**/
+    var aa = 0;
+    var lastByte, byte1, byte2, byte3;
+
+    if ((ntOffset & 1) === 0) {
+
+      for (var i = offset; i < max; i += 3) {
+
+        var byte1 = dataArray[i];
+        var byte2 = dataArray[i + 1];
+        var byte3 = dataArray[i + 2];
+
+        aminoAcids[aa++] = binToAA[byte1 | ((byte2 & 0xF) << 8)];
+        aminoAcids[aa++] = binToAA[(byte3 << 4) | (byte2 >>> 4)];
+
+      }
+
+    } else {
+
+      lastByte = dataArray[offset];
+
+      for (var i = offset + 1; i < max; i += 3) {
+
+        byte1 = dataArray[i];
+        byte2 = dataArray[i + 1];
+        byte3 = dataArray[i + 2];
+
+        aminoAcids[aa++] = binToAA[(lastByte >> 4) | (byte1 << 4)];
+        aminoAcids[aa++] = binToAA[byte2 | ((byte3 & 0xF) << 8)];
+
+        lastByte = byte3;
+
+      }
+
+    }
+
+    if (ntCount & 1) {
+      aminoAcids.pop();
+    }
+
+    return aminoAcids.join('');
+
+  };
+
+  Seq.prototype.translateFrame = function (frame, AAoffset, AAcount) {
+
+    if (frame === undefined) {
+      frame = 0;
+    }
+
+    if (frame !== 0 && frame !== 1 && frame !== 2) {
+      throw new Error('Invalid translation frame, must be 0, 1 or 2.');
+    }
+
+    if (AAoffset === undefined) {
+      return this.translate(frame);
+    }
+
+    if (AAcount === undefined) {
+      return this.translate(frame + ((AAoffset | 0) * 3));
+    }
+
+    return this.translate(frame + ((AAoffset | 0) * 3), (AAcount * 3) | 0);
+
+  };
+
+  Seq.prototype.mapSequence = function (seq, offset) {
+
+    if (!(seq instanceof Seq)) {
+      throw new Error('.mapSequence requires valid Seq');
+    }
+
+    return new MatchMap(seq, this, offset);
+
+  };
+
+  /* MatchResult */
+
+  function MatchResult(matchMap, pos, score) {
+
+    Object.defineProperty(this, '__matchMap', {value: matchMap});
+
+    this.position = pos;
+    this.score = score;
+    this.__align = null;
+
+  };
+
+  MatchResult.prototype.alignment = function () {
+
+    if (!this.__align) {
+      var map = this.__matchMap;
+      if (this.position < 0) {
+        this.__align = (new Nt.Seq())
+          .read('-')
+          .repeat(-this.position)
+          .polymerize(map.__searchSpace.replicate(0, map.__query.__length + this.position));
+      } else if (this.position + map.__query.__length > map.__searchSpace.__length) {
+        this.__align = map.__searchSpace
+          .replicate(this.position)
+          .polymerize((new Nt.Seq()).read('-').repeat(map.__searchSpace.__length - this.position));
+      } else {
+        this.__align = map.__searchSpace.replicate(this.position, map.__query.__length);
+      }
+    }
+    return this.__align;
+
+  };
+
+  MatchResult.prototype.alignmentMask = function () {
+
+    return this.__matchMap.__query.mask(this.alignment());
+
+  };
+
+  MatchResult.prototype.alignmentCover = function () {
+
+    return this.__matchMap.__query.cover(this.alignment());
+
+  };
+
+  /* MatchMap */
+
+  function MatchMap(query, searchSpace, offset) {
+
+    if (!(query instanceof Seq) || !(searchSpace instanceof Seq)) {
+      throw new Error('MatchMap requires valid Seq');
+    }
+
+    this.__query = query.replicate();
+    this.__searchSpace = searchSpace.replicate();
+    this.__results = [];
+    this.__orderedResults = [];
+    this.__matchFrequencyData = null;
+    this.__initialized = false;
+
+    this.__offset = Math.max(0, offset | 0);
+    this.__positionAdjustment = this.__offset - (this.__query.size() - 1);
+
+    this.__debug = {
+      searchTime: null,
+      prepareTime: null,
+      sortTime: null
+    };
+
+  };
+
+  MatchMap.prototype.initialize = function (results) {
+
+    this.__orderedResults = [];
+    this.__matchFrequencyData = null;
+
+    this.__initialized = true;
+
+    var t = (new Date).valueOf();
+
+    if (!results) {
+
+      var dataArray = new Uint32Array(this.__execute(this.__query.__buffer, this.__searchSpace.__buffer));
+
+      this.__debug.searchTime = (-t) + (t = (new Date).valueOf());
+
+      var queryLen = this.__query.size();
+      var searchLen = this.__searchSpace.size();
+      var resultsLen = ((8 - (queryLen % 8)) % 8) + 1;
+      var totalLen = searchLen + queryLen - 1;
+      results = [].slice.call(dataArray, resultsLen, resultsLen + totalLen);
+
+    }
+
+    this.__results = results;
+    this.__debug.prepareTime = (-t) + (t = (new Date).valueOf());
+
+    return this;
+
+  };
+
+  MatchMap.prototype.sort = function () {
+
+    if (!this.__initialized) {
+      throw new Error('MatchMap must be initialized first.');
+    }
+
+    var t = new Date().valueOf();
+
+    if (this.__debug.sortTime !== null) {
+      return this;
+    }
+
+    var adjust = this.__positionAdjustment;
+    this.__orderedResults = this.__results
+      .map(function (v, i) {
+        return {n: i + adjust, s: v};
+      })
+      .sort(function (a, b) {
+        return b.s - a.s;
+      });
+    this.__debug.sortTime = new Date().valueOf() - t;
+    return this;
+
+  };
+
+  MatchMap.prototype.__calculate_p_match = function (query, searchSpace) {
+
+    /*
+      The approximate probability that two randomly chosen nucleotides
+      from QUERY and SEARCH match each other
+    */
+
+    var queryContent = query.fractionalContentATGC();
+    var searchSpaceContent = searchSpace.fractionalContentATGC();
+
+    return (queryContent['A'] * searchSpaceContent['A']) +
+      (queryContent['T'] * searchSpaceContent['T']) +
+      (queryContent['G'] * searchSpaceContent['G']) +
+      (queryContent['C'] * searchSpaceContent['C']);
+
+  };
+
+  MatchMap.prototype.results = function (offset, count) {
+
+    if (!this.__initialized) {
+      throw new Error('MatchMap must be initialized first.');
+    }
+
+    if (offset === undefined) {
+      return this.__results.slice();
+    }
+
+    if (count === undefined) {
+      return this.__results.slice(offset | 0);
+    }
+
+    return this.__results.slice(offset | 0, count | 0);
+
+  };
+
+  MatchMap.prototype.best = function () {
+
+    if (!this.__initialized) {
+      throw new Error('MatchMap must be initialized first.');
+    }
+
+    if (!this.__orderedResults.length) {
+      throw new Error('MatchMap must be sorted first.');
+    }
+
+    var result = this.__orderedResults[0];
+    return new MatchResult(this, result.n, result.s);
+
+  };
+
+  MatchMap.prototype.top = function (n) {
+
+    if (!this.__initialized) {
+      throw new Error('MatchMap must be initialized first.');
+    }
+
+    if (!this.__orderedResults.length) {
+      throw new Error('MatchMap must be sorted first.');
+    }
+
+    var self = this;
+
+    return this.__orderedResults.slice(0, n).map(function (result) {
+      return new MatchResult(self, result.n, result.s);
+    });
+
+  };
+
+  MatchMap.prototype.bottom = function (n) {
+
+    if (!this.__initialized) {
+      throw new Error('MatchMap must be initialized first.');
+    }
+
+    if (!this.__orderedResults.length) {
+      throw new Error('MatchMap must be sorted first.');
+    }
+
+    var self = this;
+
+    var adjust = this.__positionAdjustment;
+    var len = this.__orderedResults.length;
+    return this.__orderedResults.slice(this.__orderedResults.length - n, n).map(function (result) {
+      return new MatchResult(self, result.n, result.s);
+    });
+
+  };
+
+  /* Can be optimized with binary splitting */
+
+  MatchMap.prototype.matchFrequencyData = function () {
+
+    if (!this.__initialized) {
+      throw new Error('MatchMap must be initialized first.');
+    }
+
+    if (!this.__orderedResults.length) {
+      throw new Error('MatchMap must be sorted first.');
+    }
+
+    if (this.__matchFrequencyData) {
+      return this.__matchFrequencyData;
+    }
+
+    var ordered = this.__orderedResults;
+    var matchFrequencyData = makeArray(this.__query.size() + 1);
+
+    var maxMatch = this.__query.size();
+    var lastIndex = 0;
+    var num;
+
+    for (var i = 0, len = ordered.length; i < len; i++) {
+      num = ordered[i].s;
+      if (num < maxMatch) {
+        matchFrequencyData[maxMatch] = i - lastIndex;
+        lastIndex = i;
+        maxMatch = num;
+      }
+      if (num === 0) {
+        matchFrequencyData[0] = len - i;
+        break;
+      }
+    }
+
+    return (this.__matchFrequencyData = matchFrequencyData);
+
+  };
+
+  MatchMap.prototype.__countMatches = function (int, bitCount) {
+
+    int |= int >>> 1;
+    int |= int >>> 2;
+    int &= 0x11111111;
+    int |= int >>> 3;
+    int |= int >>> 6;
+    return bitCount[((int >>> 12) & 0xF0) | (int & 0xF)];
+
+  };
+
+  MatchMap.prototype.__execute = function (queryBuffer, searchSpaceBuffer) {
+
+    var queryInts, spaceInts, queryIntsLength, spaceIntsLength,
+      arrLen, mapBuffer, mapArray,
+      A, B, A1, A2, T, cur, pos, move, i, k,
+      adjustNeg, adjustPos,
+      fnCountMatches, bitCount;
+
+    queryInts = new Uint32Array(queryBuffer, 4);
+    spaceInts = new Uint32Array(searchSpaceBuffer, 4);
+
+    fnCountMatches = this.__countMatches;
+    bitCount = __bitCount;
+
+    queryIntsLength = queryInts.length | 0;
+    spaceIntsLength = spaceInts.length | 0;
+
+    arrLen = (queryIntsLength + spaceIntsLength) << 3;
+    mapBuffer = new ArrayBuffer(4 * arrLen);
+    mapArray = new Uint32Array(mapBuffer);
+
+    for (k = 0 | 0; k < queryIntsLength; k++) {
+
+      A = queryInts[k];
+      cur = (queryIntsLength - k) << 3;
+
+      for (i = 0 | 0; i < spaceIntsLength; i++) {
+        (T = A & spaceInts[i]) && (mapArray[(i << 3) + cur] += fnCountMatches(T, bitCount));
+      }
+
+      A1 = A >>> 4;
+      A2 = A << 4;
+
+      adjustNeg = cur - 1;
+      adjustPos = cur + 1;
+
+      while (A1 || A2) {
+
+        for (i = 0 | 0; i < spaceIntsLength; i++) {
+          B = spaceInts[i];
+          pos = (i << 3);
+
+          (T = A1 & B) && (mapArray[pos + adjustNeg] += fnCountMatches(T, bitCount));
+          (T = A2 & B) && (mapArray[pos + adjustPos] += fnCountMatches(T, bitCount));
+        }
+
+        A1 >>>= 4;
+        A2 <<= 4;
+
+        --adjustNeg;
+        ++adjustPos;
+
+      }
+
+    }
+
+    return mapBuffer;
+
+  };
+
+  return {
+    Seq: Seq,
+    MatchMap: MatchMap
+  };
+
+}();