data-structure-typed 1.49.3 → 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

@@ -16,31 +16,26 @@ import { getRandomIntArray, magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const { TEN_THOUSAND, HUNDRED_THOUSAND, LINEAR } = magnitude;
+const { TEN_THOUSAND, HUNDRED_THOUSAND, MILLION } = magnitude;
 const cOrderedMap = new OrderedMap<number, number>();
 const arrHundredThousand = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND, true);
 
 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]);
@@ -96,10 +91,10 @@ if (isCompetitor) {
         hm.getElementByKey(i);
       }
     })
-    .add(`CPT LL ${LINEAR.toLocaleString()} unshift`, () => {
+    .add(`CPT LL ${MILLION.toLocaleString()} unshift`, () => {
       const list = new CLinkedList<number>();
 
-      for (let i = 0; i < LINEAR; i++) {
+      for (let i = 0; i < MILLION; i++) {
         list.pushFront(i);
       }
     })
@@ -114,33 +109,33 @@ if (isCompetitor) {
         pq.pop();
       }
     })
-    .add(`CPT DQ ${LINEAR.toLocaleString()} push`, () => {
+    .add(`CPT DQ ${MILLION.toLocaleString()} push`, () => {
       const deque = new CDeque<number>();
-      for (let i = 0; i < LINEAR; i++) {
+      for (let i = 0; i < MILLION; i++) {
         deque.pushBack(i);
       }
     })
-    .add(`CPT Q ${LINEAR.toLocaleString()} push`, () => {
+    .add(`CPT Q ${MILLION.toLocaleString()} push`, () => {
       const queue = new CQueue<number>();
 
-      for (let i = 0; i < LINEAR; i++) {
+      for (let i = 0; i < MILLION; i++) {
         queue.push(i);
       }
     })
-    .add(`CPT ST ${LINEAR.toLocaleString()} push`, () => {
+    .add(`CPT ST ${MILLION.toLocaleString()} push`, () => {
       const queue = new CStack<number>();
 
-      for (let i = 0; i < LINEAR; i++) {
+      for (let i = 0; i < MILLION; i++) {
         queue.push(i);
       }
     })
-    .add(`CPT ST ${LINEAR.toLocaleString()} push & pop`, () => {
+    .add(`CPT ST ${MILLION.toLocaleString()} push & pop`, () => {
       const queue = new CStack<number>();
 
-      for (let i = 0; i < LINEAR; i++) {
+      for (let i = 0; i < MILLION; i++) {
         queue.push(i);
       }
-      for (let i = 0; i < LINEAR; i++) {
+      for (let i = 0; i < MILLION; i++) {
         queue.pop();
       }
     });

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

@@ -5,61 +5,49 @@ import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const { LINEAR } = magnitude;
+const { MILLION } = magnitude;
 
-suite.add(`${LINEAR.toLocaleString()} push`, () => {
+suite.add(`${MILLION.toLocaleString()} push`, () => {
   const list = new DoublyLinkedList<number>();
 
-  for (let i = 0; i < LINEAR; i++) {
-    list.push(i);
-  }
+  for (let i = 0; i < MILLION; i++) list.push(i);
 });
 
-
 if (isCompetitor) {
-  suite.add(`CPT ${LINEAR.toLocaleString()} push`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} push`, () => {
     const list = new CLinkedList<number>();
 
-    for (let i = 0; i < LINEAR; i++) {
-      list.pushBack(i);
-    }
+    for (let i = 0; i < MILLION; i++) list.pushBack(i);
   });
 }
 
-suite.add(`${LINEAR.toLocaleString()} unshift`, () => {
+suite.add(`${MILLION.toLocaleString()} unshift`, () => {
   const list = new DoublyLinkedList<number>();
 
-  for (let i = 0; i < LINEAR; i++) {
-    list.unshift(i);
-  }
+  for (let i = 0; i < MILLION; i++) list.unshift(i);
 });
 
 if (isCompetitor) {
-  suite.add(`CPT ${LINEAR.toLocaleString()} unshift`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} unshift`, () => {
     const list = new CLinkedList<number>();
 
-    for (let i = 0; i < LINEAR; i++) {
-      list.pushFront(i);
-    }
+    for (let i = 0; i < MILLION; i++) list.pushFront(i);
   });
 }
 
 suite
-  .add(`${LINEAR.toLocaleString()} unshift & shift`, () => {
+  .add(`${MILLION.toLocaleString()} unshift & shift`, () => {
     const list = new DoublyLinkedList<number>();
 
-    for (let i = 0; i < LINEAR; i++) {
-      list.unshift(i);
-    }
-    for (let i = 0; i < LINEAR; i++) {
-      list.shift();
-    }
+    for (let i = 0; i < MILLION; i++) list.unshift(i);
+
+    for (let i = 0; i < MILLION; i++) list.shift();
   })
-  .add(`${LINEAR.toLocaleString()} addBefore`, () => {
+  .add(`${MILLION.toLocaleString()} addBefore`, () => {
     const doublyList = new DoublyLinkedList<number>();
     let midNode: DoublyLinkedListNode | undefined;
-    const midIndex = Math.floor(LINEAR / 2);
-    for (let i = 0; i < LINEAR; i++) {
+    const midIndex = Math.floor(MILLION / 2);
+    for (let i = 0; i < MILLION; i++) {
       doublyList.push(i);
       if (i === midIndex) {
         midNode = doublyList.getNode(i);

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

@@ -9,24 +9,16 @@ suite
   .add(`${MILLION.toLocaleString()} push & shift`, () => {
     const list = new SinglyLinkedList<number>();
 
-    for (let i = 0; i < MILLION; i++) {
-      list.push(i);
-    }
+    for (let i = 0; i < MILLION; i++) list.push(i);
 
-    for (let i = 0; i < MILLION; i++) {
-      list.shift();
-    }
+    for (let i = 0; i < MILLION; i++) list.shift();
   })
   .add(`${TEN_THOUSAND.toLocaleString()} push & pop`, () => {
     const list = new SinglyLinkedList<number>();
 
-    for (let i = 0; i < TEN_THOUSAND; i++) {
-      list.push(i);
-    }
+    for (let i = 0; i < TEN_THOUSAND; i++) list.push(i);
 
-    for (let i = 0; i < TEN_THOUSAND; i++) {
-      list.pop();
-    }
+    for (let i = 0; i < TEN_THOUSAND; i++) list.pop();
   })
   .add(`${TEN_THOUSAND.toLocaleString()} addBefore`, () => {
     const singlyList = new SinglyLinkedList<number>();

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

@@ -5,28 +5,27 @@ import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 export const suite = new Benchmark.Suite();
-const { LINEAR, HUNDRED_THOUSAND } = magnitude;
+const { MILLION, HUNDRED_THOUSAND } = magnitude;
 
-suite.add(`${LINEAR.toLocaleString()} push`, () => {
+suite.add(`${MILLION.toLocaleString()} push`, () => {
   const deque = new Deque<number>();
-  for (let i = 0; i < LINEAR; i++) deque.push(i);
+  for (let i = 0; i < MILLION; i++) deque.push(i);
 });
 
 if (isCompetitor) {
-  suite.add(`CPT ${LINEAR.toLocaleString()} push`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} push`, () => {
     const _deque = new CDeque<number>();
-    for (let i = 0; i < LINEAR; i++) _deque.pushBack(i);
+    for (let i = 0; i < MILLION; i++) _deque.pushBack(i);
   });
 }
 
+suite
+  .add(`${MILLION.toLocaleString()} push & pop`, () => {
+    const _deque = new Deque<number>();
 
-suite.add(`${LINEAR.toLocaleString()} push & pop`, () => {
-  const _deque = new Deque<number>();
-
-  for (let i = 0; i < LINEAR; i++) _deque.push(i);
-  for (let i = 0; i < LINEAR; 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

@@ -5,20 +5,20 @@ import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const { LINEAR, HUNDRED_THOUSAND } = magnitude;
+const { MILLION, HUNDRED_THOUSAND } = magnitude;
 
-suite.add(`${LINEAR.toLocaleString()} push`, () => {
+suite.add(`${MILLION.toLocaleString()} push`, () => {
   const queue = new Queue<number>();
 
-  for (let i = 0; i < LINEAR; i++) {
+  for (let i = 0; i < MILLION; i++) {
     queue.push(i);
   }
 });
 if (isCompetitor) {
-  suite.add(`CPT ${LINEAR.toLocaleString()} push`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} push`, () => {
     const queue = new CQueue<number>();
 
-    for (let i = 0; i < LINEAR; i++) {
+    for (let i = 0; i < MILLION; i++) {
       queue.push(i);
     }
   });
@@ -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/data-structures/stack/stack.test.ts

@@ -5,42 +5,42 @@ import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const { LINEAR } = magnitude;
+const { MILLION } = magnitude;
 
-suite.add(`${LINEAR.toLocaleString()} push`, () => {
+suite.add(`${MILLION.toLocaleString()} push`, () => {
   const stack = new Stack<number>();
 
-  for (let i = 0; i < LINEAR; i++) {
+  for (let i = 0; i < MILLION; i++) {
     stack.push(i);
   }
 });
 if (isCompetitor) {
-  suite.add(`CPT ${LINEAR.toLocaleString()} push`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} push`, () => {
     const queue = new CStack<number>();
 
-    for (let i = 0; i < LINEAR; i++) {
+    for (let i = 0; i < MILLION; i++) {
       queue.push(i);
     }
   });
 }
-suite.add(`${LINEAR.toLocaleString()} push & pop`, () => {
+suite.add(`${MILLION.toLocaleString()} push & pop`, () => {
   const queue = new Stack<number>();
 
-  for (let i = 0; i < LINEAR; i++) {
+  for (let i = 0; i < MILLION; i++) {
     queue.push(i);
   }
-  for (let i = 0; i < LINEAR; i++) {
+  for (let i = 0; i < MILLION; i++) {
     queue.pop();
   }
 });
 if (isCompetitor) {
-  suite.add(`CPT ${LINEAR.toLocaleString()} push & pop`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} push & pop`, () => {
     const queue = new CStack<number>();
 
-    for (let i = 0; i < LINEAR; i++) {
+    for (let i = 0; i < MILLION; i++) {
       queue.push(i);
     }
-    for (let i = 0; i < LINEAR; i++) {
+    for (let i = 0; i < MILLION; i++) {
       queue.pop();
     }
   });

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', () => {