stack-typed 1.53.7 → 1.53.9

package/dist/common/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Range = exports.DFSOperation = void 0;
+const utils_1 = require("../utils");
 var DFSOperation;
 (function (DFSOperation) {
     DFSOperation[DFSOperation["VISIT"] = 0] = "VISIT";
@@ -12,6 +13,10 @@ class Range {
         this.high = high;
         this.includeLow = includeLow;
         this.includeHigh = includeHigh;
+        if (!((0, utils_1.isComparable)(low) && (0, utils_1.isComparable)(high)))
+            throw new RangeError('low or high is not comparable');
+        if (low > high)
+            throw new RangeError('low must be less than or equal to high');
     }
     // Determine whether a key is within the range
     isInRange(key, comparator) {

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 { 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> {
@@ -36,7 +36,7 @@ export declare class AVLTreeMultiMapNode<K = any, V = any, NODE extends AVLTreeM
 /**
  * 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, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNodeNested<K, V>>> extends AVLTree<K, V, R, NODE> implements IBinaryTree<K, V, R, NODE> {
     /**
      * The constructor initializes a new AVLTreeMultiMap object with optional initial elements.
      * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
@@ -81,7 +81,7 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = object, NODE extends
      * @returns a new instance of the AVLTreeMultiMap class, with the specified options, as a TREE
      * object.
      */
-    createTree(options?: AVLTreeMultiMapOptions<K, V, R>): TREE;
+    createTree(options?: AVLTreeMultiMapOptions<K, V, R>): AVLTreeMultiMap<K, V, R, NODE>;
     /**
      * The function checks if the input is an instance of AVLTreeMultiMapNode.
      * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
@@ -90,19 +90,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.
-     */
-    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V, count?: number): [NODE | undefined, V | undefined];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -169,7 +156,39 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = object, NODE extends
      * The function overrides the clone method to create a deep copy of a tree object.
      * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
      */
-    clone(): TREE;
+    clone(): AVLTreeMultiMap<K, V, R, NODE>;
+    /**
+     * 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, AVLTreeMultiMapNode<MK, MV, AVLTreeMultiMapNodeNested<MK, MV>>>;
+    /**
+     * 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

@@ -95,8 +95,9 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      * @returns a new instance of the AVLTreeMultiMap class, with the specified options, as a TREE
      * object.
      */
+    // @ts-ignore
     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 +109,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)
@@ -160,7 +127,7 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      * @returns a boolean value.
      */
     add(keyNodeEntryOrRaw, value, count = 1) {
-        const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
+        const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
         if (newNode === undefined)
             return false;
         const orgNodeCount = (newNode === null || newNode === void 0 ? void 0 : newNode.count) || 0;
@@ -319,6 +286,7 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      * The function overrides the clone method to create a deep copy of a tree object.
      * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
      */
+    // @ts-ignore
     clone() {
         const cloned = this.createTree();
         if (this._isMapMode)
@@ -329,6 +297,67 @@ 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.
+     */
+    // @ts-ignore
+    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 { 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> {
     /**
@@ -40,7 +40,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, NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>> extends BST<K, V, R, NODE> implements IBinaryTree<K, V, R, NODE> {
     /**
      * This is a constructor function for an AVLTree class that initializes the tree with keys, nodes,
      * entries, or raw elements.
@@ -64,13 +64,16 @@ export declare class AVLTree<K = any, V = any, R = object, NODE extends AVLTreeN
      */
     createNode(key: K, value?: V): NODE;
     /**
-     * The function creates a new AVL tree with the specified options and returns it.
-     * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be
-     * passed to the `createTree` function. It is used to customize the behavior of the AVL tree that is
-     * being created.
-     * @returns a new AVLTree object.
+     * The function `createTree` in TypeScript overrides the default AVLTree creation with the provided
+     * options.
+     * @param [options] - The `options` parameter in the `createTree` function is an object that contains
+     * configuration options for creating an AVL tree. These options can include properties such as
+     * `iterationType`, `isMapMode`, `specifyComparable`, `toEntryFn`, and `isReverse`. The function
+     * creates a
+     * @returns An AVLTree object is being returned with the specified options and properties inherited
+     * from the current object.
      */
-    createTree(options?: AVLTreeOptions<K, V, R>): TREE;
+    createTree(options?: AVLTreeOptions<K, V, R>): AVLTree<K, V, R, NODE>;
     /**
      * The function checks if the input is an instance of AVLTreeNode.
      * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
@@ -107,6 +110,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<MK, MV, MR>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: AVLTreeOptions<MK, MV, MR>, thisArg?: any): AVLTree<MK, MV, MR, AVLTreeNode<MK, MV, AVLTreeNodeNested<MK, MV>>>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -78,14 +78,18 @@ class AVLTree extends bst_1.BST {
         return new AVLTreeNode(key, this._isMapMode ? undefined : value);
     }
     /**
-     * The function creates a new AVL tree with the specified options and returns it.
-     * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be
-     * passed to the `createTree` function. It is used to customize the behavior of the AVL tree that is
-     * being created.
-     * @returns a new AVLTree object.
+     * The function `createTree` in TypeScript overrides the default AVLTree creation with the provided
+     * options.
+     * @param [options] - The `options` parameter in the `createTree` function is an object that contains
+     * configuration options for creating an AVL tree. These options can include properties such as
+     * `iterationType`, `isMapMode`, `specifyComparable`, `toEntryFn`, and `isReverse`. The function
+     * creates a
+     * @returns An AVLTree object is being returned with the specified options and properties inherited
+     * from the current object.
      */
+    // @ts-ignore
     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 +144,15 @@ class AVLTree extends bst_1.BST {
         }
         return deletedResults;
     }
+    // @ts-ignore
+    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)

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, BinaryTreeNodeNested, BinaryTreeOptions, BinaryTreePrintOptions, BTNEntry, BTNRep, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, NodeCallback, NodeDisplayLayout, NodePredicate, OptNodeOrNull, ToEntryFn } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { IterableEntryBase } from '../base';
 import { Range } from '../../common';
@@ -34,7 +34,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, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>> extends IterableEntryBase<K, V | undefined> implements IBinaryTree<K, V, R, NODE> {
     iterationType: IterationType;
     /**
      * The constructor initializes a binary tree with optional options and adds keys, nodes, entries, or
@@ -59,6 +59,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
@@ -69,30 +72,20 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      */
     createNode(key: K, value?: V): NODE;
     /**
-     * The function creates a binary tree with the specified options.
-     * @param [options] - The `options` parameter in the `createTree` function is an optional parameter
-     * that allows you to provide partial configuration options for creating a binary tree. It is of type
-     * `Partial<BinaryTreeOptions<K, V, R>>`, which means you can pass in an object containing a subset
-     * of properties
-     * @returns A new instance of a binary tree with the specified options is being returned.
-     */
-    createTree(options?: BinaryTreeOptions<K, V, R>): TREE;
-    /**
-     * The function `keyValueNodeEntryRawToNodeAndValue` converts various input types into a node object
-     * or returns null.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
-     * `keyValueNodeEntryRawToNodeAndValue` function takes in a parameter `keyNodeEntryOrRaw`, which
-     * can be of type `BTNRep<K, V, NODE>` or `R`. This parameter represents either a key, a
-     * node, an entry
-     * @param {V} [value] - The `value` parameter in the `keyValueNodeEntryRawToNodeAndValue` function is
-     * an optional parameter of type `V`. It represents the value associated with the key in the node
-     * being created. If a `value` is provided, it will be used when creating the node. If
-     * @returns The `keyValueNodeEntryRawToNodeAndValue` function returns an optional node
-     * (`OptNodeOrNull<NODE>`) based on the input parameters provided. The function checks the type of the
-     * input parameter (`keyNodeEntryOrRaw`) and processes it accordingly to return a node or null
-     * value.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `createTree` function creates a new binary tree based on the provided options.
+     * @param [options] - The `options` parameter in the `createTree` method is of type
+     * `BinaryTreeOptions<K, V, R>`. This type likely contains configuration options for creating a
+     * binary tree, such as the iteration type, whether the tree is in map mode, and functions for
+     * converting entries.
+     * @returns The `createTree` method is returning an instance of the `BinaryTree` class with the
+     * provided options. The method is creating a new `BinaryTree` object with an empty array as the
+     * initial data, and then setting various options such as `iterationType`, `isMapMode`, and
+     * `toEntryFn` based on the current object's properties and the provided `options`. Finally, it
      */
-    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): [OptNodeOrNull<NODE>, V | undefined];
+    createTree(options?: BinaryTreeOptions<K, V, R>): typeof this;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -238,7 +231,7 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      * elements from the other tree.
      * @param anotherTree - `BinaryTree<K, V, R, NODE, TREE>`
      */
-    merge(anotherTree: BinaryTree<K, V, R, NODE, TREE>): void;
+    merge(anotherTree: this): void;
     /**
      * Time Complexity: O(k * n)
      * Space Complexity: O(1)
@@ -638,7 +631,7 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      * original tree using breadth-first search (bfs), and adds the nodes to the new tree. If a node in
      * the original tree is null, a null node is added to the cloned tree. If a node
      */
-    clone(): TREE;
+    clone(): this;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -655,23 +648,27 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      * @returns The `filter` method is returning a new tree that contains entries that pass the provided
      * predicate function.
      */
-    filter(predicate: EntryCallback<K, V | undefined, boolean>, thisArg?: any): TREE;
+    filter(predicate: EntryCallback<K, V | undefined, boolean>, thisArg?: any): this;
     /**
      * 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<MK, MV, MR>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: BinaryTreeOptions<MK, MV, MR>, thisArg?: any): BinaryTree<MK, MV, MR, BinaryTreeNode<MK, MV, BinaryTreeNodeNested<MK, MV>>>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -707,6 +704,22 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      * provided, the default value is set to
      */
     print(options?: BinaryTreePrintOptions, startNode?: BTNRep<K, V, NODE> | R): void;
+    /**
+     * The function `keyValueNodeEntryRawToNodeAndValue` converts various input types into a node object
+     * or returns null.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
+     * `keyValueNodeEntryRawToNodeAndValue` function takes in a parameter `keyNodeEntryOrRaw`, which
+     * can be of type `BTNRep<K, V, NODE>` or `R`. This parameter represents either a key, a
+     * node, an entry
+     * @param {V} [value] - The `value` parameter in the `keyValueNodeEntryRawToNodeAndValue` function is
+     * an optional parameter of type `V`. It represents the value associated with the key in the node
+     * being created. If a `value` is provided, it will be used when creating the node. If
+     * @returns The `keyValueNodeEntryRawToNodeAndValue` function returns an optional node
+     * (`OptNodeOrNull<NODE>`) based on the input parameters provided. The function checks the type of the
+     * input parameter (`keyNodeEntryOrRaw`) and processes it accordingly to return a node or null
+     * value.
+     */
+    protected _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): [OptNodeOrNull<NODE>, V | undefined];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)