@tldraw/commenting 0.0.0-bootstrap

package/dist-cjs/clustering/replay.js

@@ -0,0 +1,275 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var replay_exports = {};
+__export(replay_exports, {
+  D_FLOOR: () => D_FLOOR,
+  cappedReplay: () => cappedReplay
+});
+module.exports = __toCommonJS(replay_exports);
+const D_FLOOR = 1e-9;
+function cappedReplay(leaves, edges, opts) {
+  validateOptions(opts);
+  if (edges.length === 0) return [];
+  const clusters = new ClusterState(leaves);
+  const heap = new EdgeMaxHeap(edges, leaves);
+  const incident = leaves.map(() => []);
+  for (let i = 0; i < edges.length; i++) {
+    heap.push({ edgeIndex: i, z: zForEdge(edges[i], clusters, opts) });
+    incident[edges[i].a].push(i);
+    incident[edges[i].b].push(i);
+  }
+  const events = [];
+  let lastZ = Number.POSITIVE_INFINITY;
+  while (events.length < edges.length) {
+    const entry = heap.pop();
+    if (!entry) break;
+    const edge = edges[entry.edgeIndex];
+    const aRoot = clusters.find(edge.a);
+    const bRoot = clusters.find(edge.b);
+    if (aRoot === bRoot) continue;
+    const current = { edgeIndex: entry.edgeIndex, z: zForRoots(edge, aRoot, bRoot, clusters, opts) };
+    const next = heap.peek();
+    if (next && heap.higherPriority(next, current)) {
+      heap.push(current);
+      continue;
+    }
+    const z = Math.min(current.z, lastZ);
+    lastZ = z;
+    events.push(clusters.merge(aRoot, bRoot, z));
+    const root = clusters.find(edge.a);
+    const other = root === aRoot ? bRoot : aRoot;
+    const survivors = [];
+    for (const idx of [...incident[root], ...incident[other]]) {
+      const e2 = edges[idx];
+      const ra = clusters.find(e2.a);
+      const rb = clusters.find(e2.b);
+      if (ra === rb) continue;
+      survivors.push(idx);
+      heap.push({ edgeIndex: idx, z: zForRoots(e2, ra, rb, clusters, opts) });
+    }
+    incident[root] = survivors;
+  }
+  return events;
+}
+function validateOptions(opts) {
+  if (!Number.isFinite(opts.Tc) || opts.Tc <= 0) {
+    throw new Error("Tc must be greater than 0");
+  }
+  if (!Number.isFinite(opts.Dmax) || opts.Dmax <= 0) {
+    throw new Error("Dmax must be greater than 0");
+  }
+  if (opts.Dmax < opts.Tc) {
+    throw new Error("Dmax must be greater than or equal to Tc");
+  }
+}
+function zForEdge(edge, clusters, opts) {
+  return zForRoots(edge, clusters.find(edge.a), clusters.find(edge.b), clusters, opts);
+}
+function zForRoots(edge, aRoot, bRoot, clusters, opts) {
+  if (edge.d < D_FLOOR) return Number.POSITIVE_INFINITY;
+  const gap = opts.Tc / clusters.centroidDistance(aRoot, bRoot);
+  const fit = opts.Dmax / clusters.unionBboxDiag(aRoot, bRoot);
+  return Math.min(gap, fit);
+}
+class ClusterState {
+  parent;
+  minX;
+  minY;
+  maxX;
+  maxY;
+  centroidX;
+  centroidY;
+  counts;
+  nodes;
+  memberLists;
+  minMemberIds;
+  constructor(leaves) {
+    const n = leaves.length;
+    this.parent = new Int32Array(n);
+    this.minX = new Float64Array(n);
+    this.minY = new Float64Array(n);
+    this.maxX = new Float64Array(n);
+    this.maxY = new Float64Array(n);
+    this.centroidX = new Float64Array(n);
+    this.centroidY = new Float64Array(n);
+    this.counts = new Int32Array(n);
+    this.nodes = new Array(n);
+    this.memberLists = new Array(n);
+    this.minMemberIds = new Array(n);
+    for (let i = 0; i < n; i++) {
+      const leaf = leaves[i];
+      this.parent[i] = i;
+      this.minX[i] = leaf.point.x;
+      this.minY[i] = leaf.point.y;
+      this.maxX[i] = leaf.point.x;
+      this.maxY[i] = leaf.point.y;
+      this.centroidX[i] = leaf.point.x;
+      this.centroidY[i] = leaf.point.y;
+      this.counts[i] = 1;
+      this.memberLists[i] = [leaf.id];
+      this.minMemberIds[i] = leaf.id;
+      this.nodes[i] = {
+        id: leaf.id,
+        centroid: { x: leaf.point.x, y: leaf.point.y },
+        count: 1,
+        members: [leaf.id]
+      };
+    }
+  }
+  find(index) {
+    let root = index;
+    while (this.parent[root] !== root) {
+      root = this.parent[root];
+    }
+    while (this.parent[index] !== index) {
+      const next = this.parent[index];
+      this.parent[index] = root;
+      index = next;
+    }
+    return root;
+  }
+  centroidDistance(aRoot, bRoot) {
+    return Math.hypot(
+      this.centroidX[aRoot] - this.centroidX[bRoot],
+      this.centroidY[aRoot] - this.centroidY[bRoot]
+    );
+  }
+  unionBboxDiag(aRoot, bRoot) {
+    const minX = Math.min(this.minX[aRoot], this.minX[bRoot]);
+    const minY = Math.min(this.minY[aRoot], this.minY[bRoot]);
+    const maxX = Math.max(this.maxX[aRoot], this.maxX[bRoot]);
+    const maxY = Math.max(this.maxY[aRoot], this.maxY[bRoot]);
+    return Math.hypot(maxX - minX, maxY - minY);
+  }
+  merge(aRoot, bRoot, z) {
+    const leftRoot = this.minMemberIds[aRoot] < this.minMemberIds[bRoot] ? aRoot : bRoot;
+    const rightRoot = leftRoot === aRoot ? bRoot : aRoot;
+    const left = this.nodes[leftRoot];
+    const right = this.nodes[rightRoot];
+    const count = this.counts[leftRoot] + this.counts[rightRoot];
+    const members = mergeSortedMembers(this.memberLists[leftRoot], this.memberLists[rightRoot]);
+    const minX = Math.min(this.minX[leftRoot], this.minX[rightRoot]);
+    const minY = Math.min(this.minY[leftRoot], this.minY[rightRoot]);
+    const maxX = Math.max(this.maxX[leftRoot], this.maxX[rightRoot]);
+    const maxY = Math.max(this.maxY[leftRoot], this.maxY[rightRoot]);
+    const centroidX = (this.counts[leftRoot] * this.centroidX[leftRoot] + this.counts[rightRoot] * this.centroidX[rightRoot]) / count;
+    const centroidY = (this.counts[leftRoot] * this.centroidY[leftRoot] + this.counts[rightRoot] * this.centroidY[rightRoot]) / count;
+    const result = {
+      id: `cluster:${count}:${members[0]}`,
+      centroid: { x: centroidX, y: centroidY },
+      count,
+      members
+    };
+    this.parent[rightRoot] = leftRoot;
+    this.minX[leftRoot] = minX;
+    this.minY[leftRoot] = minY;
+    this.maxX[leftRoot] = maxX;
+    this.maxY[leftRoot] = maxY;
+    this.centroidX[leftRoot] = centroidX;
+    this.centroidY[leftRoot] = centroidY;
+    this.counts[leftRoot] = count;
+    this.nodes[leftRoot] = result;
+    this.memberLists[leftRoot] = members;
+    this.minMemberIds[leftRoot] = members[0];
+    return { z, children: [left, right], result };
+  }
+}
+function mergeSortedMembers(a, b) {
+  const out = new Array(a.length + b.length);
+  let i = 0;
+  let j = 0;
+  let k = 0;
+  while (i < a.length && j < b.length) {
+    if (a[i] < b[j]) {
+      out[k++] = a[i++];
+    } else {
+      out[k++] = b[j++];
+    }
+  }
+  while (i < a.length) out[k++] = a[i++];
+  while (j < b.length) out[k++] = b[j++];
+  return out;
+}
+class EdgeMaxHeap {
+  constructor(edges, leaves) {
+    this.edges = edges;
+    this.leaves = leaves;
+  }
+  edges;
+  leaves;
+  items = [];
+  peek() {
+    return this.items[0];
+  }
+  push(entry) {
+    this.items.push(entry);
+    this.siftUp(this.items.length - 1);
+  }
+  pop() {
+    if (this.items.length === 0) return void 0;
+    const first = this.items[0];
+    const last = this.items.pop();
+    if (this.items.length > 0) {
+      this.items[0] = last;
+      this.siftDown(0);
+    }
+    return first;
+  }
+  higherPriority(a, b) {
+    if (a.z > b.z) return true;
+    if (a.z < b.z) return false;
+    return edgeIdPairLess(this.edges[a.edgeIndex], this.edges[b.edgeIndex], this.leaves);
+  }
+  siftUp(index) {
+    while (index > 0) {
+      const parent = index - 1 >> 1;
+      if (!this.higherPriority(this.items[index], this.items[parent])) break;
+      [this.items[index], this.items[parent]] = [this.items[parent], this.items[index]];
+      index = parent;
+    }
+  }
+  siftDown(index) {
+    while (true) {
+      const left = index * 2 + 1;
+      const right = left + 1;
+      let best = index;
+      if (left < this.items.length && this.higherPriority(this.items[left], this.items[best])) {
+        best = left;
+      }
+      if (right < this.items.length && this.higherPriority(this.items[right], this.items[best])) {
+        best = right;
+      }
+      if (best === index) break;
+      [this.items[index], this.items[best]] = [this.items[best], this.items[index]];
+      index = best;
+    }
+  }
+}
+function edgeIdPairLess(a, b, leaves) {
+  const [aLo, aHi] = normalizedEdgeIds(a, leaves);
+  const [bLo, bHi] = normalizedEdgeIds(b, leaves);
+  if (aLo !== bLo) return aLo < bLo;
+  return aHi < bHi;
+}
+function normalizedEdgeIds(edge, leaves) {
+  const aId = leaves[edge.a].id;
+  const bId = leaves[edge.b].id;
+  return aId < bId ? [aId, bId] : [bId, aId];
+}
+//# sourceMappingURL=replay.js.map

