data-structure-typed 2.0.5 → 2.1.1

package/dist/cjs/data-structures/graph/map-graph.d.ts

@@ -1,84 +0,0 @@
-import type { MapGraphCoordinate, VertexKey } from '../../types';
-import { DirectedEdge, DirectedGraph, DirectedVertex } from './directed-graph';
-export declare class MapVertex<V = any> extends DirectedVertex<V> {
-    lat: number;
-    long: number;
-    /**
-     * The constructor function initializes an object with an key, latitude, longitude, and an optional value.
-     * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex.
-     * @param {number} lat - The "lat" parameter represents the latitude of a vertex. Latitude is a geographic coordinate
-     * that specifies the north-south position of a point on the Earth's surface. It is measured in degrees, with positive
-     * values representing points north of the equator and negative values representing points south of the equator.
-     * @param {number} long - The "long" parameter represents the longitude of a location. Longitude is a geographic
-     * coordinate that specifies the east-west position of a point on the Earth's surface. It is measured in degrees, with
-     * values ranging from -180 to 180.
-     * @param {V} [value] - The "value" parameter is an optional value of type V. It is not required to be provided when
-     * creating an instance of the class.
-     */
-    constructor(key: VertexKey, value: V, lat: number, long: number);
-}
-export declare class MapEdge<E = any> extends DirectedEdge<E> {
-    /**
-     * The constructor function initializes a new instance of a class with the given source, destination, weight, and
-     * value.
-     * @param {VertexKey} src - The `src` parameter is the source vertex ID. It represents the starting point of an edge in
-     * a graph.
-     * @param {VertexKey} dest - The `dest` parameter is the identifier of the destination vertex for an edge.
-     * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {E} [value] - The "value" parameter is an optional parameter of type E. It is used to store additional
-     * information or data associated with the edge.
-     */
-    constructor(src: VertexKey, dest: VertexKey, weight?: number, value?: E);
-}
-/**
- *
- */
-export declare class MapGraph<V = any, E = any, VO extends MapVertex<V> = MapVertex<V>, EO extends MapEdge<E> = MapEdge<E>> extends DirectedGraph<V, E, VO, EO> {
-    /**
-     * The constructor function initializes the originCoord and bottomRight properties of a MapGraphCoordinate object.
-     * @param {MapGraphCoordinate} originCoord - The `originCoord` parameter is a `MapGraphCoordinate` object that represents the
-     * starting point or reference point of the map graph. It defines the coordinates of the top-left corner of the map
-     * graph.
-     * @param {MapGraphCoordinate} [bottomRight] - The `bottomRight` parameter is an optional parameter of type
-     * `MapGraphCoordinate`. It represents the bottom right coordinate of a map graph. If this parameter is not provided,
-     * it will default to `undefined`.
-     */
-    constructor(originCoord: MapGraphCoordinate, bottomRight?: MapGraphCoordinate);
-    protected _originCoord: MapGraphCoordinate;
-    get originCoord(): MapGraphCoordinate;
-    protected _bottomRight: MapGraphCoordinate | undefined;
-    get bottomRight(): MapGraphCoordinate | undefined;
-    /**
-     * The function creates a new vertex with the given key, value, latitude, and longitude.
-     * @param {VertexKey} key - The key parameter is the unique identifier for the vertex. It is of type VertexKey, which could
-     * be a string or a number depending on how you define it in your code.
-     * @param [value] - The `value` parameter is an optional value that can be assigned to the `value` property of the vertex. It
-     * is of type `V`, which means it should be of the same type as the `value` property of the vertex class `VO`.
-     * @param {number} lat - The `lat` parameter represents the latitude of the vertex. It is a number that specifies the
-     * position of the vertex on the Earth's surface in the north-south direction.
-     * @param {number} long - The `long` parameter represents the longitude coordinate of the vertex.
-     * @returns The method is returning a new instance of the `MapVertex` class, casted as type `VO`.
-     */
-    createVertex(key: VertexKey, value?: V, lat?: number, long?: number): VO;
-    /**
-     * The function creates a new instance of a MapEdge with the given source, destination, weight, and value.
-     * @param {VertexKey} src - The source vertex ID of the edge. It represents the starting point of the edge.
-     * @param {VertexKey} dest - The `dest` parameter is the identifier of the destination vertex for the edge being
-     * created.
-     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. It
-     * is used to assign a numerical value to the edge, which can be used in algorithms such as shortest path algorithms.
-     * If the weight is not provided, it can be set to a default value or left undefined.
-     * @param [value] - The `value` parameter is an optional value that can be assigned to the edge. It can be of any type,
-     * depending on the specific implementation of the `MapEdge` class.
-     * @returns a new instance of the `MapEdge` class, cast as type `EO`.
-     */
-    createEdge(src: VertexKey, dest: VertexKey, weight?: number, value?: E): EO;
-    /**
-     * The override function is used to override the default behavior of a function.
-     * In this case, we are overriding the clone() function from Graph&lt;V, E&gt;.
-     * The clone() function returns a new graph that is an exact copy of the original graph.
-     *
-     * @return A mapgraph&lt;v, e, vo, eo&gt;
-     */
-    clone(): MapGraph<V, E, VO, EO>;
-}

