@splitsoftware/splitio-commons 0.1.1-canary.6 → 0.1.1-rc.18

package/cjs/utils/murmur3/murmur3_128.js

@@ -2,11 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hash128 = void 0;
 /* eslint-disable no-fallthrough */
-var commons_1 = require("./commons");
-var X64 = 'x64';
-var X86 = 'x86';
-var X64_ARCHS = ['arm64', 'ppc64', 'x64', 's390x', 'mipsel'];
-var isX64 = getArchType() === X64;
+var common_1 = require("./common");
 /*
  * +----------------------------------------------------------------------------------+
  * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |
@@ -125,135 +121,6 @@ function _x64Fmix(h) {
 }
 // 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 = commons_1.x86Multiply(k1, c1);
-        k1 = commons_1.x86Rotl(k1, 15);
-        k1 = commons_1.x86Multiply(k1, c2);
-        h1 ^= k1;
-        h1 = commons_1.x86Rotl(h1, 19);
-        h1 += h2;
-        h1 = commons_1.x86Multiply(h1, 5) + 0x561ccd1b;
-        k2 = commons_1.x86Multiply(k2, c2);
-        k2 = commons_1.x86Rotl(k2, 16);
-        k2 = commons_1.x86Multiply(k2, c3);
-        h2 ^= k2;
-        h2 = commons_1.x86Rotl(h2, 17);
-        h2 += h3;
-        h2 = commons_1.x86Multiply(h2, 5) + 0x0bcaa747;
-        k3 = commons_1.x86Multiply(k3, c3);
-        k3 = commons_1.x86Rotl(k3, 17);
-        k3 = commons_1.x86Multiply(k3, c4);
-        h3 ^= k3;
-        h3 = commons_1.x86Rotl(h3, 15);
-        h3 += h4;
-        h3 = commons_1.x86Multiply(h3, 5) + 0x96cd1c35;
-        k4 = commons_1.x86Multiply(k4, c4);
-        k4 = commons_1.x86Rotl(k4, 18);
-        k4 = commons_1.x86Multiply(k4, c1);
-        h4 ^= k4;
-        h4 = commons_1.x86Rotl(h4, 13);
-        h4 += h1;
-        h4 = commons_1.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 = commons_1.x86Multiply(k4, c4);
-            k4 = commons_1.x86Rotl(k4, 18);
-            k4 = commons_1.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 = commons_1.x86Multiply(k3, c3);
-            k3 = commons_1.x86Rotl(k3, 17);
-            k3 = commons_1.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 = commons_1.x86Multiply(k2, c2);
-            k2 = commons_1.x86Rotl(k2, 16);
-            k2 = commons_1.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 = commons_1.x86Multiply(k1, c1);
-            k1 = commons_1.x86Rotl(k1, 15);
-            k1 = commons_1.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 = commons_1.x86Fmix(h1);
-    h2 = commons_1.x86Fmix(h2);
-    h3 = commons_1.x86Fmix(h3);
-    h4 = commons_1.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);
-}
 function hash128x64(key, seed) {
     //
     // Given a string and an optional seed as an int, returns a 128 bit
@@ -341,14 +208,12 @@ function hash128x64(key, seed) {
     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);
 }
-function getArchType() {
-    // Values listed from https://nodejs.org/api/process.html#process_process_arch
-    // @TODO Review when supporting alternatives of Node
-    // eslint-disable-next-line no-undef
-    var arch = typeof process !== 'undefined' && process.arch ? process.arch : X86;
-    return (X64_ARCHS.indexOf(arch) > -1) ? X64 : X86;
-}
+/**
+ * x64 version of Murmur3 for 128bits.
+ *
+ * @param {string} str
+ */
 function hash128(str, seed) {
-    return isX64 ? hash128x64(commons_1.UTF16ToUTF8(str), seed >>> 0) : hash128x86(commons_1.UTF16ToUTF8(str), seed >>> 0);
+    return hash128x64(common_1.UTF16ToUTF8(str), seed >>> 0);
 }
 exports.hash128 = hash128;

