data-structure-typed 1.45.0 → 1.45.2

package/test/unit/data-structures/hash/hash-map.test.ts

@@ -1,6 +1,5 @@
-import {HashMap} from '../../../../src';
-import {getRandomInt, getRandomIntArray} from "../../../utils";
-
+import { HashMap } from '../../../../src';
+import { getRandomInt, getRandomIntArray } from '../../../utils';
 
 describe('HashMap', () => {
   let hashMap: HashMap<string, number>;
@@ -66,7 +65,6 @@ describe('HashMap', () => {
     // expect(entries).toContainEqual(['three', 3]);
   });
 
-
   it('should resize the table when load factor is exceeded', () => {
     // Set a small initial capacity for testing resizing
     hashMap = new HashMap<string, number>();
@@ -84,7 +82,6 @@ describe('HashMap', () => {
   });
 
   it('should allow using a custom hash function', () => {
-
     hashMap = new HashMap<string, number>();
 
     hashMap.set('one', 1);
@@ -115,14 +112,14 @@ describe('HashMap', () => {
   });
 
   it('should handle object keys correctly', () => {
-    const keyObj = {id: 1};
+    const keyObj = { id: 1 };
     hashMap.set(keyObj, 'objectValue');
     expect(hashMap.get(keyObj)).toBe('objectValue');
   });
 
   it('should handle number keys correctly', () => {
-    hashMap.set(999, {a: '999Value'});
-    expect(hashMap.get(999)).toEqual({a: '999Value'});
+    hashMap.set(999, { a: '999Value' });
+    expect(hashMap.get(999)).toEqual({ a: '999Value' });
   });
 
   it('should update the value for an existing key', () => {
@@ -156,7 +153,10 @@ describe('HashMap', () => {
     for (const value of hashMap) {
       values.push(value);
     }
-    expect(values).toEqual([['key1', 'value1'], ['key2', 'value2']]);
+    expect(values).toEqual([
+      ['key1', 'value1'],
+      ['key2', 'value2']
+    ]);
   });
 
   // test('should delete element at specific index', () => {
@@ -212,7 +212,6 @@ describe('HashMap', () => {
     hashMap.set('key2', 'value2');
     const iterator = hashMap.reverseBegin;
     expect(iterator.next().current).toEqual(['key1', 'value1']);
-
   });
 
   test('should return the last element', () => {
@@ -230,5 +229,4 @@ describe('HashMap', () => {
     hashMap.set('key2', 'value2');
     expect(hashMap.getAt(1)).toEqual(['key2', 'value2']);
   });
-})
-
+});

package/test/unit/data-structures/hash/hash-table.test.ts

@@ -1,4 +1,4 @@
-import {HashTable, HashTableNode} from '../../../../src';
+import { HashTable, HashTableNode } from '../../../../src';
 
 describe('HashNode', () => {
   it('should create a HashNode with key and value', () => {

package/test/unit/data-structures/heap/heap.test.ts

@@ -1,5 +1,5 @@
-import {FibonacciHeap, MaxHeap, MinHeap} from '../../../../src';
-import {logBigOMetricsWrap} from '../../../utils';
+import { FibonacciHeap, MaxHeap, MinHeap } from '../../../../src';
+import { logBigOMetricsWrap } from '../../../utils';
 
 describe('Heap Operation Test', () => {
   it('should numeric heap work well', function () {
@@ -22,34 +22,46 @@ describe('Heap Operation Test', () => {
   });
 
   it('should object heap work well', function () {
-    const minHeap = new MinHeap<{ a: string; key: number }>({comparator: (a, b) => a.key - b.key});
-    minHeap.add({key: 1, a: 'a1'});
-    minHeap.add({key: 6, a: 'a6'});
-    minHeap.add({key: 2, a: 'a2'});
-    minHeap.add({key: 0, a: 'a0'});
-
-    expect(minHeap.peek()).toEqual({a: 'a0', key: 0});
-    expect(minHeap.toArray().map(item => ({a: item.a}))).toEqual([{a: 'a0'}, {a: 'a1'}, {a: 'a2'}, {a: 'a6'}]);
+    const minHeap = new MinHeap<{ a: string; key: number }>({ comparator: (a, b) => a.key - b.key });
+    minHeap.add({ key: 1, a: 'a1' });
+    minHeap.add({ key: 6, a: 'a6' });
+    minHeap.add({ key: 2, a: 'a2' });
+    minHeap.add({ key: 0, a: 'a0' });
+
+    expect(minHeap.peek()).toEqual({ a: 'a0', key: 0 });
+    expect(minHeap.toArray().map(item => ({ a: item.a }))).toEqual([
+      { a: 'a0' },
+      { a: 'a1' },
+      { a: 'a2' },
+      { a: 'a6' }
+    ]);
     let i = 0;
-    const expectPolled = [{a: 'a0'}, {a: 'a1'}, {a: 'a2'}, {a: 'a6'}];
+    const expectPolled = [{ a: 'a0' }, { a: 'a1' }, { a: 'a2' }, { a: 'a6' }];
     while (minHeap.size > 0) {
-      expect({a: minHeap.poll()?.a}).toEqual(expectPolled[i]);
+      expect({ a: minHeap.poll()?.a }).toEqual(expectPolled[i]);
       i++;
     }
 
-    const maxHeap = new MaxHeap<{ key: number; a: string }>({comparator: (a, b) => b.key - a.key});
-    maxHeap.add({key: 1, a: 'a1'});
-    maxHeap.add({key: 6, a: 'a6'});
-    maxHeap.add({key: 5, a: 'a5'});
-    maxHeap.add({key: 2, a: 'a2'});
-    maxHeap.add({key: 0, a: 'a0'});
-    maxHeap.add({key: 9, a: 'a9'});
-    expect(maxHeap.peek()).toEqual({a: 'a9', key: 9});
-    expect(maxHeap.toArray().map(item => ({a: item.a}))).toEqual([{a: 'a9'}, {a: 'a2'}, {a: 'a6'}, {a: 'a1'}, {a: 'a0'}, {a: 'a5'}]);
-    const maxExpectPolled = [{a: 'a9'}, {a: 'a6'}, {a: 'a5'}, {a: 'a2'}, {a: 'a1'}, {a: 'a0'}];
+    const maxHeap = new MaxHeap<{ key: number; a: string }>({ comparator: (a, b) => b.key - a.key });
+    maxHeap.add({ key: 1, a: 'a1' });
+    maxHeap.add({ key: 6, a: 'a6' });
+    maxHeap.add({ key: 5, a: 'a5' });
+    maxHeap.add({ key: 2, a: 'a2' });
+    maxHeap.add({ key: 0, a: 'a0' });
+    maxHeap.add({ key: 9, a: 'a9' });
+    expect(maxHeap.peek()).toEqual({ a: 'a9', key: 9 });
+    expect(maxHeap.toArray().map(item => ({ a: item.a }))).toEqual([
+      { a: 'a9' },
+      { a: 'a2' },
+      { a: 'a6' },
+      { a: 'a1' },
+      { a: 'a0' },
+      { a: 'a5' }
+    ]);
+    const maxExpectPolled = [{ a: 'a9' }, { a: 'a6' }, { a: 'a5' }, { a: 'a2' }, { a: 'a1' }, { a: 'a0' }];
     let maxI = 0;
     while (maxHeap.size > 0) {
-      expect({a: maxHeap.poll()?.a}).toEqual(maxExpectPolled[maxI]);
+      expect({ a: maxHeap.poll()?.a }).toEqual(maxExpectPolled[maxI]);
       maxI++;
     }
   });
@@ -245,3 +257,41 @@ describe('FibonacciHeap Stress Test', () => {
     );
   });
 });
+
+// describe('Competitor performance compare', () => {
+//   const minHeap = new MinHeap<number>();
+//   const cHeap = new CHeap<number>();
+//   const cPQ = new PriorityQueue<number>(undefined, (a, b) => a - b);
+//   const n = 10000;
+//
+//   it('should add performance well', () => {
+//     const heapCost = calcRunTime(() => {
+//       for (let i = 0; i < n; i++) {
+//         minHeap.add(i);
+//       }
+//     })
+//
+//     console.log(`heapCost: ${heapCost}`)
+//   });
+//
+//   it('should add performance well', () => {
+//
+//     const cHeapCost = calcRunTime(() => {
+//       for (let i = 0; i < n; i++) {
+//         cHeap.push(i);
+//       }
+//     })
+//
+//     console.log(`cHeapCost: ${cHeapCost}`)
+//   });
+//
+//   it('should add performance well', () => {
+//
+//     const cPQCost = calcRunTime(() => {
+//       for (let i = 0; i < n; i++) {
+//         cPQ.push(i);
+//       }
+//     })
+//     console.log(`cPQCost: ${cPQCost}`)
+//   });
+// });

package/test/unit/data-structures/heap/max-heap.test.ts

@@ -1,11 +1,11 @@
-import {Comparator, MaxHeap} from '../../../../src';
+import { Comparator, MaxHeap } from '../../../../src';
 
 describe('MaxHeap', () => {
   const numberComparator: Comparator<number> = (a, b) => b - a;
   let maxHeap: MaxHeap<number>;
 
   beforeEach(() => {
-    maxHeap = new MaxHeap({comparator: numberComparator});
+    maxHeap = new MaxHeap({ comparator: numberComparator });
   });
 
   it('add and poll elements in descending order', () => {

package/test/unit/data-structures/heap/min-heap.test.ts

@@ -1,11 +1,11 @@
-import {Comparator, MinHeap} from '../../../../src';
+import { Comparator, MinHeap } from '../../../../src';
 
 describe('MinHeap', () => {
   const numberComparator: Comparator<number> = (a, b) => a - b;
   let minHeap: MinHeap<number>;
 
   beforeEach(() => {
-    minHeap = new MinHeap({comparator: numberComparator});
+    minHeap = new MinHeap({ comparator: numberComparator });
   });
 
   it('add and poll elements in ascending order', () => {

package/test/unit/data-structures/linked-list/doubly-linked-list.test.ts

@@ -1,4 +1,4 @@
-import {DoublyLinkedList, DoublyLinkedListNode} from '../../../../src';
+import { DoublyLinkedList, DoublyLinkedListNode } from '../../../../src';
 
 describe('DoublyLinkedListNode', () => {
   it('should DoublyLinkedListNode', () => {
@@ -370,9 +370,9 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 
   it('should insert and manipulate objects with numeric properties', () => {
-    const obj1 = {keyA: 10};
-    const obj2 = {keyA: 20};
-    const obj3 = {keyA: 30};
+    const obj1 = { keyA: 10 };
+    const obj2 = { keyA: 20 };
+    const obj3 = { keyA: 30 };
 
     objectList.push(obj1);
     objectList.push(obj2);
@@ -380,7 +380,7 @@ describe('DoublyLinkedList Operation Test', () => {
 
     expect(objectList.toArray()).toEqual([obj1, obj2, obj3]);
 
-    const newObj = {keyA: 25}; // Corrected newObj value
+    const newObj = { keyA: 25 }; // Corrected newObj value
     const insertSuccess = objectList.insertBefore(obj2, newObj);
     expect(insertSuccess).toBe(true);
 

package/test/unit/data-structures/linked-list/singly-linked-list.test.ts

@@ -1,4 +1,4 @@
-import {SinglyLinkedList, SinglyLinkedListNode} from '../../../../src';
+import { SinglyLinkedList, SinglyLinkedListNode } from '../../../../src';
 
 describe('SinglyLinkedListNode', () => {
   it('should SinglyLinkedList', () => {
@@ -366,9 +366,9 @@ describe('SinglyLinkedList Operation Test', () => {
   });
 
   it('should insert and manipulate objects with numeric properties', () => {
-    const obj1 = {keyA: 1};
-    const obj2 = {keyA: 2};
-    const obj3 = {keyA: 3};
+    const obj1 = { keyA: 1 };
+    const obj2 = { keyA: 2 };
+    const obj3 = { keyA: 3 };
 
     objectList.push(obj1);
     objectList.push(obj2);
@@ -376,7 +376,7 @@ describe('SinglyLinkedList Operation Test', () => {
 
     expect(objectList.toArray()).toEqual([obj1, obj2, obj3]);
 
-    const newObj = {keyA: 2.5}; // Corrected newObj value
+    const newObj = { keyA: 2.5 }; // Corrected newObj value
     const insertSuccess = objectList.insertBefore(obj2, newObj);
     expect(insertSuccess).toBe(true);
 

package/test/unit/data-structures/linked-list/skip-list.test.ts

@@ -1,4 +1,4 @@
-import {SkipList} from '../../../../src';
+import { SkipList } from '../../../../src';
 
 describe('SkipList', () => {
   let skipList: SkipList<number, string>;

package/test/unit/data-structures/matrix/matrix.test.ts

@@ -1,10 +1,10 @@
-import {MatrixNTI2D} from '../../../../src';
+import { MatrixNTI2D } from '../../../../src';
 
 describe('MatrixNTI2D', () => {
   it('should initialize a matrix with rows and columns', () => {
     const numRows = 3;
     const numCols = 4;
-    const matrix = new MatrixNTI2D({row: numRows, col: numCols});
+    const matrix = new MatrixNTI2D({ row: numRows, col: numCols });
 
     expect(matrix.toArray().length).toBe(numRows);
     expect(matrix.toArray()[0].length).toBe(numCols);
@@ -14,7 +14,7 @@ describe('MatrixNTI2D', () => {
     const numRows = 3;
     const numCols = 4;
     const initialValue = 42;
-    const matrix = new MatrixNTI2D({row: numRows, col: numCols, initialVal: initialValue});
+    const matrix = new MatrixNTI2D({ row: numRows, col: numCols, initialVal: initialValue });
 
     const matrixArray = matrix.toArray();
     for (let i = 0; i < numRows; i++) {
@@ -27,7 +27,7 @@ describe('MatrixNTI2D', () => {
   it('should initialize all elements with 0 if no initial value is provided', () => {
     const numRows = 3;
     const numCols = 4;
-    const matrix = new MatrixNTI2D({row: numRows, col: numCols});
+    const matrix = new MatrixNTI2D({ row: numRows, col: numCols });
 
     const matrixArray = matrix.toArray();
     for (let i = 0; i < numRows; i++) {
@@ -40,7 +40,7 @@ describe('MatrixNTI2D', () => {
   it('should convert the matrix to a two-dimensional array', () => {
     const numRows = 2;
     const numCols = 3;
-    const matrix = new MatrixNTI2D({row: numRows, col: numCols, initialVal: 1});
+    const matrix = new MatrixNTI2D({ row: numRows, col: numCols, initialVal: 1 });
 
     const matrixArray = matrix.toArray();
     expect(matrixArray.length).toBe(numRows);

package/test/unit/data-structures/matrix/matrix2d.test.ts

@@ -1,5 +1,5 @@
-import {Matrix2D, Vector2D} from '../../../../src';
-import {isDebugTest} from '../../../config';
+import { Matrix2D, Vector2D } from '../../../../src';
+import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
 describe('Matrix2D', () => {
@@ -288,7 +288,7 @@ describe('Matrix2D', () => {
     const vector = new Vector2D(2, 3);
     const result = Matrix2D.multiplyByVector(matrix, vector);
     isDebug && console.log(JSON.stringify(result));
-    expect(result).toEqual({x: 17, y: 35, w: 1});
+    expect(result).toEqual({ x: 17, y: 35, w: 1 });
   });
 
   it('should correctly create a view matrix', () => {

package/test/unit/data-structures/matrix/navigator.test.ts

@@ -1,5 +1,5 @@
-import {Character, Navigator, NavigatorParams, Turning} from '../../../../src';
-import {isDebugTest} from '../../../config';
+import { Character, Navigator, NavigatorParams, Turning } from '../../../../src';
+import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
 const exampleMatrix: number[][] = [

package/test/unit/data-structures/matrix/vector2d.test.ts

@@ -1,4 +1,4 @@
-import {Vector2D} from '../../../../src';
+import { Vector2D } from '../../../../src';
 
 describe('Vector2D', () => {
   it('should create a vector with default values', () => {

package/test/unit/data-structures/priority-queue/max-priority-queue.test.ts

@@ -1,4 +1,4 @@
-import {MaxPriorityQueue} from '../../../../src';
+import { MaxPriorityQueue } from '../../../../src';
 
 describe('MaxPriorityQueue Operation Test', () => {
   it('should add elements and maintain heap property', () => {
@@ -16,9 +16,9 @@ describe('MaxPriorityQueue Operation Test', () => {
   });
 
   it('should add elements and maintain heap property in a object MaxPriorityQueue', () => {
-    const priorityQueue = new MaxPriorityQueue<{ keyA: number }>({comparator: (a, b) => b.keyA - a.keyA});
-    priorityQueue.refill([{keyA: 5}, {keyA: 3}, {keyA: 1}]);
-    priorityQueue.add({keyA: 7});
+    const priorityQueue = new MaxPriorityQueue<{ keyA: number }>({ comparator: (a, b) => b.keyA - a.keyA });
+    priorityQueue.refill([{ keyA: 5 }, { keyA: 3 }, { keyA: 1 }]);
+    priorityQueue.add({ keyA: 7 });
 
     expect(priorityQueue.poll()?.keyA).toBe(7);
     expect(priorityQueue.poll()?.keyA).toBe(5);
@@ -52,7 +52,7 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an array', () => {
     const array = [5, 3, 7, 1];
-    const heap = MaxPriorityQueue.heapify<number>({nodes: array, comparator: (a, b) => b - a});
+    const heap = MaxPriorityQueue.heapify<number>({ nodes: array, comparator: (a, b) => b - a });
     heap.refill(array);
 
     expect(heap.poll()).toBe(7);
@@ -62,8 +62,8 @@ describe('MaxPriorityQueue Operation Test', () => {
   });
 
   it('should correctly heapify an object array', () => {
-    const nodes = [{keyA: 5}, {keyA: 3}, {keyA: 7}, {keyA: 1}];
-    const maxPQ = MaxPriorityQueue.heapify<{ keyA: number }>({nodes: nodes, comparator: (a, b) => b.keyA - a.keyA});
+    const nodes = [{ keyA: 5 }, { keyA: 3 }, { keyA: 7 }, { keyA: 1 }];
+    const maxPQ = MaxPriorityQueue.heapify<{ keyA: number }>({ nodes: nodes, comparator: (a, b) => b.keyA - a.keyA });
 
     expect(maxPQ.poll()?.keyA).toBe(7);
     expect(maxPQ.poll()?.keyA).toBe(5);

package/test/unit/data-structures/priority-queue/min-priority-queue.test.ts

@@ -1,4 +1,4 @@
-import {MinPriorityQueue} from '../../../../src';
+import { MinPriorityQueue } from '../../../../src';
 
 describe('MinPriorityQueue Operation Test', () => {
   it('should check if a node exists in the queue', () => {

package/test/unit/data-structures/priority-queue/priority-queue.test.ts

@@ -1,11 +1,11 @@
-import {PriorityQueue} from '../../../../src';
-import {PriorityQueue as CPriorityQueue} from 'js-sdsl';
-import {isDebugTest} from '../../../config';
+import { PriorityQueue } from '../../../../src';
+import { PriorityQueue as CPriorityQueue } from 'js-sdsl';
+import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
 describe('PriorityQueue Operation Test', () => {
   it('should PriorityQueue poll, pee, heapify, toArray work well', function () {
-    const minPQ = new PriorityQueue<number>({comparator: (a, b) => a - b});
+    const minPQ = new PriorityQueue<number>({ comparator: (a, b) => a - b });
     minPQ.refill([5, 2, 3, 4, 6, 1]);
     expect(minPQ.toArray()).toEqual([1, 2, 3, 4, 6, 5]);
     minPQ.poll();
@@ -13,16 +13,16 @@ describe('PriorityQueue Operation Test', () => {
     minPQ.poll();
     expect(minPQ.toArray()).toEqual([4, 5, 6]);
     expect(minPQ.peek()).toBe(4);
-    expect(PriorityQueue.heapify({
-      nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10],
-      comparator: (a, b) => a - b
-    }).toArray()).toEqual([
-      1, 2, 3, 5, 6, 7, 8, 9, 10
-    ]);
+    expect(
+      PriorityQueue.heapify({
+        nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10],
+        comparator: (a, b) => a - b
+      }).toArray()
+    ).toEqual([1, 2, 3, 5, 6, 7, 8, 9, 10]);
   });
 
   it('should Max PriorityQueue poll, peek, heapify, toArray work well', function () {
-    const maxPriorityQueue = new PriorityQueue<number>({comparator: (a, b) => b - a});
+    const maxPriorityQueue = new PriorityQueue<number>({ comparator: (a, b) => b - a });
     maxPriorityQueue.refill([5, 2, 3, 4, 6, 1]);
     expect(maxPriorityQueue.toArray()).toEqual([6, 5, 3, 4, 2, 1]);
     maxPriorityQueue.poll();
@@ -30,16 +30,16 @@ describe('PriorityQueue Operation Test', () => {
     maxPriorityQueue.poll();
     expect(maxPriorityQueue.toArray()).toEqual([3, 2, 1]);
     expect(maxPriorityQueue.peek()).toBe(3);
-    expect(PriorityQueue.heapify({
-      nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10],
-      comparator: (a, b) => a - b
-    }).toArray()).toEqual([
-      1, 2, 3, 5, 6, 7, 8, 9, 10
-    ]);
+    expect(
+      PriorityQueue.heapify({
+        nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10],
+        comparator: (a, b) => a - b
+      }).toArray()
+    ).toEqual([1, 2, 3, 5, 6, 7, 8, 9, 10]);
   });
 
   it('should PriorityQueue clone, sort, getNodes, dfs work well', function () {
-    const minPQ1 = new PriorityQueue<number>({comparator: (a, b) => a - b});
+    const minPQ1 = new PriorityQueue<number>({ comparator: (a, b) => a - b });
     minPQ1.refill([2, 5, 8, 3, 1, 6, 7, 4]);
     const clonedPriorityQueue = minPQ1.clone();
     expect(clonedPriorityQueue.getNodes()).toEqual(minPQ1.getNodes());
@@ -52,7 +52,7 @@ describe('PriorityQueue Operation Test', () => {
 
 describe('Priority Queue Performance Test', () => {
   it('should numeric heap work well', function () {
-    const pq = new PriorityQueue({comparator: (a, b) => b - a});
+    const pq = new PriorityQueue({ comparator: (a, b) => b - a });
 
     const tS = performance.now();
 

package/test/unit/data-structures/queue/deque.test.ts

@@ -1,6 +1,6 @@
-import {ArrayDeque, Deque, ObjectDeque} from '../../../../src';
-import {bigO} from '../../../utils';
-import {isDebugTest} from '../../../config';
+import { ArrayDeque, Deque, ObjectDeque } from '../../../../src';
+import { bigO } from '../../../utils';
+import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
 describe('Deque Tests', () => {

package/test/unit/data-structures/queue/queue.test.ts

@@ -1,6 +1,6 @@
-import {LinkedListQueue, Queue} from '../../../../src';
-import {bigO} from '../../../utils';
-import {isDebugTest} from '../../../config';
+import { LinkedListQueue, Queue } from '../../../../src';
+import { bigO } from '../../../utils';
+import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
 describe('Queue Operation Test', () => {

package/test/unit/data-structures/stack/stack.test.ts

@@ -1,4 +1,4 @@
-import {Stack} from '../../../../src';
+import { Stack } from '../../../../src';
 
 describe('Stack', () => {
   let stack: Stack<number>;

package/test/unit/data-structures/tree/tree.test.ts

@@ -1,4 +1,4 @@
-import {TreeNode} from '../../../../src';
+import { TreeNode } from '../../../../src';
 
 describe('TreeNode', () => {
   it('should create a TreeNode with the given key and value', () => {

package/test/unit/data-structures/trie/trie.test.ts

@@ -1,4 +1,4 @@
-import {Trie, TrieNode} from '../../../../src';
+import { Trie, TrieNode } from '../../../../src';
 
 describe('TrieNode', () => {
   it('should create a TrieNode with the given value', () => {

package/test/utils/array.ts

@@ -1,4 +1,4 @@
-import {getRandomInt} from './number';
+import { getRandomInt } from './number';
 
 export function getRandomIntArray(length: number = 1000, min: number = -1000, max: number = 1000, isDistinct = true) {
   if (isDistinct) {

package/test/utils/big-o.ts

@@ -1,5 +1,5 @@
-import {AnyFunction} from '../types';
-import {isDebugTest} from '../config';
+import { AnyFunction } from '../types';
+import { isDebugTest } from '../config';
 
 const isDebug = isDebugTest;
 const orderReducedBy = 1; // reduction of bigO's order compared to the baseline bigO
@@ -32,7 +32,7 @@ export const bigO = {
 
 function findPotentialN(input: any): number {
   let longestArray: any[] = [];
-  let mostProperties: {[key: string]: any} = {};
+  let mostProperties: { [key: string]: any } = {};
 
   function recurse(obj: any) {
     if (Array.isArray(obj)) {
@@ -81,7 +81,7 @@ function linearRegression(x: number[], y: number[]) {
 
   const rSquared = 1 - totalVariation / explainedVariation;
 
-  return {slope, intercept, rSquared};
+  return { slope, intercept, rSquared };
 }
 
 function estimateBigO(runtimes: number[], dataSizes: number[]): string {

package/test/utils/index.ts

@@ -5,3 +5,4 @@ export * from './json2html';
 export * from './is';
 export * from './console';
 export * from './string';
+export * from './performanc';

package/test/utils/json2html.ts

@@ -1,5 +1,5 @@
 import * as _ from './is';
-import {Json2htmlOptions} from '../types';
+import { Json2htmlOptions } from '../types';
 
 function toggleJS(options?: Json2htmlOptions): string {
   if (options?.plainHtml) {
@@ -14,7 +14,9 @@ function makeLabelDiv(options: any, level: number, keyName: string | number, dat
     return `<div class='index'><span class='json-to-html-label'>${keyName}&nbsp;</span></div>`;
   } else if (typeof keyName === 'string') {
     if (datatype === 'array') {
-      return `<div class='collapsible level${level}' ${toggleJS(options)}><span class='json-to-html-label'>${keyName}</span></div>`;
+      return `<div class='collapsible level${level}' ${toggleJS(
+        options
+      )}><span class='json-to-html-label'>${keyName}</span></div>`;
     } else if (datatype === 'object') {
       return `<div class='attribute collapsible level${level}' ${toggleJS(
         options
@@ -120,7 +122,9 @@ function _render(name: string, data: any, options: Json2htmlOptions, level: numb
     } else {
       subs =
         "<div class='altRows'>" +
-        data.map((val: any, idx: number) => _render(idx.toString(), val, options, level + 1, idx % 2)).join("</div><div class='altRows'>") +
+        data
+          .map((val: any, idx: number) => _render(idx.toString(), val, options, level + 1, idx % 2))
+          .join("</div><div class='altRows'>") +
         '</div>';
     }
     return `<div class="json-to-html-collapse clearfix ${altRow}">

package/test/utils/performanc.ts

@@ -0,0 +1,7 @@
+import { performance } from 'perf_hooks';
+
+export const calcRunTime = (callback: (...args: any[]) => any) => {
+  const startTime = performance.now();
+  callback();
+  return performance.now() - startTime;
+}