@graphty/algorithms 1.7.3 → 1.8.1

package/dist/algorithms.js

@@ -1,3 +1,7 @@
+import { INVALID_INDEX, renumberPartition, GraphBuilder } from "@graphty/graph-format";
+function isMirror(source, target) {
+  return typeof source === typeof target ? source > target : typeof source > typeof target;
+}
 class Graph {
   /**
    * Creates a new Graph instance.
@@ -14,6 +18,7 @@ class Graph {
     this.adjacencyList = /* @__PURE__ */ new Map();
     this.incomingEdges = /* @__PURE__ */ new Map();
     this.edgeCount = 0;
+    this.mutations = 0;
   }
   /**
    * Add a node to the graph
@@ -27,6 +32,7 @@ class Graph {
       if (this.config.directed) {
         this.incomingEdges.set(id, /* @__PURE__ */ new Map());
       }
+      this.mutations++;
     }
   }
   /**
@@ -63,6 +69,7 @@ class Graph {
     if (this.config.directed) {
       this.incomingEdges.delete(id);
     }
+    this.mutations++;
     return true;
   }
   /**
@@ -101,6 +108,7 @@ class Graph {
       }
     }
     this.edgeCount++;
+    this.mutations++;
   }
   /**
    * Remove an edge from the graph
@@ -126,6 +134,7 @@ class Graph {
       }
     }
     this.edgeCount--;
+    this.mutations++;
     return true;
   }
   /**
@@ -171,6 +180,17 @@ class Graph {
   get nodeCount() {
     return this.nodeMap.size;
   }
+  /**
+   * A counter that increases on every topology change (`addNode` of a new id, `removeNode`,
+   * `addEdge`, `removeEdge`, `clear`) and never on a read. Callers memoise derived structures on
+   * `(graph, mutationCount)`; graph-format design 14.1 rule 4 names this counter, and `toSnapshot`
+   * is its first consumer. It is monotone and is NOT reset by `clear()`: a reset could hand a
+   * stale cache entry a matching key.
+   * @returns The number of topology changes made to this graph
+   */
+  get mutationCount() {
+    return this.mutations;
+  }
   /**
    * Get the number of edges in the graph
    * @returns The total count of edges
@@ -199,7 +219,7 @@ class Graph {
   *edges() {
     for (const [source, edges] of this.adjacencyList) {
       for (const edge of edges.values()) {
-        if (!this.config.directed && source > edge.target) {
+        if (!this.config.directed && isMirror(source, edge.target)) {
           continue;
         }
         yield edge;
@@ -297,6 +317,7 @@ class Graph {
     this.adjacencyList.clear();
     this.incomingEdges.clear();
     this.edgeCount = 0;
+    this.mutations++;
   }
   /**
    * Get the number of unique edges in the graph
@@ -425,39 +446,39 @@ function requireSparseTypedFastBitSet() {
         }
         return newWords;
       };
-      SparseTypedFastBitSet2.prototype.add = function(index) {
-        var type = this.resize(index);
+      SparseTypedFastBitSet2.prototype.add = function(index2) {
+        var type = this.resize(index2);
         if (type === Type.ARRAY) {
           var array = this.data;
           if (this.arraySize === 0) {
-            array[this.arraySize++] = index;
+            array[this.arraySize++] = index2;
             return;
           }
-          var offset = array.indexOf(index);
+          var offset = array.indexOf(index2);
           if (offset === -1 || offset >= this.arraySize) {
             var biggest = array[0];
-            if (index > biggest) {
-              array[0] = index;
+            if (index2 > biggest) {
+              array[0] = index2;
               array[this.arraySize++] = biggest;
             } else {
-              array[this.arraySize++] = index;
+              array[this.arraySize++] = index2;
             }
           }
         } else {
-          this.data[index >>> 5] |= 1 << index;
+          this.data[index2 >>> 5] |= 1 << index2;
         }
       };
-      SparseTypedFastBitSet2.prototype.flip = function(index) {
-        var type = this.resize(index);
+      SparseTypedFastBitSet2.prototype.flip = function(index2) {
+        var type = this.resize(index2);
         if (type === Type.ARRAY) {
           var array = this.data;
-          var arrayIndex = array.indexOf(index);
+          var arrayIndex = array.indexOf(index2);
           if (arrayIndex === -1) {
-            if (this.arraySize > 0 && index > array[0]) {
+            if (this.arraySize > 0 && index2 > array[0]) {
               array[this.arraySize++] = array[0];
-              array[0] = index;
+              array[0] = index2;
             } else {
-              array[this.arraySize++] = index;
+              array[this.arraySize++] = index2;
             }
           } else {
             if (arrayIndex === 0 && this.arraySize > 1) {
@@ -476,18 +497,18 @@ function requireSparseTypedFastBitSet() {
             }
           }
         } else {
-          this.data[index >>> 5] ^= 1 << index;
+          this.data[index2 >>> 5] ^= 1 << index2;
         }
       };
       SparseTypedFastBitSet2.prototype.clear = function() {
         this.arraySize = 0;
         this.data = new Uint32Array(8);
       };
-      SparseTypedFastBitSet2.prototype.remove = function(index) {
-        var type = this.resize(index);
+      SparseTypedFastBitSet2.prototype.remove = function(index2) {
+        var type = this.resize(index2);
         if (type === Type.ARRAY) {
           var array = this.data;
-          var arrayIndex = array.indexOf(index);
+          var arrayIndex = array.indexOf(index2);
           if (arrayIndex !== -1 && arrayIndex < this.arraySize) {
             if (arrayIndex == this.arraySize - 1) {
               this.arraySize--;
@@ -507,7 +528,7 @@ function requireSparseTypedFastBitSet() {
             }
           }
         } else {
-          this.data[index >>> 5] &= ~(1 << index);
+          this.data[index2 >>> 5] &= ~(1 << index2);
         }
       };
       SparseTypedFastBitSet2.prototype.addRange = function(start, end) {
@@ -609,40 +630,40 @@ function requireSparseTypedFastBitSet() {
         }
         return true;
       };
-      SparseTypedFastBitSet2.prototype.has = function(index) {
+      SparseTypedFastBitSet2.prototype.has = function(index2) {
         if (this.arraySize === -1) {
-          return (this.data[index >>> 5] & 1 << index) !== 0;
+          return (this.data[index2 >>> 5] & 1 << index2) !== 0;
         } else {
-          var offset = this.data.indexOf(index);
+          var offset = this.data.indexOf(index2);
           return offset !== -1 && offset < this.arraySize;
         }
       };
-      SparseTypedFastBitSet2.prototype.checkedAdd = function(index) {
-        var type = this.resize(index);
+      SparseTypedFastBitSet2.prototype.checkedAdd = function(index2) {
+        var type = this.resize(index2);
         if (type === Type.ARRAY) {
           var array = this.data;
           if (this.arraySize === 0) {
-            array[this.arraySize++] = index;
+            array[this.arraySize++] = index2;
             return 1;
           }
-          var offset = array.indexOf(index);
+          var offset = array.indexOf(index2);
           if (offset === -1 || offset >= this.arraySize) {
             var biggest = array[0];
-            if (index > biggest) {
-              array[0] = index;
+            if (index2 > biggest) {
+              array[0] = index2;
               array[this.arraySize++] = biggest;
             } else {
-              array[this.arraySize++] = index;
+              array[this.arraySize++] = index2;
             }
             return 1;
           }
           return 0;
         } else {
           var words = this.data;
-          var word = words[index >>> 5];
-          var newword = word | 1 << index;
-          words[index >>> 5] = newword;
-          return (newword ^ word) >>> index;
+          var word = words[index2 >>> 5];
+          var newword = word | 1 << index2;
+          words[index2 >>> 5] = newword;
+          return (newword ^ word) >>> index2;
         }
       };
       SparseTypedFastBitSet2.prototype.trim = function() {
@@ -688,15 +709,15 @@ function requireSparseTypedFastBitSet() {
           }
         }
       };
-      SparseTypedFastBitSet2.prototype.resize = function(index, capacity) {
+      SparseTypedFastBitSet2.prototype.resize = function(index2, capacity) {
         if (capacity === void 0) {
           capacity = 0;
         }
         if (this.arraySize === -1) {
           var words = this.data;
-          if (words.length << 5 > index)
+          if (words.length << 5 > index2)
             return Type.BITSET;
-          var count = index + 32 >>> 5;
+          var count = index2 + 32 >>> 5;
           var newwords = new Uint32Array(count << 1);
           newwords.set(words);
           this.data = newwords;
@@ -712,7 +733,7 @@ function requireSparseTypedFastBitSet() {
             this.data = newData;
             return Type.ARRAY;
           } else {
-            var count = Math.max(array[0], index) + 32 >>> 5;
+            var count = Math.max(array[0], index2) + 32 >>> 5;
             if (count > array.length + capacity && array.length + capacity << 1 < 1024) {
               var newData = new Uint32Array(array.length + capacity << 1);
               newData.set(array);
@@ -904,13 +925,13 @@ function requireSparseTypedFastBitSet() {
             var otherArray = otherbitmap.data;
             var newSize = 0;
             for (var i = 0; i < otherbitmap.arraySize; i++) {
-              var index = otherArray[i];
-              if (this.has(index)) {
-                if (newSize > 0 && index > newWord[0]) {
+              var index2 = otherArray[i];
+              if (this.has(index2)) {
+                if (newSize > 0 && index2 > newWord[0]) {
                   newWord[newSize++] = newWord[0];
-                  newWord[0] = index;
+                  newWord[0] = index2;
                 } else {
-                  newWord[newSize++] = index;
+                  newWord[newSize++] = index2;
                 }
               }
             }
@@ -992,13 +1013,13 @@ function requireSparseTypedFastBitSet() {
             var newSize = 0;
             var array = order.first.data;
             for (var i = 0; i < order.first.arraySize; i++) {
-              var index = array[i];
-              if (order.second.has(index)) {
-                if (newSize > 0 && index > newArray[0]) {
+              var index2 = array[i];
+              if (order.second.has(index2)) {
+                if (newSize > 0 && index2 > newArray[0]) {
                   newArray[newSize++] = newArray[0];
-                  newArray[0] = index;
+                  newArray[0] = index2;
                 } else {
-                  newArray[newSize++] = index;
+                  newArray[newSize++] = index2;
                 }
               }
             }
@@ -1076,9 +1097,9 @@ function requireSparseTypedFastBitSet() {
           } else {
             var otherArray = otherbitmap.data;
             for (var i = 0; i < otherbitmap.arraySize; i++) {
-              var index = otherArray[i];
-              if (this.has(index)) {
-                this.remove(index);
+              var index2 = otherArray[i];
+              if (this.has(index2)) {
+                this.remove(index2);
               }
             }
             return this;
@@ -1188,8 +1209,8 @@ function requireSparseTypedFastBitSet() {
             var answer = this.size();
             var otherArray = otherbitmap.data;
             for (var i = 0; i < otherbitmap.arraySize; i++) {
-              var index = otherArray[i];
-              if (this.has(index)) {
+              var index2 = otherArray[i];
+              if (this.has(index2)) {
                 answer--;
               }
             }
@@ -1236,11 +1257,11 @@ function requireSparseTypedFastBitSet() {
             this.resize(otherArray[0]);
             var words = this.words;
             for (var i = 0; i < otherbitmap.arraySize; i++) {
-              var index = otherArray[i];
-              if ((words[index >>> 5] & 1 << index) !== 0) {
-                words[index >>> 5] &= ~(1 << index);
+              var index2 = otherArray[i];
+              if ((words[index2 >>> 5] & 1 << index2) !== 0) {
+                words[index2 >>> 5] &= ~(1 << index2);
               } else {
-                words[index >>> 5] |= 1 << index;
+                words[index2 >>> 5] |= 1 << index2;
               }
             }
             return this;
@@ -1253,11 +1274,11 @@ function requireSparseTypedFastBitSet() {
             words.set(otherbitmap.words);
             var array = this.data;
             for (var i = 0; i < this.arraySize; i++) {
-              var index = array[i];
-              if ((words[index >>> 5] & 1 << index) !== 0) {
-                words[index >>> 5] &= ~(1 << index);
+              var index2 = array[i];
+              if ((words[index2 >>> 5] & 1 << index2) !== 0) {
+                words[index2 >>> 5] &= ~(1 << index2);
               } else {
-                words[index >>> 5] |= 1 << index;
+                words[index2 >>> 5] |= 1 << index2;
               }
             }
             this.data = words;
@@ -1265,11 +1286,11 @@ function requireSparseTypedFastBitSet() {
           } else {
             var otherArray = otherbitmap.data;
             for (var i = 0; i < otherbitmap.arraySize; i++) {
-              var index = otherArray[i];
-              if (this.has(index)) {
-                this.remove(index);
+              var index2 = otherArray[i];
+              if (this.has(index2)) {
+                this.remove(index2);
               } else {
-                this.add(index);
+                this.add(index2);
               }
             }
           }
@@ -1315,11 +1336,11 @@ function requireSparseTypedFastBitSet() {
             words.set(order.second.words);
             var array = order.first.data;
             for (var i = 0; i < order.first.arraySize; i++) {
-              var index = array[i];
-              if ((words[index >>> 5] & 1 << index) !== 0) {
-                words[index >>> 5] &= ~(1 << index);
+              var index2 = array[i];
+              if ((words[index2 >>> 5] & 1 << index2) !== 0) {
+                words[index2 >>> 5] &= ~(1 << index2);
               } else {
-                words[index >>> 5] |= 1 << index;
+                words[index2 >>> 5] |= 1 << index2;
               }
             }
             var answer = new SparseTypedFastBitSet2(void 0, words);
@@ -1332,12 +1353,12 @@ function requireSparseTypedFastBitSet() {
             var newSize = order.second.arraySize;
             var array = order.first.data;
             for (var i = 0; i < order.first.arraySize; i++) {
-              var index = array[i];
-              var offset = newArray.indexOf(index);
+              var index2 = array[i];
+              var offset = newArray.indexOf(index2);
               if (offset !== -1 && offset < newSize) {
                 newArray[offset] = newArray[--newSize];
               } else {
-                newArray[newSize++] = index;
+                newArray[newSize++] = index2;
               }
             }
             if (newSize > 1) {
@@ -1382,8 +1403,8 @@ function requireSparseTypedFastBitSet() {
             var array = order.first.data;
             var answer = order.second.size();
             for (var i = 0; i < order.first.arraySize; i++) {
-              var index = array[i];
-              if (order.second.has(index)) {
+              var index2 = array[i];
+              if (order.second.has(index2)) {
                 answer--;
               } else {
                 answer++;
@@ -1395,8 +1416,8 @@ function requireSparseTypedFastBitSet() {
             var answer = order.second.arraySize;
             var array = order.first.data;
             for (var i = 0; i < order.first.arraySize; i++) {
-              var index = array[i];
-              if (order.second.has(index)) {
+              var index2 = array[i];
+              if (order.second.has(index2)) {
                 answer--;
               } else {
                 answer++;
@@ -1444,8 +1465,8 @@ function requireSparseTypedFastBitSet() {
         } else {
           var otherArray = otherbitmap.data;
           for (var i = 0; i < otherbitmap.arraySize; i++) {
-            var index = otherArray[i];
-            this.add(index);
+            var index2 = otherArray[i];
+            this.add(index2);
           }
           return this;
         }
@@ -1477,8 +1498,8 @@ function requireSparseTypedFastBitSet() {
           var answer = this.clone();
           var otherArray = otherbitmap.data;
           for (var i = 0; i < otherbitmap.arraySize; i++) {
-            var index = otherArray[i];
-            answer.add(index);
+            var index2 = otherArray[i];
+            answer.add(index2);
           }
           return answer;
         }
@@ -1619,20 +1640,20 @@ function requireTypedFastBitSet() {
       TypedFastBitSet2.fromWords = function(words) {
         return new TypedFastBitSet2(void 0, words);
       };
-      TypedFastBitSet2.prototype.add = function(index) {
-        this.resize(index);
-        this.words[index >>> 5] |= 1 << index;
+      TypedFastBitSet2.prototype.add = function(index2) {
+        this.resize(index2);
+        this.words[index2 >>> 5] |= 1 << index2;
       };
-      TypedFastBitSet2.prototype.flip = function(index) {
-        this.resize(index);
-        this.words[index >>> 5] ^= 1 << index;
+      TypedFastBitSet2.prototype.flip = function(index2) {
+        this.resize(index2);
+        this.words[index2 >>> 5] ^= 1 << index2;
       };
       TypedFastBitSet2.prototype.clear = function() {
         this.words = new Uint32Array(8);
       };
-      TypedFastBitSet2.prototype.remove = function(index) {
-        this.resize(index);
-        this.words[index >>> 5] &= ~(1 << index);
+      TypedFastBitSet2.prototype.remove = function(index2) {
+        this.resize(index2);
+        this.words[index2 >>> 5] &= ~(1 << index2);
       };
       TypedFastBitSet2.prototype.addRange = function(start, end) {
         if (start >= end) {
@@ -1678,8 +1699,8 @@ function requireTypedFastBitSet() {
         }
         return true;
       };
-      TypedFastBitSet2.prototype.has = function(index) {
-        return (this.words[index >>> 5] & 1 << index) !== 0;
+      TypedFastBitSet2.prototype.has = function(index2) {
+        return (this.words[index2 >>> 5] & 1 << index2) !== 0;
       };
       TypedFastBitSet2.prototype.hasAnyInRange = function(start, end) {
         if (start >= end)
@@ -1693,18 +1714,18 @@ function requireTypedFastBitSet() {
           return (words[firstword] & (-1 << start & -1 >>> -end)) !== 0;
         if ((words[firstword] & -1 << start) !== 0)
           return true;
-        for (var index = firstword + 1; index < endword - 1; index++)
-          if (words[index] !== 0)
+        for (var index2 = firstword + 1; index2 < endword - 1; index2++)
+          if (words[index2] !== 0)
             return true;
         return (words[endword] & -1 >>> -end) !== 0;
       };
-      TypedFastBitSet2.prototype.checkedAdd = function(index) {
+      TypedFastBitSet2.prototype.checkedAdd = function(index2) {
         var words = this.words;
-        this.resize(index);
-        var word = words[index >>> 5];
-        var newword = word | 1 << index;
-        words[index >>> 5] = newword;
-        return (newword ^ word) >>> index;
+        this.resize(index2);
+        var word = words[index2 >>> 5];
+        var newword = word | 1 << index2;
+        words[index2 >>> 5] = newword;
+        return (newword ^ word) >>> index2;
       };
       TypedFastBitSet2.prototype.trim = function() {
         var words = this.words;
@@ -1714,11 +1735,11 @@ function requireTypedFastBitSet() {
         }
         this.words = words.slice(0, nl);
       };
-      TypedFastBitSet2.prototype.resize = function(index) {
+      TypedFastBitSet2.prototype.resize = function(index2) {
         var words = this.words;
-        if (words.length << 5 > index)
+        if (words.length << 5 > index2)
           return;
-        var count = index + 32 >>> 5;
+        var count = index2 + 32 >>> 5;
         var newwords = new Uint32Array(count << 1);
         newwords.set(words);
         this.words = newwords;
@@ -2133,9 +2154,9 @@ class GraphBitSet {
    * Add a single element to the set.
    * @param index - The element index to add
    */
