legit checksums

Adler-32.js

// Adler-32
// Appears simpler than Fletcher, yet even better (possibly due to a = 1).
function adler32(data) {
    var a = 1, b = 0;
    for (var i = 0; i < data.length; i++) {
        a = (a + data[i]) % 65521;
        b = (b + a) % 65521;
    }
    return a | (b << 16);
}

BSD-16.js

// BSD-16
// From: en.wikipedia.org/wiki/BSD_checksum
function bsd16(data) {
    for(var i = 0, c = 0; i < data.length; i++) {
        c = (c >> 1) + ((c & 1) << 15);
        c += data[i];
        c &= 0xffff;
    }
    return c;
}

Fletcher-16, Fletcher-32.js

// Fletcher-16
// More complicated version, might be correct.
function fletcher16(buf) {
    var sum1 = 0xff, sum2 = 0xff;
    var i = 0;
    var len = buf.length;

    while (len) {
        var tlen = len > 20 ? 20 : len;
        len -= tlen;
        do {
            sum2 += sum1 += buf[i++];
        } while (--tlen);
        sum1 = (sum1 & 0xff) + (sum1 >> 8);
        sum2 = (sum2 & 0xff) + (sum2 >> 8);
    }
    sum1 = (sum1 & 0xff) + (sum1 >> 8);
    sum2 = (sum2 & 0xff) + (sum2 >> 8);
    return sum2 << 8 | sum1;
}

// Fletcher-16
// Modulo 255 version, might be incorrect. From: en.wikipedia.org/wiki/Fletcher's_checksum
function fletcher16a(data) {
    var a = 0, b = 0;
    for (var i = 0; i < data.length; i++) {
        a = (a + data[i]) % 255;
        b = (b + a) % 255;
    }
    return a | (b << 8);
}

// Fletcher-32
// May operate on 16-bit words (not bytes).
function fletcher32(data) {
    var _sum1 = 0xffff, _sum2 = 0xffff;
    var words = data.length;
    var dataIndex = 0;
    while (words) {
        var tlen = words > 359 ? 359 : words;
        words -= tlen;
        do {
            _sum2 += _sum1 += data[dataIndex++];
        } while (--tlen);
        _sum1 = ((_sum1 & 0xffff) >>> 0) + (_sum1 >>> 16);
        _sum2 = ((_sum2 & 0xffff) >>> 0) + (_sum2 >>> 16);
    }
    _sum1 = ((_sum1 & 0xffff) >>> 0) + (_sum1 >>> 16);
    _sum2 = ((_sum2 & 0xffff) >>> 0) + (_sum2 >>> 16);
    return ((_sum2 << 16) >>> 0 | _sum1) >>> 0;
}

FNV-32.js

// FNV-32
// 0 = FNV-0, 1 = FNV-1, 2 = FNV-1a
function fnv32(data, mode = 2) {
    var hash = mode ? 0x811c9dc5 : 0;
    for (var i = 0; i < data.length; i++) {
        (mode == 2) && (hash ^= data[i]);
        hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
		(mode < 2)  && (hash ^= data[i]);
	}
	return hash >>> 0;
}

MurmurHash.js

function MurmurHash(key, seed = 0) {
    var m = 3332679571, r = 16;
    var h = seed ^ Math.imul(key.length, m);

    for(var i = 0, chunk = -4 & key.length; i < chunk; i += 4) {
        h += key[i+3] << 24 | key[i+2] << 16 | key[i+1] << 8 | key[i];
        h = Math.imul(h, m);
        h ^= h >>> r;
    }

    switch(3 & key.length) {
        case 3: h += key[i+2] << 16;
        case 2: h += key[i+1] << 8;
        case 1: h += key[i],
                h = Math.imul(h, m);
                h ^= h >>> r;
    }

    h = Math.imul(h, m);
    h ^= h >>> 10;
    h = Math.imul(h, m);
    h ^= h >>> 17;

    return h >>> 0;
}

MurmurHash2.js

function MurmurHash2(key, seed = 0) {
    var m = 1540483477, r = 24;
    var h = seed ^ key.length;

    for(var i = 0, k, chunk = -4 & key.length; i < chunk; i += 4) {
        k = key[i+3] << 24 | key[i+2] << 16 | key[i+1] << 8 | key[i];
        k = Math.imul(k, m);
        k ^= k >>> r;
        k = Math.imul(k, m);
        h = Math.imul(h, m) ^ k;
    }

    switch (3 & key.length) {
        case 3: h ^= key[i + 2] << 16;
        case 2: h ^= key[i + 1] << 8;
        case 1: h ^= key[i];
                h = Math.imul(h, m);
    }

    h ^= h >>> 13;
    h = Math.imul(h, m);
    h ^= h >>> 15;

    return h >>> 0;
}

MurmurHash3.js

