@graphty/algorithms 1.2.0 → 1.4.2

package/src/algorithms/community/louvain.ts

@@ -1,5 +1,7 @@
-import {Graph} from "../../core/graph.js";
-import type {CommunityResult, LouvainOptions, NodeId} from "../../types/index.js";
+import { Graph } from "../../core/graph.js";
+import type { CommunityResult, LouvainOptions, NodeId } from "../../types/index.js";
+import { louvainOptimized } from "./louvain-optimized.js";
+import { calculateModularity, getNeighborCommunities, getNodeDegree, getTotalEdgeWeight } from "./modularity-utils.js";
 
 /**
  * Louvain community detection algorithm
@@ -9,21 +11,34 @@ import type {CommunityResult, LouvainOptions, NodeId} from "../../types/index.js
  *
  * References:
  * - Blondel, V. D., Guillaume, J. L., Lambiotte, R., & Lefebvre, E. (2008).
- *   Fast unfolding of communities in large networks.
- *   Journal of statistical mechanics: theory and experiment, 2008(10), P10008.
- *
+ * Fast unfolding of communities in large networks.
+ * Journal of statistical mechanics: theory and experiment, 2008(10), P10008.
  * @param graph - The input graph
  * @param options - Algorithm options
  * @returns Community detection result with communities, modularity, and iterations
  */
