data-structure-typed 1.52.1 → 1.52.3

package/test/integration/bst.test.ts

@@ -226,7 +226,10 @@ describe('Individual package BST operations test', () => {
     expect(leftMost?.key).toBe(1);
 
     const node15 = objBST.getNode(15);
-    expect(node15?.value).toEqual({ key: 15, keyA: 15 });
+    expect(node15?.value).toEqual({
+      key: 15,
+      keyA: 15
+    });
     const minNodeBySpecificNode = node15 && objBST.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 

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

@@ -30,7 +30,9 @@ suite
     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 });
+    const pq = new MJSPriorityQueue<number>([], {
+      comparator: (a, b) => b - a
+    });
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
   });
 
@@ -43,19 +45,25 @@ if (isCompetitor) {
 
 suite
   .add(`SRC PQ ${TEN_THOUSAND.toLocaleString()} add & poll`, () => {
-    const pq = new SRCPriorityQueue<number>([], { comparator: (a, b) => b - a });
+    const pq = new SRCPriorityQueue<number>([], {
+      comparator: (a, b) => b - a
+    });
 
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
     for (let i = 0; i < TEN_THOUSAND; i++) pq.poll();
   })
   .add(`CJS PQ ${TEN_THOUSAND.toLocaleString()} add & poll`, () => {
-    const pq = new CJSPriorityQueue<number>([], { comparator: (a, b) => b - a });
+    const pq = new CJSPriorityQueue<number>([], {
+      comparator: (a, b) => b - a
+    });
 
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
     for (let i = 0; i < TEN_THOUSAND; i++) pq.poll();
   })
   .add(`MJS PQ ${TEN_THOUSAND.toLocaleString()} add & poll`, () => {
-    const pq = new MJSPriorityQueue<number>([], { comparator: (a, b) => b - a });
+    const pq = new MJSPriorityQueue<number>([], {
+      comparator: (a, b) => b - a
+    });
 
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
     for (let i = 0; i < TEN_THOUSAND; i++) pq.poll();

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

@@ -9,11 +9,15 @@ const { HUNDRED_THOUSAND } = magnitude;
 
 suite
   .add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
-    const heap = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
+    const heap = new PriorityQueue<number>([], {
+      comparator: (a, b) => b - a
+    });
     for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.add(i);
   })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} add & poll`, () => {
-    const heap = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
+    const heap = new PriorityQueue<number>([], {
+      comparator: (a, b) => b - a
+    });
 
     for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.add(i);
     for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.poll();

package/test/performance/reportor.ts

@@ -51,11 +51,19 @@ testFiles.forEach((file: string) => {
   const testName = path.basename(file, '.test.ts');
   const testFunction = require(file);
   const { suite } = testFunction;
-  if (suite) performanceTests.push({ testName, suite, file });
+  if (suite)
+    performanceTests.push({
+      testName,
+      suite,
+      file
+    });
 });
 
 const composeReport = () => {
-  if (!fs.existsSync(reportDistPath)) fs.mkdirSync(reportDistPath, { recursive: true });
+  if (!fs.existsSync(reportDistPath))
+    fs.mkdirSync(reportDistPath, {
+      recursive: true
+    });
 
   const filePath = path.join(reportDistPath, 'report.json');
   const htmlFilePath = path.join(reportDistPath, 'report.html');
@@ -114,9 +122,18 @@ const composeReport = () => {
           {
             '<>': 'tr',
             html: [
-              { '<>': 'td', html: '${name}' },
-              { '<>': 'td', html: '${periodMS}' },
-              { '<>': 'td', html: '${mean}' }
+              {
+                '<>': 'td',
+                html: '${name}'
+              },
+              {
+                '<>': 'td',
+                html: '${periodMS}'
+              },
+              {
+                '<>': 'td',
+                html: '${mean}'
+              }
             ]
           }
         ]
@@ -242,9 +259,7 @@ sortedPerformanceTests.forEach(item => {
         console.log(
           // `Files: ${GREEN}${testFileCount}${END} `,
           // `Suites: ${GREEN}${performanceTests.length}${END} `,
-          `Suites Progress: ${isDone ? GREEN : YELLOW}${completedCount}${END}/${isDone ? GREEN : YELLOW}${
-            performanceTests.length
-          }${END}`,
+          `Suites Progress: ${isDone ? GREEN : YELLOW}${completedCount}${END}/${isDone ? GREEN : YELLOW}${performanceTests.length}${END}`,
           `Time: ${isTimeWarn ? YELLOW : GREEN}${runTime}s${END}`
         );
         if (isDone) {

package/test/performance/types/reportor.ts

@@ -1,3 +1,7 @@
 import * as Benchmark from 'benchmark';
 
-export type PerformanceTest = { testName: string; suite: Benchmark.Suite; file: string };
+export type PerformanceTest = {
+  testName: string;
+  suite: Benchmark.Suite;
+  file: string;
+};

package/test/types/utils/json2html.ts

@@ -1 +1,5 @@
-export type Json2htmlOptions = { plainHtml?: boolean } & Partial<{ [key: string]: any }>;
+export type Json2htmlOptions = {
+  plainHtml?: boolean;
+} & Partial<{
+  [key: string]: any;
+}>;

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

@@ -291,7 +291,9 @@ describe('AVLTreeMultiMap operations test1', () => {
 
 describe('AVLTreeMultiMap operations test recursively1', () => {
   it('should perform various operations on a Binary Search Tree with numeric values1', () => {
-    const treeMultimap = new AVLTreeMultiMap<number>([], { iterationType: 'RECURSIVE' });
+    const treeMultimap = new AVLTreeMultiMap<number>([], {
+      iterationType: 'RECURSIVE'
+    });
 
     expect(treeMultimap instanceof AVLTreeMultiMap);
     treeMultimap.add([11, 11]);
@@ -741,7 +743,9 @@ describe('AVLTree toEntryFn', () => {
   it('should toEntryFn 3', () => {
     const tree = new AVLTreeMultiMap<{ obj: { id: number } }, number>(
       [{ obj: { id: 1 } }, { obj: { id: 2 } }, { obj: { id: 3 } }, { obj: { id: 4 } }, { obj: { id: 5 } }],
-      { comparator: (a, b) => a.obj.id - b.obj.id }
+      {
+        comparator: (a, b) => a.obj.id - b.obj.id
+      }
     );
 
     const expected = [

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

@@ -228,7 +228,10 @@ describe('AVLTree APIs test', () => {
     avl.add(1);
     const node2 = new AVLTreeNode(2);
     avl.add(node2);
-    const node3 = new AVLTreeNode(3, { id: 3, text: 'text3' });
+    const node3 = new AVLTreeNode(3, {
+      id: 3,
+      text: 'text3'
+    });
     avl.add(node3);
     avl.add([3, { id: 3, text: 'text33' }]);
 
@@ -314,7 +317,10 @@ describe('AVLTree', () => {
       avl.add(1);
       const node2 = new AVLTreeNode(2);
       avl.add(node2);
-      const node3 = new AVLTreeNode(3, { id: 3, text: 'text3' });
+      const node3 = new AVLTreeNode(3, {
+        id: 3,
+        text: 'text3'
+      });
       avl.add(node3);
       avl.add([3, { id: 3, text: 'text33' }]);
 

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

@@ -8,13 +8,18 @@ describe('BinaryIndexedTree simple', () => {
 
   beforeEach(() => {
     //Create a new BinaryIndexedTree instance before each test case
-    bit = new BinaryIndexedTree({ frequency: 0, max: 10 }); // Modify the value of max as needed
+    bit = new BinaryIndexedTree({
+      frequency: 0,
+      max: 10
+    }); // Modify the value of max as needed
   });
 
   it('should initialize correctly', () => {
     expect(bit.freq).toBe(0);
     expect(bit.max).toBe(10);
-    expect(bit.freqMap).toEqual({ 0: 0 }); // Modify the initialized record value according to the actual situation
+    expect(bit.freqMap).toEqual({
+      0: 0
+    }); // Modify the initialized record value according to the actual situation
     // More initialization checks can be added
   });
 
@@ -54,7 +59,10 @@ describe('BinaryIndexedTree', () => {
   let bit: BinaryIndexedTree;
 
   beforeEach(function () {
-    bit = new BinaryIndexedTree({ frequency, max });
+    bit = new BinaryIndexedTree({
+      frequency,
+      max
+    });
   });
   it('should validate the index', function () {
     expect(() => bit.readSingle(-1)).toThrow('Index out of range');
@@ -73,7 +81,10 @@ describe('BinaryIndexedTree', () => {
   it('should frequency and max', function () {
     const frequency = 200;
     const max = 1000;
-    const bit = new BinaryIndexedTree({ frequency, max });
+    const bit = new BinaryIndexedTree({
+      frequency,
+      max
+    });
 
     expect(bit.freq).toBe(frequency);
     expect(bit.max).toBe(max);
@@ -123,7 +134,9 @@ describe('designated values', function () {
   let bit: BinaryIndexedTree;
 
   beforeEach(function () {
-    bit = new BinaryIndexedTree({ max: array.length });
+    bit = new BinaryIndexedTree({
+      max: array.length
+    });
     array.forEach((value, i) => bit.writeSingle(i, value));
   });
 
@@ -182,7 +195,9 @@ describe('descending sequence', function () {
   let bit: BinaryIndexedTree;
 
   beforeEach(function () {
-    bit = new BinaryIndexedTree({ max: array.length });
+    bit = new BinaryIndexedTree({
+      max: array.length
+    });
     array.forEach((value, i) => bit.writeSingle(i, value));
   });
 
@@ -219,7 +234,9 @@ describe('descending sequence', function () {
 
 describe('BinaryIndexedTree additional tests', () => {
   it('should handle read method correctly', () => {
-    const bit = new BinaryIndexedTree({ max: 10 });
+    const bit = new BinaryIndexedTree({
+      max: 10
+    });
     bit.writeSingle(2, 10);
     bit.writeSingle(5, 20);
     bit.writeSingle(8, 30);
@@ -227,7 +244,9 @@ describe('BinaryIndexedTree additional tests', () => {
   });
 
   it('should handle consecutive operations', () => {
-    const bit = new BinaryIndexedTree({ max: 10 });
+    const bit = new BinaryIndexedTree({
+      max: 10
+    });
     bit.writeSingle(2, 10);
     bit.update(2, 5);
     expect(bit.readSingle(2)).toBe(15);
@@ -237,7 +256,9 @@ describe('BinaryIndexedTree additional tests', () => {
   });
 
   it('should handle frequent increment updates', () => {
-    const bit = new BinaryIndexedTree({ max: 10 });
+    const bit = new BinaryIndexedTree({
+      max: 10
+    });
     for (let i = 0; i < 10; i++) {
       bit.update(2, 5);
     }
@@ -245,7 +266,9 @@ describe('BinaryIndexedTree additional tests', () => {
   });
 
   it('should handle edge cases', () => {
-    const bit = new BinaryIndexedTree({ max: 10 });
+    const bit = new BinaryIndexedTree({
+      max: 10
+    });
     bit.writeSingle(9, 100);
     expect(bit.readSingle(9)).toBe(100);
     expect(bit.lowerBound(200)).toBe(10);
@@ -291,7 +314,9 @@ describe('', () => {
 
     constructor(nums: number[]) {
       this._nums = nums;
-      this._tree = new BinaryIndexedTree({ max: nums.length + 1 });
+      this._tree = new BinaryIndexedTree({
+        max: nums.length + 1
+      });
       for (let i = 0; i < nums.length; i++) {
         this._tree.update(i + 1, nums[i]);
       }

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

@@ -570,7 +570,9 @@ describe('BinaryTree', () => {
   let tree: BinaryTree<number, string>;
 
   beforeEach(() => {
-    tree = new BinaryTree<number, string>([], { iterationType: 'RECURSIVE' });
+    tree = new BinaryTree<number, string>([], {
+      iterationType: 'RECURSIVE'
+    });
   });
 
   afterEach(() => {

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

@@ -252,7 +252,10 @@ describe('BST operations test', () => {
     expect(leftMost?.key).toBe(1);
 
     const node15 = objBST.getNode(15);
-    expect(node15?.value).toEqual({ name: 'Alice', age: 15 });
+    expect(node15?.value).toEqual({
+      name: 'Alice',
+      age: 15
+    });
     const minNodeBySpecificNode = node15 && objBST.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
@@ -411,7 +414,9 @@ describe('BST operations test', () => {
 
 describe('BST operations test recursively', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
-    const bst = new BST<number>([], { iterationType: 'RECURSIVE' });
+    const bst = new BST<number>([], {
+      iterationType: 'RECURSIVE'
+    });
     expect(bst).toBeInstanceOf(BST);
     bst.add([11, 11]);
     bst.add([3, 3]);
@@ -626,7 +631,10 @@ describe('BST operations test recursively', () => {
     expect(objBST.has(6)).toBe(true);
 
     const node6 = objBST.getNode(6);
-    expect(objBST.get(6)).toEqual({ key: 6, keyA: 6 });
+    expect(objBST.get(6)).toEqual({
+      key: 6,
+      keyA: 6
+    });
     expect(node6 && objBST.getHeight(node6)).toBe(2);
     expect(node6 && objBST.getDepth(node6)).toBe(3);
 
@@ -640,7 +648,10 @@ describe('BST operations test recursively', () => {
     expect(leftMost?.key).toBe(1);
 
     const node15 = objBST.getNode(15);
-    expect(node15?.value).toEqual({ key: 15, keyA: 15 });
+    expect(node15?.value).toEqual({
+      key: 15,
+      keyA: 15
+    });
     const minNodeBySpecificNode = node15 && objBST.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
@@ -869,7 +880,9 @@ describe('BST isBST', function () {
   });
 
   test('isBST when variant is Max', () => {
-    const bst = new BST<number, number>([1, 2, 3, 9, 8, 5, 6, 7, 4], { comparator: (a, b) => b - a });
+    const bst = new BST<number, number>([1, 2, 3, 9, 8, 5, 6, 7, 4], {
+      comparator: (a, b) => b - a
+    });
     bst.addMany([1, 2, 3, 9, 8, 5, 6, 7, 4]);
     expect(bst.isBST()).toBe(true);
   });

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

@@ -350,7 +350,9 @@ describe('TreeMultiMap operations test1', () => {
 
 describe('TreeMultiMap operations test recursively1', () => {
   it('should perform various operations on a Binary Search Tree with numeric values1', () => {
-    const tmm = new TreeMultiMap<number>([], { iterationType: 'RECURSIVE' });
+    const tmm = new TreeMultiMap<number>([], {
+      iterationType: 'RECURSIVE'
+    });
 
     expect(tmm instanceof TreeMultiMap);
     tmm.add([11, 11]);

package/test/unit/data-structures/graph/abstract-graph.test.ts

@@ -81,8 +81,7 @@ class MyGraph<
     return true;
   }
 
-  clear(): void {
-  }
+  clear(): void {}
 
   clone(): any {
     return {};
@@ -96,8 +95,7 @@ class MyGraph<
 describe('AbstractGraph Operation Test', () => {
   const myGraph: MyGraph<number, string> = new MyGraph<number, string>();
 
-  beforeEach(() => {
-  });
+  beforeEach(() => {});
   it('should edge cases', function () {
     myGraph.addVertex('A', 1);
     myGraph.addVertex('B', 2);

package/test/unit/data-structures/graph/directed-graph.test.ts

@@ -998,7 +998,6 @@ describe('DirectedGraph tarjan', () => {
 
 describe('delete', () => {
   it(`deleteVertex deletes all of it's neighbors from the inEdge Map`, () => {