package/dist/cjs/data-structures/graph/map-graph.js

@@ -1,111 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MapGraph = exports.MapEdge = exports.MapVertex = void 0;
-const directed_graph_1 = require("./directed-graph");
-class MapVertex extends directed_graph_1.DirectedVertex {
-    /**
-     * The constructor function initializes an object with an key, latitude, longitude, and an optional value.
-     * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex.
-     * @param {number} lat - The "lat" parameter represents the latitude of a vertex. Latitude is a geographic coordinate
-     * that specifies the north-south position of a point on the Earth's surface. It is measured in degrees, with positive
-     * values representing points north of the equator and negative values representing points south of the equator.
-     * @param {number} long - The "long" parameter represents the longitude of a location. Longitude is a geographic
-     * coordinate that specifies the east-west position of a point on the Earth's surface. It is measured in degrees, with
-     * values ranging from -180 to 180.
-     * @param {V} [value] - The "value" parameter is an optional value of type V. It is not required to be provided when
-     * creating an instance of the class.
-     */
-    constructor(key, value, lat, long) {
-        super(key, value);
-        this.lat = lat;
-        this.long = long;
-    }
-}
-exports.MapVertex = MapVertex;
-class MapEdge extends directed_graph_1.DirectedEdge {
-    /**
-     * The constructor function initializes a new instance of a class with the given source, destination, weight, and
-     * value.
-     * @param {VertexKey} src - The `src` parameter is the source vertex ID. It represents the starting point of an edge in
-     * a graph.
-     * @param {VertexKey} dest - The `dest` parameter is the identifier of the destination vertex for an edge.
-     * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {E} [value] - The "value" parameter is an optional parameter of type E. It is used to store additional
-     * information or data associated with the edge.
-     */
-    constructor(src, dest, weight, value) {
-        super(src, dest, weight, value);
-    }
-}
-exports.MapEdge = MapEdge;
-/**
- *
- */
-class MapGraph extends directed_graph_1.DirectedGraph {
-    /**
-     * The constructor function initializes the originCoord and bottomRight properties of a MapGraphCoordinate object.
-     * @param {MapGraphCoordinate} originCoord - The `originCoord` parameter is a `MapGraphCoordinate` object that represents the
-     * starting point or reference point of the map graph. It defines the coordinates of the top-left corner of the map
-     * graph.
-     * @param {MapGraphCoordinate} [bottomRight] - The `bottomRight` parameter is an optional parameter of type
-     * `MapGraphCoordinate`. It represents the bottom right coordinate of a map graph. If this parameter is not provided,
-     * it will default to `undefined`.
-     */
-    constructor(originCoord, bottomRight) {
-        super();
-        this._originCoord = [0, 0];
-        this._originCoord = originCoord;
-        this._bottomRight = bottomRight;
-    }
-    get originCoord() {
-        return this._originCoord;
-    }
-    get bottomRight() {
-        return this._bottomRight;
-    }
-    /**
-     * The function creates a new vertex with the given key, value, latitude, and longitude.
-     * @param {VertexKey} key - The key parameter is the unique identifier for the vertex. It is of type VertexKey, which could
-     * be a string or a number depending on how you define it in your code.
-     * @param [value] - The `value` parameter is an optional value that can be assigned to the `value` property of the vertex. It
-     * is of type `V`, which means it should be of the same type as the `value` property of the vertex class `VO`.
-     * @param {number} lat - The `lat` parameter represents the latitude of the vertex. It is a number that specifies the
-     * position of the vertex on the Earth's surface in the north-south direction.
-     * @param {number} long - The `long` parameter represents the longitude coordinate of the vertex.
-     * @returns The method is returning a new instance of the `MapVertex` class, casted as type `VO`.
-     */
-    createVertex(key, value, lat = this.originCoord[0], long = this.originCoord[1]) {
-        return new MapVertex(key, value, lat, long);
-    }
-    /**
-     * The function creates a new instance of a MapEdge with the given source, destination, weight, and value.
-     * @param {VertexKey} src - The source vertex ID of the edge. It represents the starting point of the edge.
-     * @param {VertexKey} dest - The `dest` parameter is the identifier of the destination vertex for the edge being
-     * created.
-     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. It
-     * is used to assign a numerical value to the edge, which can be used in algorithms such as shortest path algorithms.
-     * If the weight is not provided, it can be set to a default value or left undefined.
-     * @param [value] - The `value` parameter is an optional value that can be assigned to the edge. It can be of any type,
-     * depending on the specific implementation of the `MapEdge` class.
-     * @returns a new instance of the `MapEdge` class, cast as type `EO`.
-     */
-    createEdge(src, dest, weight, value) {
-        return new MapEdge(src, dest, weight, value);
-    }
-    /**
-     * The override function is used to override the default behavior of a function.
-     * In this case, we are overriding the clone() function from Graph<V, E>.
-     * The clone() function returns a new graph that is an exact copy of the original graph.
-     *
-     * @return A mapgraph<v, e, vo, eo>
-     */
-    clone() {
-        const cloned = new MapGraph(this.originCoord, this.bottomRight);
-        cloned.vertexMap = new Map(this.vertexMap);
-        cloned.inEdgeMap = new Map(this.inEdgeMap);
-        cloned.outEdgeMap = new Map(this.outEdgeMap);
-        return cloned;
-    }
-}
-exports.MapGraph = MapGraph;
-//# sourceMappingURL=map-graph.js.map

