data-structure-typed 1.52.0 → 1.52.2

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

@@ -995,3 +995,30 @@ describe('DirectedGraph tarjan', () => {
     expect(getAsVerticesArrays(sccs)).toEqual([['K', 'J', 'I', 'H', 'D', 'C', 'B'], ['G', 'F', 'E'], ['A']]);
   });
 });
+
+describe('delete', () => {
+  it(`deleteVertex deletes all of it's neighbors from the inEdge Map`, () => {
+    const graph = new DirectedGraph();
+    graph.addVertex('A');
+    graph.addVertex('B');
+    graph.addVertex('C');
+
+    graph.addEdge('B', 'A');
+    graph.addEdge('C', 'A');
+
+    // 'Incoming to A should contain ['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']); // [];
+
+    // 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']);
+  });
+});

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,6 +2,25 @@ 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>();
+
+    hp.add(2);
+    hp.add(3);
+    hp.add(1);
+    hp.add(4);
+    hp.add(6);
+    hp.add(5);
+    hp.add(7);
+
+    hp.delete(4);
+    hp.delete(7);
+    hp.delete(1);
+
+    expect(hp.size).toBe(4);
+    expect(hp.peek()).toBe(2);
+  });
+
   it('should numeric heap work well', function () {
     const minNumHeap = new MinHeap<number>();
     minNumHeap.add(1);
@@ -27,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');
@@ -44,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' },
@@ -60,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' },
@@ -83,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' },
@@ -99,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(
@@ -127,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 } },
@@ -137,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([
@@ -162,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();

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

@@ -11,10 +11,14 @@ describe('SinglyLinkedListNode', () => {
 
 describe('SinglyLinkedList Operation Test', () => {
   let list: SinglyLinkedList<number>;
-  let objectList: SinglyLinkedList<{ keyA: number }>;
+  let objectList: SinglyLinkedList<{
+    keyA: number;
+  }>;
   beforeEach(() => {
     list = new SinglyLinkedList<number>();
-    objectList = new SinglyLinkedList<{ keyA: number }>();
+    objectList = new SinglyLinkedList<{
+      keyA: number;
+    }>();
   });
 
   describe('push', () => {

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

@@ -16,7 +16,11 @@ 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 });
+    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 });
 
@@ -52,7 +56,9 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an array', () => {
     const array = [5, 3, 7, 1];
-    const heap = MaxPriorityQueue.heapify<number>(array, { comparator: (a, b) => b - a });
+    const heap = MaxPriorityQueue.heapify<number>(array, {
+      comparator: (a, b) => b - a
+    });
     heap.refill(array);
 
     expect(heap.poll()).toBe(7);
@@ -64,7 +70,11 @@ describe('MaxPriorityQueue Operation Test', () => {
   it('should correctly heapify an object array', () => {
     const elements = [{ keyA: 5 }, { keyA: 3 }, { keyA: 7 }, { keyA: 1 }];
     debugger;
-    const maxPQ = MaxPriorityQueue.heapify<{ keyA: number }>(elements, { comparator: (a, b) => b.keyA - a.keyA });
+    const maxPQ = MaxPriorityQueue.heapify<{
+      keyA: number;
+    }>(elements, {
+      comparator: (a, b) => b.keyA - a.keyA
+    });
 
     expect(maxPQ.poll()?.keyA).toBe(7);
     expect(maxPQ.poll()?.keyA).toBe(5);
@@ -73,7 +83,9 @@ describe('MaxPriorityQueue Operation Test', () => {
   });
 
   it('should object priority queue', () => {
-    const maxPQ = new MaxPriorityQueue<{ rawItem: { id: number } }>(
+    const maxPQ = new MaxPriorityQueue<{
+      rawItem: { id: number };
+    }>(
       [
         { rawItem: { id: 4 } },
         { rawItem: { id: 8 } },
@@ -83,7 +95,9 @@ describe('MaxPriorityQueue Operation Test', () => {
         { rawItem: { id: 3 } },
         { rawItem: { id: 5 } }
       ],
-      { comparator: (a, b) => b.rawItem.id - a.rawItem.id }
+      {
+        comparator: (a, b) => b.rawItem.id - a.rawItem.id
+      }
     );
 
     expect([...maxPQ.sort()]).toEqual([
@@ -108,7 +122,9 @@ describe('MaxPriorityQueue Operation Test', () => {
         { rawItem: { id: 3 } },
         { rawItem: { id: 5 } }
       ],
-      { toElementFn: rawElement => rawElement.rawItem.id }
+      {
+        toElementFn: rawElement => rawElement.rawItem.id
+      }
     );
 
     expect([...maxPQ.sort()]).toEqual([8, 7, 6, 5, 4, 3, 1]);

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

@@ -5,7 +5,9 @@ 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();
@@ -21,7 +23,9 @@ describe('PriorityQueue Operation Test', () => {
   });
 
   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();
@@ -37,7 +41,9 @@ describe('PriorityQueue Operation Test', () => {
   });
 
   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.elements).toEqual(minPQ1.elements);
@@ -50,7 +56,9 @@ describe('PriorityQueue Operation Test', () => {
 
 describe('Priority Queue Performance Test', () => {
   it('should numeric heap work well', function () {
-    const pq = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
+    const pq = new PriorityQueue<number>([], {
+      comparator: (a, b) => b - a
+    });
 
     const tS = performance.now();