avl-tree-typed 1.53.8 → 1.54.0

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

@@ -450,7 +450,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<VM>(callback: EntryCallback<K, V, VM>, thisArg?: any): LinkedHashMap<K, VM>;
+    map<MK, MV>(callback: EntryCallback<K, V, [MK, MV]>, thisArg?: any): LinkedHashMap<MK, MV>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)

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

@@ -261,7 +261,7 @@ class HashMap extends base_1.IterableEntryBase {
         const resultMap = new HashMap();
         let index = 0;
         for (const [key, value] of this) {
-            resultMap.set(key, callbackfn.call(thisArg, value, key, index++, this));
+            resultMap.set(key, callbackfn.call(thisArg, key, value, index++, this));
         }
         return resultMap;
     }
@@ -285,7 +285,7 @@ class HashMap extends base_1.IterableEntryBase {
         const filteredMap = new HashMap();
         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)) {
                 filteredMap.set(key, value);
             }
         }
@@ -758,7 +758,7 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         const filteredMap = new LinkedHashMap();
         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)) {
                 filteredMap.set(key, value);
             }
             index++;
@@ -786,8 +786,8 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         const mappedMap = new LinkedHashMap();
         let index = 0;
         for (const [key, value] of this) {
-            const newValue = callback.call(thisArg, value, key, index, this);
-            mappedMap.set(key, newValue);
+            const [newKey, newValue] = callback.call(thisArg, key, value, index, this);
+            mappedMap.set(newKey, newValue);
             index++;
         }
         return mappedMap;

package/dist/data-structures/linked-list/doubly-linked-list.d.ts

@@ -533,6 +533,16 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * @returns The method `get last()` returns the last node of the doubly linked list, or `undefined` if the list is empty.
      */
     get last(): E | undefined;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
+     * given array.
+     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
+     * @returns The `fromArray` function returns a DoublyLinkedList object.
+     */
+    static fromArray<E>(data: E[]): DoublyLinkedList<E, any>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -867,16 +877,6 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * node, or predicate function in the doubly linked list.
      */
     countOccurrences(elementOrNode: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)): number;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
-     * given array.
-     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
-     * @returns The `fromArray` function returns a DoublyLinkedList object.
-     */
-    static fromArray<E>(data: E[]): DoublyLinkedList<E, any>;
     /**
      * The function returns an iterator that iterates over the values of a linked list.
      */

package/dist/data-structures/linked-list/doubly-linked-list.js

@@ -557,6 +557,18 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         var _a;
         return (_a = this.tail) === null || _a === void 0 ? void 0 : _a.value;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
+     * given array.
+     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
+     * @returns The `fromArray` function returns a DoublyLinkedList object.
+     */
+    static fromArray(data) {
+        return new DoublyLinkedList(data);
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -1184,18 +1196,6 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         }
         return count;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
-     * given array.
-     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
-     * @returns The `fromArray` function returns a DoublyLinkedList object.
-     */
-    static fromArray(data) {
-        return new DoublyLinkedList(data);
-    }
     /**
      * The function returns an iterator that iterates over the values of a linked list.
      */

package/dist/data-structures/linked-list/singly-linked-list.d.ts

@@ -72,6 +72,16 @@ export declare class SinglyLinkedList<E = any, R = any> extends IterableElementB
      * @returns The size of the object, which is a number.
      */
     get size(): number;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given
+     * array.
+     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
+     * @returns The `fromArray` function returns a `SinglyLinkedList` object.
+     */
+    static fromArray<E>(data: E[]): SinglyLinkedList<E, any>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -384,16 +394,6 @@ export declare class SinglyLinkedList<E = any, R = any> extends IterableElementB
      * The function `_getIterator` returns an iterable iterator that yields the values of a linked list.
      */
     protected _getIterator(): IterableIterator<E>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given