package/dist-cjs/clustering/replay.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/clustering/replay.ts"],
+  "sourcesContent": ["import type { ClusterNode, LeafInput, MstEdge, RawMergeEvent } from './types'\n\nexport const D_FLOOR = 1e-9\n\nexport function cappedReplay(\n\tleaves: readonly LeafInput[],\n\tedges: readonly MstEdge[],\n\topts: { Tc: number; Dmax: number }\n): RawMergeEvent[] {\n\tvalidateOptions(opts)\n\n\tif (edges.length === 0) return []\n\n\tconst clusters = new ClusterState(leaves)\n\tconst heap = new EdgeMaxHeap(edges, leaves)\n\t// Edges incident to each current cluster root, for eager repricing: a merge\n\t// moves the result's centroid, which can RAISE an incident edge's key (the\n\t// centroid may move toward a neighbor), so the lazy pop-time recheck alone\n\t// is not enough \u2014 every price change pushes a fresh heap entry.\n\tconst incident: number[][] = leaves.map(() => [])\n\tfor (let i = 0; i < edges.length; i++) {\n\t\theap.push({ edgeIndex: i, z: zForEdge(edges[i], clusters, opts) })\n\t\tincident[edges[i].a].push(i)\n\t\tincident[edges[i].b].push(i)\n\t}\n\n\tconst events: RawMergeEvent[] = []\n\t// Emitted thresholds are clamped non-increasing: with centroid pricing a\n\t// later merge's raw price can in principle exceed an earlier one's, and the\n\t// table's descending sort is load-bearing for the runtime cursor.\n\tlet lastZ = Number.POSITIVE_INFINITY\n\twhile (events.length < edges.length) {\n\t\tconst entry = heap.pop()\n\t\tif (!entry) break\n\n\t\tconst edge = edges[entry.edgeIndex]\n\t\tconst aRoot = clusters.find(edge.a)\n\t\tconst bRoot = clusters.find(edge.b)\n\t\tif (aRoot === bRoot) continue // stale duplicate of an already-fired edge\n\n\t\tconst current = { edgeIndex: entry.edgeIndex, z: zForRoots(edge, aRoot, bRoot, clusters, opts) }\n\t\tconst next = heap.peek()\n\t\tif (next && heap.higherPriority(next, current)) {\n\t\t\theap.push(current)\n\t\t\tcontinue\n\t\t}\n\n\t\tconst z = Math.min(current.z, lastZ)\n\t\tlastZ = z\n\t\tevents.push(clusters.merge(aRoot, bRoot, z))\n\n\t\t// eager reprice: the new cluster's centroid and bbox changed, so every\n\t\t// surviving incident edge gets a fresh entry at its current price\n\t\tconst root = clusters.find(edge.a)\n\t\tconst other = root === aRoot ? bRoot : aRoot\n\t\tconst survivors: number[] = []\n\t\tfor (const idx of [...incident[root], ...incident[other]]) {\n\t\t\tconst e2 = edges[idx]\n\t\t\tconst ra = clusters.find(e2.a)\n\t\t\tconst rb = clusters.find(e2.b)\n\t\t\tif (ra === rb) continue\n\t\t\tsurvivors.push(idx)\n\t\t\theap.push({ edgeIndex: idx, z: zForRoots(e2, ra, rb, clusters, opts) })\n\t\t}\n\t\tincident[root] = survivors\n\t}\n\n\treturn events\n}\n\nfunction validateOptions(opts: { Tc: number; Dmax: number }) {\n\tif (!Number.isFinite(opts.Tc) || opts.Tc <= 0) {\n\t\tthrow new Error('Tc must be greater than 0')\n\t}\n\tif (!Number.isFinite(opts.Dmax) || opts.Dmax <= 0) {\n\t\tthrow new Error('Dmax must be greater than 0')\n\t}\n\tif (opts.Dmax < opts.Tc) {\n\t\tthrow new Error('Dmax must be greater than or equal to Tc')\n\t}\n}\n\nfunction zForEdge(\n\tedge: MstEdge,\n\tclusters: ClusterState,\n\topts: { Tc: number; Dmax: number }\n): number {\n\treturn zForRoots(edge, clusters.find(edge.a), clusters.find(edge.b), clusters, opts)\n}\n\nfunction zForRoots(\n\tedge: MstEdge,\n\taRoot: number,\n\tbRoot: number,\n\tclusters: ClusterState,\n\topts: { Tc: number; Dmax: number }\n): number {\n\tif (edge.d < D_FLOOR) return Number.POSITIVE_INFINITY\n\t// Badge-anchored gap pricing: clusters render as badges at their centroids,\n\t// so the merge is priced by the distance between the rendered centers, not\n\t// the nearest members. For leaves the two are identical; for clusters the\n\t// centroid distance is larger, so groups merge later than their closest\n\t// members would suggest \u2014 matching what the user actually sees.\n\t// (Coincident CENTROIDS with non-coincident members leave the gap term\n\t// Infinity and the fit term finite \u2014 the min stays finite, no special case.)\n\tconst gap = opts.Tc / clusters.centroidDistance(aRoot, bRoot)\n\tconst fit = opts.Dmax / clusters.unionBboxDiag(aRoot, bRoot)\n\treturn Math.min(gap, fit)\n}\n\nclass ClusterState {\n\tprivate readonly parent: Int32Array\n\tprivate readonly minX: Float64Array\n\tprivate readonly minY: Float64Array\n\tprivate readonly maxX: Float64Array\n\tprivate readonly maxY: Float64Array\n\tprivate readonly centroidX: Float64Array\n\tprivate readonly centroidY: Float64Array\n\tprivate readonly counts: Int32Array\n\tprivate readonly nodes: ClusterNode[]\n\tprivate readonly memberLists: string[][]\n\tprivate readonly minMemberIds: string[]\n\n\tconstructor(leaves: readonly LeafInput[]) {\n\t\tconst n = leaves.length\n\t\tthis.parent = new Int32Array(n)\n\t\tthis.minX = new Float64Array(n)\n\t\tthis.minY = new Float64Array(n)\n\t\tthis.maxX = new Float64Array(n)\n\t\tthis.maxY = new Float64Array(n)\n\t\tthis.centroidX = new Float64Array(n)\n\t\tthis.centroidY = new Float64Array(n)\n\t\tthis.counts = new Int32Array(n)\n\t\tthis.nodes = new Array(n)\n\t\tthis.memberLists = new Array(n)\n\t\tthis.minMemberIds = new Array(n)\n\n\t\tfor (let i = 0; i < n; i++) {\n\t\t\tconst leaf = leaves[i]\n\t\t\tthis.parent[i] = i\n\t\t\tthis.minX[i] = leaf.point.x\n\t\t\tthis.minY[i] = leaf.point.y\n\t\t\tthis.maxX[i] = leaf.point.x\n\t\t\tthis.maxY[i] = leaf.point.y\n\t\t\tthis.centroidX[i] = leaf.point.x\n\t\t\tthis.centroidY[i] = leaf.point.y\n\t\t\tthis.counts[i] = 1\n\t\t\tthis.memberLists[i] = [leaf.id]\n\t\t\tthis.minMemberIds[i] = leaf.id\n\t\t\tthis.nodes[i] = {\n\t\t\t\tid: leaf.id,\n\t\t\t\tcentroid: { x: leaf.point.x, y: leaf.point.y },\n\t\t\t\tcount: 1,\n\t\t\t\tmembers: [leaf.id],\n\t\t\t}\n\t\t}\n\t}\n\n\tfind(index: number): number {\n\t\tlet root = index\n\t\twhile (this.parent[root] !== root) {\n\t\t\troot = this.parent[root]\n\t\t}\n\t\twhile (this.parent[index] !== index) {\n\t\t\tconst next = this.parent[index]\n\t\t\tthis.parent[index] = root\n\t\t\tindex = next\n\t\t}\n\t\treturn root\n\t}\n\n\tcentroidDistance(aRoot: number, bRoot: number): number {\n\t\treturn Math.hypot(\n\t\t\tthis.centroidX[aRoot] - this.centroidX[bRoot],\n\t\t\tthis.centroidY[aRoot] - this.centroidY[bRoot]\n\t\t)\n\t}\n\n\tunionBboxDiag(aRoot: number, bRoot: number): number {\n\t\tconst minX = Math.min(this.minX[aRoot], this.minX[bRoot])\n\t\tconst minY = Math.min(this.minY[aRoot], this.minY[bRoot])\n\t\tconst maxX = Math.max(this.maxX[aRoot], this.maxX[bRoot])\n\t\tconst maxY = Math.max(this.maxY[aRoot], this.maxY[bRoot])\n\t\treturn Math.hypot(maxX - minX, maxY - minY)\n\t}\n\n\tmerge(aRoot: number, bRoot: number, z: number): RawMergeEvent {\n\t\tconst leftRoot = this.minMemberIds[aRoot] < this.minMemberIds[bRoot] ? aRoot : bRoot\n\t\tconst rightRoot = leftRoot === aRoot ? bRoot : aRoot\n\t\tconst left = this.nodes[leftRoot]\n\t\tconst right = this.nodes[rightRoot]\n\t\tconst count = this.counts[leftRoot] + this.counts[rightRoot]\n\t\tconst members = mergeSortedMembers(this.memberLists[leftRoot], this.memberLists[rightRoot])\n\n\t\tconst minX = Math.min(this.minX[leftRoot], this.minX[rightRoot])\n\t\tconst minY = Math.min(this.minY[leftRoot], this.minY[rightRoot])\n\t\tconst maxX = Math.max(this.maxX[leftRoot], this.maxX[rightRoot])\n\t\tconst maxY = Math.max(this.maxY[leftRoot], this.maxY[rightRoot])\n\t\tconst centroidX =\n\t\t\t(this.counts[leftRoot] * this.centroidX[leftRoot] +\n\t\t\t\tthis.counts[rightRoot] * this.centroidX[rightRoot]) /\n\t\t\tcount\n\t\tconst centroidY =\n\t\t\t(this.counts[leftRoot] * this.centroidY[leftRoot] +\n\t\t\t\tthis.counts[rightRoot] * this.centroidY[rightRoot]) /\n\t\t\tcount\n\n\t\t// Leaf ids are assumed not to start with `cluster:`; see the step 2 contract.\n\t\tconst result: ClusterNode = {\n\t\t\tid: `cluster:${count}:${members[0]}`,\n\t\t\tcentroid: { x: centroidX, y: centroidY },\n\t\t\tcount,\n\t\t\tmembers,\n\t\t}\n\n\t\tthis.parent[rightRoot] = leftRoot\n\t\tthis.minX[leftRoot] = minX\n\t\tthis.minY[leftRoot] = minY\n\t\tthis.maxX[leftRoot] = maxX\n\t\tthis.maxY[leftRoot] = maxY\n\t\tthis.centroidX[leftRoot] = centroidX\n\t\tthis.centroidY[leftRoot] = centroidY\n\t\tthis.counts[leftRoot] = count\n\t\tthis.nodes[leftRoot] = result\n\t\tthis.memberLists[leftRoot] = members\n\t\tthis.minMemberIds[leftRoot] = members[0]\n\n\t\treturn { z, children: [left, right], result }\n\t}\n}\n\nfunction mergeSortedMembers(a: readonly string[], b: readonly string[]): string[] {\n\tconst out = new Array<string>(a.length + b.length)\n\tlet i = 0\n\tlet j = 0\n\tlet k = 0\n\twhile (i < a.length && j < b.length) {\n\t\tif (a[i] < b[j]) {\n\t\t\tout[k++] = a[i++]\n\t\t} else {\n\t\t\tout[k++] = b[j++]\n\t\t}\n\t}\n\twhile (i < a.length) out[k++] = a[i++]\n\twhile (j < b.length) out[k++] = b[j++]\n\treturn out\n}\n\ninterface HeapEntry {\n\tedgeIndex: number\n\tz: number\n}\n\nclass EdgeMaxHeap {\n\tprivate readonly items: HeapEntry[] = []\n\n\tconstructor(\n\t\tprivate readonly edges: readonly MstEdge[],\n\t\tprivate readonly leaves: readonly LeafInput[]\n\t) {}\n\n\tpeek(): HeapEntry | undefined {\n\t\treturn this.items[0]\n\t}\n\n\tpush(entry: HeapEntry) {\n\t\tthis.items.push(entry)\n\t\tthis.siftUp(this.items.length - 1)\n\t}\n\n\tpop(): HeapEntry | undefined {\n\t\tif (this.items.length === 0) return undefined\n\t\tconst first = this.items[0]\n\t\tconst last = this.items.pop()!\n\t\tif (this.items.length > 0) {\n\t\t\tthis.items[0] = last\n\t\t\tthis.siftDown(0)\n\t\t}\n\t\treturn first\n\t}\n\n\thigherPriority(a: HeapEntry, b: HeapEntry): boolean {\n\t\tif (a.z > b.z) return true\n\t\tif (a.z < b.z) return false\n\t\treturn edgeIdPairLess(this.edges[a.edgeIndex], this.edges[b.edgeIndex], this.leaves)\n\t}\n\n\tprivate siftUp(index: number) {\n\t\twhile (index > 0) {\n\t\t\tconst parent = (index - 1) >> 1\n\t\t\tif (!this.higherPriority(this.items[index], this.items[parent])) break\n\t\t\t;[this.items[index], this.items[parent]] = [this.items[parent], this.items[index]]\n\t\t\tindex = parent\n\t\t}\n\t}\n\n\tprivate siftDown(index: number) {\n\t\twhile (true) {\n\t\t\tconst left = index * 2 + 1\n\t\t\tconst right = left + 1\n\t\t\tlet best = index\n\t\t\tif (left < this.items.length && this.higherPriority(this.items[left], this.items[best])) {\n\t\t\t\tbest = left\n\t\t\t}\n\t\t\tif (right < this.items.length && this.higherPriority(this.items[right], this.items[best])) {\n\t\t\t\tbest = right\n\t\t\t}\n\t\t\tif (best === index) break\n\t\t\t;[this.items[index], this.items[best]] = [this.items[best], this.items[index]]\n\t\t\tindex = best\n\t\t}\n\t}\n}\n\nfunction edgeIdPairLess(a: MstEdge, b: MstEdge, leaves: readonly LeafInput[]): boolean {\n\tconst [aLo, aHi] = normalizedEdgeIds(a, leaves)\n\tconst [bLo, bHi] = normalizedEdgeIds(b, leaves)\n\tif (aLo !== bLo) return aLo < bLo\n\treturn aHi < bHi\n}\n\nfunction normalizedEdgeIds(edge: MstEdge, leaves: readonly LeafInput[]): [string, string] {\n\tconst aId = leaves[edge.a].id\n\tconst bId = leaves[edge.b].id\n\treturn aId < bId ? [aId, bId] : [bId, aId]\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist-cjs/clustering/runtime.js

@@ -0,0 +1,134 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runtime_exports = {};
+__export(runtime_exports, {
+  createClusterRuntime: () => createClusterRuntime
+});
+module.exports = __toCommonJS(runtime_exports);
+function createClusterRuntime(table) {
+  return new ClusterRuntimeImpl(table);
+}
+class ClusterRuntimeImpl {
+  constructor(table) {
+    this.table = table;
+    this.resetVisible();
+  }
+  table;
+  // mutable internally; readonly through the ClusterRuntime interface
+  k = 0;
+  visible = /* @__PURE__ */ new Map();
+  seeded = false;
+  seed(zoom) {
+    validateZoom(zoom);
+    this.k = seedCount(this.table.events, zoom);
+    this.resetVisible();
+    for (let i = 0; i < this.k; i++) {
+      applyEvent(this.visible, this.table.events[i]);
+    }
+    this.seeded = true;
+  }
+  seedFrom(zoom, previous) {
+    validateZoom(zoom);
+    const ownerByMember = /* @__PURE__ */ new Map();
+    for (const node of previous.values()) {
+      for (const member of node.members) {
+        ownerByMember.set(member, node.id);
+      }
+    }
+    const events = this.table.events;
+    let k = 0;
+    while (k < events.length) {
+      const event = events[k];
+      if (zoom >= event.zSplit) break;
+      if (zoom > event.zMerge && !wasMergedTogether(event.result.members, ownerByMember)) break;
+      k++;
+    }
+    this.k = k;
+    this.resetVisible();
+    for (let i = 0; i < k; i++) {
+      applyEvent(this.visible, events[i]);
+    }
+    this.seeded = true;
+  }
+  onCamera(zoom) {
+    validateZoom(zoom);
+    if (!this.seeded) {
+      throw new Error("Cluster runtime must be seeded before onCamera");
+    }
+    while (this.k < this.table.events.length && zoom <= this.table.events[this.k].zMerge) {
+      applyEvent(this.visible, this.table.events[this.k]);
+      this.k++;
+    }
+    while (this.k > 0 && zoom >= this.table.events[this.k - 1].zSplit) {
+      this.k--;
+      unapplyEvent(this.visible, this.table.events[this.k]);
+    }
+  }
+  getVisible() {
+    return this.visible;
+  }
+  resetVisible() {
+    this.visible = /* @__PURE__ */ new Map();
+    for (const leaf of this.table.leaves) {
+      this.visible.set(leaf.id, leaf);
+    }
+  }
+}
+function wasMergedTogether(members, ownerByMember) {
+  const owner = ownerByMember.get(members[0]);
+  if (owner === void 0) return false;
+  for (let i = 1; i < members.length; i++) {
+    if (ownerByMember.get(members[i]) !== owner) return false;
+  }
+  return true;
+}
+function seedCount(events, zoom) {
+  let lo = 0;
+  let hi = events.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (zoom <= seedThreshold(events[mid])) {
+      lo = mid + 1;
+    } else {
+      hi = mid;
+    }
+  }
+  return lo;
+}
+function seedThreshold(event) {
+  return Math.sqrt(event.zMerge * event.zSplit);
+}
+function applyEvent(visible, event) {
+  for (const child of event.children) {
+    visible.delete(child.id);
+  }
+  visible.set(event.result.id, event.result);
+}
+function unapplyEvent(visible, event) {
+  visible.delete(event.result.id);
+  for (const child of event.children) {
+    visible.set(child.id, child);
+  }
+}
+function validateZoom(zoom) {
+  if (!Number.isFinite(zoom) || zoom <= 0) {
+    throw new Error("zoom must be finite and greater than 0");
+  }
+}
+//# sourceMappingURL=runtime.js.map