-  add(index) {
-    if (!this.bitset.has(index)) {
-      this.bitset.add(index);
+  add(index2) {
+    if (!this.bitset.has(index2)) {
+      this.bitset.add(index2);
       this._cardinality++;
     }
   }
@@ -2143,9 +2164,9 @@ class GraphBitSet {
    * Remove a single element from the set.
    * @param index - The element index to remove
    */
-  remove(index) {
-    if (this.bitset.has(index)) {
-      this.bitset.remove(index);
+  remove(index2) {
+    if (this.bitset.has(index2)) {
+      this.bitset.remove(index2);
       this._cardinality--;
     }
   }
@@ -2154,8 +2175,8 @@ class GraphBitSet {
    * @param index - The element index to check
    * @returns True if the element exists, false otherwise
    */
-  has(index) {
-    return this.bitset.has(index);
+  has(index2) {
+    return this.bitset.has(index2);
   }
   /**
    * Clear all elements
@@ -2261,12 +2282,12 @@ class VisitedBitArray {
    * Set bit at the specified index.
    * @param index - The bit index to set
    */
-  set(index) {
-    if (index < 0 || index >= this._size) {
-      throw new Error(`Index ${String(index)} out of bounds [0, ${String(this._size)})`);
+  set(index2) {
+    if (index2 < 0 || index2 >= this._size) {
+      throw new Error(`Index ${String(index2)} out of bounds [0, ${String(this._size)})`);
     }
-    const wordIndex = index >>> 5;
-    const bitIndex = index & 31;
+    const wordIndex = index2 >>> 5;
+    const bitIndex = index2 & 31;
     const word = this.words[wordIndex];
     if (word !== void 0) {
       this.words[wordIndex] = word | 1 << bitIndex;
@@ -2277,12 +2298,12 @@ class VisitedBitArray {
    * @param index - The bit index to get
    * @returns True if the bit is set, false otherwise
    */
-  get(index) {
-    if (index < 0 || index >= this._size) {
+  get(index2) {
+    if (index2 < 0 || index2 >= this._size) {
       return false;
     }
-    const wordIndex = index >>> 5;
-    const bitIndex = index & 31;
+    const wordIndex = index2 >>> 5;
+    const bitIndex = index2 & 31;
     const word = this.words[wordIndex];
     return word !== void 0 && (word & 1 << bitIndex) !== 0;
   }
@@ -2296,12 +2317,12 @@ class VisitedBitArray {
    * Toggle bit at the specified index.
    * @param index - The bit index to toggle
    */
-  toggle(index) {
-    if (index < 0 || index >= this._size) {
-      throw new Error(`Index ${String(index)} out of bounds [0, ${String(this._size)})`);
+  toggle(index2) {
+    if (index2 < 0 || index2 >= this._size) {
+      throw new Error(`Index ${String(index2)} out of bounds [0, ${String(this._size)})`);
     }
-    const wordIndex = index >>> 5;
-    const bitIndex = index & 31;
+    const wordIndex = index2 >>> 5;
+    const bitIndex = index2 & 31;
     const word = this.words[wordIndex];
     if (word !== void 0) {
       this.words[wordIndex] = word ^ 1 << bitIndex;
@@ -2357,8 +2378,8 @@ class VisitedBitArray {
    * @param indices - Array of bit indices to set
    */
   setMultiple(indices) {
-    for (const index of indices) {
-      this.set(index);
+    for (const index2 of indices) {
+      this.set(index2);
     }
   }
   /**
@@ -2374,9 +2395,9 @@ class VisitedBitArray {
       }
       for (let bitIndex = 0; bitIndex < 32; bitIndex++) {
         if (word & 1 << bitIndex) {
-          const index = (wordIndex << 5) + bitIndex;
-          if (index < this._size) {
-            indices.push(index);
+          const index2 = (wordIndex << 5) + bitIndex;
+          if (index2 < this._size) {
+            indices.push(index2);
           }
         }
       }
@@ -2399,19 +2420,19 @@ const _CompactDistanceArray = class _CompactDistanceArray {
    * @param index - The node index to set the distance for
    * @param distance - The distance value to set
    */
-  set(index, distance) {
+  set(index2, distance) {
     if (distance >= _CompactDistanceArray.INFINITY) {
       throw new Error(`Distance exceeds maximum value (${String(_CompactDistanceArray.INFINITY - 1)})`);
     }
-    this.data[index] = distance;
+    this.data[index2] = distance;
   }
   /**
    * Get distance at the specified index.
    * @param index - The node index to get the distance for
    * @returns The distance value, or INFINITY if not set
    */
-  get(index) {
-    const value = this.data[index];
+  get(index2) {
+    const value = this.data[index2];
     return value ?? _CompactDistanceArray.INFINITY;
   }
   /**
@@ -2419,8 +2440,8 @@ const _CompactDistanceArray = class _CompactDistanceArray {
    * @param index - The node index to check
    * @returns True if the node has been visited, false otherwise
    */
-  isVisited(index) {
-    return this.data[index] !== _CompactDistanceArray.INFINITY;
+  isVisited(index2) {
+    return this.data[index2] !== _CompactDistanceArray.INFINITY;
   }
   /**
    * Reset all distances to unvisited state.
@@ -2659,9 +2680,9 @@ class CSRGraph {
     const nodeCount = nodes.length;
     const nodeIdToIndex = /* @__PURE__ */ new Map();
     const indexToNodeId = [];
-    nodes.forEach((nodeId, index) => {
-      nodeIdToIndex.set(nodeId, index);
-      indexToNodeId[index] = nodeId;
+    nodes.forEach((nodeId, index2) => {
+      nodeIdToIndex.set(nodeId, index2);
+      indexToNodeId[index2] = nodeId;
     });
     let edgeCount = 0;
     for (const neighbors of adjacencyList.values()) {
@@ -2679,11 +2700,11 @@ class CSRGraph {
       }
       const neighbors = adjacencyList.get(nodeId) ?? [];
       const sortedNeighbors = neighbors.map((n) => {
-        const index = nodeIdToIndex.get(n);
-        if (index === void 0) {
+        const index2 = nodeIdToIndex.get(n);
+        if (index2 === void 0) {
           throw new Error(`Node ${String(n)} not found in nodeIdToIndex map`);
         }
-        return { id: n, index };
+        return { id: n, index: index2 };
       }).sort((a, b) => a.index - b.index);
       for (const neighbor of sortedNeighbors) {
         columnIndices[currentEdge] = neighbor.index;
@@ -2904,21 +2925,21 @@ class CSRGraph {
    * @returns The internal index for the node
    */
   nodeToIndex(nodeId) {
-    const index = this.data.nodeIdToIndex.get(nodeId);
-    if (index === void 0) {
+    const index2 = this.data.nodeIdToIndex.get(nodeId);
+    if (index2 === void 0) {
       throw new Error(`Node ${String(nodeId)} not found in graph`);
     }
-    return index;
+    return index2;
   }
   /**
    * Convert internal index to node ID.
    * @param index - The internal index to convert
    * @returns The node ID for the given index
    */
-  indexToNodeId(index) {
-    const nodeId = this.data.indexToNodeId[index];
+  indexToNodeId(index2) {
+    const nodeId = this.data.indexToNodeId[index2];
     if (nodeId === void 0) {
-      throw new Error(`Index ${String(index)} out of bounds`);
+      throw new Error(`Index ${String(index2)} out of bounds`);
     }
     return nodeId;
   }
@@ -3198,7 +3219,7 @@ function getCSRGraph(graph) {
   }
   return csrGraph;
 }
-function breadthFirstSearch(graph, startNode, options = {}) {
+function breadthFirstSearch$1(graph, startNode, options = {}) {
   if (!graph.hasNode(startNode)) {
     throw new Error(`Start node ${String(startNode)} not found in graph`);
   }
@@ -3799,20 +3820,20 @@ class PriorityQueue {
    * @returns True if the item was found and updated, false otherwise
    */
   updatePriority(item, newPriority) {
-    const index = this.heap.findIndex((element2) => element2.item === item);
-    if (index === -1) {
+    const index2 = this.heap.findIndex((element2) => element2.item === item);
+    if (index2 === -1) {
       return false;
     }
-    const element = this.heap[index];
+    const element = this.heap[index2];
     if (!element) {
       return false;
     }
     const oldPriority = element.priority;
     element.priority = newPriority;
     if (this.compareFn(newPriority, oldPriority) < 0) {
-      this.heapifyUp(index);
+      this.heapifyUp(index2);
     } else if (this.compareFn(newPriority, oldPriority) > 0) {
-      this.heapifyDown(index);
+      this.heapifyDown(index2);
     }
     return true;
   }
@@ -3833,15 +3854,15 @@ class PriorityQueue {
    * Move element up the heap until heap property is satisfied
    * @param index - The index of the element to heapify up
    */
-  heapifyUp(index) {
-    if (index === 0) {
+  heapifyUp(index2) {
+    if (index2 === 0) {
       return;
     }
-    const parentIndex = Math.floor((index - 1) / 2);
-    const current = this.heap[index];
+    const parentIndex = Math.floor((index2 - 1) / 2);
+    const current = this.heap[index2];
     const parent = this.heap[parentIndex];
     if (current && parent && this.compareFn(current.priority, parent.priority) < 0) {
-      this.swap(index, parentIndex);
+      this.swap(index2, parentIndex);
       this.heapifyUp(parentIndex);
     }
   }
@@ -3849,10 +3870,10 @@ class PriorityQueue {
    * Move element down the heap until heap property is satisfied
    * @param index - The index of the element to heapify down
    */
-  heapifyDown(index) {
-    const leftChildIndex = 2 * index + 1;
-    const rightChildIndex = 2 * index + 2;
-    let targetIndex = index;
+  heapifyDown(index2) {
+    const leftChildIndex = 2 * index2 + 1;
+    const rightChildIndex = 2 * index2 + 2;
+    let targetIndex = index2;
     const leftChild = this.heap[leftChildIndex];
     const target = this.heap[targetIndex];
     if (leftChildIndex < this.heap.length && leftChild && target && this.compareFn(leftChild.priority, target.priority) < 0) {
@@ -3863,8 +3884,8 @@ class PriorityQueue {
     if (rightChildIndex < this.heap.length && rightChild && newTarget && this.compareFn(rightChild.priority, newTarget.priority) < 0) {
       targetIndex = rightChildIndex;
     }
-    if (targetIndex !== index) {
-      this.swap(index, targetIndex);
+    if (targetIndex !== index2) {
+      this.swap(index2, targetIndex);
       this.heapifyDown(targetIndex);
     }
   }
@@ -4041,7 +4062,7 @@ class BidirectionalDijkstra {
     this.shortestDistance = Infinity;
   }
 }
-function dijkstra(graph, source, options = {}) {
+function dijkstra$1(graph, source, options = {}) {
   if (!graph.hasNode(source)) {
     throw new Error(`Source node ${String(source)} not found in graph`);
   }
@@ -4130,7 +4151,7 @@ function dijkstraPath(graph, source, target, options = {}) {
     const biDijkstra = new BidirectionalDijkstra(graph);
     return biDijkstra.findShortestPath(source, target);
   }
-  const results = dijkstra(graph, source, { target });
+  const results = dijkstra$1(graph, source, { target });
   return results.get(target) ?? null;
 }
 function singleSourceShortestPath(graph, source, cutoff) {
@@ -4619,6 +4640,13 @@ function bfsWeightedDistancesCSR(graph, source, cutoff) {
   }
   return distances;
 }
+function rejectIndexOptions(options, fn) {
+  if (options.sources !== void 0 || options.k !== void 0) {
+    throw new Error(
+      `${fn}: 'sources' and 'k' are node INDICES and are meaningful only against a GraphSnapshot; call accelerated(accelerator).betweennessCentrality(snapshot, options) instead`
+    );
+  }
+}
 function brandesSingleSource(graph, source, optimized) {
   const result = bfsWithPathCounting(graph, source, optimized !== void 0 ? { optimized } : {});
   return {
@@ -4708,6 +4736,7 @@ function normalizeCentrality(centrality, nodeCount, isDirected) {
   }
 }
 function betweennessCentrality(graph, options = {}) {
+  rejectIndexOptions(options, "betweennessCentrality");
   const nodes = Array.from(graph.nodes()).map((node) => node.id);
   const centrality = {};
   for (const nodeId of nodes) {
@@ -4732,6 +4761,7 @@ function betweennessCentrality(graph, options = {}) {
   return centrality;
 }
 function nodeBetweennessCentrality(graph, targetNode, options = {}) {
+  rejectIndexOptions(options, "nodeBetweennessCentrality");
   if (!graph.hasNode(targetNode)) {
     throw new Error(`Node ${String(targetNode)} not found in graph`);
   }
@@ -4739,6 +4769,7 @@ function nodeBetweennessCentrality(graph, targetNode, options = {}) {
   return allCentralities[String(targetNode)] ?? 0;
 }
 function edgeBetweennessCentrality(graph, options = {}) {
+  rejectIndexOptions(options, "edgeBetweennessCentrality");
   const nodes = Array.from(graph.nodes()).map((node) => node.id);
   const edgeCentrality = /* @__PURE__ */ new Map();
   for (const edge of Array.from(graph.edges())) {
@@ -5733,7 +5764,7 @@ class SimpleDeltaPageRank {
     }
   }
 }
-function pageRank(graph, options = {}) {
+function pageRank$1(graph, options = {}) {
   const {
     dampingFactor = 0.85,
     maxIterations = 100,
@@ -5884,7 +5915,7 @@ function pageRank(graph, options = {}) {
 }
 function personalizedPageRank(graph, personalNodes, options = {}) {
   if (personalNodes.length === 0) {
-    return pageRank(graph, options);
+    return pageRank$1(graph, options);
   }
   const nodes = Array.from(graph.nodes()).map((node) => node.id);
   const personalization = /* @__PURE__ */ new Map();
@@ -5898,17 +5929,17 @@ function personalizedPageRank(graph, personalNodes, options = {}) {
     }
     personalization.set(personalNode, personalValue);
   }
-  return pageRank(graph, {
+  return pageRank$1(graph, {
     ...options,
     personalization
   });
 }
 function pageRankCentrality(graph, options = {}) {
-  const result = pageRank(graph, options);
+  const result = pageRank$1(graph, options);
   return result.ranks;
 }
 function topPageRankNodes(graph, k, options = {}) {
-  const result = pageRank(graph, options);
+  const result = pageRank$1(graph, options);
   const nodeRanks = [];
   for (const [nodeStr, rank] of Object.entries(result.ranks)) {
     nodeRanks.push({ node: nodeStr, rank });
@@ -6075,7 +6106,7 @@ class UnionFind {
     return this.parent.size;
   }
 }
-function connectedComponents(graph) {
+function connectedComponents$1(graph) {
   if (graph.isDirected) {
     throw new Error(
       "Connected components algorithm requires an undirected graph. Use stronglyConnectedComponents for directed graphs."
@@ -6116,13 +6147,13 @@ function dfsComponent(graph, nodeId, visited, component) {
   }
 }
 function numberOfConnectedComponents(graph) {
-  return connectedComponents(graph).length;
+  return connectedComponents$1(graph).length;
 }
 function isConnected(graph) {
   return numberOfConnectedComponents(graph) <= 1;
 }
 function largestConnectedComponent(graph) {
-  const components = connectedComponents(graph);
+  const components = connectedComponents$1(graph);
   if (components.length === 0) {
     return [];
   }
@@ -6150,11 +6181,11 @@ function stronglyConnectedComponents(graph) {
   const lowLinks = /* @__PURE__ */ new Map();
   const onStack = /* @__PURE__ */ new Set();
   const stack = [];
-  let index = 0;
+  let index2 = 0;
   function tarjanSCC(nodeId) {
-    indices.set(nodeId, index);
-    lowLinks.set(nodeId, index);
-    index++;
+    indices.set(nodeId, index2);
+    lowLinks.set(nodeId, index2);
+    index2++;
     stack.push(nodeId);
     onStack.add(nodeId);
     for (const neighbor of Array.from(graph.neighbors(nodeId))) {
@@ -6200,7 +6231,7 @@ function isStronglyConnected(graph) {
   const components = stronglyConnectedComponents(graph);
   return components.length <= 1;
 }
-function weaklyConnectedComponents(graph) {
+function weaklyConnectedComponents$1(graph) {
   if (!graph.isDirected) {
     throw new Error(
       "Weakly connected components are for directed graphs. Use connectedComponents for undirected graphs."
@@ -6220,7 +6251,7 @@ function isWeaklyConnected(graph) {
   if (!graph.isDirected) {
     throw new Error("Weak connectivity check requires a directed graph");
   }
-  return weaklyConnectedComponents(graph).length <= 1;
+  return weaklyConnectedComponents$1(graph).length <= 1;
 }
 function condensationGraph(graph) {
   if (!graph.isDirected) {
@@ -6256,7 +6287,7 @@ function condensationGraph(graph) {
     components
   };
 }
-function kruskalMST(graph) {
+function kruskalMST$1(graph) {
   if (graph.isDirected) {
     throw new Error("Kruskal's algorithm requires an undirected graph");
   }
@@ -6293,7 +6324,7 @@ function kruskalMST(graph) {
   };
 }
 function minimumSpanningTree(graph) {
-  return kruskalMST(graph);
+  return kruskalMST$1(graph);
 }
 function primMST(graph, startNode) {
   if (graph.isDirected) {
@@ -6564,11 +6595,11 @@ function getNodeDegree$1(graph, nodeId) {
   return degree;
 }
 function getConnectedComponentsResult(graph) {
-  const components = connectedComponents(graph);
+  const components = connectedComponents$1(graph);
   const componentMap = /* @__PURE__ */ new Map();
-  components.forEach((component, index) => {
+  components.forEach((component, index2) => {
     component.forEach((nodeId) => {
-      componentMap.set(nodeId, index);
+      componentMap.set(nodeId, index2);
     });
   });
   return { components, componentMap };
@@ -6703,8 +6734,8 @@ function labelPropagationImpl(graph, options = {}) {
         if (labelCounts.get(currentLabel) === maxCount) {
           candidateLabels.push(currentLabel);
         }
-        const index = Math.floor(random() * candidateLabels.length);
-        const selectedLabel = candidateLabels[index];
+        const index2 = Math.floor(random() * candidateLabels.length);
+        const selectedLabel = candidateLabels[index2];
         if (selectedLabel !== void 0) {
           newLabel = selectedLabel;
         }
@@ -6860,8 +6891,8 @@ function labelPropagationSemiSupervisedImpl(graph, seedLabels, options = {}) {
       }
       let newLabel = currentLabel;
       if (candidateLabels.length > 0) {
-        const index = Math.floor(random() * candidateLabels.length);
-        const selectedLabel = candidateLabels[index];
+        const index2 = Math.floor(random() * candidateLabels.length);
+        const selectedLabel = candidateLabels[index2];
         if (selectedLabel !== void 0) {
           newLabel = selectedLabel;
         }
@@ -7760,24 +7791,24 @@ class MinPriorityQueue {
       this.heap[j] = temp;
     }
   }
-  heapifyUp(index) {
-    while (index > 0) {
-      const parentIndex = this.parent(index);
-      const current = this.heap[index];
+  heapifyUp(index2) {
+    while (index2 > 0) {
+      const parentIndex = this.parent(index2);
+      const current = this.heap[index2];
       const parent = this.heap[parentIndex];
       if (current !== void 0 && parent !== void 0 && this.compare(current, parent) < 0) {
-        this.swap(index, parentIndex);
-        index = parentIndex;
+        this.swap(index2, parentIndex);
+        index2 = parentIndex;
       } else {
         break;
       }
     }
   }
-  heapifyDown(index) {
-    while (index < this.heap.length) {
-      let minIndex = index;
-      const left = this.leftChild(index);
-      const right = this.rightChild(index);
+  heapifyDown(index2) {
+    while (index2 < this.heap.length) {
+      let minIndex = index2;
+      const left = this.leftChild(index2);
+      const right = this.rightChild(index2);
       const leftItem = this.heap[left];
       const minItem = this.heap[minIndex];
       if (left < this.heap.length && leftItem !== void 0 && minItem !== void 0 && this.compare(leftItem, minItem) < 0) {
@@ -7788,9 +7819,9 @@ class MinPriorityQueue {
       if (right < this.heap.length && rightItem !== void 0 && newMinItem !== void 0 && this.compare(rightItem, newMinItem) < 0) {
         minIndex = right;
       }
-      if (minIndex !== index) {
-        this.swap(index, minIndex);
-        index = minIndex;
+      if (minIndex !== index2) {
+        this.swap(index2, minIndex);
+        index2 = minIndex;
       } else {
         break;
       }
@@ -8451,9 +8482,9 @@ function contractNodes(graph, nodes, s, t) {
   }
   graph.delete(t);
   sNeighbors.delete(t);
-  const index = nodes.indexOf(t);
-  if (index > -1) {
-    nodes.splice(index, 1);
+  const index2 = nodes.indexOf(t);
+  if (index2 > -1) {
+    nodes.splice(index2, 1);
   }
 }
 function makeUndirected(graph) {
@@ -9021,7 +9052,7 @@ function buildTransitionMatrix(graph, nodeIds, selfLoops) {
   const n = nodeIds.length;
   const matrix = Array.from({ length: n }, () => Array(n).fill(0));
   const nodeToIndex = /* @__PURE__ */ new Map();
-  nodeIds.forEach((id, index) => nodeToIndex.set(id, index));
+  nodeIds.forEach((id, index2) => nodeToIndex.set(id, index2));
   for (let i = 0; i < n; i++) {
     const nodeId = nodeIds[i];
     if (nodeId === void 0) {
@@ -9273,9 +9304,9 @@ function calculateMCLModularity(graph, communities) {
   }
   let modularity = 0;
   const communityMap = /* @__PURE__ */ new Map();
-  communities.forEach((community, index) => {
+  communities.forEach((community, index2) => {
     community.forEach((nodeId) => {
-      communityMap.set(nodeId, index);
+      communityMap.set(nodeId, index2);
     });
   });
   for (const edge of graph.edges()) {
@@ -9302,7 +9333,7 @@ function spectralClustering(graph, options) {
   if (k >= n) {
     const communities2 = nodeIds.map((id) => [id]);
     const clusterAssignments2 = /* @__PURE__ */ new Map();
-    nodeIds.forEach((id, index) => clusterAssignments2.set(id, index));
+    nodeIds.forEach((id, index2) => clusterAssignments2.set(id, index2));
     return { communities: communities2, clusterAssignments: clusterAssignments2 };
   }
   const adjacencyMatrix = buildAdjacencyMatrix(graph, nodeIds);
@@ -9357,7 +9388,7 @@ function buildAdjacencyMatrix(graph, nodeIds) {
   const n = nodeIds.length;
   const matrix = Array.from({ length: n }, () => Array(n).fill(0));
   const nodeToIndex = /* @__PURE__ */ new Map();
-  nodeIds.forEach((id, index) => nodeToIndex.set(id, index));
+  nodeIds.forEach((id, index2) => nodeToIndex.set(id, index2));
   for (let i = 0; i < n; i++) {
     const nodeId = nodeIds[i];
     if (!nodeId) {
@@ -10261,7 +10292,7 @@ function compareAdamicAdarWithCommonNeighbors(graph, testEdges, nonEdges, option
     commonNeighbors: commonNeighborsResults
   };
 }
-function commonNeighborsScore(graph, source, target, options = {}) {
+function commonNeighborsScore$1(graph, source, target, options = {}) {
   if (!graph.hasNode(source) || !graph.hasNode(target)) {
     return 0;
   }
@@ -10283,7 +10314,7 @@ function commonNeighborsPrediction(graph, options = {}) {
       if (!includeExisting && graph.hasEdge(source, target)) {
         continue;
       }
-      const score = commonNeighborsScore(graph, source, target, { directed });
+      const score = commonNeighborsScore$1(graph, source, target, { directed });
       if (score > 0) {
         scores.push({ source, target, score });
         if (!directed && source !== target) {
@@ -10302,7 +10333,7 @@ function commonNeighborsForPairs(graph, pairs, options = {}) {
   return pairs.map(([source, target]) => ({
     source,
     target,
-    score: commonNeighborsScore(graph, source, target, options)
+    score: commonNeighborsScore$1(graph, source, target, options)
   }));
 }
 function getTopCandidatesForNode(graph, node, options = {}) {
@@ -10319,7 +10350,7 @@ function getTopCandidatesForNode(graph, node, options = {}) {
     if (!includeExisting && graph.hasEdge(node, target)) {
       continue;
     }
-    const score = commonNeighborsScore(graph, node, target, { directed });
+    const score = commonNeighborsScore$1(graph, node, target, { directed });
     if (score > 0) {
       scores.push({ source: node, target, score });
     }
@@ -11084,7 +11115,7 @@ function spectralBisection(graph, cluster, _numEigenvectors, tolerance, maxItera
   if (!eigenvector) {
     return null;
   }
-  const sortedIndices = eigenvector.map((value, index) => ({ value, index })).sort((a, b) => a.value - b.value);
+  const sortedIndices = eigenvector.map((value, index2) => ({ value, index: index2 })).sort((a, b) => a.value - b.value);
   let bestSplitIndex = Math.floor(n / 2);
   let bestModularity = -Infinity;
   for (let splitIndex = Math.floor(n * 0.2); splitIndex <= Math.floor(n * 0.8); splitIndex++) {
@@ -11301,6 +11332,485 @@ function calculateModularity(graph, assignment) {
   }
   return modularity;
 }
+function breadthFirstSearch(g, start, options = {}) {
+  const { nodeCount, rowPtr, colIdx } = g;
+  const parent = new Uint32Array(nodeCount).fill(INVALID_INDEX);
+  const depth = new Uint32Array(nodeCount).fill(INVALID_INDEX);
+  const order = new Uint32Array(nodeCount);
+  const maxDepth = options.maxDepth ?? INVALID_INDEX;
+  let head = 0;
+  let tail = 0;
+  order[tail++] = start;
+  depth[start] = 0;
+  while (head < tail) {
+    const u = order[head++];
+    const d = depth[u];
+    if (d >= maxDepth) {
+      continue;
+    }
+    const end = rowPtr[u + 1];
+    for (let a = rowPtr[u]; a < end; a++) {
+      const v = colIdx[a];
+      if (depth[v] === INVALID_INDEX) {
+        depth[v] = d + 1;
+        parent[v] = u;
+        order[tail++] = v;
+      }
+    }
+  }
+  return { order: order.subarray(0, tail), parent, depth, visitedCount: tail };
+}
+function commonNeighborsScore(s, u, v, o = {}) {
+  const fwd = s;
+  const bwd = o.directed === true ? s.reverse() : s;
+  let i = fwd.rowPtr[u];
+  const iEnd = fwd.rowPtr[u + 1];
+  let j = bwd.rowPtr[v];
+  const jEnd = bwd.rowPtr[v + 1];
+  let count = 0;
+  while (i < iEnd && j < jEnd) {
+    const a = fwd.colIdx[i];
+    const b = bwd.colIdx[j];
+    if (a === b) {
+      count++;
+      i++;
+      j++;
+      while (i < iEnd && fwd.colIdx[i] === a) {
+        i++;
+      }
+      while (j < jEnd && bwd.colIdx[j] === b) {
+        j++;
+      }
+    } else if (a < b) {
+      i++;
+    } else {
+      j++;
+    }
+  }
+  return count;
+}
+class IntUnionFind {
+  /**
+   * Create a union-find whose every element is a singleton set.
+   * @param size - The number of elements, each initially its own singleton set
+   */
+  constructor(size) {
+    this.parent = new Uint32Array(size);
+    this.rank = new Uint32Array(size);
+    for (let i = 0; i < size; i++) {
+      this.parent[i] = i;
+    }
+  }
+  /**
+   * Find the representative of an element's set, halving the path on the way up.
+   * @param x - An element index
+   * @returns The representative of x's set
+   */
+  find(x) {
+    let node = x;
+    while (this.parent[node] !== node) {
+      this.parent[node] = this.parent[this.parent[node]];
+      node = this.parent[node];
+    }
+    return node;
+  }
+  /**
+   * Merge the sets of two elements, attaching the shallower tree under the deeper one.
+   * @param a - An element index
+   * @param b - An element index
+   * @returns True when the two sets were distinct and have now been merged
+   */
+  union(a, b) {
+    const ra = this.find(a);
+    const rb = this.find(b);
+    if (ra === rb) {
+      return false;
+    }
+    if (this.rank[ra] < this.rank[rb]) {
+      this.parent[ra] = rb;
+    } else if (this.rank[ra] > this.rank[rb]) {
+      this.parent[rb] = ra;
+    } else {
+      this.parent[rb] = ra;
+      this.rank[ra]++;
+    }
+    return true;
+  }
+  /**
+   * Dense labels in FIRST-SEEN order, which is what makes `groups()` identical to the legacy
+   * iteration order and identical to the GPU's after its own `renumberPartition` readback
+   * (design 9.7's connectedComponents row).
+   * @returns The labels and the number of distinct sets
+   */
+  toLabels() {
+    const roots = new Uint32Array(this.parent.length);
+    for (let i = 0; i < roots.length; i++) {
+      roots[i] = this.find(i);
+    }
+    return renumberPartition(roots);
+  }
+}
+function withGroups(labels, count) {
+  let cached = null;
+  return {
+    labels,
+    count,
+    groups() {
+      if (cached === null) {
+        const sizes = new Uint32Array(count);
+        for (let i = 0; i < labels.length; i++) {
+          sizes[labels[i]]++;
+        }
+        const out = [];
+        for (let c = 0; c < count; c++) {
+          out.push(new Uint32Array(sizes[c]));
+        }
+        const fill = new Uint32Array(count);
+        for (let i = 0; i < labels.length; i++) {
+          const c = labels[i];
+          out[c][fill[c]++] = i;
+        }
+        cached = out;
+      }
+      return cached;
+    }
+  };
+}
+function unionEdges(s) {
+  const uf = new IntUnionFind(s.nodeCount);
+  const el = s.edgeList();
+  for (let e = 0; e < s.edgeCount; e++) {
+    uf.union(el.src[e], el.dst[e]);
+  }
+  const { labels, count } = uf.toLabels();
+  return withGroups(labels, count);
+}
+function connectedComponents(s) {
+  if (s.directed) {
+    throw new Error(
+      "Connected components requires an undirected graph. Use weaklyConnectedComponents, or pass s.toUndirected().snapshot."
+    );
+  }
+  return unionEdges(s);
+}
+function weaklyConnectedComponents(s) {
+  return unionEdges(s);
+}
+function arcSourceIn(rowPtr, arc) {
+  let lo = 0;
+  let hi = rowPtr.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (rowPtr[mid + 1] <= arc) {
+      lo = mid + 1;
+    } else {
+      hi = mid;
+    }
+  }
+  return lo;
+}
+class IndexedMinHeap {
+  /**
+   * Create an empty heap over node indices in `[0, capacity)`.
+   * @param capacity - The number of distinct node indices the heap may hold
+   */
+  constructor(capacity) {
+    this.size = 0;
+    this.heap = new Uint32Array(capacity);
+    this.slot = new Uint32Array(capacity).fill(INVALID_INDEX);
+    this.key = new Float64Array(capacity);
+  }
+  /**
+   * Whether the heap holds no entries.
+   * @returns True when the heap holds no entries
+   */
+  isEmpty() {
+    return this.size === 0;
+  }
+  /**
+   * Insert a node that is not in the heap.
+   * @param node - The node index
+   * @param key - Its key
+   */
+  push(node, key) {
+    this.key[node] = key;
+    this.heap[this.size] = node;
+    this.slot[node] = this.size;
+    this.size++;
+    this.siftUp(this.size - 1);
+  }
+  /**
+   * Insert the node, or lower its key if it is already present and the new key is smaller.
+   * @param node - The node index
+   * @param key - Its candidate key
+   */
+  pushOrDecrease(node, key) {
+    const at = this.slot[node];
+    if (at === INVALID_INDEX) {
+      this.push(node, key);
+      return;
+    }
+    if (key < this.key[node]) {
+      this.key[node] = key;
+      this.siftUp(at);
+    }
+  }
+  /**
+   * Remove and return the node with the smallest key. Undefined behaviour on an empty heap;
+   * callers guard with `isEmpty()`.
+   * @returns The node index
+   */
+  pop() {
+    const top = this.heap[0];
+    this.slot[top] = INVALID_INDEX;
+    this.size--;
+    if (this.size > 0) {
+      const moved = this.heap[this.size];
+      this.heap[0] = moved;
+      this.slot[moved] = 0;
+      this.siftDown(0);
+    }
+    return top;
+  }
+  siftUp(from) {
+    let at = from;
+    const node = this.heap[at];
+    const key = this.key[node];
+    while (at > 0) {
+      const parent = at - 1 >> 1;
+      const parentNode = this.heap[parent];
+      if (this.key[parentNode] <= key) {
+        break;
+      }
+      this.heap[at] = parentNode;
+      this.slot[parentNode] = at;
+      at = parent;
+    }
+    this.heap[at] = node;
+    this.slot[node] = at;
+  }
+  siftDown(from) {
+    let at = from;
+    const node = this.heap[at];
+    const key = this.key[node];
+    for (; ; ) {
+      const left = 2 * at + 1;
+      if (left >= this.size) {
+        break;
+      }
+      const right = left + 1;
+      const child = right < this.size && this.key[this.heap[right]] < this.key[this.heap[left]] ? right : left;
+      const childNode = this.heap[child];
+      if (key <= this.key[childNode]) {
+        break;
+      }
+      this.heap[at] = childNode;
+      this.slot[childNode] = at;
+      at = child;
+    }
+    this.heap[at] = node;
+    this.slot[node] = at;
+  }
+}
+function walkPredArcs(g, predArc, source, target) {
+  if (target === source) {
+    return Uint32Array.of(source);
+  }
+  if (predArc[target] === INVALID_INDEX) {
+    return new Uint32Array(0);
+  }
+  const reversed = [target];
+  let node = target;
+  while (node !== source) {
+    node = arcSourceIn(g.rowPtr, predArc[node]);
+    reversed.push(node);
+  }
+  const out = new Uint32Array(reversed.length);
+  for (let i = 0; i < reversed.length; i++) {
+    out[i] = reversed[reversed.length - 1 - i];
+  }
+  return out;
+}
+function walkPredEdges(g, predArc, source, target) {
+  if (target === source || predArc[target] === INVALID_INDEX) {
+    return new Uint32Array(0);
+  }
+  const reversed = [];
+  let node = target;
+  while (node !== source) {
+    const arc = predArc[node];
+    reversed.push(g.arcToEdge[arc]);
+    node = arcSourceIn(g.rowPtr, arc);
+  }
+  const out = new Uint32Array(reversed.length);
+  for (let i = 0; i < reversed.length; i++) {
+    out[i] = reversed[reversed.length - 1 - i];
+  }
+  return out;
+}
+function dijkstra(g, source, options = {}) {
+  const { nodeCount, rowPtr, colIdx } = g;
+  const weights = options.weights ?? g.weights;
+  const dist = new Float64Array(nodeCount).fill(Infinity);
+  const predArc = new Uint32Array(nodeCount).fill(INVALID_INDEX);
+  const heap = new IndexedMinHeap(nodeCount);
+  const cutoff = options.cutoff ?? Infinity;
+  dist[source] = 0;
+  heap.push(source, 0);
+  while (!heap.isEmpty()) {
+    const u = heap.pop();
+    const du = dist[u];
+    const end = rowPtr[u + 1];
+    for (let a = rowPtr[u]; a < end; a++) {
+      const w = weights === null ? 1 : weights[a];
+      const v = colIdx[a];
+      const dv = du + w;
+      if (dv < dist[v] && dv <= cutoff) {
+        dist[v] = dv;
+        predArc[v] = a;
+        heap.pushOrDecrease(v, dv);
+      }
+    }
+  }
+  return {
+    dist,
+    predArc,
+    pathTo: (target) => walkPredArcs(g, predArc, source, target),
+    pathEdges: (target) => walkPredEdges(g, predArc, source, target)
+  };
+}
+function kruskalMST(s, o = {}) {
+  const el = s.edgeList();
+  const m = s.edgeCount;
+  const keys = new Float64Array(m);
+  if (o.weights !== void 0) {
+    for (let e = 0; e < m; e++) {
+      keys[e] = o.weights[el.arc[e]];
+    }
+  } else if (el.weights !== null) {
+    for (let e = 0; e < m; e++) {
+      keys[e] = el.weights[e];
+    }
+  } else {
+    keys.fill(1);
+  }
+  const order = new Array(m);
+  for (let e = 0; e < m; e++) {
+    order[e] = e;
+  }
+  order.sort((a, b) => keys[a] - keys[b] || a - b);
+  const uf = new IntUnionFind(s.nodeCount);
+  const accepted = new Uint32Array(Math.max(s.nodeCount - 1, 0));
+  let taken = 0;
+  let totalWeight = 0;
+  for (const e of order) {
+    if (uf.union(el.src[e], el.dst[e])) {
+      accepted[taken++] = e;
+      totalWeight += keys[e];
+    }
+  }
+  return { edges: accepted.subarray(0, taken), totalWeight };
+}
+function pageRank(s, o = {}) {
+  if (!s.directed) {
+    throw new Error("PageRank requires a directed graph");
+  }
+  const n = s.nodeCount;
+  const d = o.dampingFactor ?? 0.85;
+  const maxIter = o.maxIterations ?? 100;
+  const tol = o.tolerance ?? 1e-6;
+  const rev = s.reverse();
+  const weighted = o.weighted === true && rev.weights !== null;
+  const outW = weighted ? s.weightedOutDegree() : s.outDegree();
+  let rank = new Float64Array(n).fill(1 / n);
+  let next = new Float64Array(n);
+  let it = 0;
+  let converged = false;
+  for (; it < maxIter && !converged; it++) {
+    let dangling = 0;
+    for (let u = 0; u < n; u++) {
+      if (outW[u] === 0) {
+        dangling += rank[u];
+      }
+    }
+    const base = (1 - d) / n + d * dangling / n;
+    let delta = 0;
+    for (let v = 0; v < n; v++) {
+      let acc = 0;
+      const end = rev.rowPtr[v + 1];
+      for (let a = rev.rowPtr[v]; a < end; a++) {
+        const u = rev.colIdx[a];
+        const ow = outW[u];
+        if (ow > 0) {
+          acc += rank[u] * (weighted && rev.weights !== null ? rev.weights[a] : 1) / ow;
+        }
+      }
+      next[v] = base + d * acc;
+      delta += Math.abs(next[v] - rank[v]);
+    }
+    [rank, next] = [next, rank];
+    converged = delta < tol;
+  }
+  return { scores: rank, iterations: it, converged };
+}
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  IndexedMinHeap,
+  IntUnionFind,
+  arcSourceIn,
+  breadthFirstSearch,
+  commonNeighborsScore,
+  connectedComponents,
+  dijkstra,
+  kruskalMST,
+  pageRank,
+  walkPredArcs,
+  walkPredEdges,
+  weaklyConnectedComponents
+}, Symbol.toStringTag, { value: "Module" }));
+const SNAPSHOT_CACHE = /* @__PURE__ */ new WeakMap();
+function toSnapshot(graph, options = {}) {
+  const checksum = options.checksum === true;
+  const cached = SNAPSHOT_CACHE.get(graph);
+  if (cached !== void 0 && cached.mutationCount === graph.mutationCount && (cached.checksum || !checksum)) {
+    return cached.snapshot;
+  }
+  const builder = new GraphBuilder({
+    directed: graph.isDirected,
+    weightDtype: "f64",
+    expectedNodes: graph.nodeCount,
+    expectedEdges: graph.totalEdgeCount
+  });
+  for (const node of graph.nodes()) {
+    builder.addNode(node.id);
+  }
+  for (const edge of graph.edges()) {
+    builder.addEdge(edge.source, edge.target, edge.weight);
+  }
+  const snapshot = builder.freeze({ label: "algorithms.toSnapshot", checksum });
+  SNAPSHOT_CACHE.set(graph, { mutationCount: graph.mutationCount, checksum, snapshot });
+  return snapshot;
+}
+function decorateSssp(s, source, like) {
+  const { predArc } = like;
+  return {
+    dist: like.dist,
+    predArc,
+    pathTo: (target) => walkPredArcs(s, predArc, source, target),
+    pathEdges: (target) => walkPredEdges(s, predArc, source, target)
+  };
+}
+function accelerated(acc) {
+  return {
+    accelerator: acc ?? null,
+    pageRank: (s, options) => acc?.pageRank !== void 0 ? acc.pageRank(s, options) : Promise.resolve(pageRank(s, options)),
+    sssp: (s, source, options) => acc?.sssp !== void 0 ? acc.sssp(s, source, options).then((like) => decorateSssp(s, source, like)) : Promise.resolve(dijkstra(s, source, options)),
+    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))
+  };
+}
 export {
   CSRGraph,
   CompactDistanceArray,
@@ -11312,6 +11822,7 @@ export {
   PriorityQueue,
   UnionFind,
   VisitedBitArray,
+  accelerated,
   adamicAdarForPairs,
   adamicAdarPrediction,
   adamicAdarScore,
@@ -11322,22 +11833,22 @@ export {
   bellmanFordPath,
   betweennessCentrality,
   bipartitePartition,
-  breadthFirstSearch,
+  breadthFirstSearch$1 as breadthFirstSearch,
   calculateMCLModularity,
   closenessCentrality,
   commonNeighborsForPairs,
   commonNeighborsPrediction,
-  commonNeighborsScore,
+  commonNeighborsScore$1 as commonNeighborsScore,
   compareAdamicAdarWithCommonNeighbors,
   condensationGraph,
   configureOptimizations,
-  connectedComponents,
+  connectedComponents$1 as connectedComponents,
   connectedComponentsDFS,
   createBipartiteFlowNetwork,
   createOptimizedGraph,
   degreeCentrality,
   depthFirstSearch,
-  dijkstra,
+  dijkstra$1 as dijkstra,
   dijkstraPath,
   edgeBetweennessCentrality,
   edmondsKarp,
@@ -11362,6 +11873,7 @@ export {
   heuristics,
   hierarchicalClustering,
   hits,
+  index as indexed,
   isBipartite,
   isCSRGraph,
   isConnected,
@@ -11371,7 +11883,7 @@ export {
   kCoreDecomposition,
   kargerMinCut,
   katzCentrality,
-  kruskalMST,
+  kruskalMST$1 as kruskalMST,
   labelPropagation,
   labelPropagationAsync,
   labelPropagationSemiSupervised,
@@ -11390,7 +11902,7 @@ export {
   nodeKatzCentrality,
   nodeWeightedClosenessCentrality,
   numberOfConnectedComponents,
-  pageRank,
+  pageRank$1 as pageRank,
   pageRankCentrality,
   pathfindingUtils,
   personalizedPageRank,
@@ -11404,10 +11916,11 @@ export {
   syncClustering,
   teraHAC,
   toCSRGraph,
+  toSnapshot,
   topPageRankNodes,
   topologicalSort,
   transitiveClosure,
-  weaklyConnectedComponents,
+  weaklyConnectedComponents$1 as weaklyConnectedComponents,
   weightedClosenessCentrality
 };
 //# sourceMappingURL=algorithms.js.map