linked-list-typed 1.45.0 → 1.45.1

package/dist/data-structures/hash/hash-map.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { HashMapLinkedNode, HashMapOptions, IterateDirection } from "../../types";
+import { HashMapLinkedNode, HashMapOptions, IterateDirection } from '../../types';
 /**
  * Because the implementation of HashMap relies on JavaScript's built-in objects and arrays,
  * these underlying structures have already dealt with dynamic expansion and hash collisions.
@@ -13,8 +13,8 @@ import { HashMapLinkedNode, HashMapOptions, IterateDirection } from "../../types
  */
 export declare class HashMapIterator<K, V> {
     readonly hashMap: HashMap<K, V>;
-    protected _node: HashMapLinkedNode<K, V>;
     readonly iterateDirection: IterateDirection;
+    protected _node: HashMapLinkedNode<K, V>;
     protected readonly _sentinel: HashMapLinkedNode<K, V>;
     /**
      * This is a constructor function for a linked list iterator in a HashMap data structure.
@@ -47,14 +47,12 @@ export declare class HashMapIterator<K, V> {
     next(): this;
 }
 export declare class HashMap<K = any, V = any> {
+    readonly OBJ_KEY_INDEX: symbol;
     protected _nodes: HashMapLinkedNode<K, V>[];
     protected _orgMap: Record<string, HashMapLinkedNode<K, V>>;
     protected _head: HashMapLinkedNode<K, V>;
     protected _tail: HashMapLinkedNode<K, V>;
     protected readonly _sentinel: HashMapLinkedNode<K, V>;
-    readonly OBJ_KEY_INDEX: symbol;
-    protected _size: number;
-    get size(): number;
     /**
      * The constructor initializes a HashMap object with an optional initial set of key-value pairs.
      * @param hashMap - The `hashMap` parameter is an optional parameter of type `HashMapOptions<[K,
@@ -62,6 +60,61 @@ export declare class HashMap<K = any, V = any> {
      * `K` represents the type of the key and `V` represents the
      */
     constructor(hashMap?: HashMapOptions<[K, V]>);
+    protected _size: number;
+    get size(): number;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function returns a new iterator object for a HashMap.
+     * @returns A new instance of the HashMapIterator class is being returned.
+     */
+    get begin(): HashMapIterator<K, V>;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function returns a new HashMapIterator object with the _sentinel value as both the start and
+     * end values.
+     * @returns A new instance of the HashMapIterator class is being returned.
+     */
+    get end(): HashMapIterator<K, V>;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The reverseBegin function returns a new HashMapIterator object that iterates over the elements of
+     * a HashMap in reverse order.
+     * @returns A new instance of the HashMapIterator class is being returned.
+     */
+    get reverseBegin(): HashMapIterator<K, V>;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The reverseEnd function returns a new HashMapIterator object that iterates over the elements of a
+     * HashMap in reverse order.
+     * @returns A new instance of the HashMapIterator class is being returned.
+     */
+    get reverseEnd(): HashMapIterator<K, V>;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function returns the key-value pair at the front of a data structure.
+     * @returns The front element of the data structure, represented as a tuple with a key (K) and a
+     * value (V).
+     */
+    get front(): [K, V] | undefined;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function returns the key-value pair at the end of a data structure.
+     * @returns The method is returning an array containing the key-value pair of the tail element in the
+     * data structure.
+     */
+    get back(): [K, V] | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -159,59 +212,6 @@ export declare class HashMap<K = any, V = any> {
      * The `clear` function clears all the elements in a data structure and resets its properties.
      */
     clear(): void;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function returns a new iterator object for a HashMap.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get begin(): HashMapIterator<K, V>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function returns a new HashMapIterator object with the _sentinel value as both the start and
-     * end values.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get end(): HashMapIterator<K, V>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The reverseBegin function returns a new HashMapIterator object that iterates over the elements of
-     * a HashMap in reverse order.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get reverseBegin(): HashMapIterator<K, V>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The reverseEnd function returns a new HashMapIterator object that iterates over the elements of a
-     * HashMap in reverse order.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get reverseEnd(): HashMapIterator<K, V>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function returns the key-value pair at the front of a data structure.
-     * @returns The front element of the data structure, represented as a tuple with a key (K) and a
-     * value (V).
-     */
-    get front(): [K, V] | undefined;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function returns the key-value pair at the end of a data structure.
-     * @returns The method is returning an array containing the key-value pair of the tail element in the
-     * data structure.
-     */
-    get back(): [K, V] | undefined;
     /**
      * Time Complexity: O(n), where n is the number of elements in the HashMap.
      * Space Complexity: O(1)

package/dist/data-structures/hash/hash-map.js

@@ -112,9 +112,6 @@ class HashMapIterator {
 }
 exports.HashMapIterator = HashMapIterator;
 class HashMap {
-    get size() {
-        return this._size;
-    }
     /**
      * The constructor initializes a HashMap object with an optional initial set of key-value pairs.
      * @param hashMap - The `hashMap` parameter is an optional parameter of type `HashMapOptions<[K,
@@ -122,9 +119,9 @@ class HashMap {
      * `K` represents the type of the key and `V` represents the
      */
     constructor(hashMap = []) {
+        this.OBJ_KEY_INDEX = Symbol('OBJ_KEY_INDEX');
         this._nodes = [];
         this._orgMap = {};
-        this.OBJ_KEY_INDEX = Symbol('OBJ_KEY_INDEX');
         this._size = 0;
         Object.setPrototypeOf(this._orgMap, null);
         this._sentinel = {};
@@ -133,6 +130,78 @@ class HashMap {
             this.set(el[0], el[1]);
         });
     }
+    get size() {
+        return this._size;
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function returns a new iterator object for a HashMap.
+     * @returns A new instance of the HashMapIterator class is being returned.
+     */
+    get begin() {
+        return new HashMapIterator(this._head, this._sentinel, this);
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function returns a new HashMapIterator object with the _sentinel value as both the start and
+     * end values.
+     * @returns A new instance of the HashMapIterator class is being returned.
+     */
+    get end() {
+        return new HashMapIterator(this._sentinel, this._sentinel, this);
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The reverseBegin function returns a new HashMapIterator object that iterates over the elements of
+     * a HashMap in reverse order.
+     * @returns A new instance of the HashMapIterator class is being returned.
+     */
+    get reverseBegin() {
+        return new HashMapIterator(this._tail, this._sentinel, this, 1 /* IterateDirection.REVERSE */);
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The reverseEnd function returns a new HashMapIterator object that iterates over the elements of a
+     * HashMap in reverse order.
+     * @returns A new instance of the HashMapIterator class is being returned.
+     */
+    get reverseEnd() {
+        return new HashMapIterator(this._sentinel, this._sentinel, this, 1 /* IterateDirection.REVERSE */);
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function returns the key-value pair at the front of a data structure.
+     * @returns The front element of the data structure, represented as a tuple with a key (K) and a
+     * value (V).
+     */
+    get front() {
+        if (this._size === 0)
+            return;
+        return [this._head.key, this._head.value];
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function returns the key-value pair at the end of a data structure.
+     * @returns The method is returning an array containing the key-value pair of the tail element in the
+     * data structure.
+     */
+    get back() {
+        if (this._size === 0)
+            return;
+        return [this._tail.key, this._tail.value];
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -340,75 +409,6 @@ class HashMap {
         this._size = 0;
         this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function returns a new iterator object for a HashMap.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get begin() {
-        return new HashMapIterator(this._head, this._sentinel, this);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function returns a new HashMapIterator object with the _sentinel value as both the start and
-     * end values.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get end() {
-        return new HashMapIterator(this._sentinel, this._sentinel, this);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The reverseBegin function returns a new HashMapIterator object that iterates over the elements of
-     * a HashMap in reverse order.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get reverseBegin() {
-        return new HashMapIterator(this._tail, this._sentinel, this, 1 /* IterateDirection.REVERSE */);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The reverseEnd function returns a new HashMapIterator object that iterates over the elements of a
-     * HashMap in reverse order.
-     * @returns A new instance of the HashMapIterator class is being returned.
-     */
-    get reverseEnd() {
-        return new HashMapIterator(this._sentinel, this._sentinel, this, 1 /* IterateDirection.REVERSE */);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function returns the key-value pair at the front of a data structure.
-     * @returns The front element of the data structure, represented as a tuple with a key (K) and a
-     * value (V).
-     */
-    get front() {
-        if (this._size === 0)
-            return;
-        return [this._head.key, this._head.value];
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function returns the key-value pair at the end of a data structure.
-     * @returns The method is returning an array containing the key-value pair of the tail element in the
-     * data structure.
-     */
-    get back() {
-        if (this._size === 0)
-            return;
-        return [this._tail.key, this._tail.value];
-    }
     /**
      * Time Complexity: O(n), where n is the number of elements in the HashMap.
      * Space Complexity: O(1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-list-typed",
-  "version": "1.45.0",
+  "version": "1.45.1",
   "description": "Linked List, Doubly Linked List, Singly Linked List. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {

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

@@ -5,10 +5,10 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import {BST, BSTNode} from './bst';
-import type {AVLTreeNodeNested, AVLTreeOptions, BiTreeDeleteResult, BTNKey} from '../../types';
-import {BTNCallback} from '../../types';
-import {IBinaryTree} from '../../interfaces';
+import { BST, BSTNode } from './bst';
+import type { AVLTreeNodeNested, AVLTreeOptions, BiTreeDeleteResult, BTNKey } from '../../types';
+import { BTNCallback } from '../../types';
+import { IBinaryTree } from '../../interfaces';
 
 export class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNested<V>> extends BSTNode<V, N> {
   height: number;
@@ -95,7 +95,7 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
   ): BiTreeDeleteResult<N>[] {
     if ((identifier as any) instanceof AVLTreeNode) callback = (node => node) as C;
     const deletedResults = super.delete(identifier, callback);
-    for (const {needBalanced} of deletedResults) {
+    for (const { needBalanced } of deletedResults) {
       if (needBalanced) {
         this._balancePath(needBalanced);
       }
@@ -118,7 +118,7 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
     destNode = this.ensureNotKey(destNode);
 
     if (srcNode && destNode) {
-      const {key, value, height} = destNode;
+      const { key, value, height } = destNode;
       const tempNode = this.createNode(key, value);
 
       if (tempNode) {
@@ -209,7 +209,7 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
       // Balance Restoration: If a balance issue is discovered after inserting a node, it requires balance restoration operations. Balance restoration includes four basic cases where rotation operations need to be performed to fix the balance:
       switch (
         this._balanceFactor(A) // second O(1)
-      ) {
+        ) {
         case -2:
           if (A && A.left) {
             if (this._balanceFactor(A.left) <= 0) {

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import {getMSB} from '../../utils';
+import { getMSB } from '../../utils';
 
 export class BinaryIndexedTree {
   protected readonly _freq: number;
@@ -17,10 +17,10 @@ export class BinaryIndexedTree {
    * @param  - - `frequency`: The default frequency value. It is optional and has a default
    * value of 0.
    */
-  constructor({frequency = 0, max}: {frequency?: number; max: number}) {
+  constructor({ frequency = 0, max }: { frequency?: number; max: number }) {
     this._freq = frequency;
     this._max = max;
-    this._freqMap = {0: 0};
+    this._freqMap = { 0: 0 };
     this._msb = getMSB(max);
     this._negativeCount = frequency < 0 ? max : 0;
   }

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

@@ -6,11 +6,11 @@
  * @license MIT License
  */
 
-import type {BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, BTNKey} from '../../types';
-import {BiTreeDeleteResult, DFSOrderPattern, FamilyPosition, IterationType} from '../../types';
-import {IBinaryTree} from '../../interfaces';
-import {trampoline} from '../../utils';
-import {Queue} from '../queue';
+import type { BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, BTNKey } from '../../types';
+import { BiTreeDeleteResult, DFSOrderPattern, FamilyPosition, IterationType } from '../../types';
+import { IBinaryTree } from '../../interfaces';
+import { trampoline } from '../../utils';
+import { Queue } from '../queue';
 
 /**
  * Represents a node in a binary tree.
@@ -107,7 +107,8 @@ export class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = BinaryTree
  * Represents a binary tree data structure.
  * @template N - The type of the binary tree's nodes.
  */
-export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>> implements IBinaryTree<V, N> {
+export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>>
+  implements IBinaryTree<V, N> {
   iterationType: IterationType = IterationType.ITERATIVE;
 
   /**
@@ -116,7 +117,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    */
   constructor(options?: BinaryTreeOptions) {
     if (options) {
-      const {iterationType = IterationType.ITERATIVE} = options;
+      const { iterationType = IterationType.ITERATIVE } = options;
       this.iterationType = iterationType;
     }
     this._size = 0;
@@ -315,7 +316,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
         // Handle the case when there's only one root node
         this._setRoot(null);
       } else {
-        const {familyPosition: fp} = curr;
+        const { familyPosition: fp } = curr;
         if (fp === FamilyPosition.LEFT || fp === FamilyPosition.ROOT_LEFT) {
           parent.left = curr.right;
         } else if (fp === FamilyPosition.RIGHT || fp === FamilyPosition.ROOT_RIGHT) {
@@ -330,7 +331,8 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
           const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
           orgCurrent = this._swap(curr, leftSubTreeRightMost);
           if (parentOfLeftSubTreeMax) {
-            if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost) parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
+            if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
+              parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
             else parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
             needBalanced = parentOfLeftSubTreeMax;
           }
@@ -339,7 +341,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     }
     this._size = this.size - 1;
 
-    deletedResult.push({deleted: orgCurrent, needBalanced});
+    deletedResult.push({ deleted: orgCurrent, needBalanced });
     return deletedResult;
   }
 
@@ -409,14 +411,14 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
 
       return _getMaxHeight(beginRoot);
     } else {
-      const stack: {node: N; depth: number}[] = [{node: beginRoot, depth: 0}];
+      const stack: { node: N; depth: number }[] = [{ node: beginRoot, depth: 0 }];
       let maxHeight = 0;
 
       while (stack.length > 0) {
-        const {node, depth} = stack.pop()!;
+        const { node, depth } = stack.pop()!;
 
-        if (node.left) stack.push({node: node.left, depth: depth + 1});
-        if (node.right) stack.push({node: node.right, depth: depth + 1});
+        if (node.left) stack.push({ node: node.left, depth: depth + 1 });
+        if (node.right) stack.push({ node: node.right, depth: depth + 1 });
 
         maxHeight = Math.max(maxHeight, depth);
       }
@@ -912,7 +914,10 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns The function `getLeftMost` returns the leftmost node (`N`) in the binary tree. If there
    * is no leftmost node, it returns `null` or `undefined` depending on the input.
    */
-  getLeftMost(beginRoot: BTNKey | N | null | undefined = this.root, iterationType = this.iterationType): N | null | undefined {
+  getLeftMost(
+    beginRoot: BTNKey | N | null | undefined = this.root,
+    iterationType = this.iterationType
+  ): N | null | undefined {
     beginRoot = this.ensureNotKey(beginRoot);
 
     if (!beginRoot) return beginRoot;
@@ -955,7 +960,10 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns The function `getRightMost` returns the rightmost node (`N`) in a binary tree. If there
    * is no rightmost node, it returns `null` or `undefined`, depending on the input.
    */
-  getRightMost(beginRoot: BTNKey | N | null | undefined = this.root, iterationType = this.iterationType): N | null | undefined {
+  getRightMost(
+    beginRoot: BTNKey | N | null | undefined = this.root,
+    iterationType = this.iterationType
+  ): N | null | undefined {
     // TODO support get right most by passing key in
     beginRoot = this.ensureNotKey(beginRoot);
     if (!beginRoot) return beginRoot;
@@ -1284,7 +1292,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
       _traverse(beginRoot);
     } else {
       // 0: visit, 1: print
-      const stack: {opt: 0 | 1; node: N | null | undefined}[] = [{opt: 0, node: beginRoot}];
+      const stack: { opt: 0 | 1; node: N | null | undefined }[] = [{ opt: 0, node: beginRoot }];
 
       while (stack.length > 0) {
         const cur = stack.pop();
@@ -1299,24 +1307,24 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
         } else {
           switch (pattern) {
             case 'in':
-              cur.node && stack.push({opt: 0, node: cur.node.right});
-              stack.push({opt: 1, node: cur.node});
-              cur.node && stack.push({opt: 0, node: cur.node.left});
+              cur.node && stack.push({ opt: 0, node: cur.node.right });
+              stack.push({ opt: 1, node: cur.node });
+              cur.node && stack.push({ opt: 0, node: cur.node.left });
               break;
             case 'pre':
-              cur.node && stack.push({opt: 0, node: cur.node.right});
-              cur.node && stack.push({opt: 0, node: cur.node.left});
-              stack.push({opt: 1, node: cur.node});
+              cur.node && stack.push({ opt: 0, node: cur.node.right });
+              cur.node && stack.push({ opt: 0, node: cur.node.left });
+              stack.push({ opt: 1, node: cur.node });
               break;
             case 'post':
-              stack.push({opt: 1, node: cur.node});
-              cur.node && stack.push({opt: 0, node: cur.node.right});
-              cur.node && stack.push({opt: 0, node: cur.node.left});
+              stack.push({ opt: 1, node: cur.node });
+              cur.node && stack.push({ opt: 0, node: cur.node.right });
+              cur.node && stack.push({ opt: 0, node: cur.node.left });
               break;
             default:
-              cur.node && stack.push({opt: 0, node: cur.node.right});
-              stack.push({opt: 1, node: cur.node});
-              cur.node && stack.push({opt: 0, node: cur.node.left});
+              cur.node && stack.push({ opt: 0, node: cur.node.right });
+              stack.push({ opt: 1, node: cur.node });
+              cur.node && stack.push({ opt: 0, node: cur.node.left });
               break;
           }
         }
@@ -1686,7 +1694,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns The `*[Symbol.iterator]` method returns a generator object that yields the keys of the
    * binary tree nodes in a specific order.
    */
-  *[Symbol.iterator](node = this.root): Generator<BTNKey, void, undefined> {
+  * [Symbol.iterator](node = this.root): Generator<BTNKey, void, undefined> {
     if (!node) {
       return;
     }
@@ -1798,7 +1806,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     destNode = this.ensureNotKey(destNode);
 
     if (srcNode && destNode) {
-      const {key, value} = destNode;
+      const { key, value } = destNode;
       const tempNode = this.createNode(key, value);
 
       if (tempNode) {

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

@@ -5,11 +5,11 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type {BSTComparator, BSTNodeNested, BSTOptions, BTNCallback, BTNKey} from '../../types';
-import {CP, IterationType} from '../../types';
-import {BinaryTree, BinaryTreeNode} from './binary-tree';
-import {IBinaryTree} from '../../interfaces';
-import {Queue} from '../queue';
+import type { BSTComparator, BSTNodeNested, BSTOptions, BTNCallback, BTNKey } from '../../types';
+import { CP, IterationType } from '../../types';
+import { BinaryTree, BinaryTreeNode } from './binary-tree';
+import { IBinaryTree } from '../../interfaces';
+import { Queue } from '../queue';
 
 export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extends BinaryTreeNode<V, N> {
   override parent?: N;
@@ -62,7 +62,9 @@ export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extend
   }
 }
 
-export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>> extends BinaryTree<V, N> implements IBinaryTree<V, N> {
+export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>>
+  extends BinaryTree<V, N>
+  implements IBinaryTree<V, N> {
   /**
    * The constructor function initializes a binary search tree with an optional comparator function.
    * @param {BSTOptions} [options] - An optional object that contains additional configuration options
@@ -72,7 +74,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     super(options);
     this._root = undefined;
     if (options !== undefined) {
-      const {comparator} = options;
+      const { comparator } = options;
       if (comparator !== undefined) {
         this._comparator = comparator;
       }
@@ -225,7 +227,9 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     }
 
     const inserted: (N | undefined)[] = [];
-    const combinedArr: [BTNKey | N, V][] = keysOrNodes.map((value: BTNKey | N, index) => [value, data?.[index]] as [BTNKey | N, V]);
+    const combinedArr: [BTNKey | N, V][] = keysOrNodes.map(
+      (value: BTNKey | N, index) => [value, data?.[index]] as [BTNKey | N, V]
+    );
 
     let sorted = [];
 

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

@@ -6,12 +6,23 @@
  * @license MIT License
  */
 
-import {BiTreeDeleteResult, BTNCallback, BTNKey, IterationType, RBTNColor, RBTreeOptions, RedBlackTreeNodeNested} from '../../types';
-import {BST, BSTNode} from './bst';
-import {IBinaryTree} from '../../interfaces';
-import {BinaryTreeNode} from './binary-tree';
-
-export class RedBlackTreeNode<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTreeNodeNested<V>> extends BSTNode<V, N> {
+import {
+  BiTreeDeleteResult,
+  BTNCallback,
+  BTNKey,
+  IterationType,
+  RBTNColor,
+  RBTreeOptions,
+  RedBlackTreeNodeNested
+} from '../../types';
+import { BST, BSTNode } from './bst';
+import { IBinaryTree } from '../../interfaces';
+import { BinaryTreeNode } from './binary-tree';
+
+export class RedBlackTreeNode<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTreeNodeNested<V>> extends BSTNode<
+  V,
+  N
+> {
   color: RBTNColor;
 
   constructor(key: BTNKey, value?: V, color: RBTNColor = RBTNColor.BLACK) {

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

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 
-import type {SegmentTreeNodeVal} from '../../types';
+import type { SegmentTreeNodeVal } from '../../types';
 
 export class SegmentTreeNode {
   start = 0;