@graphty/algorithms 1.3.1 → 1.4.2

package/src/algorithms/centrality/eigenvector.ts

@@ -1,5 +1,5 @@
-import type {Graph} from "../../core/graph.js";
-import type {CentralityOptions, CentralityResult} from "../../types/index.js";
+import type { Graph } from "../../core/graph.js";
+import type { CentralityOptions, CentralityResult } from "../../types/index.js";
 
 /**
  * Eigenvector centrality implementation
@@ -19,19 +19,14 @@ export interface EigenvectorCentralityOptions extends CentralityOptions {
 }
 
 /**
- * Calculate eigenvector centrality for all nodes in the graph
- * Uses the power iteration method to find the dominant eigenvector
+ * Calculate eigenvector centrality for all nodes in the graph.
+ * Uses the power iteration method to find the dominant eigenvector.
+ * @param graph - The graph to compute eigenvector centrality on
+ * @param options - Configuration options for the computation
+ * @returns Object mapping node IDs to their eigenvector centrality scores
  */
-export function eigenvectorCentrality(
-    graph: Graph,
-    options: EigenvectorCentralityOptions = {},
-): CentralityResult {
-    const {
-        maxIterations = 100,
-        tolerance = 1e-6,
-        normalized = true,
-        startVector,
-    } = options;
+export function eigenvectorCentrality(graph: Graph, options: EigenvectorCentralityOptions = {}): CentralityResult {
+    const { maxIterations = 100, tolerance = 1e-6, normalized = true, startVector } = options;
 
     const centrality: CentralityResult = {};
     const nodes = Array.from(graph.nodes());
@@ -146,7 +141,11 @@ export function eigenvectorCentrality(
 }
 
 /**
- * Calculate eigenvector centrality for a specific node
+ * Calculate eigenvector centrality for a specific node.
+ * @param graph - The graph to compute eigenvector centrality on
+ * @param nodeId - The ID of the node to calculate centrality for
+ * @param options - Configuration options for the computation
+ * @returns The eigenvector centrality score for the specified node
  */
 export function nodeEigenvectorCentrality(
     graph: Graph,

package/src/algorithms/centrality/hits.ts

@@ -1,5 +1,5 @@
-import type {Graph} from "../../core/graph.js";
-import type {CentralityOptions} from "../../types/index.js";
+import type { Graph } from "../../core/graph.js";
+import type { CentralityOptions } from "../../types/index.js";
 
 /**
  * HITS (Hyperlink-Induced Topic Search) algorithm implementation
@@ -25,18 +25,14 @@ export interface HITSOptions extends CentralityOptions {
 }
 
 /**
- * Calculate HITS hub and authority scores for all nodes in the graph
- * Uses iterative method with normalization
+ * Calculate HITS hub and authority scores for all nodes in the graph.
+ * Uses iterative method with normalization.
+ * @param graph - The graph to compute HITS scores on
+ * @param options - Configuration options for the computation
+ * @returns Object containing hub and authority scores for all nodes
  */
-export function hits(
-    graph: Graph,
-    options: HITSOptions = {},
-): HITSResult {
-    const {
-        maxIterations = 100,
-        tolerance = 1e-6,
-        normalized = true,
-    } = options;
+export function hits(graph: Graph, options: HITSOptions = {}): HITSResult {
+    const { maxIterations = 100, tolerance = 1e-6, normalized = true } = options;
 
     const hubs: Record<string, number> = {};
     const authorities: Record<string, number> = {};
@@ -45,7 +41,7 @@ export function hits(
     const nodeIds = nodes.map((node) => node.id);
 
     if (nodeIds.length === 0) {
-        return {hubs, authorities};
+        return { hubs, authorities };
     }
 
     // Initialize scores
@@ -185,17 +181,21 @@ export function hits(
         }
     }
 
-    return {hubs, authorities};
+    return { hubs, authorities };
 }
 
 /**
- * Calculate HITS scores for a specific node
+ * Calculate HITS scores for a specific node.
+ * @param graph - The graph to compute HITS scores on
+ * @param nodeId - The ID of the node to calculate scores for
+ * @param options - Configuration options for the computation
+ * @returns Object containing hub and authority scores for the specified node
  */
 export function nodeHITS(
     graph: Graph,
     nodeId: string | number,
     options: HITSOptions = {},
-): {hub: number, authority: number} {
+): { hub: number; authority: number } {
     if (!graph.hasNode(nodeId)) {
         throw new Error(`Node ${String(nodeId)} not found in graph`);
     }

package/src/algorithms/centrality/index.ts

@@ -2,18 +2,23 @@
  * Centrality algorithms
  */
 
-export type {BetweennessCentralityOptions} from "./betweenness.js";
-export {betweennessCentrality, edgeBetweennessCentrality, nodeBetweennessCentrality} from "./betweenness.js";
-export type {ClosenessCentralityOptions} from "./closeness.js";
-export {closenessCentrality, nodeClosenessCentrality, nodeWeightedClosenessCentrality, weightedClosenessCentrality} from "./closeness.js";
-export {degreeCentrality, nodeDegreeCentrality} from "./degree.js";
-export type {DeltaPageRankOptions} from "./delta-pagerank.js";
-export {DeltaPageRank, PriorityDeltaPageRank} from "./delta-pagerank.js";
-export type {EigenvectorCentralityOptions} from "./eigenvector.js";
-export {eigenvectorCentrality, nodeEigenvectorCentrality} from "./eigenvector.js";
-export type {HITSOptions, HITSResult} from "./hits.js";
-export {hits, nodeHITS} from "./hits.js";
-export type {KatzCentralityOptions} from "./katz.js";
-export {katzCentrality, nodeKatzCentrality} from "./katz.js";
-export type {PageRankOptions, PageRankResult} from "./pagerank.js";
-export {pageRank, pageRankCentrality, personalizedPageRank, topPageRankNodes} from "./pagerank.js";
+export type { BetweennessCentralityOptions } from "./betweenness.js";
+export { betweennessCentrality, edgeBetweennessCentrality, nodeBetweennessCentrality } from "./betweenness.js";
+export type { ClosenessCentralityOptions } from "./closeness.js";
+export {
+    closenessCentrality,
+    nodeClosenessCentrality,
+    nodeWeightedClosenessCentrality,
+    weightedClosenessCentrality,
+} from "./closeness.js";
+export { degreeCentrality, nodeDegreeCentrality } from "./degree.js";
+export type { DeltaPageRankOptions } from "./delta-pagerank.js";
+export { DeltaPageRank, PriorityDeltaPageRank } from "./delta-pagerank.js";
+export type { EigenvectorCentralityOptions } from "./eigenvector.js";
+export { eigenvectorCentrality, nodeEigenvectorCentrality } from "./eigenvector.js";
+export type { HITSOptions, HITSResult } from "./hits.js";
+export { hits, nodeHITS } from "./hits.js";
+export type { KatzCentralityOptions } from "./katz.js";
+export { katzCentrality, nodeKatzCentrality } from "./katz.js";
+export type { PageRankOptions, PageRankResult } from "./pagerank.js";
+export { pageRank, pageRankCentrality, personalizedPageRank, topPageRankNodes } from "./pagerank.js";

package/src/algorithms/centrality/katz.ts

@@ -1,5 +1,5 @@
-import type {Graph} from "../../core/graph.js";
-import type {CentralityOptions, CentralityResult} from "../../types/index.js";
+import type { Graph } from "../../core/graph.js";
+import type { CentralityOptions, CentralityResult } from "../../types/index.js";
 
 /**
  * Katz centrality implementation
@@ -22,20 +22,14 @@ export interface KatzCentralityOptions extends CentralityOptions {
 }
 
 /**
- * Calculate Katz centrality for all nodes in the graph
- * Uses iterative method to compute centrality scores
+ * Calculate Katz centrality for all nodes in the graph.
+ * Uses iterative method to compute centrality scores.
+ * @param graph - The graph to compute Katz centrality on
+ * @param options - Configuration options for the computation
+ * @returns Object mapping node IDs to their Katz centrality scores
  */
-export function katzCentrality(
-    graph: Graph,
-    options: KatzCentralityOptions = {},
-): CentralityResult {
-    const {
-        alpha = 0.1,
-        beta = 1.0,
-        maxIterations = 100,
-        tolerance = 1e-6,
-        normalized = true,
-    } = options;
+export function katzCentrality(graph: Graph, options: KatzCentralityOptions = {}): CentralityResult {
+    const { alpha = 0.1, beta = 1.0, maxIterations = 100, tolerance = 1e-6, normalized = true } = options;
 
     const centrality: CentralityResult = {};
     const nodes = Array.from(graph.nodes());
@@ -68,16 +62,14 @@ export function katzCentrality(
 
             // For directed graphs, use in-neighbors
             // For undirected graphs, use all neighbors
-            const neighbors = graph.isDirected ?
-                Array.from(graph.inNeighbors(nodeId)) :
-                graph.neighbors(nodeId);
+            const neighbors = graph.isDirected ? Array.from(graph.inNeighbors(nodeId)) : graph.neighbors(nodeId);
 
             for (const neighbor of neighbors) {
                 const neighborKey = neighbor.toString();
                 sum += previousScores.get(neighborKey) ?? 0;
             }
 
-            currentScores.set(nodeId.toString(), (alpha * sum) + beta);
+            currentScores.set(nodeId.toString(), alpha * sum + beta);
         }
 
         // Check for convergence
@@ -123,13 +115,13 @@ export function katzCentrality(
 }
 
 /**
- * Calculate Katz centrality for a specific node
+ * Calculate Katz centrality for a specific node.
+ * @param graph - The graph to compute Katz centrality on
+ * @param nodeId - The ID of the node to calculate centrality for
+ * @param options - Configuration options for the computation
+ * @returns The Katz centrality score for the specified node
  */
-export function nodeKatzCentrality(
-    graph: Graph,
-    nodeId: string | number,
-    options: KatzCentralityOptions = {},
-): number {
+export function nodeKatzCentrality(graph: Graph, nodeId: string | number, options: KatzCentralityOptions = {}): number {
     if (!graph.hasNode(nodeId)) {
         throw new Error(`Node ${String(nodeId)} not found in graph`);
     }

package/src/algorithms/centrality/pagerank.ts

@@ -1,6 +1,6 @@
-import type {Graph} from "../../core/graph.js";
-import type {NodeId} from "../../types/index.js";
-import {SimpleDeltaPageRank} from "./delta-pagerank-simple.js";
+import type { Graph } from "../../core/graph.js";
+import type { NodeId } from "../../types/index.js";
+import { SimpleDeltaPageRank } from "./delta-pagerank-simple.js";
 
 /**
  * PageRank algorithm implementation
@@ -76,11 +76,11 @@ export interface PageRankResult {
  *
  * For initial computation on small-medium graphs, standard algorithm may be faster
  * due to lower overhead.
+ * @param graph - The directed input graph to analyze
+ * @param options - Algorithm configuration options
+ * @returns PageRank result containing ranks, iteration count, and convergence status
  */
-export function pageRank(
-    graph: Graph,
-    options: PageRankOptions = {},
-): PageRankResult {
+export function pageRank(graph: Graph, options: PageRankOptions = {}): PageRankResult {
     const {
         dampingFactor = 0.85,
         maxIterations = 100,
@@ -102,7 +102,7 @@ export function pageRank(
     const n = nodes.length;
 
     if (n === 0) {
-        return {ranks: {}, iterations: 0, converged: true};
+        return { ranks: {}, iterations: 0, converged: true };
     }
 
     // Use delta-based optimization by default for larger graphs
@@ -221,7 +221,7 @@ export function pageRank(
         }
 
         if (danglingSum > 0) {
-            const danglingContribution = dampingFactor * danglingSum / n;
+            const danglingContribution = (dampingFactor * danglingSum) / n;
             for (const nodeId of nodes) {
                 const currentRank = newRanks.get(nodeId) ?? 0;
                 if (personalVector) {
@@ -284,6 +284,10 @@ export function pageRank(
 
 /**
  * Calculate Personalized PageRank for a specific set of source nodes
+ * @param graph - The directed input graph to analyze
+ * @param personalNodes - Nodes to personalize the PageRank towards
+ * @param options - Algorithm configuration options
+ * @returns PageRank result containing ranks, iteration count, and convergence status
  */
 export function personalizedPageRank(
     graph: Graph,
@@ -314,35 +318,39 @@ export function personalizedPageRank(
     }
 
     return pageRank(graph, {
-        ... options,
+        ...options,
         personalization,
     });
 }
 
 /**
  * Calculate PageRank centrality (normalized PageRank scores)
+ * @param graph - The directed input graph to analyze
+ * @param options - Algorithm configuration options
+ * @returns PageRank scores for each node keyed by node ID
  */
-export function pageRankCentrality(
-    graph: Graph,
-    options: PageRankOptions = {},
-): Record<string, number> {
+export function pageRankCentrality(graph: Graph, options: PageRankOptions = {}): Record<string, number> {
     const result = pageRank(graph, options);
     return result.ranks;
 }
 
 /**
  * Get the top-k nodes by PageRank score
+ * @param graph - The directed input graph to analyze
+ * @param k - Number of top nodes to return
+ * @param options - Algorithm configuration options
+ * @returns Array of top-k nodes with their PageRank scores, sorted descending
  */
 export function topPageRankNodes(
     graph: Graph,
     k: number,
     options: PageRankOptions = {},
-): {node: NodeId, rank: number}[] {
+): { node: NodeId; rank: number }[] {
     const result = pageRank(graph, options);
 
-    const nodeRanks: {node: NodeId, rank: number}[] = [];
+    const nodeRanks: { node: NodeId; rank: number }[] = [];
     for (const [nodeStr, rank] of Object.entries(result.ranks)) {
-        nodeRanks.push({node: nodeStr as NodeId, rank});
+        nodeRanks.push({ node: nodeStr as NodeId, rank });
     }
 
     // Sort by rank in descending order
@@ -353,6 +361,7 @@ export function topPageRankNodes(
 
 /**
  * Normalize ranks so they sum to 1
+ * @param ranks - The ranks map to normalize in place
  */
 function normalizeRanks(ranks: Map<NodeId, number>): void {
     let sum = 0;

package/src/algorithms/community/girvan-newman.ts

@@ -1,6 +1,6 @@
-import {Graph} from "../../core/graph.js";
-import type {CommunityResult, ComponentResult, GirvanNewmanOptions, NodeId} from "../../types/index.js";
-import {connectedComponents} from "../components/connected.js";
+import { Graph } from "../../core/graph.js";
+import type { CommunityResult, ComponentResult, GirvanNewmanOptions, NodeId } from "../../types/index.js";
+import { connectedComponents } from "../components/connected.js";
 
 /**
  * Girvan-Newman community detection algorithm
@@ -14,18 +14,14 @@ import {connectedComponents} from "../components/connected.js";
  *
  * References:
  * - Girvan, M., & Newman, M. E. J. (2002). Community structure in social
- *   and biological networks. Proceedings of the National Academy of Sciences,
- *   99(12), 7821-7826.
- *
+ * and biological networks. Proceedings of the National Academy of Sciences,
+ * 99(12), 7821-7826.
  * @param graph - The input graph
  * @param options - Algorithm options
  * @returns Array of community detection results representing the dendrogram
  */
-export function girvanNewman(
-    graph: Graph,
-    options: GirvanNewmanOptions = {},
-): CommunityResult[] {
-    const {maxCommunities} = options;
+export function girvanNewman(graph: Graph, options: GirvanNewmanOptions = {}): CommunityResult[] {
+    const { maxCommunities } = options;
     const minCommunitySize = options.minCommunitySize ?? 1;
     const maxIterations = options.maxIterations ?? 100; // Prevent infinite loops
 
@@ -50,20 +46,20 @@ export function girvanNewman(
         }
 
         // Find edges with maximum betweenness
-        const maxBetweenness = Math.max(... edgeBetweenness.values());
-        const edgesToRemove: {source: NodeId, target: NodeId}[] = [];
+        const maxBetweenness = Math.max(...edgeBetweenness.values());
+        const edgesToRemove: { source: NodeId; target: NodeId }[] = [];
 
         for (const [edgeKey, centrality] of edgeBetweenness) {
             if (Math.abs(centrality - maxBetweenness) < 1e-10) {
                 const [source, target] = edgeKey.split("|");
                 if (source && target) {
-                    edgesToRemove.push({source, target});
+                    edgesToRemove.push({ source, target });
                 }
             }
         }
 
         // Remove edges with highest betweenness
-        for (const {source, target} of edgesToRemove) {
+        for (const { source, target } of edgesToRemove) {
             workingGraph.removeEdge(source, target);
         }
 
@@ -71,9 +67,7 @@ export function girvanNewman(
         components = getConnectedComponentsResult(workingGraph);
 
         // Filter communities by minimum size
-        const validCommunities = components.components.filter(
-            (community) => community.length >= minCommunitySize,
-        );
+        const validCommunities = components.components.filter((community) => community.length >= minCommunitySize);
 
         // Calculate modularity for the new community structure
         const modularity = calculateModularity(graph, components.componentMap);
@@ -102,6 +96,8 @@ export function girvanNewman(
  *
  * Edge betweenness is the fraction of shortest paths that pass through the edge.
  * We adapt node betweenness centrality calculation to work with edges.
+ * @param graph - The input graph to analyze
+ * @returns Map of edge keys to their betweenness centrality values
  */
 function calculateEdgeBetweenness(graph: Graph): Map<string, number> {
     const edgeBetweenness = new Map<string, number>();
@@ -117,7 +113,7 @@ function calculateEdgeBetweenness(graph: Graph): Map<string, number> {
         const source = sourceNode.id;
 
         // Run BFS to find all shortest paths from source
-        const {distances, predecessors, pathCounts} = findAllShortestPaths(graph, source);
+        const { distances, predecessors, pathCounts } = findAllShortestPaths(graph, source);
 
         // Calculate dependency for each node and accumulate edge betweenness
         const dependency = new Map<NodeId, number>();
@@ -191,8 +187,14 @@ function calculateEdgeBetweenness(graph: Graph): Map<string, number> {
 
 /**
  * Find all shortest paths from a source node using optimized BFS
+ * @param graph - The input graph to search
+ * @param source - The source node to compute shortest paths from
+ * @returns Object containing distances, predecessors, and path counts
  */
-function findAllShortestPaths(graph: Graph, source: NodeId): {
+function findAllShortestPaths(
+    graph: Graph,
+    source: NodeId,
+): {
     distances: Map<NodeId, number>;
     predecessors: Map<NodeId, NodeId[]>;
     pathCounts: Map<NodeId, number>;
@@ -262,11 +264,14 @@ function findAllShortestPaths(graph: Graph, source: NodeId): {
         }
     }
 
-    return {distances, predecessors, pathCounts};
+    return { distances, predecessors, pathCounts };
 }
 
 /**
  * Generate a consistent edge key for undirected graphs
+ * @param source - The source node ID
+ * @param target - The target node ID
+ * @returns A consistent string key for the edge (ordered alphabetically)
  */
 function getEdgeKey(source: NodeId, target: NodeId): string {
     // For undirected graphs, ensure consistent ordering
@@ -282,11 +287,11 @@ function getEdgeKey(source: NodeId, target: NodeId): string {
 
 /**
  * Calculate modularity for a given community structure - optimized version
+ * @param graph - The original graph
+ * @param communityMap - Map from node IDs to community indices
+ * @returns The modularity score of the partition
  */
-function calculateModularity(
-    graph: Graph,
-    communityMap: Map<NodeId, number>,
-): number {
+function calculateModularity(graph: Graph, communityMap: Map<NodeId, number>): number {
     const totalEdgeWeight = getTotalEdgeWeight(graph);
     if (totalEdgeWeight === 0) {
         return 0;
@@ -313,7 +318,7 @@ function calculateModularity(
                 continue;
             }
 
-            modularity += edgeWeight - ((degreeI * degreeJ) / (2 * totalEdgeWeight));
+            modularity += edgeWeight - (degreeI * degreeJ) / (2 * totalEdgeWeight);
         }
     }
 
@@ -322,6 +327,8 @@ function calculateModularity(
 
 /**
  * Calculate total edge weight in the graph
+ * @param graph - The input graph
+ * @returns Total sum of all edge weights
  */
 function getTotalEdgeWeight(graph: Graph): number {
     let totalWeight = 0;
@@ -335,6 +342,9 @@ function getTotalEdgeWeight(graph: Graph): number {
 
 /**
  * Get the total degree (sum of edge weights) for a node
+ * @param graph - The input graph
+ * @param nodeId - The node ID to compute degree for
+ * @returns The weighted degree of the node
  */
 function getNodeDegree(graph: Graph, nodeId: NodeId): number {
     let degree = 0;
@@ -349,6 +359,8 @@ function getNodeDegree(graph: Graph, nodeId: NodeId): number {
 
 /**
  * Convert connected components result to ComponentResult format
+ * @param graph - The input graph
+ * @returns Object containing components array and node-to-component map
  */
 function getConnectedComponentsResult(graph: Graph): ComponentResult {
     const components = connectedComponents(graph);
@@ -360,6 +372,5 @@ function getConnectedComponentsResult(graph: Graph): ComponentResult {
         });
     });
 
-    return {components, componentMap};
+    return { components, componentMap };
 }
-

package/src/algorithms/community/index.ts

@@ -6,10 +6,9 @@
  * than with the rest of the network.
  */
 
-export {girvanNewman} from "./girvan-newman.js";
-export type {LabelPropagationOptions, LabelPropagationResult} from "./label-propagation.js";
-export {labelPropagation, labelPropagationAsync, labelPropagationSemiSupervised} from "./label-propagation.js";
-export type {LeidenOptions, LeidenResult} from "./leiden.js";
-export {leiden} from "./leiden.js";
-export {louvain} from "./louvain.js";
-
+export { girvanNewman } from "./girvan-newman.js";
+export type { LabelPropagationOptions, LabelPropagationResult } from "./label-propagation.js";
+export { labelPropagation, labelPropagationAsync, labelPropagationSemiSupervised } from "./label-propagation.js";
+export type { LeidenOptions, LeidenResult } from "./leiden.js";
+export { leiden } from "./leiden.js";
+export { louvain } from "./louvain.js";

package/src/algorithms/community/label-propagation.ts

@@ -9,9 +9,9 @@
  * detect community structures in large-scale networks"
  */
 
-import type {Graph} from "../../core/graph.js";
-import {graphToMap} from "../../utils/graph-converters.js";
-import {SeededRandom, shuffle} from "../../utils/math-utilities.js";
+import type { Graph } from "../../core/graph.js";
+import { graphToMap } from "../../utils/graph-converters.js";
+import { SeededRandom, shuffle } from "../../utils/math-utilities.js";
 
 export interface LabelPropagationOptions {
     maxIterations?: number;
@@ -26,15 +26,15 @@ export interface LabelPropagationResult {
 
 /**
  * Internal implementation of Label Propagation Algorithm
+ * @param graph - Map representation of the graph (node to neighbors with weights)
+ * @param options - Algorithm configuration options
+ * @returns Community assignments, iteration count, and convergence status
  */
 function labelPropagationImpl(
     graph: Map<string, Map<string, number>>,
     options: LabelPropagationOptions = {},
 ): LabelPropagationResult {
-    const {
-        maxIterations = 100,
-        randomSeed = 42,
-    } = options;
+    const { maxIterations = 100, randomSeed = 42 } = options;
 
     if (graph.size === 0) {
         return {
@@ -61,7 +61,7 @@ function labelPropagationImpl(
         converged = true;
 
         // Create random order for node updates
-        const nodeOrder = [... nodes];
+        const nodeOrder = [...nodes];
         shuffle(nodeOrder, random);
 
         // Update each node's label
@@ -151,14 +151,15 @@ function labelPropagationImpl(
 /**
  * Internal implementation of Asynchronous Label Propagation
  * Updates all nodes simultaneously (can lead to oscillations)
+ * @param graph - Map representation of the graph (node to neighbors with weights)
+ * @param options - Algorithm configuration options
+ * @returns Community assignments, iteration count, and convergence status
  */
 function labelPropagationAsyncImpl(
     graph: Map<string, Map<string, number>>,
     options: LabelPropagationOptions = {},
 ): LabelPropagationResult {
-    const {
-        maxIterations = 100,
-    } = options;
+    const { maxIterations = 100 } = options;
 
     if (graph.size === 0) {
         return {
@@ -261,16 +262,17 @@ function labelPropagationAsyncImpl(
 /**
  * Internal implementation of Semi-supervised Label Propagation
  * Some nodes have fixed labels that don't change
+ * @param graph - Map representation of the graph (node to neighbors with weights)
+ * @param seedLabels - Map of node IDs to their fixed community labels
+ * @param options - Algorithm configuration options
+ * @returns Community assignments, iteration count, and convergence status
  */
 function labelPropagationSemiSupervisedImpl(
     graph: Map<string, Map<string, number>>,
     seedLabels: Map<string, number>,
     options: LabelPropagationOptions = {},
 ): LabelPropagationResult {
-    const {
-        maxIterations = 100,
-        randomSeed = 42,
-    } = options;
+    const { maxIterations = 100, randomSeed = 42 } = options;
 
     // Initialize random number generator
     const random = SeededRandom.createGenerator(randomSeed);
@@ -278,7 +280,7 @@ function labelPropagationSemiSupervisedImpl(
     // Initialize labels
     const labels = new Map<string, number>();
     const nodes = Array.from(graph.keys());
-    let labelCounter = Math.max(... Array.from(seedLabels.values())) + 1;
+    let labelCounter = Math.max(...Array.from(seedLabels.values())) + 1;
 
     for (const node of nodes) {
         if (seedLabels.has(node)) {
@@ -366,7 +368,6 @@ function labelPropagationSemiSupervisedImpl(
 /**
  * Label Propagation Algorithm
  * Each node adopts the most frequent label among its neighbors
- *
  * @param graph - Undirected graph (can be weighted)
  * @param options - Algorithm options
  * @returns Community assignments
@@ -374,10 +375,7 @@ function labelPropagationSemiSupervisedImpl(
  * Time Complexity: O(m) per iteration, typically O(km) for k iterations
  * Space Complexity: O(n)
  */
-export function labelPropagation(
-    graph: Graph,
-    options: LabelPropagationOptions = {},
-): LabelPropagationResult {
+export function labelPropagation(graph: Graph, options: LabelPropagationOptions = {}): LabelPropagationResult {
     // Convert Graph to Map representation
     const graphMap = graphToMap(graph);
     return labelPropagationImpl(graphMap, options);
@@ -386,15 +384,11 @@ export function labelPropagation(
 /**
  * Asynchronous Label Propagation
  * Updates all nodes simultaneously (can lead to oscillations)
- *
  * @param graph - Undirected graph (can be weighted)
  * @param options - Algorithm options
  * @returns Community assignments
  */
-export function labelPropagationAsync(
-    graph: Graph,
-    options: LabelPropagationOptions = {},
-): LabelPropagationResult {
+export function labelPropagationAsync(graph: Graph, options: LabelPropagationOptions = {}): LabelPropagationResult {
     // Convert Graph to Map representation
     const graphMap = graphToMap(graph);
     return labelPropagationAsyncImpl(graphMap, options);
@@ -403,7 +397,6 @@ export function labelPropagationAsync(
 /**
  * Semi-supervised Label Propagation
  * Some nodes have fixed labels that don't change
- *
  * @param graph - Undirected graph (can be weighted)
  * @param seedLabels - Initial fixed labels for some nodes
  * @param options - Algorithm options
@@ -418,4 +411,3 @@ export function labelPropagationSemiSupervised(
     const graphMap = graphToMap(graph);
     return labelPropagationSemiSupervisedImpl(graphMap, seedLabels, options);
 }
-