-     * array.
-     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
-     * @returns The `fromArray` function returns a `SinglyLinkedList` object.
-     */
-    static fromArray<E>(data: E[]): SinglyLinkedList<E, any>;
     /**
      * The _isPredicate function in TypeScript checks if the input is a function that takes a
      * SinglyLinkedListNode as an argument and returns a boolean.

package/dist/data-structures/linked-list/singly-linked-list.js

@@ -90,6 +90,22 @@ class SinglyLinkedList extends base_1.IterableElementBase {
     get size() {
         return this._size;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given
+     * array.
+     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
+     * @returns The `fromArray` function returns a `SinglyLinkedList` object.
+     */
+    static fromArray(data) {
+        const singlyLinkedList = new SinglyLinkedList();
+        for (const item of data) {
+            singlyLinkedList.push(item);
+        }
+        return singlyLinkedList;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -690,22 +706,6 @@ class SinglyLinkedList extends base_1.IterableElementBase {
             current = current.next;
         }
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given
-     * array.
-     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
-     * @returns The `fromArray` function returns a `SinglyLinkedList` object.
-     */
-    static fromArray(data) {
-        const singlyLinkedList = new SinglyLinkedList();
-        for (const item of data) {
-            singlyLinkedList.push(item);
-        }
-        return singlyLinkedList;
-    }
     /**
      * The _isPredicate function in TypeScript checks if the input is a function that takes a
      * SinglyLinkedListNode as an argument and returns a boolean.

package/dist/interfaces/binary-tree.d.ts

@@ -1,6 +1,6 @@
 import { BinaryTree, BinaryTreeNode } from '../data-structures';
 import type { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BTNRep, NodePredicate } from '../types';
-export interface IBinaryTree<K = any, V = any, R = object, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNodeNested<K, V>, TREE extends BinaryTree<K, V, R, NODE, TREE> = BinaryTreeNested<K, V, R, NODE>> {
+export interface IBinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = object, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNodeNested<K, V>, TREE extends BinaryTree<K, V, R, MK, MV, MR, NODE, TREE> = BinaryTreeNested<K, V, R, MK, MV, MR, NODE>> {
     createNode(key: K, value?: NODE['value']): NODE;
     createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): TREE;
     add(keyOrNodeOrEntryOrRawElement: BTNRep<K, V, NODE>, value?: V, count?: number): boolean;

package/dist/types/data-structures/base/base.d.ts

@@ -1,5 +1,5 @@
 import { IterableElementBase, IterableEntryBase } from '../../../data-structures';
-export type EntryCallback<K, V, R> = (value: V, key: K, index: number, container: IterableEntryBase<K, V>) => R;
+export type EntryCallback<K, V, R> = (key: K, value: V, index: number, container: IterableEntryBase<K, V>) => R;
 export type ElementCallback<E, R, RT, C> = (element: E, index: number, container: IterableElementBase<E, R, C>) => RT;
 export type ReduceEntryCallback<K, V, R> = (accumulator: R, value: V, key: K, index: number, container: IterableEntryBase<K, V>) => R;
 export type ReduceElementCallback<E, R, RT, C> = (accumulator: RT, element: E, index: number, container: IterableElementBase<E, R, C>) => RT;

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

@@ -1,5 +1,5 @@
 import { AVLTreeMultiMap, AVLTreeMultiMapNode } from '../../../data-structures';
 import type { AVLTreeOptions } from './avl-tree';
-export type AVLTreeMultiMapNodeNested<K, V> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type AVLTreeMultiMapNested<K, V, R, NODE extends AVLTreeMultiMapNode<K, V, NODE>> = AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AVLTreeMultiMapNodeNested<K, V> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, any>>>;
+export type AVLTreeMultiMapNested<K, V, R, MK, MV, MR, NODE extends AVLTreeMultiMapNode<K, V, NODE>> = AVLTreeMultiMap<K, V, R, MK, MV, MR, NODE, AVLTreeMultiMap<K, V, R, MK, MV, MR, NODE, AVLTreeMultiMap<K, V, R, MK, MV, MR, NODE, any>>>;
 export type AVLTreeMultiMapOptions<K, V, R> = AVLTreeOptions<K, V, R> & {};

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

@@ -1,5 +1,5 @@
 import { AVLTree, AVLTreeNode } from '../../../data-structures';
 import { BSTOptions } from './bst';
-export type AVLTreeNodeNested<K, V> = AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type AVLTreeNested<K, V, R, NODE extends AVLTreeNode<K, V, NODE>> = AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, AVLTree<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AVLTreeNodeNested<K, V> = AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, any>>>;
+export type AVLTreeNested<K, V, R, MK, MV, MR, NODE extends AVLTreeNode<K, V, NODE>> = AVLTree<K, V, R, MK, MV, MR, NODE, AVLTree<K, V, R, MK, MV, MR, NODE, AVLTree<K, V, R, MK, MV, MR, NODE, any>>>;
 export type AVLTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};

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

@@ -1,8 +1,8 @@
 import { BinaryTree, BinaryTreeNode } from '../../../data-structures';
 import { IterationType, OptValue } from '../../common';
 import { DFSOperation } from '../../../common';
-export type BinaryTreeNodeNested<K, V> = BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type BinaryTreeNested<K, V, R, NODE extends BinaryTreeNode<K, V, NODE>> = BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type BinaryTreeNodeNested<K, V> = BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, any>>>;
+export type BinaryTreeNested<K, V, R, MK, MV, MR, NODE extends BinaryTreeNode<K, V, NODE>> = BinaryTree<K, V, R, MK, MV, MR, NODE, BinaryTree<K, V, R, MK, MV, MR, NODE, BinaryTree<K, V, R, MK, MV, MR, NODE, any>>>;
 export type ToEntryFn<K, V, R> = (rawElement: R) => BTNEntry<K, V>;
 export type BinaryTreeOptions<K, V, R> = {
     iterationType?: IterationType;

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

@@ -1,10 +1,10 @@
 import { BST, BSTNode } from '../../../data-structures';
 import type { BinaryTreeOptions } from './binary-tree';
 import { Comparable } from '../../utils';
-export type BSTNodeNested<K, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type BSTNested<K, V, R, NODE extends BSTNode<K, V, NODE>> = BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type BSTNodeNested<K, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, any>>>;
+export type BSTNested<K, V, R, MK, MV, MR, NODE extends BSTNode<K, V, NODE>> = BST<K, V, R, MK, MV, MR, NODE, BST<K, V, R, MK, MV, MR, NODE, BST<K, V, R, MK, MV, MR, NODE, any>>>;
 export type BSTOptions<K, V, R> = BinaryTreeOptions<K, V, R> & {
-    extractComparable?: (key: K) => Comparable;
+    specifyComparable?: (key: K) => Comparable;
     isReverse?: boolean;
 };
 export type BSTNOptKey<K> = K | undefined;

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

@@ -1,6 +1,6 @@
 import { RedBlackTree, RedBlackTreeNode } from '../../../data-structures';
 import type { BSTOptions } from "./bst";
 export type RBTNColor = 'RED' | 'BLACK';
-export type RedBlackTreeNodeNested<K, V> = RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type RedBlackTreeNested<K, V, R, NODE extends RedBlackTreeNode<K, V, NODE>> = RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type RBTreeOptions<K, V, R> = Omit<BSTOptions<K, V, R>, 'isReverse'> & {};
+export type RedBlackTreeNodeNested<K, V> = RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, any>>>;
+export type RedBlackTreeNested<K, V, R, MK, MV, MR, NODE extends RedBlackTreeNode<K, V, NODE>> = RedBlackTree<K, V, R, MK, MV, MR, NODE, RedBlackTree<K, V, R, MK, MV, MR, NODE, RedBlackTree<K, V, R, MK, MV, MR, NODE, any>>>;
+export type RedBlackTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};

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

@@ -1,5 +1,5 @@
 import { TreeMultiMap, TreeMultiMapNode } from '../../../data-structures';
-import type { RBTreeOptions } from './rb-tree';
-export type TreeMultiMapNodeNested<K, V> = TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type TreeMultiMapNested<K, V, R, NODE extends TreeMultiMapNode<K, V, NODE>> = TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, TreeMultiMap<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type TreeMultiMapOptions<K, V, R> = RBTreeOptions<K, V, R> & {};
+import type { RedBlackTreeOptions } from './rb-tree';
+export type TreeMultiMapNodeNested<K, V> = TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, any>>>;
+export type TreeMultiMapNested<K, V, R, MK, MV, MR, NODE extends TreeMultiMapNode<K, V, NODE>> = TreeMultiMap<K, V, R, MK, MV, MR, NODE, TreeMultiMap<K, V, R, MK, MV, MR, NODE, TreeMultiMap<K, V, R, MK, MV, MR, NODE, any>>>;
+export type TreeMultiMapOptions<K, V, R> = RedBlackTreeOptions<K, V, R> & {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "avl-tree-typed",
-  "version": "1.53.8",
+  "version": "1.54.0",
   "description": "AVLTree(Adelson-Velsky and Landis Tree). Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -163,6 +163,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.53.8"
+    "data-structure-typed": "^1.54.0"
   }
 }

package/src/data-structures/base/iterable-entry-base.ts

@@ -70,7 +70,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
   every(predicate: EntryCallback<K, V, boolean>, thisArg?: any): boolean {
     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;
       }
     }
@@ -95,7 +95,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
   some(predicate: EntryCallback<K, V, boolean>, thisArg?: any): boolean {
     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;
       }
     }
@@ -119,7 +119,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
     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);
     }
   }
 
@@ -144,7 +144,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
     let index = 0;
     for (const item of this) {
       const [key, value] = item;
-      if (callbackfn.call(thisArg, value, key, index++, this)) return item;
+      if (callbackfn.call(thisArg, key, value, index++, this)) return item;
     }
     return;
   }

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

@@ -12,6 +12,7 @@ import type {
   BinaryTreeDeleteResult,
   BSTNOptKeyOrNode,
   BTNRep,
+  EntryCallback,
   IterationType
 } from '../../types';
 import { IBinaryTree } from '../../interfaces';
@@ -36,25 +37,6 @@ export class AVLTreeMultiMapNode<
     super(key, value);
     this.count = count;
   }
-
-  protected _count: number = 1;
-
-  /**
-   * 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 {
-    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: number) {
-    this._count = value;
-  }
 }
 
 /**
@@ -64,17 +46,23 @@ export 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, NODE, TREE> = AVLTreeMultiMap<
+    TREE extends AVLTreeMultiMap<K, V, R, MK, MV, MR, NODE, TREE> = AVLTreeMultiMap<
       K,
       V,
       R,
+      MK,
+      MV,
+      MR,
       NODE,
-      AVLTreeMultiMapNested<K, V, R, NODE>
+      AVLTreeMultiMapNested<K, V, R, MK, MV, MR, NODE>
     >
   >
-  extends AVLTree<K, V, R, NODE, TREE>
-  implements IBinaryTree<K, V, R, NODE, TREE>
+  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.
@@ -140,10 +128,10 @@ export class AVLTreeMultiMap<
    * object.
    */
   override createTree(options?: AVLTreeMultiMapOptions<K, V, R>): TREE {
-    return new AVLTreeMultiMap<K, V, R, NODE, TREE>([], {
+    return new AVLTreeMultiMap<K, V, R, MK, MV, MR, NODE, TREE>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
-      extractComparable: this._extractComparable,
+      specifyComparable: this._specifyComparable,
       toEntryFn: this._toEntryFn,
       isReverse: this._isReverse,
       ...options
@@ -161,44 +149,6 @@ export class AVLTreeMultiMap<
     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.
-   */
-  protected override _keyValueNodeEntryRawToNodeAndValue(
-    keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R,
-    value?: V,
-    count = 1
-  ): [NODE | undefined, V | undefined] {
-    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 ?? entryValue;
-      return [this.createNode(key, finalValue, count), finalValue];
-    }
-
-    if (this.isRaw(keyNodeEntryOrRaw)) {
-      const [key, entryValue] = this._toEntryFn!(keyNodeEntryOrRaw);
-      const finalValue = 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)
@@ -264,7 +214,7 @@ export class AVLTreeMultiMap<
     } else {
       if (!curr.left) {
         if (!parent) {
-          if (curr.right !== undefined) this._setRoot(curr.right);
+          if (curr.right !== undefined && curr.right !== null) this._setRoot(curr.right);
         } else {
           const { familyPosition: fp } = curr;
           if (fp === 'LEFT' || fp === 'ROOT_LEFT') {
@@ -382,6 +332,75 @@ export class AVLTreeMultiMap<
     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.
+   */
+  override map<MK, MV, MR>(
+    callback: EntryCallback<K, V | undefined, [MK, MV]>,
+    options?: AVLTreeMultiMapOptions<MK, MV, MR>,
+    thisArg?: any
+  ): AVLTreeMultiMap<MK, MV, MR> {
+    const newTree = new AVLTreeMultiMap<MK, MV, MR>([], 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.
+   */
+  protected override _keyValueNodeEntryRawToNodeAndValue(
+    keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R,
+    value?: V,
+    count = 1
+  ): [NODE | undefined, V | undefined] {
+    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 ?? entryValue;
+      return [this.createNode(key, finalValue, count), finalValue];
+    }
+
+    if (this.isRaw(keyNodeEntryOrRaw)) {
+      const [key, entryValue] = this._toEntryFn!(keyNodeEntryOrRaw);
+      const finalValue = 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)