@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/esm/utils/murmur3/common.js

@@ -1,39 +0,0 @@
-import { stringSource, stringDestination, encodeUTF16toUTF8 } from './utfx';
-export function UTF16ToUTF8(key) {
-    var sd;
-    encodeUTF16toUTF8(stringSource(key), sd = stringDestination());
-    return sd();
-}
-/*!
- * +----------------------------------------------------------------------------------+
- * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |
- * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms.      |
- * |----------------------------------------------------------------------------------|
- * | Copyright (c) 2012-2020 Karan Lyons. Freely distributable under the MIT license. |
- * +----------------------------------------------------------------------------------+
- */
-export function x86Multiply(m, n) {
-    //
-    // Given two 32bit ints, returns the two multiplied together as a
-    // 32bit int.
-    //
-    return ((m & 0xffff) * n) + ((((m >>> 16) * n) & 0xffff) << 16);
-}
-export function x86Rotl(m, n) {
-    //
-    // Given a 32bit int and an int representing a number of bit positions,
-    // returns the 32bit int rotated left by that number of positions.
-    //
-    return (m << n) | (m >>> (32 - n));
-}
-export function x86Fmix(h) {
-    //
-    // Given a block, returns murmurHash3's final x86 mix of that block.
-    //
-    h ^= h >>> 16;
-    h = x86Multiply(h, 0x85ebca6b);
-    h ^= h >>> 13;
-    h = x86Multiply(h, 0xc2b2ae35);
-    h ^= h >>> 16;
-    return h;
-}

package/esm/utils/murmur3/legacy.js

@@ -1,39 +0,0 @@
-// Deprecated hashing function, used for split bucketing. Replaced by murmur3
-//
-// JAVA reference implementation for the hashing function.
-//
-// int h = 0;
-// for (int i = 0; i < key.length(); i++) {
-//     h = 31 * h + key.charAt(i);
-// }
-// return h ^ seed; // XOR the hash and seed
-//
-function ToInteger(x) {
-    x = Number(x);
-    return x < 0 ? Math.ceil(x) : Math.floor(x);
-}
-function modulo(a, b) {
-    return a - Math.floor(a / b) * b;
-}
-function ToUint32(x) {
-    return modulo(ToInteger(x), Math.pow(2, 32));
-}
-function ToInt32(x) {
-    var uint32 = ToUint32(x);
-    if (uint32 >= Math.pow(2, 31)) {
-        return uint32 - Math.pow(2, 32);
-    }
-    else {
-        return uint32;
-    }
-}
-export function hash(str, seed) {
-    var h = 0;
-    for (var i = 0; i < str.length; i++) {
-        h = ToInt32(ToInt32(31 * h) + str.charCodeAt(i));
-    }
-    return ToInt32(h ^ seed);
-}
-export function bucket(str, seed) {
-    return Math.abs(hash(str, seed) % 100) + 1;
-}

package/esm/utils/murmur3/murmur3.js

@@ -1,57 +0,0 @@
-/* eslint-disable no-fallthrough */
-import { UTF16ToUTF8, x86Fmix, x86Multiply, x86Rotl } from './common';
-/*
- * +----------------------------------------------------------------------------------+
- * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |
- * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms.      |
- * |----------------------------------------------------------------------------------|
- * | Copyright (c) 2012-2020 Karan Lyons. Freely distributable under the MIT license. |
- * +----------------------------------------------------------------------------------+
- */
-// PUBLIC FUNCTIONS
-// ----------------
-function hash32(key, seed) {
-    //
-    // Given a string and an optional seed as an int, returns a 32 bit hash
-    // using the x86 flavor of MurmurHash3, as an unsigned int.
-    //
-    key = key || '';
-    seed = seed || 0;
-    var remainder = key.length % 4;
-    var bytes = key.length - remainder;
-    var h1 = seed;
-    var k1 = 0;
-    var c1 = 0xcc9e2d51;
-    var c2 = 0x1b873593;
-    for (var i = 0; i < bytes; i = i + 4) {
-        k1 = ((key.charCodeAt(i) & 0xff)) | ((key.charCodeAt(i + 1) & 0xff) << 8) | ((key.charCodeAt(i + 2) & 0xff) << 16) | ((key.charCodeAt(i + 3) & 0xff) << 24);
-        k1 = x86Multiply(k1, c1);
-        k1 = x86Rotl(k1, 15);
-        k1 = x86Multiply(k1, c2);
-        h1 ^= k1;
-        h1 = x86Rotl(h1, 13);
-        h1 = x86Multiply(h1, 5) + 0xe6546b64;
-    }
-    k1 = 0;
-    switch (remainder) {
-        case 3:
-            k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
-        case 2:
-            k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
-        case 1:
-            k1 ^= (key.charCodeAt(i) & 0xff);
-            k1 = x86Multiply(k1, c1);
-            k1 = x86Rotl(k1, 15);
-            k1 = x86Multiply(k1, c2);
-            h1 ^= k1;
-    }
-    h1 ^= key.length;
-    h1 = x86Fmix(h1);
-    return h1 >>> 0;
-}
-export function hash(str, seed) {
-    return hash32(UTF16ToUTF8(str), seed >>> 0);
-}
-export function bucket(str, seed) {
-    return Math.abs(hash(str, seed) % 100) + 1;
-}

