data-structure-typed 0.8.17 → 0.9.16

package/dist/utils/utils.js

@@ -0,0 +1,651 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zip = exports.memo = exports.arrayRemove = exports.timeEnd = exports.timeStart = exports.bunnyConsole = exports.deepAdd = exports.deepReplaceValues = exports.deepRenameKeys = exports.deepRemoveByKey = exports.deepKeysConvert = exports.StringUtil = exports.diffAB = exports.onlyInB = exports.onlyInA = exports.comparerArray = exports.capitalizeFirstLetter = exports.capitalizeWords = exports.randomDate = exports.minuted = exports.keyValueToArray = exports.extractValue = exports.wait = exports.WaitManager = exports.addDays = exports.isLeafParent = exports.isSameStructure = exports.reverseColor = exports.deepObjectStrictEqual = exports.strictObjectIsEqual = exports.strictEqual = exports.looseEqual = exports.isObject = exports.getValue = exports.incrementId = exports.IncrementId = exports.uuidV4 = exports.randomText = void 0;
+var _ = __importStar(require("lodash"));
+function randomText(length) {
+    var result = '';
+    var characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    var charactersLength = characters.length;
+    for (var i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+    return result;
+}
+exports.randomText = randomText;
+var uuidV4 = function () {
+    return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {
+        var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+};
+exports.uuidV4 = uuidV4;
+var IncrementId = /** @class */ (function () {
+    function IncrementId(prefix) {
+        this._prefix = prefix ? prefix : '';
+        this._id = this._prefix + '0';
+    }
+    IncrementId.prototype.getId = function () {
+        var _a = this, _id = _a._id, _prefix = _a._prefix;
+        if (!_id) {
+            this._id = _prefix + '0';
+        }
+        else {
+            var idNumStr = _id.substr(_prefix.length, _id.length - _prefix.length);
+            var newIdNum = parseInt(idNumStr, 10) + 1;
+            this._id = _prefix + newIdNum.toString();
+        }
+        return this._id;
+    };
+    return IncrementId;
+}());
+exports.IncrementId = IncrementId;
+function incrementId(prefix) {
+    var _prefix = prefix ? prefix : '';
+    var _id = _prefix + '0';
+    return function id() {
+        var idNumStr = _id.substr(_prefix.length, _id.length - _prefix.length);
+        var newIdNum = parseInt(idNumStr, 10) + 1;
+        _id = _prefix + newIdNum.toString();
+        return _id;
+    };
+}
+exports.incrementId = incrementId;
+var getValue = function (obj, names) { return names.map(function (i) { return obj[i]; }); };
+exports.getValue = getValue;
+var isObject = function (object) { return object != null && typeof object === 'object'; };
+exports.isObject = isObject;
+var looseEqual = function (a, b) { return a == b; };
+exports.looseEqual = looseEqual;
+var strictEqual = function (a, b) { return a === b; };
+exports.strictEqual = strictEqual;
+var strictObjectIsEqual = function (a, b) { return Object.is(a, b); };
+exports.strictObjectIsEqual = strictObjectIsEqual;
+var deepObjectStrictEqual = function (object1, object2) {
+    var e_1, _a;
+    var keys1 = Object.keys(object1);
+    var keys2 = Object.keys(object2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    try {
+        for (var keys1_1 = __values(keys1), keys1_1_1 = keys1_1.next(); !keys1_1_1.done; keys1_1_1 = keys1_1.next()) {
+            var key = keys1_1_1.value;
+            var val1 = object1[key];
+            var val2 = object2[key];
+            var areObjects = (0, exports.isObject)(val1) && (0, exports.isObject)(val2);
+            if (areObjects && !(0, exports.deepObjectStrictEqual)(val1, val2) ||
+                !areObjects && val1 !== val2) {
+                return false;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (keys1_1_1 && !keys1_1_1.done && (_a = keys1_1.return)) _a.call(keys1_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return true;
+};
+exports.deepObjectStrictEqual = deepObjectStrictEqual;
+function reverseColor(oldColor) {
+    var oldColorTemp = '0x' + oldColor.replace(/#/g, '');
+    var str = '000000' + (0xFFFFFF - Number(oldColorTemp)).toString(16);
+    return '#' + str.substring(str.length - 6, str.length);
+}
+exports.reverseColor = reverseColor;
+var isSameStructure = function (objA, objB) {
+    var objATraversable = objA;
+    var objBTraversable = objB;
+    var objAKeys = Object.keys(objATraversable);
+    var objBKeys = Object.keys(objBTraversable);
+    var isSame = true;
+    if (objAKeys.length !== objBKeys.length) {
+        return isSame = false;
+    }
+    else {
+        objAKeys.forEach(function (i) {
+            if (!objBKeys.includes(i)) {
+                return isSame = false;
+            }
+        });
+        return isSame;
+    }
+};
+exports.isSameStructure = isSameStructure;
+var isLeafParent = function (obj) {
+    var isLeaf = true;
+    Object.values(obj).forEach(function (value) {
+        if (typeof value === 'object' && value instanceof Array) {
+            value.forEach(function (item) {
+                if (typeof item === 'object') {
+                    return false;
+                }
+            });
+            return isLeaf = true;
+        }
+        if (!['string', 'boolean', 'number', 'undefined', 'function'].includes(typeof value) && (value !== null)) {
+            return isLeaf = false;
+        }
+    });
+    return isLeaf;
+};
+exports.isLeafParent = isLeafParent;
+var addDays = function (date, days) {
+    date.setDate(date.getDate() + days);
+    return date;
+};
+exports.addDays = addDays;
+var WaitManager = /** @class */ (function () {
+    function WaitManager(nXSpeed) {
+        this._time30 = 20000;
+        this._nXSpeed = 1;
+        this._time1 = 1000;
+        this._time2 = 2000;
+        this._time3 = 3000;
+        this._time4 = 4000;
+        this._time10 = 10000;
+        this._time20 = 20000;
+        this._time60 = 60000;
+        this._cusTime = 1000;
+        if (nXSpeed === undefined)
+            nXSpeed = 1;
+        this._nXSpeed = nXSpeed;
+    }
+    Object.defineProperty(WaitManager.prototype, "time1", {
+        get: function () {
+            return this._time1 / this._nXSpeed;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WaitManager.prototype, "time2", {
+        get: function () {
+            return this._time2 / this._nXSpeed;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WaitManager.prototype, "time3", {
+        get: function () {
+            return this._time3 / this._nXSpeed;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WaitManager.prototype, "time4", {
+        get: function () {
+            return this._time4 / this._nXSpeed;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WaitManager.prototype, "time10", {
+        get: function () {
+            return this._time10 / this._nXSpeed;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WaitManager.prototype, "time20", {
+        get: function () {
+            return this._time20 / this._nXSpeed;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WaitManager.prototype, "time50", {
+        get: function () {
+            return this._time30 / this._nXSpeed;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WaitManager.prototype, "time60", {
+        get: function () {
+            return this._time60 / this._nXSpeed;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WaitManager.prototype, "cusTime", {
+        get: function () {
+            return this._cusTime / this._nXSpeed;
+        },
+        set: function (v) {
+            this._cusTime = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return WaitManager;
+}());
+exports.WaitManager = WaitManager;
+var wait = function (ms, resolveValue) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, new Promise(function (resolve, reject) {
+                setTimeout(function () {
+                    var finalResolveValue = resolveValue || true;
+                    resolve(finalResolveValue);
+                }, ms);
+            })];
+    });
+}); };
+exports.wait = wait;
+function extractValue(data) {
+    var result = [];
+    if (data && data.length > 0) {
+        result = data.map(function (item) { return item.value; });
+    }
+    return result;
+}
+exports.extractValue = extractValue;
+function keyValueToArray(data) {
+    var e_2, _a;
+    var itemArray = [];
+    var keys = Object.keys(data);
+    try {
+        for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
+            var i = keys_1_1.value;
+            itemArray.push(__assign(__assign({}, data[i]), { _id: i }));
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return itemArray;
+}
+exports.keyValueToArray = keyValueToArray;
+function minuted(time) {
+    var minutes = Math.floor(time / 60000).toString();
+    var seconds = Math.floor((time % 60000) / 1000).toString().padStart(2, '0');
+    return "".concat(minutes, ":").concat(seconds);
+}
+exports.minuted = minuted;
+function randomDate(start, end, specificProbabilityStart, specificProbability) {
+    if (!start)
+        start = new Date('1970-1-1');
+    if (!end)
+        end = new Date();
+    if (specificProbabilityStart) {
+        if (!specificProbability)
+            specificProbability = 0.5;
+        if (Math.random() <= specificProbability) {
+            return new Date(specificProbabilityStart.getTime() + Math.random() * (end.getTime() - specificProbabilityStart.getTime()));
+        }
+    }
+    return new Date(start.getTime() + Math.random() * (end.getTime() - start.getTime()));
+}
+exports.randomDate = randomDate;
+var capitalizeWords = function (str) { return str.replace(/(?:^|\s)\S/g, function (a) { return a.toUpperCase(); }); };
+exports.capitalizeWords = capitalizeWords;
+var capitalizeFirstLetter = function (str) { return str.charAt(0).toUpperCase() + str.slice(1); };
+exports.capitalizeFirstLetter = capitalizeFirstLetter;
+var comparerArray = function (otherArray, limitKeys) {
+    return function (current) {
+        return otherArray.filter(function (other) {
+            if (!limitKeys) {
+                return _.isEqual(current, other);
+            }
+            else {
+                // TODO
+            }
+        }).length == 0;
+    };
+};
+exports.comparerArray = comparerArray;
+var onlyInA = function (a, b) { return a.filter((0, exports.comparerArray)(b)); };
+exports.onlyInA = onlyInA;
+var onlyInB = function (a, b) { return b.filter((0, exports.comparerArray)(a)); };
+exports.onlyInB = onlyInB;
+var diffAB = function (a, b) { return (0, exports.onlyInA)(a, b).concat((0, exports.onlyInB)(a, b)); };
+exports.diffAB = diffAB;
+var StringUtil = /** @class */ (function () {
+    function StringUtil() {
+    }
+    // camelCase
+    StringUtil.toCamelCase = function (str) {
+        return _.camelCase(str);
+    };
+    // snake_case
+    StringUtil.toSnakeCase = function (str) {
+        return _.snakeCase(str);
+    };
+    // PascalCase
+    StringUtil.toPascalCase = function (str) {
+        return _.startCase(_.camelCase(str)).replace(/ /g, '');
+    };
+    // CONSTANT_CASE
+    StringUtil.toConstantCase = function (str) {
+        return _.upperCase(str).replace(/ /g, '_');
+    };
+    // kebab-case
+    StringUtil.toKebabCase = function (str) {
+        return _.kebabCase(str);
+    };
+    // lowercase
+    StringUtil.toLowerCase = function (str) {
+        return _.lowerCase(str).replace(/ /g, '');
+    };
+    // Title Case
+    StringUtil.toTitleCase = function (str) {
+        return _.startCase(_.camelCase(str));
+    };
+    // Sentence case
+    StringUtil.toSentenceCase = function (str) {
+        return _.upperFirst(_.lowerCase(str));
+    };
+    // path/case
+    StringUtil.toPathCase = function (str) {
+        return _.lowerCase(str).replace(/ /g, '/');
+    };
+    // dot.case
+    StringUtil.toDotCase = function (str) {
+        return _.lowerCase(str).replace(/ /g, '.');
+    };
+    return StringUtil;
+}());
+exports.StringUtil = StringUtil;
+var deepKeysConvert = function (obj, toType) {
+    var _toType = toType || 'snake';
+    if (Array.isArray(obj)) {
+        return obj.map(function (v) { return (0, exports.deepKeysConvert)(v, _toType); });
+    }
+    else if (obj !== null && obj.constructor === Object) {
+        return Object.keys(obj).reduce(function (result, key) {
+            var _a;
+            var newKey = '';
+            switch (_toType) {
+                case 'camel':
+                    newKey = StringUtil.toCamelCase(key);
+                    break;
+                case 'snake':
+                    newKey = StringUtil.toSnakeCase(key);
+                    break;
+                case 'pascal':
+                    newKey = StringUtil.toPascalCase(key);
+                    break;
+                case 'constant':
+                    newKey = StringUtil.toConstantCase(key);
+                    break;
+                case 'kebab':
+                    newKey = StringUtil.toKebabCase(key);
+                    break;
+                case 'lower':
+                    newKey = StringUtil.toLowerCase(key);
+                    break;
+                case 'title':
+                    newKey = StringUtil.toTitleCase(key);
+                    break;
+                case 'sentence':
+                    newKey = StringUtil.toSentenceCase(key);
+                    break;
+                case 'path':
+                    newKey = StringUtil.toPathCase(key);
+                    break;
+                case 'dot':
+                    newKey = StringUtil.toDotCase(key);
+                    break;
+                default:
+                    newKey = StringUtil.toDotCase(key);
+                    break;
+            }
+            return __assign(__assign({}, result), (_a = {}, _a[newKey] = (0, exports.deepKeysConvert)(obj[key], _toType), _a));
+        }, {});
+    }
+    return obj;
+};
+exports.deepKeysConvert = deepKeysConvert;
+var deepRemoveByKey = function (obj, keysToBeRemoved) {
+    var result = _.transform(obj, function (result, value, key) {
+        if (_.isObject(value)) {
+            value = (0, exports.deepRemoveByKey)(value, keysToBeRemoved);
+        }
+        if (!keysToBeRemoved.includes(key)) {
+            _.isArray(obj) ? result.push(value) : result[key] = value;
+        }
+    });
+    return result;
+};
+exports.deepRemoveByKey = deepRemoveByKey;
+var deepRenameKeys = function (obj, keysMap) {
+    return _.transform(obj, function (result, value, key) {
+        var currentKey = keysMap[key] || key;
+        result[currentKey] = _.isObject(value) ? (0, exports.deepRenameKeys)(value, keysMap) : value;
+    });
+};
+exports.deepRenameKeys = deepRenameKeys;
+var deepReplaceValues = function (obj, keyReducerMap) {
+    var newObject = _.clone(obj);
+    _.each(obj, function (val, key) {
+        for (var item in keyReducerMap) {
+            if (key === item) {
+                newObject[key] = keyReducerMap[item](newObject);
+            }
+            else if (typeof (val) === 'object' || val instanceof Array) {
+                newObject[key] = (0, exports.deepReplaceValues)(val, keyReducerMap);
+            }
+        }
+    });
+    return newObject;
+};
+exports.deepReplaceValues = deepReplaceValues;
+// TODO determine depth and pass root node as a param through callback
+var deepAdd = function (obj, keyReducerMap, isItemRootParent) {
+    var newObject = _.clone(obj);
+    if (_.isObject(newObject) && !_.isArray(newObject)) {
+        for (var item in keyReducerMap) {
+            newObject[item] = keyReducerMap[item](newObject);
+        }
+    }
+    _.each(obj, function (val, key) {
+        if (_.isObject(val)) {
+            for (var item in keyReducerMap) {
+                // @ts-ignore
+                newObject[key] = (0, exports.deepAdd)(val, keyReducerMap, isItemRootParent);
+            }
+        }
+    });
+    return newObject;
+};
+exports.deepAdd = deepAdd;
+var styleString = function (color) { return "color: ".concat(color, "; font-weight: bold"); };
+var styleHeader = function (header) { return "%c[".concat(header, "]"); };
+exports.bunnyConsole = {
+    log: function (headerLog) {
+        if (headerLog === void 0) { headerLog = 'bunny'; }
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        return console.log.apply(console, __spreadArray([styleHeader(headerLog), styleString('black')], __read(args), false));
+    },
+    warn: function (headerLog) {
+        if (headerLog === void 0) { headerLog = 'bunny'; }
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        return console.warn.apply(console, __spreadArray([styleHeader(headerLog), styleString('orange')], __read(args), false));
+    },
+    error: function (headerLog) {
+        if (headerLog === void 0) { headerLog = 'bunny'; }
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        return console.error.apply(console, __spreadArray([styleHeader(headerLog), styleString('red')], __read(args), false));
+    }
+};
+var timeStart = function () {
+    return performance ? performance.now() : new Date().getTime();
+};
+exports.timeStart = timeStart;
+var timeEnd = function (startTime, headerLog, consoleConditionFn) {
+    var timeSpent = (performance ? performance.now() : new Date().getTime()) - startTime;
+    var isPassCondition = consoleConditionFn ? consoleConditionFn(timeSpent) : true;
+    if (isPassCondition) {
+        exports.bunnyConsole.log(headerLog ? headerLog : 'time spent', timeSpent.toFixed(2));
+    }
+};
+exports.timeEnd = timeEnd;
+var arrayRemove = function (array, predicate) {
+    var i = -1, len = array ? array.length : 0;
+    var result = [];
+    while (++i < len) {
+        var value = array[i];
+        if (predicate(value, i, array)) {
+            result.push(value);
+            Array.prototype.splice.call(array, i--, 1);
+            len--;
+        }
+    }
+    return result;
+};
+exports.arrayRemove = arrayRemove;
+function memo() {
+    var cache = {};
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    return function (target, propertyKey, descriptor) {
+        var originalMethod = descriptor.value;
+        descriptor.value = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var cacheKey = "__cacheKey__".concat(args.toString());
+            // eslint-disable-next-line no-prototype-builtins
+            if (!cache.hasOwnProperty(cacheKey)) {
+                cache[cacheKey] = originalMethod.apply(this, args);
+            }
+            return cache[cacheKey];
+        };
+    };
+}
+exports.memo = memo;
+function zip(array1, array2, options) {
+    var zipped = [];
+    var zippedObjCoords = [];
+    var isToObj = (options ? options : { isToObj: false }).isToObj;
+    for (var i = 0; i < array1.length; i++) {
+        if (isToObj) {
+            zippedObjCoords.push({ x: array1[i], y: array2[i] });
+        }
+        else {
+            zipped.push([array1[i], array2[i]]);
+        }
+    }
+    return isToObj ? zippedObjCoords : zipped;
+}
+exports.zip = zip;