directed-graph-typed 1.47.7 → 1.47.9

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

@@ -9,11 +9,11 @@ import type { SegmentTreeNodeVal } from '../../types';
 export declare class SegmentTreeNode {
     start: number;
     end: number;
-    value: SegmentTreeNodeVal | null;
+    value: SegmentTreeNodeVal | undefined;
     sum: number;
-    left: SegmentTreeNode | null;
-    right: SegmentTreeNode | null;
-    constructor(start: number, end: number, sum: number, value?: SegmentTreeNodeVal | null);
+    left: SegmentTreeNode | undefined;
+    right: SegmentTreeNode | undefined;
+    constructor(start: number, end: number, sum: number, value?: SegmentTreeNodeVal | undefined);
 }
 export declare class SegmentTree {
     /**
@@ -32,8 +32,8 @@ export declare class SegmentTree {
     get start(): number;
     protected _end: number;
     get end(): number;
-    protected _root: SegmentTreeNode | null;
-    get root(): SegmentTreeNode | null;
+    protected _root: SegmentTreeNode | undefined;
+    get root(): SegmentTreeNode | undefined;
     /**
      * The build function creates a segment tree by recursively dividing the given range into smaller segments and assigning
      * the sum of values to each segment.

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

@@ -12,14 +12,14 @@ class SegmentTreeNode {
     constructor(start, end, sum, value) {
         this.start = 0;
         this.end = 0;
-        this.value = null;
+        this.value = undefined;
         this.sum = 0;
-        this.left = null;
-        this.right = null;
+        this.left = undefined;
+        this.right = undefined;
         this.start = start;
         this.end = end;
         this.sum = sum;
-        this.value = value || null;
+        this.value = value || undefined;
     }
 }
 exports.SegmentTreeNode = SegmentTreeNode;
@@ -45,7 +45,7 @@ class SegmentTree {
             this._root = this.build(start, end);
         }
         else {
-            this._root = null;
+            this._root = undefined;
             this._values = [];
         }
     }
@@ -96,7 +96,7 @@ class SegmentTree {
      * @returns The function does not return anything.
      */
     updateNode(index, sum, value) {
-        const root = this.root || null;
+        const root = this.root || undefined;
         if (!root) {
             return;
         }
@@ -132,7 +132,7 @@ class SegmentTree {
      * @returns The function `querySumByRange` returns a number.
      */
     querySumByRange(indexA, indexB) {
-        const root = this.root || null;
+        const root = this.root || undefined;
         if (!root) {
             return 0;
         }

package/dist/data-structures/graph/abstract-graph.d.ts

@@ -47,13 +47,13 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * @param value
      */
     abstract createEdge(srcOrV1: VertexKey, destOrV2: VertexKey, weight?: number, value?: E): EO;
-    abstract deleteEdge(edge: EO): EO | null;
-    abstract getEdge(srcOrKey: VO | VertexKey, destOrKey: VO | VertexKey): EO | null;
+    abstract deleteEdge(edge: EO): EO | undefined;
+    abstract getEdge(srcOrKey: VO | VertexKey, destOrKey: VO | VertexKey): EO | undefined;
     abstract degreeOf(vertexOrKey: VO | VertexKey): number;
     abstract edgeSet(): EO[];
     abstract edgesOf(vertexOrKey: VO | VertexKey): EO[];
     abstract getNeighbors(vertexOrKey: VO | VertexKey): VO[];
-    abstract getEndsOfEdge(edge: EO): [VO, VO] | null;
+    abstract getEndsOfEdge(edge: EO): [VO, VO] | undefined;
     /**
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -62,13 +62,13 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
      *
-     * The function "getVertex" returns the vertex with the specified ID or null if it doesn't exist.
+     * The function "getVertex" returns the vertex with the specified ID or undefined if it doesn't exist.
      * @param {VertexKey} vertexKey - The `vertexKey` parameter is the identifier of the vertex that you want to retrieve from
      * the `_vertices` map.
      * @returns The method `getVertex` returns the vertex with the specified `vertexKey` if it exists in the `_vertices`
-     * map. If the vertex does not exist, it returns `null`.
+     * map. If the vertex does not exist, it returns `undefined`.
      */
-    getVertex(vertexKey: VertexKey): VO | null;
+    getVertex(vertexKey: VertexKey): VO | undefined;
     /**
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -201,7 +201,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * vertices. If `isWeight` is `false` or not provided, it uses a breadth-first search (BFS) algorithm to calculate the
      * minimum number of
      */
-    getMinCostBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean): number | null;
+    getMinCostBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean): number | undefined;
     /**
      * Time Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
      * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
@@ -223,9 +223,9 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * followed by iterative computation of the shortest path. This approach may result in exponential time complexity,
      * so the default method is to use the Dijkstra algorithm to obtain the shortest weighted path.
      * @returns The function `getMinPathBetween` returns an array of vertices (`VO[]`) representing the minimum path between
-     * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `null`.
+     * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `undefined`.
      */
-    getMinPathBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean, isDFS?: boolean): VO[] | null;
+    getMinPathBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean, isDFS?: boolean): VO[] | undefined;
     /**
      *  Dijkstra algorithm time: O(VE) space: O(VO + EO)
      * /
@@ -242,9 +242,9 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * a graph without using a heap data structure.
      * @param {VO | VertexKey} src - The source vertex from which to start the Dijkstra's algorithm. It can be either a
      * vertex object or a vertex ID.
-     * @param {VO | VertexKey | null} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
+     * @param {VO | VertexKey | undefined} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
      * parameter that specifies the destination vertex for the Dijkstra algorithm. It can be either a vertex object or its
-     * identifier. If no destination is provided, the value is set to `null`.
+     * identifier. If no destination is provided, the value is set to `undefined`.
      * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
      * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
      * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
@@ -253,7 +253,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
      * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<VO>`.
      */