package/esm/utils/murmur3/murmur3_128.js

@@ -1,215 +0,0 @@
-/* eslint-disable no-fallthrough */
-import { UTF16ToUTF8 } from './common';
-/*
- * +----------------------------------------------------------------------------------+
- * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |
- * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms.      |
- * |----------------------------------------------------------------------------------|
- * | Copyright (c) 2012-2020 Karan Lyons. Freely distributable under the MIT license. |
- * +----------------------------------------------------------------------------------+
- */
-// PRIVATE FUNCTIONS
-// -----------------
-function _x64Add(m, n) {
-    //
-    // Given two 64bit ints (as an array of two 32bit ints) returns the two
-    // added together as a 64bit int (as an array of two 32bit ints).
-    //
-    m = [m[0] >>> 16, m[0] & 0xffff, m[1] >>> 16, m[1] & 0xffff];
-    n = [n[0] >>> 16, n[0] & 0xffff, n[1] >>> 16, n[1] & 0xffff];
-    var o = [0, 0, 0, 0];
-    o[3] += m[3] + n[3];
-    o[2] += o[3] >>> 16;
-    o[3] &= 0xffff;
-    o[2] += m[2] + n[2];
-    o[1] += o[2] >>> 16;
-    o[2] &= 0xffff;
-    o[1] += m[1] + n[1];
-    o[0] += o[1] >>> 16;
-    o[1] &= 0xffff;
-    o[0] += m[0] + n[0];
-    o[0] &= 0xffff;
-    return [(o[0] << 16) | o[1], (o[2] << 16) | o[3]];
-}
-function _x64Multiply(m, n) {
-    //
-    // Given two 64bit ints (as an array of two 32bit ints) returns the two
-    // multiplied together as a 64bit int (as an array of two 32bit ints).
-    //
-    m = [m[0] >>> 16, m[0] & 0xffff, m[1] >>> 16, m[1] & 0xffff];
-    n = [n[0] >>> 16, n[0] & 0xffff, n[1] >>> 16, n[1] & 0xffff];
-    var o = [0, 0, 0, 0];
-    o[3] += m[3] * n[3];
-    o[2] += o[3] >>> 16;
-    o[3] &= 0xffff;
-    o[2] += m[2] * n[3];
-    o[1] += o[2] >>> 16;
-    o[2] &= 0xffff;
-    o[2] += m[3] * n[2];
-    o[1] += o[2] >>> 16;
-    o[2] &= 0xffff;
-    o[1] += m[1] * n[3];
-    o[0] += o[1] >>> 16;
-    o[1] &= 0xffff;
-    o[1] += m[2] * n[2];
-    o[0] += o[1] >>> 16;
-    o[1] &= 0xffff;
-    o[1] += m[3] * n[1];
-    o[0] += o[1] >>> 16;
-    o[1] &= 0xffff;
-    o[0] += (m[0] * n[3]) + (m[1] * n[2]) + (m[2] * n[1]) + (m[3] * n[0]);
-    o[0] &= 0xffff;
-    return [(o[0] << 16) | o[1], (o[2] << 16) | o[3]];
-}
-function _x64Rotl(m, n) {
-    //
-    // Given a 64bit int (as an array of two 32bit ints) and an int
-    // representing a number of bit positions, returns the 64bit int (as an
-    // array of two 32bit ints) rotated left by that number of positions.
-    //
-    n %= 64;
-    if (n === 32) {
-        return [m[1], m[0]];
-    }
-    else if (n < 32) {
-        return [(m[0] << n) | (m[1] >>> (32 - n)), (m[1] << n) | (m[0] >>> (32 - n))];
-    }
-    else {
-        n -= 32;
-        return [(m[1] << n) | (m[0] >>> (32 - n)), (m[0] << n) | (m[1] >>> (32 - n))];
-    }
-}
-function _x64LeftShift(m, n) {
-    //
-    // Given a 64bit int (as an array of two 32bit ints) and an int
-    // representing a number of bit positions, returns the 64bit int (as an
-    // array of two 32bit ints) shifted left by that number of positions.
-    //
-    n %= 64;
-    if (n === 0) {
-        return m;
-    }
-    else if (n < 32) {
-        return [(m[0] << n) | (m[1] >>> (32 - n)), m[1] << n];
-    }
-    else {
-        return [m[1] << (n - 32), 0];
-    }
-}
-function _x64Xor(m, n) {
-    //
-    // Given two 64bit ints (as an array of two 32bit ints) returns the two
-    // xored together as a 64bit int (as an array of two 32bit ints).
-    //
-    return [m[0] ^ n[0], m[1] ^ n[1]];
-}
-function _x64Fmix(h) {
-    //
-    // Given a block, returns murmurHash3's final x64 mix of that block.
-    // (`[0, h[0] >>> 1]` is a 33 bit unsigned right shift. This is the
-    // only place where we need to right shift 64bit ints.)
-    //
-    h = _x64Xor(h, [0, h[0] >>> 1]);
-    h = _x64Multiply(h, [0xff51afd7, 0xed558ccd]);
-    h = _x64Xor(h, [0, h[0] >>> 1]);
-    h = _x64Multiply(h, [0xc4ceb9fe, 0x1a85ec53]);
-    h = _x64Xor(h, [0, h[0] >>> 1]);
-    return h;
-}
-// PUBLIC FUNCTIONS
-// ----------------
-function hash128x64(key, seed) {
-    //
-    // Given a string and an optional seed as an int, returns a 128 bit
-    // hash using the x64 flavor of MurmurHash3, as an unsigned hex.
-    //
-    key = key || '';
-    seed = seed || 0;
-    var remainder = key.length % 16;
-    var bytes = key.length - remainder;
-    var h1 = [0, seed];
-    var h2 = [0, seed];
-    var k1 = [0, 0];
-    var k2 = [0, 0];
-    var c1 = [0x87c37b91, 0x114253d5];
-    var c2 = [0x4cf5ad43, 0x2745937f];
-    for (var i = 0; i < bytes; i = i + 16) {
-        k1 = [((key.charCodeAt(i + 4) & 0xff)) | ((key.charCodeAt(i + 5) & 0xff) << 8) | ((key.charCodeAt(i + 6) & 0xff) << 16) | ((key.charCodeAt(i + 7) & 0xff) << 24), ((key.charCodeAt(i) & 0xff)) | ((key.charCodeAt(i + 1) &
-                0xff) << 8) | ((key.charCodeAt(i + 2) & 0xff) << 16) | ((key.charCodeAt(i + 3) & 0xff) << 24)];
-        k2 = [((key.charCodeAt(i + 12) & 0xff)) | ((key.charCodeAt(i + 13) & 0xff) << 8) | ((key.charCodeAt(i + 14) & 0xff) << 16) | ((key.charCodeAt(i + 15) & 0xff) << 24), ((key.charCodeAt(i + 8) & 0xff)) | ((key.charCodeAt(i +
-                9) & 0xff) << 8) | ((key.charCodeAt(i + 10) & 0xff) << 16) | ((key.charCodeAt(i + 11) & 0xff) << 24)];
-        k1 = _x64Multiply(k1, c1);
-        k1 = _x64Rotl(k1, 31);
-        k1 = _x64Multiply(k1, c2);
-        h1 = _x64Xor(h1, k1);
-        h1 = _x64Rotl(h1, 27);
-        h1 = _x64Add(h1, h2);
-        h1 = _x64Add(_x64Multiply(h1, [0, 5]), [0, 0x52dce729]);
-        k2 = _x64Multiply(k2, c2);
-        k2 = _x64Rotl(k2, 33);
-        k2 = _x64Multiply(k2, c1);
-        h2 = _x64Xor(h2, k2);
-        h2 = _x64Rotl(h2, 31);
-        h2 = _x64Add(h2, h1);
-        h2 = _x64Add(_x64Multiply(h2, [0, 5]), [0, 0x38495ab5]);
-    }
-    k1 = [0, 0];
-    k2 = [0, 0];
-    switch (remainder) {
-        case 15:
-            k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 14)], 48));
-        case 14:
-            k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 13)], 40));
-        case 13:
-            k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 12)], 32));
-        case 12:
-            k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 11)], 24));
-        case 11:
-            k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 10)], 16));
-        case 10:
-            k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 9)], 8));
-        case 9:
-            k2 = _x64Xor(k2, [0, key.charCodeAt(i + 8)]);
-            k2 = _x64Multiply(k2, c2);
-            k2 = _x64Rotl(k2, 33);
-            k2 = _x64Multiply(k2, c1);
-            h2 = _x64Xor(h2, k2);
-        case 8:
-            k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 7)], 56));
-        case 7:
-            k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 6)], 48));
-        case 6:
-            k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 5)], 40));
-        case 5:
-            k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 4)], 32));
-        case 4:
-            k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 3)], 24));
-        case 3:
-            k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 2)], 16));
-        case 2:
-            k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 1)], 8));
-        case 1:
-            k1 = _x64Xor(k1, [0, key.charCodeAt(i)]);
-            k1 = _x64Multiply(k1, c1);
-            k1 = _x64Rotl(k1, 31);
-            k1 = _x64Multiply(k1, c2);
-            h1 = _x64Xor(h1, k1);
-    }
-    h1 = _x64Xor(h1, [0, key.length]);
-    h2 = _x64Xor(h2, [0, key.length]);
-    h1 = _x64Add(h1, h2);
-    h2 = _x64Add(h2, h1);
-    h1 = _x64Fmix(h1);
-    h2 = _x64Fmix(h2);
-    h1 = _x64Add(h1, h2);
-    h2 = _x64Add(h2, h1);
-    return ('00000000' + (h1[0] >>> 0).toString(16)).slice(-8) + ('00000000' + (h1[1] >>> 0).toString(16)).slice(-8) + ('00000000' + (h2[0] >>> 0).toString(16)).slice(-8) + ('00000000' + (h2[1] >>> 0).toString(16)).slice(-8);
-}
-/**
- * x64 version of Murmur3 for 128bits.
- *
- * @param str - The string to hash.
- */
-export function hash128(str, seed) {
-    return hash128x64(UTF16ToUTF8(str), seed >>> 0);
-}

