undirected-graph-typed 1.53.7 → 1.53.9

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

@@ -5,9 +5,9 @@
  * @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, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
 import { IBinaryTree } from '../../interfaces';
-import { RedBlackTree, RedBlackTreeNode } from './rb-tree';
+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> {
     /**
      * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
@@ -35,7 +35,7 @@ export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMa
      */
     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, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>> extends RedBlackTree<K, V, R, NODE> implements IBinaryTree<K, V, R, NODE> {
     /**
      * The constructor function initializes a TreeMultiMap object with optional initial data.
      * @param keysNodesEntriesOrRaws - The parameter `keysNodesEntriesOrRaws` is an
@@ -83,20 +83,7 @@ export declare class TreeMultiMap<K = any, V = any, R = object, NODE extends Tre
      * @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`.
      */
-    createTree(options?: TreeMultiMapOptions<K, V, R>): 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.
-     */
-    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V, count?: number): [NODE | undefined, V | undefined];
+    createTree(options?: TreeMultiMapOptions<K, V, R>): TreeMultiMap<K, V, R, NODE>;
     /**
      * The function checks if the input is an instance of the TreeMultiMapNode class.
      * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
@@ -167,7 +154,36 @@ export declare class TreeMultiMap<K = any, V = any, R = object, NODE extends Tre
      * 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.
      */
-    clone(): TREE;
+    clone(): TreeMultiMap<K, V, R, 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<MK, MV, MR>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: TreeMultiMapOptions<MK, MV, MR>, thisArg?: any): TreeMultiMap<MK, MV, MR, TreeMultiMapNode<MK, MV, TreeMultiMapNodeNested<MK, MV>>>;
+    /**
+     * 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 _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V, count?: number): [NODE | undefined, V | undefined];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeMultiMap = exports.TreeMultiMapNode = void 0;
-const rb_tree_1 = require("./rb-tree");
-class TreeMultiMapNode extends rb_tree_1.RedBlackTreeNode {
+const red_black_tree_1 = require("./red-black-tree");
+class TreeMultiMapNode extends red_black_tree_1.RedBlackTreeNode {
     /**
      * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
      * @param {K} key - The key parameter represents the key of the node in the Red-Black Tree. It is
@@ -37,7 +37,7 @@ class TreeMultiMapNode extends rb_tree_1.RedBlackTreeNode {
     }
 }
 exports.TreeMultiMapNode = TreeMultiMapNode;
-class TreeMultiMap extends rb_tree_1.RedBlackTree {
+class TreeMultiMap extends red_black_tree_1.RedBlackTree {
     /**
      * The constructor function initializes a TreeMultiMap object with optional initial data.
      * @param keysNodesEntriesOrRaws - The parameter `keysNodesEntriesOrRaws` is an
@@ -98,43 +98,9 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      * @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`.
      */
