data-structure-typed 1.45.0 → 1.45.2

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

@@ -1,6 +1,6 @@
-import {BinaryTree, BinaryTreeNode, IterationType} from '../../../../src';
-import {getRandomIntArray} from '../../../utils';
-import {FamilyPosition} from 'binary-tree-typed';
+import { BinaryTree, BinaryTreeNode, IterationType } from '../../../../src';
+import { getRandomIntArray } from '../../../utils';
+import { FamilyPosition } from 'binary-tree-typed';
 // import {isDebugTest} from '../../../config';
 
 // const isDebug = isDebugTest;
@@ -242,8 +242,12 @@ describe('BinaryTree', () => {
     tree.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
     expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.ITERATIVE)).toEqual([6, 3, 7]);
     expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.RECURSIVE)).toEqual([6, 3, 7]);
-    expect(tree.subTreeTraverse(node => (node ? node.key : null), tree.getNode(6), IterationType.ITERATIVE, true)).toEqual([6, 3, 7, null]);
-    expect(tree.subTreeTraverse(node => (node ? node.key : null), tree.getNode(6), IterationType.RECURSIVE, true)).toEqual([6, 3, 7, null]);
+    expect(
+      tree.subTreeTraverse(node => (node ? node.key : null), tree.getNode(6), IterationType.ITERATIVE, true)
+    ).toEqual([6, 3, 7, null]);
+    expect(
+      tree.subTreeTraverse(node => (node ? node.key : null), tree.getNode(6), IterationType.RECURSIVE, true)
+    ).toEqual([6, 3, 7, null]);
   });
 
   it('should clear the tree', () => {
@@ -315,81 +319,41 @@ describe('BinaryTree traversals', () => {
 
   const arr = [35, 20, 40, 15, 29, null, 50, null, 16, 28, 30, 45, 55];
   tree.refill(arr);
-  expect(tree.bfs(node => node, tree.root, IterationType.ITERATIVE, true).map(node => (node ? node.key : null))).toEqual([
-    35,
-    20,
-    40,
-    15,
-    29,
-    null,
-    50,
-    null,
-    16,
-    28,
-    30,
-    45,
-    55
-  ]);
-  expect(tree.bfs(node => node, tree.root, IterationType.RECURSIVE, true).map(node => (node ? node.key : null))).toEqual([
-    35,
-    20,
-    40,
-    15,
-    29,
-    null,
-    50,
-    null,
-    16,
-    28,
-    30,
-    45,
-    55
-  ]);
-  expect(tree.bfs(node => node, tree.root, IterationType.ITERATIVE).map(node => (node === null ? null : node.key))).toEqual([
-    35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55
-  ]);
-  expect(tree.bfs(node => node, tree.root, IterationType.RECURSIVE).map(node => (node === null ? null : node.key))).toEqual([
-    35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55
-  ]);
+  expect(
+    tree.bfs(node => node, tree.root, IterationType.ITERATIVE, true).map(node => (node ? node.key : null))
+  ).toEqual([35, 20, 40, 15, 29, null, 50, null, 16, 28, 30, 45, 55]);
+  expect(
+    tree.bfs(node => node, tree.root, IterationType.RECURSIVE, true).map(node => (node ? node.key : null))
+  ).toEqual([35, 20, 40, 15, 29, null, 50, null, 16, 28, 30, 45, 55]);
+  expect(
+    tree.bfs(node => node, tree.root, IterationType.ITERATIVE).map(node => (node === null ? null : node.key))
+  ).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
+  expect(
+    tree.bfs(node => node, tree.root, IterationType.RECURSIVE).map(node => (node === null ? null : node.key))
+  ).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
 
   expect(tree.dfs(node => node.key, 'pre')).toEqual([35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55]);
-  expect(tree.dfs(node => node.key, 'pre', tree.root, IterationType.RECURSIVE)).toEqual([35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55]);
-  expect(tree.dfs(node => node, 'pre', tree.root, IterationType.ITERATIVE, true).map(node => (node ? node.key : null))).toEqual([
-    35,
-    20,
-    15,
-    null,
-    16,
-    29,
-    28,
-    30,
-    40,
-    null,
-    50,
-    45,
-    55
-  ]);
-  expect(tree.dfs(node => node, 'pre', tree.root, IterationType.RECURSIVE, true).map(node => (node ? node.key : null))).toEqual([
-    35,
-    20,
-    15,
-    null,
-    16,
-    29,
-    28,
-    30,
-    40,
-    null,
-    50,
-    45,
-    55
+  expect(tree.dfs(node => node.key, 'pre', tree.root, IterationType.RECURSIVE)).toEqual([
+    35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55
   ]);
+  expect(
+    tree.dfs(node => node, 'pre', tree.root, IterationType.ITERATIVE, true).map(node => (node ? node.key : null))
+  ).toEqual([35, 20, 15, null, 16, 29, 28, 30, 40, null, 50, 45, 55]);
+  expect(
+    tree.dfs(node => node, 'pre', tree.root, IterationType.RECURSIVE, true).map(node => (node ? node.key : null))
+  ).toEqual([35, 20, 15, null, 16, 29, 28, 30, 40, null, 50, 45, 55]);
 
   expect(tree.dfs(node => node.key, 'in')).toEqual([15, 16, 20, 28, 29, 30, 35, 40, 45, 50, 55]);
   expect(tree.dfs(node => node.key, 'post')).toEqual([16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35]);
-  expect(tree.dfs(node => node.key, 'post', tree.root, IterationType.RECURSIVE)).toEqual([16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35]);
-  expect(tree.bfs(node => node.key, tree.root, IterationType.RECURSIVE)).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
-  expect(tree.bfs(node => node.key, tree.root, IterationType.ITERATIVE)).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
+  expect(tree.dfs(node => node.key, 'post', tree.root, IterationType.RECURSIVE)).toEqual([
+    16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35
+  ]);
+  expect(tree.bfs(node => node.key, tree.root, IterationType.RECURSIVE)).toEqual([
+    35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55
+  ]);
+  expect(tree.bfs(node => node.key, tree.root, IterationType.ITERATIVE)).toEqual([
+    35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55
+  ]);
 
   expect(tree.listLevels(node => node.key)).toEqual([[35], [20, 40], [15, 29, 50], [16, 28, 30, 45, 55]]);
 
@@ -417,7 +381,7 @@ describe('BinaryTree', () => {
   let tree: BinaryTree<string>;
 
   beforeEach(() => {
-    tree = new BinaryTree<string>({iterationType: IterationType.RECURSIVE});
+    tree = new BinaryTree<string>({ iterationType: IterationType.RECURSIVE });
   });
 
   afterEach(() => {
@@ -560,7 +524,13 @@ describe('BinaryTree', () => {
     expect(nodes.length).toBe(1);
     expect(nodes[0].key).toBe(3);
 
-    const nodesRec = tree.getNodes('B', (node: BinaryTreeNode<string>) => node.value, false, tree.root, IterationType.RECURSIVE);
+    const nodesRec = tree.getNodes(
+      'B',
+      (node: BinaryTreeNode<string>) => node.value,
+      false,
+      tree.root,
+      IterationType.RECURSIVE
+    );
 
     expect(nodesRec.length).toBe(1);
     expect(nodesRec[0].key).toBe(3);

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

@@ -1,5 +1,5 @@
-import {BST, BSTNode, CP, IterationType} from '../../../../src';
-import {isDebugTest} from '../../../config';
+import { BST, BSTNode, CP, IterationType } from '../../../../src';
+import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
 
@@ -191,23 +191,23 @@ describe('BST operations test', () => {
   it('should perform various operations on a Binary Search Tree with object values', () => {
     const objBST = new BST<{ key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
-    objBST.add(11, {key: 11, keyA: 11});
-    objBST.add(3, {key: 3, keyA: 3});
+    objBST.add(11, { key: 11, keyA: 11 });
+    objBST.add(3, { key: 3, keyA: 3 });
     const values = [
-      {key: 15, keyA: 15},
-      {key: 1, keyA: 1},
-      {key: 8, keyA: 8},
-      {key: 13, keyA: 13},
-      {key: 16, keyA: 16},
-      {key: 2, keyA: 2},
-      {key: 6, keyA: 6},
-      {key: 9, keyA: 9},
-      {key: 12, keyA: 12},
-      {key: 14, keyA: 14},
-      {key: 4, keyA: 4},
-      {key: 7, keyA: 7},
-      {key: 10, keyA: 10},
-      {key: 5, keyA: 5}
+      { key: 15, keyA: 15 },
+      { key: 1, keyA: 1 },
+      { key: 8, keyA: 8 },
+      { key: 13, keyA: 13 },
+      { key: 16, keyA: 16 },
+      { key: 2, keyA: 2 },
+      { key: 6, keyA: 6 },
+      { key: 9, keyA: 9 },
+      { key: 12, keyA: 12 },
+      { key: 14, keyA: 14 },
+      { key: 4, keyA: 4 },
+      { key: 7, keyA: 7 },
+      { key: 10, keyA: 10 },
+      { key: 5, keyA: 5 }
     ];
 
     objBST.addMany(
@@ -236,7 +236,7 @@ describe('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);
 
@@ -395,7 +395,7 @@ 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({iterationType: IterationType.RECURSIVE});
+    const bst = new BST({ iterationType: IterationType.RECURSIVE });
     expect(bst).toBeInstanceOf(BST);
     bst.add(11, 11);
     bst.add(3, 3);
@@ -582,23 +582,23 @@ describe('BST operations test recursively', () => {
   it('should perform various operations on a Binary Search Tree with object values', () => {
     const objBST = new BST<{ key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
-    objBST.add(11, {key: 11, keyA: 11});
-    objBST.add(3, {key: 3, keyA: 3});
+    objBST.add(11, { key: 11, keyA: 11 });
+    objBST.add(3, { key: 3, keyA: 3 });
     const values = [
-      {key: 15, keyA: 15},
-      {key: 1, keyA: 1},
-      {key: 8, keyA: 8},
-      {key: 13, keyA: 13},
-      {key: 16, keyA: 16},
-      {key: 2, keyA: 2},
-      {key: 6, keyA: 6},
-      {key: 9, keyA: 9},
-      {key: 12, keyA: 12},
-      {key: 14, keyA: 14},
-      {key: 4, keyA: 4},
-      {key: 7, keyA: 7},
-      {key: 10, keyA: 10},
-      {key: 5, keyA: 5}
+      { key: 15, keyA: 15 },
+      { key: 1, keyA: 1 },
+      { key: 8, keyA: 8 },
+      { key: 13, keyA: 13 },
+      { key: 16, keyA: 16 },
+      { key: 2, keyA: 2 },
+      { key: 6, keyA: 6 },
+      { key: 9, keyA: 9 },
+      { key: 12, keyA: 12 },
+      { key: 14, keyA: 14 },
+      { key: 4, keyA: 4 },
+      { key: 7, keyA: 7 },
+      { key: 10, keyA: 10 },
+      { key: 5, keyA: 5 }
     ];
 
     objBST.addMany(
@@ -614,7 +614,7 @@ 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);
 
@@ -628,7 +628,7 @@ 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);
 
@@ -843,7 +843,11 @@ describe('BST Performance test', function () {
     bst.addMany([4, 2, 6, 1, 3, 5, 7]);
     expect(bst.subTreeTraverse(node => node.key, bst.getNode(6), IterationType.ITERATIVE)).toEqual([6, 5, 7]);
     expect(bst.subTreeTraverse(node => node.key, bst.getNode(6), IterationType.RECURSIVE)).toEqual([6, 5, 7]);
-    expect(bst.subTreeTraverse(node => node?.key ?? undefined, bst.getNode(6), IterationType.ITERATIVE, true)).toEqual([6, 5, 7]);
-    expect(bst.subTreeTraverse(node => node?.key ?? undefined, bst.getNode(6), IterationType.RECURSIVE, true)).toEqual([6, 5, 7]);
+    expect(bst.subTreeTraverse(node => node?.key ?? undefined, bst.getNode(6), IterationType.ITERATIVE, true)).toEqual([
+      6, 5, 7
+    ]);
+    expect(bst.subTreeTraverse(node => node?.key ?? undefined, bst.getNode(6), IterationType.RECURSIVE, true)).toEqual([
+      6, 5, 7
+    ]);
   });
 });

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

@@ -1,4 +1,4 @@
-import {AVLTree, BST} from '../../../../src';
+import { AVLTree, BST } from '../../../../src';
 
 describe('Overall BinaryTree Test', () => {
   it('should perform various operations on BinaryTree', () => {
@@ -30,26 +30,26 @@ describe('Overall BinaryTree Test', () => {
     expect(bfsIDs[0]).toBe(11);
 
     const objBST = new BST<{ key: number; keyA: number }>();
-    objBST.add(11, {key: 11, keyA: 11});
-    objBST.add(3, {key: 3, keyA: 3});
+    objBST.add(11, { key: 11, keyA: 11 });
+    objBST.add(3, { key: 3, keyA: 3 });
 
     objBST.addMany(
       [15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5],
       [
-        {key: 15, keyA: 15},
-        {key: 1, keyA: 1},
-        {key: 8, keyA: 8},
-        {key: 13, keyA: 13},
-        {key: 16, keyA: 16},
-        {key: 2, keyA: 2},
-        {key: 6, keyA: 6},
-        {key: 9, keyA: 9},
-        {key: 12, keyA: 12},
-        {key: 14, keyA: 14},
-        {key: 4, keyA: 4},
-        {key: 7, keyA: 7},
-        {key: 10, keyA: 10},
-        {key: 5, keyA: 5}
+        { key: 15, keyA: 15 },
+        { key: 1, keyA: 1 },
+        { key: 8, keyA: 8 },
+        { key: 13, keyA: 13 },
+        { key: 16, keyA: 16 },
+        { key: 2, keyA: 2 },
+        { key: 6, keyA: 6 },
+        { key: 9, keyA: 9 },
+        { key: 12, keyA: 12 },
+        { key: 14, keyA: 14 },
+        { key: 4, keyA: 4 },
+        { key: 7, keyA: 7 },
+        { key: 10, keyA: 10 },
+        { key: 5, keyA: 5 }
       ]
     );
 

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

@@ -1,7 +1,7 @@
-import {IterationType, RBTNColor, RedBlackTree, RedBlackTreeNode} from '../../../../src';
-import {getRandomInt, getRandomIntArray, magnitude} from '../../../utils';
-import {isDebugTest} from '../../../config';
-import {OrderedMap} from 'js-sdsl';
+import { IterationType, RBTNColor, RedBlackTree, RedBlackTreeNode } from '../../../../src';
+import { getRandomInt, getRandomIntArray, magnitude } from '../../../utils';
+import { isDebugTest } from '../../../config';
+import { OrderedMap } from 'js-sdsl';
 
 const isDebug = isDebugTest;
 
@@ -438,12 +438,12 @@ describe('RedBlackTree', () => {
     expect(tree.size).toBe(51);
     expect(tree.isBST()).toBe(true);
     expect(tree.dfs(n => n.key, 'in', tree.root, IterationType.ITERATIVE)).toEqual([
-      49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
-      82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
+      49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
+      77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
     ]);
     expect(tree.dfs(n => n.key, 'in', tree.root, IterationType.RECURSIVE)).toEqual([
-      49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
-      82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
+      49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
+      77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
     ]);
   });
 
@@ -468,7 +468,7 @@ describe('RedBlackTree', () => {
     // TODO there is a bug when dfs the tree with NIL node
     // expect(tree.isBST()).toBe(true);
   });
-  const {HUNDRED_THOUSAND} = magnitude;
+  const { HUNDRED_THOUSAND } = magnitude;
   const arr = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND, true);
   const competitor = new OrderedMap<number, number>();
 

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

@@ -1,4 +1,4 @@
-import {SegmentTree} from '../../../../src';
+import { SegmentTree } from '../../../../src';
 
 describe('SegmentTree', () => {
   let segmentTree: SegmentTree;

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

@@ -1,5 +1,5 @@
-import {CP, IterationType, TreeMultimap, TreeMultimapNode} from '../../../../src';
-import {isDebugTest} from '../../../config';
+import { CP, IterationType, TreeMultimap, TreeMultimapNode } from '../../../../src';
+import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
 
@@ -209,23 +209,23 @@ describe('TreeMultimap operations test', () => {
   it('should perform various operations on a Binary Search Tree with object values', () => {
     const objTreeMultimap = new TreeMultimap<{ key: number; keyA: number }>();
     expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
-    objTreeMultimap.add(11, {key: 11, keyA: 11});
-    objTreeMultimap.add(3, {key: 3, keyA: 3});
+    objTreeMultimap.add(11, { key: 11, keyA: 11 });
+    objTreeMultimap.add(3, { key: 3, keyA: 3 });
     const values = [
-      {key: 15, keyA: 15},
-      {key: 1, keyA: 1},
-      {key: 8, keyA: 8},
-      {key: 13, keyA: 13},
-      {key: 16, keyA: 16},
-      {key: 2, keyA: 2},
-      {key: 6, keyA: 6},
-      {key: 9, keyA: 9},
-      {key: 12, keyA: 12},
-      {key: 14, keyA: 14},
-      {key: 4, keyA: 4},
-      {key: 7, keyA: 7},
-      {key: 10, keyA: 10},
-      {key: 5, keyA: 5}
+      { key: 15, keyA: 15 },
+      { key: 1, keyA: 1 },
+      { key: 8, keyA: 8 },
+      { key: 13, keyA: 13 },
+      { key: 16, keyA: 16 },
+      { key: 2, keyA: 2 },
+      { key: 6, keyA: 6 },
+      { key: 9, keyA: 9 },
+      { key: 12, keyA: 12 },
+      { key: 14, keyA: 14 },
+      { key: 4, keyA: 4 },
+      { key: 7, keyA: 7 },
+      { key: 10, keyA: 10 },
+      { key: 5, keyA: 5 }
     ];
 
     objTreeMultimap.addMany(
@@ -245,7 +245,7 @@ describe('TreeMultimap operations test', () => {
 
 describe('TreeMultimap operations test recursively', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
-    const treeMultimap = new TreeMultimap({iterationType: IterationType.RECURSIVE});
+    const treeMultimap = new TreeMultimap({ iterationType: IterationType.RECURSIVE });
 
     expect(treeMultimap instanceof TreeMultimap);
     treeMultimap.add(11, 11);
@@ -449,23 +449,23 @@ describe('TreeMultimap operations test recursively', () => {
   it('should perform various operations on a Binary Search Tree with object values', () => {
     const objTreeMultimap = new TreeMultimap<{ key: number; keyA: number }>();
     expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
-    objTreeMultimap.add(11, {key: 11, keyA: 11});
-    objTreeMultimap.add(3, {key: 3, keyA: 3});
+    objTreeMultimap.add(11, { key: 11, keyA: 11 });
+    objTreeMultimap.add(3, { key: 3, keyA: 3 });
     const values = [
-      {key: 15, keyA: 15},
-      {key: 1, keyA: 1},
-      {key: 8, keyA: 8},
-      {key: 13, keyA: 13},
-      {key: 16, keyA: 16},
-      {key: 2, keyA: 2},
-      {key: 6, keyA: 6},
-      {key: 9, keyA: 9},
-      {key: 12, keyA: 12},
-      {key: 14, keyA: 14},
-      {key: 4, keyA: 4},
-      {key: 7, keyA: 7},
-      {key: 10, keyA: 10},
-      {key: 5, keyA: 5}
+      { key: 15, keyA: 15 },
+      { key: 1, keyA: 1 },
+      { key: 8, keyA: 8 },
+      { key: 13, keyA: 13 },
+      { key: 16, keyA: 16 },
+      { key: 2, keyA: 2 },
+      { key: 6, keyA: 6 },
+      { key: 9, keyA: 9 },
+      { key: 12, keyA: 12 },
+      { key: 14, keyA: 14 },
+      { key: 4, keyA: 4 },
+      { key: 7, keyA: 7 },
+      { key: 10, keyA: 10 },
+      { key: 5, keyA: 5 }
     ];
 
     objTreeMultimap.addMany(

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

@@ -1,4 +1,4 @@
-import {AbstractEdge, AbstractGraph, AbstractVertex, VertexKey} from '../../../../src';
+import { AbstractEdge, AbstractGraph, AbstractVertex, VertexKey } from '../../../../src';
 
 class MyVertex<V = any> extends AbstractVertex<V> {
   data?: V;
@@ -22,12 +22,12 @@ class MyEdge<E = any> extends AbstractEdge<E> {
   }
 }
 
-class MyGraph<V = any, E = any, VO extends MyVertex<V> = MyVertex<V>, EO extends MyEdge<E> = MyEdge<E>> extends AbstractGraph<
-  V,
-  E,
-  VO,
-  EO
-> {
+class MyGraph<
+  V = any,
+  E = any,
+  VO extends MyVertex<V> = MyVertex<V>,
+  EO extends MyEdge<E> = MyEdge<E>
+> extends AbstractGraph<V, E, VO, EO> {
   createVertex(key: VertexKey, value?: V): VO {
     return new MyVertex(key, value) as VO;
   }

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

@@ -1,4 +1,4 @@
-import {DirectedEdge, DirectedGraph, DirectedVertex, VertexKey} from '../../../../src';
+import { DirectedEdge, DirectedGraph, DirectedVertex, VertexKey } from '../../../../src';
 
 describe('DirectedGraph Operation Test', () => {
   let graph: DirectedGraph;
@@ -126,12 +126,12 @@ class MyEdge<E = any> extends DirectedEdge<E> {
   }
 }
 
-class MyDirectedGraph<V = any, E = any, VO extends MyVertex<V> = MyVertex<V>, EO extends MyEdge<E> = MyEdge<E>> extends DirectedGraph<
-  V,
-  E,
-  VO,
-  EO
-> {
+class MyDirectedGraph<
+  V = any,
+  E = any,
+  VO extends MyVertex<V> = MyVertex<V>,
+  EO extends MyEdge<E> = MyEdge<E>
+> extends DirectedGraph<V, E, VO, EO> {
   createVertex(key: VertexKey, value: V): VO {
     return new MyVertex(key, value) as VO;
   }
@@ -319,7 +319,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
     const fordResult1 = myGraph.bellmanFord(1);
     expect(fordResult1).toBeTruthy();
     expect(fordResult1.hasNegativeCycle).toBeUndefined();
-    const {distMap, preMap, paths, min, minPath} = fordResult1;
+    const { distMap, preMap, paths, min, minPath } = fordResult1;
     expect(distMap).toBeInstanceOf(Map);
     expect(distMap.size).toBe(9);
     expect(distMap.get(vertex1)).toBe(0);
@@ -343,7 +343,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
     const floydResult = myGraph.floydWarshall();
     expect(floydResult).toBeTruthy();
     if (floydResult) {
-      const {costs, predecessor} = floydResult;
+      const { costs, predecessor } = floydResult;
       expect(costs).toBeInstanceOf(Array);
       expect(costs.length).toBe(9);
       expect(costs[0]).toEqual([32, 12, 35, 14, 70, Infinity, 61, Infinity, 19]);
@@ -351,9 +351,29 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
       expect(costs[2]).toEqual([3, 15, 38, 17, 35, Infinity, 64, Infinity, 22]);
       expect(costs[3]).toEqual([123, 135, 120, 137, 155, Infinity, 47, Infinity, 126]);
       expect(costs[4]).toEqual([133, 145, 130, 147, 165, Infinity, 57, Infinity, 136]);
-      expect(costs[5]).toEqual([Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity]);
+      expect(costs[5]).toEqual([
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity
+      ]);
       expect(costs[6]).toEqual([76, 88, 73, 90, 108, Infinity, 137, Infinity, 79]);
-      expect(costs[7]).toEqual([Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity, Infinity]);
+      expect(costs[7]).toEqual([
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity,
+        Infinity
+      ]);
       expect(costs[8]).toEqual([173, 185, 170, 187, 205, Infinity, 97, Infinity, 176]);
 
       expect(predecessor).toBeInstanceOf(Array);
@@ -369,7 +389,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
 
     expect(dijkstraRes12tt).toBeTruthy();
     if (dijkstraRes12tt) {
-      const {distMap, minDist, minPath, paths} = dijkstraRes12tt;
+      const { distMap, minDist, minPath, paths } = dijkstraRes12tt;
       expect(distMap).toBeInstanceOf(Map);
       expect(distMap.size).toBe(9);
       expect(distMap.get(vertex1)).toBe(0);
@@ -420,7 +440,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
 
     expect(dijkstraRes1ntt).toBeTruthy();
     if (dijkstraRes1ntt) {
-      const {distMap, minDist, minPath, paths} = dijkstraRes1ntt;
+      const { distMap, minDist, minPath, paths } = dijkstraRes1ntt;
       expect(distMap).toBeInstanceOf(Map);
       expect(distMap.size).toBe(9);
       expect(distMap.get(vertex1)).toBe(0);
@@ -482,7 +502,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
     const dijkstraWithoutHeapRes1ntt = myGraph.dijkstraWithoutHeap(1, null, true, true);
     expect(dijkstraWithoutHeapRes1ntt).toBeTruthy();
     if (dijkstraWithoutHeapRes1ntt) {
-      const {distMap, minDist, minPath, paths} = dijkstraWithoutHeapRes1ntt;
+      const { distMap, minDist, minPath, paths } = dijkstraWithoutHeapRes1ntt;
       expect(distMap).toBeInstanceOf(Map);
       expect(distMap.size).toBe(9);
       expect(distMap.get(vertex1)).toBe(0);

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

@@ -1,4 +1,4 @@
-import {MapEdge, MapGraph, MapVertex} from '../../../../src';
+import { MapEdge, MapGraph, MapVertex } from '../../../../src';
 
 describe('MapGraph Operation Test', () => {
   it('dijkstra shortest path', () => {

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

@@ -1,4 +1,4 @@
-import {DirectedGraph, UndirectedGraph} from '../../../../src';
+import { DirectedGraph, UndirectedGraph } from '../../../../src';
 
 describe('Overall Graph Operation Test', () => {
   it('Overall DirectedGraph Operation Test', () => {

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

@@ -1,4 +1,4 @@
-import {UndirectedEdge, UndirectedGraph, UndirectedVertex} from '../../../../src';
+import { UndirectedEdge, UndirectedGraph, UndirectedVertex } from '../../../../src';
 import saltyVertexes from './salty-vertexes.json';
 import saltyEdges from './salty-edges.json';
 

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

@@ -1,4 +1,4 @@
-import {CoordinateMap} from '../../../../src';
+import { CoordinateMap } from '../../../../src';
 
 describe('CoordinateMap', () => {
   it('should set and get values correctly', () => {

package/test/unit/data-structures/hash/coordinate-set.test.ts

@@ -1,4 +1,4 @@
-import {CoordinateSet} from '../../../../src';
+import { CoordinateSet } from '../../../../src';
 
 describe('CoordinateSet', () => {
   it('should add and check values correctly', () => {