package/esm/utils/murmur3/murmur3_128_x86.js

@@ -1,150 +0,0 @@
-/* eslint-disable no-fallthrough */
-import { UTF16ToUTF8, x86Fmix, x86Multiply, x86Rotl } from './common';
-/*!
- * +----------------------------------------------------------------------------------+
- * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |
- * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms.      |
- * |----------------------------------------------------------------------------------|
- * | Copyright (c) 2012-2020 Karan Lyons. Freely distributable under the MIT license. |
- * +----------------------------------------------------------------------------------+
- */
-// PUBLIC FUNCTIONS
-// ----------------
-function hash128x86(key, seed) {
-    //
-    // Given a string and an optional seed as an int, returns a 128 bit
-    // hash using the x86 flavor of MurmurHash3, as an unsigned hex.
-    //
-    key = key || '';
-    seed = seed || 0;
-    var remainder = key.length % 16;
-    var bytes = key.length - remainder;
-    var h1 = seed;
-    var h2 = seed;
-    var h3 = seed;
-    var h4 = seed;
-    var k1 = 0;
-    var k2 = 0;
-    var k3 = 0;
-    var k4 = 0;
-    var c1 = 0x239b961b;
-    var c2 = 0xab0e9789;
-    var c3 = 0x38b34ae5;
-    var c4 = 0xa1e38b93;
-    for (var i = 0; i < bytes; i = i + 16) {
-        k1 = ((key.charCodeAt(i) & 0xff)) | ((key.charCodeAt(i + 1) & 0xff) << 8) | ((key.charCodeAt(i + 2) & 0xff) << 16) | ((key.charCodeAt(i + 3) & 0xff) << 24);
-        k2 = ((key.charCodeAt(i + 4) & 0xff)) | ((key.charCodeAt(i + 5) & 0xff) << 8) | ((key.charCodeAt(i + 6) & 0xff) << 16) | ((key.charCodeAt(i + 7) & 0xff) << 24);
-        k3 = ((key.charCodeAt(i + 8) & 0xff)) | ((key.charCodeAt(i + 9) & 0xff) << 8) | ((key.charCodeAt(i + 10) & 0xff) << 16) | ((key.charCodeAt(i + 11) & 0xff) << 24);
-        k4 = ((key.charCodeAt(i + 12) & 0xff)) | ((key.charCodeAt(i + 13) & 0xff) << 8) | ((key.charCodeAt(i + 14) & 0xff) << 16) | ((key.charCodeAt(i + 15) & 0xff) << 24);
-        k1 = x86Multiply(k1, c1);
-        k1 = x86Rotl(k1, 15);
-        k1 = x86Multiply(k1, c2);
-        h1 ^= k1;
-        h1 = x86Rotl(h1, 19);
-        h1 += h2;
-        h1 = x86Multiply(h1, 5) + 0x561ccd1b;
-        k2 = x86Multiply(k2, c2);
-        k2 = x86Rotl(k2, 16);
-        k2 = x86Multiply(k2, c3);
-        h2 ^= k2;
-        h2 = x86Rotl(h2, 17);
-        h2 += h3;
-        h2 = x86Multiply(h2, 5) + 0x0bcaa747;
-        k3 = x86Multiply(k3, c3);
-        k3 = x86Rotl(k3, 17);
-        k3 = x86Multiply(k3, c4);
-        h3 ^= k3;
-        h3 = x86Rotl(h3, 15);
-        h3 += h4;
-        h3 = x86Multiply(h3, 5) + 0x96cd1c35;
-        k4 = x86Multiply(k4, c4);
-        k4 = x86Rotl(k4, 18);
-        k4 = x86Multiply(k4, c1);
-        h4 ^= k4;
-        h4 = x86Rotl(h4, 13);
-        h4 += h1;
-        h4 = x86Multiply(h4, 5) + 0x32ac3b17;
-    }
-    k1 = 0;
-    k2 = 0;
-    k3 = 0;
-    k4 = 0;
-    switch (remainder) {
-        case 15:
-            k4 ^= key.charCodeAt(i + 14) << 16;
-        case 14:
-            k4 ^= key.charCodeAt(i + 13) << 8;
-        case 13:
-            k4 ^= key.charCodeAt(i + 12);
-            k4 = x86Multiply(k4, c4);
-            k4 = x86Rotl(k4, 18);
-            k4 = x86Multiply(k4, c1);
-            h4 ^= k4;
-        case 12:
-            k3 ^= key.charCodeAt(i + 11) << 24;
-        case 11:
-            k3 ^= key.charCodeAt(i + 10) << 16;
-        case 10:
-            k3 ^= key.charCodeAt(i + 9) << 8;
-        case 9:
-            k3 ^= key.charCodeAt(i + 8);
-            k3 = x86Multiply(k3, c3);
-            k3 = x86Rotl(k3, 17);
-            k3 = x86Multiply(k3, c4);
-            h3 ^= k3;
-        case 8:
-            k2 ^= key.charCodeAt(i + 7) << 24;
-        case 7:
-            k2 ^= key.charCodeAt(i + 6) << 16;
-        case 6:
-            k2 ^= key.charCodeAt(i + 5) << 8;
-        case 5:
-            k2 ^= key.charCodeAt(i + 4);
-            k2 = x86Multiply(k2, c2);
-            k2 = x86Rotl(k2, 16);
-            k2 = x86Multiply(k2, c3);
-            h2 ^= k2;
-        case 4:
-            k1 ^= key.charCodeAt(i + 3) << 24;
-        case 3:
-            k1 ^= key.charCodeAt(i + 2) << 16;
-        case 2:
-            k1 ^= key.charCodeAt(i + 1) << 8;
-        case 1:
-            k1 ^= key.charCodeAt(i);
-            k1 = x86Multiply(k1, c1);
-            k1 = x86Rotl(k1, 15);
-            k1 = x86Multiply(k1, c2);
-            h1 ^= k1;
-    }
-    h1 ^= key.length;
-    h2 ^= key.length;
-    h3 ^= key.length;
-    h4 ^= key.length;
-    h1 += h2;
-    h1 += h3;
-    h1 += h4;
-    h2 += h1;
-    h3 += h1;
-    h4 += h1;
-    h1 = x86Fmix(h1);
-    h2 = x86Fmix(h2);
-    h3 = x86Fmix(h3);
-    h4 = x86Fmix(h4);
-    h1 += h2;
-    h1 += h3;
-    h1 += h4;
-    h2 += h1;
-    h3 += h1;
-    h4 += h1;
-    return ('00000000' + (h1 >>> 0).toString(16)).slice(-8) + ('00000000' + (h2 >>> 0).toString(16)).slice(-8) + ('00000000' + (h3 >>> 0).toString(16)).slice(-8) + ('00000000' + (h4 >>> 0).toString(16)).slice(-8);
-}
-/**
- * x86 version of Murmur3 for 128bits.
- * Used by hashImpression128 because in JS it is more efficient than the x64 version, no matter the underlying OS/CPU arch.
- *
- * @param str - The string to hash.
- */
-export function hash128(str, seed) {
-    return hash128x86(UTF16ToUTF8(str), seed >>> 0);
-}