package/dist/cjs/data-structures/graph/map-graph.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"map-graph.js","sourceRoot":"","sources":["../../../../src/data-structures/graph/map-graph.ts"],"names":[],"mappings":";;;AACA,qDAA+E;AAE/E,MAAa,SAAmB,SAAQ,+BAAiB;IAIvD;;;;;;;;;;;OAWG;IACH,YAAY,GAAc,EAAE,KAAQ,EAAE,GAAW,EAAE,IAAY;QAC7D,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAClB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AArBD,8BAqBC;AAED,MAAa,OAAiB,SAAQ,6BAAe;IACnD;;;;;;;;;OASG;IACH,YAAY,GAAc,EAAE,IAAe,EAAE,MAAe,EAAE,KAAS;QACrE,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;IAClC,CAAC;CACF;AAdD,0BAcC;AAED;;GAEG;AACH,MAAa,QAKX,SAAQ,8BAA2B;IACnC;;;;;;;;OAQG;IACH,YAAY,WAA+B,EAAE,WAAgC;QAC3E,KAAK,EAAE,CAAC;QAKA,iBAAY,GAAuB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAJlD,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC;QAChC,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC;IAClC,CAAC;IAID,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAID,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED;;;;;;;;;;OAUG;IACM,YAAY,CACnB,GAAc,EACd,KAAS,EACT,MAAc,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EACjC,OAAe,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QAElC,OAAO,IAAI,SAAS,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,CAAO,CAAC;IACpD,CAAC;IAED;;;;;;;;;;;OAWG;IACM,UAAU,CAAC,GAAc,EAAE,IAAe,EAAE,MAAe,EAAE,KAAS;QAC7E,OAAO,IAAI,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAO,CAAC;IACrD,CAAC;IAED;;;;;;OAMG;IACM,KAAK;QACZ,MAAM,MAAM,GAAG,IAAI,QAAQ,CAAe,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAC9E,MAAM,CAAC,SAAS,GAAG,IAAI,GAAG,CAAgB,IAAI,CAAC,SAAS,CAAC,CAAC;QAC1D,MAAM,CAAC,SAAS,GAAG,IAAI,GAAG,CAAW,IAAI,CAAC,SAAS,CAAC,CAAC;QACrD,MAAM,CAAC,UAAU,GAAG,IAAI,GAAG,CAAW,IAAI,CAAC,UAAU,CAAC,CAAC;QACvD,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AAnFD,4BAmFC"}

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

