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

package/cjs/utils/lang/index.js

@@ -1,281 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.uniqueId = exports.uniqAsStrings = exports.uniq = exports.toString = exports.toNumber = exports.startsWith = exports.merge = exports.stringToUpperCase = exports.isString = exports.isObject = exports.isNaNNumber = exports.isIntegerNumber = exports.isFiniteNumber = exports.isBoolean = exports.groupBy = exports.get = exports.forOwn = exports.findIndex = exports.find = exports.endsWith = void 0;
-var tslib_1 = require("tslib");
-/**
- * Checks if the target string ends with the sub string.
- */
-function endsWith(target, sub, caseInsensitive) {
-    if (caseInsensitive === void 0) { caseInsensitive = false; }
-    if (!(isString(target) && isString(sub))) {
-        return false;
-    }
-    if (caseInsensitive) {
-        target = target.toLowerCase();
-        sub = sub.toLowerCase();
-    }
-    return target.slice(target.length - sub.length) === sub;
-}
-exports.endsWith = endsWith;
-/**
- * Loops through a source collection (an object or an array) running iteratee
- * against each element. It returns the first element for which iteratee returned
- * a truthy value and stops the loop.
- * Iteratee receives three arguments (element, key/index, collection)
- */
-function find(source, iteratee) {
-    var res;
-    if (isObject(source)) {
-        var keys = Object.keys(source);
-        for (var i = 0; i < keys.length && !res; i++) {
-            var key = keys[i];
-            var iterateeResult = iteratee(source[key], key, source);
-            if (iterateeResult)
-                res = source[key];
-        }
-    }
-    else if (Array.isArray(source)) {
-        for (var i = 0; i < source.length && !res; i++) {
-            var iterateeResult = iteratee(source[i], i, source);
-            if (iterateeResult)
-                res = source[i];
-        }
-    }
-    return res;
-}
-exports.find = find;
-/**
- * Evaluates iteratee for each element of the source array. Returns the index of the first element
- * for which iteratee returns truthy. If no element is found or there's an issue with the params it returns -1.
- */
-function findIndex(source, iteratee) {
-    if (Array.isArray(source) && typeof iteratee === 'function') {
-        for (var i = 0; i < source.length; i++) {
-            if (iteratee(source[i], i, source) === true) {
-                return i;
-            }
-        }
-    }
-    return -1;
-}
-exports.findIndex = findIndex;
-/**
- * Executes iteratee for given obj own props.
- */
-function forOwn(obj, iteratee) {
-    var keys = Object.keys(obj);
-    keys.forEach(function (key) { return iteratee(obj[key], key, obj); });
-    return obj;
-}
-exports.forOwn = forOwn;
-/**
- * Safely retrieve the specified prop from obj. If we can't retrieve
- * that property value, we return the default value.
- */
-function get(obj, prop, val) {
-    var res = val;
-    try { // No risks nor lots of checks.
-        var pathPieces = prop.split('.');
-        var partial_1 = obj;
-        pathPieces.forEach(function (pathPiece) { return partial_1 = partial_1[pathPiece]; });
-        if (typeof partial_1 !== 'undefined')
-            res = partial_1;
-    }
-    catch (e) {
-        // noop
-    }
-    return res;
-}
-exports.get = get;
-/**
- * Parses an array into a map of different arrays, grouping by the specified prop value.
- */
-function groupBy(source, prop) {
-    var map = {};
-    if (Array.isArray(source) && isString(prop)) {
-        for (var i = 0; i < source.length; i++) {
-            var key = source[i][prop];
-            // Skip the element if the key is not a string.
-            if (isString(key)) {
-                if (!map[key])
-                    map[key] = [];
-                map[key].push(source[i]);
-            }
-        }
-    }
-    return map;
-}
-exports.groupBy = groupBy;
-/**
- * Checks if a given value is a boolean.
- */
-function isBoolean(val) {
-    return val === true || val === false;
-}
-exports.isBoolean = isBoolean;
-/**
- * Checks if a given value is a finite value of number type or Number object.
- * Unlike `Number.isFinite`, it also tests Number object instances.
- * Unlike global `isFinite`, it returns false if the value is not a number or Number object instance.
- */
-function isFiniteNumber(val) {
-    if (val instanceof Number)
-        val = val.valueOf();
-    return typeof val === 'number' ?
-        Number.isFinite ? Number.isFinite(val) : isFinite(val) :
-        false;
-}
-exports.isFiniteNumber = isFiniteNumber;
-/**
- * Checks if a given value is an integer value of number type or Number object.
- * Unlike `Number.isInteger`, it also tests Number object instances.
- */
-function isIntegerNumber(val) {
-    if (val instanceof Number)
-        val = val.valueOf();
-    return typeof val === 'number' ?
-        Number.isInteger ? Number.isInteger(val) : isFinite(val) && Math.floor(val) === val :
-        false;
-}
-exports.isIntegerNumber = isIntegerNumber;
-/**
- * Checks if a given value is a NaN value of number type or Number object.
- * Unlike `Number.isNaN`, it also tests Number object instances.
- * Unlike global `isNan`, it returns false if the value is not a number or Number object instance.
- */
-function isNaNNumber(val) {
-    if (val instanceof Number)
-        val = val.valueOf();
-    // @TODO replace with `Number.isNaN` once it is fully supported by targets
-    return val !== val;
-}
-exports.isNaNNumber = isNaNNumber;
-/**
- * Validates if a value is an object created by the Object constructor (plain object).
- * It checks `constructor.name` to avoid false negatives when validating values on a separate VM context, which has its own global built-ins.
- */
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object' && (obj.constructor === Object ||
-        (obj.constructor != null && obj.constructor.name === 'Object'));
-}
-exports.isObject = isObject;
-/**
- * Checks if a given value is a string.
- */
-function isString(val) {
-    return typeof val === 'string' || val instanceof String;
-}
-exports.isString = isString;
-/**
- * String sanitizer. Returns the provided value converted to uppercase if it is a string.
- */
-function stringToUpperCase(val) {
-    return isString(val) ? val.toUpperCase() : val;
-}
-exports.stringToUpperCase = stringToUpperCase;
-/**
- * Deep copy version of Object.assign using recursion.
- * There are some assumptions here. It's for internal use and we don't need verbose errors
- * or to ensure the data types or whatever. Parameters should always be correct (at least have a target and a source, of type object).
- */
-function merge(target, source) {
-    var rest = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        rest[_i - 2] = arguments[_i];
-    }
-    var res = target;
-    isObject(source) && Object.keys(source).forEach(function (key) {
-        var val = source[key];
-        if (isObject(val)) {
-            if (res[key] && isObject(res[key])) { // If both are objects, merge into a new one.
-                val = merge({}, res[key], val);
-            }
-            else { // else make a copy.
-                val = merge({}, val);
-            }
-        }
-        // We skip undefined values.
-        if (val !== undefined)
-            res[key] = val;
-    });
-    if (rest && rest.length) {
-        var nextSource = rest.splice(0, 1)[0];
-        res = merge.apply(void 0, (0, tslib_1.__spreadArray)([res, nextSource], rest, false));
-    }
-    return res;
-}
-exports.merge = merge;
-/**
- * Checks if the target string starts with the sub string.
- */
-function startsWith(target, sub) {
-    if (!(isString(target) && isString(sub))) {
-        return false;
-    }
-    return target.slice(0, sub.length) === sub;
-}
-exports.startsWith = startsWith;
-/**
- * Transforms a value into a number.
- * Note: We're not expecting anything fancy here. If we are at some point, add more type checks.
- */
-function toNumber(val) {
-    if (typeof val === 'number')
-        return val;
-    if (isObject(val) && typeof val.valueOf === 'function') {
-        var valOf = val.valueOf();
-        val = isObject(valOf) ? valOf + '' : valOf;
-    }
-    if (typeof val !== 'string') {
-        return val === 0 ? val : +val;
-    }
-    // Remove trailing whitespaces.
-    val = val.replace(/^\s+|\s+$/g, '');
-    return +val;
-}
-exports.toNumber = toNumber;
-/**
- * Transforms a value into it's string representation.
- */
-function toString(val) {
-    if (val == null)
-        return '';
-    if (typeof val === 'string')
-        return val;
-    if (Array.isArray(val))
-        return val.map(function (val) { return isString(val) ? val : ''; }) + '';
-    var result = val + '';
-    return (result === '0' && (1 / val) === Number.NEGATIVE_INFINITY) ? '-0' : result;
-}
-exports.toString = toString;
-/**
- * Removes duplicate items on an array of strings.
- */
-function uniq(arr) {
-    var seen = {};
-    return arr.filter(function (item) {
-        return Object.prototype.hasOwnProperty.call(seen, item) ? false : seen[item] = true;
-    });
-}
-exports.uniq = uniq;
-/**
- * Removes duplicate items on an array of objects using an optional `stringify` function as equality criteria.
- * It uses JSON.stringify as default criteria.
- */
-function uniqAsStrings(arr, stringify) {
-    if (stringify === void 0) { stringify = JSON.stringify; }
-    var seen = {};
-    return arr.filter(function (item) {
-        var itemString = stringify(item);
-        return Object.prototype.hasOwnProperty.call(seen, itemString) ? false : seen[itemString] = true;
-    });
-}
-exports.uniqAsStrings = uniqAsStrings;
-var uniqueIdCounter = -1;
-/**
- * Returns a number to be used as ID, which will be unique.
- */
-function uniqueId() {
-    return uniqueIdCounter++;
-}
-exports.uniqueId = uniqueId;

