@graphty/algorithms 1.3.1 → 1.5.0

package/src/algorithms/centrality/degree.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";
 
 /**
  * Degree centrality implementation
@@ -10,13 +10,13 @@ import type {CentralityOptions, CentralityResult} from "../../types/index.js";
 
 /**
  * Calculate degree centrality for all nodes in the graph
+ * @param graph - The input graph to analyze
+ * @param options - Algorithm configuration options
+ * @returns Centrality scores for each node keyed by node ID
  */
-export function degreeCentrality(
-    graph: Graph,
-    options: CentralityOptions = {},
-): CentralityResult {
+export function degreeCentrality(graph: Graph, options: CentralityOptions = {}): CentralityResult {
     const centrality: CentralityResult = {};
-    const {nodeCount} = graph;
+    const { nodeCount } = graph;
 
     // Calculate normalization factor (same for both directed and undirected graphs)
     const maxPossibleDegree = nodeCount - 1;
@@ -49,9 +49,7 @@ export function degreeCentrality(
         }
 
         // Apply normalization if requested
-        const normalizedDegree = options.normalized && maxPossibleDegree > 0 ?
-            degree / maxPossibleDegree :
-            degree;
+        const normalizedDegree = options.normalized && maxPossibleDegree > 0 ? degree / maxPossibleDegree : degree;
 
         centrality[node.id.toString()] = normalizedDegree;
     }
@@ -61,17 +59,17 @@ export function degreeCentrality(
 
 /**
  * Calculate degree centrality for a specific node
+ * @param graph - The input graph to analyze
+ * @param nodeId - The node to calculate centrality for
+ * @param options - Algorithm configuration options
+ * @returns The degree centrality score for the node
  */
-export function nodeDegreeCentrality(
-    graph: Graph,
-    nodeId: string | number,
-    options: CentralityOptions = {},
-): number {
+export function nodeDegreeCentrality(graph: Graph, nodeId: string | number, options: CentralityOptions = {}): number {
     if (!graph.hasNode(nodeId)) {
         throw new Error(`Node ${String(nodeId)} not found in graph`);
     }
 
-    const {nodeCount} = graph;
+    const { nodeCount } = graph;
     let degree: number;
 
     if (graph.isDirected && options.mode) {
@@ -99,7 +97,5 @@ export function nodeDegreeCentrality(
     // Apply normalization if requested
     const maxPossibleDegree = nodeCount - 1;
 
-    return options.normalized && maxPossibleDegree > 0 ?
-        degree / maxPossibleDegree :
-        degree;
+    return options.normalized && maxPossibleDegree > 0 ? degree / maxPossibleDegree : degree;
 }

package/src/algorithms/centrality/delta-pagerank-simple.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";
 
 /**
  * Simplified Delta-based PageRank that matches the standard algorithm
@@ -13,6 +13,10 @@ export class SimpleDeltaPageRank {
     private nodeCount: number;
     private previousScores: Map<NodeId, number> | null = null;
 
+    /**
+     * Creates a new SimpleDeltaPageRank instance for the given graph.
+     * @param graph - The directed graph to compute PageRank on
+     */
     constructor(graph: Graph) {
         if (!graph.isDirected) {
             throw new Error("PageRank requires a directed graph");
@@ -22,20 +26,26 @@ export class SimpleDeltaPageRank {
         this.nodeCount = graph.nodeCount;
     }
 
-    public compute(options: {
-        dampingFactor?: number;
-        tolerance?: number;
-        maxIterations?: number;
-        personalization?: Map<NodeId, number>;
-        weight?: string;
-    } = {}): Map<NodeId, number> {
-        const {
-            dampingFactor = 0.85,
-            tolerance = 1e-6,
-            maxIterations = 100,
-            personalization,
-            weight,
-        } = options;
+    /**
+     * Computes PageRank scores for all nodes in the graph using power iteration.
+     * @param options - Configuration options for PageRank computation
+     * @param options.dampingFactor - Probability of following a link (default: 0.85)
+     * @param options.tolerance - Convergence tolerance threshold (default: 1e-6)
+     * @param options.maxIterations - Maximum number of iterations (default: 100)
+     * @param options.personalization - Personalization vector for Personalized PageRank
+     * @param options.weight - Edge attribute name for weighted PageRank
+     * @returns Map of node IDs to their PageRank scores
+     */
+    public compute(
+        options: {
+            dampingFactor?: number;
+            tolerance?: number;
+            maxIterations?: number;
+            personalization?: Map<NodeId, number>;
+            weight?: string;
+        } = {},
+    ): Map<NodeId, number> {
+        const { dampingFactor = 0.85, tolerance = 1e-6, maxIterations = 100, personalization, weight } = options;
 
         if (this.nodeCount === 0) {
             return new Map();
@@ -97,7 +107,7 @@ export class SimpleDeltaPageRank {
             }
 
             if (danglingSum > 0) {
-                const danglingContribution = dampingFactor * danglingSum / this.nodeCount;
+                const danglingContribution = (dampingFactor * danglingSum) / this.nodeCount;
                 for (const nodeId of scores.keys()) {
                     const current = newScores.get(nodeId) ?? 0;
                     if (personalVector) {
@@ -175,9 +185,13 @@ export class SimpleDeltaPageRank {
     /**
      * Perform incremental update after graph modification.
      * This is where delta-based approach provides significant speedup.
-     *
-     * @param modifiedNodes Set of nodes that were modified (edges added/removed)
-     * @param options Computation options
+     * @param modifiedNodes - Set of nodes that were modified (edges added/removed)
+     * @param options - Computation options
+     * @param options.dampingFactor - Probability of following a link (default: 0.85)
+     * @param options.tolerance - Convergence tolerance threshold (default: 1e-6)
+     * @param options.maxIterations - Maximum number of iterations (default: 100)
+     * @param options.personalization - Personalization vector for Personalized PageRank
+     * @param options.weight - Edge attribute name for weighted PageRank
      * @returns Updated PageRank scores
      */
     public update(
@@ -195,13 +209,7 @@ export class SimpleDeltaPageRank {
             return this.compute(options);
         }
 
-        const {
-            dampingFactor = 0.85,
-            tolerance = 1e-6,
-            maxIterations = 100,
-            personalization,
-            weight,
-        } = options;
+        const { dampingFactor = 0.85, tolerance = 1e-6, maxIterations = 100, personalization, weight } = options;
 
         // Initialize scores from previous computation
         const scores = new Map(this.previousScores);
@@ -275,7 +283,7 @@ export class SimpleDeltaPageRank {
             }
 
             if (danglingSum > 0) {
-                const danglingContribution = dampingFactor * danglingSum / this.nodeCount;
+                const danglingContribution = (dampingFactor * danglingSum) / this.nodeCount;
                 for (const nodeId of scores.keys()) {
                     const current = newScores.get(nodeId) ?? 0;
                     if (personalVector) {

package/src/algorithms/centrality/delta-pagerank.ts

@@ -1,6 +1,6 @@
-import type {Graph} from "../../core/graph.js";
-import {PriorityQueue} from "../../data-structures/priority-queue.js";
-import type {NodeId} from "../../types/index.js";
+import type { Graph } from "../../core/graph.js";
+import { PriorityQueue } from "../../data-structures/priority-queue.js";
+import type { NodeId } from "../../types/index.js";
 
 /**
  * Delta-based PageRank implementation for faster convergence
@@ -45,6 +45,10 @@ export interface DeltaPageRankOptions {
     weight?: string;
 }
 
+/**
+ * Delta-based PageRank class that tracks changes between iterations
+ * and only processes nodes with significant changes for improved performance.
+ */
 export class DeltaPageRank {
     private graph: Graph;
     private scores: Map<NodeId, number>;
@@ -55,6 +59,10 @@ export class DeltaPageRank {
     private danglingNodes: Set<NodeId>;
     private nodeCount: number;
 
+    /**
+     * Creates a new DeltaPageRank instance for the given graph.
+     * @param graph - The directed graph to compute PageRank on
+     */
     constructor(graph: Graph) {
         if (!graph.isDirected) {
             throw new Error("DeltaPageRank requires a directed graph");
@@ -101,6 +109,11 @@ export class DeltaPageRank {
         }
     }
 
+    /**
+     * Computes PageRank scores using delta-based iteration for faster convergence.
+     * @param options - Configuration options for PageRank computation
+     * @returns Map of node IDs to their PageRank scores
+     */
     public compute(options: DeltaPageRankOptions = {}): Map<NodeId, number> {
         const {
             dampingFactor = 0.85,
@@ -149,7 +162,7 @@ export class DeltaPageRank {
             }
 
             if (danglingSum > 0) {
-                const danglingContribution = dampingFactor * danglingSum / this.nodeCount;
+                const danglingContribution = (dampingFactor * danglingSum) / this.nodeCount;
                 for (const node of this.graph.nodes()) {
                     const nodeId = node.id;
                     const currentDelta = nextDeltas.get(nodeId) ?? 0;
@@ -197,7 +210,7 @@ export class DeltaPageRank {
                 const nodeId = node.id;
                 const currentDelta = nextDeltas.get(nodeId) ?? 0;
                 if (personalVector) {
-                    nextDeltas.set(nodeId, currentDelta + ((1 - dampingFactor) * (personalVector.get(nodeId) ?? 0)));
+                    nextDeltas.set(nodeId, currentDelta + (1 - dampingFactor) * (personalVector.get(nodeId) ?? 0));
                 } else {
                     nextDeltas.set(nodeId, currentDelta + randomJump);
                 }
@@ -231,13 +244,13 @@ export class DeltaPageRank {
     }
 
     /**
-     * Update PageRank scores after graph modification
-     * This is where delta-based approach really shines
+     * Update PageRank scores after graph modification.
+     * This is where delta-based approach really shines.
+     * @param modifiedNodes - Set of nodes that were modified (edges added/removed)
+     * @param options - Configuration options for PageRank computation
+     * @returns Updated PageRank scores
      */
-    public update(
-        modifiedNodes: Set<NodeId>,
-        options: DeltaPageRankOptions = {},
-    ): Map<NodeId, number> {
+    public update(modifiedNodes: Set<NodeId>, options: DeltaPageRankOptions = {}): Map<NodeId, number> {
         // Mark modified nodes and their neighbors as active
         this.activeNodes.clear();
 
@@ -286,6 +299,10 @@ export class PriorityDeltaPageRank {
     private danglingNodes: Set<NodeId>;
     private nodeCount: number;
 
+    /**
+     * Creates a new PriorityDeltaPageRank instance for the given graph.
+     * @param graph - The directed graph to compute PageRank on
+     */
     constructor(graph: Graph) {
         if (!graph.isDirected) {
             throw new Error("PriorityDeltaPageRank requires a directed graph");
@@ -332,6 +349,12 @@ export class PriorityDeltaPageRank {
         }
     }
 
+    /**
+     * Computes PageRank scores using priority queue-based delta iteration.
+     * Processes nodes in order of their delta magnitude for optimal convergence.
+     * @param options - Configuration options for PageRank computation
+     * @returns Map of node IDs to their PageRank scores
+     */
     public computeWithPriority(options: DeltaPageRankOptions = {}): Map<NodeId, number> {
         const {
             dampingFactor = 0.85,

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;