min-heap-typed 1.53.8 → 1.54.0

package/dist/data-structures/base/iterable-entry-base.js

@@ -65,7 +65,7 @@ class IterableEntryBase {
     every(predicate, thisArg) {
         let index = 0;
         for (const item of this) {
-            if (!predicate.call(thisArg, item[1], item[0], index++, this)) {
+            if (!predicate.call(thisArg, item[0], item[1], index++, this)) {
                 return false;
             }
         }
@@ -89,7 +89,7 @@ class IterableEntryBase {
     some(predicate, thisArg) {
         let index = 0;
         for (const item of this) {
-            if (predicate.call(thisArg, item[1], item[0], index++, this)) {
+            if (predicate.call(thisArg, item[0], item[1], index++, this)) {
                 return true;
             }
         }
@@ -112,7 +112,7 @@ class IterableEntryBase {
         let index = 0;
         for (const item of this) {
             const [key, value] = item;
-            callbackfn.call(thisArg, value, key, index++, this);
+            callbackfn.call(thisArg, key, value, index++, this);
         }
     }
     /**
@@ -136,7 +136,7 @@ class IterableEntryBase {
         let index = 0;
         for (const item of this) {
             const [key, value] = item;
-            if (callbackfn.call(thisArg, value, key, index++, this))
+            if (callbackfn.call(thisArg, key, value, index++, this))
                 return item;
         }
         return;

package/dist/data-structures/binary-tree/avl-tree-multi-map.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNOptKeyOrNode, BTNRep, IterationType } from '../../types';
+import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNOptKeyOrNode, BTNRep, EntryCallback, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class AVLTreeMultiMapNode<K = any, V = any, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNodeNested<K, V>> extends AVLTreeNode<K, V, NODE> {
@@ -20,23 +20,11 @@ export declare class AVLTreeMultiMapNode<K = any, V = any, NODE extends AVLTreeM
      * parameter when creating a new instance of the `BinaryTreeNode` class.
      */
     constructor(key: K, value?: V, count?: number);
-    protected _count: number;
-    /**
-     * The function returns the value of the protected variable _count.
-     * @returns The count property of the object, which is of type number.
-     */
-    get count(): number;
-    /**
-     * The above function sets the value of the count property.
-     * @param {number} value - The value parameter is of type number, which means it can accept any
-     * numeric value.
-     */
-    set count(value: number);
 }
 /**
  * The only distinction between a AVLTreeMultiMap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export declare class AVLTreeMultiMap<K = any, V = any, R = object, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNodeNested<K, V>>, TREE extends AVLTreeMultiMap<K, V, R, NODE, TREE> = AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMapNested<K, V, R, NODE>>> extends AVLTree<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
+export declare class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR = object, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNodeNested<K, V>>, TREE extends AVLTreeMultiMap<K, V, R, MK, MV, MR, NODE, TREE> = AVLTreeMultiMap<K, V, R, MK, MV, MR, NODE, AVLTreeMultiMapNested<K, V, R, MK, MV, MR, NODE>>> extends AVLTree<K, V, R, MK, MV, MR, NODE, TREE> implements IBinaryTree<K, V, R, MK, MV, MR, NODE, TREE> {
     /**
      * The constructor initializes a new AVLTreeMultiMap object with optional initial elements.
      * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
@@ -90,19 +78,6 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = object, NODE extends
      * an instance of the `AVLTreeMultiMapNode` class.
      */
     isNode(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): keyNodeEntryOrRaw is NODE;
-    /**
-     * The function `keyValueNodeEntryRawToNodeAndValue` converts a key, value, entry, or raw element into
-     * a node object.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
-     * `keyNodeEntryOrRaw` parameter can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `override` function. It represents the value associated with the key in the data structure. If no
-     * value is provided, it will default to `undefined`.
-     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
-     * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
-     * @returns either a NODE object or undefined.
-     */
-    protected _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V, count?: number): [NODE | undefined, V | undefined];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -170,6 +145,38 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = object, NODE extends
      * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
      */
     clone(): TREE;
+    /**
+     * The `map` function in TypeScript overrides the default behavior to create a new AVLTreeMultiMap
+     * with modified entries based on a provided callback.
+     * @param callback - The `callback` parameter is a function that will be called for each entry in the
+     * AVLTreeMultiMap. It takes four arguments:
+     * @param [options] - The `options` parameter in the `override map` function is of type
+     * `AVLTreeMultiMapOptions<MK, MV, MR>`. This parameter allows you to provide additional
+     * configuration options when creating a new `AVLTreeMultiMap` instance within the `map` function.
+     * These options
+     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
+     * the value of `this` when executing the `callback` function. It allows you to set the context
+     * (value of `this`) for the callback function. This can be useful when you want to access properties
+     * or
+     * @returns The `map` method is returning a new `AVLTreeMultiMap` instance with the entries
+     * transformed by the provided `callback` function. Each entry in the original tree is passed to the
+     * `callback` function along with the index and the original tree itself. The transformed entries are
+     * then added to the new `AVLTreeMultiMap` instance, which is returned at the end.
+     */
+    map<MK, MV, MR>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: AVLTreeMultiMapOptions<MK, MV, MR>, thisArg?: any): AVLTreeMultiMap<MK, MV, MR>;
+    /**
+     * The function `keyValueNodeEntryRawToNodeAndValue` converts a key, value, entry, or raw element into
+     * a node object.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
+     * `keyNodeEntryOrRaw` parameter can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
+     * `override` function. It represents the value associated with the key in the data structure. If no
+     * value is provided, it will default to `undefined`.
+     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
+     * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
+     * @returns either a NODE object or undefined.
+     */
+    protected _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V, count?: number): [NODE | undefined, V | undefined];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

package/dist/data-structures/binary-tree/avl-tree-multi-map.js

@@ -15,24 +15,8 @@ class AVLTreeMultiMapNode extends avl_tree_1.AVLTreeNode {
      */
     constructor(key, value, count = 1) {
         super(key, value);
-        this._count = 1;
         this.count = count;
     }
-    /**
-     * The function returns the value of the protected variable _count.
-     * @returns The count property of the object, which is of type number.
-     */
-    get count() {
-        return this._count;
-    }
-    /**
-     * The above function sets the value of the count property.
-     * @param {number} value - The value parameter is of type number, which means it can accept any
-     * numeric value.
-     */
-    set count(value) {
-        this._count = value;
-    }
 }
 exports.AVLTreeMultiMapNode = AVLTreeMultiMapNode;
 /**
@@ -96,7 +80,7 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      * object.
      */
     createTree(options) {
-        return new AVLTreeMultiMap([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, extractComparable: this._extractComparable, toEntryFn: this._toEntryFn, isReverse: this._isReverse }, options));
+        return new AVLTreeMultiMap([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, specifyComparable: this._specifyComparable, toEntryFn: this._toEntryFn, isReverse: this._isReverse }, options));
     }
     /**
      * The function checks if the input is an instance of AVLTreeMultiMapNode.
@@ -108,40 +92,6 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
     isNode(keyNodeEntryOrRaw) {
         return keyNodeEntryOrRaw instanceof AVLTreeMultiMapNode;
     }
-    /**
-     * The function `keyValueNodeEntryRawToNodeAndValue` converts a key, value, entry, or raw element into
-     * a node object.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
-     * `keyNodeEntryOrRaw` parameter can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `override` function. It represents the value associated with the key in the data structure. If no
-     * value is provided, it will default to `undefined`.
-     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
-     * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
-     * @returns either a NODE object or undefined.
-     */
-    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count = 1) {
-        if (keyNodeEntryOrRaw === undefined || keyNodeEntryOrRaw === null)
-            return [undefined, undefined];
-        if (this.isNode(keyNodeEntryOrRaw))
-            return [keyNodeEntryOrRaw, value];
-        if (this.isEntry(keyNodeEntryOrRaw)) {
-            const [key, entryValue] = keyNodeEntryOrRaw;
-            if (key === undefined || key === null)
-                return [undefined, undefined];
-            const finalValue = value !== null && value !== void 0 ? value : entryValue;
-            return [this.createNode(key, finalValue, count), finalValue];
-        }
-        if (this.isRaw(keyNodeEntryOrRaw)) {
-            const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
-            const finalValue = value !== null && value !== void 0 ? value : entryValue;
-            if (this.isKey(key))
-                return [this.createNode(key, finalValue, count), finalValue];
-        }
-        if (this.isKey(keyNodeEntryOrRaw))
-            return [this.createNode(keyNodeEntryOrRaw, value, count), value];
-        return [undefined, undefined];
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -206,7 +156,7 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
         else {
             if (!curr.left) {
                 if (!parent) {
-                    if (curr.right !== undefined)
+                    if (curr.right !== undefined && curr.right !== null)
                         this._setRoot(curr.right);
                 }
                 else {
@@ -329,6 +279,66 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
             cloned._store = this._store;
         return cloned;
     }
+    /**
+     * The `map` function in TypeScript overrides the default behavior to create a new AVLTreeMultiMap
+     * with modified entries based on a provided callback.
+     * @param callback - The `callback` parameter is a function that will be called for each entry in the
+     * AVLTreeMultiMap. It takes four arguments:
+     * @param [options] - The `options` parameter in the `override map` function is of type
+     * `AVLTreeMultiMapOptions<MK, MV, MR>`. This parameter allows you to provide additional
+     * configuration options when creating a new `AVLTreeMultiMap` instance within the `map` function.
+     * These options
+     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
+     * the value of `this` when executing the `callback` function. It allows you to set the context
+     * (value of `this`) for the callback function. This can be useful when you want to access properties
+     * or
+     * @returns The `map` method is returning a new `AVLTreeMultiMap` instance with the entries
+     * transformed by the provided `callback` function. Each entry in the original tree is passed to the
+     * `callback` function along with the index and the original tree itself. The transformed entries are
+     * then added to the new `AVLTreeMultiMap` instance, which is returned at the end.
+     */
+    map(callback, options, thisArg) {
+        const newTree = new AVLTreeMultiMap([], options);
+        let index = 0;
+        for (const [key, value] of this) {
+            newTree.add(callback.call(thisArg, key, value, index++, this));
+        }
+        return newTree;
+    }
+    /**
+     * The function `keyValueNodeEntryRawToNodeAndValue` converts a key, value, entry, or raw element into
+     * a node object.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
+     * `keyNodeEntryOrRaw` parameter can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
+     * `override` function. It represents the value associated with the key in the data structure. If no
+     * value is provided, it will default to `undefined`.
+     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
+     * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
+     * @returns either a NODE object or undefined.
+     */
+    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count = 1) {
+        if (keyNodeEntryOrRaw === undefined || keyNodeEntryOrRaw === null)
+            return [undefined, undefined];
+        if (this.isNode(keyNodeEntryOrRaw))
+            return [keyNodeEntryOrRaw, value];
+        if (this.isEntry(keyNodeEntryOrRaw)) {
+            const [key, entryValue] = keyNodeEntryOrRaw;
+            if (key === undefined || key === null)
+                return [undefined, undefined];
+            const finalValue = value !== null && value !== void 0 ? value : entryValue;
+            return [this.createNode(key, finalValue, count), finalValue];
+        }
+        if (this.isRaw(keyNodeEntryOrRaw)) {
+            const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
+            const finalValue = value !== null && value !== void 0 ? value : entryValue;
+            if (this.isKey(key))
+                return [this.createNode(key, finalValue, count), finalValue];
+        }
+        if (this.isKey(keyNodeEntryOrRaw))
+            return [this.createNode(keyNodeEntryOrRaw, value, count), value];
+        return [undefined, undefined];
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

package/dist/data-structures/binary-tree/avl-tree.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeleteResult, BSTNOptKeyOrNode, BTNRep } from '../../types';
+import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeleteResult, BSTNOptKeyOrNode, BTNRep, EntryCallback } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 export declare class AVLTreeNode<K = any, V = any, NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
     /**
@@ -18,18 +18,6 @@ export declare class AVLTreeNode<K = any, V = any, NODE extends AVLTreeNode<K, V
      * value associated with the key in the constructor.
      */
     constructor(key: K, value?: V);
-    protected _height: number;
-    /**
-     * The function returns the value of the height property.
-     * @returns The height of the object.
-     */
-    get height(): number;
-    /**
-     * The above function sets the value of the height property.
-     * @param {number} value - The value parameter is a number that represents the new height value to be
-     * set.
-     */
-    set height(value: number);
 }
 /**
  * 1. Height-Balanced: Each node's left and right subtrees differ in height by no more than one.
@@ -40,7 +28,7 @@ export declare class AVLTreeNode<K = any, V = any, NODE extends AVLTreeNode<K, V
  * 6. Complex Insertions and Deletions: Due to rebalancing, these operations are more complex than in a regular BST.
  * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.
  */
