@graphty/algorithms 2.0.6 → 2.1.1

package/dist/algorithms.js

@@ -3282,7 +3282,7 @@ function breadthFirstSearchStandard(graph, startNode, options = {}) {
     if (options.visitCallback) {
       options.visitCallback(current.node, current.level);
     }
-    if (options.targetNode && current.node === options.targetNode) {
+    if (options.targetNode !== void 0 && current.node === options.targetNode) {
       break;
     }
     for (const neighbor of graph.neighbors(current.node)) {
@@ -3472,7 +3472,7 @@ function isBipartite(graph) {
       visited.add(node.id);
       while (queue.length > 0) {
         const current = queue.shift();
-        if (!current) {
+        if (current === void 0) {
           break;
         }
         const currentColor = color.get(current);
@@ -3526,7 +3526,7 @@ function dfsIterative(graph, startNode, visited, order, tree, options) {
       if (options.visitCallback) {
         options.visitCallback(current.node, current.depth);
       }
-      if (options.targetNode && current.node === options.targetNode) {
+      if (options.targetNode !== void 0 && current.node === options.targetNode) {
         break;
       }
       const neighbors = Array.from(graph.neighbors(current.node));
@@ -3547,7 +3547,7 @@ function dfsRecursive(graph, node, visited, order, tree, options, depth, parent
     if (options.visitCallback) {
       options.visitCallback(node, depth);
     }
-    if (options.targetNode && node === options.targetNode) {
+    if (options.targetNode !== void 0 && node === options.targetNode) {
       return;
     }
   }
@@ -3723,7 +3723,7 @@ function bellmanFord(graph, source, options = {}) {
           distances.set(v, newDistance);
           predecessors.set(v, u);
           updated = true;
-          if (options.target && v === options.target) {
+          if (options.target !== void 0 && v === options.target) {
             break;
           }
         }
@@ -4077,7 +4077,7 @@ class BidirectionalDijkstra {
     return minDist;
   }
   reconstructPath() {
-    if (!this.meetingNode) {
+    if (this.meetingNode === null) {
       return [];
     }
     const path = [];
@@ -4138,7 +4138,7 @@ function dijkstra$1(graph, source, options = {}) {
       continue;
     }
     visited.add(currentNode);
-    if (options.target && currentNode === options.target) {
+    if (options.target !== void 0 && currentNode === options.target) {
       break;
     }
     if (currentDistance === Infinity) {
@@ -4713,7 +4713,7 @@ function accumulateBetweenness(result, source, centrality, options) {
   }
   for (let i = stack.length - 1; i >= 0; i--) {
     const w = stack[i];
-    if (!w) {
+    if (w === void 0) {
       continue;
     }
     const wPreds = predecessors.get(w) ?? [];
@@ -4747,7 +4747,7 @@ function accumulateEdgeBetweenness(result, source, edgeCentrality, options) {
   }
   for (let i = stack.length - 1; i >= 0; i--) {
     const w = stack[i];
-    if (!w) {
+    if (w === void 0) {
       continue;
     }
     const wPreds = predecessors.get(w) ?? [];
@@ -5381,7 +5381,7 @@ function nodeEigenvectorCentrality(graph, nodeId, options = {}) {
   const centrality = eigenvectorCentrality(graph, options);
   return centrality[nodeId.toString()] ?? 0;
 }
-function hits(graph, options = {}) {
+function hits$1(graph, options = {}) {
   const { maxIterations = 100, tolerance = 1e-6, normalized = true } = options;
   const hubs = {};
   const authorities = {};
@@ -5498,14 +5498,14 @@ function nodeHITS(graph, nodeId, options = {}) {
   if (!graph.hasNode(nodeId)) {
     throw new Error(`Node ${String(nodeId)} not found in graph`);
   }
-  const result = hits(graph, options);
+  const result = hits$1(graph, options);
   const key = nodeId.toString();
   return {
     hub: result.hubs[key] ?? 0,
     authority: result.authorities[key] ?? 0
   };
 }
-function katzCentrality(graph, options = {}) {
+function katzCentrality$1(graph, options = {}) {
   const { alpha = 0.1, beta = 1, maxIterations = 100, tolerance = 1e-6, normalized = true } = options;
   const centrality = {};
   const nodes = Array.from(graph.nodes());
@@ -5566,7 +5566,7 @@ function nodeKatzCentrality(graph, nodeId, options = {}) {
   if (!graph.hasNode(nodeId)) {
     throw new Error(`Node ${String(nodeId)} not found in graph`);
   }
-  const centrality = katzCentrality(graph, options);
+  const centrality = katzCentrality$1(graph, options);
   return centrality[nodeId.toString()] ?? 0;
 }
 class SimpleDeltaPageRank {
@@ -6411,7 +6411,7 @@ function primMST(graph, startNode) {
     };
   }
   const start = startNode ?? nodes[0]?.id;
-  if (!start) {
+  if (start === void 0) {
     return {
       edges: [],
       totalWeight: 0
@@ -6579,7 +6579,7 @@ function findAllShortestPaths(graph, source) {
   let queueIndex = 0;
   while (queueIndex < queue.length) {
     const current = queue[queueIndex++];
-    if (!current) {
+    if (current === void 0) {
       continue;
     }
     if (visited.has(current)) {
@@ -7361,7 +7361,7 @@ class OptimizedLouvain {
       for (let i = 0; i < membership.length; i++) {
         membership[i] = community[membership[i]];
       }
-      level = aggregate(level, community, count);
+      level = aggregate$1(level, community, count);
     }
     const groups = Array.from({ length: level.n }, () => []);
     for (let i = 0; i < membership.length; i++) {
@@ -7544,7 +7544,7 @@ function buildCsr(n, counts, edges, self, degree) {
   }
   return { n, offsets, targets, weights, self, degree };
 }
-function aggregate(level, community, count) {
+function aggregate$1(level, community, count) {
   const self = new Float64Array(count);
   const degree = new Float64Array(count);
   const members = Array.from({ length: count }, () => []);
@@ -7652,7 +7652,7 @@ function calculateModularity$1(graph, communities, resolution = 1) {
   }
   return modularity;
 }
-function louvain(graph, options = {}) {
+function louvain$1(graph, options = {}) {
   const resolution = options.resolution ?? 1;
   const maxIterations = options.maxIterations ?? 100;
   const tolerance = options.tolerance ?? 1e-6;
@@ -9018,7 +9018,7 @@ function kCoreDecompositionImpl(graph) {
   return { cores, coreness, maxCore };
 }
 function getKCore(graph, k) {
-  const { coreness } = kCoreDecomposition(graph);
+  const { coreness } = kCoreDecomposition$1(graph);
   const kCore = /* @__PURE__ */ new Set();
   for (const [node, core] of coreness) {
     if (core >= k) {
@@ -9027,7 +9027,7 @@ function getKCore(graph, k) {
   }
   return kCore;
 }
-function kCoreDecomposition(graph) {
+function kCoreDecomposition$1(graph) {
   const adjacencySet = graphToAdjacencySet(graph);
   return kCoreDecompositionImpl(adjacencySet);
 }
@@ -9383,7 +9383,7 @@ function spectralClustering(graph, options) {
   for (let i = 0; i < nodeIds.length; i++) {
     const clusterId = kmeans.assignments[i] ?? 0;
     const nodeId = nodeIds[i];
-    if (!nodeId) {
+    if (nodeId === void 0) {
       continue;
     }
     if (clusterId >= 0 && clusterId < k) {
@@ -9415,7 +9415,7 @@ function buildAdjacencyMatrix(graph, nodeIds) {
   nodeIds.forEach((id, index2) => nodeToIndex.set(id, index2));
   for (let i = 0; i < n; i++) {
     const nodeId = nodeIds[i];
-    if (!nodeId) {
+    if (nodeId === void 0) {
       continue;
     }
     const neighbors = graph.neighbors(nodeId);
@@ -9955,7 +9955,7 @@ function getCandidatePairs(g1, g2, state, nodes1, nodes2) {
       break;
     }
   }
-  if (!node1) {
+  if (node1 === null) {
     for (const [n] of state.in1) {
       if (!state.core1.has(n)) {
         node1 = n;
@@ -9963,7 +9963,7 @@ function getCandidatePairs(g1, g2, state, nodes1, nodes2) {
       }
     }
   }
-  if (!node1) {
+  if (node1 === null) {
     for (const n of nodes1) {
       if (!state.core1.has(n)) {
         node1 = n;
@@ -9971,7 +9971,7 @@ function getCandidatePairs(g1, g2, state, nodes1, nodes2) {
       }
     }
   }
-  if (!node1) {
+  if (node1 === null) {
     return pairs;
   }
   for (const node2 of nodes2) {
@@ -11708,6 +11708,467 @@ function dijkstra(g, source, options = {}) {
     pathEdges: (target) => walkPredEdges(g, predArc, source, target)
   };
 }
+function l2Normalize(v) {
+  let sum = 0;
+  for (let i = 0; i < v.length; i++) {
+    sum += v[i] * v[i];
+  }
+  const norm = Math.sqrt(sum);
+  if (norm > 0) {
+    for (let i = 0; i < v.length; i++) {
+      v[i] /= norm;
+    }
+  }
+}
+function maxNormalize(v) {
+  let max = 0;
+  for (let i = 0; i < v.length; i++) {
+    if (v[i] > max) {
+      max = v[i];
+    }
+  }
+  if (max > 0) {
+    for (let i = 0; i < v.length; i++) {
+      v[i] /= max;
+    }
+  }
+}
+function hits(s, o = {}) {
+  const n = s.nodeCount;
+  const maxIter = o.maxIterations ?? 100;
+  const tol = o.tolerance ?? 1e-6;
+  const rev = s.reverse();
+  const fwdW = o.weighted === true ? s.weights : null;
+  const revW = o.weighted === true ? rev.weights : null;
+  let hubs = new Float64Array(n).fill(n === 0 ? 0 : 1 / Math.sqrt(n));
+  let authorities = new Float64Array(n).fill(n === 0 ? 0 : 1 / Math.sqrt(n));
+  let nextHubs = new Float64Array(n);
+  let nextAuthorities = new Float64Array(n);
+  let it = 0;
+  let converged = false;
+  for (; it < maxIter && !converged; it++) {
+    for (let v = 0; v < n; v++) {
+      let auth = 0;
+      const inEnd = rev.rowPtr[v + 1];
+      for (let a = rev.rowPtr[v]; a < inEnd; a++) {
+        auth += hubs[rev.colIdx[a]] * (revW === null ? 1 : revW[a]);
+      }
+      nextAuthorities[v] = auth;
+      let hub = 0;
+      const outEnd = s.rowPtr[v + 1];
+      for (let a = s.rowPtr[v]; a < outEnd; a++) {
+        hub += authorities[s.colIdx[a]] * (fwdW === null ? 1 : fwdW[a]);
+      }
+      nextHubs[v] = hub;
+    }
+    l2Normalize(nextAuthorities);
+    l2Normalize(nextHubs);
+    let maxDiff = 0;
+    for (let v = 0; v < n; v++) {
+      const dh = Math.abs(nextHubs[v] - hubs[v]);
+      if (dh > maxDiff) {
+        maxDiff = dh;
+      }
+      const da = Math.abs(nextAuthorities[v] - authorities[v]);
+      if (da > maxDiff) {
+        maxDiff = da;
+      }
+    }
+    [hubs, nextHubs] = [nextHubs, hubs];
+    [authorities, nextAuthorities] = [nextAuthorities, authorities];
+    converged = maxDiff < tol;
+  }
+  if (o.normalized === false) {
+    maxNormalize(hubs);
+    maxNormalize(authorities);
+  }
+  return { hubs, authorities, iterations: it, converged };
+}
+function kCoreDecomposition(s) {
+  if (s.directed) {
+    throw new Error("k-core requires an undirected graph. Pass s.toUndirected().snapshot.");
+  }
+  const n = s.nodeCount;
+  const { rowPtr, colIdx } = s;
+  const degree = new Uint32Array(n);
+  let maxDegree = 0;
+  for (let u = 0; u < n; u++) {
+    let d = 0;
+    let last = -1;
+    const end = rowPtr[u + 1];
+    for (let a = rowPtr[u]; a < end; a++) {
+      const v = colIdx[a];
+      if (v !== u && v !== last) {
+        d++;
+      }
+      last = v;
+    }
+    degree[u] = d;
+    if (d > maxDegree) {
+      maxDegree = d;
+    }
+  }
+  const bin = new Uint32Array(maxDegree + 1);
+  for (let u = 0; u < n; u++) {
+    bin[degree[u]]++;
+  }
+  let start = 0;
+  for (let d = 0; d <= maxDegree; d++) {
+    const count = bin[d];
+    bin[d] = start;
+    start += count;
+  }
+  const vert = new Uint32Array(n);
+  const pos = new Uint32Array(n);
+  for (let u = 0; u < n; u++) {
+    pos[u] = bin[degree[u]];
+    vert[pos[u]] = u;
+    bin[degree[u]]++;
+  }
+  for (let d = maxDegree; d > 0; d--) {
+    bin[d] = bin[d - 1];
+  }
+  bin[0] = 0;
+  let maxCore = 0;
+  for (let i = 0; i < n; i++) {
+    const v = vert[i];
+    const dv = degree[v];
+    if (dv > maxCore) {
+      maxCore = dv;
+    }
+    const end = rowPtr[v + 1];
+    let last = -1;
+    for (let a = rowPtr[v]; a < end; a++) {
+      const u = colIdx[a];
+      const skip = u === v || u === last;
+      last = u;
+      if (skip) {
+        continue;
+      }
+      const du = degree[u];
+      if (du > dv) {
+        const pu = pos[u];
+        const pw = bin[du];
+        const w = vert[pw];
+        if (u !== w) {
+          vert[pu] = w;
+          vert[pw] = u;
+          pos[u] = pw;
+          pos[w] = pu;
+        }
+        bin[du]++;
+        degree[u] = du - 1;
+      }
+    }
+  }
+  let cached = null;
+  return {
+    coreness: degree,
+    maxCore,
+    cores() {
+      if (cached === null) {
+        const sizes = new Uint32Array(maxCore + 1);
+        for (let u = 0; u < n; u++) {
+          sizes[degree[u]]++;
+        }
+        const out = [];
+        for (let k = 0; k <= maxCore; k++) {
+          out.push(new Uint32Array(sizes[k]));
+        }
+        const fill = new Uint32Array(maxCore + 1);
+        for (let u = 0; u < n; u++) {
+          const k = degree[u];
+          out[k][fill[k]++] = u;
+        }
+        cached = out;
+      }
+      return cached;
+    }
+  };
+}
+function katzCentrality(s, o = {}) {
+  const n = s.nodeCount;
+  const alpha = o.alpha ?? 0.1;
+  const beta = o.beta ?? 1;
+  const maxIter = o.maxIterations ?? 100;
+  const tol = o.tolerance ?? 1e-6;
+  const rev = s.reverse();
+  const weights = o.weighted === true ? rev.weights : null;
+  let cur = new Float64Array(n).fill(beta);
+  let next = new Float64Array(n);
+  let it = 0;
+  let converged = false;
+  for (; it < maxIter && !converged; it++) {
+    let maxDiff = 0;
+    for (let v = 0; v < n; v++) {
+      let sum = 0;
+      const end = rev.rowPtr[v + 1];
+      for (let a = rev.rowPtr[v]; a < end; a++) {
+        sum += cur[rev.colIdx[a]] * (weights === null ? 1 : weights[a]);
+      }
+      next[v] = alpha * sum + beta;
+      const diff = Math.abs(next[v] - cur[v]);
+      if (diff > maxDiff) {
+        maxDiff = diff;
+      }
+    }
+    [cur, next] = [next, cur];
+    converged = maxDiff < tol;
+  }
+  if (o.normalized !== false) {
+    let min = Infinity;
+    let max = -Infinity;
+    for (let v = 0; v < n; v++) {
+      if (cur[v] < min) {
+        min = cur[v];
+      }
+      if (cur[v] > max) {
+        max = cur[v];
+      }
+    }
+    const range = max - min;
+    if (range > 0) {
+      for (let v = 0; v < n; v++) {
+        cur[v] = (cur[v] - min) / range;
+      }
+    }
+  }
+  return { scores: cur, iterations: it, converged };
+}
+function buildLevel0(s) {
+  const n = s.nodeCount;
+  const rowPtr = new Uint32Array(n + 1);
+  for (let u = 0; u < n; u++) {
+    let kept = 0;
+    const end = s.rowPtr[u + 1];
+    for (let a = s.rowPtr[u]; a < end; a++) {
+      if (s.colIdx[a] !== u) {
+        kept++;
+      }
+    }
+    rowPtr[u + 1] = rowPtr[u] + kept;
+  }
+  const arcs = rowPtr[n];
+  const colIdx = new Uint32Array(arcs);
+  const w = new Float64Array(arcs);
+  const loop = new Float64Array(n);
+  const deg = new Float64Array(n);
+  let k = 0;
+  for (let u = 0; u < n; u++) {
+    let rowWeight = 0;
+    const end = s.rowPtr[u + 1];
+    for (let a = s.rowPtr[u]; a < end; a++) {
+      const v = s.colIdx[a];
+      const weight = s.weights === null ? 1 : s.weights[a];
+      if (v === u) {
+        loop[u] += weight;
+      } else {
+        colIdx[k] = v;
+        w[k] = weight;
+        k++;
+        rowWeight += weight;
+      }
+    }
+    deg[u] = rowWeight + 2 * loop[u];
+  }
+  return { n, rowPtr, colIdx, w, loop, deg };
+}
+function modularityOf(level, comm, count, resolution, m2) {
+  const inside = new Float64Array(count);
+  const tot = new Float64Array(count);
+  for (let u = 0; u < level.n; u++) {
+    const c = comm[u];
+    tot[c] += level.deg[u];
+    inside[c] += 2 * level.loop[u];
+    const end = level.rowPtr[u + 1];
+    for (let a = level.rowPtr[u]; a < end; a++) {
+      if (comm[level.colIdx[a]] === c) {
+        inside[c] += level.w[a];
+      }
+    }
+  }
+  let q = 0;
+  for (let c = 0; c < count; c++) {
+    const share = tot[c] / m2;
+    q += inside[c] / m2 - resolution * share * share;
+  }
+  return q;
+}
+function localMove(level, comm, resolution, m2, maxVisitsPerNode) {
+  const { n } = level;
+  const tot = new Float64Array(n);
+  for (let u = 0; u < n; u++) {
+    comm[u] = u;
+    tot[u] = level.deg[u];
+  }
+  const acc = new Float64Array(n);
+  const stamp = new Int32Array(n).fill(-1);
+  const touched = new Uint32Array(n);
+  const capacity = n + 1;
+  const queue = new Uint32Array(capacity);
+  const queued = new Uint8Array(n);
+  let head = 0;
+  let tail = n;
+  for (let u = 0; u < n; u++) {
+    queue[u] = u;
+    queued[u] = 1;
+  }
+  let mark = 0;
+  let visits = 0;
+  const maxVisits = maxVisitsPerNode * n;
+  let movedAny = false;
+  while (head !== tail && visits < maxVisits) {
+    const u = queue[head];
+    head = head + 1 === capacity ? 0 : head + 1;
+    queued[u] = 0;
+    visits++;
+    const cu = comm[u];
+    const ku = level.deg[u];
+    tot[cu] -= ku;
+    mark++;
+    let cnt = 0;
+    const end = level.rowPtr[u + 1];
+    for (let a = level.rowPtr[u]; a < end; a++) {
+      const c = comm[level.colIdx[a]];
+      if (stamp[c] !== mark) {
+        stamp[c] = mark;
+        acc[c] = 0;
+        touched[cnt++] = c;
+      }
+      acc[c] += level.w[a];
+    }
+    let best = cu;
+    let bestGain = (stamp[cu] === mark ? acc[cu] : 0) - resolution * ku * tot[cu] / m2;
+    for (let i = 0; i < cnt; i++) {
+      const c = touched[i];
+      if (c === cu) {
+        continue;
+      }
+      const gain = acc[c] - resolution * ku * tot[c] / m2;
+      if (gain > bestGain) {
+        bestGain = gain;
+        best = c;
+      }
+    }
+    tot[best] += ku;
+    if (best !== cu) {
+      comm[u] = best;
+      movedAny = true;
+      for (let a = level.rowPtr[u]; a < end; a++) {
+        const v = level.colIdx[a];
+        if (queued[v] === 0 && comm[v] !== best) {
+          queued[v] = 1;
+          queue[tail] = v;
+          tail = tail + 1 === capacity ? 0 : tail + 1;
+        }
+      }
+    }
+  }
+  return movedAny;
+}
+function aggregate(level, comm, count) {
+  const start = new Uint32Array(count + 1);
+  for (let u = 0; u < level.n; u++) {
+    start[comm[u] + 1]++;
+  }
+  for (let c = 0; c < count; c++) {
+    start[c + 1] += start[c];
+  }
+  const members = new Uint32Array(level.n);
+  const fill = start.slice(0, count);
+  for (let u = 0; u < level.n; u++) {
+    members[fill[comm[u]]++] = u;
+  }
+  const rowPtr = new Uint32Array(count + 1);
+  const colIdx = new Uint32Array(level.colIdx.length);
+  const w = new Float64Array(level.colIdx.length);
+  const loop = new Float64Array(count);
+  const deg = new Float64Array(count);
+  const acc = new Float64Array(count);
+  const stamp = new Int32Array(count).fill(-1);
+  const touched = new Uint32Array(count);
+  let k = 0;
+  for (let c = 0; c < count; c++) {
+    rowPtr[c] = k;
+    let internalArcs = 0;
+    let cnt = 0;
+    for (let i = start[c]; i < start[c + 1]; i++) {
+      const u = members[i];
+      loop[c] += level.loop[u];
+      const end = level.rowPtr[u + 1];
+      for (let a = level.rowPtr[u]; a < end; a++) {
+        const other = comm[level.colIdx[a]];
+        if (other === c) {
+          internalArcs += level.w[a];
+          continue;
+        }
+        if (stamp[other] !== c) {
+          stamp[other] = c;
+          acc[other] = 0;
+          touched[cnt++] = other;
+        }
+        acc[other] += level.w[a];
+      }
+    }
+    loop[c] += internalArcs / 2;
+    let rowWeight = 0;
+    for (let i = 0; i < cnt; i++) {
+      const other = touched[i];
+      colIdx[k] = other;
+      w[k] = acc[other];
+      rowWeight += acc[other];
+      k++;
+    }
+    deg[c] = rowWeight + 2 * loop[c];
+  }
+  rowPtr[count] = k;
+  return { n: count, rowPtr, colIdx: colIdx.subarray(0, k), w: w.subarray(0, k), loop, deg };
+}
+function louvain(s, o = {}) {
+  if (s.directed) {
+    throw new Error("Louvain requires an undirected graph. Pass s.toUndirected().snapshot.");
+  }
+  const resolution = o.resolution ?? 1;
+  const maxIterations = o.maxIterations ?? 100;
+  const tolerance = o.tolerance ?? 1e-6;
+  const n0 = s.nodeCount;
+  const labels = new Uint32Array(n0);
+  for (let u = 0; u < n0; u++) {
+    labels[u] = u;
+  }
+  let level = buildLevel0(s);
+  let m2 = 0;
+  for (let u = 0; u < n0; u++) {
+    m2 += level.deg[u];
+  }
+  if (m2 === 0) {
+    return { ...withGroups(labels, n0), modularity: 0, iterations: 0 };
+  }
+  let q = modularityOf(level, labels, n0, resolution, m2);
+  let iterations = 0;
+  for (let iteration = 0; iteration < maxIterations; iteration++) {
+    const comm = new Uint32Array(level.n);
+    if (!localMove(level, comm, resolution, m2, maxIterations)) {
+      break;
+    }
+    const dense = renumberPartition(comm);
+    const { count } = dense;
+    const packed = dense.labels;
+    const newQ = modularityOf(level, packed, count, resolution, m2);
+    for (let u = 0; u < n0; u++) {
+      labels[u] = packed[labels[u]];
+    }
+    iterations = iteration + 1;
+    const gain = newQ - q;
+    q = newQ;
+    if (gain < tolerance || count === level.n) {
+      break;
+    }
+    level = aggregate(level, packed, count);
+  }
+  const final = renumberPartition(labels);
+  return { ...withGroups(final.labels, final.count), modularity: q, iterations };
+}
 function kruskalMST(s, o = {}) {
   const el = s.edgeList();
   const m = s.edgeCount;
@@ -11791,7 +12252,11 @@ const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
   commonNeighborsScore,
   connectedComponents,
   dijkstra,
+  hits,
+  kCoreDecomposition,
+  katzCentrality,
   kruskalMST,
+  louvain,
   pageRank,
   walkPredArcs,
   walkPredEdges,
@@ -11837,7 +12302,11 @@ function accelerated(acc) {
     breadthFirstSearch: (s, source, options) => acc?.breadthFirstSearch !== void 0 ? acc.breadthFirstSearch(s, source, options) : Promise.resolve(breadthFirstSearch(s, source, options)),
     connectedComponents: (s) => acc?.connectedComponents !== void 0 ? acc.connectedComponents(s) : Promise.resolve(connectedComponents(s)),
     weaklyConnectedComponents: (s) => acc?.weaklyConnectedComponents !== void 0 ? acc.weaklyConnectedComponents(s) : Promise.resolve(weaklyConnectedComponents(s)),
-    minimumSpanningTree: (s, options) => acc?.minimumSpanningTree !== void 0 ? acc.minimumSpanningTree(s, options) : Promise.resolve(kruskalMST(s, options))
+    minimumSpanningTree: (s, options) => acc?.minimumSpanningTree !== void 0 ? acc.minimumSpanningTree(s, options) : Promise.resolve(kruskalMST(s, options)),
+    kCoreDecomposition: (s) => acc?.kCoreDecomposition !== void 0 ? acc.kCoreDecomposition(s) : Promise.resolve(kCoreDecomposition(s)),
+    katzCentrality: (s, options) => acc?.katzCentrality !== void 0 ? acc.katzCentrality(s, options) : Promise.resolve(katzCentrality(s, options)),
+    hits: (s, options) => acc?.hits !== void 0 ? acc.hits(s, options) : Promise.resolve(hits(s, options)),
+    louvain: (s, options) => acc?.louvain !== void 0 ? acc.louvain(s, options) : Promise.resolve(louvain(s, options))
   };
 }
 export {
@@ -11903,7 +12372,7 @@ export {
   hasNegativeCycle,
   heuristics,
   hierarchicalClustering,
-  hits,
+  hits$1 as hits,
   index as indexed,
   isBipartite,
   isCSRGraph,
@@ -11911,16 +12380,16 @@ export {
   isGraphIsomorphic,
   isStronglyConnected,
   isWeaklyConnected,
-  kCoreDecomposition,
+  kCoreDecomposition$1 as kCoreDecomposition,
   kargerMinCut,
-  katzCentrality,
+  katzCentrality$1 as katzCentrality,
   kruskalMST$1 as kruskalMST,
   labelPropagation,
   labelPropagationAsync,
   labelPropagationSemiSupervised,
   largestConnectedComponent,
   leiden,
-  louvain,
+  louvain$1 as louvain,
   markovClustering,
   maximumBipartiteMatching,
   minSTCut,