@raikuxq/alg-ds 1.1.3 → 1.1.4

package/lib/algorithms/binary-search.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Find element's index in sorted array
+ * Time complexity: O(log(n))
+ */
+export declare const binarySearch: (elements: Array<number>, searchElement: number) => number | null;

package/lib/algorithms/binary-search.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binarySearch = void 0;
+/**
+ * Find element's index in sorted array
+ * Time complexity: O(log(n))
+ */
+exports.binarySearch = function (elements, searchElement) {
+    var length = elements.length;
+    var leftIndex = 0;
+    var rightIndex = length - 1;
+    while (leftIndex <= rightIndex) {
+        var midIndex = Math.ceil((leftIndex + rightIndex) / 2);
+        var midEl = elements[midIndex];
+        if (searchElement == midEl) {
+            return midIndex;
+        }
+        else if (midEl > searchElement) {
+            rightIndex = midIndex - 1;
+        }
+        else if (midEl < searchElement) {
+            leftIndex = midIndex + 1;
+        }
+    }
+    return null;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmluYXJ5LXNlYXJjaC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hbGdvcml0aG1zL2JpbmFyeS1zZWFyY2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUE7OztHQUdHO0FBQ1UsUUFBQSxZQUFZLEdBQUcsVUFDMUIsUUFBdUIsRUFDdkIsYUFBcUI7SUFFckIsSUFBTSxNQUFNLEdBQVcsUUFBUSxDQUFDLE1BQU0sQ0FBQztJQUV2QyxJQUFJLFNBQVMsR0FBRyxDQUFDLENBQUM7SUFDbEIsSUFBSSxVQUFVLEdBQVcsTUFBTSxHQUFHLENBQUMsQ0FBQztJQUVwQyxPQUFPLFNBQVMsSUFBSSxVQUFVLEVBQUU7UUFDOUIsSUFBTSxRQUFRLEdBQVcsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLFNBQVMsR0FBRyxVQUFVLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztRQUNqRSxJQUFNLEtBQUssR0FBVyxRQUFRLENBQUMsUUFBUSxDQUFDLENBQUM7UUFFekMsSUFBSSxhQUFhLElBQUksS0FBSyxFQUFFO1lBQzFCLE9BQU8sUUFBUSxDQUFDO1NBQ2pCO2FBQU0sSUFBSSxLQUFLLEdBQUcsYUFBYSxFQUFFO1lBQ2hDLFVBQVUsR0FBRyxRQUFRLEdBQUcsQ0FBQyxDQUFDO1NBQzNCO2FBQU0sSUFBSSxLQUFLLEdBQUcsYUFBYSxFQUFFO1lBQ2hDLFNBQVMsR0FBRyxRQUFRLEdBQUcsQ0FBQyxDQUFDO1NBQzFCO0tBQ0Y7SUFFRCxPQUFPLElBQUksQ0FBQztBQUNkLENBQUMsQ0FBQyJ9

package/lib/algorithms/factorial.d.ts

@@ -0,0 +1,9 @@
+import { FnToMemoize } from "../types/FnToMemoize";
+/**
+ * Time complexity: O(n!)
+ */
+export declare const factorial: (x: number) => number;
+/**
+ * Time complexity: O(n) - due to caching
+ */
+export declare const memoizedFactorial: FnToMemoize<number, number>;

package/lib/algorithms/factorial.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoizedFactorial = exports.factorial = void 0;
+var memoize_1 = require("./memoize");
+/**
+ * Time complexity: O(n!)
+ */
+exports.factorial = function (x) {
+    return x > 1 ? x * exports.factorial(x - 1) : x;
+};
+/**
+ * Time complexity: O(n) - due to caching
+ */
+exports.memoizedFactorial = memoize_1.memoize(function (n) {
+    return n > 1 ? n * exports.memoizedFactorial(n - 1) : n;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjdG9yaWFsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FsZ29yaXRobXMvZmFjdG9yaWFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHFDQUFvQztBQUdwQzs7R0FFRztBQUNVLFFBQUEsU0FBUyxHQUFHLFVBQUMsQ0FBUztJQUNqQyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsR0FBRyxpQkFBUyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBQzFDLENBQUMsQ0FBQztBQUVGOztHQUVHO0FBQ1UsUUFBQSxpQkFBaUIsR0FBZ0MsaUJBQU8sQ0FDbkUsVUFBQyxDQUFTO0lBQ1IsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcseUJBQWlCLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDbEQsQ0FBQyxDQUNGLENBQUMifQ==

package/lib/algorithms/fibonacci.d.ts

@@ -0,0 +1,9 @@
+import { FnToMemoize } from "../types/FnToMemoize";
+/**
+ * Time complexity: O(n!)
+ */
+export declare const fibonacci: (n: number) => number;
+/**
+ * Time complexity: O(n) - due to caching
+ */
+export declare const memoizedFibonacci: FnToMemoize<number, number>;

package/lib/algorithms/fibonacci.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoizedFibonacci = exports.fibonacci = void 0;
+var memoize_1 = require("./memoize");
+/**
+ * Time complexity: O(n!)
+ */
+exports.fibonacci = function (n) {
+    return n > 1 ? exports.fibonacci(n - 1) + exports.fibonacci(n - 2) : n;
+};
+/**
+ * Time complexity: O(n) - due to caching
+ */
+exports.memoizedFibonacci = memoize_1.memoize(function (n) {
+    return n > 1 ? exports.memoizedFibonacci(n - 1) + exports.memoizedFibonacci(n - 2) : n;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlib25hY2NpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FsZ29yaXRobXMvZmlib25hY2NpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUNBLHFDQUFvQztBQUVwQzs7R0FFRztBQUNVLFFBQUEsU0FBUyxHQUFHLFVBQUMsQ0FBUztJQUNqQyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLGlCQUFTLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxHQUFHLGlCQUFTLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDekQsQ0FBQyxDQUFDO0FBRUY7O0dBRUc7QUFDVSxRQUFBLGlCQUFpQixHQUFnQyxpQkFBTyxDQUNuRSxVQUFDLENBQVM7SUFDUixPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLHlCQUFpQixDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsR0FBRyx5QkFBaUIsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUN6RSxDQUFDLENBQ0YsQ0FBQyJ9

package/lib/algorithms/memoize.d.ts

@@ -0,0 +1,5 @@
+import { FnToMemoize } from "../types/FnToMemoize";
+/**
+ * Wrapper function that storing the results of calls and returning the cached result when the same inputs occur again
+ */
+export declare const memoize: <Key, Value>(fn: FnToMemoize<Key, Value>) => FnToMemoize<Key, Value>;

package/lib/algorithms/memoize.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoize = void 0;
+/**
+ * Wrapper function that storing the results of calls and returning the cached result when the same inputs occur again
+ */
+exports.memoize = function (fn) {
+    var cache = new Map();
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var jsonArgs = JSON.stringify(args);
+        if (!cache.has(jsonArgs)) {
+            var result = fn.apply(void 0, args);
+            cache.set(jsonArgs, result);
+        }
+        return cache.get(jsonArgs);
+    };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVtb2l6ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hbGdvcml0aG1zL21lbW9pemUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRUE7O0dBRUc7QUFDVSxRQUFBLE9BQU8sR0FBRyxVQUNyQixFQUEyQjtJQUUzQixJQUFNLEtBQUssR0FBRyxJQUFJLEdBQUcsRUFBaUIsQ0FBQztJQUV2QyxPQUFPO1FBQUMsY0FBbUI7YUFBbkIsVUFBbUIsRUFBbkIscUJBQW1CLEVBQW5CLElBQW1CO1lBQW5CLHlCQUFtQjs7UUFDekIsSUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUV0QyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsRUFBRTtZQUN4QixJQUFNLE1BQU0sR0FBRyxFQUFFLGVBQUksSUFBSSxDQUFDLENBQUM7WUFDM0IsS0FBSyxDQUFDLEdBQUcsQ0FBQyxRQUFRLEVBQUUsTUFBTSxDQUFDLENBQUM7U0FDN0I7UUFFRCxPQUFjLEtBQUssQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDcEMsQ0FBQyxDQUFDO0FBQ0osQ0FBQyxDQUFDIn0=

package/lib/algorithms/sorts/bubble-sort.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Bubble sorting algorithm
+ *
+ * @description
+ * Time complexity: Best O(n); Avg O(n \^ 2); Worst O(n \^ 2)
+ * @description
+ * Memory complexity: Worst case: O(1)
+ */
+export declare const bubbleSort: (arr: Array<number>) => Array<number>;

package/lib/algorithms/sorts/bubble-sort.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bubbleSort = void 0;
+var utils_1 = require("../../utils");
+/**
+ * Bubble sorting algorithm
+ *
+ * @description
+ * Time complexity: Best O(n); Avg O(n \^ 2); Worst O(n \^ 2)
+ * @description
+ * Memory complexity: Worst case: O(1)
+ */
+exports.bubbleSort = function (arr) {
+    for (var i = 0; i < arr.length - 1; i++) {
+        for (var j = 0; j < arr.length - 1; j++) {
+            if (arr[j] > arr[j + 1]) {
+                utils_1.swapArrayItems(arr, j, j + 1);
+            }
+        }
+    }
+    return arr;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnViYmxlLXNvcnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYWxnb3JpdGhtcy9zb3J0cy9idWJibGUtc29ydC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxxQ0FBNkM7QUFFN0M7Ozs7Ozs7R0FPRztBQUNVLFFBQUEsVUFBVSxHQUFHLFVBQUMsR0FBa0I7SUFDM0MsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLEdBQUcsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFLENBQUMsRUFBRSxFQUFFO1FBQ3ZDLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxHQUFHLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRSxDQUFDLEVBQUUsRUFBRTtZQUN2QyxJQUFJLEdBQUcsQ0FBQyxDQUFDLENBQUMsR0FBRyxHQUFHLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFO2dCQUN2QixzQkFBYyxDQUFDLEdBQUcsRUFBRSxDQUFDLEVBQUUsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDO2FBQy9CO1NBQ0Y7S0FDRjtJQUVELE9BQU8sR0FBRyxDQUFDO0FBQ2IsQ0FBQyxDQUFDIn0=

package/lib/algorithms/sorts/insertion-sort.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Insertion sorting algorithm
+ *
+ * @description
+ * Time complexity: Best O(n); Avg O(n \^ 2); Worst O(n \^ 2);
+ * @description
+ * Memory complexity: Worst case: O(1)
+ */
+export declare const insertionSort: (arr: Array<number>) => Array<number>;

package/lib/algorithms/sorts/insertion-sort.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertionSort = void 0;
+var utils_1 = require("../../utils");
+/**
+ * Insertion sorting algorithm
+ *
+ * @description
+ * Time complexity: Best O(n); Avg O(n \^ 2); Worst O(n \^ 2);
+ * @description
+ * Memory complexity: Worst case: O(1)
+ */
+exports.insertionSort = function (arr) {
+    for (var i = 1; i < arr.length; i++) {
+        var current = arr[i];
+        var j = i - 1;
+        while (j >= 0 && arr[j] > current) {
+            utils_1.swapArrayItems(arr, j + 1, j);
+            j--;
+        }
+        arr[j + 1] = current;
+    }
+    return arr;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5zZXJ0aW9uLXNvcnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYWxnb3JpdGhtcy9zb3J0cy9pbnNlcnRpb24tc29ydC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxxQ0FBNkM7QUFFN0M7Ozs7Ozs7R0FPRztBQUNVLFFBQUEsYUFBYSxHQUFHLFVBQUMsR0FBa0I7SUFDOUMsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLEdBQUcsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxFQUFFLEVBQUU7UUFDbkMsSUFBTSxPQUFPLEdBQUcsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ3ZCLElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUM7UUFFZCxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksR0FBRyxDQUFDLENBQUMsQ0FBQyxHQUFHLE9BQU8sRUFBRTtZQUNqQyxzQkFBYyxDQUFDLEdBQUcsRUFBRSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO1lBQzlCLENBQUMsRUFBRSxDQUFDO1NBQ0w7UUFFRCxHQUFHLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxHQUFHLE9BQU8sQ0FBQztLQUN0QjtJQUVELE9BQU8sR0FBRyxDQUFDO0FBQ2IsQ0FBQyxDQUFDIn0=

package/lib/algorithms/sorts/merge-sort.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Merge sorting algorithm
+ *
+ * @description
+ * Time complexity: Best O(n * log(n)); Avg O(n * log(n)); Worst O(n * log(n))
+ * @description
+ * Memory complexity: Worst case: O(n)
+ */
+export declare const mergeSort: (arr: Array<number>) => Array<number>;

package/lib/algorithms/sorts/merge-sort.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeSort = void 0;
+/**
+ * Merge two sorted arrays into one array
+ */
+var merge = function (arr, leftIndex, midIndex, rightIndex) {
+    var container = arr.slice(leftIndex, rightIndex + 1);
+    var resultArrIndex = leftIndex;
+    var leftHalfIndex = leftIndex;
+    var rightHalfIndex = midIndex + 1;
+    /** While both halves of array are not ended */
+    while (leftHalfIndex <= midIndex && rightHalfIndex <= rightIndex) {
+        var leftHalfElement = container[leftHalfIndex - leftIndex];
+        var rightHalfElement = container[rightHalfIndex - leftIndex];
+        if (leftHalfElement < rightHalfElement) {
+            arr[resultArrIndex] = leftHalfElement;
+            leftHalfIndex++;
+        }
+        else {
+            arr[resultArrIndex] = rightHalfElement;
+            rightHalfIndex++;
+        }
+        resultArrIndex++;
+    }
+    /** If one of halves is ended, the remaining one will just be pushed to result */
+    while (leftHalfIndex <= midIndex) {
+        arr[resultArrIndex] = container[leftHalfIndex - leftIndex];
+        resultArrIndex++;
+        leftHalfIndex++;
+    }
+    while (rightHalfIndex <= rightIndex) {
+        arr[resultArrIndex] = container[rightHalfIndex - leftIndex];
+        resultArrIndex++;
+        rightHalfIndex++;
+    }
+};
+/**
+ * Divide array into 2 halves and merge them
+ */
+var sortRange = function (arr, leftIndex, rightIndex) {
+    if (rightIndex > leftIndex) {
+        var midIndex = Math.floor(leftIndex + (rightIndex - leftIndex) / 2);
+        sortRange(arr, leftIndex, midIndex);
+        sortRange(arr, midIndex + 1, rightIndex);
+        merge(arr, leftIndex, midIndex, rightIndex);
+    }
+};
+/**
+ * Merge sorting algorithm
+ *
+ * @description
+ * Time complexity: Best O(n * log(n)); Avg O(n * log(n)); Worst O(n * log(n))
+ * @description
+ * Memory complexity: Worst case: O(n)
+ */
+exports.mergeSort = function (arr) {
+    sortRange(arr, 0, arr.length - 1);
+    return arr;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/algorithms/sorts/quick-sort.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Quick sort algorithm
+ *
+ * @description
+ * Time complexity: Best O(n * log(n)); Avg O(n * log(n)); Worst O(n  ^2)
+ * @description
+ * Memory complexity: Worst case: O(1)
+ */
+export declare const quickSort: (arr: Array<number>) => Array<number>;

package/lib/algorithms/sorts/quick-sort.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quickSort = void 0;
+var utils_1 = require("../../utils");
+/**
+ * Quick sort algorithm
+ *
+ * @description
+ * Time complexity: Best O(n * log(n)); Avg O(n * log(n)); Worst O(n  ^2)
+ * @description
+ * Memory complexity: Worst case: O(1)
+ */
+exports.quickSort = function (arr) {
+    var partition = function (arr, leftIndex, rightIndex) {
+        var pivot = arr[leftIndex];
+        var leftWall = leftIndex;
+        var rightWall = rightIndex;
+        while (leftWall <= rightWall) {
+            while (arr[rightWall] > pivot) {
+                rightWall--;
+            }
+            while (arr[leftWall] < pivot) {
+                leftWall++;
+            }
+            if (leftWall <= rightWall) {
+                utils_1.swapArrayItems(arr, leftWall, rightWall);
+                rightWall--;
+                leftWall++;
+            }
+        }
+        return leftWall;
+    };
+    var sort = function (arr, leftIndex, rightIndex) {
+        if (leftIndex === void 0) { leftIndex = 0; }
+        if (rightIndex === void 0) { rightIndex = arr.length - 1; }
+        if (leftIndex < rightIndex) {
+            var pivot = partition(arr, leftIndex, rightIndex);
+            sort(arr, leftIndex, pivot - 1);
+            sort(arr, pivot, rightIndex);
+        }
+        return arr;
+    };
+    return sort(arr);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVpY2stc29ydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hbGdvcml0aG1zL3NvcnRzL3F1aWNrLXNvcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEscUNBQTZDO0FBRTdDOzs7Ozs7O0dBT0c7QUFDVSxRQUFBLFNBQVMsR0FBRyxVQUFDLEdBQWtCO0lBQzFDLElBQU0sU0FBUyxHQUFHLFVBQ2hCLEdBQWtCLEVBQ2xCLFNBQWlCLEVBQ2pCLFVBQWtCO1FBRWxCLElBQU0sS0FBSyxHQUFHLEdBQUcsQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUU3QixJQUFJLFFBQVEsR0FBRyxTQUFTLENBQUM7UUFDekIsSUFBSSxTQUFTLEdBQUcsVUFBVSxDQUFDO1FBRTNCLE9BQU8sUUFBUSxJQUFJLFNBQVMsRUFBRTtZQUM1QixPQUFPLEdBQUcsQ0FBQyxTQUFTLENBQUMsR0FBRyxLQUFLLEVBQUU7Z0JBQzdCLFNBQVMsRUFBRSxDQUFDO2FBQ2I7WUFDRCxPQUFPLEdBQUcsQ0FBQyxRQUFRLENBQUMsR0FBRyxLQUFLLEVBQUU7Z0JBQzVCLFFBQVEsRUFBRSxDQUFDO2FBQ1o7WUFDRCxJQUFJLFFBQVEsSUFBSSxTQUFTLEVBQUU7Z0JBQ3pCLHNCQUFjLENBQUMsR0FBRyxFQUFFLFFBQVEsRUFBRSxTQUFTLENBQUMsQ0FBQztnQkFDekMsU0FBUyxFQUFFLENBQUM7Z0JBQ1osUUFBUSxFQUFFLENBQUM7YUFDWjtTQUNGO1FBRUQsT0FBTyxRQUFRLENBQUM7SUFDbEIsQ0FBQyxDQUFDO0lBRUYsSUFBTSxJQUFJLEdBQUcsVUFDWCxHQUFrQixFQUNsQixTQUFhLEVBQ2IsVUFBbUM7UUFEbkMsMEJBQUEsRUFBQSxhQUFhO1FBQ2IsMkJBQUEsRUFBQSxhQUFxQixHQUFHLENBQUMsTUFBTSxHQUFHLENBQUM7UUFFbkMsSUFBSSxTQUFTLEdBQUcsVUFBVSxFQUFFO1lBQzFCLElBQU0sS0FBSyxHQUFHLFNBQVMsQ0FBQyxHQUFHLEVBQUUsU0FBUyxFQUFFLFVBQVUsQ0FBQyxDQUFDO1lBRXBELElBQUksQ0FBQyxHQUFHLEVBQUUsU0FBUyxFQUFFLEtBQUssR0FBRyxDQUFDLENBQUMsQ0FBQztZQUNoQyxJQUFJLENBQUMsR0FBRyxFQUFFLEtBQUssRUFBRSxVQUFVLENBQUMsQ0FBQztTQUM5QjtRQUNELE9BQU8sR0FBRyxDQUFDO0lBQ2IsQ0FBQyxDQUFDO0lBRUYsT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7QUFDbkIsQ0FBQyxDQUFDIn0=

package/lib/algorithms/sorts/select-sort.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Selection sorting algorithm
+ *
+ * @description
+ * Time complexity: Best O(n \^ 2); Avg O(n \^ 2); Worst O(n \^ 2)
+ * @description
+ * Memory complexity: Worst case: O(1)
+ */
+export declare const selectSort: (arr: Array<number>) => Array<number>;

package/lib/algorithms/sorts/select-sort.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectSort = void 0;
+var utils_1 = require("../../utils");
+/**
+ * Selection sorting algorithm
+ *
+ * @description
+ * Time complexity: Best O(n \^ 2); Avg O(n \^ 2); Worst O(n \^ 2)
+ * @description
+ * Memory complexity: Worst case: O(1)
+ */
+exports.selectSort = function (arr) {
+    for (var index = 0; index < arr.length; index++) {
+        var minIndex = utils_1.getMinIndexFromIndex(arr, index);
+        utils_1.swapArrayItems(arr, minIndex, index);
+    }
+    return arr;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0LXNvcnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYWxnb3JpdGhtcy9zb3J0cy9zZWxlY3Qtc29ydC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxxQ0FBbUU7QUFFbkU7Ozs7Ozs7R0FPRztBQUNVLFFBQUEsVUFBVSxHQUFHLFVBQUMsR0FBa0I7SUFDM0MsS0FBSyxJQUFJLEtBQUssR0FBRyxDQUFDLEVBQUUsS0FBSyxHQUFHLEdBQUcsQ0FBQyxNQUFNLEVBQUUsS0FBSyxFQUFFLEVBQUU7UUFDL0MsSUFBTSxRQUFRLEdBQVcsNEJBQW9CLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxDQUFDO1FBRTFELHNCQUFjLENBQVMsR0FBRyxFQUFFLFFBQVEsRUFBRSxLQUFLLENBQUMsQ0FBQztLQUM5QztJQUVELE9BQU8sR0FBRyxDQUFDO0FBQ2IsQ0FBQyxDQUFDIn0=

package/lib/algorithms/transpose-matrix.d.ts

@@ -0,0 +1,5 @@
+import { ArrayMatrix } from "../types/ArrayMatrix";
+/**
+ * Will flips a matrix over its diagonal
+ */
+export declare const transposeMatrix: (matrix: ArrayMatrix) => ArrayMatrix;

package/lib/algorithms/transpose-matrix.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transposeMatrix = void 0;
+/**
+ * Will flips a matrix over its diagonal
+ */
+exports.transposeMatrix = function (matrix) {
+    /** Validation */
+    matrix.forEach(function (subArray) {
+        var checkIsSameLength = subArray.length === matrix.length;
+        if (!checkIsSameLength) {
+            throw new Error("Given array is not a matrix");
+        }
+    });
+    return matrix.reduce(function (acc, current, currentIndex) {
+        acc[currentIndex] = matrix.map(function (rowArr) { return rowArr[currentIndex]; });
+        return acc;
+    }, new Array(matrix.length));
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNwb3NlLW1hdHJpeC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hbGdvcml0aG1zL3RyYW5zcG9zZS1tYXRyaXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRUE7O0dBRUc7QUFDVSxRQUFBLGVBQWUsR0FBRyxVQUFDLE1BQW1CO0lBQ2pELGlCQUFpQjtJQUNqQixNQUFNLENBQUMsT0FBTyxDQUFDLFVBQUMsUUFBUTtRQUN0QixJQUFNLGlCQUFpQixHQUFHLFFBQVEsQ0FBQyxNQUFNLEtBQUssTUFBTSxDQUFDLE1BQU0sQ0FBQztRQUM1RCxJQUFJLENBQUMsaUJBQWlCLEVBQUU7WUFDdEIsTUFBTSxJQUFJLEtBQUssQ0FBQyw2QkFBNkIsQ0FBQyxDQUFDO1NBQ2hEO0lBQ0gsQ0FBQyxDQUFDLENBQUM7SUFFSCxPQUFPLE1BQU0sQ0FBQyxNQUFNLENBQUMsVUFBQyxHQUFHLEVBQUUsT0FBTyxFQUFFLFlBQVk7UUFDOUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxHQUFHLE1BQU0sQ0FBQyxHQUFHLENBQUMsVUFBQyxNQUFNLElBQUssT0FBQSxNQUFNLENBQUMsWUFBWSxDQUFDLEVBQXBCLENBQW9CLENBQUMsQ0FBQztRQUNqRSxPQUFPLEdBQUcsQ0FBQztJQUNiLENBQUMsRUFBRSxJQUFJLEtBQUssQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQztBQUMvQixDQUFDLENBQUMifQ==

package/lib/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const EDGE_EXISTS_STATE = 1;
+export declare const EDGE_NOT_EXISTS_STATE = 0;

package/lib/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EDGE_NOT_EXISTS_STATE = exports.EDGE_EXISTS_STATE = void 0;
+exports.EDGE_EXISTS_STATE = 1;
+exports.EDGE_NOT_EXISTS_STATE = 0;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBYSxRQUFBLGlCQUFpQixHQUFHLENBQUMsQ0FBQztBQUN0QixRQUFBLHFCQUFxQixHQUFHLENBQUMsQ0FBQyJ9

package/lib/data-structures/BinaryTree/AbstractBinaryTree/AbstractBinaryNode.d.ts

@@ -0,0 +1,15 @@
+export default abstract class AbstractBinaryNode<T> {
+    protected _data: T;
+    protected _left: AbstractBinaryNode<T> | null;
+    protected _right: AbstractBinaryNode<T> | null;
+    protected _parent: AbstractBinaryNode<T> | null;
+    protected constructor(initialData: T);
+    get data(): T;
+    set data(value: T);
+    get left(): AbstractBinaryNode<T> | null;
+    set left(value: AbstractBinaryNode<T> | null);
+    get right(): AbstractBinaryNode<T> | null;
+    set right(value: AbstractBinaryNode<T> | null);
+    get parent(): AbstractBinaryNode<T> | null;
+    set parent(value: AbstractBinaryNode<T> | null);
+}

package/lib/data-structures/BinaryTree/AbstractBinaryTree/AbstractBinaryNode.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var AbstractBinaryNode = /** @class */ (function () {
+    function AbstractBinaryNode(initialData) {
+        this._data = initialData;
+        this._left = null;
+        this._right = null;
+        this._parent = null;
+    }
+    Object.defineProperty(AbstractBinaryNode.prototype, "data", {
+        get: function () {
+            return this._data;
+        },
+        set: function (value) {
+            this._data = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractBinaryNode.prototype, "left", {
+        get: function () {
+            return this._left;
+        },
+        set: function (value) {
+            this._left = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractBinaryNode.prototype, "right", {
+        get: function () {
+            return this._right;
+        },
+        set: function (value) {
+            this._right = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractBinaryNode.prototype, "parent", {
+        get: function () {
+            return this._parent;
+        },
+        set: function (value) {
+            this._parent = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return AbstractBinaryNode;
+}());
+exports.default = AbstractBinaryNode;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWJzdHJhY3RCaW5hcnlOb2RlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2RhdGEtc3RydWN0dXJlcy9CaW5hcnlUcmVlL0Fic3RyYWN0QmluYXJ5VHJlZS9BYnN0cmFjdEJpbmFyeU5vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQTtJQU1FLDRCQUFzQixXQUFjO1FBQ2xDLElBQUksQ0FBQyxLQUFLLEdBQUcsV0FBVyxDQUFDO1FBQ3pCLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDO1FBQ2xCLElBQUksQ0FBQyxNQUFNLEdBQUcsSUFBSSxDQUFDO1FBQ25CLElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDO0lBQ3RCLENBQUM7SUFFRCxzQkFBVyxvQ0FBSTthQUFmO1lBQ0UsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDO1FBQ3BCLENBQUM7YUFFRCxVQUFnQixLQUFRO1lBQ3RCLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ3JCLENBQUM7OztPQUpBO0lBTUQsc0JBQVcsb0NBQUk7YUFBZjtZQUNFLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQztRQUNwQixDQUFDO2FBRUQsVUFBZ0IsS0FBbUM7WUFDakQsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7UUFDckIsQ0FBQzs7O09BSkE7SUFNRCxzQkFBVyxxQ0FBSzthQUFoQjtZQUNFLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQztRQUNyQixDQUFDO2FBRUQsVUFBaUIsS0FBbUM7WUFDbEQsSUFBSSxDQUFDLE1BQU0sR0FBRyxLQUFLLENBQUM7UUFDdEIsQ0FBQzs7O09BSkE7SUFNRCxzQkFBVyxzQ0FBTTthQUFqQjtZQUNFLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQztRQUN0QixDQUFDO2FBRUQsVUFBa0IsS0FBbUM7WUFDbkQsSUFBSSxDQUFDLE9BQU8sR0FBRyxLQUFLLENBQUM7UUFDdkIsQ0FBQzs7O09BSkE7SUFLSCx5QkFBQztBQUFELENBQUMsQUE1Q0QsSUE0Q0MifQ==

package/lib/data-structures/BinaryTree/AbstractBinaryTree/AbstractBinaryTree.d.ts

@@ -0,0 +1,60 @@
+import IBinaryTree from "../../../types/IBinaryTree";
+import { FnCompareTwo } from "../../../types/FnCompareTwo";
+import AbstractBinaryNode from "./AbstractBinaryNode";
+import { EnumTreeTraversalType } from "../../../types/EnumTreeTraversalType";
+/**
+ *
+ */
+export default abstract class AbstractBinaryTree<T> implements IBinaryTree<T> {
+    /**
+     * Function that checks is node A better
+     * @default a > b
+     * @example 5 > 4
+     * @example 'abc' > 'aba'
+     */
+    protected compare: FnCompareTwo<T>;
+    protected _head: AbstractBinaryNode<T> | null;
+    protected _length: number;
+    /**
+     *
+     * @param fnCompare
+     * @protected
+     */
+    protected constructor(fnCompare?: FnCompareTwo<T>);
+    /**
+     * Returns nodes count in the entire tree
+     */
+    length(): number;
+    /**
+     * Will create new node and place it according to the type of tree rules
+     */
+    abstract insert(value: T): void;
+    /**
+     * Will check if tree has a node with given data
+     */
+    abstract has(value: T): boolean;
+    /**
+     * Will delete node from the tree and restructure it
+     */
+    abstract delete(value: T): void;
+    /**
+     * Max value of the tree
+     */
+    abstract max(): T;
+    /**
+     * Min value of the tree
+     */
+    abstract min(): T;
+    /**
+     * Returns same class instance with new head node
+     */
+    abstract subtree(value: T): IBinaryTree<T>;
+    /**
+     * Returns the highest branch length in the tree
+     */
+    abstract height(): number;
+    /**
+     * In-order/Pre-order/Post-order traversing of the tree
+     */
+    abstract traverse(type: EnumTreeTraversalType): Array<T>;
+}

package/lib/data-structures/BinaryTree/AbstractBinaryTree/AbstractBinaryTree.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ *
+ */
+var AbstractBinaryTree = /** @class */ (function () {
+    /**
+     *
+     * @param fnCompare
+     * @protected
+     */
+    function AbstractBinaryTree(fnCompare) {
+        /**
+         * Function that checks is node A better
+         * @default a > b
+         * @example 5 > 4
+         * @example 'abc' > 'aba'
+         */
+        this.compare = function (a, b) { return a > b; };
+        if (fnCompare) {
+            this.compare = fnCompare;
+            console.log(this.compare);
+        }
+        this._head = null;
+        this._length = 0;
+    }
+    /**
+     * Returns nodes count in the entire tree
+     */
+    AbstractBinaryTree.prototype.length = function () {
+        return this._length;
+    };
+    return AbstractBinaryTree;
+}());
+exports.default = AbstractBinaryTree;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWJzdHJhY3RCaW5hcnlUcmVlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2RhdGEtc3RydWN0dXJlcy9CaW5hcnlUcmVlL0Fic3RyYWN0QmluYXJ5VHJlZS9BYnN0cmFjdEJpbmFyeVRyZWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFLQTs7R0FFRztBQUNIO0lBV0U7Ozs7T0FJRztJQUNILDRCQUFzQixTQUEyQjtRQWZqRDs7Ozs7V0FLRztRQUNPLFlBQU8sR0FBb0IsVUFBQyxDQUFJLEVBQUUsQ0FBSSxJQUFLLE9BQUEsQ0FBQyxHQUFHLENBQUMsRUFBTCxDQUFLLENBQUM7UUFVekQsSUFBSSxTQUFTLEVBQUU7WUFDYixJQUFJLENBQUMsT0FBTyxHQUFHLFNBQVMsQ0FBQztZQUN6QixPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztTQUMzQjtRQUNELElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDO1FBQ2xCLElBQUksQ0FBQyxPQUFPLEdBQUcsQ0FBQyxDQUFDO0lBQ25CLENBQUM7SUFFRDs7T0FFRztJQUNJLG1DQUFNLEdBQWI7UUFDRSxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7SUFDdEIsQ0FBQztJQXlDSCx5QkFBQztBQUFELENBQUMsQUF2RUQsSUF1RUMifQ==

package/lib/data-structures/BinaryTree/BinarySearchTree/BinarySearchNode.d.ts

@@ -0,0 +1,13 @@
+import AbstractBinaryNode from "../AbstractBinaryTree/AbstractBinaryNode";
+export default class BinarySearchNode<T> extends AbstractBinaryNode<T> {
+    protected _left: BinarySearchNode<T> | null;
+    protected _right: BinarySearchNode<T> | null;
+    protected _parent: BinarySearchNode<T> | null;
+    constructor(initialData: T);
+    get left(): BinarySearchNode<T> | null;
+    set left(value: BinarySearchNode<T> | null);
+    get right(): BinarySearchNode<T> | null;
+    set right(value: BinarySearchNode<T> | null);
+    get parent(): BinarySearchNode<T> | null;
+    set parent(value: BinarySearchNode<T> | null);
+}

package/lib/data-structures/BinaryTree/BinarySearchTree/BinarySearchNode.js

@@ -0,0 +1,59 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var AbstractBinaryNode_1 = require("../AbstractBinaryTree/AbstractBinaryNode");
+var BinarySearchNode = /** @class */ (function (_super) {
+    __extends(BinarySearchNode, _super);
+    function BinarySearchNode(initialData) {
+        var _this = _super.call(this, initialData) || this;
+        _this._left = null;
+        _this._right = null;
+        _this._parent = null;
+        return _this;
+    }
+    Object.defineProperty(BinarySearchNode.prototype, "left", {
+        get: function () {
+            return this._left;
+        },
+        set: function (value) {
+            this._left = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinarySearchNode.prototype, "right", {
+        get: function () {
+            return this._right;
+        },
+        set: function (value) {
+            this._right = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinarySearchNode.prototype, "parent", {
+        get: function () {
+            return this._parent;
+        },
+        set: function (value) {
+            this._parent = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BinarySearchNode;
+}(AbstractBinaryNode_1.default));
+exports.default = BinarySearchNode;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQmluYXJ5U2VhcmNoTm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kYXRhLXN0cnVjdHVyZXMvQmluYXJ5VHJlZS9CaW5hcnlTZWFyY2hUcmVlL0JpbmFyeVNlYXJjaE5vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsK0VBQTBFO0FBRTFFO0lBQWlELG9DQUFxQjtJQUtwRSwwQkFBbUIsV0FBYztRQUFqQyxZQUNFLGtCQUFNLFdBQVcsQ0FBQyxTQUluQjtRQUhDLEtBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDO1FBQ2xCLEtBQUksQ0FBQyxNQUFNLEdBQUcsSUFBSSxDQUFDO1FBQ25CLEtBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDOztJQUN0QixDQUFDO0lBRUQsc0JBQVcsa0NBQUk7YUFBZjtZQUNFLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQztRQUNwQixDQUFDO2FBRUQsVUFBZ0IsS0FBaUM7WUFDL0MsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7UUFDckIsQ0FBQzs7O09BSkE7SUFNRCxzQkFBVyxtQ0FBSzthQUFoQjtZQUNFLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQztRQUNyQixDQUFDO2FBRUQsVUFBaUIsS0FBaUM7WUFDaEQsSUFBSSxDQUFDLE1BQU0sR0FBRyxLQUFLLENBQUM7UUFDdEIsQ0FBQzs7O09BSkE7SUFNRCxzQkFBVyxvQ0FBTTthQUFqQjtZQUNFLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQztRQUN0QixDQUFDO2FBRUQsVUFBa0IsS0FBaUM7WUFDakQsSUFBSSxDQUFDLE9BQU8sR0FBRyxLQUFLLENBQUM7UUFDdkIsQ0FBQzs7O09BSkE7SUFLSCx1QkFBQztBQUFELENBQUMsQUFuQ0QsQ0FBaUQsNEJBQWtCLEdBbUNsRSJ9