graph-typed 1.53.8 → 1.54.0

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

@@ -5,38 +5,38 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNested, BSTNodeNested, BSTNOptKeyOrNode, BSTOptions, BTNRep, Comparable, Comparator, CP, DFSOrderPattern, IterationType, NodeCallback, NodePredicate, OptNode } from '../../types';
+import { BSTNested, BSTNodeNested, BSTNOptKeyOrNode, BSTOptions, BTNRep, Comparable, Comparator, CP, DFSOrderPattern, EntryCallback, IterationType, NodeCallback, NodePredicate, OptNode, OptNodeOrNull } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 import { Range } from '../../common';
 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;
+    _left?: OptNodeOrNull<NODE>;
     /**
      * The function returns the value of the `_left` property.
      * @returns The `_left` property of the current object is being returned.
      */
-    get left(): OptNode<NODE>;
+    get left(): OptNodeOrNull<NODE>;
     /**
      * The function sets the left child of a node and updates the parent reference of the child.
      * @param {OptNode<NODE>} v - The parameter `v` is of type `OptNode<NODE>`. It can either be an
      * instance of the `NODE` class or `undefined`.
      */
-    set left(v: OptNode<NODE>);
-    protected _right?: NODE;
+    set left(v: OptNodeOrNull<NODE>);
+    _right?: OptNodeOrNull<NODE>;
     /**
      * The function returns the right node of a binary tree or undefined if there is no right node.
      * @returns The method is returning the value of the `_right` property, which is of type `NODE` or
      * `undefined`.
      */
-    get right(): OptNode<NODE>;
+    get right(): OptNodeOrNull<NODE>;
     /**
      * The function sets the right child of a node and updates the parent reference of the child.
      * @param {OptNode<NODE>} v - The parameter `v` is of type `OptNode<NODE>`. It can either be a
      * `NODE` object or `undefined`.
      */
-    set right(v: OptNode<NODE>);
+    set right(v: OptNodeOrNull<NODE>);
 }
 /**
  * 1. Node Order: Each node's left child has a lesser value, and the right child has a greater value.
@@ -103,7 +103,7 @@ export declare class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE>
  *     console.log(findLCA(5, 35)); // 15
  *     console.log(findLCA(20, 30)); // 25
  */
-export declare class BST<K = any, V = any, R = object, 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 = object, MK = any, MV = any, MR = object, NODE extends BSTNode<K, V, NODE> = BSTNode<K, V, BSTNodeNested<K, V>>, TREE extends BST<K, V, R, MK, MV, MR, NODE, TREE> = BST<K, V, R, MK, MV, MR, NODE, BSTNested<K, V, R, MK, MV, MR, NODE>>> extends BinaryTree<K, V, R, MK, MV, MR, NODE, TREE> implements IBinaryTree<K, V, R, MK, MV, MR, NODE, TREE> {
     /**
      * This is the constructor function for a Binary Search Tree class in TypeScript.
      * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
@@ -220,16 +220,6 @@ export declare class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V
      * successfully inserted into the data structure.
      */
     addMany(keysNodesEntriesOrRaws: Iterable<R | BTNRep<K, V, NODE>>, values?: Iterable<V | undefined>, isBalanceAdd?: boolean, iterationType?: IterationType): boolean[];
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `merge` function overrides the base class method by adding elements from another
-     * binary search tree.
-     * @param anotherTree - `anotherTree` is an instance of a Binary Search Tree (BST) with key type `K`,
-     * value type `V`, return type `R`, node type `NODE`, and tree type `TREE`.
-     */
-    merge(anotherTree: BST<K, V, R, NODE, TREE>): void;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(k + log n)
@@ -414,13 +404,13 @@ export declare class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V
      * @returns The `_comparator` property is being returned.
      */
     get comparator(): Comparator<K>;
-    protected _extractComparable?: (key: K) => Comparable;
+    protected _specifyComparable?: (key: K) => Comparable;
     /**
-     * This function returns the value of the `_extractComparable` property.
-     * @returns The method `extractComparable()` is being returned, which is a getter method for the
-     * `_extractComparable` property.
+     * This function returns the value of the `_specifyComparable` property.
+     * @returns The method `specifyComparable()` is being returned, which is a getter method for the
+     * `_specifyComparable` property.
      */
-    get extractComparable(): ((key: K) => Comparable) | undefined;
+    get specifyComparable(): ((key: K) => Comparable) | undefined;
     /**
      * The function sets the root of a tree-like structure and updates the parent property of the new
      * root.
@@ -428,4 +418,5 @@ export declare class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V
      */
     protected _setRoot(v: OptNode<NODE>): void;
     protected _compare(a: K, b: K): number;
+    map(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: BSTOptions<MK, MV, MR>, thisArg?: any): BST<MK, MV, MR>;
 }

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

