min-heap-typed 1.51.9 → 1.52.0

package/dist/data-structures/base/{iterable-base.js → iterable-entry-base.js}

@@ -1,7 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IterableElementBase = exports.IterableEntryBase = void 0;
+exports.IterableEntryBase = void 0;
 class IterableEntryBase {
+    // protected _toEntryFn?: (rawElement: R) => BTNEntry<K, V>;
+    //
+    // /**
+    //  * The function returns the value of the _toEntryFn property.
+    //  * @returns The function being returned is `this._toEntryFn`.
+    //  */
+    // get toEntryFn() {
+    //   return this._toEntryFn;
+    // }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -262,32 +271,6 @@ class IterableEntryBase {
         }
         return accumulator;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
-    print() {
-        console.log([...this]);
-    }
-}
-exports.IterableEntryBase = IterableEntryBase;
-class IterableElementBase {
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function is an implementation of the Symbol.iterator method that returns an IterableIterator.
-     * @param {any[]} args - The `args` parameter in the code snippet represents a rest parameter. It
-     * allows the function to accept any number of arguments as an array. In this case, the `args`
-     * parameter is used to pass any number of arguments to the `_getIterator` method.
-     */
-    *[Symbol.iterator](...args) {
-        yield* this._getIterator(...args);
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -296,170 +279,10 @@ class IterableElementBase {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The function returns an iterator that yields all the values in the object.
-     */
-    *values() {
-        for (const item of this) {
-            yield item;
-        }
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `every` function checks if every element in the array satisfies a given predicate.
-     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
-     * the current element being processed, its index, and the array it belongs to. It should return a
-     * boolean value indicating whether the element satisfies a certain condition or not.
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
-     * passed as the `this` value to the `predicate` function. If `thisArg` is
-     * @returns The `every` method is returning a boolean value. It returns `true` if every element in
-     * the array satisfies the provided predicate function, and `false` otherwise.
-     */
-    every(predicate, thisArg) {
-        let index = 0;
-        for (const item of this) {
-            if (!predicate.call(thisArg, item, index++, this)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The "some" function checks if at least one element in a collection satisfies a given predicate.
-     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
-     * `value`, `index`, and `array`. It should return a boolean value indicating whether the current
-     * element satisfies the condition.
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as the `this` value when executing the `predicate` function. If `thisArg` is provided,
-     * it will be passed as the `this` value to the `predicate` function. If `thisArg
-     * @returns a boolean value. It returns true if the predicate function returns true for any element
-     * in the collection, and false otherwise.
-     */
-    some(predicate, thisArg) {
-        let index = 0;
-        for (const item of this) {
-            if (predicate.call(thisArg, item, index++, this)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `forEach` function iterates over each element in an array-like object and calls a callback
-     * function for each element.
-     * @param callbackfn - The callbackfn parameter is a function that will be called for each element in
-     * the array. It takes three arguments: the current element being processed, the index of the current
-     * element, and the array that forEach was called upon.
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
-     * be passed as the `this` value to the `callbackfn` function. If `thisArg
-     */
-    forEach(callbackfn, thisArg) {
-        let index = 0;
-        for (const item of this) {
-            callbackfn.call(thisArg, item, index++, this);
-        }
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `find` function iterates over the elements of an array-like object and returns the first
-     * element that satisfies the provided callback function.
-     * @param callbackfn - The callbackfn parameter is a function that will be called for each element in
-     * the array. It takes three arguments: the current element being processed, the index of the current
-     * element, and the array itself. The function should return a boolean value indicating whether the
-     * current element matches the desired condition.
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
-     * be passed as the `this` value to the `callbackfn` function. If `thisArg
-     * @returns The `find` method returns the first element in the array that satisfies the provided
-     * callback function. If no element satisfies the callback function, `undefined` is returned.
-     */
-    find(callbackfn, thisArg) {
-        let index = 0;
-        for (const item of this) {
-            if (callbackfn.call(thisArg, item, index++, this))
-                return item;
-        }
-        return;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function checks if a given element exists in a collection.
-     * @param {E} element - The parameter "element" is of type E, which means it can be any type. It
-     * represents the element that we want to check for existence in the collection.
-     * @returns a boolean value. It returns true if the element is found in the collection, and false
-     * otherwise.
-     */
-    has(element) {
-        for (const ele of this) {
-            if (ele === element)
-                return true;
-        }
-        return false;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `reduce` function iterates over the elements of an array-like object and applies a callback
-     * function to reduce them into a single value.
-     * @param callbackfn - The callbackfn parameter is a function that will be called for each element in
-     * the array. It takes four arguments:
-     * @param {U} initialValue - The initialValue parameter is the initial value of the accumulator. It
-     * is the value that the accumulator starts with before the reduction operation begins.
-     * @returns The `reduce` method is returning the final value of the accumulator after iterating over
-     * all the elements in the array and applying the callback function to each element.
-     */
-    reduce(callbackfn, initialValue) {
-        let accumulator = initialValue;
-        let index = 0;
-        for (const item of this) {
-            accumulator = callbackfn(accumulator, item, index++, this);
-        }
-        return accumulator;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * The print function logs the elements of an array to the console.
      */
     print() {
         console.log([...this]);
     }
 }
-exports.IterableElementBase = IterableElementBase;
+exports.IterableEntryBase = IterableEntryBase;

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

@@ -5,11 +5,11 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, Comparable, IterationType, KeyOrNodeOrEntry } from '../../types';
+import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, IterationType, KeyOrNodeOrEntry } from '../../types';
 import { BTNEntry } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
-export declare class AVLTreeMultiMapNode<K extends Comparable, V = any, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNodeNested<K, V>> extends AVLTreeNode<K, V, NODE> {
+export declare class AVLTreeMultiMapNode<K = any, V = any, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNodeNested<K, V>> extends AVLTreeNode<K, V, NODE> {
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
@@ -37,7 +37,7 @@ export declare class AVLTreeMultiMapNode<K extends Comparable, V = any, NODE ext
 /**
  * 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 extends Comparable, V = any, R = BTNEntry<K, V>, 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 = BTNEntry<K, V>, 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> {
     /**
      * The constructor initializes a new AVLTreeMultiMap object with optional initial elements.
      * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an

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

@@ -6,10 +6,10 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, Comparable, KeyOrNodeOrEntry } from '../../types';
+import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry } from '../../types';
 import { BTNEntry } from '../../types';
 import { IBinaryTree } from '../../interfaces';
-export declare class AVLTreeNode<K extends Comparable, V = any, NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
+export declare class AVLTreeNode<K = any, V = any, NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
     /**
      * The constructor function initializes a new instance of a class with a key and an optional value,
      * and sets the height property to 0.
@@ -41,7 +41,7 @@ export declare class AVLTreeNode<K extends Comparable, V = any, NODE extends AVL
  * 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 extends Comparable, V = any, R = BTNEntry<K, V>, 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 = BTNEntry<K, V>, 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> {
     /**
      * This is a constructor function for an AVLTree class that initializes the tree with keys, nodes,
      * entries, or raw elements.

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BinaryTreePrintOptions, BTNCallback, BTNEntry, Comparable, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, KeyOrNodeOrEntry, NodeDisplayLayout } from '../../types';
+import type { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BinaryTreePrintOptions, BTNCallback, BTNEntry, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, KeyOrNodeOrEntry, NodeDisplayLayout } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { IterableEntryBase } from '../base';
 /**
@@ -13,7 +13,7 @@ import { IterableEntryBase } from '../base';
  * @template V - The type of data stored in the node.
  * @template NODE - The type of the family relationship in the binary tree.
  */
-export declare class BinaryTreeNode<K extends Comparable, V = any, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>> {
+export declare class BinaryTreeNode<K = any, V = any, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>> {
     key: K;
     value?: V;
     parent?: NODE;
@@ -65,11 +65,11 @@ export declare class BinaryTreeNode<K extends Comparable, V = any, NODE extends
  * 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 extends Comparable, V = any, R = BTNEntry<K, V>, 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 = BTNEntry<K, V>, 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> {
     iterationType: IterationType;
     /**
      * The constructor function initializes a binary tree object with optional keysOrNodesOrEntriesOrRawElements and options.
-     * @param [keysOrNodesOrEntriesOrRawElements] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
+     * @param [keysOrNodesOrEntriesOrRawElements] - Optional iterable of KeyOrNodeOrEntry objects. These objects represent the
      * nodes to be added to the binary tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary tree. In this case, it is of type

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

@@ -96,7 +96,7 @@ exports.BinaryTreeNode = BinaryTreeNode;
 class BinaryTree extends base_1.IterableEntryBase {
     /**
      * The constructor function initializes a binary tree object with optional keysOrNodesOrEntriesOrRawElements and options.
-     * @param [keysOrNodesOrEntriesOrRawElements] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
+     * @param [keysOrNodesOrEntriesOrRawElements] - Optional iterable of KeyOrNodeOrEntry objects. These objects represent the
      * nodes to be added to the binary tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary tree. In this case, it is of type
@@ -115,6 +115,8 @@ class BinaryTree extends base_1.IterableEntryBase {
                 this.iterationType = iterationType;
             if (typeof toEntryFn === 'function')
                 this._toEntryFn = toEntryFn;
+            else if (toEntryFn)
+                throw TypeError('toEntryFn must be a function type');
         }
         if (keysOrNodesOrEntriesOrRawElements)
             this.addMany(keysOrNodesOrEntriesOrRawElements);
@@ -1699,12 +1701,12 @@ class BinaryTree extends base_1.IterableEntryBase {
         }
         else if (node !== null && node !== undefined) {
             // Display logic of normal nodes
-            const key = node.key, line = this.isNIL(node) ? 'S' : key.toString(), width = line.length;
+            const key = node.key, line = this.isNIL(node) ? 'S' : String(key), width = line.length;
             return _buildNodeDisplay(line, width, this._displayAux(node.left, options), this._displayAux(node.right, options));
         }
         else {
             // For cases where none of the conditions are met, null, undefined, and NaN nodes are not displayed
-            const line = node === undefined ? 'U' : 'NODE', width = line.length;
+            const line = node === undefined ? 'U' : 'N', width = line.length;
             return _buildNodeDisplay(line, width, [[''], 1, 0, 0], [[''], 1, 0, 0]);
         }
         function _buildNodeDisplay(line, width, left, right) {

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

@@ -5,11 +5,11 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNested, BSTNKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, Comparable, Comparator, CP, DFSOrderPattern, IterationType, KeyOrNodeOrEntry } from '../../types';
+import type { BSTNested, BSTNKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, Comparator, CP, DFSOrderPattern, IterationType, KeyOrNodeOrEntry } from '../../types';
 import { BTNEntry } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
-export declare class BSTNode<K extends Comparable, V = any, NODE extends BSTNode<K, V, NODE> = BSTNodeNested<K, V>> extends BinaryTreeNode<K, V, NODE> {
+export declare class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNodeNested<K, V>> extends BinaryTreeNode<K, V, NODE> {
     parent?: NODE;
     constructor(key: K, value?: V);
     protected _left?: NODE;
@@ -47,7 +47,7 @@ export declare class BSTNode<K extends Comparable, V = any, NODE extends BSTNode
  * 6. Balance Variability: Can become unbalanced; special types maintain balance.
  * 7. No Auto-Balancing: Standard BSTs don't automatically balance themselves.
  */
-export declare class BST<K extends Comparable, V = any, R = BTNEntry<K, V>, NODE extends BSTNode<K, V, NODE> = BSTNode<K, V, BSTNodeNested<K, V>>, TREE extends BST<K, V, R, NODE, TREE> = BST<K, V, R, NODE, BSTNested<K, V, R, NODE>>> extends BinaryTree<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
+export declare class BST<K = any, V = any, R = BTNEntry<K, V>, NODE extends BSTNode<K, V, NODE> = BSTNode<K, V, BSTNodeNested<K, V>>, TREE extends BST<K, V, R, NODE, TREE> = BST<K, V, R, NODE, BSTNested<K, V, R, NODE>>> extends BinaryTree<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
     /**
      * This is the constructor function for a Binary Search Tree class in TypeScript.
      * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an
@@ -349,15 +349,7 @@ export declare class BST<K extends Comparable, V = any, R = BTNEntry<K, V>, NODE
      * @returns a boolean value.
      */
     isAVLBalanced(iterationType?: IterationType): boolean;
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     protected _DEFAULT_COMPARATOR: (a: K, b: K) => number;
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     protected _comparator: Comparator<K>;
     /**
      * Time Complexity: O(n)

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

@@ -70,13 +70,9 @@ class BST extends binary_tree_1.BinaryTree {
     constructor(keysOrNodesOrEntriesOrRawElements = [], options) {
         super([], options);
         this._root = undefined;
-        /**
-         * Time complexity: O(n)
-         * Space complexity: O(n)
-         */
         this._DEFAULT_COMPARATOR = (a, b) => {
-            if (typeof a === 'object' && typeof b === 'object' && this.comparator === this._DEFAULT_COMPARATOR) {
-                throw TypeError('When comparing two object types, it is necessary to customize a [comparator] function of options parameter during the instantiation of the data structure.');
+            if (typeof a === 'object' || typeof b === 'object') {
+                throw TypeError(`When comparing object types, a custom comparator must be defined in the constructor's options parameter.`);
             }
             if (a > b)
                 return 1;
@@ -84,10 +80,6 @@ class BST extends binary_tree_1.BinaryTree {
                 return -1;
             return 0;
         };
-        /**
-         * Time complexity: O(n)
-         * Space complexity: O(n)
-         */
         this._comparator = this._DEFAULT_COMPARATOR;
         if (options) {
             const { comparator } = options;

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

@@ -1,8 +1,8 @@
-import type { BinaryTreeDeleteResult, BTNCallback, Comparable, CRUD, KeyOrNodeOrEntry, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
+import type { BinaryTreeDeleteResult, BTNCallback, CRUD, KeyOrNodeOrEntry, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 import { BTNEntry } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
-export declare class RedBlackTreeNode<K extends Comparable, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
+export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
     /**
      * The constructor function initializes a Red-Black Tree Node with a key, an optional value, and a
      * color.
@@ -27,7 +27,7 @@ export declare class RedBlackTreeNode<K extends Comparable, V = any, NODE extend
      */
     set color(value: RBTNColor);
 }
-export declare class RedBlackTree<K extends Comparable, V = any, R = BTNEntry<K, V>, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>, TREE extends RedBlackTree<K, V, R, NODE, TREE> = RedBlackTree<K, V, R, NODE, RedBlackTreeNested<K, V, R, NODE>>> extends BST<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
+export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>, TREE extends RedBlackTree<K, V, R, NODE, TREE> = RedBlackTree<K, V, R, NODE, RedBlackTreeNested<K, V, R, NODE>>> extends BST<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript.
      * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an

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

@@ -5,11 +5,11 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, Comparable, IterationType, KeyOrNodeOrEntry, RBTNColor, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, IterationType, KeyOrNodeOrEntry, RBTNColor, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
 import { BTNEntry } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './rb-tree';
-export declare class TreeMultiMapNode<K extends Comparable, V = any, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>> extends RedBlackTreeNode<K, V, NODE> {
+export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>> extends RedBlackTreeNode<K, V, NODE> {
     /**
      * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
      * @param {K} key - The key parameter represents the key of the node in the Red-Black Tree. It is
@@ -36,7 +36,7 @@ export declare class TreeMultiMapNode<K extends Comparable, V = any, NODE extend
      */
     set count(value: number);
 }
-export declare class TreeMultiMap<K extends Comparable, V = any, R = BTNEntry<K, V>, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>, TREE extends TreeMultiMap<K, V, R, NODE, TREE> = TreeMultiMap<K, V, R, NODE, TreeMultiMapNested<K, V, R, NODE>>> extends RedBlackTree<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
+export declare class TreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>, TREE extends TreeMultiMap<K, V, R, NODE, TREE> = TreeMultiMap<K, V, R, NODE, TreeMultiMapNested<K, V, R, NODE>>> extends RedBlackTree<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
     /**
      * The constructor function initializes a TreeMultiMap object with optional initial data.
      * @param keysOrNodesOrEntriesOrRawElements - The parameter `keysOrNodesOrEntriesOrRawElements` is an

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

@@ -150,7 +150,7 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * @returns The `map` method is returning a new `HashMap` object with the transformed values based on
      * the provided callback function.
      */
-    map<U>(callbackfn: EntryCallback<K, V, U>, thisArg?: any): HashMap<K, U>;
+    map<VM>(callbackfn: EntryCallback<K, V, VM>, thisArg?: any): HashMap<K, VM>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -482,7 +482,7 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      * @returns a new `LinkedHashMap` object with the values mapped according to the provided callback
      * function.
      */
-    map<NV>(callback: EntryCallback<K, V, NV>, thisArg?: any): LinkedHashMap<K, NV>;
+    map<VM>(callback: EntryCallback<K, V, VM>, thisArg?: any): LinkedHashMap<K, VM>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)