package/cjs/utils/lang/objectAssign.js

@@ -1,20 +0,0 @@
-"use strict";
-/**
- * A tiny polyfill for Object.assign
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.objectAssign = void 0;
-exports.objectAssign = Object.assign || function (target) {
-    if (target === null || target === undefined)
-        throw new TypeError('Object.assign cannot be called with null or undefined');
-    target = Object(target);
-    for (var i = 1; i < arguments.length; i++) {
-        var source = Object(arguments[i]); // eslint-disable-next-line no-restricted-syntax
-        for (var key in source) {
-            if (Object.prototype.hasOwnProperty.call(source, key)) {
-                target[key] = source[key];
-            }
-        }
-    }
-    return target;
-};

package/cjs/utils/lang/sets.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.returnDifference = exports.returnSetsUnion = exports.setToArray = void 0;
-function setToArray(set) {
-    if (Array.from)
-        return Array.from(set);
-    var array = [];
-    set.forEach(function (value) {
-        array.push(value);
-    });
-    return array;
-}
-exports.setToArray = setToArray;
-function returnSetsUnion(set, set2) {
-    return new Set(setToArray(set).concat(setToArray(set2)));
-}
-exports.returnSetsUnion = returnSetsUnion;
-function returnDifference(list, list2) {
-    if (list === void 0) { list = []; }
-    if (list2 === void 0) { list2 = []; }
-    return list.filter(function (item) { return list2.indexOf(item) === -1; });
-}
-exports.returnDifference = returnDifference;

package/cjs/utils/murmur3/common.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.x86Fmix = exports.x86Rotl = exports.x86Multiply = exports.UTF16ToUTF8 = void 0;
-var utfx_1 = require("./utfx");
-function UTF16ToUTF8(key) {
-    var sd;
-    (0, utfx_1.encodeUTF16toUTF8)((0, utfx_1.stringSource)(key), sd = (0, utfx_1.stringDestination)());
-    return sd();
-}
-exports.UTF16ToUTF8 = UTF16ToUTF8;
-/*!
- * +----------------------------------------------------------------------------------+
- * | 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. |
- * +----------------------------------------------------------------------------------+
- */
-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);
-}
-exports.x86Multiply = x86Multiply;
-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));
-}
-exports.x86Rotl = x86Rotl;
-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;
-}
-exports.x86Fmix = x86Fmix;

