@graphty/algorithms 1.3.1 → 1.5.0

package/src/algorithms/matching/isomorphism.ts

@@ -1,5 +1,5 @@
-import type {Graph} from "../../core/graph.js";
-import type {NodeId} from "../../types/index.js";
+import type { Graph } from "../../core/graph.js";
+import type { NodeId } from "../../types/index.js";
 
 /**
  * Graph Isomorphism (VF2) algorithm implementation
@@ -37,19 +37,19 @@ interface VF2State {
 
 /**
  * Check if two graphs are isomorphic using VF2 algorithm
+ * @param graph1 - The first graph to compare
+ * @param graph2 - The second graph to compare
+ * @param options - Optional configuration for node and edge matching predicates
+ * @returns An object indicating if the graphs are isomorphic and an optional mapping between nodes
  */
-export function isGraphIsomorphic(
-    graph1: Graph,
-    graph2: Graph,
-    options: IsomorphismOptions = {},
-): IsomorphismResult {
+export function isGraphIsomorphic(graph1: Graph, graph2: Graph, options: IsomorphismOptions = {}): IsomorphismResult {
     // Quick checks
     if (graph1.nodeCount !== graph2.nodeCount || graph1.totalEdgeCount !== graph2.totalEdgeCount) {
-        return {isIsomorphic: false};
+        return { isIsomorphic: false };
     }
 
     if (graph1.isDirected !== graph2.isDirected) {
-        return {isIsomorphic: false};
+        return { isIsomorphic: false };
     }
 
     const nodes1 = Array.from(graph1.nodes()).map((n) => n.id);
@@ -61,7 +61,7 @@ export function isGraphIsomorphic(
 
     for (let i = 0; i < degrees1.length; i++) {
         if (degrees1[i] !== degrees2[i]) {
-            return {isIsomorphic: false};
+            return { isIsomorphic: false };
         }
     }
 
@@ -87,11 +87,19 @@ export function isGraphIsomorphic(
         };
     }
 
-    return {isIsomorphic: false};
+    return { isIsomorphic: false };
 }
 
 /**
  * VF2 recursive search
+ * @param g1 - The first graph being compared
+ * @param g2 - The second graph being compared
+ * @param state - The current VF2 algorithm state containing mappings and terminal sets
+ * @param nodes1 - Array of node IDs from the first graph
+ * @param nodes2 - Array of node IDs from the second graph
+ * @param options - Configuration options for matching predicates
+ * @param mappings - Array to collect found isomorphism mappings
+ * @returns True if an isomorphism was found and search should stop, false otherwise
  */
 function vf2Recurse(
     g1: Graph,
@@ -127,6 +135,12 @@ function vf2Recurse(
 
 /**
  * Get candidate pairs for the next mapping
+ * @param g1 - The first graph being compared
+ * @param g2 - The second graph being compared
+ * @param state - The current VF2 algorithm state containing mappings and terminal sets
+ * @param nodes1 - Array of node IDs from the first graph
+ * @param nodes2 - Array of node IDs from the second graph
+ * @returns Array of candidate node pairs to try matching
  */
 function getCandidatePairs(
     g1: Graph,
@@ -187,6 +201,13 @@ function getCandidatePairs(
 
 /**
  * Check if a pair is feasible
+ * @param g1 - The first graph being compared
+ * @param g2 - The second graph being compared
+ * @param state - The current VF2 algorithm state containing mappings and terminal sets
+ * @param node1 - The candidate node from the first graph
+ * @param node2 - The candidate node from the second graph
+ * @param options - Configuration options for matching predicates
+ * @returns True if the node pair can be feasibly matched, false otherwise
  */
 function isFeasible(
     g1: Graph,
@@ -222,8 +243,14 @@ function isFeasible(
     }
 
     // Check terminal set sizes
-    let new1In = 0; let new1Out = 0; let term1In = 0; let term1Out = 0;
-    let new2In = 0; let new2Out = 0; let term2In = 0; let term2Out = 0;
+    let new1In = 0;
+    let new1Out = 0;
+    let term1In = 0;
+    let term1Out = 0;
+    let new2In = 0;
+    let new2Out = 0;
+    let term2In = 0;
+    let term2Out = 0;
 
     for (const neighbor of neighbors1) {
         if (state.core1.has(neighbor)) {
@@ -271,20 +298,19 @@ function isFeasible(
         }
     }
 
-    return term1In === term2In && term1Out === term2Out &&
-           new1In === new2In && new1Out === new2Out;
+    return term1In === term2In && term1Out === term2Out && new1In === new2In && new1Out === new2Out;
 }
 
 /**
  * Add a pair to the mapping and update terminal sets
+ * @param g1 - The first graph being compared
+ * @param g2 - The second graph being compared
+ * @param state - The current VF2 algorithm state containing mappings and terminal sets
+ * @param node1 - The node from the first graph to add to the mapping
+ * @param node2 - The node from the second graph to add to the mapping
+ * @returns A new VF2 state with the pair added and terminal sets updated
  */
-function addPair(
-    g1: Graph,
-    g2: Graph,
-    state: VF2State,
-    node1: NodeId,
-    node2: NodeId,
-): VF2State {
+function addPair(g1: Graph, g2: Graph, state: VF2State, node1: NodeId, node2: NodeId): VF2State {
     const newState: VF2State = {
         core1: new Map(state.core1),
         core2: new Map(state.core2),
@@ -340,6 +366,10 @@ function addPair(
 
 /**
  * Find all isomorphisms between two graphs
+ * @param graph1 - The first graph to compare
+ * @param graph2 - The second graph to compare
+ * @param options - Optional configuration for node and edge matching predicates
+ * @returns An array of all possible node mappings between the graphs
  */
 export function findAllIsomorphisms(
     graph1: Graph,
@@ -386,7 +416,7 @@ export function findAllIsomorphisms(
 
     // Find all isomorphisms
     const mappings: Map<NodeId, NodeId>[] = [];
-    vf2Recurse(graph1, graph2, state, nodes1, nodes2, {... options, findAllMappings: true}, mappings);
+    vf2Recurse(graph1, graph2, state, nodes1, nodes2, { ...options, findAllMappings: true }, mappings);
 
     return mappings;
 }

package/src/algorithms/mst/index.ts

@@ -1,4 +1,3 @@
-export type {MSTResult} from "./kruskal.js";
-export {kruskalMST, minimumSpanningTree} from "./kruskal.js";
-export {primMST} from "./prim.js";
-
+export type { MSTResult } from "./kruskal.js";
+export { kruskalMST, minimumSpanningTree } from "./kruskal.js";
+export { primMST } from "./prim.js";

package/src/algorithms/mst/kruskal.ts

@@ -1,12 +1,20 @@
-import {Graph} from "../../core/graph.js";
-import {UnionFind} from "../../data-structures/union-find.js";
-import type {Edge} from "../../types/index.js";
+import { Graph } from "../../core/graph.js";
+import { UnionFind } from "../../data-structures/union-find.js";
+import type { Edge } from "../../types/index.js";
 
 export interface MSTResult {
     edges: Edge[];
     totalWeight: number;
 }
 
+/**
+ * Computes the minimum spanning tree of an undirected graph using Kruskal's algorithm.
+ * The algorithm sorts edges by weight and greedily adds edges that don't create cycles,
+ * using a union-find data structure to efficiently detect cycles.
+ * @param graph - The undirected graph to compute the MST for
+ * @returns The minimum spanning tree as a set of edges and the total weight
+ * @throws Error if the graph is directed or not connected
+ */
 export function kruskalMST(graph: Graph): MSTResult {
     if (graph.isDirected) {
         throw new Error("Kruskal's algorithm requires an undirected graph");
@@ -16,9 +24,10 @@ export function kruskalMST(graph: Graph): MSTResult {
     const visitedEdges = new Set<string>();
 
     for (const edge of Array.from(graph.edges())) {
-        const edgeKey = edge.source < edge.target ?
-            `${String(edge.source)}-${String(edge.target)}` :
-            `${String(edge.target)}-${String(edge.source)}`;
+        const edgeKey =
+            edge.source < edge.target
+                ? `${String(edge.source)}-${String(edge.target)}`
+                : `${String(edge.target)}-${String(edge.source)}`;
 
         if (!visitedEdges.has(edgeKey)) {
             visitedEdges.add(edgeKey);
@@ -56,6 +65,12 @@ export function kruskalMST(graph: Graph): MSTResult {
     };
 }
 
+/**
+ * Alias for kruskalMST. Computes the minimum spanning tree of an undirected graph.
+ * @param graph - The undirected graph to compute the MST for
+ * @returns The minimum spanning tree as a set of edges and the total weight
+ * @throws Error if the graph is directed or not connected
+ */
 export function minimumSpanningTree(graph: Graph): MSTResult {
     return kruskalMST(graph);
 }

package/src/algorithms/mst/prim.ts

@@ -1,8 +1,17 @@
-import {Graph} from "../../core/graph.js";
-import {PriorityQueue} from "../../data-structures/priority-queue.js";
-import type {Edge, NodeId} from "../../types/index.js";
-import type {MSTResult} from "./kruskal.js";
+import { Graph } from "../../core/graph.js";
+import { PriorityQueue } from "../../data-structures/priority-queue.js";
+import type { Edge, NodeId } from "../../types/index.js";
+import type { MSTResult } from "./kruskal.js";
 
+/**
+ * Computes the minimum spanning tree of an undirected graph using Prim's algorithm.
+ * The algorithm grows the MST from a starting node by repeatedly adding the minimum
+ * weight edge that connects a node in the tree to a node outside the tree.
+ * @param graph - The undirected graph to compute the MST for
+ * @param startNode - Optional starting node; if not provided, uses the first node in the graph
+ * @returns The minimum spanning tree as a set of edges and the total weight
+ * @throws Error if the graph is directed, the start node is not found, or the graph is not connected
+ */
 export function primMST(graph: Graph, startNode?: NodeId): MSTResult {
     if (graph.isDirected) {
         throw new Error("Prim's algorithm requires an undirected graph");

package/src/algorithms/shortest-path/bellman-ford.ts

@@ -1,6 +1,6 @@
-import type {Graph} from "../../core/graph.js";
-import type {NodeId, ShortestPathResult} from "../../types/index.js";
-import {reconstructPath} from "../../utils/graph-utilities.js";
+import type { Graph } from "../../core/graph.js";
+import type { NodeId, ShortestPathResult } from "../../types/index.js";
+import { reconstructPath } from "../../utils/graph-utilities.js";
 
 /**
  * Bellman-Ford algorithm implementation for single-source shortest paths
@@ -44,12 +44,12 @@ export interface BellmanFordResult {
 
 /**
  * Find shortest paths from source using Bellman-Ford algorithm
+ * @param graph - The graph to search
+ * @param source - The starting node for the search
+ * @param options - Algorithm options including optional target for early termination
+ * @returns The distances, predecessors, and negative cycle information
  */
-export function bellmanFord(
-    graph: Graph,
-    source: NodeId,
-    options: BellmanFordOptions = {},
-): BellmanFordResult {
+export function bellmanFord(graph: Graph, source: NodeId, options: BellmanFordOptions = {}): BellmanFordResult {
     if (!graph.hasNode(source)) {
         throw new Error(`Source node ${String(source)} not found in graph`);
     }
@@ -130,12 +130,12 @@ export function bellmanFord(
 
 /**
  * Find shortest path between two specific nodes using Bellman-Ford
+ * @param graph - The graph to search
+ * @param source - The starting node for the path
+ * @param target - The destination node for the path
+ * @returns The shortest path result or null if no path exists
  */
-export function bellmanFordPath(
-    graph: Graph,
-    source: NodeId,
-    target: NodeId,
-): ShortestPathResult | null {
+export function bellmanFordPath(graph: Graph, source: NodeId, target: NodeId): ShortestPathResult | null {
     if (!graph.hasNode(source)) {
         throw new Error(`Source node ${String(source)} not found in graph`);
     }
@@ -144,7 +144,7 @@ export function bellmanFordPath(
         throw new Error(`Target node ${String(target)} not found in graph`);
     }
 
-    const result = bellmanFord(graph, source, {target});
+    const result = bellmanFord(graph, source, { target });
 
     if (result.hasNegativeCycle) {
         throw new Error("Graph contains a negative cycle");
@@ -168,6 +168,8 @@ export function bellmanFordPath(
 
 /**
  * Check if graph has negative cycles using Bellman-Ford
+ * @param graph - The graph to check for negative cycles
+ * @returns True if the graph contains a negative cycle
  */
 export function hasNegativeCycle(graph: Graph): boolean {
     const nodes = Array.from(graph.nodes());
@@ -198,4 +200,3 @@ export function hasNegativeCycle(graph: Graph): boolean {
 
     return false;
 }
-

package/src/algorithms/shortest-path/bidirectional-dijkstra.ts

@@ -1,6 +1,6 @@
-import type {Graph} from "../../core/graph.js";
-import {PriorityQueue} from "../../data-structures/priority-queue.js";
-import type {NodeId, ShortestPathResult} from "../../types/index.js";
+import type { Graph } from "../../core/graph.js";
+import { PriorityQueue } from "../../data-structures/priority-queue.js";
+import type { NodeId, ShortestPathResult } from "../../types/index.js";
 
 interface SearchState {
     distances: Map<NodeId, number>;
@@ -30,6 +30,10 @@ export class BidirectionalDijkstra {
     private meetingNode: NodeId | null = null;
     private shortestDistance = Infinity;
 
+    /**
+     * Creates a new BidirectionalDijkstra instance
+     * @param graph - The graph to search for shortest paths
+     */
     constructor(graph: Graph) {
         this.graph = graph;
         this.forwardSearch = this.initSearchState();
@@ -46,10 +50,13 @@ export class BidirectionalDijkstra {
     }
 
     /**
-   * Find shortest path between source and target nodes
-   */
+     * Find shortest path between source and target nodes
+     * @param source - The starting node for the path
+     * @param target - The destination node for the path
+     * @returns The shortest path result or null if no path exists
+     */
     public findShortestPath(source: NodeId, target: NodeId): ShortestPathResult | null {
-    // Reset state for new search
+        // Reset state for new search
         this.reset();
         if (!this.graph.hasNode(source)) {
             throw new Error(`Source node ${String(source)} not found in graph`);
@@ -79,15 +86,16 @@ export class BidirectionalDijkstra {
         this.backwardSearch.frontier.enqueue(target, 0);
 
         // Main search loop
-        while (!this.forwardSearch.frontier.isEmpty() ||
-           !this.backwardSearch.frontier.isEmpty()) {
+        while (!this.forwardSearch.frontier.isEmpty() || !this.backwardSearch.frontier.isEmpty()) {
             // Alternate between forward and backward search
             // Choose the search with smaller frontier for better performance
             let searchExpanded = false;
 
-            if (!this.forwardSearch.frontier.isEmpty() &&
-          (this.backwardSearch.frontier.isEmpty() ||
-           this.forwardSearch.frontier.size() <= this.backwardSearch.frontier.size())) {
+            if (
+                !this.forwardSearch.frontier.isEmpty() &&
+                (this.backwardSearch.frontier.isEmpty() ||
+                    this.forwardSearch.frontier.size() <= this.backwardSearch.frontier.size())
+            ) {
                 if (this.expandSearch(this.forwardSearch, this.backwardSearch, true)) {
                     break;
                 }
@@ -102,8 +110,7 @@ export class BidirectionalDijkstra {
             }
 
             // Continue until both frontiers are empty or we've found an optimal path
-            if (this.forwardSearch.frontier.isEmpty() &&
-          this.backwardSearch.frontier.isEmpty()) {
+            if (this.forwardSearch.frontier.isEmpty() && this.backwardSearch.frontier.isEmpty()) {
                 break;
             }
         }
@@ -119,11 +126,7 @@ export class BidirectionalDijkstra {
         };
     }
 
-    private expandSearch(
-        search: SearchState,
-        oppositeSearch: SearchState,
-        isForward: boolean,
-    ): boolean {
+    private expandSearch(search: SearchState, oppositeSearch: SearchState, isForward: boolean): boolean {
         const current = search.frontier.dequeue();
         if (current === undefined) {
             return false;
@@ -150,18 +153,16 @@ export class BidirectionalDijkstra {
         }
 
         // Explore neighbors
-        const neighbors = isForward ?
-            Array.from(this.graph.neighbors(current)) :
-            Array.from(this.graph.inNeighbors(current));
+        const neighbors = isForward
+            ? Array.from(this.graph.neighbors(current))
+            : Array.from(this.graph.inNeighbors(current));
 
         for (const neighbor of neighbors) {
             if (search.visited.has(neighbor)) {
                 continue;
             }
 
-            const edge = isForward ?
-                this.graph.getEdge(current, neighbor) :
-                this.graph.getEdge(neighbor, current);
+            const edge = isForward ? this.graph.getEdge(current, neighbor) : this.graph.getEdge(neighbor, current);
 
             if (!edge) {
                 continue;
@@ -175,8 +176,7 @@ export class BidirectionalDijkstra {
             const newDistance = distance + edgeWeight;
             const currentNeighborDistance = search.distances.get(neighbor);
 
-            if (!search.distances.has(neighbor) ||
-          newDistance < (currentNeighborDistance ?? Infinity)) {
+            if (!search.distances.has(neighbor) || newDistance < (currentNeighborDistance ?? Infinity)) {
                 search.distances.set(neighbor, newDistance);
                 search.previous.set(neighbor, current);
                 search.frontier.enqueue(neighbor, newDistance);
@@ -186,7 +186,7 @@ export class BidirectionalDijkstra {
         return false;
     }
 
-    private getMinDistance(frontier: PriorityQueue<NodeId>): number {
+    private _getMinDistance(frontier: PriorityQueue<NodeId>): number {
         if (frontier.isEmpty()) {
             return Infinity;
         }
@@ -237,8 +237,8 @@ export class BidirectionalDijkstra {
     }
 
     /**
-   * Reset the search state for reuse
-   */
+     * Reset the search state for reuse
+     */
     public reset(): void {
         this.forwardSearch = this.initSearchState();
         this.backwardSearch = this.initSearchState();

package/src/algorithms/shortest-path/dijkstra.ts

@@ -1,8 +1,8 @@
-import type {Graph} from "../../core/graph.js";
-import {PriorityQueue} from "../../data-structures/priority-queue.js";
-import type {DijkstraOptions, NodeId, ShortestPathResult} from "../../types/index.js";
-import {reconstructPath} from "../../utils/graph-utilities.js";
-import {BidirectionalDijkstra} from "./bidirectional-dijkstra.js";
+import type { Graph } from "../../core/graph.js";
+import { PriorityQueue } from "../../data-structures/priority-queue.js";
+import type { DijkstraOptions, NodeId, ShortestPathResult } from "../../types/index.js";
+import { reconstructPath } from "../../utils/graph-utilities.js";
+import { BidirectionalDijkstra } from "./bidirectional-dijkstra.js";
 
 /**
  * Dijkstra's algorithm implementation for single-source shortest paths
@@ -13,12 +13,12 @@ import {BidirectionalDijkstra} from "./bidirectional-dijkstra.js";
 
 /**
  * Find shortest paths from source to all reachable nodes using Dijkstra's algorithm
+ * @param graph - The graph to search
+ * @param source - The starting node for the search
+ * @param options - Algorithm options including optional target for early termination
+ * @returns A map of node IDs to their shortest path results
  */
-export function dijkstra(
-    graph: Graph,
-    source: NodeId,
-    options: DijkstraOptions = {},
-): Map<NodeId, ShortestPathResult> {
+export function dijkstra(graph: Graph, source: NodeId, options: DijkstraOptions = {}): Map<NodeId, ShortestPathResult> {
     if (!graph.hasNode(source)) {
         throw new Error(`Source node ${String(source)} not found in graph`);
     }
@@ -119,6 +119,11 @@ export function dijkstra(
  *
  * Uses bidirectional search by default for improved performance on point-to-point queries.
  * Automatically falls back to standard Dijkstra for very small graphs or when explicitly disabled.
+ * @param graph - The graph to search
+ * @param source - The starting node for the path
+ * @param target - The destination node for the path
+ * @param options - Algorithm options including bidirectional search toggle
+ * @returns The shortest path result or null if no path exists
  */
 export function dijkstraPath(
     graph: Graph,
@@ -153,18 +158,18 @@ export function dijkstraPath(
     }
 
     // Fallback to standard dijkstra
-    const results = dijkstra(graph, source, {target});
+    const results = dijkstra(graph, source, { target });
     return results.get(target) ?? null;
 }
 
 /**
  * Single-source shortest paths with early termination optimization
+ * @param graph - The graph to search
+ * @param source - The starting node for the search
+ * @param cutoff - Optional maximum distance to search
+ * @returns A map of node IDs to their distances from the source
  */
-export function singleSourceShortestPath(
-    graph: Graph,
-    source: NodeId,
-    cutoff?: number,
-): Map<NodeId, number> {
+export function singleSourceShortestPath(graph: Graph, source: NodeId, cutoff?: number): Map<NodeId, number> {
     if (!graph.hasNode(source)) {
         throw new Error(`Source node ${String(source)} not found in graph`);
     }
@@ -244,6 +249,8 @@ export function singleSourceShortestPath(
 /**
  * All-pairs shortest paths using repeated Dijkstra
  * Note: For dense graphs, consider Floyd-Warshall algorithm instead
+ * @param graph - The graph to compute all-pairs shortest paths for
+ * @returns A nested map of source to target to distance
  */
 export function allPairsShortestPath(graph: Graph): Map<NodeId, Map<NodeId, number>> {
     const results = new Map<NodeId, Map<NodeId, number>>();
@@ -255,4 +262,3 @@ export function allPairsShortestPath(graph: Graph): Map<NodeId, Map<NodeId, numb
 
     return results;
 }
-

package/src/algorithms/shortest-path/floyd-warshall.ts

@@ -1,5 +1,5 @@
-import {Graph} from "../../core/graph.js";
-import type {NodeId} from "../../types/index.js";
+import { Graph } from "../../core/graph.js";
+import type { NodeId } from "../../types/index.js";
 
 export interface FloydWarshallResult {
     distances: Map<NodeId, Map<NodeId, number>>;
@@ -7,6 +7,11 @@ export interface FloydWarshallResult {
     hasNegativeCycle: boolean;
 }
 
+/**
+ * Computes all-pairs shortest paths using the Floyd-Warshall algorithm
+ * @param graph - The graph to compute shortest paths for
+ * @returns The distances, predecessors, and negative cycle detection result
+ */
 export function floydWarshall(graph: Graph): FloydWarshallResult {
     const nodes = Array.from(graph.nodes()).map((n) => n.id);
     const distances = new Map<NodeId, Map<NodeId, number>>();
@@ -105,11 +110,18 @@ export function floydWarshall(graph: Graph): FloydWarshallResult {
     };
 }
 
+/**
+ * Finds the shortest path between two nodes using Floyd-Warshall
+ * @param graph - The graph to search
+ * @param source - The starting node for the path
+ * @param target - The destination node for the path
+ * @returns The path and distance or null if no path exists
+ */
 export function floydWarshallPath(
     graph: Graph,
     source: NodeId,
     target: NodeId,
-): {path: NodeId[], distance: number} | null {
+): { path: NodeId[]; distance: number } | null {
     const result = floydWarshall(graph);
 
     if (!graph.hasNode(source) || !graph.hasNode(target)) {
@@ -146,12 +158,17 @@ export function floydWarshallPath(
 
     if (current === source) {
         path.unshift(source);
-        return {path, distance};
+        return { path, distance };
     }
 
     return null;
 }
 
+/**
+ * Computes the transitive closure of a graph using Floyd-Warshall
+ * @param graph - The graph to compute transitive closure for
+ * @returns A map of each node to the set of nodes reachable from it
+ */
 export function transitiveClosure(graph: Graph): Map<NodeId, Set<NodeId>> {
     const result = floydWarshall(graph);
     const closure = new Map<NodeId, Set<NodeId>>();

package/src/algorithms/shortest-path/index.ts

@@ -2,8 +2,8 @@
  * Shortest path algorithms
  */
 
-export type {BellmanFordOptions, BellmanFordResult} from "./bellman-ford.js";
-export {bellmanFord, bellmanFordPath, hasNegativeCycle} from "./bellman-ford.js";
-export {allPairsShortestPath, dijkstra, dijkstraPath, singleSourceShortestPath} from "./dijkstra.js";
-export type {FloydWarshallResult} from "./floyd-warshall.js";
-export {floydWarshall, floydWarshallPath, transitiveClosure} from "./floyd-warshall.js";
+export type { BellmanFordOptions, BellmanFordResult } from "./bellman-ford.js";
+export { bellmanFord, bellmanFordPath, hasNegativeCycle } from "./bellman-ford.js";
+export { allPairsShortestPath, dijkstra, dijkstraPath, singleSourceShortestPath } from "./dijkstra.js";
+export type { FloydWarshallResult } from "./floyd-warshall.js";
+export { floydWarshall, floydWarshallPath, transitiveClosure } from "./floyd-warshall.js";