package/dist-cjs/clustering/runtime.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/clustering/runtime.ts"],
+  "sourcesContent": ["import type { ClusterNode, ClusterTable, MergeEvent } from './types'\n\n/** @public */\nexport interface ClusterRuntime {\n\t/** Events[0..k) are active. Exposed for tests and debugging. */\n\treadonly k: number\n\t/** Reset state from scratch for the given zoom (cold start / after rebuild). */\n\tseed(zoom: number): void\n\t/**\n\t * Reset state for the given zoom, carrying hysteresis state over from a previous partition\n\t * (the visible map of the model being replaced). Threshold-forced events ignore history:\n\t * zoom \\<= zMerge is always active, zoom \\>= zSplit always inactive. An event inside its band\n\t * is active iff its members were merged together in `previous`; a band event with no history\n\t * (e.g. introduced by the rebuild) stays inactive until the next zoom-out crosses its zMerge.\n\t * Active events must form a prefix of the table, so classification stops at the first\n\t * inactive event; later band-active events conservatively resolve to split.\n\t */\n\tseedFrom(zoom: number, previous: ReadonlyMap<string, ClusterNode>): void\n\t/** Advance/retreat the cursor for a camera change. No-op if zoom sits inside all bands. */\n\tonCamera(zoom: number): void\n\t/** The current partition: cluster id \u2192 node. Do not mutate. */\n\tgetVisible(): ReadonlyMap<string, ClusterNode>\n}\n\n/** @public */\nexport function createClusterRuntime(table: ClusterTable): ClusterRuntime {\n\treturn new ClusterRuntimeImpl(table)\n}\n\nclass ClusterRuntimeImpl implements ClusterRuntime {\n\t// mutable internally; readonly through the ClusterRuntime interface\n\tk = 0\n\tprivate visible = new Map<string, ClusterNode>()\n\tprivate seeded = false\n\n\tconstructor(private readonly table: ClusterTable) {\n\t\tthis.resetVisible()\n\t}\n\n\tseed(zoom: number): void {\n\t\tvalidateZoom(zoom)\n\t\tthis.k = seedCount(this.table.events, zoom)\n\t\tthis.resetVisible()\n\t\tfor (let i = 0; i < this.k; i++) {\n\t\t\tapplyEvent(this.visible, this.table.events[i])\n\t\t}\n\t\tthis.seeded = true\n\t}\n\n\tseedFrom(zoom: number, previous: ReadonlyMap<string, ClusterNode>): void {\n\t\tvalidateZoom(zoom)\n\t\tconst ownerByMember = new Map<string, string>()\n\t\tfor (const node of previous.values()) {\n\t\t\tfor (const member of node.members) {\n\t\t\t\townerByMember.set(member, node.id)\n\t\t\t}\n\t\t}\n\n\t\tconst events = this.table.events\n\t\tlet k = 0\n\t\twhile (k < events.length) {\n\t\t\tconst event = events[k]\n\t\t\tif (zoom >= event.zSplit) break\n\t\t\tif (zoom > event.zMerge && !wasMergedTogether(event.result.members, ownerByMember)) break\n\t\t\tk++\n\t\t}\n\n\t\tthis.k = k\n\t\tthis.resetVisible()\n\t\tfor (let i = 0; i < k; i++) {\n\t\t\tapplyEvent(this.visible, events[i])\n\t\t}\n\t\tthis.seeded = true\n\t}\n\n\tonCamera(zoom: number): void {\n\t\tvalidateZoom(zoom)\n\t\tif (!this.seeded) {\n\t\t\tthrow new Error('Cluster runtime must be seeded before onCamera')\n\t\t}\n\n\t\twhile (this.k < this.table.events.length && zoom <= this.table.events[this.k].zMerge) {\n\t\t\tapplyEvent(this.visible, this.table.events[this.k])\n\t\t\tthis.k++\n\t\t}\n\t\twhile (this.k > 0 && zoom >= this.table.events[this.k - 1].zSplit) {\n\t\t\tthis.k--\n\t\t\tunapplyEvent(this.visible, this.table.events[this.k])\n\t\t}\n\t}\n\n\tgetVisible(): ReadonlyMap<string, ClusterNode> {\n\t\treturn this.visible\n\t}\n\n\tprivate resetVisible() {\n\t\tthis.visible = new Map()\n\t\tfor (const leaf of this.table.leaves) {\n\t\t\tthis.visible.set(leaf.id, leaf)\n\t\t}\n\t}\n}\n\n/** True iff every member id belonged to the same node of the previous partition. */\nfunction wasMergedTogether(\n\tmembers: readonly string[],\n\townerByMember: ReadonlyMap<string, string>\n): boolean {\n\tconst owner = ownerByMember.get(members[0])\n\tif (owner === undefined) return false\n\tfor (let i = 1; i < members.length; i++) {\n\t\tif (ownerByMember.get(members[i]) !== owner) return false\n\t}\n\treturn true\n}\n\nfunction seedCount(events: readonly MergeEvent[], zoom: number): number {\n\tlet lo = 0\n\tlet hi = events.length\n\twhile (lo < hi) {\n\t\tconst mid = (lo + hi) >> 1\n\t\tif (zoom <= seedThreshold(events[mid])) {\n\t\t\tlo = mid + 1\n\t\t} else {\n\t\t\thi = mid\n\t\t}\n\t}\n\treturn lo\n}\n\nfunction seedThreshold(event: MergeEvent): number {\n\treturn Math.sqrt(event.zMerge * event.zSplit)\n}\n\nfunction applyEvent(visible: Map<string, ClusterNode>, event: MergeEvent) {\n\tfor (const child of event.children) {\n\t\tvisible.delete(child.id)\n\t}\n\tvisible.set(event.result.id, event.result)\n}\n\nfunction unapplyEvent(visible: Map<string, ClusterNode>, event: MergeEvent) {\n\tvisible.delete(event.result.id)\n\tfor (const child of event.children) {\n\t\tvisible.set(child.id, child)\n\t}\n}\n\nfunction validateZoom(zoom: number) {\n\tif (!Number.isFinite(zoom) || zoom <= 0) {\n\t\tthrow new Error('zoom must be finite and greater than 0')\n\t}\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist-cjs/clustering/schedule.js

@@ -0,0 +1,170 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schedule_exports = {};
+__export(schedule_exports, {
+  contract: () => contract,
+  finalize: () => finalize
+});
+module.exports = __toCommonJS(schedule_exports);
+function contract(raw, eps) {
+  if (!Number.isFinite(eps) || eps < 0) {
+    throw new Error("eps must be finite and greater than or equal to 0");
+  }
+  const out = [];
+  let i = 0;
+  while (i < raw.length) {
+    const anchor = raw[i].z;
+    let j = i;
+    while (j + 1 < raw.length && raw[j + 1].z >= anchor / (1 + eps)) {
+      j++;
+    }
+    const chains = contractWindow(raw.slice(i, j + 1), anchor);
+    out.push(...chains);
+    i = j + 1;
+  }
+  return out;
+}
+function finalize(events, opts) {
+  validateFinalizeOptions(opts);
+  const r = opts.Tu / opts.Tc;
+  const zMergeCap = opts.maxSplitZoom / r;
+  const out = [];
+  for (const event of events) {
+    const zMerge = Math.min(event.zMerge, zMergeCap);
+    if (zMerge < opts.minZoom) break;
+    let zSplit = zMerge * r;
+    if (zMerge < opts.maxZoom) {
+      zSplit = Math.min(zSplit, opts.maxZoom);
+    }
+    out.push({
+      zMerge,
+      zSplit,
+      children: event.children,
+      result: event.result
+    });
+  }
+  return out;
+}
+function contractWindow(events, zMerge) {
+  const uf = new ComponentUnionFind(events.length);
+  const resultToIndex = /* @__PURE__ */ new Map();
+  for (let i = 0; i < events.length; i++) {
+    resultToIndex.set(events[i].result.id, i);
+  }
+  for (let i = 0; i < events.length; i++) {
+    for (const child of events[i].children) {
+      const producer = resultToIndex.get(child.id);
+      if (producer !== void 0) {
+        uf.union(i, producer);
+      }
+    }
+  }
+  const byRoot = /* @__PURE__ */ new Map();
+  for (let i = 0; i < events.length; i++) {
+    const root = uf.find(i);
+    const list = byRoot.get(root);
+    if (list) {
+      list.push(i);
+    } else {
+      byRoot.set(root, [i]);
+    }
+  }
+  return Array.from(byRoot.values()).map((indices) => contractChain(events, indices, zMerge)).sort((a, b) => compareNodesByMinMember(a.result, b.result));
+}
+function contractChain(events, indices, zMerge) {
+  const produced = /* @__PURE__ */ new Set();
+  const consumedProduced = /* @__PURE__ */ new Set();
+  for (const index of indices) {
+    produced.add(events[index].result.id);
+  }
+  for (const index of indices) {
+    for (const child of events[index].children) {
+      if (produced.has(child.id)) consumedProduced.add(child.id);
+    }
+  }
+  const childrenById = /* @__PURE__ */ new Map();
+  for (const index of indices) {
+    for (const child of events[index].children) {
+      if (!produced.has(child.id)) childrenById.set(child.id, child);
+    }
+  }
+  let result;
+  for (const index of indices) {
+    const candidate = events[index].result;
+    if (!consumedProduced.has(candidate.id)) {
+      if (!result || compareNodesByMinMember(candidate, result) < 0) result = candidate;
+    }
+  }
+  return {
+    zMerge,
+    children: Array.from(childrenById.values()).sort(compareNodesByMinMember),
+    result
+  };
+}
+function validateFinalizeOptions(opts) {
+  if (!Number.isFinite(opts.maxSplitZoom) || opts.maxSplitZoom <= 0) {
+    throw new Error("maxSplitZoom must be finite and greater than 0");
+  }
+  if (!Number.isFinite(opts.Tc) || opts.Tc <= 0) {
+    throw new Error("Tc must be finite and greater than 0");
+  }
+  if (!Number.isFinite(opts.Tu) || opts.Tu <= opts.Tc) {
+    throw new Error("Tu must be finite and greater than Tc");
+  }
+  if (!Number.isFinite(opts.minZoom) || opts.minZoom <= 0) {
+    throw new Error("minZoom must be finite and greater than 0");
+  }
+  if (!Number.isFinite(opts.maxZoom) || opts.maxZoom <= opts.minZoom) {
+    throw new Error("maxZoom must be finite and greater than minZoom");
+  }
+}
+function compareNodesByMinMember(a, b) {
+  const aMin = a.members[0];
+  const bMin = b.members[0];
+  if (aMin < bMin) return -1;
+  if (aMin > bMin) return 1;
+  return 0;
+}
+class ComponentUnionFind {
+  parent;
+  constructor(n) {
+    this.parent = new Int32Array(n);
+    for (let i = 0; i < n; i++) {
+      this.parent[i] = i;
+    }
+  }
+  find(index) {
+    let root = index;
+    while (this.parent[root] !== root) {
+      root = this.parent[root];
+    }
+    while (this.parent[index] !== index) {
+      const next = this.parent[index];
+      this.parent[index] = root;
+      index = next;
+    }
+    return root;
+  }
+  union(a, b) {
+    const rootA = this.find(a);
+    const rootB = this.find(b);
+    if (rootA !== rootB) this.parent[rootB] = rootA;
+  }
+}
+//# sourceMappingURL=schedule.js.map

package/dist-cjs/clustering/schedule.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/clustering/schedule.ts"],
+  "sourcesContent": ["import type { ClusterNode, ContractedEvent, MergeEvent, RawMergeEvent } from './types'\n\nexport function contract(raw: readonly RawMergeEvent[], eps: number): ContractedEvent[] {\n\tif (!Number.isFinite(eps) || eps < 0) {\n\t\tthrow new Error('eps must be finite and greater than or equal to 0')\n\t}\n\n\tconst out: ContractedEvent[] = []\n\tlet i = 0\n\twhile (i < raw.length) {\n\t\tconst anchor = raw[i].z\n\t\tlet j = i\n\t\twhile (j + 1 < raw.length && raw[j + 1].z >= anchor / (1 + eps)) {\n\t\t\tj++\n\t\t}\n\n\t\tconst chains = contractWindow(raw.slice(i, j + 1), anchor)\n\t\tout.push(...chains)\n\t\ti = j + 1\n\t}\n\n\treturn out\n}\n\nexport function finalize(\n\tevents: readonly ContractedEvent[],\n\topts: { Tc: number; Tu: number; minZoom: number; maxZoom: number; maxSplitZoom: number }\n): MergeEvent[] {\n\tvalidateFinalizeOptions(opts)\n\n\tconst r = opts.Tu / opts.Tc\n\t// Every cluster must have split by maxSplitZoom, however close (or coincident) its members.\n\t// Capping zMerge at maxSplitZoom / r keeps the whole band below the cap, preserving\n\t// zSplit > zMerge and the table's sort order (min with a constant is order-preserving).\n\tconst zMergeCap = opts.maxSplitZoom / r\n\tconst out: MergeEvent[] = []\n\tfor (const event of events) {\n\t\tconst zMerge = Math.min(event.zMerge, zMergeCap)\n\t\tif (zMerge < opts.minZoom) break\n\t\tlet zSplit = zMerge * r\n\t\tif (zMerge < opts.maxZoom) {\n\t\t\tzSplit = Math.min(zSplit, opts.maxZoom)\n\t\t}\n\t\tout.push({\n\t\t\tzMerge,\n\t\t\tzSplit,\n\t\t\tchildren: event.children,\n\t\t\tresult: event.result,\n\t\t})\n\t}\n\treturn out\n}\n\nfunction contractWindow(events: readonly RawMergeEvent[], zMerge: number): ContractedEvent[] {\n\tconst uf = new ComponentUnionFind(events.length)\n\tconst resultToIndex = new Map<string, number>()\n\tfor (let i = 0; i < events.length; i++) {\n\t\tresultToIndex.set(events[i].result.id, i)\n\t}\n\n\tfor (let i = 0; i < events.length; i++) {\n\t\tfor (const child of events[i].children) {\n\t\t\tconst producer = resultToIndex.get(child.id)\n\t\t\tif (producer !== undefined) {\n\t\t\t\tuf.union(i, producer)\n\t\t\t}\n\t\t}\n\t}\n\n\tconst byRoot = new Map<number, number[]>()\n\tfor (let i = 0; i < events.length; i++) {\n\t\tconst root = uf.find(i)\n\t\tconst list = byRoot.get(root)\n\t\tif (list) {\n\t\t\tlist.push(i)\n\t\t} else {\n\t\t\tbyRoot.set(root, [i])\n\t\t}\n\t}\n\n\treturn Array.from(byRoot.values())\n\t\t.map((indices) => contractChain(events, indices, zMerge))\n\t\t.sort((a, b) => compareNodesByMinMember(a.result, b.result))\n}\n\nfunction contractChain(\n\tevents: readonly RawMergeEvent[],\n\tindices: readonly number[],\n\tzMerge: number\n): ContractedEvent {\n\tconst produced = new Set<string>()\n\tconst consumedProduced = new Set<string>()\n\tfor (const index of indices) {\n\t\tproduced.add(events[index].result.id)\n\t}\n\tfor (const index of indices) {\n\t\tfor (const child of events[index].children) {\n\t\t\tif (produced.has(child.id)) consumedProduced.add(child.id)\n\t\t}\n\t}\n\n\tconst childrenById = new Map<string, ClusterNode>()\n\tfor (const index of indices) {\n\t\tfor (const child of events[index].children) {\n\t\t\tif (!produced.has(child.id)) childrenById.set(child.id, child)\n\t\t}\n\t}\n\n\tlet result: ClusterNode | undefined\n\tfor (const index of indices) {\n\t\tconst candidate = events[index].result\n\t\tif (!consumedProduced.has(candidate.id)) {\n\t\t\tif (!result || compareNodesByMinMember(candidate, result) < 0) result = candidate\n\t\t}\n\t}\n\n\treturn {\n\t\tzMerge,\n\t\tchildren: Array.from(childrenById.values()).sort(compareNodesByMinMember),\n\t\tresult: result!,\n\t}\n}\n\nfunction validateFinalizeOptions(opts: {\n\tTc: number\n\tTu: number\n\tminZoom: number\n\tmaxZoom: number\n\tmaxSplitZoom: number\n}) {\n\tif (!Number.isFinite(opts.maxSplitZoom) || opts.maxSplitZoom <= 0) {\n\t\tthrow new Error('maxSplitZoom must be finite and greater than 0')\n\t}\n\tif (!Number.isFinite(opts.Tc) || opts.Tc <= 0) {\n\t\tthrow new Error('Tc must be finite and greater than 0')\n\t}\n\tif (!Number.isFinite(opts.Tu) || opts.Tu <= opts.Tc) {\n\t\tthrow new Error('Tu must be finite and greater than Tc')\n\t}\n\tif (!Number.isFinite(opts.minZoom) || opts.minZoom <= 0) {\n\t\tthrow new Error('minZoom must be finite and greater than 0')\n\t}\n\tif (!Number.isFinite(opts.maxZoom) || opts.maxZoom <= opts.minZoom) {\n\t\tthrow new Error('maxZoom must be finite and greater than minZoom')\n\t}\n}\n\nfunction compareNodesByMinMember(a: ClusterNode, b: ClusterNode): number {\n\tconst aMin = a.members[0]\n\tconst bMin = b.members[0]\n\tif (aMin < bMin) return -1\n\tif (aMin > bMin) return 1\n\treturn 0\n}\n\nclass ComponentUnionFind {\n\tprivate readonly parent: Int32Array\n\n\tconstructor(n: number) {\n\t\tthis.parent = new Int32Array(n)\n\t\tfor (let i = 0; i < n; i++) {\n\t\t\tthis.parent[i] = i\n\t\t}\n\t}\n\n\tfind(index: number): number {\n\t\tlet root = index\n\t\twhile (this.parent[root] !== root) {\n\t\t\troot = this.parent[root]\n\t\t}\n\t\twhile (this.parent[index] !== index) {\n\t\t\tconst next = this.parent[index]\n\t\t\tthis.parent[index] = root\n\t\t\tindex = next\n\t\t}\n\t\treturn root\n\t}\n\n\tunion(a: number, b: number) {\n\t\tconst rootA = this.find(a)\n\t\tconst rootB = this.find(b)\n\t\tif (rootA !== rootB) this.parent[rootB] = rootA\n\t}\n}\n"],
+  "mappings": "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",
+  "names": []
+}