-
     const graph = new DirectedGraph();
     graph.addVertex('A');
     graph.addVertex('B');
@@ -1008,18 +1007,18 @@ describe('delete', () => {
     graph.addEdge('C', 'A');
 
     // 'Incoming to A should contain ['B','C']
-    expect(graph.incomingEdgesOf('A').map((e) => e.src)).toEqual(['B','C']); //  ['B','C']
+    expect(graph.incomingEdgesOf('A').map(e => e.src)).toEqual(['B', 'C']); //  ['B','C']
 
     // Now delete B, which has no direct link to C, only that C -> A.
     graph.deleteVertex('B');
 
     // Now if we do the same call to incoming edges for we should get only ['C']
-    expect(graph.incomingEdgesOf('A').map((e) => e.src)).toEqual(['C']); // [];
+    expect(graph.incomingEdgesOf('A').map(e => e.src)).toEqual(['C']); // [];
 
     // but it only shows an empty array, since we deleted all of `A's edges, not just the one to `B`.
 
     // If we check C, it correctly shows A as an outgoing edge,
     // even though A no longer has any knowledge of C linking to it.
-    expect(graph.outgoingEdgesOf('C').map((e) => e.dest)).toEqual(['A']);
+    expect(graph.outgoingEdgesOf('C').map(e => e.dest)).toEqual(['A']);
   });