package/esm/utils/murmur3/murmur3_64.js

@@ -1,32 +0,0 @@
-import { hash128 } from './murmur3_128';
-/**
- * Use instead of parseInt, to not lose precision when converting big integers (greater than 2^53 - 1)
- */
-function hex2dec(s) {
-    var i, j, digits = [0], carry;
-    for (i = 0; i < s.length; i += 1) {
-        carry = parseInt(s.charAt(i), 16);
-        for (j = digits.length - 1; j >= 0; j -= 1) {
-            digits[j] = digits[j] * 16 + carry;
-            carry = digits[j] / 10 | 0;
-            digits[j] %= 10;
-        }
-        while (carry > 0) {
-            digits.unshift(carry % 10);
-            carry = carry / 10 | 0;
-        }
-    }
-    return digits.join('');
-}
-/**
- * Gets the higher 64 bits of the x64 version of Murmur3 for 128bits, as decimal and hexadecimal number strings.
- * Used for MySegments channel V2 notifications.
- * @param str - The string to hash
- */
-export function hash64(str) {
-    var hex = hash128(str).slice(0, 16);
-    return {
-        hex: hex,
-        dec: hex2dec(hex) // KeyList notification
-    };
-}

package/esm/utils/murmur3/utfx.js

@@ -1,102 +0,0 @@
-/*
- Trimmed version of "utfx" library (https://www.npmjs.com/package/utfx/v/1.0.1) used to encode,
- decode and convert UTF8 / UTF16 in JavaScript, with the minimal methods used by the SDK.
-
- utfx (c) 2014 Daniel Wirtz <dcode@dcode.io>
- Released under the Apache License, Version 2.0
- see: https://github.com/dcodeIO/utfx for details
-*/
-/**
- * Encodes UTF8 code points to UTF8 bytes.
- * @param src - Code points source, either as a function returning the next code point
- *  respectively `null` if there are no more code points left or a single numeric code point.
- * @param dst - Bytes destination as a function successively called with the next byte
- */
-function encodeUTF8(src, dst) {
-    var cp = null;
-    if (typeof src === 'number')
-        cp = src, src = function () { return null; };
-    while (cp !== null || (cp = src()) !== null) {
-        if (cp < 0x80)
-            dst(cp & 0x7F);
-        else if (cp < 0x800)
-            dst(((cp >> 6) & 0x1F) | 0xC0), dst((cp & 0x3F) | 0x80);
-        else if (cp < 0x10000)
-            dst(((cp >> 12) & 0x0F) | 0xE0), dst(((cp >> 6) & 0x3F) | 0x80), dst((cp & 0x3F) | 0x80);
-        else
-            dst(((cp >> 18) & 0x07) | 0xF0), dst(((cp >> 12) & 0x3F) | 0x80), dst(((cp >> 6) & 0x3F) | 0x80), dst((cp & 0x3F) | 0x80);
-        cp = null;
-    }
-}
-/**
- * Converts UTF16 characters to UTF8 code points.
- * @param src - Characters source as a function returning the next char code respectively
- *  `null` if there are no more characters left.
- * @param dst - Code points destination as a function successively called with each converted code
- *  point.
- */
-function UTF16toUTF8(src, dst) {
-    var c1, c2 = null;
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        if ((c1 = c2 !== null ? c2 : src()) === null)
-            break;
-        if (c1 >= 0xD800 && c1 <= 0xDFFF) {
-            if ((c2 = src()) !== null) {
-                if (c2 >= 0xDC00 && c2 <= 0xDFFF) {
-                    dst((c1 - 0xD800) * 0x400 + c2 - 0xDC00 + 0x10000);
-                    c2 = null;
-                    continue;
-                }
-            }
-        }
-        dst(c1);
-    }
-    if (c2 !== null)
-        dst(c2);
-}
-/**
- * Converts and encodes UTF16 characters to UTF8 bytes.
- * @param src - Characters source as a function returning the next char code respectively `null`
- *  if there are no more characters left.
- * @param dst - Bytes destination as a function successively called with the next byte.
- */
-export function encodeUTF16toUTF8(src, dst) {
-    UTF16toUTF8(src, function (cp) {
-        encodeUTF8(cp, dst);
-    });
-}
-/**
- * String.fromCharCode reference for compile time renaming.
- */
-var stringFromCharCode = String.fromCharCode;
-/**
- * Creates a source function for a string.
- * @param s - String to read from
- * @returns Source function returning the next char code respectively `null` if there are
- *  no more characters left.
- * @throws If the argument is invalid
- */
-export function stringSource(s) {
-    if (typeof s !== 'string')
-        throw TypeError('Illegal argument: ' + (typeof s));
-    var i = 0;
-    return function () {
-        return i >= s.length ? null : s.charCodeAt(i++);
-    };
-}
-/**
- * Creates a destination function for a string.
- * @returns Destination function successively called with the next char code.
- *  Returns the final string when called without arguments.
- */
-export function stringDestination() {
-    var cs = [], ps = [];
-    return function () {
-        if (arguments.length === 0)
-            return ps.join('') + stringFromCharCode.apply(String, cs);
-        if (cs.length + arguments.length > 1024)
-            ps.push(stringFromCharCode.apply(String, cs)), cs.length = 0; // @ts-ignore
-        Array.prototype.push.apply(cs, arguments);
-    };
-}

package/esm/utils/promise/thenable.js

@@ -1,4 +0,0 @@
-// returns true if the given value is a thenable object
-export function thenable(o) {
-    return o !== undefined && o !== null && typeof o.then === 'function';
-}

package/esm/utils/promise/timeout.js

@@ -1,16 +0,0 @@
-export function timeout(ms, promise) {
-    if (ms < 1)
-        return promise;
-    return new Promise(function (resolve, reject) {
-        var tid = setTimeout(function () {
-            reject(new Error("Operation timed out because it exceeded the configured time limit of " + ms + " ms."));
-        }, ms);
-        promise.then(function (res) {
-            clearTimeout(tid);
-            resolve(res);
-        }, function (err) {
-            clearTimeout(tid);
-            reject(err);
-        });
-    });
-}