package/cjs/utils/murmur3/legacy.js

@@ -1,44 +0,0 @@
-"use strict";
-// Deprecated hashing function, used for split bucketing. Replaced by murmur3
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bucket = exports.hash = void 0;
-//
-// 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;
-    }
-}
-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);
-}
-exports.hash = hash;
-function bucket(str, seed) {
-    return Math.abs(hash(str, seed) % 100) + 1;
-}
-exports.bucket = bucket;

package/cjs/utils/murmur3/murmur3.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bucket = exports.hash = 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 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 = (0, common_1.x86Multiply)(k1, c1);
-        k1 = (0, common_1.x86Rotl)(k1, 15);
-        k1 = (0, common_1.x86Multiply)(k1, c2);
-        h1 ^= k1;
-        h1 = (0, common_1.x86Rotl)(h1, 13);
-        h1 = (0, common_1.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 = (0, common_1.x86Multiply)(k1, c1);
-            k1 = (0, common_1.x86Rotl)(k1, 15);
-            k1 = (0, common_1.x86Multiply)(k1, c2);
-            h1 ^= k1;
-    }
-    h1 ^= key.length;
-    h1 = (0, common_1.x86Fmix)(h1);
-    return h1 >>> 0;
-}
-function hash(str, seed) {
-    return hash32((0, common_1.UTF16ToUTF8)(str), seed >>> 0);
-}
-exports.hash = hash;
-function bucket(str, seed) {
-    return Math.abs(hash(str, seed) % 100) + 1;
-}
-exports.bucket = bucket;

package/cjs/utils/murmur3/murmur3_128.js

@@ -1,219 +0,0 @@
-"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. |
- * +----------------------------------------------------------------------------------+
- */
-// 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.
- */
-function hash128(str, seed) {
-    return hash128x64((0, common_1.UTF16ToUTF8)(str), seed >>> 0);
-}
-exports.hash128 = hash128;