avl-tree-typed 1.40.0-rc → 1.40.0

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

@@ -0,0 +1,31 @@
+import {BinaryTreeNode} from '../../../data-structures';
+
+/**
+ * Enum representing different loop types.
+ *
+ * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
+ * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
+ */
+
+export enum IterationType {
+  ITERATIVE = 'ITERATIVE',
+  RECURSIVE = 'RECURSIVE'
+}
+
+export enum FamilyPosition {
+  ROOT = 'ROOT',
+  LEFT = 'LEFT',
+  RIGHT = 'RIGHT',
+  ROOT_LEFT = 'ROOT_LEFT',
+  ROOT_RIGHT = 'ROOT_RIGHT',
+  ISOLATED = 'ISOLATED',
+  MAL_NODE = 'MAL_NODE'
+}
+
+export type BTNKey = number;
+
+export type BinaryTreeDeletedResult<N> = { deleted: N | null | undefined; needBalanced: N | null };
+
+export type BinaryTreeNodeNested<T> = BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+export type BinaryTreeOptions = { iterationType?: IterationType }

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

@@ -0,0 +1,11 @@
+import {BSTNode} from '../../../data-structures';
+import type {BinaryTreeOptions, BTNKey} from './binary-tree';
+
+export type BSTComparator = (a: BTNKey, b: BTNKey) => number;
+
+// prettier-ignore
+export type BSTNodeNested<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+export type BSTOptions = BinaryTreeOptions & {
+  comparator?: BSTComparator,
+}

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

@@ -0,0 +1,6 @@
+export * from './binary-tree';
+export * from './bst';
+export * from './avl-tree';
+export * from './segment-tree';
+export * from './tree-multiset';
+export * from './rb-tree';

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

@@ -0,0 +1,8 @@
+import {BinaryTreeOptions} from './binary-tree';
+import {RBTreeNode} from '../../../data-structures';
+
+export enum RBColor { RED = 'RED', BLACK = 'BLACK'}
+
+export type RBTreeNodeNested<T> = RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+export type RBTreeOptions = BinaryTreeOptions & {}

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

@@ -0,0 +1 @@
+export type SegmentTreeNodeVal = number;

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

@@ -0,0 +1,6 @@
+import {TreeMultisetNode} from '../../../data-structures';
+import {AVLTreeOptions} from './avl-tree';
+
+export type TreeMultisetNodeNested<T> = TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+export type TreeMultisetOptions = Omit<AVLTreeOptions, 'isMergeDuplicatedNodeByKey'> & {}

package/src/types/data-structures/graph/abstract-graph.ts

@@ -0,0 +1,11 @@
+export type VertexKey = string | number;
+
+export type DijkstraResult<V> = {
+  distMap: Map<V, number>;
+  distPaths?: Map<V, V[]>;
+  preMap: Map<V, V | null>;
+  seen: Set<V>;
+  paths: V[][];
+  minDist: number;
+  minPath: V[];
+} | null;

package/src/types/data-structures/graph/directed-graph.ts

@@ -0,0 +1,8 @@
+// 0 means unknown, 1 means visiting, 2 means visited;
+export type TopologicalStatus = 0 | 1 | 2;
+
+export enum TopologicalProperty {
+  VAL = 'VAL',
+  NODE = 'NODE',
+  ID = 'ID'
+}

package/src/types/data-structures/graph/index.ts

@@ -0,0 +1,3 @@
+export * from './abstract-graph';
+export * from './map-graph';
+export * from './directed-graph';

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

@@ -0,0 +1 @@
+export type MapGraphCoordinate = [number, number];

package/src/types/data-structures/graph/undirected-graph.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

package/src/types/data-structures/hash/coordinate-set.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export type HashFunction<K> = (key: K) => number;

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

@@ -0,0 +1 @@
+export {};

package/src/types/data-structures/hash/tree-set.ts

@@ -0,0 +1 @@
+export {};

package/src/types/data-structures/heap/heap.ts

@@ -0,0 +1 @@
+export {};

package/src/types/data-structures/heap/index.ts

@@ -0,0 +1 @@
+export * from './heap';

package/src/types/data-structures/heap/max-heap.ts

@@ -0,0 +1 @@
+export {};

package/src/types/data-structures/heap/min-heap.ts

@@ -0,0 +1 @@
+export {};

package/src/types/data-structures/index.ts