-export function louvain(
-    graph: Graph,
-    options: LouvainOptions = {},
-): CommunityResult {
+export function louvain(graph: Graph, options: LouvainOptions = {}): CommunityResult {
     const resolution = options.resolution ?? 1.0;
     const maxIterations = options.maxIterations ?? 100;
     const tolerance = options.tolerance ?? 1e-6;
 
+    // Use optimized version by default for larger graphs
+    // Only disable if explicitly requested or graph is very small
+    const shouldUseOptimized = options.useOptimized !== false && graph.nodeCount > 50;
+
+    if (shouldUseOptimized) {
+        return louvainOptimized(graph, {
+            resolution,
+            maxIterations,
+            tolerance,
+            // Enable all optimizations by default
+            pruneLeaves: true,
+            importanceOrdering: true,
+            thresholdCycling: true,
+            pruningThreshold: 0.01,
+        });
+    }
+
     // Initialize: each node in its own community
     const communities = initializeCommunities(graph);
     let modularity = calculateModularity(graph, communities, resolution);
@@ -38,7 +53,7 @@ export function louvain(
             const newModularity = calculateModularity(graph, communities, resolution);
 
             // Check for convergence
-            if ((newModularity - modularity) < tolerance) {
+            if (newModularity - modularity < tolerance) {
                 break;
             }
 
@@ -56,6 +71,8 @@ export function louvain(
 
 /**
  * Initialize communities: each node in its own community
+ * @param graph - The input graph
+ * @returns Map of node IDs to their initial community IDs
  */
 function initializeCommunities(graph: Graph): Map<NodeId, number> {
     const communities = new Map<NodeId, number>();
@@ -72,12 +89,12 @@ function initializeCommunities(graph: Graph): Map<NodeId, number> {
  * Phase 1 of Louvain algorithm: Local optimization
  * For each node, try moving to neighboring communities and keep the move
  * that provides the best modularity gain.
+ * @param graph - The input graph
+ * @param communities - Map of node IDs to community IDs
+ * @param resolution - Resolution parameter for modularity calculation
+ * @returns True if any improvement was made, false otherwise
  */
-function louvainPhase1(
-    graph: Graph,
-    communities: Map<NodeId, number>,
-    resolution: number,
-): boolean {
+function louvainPhase1(graph: Graph, communities: Map<NodeId, number>, resolution: number): boolean {
     let globalImprovement = false;
     let localImprovement = true;
 
@@ -94,7 +111,11 @@ function louvainPhase1(
 
             // Calculate current modularity contribution
             const currentModularity = nodeModularityContribution(
-                graph, nodeId, currentCommunity, communities, resolution,
+                graph,
+                nodeId,
+                currentCommunity,
+                communities,
+                resolution,
             );
 
             let bestCommunity = currentCommunity;
@@ -109,7 +130,11 @@ function louvainPhase1(
                 }
 
                 const newModularity = nodeModularityContribution(
-                    graph, nodeId, neighborCommunity, communities, resolution,
+                    graph,
+                    nodeId,
+                    neighborCommunity,
+                    communities,
+                    resolution,
                 );
 
                 if (newModularity > bestModularity) {
@@ -132,6 +157,12 @@ function louvainPhase1(
 
 /**
  * Calculate modularity contribution of a node to a specific community
+ * @param graph - The input graph
+ * @param nodeId - The node ID to evaluate
+ * @param community - The community to measure contribution to
+ * @param communities - Map of all node IDs to community IDs
+ * @param resolution - Resolution parameter for modularity calculation
+ * @returns The modularity contribution of the node to the specified community
  */
 function nodeModularityContribution(
     graph: Graph,
@@ -168,90 +199,16 @@ function nodeModularityContribution(
     }
 
     // Modularity formula: Q = (1/2m) * Σ[A_ij - (k_i * k_j)/(2m)] * δ(c_i, c_j)
-    const modularityIncrease = (internalLinks - ((resolution * nodeDegree * communityDegree) / (2 * totalEdgeWeight))) / totalEdgeWeight;
+    const modularityIncrease =
+        (internalLinks - (resolution * nodeDegree * communityDegree) / (2 * totalEdgeWeight)) / totalEdgeWeight;
 
     return modularityIncrease;
 }
 
-/**
- * Get communities of neighboring nodes
- */
-function getNeighborCommunities(
-    graph: Graph,
-    nodeId: NodeId,
-    communities: Map<NodeId, number>,
-): Set<number> {
-    const neighborCommunities = new Set<number>();
-
-    for (const neighbor of graph.neighbors(nodeId)) {
-        const community = communities.get(neighbor);
-        if (community !== undefined) {
-            neighborCommunities.add(community);
-        }
-    }
-
-    return neighborCommunities;
-}
-
-/**
- * Calculate total modularity of the current community assignment
- */
-function calculateModularity(
-    graph: Graph,
-    communities: Map<NodeId, number>,
-    resolution: number,
-): number {
-    const totalEdgeWeight = getTotalEdgeWeight(graph);
-    if (totalEdgeWeight === 0) {
-        return 0;
-    }
-
-    let modularity = 0;
-
-    // For undirected graphs, we need to be careful not to double-count edges
-    const countedEdges = new Set<string>();
-
-    // Calculate modularity: Q = (1/2m) * Σ[A_ij - γ(k_i * k_j)/(2m)] * δ(c_i, c_j)
-    for (const nodeI of graph.nodes()) {
-        for (const nodeJ of graph.nodes()) {
-            // Skip if already counted this pair in undirected graph
-            if (!graph.isDirected) {
-                const nodeIStr = String(nodeI.id);
-                const nodeJStr = String(nodeJ.id);
-                const edgeKey = nodeIStr <= nodeJStr ? `${nodeIStr}-${nodeJStr}` : `${nodeJStr}-${nodeIStr}`;
-                if (countedEdges.has(edgeKey)) {
-                    continue;
-                }
-
-                countedEdges.add(edgeKey);
-            }
-
-            if (communities.get(nodeI.id) === communities.get(nodeJ.id)) {
-                const edge = graph.getEdge(nodeI.id, nodeJ.id);
-                const reverseEdge = !graph.isDirected ? graph.getEdge(nodeJ.id, nodeI.id) : null;
-
-                let edgeWeight = 0;
-                if (edge) {
-                    edgeWeight += edge.weight ?? 1;
-                }
-
-                if (reverseEdge && nodeI.id !== nodeJ.id) {
-                    edgeWeight += reverseEdge.weight ?? 1;
-                }
-
-                const degreeI = getNodeDegree(graph, nodeI.id);
-                const degreeJ = getNodeDegree(graph, nodeJ.id);
-
-                modularity += edgeWeight - ((resolution * degreeI * degreeJ) / (2 * totalEdgeWeight));
-            }
-        }
-    }
-
-    return modularity / (2 * totalEdgeWeight);
-}
-
 /**
  * Extract final community structure
+ * @param communities - Map of node IDs to community IDs
+ * @returns Array of communities (each is an array of node IDs)
  */
 function extractCommunities(communities: Map<NodeId, number>): NodeId[][] {
     const communityMap = new Map<number, NodeId[]>();
@@ -269,30 +226,3 @@ function extractCommunities(communities: Map<NodeId, number>): NodeId[][] {
 
     return Array.from(communityMap.values());
 }
-
-/**
- * Calculate total edge weight in the graph
- */
-function getTotalEdgeWeight(graph: Graph): number {
-    let totalWeight = 0;
-
-    for (const edge of graph.edges()) {
-        totalWeight += edge.weight ?? 1;
-    }
-
-    return totalWeight;
-}
-
-/**
- * Get the total degree (sum of edge weights) for a node
- */
-function getNodeDegree(graph: Graph, nodeId: NodeId): number {
-    let degree = 0;
-
-    for (const neighbor of graph.neighbors(nodeId)) {
-        const edge = graph.getEdge(nodeId, neighbor);
-        degree += edge?.weight ?? 1;
-    }
-
-    return degree;
-}

package/src/algorithms/community/modularity-utils.ts

@@ -0,0 +1,134 @@
+/**
+ * Shared modularity calculation utilities for community detection algorithms
+ *
+ * Used by: Louvain, Leiden, Girvan-Newman
+ */
+import type { Graph } from "../../core/graph.js";
+import type { NodeId } from "../../types/index.js";
+
+/**
+ * Calculate total edge weight in the graph
+ *
+ * For undirected graphs, each edge is counted once.
+ * For directed graphs, each directed edge is counted once.
+ * @param graph - The input graph
+ * @returns Total sum of edge weights (default weight is 1)
+ */
+export function getTotalEdgeWeight(graph: Graph): number {
+    let totalWeight = 0;
+
+    for (const edge of graph.edges()) {
+        totalWeight += edge.weight ?? 1;
+    }
+
+    return totalWeight;
+}
+
+/**
+ * Get the total degree (sum of edge weights) for a node
+ *
+ * Computes the weighted degree by summing all edge weights incident to the node.
+ * @param graph - The input graph
+ * @param nodeId - The node ID to compute degree for
+ * @returns The weighted degree of the node
+ */
+export function getNodeDegree(graph: Graph, nodeId: NodeId): number {
+    let degree = 0;
+
+    for (const neighbor of graph.neighbors(nodeId)) {
+        const edge = graph.getEdge(nodeId, neighbor);
+        degree += edge?.weight ?? 1;
+    }
+
+    return degree;
+}
+
+/**
+ * Get communities of neighboring nodes
+ *
+ * Returns the set of community IDs that neighbors of the given node belong to.
+ * @param graph - The input graph
+ * @param nodeId - The node to get neighbor communities for
+ * @param communities - Map from node IDs to community IDs
+ * @returns Set of community IDs that neighbors belong to
+ */
+export function getNeighborCommunities(graph: Graph, nodeId: NodeId, communities: Map<NodeId, number>): Set<number> {
+    const neighborCommunities = new Set<number>();
+
+    for (const neighbor of graph.neighbors(nodeId)) {
+        const community = communities.get(neighbor);
+        if (community !== undefined) {
+            neighborCommunities.add(community);
+        }
+    }
+
+    return neighborCommunities;
+}
+
+/**
+ * Calculate modularity of a partition
+ *
+ * Modularity measures the quality of a community partition. It compares the
+ * number of edges within communities to what would be expected in a random graph.
+ *
+ * Formula: Q = (1/2m) * Σ[A_ij - γ(k_i * k_j)/(2m)] * δ(c_i, c_j)
+ * where:
+ * - m = total edge weight
+ * - A_ij = adjacency matrix entry (edge weight between i and j)
+ * - k_i, k_j = degrees of nodes i and j
+ * - γ = resolution parameter (higher values favor smaller communities)
+ * - δ = Kronecker delta (1 if same community, 0 otherwise)
+ * @param graph - The input graph
+ * @param communities - Map from node IDs to community IDs
+ * @param resolution - Resolution parameter (default: 1.0)
+ * @returns Modularity score (range typically -0.5 to 1.0)
+ */
+export function calculateModularity(graph: Graph, communities: Map<NodeId, number>, resolution = 1.0): number {
+    const totalEdgeWeight = getTotalEdgeWeight(graph);
+    if (totalEdgeWeight === 0) {
+        return 0;
+    }
+
+    let modularity = 0;
+
+    // For undirected graphs, we need to be careful not to double-count edges
+    const countedEdges = new Set<string>();
+
+    // Calculate modularity: Q = (1/2m) * Σ[A_ij - γ(k_i * k_j)/(2m)] * δ(c_i, c_j)
+    for (const nodeI of graph.nodes()) {
+        for (const nodeJ of graph.nodes()) {
+            // Skip if already counted this pair in undirected graph
+            if (!graph.isDirected) {
+                const nodeIStr = String(nodeI.id);
+                const nodeJStr = String(nodeJ.id);
+                const edgeKey = nodeIStr <= nodeJStr ? `${nodeIStr}-${nodeJStr}` : `${nodeJStr}-${nodeIStr}`;
+                if (countedEdges.has(edgeKey)) {
+                    continue;
+                }
+
+                countedEdges.add(edgeKey);
+            }
+
+            if (communities.get(nodeI.id) === communities.get(nodeJ.id)) {
+                const edge = graph.getEdge(nodeI.id, nodeJ.id);
+                const reverseEdge = !graph.isDirected ? graph.getEdge(nodeJ.id, nodeI.id) : null;
+
+                let edgeWeight = 0;
+                if (edge) {
+                    edgeWeight += edge.weight ?? 1;
+                }
+
+                if (reverseEdge && nodeI.id !== nodeJ.id) {
+                    edgeWeight += reverseEdge.weight ?? 1;
+                }
+
+                const degreeI = getNodeDegree(graph, nodeI.id);
+                const degreeJ = getNodeDegree(graph, nodeJ.id);
+
+                modularity += edgeWeight - (resolution * degreeI * degreeJ) / (2 * totalEdgeWeight);
+            }
+        }
+    }
+
+    return modularity / (2 * totalEdgeWeight);
+}

package/src/algorithms/components/connected.ts

@@ -1,6 +1,6 @@
-import type {Graph} from "../../core/graph.js";
-import {UnionFind} from "../../data-structures/union-find.js";
-import type {NodeId} from "../../types/index.js";
+import type { Graph } from "../../core/graph.js";
+import { UnionFind } from "../../data-structures/union-find.js";
+import type { NodeId } from "../../types/index.js";
 
 /**
  * Connected components algorithms
@@ -11,10 +11,14 @@ import type {NodeId} from "../../types/index.js";
 
 /**
  * Find connected components in an undirected graph using Union-Find
+ * @param graph - The input graph (must be undirected)
+ * @returns Array of connected components, each containing an array of node IDs
  */
 export function connectedComponents(graph: Graph): NodeId[][] {
     if (graph.isDirected) {
-        throw new Error("Connected components algorithm requires an undirected graph. Use stronglyConnectedComponents for directed graphs.");
+        throw new Error(
+            "Connected components algorithm requires an undirected graph. Use stronglyConnectedComponents for directed graphs.",
+        );
     }
 
     const nodes = Array.from(graph.nodes()).map((node) => node.id);
@@ -35,6 +39,8 @@ export function connectedComponents(graph: Graph): NodeId[][] {
 
 /**
  * Find connected components using DFS (alternative implementation)
+ * @param graph - The input graph (must be undirected)
+ * @returns Array of connected components, each containing an array of node IDs
  */
 export function connectedComponentsDFS(graph: Graph): NodeId[][] {
     if (graph.isDirected) {
@@ -57,13 +63,12 @@ export function connectedComponentsDFS(graph: Graph): NodeId[][] {
 
 /**
  * DFS helper for connected components
+ * @param graph - The input graph
+ * @param nodeId - The starting node ID
+ * @param visited - Set of already visited node IDs
+ * @param component - Array to accumulate component members
  */
-function dfsComponent(
-    graph: Graph,
-    nodeId: NodeId,
-    visited: Set<NodeId>,
-    component: NodeId[],
-): void {
+function dfsComponent(graph: Graph, nodeId: NodeId, visited: Set<NodeId>, component: NodeId[]): void {
     visited.add(nodeId);
     component.push(nodeId);
 
@@ -76,6 +81,8 @@ function dfsComponent(
 
 /**
  * Find the number of connected components
+ * @param graph - The input graph (must be undirected)
+ * @returns The number of connected components in the graph
  */
 export function numberOfConnectedComponents(graph: Graph): number {
     return connectedComponents(graph).length;
@@ -83,6 +90,8 @@ export function numberOfConnectedComponents(graph: Graph): number {
 
 /**
  * Check if the graph is connected (has exactly one connected component)
+ * @param graph - The input graph (must be undirected)
+ * @returns True if the graph is connected, false otherwise
  */
 export function isConnected(graph: Graph): boolean {
     return numberOfConnectedComponents(graph) <= 1;
@@ -90,6 +99,8 @@ export function isConnected(graph: Graph): boolean {
 
 /**
  * Find the largest connected component
+ * @param graph - The input graph (must be undirected)
+ * @returns Array of node IDs in the largest connected component
  */
 export function largestConnectedComponent(graph: Graph): NodeId[] {
     const components = connectedComponents(graph);
@@ -98,13 +109,14 @@ export function largestConnectedComponent(graph: Graph): NodeId[] {
         return [];
     }
 
-    return components.reduce((largest, current) =>
-        current.length > largest.length ? current : largest,
-    );
+    return components.reduce((largest, current) => (current.length > largest.length ? current : largest));
 }
 
 /**
  * Get the connected component containing a specific node
+ * @param graph - The input graph (must be undirected)
+ * @param nodeId - The node ID to find the component for
+ * @returns Array of node IDs in the same component as the specified node
  */
 export function getConnectedComponent(graph: Graph, nodeId: NodeId): NodeId[] {
     if (!graph.hasNode(nodeId)) {
@@ -125,6 +137,8 @@ export function getConnectedComponent(graph: Graph, nodeId: NodeId): NodeId[] {
 
 /**
  * Find strongly connected components using Tarjan's algorithm
+ * @param graph - The input graph (must be directed)
+ * @returns Array of strongly connected components, each containing an array of node IDs
  */
 export function stronglyConnectedComponents(graph: Graph): NodeId[][] {
     if (!graph.isDirected) {
@@ -198,6 +212,8 @@ export function stronglyConnectedComponents(graph: Graph): NodeId[][] {
 
 /**
  * Check if a directed graph is strongly connected
+ * @param graph - The input graph (must be directed)
+ * @returns True if the graph is strongly connected, false otherwise
  */
 export function isStronglyConnected(graph: Graph): boolean {
     if (!graph.isDirected) {
@@ -211,10 +227,14 @@ export function isStronglyConnected(graph: Graph): boolean {
 /**
  * Find weakly connected components in a directed graph
  * (treat the graph as undirected for connectivity)
+ * @param graph - The input graph (must be directed)
+ * @returns Array of weakly connected components, each containing an array of node IDs
  */
 export function weaklyConnectedComponents(graph: Graph): NodeId[][] {
     if (!graph.isDirected) {
-        throw new Error("Weakly connected components are for directed graphs. Use connectedComponents for undirected graphs.");
+        throw new Error(
+            "Weakly connected components are for directed graphs. Use connectedComponents for undirected graphs.",
+        );
     }
 
     const nodes = Array.from(graph.nodes()).map((node) => node.id);
@@ -235,6 +255,8 @@ export function weaklyConnectedComponents(graph: Graph): NodeId[][] {
 
 /**
  * Check if a directed graph is weakly connected
+ * @param graph - The input graph (must be directed)
+ * @returns True if the graph is weakly connected, false otherwise
  */
 export function isWeaklyConnected(graph: Graph): boolean {
     if (!graph.isDirected) {
@@ -246,6 +268,8 @@ export function isWeaklyConnected(graph: Graph): boolean {
 
 /**
  * Find condensation graph (quotient graph of strongly connected components)
+ * @param graph - The input graph (must be directed)
+ * @returns Object containing the condensed graph, component map, and component arrays
  */
 export function condensationGraph(graph: Graph): {
     condensedGraph: Graph;
@@ -258,7 +282,7 @@ export function condensationGraph(graph: Graph): {
 
     const components = stronglyConnectedComponents(graph);
     const componentMap = new Map<NodeId, number>();
-    const condensedGraph = new (graph.constructor as new (config: {directed: boolean}) => Graph)({directed: true});
+    const condensedGraph = new (graph.constructor as new (config: { directed: boolean }) => Graph)({ directed: true });
 
     // Map each node to its component index
     for (let i = 0; i < components.length; i++) {
@@ -279,8 +303,7 @@ export function condensationGraph(graph: Graph): {
         const sourceComponent = componentMap.get(edge.source);
         const targetComponent = componentMap.get(edge.target);
 
-        if (sourceComponent !== undefined && targetComponent !== undefined &&
-            sourceComponent !== targetComponent) {
+        if (sourceComponent !== undefined && targetComponent !== undefined && sourceComponent !== targetComponent) {
             const edgeKey = `${String(sourceComponent)}-${String(targetComponent)}`;
 
             if (!addedEdges.has(edgeKey)) {

package/src/algorithms/matching/bipartite.ts

@@ -1,5 +1,6 @@
-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";
+import { bfsColoringWithPartitions } from "../traversal/bfs-variants.js";
 
 /**
  * Maximum Bipartite Matching implementation using Hopcroft-Karp algorithm
@@ -24,13 +25,17 @@ export interface BipartiteMatchingOptions {
 /**
  * Find maximum matching in a bipartite graph using augmenting path algorithm
  * (simplified implementation that's more reliable than Hopcroft-Karp for this context)
+ * @param graph - The bipartite graph to find maximum matching for
+ * @param options - Optional configuration including left and right node partitions
+ * @returns The maximum matching as a map from left nodes to right nodes and the matching size
+ * @throws Error if the graph is not bipartite
  */
 export function maximumBipartiteMatching(
     graph: Graph,
     options: BipartiteMatchingOptions = {},
 ): BipartiteMatchingResult {
     // If partitions not provided, try to infer them
-    let {leftNodes, rightNodes} = options;
+    let { leftNodes, rightNodes } = options;
 
     if (!leftNodes || !rightNodes) {
         const partition = bipartitePartition(graph);
@@ -86,66 +91,32 @@ export function maximumBipartiteMatching(
 
 /**
  * Check if graph is bipartite and return the partition
+ * @param graph - The graph to check for bipartiteness
+ * @returns An object with left and right node sets if bipartite, or null if not bipartite
  */
-export function bipartitePartition(graph: Graph): {left: Set<NodeId>, right: Set<NodeId>} | null {
-    const color = new Map<NodeId, boolean>();
-    const left = new Set<NodeId>();
-    const right = new Set<NodeId>();
+export function bipartitePartition(graph: Graph): { left: Set<NodeId>; right: Set<NodeId> } | null {
+    const result = bfsColoringWithPartitions(graph);
 
-    const nodes = Array.from(graph.nodes());
-
-    for (const startNode of nodes) {
-        if (color.has(startNode.id)) {
-            continue;
-        }
-
-        // BFS to color the component
-        const queue = [startNode.id];
-        color.set(startNode.id, true);
-        left.add(startNode.id);
-
-        while (queue.length > 0) {
-            const u = queue.shift();
-            if (u === undefined) {
-                continue;
-            }
-
-            const uColor = color.get(u);
-            if (uColor === undefined) {
-                continue;
-            }
-
-            const neighbors = Array.from(graph.neighbors(u));
-            for (const v of neighbors) {
-                if (!color.has(v)) {
-                    color.set(v, !uColor);
-                    if (!uColor) {
-                        left.add(v);
-                    } else {
-                        right.add(v);
-                    }
-
-                    queue.push(v);
-                } else if (color.get(v) === uColor) {
-                    // Same color as neighbor - not bipartite
-                    return null;
-                }
-            }
-        }
+    if (!result.isBipartite || !result.partitions) {
+        return null;
     }
 
-    return {left, right};
+    return {
+        left: result.partitions[0],
+        right: result.partitions[1],
+    };
 }
 
 /**
  * Simple greedy bipartite matching algorithm
  * Useful for comparison or when Hopcroft-Karp is overkill
+ * @param graph - The bipartite graph to find matching for
+ * @param options - Optional configuration including left and right node partitions
+ * @returns The matching as a map from left nodes to right nodes and the matching size
+ * @throws Error if the graph is not bipartite
  */
-export function greedyBipartiteMatching(
-    graph: Graph,
-    options: BipartiteMatchingOptions = {},
-): BipartiteMatchingResult {
-    let {leftNodes, rightNodes} = options;
+export function greedyBipartiteMatching(graph: Graph, options: BipartiteMatchingOptions = {}): BipartiteMatchingResult {
+    let { leftNodes, rightNodes } = options;
 
     if (!leftNodes || !rightNodes) {
         const partition = bipartitePartition(graph);

package/src/algorithms/matching/index.ts

@@ -2,7 +2,7 @@
  * Graph matching algorithms
  */
 
-export type {BipartiteMatchingOptions, BipartiteMatchingResult} from "./bipartite.js";
-export {bipartitePartition, greedyBipartiteMatching, maximumBipartiteMatching} from "./bipartite.js";
-export type {IsomorphismOptions, IsomorphismResult} from "./isomorphism.js";
-export {findAllIsomorphisms, isGraphIsomorphic} from "./isomorphism.js";
+export type { BipartiteMatchingOptions, BipartiteMatchingResult } from "./bipartite.js";
+export { bipartitePartition, greedyBipartiteMatching, maximumBipartiteMatching } from "./bipartite.js";
+export type { IsomorphismOptions, IsomorphismResult } from "./isomorphism.js";
+export { findAllIsomorphisms, isGraphIsomorphic } from "./isomorphism.js";