data-structure-typed 1.49.4 → 1.49.5

package/src/types/data-structures/base/base.ts

@@ -1,6 +1,17 @@
-import { IterableElementBase, IterableEntryBase } from "../../../data-structures";
+import { IterableElementBase, IterableEntryBase } from '../../../data-structures';
 
 export type EntryCallback<K, V, R> = (value: V, key: K, index: number, container: IterableEntryBase<K, V>) => R;
 export type ElementCallback<V, R> = (element: V, index: number, container: IterableElementBase<V>) => R;
-export type ReduceEntryCallback<K, V, R> = (accumulator: R, value: V, key: K, index: number, container: IterableEntryBase<K, V>) => R;
-export type ReduceElementCallback<V, R> = (accumulator: R, element: V, index: number, container: IterableElementBase<V>) => R;
+export type ReduceEntryCallback<K, V, R> = (
+  accumulator: R,
+  value: V,
+  key: K,
+  index: number,
+  container: IterableEntryBase<K, V>
+) => R;
+export type ReduceElementCallback<V, R> = (
+  accumulator: R,
+  element: V,
+  index: number,
+  container: IterableElementBase<V>
+) => R;

package/src/types/data-structures/base/index.ts

@@ -1 +1 @@
-export * from './base';
+export * from './base';

package/src/types/data-structures/graph/abstract-graph.ts

@@ -1,6 +1,7 @@
 export type VertexKey = string | number;
 