@@ -0,0 +1,11 @@
+export * from './binary-tree';
+export * from './graph';
+export * from './linked-list';
+export * from './heap';
+export * from './matrix';
+export * from './hash';
+export * from './priority-queue';
+export * from './queue';
+export * from './stack';
+export * from './tree';
+export * from './trie';

package/src/types/data-structures/linked-list/doubly-linked-list.ts

@@ -0,0 +1 @@
+export {};

package/src/types/data-structures/linked-list/index.ts

@@ -0,0 +1,2 @@
+export * from './singly-linked-list';
+export * from './doubly-linked-list';

package/src/types/data-structures/linked-list/singly-linked-list.ts

@@ -0,0 +1 @@
+export {};

package/src/types/data-structures/linked-list/skip-linked-list.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export * from './navigator';

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,14 @@
+export type Direction = 'up' | 'right' | 'down' | 'left';
+
+export type Turning = { [key in Direction]: Direction };
+
+export type NavigatorParams<T = any> = {
+  matrix: T[][];
+  turning: Turning;
+  onMove: (cur: [number, number]) => void;
+  init: {
+    cur: [number, number];
+    charDir: Direction;
+    VISITED: T;
+  };
+};

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

@@ -0,0 +1 @@
+export {};

package/src/types/data-structures/priority-queue/index.ts

@@ -0,0 +1,3 @@
+export * from './priority-queue';
+export * from './min-priority-queue';
+export * from './max-priority-queue';

package/src/types/data-structures/priority-queue/max-priority-queue.ts

@@ -0,0 +1 @@
+export {};

package/src/types/data-structures/priority-queue/min-priority-queue.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+export * from './queue';
+export * from './deque';

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

@@ -0,0 +1 @@
+export {};

package/src/types/data-structures/stack/index.ts

@@ -0,0 +1 @@
+export * from './stack';

package/src/types/data-structures/stack/stack.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export * from './tree';

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export * from './trie';

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

@@ -0,0 +1 @@
+export {};

package/src/types/helpers.ts

@@ -0,0 +1,11 @@
+export type Comparator<T> = (a: T, b: T) => number;
+
+export type DFSOrderPattern = 'pre' | 'in' | 'post';
+
+export type BTNCallback<N, D = any> = (node: N) => D;
+
+export enum CP {
+  lt = 'lt',
+  eq = 'eq',
+  gt = 'gt'
+}

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from './data-structures';
+export * from './helpers';
+export * from './utils';

package/src/types/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './utils';
+export * from './validate-type';

package/src/types/utils/utils.ts

@@ -0,0 +1,6 @@
+export type ToThunkFn = () => ReturnType<TrlFn>;
+export type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: symbol };
+export type TrlFn = (...args: any[]) => any;
+export type TrlAsyncFn = (...args: any[]) => any;
+
+export type SpecifyOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

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

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

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './utils';

package/src/utils/utils.ts

