queue-typed 1.53.8 → 1.53.9

package/src/data-structures/binary-tree/bst.ts

@@ -5,8 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type {
-  BSTNested,
+import {
   BSTNodeNested,
   BSTNOptKeyOrNode,
   BSTOptions,
@@ -15,6 +14,7 @@ import type {
   Comparator,
   CP,
   DFSOrderPattern,
+  EntryCallback,
   IterationType,
   NodeCallback,
   NodePredicate,
@@ -151,15 +151,9 @@ export class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNod
  *     console.log(findLCA(5, 35)); // 15
  *     console.log(findLCA(20, 30)); // 25
  */
-export 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 class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V, NODE> = BSTNode<K, V, BSTNodeNested<K, V>>>
+  extends BinaryTree<K, V, R, NODE>
+  implements IBinaryTree<K, V, R, NODE>
 {
   /**
    * This is the constructor function for a Binary Search Tree class in TypeScript.
@@ -173,8 +167,8 @@ export class BST<
     super([], options);
 
     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;
     }
 
@@ -202,6 +196,45 @@ export class BST<
     return this._isReverse;
   }
 
+  protected _comparator: Comparator<K> = (a: K, b: K): number => {
+    if (isComparable(a) && isComparable(b)) {
+      if (a > b) return 1;
+      if (a < b) return -1;
+      return 0;
+    }
+    if (this._specifyComparable) {
+      if (this._specifyComparable(a) > this._specifyComparable(b)) return 1;
+      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 specifyComparable must be defined in the constructor's options parameter.`
+      );
+    }
+
+    return 0;
+  };
+
+  /**
+   * The function returns the value of the _comparator property.
+   * @returns The `_comparator` property is being returned.
+   */
+  get comparator() {
+    return this._comparator;
+  }
+
+  protected _specifyComparable?: (key: K) => Comparable;
+
+  /**
+   * 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
@@ -215,39 +248,26 @@ export class BST<
   }
 
   /**
-   * 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.
    */
-  override createTree(options?: BSTOptions<K, V, R>): TREE {
-    return new BST<K, V, R, NODE, TREE>([], {
+  // @ts-ignore
+  override createTree(options?: BSTOptions<K, V, R>) {
+    return new BST<K, V, R>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
-      extractComparable: this._extractComparable,
+      specifyComparable: this._specifyComparable,
       toEntryFn: this._toEntryFn,
       isReverse: this._isReverse,
       ...options
-    }) as TREE;
-  }
-
-  /**
-   * 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.
-   */
-  protected override _keyValueNodeEntryRawToNodeAndValue(
-    keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R,
-    value?: V
-  ): [OptNode<NODE>, V | undefined] {
-    const [node, entryValue] = super._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
-    if (node === null) return [undefined, undefined];
-    return [node, value ?? entryValue];
+    });
   }
 
   /**
@@ -292,7 +312,7 @@ export class BST<
    * this._DEFAULT_COMPARATOR`.
    */
   override isKey(key: any): key is K {
-    return isComparable(key, this._extractComparable !== undefined);
+    return isComparable(key, this._specifyComparable !== undefined);
   }
 
   /**
@@ -472,7 +492,7 @@ export class BST<
    * @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`.
    */
-  override merge(anotherTree: BST<K, V, R, NODE, TREE>) {
+  override merge(anotherTree: this) {
     this.addMany(anotherTree, [], false);
   }
 
@@ -924,43 +944,36 @@ export class BST<
     return balanced;
   }
 
-  protected _comparator: Comparator<K> = (a: K, b: K): number => {
-    if (isComparable(a) && isComparable(b)) {
-      if (a > b) return 1;
-      if (a < b) return -1;
-      return 0;
-    }
-    if (this._extractComparable) {
-      if (this._extractComparable(a) > this._extractComparable(b)) return 1;
-      if (this._extractComparable(a) < this._extractComparable(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.`
-      );
+  // @ts-ignore
+  override map<MK, MV, MR>(
+    callback: EntryCallback<K, V | undefined, [MK, MV]>,
+    options?: BSTOptions<MK, MV, MR>,
+    thisArg?: any
+  ) {
+    const newTree = new BST<MK, MV, MR>([], options);
+    let index = 0;
+    for (const [key, value] of this) {
+      newTree.add(callback.call(thisArg, key, value, index++, this));
     }
-
-    return 0;
-  };
-
-  /**
-   * The function returns the value of the _comparator property.
-   * @returns The `_comparator` property is being returned.
-   */
-  get comparator() {
-    return this._comparator;
+    return newTree;
   }
 
-  protected _extractComparable?: (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.
+   * 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;
+  protected override _keyValueNodeEntryRawToNodeAndValue(
+    keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R,
+    value?: V
+  ): [OptNode<NODE>, V | undefined] {
+    const [node, entryValue] = super._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+    if (node === null) return [undefined, undefined];
+    return [node, value ?? entryValue];
   }
 
   /**

package/src/data-structures/binary-tree/red-black-tree.ts

@@ -2,10 +2,10 @@ import type {
   BinaryTreeDeleteResult,
   BTNRep,
   CRUD,
+  EntryCallback,
   OptNode,
   RBTNColor,
-  RBTreeOptions,
-  RedBlackTreeNested,
+  RedBlackTreeOptions,
   RedBlackTreeNodeNested
 } from '../../types';
 import { BST, BSTNode } from './bst';
@@ -108,23 +108,22 @@ export 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>>
+    NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>
   >
-  extends BST<K, V, R, NODE, TREE>
-  implements IBinaryTree<K, V, R, NODE, TREE>
+  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>) {
     super([], options);
 
     this._root = this.NIL;
@@ -163,19 +162,23 @@ export class RedBlackTree<
   }
 
   /**
-   * 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.
    */
-  override createTree(options?: RBTreeOptions<K, V, R>): TREE {
-    return new RedBlackTree<K, V, R, NODE, TREE>([], {
+  // @ts-ignore
+  override createTree(options?: RedBlackTreeOptions<K, V, R>) {
+    return new RedBlackTree<K, V, R>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
-      extractComparable: this._extractComparable,
+      specifyComparable: this._specifyComparable,
       toEntryFn: this._toEntryFn,
       ...options
-    }) as TREE;
+    });
   }
 
   /**
@@ -192,42 +195,6 @@ export class RedBlackTree<
     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)
@@ -353,6 +320,40 @@ export class RedBlackTree<
     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
+  override map<MK, MV, MR>(
+    callback: EntryCallback<K, V | undefined, [MK, MV]>,
+    options?: RedBlackTreeOptions<MK, MV, MR>,
+    thisArg?: any
+  ) {
+    const newTree = new RedBlackTree<MK, MV, MR>([], 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)
@@ -419,7 +420,7 @@ export class RedBlackTree<
 
     if (!parent) {
       this._setRoot(node);
-    } else if (node.key < parent.key) {
+    } else if (this._compare(node.key, parent.key) < 0) {
       parent.left = node;
     } else {
       parent.right = node;

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

@@ -9,10 +9,10 @@ import type {
   BinaryTreeDeleteResult,
   BSTNOptKeyOrNode,
   BTNRep,
+  EntryCallback,
   IterationType,
   OptNode,
   RBTNColor,
-  TreeMultiMapNested,
   TreeMultiMapNodeNested,
   TreeMultiMapOptions
 } from '../../types';
@@ -65,11 +65,10 @@ export 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>>
+    NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>
   >
-  extends RedBlackTree<K, V, R, NODE, TREE>
-  implements IBinaryTree<K, V, R, NODE, TREE>
+  extends RedBlackTree<K, V, R, NODE>
+  implements IBinaryTree<K, V, R, NODE>
 {
   /**
    * The constructor function initializes a TreeMultiMap object with optional initial data.
@@ -135,53 +134,15 @@ export class TreeMultiMap<
    * @returns a new instance of the `TreeMultiMap` class, with the provided options merged with the
    * existing `iterationType` property. The returned value is casted as `TREE`.
    */
-  override createTree(options?: TreeMultiMapOptions<K, V, R>): TREE {
-    return new TreeMultiMap<K, V, R, NODE, TREE>([], {
+  // @ts-ignore
+  override createTree(options?: TreeMultiMapOptions<K, V, R>) {
+    return new TreeMultiMap<K, V, R, NODE>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
-      extractComparable: this._extractComparable,
+      specifyComparable: this._specifyComparable,
       toEntryFn: this._toEntryFn,
       ...options
-    }) as TREE;
-  }
-
-  /**
-   * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
-   * node based on the input.
-   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-   * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-   * @param {V} [value] - The `value` parameter is an optional value that represents the value
-   * associated with the key in the node. It is used when creating a new node or updating the value of
-   * an existing node.
-   * @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;
-      if (this.isKey(key)) return [this.createNode(key, finalValue, 'BLACK', 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, 'BLACK', count), finalValue];
-    }
-
-    if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value, 'BLACK', count), value];
-
-    return [undefined, undefined];
+    });
   }
 
   /**
@@ -402,13 +363,82 @@ export class TreeMultiMap<
    * The function overrides the clone method to create a deep copy of a tree object.
    * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
    */
-  override clone(): TREE {
+  // @ts-ignore
+  override clone() {
     const cloned = this.createTree();
     this.bfs(node => cloned.add(node.key, undefined, node.count));
     if (this._isMapMode) cloned._store = this._store;
     return cloned;
   }
 
+  /**
+   * 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.
+   */
+  // @ts-ignore
+  override map<MK, MV, MR>(
+    callback: EntryCallback<K, V | undefined, [MK, MV]>,
+    options?: TreeMultiMapOptions<MK, MV, MR>,
+    thisArg?: any
+  ) {
+    const newTree = new TreeMultiMap<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` takes in a key, value, and count and returns a
+   * node based on the input.
+   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+   * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+   * @param {V} [value] - The `value` parameter is an optional value that represents the value
+   * associated with the key in the node. It is used when creating a new node or updating the value of
+   * an existing node.
+   * @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;
+      if (this.isKey(key)) return [this.createNode(key, finalValue, 'BLACK', 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, 'BLACK', count), finalValue];
+    }
+
+    if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value, 'BLACK', count), value];
+
+    return [undefined, undefined];
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)

package/src/data-structures/graph/abstract-graph.ts

@@ -947,7 +947,7 @@ export abstract class AbstractGraph<
     const filtered: [VertexKey, V | undefined][] = [];
     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++;
@@ -972,7 +972,7 @@ export abstract class AbstractGraph<
     const mapped: T[] = [];
     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;

package/src/data-structures/hash/hash-map.ts

@@ -287,7 +287,7 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
     const resultMap = new HashMap<K, VM>();
     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;
   }
@@ -312,7 +312,7 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
     const filteredMap = new HashMap<K, V>();
     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);
       }
     }
@@ -826,7 +826,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     const filteredMap = new LinkedHashMap<K, V>();
     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++;
@@ -851,12 +851,12 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
    * @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> {
-    const mappedMap = new LinkedHashMap<K, VM>();
+  map<MK, MV>(callback: EntryCallback<K, V, [MK, MV]>, thisArg?: any): LinkedHashMap<MK, MV> {
+    const mappedMap = new LinkedHashMap<MK, MV>();
     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/src/data-structures/linked-list/doubly-linked-list.ts

@@ -588,6 +588,19 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     return this.tail?.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<E>(data: E[]) {
+    return new DoublyLinkedList<E>(data);
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -1252,19 +1265,6 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     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<E>(data: E[]) {
-    return new DoublyLinkedList<E>(data);
-  }
-
   /**
    * The function returns an iterator that iterates over the values of a linked list.
    */