package/cjs/utils/murmur3/murmur3_128_x86.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hash128 = void 0;
+/* eslint-disable no-fallthrough */
+var common_1 = require("./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 = common_1.x86Multiply(k1, c1);
+        k1 = common_1.x86Rotl(k1, 15);
+        k1 = common_1.x86Multiply(k1, c2);
+        h1 ^= k1;
+        h1 = common_1.x86Rotl(h1, 19);
+        h1 += h2;
+        h1 = common_1.x86Multiply(h1, 5) + 0x561ccd1b;
+        k2 = common_1.x86Multiply(k2, c2);
+        k2 = common_1.x86Rotl(k2, 16);
+        k2 = common_1.x86Multiply(k2, c3);
+        h2 ^= k2;
+        h2 = common_1.x86Rotl(h2, 17);
+        h2 += h3;
+        h2 = common_1.x86Multiply(h2, 5) + 0x0bcaa747;
+        k3 = common_1.x86Multiply(k3, c3);
+        k3 = common_1.x86Rotl(k3, 17);
+        k3 = common_1.x86Multiply(k3, c4);
+        h3 ^= k3;
+        h3 = common_1.x86Rotl(h3, 15);
+        h3 += h4;
+        h3 = common_1.x86Multiply(h3, 5) + 0x96cd1c35;
+        k4 = common_1.x86Multiply(k4, c4);
+        k4 = common_1.x86Rotl(k4, 18);
+        k4 = common_1.x86Multiply(k4, c1);
+        h4 ^= k4;
+        h4 = common_1.x86Rotl(h4, 13);
+        h4 += h1;
+        h4 = common_1.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 = common_1.x86Multiply(k4, c4);
+            k4 = common_1.x86Rotl(k4, 18);
+            k4 = common_1.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 = common_1.x86Multiply(k3, c3);
+            k3 = common_1.x86Rotl(k3, 17);
+            k3 = common_1.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 = common_1.x86Multiply(k2, c2);
+            k2 = common_1.x86Rotl(k2, 16);
+            k2 = common_1.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 = common_1.x86Multiply(k1, c1);
+            k1 = common_1.x86Rotl(k1, 15);
+            k1 = common_1.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 = common_1.x86Fmix(h1);
+    h2 = common_1.x86Fmix(h2);
+    h3 = common_1.x86Fmix(h3);
+    h4 = common_1.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
+ */
+function hash128(str, seed) {
+    return hash128x86(common_1.UTF16ToUTF8(str), seed >>> 0);
+}
+exports.hash128 = hash128;

package/cjs/utils/murmur3/murmur3_64.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hash64 = void 0;
+var murmur3_128_1 = require("./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 {string} str
+ */
+function hash64(str) {
+    var hex = murmur3_128_1.hash128(str).slice(0, 16);
+    return {
+        hex: hex,
+        dec: hex2dec(hex) // KeyList notification
+    };
+}
+exports.hash64 = hash64;

package/cjs/utils/murmur3/utfx.js

@@ -8,114 +8,108 @@
  see: https://github.com/dcodeIO/utfx for details
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = (function () {
-    /**
-     * utfx namespace.
-     * @exports utfx
-     * @type {!Object.<string,*>}
-     */
-    // @ts-ignore
-    var utfx = {};
-    /**
-     * 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
-     */
-    utfx.encodeUTF8 = function (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
-     */
-    utfx.UTF16toUTF8 = function (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;
-                    }
+exports.stringDestination = exports.stringSource = exports.encodeUTF16toUTF8 = void 0;
+/**
+ * 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
-     */
-    utfx.encodeUTF16toUTF8 = function (src, dst) {
-        utfx.UTF16toUTF8(src, function (cp) {
-            utfx.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
-     */
-    utfx.stringSource = function (s) {
-        if (typeof s !== 'string')
-            throw TypeError('Illegal argument: ' + (typeof s));
-        var i = 0;
-        return function () {
-            return i >= s.length ? null : s.charCodeAt(i++);
-        };
+        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
+ */
+function encodeUTF16toUTF8(src, dst) {
+    UTF16toUTF8(src, function (cp) {
+        encodeUTF8(cp, dst);
+    });
+}
+exports.encodeUTF16toUTF8 = encodeUTF16toUTF8;
+/**
+ * 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
+ */
+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
-     */
-    utfx.stringDestination = function () {
-        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);
-        };
+}
+exports.stringSource = stringSource;
+/**
+ * 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
+ */
+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);
     };
-    return utfx;
-})();
+}
+exports.stringDestination = stringDestination;

package/cjs/utils/promise/wrapper.js

@@ -33,18 +33,21 @@ function promiseWrapper(customPromise, defaultOnRejected) {
             });
         });
         var originalThen = newPromise.then;
