data-structure-typed 1.48.4 → 1.48.5

package/dist/mjs/data-structures/graph/undirected-graph.d.ts

@@ -12,7 +12,7 @@ export declare class UndirectedVertex<V = any> extends AbstractVertex<V> {
     constructor(key: VertexKey, value?: V);
 }
 export declare class UndirectedEdge<E = number> extends AbstractEdge<E> {
-    vertices: [VertexKey, VertexKey];
+    vertexMap: [VertexKey, VertexKey];
     /**
      * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
      * value.
@@ -27,11 +27,11 @@ export declare class UndirectedEdge<E = number> extends AbstractEdge<E> {
 }
 export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVertex<V> = UndirectedVertex<V>, EO extends UndirectedEdge<E> = UndirectedEdge<E>> extends AbstractGraph<V, E, VO, EO> implements IGraph<V, E, VO, EO> {
     /**
-     * The constructor initializes a new Map object to store edges.
+     * The constructor initializes a new Map object to store edgeMap.
      */
     constructor();
-    protected _edges: Map<VO, EO[]>;
-    get edges(): Map<VO, EO[]>;
+    protected _edgeMap: Map<VO, EO[]>;
+    get edgeMap(): Map<VO, EO[]>;
     /**
      * The function creates a new vertex with an optional value and returns it.
      * @param {VertexKey} key - The `key` parameter is the unique identifier for the vertex. It is used to distinguish one
@@ -43,7 +43,7 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      */
     createVertex(key: VertexKey, value?: VO['value']): VO;
     /**
-     * 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
@@ -54,14 +54,14 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      */
     createEdge(v1: VertexKey, v2: VertexKey, weight?: number, value?: EO['value']): EO;
     /**
-     * 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
@@ -70,29 +70,29 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      */
     getEdge(v1: VO | VertexKey | undefined, v2: VO | VertexKey | undefined): EO | 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: VO | VertexKey, v2: VO | VertexKey): EO | 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 `deleteEdge` deletes an edge between two vertices in a graph.
+     * 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
@@ -124,11 +124,11 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * 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: VertexKey | VO): number;
     /**
@@ -139,36 +139,36 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * 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: VertexKey | VO): EO[];
     /**
-     * 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(): EO[];
     /**
-     * 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: VO | VertexKey): VO[];
     /**
@@ -179,10 +179,10 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * 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: EO): [VO, VO] | undefined;
@@ -194,7 +194,7 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * 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.
      */

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

@@ -20,7 +20,7 @@ export class UndirectedVertex extends AbstractVertex {
     }
 }
 export class UndirectedEdge extends AbstractEdge {
-    vertices;
+    vertexMap;
     /**
      * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
      * value.
@@ -33,20 +33,20 @@ export class UndirectedEdge extends AbstractEdge {
      */
     constructor(v1, v2, weight, value) {
         super(weight, value);
-        this.vertices = [v1, v2];
+        this.vertexMap = [v1, v2];
     }
 }
 export class UndirectedGraph extends 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();
     }