+    // @ts-ignore
     createTree(options) {
-        return new TreeMultiMap([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, extractComparable: this._extractComparable, toEntryFn: this._toEntryFn }, options));
-    }
-    /**
-     * 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.
-     */
-    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count = 1) {
-        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 !== null && value !== void 0 ? 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 !== null && value !== void 0 ? 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];
+        return new TreeMultiMap([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, specifyComparable: this._specifyComparable, toEntryFn: this._toEntryFn }, options));
     }
     /**
      * The function checks if the input is an instance of the TreeMultiMapNode class.
@@ -163,7 +129,7 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      * was successful, and false otherwise.
      */
     add(keyNodeEntryOrRaw, value, count = 1) {
-        const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
+        const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
         const orgCount = (newNode === null || newNode === void 0 ? void 0 : newNode.count) || 0;
         const isSuccessAdded = super.add(newNode, newValue);
         if (isSuccessAdded) {
@@ -353,6 +319,7 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      * 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.
      */
+    // @ts-ignore
     clone() {
         const cloned = this.createTree();
         this.bfs(node => cloned.add(node.key, undefined, node.count));
@@ -360,6 +327,65 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
             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
+    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;
+    }
+    /**
+     * 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.
+     */
+    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count = 1) {
+        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 !== null && value !== void 0 ? 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 !== null && value !== void 0 ? 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/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;

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

@@ -62,6 +62,9 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      */
     get hashFn(): (key: K) => string;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if a given element is an array with exactly two elements.
      * @param {any} rawElement - The `rawElement` parameter is of type `any`, which means it can be any
      * data type.
@@ -69,16 +72,25 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      */
     isEntry(rawElement: any): rawElement is [K, V];
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if the size of an object is equal to zero and returns a boolean value.
      * @returns A boolean value indicating whether the size of the object is 0 or not.
      */
     isEmpty(): boolean;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear() function resets the state of an object by clearing its internal store, object map, and
      * size.
      */
     clear(): void;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `set` function adds a key-value pair to a map-like data structure, incrementing the size if
      * the key is not already present.
      * @param {K} key - The key parameter is the key used to identify the value in the data structure. It
@@ -89,6 +101,9 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      */
     set(key: K, value: V): boolean;
     /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
      * The function `setMany` takes an iterable collection of objects, maps each object to a key-value
      * pair using a mapping function, and sets each key-value pair in the current object.
      * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements of a type
@@ -97,6 +112,9 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      */
     setMany(entryOrRawElements: Iterable<R | [K, V]>): boolean[];
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `get` function retrieves a value from a map based on a given key, either from an object map or
      * a string map.
      * @param {K} key - The `key` parameter is the key used to retrieve a value from the map. It can be
@@ -106,6 +124,9 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      */
     get(key: K): V | undefined;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `has` function checks if a given key exists in the `_objMap` or `_store` based on whether it
      * is an object key or not.
      * @param {K} key - The parameter "key" is of type K, which means it can be any type.
@@ -113,6 +134,9 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      */
     has(key: K): boolean;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `delete` function removes an element from a map-like data structure based on the provided key.
      * @param {K} key - The `key` parameter is the key of the element that you want to delete from the
      * data structure.
@@ -292,6 +316,9 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      */
     set(key: K, value?: V): boolean;
     /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
      * The function `setMany` takes an iterable collection, converts each element into a key-value pair
      * using a provided function, and sets each key-value pair in the current object, returning an array
      * of booleans indicating the success of each set operation.
@@ -301,6 +328,9 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      */
     setMany(entryOrRawElements: Iterable<R | [K, V]>): boolean[];
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if a given key exists in a map, using different logic depending on whether the
      * key is a weak key or not.
      * @param {K} key - The `key` parameter is the key that is being checked for existence in the map.
@@ -420,7 +450,7 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      * @returns a new `LinkedHashMap` object with the values mapped according to the provided callback
      * function.
      */
-    map<VM>(callback: EntryCallback<K, V, VM>, thisArg?: any): LinkedHashMap<K, VM>;
+    map<MK, MV>(callback: EntryCallback<K, V, [MK, MV]>, thisArg?: any): LinkedHashMap<MK, MV>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)

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

@@ -75,6 +75,9 @@ class HashMap extends base_1.IterableEntryBase {
         return this._hashFn;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if a given element is an array with exactly two elements.
      * @param {any} rawElement - The `rawElement` parameter is of type `any`, which means it can be any
      * data type.
@@ -84,6 +87,9 @@ class HashMap extends base_1.IterableEntryBase {
         return Array.isArray(rawElement) && rawElement.length === 2;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if the size of an object is equal to zero and returns a boolean value.
      * @returns A boolean value indicating whether the size of the object is 0 or not.
      */
@@ -91,6 +97,9 @@ class HashMap extends base_1.IterableEntryBase {
         return this._size === 0;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear() function resets the state of an object by clearing its internal store, object map, and
      * size.
      */
@@ -100,6 +109,9 @@ class HashMap extends base_1.IterableEntryBase {
         this._size = 0;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `set` function adds a key-value pair to a map-like data structure, incrementing the size if
      * the key is not already present.
      * @param {K} key - The key parameter is the key used to identify the value in the data structure. It
@@ -125,6 +137,9 @@ class HashMap extends base_1.IterableEntryBase {
         return true;
     }
     /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
      * The function `setMany` takes an iterable collection of objects, maps each object to a key-value
      * pair using a mapping function, and sets each key-value pair in the current object.
      * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements of a type
@@ -150,6 +165,9 @@ class HashMap extends base_1.IterableEntryBase {
         return results;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `get` function retrieves a value from a map based on a given key, either from an object map or
      * a string map.
      * @param {K} key - The `key` parameter is the key used to retrieve a value from the map. It can be
@@ -168,6 +186,9 @@ class HashMap extends base_1.IterableEntryBase {
         }
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `has` function checks if a given key exists in the `_objMap` or `_store` based on whether it
      * is an object key or not.
      * @param {K} key - The parameter "key" is of type K, which means it can be any type.
@@ -183,6 +204,9 @@ class HashMap extends base_1.IterableEntryBase {
         }
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The `delete` function removes an element from a map-like data structure based on the provided key.
      * @param {K} key - The `key` parameter is the key of the element that you want to delete from the
      * data structure.
@@ -237,7 +261,7 @@ class HashMap extends base_1.IterableEntryBase {
         const resultMap = new HashMap();
         let index = 0;
         for (const [key, value] of this) {
-            resultMap.set(key, callbackfn.call(thisArg, value, key, index++, this));
+            resultMap.set(key, callbackfn.call(thisArg, key, value, index++, this));
         }
         return resultMap;
     }
@@ -261,7 +285,7 @@ class HashMap extends base_1.IterableEntryBase {
         const filteredMap = new HashMap();
         let index = 0;
         for (const [key, value] of this) {
-            if (predicate.call(thisArg, value, key, index++, this)) {
+            if (predicate.call(thisArg, key, value, index++, this)) {
                 filteredMap.set(key, value);
             }
         }
@@ -523,6 +547,9 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         return true;
     }
     /**
+     * Time Complexity: O(k)
+     * Space Complexity: O(k)
+     *
      * The function `setMany` takes an iterable collection, converts each element into a key-value pair
      * using a provided function, and sets each key-value pair in the current object, returning an array
      * of booleans indicating the success of each set operation.
@@ -549,6 +576,9 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         return results;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if a given key exists in a map, using different logic depending on whether the
      * key is a weak key or not.
      * @param {K} key - The `key` parameter is the key that is being checked for existence in the map.
@@ -728,7 +758,7 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         const filteredMap = new LinkedHashMap();
         let index = 0;
         for (const [key, value] of this) {
-            if (predicate.call(thisArg, value, key, index, this)) {
+            if (predicate.call(thisArg, key, value, index, this)) {
                 filteredMap.set(key, value);
             }
             index++;
@@ -756,8 +786,8 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         const mappedMap = new LinkedHashMap();
         let index = 0;
         for (const [key, value] of this) {
-            const newValue = callback.call(thisArg, value, key, index, this);
-            mappedMap.set(key, newValue);
+            const [newKey, newValue] = callback.call(thisArg, key, value, index, this);
+            mappedMap.set(newKey, newValue);
             index++;
         }
         return mappedMap;

package/dist/data-structures/heap/heap.d.ts

@@ -224,10 +224,27 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R, He
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * Insert an element into the heap and maintain the heap properties.
-     * @param element - The element to be inserted.
+     * The add function pushes an element into an array and then triggers a bubble-up operation.
+     * @param {E} element - The `element` parameter represents the element that you want to add to the
+     * data structure.
+     * @returns The `add` method is returning a boolean value, which is the result of calling the
+     * `_bubbleUp` method with the index `this.elements.length - 1` as an argument.
      */
     add(element: E): boolean;
+    /**
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
+     *
+     * The `addMany` function iterates over elements and adds them to a collection, returning an array of
+     * boolean values indicating success or failure.
+     * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the `addMany` method is
+     * an iterable containing elements of type `E` or `R`. The method iterates over each element in the
+     * iterable and adds them to the data structure. If a transformation function `_toElementFn` is
+     * provided, it transforms the element
+     * @returns The `addMany` method returns an array of boolean values indicating whether each element
+     * in the input iterable was successfully added to the data structure.
+     */
+    addMany(elements: Iterable<E> | Iterable<R>): boolean[];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -340,7 +357,7 @@ export declare class Heap<E = any, R = any> extends IterableElementBase<E, R, He
      */
     filter(callback: ElementCallback<E, R, boolean, Heap<E, R>>, thisArg?: any): Heap<E, R>;
     /**
-     * Time Complexity: O(n log n)
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
      * The `map` function creates a new heap by applying a callback function to each element of the

package/dist/data-structures/heap/heap.js

@@ -218,14 +218,7 @@ class Heap extends base_1.IterableElementBase {
             if (comparator)
                 this._comparator = comparator;
         }
-        if (elements) {
-            for (const el of elements) {
-                if (this.toElementFn)
-                    this.add(this.toElementFn(el));
-                else
-                    this.add(el);
-            }
-        }
+        this.addMany(elements);
     }
     /**
      * The function returns an array of elements.
@@ -261,13 +254,40 @@ class Heap extends base_1.IterableElementBase {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * Insert an element into the heap and maintain the heap properties.
-     * @param element - The element to be inserted.
+     * The add function pushes an element into an array and then triggers a bubble-up operation.
+     * @param {E} element - The `element` parameter represents the element that you want to add to the
+     * data structure.
+     * @returns The `add` method is returning a boolean value, which is the result of calling the
+     * `_bubbleUp` method with the index `this.elements.length - 1` as an argument.
      */
     add(element) {
         this._elements.push(element);
         return this._bubbleUp(this.elements.length - 1);
     }
+    /**
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
+     *
+     * The `addMany` function iterates over elements and adds them to a collection, returning an array of
+     * boolean values indicating success or failure.
+     * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the `addMany` method is
+     * an iterable containing elements of type `E` or `R`. The method iterates over each element in the
+     * iterable and adds them to the data structure. If a transformation function `_toElementFn` is
+     * provided, it transforms the element
+     * @returns The `addMany` method returns an array of boolean values indicating whether each element
+     * in the input iterable was successfully added to the data structure.
+     */
+    addMany(elements) {
+        const ans = [];
+        for (const el of elements) {
+            if (this._toElementFn) {
+                ans.push(this.add(this._toElementFn(el)));
+                continue;
+            }
+            ans.push(this.add(el));
+        }
+        return ans;
+    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -470,7 +490,7 @@ class Heap extends base_1.IterableElementBase {
         return filteredList;
     }
     /**
-     * Time Complexity: O(n log n)
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
      * The `map` function creates a new heap by applying a callback function to each element of the