@@ -137,22 +137,22 @@ class BST extends binary_tree_1.BinaryTree {
                     return -1;
                 return 0;
             }
-            if (this._extractComparable) {
-                if (this._extractComparable(a) > this._extractComparable(b))
+            if (this._specifyComparable) {
+                if (this._specifyComparable(a) > this._specifyComparable(b))
                     return 1;
-                if (this._extractComparable(a) < this._extractComparable(b))
+                if (this._specifyComparable(a) < this._specifyComparable(b))
                     return -1;
                 return 0;
             }
             if (typeof a === 'object' || typeof b === 'object') {
-                throw TypeError(`When comparing object types, a custom extractComparable must be defined in the constructor's options parameter.`);
+                throw TypeError(`When comparing object types, a custom specifyComparable must be defined in the constructor's options parameter.`);
             }
             return 0;
         };
         if (options) {
-            const { extractComparable, isReverse } = options;
-            if (typeof extractComparable === 'function')
-                this._extractComparable = extractComparable;
+            const { specifyComparable, isReverse } = options;
+            if (typeof specifyComparable === 'function')
+                this._specifyComparable = specifyComparable;
             if (isReverse !== undefined)
                 this._isReverse = isReverse;
         }
@@ -193,7 +193,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns a new instance of the BST class with the provided options.
      */
     createTree(options) {
-        return new BST([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, extractComparable: this._extractComparable, toEntryFn: this._toEntryFn, isReverse: this._isReverse }, options));
+        return new BST([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, specifyComparable: this._specifyComparable, toEntryFn: this._toEntryFn, isReverse: this._isReverse }, options));
     }
     /**
      * The function overrides a method and converts a key, value pair or entry or raw element to a node.
@@ -248,7 +248,7 @@ class BST extends binary_tree_1.BinaryTree {
      * this._DEFAULT_COMPARATOR`.
      */
     isKey(key) {
-        return (0, utils_1.isComparable)(key, this._extractComparable !== undefined);
+        return (0, utils_1.isComparable)(key, this._specifyComparable !== undefined);
     }
     /**
      * Time Complexity: O(log n)
@@ -288,7 +288,8 @@ class BST extends binary_tree_1.BinaryTree {
                     this._size++;
                     return true;
                 }
-                current = current.left;
+                if (current.left !== null)
+                    current = current.left;
             }
             else {
                 if (current.right === undefined) {
@@ -298,7 +299,8 @@ class BST extends binary_tree_1.BinaryTree {
                     this._size++;
                     return true;
                 }
-                current = current.right;
+                if (current.right !== null)
+                    current = current.right;
             }
         }
         return false;
@@ -405,18 +407,6 @@ class BST extends binary_tree_1.BinaryTree {
         }
         return inserted;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `merge` function overrides the base class method by adding elements from another
-     * binary search tree.
-     * @param anotherTree - `anotherTree` is an instance of a Binary Search Tree (BST) with key type `K`,
-     * value type `V`, return type `R`, node type `NODE`, and tree type `TREE`.
-     */
-    merge(anotherTree) {
-        this.addMany(anotherTree, [], false);
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(k + log n)
@@ -817,7 +807,8 @@ class BST extends binary_tree_1.BinaryTree {
             while (stack.length > 0 || node) {
                 if (node) {
                     stack.push(node);
-                    node = node.left;
+                    if (node.left !== null)
+                        node = node.left;
                 }
                 else {
                     node = stack[stack.length - 1];
@@ -848,12 +839,12 @@ class BST extends binary_tree_1.BinaryTree {
         return this._comparator;
     }
     /**
-     * This function returns the value of the `_extractComparable` property.
-     * @returns The method `extractComparable()` is being returned, which is a getter method for the
-     * `_extractComparable` property.
+     * This function returns the value of the `_specifyComparable` property.
+     * @returns The method `specifyComparable()` is being returned, which is a getter method for the
+     * `_specifyComparable` property.
      */
-    get extractComparable() {
-        return this._extractComparable;
+    get specifyComparable() {
+        return this._specifyComparable;
     }
     /**
      * The function sets the root of a tree-like structure and updates the parent property of the new
@@ -869,5 +860,13 @@ class BST extends binary_tree_1.BinaryTree {
     _compare(a, b) {
         return this._isReverse ? -this._comparator(a, b) : this._comparator(a, b);
     }
+    map(callback, options, thisArg) {
+        const newTree = new BST([], options);
+        let index = 0;
+        for (const [key, value] of this) {
+            newTree.add(callback.call(thisArg, key, value, index++, this));
+        }
+        return newTree;
+    }
 }
 exports.BST = BST;

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

@@ -1,4 +1,4 @@
-import type { BinaryTreeDeleteResult, BTNRep, CRUD, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
+import type { BinaryTreeDeleteResult, BTNRep, CRUD, EntryCallback, RBTNColor, RedBlackTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
@@ -14,17 +14,6 @@ export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTre
      * Tree Node. It is an optional parameter with a default value of `'BLACK'`.
      */
     constructor(key: K, value?: V, color?: RBTNColor);
-    protected _color: RBTNColor;
-    /**
-     * The function returns the color value of a variable.
-     * @returns The color value stored in the private variable `_color`.
-     */
-    get color(): RBTNColor;
-    /**
-     * The function sets the color property to the specified value.
-     * @param {RBTNColor} value - The value parameter is of type RBTNColor.
-     */
-    set color(value: RBTNColor);
 }
 /**
  * 1. Efficient self-balancing, but not completely balanced. Compared with AVLTree, the addition and deletion efficiency is high but the query efficiency is slightly lower.
@@ -79,18 +68,18 @@ export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTre
  *     );
  *     console.log(stocksInRange); // ['GOOGL', 'MSFT', 'META']
  */
-export declare class RedBlackTree<K = any, V = any, R = object, 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 = object, MK = any, MV = any, MR = object, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>, TREE extends RedBlackTree<K, V, R, MK, MV, MR, NODE, TREE> = RedBlackTree<K, V, R, MK, MV, MR, NODE, RedBlackTreeNested<K, V, R, MK, MV, MR, NODE>>> extends BST<K, V, R, MK, MV, MR, NODE, TREE> implements IBinaryTree<K, V, R, MK, MV, MR, NODE, TREE> {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript.
      * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
      * iterable object that can contain either keys, nodes, entries, or raw elements. It is used to
      * initialize the RBTree with the provided elements.
      * @param [options] - The `options` parameter is an optional object that can be passed to the
-     * constructor. It is of type `RBTreeOptions<K, V, R>`. This object can contain various options for
+     * constructor. It is of type `RedBlackTreeOptions<K, V, R>`. This object can contain various options for
      * configuring the behavior of the Red-Black Tree. The specific properties and their meanings would
      * depend on the implementation
      */
-    constructor(keysNodesEntriesOrRaws?: Iterable<R | BTNRep<K, V, NODE>>, options?: RBTreeOptions<K, V, R>);
+    constructor(keysNodesEntriesOrRaws?: Iterable<R | BTNRep<K, V, NODE>>, options?: RedBlackTreeOptions<K, V, R>);
     protected _root: NODE | undefined;
     /**
      * The function returns the root node of a tree or undefined if there is no root.
@@ -118,7 +107,7 @@ export declare class RedBlackTree<K = any, V = any, R = object, NODE extends Red
      * configuration options for creating the Red-Black Tree. It has the following properties:
      * @returns a new instance of a RedBlackTree object.
      */
-    createTree(options?: RBTreeOptions<K, V, R>): TREE;
+    createTree(options?: RedBlackTreeOptions<K, V, R>): TREE;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -255,4 +244,25 @@ export declare class RedBlackTree<K = any, V = any, R = object, NODE extends Red
      * @returns void, which means it does not return any value.
      */
     protected _rightRotate(y: NODE | undefined): void;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript overrides the default behavior to create a new Red-Black Tree by
+     * applying a callback to each entry in the original tree.
+     * @param callback - A function that will be called for each entry in the tree, with parameters
+     * representing the key, value, index, and the tree itself. It should return an entry for the new
+     * tree.
+     * @param [options] - The `options` parameter in the `map` method is of type `RedBlackTreeOptions<MK, MV,
+     * MR>`. This parameter allows you to specify additional options or configurations for the Red-Black
+     * Tree that will be created during the mapping process. These options could include things like
+     * custom comparators
+     * @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 A new Red-Black Tree is being returned, where each entry has been transformed using the
+     * provided callback function.
+     */
+    map(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: RedBlackTreeOptions<MK, MV, MR>, thisArg?: any): RedBlackTree<MK, MV, MR>;
 }

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

@@ -18,20 +18,6 @@ class RedBlackTreeNode extends bst_1.BSTNode {
         super(key, value);
         this._color = color;
     }
-    /**
-     * The function returns the color value of a variable.
-     * @returns The color value stored in the private variable `_color`.
-     */
-    get color() {
-        return this._color;
-    }
-    /**
-     * The function sets the color property to the specified value.
-     * @param {RBTNColor} value - The value parameter is of type RBTNColor.
-     */
-    set color(value) {
-        this._color = value;
-    }
 }
 exports.RedBlackTreeNode = RedBlackTreeNode;
 /**
@@ -94,7 +80,7 @@ class RedBlackTree extends bst_1.BST {
      * iterable object that can contain either keys, nodes, entries, or raw elements. It is used to
      * initialize the RBTree with the provided elements.
      * @param [options] - The `options` parameter is an optional object that can be passed to the
-     * constructor. It is of type `RBTreeOptions<K, V, R>`. This object can contain various options for
+     * constructor. It is of type `RedBlackTreeOptions<K, V, R>`. This object can contain various options for
      * configuring the behavior of the Red-Black Tree. The specific properties and their meanings would
      * depend on the implementation
      */
@@ -136,7 +122,7 @@ class RedBlackTree extends bst_1.BST {
      * @returns a new instance of a RedBlackTree object.
      */
     createTree(options) {
-        return new RedBlackTree([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, extractComparable: this._extractComparable, toEntryFn: this._toEntryFn }, options));
+        return new RedBlackTree([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, specifyComparable: this._specifyComparable, toEntryFn: this._toEntryFn }, options));
     }
     /**
      * Time Complexity: O(1)
@@ -151,41 +137,6 @@ class RedBlackTree extends bst_1.BST {
     isNode(keyNodeEntryOrRaw) {
         return keyNodeEntryOrRaw instanceof RedBlackTreeNode;
     }
-    // /**
-    //  * Time Complexity: O(1)
-    //  * Space Complexity: O(1)
-    //  */
-    //
-    // /**
-    //  * Time Complexity: O(1)
-    //  * Space Complexity: O(1)
-    //  *
-    //  * The function `keyValueNodeEntryRawToNodeAndValue` takes a key, value, or entry and returns a node if it is
-    //  * valid, otherwise it returns undefined.
-    //  * @param {BTNRep<K, V, NODE>} keyNodeEntryOrRaw - The key, value, or entry to convert.
-    //  * @param {V} [value] - The value associated with the key (if `keyNodeEntryOrRaw` is a key).
-    //  * @returns {NODE | undefined} - The corresponding Red-Black Tree node, or `undefined` if conversion fails.
-    //  */
-    // override keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): NODE | undefined {
-    //
-    //   if (keyNodeEntryOrRaw === null || keyNodeEntryOrRaw === undefined) return;
-    //   if (this.isNode(keyNodeEntryOrRaw)) return keyNodeEntryOrRaw;
-    //
-    //   if (this._toEntryFn) {
-    //     const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw as R);
-    //     if (this.isKey(key)) return this.createNode(key, value ?? entryValue, 'RED');
-    //   }
-    //
-    //   if (this.isEntry(keyNodeEntryOrRaw)) {
-    //     const [key, value] = keyNodeEntryOrRaw;
-    //     if (key === undefined || key === null) return;
-    //     else return  this.createNode(key, value, 'RED');
-    //   }
-    //
-    //   if (this.isKey(keyNodeEntryOrRaw)) return this.createNode(keyNodeEntryOrRaw, value, 'RED');
-    //
-    //   return ;
-    // }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -266,8 +217,10 @@ class RedBlackTree extends bst_1.BST {
         let originalColor = nodeToDelete.color;
         let replacementNode;
         if (!this.isRealNode(nodeToDelete.left)) {
-            replacementNode = nodeToDelete.right;
-            this._transplant(nodeToDelete, nodeToDelete.right);
+            if (nodeToDelete.right !== null) {
+                replacementNode = nodeToDelete.right;
+                this._transplant(nodeToDelete, nodeToDelete.right);
+            }
         }
         else if (!this.isRealNode(nodeToDelete.right)) {
             replacementNode = nodeToDelete.left;
@@ -277,15 +230,18 @@ class RedBlackTree extends bst_1.BST {
             const successor = this.getLeftMost(node => node, nodeToDelete.right);
             if (successor) {
                 originalColor = successor.color;
-                replacementNode = successor.right;
+                if (successor.right !== null)
+                    replacementNode = successor.right;
                 if (successor.parent === nodeToDelete) {
                     if (this.isRealNode(replacementNode)) {
                         replacementNode.parent = successor;
                     }
                 }
                 else {
-                    this._transplant(successor, successor.right);
-                    successor.right = nodeToDelete.right;
+                    if (successor.right !== null) {
+                        this._transplant(successor, successor.right);
+                        successor.right = nodeToDelete.right;
+                    }
                     if (this.isRealNode(successor.right)) {
                         successor.right.parent = successor;
                     }
@@ -372,7 +328,7 @@ class RedBlackTree extends bst_1.BST {
         if (!parent) {
             this._setRoot(node);
         }
-        else if (node.key < parent.key) {
+        else if (this._compare(node.key, parent.key) < 0) {
             parent.left = node;
         }
         else {
@@ -416,7 +372,7 @@ class RedBlackTree extends bst_1.BST {
      * structure. It can either be a valid node or `undefined`.
      */
     _insertFixup(z) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         // Continue fixing the tree as long as the parent of z is red
         while (((_a = z === null || z === void 0 ? void 0 : z.parent) === null || _a === void 0 ? void 0 : _a.color) === 'RED') {
             // Check if the parent of z is the left child of its parent
@@ -450,7 +406,7 @@ class RedBlackTree extends bst_1.BST {
             else {
                 // Symmetric case for the right child (left and right exchanged)
                 // Follow the same logic as above with left and right exchanged
-                const y = (_d = (_c = z === null || z === void 0 ? void 0 : z.parent) === null || _c === void 0 ? void 0 : _c.parent) === null || _d === void 0 ? void 0 : _d.left;
+                const y = (_e = (_d = (_c = z === null || z === void 0 ? void 0 : z.parent) === null || _c === void 0 ? void 0 : _c.parent) === null || _d === void 0 ? void 0 : _d.left) !== null && _e !== void 0 ? _e : undefined;
                 if ((y === null || y === void 0 ? void 0 : y.color) === 'RED') {
                     z.parent.color = 'BLACK';
                     y.color = 'BLACK';
@@ -623,5 +579,33 @@ class RedBlackTree extends bst_1.BST {
         x.right = y;
         y.parent = x;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript overrides the default behavior to create a new Red-Black Tree by
+     * applying a callback to each entry in the original tree.
+     * @param callback - A function that will be called for each entry in the tree, with parameters
+     * representing the key, value, index, and the tree itself. It should return an entry for the new
+     * tree.
+     * @param [options] - The `options` parameter in the `map` method is of type `RedBlackTreeOptions<MK, MV,
+     * MR>`. This parameter allows you to specify additional options or configurations for the Red-Black
+     * Tree that will be created during the mapping process. These options could include things like
+     * custom comparators
+     * @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 A new Red-Black Tree is being returned, where each entry has been transformed using the
+     * provided callback function.
+     */
+    map(callback, options, thisArg) {
+        const newTree = new RedBlackTree([], options);
+        let index = 0;
+        for (const [key, value] of this) {
+            newTree.add(callback.call(thisArg, key, value, index++, this));
+        }
+        return newTree;
+    }
 }
 exports.RedBlackTree = RedBlackTree;

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BSTNOptKeyOrNode, BTNRep, IterationType, RBTNColor, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNOptKeyOrNode, BTNRep, EntryCallback, IterationType, RBTNColor, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
 export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>> extends RedBlackTreeNode<K, V, NODE> {
@@ -22,20 +22,8 @@ export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMa
      * in a Red-Black Tree. It is optional and has a default value of `'BLACK'`.
      */
     constructor(key: K, value?: V, count?: number, color?: RBTNColor);
-    protected _count: number;
-    /**
-     * The function returns the value of the private variable _count.
-     * @returns The count property of the object, which is of type number.
-     */
-    get count(): number;
-    /**
-     * The above function sets the value of the count property.
-     * @param {number} value - The value parameter is of type number, which means it can accept any
-     * numeric value.
-     */
-    set count(value: number);
 }
-export declare class TreeMultiMap<K = any, V = any, R = object, 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 = object, MK = any, MV = any, MR = object, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>, TREE extends TreeMultiMap<K, V, R, MK, MV, MR, NODE, TREE> = TreeMultiMap<K, V, R, MK, MV, MR, NODE, TreeMultiMapNested<K, V, R, MK, MV, MR, NODE>>> extends RedBlackTree<K, V, R, MK, MV, MR, NODE, TREE> implements IBinaryTree<K, V, R, MK, MV, MR, NODE, TREE> {
     /**
      * The constructor function initializes a TreeMultiMap object with optional initial data.
      * @param keysNodesEntriesOrRaws - The parameter `keysNodesEntriesOrRaws` is an
@@ -195,4 +183,20 @@ export declare class TreeMultiMap<K = any, V = any, R = object, NODE extends Tre
      * superclass, which is of type `NODE`.
      */
     protected _replaceNode(oldNode: NODE, newNode: NODE): NODE;
+    /**
+     * The `map` function in TypeScript overrides the default behavior to create a new TreeMultiMap 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
+     * map. It takes four arguments:
+     * @param [options] - The `options` parameter in the `override map` function is of type
+     * `TreeMultiMapOptions<MK, MV, MR>`. This parameter allows you to provide additional configuration
+     * options when creating a new `TreeMultiMap` instance within the `map` function. These options could
+     * include things like
+     * @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 when it is called within the `map` function. This
+     * @returns A new TreeMultiMap instance is being returned, which is populated with entries generated
+     * by the provided callback function.
+     */
+    map(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: TreeMultiMapOptions<MK, MV, MR>, thisArg?: any): TreeMultiMap<MK, MV, MR>;
 }

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

@@ -17,24 +17,8 @@ class TreeMultiMapNode extends red_black_tree_1.RedBlackTreeNode {
      */
     constructor(key, value, count = 1, color = 'BLACK') {
         super(key, value, color);
-        this._count = 1;
         this.count = count;
     }
-    /**
-     * The function returns the value of the private variable _count.
-     * @returns The count property of the object, which is of type number.
-     */
-    get count() {
-        return this._count;
-    }
-    /**
-     * The above function sets the value of the count property.
-     * @param {number} value - The value parameter is of type number, which means it can accept any
-     * numeric value.
-     */
-    set count(value) {
-        this._count = value;
-    }
 }
 exports.TreeMultiMapNode = TreeMultiMapNode;
 class TreeMultiMap extends red_black_tree_1.RedBlackTree {
@@ -99,7 +83,7 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
      * existing `iterationType` property. The returned value is casted as `TREE`.
      */
     createTree(options) {
-        return new TreeMultiMap([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, extractComparable: this._extractComparable, toEntryFn: this._toEntryFn }, options));
+        return new TreeMultiMap([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, specifyComparable: this._specifyComparable, toEntryFn: this._toEntryFn }, options));
     }
     /**
      * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
@@ -204,10 +188,13 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
         let originalColor = nodeToDelete.color;
         let replacementNode;
         if (!this.isRealNode(nodeToDelete.left)) {
-            replacementNode = nodeToDelete.right;
+            if (nodeToDelete.right !== null)
+                replacementNode = nodeToDelete.right;
             if (ignoreCount || nodeToDelete.count <= 1) {
-                this._transplant(nodeToDelete, nodeToDelete.right);
-                this._count -= nodeToDelete.count;
+                if (nodeToDelete.right !== null) {
+                    this._transplant(nodeToDelete, nodeToDelete.right);
+                    this._count -= nodeToDelete.count;
+                }
             }
             else {
                 nodeToDelete.count--;
@@ -233,7 +220,8 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
             const successor = this.getLeftMost(node => node, nodeToDelete.right);
             if (successor) {
                 originalColor = successor.color;
-                replacementNode = successor.right;
+                if (successor.right !== null)
+                    replacementNode = successor.right;
                 if (successor.parent === nodeToDelete) {
                     if (this.isRealNode(replacementNode)) {
                         replacementNode.parent = successor;
@@ -241,8 +229,10 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
                 }
                 else {
                     if (ignoreCount || nodeToDelete.count <= 1) {
-                        this._transplant(successor, successor.right);
-                        this._count -= nodeToDelete.count;
+                        if (successor.right !== null) {
+                            this._transplant(successor, successor.right);
+                            this._count -= nodeToDelete.count;
+                        }
                     }
                     else {
                         nodeToDelete.count--;
@@ -412,5 +402,28 @@ class TreeMultiMap extends red_black_tree_1.RedBlackTree {
         newNode.count = oldNode.count + newNode.count;
         return super._replaceNode(oldNode, newNode);
     }
+    /**
+     * The `map` function in TypeScript overrides the default behavior to create a new TreeMultiMap 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
+     * map. It takes four arguments:
+     * @param [options] - The `options` parameter in the `override map` function is of type
+     * `TreeMultiMapOptions<MK, MV, MR>`. This parameter allows you to provide additional configuration
+     * options when creating a new `TreeMultiMap` instance within the `map` function. These options could
+     * include things like
+     * @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 when it is called within the `map` function. This
+     * @returns A new TreeMultiMap instance is being returned, which is populated with entries generated
+     * by the provided callback function.
+     */
+    map(callback, options, thisArg) {
+        const newTree = new TreeMultiMap([], options);
+        let index = 0;
+        for (const [key, value] of this) {
+            newTree.add(callback.call(thisArg, key, value, index++, this));
+        }
+        return newTree;
+    }
 }
 exports.TreeMultiMap = TreeMultiMap;

package/dist/data-structures/graph/abstract-graph.js

@@ -813,7 +813,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
         const filtered = [];
         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)) {
                 filtered.push([key, value]);
             }
             index++;
@@ -837,7 +837,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
         const mapped = [];
         let index = 0;
         for (const [key, value] of this) {
-            mapped.push(callback.call(thisArg, value, key, index, this));
+            mapped.push(callback.call(thisArg, key, value, index, this));
             index++;
         }
         return mapped;