function MurmurHash3(key, seed = 0) {
    function rotl32(x, r) {
        return (x << r) | (x >>> (32 - r));
    }

    var c1 = 3432918353, c2 = 461845907;
    var h = seed;

    for(var i = 0, k, chunk = -4 & key.length; i < chunk; i += 4) {
        k = key[i+3] << 24 | key[i+2] << 16 | key[i+1] << 8 | key[i];
        k = Math.imul(k, c1);
        k = rotl32(k, 15);
        k = Math.imul(k, c2);
        h ^= k;
        h = rotl32(h, 13);
        h = Math.imul(h, 5) + 3864292196;
    }

    k = 0;
    switch (3 & key.length) {
        case 3: k ^= key[i+2] << 16;
        case 2: k ^= key[i+1] << 8;
        case 1: k ^= key[i];
                k = Math.imul(k, c1);
                k = rotl32(k, 15);
                k = Math.imul(k, c2);
                h ^= k;
    }

    h ^= key.length;
    h ^= h >>> 16;
    h = Math.imul(h, 2246822507);
    h ^= h >>> 13;
    h = Math.imul(h, 3266489909);
    h ^= h >>> 16;

    return h >>> 0;
}

zzz____MurmurHash_old.js

// MurmurHash 1
function MurmurHash1(data, seed = 0) {
    function mul32(n, u) {
        return ((u - (0xffff&u)) * n |0) + ((0xffff&u) * n |0) |0;
    }
    var m = 0xc6a4a793, h = seed ^ mul32(data.length, m);

    for(var i = 0, round = data.length & ~3; i < round; i += 4) {
        h += (data[i]) | ((data[i+1])<<8) | ((data[i+2])<<16) | ((data[i+3])<<24);
        h = mul32(h, m);
        h ^= h >>> 16;
    }
    
    switch(data.length & 3) {
        case 3: h += data[i + 2] << 16;
        case 2: h += data[i + 1] << 8;
        case 1: h += data[i + 0], h = mul32(h, m), h ^= h >>> 16;
    };
    
    h = mul32(h, m), h ^= h >>> 10;
    h = mul32(h, m), h ^= h >>> 17;
    
    return h >>> 0;
}

// MurmurHash 2
function MurmurHash2(data, seed = 0) {
    function mul32(n, u) {
        return ((u - (0xffff&u)) * n |0) + ((0xffff&u) * n |0) |0;
    }
    var m = 0x5bd1e995, h = seed ^ data.length, k;

    for(var i = 0, round = data.length & ~3; i < round; i += 4) {
        k = (data[i]) | ((data[i+1])<<8) | ((data[i+2])<<16) | ((data[i+3])<<24);
        k = mul32(k, m), k ^= k >>> 24;
        k = mul32(k, m);
        h = mul32(h, m) ^ k;
    }

    switch (data.length & 3) {
        case 3: h ^= data[i + 2] << 16;
        case 2: h ^= data[i + 1] << 8;
        case 1: h ^= data[i], h = mul32(h, m);
    }

    h ^= h >>> 13;
    h = mul32(h, m), h ^= h >>> 15;

    return h >>> 0;
}