@@ -1,231 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Pablo Zeng
- * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import type { VertexKey } from '../../types';
-import { IGraph } from '../../interfaces';
-import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
-export declare class UndirectedVertex<V = any> extends AbstractVertex<V> {
-    /**
-     * The constructor function initializes a vertex with an optional value.
-     * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
-     * used to uniquely identify the vertex within a graph or network.
-     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It is used to initialize the value of the
-     * vertex. If no value is provided, the vertex will be initialized with a default value.
-     */
-    constructor(key: VertexKey, value?: V);
-}
-export declare class UndirectedEdge<E = number> extends AbstractEdge<E> {
-    endpoints: [VertexKey, VertexKey];
-    /**
-     * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
-     * value.
-     * @param {VertexKey} v1 - The first vertex ID of the edge.
-     * @param {VertexKey} v2 - The parameter `v2` is a `VertexKey`, which represents the identifier of the second vertex in a
-     * graph edge.
-     * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {E} [value] - The "value" parameter is an optional parameter of type E. It is used to store a value associated
-     * with the edge.
-     */
-    constructor(v1: VertexKey, v2: VertexKey, weight?: number, value?: 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 edgeMap.
-     */
-    constructor();
-    protected _edgeMap: Map<VO, EO[]>;
-    get edgeMap(): Map<VO, EO[]>;
-    set edgeMap(v: 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
-     * vertex from another in the graph.
-     * @param [value] - The `value` parameter is an optional value that can be assigned to the vertex. If a value is provided,
-     * it will be used as the value of the vertex. If no value is provided, the `key` parameter will be used as the value of
-     * the vertex.
-     * @returns The method is returning a new instance of the `UndirectedVertex` class, casted as type `VO`.
-     */
-    createVertex(key: VertexKey, value?: VO['value']): VO;
-    /**
-     * 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
-     * no weight is provided, it defaults to 1.
-     * @param [value] - The `value` parameter is an optional value that can be assigned to the edge. It can be of any type and
-     * is used to store additional information or data associated with the edge.
-     * @returns a new instance of the `UndirectedEdge` class, which is casted as type `EO`.
-     */
-    createEdge(v1: VertexKey, v2: VertexKey, weight?: number, value?: EO['value']): EO;
-    /**
-     * 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 endpoints, 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
-     * object), `undefined`, or `VertexKey` (vertex ID).
-     * @returns an edge (EO) or undefined.
-     */
-    getEdge(v1: VO | VertexKey | undefined, v2: VO | VertexKey | undefined): EO | undefined;
-    /**
-     * 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 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 endpoints (VO) does not exist.
-     */
-    deleteEdgeBetween(v1: VO | VertexKey, v2: VO | VertexKey): EO | undefined;
-    /**
-     * 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 endpoints 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: EO | VertexKey, otherSideVertexKey?: VertexKey): EO | undefined;
-    /**
-     * 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: VO | VertexKey): boolean;
-    /**
-     * 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 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
-     * edgeMap connected to that vertex.
-     */
-    degreeOf(vertexOrKey: VertexKey | VO): number;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * 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 edgeMap.
-     */
-    edgesOf(vertexOrKey: VertexKey | VO): EO[];
-    /**
-     * 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 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 vertexMap and |E| is the number of edgeMap.
-     * Space Complexity: O(|E|)
-     *
-     * The function "getNeighbors" returns an array of neighboring endpoints 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 vertexMap (VO[]).
-     */
-    getNeighbors(vertexOrKey: VO | VertexKey): VO[];
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function "getEndsOfEdge" returns the endpoints 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 endpoints `[VO, VO]` if the edge exists in the
-     * graph. If the edge does not exist, it returns `undefined`.
-     */
-    getEndsOfEdge(edge: EO): [VO, VO] | undefined;
-    /**
-     * The isEmpty function checks if the graph is empty.
-     * @return True if the graph is empty and false otherwise
-     */
-    isEmpty(): boolean;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The clear function resets the vertex and edge maps to empty maps.
-     */
-    clear(): void;
-    /**
-     * The clone function creates a new UndirectedGraph object and copies the
-     * vertexMap and edgeMap from this graph to the new one. This is done by
-     * assigning each of these properties to their respective counterparts in the
-     * cloned graph. The clone function returns a reference to this newly created,
-     * cloned UndirectedGraph object.
-     *
-     * @return A new instance of the undirectedgraph class
-     */
-    clone(): UndirectedGraph<V, E, VO, EO>;
-    /**
-     *  Time Complexity: O(V + E)
-     *  Space Complexity: O(V)
-     *   Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
-     *  1. Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time
-     *
-     * The function `tarjan` implements the Tarjan's algorithm to find bridges and cut vertices in a
-     * graph.
-     * @returns The function `tarjan()` returns an object with the following properties:
-     */
-    tarjan(): {
-        dfnMap: Map<VO, number>;
-        lowMap: Map<VO, number>;
-        bridges: EO[];
-        cutVertices: VO[];
-    };
-    /**
-     * The function "getBridges" returns an array of bridges in a graph using the Tarjan's algorithm.
-     * @returns The function `getBridges()` is returning the bridges found using the Tarjan's algorithm.
-     */
-    getBridges(): EO[];
-    /**
-     * The function "getCutVertices" returns an array of cut vertices using the Tarjan's algorithm.
-     * @returns the cut vertices found using the Tarjan's algorithm.
-     */
-    getCutVertices(): VO[];
-    /**
-     * The function returns the dfnMap property of the result of the tarjan() function.
-     * @returns the `dfnMap` property of the result of calling the `tarjan()` function.
-     */
-    getDFNMap(): Map<VO, number>;
-    /**
-     * The function returns the lowMap property of the result of the tarjan() function.
-     * @returns the lowMap property of the result of calling the tarjan() function.
-     */
-    getLowMap(): Map<VO, number>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * 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.
-     */
-    protected _addEdge(edge: EO): boolean;
-}