-export declare class AVLTree<K = any, V = any, R = object, NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>, TREE extends AVLTree<K, V, R, NODE, TREE> = AVLTree<K, V, R, NODE, AVLTreeNested<K, V, R, NODE>>> extends BST<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
+export declare class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = object, NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>, TREE extends AVLTree<K, V, R, MK, MV, MR, NODE, TREE> = AVLTree<K, V, R, MK, MV, MR, NODE, AVLTreeNested<K, V, R, MK, MV, MR, NODE>>> extends BST<K, V, R, MK, MV, MR, NODE, TREE> implements IBinaryTree<K, V, R, MK, MV, MR, NODE, TREE> {
     /**
      * This is a constructor function for an AVLTree class that initializes the tree with keys, nodes,
      * entries, or raw elements.
@@ -107,6 +95,7 @@ export declare class AVLTree<K = any, V = any, R = object, NODE extends AVLTreeN
      * `deletedResults`, which is an array of `BinaryTreeDeleteResult` objects.
      */
     delete(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): BinaryTreeDeleteResult<NODE>[];
+    map(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: AVLTreeOptions<MK, MV, MR>, thisArg?: any): AVLTree<MK, MV, MR>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

package/dist/data-structures/binary-tree/avl-tree.js

@@ -20,22 +20,6 @@ class AVLTreeNode extends bst_1.BSTNode {
      */
     constructor(key, value) {
         super(key, value);
-        this._height = 0;
-    }
-    /**
-     * The function returns the value of the height property.
-     * @returns The height of the object.
-     */
-    get height() {
-        return this._height;
-    }
-    /**
-     * The above function sets the value of the height property.
-     * @param {number} value - The value parameter is a number that represents the new height value to be
-     * set.
-     */
-    set height(value) {
-        this._height = value;
     }
 }
 exports.AVLTreeNode = AVLTreeNode;
@@ -85,7 +69,7 @@ class AVLTree extends bst_1.BST {
      * @returns a new AVLTree object.
      */
     createTree(options) {
-        return new AVLTree([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, extractComparable: this._extractComparable, toEntryFn: this._toEntryFn, isReverse: this._isReverse }, options));
+        return new AVLTree([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, specifyComparable: this._specifyComparable, toEntryFn: this._toEntryFn, isReverse: this._isReverse }, options));
     }
     /**
      * The function checks if the input is an instance of AVLTreeNode.
@@ -140,6 +124,14 @@ class AVLTree extends bst_1.BST {
         }
         return deletedResults;
     }
+    map(callback, options, thisArg) {
+        const newTree = new AVLTree([], options);
+        let index = 0;
+        for (const [key, value] of this) {
+            newTree.add(callback.call(thisArg, key, value, index++, this));
+        }
+        return newTree;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -224,7 +216,8 @@ class AVLTree extends bst_1.BST {
     _balanceLL(A) {
         const parentOfA = A.parent;
         const B = A.left;
-        A.parent = B;
+        if (B !== null)
+            A.parent = B;
         if (B && B.right) {
             B.right.parent = A;
         }
@@ -265,13 +258,14 @@ class AVLTree extends bst_1.BST {
         if (B) {
             C = B.right;
         }
-        if (A)
+        if (A && C !== null)
             A.parent = C;
-        if (B)
+        if (B && C !== null)
             B.parent = C;
         if (C) {
             if (C.left) {
-                C.left.parent = B;
+                if (B !== null)
+                    C.left.parent = B;
             }
             if (C.right) {
                 C.right.parent = A;
@@ -315,7 +309,8 @@ class AVLTree extends bst_1.BST {
     _balanceRR(A) {
         const parentOfA = A.parent;
         const B = A.right;
-        A.parent = B;
+        if (B !== null)
+            A.parent = B;
         if (B) {
             if (B.left) {
                 B.left.parent = A;
@@ -358,15 +353,17 @@ class AVLTree extends bst_1.BST {
         if (B) {
             C = B.left;
         }
-        A.parent = C;
-        if (B)
+        if (C !== null)
+            A.parent = C;
+        if (B && C !== null)
             B.parent = C;
         if (C) {
             if (C.left) {
                 C.left.parent = A;
             }
             if (C.right) {
-                C.right.parent = B;
+                if (B !== null)
+                    C.right.parent = B;
             }
             C.parent = parentOfA;
         }

package/dist/data-structures/binary-tree/binary-tree.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BinaryTreePrintOptions, BTNEntry, BTNRep, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, NodeCallback, NodeDisplayLayout, NodePredicate, OptNodeOrNull, ToEntryFn } from '../../types';
+import { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BinaryTreePrintOptions, BTNEntry, BTNRep, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, NodeCallback, NodeDisplayLayout, NodePredicate, OptNodeOrNull, type RBTNColor, ToEntryFn } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { IterableEntryBase } from '../base';
 import { Range } from '../../common';
@@ -19,12 +19,21 @@ export declare class BinaryTreeNode<K = any, V = any, NODE extends BinaryTreeNod
     value?: V;
     parent?: NODE;
     constructor(key: K, value?: V);
-    protected _left?: OptNodeOrNull<NODE>;
+    _left?: OptNodeOrNull<NODE>;
     get left(): OptNodeOrNull<NODE>;
     set left(v: OptNodeOrNull<NODE>);
-    protected _right?: OptNodeOrNull<NODE>;
+    _right?: OptNodeOrNull<NODE>;
     get right(): OptNodeOrNull<NODE>;
     set right(v: OptNodeOrNull<NODE>);
+    _height: number;
+    get height(): number;
+    set height(value: number);
+    _color: RBTNColor;
+    get color(): RBTNColor;
+    set color(value: RBTNColor);
+    _count: number;
+    get count(): number;
+    set count(value: number);
     get familyPosition(): FamilyPosition;
 }
 /**
@@ -34,7 +43,7 @@ export declare class BinaryTreeNode<K = any, V = any, NODE extends BinaryTreeNod
  * 4. Subtrees: Each child of a node forms the root of a subtree.
  * 5. Leaf Nodes: Nodes without children are leaves.
  */
