directed-graph-typed 1.53.7 → 1.53.9

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

@@ -4,6 +4,7 @@ exports.BST = exports.BSTNode = void 0;
 const binary_tree_1 = require("./binary-tree");
 const queue_1 = require("../queue");
 const utils_1 = require("../../utils");
+const common_1 = require("../../common");
 class BSTNode extends binary_tree_1.BinaryTreeNode {
     constructor(key, value) {
         super(key, value);
@@ -59,32 +60,48 @@ exports.BSTNode = BSTNode;
  * 6. Balance Variability: Can become unbalanced; special types maintain balance.
  * 7. No Auto-Balancing: Standard BSTs don't automatically balance themselves.
  * @example
- * // Find kth smallest element
- *     // Create a BST with some elements
- *     const bst = new BST<number>([5, 3, 7, 1, 4, 6, 8]);
- *     const sortedKeys = bst.dfs(node => node.key, 'IN');
+ * // Merge 3 sorted datasets
+ *     const dataset1 = new BST<number, string>([
+ *       [1, 'A'],
+ *       [7, 'G']
+ *     ]);
+ *     const dataset2 = [
+ *       [2, 'B'],
+ *       [6, 'F']
+ *     ];
+ *     const dataset3 = new BST<number, string>([
+ *       [3, 'C'],
+ *       [5, 'E'],
+ *       [4, 'D']
+ *     ]);
  *
- *     // Helper function to find kth smallest
- *     const findKthSmallest = (k: number): number | undefined => {
- *       return sortedKeys[k - 1];
- *     };
+ *     // Merge datasets into a single BinarySearchTree
+ *     const merged = new BST<number, string>(dataset1);
+ *     merged.addMany(dataset2);
+ *     merged.merge(dataset3);
  *
- *     // Assertions
- *     console.log(findKthSmallest(1)); // 1
- *     console.log(findKthSmallest(3)); // 4
- *     console.log(findKthSmallest(7)); // 8
+ *     // Verify merged dataset is in sorted order
+ *     console.log([...merged.values()]); // ['A', 'B', 'C', 'D', 'E', 'F', 'G']
  * @example
  * // Find elements in a range
  *     const bst = new BST<number>([10, 5, 15, 3, 7, 12, 18]);
  *     console.log(bst.search(new Range(5, 10))); // [10, 5, 7]
- *     console.log(bst.search(new Range(4, 12))); // [10, 12, 5, 7]
+ *     console.log(bst.rangeSearch([4, 12], node => node.key.toString())); // ['10', '12', '5', '7']
  *     console.log(bst.search(new Range(4, 12, true, false))); // [10, 5, 7]
- *     console.log(bst.search(new Range(15, 20))); // [15, 18]
+ *     console.log(bst.rangeSearch([15, 20])); // [15, 18]
  *     console.log(bst.search(new Range(15, 20, false))); // [18]
  * @example
  * // Find lowest common ancestor
  *     const bst = new BST<number>([20, 10, 30, 5, 15, 25, 35, 3, 7, 12, 18]);
  *
+ *     // LCA helper function
+ *     const findLCA = (num1: number, num2: number): number | undefined => {
+ *       const path1 = bst.getPathToRoot(num1);
+ *       const path2 = bst.getPathToRoot(num2);
+ *       // Find the first common ancestor
+ *       return findFirstCommon(path1, path2);
+ *     };
+ *
  *     function findFirstCommon(arr1: number[], arr2: number[]): number | undefined {
  *       for (const num of arr1) {
  *         if (arr2.indexOf(num) !== -1) {
@@ -94,14 +111,6 @@ exports.BSTNode = BSTNode;
  *       return undefined;
  *     }
  *
- *     // LCA helper function
- *     const findLCA = (num1: number, num2: number): number | undefined => {
- *       const path1 = bst.getPathToRoot(num1);
- *       const path2 = bst.getPathToRoot(num2);
- *       // Find the first common ancestor
- *       return findFirstCommon(path1, path2);
- *     };
- *
  *     // Assertions
  *     console.log(findLCA(3, 10)); // 7
  *     console.log(findLCA(5, 35)); // 15
@@ -128,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;
         }
@@ -165,6 +174,21 @@ class BST extends binary_tree_1.BinaryTree {
     get isReverse() {
         return this._isReverse;
     }
+    /**
+     * The function returns the value of the _comparator property.
+     * @returns The `_comparator` property is being returned.
+     */
+    get comparator() {
+        return this._comparator;
+    }
+    /**
+     * 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 specifyComparable() {
+        return this._specifyComparable;
+    }
     /**
      * The function creates a new BSTNode with the given key and value and returns it.
      * @param {K} key - The key parameter is of type K, which represents the type of the key for the node
@@ -177,29 +201,19 @@ class BST extends binary_tree_1.BinaryTree {
         return new BSTNode(key, this._isMapMode ? undefined : value);
     }
     /**
-     * The function creates a new binary search tree with the specified options.
-     * @param [options] - The `options` parameter is an optional object that allows you to customize the
-     * behavior of the `createTree` method. It accepts a partial `BSTOptions` object, which has the
-     * following properties:
-     * @returns a new instance of the BST class with the provided options.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `createTree` function in TypeScript overrides the default options with the provided options to
+     * create a new Binary Search Tree.
+     * @param [options] - The `options` parameter in the `createTree` method is an optional object that
+     * can contain the following properties:
+     * @returns A new instance of a Binary Search Tree (BST) is being returned with the specified options
+     * and properties inherited from the current instance.
      */
+    // @ts-ignore
     createTree(options) {
-        return new BST([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, extractComparable: this._extractComparable, 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.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - A variable that can be of
-     * type R or BTNRep<K, V, NODE>. It represents either a key, a node, an entry, or a raw
-     * element.
-     * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
-     * value associated with a key in a key-value pair.
-     * @returns either a NODE object or undefined.
-     */
-    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
-        const [node, entryValue] = super.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
-        if (node === null)
-            return [undefined, undefined];
-        return [node, value !== null && value !== void 0 ? value : entryValue];
+        return new BST([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, specifyComparable: this._specifyComparable, toEntryFn: this._toEntryFn, isReverse: this._isReverse }, options));
     }
     /**
      * Time Complexity: O(log n)
@@ -239,7 +253,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)
@@ -253,7 +267,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns a boolean value.
      */
     add(keyNodeEntryOrRaw, value) {
-        const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+        const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
         if (newNode === undefined)
             return false;
         if (this._root === undefined) {
@@ -547,6 +561,31 @@ class BST extends binary_tree_1.BinaryTree {
         }
         return ans;
     }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(n)
+     *
+     * The `rangeSearch` function searches for nodes within a specified range in a binary search tree.
+     * @param {Range<K> | [K, K]} range - The `range` parameter in the `rangeSearch` function can be
+     * either a `Range` object or an array of two elements representing the range boundaries.
+     * @param {C} callback - The `callback` parameter in the `rangeSearch` function is a callback
+     * function that is used to process each node that is found within the specified range during the
+     * search operation. It is of type `NodeCallback<NODE>`, where `NODE` is the type of nodes in the
+     * data structure.
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `rangeSearch`
+     * function represents the node from which the search for nodes within the specified range will
+     * begin. It is the starting point for the range search operation.
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `rangeSearch` function
+     * is used to specify the type of iteration to be performed during the search operation. It has a
+     * default value of `this.iterationType`, which suggests that it is likely a property of the class or
+     * object that the `rangeSearch`
+     * @returns The `rangeSearch` function is returning the result of calling the `search` method with
+     * the specified parameters.
+     */
+    rangeSearch(range, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+        const searchRange = range instanceof common_1.Range ? range : new common_1.Range(range[0], range[1]);
+        return this.search(searchRange, false, callback, startNode, iterationType);
+    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -806,20 +845,29 @@ class BST extends binary_tree_1.BinaryTree {
         }
         return balanced;
     }
-    /**
-     * The function returns the value of the _comparator property.
-     * @returns The `_comparator` property is being returned.
-     */
-    get comparator() {
-        return this._comparator;
+    // @ts-ignore
+    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;
     }
     /**
-     * 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.
+     * The function overrides a method and converts a key, value pair or entry or raw element to a node.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - A variable that can be of
+     * type R or BTNRep<K, V, NODE>. It represents either a key, a node, an entry, or a raw
+     * element.
+     * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
+     * value associated with a key in a key-value pair.
+     * @returns either a NODE object or undefined.
      */
-    get extractComparable() {
-        return this._extractComparable;
+    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
+        const [node, entryValue] = super._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+        if (node === null)
+            return [undefined, undefined];
+        return [node, value !== null && value !== void 0 ? value : entryValue];
     }
     /**
      * The function sets the root of a tree-like structure and updates the parent property of the new

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

@@ -3,6 +3,6 @@ export * from './bst';
 export * from './binary-indexed-tree';
 export * from './segment-tree';
 export * from './avl-tree';
-export * from './rb-tree';
+export * from './red-black-tree';
 export * from './avl-tree-multi-map';
 export * from './tree-multi-map';

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

@@ -19,6 +19,6 @@ __exportStar(require("./bst"), exports);
 __exportStar(require("./binary-indexed-tree"), exports);
 __exportStar(require("./segment-tree"), exports);
 __exportStar(require("./avl-tree"), exports);
-__exportStar(require("./rb-tree"), exports);
+__exportStar(require("./red-black-tree"), exports);
 __exportStar(require("./avl-tree-multi-map"), exports);
 __exportStar(require("./tree-multi-map"), exports);

package/dist/data-structures/binary-tree/{rb-tree.d.ts → 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, 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> {
@@ -29,19 +29,68 @@ export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTre
 /**
  * 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.
  * 2. It is BST itself. Compared with Heap which is not completely ordered, RedBlackTree is completely ordered.
+ * @example
+ * // Find elements in a range
+ *     const bst = new RedBlackTree<number>([10, 5, 15, 3, 7, 12, 18]);
+ *     console.log(bst.search(new Range(5, 10))); // [5, 10, 7]
+ *     console.log(bst.search(new Range(4, 12))); // [5, 10, 12, 7]
+ *     console.log(bst.search(new Range(15, 20))); // [15, 18]
+ * @example
+ * // using Red-Black Tree as a price-based index for stock data
+ *     // Define the structure of individual stock records
+ *     interface StockRecord {
+ *       price: number; // Stock price (key for indexing)
+ *       symbol: string; // Stock ticker symbol
+ *       volume: number; // Trade volume
+ *     }
+ *
+ *     // Simulate stock market data as it might come from an external feed
+ *     const marketStockData: StockRecord[] = [
+ *       { price: 142.5, symbol: 'AAPL', volume: 1000000 },
+ *       { price: 335.2, symbol: 'MSFT', volume: 800000 },
+ *       { price: 3285.04, symbol: 'AMZN', volume: 500000 },
+ *       { price: 267.98, symbol: 'META', volume: 750000 },
+ *       { price: 234.57, symbol: 'GOOGL', volume: 900000 }
+ *     ];
+ *
+ *     // Extend the stock record type to include metadata for database usage
+ *     type StockTableRecord = StockRecord & { lastUpdated: Date };
+ *
+ *     // Create a Red-Black Tree to index stock records by price
+ *     // Simulates a database index with stock price as the key for quick lookups
+ *     const priceIndex = new RedBlackTree<number, StockTableRecord, StockRecord>(marketStockData, {
+ *       toEntryFn: stockRecord => [
+ *         stockRecord.price, // Use stock price as the key
+ *         {
+ *           ...stockRecord,
+ *           lastUpdated: new Date() // Add a timestamp for when the record was indexed
+ *         }
+ *       ]
+ *     });
+ *
+ *     // Query the stock with the highest price
+ *     const highestPricedStock = priceIndex.getRightMost();
+ *     console.log(priceIndex.get(highestPricedStock)?.symbol); // 'AMZN' // Amazon has the highest price
+ *
+ *     // Query stocks within a specific price range (200 to 400)
+ *     const stocksInRange = priceIndex.rangeSearch(
+ *       [200, 400], // Price range
+ *       node => priceIndex.get(node)?.symbol // Extract stock symbols for the result
+ *     );
+ *     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, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>> extends BST<K, V, R, NODE> implements IBinaryTree<K, V, R, NODE> {
     /**
      * 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.
+     * initialize the RedBlackTree 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.
@@ -64,12 +113,15 @@ export declare class RedBlackTree<K = any, V = any, R = object, NODE extends Red
      */
     createNode(key: K, value?: V, color?: RBTNColor): NODE;
     /**
-     * The function creates a new Red-Black Tree with the specified options.
-     * @param [options] - The `options` parameter is an optional object that contains additional
-     * configuration options for creating the Red-Black Tree. It has the following properties:
-     * @returns a new instance of a RedBlackTree object.
+     * The function `createTree` overrides the default implementation to create a Red-Black Tree with
+     * specified options in TypeScript.
+     * @param [options] - The `options` parameter in the `createTree` method is of type `RedBlackTreeOptions<K,
+     * V, R>`, which is a generic type with three type parameters `K`, `V`, and `R`. This parameter
+     * allows you to pass additional configuration options when creating a new Red-
+     * @returns A new instance of a RedBlackTree with the specified options and properties from the
+     * current object is being returned.
      */
-    createTree(options?: RBTreeOptions<K, V, R>): TREE;
+    createTree(options?: RedBlackTreeOptions<K, V, R>): RedBlackTree<K, V, R, RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -120,6 +172,27 @@ export declare class RedBlackTree<K = any, V = any, R = object, NODE extends Red
      * balancing is needed.
      */
     delete(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): BinaryTreeDeleteResult<NODE>[];
+    /**
+     * 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<MK, MV, MR>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: RedBlackTreeOptions<MK, MV, MR>, thisArg?: any): RedBlackTree<MK, MV, MR, RedBlackTreeNode<MK, MV, RedBlackTreeNodeNested<MK, MV>>>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

package/dist/data-structures/binary-tree/{rb-tree.js → red-black-tree.js}

@@ -37,15 +37,64 @@ exports.RedBlackTreeNode = RedBlackTreeNode;
 /**
  * 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.
  * 2. It is BST itself. Compared with Heap which is not completely ordered, RedBlackTree is completely ordered.
+ * @example
+ * // Find elements in a range
+ *     const bst = new RedBlackTree<number>([10, 5, 15, 3, 7, 12, 18]);
+ *     console.log(bst.search(new Range(5, 10))); // [5, 10, 7]
+ *     console.log(bst.search(new Range(4, 12))); // [5, 10, 12, 7]
+ *     console.log(bst.search(new Range(15, 20))); // [15, 18]
+ * @example
+ * // using Red-Black Tree as a price-based index for stock data
+ *     // Define the structure of individual stock records
+ *     interface StockRecord {
+ *       price: number; // Stock price (key for indexing)
+ *       symbol: string; // Stock ticker symbol
+ *       volume: number; // Trade volume
+ *     }
+ *
+ *     // Simulate stock market data as it might come from an external feed
+ *     const marketStockData: StockRecord[] = [
+ *       { price: 142.5, symbol: 'AAPL', volume: 1000000 },
+ *       { price: 335.2, symbol: 'MSFT', volume: 800000 },
+ *       { price: 3285.04, symbol: 'AMZN', volume: 500000 },
+ *       { price: 267.98, symbol: 'META', volume: 750000 },
+ *       { price: 234.57, symbol: 'GOOGL', volume: 900000 }
+ *     ];
+ *
+ *     // Extend the stock record type to include metadata for database usage
+ *     type StockTableRecord = StockRecord & { lastUpdated: Date };
+ *
+ *     // Create a Red-Black Tree to index stock records by price
+ *     // Simulates a database index with stock price as the key for quick lookups
+ *     const priceIndex = new RedBlackTree<number, StockTableRecord, StockRecord>(marketStockData, {
+ *       toEntryFn: stockRecord => [
+ *         stockRecord.price, // Use stock price as the key
+ *         {
+ *           ...stockRecord,
+ *           lastUpdated: new Date() // Add a timestamp for when the record was indexed
+ *         }
+ *       ]
+ *     });
+ *
+ *     // Query the stock with the highest price
+ *     const highestPricedStock = priceIndex.getRightMost();
+ *     console.log(priceIndex.get(highestPricedStock)?.symbol); // 'AMZN' // Amazon has the highest price
+ *
+ *     // Query stocks within a specific price range (200 to 400)
+ *     const stocksInRange = priceIndex.rangeSearch(
+ *       [200, 400], // Price range
+ *       node => priceIndex.get(node)?.symbol // Extract stock symbols for the result
+ *     );
+ *     console.log(stocksInRange); // ['GOOGL', 'MSFT', 'META']
  */
 class RedBlackTree extends bst_1.BST {
     /**
      * 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.
+     * initialize the RedBlackTree 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
      */
@@ -81,13 +130,17 @@ class RedBlackTree extends bst_1.BST {
         return new RedBlackTreeNode(key, this._isMapMode ? undefined : value, color);
     }
     /**
-     * The function creates a new Red-Black Tree with the specified options.
-     * @param [options] - The `options` parameter is an optional object that contains additional
-     * configuration options for creating the Red-Black Tree. It has the following properties:
-     * @returns a new instance of a RedBlackTree object.
+     * The function `createTree` overrides the default implementation to create a Red-Black Tree with
+     * specified options in TypeScript.
+     * @param [options] - The `options` parameter in the `createTree` method is of type `RedBlackTreeOptions<K,
+     * V, R>`, which is a generic type with three type parameters `K`, `V`, and `R`. This parameter
+     * allows you to pass additional configuration options when creating a new Red-
+     * @returns A new instance of a RedBlackTree with the specified options and properties from the
+     * current object is being returned.
      */
+    // @ts-ignore
     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)
@@ -102,41 +155,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)
@@ -164,7 +182,7 @@ class RedBlackTree extends bst_1.BST {
      * returns true. If the node cannot be added or updated, the method returns false.
      */
     add(keyNodeEntryOrRaw, value) {
-        const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+        const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
         if (!this.isRealNode(newNode))
             return false;
         const insertStatus = this._insert(newNode);
@@ -259,6 +277,35 @@ class RedBlackTree extends bst_1.BST {
         results.push({ deleted: nodeToDelete, needBalanced: undefined });
         return results;
     }
+    /**
+     * 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.
+     */
+    // @ts-ignore
+    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;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -323,7 +370,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 {