@splitsoftware/splitio 10.17.3-rc.1 → 10.17.3-rc.4

package/src/engine/engine/murmur3/murmur3_128.js

@@ -0,0 +1,273 @@
+/* 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 /*: string */, seed /*: number */) /*: string */ {
+  //
+  // 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 {string} str
+ */
+export function hash128(str /*: string */, seed /*: number */) /*: string */ {
+  return hash128x64(UTF16ToUTF8(str), seed >>> 0);
+}

package/src/engine/engine/murmur3/murmur3_128_x86.js

@@ -0,0 +1,188 @@
+/* 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 /*: string */, seed /*: number */) /*: string */ {
+  //
+  // 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 {string} str
+ */
+export function hash128(str /*: string */, seed /*: number */) /*: string */ {
+  return hash128x86(UTF16ToUTF8(str), seed >>> 0);
+}

package/src/engine/engine/murmur3/murmur3_64.js

@@ -0,0 +1,34 @@
+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 /*: string */) /*: string */ {
+  let 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 {string} str
+ */
+export function hash64(str /*: string */) /*: { hex: string, dec: string } */ {
+  const hex = hash128(str).slice(0, 16);
+  return {
+    hex, // BoundedFetchRequest notification
+    dec: hex2dec(hex) // KeyList notification
+  };
+}

package/src/engine/engine/murmur3/utfx.js

@@ -0,0 +1,111 @@
+/*
+ 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 {(!function():number|null) | number} 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 {!function(number)} dst Bytes destination as a function successively called with the next byte
+ * @expose
+ */
+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 {!function():number|null} src Characters source as a function returning the next char code respectively
+ *  `null` if there are no more characters left.
+ * @param {!function(number)} dst Code points destination as a function successively called with each converted code
+ *  point.
+ * @expose
+ */
+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 {!function():number|null} src Characters source as a function returning the next char code respectively `null`
+ *  if there are no more characters left.
+ * @param {!function(number)} dst Bytes destination as a function successively called with the next byte.
+ * @expose
+ */
+export function encodeUTF16toUTF8(src, dst) {
+  UTF16toUTF8(src, function (cp) {
+    encodeUTF8(cp, dst);
+  });
+}
+
+/**
+ * String.fromCharCode reference for compile time renaming.
+ * @type {!function(...[number]):string}
+ * @inner
+ */
+var stringFromCharCode = String.fromCharCode;
+
+/**
+ * Creates a source function for a string.
+ * @param {string} s String to read from
+ * @returns {!function():number|null} Source function returning the next char code respectively `null` if there are
+ *  no more characters left.
+ * @throws {TypeError} If the argument is invalid
+ * @expose
+ */
+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 {function(number=):undefined|string} Destination function successively called with the next char code.
+ *  Returns the final string when called without arguments.
+ * @expose
+ */
+export function stringDestination() {
+  const 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;
+    Array.prototype.push.apply(cs, arguments);
+  };
+}