data-structure-typed 1.44.1 → 1.45.1

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

@@ -1,4 +1,4 @@
-import {SinglyLinkedList, SinglyLinkedListNode} from '../../../../src';
+import { SinglyLinkedList, SinglyLinkedListNode } from '../../../../src';
 
 describe('SinglyLinkedListNode', () => {
   it('should SinglyLinkedList', () => {
@@ -11,10 +11,10 @@ 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', () => {
@@ -366,9 +366,9 @@ describe('SinglyLinkedList Operation Test', () => {
   });
 
   it('should insert and manipulate objects with numeric properties', () => {
-    const obj1 = {keyA: 1};
-    const obj2 = {keyA: 2};
-    const obj3 = {keyA: 3};
+    const obj1 = { keyA: 1 };
+    const obj2 = { keyA: 2 };
+    const obj3 = { keyA: 3 };
 
     objectList.push(obj1);
     objectList.push(obj2);
@@ -376,7 +376,7 @@ describe('SinglyLinkedList Operation Test', () => {
 
     expect(objectList.toArray()).toEqual([obj1, obj2, obj3]);
 
-    const newObj = {keyA: 2.5}; // Corrected newObj value
+    const newObj = { keyA: 2.5 }; // Corrected newObj value
     const insertSuccess = objectList.insertBefore(obj2, newObj);
     expect(insertSuccess).toBe(true);
 

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

@@ -1,4 +1,4 @@
-import {SkipList} from '../../../../src';
+import { SkipList } from '../../../../src';
 
 describe('SkipList', () => {
   let skipList: SkipList<number, string>;
@@ -65,21 +65,21 @@ describe('SkipList', () => {
     skipList.add(4, 'Four');
   });
 
-  test('getFirst() should return the getFirst element', () => {
+  it('getFirst() should return the getFirst element', () => {
     expect(skipList.getFirst()).toBe('One');
   });
 
-  test('getLast() should return the getLast element', () => {
+  it('getLast() should return the getLast element', () => {
     expect(skipList.getLast()).toBe('Four');
   });
 
-  test('higher(key) should return the getFirst element greater than the given key', () => {
+  it('higher(key) should return the getFirst element greater than the given key', () => {
     expect(skipList.higher(2)).toBe('Three');
     expect(skipList.higher(3)).toBe('Four');
     expect(skipList.higher(4)).toBeUndefined();
   });
 
-  test('lower(key) should return the getLast element less than the given key', () => {
+  it('lower(key) should return the getLast element less than the given key', () => {
     expect(skipList.lower(2)).toBe('One');
     expect(skipList.lower(1)).toBe(null);
   });

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

@@ -1,10 +1,10 @@
-import {MatrixNTI2D} from '../../../../src';
+import { MatrixNTI2D } from '../../../../src';
 
 describe('MatrixNTI2D', () => {
   it('should initialize a matrix with rows and columns', () => {
     const numRows = 3;
     const numCols = 4;
-    const matrix = new MatrixNTI2D({row: numRows, col: numCols});
+    const matrix = new MatrixNTI2D({ row: numRows, col: numCols });
 
     expect(matrix.toArray().length).toBe(numRows);
     expect(matrix.toArray()[0].length).toBe(numCols);
@@ -14,7 +14,7 @@ describe('MatrixNTI2D', () => {
     const numRows = 3;
     const numCols = 4;
     const initialValue = 42;
-    const matrix = new MatrixNTI2D({row: numRows, col: numCols, initialVal: initialValue});
+    const matrix = new MatrixNTI2D({ row: numRows, col: numCols, initialVal: initialValue });
 
     const matrixArray = matrix.toArray();
     for (let i = 0; i < numRows; i++) {
@@ -27,7 +27,7 @@ describe('MatrixNTI2D', () => {
   it('should initialize all elements with 0 if no initial value is provided', () => {
     const numRows = 3;
     const numCols = 4;
-    const matrix = new MatrixNTI2D({row: numRows, col: numCols});
+    const matrix = new MatrixNTI2D({ row: numRows, col: numCols });
 
     const matrixArray = matrix.toArray();
     for (let i = 0; i < numRows; i++) {
@@ -40,7 +40,7 @@ describe('MatrixNTI2D', () => {
   it('should convert the matrix to a two-dimensional array', () => {
     const numRows = 2;
     const numCols = 3;
-    const matrix = new MatrixNTI2D({row: numRows, col: numCols, initialVal: 1});
+    const matrix = new MatrixNTI2D({ row: numRows, col: numCols, initialVal: 1 });
 
     const matrixArray = matrix.toArray();
     expect(matrixArray.length).toBe(numRows);

package/test/unit/data-structures/matrix/matrix2d.test.ts

@@ -1,5 +1,5 @@
-import {Matrix2D, Vector2D} from '../../../../src';
-import {isDebugTest} from '../../../config';
+import { Matrix2D, Vector2D } from '../../../../src';
+import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
 describe('Matrix2D', () => {
@@ -288,7 +288,7 @@ describe('Matrix2D', () => {
     const vector = new Vector2D(2, 3);
     const result = Matrix2D.multiplyByVector(matrix, vector);
     isDebug && console.log(JSON.stringify(result));
-    expect(result).toEqual({x: 17, y: 35, w: 1});
+    expect(result).toEqual({ x: 17, y: 35, w: 1 });
   });
 
   it('should correctly create a view matrix', () => {

package/test/unit/data-structures/matrix/navigator.test.ts

@@ -1,5 +1,5 @@
-import {Character, Navigator, NavigatorParams, Turning} from '../../../../src';
-import {isDebugTest} from '../../../config';
+import { Character, Navigator, NavigatorParams, Turning } from '../../../../src';
+import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
 const exampleMatrix: number[][] = [

package/test/unit/data-structures/matrix/vector2d.test.ts

@@ -1,4 +1,4 @@
-import {Vector2D} from '../../../../src';
+import { Vector2D } from '../../../../src';
 
 describe('Vector2D', () => {
   it('should create a vector with default values', () => {

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

@@ -1,4 +1,4 @@
-import {MaxPriorityQueue} from '../../../../src';
+import { MaxPriorityQueue } from '../../../../src';
 
 describe('MaxPriorityQueue Operation Test', () => {
   it('should add elements and maintain heap property', () => {
@@ -16,9 +16,9 @@ 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});
-    priorityQueue.refill([{keyA: 5}, {keyA: 3}, {keyA: 1}]);
-    priorityQueue.add({keyA: 7});
+    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 });
 
     expect(priorityQueue.poll()?.keyA).toBe(7);
     expect(priorityQueue.poll()?.keyA).toBe(5);
@@ -52,7 +52,7 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an array', () => {
     const array = [5, 3, 7, 1];
-    const heap = MaxPriorityQueue.heapify<number>({nodes: array, comparator: (a, b) => b - a});
+    const heap = MaxPriorityQueue.heapify<number>({ nodes: array, comparator: (a, b) => b - a });
     heap.refill(array);
 
     expect(heap.poll()).toBe(7);
@@ -62,8 +62,8 @@ describe('MaxPriorityQueue Operation Test', () => {
   });
 
   it('should correctly heapify an object array', () => {
-    const nodes = [{keyA: 5}, {keyA: 3}, {keyA: 7}, {keyA: 1}];
-    const maxPQ = MaxPriorityQueue.heapify<{keyA: number}>({nodes: nodes, comparator: (a, b) => b.keyA - a.keyA});
+    const nodes = [{ keyA: 5 }, { keyA: 3 }, { keyA: 7 }, { keyA: 1 }];
+    const maxPQ = MaxPriorityQueue.heapify<{ keyA: number }>({ nodes: nodes, comparator: (a, b) => b.keyA - a.keyA });
 
     expect(maxPQ.poll()?.keyA).toBe(7);
     expect(maxPQ.poll()?.keyA).toBe(5);

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

@@ -1,4 +1,4 @@
-import {MinPriorityQueue} from '../../../../src';
+import { MinPriorityQueue } from '../../../../src';
 
 describe('MinPriorityQueue Operation Test', () => {
   it('should check if a node exists in the queue', () => {

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

@@ -1,11 +1,11 @@
-import {PriorityQueue} from '../../../../src';
-import {PriorityQueue as CPriorityQueue} from 'js-sdsl';
-import {isDebugTest} from '../../../config';
+import { PriorityQueue } from '../../../../src';
+import { PriorityQueue as CPriorityQueue } from 'js-sdsl';
+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();
@@ -13,13 +13,16 @@ describe('PriorityQueue Operation Test', () => {
     minPQ.poll();
     expect(minPQ.toArray()).toEqual([4, 5, 6]);
     expect(minPQ.peek()).toBe(4);
-    expect(PriorityQueue.heapify({nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10], comparator: (a, b) => a - b}).toArray()).toEqual([
-      1, 2, 3, 5, 6, 7, 8, 9, 10
-    ]);
+    expect(
+      PriorityQueue.heapify({
+        nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10],
+        comparator: (a, b) => a - b
+      }).toArray()
+    ).toEqual([1, 2, 3, 5, 6, 7, 8, 9, 10]);
   });
 
   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();
@@ -27,13 +30,16 @@ describe('PriorityQueue Operation Test', () => {
     maxPriorityQueue.poll();
     expect(maxPriorityQueue.toArray()).toEqual([3, 2, 1]);
     expect(maxPriorityQueue.peek()).toBe(3);
-    expect(PriorityQueue.heapify({nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10], comparator: (a, b) => a - b}).toArray()).toEqual([
-      1, 2, 3, 5, 6, 7, 8, 9, 10
-    ]);
+    expect(
+      PriorityQueue.heapify({
+        nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10],
+        comparator: (a, b) => a - b
+      }).toArray()
+    ).toEqual([1, 2, 3, 5, 6, 7, 8, 9, 10]);
   });
 
   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.getNodes()).toEqual(minPQ1.getNodes());
@@ -46,7 +52,7 @@ describe('PriorityQueue Operation Test', () => {
 
 describe('Priority Queue Performance Test', () => {
   it('should numeric heap work well', function () {
-    const pq = new PriorityQueue({comparator: (a, b) => b - a});
+    const pq = new PriorityQueue({ comparator: (a, b) => b - a });
 
     const tS = performance.now();
 

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

@@ -1,6 +1,6 @@
-import {ArrayDeque, Deque, ObjectDeque} from '../../../../src';
-import {bigO} from '../../../utils';
-import {isDebugTest} from '../../../config';
+import { ArrayDeque, Deque, ObjectDeque } from '../../../../src';
+import { bigO } from '../../../utils';
+import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
 describe('Deque Tests', () => {
@@ -155,12 +155,12 @@ describe('Deque', () => {
     deque = new Deque<number>();
   });
 
-  test('should initialize an empty deque', () => {
+  it('should initialize an empty deque', () => {
     expect(deque.size).toBe(0);
     expect(deque.isEmpty()).toBe(true);
   });
 
-  test('should add elements to the front and back', () => {
+  it('should add elements to the front and back', () => {
     deque.addFirst(1);
     deque.addLast(2);
 
@@ -169,7 +169,7 @@ describe('Deque', () => {
     expect(deque.getLast()).toBe(2);
   });
 
-  test('should remove elements from the front and back', () => {
+  it('should remove elements from the front and back', () => {
     deque.addFirst(1);
     deque.addLast(2);
 
@@ -181,7 +181,7 @@ describe('Deque', () => {
     expect(lastElement).toBe(2);
   });
 
-  test('should get elements by index', () => {
+  it('should get elements by index', () => {
     deque.addLast(1);
     deque.addLast(2);
     deque.addLast(3);
@@ -191,13 +191,13 @@ describe('Deque', () => {
     expect(deque.getAt(2)).toBe(3);
   });
 
-  test('should return null for out-of-bounds index', () => {
+  it('should return null for out-of-bounds index', () => {
     expect(deque.getAt(0)).toBe(undefined);
     expect(deque.getAt(1)).toBe(undefined);
     expect(deque.getAt(-1)).toBe(undefined);
   });
 
-  test('should check if the deque is empty', () => {
+  it('should check if the deque is empty', () => {
     expect(deque.isEmpty()).toBe(true);
 
     deque.addLast(1);
@@ -215,12 +215,12 @@ describe('ArrayDeque', () => {
     deque = new ArrayDeque<number>();
   });
 
-  test('should initialize an empty deque', () => {
+  it('should initialize an empty deque', () => {
     expect(deque.size).toBe(0);
     expect(deque.isEmpty()).toBe(true);
   });
 
-  test('should add elements to the front and back', () => {
+  it('should add elements to the front and back', () => {
     deque.addFirst(1);
     deque.addLast(2);
 
@@ -229,7 +229,7 @@ describe('ArrayDeque', () => {
     expect(deque.getLast()).toBe(2);
   });
 
-  test('should remove elements from the front and back', () => {
+  it('should remove elements from the front and back', () => {
     deque.addFirst(1);
     deque.addLast(2);
 
@@ -241,7 +241,7 @@ describe('ArrayDeque', () => {
     expect(lastElement).toBe(2);
   });
 
-  test('should get elements by index', () => {
+  it('should get elements by index', () => {
     deque.addLast(1);
     deque.addLast(2);
     deque.addLast(3);
@@ -251,13 +251,13 @@ describe('ArrayDeque', () => {
     expect(deque.get(2)).toBe(3);
   });
 
-  test('should return null for out-of-bounds index', () => {
+  it('should return null for out-of-bounds index', () => {
     expect(deque.get(0)).toBe(null);
     expect(deque.get(1)).toBe(null);
     expect(deque.get(-1)).toBe(null);
   });
 
-  test('should check if the deque is empty', () => {
+  it('should check if the deque is empty', () => {
     expect(deque.isEmpty()).toBe(true);
 
     deque.addLast(1);
@@ -267,7 +267,7 @@ describe('ArrayDeque', () => {
     expect(deque.isEmpty()).toBe(true);
   });
 
-  test('should set elements at a specific index', () => {
+  it('should set elements at a specific index', () => {
     deque.addLast(1);
     deque.addLast(2);
     deque.addLast(3);
@@ -279,7 +279,7 @@ describe('ArrayDeque', () => {
     expect(deque.get(2)).toBe(3);
   });
 
-  test('should insert elements at a specific index', () => {
+  it('should insert elements at a specific index', () => {
     deque.addLast(1);
     deque.addLast(2);
     deque.addLast(3);
@@ -293,7 +293,7 @@ describe('ArrayDeque', () => {
     expect(deque.get(3)).toBe(3);
   });
 
-  test('should delete elements at a specific index', () => {
+  it('should delete elements at a specific index', () => {
     deque.addLast(1);
     deque.addLast(2);
     deque.addLast(3);
@@ -314,7 +314,7 @@ describe('ObjectDeque', () => {
     deque = new ObjectDeque<number>();
   });
 
-  test('should add elements to the front of the deque', () => {
+  it('should add elements to the front of the deque', () => {
     deque.addFirst(1);
     deque.addFirst(2);
 
@@ -323,7 +323,7 @@ describe('ObjectDeque', () => {
     expect(deque.getLast()).toBe(1);
   });
 
-  test('should add elements to the end of the deque', () => {
+  it('should add elements to the end of the deque', () => {
     deque.addLast(1);
     deque.addLast(2);
 
@@ -332,7 +332,7 @@ describe('ObjectDeque', () => {
     expect(deque.getLast()).toBe(2);
   });
 
-  test('should remove elements from the front of the deque', () => {
+  it('should remove elements from the front of the deque', () => {
     deque.addLast(1);
     deque.addLast(2);
 
@@ -343,7 +343,7 @@ describe('ObjectDeque', () => {
     expect(deque.getFirst()).toBe(2);
   });
 
-  test('should remove elements from the end of the deque', () => {
+  it('should remove elements from the end of the deque', () => {
     deque.addLast(1);
     deque.addLast(2);
 
@@ -354,7 +354,7 @@ describe('ObjectDeque', () => {
     expect(deque.getLast()).toBe(2);
   });
 
-  test('should return the element at the front of the deque without removing it', () => {
+  it('should return the element at the front of the deque without removing it', () => {
     deque.addFirst(1);
     deque.addFirst(2);
 
@@ -362,7 +362,7 @@ describe('ObjectDeque', () => {
     expect(deque.size).toBe(2);
   });
 
-  test('should return the element at the end of the deque without removing it', () => {
+  it('should return the element at the end of the deque without removing it', () => {
     deque.addLast(1);
     deque.addLast(2);
 
@@ -370,7 +370,7 @@ describe('ObjectDeque', () => {
     expect(deque.size).toBe(2);
   });
 
-  test('should return the correct size of the deque', () => {
+  it('should return the correct size of the deque', () => {
     deque.addFirst(1);
     deque.addLast(2);
     deque.addLast(3);
@@ -378,7 +378,7 @@ describe('ObjectDeque', () => {
     expect(deque.size).toBe(3);
   });
 
-  test('should check if the deque is empty', () => {
+  it('should check if the deque is empty', () => {
     expect(deque.isEmpty()).toBe(true);
 
     deque.addFirst(1);
@@ -386,7 +386,7 @@ describe('ObjectDeque', () => {
     expect(deque.isEmpty()).toBe(false);
   });
 
-  test('should set elements at a specific index', () => {
+  it('should set elements at a specific index', () => {
     deque.addFirst(1);
     deque.addLast(2);
     deque.addLast(3);
@@ -396,7 +396,7 @@ describe('ObjectDeque', () => {
     expect(deque.getLast()).toBe(3);
   });
 
-  test('should insert elements at a specific index', () => {
+  it('should insert elements at a specific index', () => {
     deque.addFirst(1);
     deque.addLast(2);
     deque.addLast(3);

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

@@ -1,6 +1,6 @@
-import {LinkedListQueue, Queue} from '../../../../src';
-import {bigO} from '../../../utils';
-import {isDebugTest} from '../../../config';
+import { LinkedListQueue, Queue } from '../../../../src';
+import { bigO } from '../../../utils';
+import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
 describe('Queue Operation Test', () => {

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

@@ -1,4 +1,4 @@
-import {Stack} from '../../../../src';
+import { Stack } from '../../../../src';
 
 describe('Stack', () => {
   let stack: Stack<number>;

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

@@ -1,4 +1,4 @@
-import {TreeNode} from '../../../../src';
+import { TreeNode } from '../../../../src';
 
 describe('TreeNode', () => {
   it('should create a TreeNode with the given key and value', () => {

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

@@ -1,4 +1,4 @@
-import {Trie, TrieNode} from '../../../../src';
+import { Trie, TrieNode } from '../../../../src';
 
 describe('TrieNode', () => {
   it('should create a TrieNode with the given value', () => {
@@ -761,7 +761,7 @@ describe('Trie operations', () => {
     trie = new Trie();
   });
 
-  test('Add and Find Words', () => {
+  it('Add and Find Words', () => {
     trie.add('apple');
     trie.add('banana');
     expect(trie.has('apple')).toBe(true);
@@ -769,7 +769,7 @@ describe('Trie operations', () => {
     expect(trie.has('cherry')).toBe(false);
   });
 
-  test('Remove Words', () => {
+  it('Remove Words', () => {
     trie.add('apple');
     trie.add('banana');
     expect(trie.delete('apple')).toBe(true);
@@ -777,39 +777,39 @@ describe('Trie operations', () => {
     expect(trie.delete('cherry')).toBe(false);
   });
 
-  test('Case Sensitivity', () => {
+  it('Case Sensitivity', () => {
     const caseInsensitiveTrie = new Trie(['apple', 'Banana'], false);
     expect(caseInsensitiveTrie.has('APPLE')).toBe(true);
     expect(caseInsensitiveTrie.has('banana')).toBe(true);
     expect(caseInsensitiveTrie.has('Cherry')).toBe(false);
   });
 
-  test('Pure Prefix Check', () => {
+  it('Pure Prefix Check', () => {
     trie.add('apple');
     expect(trie.hasPurePrefix('appl')).toBe(true);
     expect(trie.hasPurePrefix('apple')).toBe(false);
   });
 
-  test('Prefix Check', () => {
+  it('Prefix Check', () => {
     trie.add('apple');
     expect(trie.hasPrefix('app')).toBe(true);
     expect(trie.hasPrefix('ban')).toBe(false);
   });
 
-  test('Common Prefix Check', () => {
+  it('Common Prefix Check', () => {
     trie.add('apple');
     trie.add('appetizer');
     expect(trie.hasCommonPrefix('app')).toBe(true);
     expect(trie.hasCommonPrefix('apple')).toBe(false);
   });
 
-  test('Longest Common Prefix', () => {
+  it('Longest Common Prefix', () => {
     trie.add('apple');
     trie.add('appetizer');
     expect(trie.getLongestCommonPrefix()).toBe('app');
   });
 
-  test('Get Words by Prefix', () => {
+  it('Get Words by Prefix', () => {
     trie.add('apple');
     trie.add('appetizer');
     trie.add('banana');
@@ -817,7 +817,7 @@ describe('Trie operations', () => {
     expect(words).toEqual(['apple', 'appetizer']);
   });
 
-  test('Tree Height', () => {
+  it('Tree Height', () => {
     trie.add('apple');
     trie.add('banana');
     expect(trie.getHeight()).toBe(6); // Assuming 'apple' and 'banana' are the longest words.

package/test/utils/array.ts

@@ -1,6 +1,6 @@
-import {getRandomInt} from './number';
+import { getRandomInt } from './number';
 
-export function getRandomIntArray(length: number, min: number = -1000, max: number = 1000, isDistinct = true) {
+export function getRandomIntArray(length: number = 1000, min: number = -1000, max: number = 1000, isDistinct = true) {
   if (isDistinct) {
     const set = new Set<number>();
     const ans: number[] = [];

package/test/utils/big-o.ts

@@ -1,5 +1,5 @@
-import {AnyFunction} from '../types';
-import {isDebugTest} from '../config';
+import { AnyFunction } from '../types';
+import { isDebugTest } from '../config';
 
 const isDebug = isDebugTest;
 const orderReducedBy = 1; // reduction of bigO's order compared to the baseline bigO
@@ -32,7 +32,7 @@ export const bigO = {
 
 function findPotentialN(input: any): number {
   let longestArray: any[] = [];
-  let mostProperties: {[key: string]: any} = {};
+  let mostProperties: { [key: string]: any } = {};
 
   function recurse(obj: any) {
     if (Array.isArray(obj)) {
@@ -81,7 +81,7 @@ function linearRegression(x: number[], y: number[]) {
 
   const rSquared = 1 - totalVariation / explainedVariation;
 
-  return {slope, intercept, rSquared};
+  return { slope, intercept, rSquared };
 }
 
 function estimateBigO(runtimes: number[], dataSizes: number[]): string {

package/test/utils/json2html.ts

@@ -1,5 +1,5 @@
 import * as _ from './is';
-import {Json2htmlOptions} from '../types';
+import { Json2htmlOptions } from '../types';
 
 function toggleJS(options?: Json2htmlOptions): string {
   if (options?.plainHtml) {
@@ -14,7 +14,9 @@ function makeLabelDiv(options: any, level: number, keyName: string | number, dat
     return `<div class='index'><span class='json-to-html-label'>${keyName}&nbsp;</span></div>`;
   } else if (typeof keyName === 'string') {
     if (datatype === 'array') {
-      return `<div class='collapsible level${level}' ${toggleJS(options)}><span class='json-to-html-label'>${keyName}</span></div>`;
+      return `<div class='collapsible level${level}' ${toggleJS(
+        options
+      )}><span class='json-to-html-label'>${keyName}</span></div>`;
     } else if (datatype === 'object') {
       return `<div class='attribute collapsible level${level}' ${toggleJS(
         options
@@ -120,7 +122,9 @@ function _render(name: string, data: any, options: Json2htmlOptions, level: numb
     } else {
       subs =
         "<div class='altRows'>" +
-        data.map((val: any, idx: number) => _render(idx.toString(), val, options, level + 1, idx % 2)).join("</div><div class='altRows'>") +
+        data
+          .map((val: any, idx: number) => _render(idx.toString(), val, options, level + 1, idx % 2))
+          .join("</div><div class='altRows'>") +
         '</div>';
     }
     return `<div class="json-to-html-collapse clearfix ${altRow}">

package/test/utils/number.ts

@@ -1,4 +1,4 @@
-export function getRandomInt(min: number, max: number) {
+export function getRandomInt(min: number = 0, max: number = 1000) {
   return Math.floor(Math.random() * (max - min + 1)) + min;
 }