-export declare class BinaryTree<K = any, V = any, R = object, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>, TREE extends BinaryTree<K, V, R, NODE, TREE> = BinaryTree<K, V, R, NODE, BinaryTreeNested<K, V, R, NODE>>> extends IterableEntryBase<K, V | undefined> implements IBinaryTree<K, V, R, NODE, TREE> {
+export declare class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = object, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>, TREE extends BinaryTree<K, V, R, MK, MV, MR, NODE, TREE> = BinaryTree<K, V, R, MK, MV, MR, NODE, BinaryTreeNested<K, V, R, MK, MV, MR, NODE>>> extends IterableEntryBase<K, V | undefined> implements IBinaryTree<K, V, R, MK, MV, MR, NODE, TREE> {
     iterationType: IterationType;
     /**
      * The constructor initializes a binary tree with optional options and adds keys, nodes, entries, or
@@ -59,6 +68,9 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
     protected _toEntryFn?: ToEntryFn<K, V, R>;
     get toEntryFn(): ToEntryFn<K, V, R> | undefined;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function creates a new binary tree node with a specified key and optional value.
      * @param {K} key - The `key` parameter is the key of the node being created in the binary tree.
      * @param {V} [value] - The `value` parameter in the `createNode` function is optional, meaning it is
@@ -660,18 +672,22 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `map` function iterates over key-value pairs in a tree data structure, applies a callback
-     * function to each value, and returns a new tree with the updated values.
-     * @param callback - The `callback` parameter in the `map` method is a function that will be called
-     * on each entry in the tree. It takes four arguments:
-     * @param {any} [thisArg] - The `thisArg` parameter in the `map` function is an optional parameter
-     * that specifies the value to be passed as `this` when executing the callback function. If provided,
-     * the `thisArg` value will be used as the `this` value within the callback function. If `thisArg
-     * @returns The `map` method is returning a new tree with the entries modified by the provided
-     * callback function. Each entry in the original tree is passed to the callback function, and the
-     * result of the callback function is added to the new tree.
-     */
-    map(callback: EntryCallback<K, V | undefined, V>, thisArg?: any): TREE;
+     * The `map` function in TypeScript creates a new BinaryTree by applying a callback function to each
+     * entry in the original BinaryTree.
+     * @param callback - A function that will be called for each entry in the current binary tree. It
+     * takes the key, value (which can be undefined), and an array containing the mapped key and value as
+     * arguments.
+     * @param [options] - The `options` parameter in the `map` method is of type `BinaryTreeOptions<MK,
+     * MV, MR>`. It is an optional parameter that allows you to specify additional options for the binary
+     * tree being created during the mapping process. These options could include things like custom
+     * comparators, initial
+     * @param {any} [thisArg] - The `thisArg` parameter in the `map` method is used to specify the value
+     * of `this` when executing the `callback` function. It allows you to set the context (value of
+     * `this`) within the callback function. If `thisArg` is provided, it will be passed
+     * @returns The `map` function is returning a new `BinaryTree` instance filled with entries that are
+     * the result of applying the provided `callback` function to each entry in the original tree.
+     */
+    map(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: BinaryTreeOptions<MK, MV, MR>, thisArg?: any): BinaryTree<MK, MV, MR>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

package/dist/data-structures/binary-tree/binary-tree.js

@@ -19,6 +19,9 @@ const common_1 = require("../../common");
  */
 class BinaryTreeNode {
     constructor(key, value) {
+        this._height = 0;
+        this._color = 'BLACK';
+        this._count = 1;
         this.key = key;
         this.value = value;
     }
@@ -40,6 +43,24 @@ class BinaryTreeNode {
         }
         this._right = v;
     }
+    get height() {
+        return this._height;
+    }
+    set height(value) {
+        this._height = value;
+    }
+    get color() {
+        return this._color;
+    }
+    set color(value) {
+        this._color = value;
+    }
+    get count() {
+        return this._count;
+    }
+    set count(value) {
+        this._count = value;
+    }
     get familyPosition() {
         const that = this;
         if (!this.parent) {
@@ -113,6 +134,9 @@ class BinaryTree extends base_1.IterableEntryBase {
         return this._toEntryFn;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function creates a new binary tree node with a specified key and optional value.
      * @param {K} key - The `key` parameter is the key of the node being created in the binary tree.
      * @param {V} [value] - The `value` parameter in the `createNode` function is optional, meaning it is
@@ -1499,7 +1523,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         const newTree = this.createTree();
         let index = 0;
         for (const [key, value] of this) {
-            if (predicate.call(thisArg, value, key, index++, this)) {
+            if (predicate.call(thisArg, key, value, index++, this)) {
                 newTree.add([key, value]);
             }
         }
@@ -1509,34 +1533,29 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `map` function iterates over key-value pairs in a tree data structure, applies a callback
-     * function to each value, and returns a new tree with the updated values.
-     * @param callback - The `callback` parameter in the `map` method is a function that will be called
-     * on each entry in the tree. It takes four arguments:
-     * @param {any} [thisArg] - The `thisArg` parameter in the `map` function is an optional parameter
-     * that specifies the value to be passed as `this` when executing the callback function. If provided,
-     * the `thisArg` value will be used as the `this` value within the callback function. If `thisArg
-     * @returns The `map` method is returning a new tree with the entries modified by the provided
-     * callback function. Each entry in the original tree is passed to the callback function, and the
-     * result of the callback function is added to the new tree.
+     * The `map` function in TypeScript creates a new BinaryTree by applying a callback function to each
+     * entry in the original BinaryTree.
+     * @param callback - A function that will be called for each entry in the current binary tree. It
+     * takes the key, value (which can be undefined), and an array containing the mapped key and value as
+     * arguments.
+     * @param [options] - The `options` parameter in the `map` method is of type `BinaryTreeOptions<MK,
+     * MV, MR>`. It is an optional parameter that allows you to specify additional options for the binary
+     * tree being created during the mapping process. These options could include things like custom
+     * comparators, initial
+     * @param {any} [thisArg] - The `thisArg` parameter in the `map` method is used to specify the value
+     * of `this` when executing the `callback` function. It allows you to set the context (value of
+     * `this`) within the callback function. If `thisArg` is provided, it will be passed
+     * @returns The `map` function is returning a new `BinaryTree` instance filled with entries that are
+     * the result of applying the provided `callback` function to each entry in the original tree.
      */
-    map(callback, thisArg) {
-        const newTree = this.createTree();
+    map(callback, options, thisArg) {
+        const newTree = new BinaryTree([], options);
         let index = 0;
         for (const [key, value] of this) {
-            newTree.add([key, callback.call(thisArg, value, key, index++, this)]);
+            newTree.add(callback.call(thisArg, key, value, index++, this));
         }
         return newTree;
     }
-    // // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
-    // // map<NV>(callback: (entry: [K, V | undefined], tree: this) => NV) {
-    // //   const newTree = this.createTree();
-    // //   for (const [key, value] of this) {
-    // //     newTree.add(key, callback([key, value], this));
-    // //   }
-    // //   return newTree;
-    // // }
-    //
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -1568,7 +1587,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         if (opts.isShowRedBlackNIL)
             output += `S for Sentinel Node(NIL)\n`;
         const display = (root) => {
-            const [lines, , ,] = this._displayAux(root, opts);
+            const [lines, ,] = this._displayAux(root, opts);
             let paragraph = '';
             for (const line of lines) {
                 paragraph += line + '\n';