-})
+});

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

@@ -147,7 +147,9 @@ describe('HashMap', () => {
         }
       }
 
-      const eHM = new ExtendedHashMap<string, number>([], { someOtherParam: 'someOtherParam' });
+      const eHM = new ExtendedHashMap<string, number>([], {
+        someOtherParam: 'someOtherParam'
+      });
       eHM.set('one', 1);
       expect(eHM.get('one')).toBe(1);
     });
@@ -357,7 +359,9 @@ describe('LinkedHashMap', () => {
 
   it('should handle number keys correctly', () => {
     hashMap.set(999, { a: '999Value' });
-    expect(hashMap.get(999)).toEqual({ a: '999Value' });
+    expect(hashMap.get(999)).toEqual({
+      a: '999Value'
+    });
   });
 
   it('should update the value for an existing key', () => {

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

@@ -2,7 +2,6 @@ import { FibonacciHeap, Heap, MaxHeap, MinHeap } from '../../../../src';
 import { logBigOMetricsWrap } from '../../../utils';
 
 describe('Heap Operation Test', () => {
-
   it('should heap add and delete work well', function () {
     const hp = new MinHeap<number>();
 
@@ -47,7 +46,9 @@ describe('Heap Operation Test', () => {
   });
 
   it('should clone', function () {
-    const minNumHeap = new Heap<string>([], { comparator: (a, b) => Number(a) - Number(b) });
+    const minNumHeap = new Heap<string>([], {
+      comparator: (a, b) => Number(a) - Number(b)
+    });
     minNumHeap.add('1');
     minNumHeap.add('6');
     minNumHeap.add('2');
@@ -64,13 +65,21 @@ 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 });
+    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.peek()).toEqual({
+      a: 'a0',
+      key: 0
+    });
     expect(minHeap.toArray().map(item => ({ a: item.a }))).toEqual([
       { a: 'a0' },
       { a: 'a1' },
@@ -80,18 +89,28 @@ describe('Heap Operation Test', () => {
     let i = 0;
     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 });
+    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.peek()).toEqual({
+      a: 'a9',
+      key: 9
+    });
     expect(maxHeap.toArray().map(item => ({ a: item.a }))).toEqual([
       { a: 'a9' },
       { a: 'a2' },
@@ -103,13 +122,18 @@ describe('Heap Operation Test', () => {
     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++;
     }
   });
 
   it('should object heap map & filter', function () {
-    const minHeap = new MinHeap<{ a: string; key: number }>(
+    const minHeap = new MinHeap<{
+      a: string;
+      key: number;
+    }>(
       [
         { key: 1, a: 'a1' },
         { key: 6, a: 'a6' },
@@ -119,7 +143,9 @@ describe('Heap Operation Test', () => {
         { key: 4, a: 'a4' },
         { key: 0, a: 'a0' }
       ],
-      { comparator: (a, b) => a.key - b.key }
+      {
+        comparator: (a, b) => a.key - b.key
+      }
     );
 
     const mappedMinHeap = minHeap.map(
@@ -147,7 +173,9 @@ describe('Heap Operation Test', () => {
   });
 
   it('should object heap', () => {
-    const heap = new Heap<{ rawItem: { id: number } }>(
+    const heap = new Heap<{
+      rawItem: { id: number };
+    }>(
       [
         { rawItem: { id: 4 } },
         { rawItem: { id: 8 } },
@@ -157,7 +185,9 @@ describe('Heap Operation Test', () => {
         { rawItem: { id: 3 } },
         { rawItem: { id: 5 } }
       ],
-      { comparator: (a, b) => a.rawItem.id - b.rawItem.id }
+      {
+        comparator: (a, b) => a.rawItem.id - b.rawItem.id
+      }
     );
 
     expect([...heap.sort()]).toEqual([
@@ -182,7 +212,9 @@ describe('Heap Operation Test', () => {
         { rawItem: { id: 3 } },
         { rawItem: { id: 5 } }
       ],
-      { toElementFn: rawElement => rawElement.rawItem.id }
+      {
+        toElementFn: rawElement => rawElement.rawItem.id
+      }
     );
 
     expect([...heap.sort()]).toEqual([1, 3, 4, 5, 6, 7, 8]);

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

@@ -5,7 +5,9 @@ describe('MaxHeap', () => {
   let maxHeap: MaxHeap<number>;
 
   beforeEach(() => {
-    maxHeap = new MaxHeap<number>([], { comparator: numberComparator });
+    maxHeap = new MaxHeap<number>([], {
+      comparator: numberComparator
+    });
   });
 
   it('add and poll elements in descending order', () => {
@@ -51,7 +53,10 @@ describe('MaxHeap', () => {
   });
 
   it('should object heap map & filter', function () {
-    const maxHeap = new MaxHeap<{ a: string; key: number }>(
+    const maxHeap = new MaxHeap<{
+      a: string;
+      key: number;
+    }>(
       [
         { key: 1, a: 'a1' },
         { key: 6, a: 'a6' },
@@ -61,7 +66,9 @@ describe('MaxHeap', () => {
         { key: 4, a: 'a4' },
         { key: 0, a: 'a0' }
       ],
-      { comparator: (a, b) => b.key - a.key }
+      {
+        comparator: (a, b) => b.key - a.key
+      }
     );
 
     const mappedMaxHeap = maxHeap.map(

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

@@ -5,7 +5,9 @@ describe('MinHeap', () => {
   let minHeap: MinHeap<number>;
 
   beforeEach(() => {
-    minHeap = new MinHeap<number>([], { comparator: numberComparator });
+    minHeap = new MinHeap<number>([], {
+      comparator: numberComparator
+    });
   });
 
   it('add and poll elements in ascending order', () => {

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

@@ -79,7 +79,9 @@ describe('DoublyLinkedList Operation Test', () => {
 
 describe('DoublyLinkedList Operation Test', () => {
   let list: DoublyLinkedList<number>;
-  let objectList: DoublyLinkedList<{ keyA: number }>;
+  let objectList: DoublyLinkedList<{
+    keyA: number;
+  }>;
 
   beforeEach(() => {
     list = new DoublyLinkedList();