data-structure-typed 1.45.0 → 1.45.2

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

@@ -3,7 +3,7 @@
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-import {SinglyLinkedList} from '../linked-list';
+import { SinglyLinkedList } from '../linked-list';
 
 export class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
   /**
@@ -300,7 +300,7 @@ export class Queue<E = any> {
     return new Queue(this.nodes.slice(this.offset));
   }
 
-  *[Symbol.iterator]() {
+  * [Symbol.iterator]() {
     for (const item of this.nodes) {
       yield item;
     }

package/src/data-structures/tree/tree.ts

@@ -27,7 +27,7 @@ export class TreeNode<V = any> {
         if (level > maxDepth) {
           maxDepth = level;
         }
-        const {children} = node;
+        const { children } = node;
         if (children) {
           for (let i = 0, len = children.length; i < len; i++) {
             bfs(children[i], level + 1);

package/src/data-structures/trie/trie.ts

@@ -164,7 +164,7 @@ export class Trie {
         if (level > maxDepth) {
           maxDepth = level;
         }
-        const {children} = node;
+        const { children } = node;
         if (children) {
           for (const child of children.entries()) {
             bfs(child[1], level + 1);

package/src/interfaces/binary-tree.ts

@@ -1,5 +1,5 @@
-import {BinaryTreeNode} from '../data-structures';
-import {BinaryTreeNodeNested, BiTreeDeleteResult, BTNCallback, BTNKey} from '../types';
+import { BinaryTreeNode } from '../data-structures';
+import { BinaryTreeNodeNested, BiTreeDeleteResult, BTNCallback, BTNKey } from '../types';
 
 export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>> {
   createNode(key: BTNKey, value?: N['value']): N;

package/src/interfaces/graph.ts

@@ -1,4 +1,4 @@
-import {VertexKey} from '../types';
+import { VertexKey } from '../types';
 
 export interface IGraph<V, E, VO, EO> {
   createVertex(key: VertexKey, value?: V): VO;

package/src/types/data-structures/binary-tree/avl-tree.ts

@@ -1,5 +1,5 @@
-import {AVLTreeNode} from '../../../data-structures';
-import {BSTOptions} from './bst';
+import { AVLTreeNode } from '../../../data-structures';
+import { BSTOptions } from './bst';
 
 export type AVLTreeNodeNested<T> = AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 export type AVLTreeOptions = BSTOptions & {};

package/src/types/data-structures/binary-tree/binary-tree.ts

@@ -1,4 +1,4 @@
-import {BinaryTreeNode} from '../../../data-structures';
+import { BinaryTreeNode } from '../../../data-structures';
 
 /**
  * Enum representing different loop types.

package/src/types/data-structures/binary-tree/bst.ts

@@ -1,5 +1,5 @@
-import {BSTNode} from '../../../data-structures';
-import type {BinaryTreeOptions, BTNKey} from './binary-tree';
+import { BSTNode } from '../../../data-structures';
+import type { BinaryTreeOptions, BTNKey } from './binary-tree';
 
 export type BSTComparator = (a: BTNKey, b: BTNKey) => number;
 

package/src/types/data-structures/binary-tree/rb-tree.ts

@@ -1,5 +1,5 @@
-import {RedBlackTreeNode} from '../../../data-structures';
-import {BSTOptions} from "./bst";
+import { RedBlackTreeNode } from '../../../data-structures';
+import { BSTOptions } from "./bst";
 
 export enum RBTNColor { RED = 1, BLACK = 0}
 

package/src/types/data-structures/binary-tree/tree-multimap.ts

@@ -1,5 +1,5 @@
-import {TreeMultimapNode} from '../../../data-structures';
-import {AVLTreeOptions} from './avl-tree';
+import { TreeMultimapNode } from '../../../data-structures';
+import { AVLTreeOptions } from './avl-tree';
 
 export type TreeMultimapNodeNested<T> = TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 

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

@@ -7,11 +7,11 @@ export type HashMapOptions<T> = {
   sizeFunction?: number | (() => number);
   fixedLength?: number;
   forEach: (callback: (el: T) => void) => void;
-}
+};
 
 export type HashMapLinkedNode<K, V> = {
-  key: K
-  value: V
-  next: HashMapLinkedNode<K, V>
-  prev: HashMapLinkedNode<K, V>
-}
+  key: K;
+  value: V;
+  next: HashMapLinkedNode<K, V>;
+  prev: HashMapLinkedNode<K, V>;
+};

package/src/types/data-structures/matrix/navigator.ts

@@ -1,6 +1,6 @@
 export type Direction = 'up' | 'right' | 'down' | 'left';
 
-export type Turning = {[key in Direction]: Direction};
+export type Turning = { [key in Direction]: Direction };
 
 export type NavigatorParams<T = any> = {
   matrix: T[][];

package/src/types/utils/utils.ts

@@ -1,5 +1,5 @@
 export type ToThunkFn = () => ReturnType<TrlFn>;
-export type Thunk = () => ReturnType<ToThunkFn> & {__THUNK__: symbol};
+export type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: symbol };
 export type TrlFn = (...args: any[]) => any;
 export type TrlAsyncFn = (...args: any[]) => any;
 

package/src/types/utils/validate-type.ts

@@ -1,6 +1,6 @@
-export type KeyValueObject = {[key: string]: any};
+export type KeyValueObject = { [key: string]: any };
 
-export type KeyValueObjectWithKey = {[key: string]: any; key: string | number | symbol};
+export type KeyValueObjectWithKey = { [key: string]: any; key: string | number | symbol };
 
 export type NonNumberNonObjectButDefined = string | boolean | symbol | null;
 
@@ -16,6 +16,20 @@ export type ObjectWithNumberKey = {
   key: number;
 };
 
-export type RestrictValByKey = NonNumberNonObjectButDefined | ObjectWithoutKey | ObjectWithNonNumberKey | ObjectWithNumberKey;
+export type RestrictValByKey =
+  | NonNumberNonObjectButDefined
+  | ObjectWithoutKey
+  | ObjectWithNonNumberKey
+  | ObjectWithNumberKey;
 
-export type DummyAny = string | number | boolean | null | undefined | object | symbol | void | ((...args: []) => any) | never;
+export type DummyAny =
+  | string
+  | number
+  | boolean
+  | null
+  | undefined
+  | object
+  | symbol
+  | void
+  | ((...args: []) => any)
+  | never;

package/src/utils/utils.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type {Thunk, ToThunkFn, TrlAsyncFn, TrlFn} from '../types';
+import type { Thunk, ToThunkFn, TrlAsyncFn, TrlFn } from '../types';
 
 export const uuidV4 = function () {
   return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {
@@ -57,7 +57,7 @@ export const trampoline = (fn: TrlFn) => {
 
       return result;
     },
-    {cont}
+    { cont }
   );
 };
 
@@ -74,7 +74,7 @@ export const trampolineAsync = (fn: TrlAsyncFn) => {
 
       return result;
     },
-    {cont}
+    { cont }
   );
 };
 
@@ -87,13 +87,13 @@ export const getMSB = (value: number): number => {
 
 export const rangeCheck = (index: number, min: number, max: number, message = 'Index out of bounds.'): void => {
   if (index < min || index > max) throw new RangeError(message);
-}
+};
 
 export const throwRangeError = (message = 'The value is off-limits.'): void => {
   throw new RangeError(message);
-}
+};
 
 export const isObjOrFunc = (input: unknown): input is Record<string, unknown> | ((...args: any[]) => any) => {
   const inputType = typeof input;
   return (inputType === 'object' && input !== null) || inputType === 'function';
-}
+};

package/test/integration/all-in-one.ts

@@ -1,4 +1,4 @@
-import {AVLTree, CP} from 'data-structure-typed';
+import { AVLTree, CP } from 'data-structure-typed';
 
 describe('AVL Tree Test from data-structure-typed', () => {
   it('should perform various operations on a AVL Tree from data-structure-typed', () => {

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

@@ -1,4 +1,4 @@
-import {AVLTree, CP} from 'avl-tree-typed';
+import { AVLTree, CP } from 'avl-tree-typed';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {

package/test/integration/bst.test.ts

@@ -1,4 +1,4 @@
-import {BST, BSTNode, CP} from 'bst-typed';
+import { BST, BSTNode, CP } from 'bst-typed';
 
 describe('Individual package BST operations test', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
@@ -183,25 +183,25 @@ describe('Individual package BST operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<{key: number; keyA: number}>();
+    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(
@@ -230,7 +230,7 @@ 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/integration/heap.test.js

@@ -1,4 +1,4 @@
-const {MinHeap} = require('heap-typed');
+const { MinHeap } = require('heap-typed');
 
 describe('JS Heap Operation Test', () => {
   it('should numeric heap work well', function () {

package/test/integration/index.html

@@ -35,7 +35,7 @@
     console.error(e);
   }
   try {
-    const {AVLTree} = window.dataStructureTyped;
+    const { AVLTree } = window.dataStructureTyped;
     const avlTree = new AVLTree();
     const $avlTree = document.createElement('li');
     const $avlTreeSpan = document.createElement('span');
@@ -52,7 +52,7 @@
   }
 
   try {
-    const {BinaryTree} = dataStructureTyped;
+    const { BinaryTree } = dataStructureTyped;
     const tree = new BinaryTree();
     tree.add(3);
     tree.add(12);
@@ -76,8 +76,8 @@
 
 
   try {
-    const {OrderedMap} = sdsl;
-    const {RedBlackTree} = dataStructureTyped;
+    const { OrderedMap } = sdsl;
+    const { RedBlackTree } = dataStructureTyped;
     const cTree = new OrderedMap();
     const tree = new RedBlackTree();
     const tS = performance.now();
@@ -101,9 +101,9 @@
   }
 
   try {
-    const {PriorityQueue: CPriorityQueue} = sdsl;
-    const {PriorityQueue} = dataStructureTyped;
-    const pq = new PriorityQueue({comparator: (a, b) => b - a});
+    const { PriorityQueue: CPriorityQueue } = sdsl;
+    const { PriorityQueue } = dataStructureTyped;
+    const pq = new PriorityQueue({ comparator: (a, b) => b - a });
 
     const tS = performance.now();
 

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

@@ -1,10 +1,10 @@
-import {AVLTree} from '../../../../src';
+import { AVLTree } from '../../../../src';
 import * as Benchmark from 'benchmark';
-import {getRandomIntArray, magnitude} from '../../../utils';
+import { getRandomIntArray, magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
 const avl = new AVLTree<number>();
-const {TEN_THOUSAND} = magnitude;
+const { TEN_THOUSAND } = magnitude;
 const arr = getRandomIntArray(TEN_THOUSAND, 0, TEN_THOUSAND, true);
 
 suite
@@ -33,4 +33,4 @@ suite
     }
   });
 
-export {suite};
+export { suite };

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

@@ -1,10 +1,10 @@
-import {BinaryTree} from '../../../../src';
+import { BinaryTree } from '../../../../src';
 import * as Benchmark from 'benchmark';
-import {getRandomIntArray, magnitude} from '../../../utils';
+import { getRandomIntArray, magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
 const biTree = new BinaryTree<number>();
-const {N_LOG_N} = magnitude;
+const { N_LOG_N } = magnitude;
 const arr = getRandomIntArray(N_LOG_N, 0, N_LOG_N, true);
 
 suite
@@ -42,4 +42,4 @@ suite
     for (let i = 0; i < N_LOG_N; i++) biTree.morris(n => n, 'pre');
   });
 
-export {suite};
+export { suite };

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

@@ -1,10 +1,10 @@
-import {BST} from '../../../../src';
+import { BST } from '../../../../src';
 import * as Benchmark from 'benchmark';
-import {getRandomIntArray, magnitude} from '../../../utils';
+import { getRandomIntArray, magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
 const bst = new BST<number>();
-const {TEN_THOUSAND} = magnitude;
+const { TEN_THOUSAND } = magnitude;
 const arr = getRandomIntArray(TEN_THOUSAND, 0, TEN_THOUSAND, true);
 
 suite
@@ -33,4 +33,4 @@ suite
     }
   });
 
-export {suite};
+export { suite };

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

@@ -1,14 +1,14 @@
-import {RedBlackTree} from '../../../../src';
+import { RedBlackTree } from '../../../../src';
 import * as Benchmark from 'benchmark';
-import {getRandomIntArray, magnitude} from '../../../utils';
-import {OrderedMap} from 'js-sdsl';
-import {isCompetitor} from '../../../config';
+import { getRandomIntArray, magnitude } from '../../../utils';
+import { OrderedMap } from 'js-sdsl';
+import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
 const rbTree = new RedBlackTree();
-const {HUNDRED_THOUSAND} = magnitude;
+const { HUNDRED_THOUSAND } = magnitude;
 const arr = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND, true);
-const competitor = new OrderedMap<number, number>();
+const cOrderedMap = new OrderedMap<number, number>();
 
 suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
   rbTree.clear();
@@ -18,9 +18,9 @@ suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
 });
 
 if (isCompetitor) {
-  suite.add(`${HUNDRED_THOUSAND.toLocaleString()} competitor add`, () => {
+  suite.add(`${HUNDRED_THOUSAND.toLocaleString()} CPT add`, () => {
     for (let i = 0; i < arr.length; i++) {
-      competitor.setElement(arr[i], arr[i]);
+      cOrderedMap.setElement(arr[i], arr[i]);
     }
   });
 }
@@ -41,4 +41,4 @@ suite
     }
   });
 
-export {suite};
+export { suite };

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

@@ -0,0 +1,142 @@
+import { PriorityQueue as MJSPriorityQueue } from '../../../dist/cjs';
+import { PriorityQueue as SRCPriorityQueue } from '../../../src';
+import { PriorityQueue as CJSPriorityQueue } from '../../../dist/mjs';
+import {
+  Deque as CDeque,
+  HashMap as CHashMap,
+  LinkList as CLinkedList,
+  OrderedMap,
+  PriorityQueue as CPriorityQueue,
+  Queue as CQueue,
+  Stack as CStack
+} from 'js-sdsl';
+
+import * as Benchmark from 'benchmark';
+import { getRandomIntArray, magnitude } from '../../utils';
+import { isCompetitor } from '../../config';
+
+const suite = new Benchmark.Suite();
+const { TEN_THOUSAND, HUNDRED_THOUSAND, LINEAR } = magnitude;
+const cOrderedMap = new OrderedMap<number, number>();
+const arrHundredThousand = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND, true);
+
+suite.add(`SRC ${TEN_THOUSAND.toLocaleString()} add`, () => {
+
+  const pq = new SRCPriorityQueue<number>({ comparator: (a, b) => b - a });
+  for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
+}).add(`CJS ${TEN_THOUSAND.toLocaleString()} add`, () => {
+
+  const pq = new CJSPriorityQueue<number>({ comparator: (a, b) => b - a });
+  for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
+}).add(`MJS ${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);
+  });
+}
+
+suite.add(`SRC PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
+  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.pop();
+}).add(`CJS PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
+  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.pop();
+}).add(`MJS PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
+  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.pop();
+});
+
+
+if (isCompetitor) {
+  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();
+  })
+    .add(`CPT OM ${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
+      for (let i = 0; i < arrHundredThousand.length; i++) {
+        cOrderedMap.setElement(arrHundredThousand[i], arrHundredThousand[i]);
+      }
+    })
+    .add(`CPT HM ${TEN_THOUSAND.toLocaleString()} set`, () => {
+      const hm = new CHashMap<number, number>();
+
+      for (let i = 0; i < TEN_THOUSAND; i++) {
+        hm.setElement(i, i);
+      }
+    })
+    .add(`CPT HM ${TEN_THOUSAND.toLocaleString()} set & get`, () => {
+      const hm = new CHashMap<number, number>();
+
+      for (let i = 0; i < TEN_THOUSAND; i++) {
+        hm.setElement(i, i);
+      }
+      for (let i = 0; i < TEN_THOUSAND; i++) {
+        hm.getElementByKey(i);
+      }
+    })
+    .add(`CPT LL ${LINEAR.toLocaleString()} unshift`, () => {
+      const list = new CLinkedList<number>();
+
+      for (let i = 0; i < LINEAR; i++) {
+        list.pushFront(i);
+      }
+    })
+    .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();
+      }
+    })
+    .add(`CPT DQ ${LINEAR.toLocaleString()} push`, () => {
+      const deque = new CDeque<number>();
+      for (let i = 0; i < LINEAR; i++) {
+        deque.pushBack(i);
+      }
+    })
+    .add(`CPT Q ${LINEAR.toLocaleString()} push`, () => {
+      const queue = new CQueue<number>();
+
+      for (let i = 0; i < LINEAR; i++) {
+        queue.push(i);
+      }
+    })
+    .add(`CPT ST ${LINEAR.toLocaleString()} push`, () => {
+      const queue = new CStack<number>();
+
+      for (let i = 0; i < LINEAR; i++) {
+        queue.push(i);
+      }
+    })
+    .add(`CPT ST ${LINEAR.toLocaleString()} push & pop`, () => {
+      const queue = new CStack<number>();
+
+      for (let i = 0; i < LINEAR; i++) {
+        queue.push(i);
+      }
+      for (let i = 0; i < LINEAR; i++) {
+        queue.pop();
+      }
+    });
+}
+
+export { suite };

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

@@ -1,9 +1,9 @@
-import {DirectedGraph} from '../../../../src';
+import { DirectedGraph } from '../../../../src';
 import * as Benchmark from 'benchmark';
-import {getRandomIndex, getRandomWords, magnitude} from '../../../utils';
+import { getRandomIndex, getRandomWords, magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const {THOUSAND} = magnitude;
+const { THOUSAND } = magnitude;
 const graph = new DirectedGraph<number, number>();
 const vertexes = getRandomWords(THOUSAND);
 
@@ -46,4 +46,4 @@ suite
     // }
   });
 
-export {suite};
+export { suite };

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

@@ -1,11 +1,11 @@
-import {HashMap} from '../../../../src';
-import {HashMap as CHashMap} from 'js-sdsl';
+import { HashMap } from '../../../../src';
+import { HashMap as CHashMap } from 'js-sdsl';
 import * as Benchmark from 'benchmark';
-import {magnitude} from '../../../utils';
-import {isCompetitor} from '../../../config';
+import { magnitude } from '../../../utils';
+import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const {TEN_THOUSAND} = magnitude;
+const { TEN_THOUSAND } = magnitude;
 
 suite.add(`${TEN_THOUSAND.toLocaleString()} set`, () => {
   const hm = new HashMap<number, number>();
@@ -15,7 +15,7 @@ suite.add(`${TEN_THOUSAND.toLocaleString()} set`, () => {
   }
 });
 if (isCompetitor) {
-  suite.add(`${TEN_THOUSAND.toLocaleString()} competitor set`, () => {
+  suite.add(`${TEN_THOUSAND.toLocaleString()} CPT set`, () => {
     const hm = new CHashMap<number, number>();
 
     for (let i = 0; i < TEN_THOUSAND; i++) {
@@ -34,7 +34,7 @@ suite.add(`${TEN_THOUSAND.toLocaleString()} set & get`, () => {
   }
 });
 if (isCompetitor) {
-  suite.add(`${TEN_THOUSAND.toLocaleString()} competitor set & get`, () => {
+  suite.add(`${TEN_THOUSAND.toLocaleString()} CPT set & get`, () => {
     const hm = new CHashMap<number, number>();
 
     for (let i = 0; i < TEN_THOUSAND; i++) {
@@ -45,4 +45,4 @@ if (isCompetitor) {
     }
   });
 }
-export {suite};
+export { suite };