@@ -0,0 +1,86 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type {Thunk, ToThunkFn, TrlAsyncFn, TrlFn} from '../types';
+
+export const uuidV4 = function () {
+  return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {
+    const r = (Math.random() * 16) | 0,
+      v = c == 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+};
+
+export const arrayRemove = function <T>(array: T[], predicate: (item: T, index: number, array: T[]) => boolean): T[] {
+  let i = -1,
+    len = array ? array.length : 0;
+  const result = [];
+
+  while (++i < len) {
+    const value = array[i];
+    if (predicate(value, i, array)) {
+      result.push(value);
+      Array.prototype.splice.call(array, i--, 1);
+      len--;
+    }
+  }
+
+  return result;
+};
+
+export const THUNK_SYMBOL = Symbol('thunk');
+
+export const isThunk = (fnOrValue: any) => {
+  return typeof fnOrValue === 'function' && fnOrValue.__THUNK__ === THUNK_SYMBOL;
+};
+
+export const toThunk = (fn: ToThunkFn): Thunk => {
+  const thunk = () => fn();
+  thunk.__THUNK__ = THUNK_SYMBOL;
+  return thunk;
+};
+
+export const trampoline = (fn: TrlFn) => {
+  const cont = (...args: [...Parameters<TrlFn>]) => toThunk(() => fn(...args));
+
+  return Object.assign(
+    (...args: [...Parameters<TrlFn>]) => {
+      let result = fn(...args);
+
+      while (isThunk(result) && typeof result === 'function') {
+        result = result();
+      }
+
+      return result;
+    },
+    {cont}
+  );
+};
+
+export const trampolineAsync = (fn: TrlAsyncFn) => {
+  const cont = (...args: [...Parameters<TrlAsyncFn>]) => toThunk(() => fn(...args));
+
+  return Object.assign(
+    async (...args: [...Parameters<TrlAsyncFn>]) => {
+      let result = await fn(...args);
+
+      while (isThunk(result) && typeof result === 'function') {
+        result = await result();
+      }
+
+      return result;
+    },
+    {cont}
+  );
+};
+
+export const getMSB = (value: number): number => {
+  if (value <= 0) {
+    return 0;
+  }
+  return 1 << (31 - Math.clz32(value));
+};

package/test/index.test.ts

@@ -1,111 +1,111 @@
 import {AVLTree} from '../src';
 
 describe('AVL Tree Test', () => {
-    it('should perform various operations on a AVL Tree', () => {
+  it('should perform various operations on a AVL Tree', () => {
 
-        const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-        const tree = new AVLTree();
+    const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+    const tree = new AVLTree();
 
-        for (const i of arr) tree.add(i, i);
+    for (const i of arr) tree.add(i, i);
 
-        const node6 = tree.get(6);
+    const node6 = tree.get(6);
 
-        expect(node6 && tree.getHeight(node6)).toBe(3);
-        expect(node6 && tree.getDepth(node6)).toBe(1);
+    expect(node6 && tree.getHeight(node6)).toBe(3);
+    expect(node6 && tree.getDepth(node6)).toBe(1);
 
-        const getNodeById = tree.get(10, 'id');
-        expect(getNodeById?.id).toBe(10);
+    const getNodeById = tree.get(10, 'id');
+    expect(getNodeById?.id).toBe(10);
 
 
-        const getMinNodeByRoot = tree.getLeftMost();
-        expect(getMinNodeByRoot?.id).toBe(1);
+    const getMinNodeByRoot = tree.getLeftMost();
+    expect(getMinNodeByRoot?.id).toBe(1);
 
-        const node15 = tree.get(15);
-        const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
-        expect(getMinNodeBySpecificNode?.id).toBe(12);
+    const node15 = tree.get(15);
+    const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
+    expect(getMinNodeBySpecificNode?.id).toBe(12);
 
-        const subTreeSum = node15 && tree.subTreeSum(node15);
-        expect(subTreeSum).toBe(70);
+    const subTreeSum = node15 && tree.subTreeSum(node15);
+    expect(subTreeSum).toBe(70);
 
-        const lesserSum = tree.lesserSum(10);
-        expect(lesserSum).toBe(45);
+    const lesserSum = tree.lesserSum(10);
+    expect(lesserSum).toBe(45);
 
 
-        // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
-        expect(node15?.val).toBe(15);
+    // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
+    expect(node15?.val).toBe(15);
 
-        const dfs = tree.DFS('in', 'node');
-        expect(dfs[0].id).toBe(1);
-        expect(dfs[dfs.length - 1].id).toBe(16);
+    const dfs = tree.DFS('in', 'node');
+    expect(dfs[0].id).toBe(1);
+    expect(dfs[dfs.length - 1].id).toBe(16);
 
-        tree.perfectlyBalance();
-        const bfs = tree.BFS('node');
-        expect(tree.isPerfectlyBalanced()).toBe(true);
-        expect(bfs[0].id).toBe(8);
-        expect(bfs[bfs.length - 1].id).toBe(16);
+    tree.perfectlyBalance();
+    const bfs = tree.BFS('node');
+    expect(tree.isPerfectlyBalanced()).toBe(true);
+    expect(bfs[0].id).toBe(8);
+    expect(bfs[bfs.length - 1].id).toBe(16);
 
-        expect(tree.remove(11)[0].deleted?.id).toBe(11);
-        expect(tree.isAVLBalanced()).toBe(true);
-        expect(node15 && tree.getHeight(node15)).toBe(2);
+    expect(tree.remove(11)[0].deleted?.id).toBe(11);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(node15 && tree.getHeight(node15)).toBe(2);
 
-        expect(tree.remove(1)[0].deleted?.id).toBe(1);
-        expect(tree.isAVLBalanced()).toBe(true);
-        expect(tree.getHeight()).toBe(4);
+    expect(tree.remove(1)[0].deleted?.id).toBe(1);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
 
-        expect(tree.remove(4)[0].deleted?.id).toBe(4);
-        expect(tree.isAVLBalanced()).toBe(true);
-        expect(tree.getHeight()).toBe(4);
+    expect(tree.remove(4)[0].deleted?.id).toBe(4);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
 
-        expect(tree.remove(10)[0].deleted?.id).toBe(10);
-        expect(tree.isAVLBalanced()).toBe(true);
-        expect(tree.getHeight()).toBe(3);
+    expect(tree.remove(10)[0].deleted?.id).toBe(10);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
 
-        expect(tree.remove(15)[0].deleted?.id).toBe(15);
-        expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.remove(15)[0].deleted?.id).toBe(15);
+    expect(tree.isAVLBalanced()).toBe(true);
 
-        expect(tree.getHeight()).toBe(3);
+    expect(tree.getHeight()).toBe(3);
 
-        expect(tree.remove(5)[0].deleted?.id).toBe(5);
-        expect(tree.isAVLBalanced()).toBe(true);
-        expect(tree.getHeight()).toBe(3);
+    expect(tree.remove(5)[0].deleted?.id).toBe(5);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
 
-        expect(tree.remove(13)[0].deleted?.id).toBe(13);
-        expect(tree.isAVLBalanced()).toBe(true);
-        expect(tree.getHeight()).toBe(3);
+    expect(tree.remove(13)[0].deleted?.id).toBe(13);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
 
-        expect(tree.remove(3)[0].deleted?.id).toBe(3);
-        expect(tree.isAVLBalanced()).toBe(true);
-        expect(tree.getHeight()).toBe(3);
+    expect(tree.remove(3)[0].deleted?.id).toBe(3);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
 
-        expect(tree.remove(8)[0].deleted?.id).toBe(8);
-        expect(tree.isAVLBalanced()).toBe(true);
-        expect(tree.getHeight()).toBe(3);
+    expect(tree.remove(8)[0].deleted?.id).toBe(8);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
 
-        expect(tree.remove(6)[0].deleted?.id).toBe(6);
-        expect(tree.remove(6).length).toBe(0);
-        expect(tree.isAVLBalanced()).toBe(true);
-        expect(tree.getHeight()).toBe(2);
+    expect(tree.remove(6)[0].deleted?.id).toBe(6);
+    expect(tree.remove(6).length).toBe(0);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
 
-        expect(tree.remove(7)[0].deleted?.id).toBe(7);
-        expect(tree.isAVLBalanced()).toBe(true);
-        expect(tree.getHeight()).toBe(2);
+    expect(tree.remove(7)[0].deleted?.id).toBe(7);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
 
-        expect(tree.remove(9)[0].deleted?.id).toBe(9);
-        expect(tree.isAVLBalanced()).toBe(true);
-        expect(tree.getHeight()).toBe(2);
-        expect(tree.remove(14)[0].deleted?.id).toBe(14);
-        expect(tree.isAVLBalanced()).toBe(true);
-        expect(tree.getHeight()).toBe(1);
+    expect(tree.remove(9)[0].deleted?.id).toBe(9);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+    expect(tree.remove(14)[0].deleted?.id).toBe(14);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(1);
 
-        expect(tree.isAVLBalanced()).toBe(true);
-        const lastBFSIds = tree.BFS();
-        expect(lastBFSIds[0]).toBe(12);
-        expect(lastBFSIds[1]).toBe(2);
-        expect(lastBFSIds[2]).toBe(16);
+    expect(tree.isAVLBalanced()).toBe(true);
+    const lastBFSIds = tree.BFS();
+    expect(lastBFSIds[0]).toBe(12);
+    expect(lastBFSIds[1]).toBe(2);
+    expect(lastBFSIds[2]).toBe(16);
 
-        const lastBFSNodes = tree.BFS('node');
-        expect(lastBFSNodes[0].id).toBe(12);
-        expect(lastBFSNodes[1].id).toBe(2);
-        expect(lastBFSNodes[2].id).toBe(16);
-    });
+    const lastBFSNodes = tree.BFS('node');
+    expect(lastBFSNodes[0].id).toBe(12);
+    expect(lastBFSNodes[1].id).toBe(2);
+    expect(lastBFSNodes[2].id).toBe(16);
+  });
 });

package/tsconfig.json

@@ -26,9 +26,8 @@
       "node_modules/@types"
     ]
   },
-
   "include": [
-    "src",
+    "src"
   ],
   "exclude": [
     //    "node_modules/data-structure-typed",