-export type DijkstraResult<V> = {
+export type DijkstraResult<V> =
+  | {
   distMap: Map<V, number>;
   distPaths?: Map<V, V[]>;
   preMap: Map<V, V | undefined>;
@@ -8,4 +9,5 @@ export type DijkstraResult<V> = {
   paths: V[][];
   minDist: number;
   minPath: V[];
-} | undefined;
+}
+  | undefined;

package/src/types/data-structures/hash/hash-map.ts

@@ -7,7 +7,7 @@ export type HashMapLinkedNode<K, V> = {
 
 export type HashMapOptions<K> = {
   hashFn: (key: K) => string;
-  objHashFn: (key: K) => object
-}
+  objHashFn: (key: K) => object;
+};
 
-export type HashMapStoreItem<K, V> = { key: K, value: V };
+export type HashMapStoreItem<K, V> = { key: K; value: V };

package/src/types/data-structures/heap/heap.ts

@@ -1,3 +1,3 @@
-import { Comparator } from "../../common";
+import { Comparator } from '../../common';
 
-export type HeapOptions<T> = { comparator: Comparator<T> }
+export type HeapOptions<T> = { comparator: Comparator<T> };

package/src/types/data-structures/priority-queue/priority-queue.ts

@@ -1,3 +1,3 @@
-import { HeapOptions } from "../heap";
+import { HeapOptions } from '../heap';
 
-export type PriorityQueueOptions<T> = HeapOptions<T> & {}
+export type PriorityQueueOptions<T> = HeapOptions<T> & {};

package/src/utils/utils.ts

@@ -98,4 +98,10 @@ export const isWeakKey = (input: unknown): input is object => {
   return (inputType === 'object' && input !== null) || inputType === 'function';
 };
 
-export const calcMinUnitsRequired = (totalQuantity: number, unitSize: number) => Math.floor((totalQuantity + unitSize - 1) / unitSize)
+export const calcMinUnitsRequired = (totalQuantity: number, unitSize: number) =>
+  Math.floor((totalQuantity + unitSize - 1) / unitSize);
+
+export const roundFixed = (num: number, digit: number = 10) => {
+  const multiplier = Math.pow(10, digit);
+  return Math.round(num * multiplier) / multiplier;
+};

package/test/integration/avl-tree.test.ts

@@ -2,7 +2,24 @@ import { AVLTree, CP } from 'avl-tree-typed';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {
-    const arr: [number, number][] = [[11, 11], [3, 3], [15, 15], [1, 1], [8, 8], [13, 13], [16, 16], [2, 2], [6, 6], [9, 9], [12, 12], [14, 14], [4, 4], [7, 7], [10, 10], [5, 5]];
+    const arr: [number, number][] = [
+      [11, 11],
+      [3, 3],
+      [15, 15],
+      [1, 1],
+      [8, 8],
+      [13, 13],
+      [16, 16],
+      [2, 2],
+      [6, 6],
+      [9, 9],
+      [12, 12],
+      [14, 14],
+      [4, 4],
+      [7, 7],
+      [10, 10],
+      [5, 5]
+    ];
     const tree = new AVLTree();
 
     for (const i of arr) tree.add(i);

package/test/integration/bst.test.ts

@@ -7,7 +7,7 @@ describe('Individual package BST operations test', () => {
     bst.add([11, 11]);
     bst.add([3, 3]);
     const idsOrValues = [15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    bst.addMany(idsOrValues, false);
+    bst.addMany(idsOrValues, undefined);
     expect(bst.root).toBeInstanceOf(BSTNode);
 
     if (bst.root) expect(bst.root.key).toBe(11);
@@ -204,7 +204,7 @@ describe('Individual package BST operations test', () => {
       [5, { key: 5, keyA: 5 }]
     ];
 
-    objBST.addMany(values, false);
+    objBST.addMany(values, undefined);
 
     expect(objBST.root).toBeInstanceOf(BSTNode);
 

package/test/performance/data-structures/binary-tree/rb-tree.test.ts

@@ -45,7 +45,7 @@ suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & iterator`, () => {
   rbTree.clear();
   for (let i = 0; i < arr.length; i++) rbTree.add(arr[i]);
   const entries = [...rbTree];
-  return entries.length === HUNDRED_THOUSAND
+  return entries.length === HUNDRED_THOUSAND;
 });
 
 export { suite };

package/test/performance/data-structures/comparison/comparison.test.ts

@@ -22,25 +22,20 @@ const arrHundredThousand = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSA
 
 suite
   .add(`SRC PQ ${TEN_THOUSAND.toLocaleString()} add`, () => {
-
     const pq = new SRCPriorityQueue<number>();
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
   })
   .add(`CJS PQ ${TEN_THOUSAND.toLocaleString()} add`, () => {
-
-
     const pq = new CJSPriorityQueue<number>();
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
   })
   .add(`MJS PQ ${TEN_THOUSAND.toLocaleString()} add`, () => {
-
     const pq = new MJSPriorityQueue<number>([], { comparator: (a, b) => b - a });
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
   });
 
 if (isCompetitor) {
   suite.add(`CPT PQ ${TEN_THOUSAND.toLocaleString()} add`, () => {
-
     const pq = new CPriorityQueue<number>();
     for (let i = 0; i < TEN_THOUSAND; i++) pq.push(i);
   });
@@ -66,14 +61,14 @@ suite
     for (let i = 0; i < TEN_THOUSAND; i++) pq.poll();
   });
 
-
 if (isCompetitor) {
-  suite.add(`CPT PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
-    const pq = new CPriorityQueue<number>();
+  suite
+    .add(`CPT PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
+      const pq = new CPriorityQueue<number>();
 
-    for (let i = 0; i < TEN_THOUSAND; i++) pq.push(i);
-    for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();
-  })
+      for (let i = 0; i < TEN_THOUSAND; i++) pq.push(i);
+      for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();
+    })
     .add(`CPT OM ${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
       for (let i = 0; i < arrHundredThousand.length; i++) {
         cOrderedMap.setElement(arrHundredThousand[i], arrHundredThousand[i]);

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

@@ -78,7 +78,6 @@ suite.add(`Native Set ${MILLION.toLocaleString()} add & has`, () => {
   for (let i = 0; i < MILLION; i++) hs.add(i);
 
   for (let i = 0; i < MILLION; i++) hs.has(i);
-
 });
 
 suite.add(`${MILLION.toLocaleString()} ObjKey set & get`, () => {
@@ -86,7 +85,7 @@ suite.add(`${MILLION.toLocaleString()} ObjKey set & get`, () => {
   const objKeys: [number, number][] = [];
   for (let i = 0; i < MILLION; i++) {
     const obj: [number, number] = [i, i];
-    objKeys.push(obj)
+    objKeys.push(obj);
     hm.set(obj, i);
   }
   for (let i = 0; i < MILLION; i++) {
@@ -99,7 +98,7 @@ suite.add(`Native Map ${MILLION.toLocaleString()} ObjKey set & get`, () => {
   const objs: [number, number][] = [];
   for (let i = 0; i < MILLION; i++) {
     const obj: [number, number] = [i, i];
-    objs.push(obj)
+    objs.push(obj);
     hm.set(obj, i);
   }
   for (let i = 0; i < MILLION; i++) {
@@ -112,7 +111,7 @@ suite.add(`Native Set ${MILLION.toLocaleString()} ObjKey add & has`, () => {
   const objs: [number, number][] = [];
   for (let i = 0; i < MILLION; i++) {
     const obj: [number, number] = [i, i];
-    objs.push(obj)
+    objs.push(obj);
     hs.add(obj);
   }
   for (let i = 0; i < MILLION; i++) {

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

@@ -13,7 +13,6 @@ suite.add(`${MILLION.toLocaleString()} push`, () => {
   for (let i = 0; i < MILLION; i++) list.push(i);
 });
 
-
 if (isCompetitor) {
   suite.add(`CPT ${MILLION.toLocaleString()} push`, () => {
     const list = new CLinkedList<number>();

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

@@ -19,14 +19,13 @@ if (isCompetitor) {
   });
 }
 
+suite
+  .add(`${MILLION.toLocaleString()} push & pop`, () => {
+    const _deque = new Deque<number>();
 
-suite.add(`${MILLION.toLocaleString()} push & pop`, () => {
-  const _deque = new Deque<number>();
-
-  for (let i = 0; i < MILLION; i++) _deque.push(i);
-  for (let i = 0; i < MILLION; i++) _deque.pop();
-
-})
+    for (let i = 0; i < MILLION; i++) _deque.push(i);
+    for (let i = 0; i < MILLION; i++) _deque.pop();
+  })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
     const _deque = new Deque<number>();
 

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

@@ -33,16 +33,17 @@ suite.add(`${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
     queue.shift();
   }
 });
-suite.add(`Native Array ${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
-  const arr = new Array<number>();
+suite
+  .add(`Native Array ${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
+    const arr = new Array<number>();
 
-  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-    arr.push(i);
-  }
-  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-    arr.shift();
-  }
-})
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+      arr.push(i);
+    }
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+      arr.shift();
+    }
+  })
   .add(`Native Array ${HUNDRED_THOUSAND.toLocaleString()} push & pop`, () => {
     const arr = new Array<number>();
 

package/test/performance/reportor.ts

@@ -5,20 +5,19 @@ import * as fastGlob from 'fast-glob';
 import { Color, numberFix, render } from '../utils';
 import { PerformanceTest } from './types';
 
-
 const args = process.argv.slice(2);
 
 const { GREEN, BOLD, END, YELLOW, GRAY, CYAN, BG_YELLOW } = Color;
 
 const getRelativePath = (file: string) => {
   return path.relative(__dirname, file);
-}
+};
 const coloredLabeled = (label: string, file: string) => {
   const relativeFilePath = getRelativePath(file);
   const directory = path.dirname(relativeFilePath);
   const fileName = path.basename(relativeFilePath);
   return `${BG_YELLOW} ${label} ${END} ${GRAY}${directory}/${END}${CYAN}${fileName}${END}`;
-}
+};
 
 const parentDirectory = path.resolve(__dirname, '../..');
 const reportDistPath = path.join(parentDirectory, 'benchmark');
@@ -29,20 +28,19 @@ let testFiles: string[];
 
 let isIndividual = false;
 if (args.length > 0) {
-  console.log(`arguments: ${args.join(' ')}`)
+  console.log(`arguments: ${args.join(' ')}`);
 
-  testFiles = allFiles.filter(file =>
-    args.every(word => file.includes(word))
-  );
+  testFiles = allFiles.filter(file => args.every(word => file.includes(word)));
   isIndividual = true;
-  console.log(`${testFiles.map(file => coloredLabeled('Matched', file)).join(`
-`)}`);
+  console.log(
+    `${testFiles.map(file => coloredLabeled('Matched', file)).join(`
+`)}`
+  );
 } else {
   isIndividual = false;
   testFiles = allFiles;
 }
 
-
 const report: { [key: string]: any } = {};
 
 let completedCount = 0;
@@ -132,11 +130,12 @@ const composeReport = () => {
   html += `</div>
                     </body>
                   </html>`;
-  if (!isIndividual) replaceMarkdownContent(
-    '[//]: # (No deletion!!! Start of Replace Section)', // Start tag
-    '[//]: # (No deletion!!! End of Replace Section)', // end identifier
-    htmlTables // New content to be inserted
-  );
+  if (!isIndividual)
+    replaceMarkdownContent(
+      '[//]: # (No deletion!!! Start of Replace Section)', // Start tag
+      '[//]: # (No deletion!!! End of Replace Section)', // end identifier
+      htmlTables // New content to be inserted
+    );
   fs.writeFileSync(htmlFilePath, html);
   console.log(`Performance ${BOLD}${GREEN}report${END} file generated in file://${BOLD}${GREEN}${htmlFilePath}${END}`);
 };

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

@@ -318,13 +318,20 @@ describe('AVLTree iterative methods test', () => {
   test('filter should return a new tree with filtered elements', () => {
     const filteredTree = avl.filter((value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
-    expect([...filteredTree]).toEqual([[2, 'b'], [3, 'c']]);
+    expect([...filteredTree]).toEqual([
+      [2, 'b'],
+      [3, 'c']
+    ]);
   });
 
   test('map should return a new tree with modified elements', () => {
     const mappedTree = avl.map((value, key) => (key * 2).toString());
     expect(mappedTree.size).toBe(3);
-    expect([...mappedTree]).toEqual([[1, '2'], [2, '4'], [3, '6']]);
+    expect([...mappedTree]).toEqual([
+      [1, '2'],
+      [2, '4'],
+      [3, '6']
+    ]);
   });
 
   test('reduce should accumulate values', () => {
@@ -339,7 +346,11 @@ describe('AVLTree iterative methods test', () => {
     }
 
     expect(entries.length).toBe(3);
-    expect(entries).toEqual([[1, 'a'], [2, 'b'], [3, 'c']]);
+    expect(entries).toEqual([
+      [1, 'a'],
+      [2, 'b'],
+      [3, 'c']
+    ]);
   });
 
   test('should clone work well', () => {

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

@@ -265,7 +265,22 @@ describe('BinaryTree', () => {
     tree.clear();
     tree.addMany([-10, -10, -10, 9, 9, 20, null, null, 15, 7, 8, null, 2, null, 6, null, null, 8, 8, 8]);
 
-    expect(tree.bfs(node => node ? node.key : null, undefined, undefined, true)).toEqual([-10, 9, 20, null, null, 15, 7, 8, null, 2, null, 6, null, null])
+    expect(tree.bfs(node => (node ? node.key : null), undefined, undefined, true)).toEqual([
+      -10,
+      9,
+      20,
+      null,
+      null,
+      15,
+      7,
+      8,
+      null,
+      2,
+      null,
+      6,
+      null,
+      null
+    ]);
   });
 });
 
@@ -525,18 +540,12 @@ describe('BinaryTree', () => {
     tree.add([3, 'B']);
     tree.add([7, 'C']);
 
-    const nodes = tree.getNodes('B', (node) => node.value);
+    const nodes = tree.getNodes('B', node => node.value);
 
     expect(nodes.length).toBe(1);
     expect(nodes[0].key).toBe(3);
 
-    const nodesRec = tree.getNodes(
-      'B',
-      (node) => node.value,
-      false,
-      tree.root,
-      IterationType.RECURSIVE
-    );
+    const nodesRec = tree.getNodes('B', node => node.value, false, tree.root, IterationType.RECURSIVE);
 
     expect(nodesRec.length).toBe(1);
     expect(nodesRec[0].key).toBe(3);
@@ -548,9 +557,17 @@ describe('BinaryTree', () => {
     tree.add([7, 'C']);
 
     tree.iterationType = IterationType.ITERATIVE;
-    expect([...tree]).toEqual([[3, "B"], [5, "A"], [7, "C"]]);
+    expect([...tree]).toEqual([
+      [3, 'B'],
+      [5, 'A'],
+      [7, 'C']
+    ]);
     tree.iterationType = IterationType.RECURSIVE;
-    expect([...tree]).toEqual([[3, "B"], [5, "A"], [7, "C"]]);
+    expect([...tree]).toEqual([
+      [3, 'B'],
+      [5, 'A'],
+      [7, 'C']
+    ]);
     tree.iterationType = IterationType.ITERATIVE;
 
     const result = tree.morris();
@@ -600,13 +617,20 @@ describe('BinaryTree iterative methods test', () => {
   test('filter should return a new tree with filtered elements', () => {
     const filteredTree = binaryTree.filter((value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
-    expect([...filteredTree]).toEqual([[3, 'c'], [2, 'b']]);
+    expect([...filteredTree]).toEqual([
+      [3, 'c'],
+      [2, 'b']
+    ]);
   });
 
   test('map should return a new tree with modified elements', () => {
     const mappedTree = binaryTree.map((value, key) => (key * 2).toString());
     expect(mappedTree.size).toBe(3);
-    expect([...mappedTree]).toEqual([[1, '2'], [2, '4'], [3, '6']]);
+    expect([...mappedTree]).toEqual([
+      [1, '2'],
+      [2, '4'],
+      [3, '6']
+    ]);
   });
 
   test('reduce should accumulate values', () => {
@@ -621,7 +645,11 @@ describe('BinaryTree iterative methods test', () => {
     }
 
     expect(entries.length).toBe(3);
-    expect(entries).toEqual([[2, 'b'], [1, 'a'], [3, 'c']]);
+    expect(entries).toEqual([
+      [2, 'b'],
+      [1, 'a'],
+      [3, 'c']
+    ]);
   });
 
   test('should clone work well', () => {
@@ -641,17 +669,24 @@ describe('BinaryTree iterative methods test', () => {
   });
 
   test('should iterative method return undefined when the node is null', () => {
-    const tree = new BinaryTree()
+    const tree = new BinaryTree();
     tree.addMany([-10, -10, -10, 9, 9, 20, null, null, 15, 7, 8, null, 2, null, 6, null, null, 8, 8, 8]);
     const bfsResult = tree.bfs(undefined, undefined, undefined, true);
     expect(bfsResult).toEqual([
-      -10, 9,
-      20, undefined,
-      undefined, 15,
-      7, 8,
-      undefined, 2,
-      undefined, 6,
-      undefined, undefined
+      -10,
+      9,
+      20,
+      undefined,
+      undefined,
+      15,
+      7,
+      8,
+      undefined,
+      2,
+      undefined,
+      6,
+      undefined,
+      undefined
     ]);
-  })
-});
+  });
+});

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

@@ -9,7 +9,22 @@ describe('BST operations test', () => {
     expect(bst).toBeInstanceOf(BST);
     bst.add([11, 11]);
     bst.add([3, 3]);
-    const idsAndValues: [number, number][] = [[15, 15], [1, 1], [8, 8], [13, 13], [16, 16], [2, 2], [6, 6], [9, 9], [12, 12], [14, 14], [4, 4], [7, 7], [10, 10], [5, 5]];
+    const idsAndValues: [number, number][] = [
+      [15, 15],
+      [1, 1],
+      [8, 8],
+      [13, 13],
+      [16, 16],
+      [2, 2],
+      [6, 6],
+      [9, 9],
+      [12, 12],
+      [14, 14],
+      [4, 4],
+      [7, 7],
+      [10, 10],
+      [5, 5]
+    ];
     bst.addMany(idsAndValues, undefined, false);
     expect(bst.root).toBeInstanceOf(BSTNode);
 
@@ -194,22 +209,26 @@ describe('BST operations test', () => {
     objBST.add([11, { name: '11', age: 11 }]);
     objBST.add([3, { name: '3', age: 3 }]);
 
-    objBST.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], [
-      { "name": "Alice", "age": 15 },
-      { "name": "Bob", "age": 1 },
-      { "name": "Charlie", "age": 8 },
-      { "name": "David", "age": 13 },
-      { "name": "Emma", "age": 16 },
-      { "name": "Frank", "age": 2 },
-      { "name": "Grace", "age": 6 },
-      { "name": "Hannah", "age": 9 },
-      { "name": "Isaac", "age": 12 },
-      { "name": "Jack", "age": 14 },
-      { "name": "Katie", "age": 4 },
-      { "name": "Liam", "age": 7 },
-      { "name": "Mia", "age": 10 },
-      { "name": "Noah", "age": 5 }
-    ], false);
+    objBST.addMany(
+      [15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5],
+      [
+        { name: 'Alice', age: 15 },
+        { name: 'Bob', age: 1 },
+        { name: 'Charlie', age: 8 },
+        { name: 'David', age: 13 },
+        { name: 'Emma', age: 16 },
+        { name: 'Frank', age: 2 },
+        { name: 'Grace', age: 6 },
+        { name: 'Hannah', age: 9 },
+        { name: 'Isaac', age: 12 },
+        { name: 'Jack', age: 14 },
+        { name: 'Katie', age: 4 },
+        { name: 'Liam', age: 7 },
+        { name: 'Mia', age: 10 },
+        { name: 'Noah', age: 5 }
+      ],
+      false
+    );
 
     expect(objBST.root).toBeInstanceOf(BSTNode);
 
@@ -596,11 +615,7 @@ describe('BST operations test recursively', () => {
       [5, { key: 5, keyA: 5 }]
     ];
 
-    objBST.addMany(
-      entries,
-      undefined,
-      false
-    );
+    objBST.addMany(entries, undefined, false);
 
     expect(objBST.root).toBeInstanceOf(BSTNode);
 
@@ -878,13 +893,20 @@ describe('BST iterative methods test', () => {
   test('filter should return a new tree with filtered elements', () => {
     const filteredTree = bst.filter((value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
-    expect([...filteredTree]).toEqual([[2, 'b'], [3, 'c']]);
+    expect([...filteredTree]).toEqual([
+      [2, 'b'],
+      [3, 'c']
+    ]);
   });
 
   test('map should return a new tree with modified elements', () => {
     const mappedTree = bst.map((value, key) => (key * 2).toString());
     expect(mappedTree.size).toBe(3);
-    expect([...mappedTree]).toEqual([[1, '2'], [2, '4'], [3, '6']]);
+    expect([...mappedTree]).toEqual([
+      [1, '2'],
+      [2, '4'],
+      [3, '6']
+    ]);
   });
 
   test('reduce should accumulate values', () => {
@@ -899,7 +921,11 @@ describe('BST iterative methods test', () => {
     }
 
     expect(entries.length).toBe(3);
-    expect(entries).toEqual([[1, 'a'], [2, 'b'], [3, 'c']]);
+    expect(entries).toEqual([
+      [1, 'a'],
+      [2, 'b'],
+      [3, 'c']
+    ]);
   });
 
   test('should clone work well', () => {
@@ -917,4 +943,4 @@ describe('BST iterative methods test', () => {
     const values = bst.values();
     expect([...values]).toEqual(['a', 'b', 'c']);
   });
-});
+});