-    dijkstraWithoutHeap(src: VO | VertexKey, dest?: VO | VertexKey | null, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO>;
+    dijkstraWithoutHeap(src: VO | VertexKey, dest?: VO | VertexKey | undefined, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO>;
     /**
      *  Dijkstra algorithm time: O(logVE) space: O(VO + EO)
      *
@@ -276,7 +276,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * optional destination vertex, and optionally returns the minimum distance, the paths, and other information.
      * @param {VO | VertexKey} src - The `src` parameter represents the source vertex from which the Dijkstra algorithm will
      * start. It can be either a vertex object or a vertex ID.
-     * @param {VO | VertexKey | null} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
+     * @param {VO | VertexKey | undefined} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
      * vertex to which the shortest path is calculated from the source vertex. If no destination is provided, the algorithm
      * will calculate the shortest paths to all other vertices from the source vertex.
      * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
@@ -287,7 +287,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
      * @returns The function `dijkstra` returns an object of type `DijkstraResult<VO>`.
      */
-    dijkstra(src: VO | VertexKey, dest?: VO | VertexKey | null, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO>;
+    dijkstra(src: VO | VertexKey, dest?: VO | VertexKey | undefined, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO>;
     /**
      * Time Complexity: O(V * E) - Quadratic time in the worst case (Bellman-Ford algorithm).
      * Space Complexity: O(V + E) - Depends on the implementation (Bellman-Ford algorithm).
@@ -353,12 +353,12 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * graph.
      * @returns The function `floydWarshall()` returns an object with two properties: `costs` and `predecessor`. The `costs`
      * property is a 2D array of numbers representing the shortest path costs between vertices in a graph. The
-     * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
+     * `predecessor` property is a 2D array of vertices (or `undefined`) representing the predecessor vertices in the shortest
      * path between vertices in the
      */
     floydWarshall(): {
         costs: number[][];
-        predecessor: (VO | null)[][];
+        predecessor: (VO | undefined)[][];
     };
     /**
      * Time Complexity: O(V + E) - Linear time (Tarjan's algorithm).
@@ -443,8 +443,13 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * @returns the bridges found using the Tarjan algorithm.
      */
     getBridges(): EO[];
+    [Symbol.iterator](): Iterator<[VertexKey, V | undefined]>;
+    forEach(callback: (entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => void): void;
+    filter(predicate: (entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => boolean): [VertexKey, V | undefined][];
+    map<T>(callback: (entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => T): T[];
+    reduce<T>(callback: (accumulator: T, entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => T, initialValue: T): T;
     protected abstract _addEdgeOnly(edge: EO): boolean;
     protected _addVertexOnly(newVertex: VO): boolean;
-    protected _getVertex(vertexOrKey: VertexKey | VO): VO | null;
+    protected _getVertex(vertexOrKey: VertexKey | VO): VO | undefined;
     protected _getVertexKey(vertexOrKey: VO | VertexKey): VertexKey;
 }

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

@@ -60,14 +60,14 @@ class AbstractGraph {
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
      *
-     * The function "getVertex" returns the vertex with the specified ID or null if it doesn't exist.
+     * The function "getVertex" returns the vertex with the specified ID or undefined if it doesn't exist.
      * @param {VertexKey} vertexKey - The `vertexKey` parameter is the identifier of the vertex that you want to retrieve from
      * the `_vertices` map.
      * @returns The method `getVertex` returns the vertex with the specified `vertexKey` if it exists in the `_vertices`
-     * map. If the vertex does not exist, it returns `null`.
+     * map. If the vertex does not exist, it returns `undefined`.
      */
     getVertex(vertexKey) {
-        return this._vertices.get(vertexKey) || null;
+        return this._vertices.get(vertexKey) || undefined;
     }
     /**
      * Time Complexity: O(1) - Constant time for Map lookup.
@@ -305,7 +305,7 @@ class AbstractGraph {
             const vertex2 = this._getVertex(v2);
             const vertex1 = this._getVertex(v1);
             if (!(vertex1 && vertex2)) {
-                return null;
+                return undefined;
             }
             const visited = new Map();
             const queue = new queue_1.Queue([vertex1]);
@@ -330,7 +330,7 @@ class AbstractGraph {
                 }
                 cost++;
             }
-            return null;
+            return undefined;
         }
     }
     /**
@@ -354,7 +354,7 @@ class AbstractGraph {
      * followed by iterative computation of the shortest path. This approach may result in exponential time complexity,
      * so the default method is to use the Dijkstra algorithm to obtain the shortest weighted path.
      * @returns The function `getMinPathBetween` returns an array of vertices (`VO[]`) representing the minimum path between
-     * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `null`.
+     * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `undefined`.
      */
     getMinPathBetween(v1, v2, isWeight, isDFS = false) {
         var _a, _b;
@@ -374,7 +374,7 @@ class AbstractGraph {
                     }
                     index++;
                 }
-                return allPaths[minIndex] || null;
+                return allPaths[minIndex] || undefined;
             }
             else {
                 return (_b = (_a = this.dijkstra(v1, v2, true, true)) === null || _a === void 0 ? void 0 : _a.minPath) !== null && _b !== void 0 ? _b : [];
@@ -423,9 +423,9 @@ class AbstractGraph {
      * a graph without using a heap data structure.
      * @param {VO | VertexKey} src - The source vertex from which to start the Dijkstra's algorithm. It can be either a
      * vertex object or a vertex ID.
-     * @param {VO | VertexKey | null} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
+     * @param {VO | VertexKey | undefined} [dest] - The `dest` parameter in the `dijkstraWithoutHeap` function is an optional
      * parameter that specifies the destination vertex for the Dijkstra algorithm. It can be either a vertex object or its
-     * identifier. If no destination is provided, the value is set to `null`.
+     * identifier. If no destination is provided, the value is set to `undefined`.
      * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
      * distance from the source vertex to the destination vertex should be calculated and returned in the result. If
      * `getMinDist` is set to `true`, the `minDist` property in the result will contain the minimum distance
@@ -440,9 +440,9 @@ class AbstractGraph {
         if (genPaths === undefined)
             genPaths = false;
         if (dest === undefined)
-            dest = null;
+            dest = undefined;
         let minDist = Infinity;
-        let minDest = null;
+        let minDest = undefined;
         let minPath = [];
         const paths = [];
         const vertices = this._vertices;
@@ -450,9 +450,9 @@ class AbstractGraph {
         const seen = new Set();
         const preMap = new Map(); // predecessor
         const srcVertex = this._getVertex(src);
-        const destVertex = dest ? this._getVertex(dest) : null;
+        const destVertex = dest ? this._getVertex(dest) : undefined;
         if (!srcVertex) {
-            return null;
+            return undefined;
         }
         for (const vertex of vertices) {
             const vertexOrKey = vertex[1];
@@ -460,10 +460,10 @@ class AbstractGraph {
                 distMap.set(vertexOrKey, Infinity);
         }
         distMap.set(srcVertex, 0);
-        preMap.set(srcVertex, null);
+        preMap.set(srcVertex, undefined);
         const getMinOfNoSeen = () => {
             let min = Infinity;
-            let minV = null;
+            let minV = undefined;
             for (const [key, value] of distMap) {
                 if (!seen.has(key)) {
                     if (value < min) {
@@ -511,7 +511,7 @@ class AbstractGraph {
                         if (edge) {
                             const curFromMap = distMap.get(cur);
                             const neighborFromMap = distMap.get(neighbor);
-                            // TODO after no-non-null-assertion not ensure the logic
+                            // TODO after no-non-undefined-assertion not ensure the logic
                             if (curFromMap !== undefined && neighborFromMap !== undefined) {
                                 if (edge.weight + curFromMap < neighborFromMap) {
                                     distMap.set(neighbor, edge.weight + curFromMap);
@@ -558,7 +558,7 @@ class AbstractGraph {
      * optional destination vertex, and optionally returns the minimum distance, the paths, and other information.
      * @param {VO | VertexKey} src - The `src` parameter represents the source vertex from which the Dijkstra algorithm will
      * start. It can be either a vertex object or a vertex ID.
-     * @param {VO | VertexKey | null} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
+     * @param {VO | VertexKey | undefined} [dest] - The `dest` parameter is the destination vertex or vertex ID. It specifies the
      * vertex to which the shortest path is calculated from the source vertex. If no destination is provided, the algorithm
      * will calculate the shortest paths to all other vertices from the source vertex.
      * @param {boolean} [getMinDist] - The `getMinDist` parameter is a boolean flag that determines whether the minimum
@@ -576,9 +576,9 @@ class AbstractGraph {
         if (genPaths === undefined)
             genPaths = false;
         if (dest === undefined)
-            dest = null;
+            dest = undefined;
         let minDist = Infinity;
-        let minDest = null;
+        let minDest = undefined;
         let minPath = [];
         const paths = [];
         const vertices = this._vertices;
@@ -586,9 +586,9 @@ class AbstractGraph {
         const seen = new Set();
         const preMap = new Map(); // predecessor
         const srcVertex = this._getVertex(src);
-        const destVertex = dest ? this._getVertex(dest) : null;
+        const destVertex = dest ? this._getVertex(dest) : undefined;
         if (!srcVertex)
-            return null;
+            return undefined;
         for (const vertex of vertices) {
             const vertexOrKey = vertex[1];
             if (vertexOrKey instanceof AbstractVertex)
@@ -597,11 +597,11 @@ class AbstractGraph {
         const heap = new priority_queue_1.PriorityQueue([], { comparator: (a, b) => a.key - b.key });
         heap.add({ key: 0, value: srcVertex });
         distMap.set(srcVertex, 0);
-        preMap.set(srcVertex, null);
+        preMap.set(srcVertex, undefined);
         /**
          * The function `getPaths` retrieves all paths from vertices to a specified minimum vertex.
-         * @param {VO | null} minV - The parameter `minV` is of type `VO | null`. It represents the minimum vertex value or
-         * null.
+         * @param {VO | undefined} minV - The parameter `minV` is of type `VO | undefined`. It represents the minimum vertex value or
+         * undefined.
          */
         const getPaths = (minV) => {
             for (const vertex of vertices) {
@@ -737,7 +737,7 @@ class AbstractGraph {
                 }
             }
         }
-        let minDest = null;
+        let minDest = undefined;
         if (getMin) {
             distMap.forEach((d, v) => {
                 if (v !== srcVertex) {
@@ -813,7 +813,7 @@ class AbstractGraph {
      * graph.
      * @returns The function `floydWarshall()` returns an object with two properties: `costs` and `predecessor`. The `costs`
      * property is a 2D array of numbers representing the shortest path costs between vertices in a graph. The
-     * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
+     * `predecessor` property is a 2D array of vertices (or `undefined`) representing the predecessor vertices in the shortest
      * path between vertices in the
      */
     floydWarshall() {
@@ -827,7 +827,7 @@ class AbstractGraph {
             costs[i] = [];
             predecessor[i] = [];
             for (let j = 0; j < n; j++) {
-                predecessor[i][j] = null;
+                predecessor[i][j] = undefined;
             }
         }
         for (let i = 0; i < n; i++) {
@@ -919,7 +919,7 @@ class AbstractGraph {
                     }
                     const childLow = lowMap.get(neighbor);
                     const curLow = lowMap.get(cur);
-                    // TODO after no-non-null-assertion not ensure the logic
+                    // TODO after no-non-undefined-assertion not ensure the logic
                     if (curLow !== undefined && childLow !== undefined) {
                         lowMap.set(cur, Math.min(curLow, childLow));
                     }
@@ -943,7 +943,7 @@ class AbstractGraph {
                 }
             }
         };
-        dfs(root, null);
+        dfs(root, undefined);
         let SCCs = new Map();
         const getSCCs = () => {
             const SCCs = new Map();
@@ -1028,6 +1028,47 @@ class AbstractGraph {
     getBridges() {
         return this.tarjan(false, true, false, false).bridges;
     }
+    *[Symbol.iterator]() {
+        for (const vertex of this._vertices.values()) {
+            yield [vertex.key, vertex.value];
+        }
+    }
+    forEach(callback) {
+        let index = 0;
+        for (const vertex of this) {
+            callback(vertex, index, this._vertices);
+            index++;
+        }
+    }
+    filter(predicate) {
+        const filtered = [];
+        let index = 0;
+        for (const entry of this) {
+            if (predicate(entry, index, this._vertices)) {
+                filtered.push(entry);
+            }
+            index++;
+        }
+        return filtered;
+    }
+    map(callback) {
+        const mapped = [];
+        let index = 0;
+        for (const entry of this) {
+            mapped.push(callback(entry, index, this._vertices));
+            index++;
+        }
+        return mapped;
+    }
+    reduce(callback, initialValue) {
+        let accumulator = initialValue;
+        let index = 0;
+        for (const entry of this) {
+            accumulator = callback(accumulator, entry, index, this._vertices);
+            index++;
+        }
+        return accumulator;
+    }
     _addVertexOnly(newVertex) {
         if (this.hasVertex(newVertex)) {
             return false;
@@ -1038,7 +1079,7 @@ class AbstractGraph {
     }
     _getVertex(vertexOrKey) {
         const vertexKey = this._getVertexKey(vertexOrKey);
-        return this._vertices.get(vertexKey) || null;
+        return this._vertices.get(vertexKey) || undefined;
     }
     _getVertexKey(vertexOrKey) {
         return vertexOrKey instanceof AbstractVertex ? vertexOrKey.key : vertexOrKey;

package/dist/data-structures/graph/directed-graph.d.ts

@@ -74,13 +74,13 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * Space Complexity: O(1)
      *
      * The `getEdge` function retrieves an edge between two vertices based on their source and destination IDs.
-     * @param {VO | VertexKey | null} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
-     * @param {VO | VertexKey | null} destOrKey - The `destOrKey` parameter in the `getEdge` function represents the
-     * destination vertex of the edge. It can be either a vertex object (`VO`), a vertex ID (`VertexKey`), or `null` if the
+     * @param {VO | VertexKey | undefined} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
+     * @param {VO | VertexKey | undefined} destOrKey - The `destOrKey` parameter in the `getEdge` function represents the
+     * destination vertex of the edge. It can be either a vertex object (`VO`), a vertex ID (`VertexKey`), or `undefined` if the
      * destination is not specified.
-     * @returns the first edge found between the source and destination vertices, or null if no such edge is found.
+     * @returns the first edge found between the source and destination vertices, or undefined if no such edge is found.
      */
-    getEdge(srcOrKey: VO | VertexKey | null, destOrKey: VO | VertexKey | null): EO | null;
+    getEdge(srcOrKey: VO | VertexKey | undefined, destOrKey: VO | VertexKey | undefined): EO | undefined;
     /**
      * Time Complexity: O(|E|) where |E| is the number of edges
      * Space Complexity: O(1)
@@ -92,9 +92,9 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * The function removes an edge between two vertices in a graph and returns the removed edge.
      * @param {VO | VertexKey} srcOrKey - The source vertex or its ID.
      * @param {VO | VertexKey} destOrKey - The `destOrKey` parameter represents the destination vertex or its ID.
-     * @returns the removed edge (EO) if it exists, or null if either the source or destination vertex does not exist.
+     * @returns the removed edge (EO) if it exists, or undefined if either the source or destination vertex does not exist.
      */
-    deleteEdgeSrcToDest(srcOrKey: VO | VertexKey, destOrKey: VO | VertexKey): EO | null;
+    deleteEdgeSrcToDest(srcOrKey: VO | VertexKey, destOrKey: VO | VertexKey): EO | undefined;
     /**
      * Time Complexity: O(|E|) where |E| is the number of edges
      * Space Complexity: O(1)
@@ -103,12 +103,12 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * Time Complexity: O(|E|) where |E| is the number of edges
      * Space Complexity: O(1)
      *
-     * The function removes an edge from a graph and returns the removed edge, or null if the edge was not found.
+     * The function removes an edge from a graph and returns the removed edge, or undefined if the edge was not found.
      * @param {EO} edge - The `edge` parameter is an object that represents an edge in a graph. It has two properties: `src`
      * and `dest`, which represent the source and destination vertices of the edge, respectively.
-     * @returns The method `deleteEdge` returns the removed edge (`EO`) if it exists, or `null` if the edge does not exist.
+     * @returns The method `deleteEdge` returns the removed edge (`EO`) if it exists, or `undefined` if the edge does not exist.
      */
-    deleteEdge(edge: EO): EO | null;
+    deleteEdge(edge: EO): EO | undefined;
     /**
      * Time Complexity: O(|E|) where |E| is the number of edges
      * Space Complexity: O(1)
@@ -213,11 +213,11 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function "getEdgeSrc" returns the source vertex of an edge, or null if the edge does not exist.
+     * The function "getEdgeSrc" returns the source vertex of an edge, or undefined if the edge does not exist.
      * @param {EO} e - The parameter "e" is of type EO, which represents an edge in a graph.
-     * @returns either a vertex object (VO) or null.
+     * @returns either a vertex object (VO) or undefined.
      */
-    getEdgeSrc(e: EO): VO | null;
+    getEdgeSrc(e: EO): VO | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -228,9 +228,9 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      *
      * The function "getEdgeDest" returns the destination vertex of an edge.
      * @param {EO} e - The parameter "e" is of type "EO", which represents an edge in a graph.
-     * @returns either a vertex object of type VO or null.
+     * @returns either a vertex object of type VO or undefined.
      */
-    getEdgeDest(e: EO): VO | null;
+    getEdgeDest(e: EO): VO | undefined;
     /**
      * Time Complexity: O(|E|) where |E| is the number of edges
      * Space Complexity: O(1)
@@ -240,11 +240,11 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * Space Complexity: O(1)
      *
      * The function `getDestinations` returns an array of destination vertices connected to a given vertex.
-     * @param {VO | VertexKey | null} vertex - The `vertex` parameter represents the starting vertex from which we want to
-     * find the destinations. It can be either a `VO` object, a `VertexKey` value, or `null`.
+     * @param {VO | VertexKey | undefined} vertex - The `vertex` parameter represents the starting vertex from which we want to
+     * find the destinations. It can be either a `VO` object, a `VertexKey` value, or `undefined`.
      * @returns an array of vertices (VO[]).
      */
-    getDestinations(vertex: VO | VertexKey | null): VO[];
+    getDestinations(vertex: VO | VertexKey | undefined): VO[];
     /**
      * Time Complexity: O(|V| + |E|) where |V| is the number of vertices and |E| is the number of edges
      * Space Complexity: O(|V|)
@@ -254,13 +254,13 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * Space Complexity: O(|V|)
      *
      * The `topologicalSort` function performs a topological sort on a graph and returns an array of vertices or vertex IDs
-     * in the sorted order, or null if the graph contains a cycle.
+     * in the sorted order, or undefined if the graph contains a cycle.
      * @param {'vertex' | 'key'} [propertyName] - The `propertyName` parameter is an optional parameter that specifies the
      * property to use for sorting the vertices. It can have two possible values: 'vertex' or 'key'. If 'vertex' is
      * specified, the vertices themselves will be used for sorting. If 'key' is specified, the ids of
-     * @returns an array of vertices or vertex IDs in topological order. If there is a cycle in the graph, it returns null.
+     * @returns an array of vertices or vertex IDs in topological order. If there is a cycle in the graph, it returns undefined.
      */
-    topologicalSort(propertyName?: 'vertex' | 'key'): Array<VO | VertexKey> | null;
+    topologicalSort(propertyName?: 'vertex' | 'key'): Array<VO | VertexKey> | undefined;
     /**
      * Time Complexity: O(|E|) where |E| is the number of edges
      * Space Complexity: O(|E|)
@@ -296,12 +296,12 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * Space Complexity: O(1)
      *
      * The function "getEndsOfEdge" returns the source and destination vertices of an edge if it exists in the graph,
-     * otherwise it returns null.
+     * 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
-     * graph. If the edge does not exist, it returns `null`.
+     * graph. If the edge does not exist, it returns `undefined`.
      */
-    getEndsOfEdge(edge: EO): [VO, VO] | null;
+    getEndsOfEdge(edge: EO): [VO, VO] | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)