-        newPromise.then = function (onfulfilled, onrejected) {
-            var result = originalThen.call(newPromise, onfulfilled, onrejected);
-            if (typeof onfulfilled === 'function')
-                hasOnFulfilled = true;
-            if (typeof onrejected === 'function') {
-                hasOnRejected = true;
-                return result;
-            }
-            else {
-                return chain(result);
+        // Using `defineProperty` in case Promise.prototype.then property is not writable
+        Object.defineProperty(newPromise, 'then', {
+            value: function (onfulfilled, onrejected) {
+                var result = originalThen.call(newPromise, onfulfilled, onrejected);
+                if (typeof onfulfilled === 'function')
+                    hasOnFulfilled = true;
+                if (typeof onrejected === 'function') {
+                    hasOnRejected = true;
+                    return result;
+                }
+                else {
+                    return chain(result);
+                }
             }
-        };
+        });
         return newPromise;
     }
     var result = chain(customPromise);

package/cjs/utils/settingsValidation/index.js

@@ -65,7 +65,8 @@ var base = {
     sync: {
         splitFilters: undefined,
         // impressions collection mode
-        impressionsMode: constants_1.OPTIMIZED
+        impressionsMode: constants_1.OPTIMIZED,
+        localhostMode: undefined
     },
     runtime: {
         ip: false,
@@ -85,7 +86,7 @@ function fromSecondsToMillis(n) {
  * @param validationParams defaults and fields validators used to validate and creates a settings object from a given config
  */
 function settingsValidation(config, validationParams) {
-    var defaults = validationParams.defaults, runtime = validationParams.runtime, storage = validationParams.storage, integrations = validationParams.integrations, logger = validationParams.logger;
+    var defaults = validationParams.defaults, runtime = validationParams.runtime, storage = validationParams.storage, integrations = validationParams.integrations, logger = validationParams.logger, localhost = validationParams.localhost;
     // creates a settings object merging base, defaults and config objects.
     var withDefaults = lang_1.merge({}, base, defaults, config);
     // ensure a valid logger.
@@ -123,6 +124,8 @@ function settingsValidation(config, validationParams) {
     // @ts-ignore, modify readonly prop
     if (integrations)
         withDefaults.integrations = integrations(withDefaults);
+    if (localhost)
+        withDefaults.sync.localhostMode = localhost(withDefaults);
     // validate push options
     if (withDefaults.streamingEnabled !== false) { // @ts-ignore, modify readonly prop
         withDefaults.streamingEnabled = true;

package/cjs/utils/settingsValidation/localhost/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateLocalhost = void 0;
+var constants_1 = require("../../../logger/constants");
+var constants_2 = require("../../constants");
+/**
+ * This function validates `settings.storage` object
+ *
+ * @param {any} settings config object provided by the user to initialize the sdk
+ *
+ * @returns {Object} valid storage factory. It might be the default `InMemoryStorageCSFactory` if the provided storage is invalid.
+ */
+function validateLocalhost(settings) {
+    var localhostMode = settings.sync.localhostMode;
+    if (settings.mode === constants_2.LOCALHOST_MODE && (typeof localhostMode !== 'function' || localhostMode.type !== constants_2.LOCALHOST_MODE)) {
+        settings.log.error(constants_1.ERROR_LOCALHOST_MODULE_REQUIRED);
+    }
+    return localhostMode;
+}
+exports.validateLocalhost = validateLocalhost;