-    _edges;
-    get edges() {
-        return this._edges;
+    _edgeMap;
+    get edgeMap() {
+        return this._edgeMap;
     }
     /**
      * The function creates a new vertex with an optional value and returns it.
@@ -61,7 +61,7 @@ export class UndirectedGraph extends AbstractGraph {
         return new UndirectedVertex(key, 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
@@ -74,14 +74,14 @@ export class UndirectedGraph extends AbstractGraph {
         return new UndirectedEdge(v1, v2, 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
@@ -89,29 +89,29 @@ export class UndirectedGraph extends AbstractGraph {
      * @returns an edge (EO) or undefined.
      */
     getEdge(v1, v2) {
-        let edges = [];
+        let edgeMap = [];
         if (v1 !== undefined && v2 !== undefined) {
             const vertex1 = this._getVertex(v1);
             const vertex2 = this._getVertex(v2);
             if (vertex1 && vertex2) {
-                edges = this._edges.get(vertex1)?.filter(e => e.vertices.includes(vertex2.key));
+                edgeMap = this._edgeMap.get(vertex1)?.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);
@@ -119,26 +119,26 @@ export class UndirectedGraph extends AbstractGraph {
         if (!vertex1 || !vertex2) {
             return undefined;
         }
-        const v1Edges = this._edges.get(vertex1);
+        const v1Edges = this._edgeMap.get(vertex1);
         let removed = undefined;
         if (v1Edges) {
-            removed = arrayRemove(v1Edges, (e) => e.vertices.includes(vertex2.key))[0] || undefined;
+            removed = arrayRemove(v1Edges, (e) => e.vertexMap.includes(vertex2.key))[0] || undefined;
         }
-        const v2Edges = this._edges.get(vertex2);
+        const v2Edges = this._edgeMap.get(vertex2);
         if (v2Edges) {
-            arrayRemove(v2Edges, (e) => e.vertices.includes(vertex1.key));
+            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 function `deleteEdge` deletes an edge between two vertices in a graph.
+     * 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
@@ -159,8 +159,8 @@ export class UndirectedGraph extends AbstractGraph {
             }
         }
         else {
-            oneSide = this._getVertex(edgeOrOneSideVertexKey.vertices[0]);
-            otherSide = this._getVertex(edgeOrOneSideVertexKey.vertices[1]);
+            oneSide = this._getVertex(edgeOrOneSideVertexKey.vertexMap[0]);
+            otherSide = this._getVertex(edgeOrOneSideVertexKey.vertexMap[1]);
         }
         if (oneSide && otherSide) {
             return this.deleteEdgeBetween(oneSide, otherSide);
@@ -196,17 +196,17 @@ export class UndirectedGraph extends AbstractGraph {
         const neighbors = this.getNeighbors(vertexOrKey);
         if (vertex) {
             neighbors.forEach(neighbor => {
-                const neighborEdges = this._edges.get(neighbor);
+                const neighborEdges = this._edgeMap.get(neighbor);
                 if (neighborEdges) {
                     const restEdges = neighborEdges.filter(edge => {
-                        return !edge.vertices.includes(vertexKey);
+                        return !edge.vertexMap.includes(vertexKey);
                     });
-                    this._edges.set(neighbor, restEdges);
+                    this._edgeMap.set(neighbor, restEdges);
                 }
             });
-            this._edges.delete(vertex);
+            this._edgeMap.delete(vertex);
         }
-        return this._vertices.delete(vertexKey);
+        return this._vertexMap.delete(vertexKey);
     }
     /**
      * Time Complexity: O(1)
@@ -216,16 +216,16 @@ export class UndirectedGraph extends 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) {
         const vertex = this._getVertex(vertexOrKey);
         if (vertex) {
-            return this._edges.get(vertex)?.length || 0;
+            return this._edgeMap.get(vertex)?.length || 0;
         }
         else {
             return 0;
@@ -239,52 +239,52 @@ export class UndirectedGraph extends 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 = [];
@@ -292,7 +292,7 @@ export class UndirectedGraph extends 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);
                 }
@@ -308,18 +308,18 @@ export class UndirectedGraph extends 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];
         }
@@ -335,22 +335,22 @@ export class UndirectedGraph extends 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/mjs/data-structures/hash/hash-map.d.ts

@@ -5,9 +5,9 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { HashMapLinkedNode, HashMapOptions, HashMapStoreItem, PairCallback } from '../../types';
-import { IterablePairBase } from "../base";
-export declare class HashMap<K = any, V = any> extends IterablePairBase<K, V> {
+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>;
     };
@@ -85,7 +85,7 @@ export declare class HashMap<K = any, V = any> extends IterablePairBase<K, V> {
      * @returns The `map` method is returning a new `HashMap` object with the transformed values based on
      * the provided callback function.
      */
-    map<U>(callbackfn: PairCallback<K, V, U>, thisArg?: any): HashMap<K, U>;
+    map<U>(callbackfn: EntryCallback<K, V, U>, thisArg?: any): HashMap<K, U>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -106,7 +106,7 @@ export declare class HashMap<K = any, V = any> extends IterablePairBase<K, V> {
      * @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: PairCallback<K, V, boolean>, thisArg?: any): HashMap<K, V>;
+    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
@@ -117,7 +117,7 @@ export declare class HashMap<K = any, V = any> extends IterablePairBase<K, V> {
     protected _isObjKey(key: any): key is (object | ((...args: any[]) => any));
     protected _getNoObjKey(key: K): string;
 }
-export declare class LinkedHashMap<K = any, V = any> extends IterablePairBase<K, V> {
+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>;
@@ -253,7 +253,7 @@ export declare class LinkedHashMap<K = any, V = any> extends IterablePairBase<K,
      * @returns a new `LinkedHashMap` object that contains the key-value pairs from the original
      * `LinkedHashMap` object that satisfy the given predicate function.
      */
-    filter(predicate: PairCallback<K, V, boolean>, thisArg?: any): LinkedHashMap<K, V>;
+    filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): LinkedHashMap<K, V>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -275,7 +275,7 @@ export declare class LinkedHashMap<K = any, V = any> extends IterablePairBase<K,
      * @returns a new `LinkedHashMap` object with the values mapped according to the provided callback
      * function.
      */
-    map<NV>(callback: PairCallback<K, V, NV>, thisArg?: any): LinkedHashMap<K, NV>;
+    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.

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

@@ -6,8 +6,8 @@
  * @license MIT License
  */
 import { isWeakKey, rangeCheck } from '../../utils';
-import { IterablePairBase } from "../base";
-export class HashMap extends IterablePairBase {
+import { IterableEntryBase } from "../base";
+export class HashMap extends IterableEntryBase {
     _store = {};
     _objMap = new Map();
     /**
@@ -225,7 +225,7 @@ export class HashMap extends IterablePairBase {
         return strKey;
     }
 }
-export class LinkedHashMap extends IterablePairBase {
+export class LinkedHashMap extends IterableEntryBase {
     _noObjMap = {};
     _objMap = new WeakMap();
     _head;

package/dist/mjs/interfaces/binary-tree.d.ts

@@ -3,7 +3,7 @@ import { BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BiTreeDelete
 export interface IBinaryTree<K = number, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNodeNested<K, V>, TREE extends BinaryTree<K, V, N, TREE> = BinaryTreeNested<K, V, N>> {
     createNode(key: K, value?: N['value']): N;
     createTree(options?: Partial<BinaryTreeOptions<K>>): TREE;
-    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, count?: number): N | null | undefined;
+    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V, count?: number): N | null | undefined;
     addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>): (N | null | undefined)[];
     delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BiTreeDeleteResult<N>[];
 }

package/dist/mjs/types/data-structures/base/base.d.ts

@@ -1,5 +1,5 @@
-import { IterableElementBase, IterablePairBase } from "../../../data-structures";
-export type PairCallback<K, V, R> = (value: V, key: K, index: number, container: IterablePairBase<K, V>) => R;
+import { IterableElementBase, IterableEntryBase } from "../../../data-structures";
+export type EntryCallback<K, V, R> = (value: V, key: K, index: number, container: IterableEntryBase<K, V>) => R;
 export type ElementCallback<V, R> = (element: V, index: number, container: IterableElementBase<V>) => R;
-export type ReducePairCallback<K, V, R> = (accumulator: R, value: V, key: K, index: number, container: IterablePairBase<K, V>) => R;
+export type ReduceEntryCallback<K, V, R> = (accumulator: R, value: V, key: K, index: number, container: IterableEntryBase<K, V>) => R;
 export type ReduceElementCallback<V, R> = (accumulator: R, element: V, index: number, container: IterableElementBase<V>) => R;