directed-graph-typed 1.48.0 → 1.49.0

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

@@ -36,20 +36,20 @@ class UndirectedEdge extends abstract_graph_1.AbstractEdge {
      */
     constructor(v1, v2, weight, value) {
         super(weight, value);
-        this.vertices = [v1, v2];
+        this.vertexMap = [v1, v2];
     }
 }
 exports.UndirectedEdge = UndirectedEdge;
 class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     /**
-     * The constructor initializes a new Map object to store edges.
+     * The constructor initializes a new Map object to store edgeMap.
      */
     constructor() {
         super();
-        this._edges = new Map();
+        this._edgeMap = new Map();
     }
-    get edges() {
-        return this._edges;
+    get edgeMap() {
+        return this._edgeMap;
     }
     /**
      * The function creates a new vertex with an optional value and returns it.
@@ -64,7 +64,7 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
         return new UndirectedVertex(key, value !== null && value !== void 0 ? value : key);
     }
     /**
-     * The function creates an undirected edge between two vertices with an optional weight and value.
+     * The function creates an undirected edge between two vertexMap with an optional weight and value.
      * @param {VertexKey} v1 - The parameter `v1` represents the first vertex of the edge.
      * @param {VertexKey} v2 - The parameter `v2` represents the second vertex of the edge.
      * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. If
@@ -77,14 +77,14 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
         return new UndirectedEdge(v1, v2, weight !== null && weight !== void 0 ? weight : 1, value);
     }
     /**
-     * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+     * Time Complexity: O(|E|), where |E| is the number of edgeMap incident to the given vertex.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+     * Time Complexity: O(|E|), where |E| is the number of edgeMap incident to the given vertex.
      * Space Complexity: O(1)
      *
-     * The function `getEdge` returns the first edge that connects two vertices, or undefined if no such edge exists.
+     * The function `getEdge` returns the first edge that connects two vertexMap, or undefined if no such edge exists.
      * @param {VO | VertexKey | undefined} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
      * object), `undefined`, or `VertexKey` (a string or number representing the ID of a vertex).
      * @param {VO | VertexKey | undefined} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
@@ -93,29 +93,29 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
      */
     getEdge(v1, v2) {
         var _a;
-        let edges = [];
+        let edgeMap = [];
         if (v1 !== undefined && v2 !== undefined) {
             const vertex1 = this._getVertex(v1);
             const vertex2 = this._getVertex(v2);
             if (vertex1 && vertex2) {
-                edges = (_a = this._edges.get(vertex1)) === null || _a === void 0 ? void 0 : _a.filter(e => e.vertices.includes(vertex2.key));
+                edgeMap = (_a = this._edgeMap.get(vertex1)) === null || _a === void 0 ? void 0 : _a.filter(e => e.vertexMap.includes(vertex2.key));
             }
         }
-        return edges ? edges[0] || undefined : undefined;
+        return edgeMap ? edgeMap[0] || undefined : undefined;
     }
     /**
-     * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+     * Time Complexity: O(|E|), where |E| is the number of edgeMap incident to the given vertex.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+     * Time Complexity: O(|E|), where |E| is the number of edgeMap incident to the given vertex.
      * Space Complexity: O(1)
      *
-     * The function removes an edge between two vertices in a graph and returns the removed edge.
+     * The function removes an edge between two vertexMap in a graph and returns the removed edge.
      * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
      * @param {VO | VertexKey} v2 - VO | VertexKey - This parameter can be either a vertex object (VO) or a vertex ID
      * (VertexKey). It represents the second vertex of the edge that needs to be removed.
-     * @returns the removed edge (EO) if it exists, or undefined if either of the vertices (VO) does not exist.
+     * @returns the removed edge (EO) if it exists, or undefined if either of the vertexMap (VO) does not exist.
      */
     deleteEdgeBetween(v1, v2) {
         const vertex1 = this._getVertex(v1);
@@ -123,31 +123,94 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
         if (!vertex1 || !vertex2) {
             return undefined;
         }
-        const v1Edges = this._edges.get(vertex1);
+        const v1Edges = this._edgeMap.get(vertex1);
         let removed = undefined;
         if (v1Edges) {
-            removed = (0, utils_1.arrayRemove)(v1Edges, (e) => e.vertices.includes(vertex2.key))[0] || undefined;
+            removed = (0, utils_1.arrayRemove)(v1Edges, (e) => e.vertexMap.includes(vertex2.key))[0] || undefined;
         }
-        const v2Edges = this._edges.get(vertex2);
+        const v2Edges = this._edgeMap.get(vertex2);
         if (v2Edges) {
-            (0, utils_1.arrayRemove)(v2Edges, (e) => e.vertices.includes(vertex1.key));
+            (0, utils_1.arrayRemove)(v2Edges, (e) => e.vertexMap.includes(vertex1.key));
         }
         return removed;
     }
     /**
-     * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+     * Time Complexity: O(E), where E is the number of edgeMap incident to the given vertex.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+     * Time Complexity: O(E), where E is the number of edgeMap incident to the given vertex.
      * Space Complexity: O(1)
      *
-     * The deleteEdge function removes an edge between two vertices in a graph.
-     * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
-     * @returns The method is returning either the removed edge (of type EO) or undefined if the edge was not found.
+     * The function `deleteEdge` deletes an edge between two vertexMap in a graph.
+     * @param {EO | VertexKey} edgeOrOneSideVertexKey - The parameter `edgeOrOneSideVertexKey` can be
+     * either an edge object or a vertex key.
+     * @param {VertexKey} [otherSideVertexKey] - The parameter `otherSideVertexKey` is an optional
+     * parameter that represents the key of the vertex on the other side of the edge. It is used when the
+     * `edgeOrOneSideVertexKey` parameter is a vertex key, and it specifies the key of the vertex on the
+     * other side of the
+     * @returns The `deleteEdge` function returns either the deleted edge object (EO) or `undefined`.
+     */
+    deleteEdge(edgeOrOneSideVertexKey, otherSideVertexKey) {
+        let oneSide, otherSide;
+        if (this.isVertexKey(edgeOrOneSideVertexKey)) {
+            if (this.isVertexKey(otherSideVertexKey)) {
+                oneSide = this._getVertex(edgeOrOneSideVertexKey);
+                otherSide = this._getVertex(otherSideVertexKey);
+            }
+            else {
+                return;
+            }
+        }
+        else {
+            oneSide = this._getVertex(edgeOrOneSideVertexKey.vertexMap[0]);
+            otherSide = this._getVertex(edgeOrOneSideVertexKey.vertexMap[1]);
+        }
+        if (oneSide && otherSide) {
+            return this.deleteEdgeBetween(oneSide, otherSide);
+        }
+        else {
+            return;
+        }
+    }
+    /**
+     * Time Complexity: O(1) - Constant time for Map operations.
+     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
      */
-    deleteEdge(edge) {
-        return this.deleteEdgeBetween(edge.vertices[0], edge.vertices[1]);
+    /**
+     * Time Complexity: O(1) - Constant time for Map operations.
+     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+     *
+     * The `deleteVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
+     * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
+     * (`VertexKey`).
+     * @returns The method is returning a boolean value.
+     */
+    deleteVertex(vertexOrKey) {
+        let vertexKey;
+        let vertex;
+        if (this.isVertexKey(vertexOrKey)) {
+            vertex = this.getVertex(vertexOrKey);
+            vertexKey = vertexOrKey;
+        }
+        else {
+            vertex = vertexOrKey;
+            vertexKey = this._getVertexKey(vertexOrKey);
+        }
+        const neighbors = this.getNeighbors(vertexOrKey);
+        if (vertex) {
+            neighbors.forEach(neighbor => {
+                const neighborEdges = this._edgeMap.get(neighbor);
+                if (neighborEdges) {
+                    const restEdges = neighborEdges.filter(edge => {
+                        return !edge.vertexMap.includes(vertexKey);
+                    });
+                    this._edgeMap.set(neighbor, restEdges);
+                }
+            });
+            this._edgeMap.delete(vertex);
+        }
+        return this._vertexMap.delete(vertexKey);
     }
     /**
      * Time Complexity: O(1)
@@ -157,17 +220,17 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `degreeOf` returns the degree of a vertex in a graph, which is the number of edges connected to that
+     * The function `degreeOf` returns the degree of a vertex in a graph, which is the number of edgeMap connected to that
      * vertex.
      * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`.
      * @returns The function `degreeOf` returns the degree of a vertex in a graph. The degree of a vertex is the number of
-     * edges connected to that vertex.
+     * edgeMap connected to that vertex.
      */
     degreeOf(vertexOrKey) {
         var _a;
         const vertex = this._getVertex(vertexOrKey);
         if (vertex) {
-            return ((_a = this._edges.get(vertex)) === null || _a === void 0 ? void 0 : _a.length) || 0;
+            return ((_a = this._edgeMap.get(vertex)) === null || _a === void 0 ? void 0 : _a.length) || 0;
         }
         else {
             return 0;
@@ -181,52 +244,52 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function returns the edges of a given vertex or vertex ID.
+     * The function returns the edgeMap of a given vertex or vertex ID.
      * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`. A `VertexKey` is a
      * unique identifier for a vertex in a graph, while `VO` represents the type of the vertex.
-     * @returns an array of edges.
+     * @returns an array of edgeMap.
      */
     edgesOf(vertexOrKey) {
         const vertex = this._getVertex(vertexOrKey);
         if (vertex) {
-            return this._edges.get(vertex) || [];
+            return this._edgeMap.get(vertex) || [];
         }
         else {
             return [];
         }
     }
     /**
-     * Time Complexity: O(|V| + |E|), where |V| is the number of vertices and |E| is the number of edges.
+     * Time Complexity: O(|V| + |E|), where |V| is the number of vertexMap and |E| is the number of edgeMap.
      * Space Complexity: O(|E|)
      */
     /**
-     * Time Complexity: O(|V| + |E|), where |V| is the number of vertices and |E| is the number of edges.
+     * Time Complexity: O(|V| + |E|), where |V| is the number of vertexMap and |E| is the number of edgeMap.
      * Space Complexity: O(|E|)
      *
-     * The function "edgeSet" returns an array of unique edges from a set of edges.
+     * The function "edgeSet" returns an array of unique edgeMap from a set of edgeMap.
      * @returns The method `edgeSet()` returns an array of type `EO[]`.
      */
     edgeSet() {
         const edgeSet = new Set();
-        this._edges.forEach(edges => {
-            edges.forEach(edge => {
+        this._edgeMap.forEach(edgeMap => {
+            edgeMap.forEach(edge => {
                 edgeSet.add(edge);
             });
         });
         return [...edgeSet];
     }
     /**
-     * Time Complexity: O(|V| + |E|), where |V| is the number of vertices and |E| is the number of edges.
+     * Time Complexity: O(|V| + |E|), where |V| is the number of vertexMap and |E| is the number of edgeMap.
      * Space Complexity: O(|E|)
      */
     /**
-     * Time Complexity: O(|V| + |E|), where |V| is the number of vertices and |E| is the number of edges.
+     * Time Complexity: O(|V| + |E|), where |V| is the number of vertexMap and |E| is the number of edgeMap.
      * Space Complexity: O(|E|)
      *
-     * The function "getNeighbors" returns an array of neighboring vertices for a given vertex or vertex ID.
+     * The function "getNeighbors" returns an array of neighboring vertexMap for a given vertex or vertex ID.
      * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
      * (`VertexKey`).
-     * @returns an array of vertices (VO[]).
+     * @returns an array of vertexMap (VO[]).
      */
     getNeighbors(vertexOrKey) {
         const neighbors = [];
@@ -234,7 +297,7 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
         if (vertex) {
             const neighborEdges = this.edgesOf(vertex);
             for (const edge of neighborEdges) {
-                const neighbor = this._getVertex(edge.vertices.filter(e => e !== vertex.key)[0]);
+                const neighbor = this._getVertex(edge.vertexMap.filter(e => e !== vertex.key)[0]);
                 if (neighbor) {
                     neighbors.push(neighbor);
                 }
@@ -250,18 +313,18 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function "getEndsOfEdge" returns the vertices at the ends of an edge if the edge exists in the graph, otherwise
+     * The function "getEndsOfEdge" returns the vertexMap at the ends of an edge if the edge exists in the graph, otherwise
      * it returns undefined.
      * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
-     * @returns The function `getEndsOfEdge` returns an array containing two vertices `[VO, VO]` if the edge exists in the
+     * @returns The function `getEndsOfEdge` returns an array containing two vertexMap `[VO, VO]` if the edge exists in the
      * graph. If the edge does not exist, it returns `undefined`.
      */
     getEndsOfEdge(edge) {
-        if (!this.hasEdge(edge.vertices[0], edge.vertices[1])) {
+        if (!this.hasEdge(edge.vertexMap[0], edge.vertexMap[1])) {
             return undefined;
         }
-        const v1 = this._getVertex(edge.vertices[0]);
-        const v2 = this._getVertex(edge.vertices[1]);
+        const v1 = this._getVertex(edge.vertexMap[0]);
+        const v2 = this._getVertex(edge.vertexMap[1]);
         if (v1 && v2) {
             return [v1, v2];
         }
@@ -277,22 +340,22 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function adds an edge to the graph by updating the adjacency list with the vertices of the edge.
+     * The function adds an edge to the graph by updating the adjacency list with the vertexMap of the edge.
      * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
      * @returns a boolean value.
      */
     _addEdgeOnly(edge) {
-        for (const end of edge.vertices) {
+        for (const end of edge.vertexMap) {
             const endVertex = this._getVertex(end);
             if (endVertex === undefined)
                 return false;
             if (endVertex) {
-                const edges = this._edges.get(endVertex);
-                if (edges) {
-                    edges.push(edge);
+                const edgeMap = this._edgeMap.get(endVertex);
+                if (edgeMap) {
+                    edgeMap.push(edge);
                 }
                 else {
-                    this._edges.set(endVertex, [edge]);
+                    this._edgeMap.set(endVertex, [edge]);
                 }
             }
         }

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

@@ -5,8 +5,119 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { HashMapLinkedNode, HashMapOptions } from '../../types';
-export declare class HashMap<K = any, V = any> {
+import { EntryCallback, HashMapLinkedNode, HashMapOptions, HashMapStoreItem } from '../../types';
+import { IterableEntryBase } from "../base";
+export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
+    protected _store: {
+        [key: string]: HashMapStoreItem<K, V>;
+    };
+    protected _objMap: Map<object, V>;
+    /**
+     * The constructor function initializes a new instance of a class with optional elements and options.
+     * @param elements - The `elements` parameter is an iterable containing key-value pairs `[K, V]`. It
+     * is optional and defaults to an empty array `[]`. This parameter is used to initialize the map with
+     * key-value pairs.
+     * @param [options] - The `options` parameter is an optional object that can contain additional
+     * configuration options for the constructor. In this case, it has one property:
+     */
+    constructor(elements?: Iterable<[K, V]>, options?: {
+        hashFn: (key: K) => string;
+    });
+    protected _size: number;
+    get size(): number;
+    isEmpty(): boolean;
+    clear(): void;
+    /**
+     * 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
+     * can be of any type, but if it is an object, it will be stored in a Map, otherwise it will be
+     * stored in a regular JavaScript object.
+     * @param {V} value - The value parameter represents the value that you want to associate with the
+     * key in the data structure.
+     */
+    set(key: K, value: V): void;
+    /**
+     * The function "setMany" sets multiple key-value pairs in a map.
+     * @param elements - The `elements` parameter is an iterable containing key-value pairs. Each
+     * key-value pair is represented as an array with two elements: the key and the value.
+     */
+    setMany(elements: Iterable<[K, V]>): void;
+    /**
+     * 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
+     * of any type, but it should be compatible with the key type used when the map was created.
+     * @returns The method `get(key: K)` returns a value of type `V` if the key exists in the `_objMap`
+     * or `_store`, otherwise it returns `undefined`.
+     */
+    get(key: K): V | undefined;
+    /**
+     * 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.
+     * @returns The `has` method is returning a boolean value.
+     */
+    has(key: K): boolean;
+    /**
+     * 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.
+     * @returns The `delete` method returns a boolean value. It returns `true` if the key was
+     * successfully deleted from the map, and `false` if the key was not found in the map.
+     */
+    delete(key: K): boolean;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript creates a new HashMap by applying a callback function to each
+     * key-value pair in the original HashMap.
+     * @param callbackfn - The callback function that will be called for each key-value pair in the
+     * HashMap. It takes four parameters:
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
+     * be passed as the `this` value to the `callbackfn` function. If `thisArg
+     * @returns The `map` method is returning a new `HashMap` object with the transformed values based on
+     * the provided callback function.
+     */
+    map<U>(callbackfn: EntryCallback<K, V, U>, thisArg?: any): HashMap<K, U>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new HashMap containing key-value pairs from the original HashMap
+     * that satisfy a given predicate function.
+     * @param predicate - The predicate parameter is a function that takes four arguments: value, key,
+     * index, and map. It is used to determine whether an element should be included in the filtered map
+     * or not. The function should return a boolean value - true if the element should be included, and
+     * false otherwise.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `predicate` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `HashMap` object that contains the key-value pairs
+     * from the original `HashMap` that pass the provided `predicate` function.
+     */
+    filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): HashMap<K, V>;
+    print(): void;
+    /**
+     * The function returns an iterator that yields key-value pairs from both an object store and an
+     * object map.
+     */
+    protected _getIterator(): IterableIterator<[K, V]>;
+    protected _hashFn: (key: K) => string;
+    protected _isObjKey(key: any): key is (object | ((...args: any[]) => any));
+    protected _getNoObjKey(key: K): string;
+}
+export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>>;
     protected _objMap: WeakMap<object, HashMapLinkedNode<K, V | undefined>>;
     protected _head: HashMapLinkedNode<K, V | undefined>;
@@ -57,6 +168,8 @@ export declare class HashMap<K = any, V = any> {
      * @returns the size of the data structure after the key-value pair has been set.
      */
     set(key: K, value?: V): number;
+    has(key: K): boolean;
+    setMany(entries: Iterable<[K, V]>): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -120,54 +233,57 @@ export declare class HashMap<K = any, V = any> {
      * The `clear` function clears all the elements in a data structure and resets its properties.
      */
     clear(): void;
+    clone(): LinkedHashMap<K, V>;
     /**
-     * Time Complexity: O(n), where n is the number of elements in the HashMap.
-     * Space Complexity: O(1)
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      *
-     * The `forEach` function iterates over each element in a HashMap and executes a callback function on
-     * each element.
-     * @param callback - The callback parameter is a function that will be called for each element in the
-     * HashMap. It takes three arguments:
-     */
-    forEach(callback: (element: [K, V], index: number, hashMap: HashMap<K, V>) => void): void;
-    /**
-     * The `filter` function takes a predicate function and returns a new HashMap containing only the
-     * key-value pairs that satisfy the predicate.
-     * @param predicate - The `predicate` parameter is a function that takes two arguments: `element` and
-     * `map`.
-     * @returns a new HashMap object that contains the key-value pairs from the original HashMap that
-     * satisfy the given predicate function.
-     */
-    filter(predicate: (element: [K, V], index: number, map: HashMap<K, V>) => boolean): HashMap<K, V>;
-    /**
-     * The `map` function takes a callback function and returns a new HashMap with the values transformed
-     * by the callback.
-     * @param callback - The `callback` parameter is a function that takes two arguments: `element` and
-     * `map`.
-     * @returns a new HashMap object with the values mapped according to the provided callback function.
-     */
-    map<NV>(callback: (element: [K, V], index: number, map: HashMap<K, V>) => NV): HashMap<K, NV>;
-    /**
-     * The `reduce` function iterates over the elements of a HashMap and applies a callback function to
-     * each element, accumulating a single value.
-     * @param callback - The callback parameter is a function that takes three arguments: accumulator,
-     * element, and map. It is called for each element in the HashMap and is used to accumulate a single
-     * result.
-     * @param {A} initialValue - The `initialValue` parameter is the initial value of the accumulator. It
-     * is the value that will be passed as the first argument to the `callback` function when reducing
-     * the elements of the map.
-     * @returns The `reduce` function is returning the final value of the accumulator after iterating
-     * over all the elements in the HashMap and applying the callback function to each element.
-     */
-    reduce<A>(callback: (accumulator: A, element: [K, V], index: number, map: HashMap<K, V>) => A, initialValue: A): A;
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the HashMap.
+     * The `filter` function creates a new `LinkedHashMap` containing key-value pairs from the original
+     * map that satisfy a given predicate function.
+     * @param predicate - The `predicate` parameter is a callback function that takes four arguments:
+     * `value`, `key`, `index`, and `this`. It should return a boolean value indicating whether the
+     * current element should be included in the filtered map or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the `predicate` function. It is used when you want to bind a
+     * specific object as the context for the `predicate` function. If `thisArg` is not provided, `this
+     * @returns a new `LinkedHashMap` object that contains the key-value pairs from the original
+     * `LinkedHashMap` object that satisfy the given predicate function.
+     */
+    filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): LinkedHashMap<K, V>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript creates a new `LinkedHashMap` by applying a callback function to
+     * each key-value pair in the original map.
+     * @param callback - The callback parameter is a function that will be called for each key-value pair
+     * in the map. It takes four arguments: the value of the current key-value pair, the key of the
+     * current key-value pair, the index of the current key-value pair, and the map itself. The callback
+     * function should
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. If provided, the callback function will
+     * be called with `thisArg` as its `this` value. If not provided, `this` will refer to the current
+     * map
+     * @returns a new `LinkedHashMap` object with the values mapped according to the provided callback
+     * function.
+     */
+    map<NV>(callback: EntryCallback<K, V, NV>, thisArg?: any): LinkedHashMap<K, NV>;
+    print(): void;
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
      * Space Complexity: O(1)
      *
      * The above function is an iterator that yields key-value pairs from a linked list.
      */
-    [Symbol.iterator](): Generator<[K, V], void, unknown>;
-    print(): void;
+    protected _getIterator(): Generator<[K, V], void, unknown>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)