data-structure-typed 1.45.0 → 1.45.1

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,12 +1,12 @@
-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>();
 
@@ -41,4 +41,4 @@ suite
     }
   });
 
-export {suite};
+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>();
@@ -45,4 +45,4 @@ if (isCompetitor) {
     }
   });
 }
-export {suite};
+export { suite };

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

@@ -1,13 +1,13 @@
-import {FibonacciHeap, Heap} from '../../../../src';
+import { FibonacciHeap, Heap } from '../../../../src';
 import * as Benchmark from 'benchmark';
-import {magnitude} from '../../../utils';
+import { magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const {TEN_THOUSAND} = magnitude;
+const { TEN_THOUSAND } = magnitude;
 
 suite
   .add(`${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
-    const heap = new Heap<number>({comparator: (a, b) => b - a});
+    const heap = new Heap<number>({ comparator: (a, b) => b - a });
 
     for (let i = 0; i < TEN_THOUSAND; i++) {
       heap.add(i);
@@ -27,4 +27,4 @@ suite
     }
   });
 
-export {suite};
+export { suite };

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

@@ -1,11 +1,11 @@
-import {DoublyLinkedList, DoublyLinkedListNode} from '../../../../src';
-import {LinkList as CLinkedList} from 'js-sdsl';
+import { DoublyLinkedList, DoublyLinkedListNode } from '../../../../src';
+import { LinkList as CLinkedList } 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 {LINEAR} = magnitude;
+const { LINEAR } = magnitude;
 
 suite.add(`${LINEAR.toLocaleString()} unshift`, () => {
   const list = new DoublyLinkedList<number>();
@@ -48,4 +48,4 @@ suite
     }
   });
 
-export {suite};
+export { suite };

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

@@ -1,9 +1,9 @@
-import {SinglyLinkedList, SinglyLinkedListNode} from '../../../../src';
+import { SinglyLinkedList, SinglyLinkedListNode } from '../../../../src';
 import * as Benchmark from 'benchmark';
-import {magnitude} from '../../../utils';
+import { magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const {TEN_THOUSAND} = magnitude;
+const { TEN_THOUSAND } = magnitude;
 
 suite
   .add(`${TEN_THOUSAND.toLocaleString()} push & pop`, () => {
@@ -31,4 +31,4 @@ suite
     }
   });
 
-export {suite};
+export { suite };

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

@@ -1,12 +1,14 @@
-import {MaxPriorityQueue} from '../../../../src';
+import { MaxPriorityQueue } from '../../../../src';
 import * as Benchmark from 'benchmark';
-import {magnitude} from '../../../utils';
+import { magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const {TEN_THOUSAND} = magnitude;
+const { TEN_THOUSAND } = magnitude;
 
 suite.add(`${TEN_THOUSAND.toLocaleString()} refill & poll`, () => {
-  const nodes = Array.from(new Set<number>(Array.from(new Array(TEN_THOUSAND), () => Math.floor(Math.random() * TEN_THOUSAND * 100))));
+  const nodes = Array.from(
+    new Set<number>(Array.from(new Array(TEN_THOUSAND), () => Math.floor(Math.random() * TEN_THOUSAND * 100)))
+  );
   const maxPQ = new MaxPriorityQueue<number>();
   maxPQ.refill(nodes);
   while (maxPQ.size > 0) {
@@ -14,4 +16,4 @@ suite.add(`${TEN_THOUSAND.toLocaleString()} refill & poll`, () => {
   }
 });
 
-export {suite};
+export { suite };

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

@@ -1,14 +1,14 @@
-import {PriorityQueue as CPriorityQueue} from 'js-sdsl';
-import {PriorityQueue} from '../../../../src';
+import { PriorityQueue as CPriorityQueue } from 'js-sdsl';
+import { PriorityQueue } from '../../../../src';
 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()} add & pop`, () => {
-  const pq = new PriorityQueue<number>({comparator: (a, b) => b - a});
+  const pq = new PriorityQueue<number>({ comparator: (a, b) => b - a });
 
   for (let i = 0; i < TEN_THOUSAND; i++) {
     pq.add(i);
@@ -32,4 +32,4 @@ if (isCompetitor) {
   });
 }
 
-export {suite};
+export { suite };

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

@@ -1,11 +1,11 @@
-import {Deque} from '../../../../src';
-import {Deque as CDeque} from 'js-sdsl';
+import { Deque } from '../../../../src';
+import { Deque as CDeque } from 'js-sdsl';
 import * as Benchmark from 'benchmark';
-import {magnitude} from '../../../utils';
-import {isCompetitor} from '../../../config';
+import { magnitude } from '../../../utils';
+import { isCompetitor } from '../../../config';
 
 export const suite = new Benchmark.Suite();
-const {LINEAR} = magnitude;
+const { LINEAR } = magnitude;
 
 suite.add(`${LINEAR.toLocaleString()} push`, () => {
   const deque = new Deque<number>();

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

@@ -1,11 +1,11 @@
-import {Queue} from '../../../../src';
-import {Queue as CQueue} from 'js-sdsl';
+import { Queue } from '../../../../src';
+import { Queue as CQueue } 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 {LINEAR} = magnitude;
+const { LINEAR } = magnitude;
 
 suite.add(`${LINEAR.toLocaleString()} push`, () => {
   const queue = new Queue<number>();
@@ -32,4 +32,4 @@ suite.add(`${LINEAR.toLocaleString()} push & shift`, () => {
   }
 });
 
-export {suite};
+export { suite };

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

@@ -1,11 +1,11 @@
-import {Stack} from '../../../../src';
-import {Stack as CStack} from 'js-sdsl';
+import { Stack } from '../../../../src';
+import { Stack as CStack } 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 {LINEAR} = magnitude;
+const { LINEAR } = magnitude;
 
 suite.add(`${LINEAR.toLocaleString()} push`, () => {
   const stack = new Stack<number>();
@@ -46,4 +46,4 @@ if (isCompetitor) {
   });
 }
 
-export {suite};
+export { suite };

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

@@ -1,9 +1,9 @@
-import {Trie} from '../../../../src';
+import { Trie } from '../../../../src';
 import * as Benchmark from 'benchmark';
-import {getRandomWords, magnitude} from '../../../utils';
+import { getRandomWords, magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const {HUNDRED_THOUSAND} = magnitude;
+const { HUNDRED_THOUSAND } = magnitude;
 const trie = new Trie();
 const randomWords = getRandomWords(HUNDRED_THOUSAND, false);
 
@@ -19,4 +19,4 @@ suite
     }
   });
 
-export {suite};
+export { suite };