// MurmurHash3
function MurmurHash3(data, seed = 0) {
    function mul32(n, u) {
        return ((u - (0xffff&u)) * n |0) + ((0xffff&u) * n |0) |0;
    }
    var m1 = 0xcc9e2d51, m2 = 0x1b873593, h = seed, k;

    for (var i = 0, round = data.length & ~3; i < round; i += 4) {
        k = (data[i]) | ((data[i+1])<<8) | ((data[i+2])<<16) | ((data[i+3])<<24);
        k = mul32(k, m1);
        k = ((k & 0x1ffff) << 15) | (k >>> 17);
        k = mul32(k, m2);
        h ^= k;
        h = ((h & 0x7ffff) << 13) | (h >>> 19);
        h = (h * 5 + 0xe6546b64) | 0;
    }

    k = 0;
    switch (data.length & 3) {
        case 3: k  = (data[i + 2]) << 16;
        case 2: k |= (data[i + 1]) << 8;
        case 1:
            k |= (data[i]);
            k = mul32(k, m1);
            k = ((k & 0x1ffff) << 15) | (k >>> 17);
            k = mul32(k, m2);
            h ^= k;
    }

    h ^= data.length;
    h ^= h >>> 16;
    h = mul32(h, 0x85ebca6b), h ^= h >>> 13;
    h = mul32(h, 0xc2b2ae35), h ^= h >>> 16;

    return h >>> 0;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


// old shit here


// MurmurHash3
// version 1, optimized
function MurmurHash3(data, seed = 0) {
    function mul32(m, n) {
        var nlo = n & 0xffff, nhi = n - nlo;
        return ((nhi * m | 0) + (nlo * m | 0)) | 0;
    }
    var c1 = 0xcc9e2d51, c2 = 0x1b873593;
    var h1 = seed, roundedEnd = data.length & ~0x3;
    for (var i = 0; i < roundedEnd; i += 4) {
        var k1 = (data[i] & 0xff) |
            ((data[i + 1] & 0xff) << 8) |
            ((data[i + 2] & 0xff) << 16) |
            ((data[i + 3] & 0xff) << 24);
        k1 = mul32(k1, c1);
        k1 = ((k1 & 0x1ffff) << 15) | (k1 >>> 17);
        k1 = mul32(k1, c2);
        h1 ^= k1;
        h1 = ((h1 & 0x7ffff) << 13) | (h1 >>> 19);
        h1 = (h1 * 5 + 0xe6546b64) | 0;
    }
    k1 = 0;
    switch (data.length % 4) {
        case 3:
            k1 = (data[roundedEnd + 2] & 0xff) << 16;
        case 2:
            k1 |= (data[roundedEnd + 1] & 0xff) << 8;
        case 1:
            k1 |= (data[roundedEnd] & 0xff);
            k1 = mul32(k1, c1);
            k1 = ((k1 & 0x1ffff) << 15) | (k1 >>> 17);
            k1 = mul32(k1, c2);
            h1 ^= k1;
    }
    h1 ^= data.length;
    h1 ^= h1 >>> 16;
    h1 = mul32(h1, 0x85ebca6b);
    h1 ^= h1 >>> 13;
    h1 = mul32(h1, 0xc2b2ae35);
    h1 ^= h1 >>> 16;
    return h1 >>> 0;
}

// MurmurHash2
// incorrect version.
function MurmurHash2(data, seed = 0) {
    var l = data.length, h = seed ^ l, i = 0, k;
    while (l >= 4) {
    k = (data[i] & 0xff) |
        ((data[++i] & 0xff) << 8) |
        ((data[++i] & 0xff) << 16) |
        ((data[++i] & 0xff) << 24);
    k = (((k & 0xffff) * 0x5bd1e995) + ((((k >>> 16) * 0x5bd1e995) & 0xffff) << 16));
    k ^= k >>> 24;
    k = (((k & 0xffff) * 0x5bd1e995) + ((((k >>> 16) * 0x5bd1e995) & 0xffff) << 16));
    h = (((h & 0xffff) * 0x5bd1e995) + ((((h >>> 16) * 0x5bd1e995) & 0xffff) << 16)) ^ k;
    l -= 4;
    ++i;
  }
  switch (l) {
  case 3: h ^= (data[i + 2] & 0xff) << 16;
  case 2: h ^= (data[i + 1] & 0xff) << 8;
  case 1: h ^= (data[i] & 0xff);
          h = (((h & 0xffff) * 0x5bd1e995) + ((((h >>> 16) * 0x5bd1e995) & 0xffff) << 16));
  }
  h ^= h >>> 13;
  h = (((h & 0xffff) * 0x5bd1e995) + ((((h >>> 16) * 0x5bd1e995) & 0xffff) << 16));
  h ^= h >>> 15;
  return h >>> 0;
}

// MurmurHash3
// version 2, alternate
function MurmurHash3a(data, seed = 0) {
    var remainder = data.length & 3, bytes = data.length - remainder, h1 = seed, h1b,
    c1 = 0xcc9e2d51, c1b, c2 = 0x1b873593, c2b, k1, i = 0;
    while (i < bytes) {
        k1 = ((data[i] & 0xff)) |
          ((data[++i] & 0xff) << 8) |
          ((data[++i] & 0xff) << 16) |
          ((data[++i] & 0xff) << 24);
        ++i;
        k1 = ((((k1 & 0xffff) * c1) + ((((k1 >>> 16) * c1) & 0xffff) << 16))) & 0xffffffff;
        k1 = (k1 << 15) | (k1 >>> 17);
        k1 = ((((k1 & 0xffff) * c2) + ((((k1 >>> 16) * c2) & 0xffff) << 16))) & 0xffffffff;
        h1 ^= k1;
        h1 = (h1 << 13) | (h1 >>> 19);
        h1b = ((((h1 & 0xffff) * 5) + ((((h1 >>> 16) * 5) & 0xffff) << 16))) & 0xffffffff;
        h1 = (((h1b & 0xffff) + 0x6b64) + ((((h1b >>> 16) + 0xe654) & 0xffff) << 16));
    }
    k1 = 0;
    switch (remainder) {
        case 3: k1 ^= (data[i + 2] & 0xff) << 16;
        case 2: k1 ^= (data[i + 1] & 0xff) << 8;
        case 1: k1 ^= (data[i] & 0xff);
        k1 = (((k1 & 0xffff) * c1) + ((((k1 >>> 16) * c1) & 0xffff) << 16)) & 0xffffffff;
        k1 = (k1 << 15) | (k1 >>> 17);
        k1 = (((k1 & 0xffff) * c2) + ((((k1 >>> 16) * c2) & 0xffff) << 16)) & 0xffffffff;
        h1 ^= k1;
    }
    h1 ^= data.length;
    h1 ^= h1 >>> 16;
    h1 = (((h1 & 0xffff) * 0x85ebca6b) + ((((h1 >>> 16) * 0x85ebca6b) & 0xffff) << 16)) & 0xffffffff;
    h1 ^= h1 >>> 13;
    h1 = ((((h1 & 0xffff) * 0xc2b2ae35) + ((((h1 >>> 16) * 0xc2b2ae35) & 0xffff) << 16))) & 0xffffffff;
    h1 ^= h1 >>> 16;
    return h1 >>> 0;
}