visualproof 0.0.0-stage → 0.2.0

package/dist/web/bundle/layout.js

@@ -0,0 +1,1010 @@
+// node_modules/d3-hierarchy/src/lcg.js
+var a = 1664525;
+var c = 1013904223;
+var m = 4294967296;
+function lcg_default() {
+  let s = 1;
+  return () => (s = (a * s + c) % m) / m;
+}
+
+// node_modules/d3-hierarchy/src/array.js
+function array_default(x) {
+  return typeof x === "object" && "length" in x ? x : Array.from(x);
+}
+function shuffle(array, random) {
+  let m2 = array.length, t, i;
+  while (m2) {
+    i = random() * m2-- | 0;
+    t = array[m2];
+    array[m2] = array[i];
+    array[i] = t;
+  }
+  return array;
+}
+
+// node_modules/d3-hierarchy/src/pack/enclose.js
+function enclose_default(circles) {
+  return packEncloseRandom(circles, lcg_default());
+}
+function packEncloseRandom(circles, random) {
+  var i = 0, n = (circles = shuffle(Array.from(circles), random)).length, B = [], p, e;
+  while (i < n) {
+    p = circles[i];
+    if (e && enclosesWeak(e, p)) ++i;
+    else e = encloseBasis(B = extendBasis(B, p)), i = 0;
+  }
+  return e;
+}
+function extendBasis(B, p) {
+  var i, j;
+  if (enclosesWeakAll(p, B)) return [p];
+  for (i = 0; i < B.length; ++i) {
+    if (enclosesNot(p, B[i]) && enclosesWeakAll(encloseBasis2(B[i], p), B)) {
+      return [B[i], p];
+    }
+  }
+  for (i = 0; i < B.length - 1; ++i) {
+    for (j = i + 1; j < B.length; ++j) {
+      if (enclosesNot(encloseBasis2(B[i], B[j]), p) && enclosesNot(encloseBasis2(B[i], p), B[j]) && enclosesNot(encloseBasis2(B[j], p), B[i]) && enclosesWeakAll(encloseBasis3(B[i], B[j], p), B)) {
+        return [B[i], B[j], p];
+      }
+    }
+  }
+  throw new Error();
+}
+function enclosesNot(a2, b) {
+  var dr = a2.r - b.r, dx = b.x - a2.x, dy = b.y - a2.y;
+  return dr < 0 || dr * dr < dx * dx + dy * dy;
+}
+function enclosesWeak(a2, b) {
+  var dr = a2.r - b.r + Math.max(a2.r, b.r, 1) * 1e-9, dx = b.x - a2.x, dy = b.y - a2.y;
+  return dr > 0 && dr * dr > dx * dx + dy * dy;
+}
+function enclosesWeakAll(a2, B) {
+  for (var i = 0; i < B.length; ++i) {
+    if (!enclosesWeak(a2, B[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+function encloseBasis(B) {
+  switch (B.length) {
+    case 1:
+      return encloseBasis1(B[0]);
+    case 2:
+      return encloseBasis2(B[0], B[1]);
+    case 3:
+      return encloseBasis3(B[0], B[1], B[2]);
+  }
+}
+function encloseBasis1(a2) {
+  return {
+    x: a2.x,
+    y: a2.y,
+    r: a2.r
+  };
+}
+function encloseBasis2(a2, b) {
+  var x1 = a2.x, y1 = a2.y, r1 = a2.r, x2 = b.x, y2 = b.y, r2 = b.r, x21 = x2 - x1, y21 = y2 - y1, r21 = r2 - r1, l = Math.sqrt(x21 * x21 + y21 * y21);
+  return {
+    x: (x1 + x2 + x21 / l * r21) / 2,
+    y: (y1 + y2 + y21 / l * r21) / 2,
+    r: (l + r1 + r2) / 2
+  };
+}
+function encloseBasis3(a2, b, c2) {
+  var x1 = a2.x, y1 = a2.y, r1 = a2.r, x2 = b.x, y2 = b.y, r2 = b.r, x3 = c2.x, y3 = c2.y, r3 = c2.r, a22 = x1 - x2, a3 = x1 - x3, b2 = y1 - y2, b3 = y1 - y3, c22 = r2 - r1, c3 = r3 - r1, d1 = x1 * x1 + y1 * y1 - r1 * r1, d2 = d1 - x2 * x2 - y2 * y2 + r2 * r2, d3 = d1 - x3 * x3 - y3 * y3 + r3 * r3, ab = a3 * b2 - a22 * b3, xa = (b2 * d3 - b3 * d2) / (ab * 2) - x1, xb = (b3 * c22 - b2 * c3) / ab, ya = (a3 * d2 - a22 * d3) / (ab * 2) - y1, yb = (a22 * c3 - a3 * c22) / ab, A = xb * xb + yb * yb - 1, B = 2 * (r1 + xa * xb + ya * yb), C = xa * xa + ya * ya - r1 * r1, r = -(Math.abs(A) > 1e-6 ? (B + Math.sqrt(B * B - 4 * A * C)) / (2 * A) : C / B);
+  return {
+    x: x1 + xa + xb * r,
+    y: y1 + ya + yb * r,
+    r
+  };
+}
+
+// node_modules/d3-hierarchy/src/pack/siblings.js
+function place(b, a2, c2) {
+  var dx = b.x - a2.x, x, a22, dy = b.y - a2.y, y, b2, d2 = dx * dx + dy * dy;
+  if (d2) {
+    a22 = a2.r + c2.r, a22 *= a22;
+    b2 = b.r + c2.r, b2 *= b2;
+    if (a22 > b2) {
+      x = (d2 + b2 - a22) / (2 * d2);
+      y = Math.sqrt(Math.max(0, b2 / d2 - x * x));
+      c2.x = b.x - x * dx - y * dy;
+      c2.y = b.y - x * dy + y * dx;
+    } else {
+      x = (d2 + a22 - b2) / (2 * d2);
+      y = Math.sqrt(Math.max(0, a22 / d2 - x * x));
+      c2.x = a2.x + x * dx - y * dy;
+      c2.y = a2.y + x * dy + y * dx;
+    }
+  } else {
+    c2.x = a2.x + c2.r;
+    c2.y = a2.y;
+  }
+}
+function intersects(a2, b) {
+  var dr = a2.r + b.r - 1e-6, dx = b.x - a2.x, dy = b.y - a2.y;
+  return dr > 0 && dr * dr > dx * dx + dy * dy;
+}
+function score(node) {
+  var a2 = node._, b = node.next._, ab = a2.r + b.r, dx = (a2.x * b.r + b.x * a2.r) / ab, dy = (a2.y * b.r + b.y * a2.r) / ab;
+  return dx * dx + dy * dy;
+}
+function Node(circle) {
+  this._ = circle;
+  this.next = null;
+  this.previous = null;
+}
+function packSiblingsRandom(circles, random) {
+  if (!(n = (circles = array_default(circles)).length)) return 0;
+  var a2, b, c2, n, aa, ca, i, j, k, sj, sk;
+  a2 = circles[0], a2.x = 0, a2.y = 0;
+  if (!(n > 1)) return a2.r;
+  b = circles[1], a2.x = -b.r, b.x = a2.r, b.y = 0;
+  if (!(n > 2)) return a2.r + b.r;
+  place(b, a2, c2 = circles[2]);
+  a2 = new Node(a2), b = new Node(b), c2 = new Node(c2);
+  a2.next = c2.previous = b;
+  b.next = a2.previous = c2;
+  c2.next = b.previous = a2;
+  pack: for (i = 3; i < n; ++i) {
+    place(a2._, b._, c2 = circles[i]), c2 = new Node(c2);
+    j = b.next, k = a2.previous, sj = b._.r, sk = a2._.r;
+    do {
+      if (sj <= sk) {
+        if (intersects(j._, c2._)) {
+          b = j, a2.next = b, b.previous = a2, --i;
+          continue pack;
+        }
+        sj += j._.r, j = j.next;
+      } else {
+        if (intersects(k._, c2._)) {
+          a2 = k, a2.next = b, b.previous = a2, --i;
+          continue pack;
+        }
+        sk += k._.r, k = k.previous;
+      }
+    } while (j !== k.next);
+    c2.previous = a2, c2.next = b, a2.next = b.previous = b = c2;
+    aa = score(a2);
+    while ((c2 = c2.next) !== b) {
+      if ((ca = score(c2)) < aa) {
+        a2 = c2, aa = ca;
+      }
+    }
+    b = a2.next;
+  }
+  a2 = [b._], c2 = b;
+  while ((c2 = c2.next) !== b) a2.push(c2._);
+  c2 = packEncloseRandom(a2, random);
+  for (i = 0; i < n; ++i) a2 = circles[i], a2.x -= c2.x, a2.y -= c2.y;
+  return c2.r;
+}
+function siblings_default(circles) {
+  packSiblingsRandom(circles, lcg_default());
+  return circles;
+}
+
+// src/shared/separate.ts
+var SLACK = 0.5;
+var Separator = class {
+  head = new Int32Array(0);
+  next = new Int32Array(0);
+  mask = 0;
+  moved = new Uint8Array(0);
+  movedNext = new Uint8Array(0);
+  movedSmall = new Int32Array(0);
+  cell;
+  constructor(cell) {
+    this.cell = cell;
+  }
+  ensure(n, nSmall) {
+    if (this.next.length < n) {
+      this.next = new Int32Array(n);
+      this.moved = new Uint8Array(n);
+      this.movedNext = new Uint8Array(n);
+      this.movedSmall = new Int32Array(n);
+    }
+    let size = 64;
+    while (size < 2 * nSmall) size <<= 1;
+    if (this.head.length !== size) this.head = new Int32Array(size);
+    this.mask = size - 1;
+  }
+  key(x, y) {
+    return (Math.imul(Math.floor(x / this.cell), 73856093) ^ Math.imul(Math.floor(y / this.cell), 19349663)) & this.mask;
+  }
+  build(B) {
+    this.head.fill(-1);
+    for (let s = 0; s < B.small.length; s++) {
+      const k = B.small[s];
+      const h = this.key(B.x[k], B.y[k]);
+      this.next[k] = this.head[h];
+      this.head[h] = k;
+    }
+  }
+  /** Push a and b apart if they overlap; marks what moved. */
+  push(B, a2, b) {
+    const dx = B.x[b] - B.x[a2], dy = B.y[b] - B.y[a2];
+    const need = B.r[a2] + B.r[b];
+    const d2 = dx * dx + dy * dy;
+    if (d2 >= (need - SLACK) * (need - SLACK)) return false;
+    const pa = B.pinned[a2], pb = B.pinned[b];
+    const fixA = pa && (!pb || B.seq[a2] > B.seq[b]);
+    const fixB = pb && (!pa || B.seq[b] > B.seq[a2]);
+    const d = Math.sqrt(d2) || 1e-3;
+    const over = need - d;
+    const ra = B.r[a2] * B.r[a2], rb = B.r[b] * B.r[b];
+    const wa = fixA ? 0 : fixB ? 1 : rb / (ra + rb);
+    const ux = d2 ? dx / d : 1, uy = d2 ? dy / d : 0;
+    if (wa > 0) {
+      B.x[a2] -= ux * over * wa;
+      B.y[a2] -= uy * over * wa;
+      this.movedNext[a2] = 1;
+    }
+    if (wa < 1) {
+      B.x[b] += ux * over * (1 - wa);
+      B.y[b] += uy * over * (1 - wa);
+      this.movedNext[b] = 1;
+    }
+    return true;
+  }
+  overlap(B, a2, b) {
+    const dx = B.x[b] - B.x[a2], dy = B.y[b] - B.y[a2];
+    const need = B.r[a2] + B.r[b] - SLACK;
+    return dx * dx + dy * dy < need * need;
+  }
+  /**
+   * Up to `rounds` rounds of separation. After each round a body further from the origin than
+   * `limit[k]` is brought back to it (null: no limit). Returns whether anything still moved in
+   * the last round.
+   */
+  separate(B, rounds, limit) {
+    const { big, small } = B;
+    this.ensure(B.n, small.length);
+    const moved = this.moved, next = this.movedNext;
+    moved.fill(1, 0, B.n);
+    let any = false;
+    for (let round2 = 0; round2 < rounds; round2++) {
+      any = false;
+      next.fill(0, 0, B.n);
+      this.build(B);
+      let nMovedSmall = 0;
+      for (let s = 0; s < small.length; s++) if (moved[small[s]]) this.movedSmall[nMovedSmall++] = small[s];
+      for (let p = 0; p < big.length; p++) {
+        const a2 = big[p];
+        for (let q = p + 1; q < big.length; q++) {
+          const b = big[q];
+          if ((moved[a2] || moved[b]) && this.push(B, a2, b)) any = true;
+        }
+        if (moved[a2]) {
+          for (let s = 0; s < small.length; s++) if (this.push(B, a2, small[s])) any = true;
+        } else {
+          for (let s = 0; s < nMovedSmall; s++) if (this.push(B, a2, this.movedSmall[s])) any = true;
+        }
+      }
+      for (let s = 0; s < nMovedSmall; s++) {
+        const a2 = this.movedSmall[s];
+        const gx = Math.floor(B.x[a2] / this.cell), gy = Math.floor(B.y[a2] / this.cell);
+        for (let i = gx - 1; i <= gx + 1; i++) {
+          for (let j = gy - 1; j <= gy + 1; j++) {
+            const h = (Math.imul(i, 73856093) ^ Math.imul(j, 19349663)) & this.mask;
+            for (let b = this.head[h]; b >= 0; b = this.next[b]) {
+              if (b === a2 || moved[b] && b < a2) continue;
+              if (this.push(B, a2, b)) any = true;
+            }
+          }
+        }
+      }
+      if (limit) {
+        for (let k = 0; k < B.n; k++) {
+          const d = Math.hypot(B.x[k], B.y[k]);
+          if (d > limit[k]) {
+            B.x[k] *= limit[k] / d;
+            B.y[k] *= limit[k] / d;
+            next[k] = 1;
+          }
+        }
+      }
+      moved.set(next.subarray(0, B.n));
+      if (!any) break;
+    }
+    return any;
+  }
+  /** Whether any two bodies overlap (two drops on each other included). */
+  overlaps(B) {
+    const { big, small } = B;
+    this.ensure(B.n, small.length);
+    for (let p = 0; p < big.length; p++) {
+      for (let q = p + 1; q < big.length; q++) if (this.overlap(B, big[p], big[q])) return true;
+      for (let s = 0; s < small.length; s++) if (this.overlap(B, big[p], small[s])) return true;
+    }
+    this.build(B);
+    for (let s = 0; s < small.length; s++) {
+      const a2 = small[s];
+      const gx = Math.floor(B.x[a2] / this.cell), gy = Math.floor(B.y[a2] / this.cell);
+      for (let i = gx - 1; i <= gx + 1; i++) {
+        for (let j = gy - 1; j <= gy + 1; j++) {
+          const h = (Math.imul(i, 73856093) ^ Math.imul(j, 19349663)) & this.mask;
+          for (let b = this.head[h]; b >= 0; b = this.next[b]) if (b > a2 && this.overlap(B, a2, b)) return true;
+        }
+      }
+    }
+    return false;
+  }
+};
+
+// src/shared/layout.ts
+var LEAF_R = 5;
+var GAP = 2.5;
+var EXT_KEY = "\u27E8external\u27E9";
+function splitName(name) {
+  const out = [];
+  let cur = "";
+  let depth = 0;
+  for (const ch of name) {
+    if (ch === "\xAB") depth++;
+    else if (ch === "\xBB") depth--;
+    if (ch === "." && depth === 0) {
+      out.push(cur);
+      cur = "";
+    } else cur += ch;
+  }
+  out.push(cur);
+  return out;
+}
+function tnode(key, label, parent, ext) {
+  const none = new Float64Array(0);
+  return { key, label, parent, kids: /* @__PURE__ */ new Map(), leaves: [], ext, count: 0, x: 0, y: 0, r: 0, id: -1, slot: 0, m: 0, flow: /* @__PURE__ */ new Map(), gOut: none, gIn: none };
+}
+function pathOf(mode, n, prefixes) {
+  if (n.ext) {
+    if (mode === "module") return [EXT_KEY, ...n.module.split(".").slice(0, 2)];
+    const parts2 = splitName(n.name);
+    return parts2.length > 1 ? [EXT_KEY, parts2[0]] : [EXT_KEY];
+  }
+  if (mode === "module") return n.module.split(".");
+  const parts = splitName(n.name);
+  return prefixes.has(n.name) ? parts : parts.slice(0, -1);
+}
+function potentials(c2) {
+  const m2 = c2.m;
+  const pa = [], pb = [], pc = [];
+  const rhs = new Float64Array(m2);
+  const diag = new Float64Array(m2);
+  const join = (a2, b, ab, ba) => {
+    const tot = ab + ba;
+    const g = Math.log1p(tot);
+    const drop = (ab - ba) / tot;
+    rhs[a2] += g * drop;
+    diag[a2] += g;
+    if (b < m2) {
+      rhs[b] -= g * drop;
+      diag[b] += g;
+      pa.push(a2);
+      pb.push(b);
+      pc.push(g);
+    }
+  };
+  for (const [key, ab] of c2.flow) {
+    const a2 = Math.floor(key / (m2 + 1)), b = key - a2 * (m2 + 1);
+    const ba = c2.flow.get(b * (m2 + 1) + a2) ?? 0;
+    if (a2 < b || ba === 0) join(a2, b, ab, ba);
+  }
+  for (let a2 = 0; a2 < m2; a2++) if (c2.gOut[a2] + c2.gIn[a2] > 0) join(a2, m2, c2.gOut[a2], c2.gIn[a2]);
+  const EPS = 1e-4;
+  const mul = (x, y) => {
+    for (let k = 0; k < m2; k++) y[k] = (diag[k] + EPS) * x[k];
+    for (let e = 0; e < pa.length; e++) {
+      const a2 = pa[e], b = pb[e], g = pc[e];
+      y[a2] -= g * x[b];
+      y[b] -= g * x[a2];
+    }
+  };
+  const phi = new Float64Array(m2);
+  const r = rhs.slice();
+  const p = r.slice();
+  const Ap = new Float64Array(m2);
+  let rr = r.reduce((s, v) => s + v * v, 0);
+  const stop = rr * 1e-12;
+  for (let it = 0; it < 1e3 && rr > stop && rr > 0; it++) {
+    mul(p, Ap);
+    let pAp = 0;
+    for (let k = 0; k < m2; k++) pAp += p[k] * Ap[k];
+    const alpha = rr / pAp;
+    let next = 0;
+    for (let k = 0; k < m2; k++) {
+      phi[k] += alpha * p[k];
+      r[k] -= alpha * Ap[k];
+      next += r[k] * r[k];
+    }
+    const beta = next / rr;
+    rr = next;
+    for (let k = 0; k < m2; k++) p[k] = r[k] + beta * p[k];
+  }
+  return phi;
+}
+var separator = new Separator(2 * LEAF_R + GAP);
+var PITCH = 2 * LEAF_R + 0.3;
+function settle(items, phi) {
+  const n = items.length;
+  const order = [...items.keys()].sort((p, q) => phi[q] - phi[p] || p - q);
+  let total = 0;
+  for (const it of items) total += Math.PI * (it.r + 0.3) ** 2;
+  const R = Math.sqrt(total / (Math.PI * 0.78));
+  const above = (t) => (Math.acos(t) - t * Math.sqrt(1 - t * t)) / Math.PI;
+  const heightOf = (f) => {
+    let lo = -1, hi = 1;
+    for (let k = 0; k < 40; k++) {
+      const mid = (lo + hi) / 2;
+      if (above(mid) > f) lo = mid;
+      else hi = mid;
+    }
+    return (lo + hi) / 2;
+  };
+  const share = new Float64Array(n);
+  let acc = 0;
+  for (const k of order) {
+    const a2 = Math.PI * (items[k].r + 0.3) ** 2;
+    share[k] = heightOf((acc + a2 / 2) / total);
+    acc += a2;
+  }
+  const big = [...items.keys()].filter((k) => items[k].sub).sort((p, q) => items[q].r - items[p].r || p - q);
+  const leaves = order.filter((k) => !items[k].sub);
+  if (big.length === 0) {
+    const spots = siblings_default(leaves.map(() => ({ x: 0, y: 0, r: LEAF_R + 0.15 })));
+    spots.sort((a2, b) => a2.y - b.y || a2.x - b.x);
+    leaves.forEach((k, j) => {
+      items[k].x = spots[j].x;
+      items[k].y = spots[j].y;
+    });
+    return;
+  }
+  let scale = R;
+  for (let pass = 0; pass < 3; pass++) {
+    place2(share.map((t) => -t * scale));
+    let x0 = Infinity, x1 = -Infinity, y0 = Infinity, y1 = -Infinity;
+    for (const it of items) {
+      x0 = Math.min(x0, it.x - it.r);
+      x1 = Math.max(x1, it.x + it.r);
+      y0 = Math.min(y0, it.y - it.r);
+      y1 = Math.max(y1, it.y + it.r);
+    }
+    const aspect = (x1 - x0) / Math.max(1e-6, y1 - y0);
+    if (Math.abs(aspect - 1) < 0.06 || big.length === 0) break;
+    scale *= Math.sqrt(aspect);
+  }
+  finish();
+  function place2(ty) {
+    const px = [], py = [], pr = [];
+    const free = (x, y, r) => {
+      for (let j = 0; j < px.length; j++) {
+        const need = r + pr[j] + 0.3;
+        if ((x - px[j]) ** 2 + (y - py[j]) ** 2 < need * need) return false;
+      }
+      return true;
+    };
+    const cost = (x, y, t) => (y - t) ** 2 + 0.3 * x * x;
+    const ANGLES = 24;
+    for (const k of big) {
+      const r = items[k].r;
+      const t = ty[k];
+      let bx = 0, by = t, best = free(0, t, r) ? 0 : Infinity;
+      if (best > 0) {
+        const near = px.map((_, j) => j).sort((a2, b) => Math.hypot(px[a2], py[a2] - t) - pr[a2] - (Math.hypot(px[b], py[b] - t) - pr[b])).slice(0, 12);
+        for (const j of near) {
+          const d = r + pr[j] + 0.3;
+          for (let s = 0; s < ANGLES; s++) {
+            const a2 = 2 * Math.PI * s / ANGLES;
+            const x = px[j] + d * Math.cos(a2), y = py[j] + d * Math.sin(a2);
+            const c2 = cost(x, y, t);
+            if (c2 < best && free(x, y, r)) {
+              best = c2;
+              bx = x;
+              by = y;
+            }
+          }
+        }
+        for (let step = 1; best === Infinity; step++) {
+          for (const x of [step * r, -step * r]) if (best === Infinity && free(x, t, r)) [best, bx, by] = [0, x, t];
+        }
+      }
+      items[k].x = bx;
+      items[k].y = by;
+      px.push(bx);
+      py.push(by);
+      pr.push(r);
+    }
+    if (big.length > 1) {
+      const D = {
+        n: big.length,
+        x: Float64Array.from(px),
+        y: Float64Array.from(py),
+        r: Float64Array.from(pr, (r) => r + 0.3),
+        pinned: new Uint8Array(big.length),
+        seq: new Float64Array(big.length),
+        big: Int32Array.from(big.keys()),
+        small: new Int32Array(0)
+      };
+      for (let it = 0; it < 80; it++) {
+        for (let j = 0; j < big.length; j++) {
+          D.x[j] *= 0.93;
+          D.y[j] += (ty[big[j]] - D.y[j]) * 0.1;
+          D.y[j] *= 0.985;
+        }
+        separator.separate(D, 4, null);
+      }
+      for (let guard = 0; guard < 20 && separator.overlaps(D); guard++) separator.separate(D, 50, null);
+      big.forEach((k, j) => {
+        items[k].x = px[j] = D.x[j];
+        items[k].y = py[j] = D.y[j];
+      });
+    }
+    if (leaves.length) {
+      const rowH = PITCH * Math.sqrt(3) / 2;
+      let Rl = Math.sqrt(leaves.length) * PITCH * 0.55 + 2 * PITCH;
+      let cells = [];
+      for (let attempt = 0; attempt < 60; attempt++) {
+        cells = [];
+        const rows = Math.ceil(Rl / rowH);
+        for (let j = -rows; j <= rows; j++) {
+          const y = j * rowH;
+          const off = j & 1 ? PITCH / 2 : 0;
+          const cols = Math.ceil(Rl / PITCH) + 1;
+          for (let i = -cols; i <= cols; i++) {
+            const x = i * PITCH + off;
+            const d2 = x * x + y * y;
+            if (d2 > Rl * Rl) continue;
+            let ok = true;
+            for (let q = 0; q < px.length && ok; q++) {
+              const need = pr[q] + LEAF_R + 0.3;
+              if ((x - px[q]) ** 2 + (y - py[q]) ** 2 < need * need) ok = false;
+            }
+            if (ok) cells.push([x, y, d2]);
+          }
+        }
+        if (cells.length >= leaves.length) break;
+        Rl *= 1.08;
+      }
+      cells.sort((a2, b) => a2[2] - b[2] || a2[1] - b[1] || a2[0] - b[0]);
+      const chosen = cells.slice(0, leaves.length).sort((a2, b) => a2[1] - b[1] || a2[0] - b[0]);
+      leaves.forEach((k, j) => {
+        items[k].x = chosen[j][0];
+        items[k].y = chosen[j][1];
+      });
+    }
+  }
+  function finish() {
+    const B = {
+      n,
+      x: Float64Array.from(items, (it) => it.x),
+      y: Float64Array.from(items, (it) => it.y),
+      r: Float64Array.from(items, (it) => it.r + 0.3),
+      pinned: new Uint8Array(n),
+      seq: new Float64Array(n),
+      big: Int32Array.from(big),
+      small: Int32Array.from(leaves)
+    };
+    if (separator.overlaps(B)) {
+      for (let guard = 0; guard < 20 && separator.overlaps(B); guard++) separator.separate(B, 50, null);
+      items.forEach((it, k) => {
+        it.x = B.x[k];
+        it.y = B.y[k];
+      });
+    }
+  }
+}
+function layoutCluster(c2, pos) {
+  for (const k of c2.kids.values()) layoutCluster(k, pos);
+  const items = [];
+  for (const k of c2.kids.values()) items.push({ key: "c:" + k.key, r: k.r, x: 0, y: 0, sub: k });
+  for (const n of c2.leaves) items.push({ key: "n:" + n, r: LEAF_R, x: 0, y: 0, leaf: n });
+  c2.count = c2.leaves.length + [...c2.kids.values()].reduce((a2, k) => a2 + k.count, 0);
+  if (items.length === 1) {
+    items[0].x = 0;
+    items[0].y = 0;
+  } else if (items.length > 1) {
+    settle(items, potentials(c2));
+  }
+  const enc = items.length ? enclose_default(items.map((i) => ({ x: i.x, y: i.y, r: i.r }))) : { x: 0, y: 0, r: 0 };
+  const pad = c2.parent ? 10 + Math.min(14, Math.sqrt(c2.count)) : 0;
+  c2.r = (enc?.r ?? 0) + pad;
+  for (const it of items) {
+    const x = it.x - (enc?.x ?? 0);
+    const y = it.y - (enc?.y ?? 0);
+    if (it.sub) {
+      it.sub.x = x;
+      it.sub.y = y;
+    } else {
+      pos[2 * it.leaf] = x;
+      pos[2 * it.leaf + 1] = y;
+    }
+  }
+}
+function buildTree(mode, nodes, hidden) {
+  const prefixes = /* @__PURE__ */ new Set();
+  if (mode === "namespace") {
+    for (const n of nodes) {
+      if (n.ext) continue;
+      const parts = splitName(n.name);
+      for (let i = 1; i < parts.length; i++) prefixes.add(parts.slice(0, i).join("."));
+    }
+  }
+  const root = tnode("", "", null, false);
+  const home = new Array(nodes.length);
+  nodes.forEach((n, i) => {
+    let cur = root;
+    for (const part of pathOf(mode, n, prefixes)) {
+      const key = cur.key ? `${cur.key}.${part}` : part;
+      let next = cur.kids.get(part);
+      if (!next) {
+        next = tnode(key, part === EXT_KEY ? "External" : part, cur, cur.ext || part === EXT_KEY);
+        cur.kids.set(part, next);
+      }
+      cur = next;
+    }
+    cur.leaves.push(i);
+  });
+  const collapse = (c2) => {
+    for (const [part, k] of [...c2.kids]) {
+      let kid = k;
+      while (kid.leaves.length === 0 && kid.kids.size === 1 && kid.key !== EXT_KEY) {
+        const only = [...kid.kids.values()][0];
+        only.label = `${kid.label}.${only.label}`;
+        only.parent = c2;
+        kid = only;
+      }
+      c2.kids.set(part, kid);
+      collapse(kid);
+    }
+  };
+  collapse(root);
+  const via = /* @__PURE__ */ new Map();
+  const lift = (c2) => {
+    const kids = /* @__PURE__ */ new Map();
+    for (const k of c2.kids.values()) {
+      lift(k);
+      if (!hidden.has(k.key)) {
+        kids.set(k.key, k);
+        continue;
+      }
+      for (const kk of k.kids.values()) {
+        kk.parent = c2;
+        via.set(kk, [k.label, ...via.get(kk) ?? []]);
+        kids.set(kk.key, kk);
+      }
+      c2.leaves.push(...k.leaves);
+    }
+    c2.kids = kids;
+    if (hidden.has(c2.key)) return;
+    const seen = /* @__PURE__ */ new Map();
+    for (const k of kids.values()) seen.set(k.label, (seen.get(k.label) ?? 0) + 1);
+    for (const k of kids.values()) if (seen.get(k.label) > 1 && via.has(k)) k.label = [...via.get(k), k.label].join(".");
+  };
+  if (hidden.size) lift(root);
+  const reindex = (c2) => {
+    for (const n of c2.leaves) home[n] = c2;
+    for (const k of c2.kids.values()) reindex(k);
+  };
+  reindex(root);
+  return { root, home };
+}
+function flatten(root, n, rel) {
+  const clusters = [];
+  const x = new Array(n).fill(0);
+  const y = new Array(n).fill(0);
+  const cluster = new Array(n).fill(-1);
+  const place2 = (c2, ox, oy, parentId, depth) => {
+    const cx = ox + c2.x;
+    const cy = oy + c2.y;
+    let id = parentId;
+    if (c2.parent) {
+      id = clusters.length;
+      c2.id = id;
+      clusters.push({
+        key: c2.key,
+        label: c2.label,
+        parent: parentId,
+        depth,
+        x: round(cx),
+        y: round(cy),
+        lx: 0,
+        ly: 0,
+        r: round(c2.r),
+        count: c2.count,
+        ext: c2.ext
+      });
+    }
+    for (const i of c2.leaves) {
+      if (rel) {
+        x[i] = round(cx + rel[2 * i]);
+        y[i] = round(cy + rel[2 * i + 1]);
+      }
+      cluster[i] = id;
+    }
+    for (const k of c2.kids.values()) place2(k, cx, cy, id, c2.parent ? depth + 1 : 0);
+  };
+  place2(root, 0, 0, -1, 0);
+  return withLocal({ x, y, lx: [], ly: [], cluster, clusters });
+}
+function computeLayout(mode, nodes, edges, hidden = []) {
+  const { root, home } = buildTree(mode, nodes, new Set(hidden));
+  const leafSlot = new Int32Array(nodes.length);
+  const number = (c2) => {
+    let s = 0;
+    for (const k of c2.kids.values()) {
+      k.slot = s++;
+      number(k);
+    }
+    for (const n of c2.leaves) leafSlot[n] = s++;
+    c2.m = s;
+    c2.gOut = new Float64Array(s);
+    c2.gIn = new Float64Array(s);
+  };
+  number(root);
+  const chain = (c2) => {
+    const out = [];
+    for (let x = c2; x; x = x.parent) out.push(x);
+    return out.reverse();
+  };
+  const chains = /* @__PURE__ */ new Map();
+  const chainOf = (c2) => {
+    let ch = chains.get(c2);
+    if (!ch) chains.set(c2, ch = chain(c2));
+    return ch;
+  };
+  for (let e = 0; e < edges.length; e += 3) {
+    const u = edges[e];
+    const v = edges[e + 1];
+    if (u === v) continue;
+    const cu = chainOf(home[u]);
+    const cv = chainOf(home[v]);
+    let i = 0;
+    while (i < cu.length && i < cv.length && cu[i] === cv[i]) i++;
+    const meet = cu[i - 1];
+    const a2 = i < cu.length ? cu[i].slot : leafSlot[u];
+    const b = i < cv.length ? cv[i].slot : leafSlot[v];
+    if (a2 !== b) {
+      const key = a2 * (meet.m + 1) + b;
+      meet.flow.set(key, (meet.flow.get(key) ?? 0) + 1);
+    }
+    for (let j = i; j < cu.length; j++) cu[j].gOut[j + 1 < cu.length ? cu[j + 1].slot : leafSlot[u]]++;
+    for (let j = i; j < cv.length; j++) cv[j].gIn[j + 1 < cv.length ? cv[j + 1].slot : leafSlot[v]]++;
+  }
+  const rel = new Float64Array(nodes.length * 2);
+  layoutCluster(root, rel);
+  return flatten(root, nodes.length, rel);
+}
+function withLocal(L) {
+  for (const c2 of L.clusters) {
+    const p = c2.parent >= 0 ? L.clusters[c2.parent] : null;
+    c2.lx = round(c2.x - (p ? p.x : 0));
+    c2.ly = round(c2.y - (p ? p.y : 0));
+  }
+  L.lx = L.x.map((x, i) => round(x - (L.cluster[i] >= 0 ? L.clusters[L.cluster[i]].x : 0)));
+  L.ly = L.y.map((y, i) => round(y - (L.cluster[i] >= 0 ? L.clusters[L.cluster[i]].y : 0)));
+  return L;
+}
+function round(v) {
+  return Math.round(v * 10) / 10;
+}
+var SPACING = 2 * LEAF_R;
+var Occupancy = class {
+  cells = /* @__PURE__ */ new Map();
+  key(x, y) {
+    return `${Math.floor(x / SPACING)},${Math.floor(y / SPACING)}`;
+  }
+  add(x, y) {
+    const k = this.key(x, y);
+    const c2 = this.cells.get(k);
+    if (c2) c2.push([x, y]);
+    else this.cells.set(k, [[x, y]]);
+  }
+  free(x, y) {
+    const gx = Math.floor(x / SPACING);
+    const gy = Math.floor(y / SPACING);
+    for (let i = gx - 1; i <= gx + 1; i++) {
+      for (let j = gy - 1; j <= gy + 1; j++) {
+        for (const [px, py] of this.cells.get(`${i},${j}`) ?? []) {
+          if ((px - x) ** 2 + (py - y) ** 2 < SPACING * SPACING) return false;
+        }
+      }
+    }
+    return true;
+  }
+};
+function nearestFree(occ, x, y, discs = []) {
+  const ok = (px, py) => occ.free(px, py) && discs.every((d) => (d.x - px) ** 2 + (d.y - py) ** 2 >= (d.r + LEAF_R) ** 2);
+  if (ok(x, y)) return [x, y];
+  for (let ring = 1; ring < 400; ring++) {
+    const n = 6 * ring;
+    for (let k = 0; k < n; k++) {
+      const a2 = 2 * Math.PI * k / n;
+      const px = x + Math.cos(a2) * ring * SPACING;
+      const py = y + Math.sin(a2) * ring * SPACING;
+      if (ok(px, py)) return [px, py];
+    }
+  }
+  return [x, y];
+}
+function stabilize(fresh, nodes, mem) {
+  if (!mem) return fresh;
+  const survivors = nodes.filter((n) => mem.nodes[n.name]).length;
+  if (survivors < nodes.length * 0.5) return fresh;
+  const MOVE = 0.1;
+  const extent = (xs) => Math.max(1, ...xs.map(([x2, y2, r]) => Math.hypot(x2, y2) + r));
+  const freshTop = extent(fresh.clusters.filter((c2) => c2.parent < 0).map((c2) => [c2.x, c2.y, c2.r]));
+  const oldTop = extent(Object.values(mem.clusters));
+  const keeps = (fy, fr, oy, or) => Math.abs(fy / fr - oy / or) <= MOVE;
+  const cs = fresh.clusters.map((c2) => ({ ...c2 }));
+  for (let i = 0; i < cs.length; i++) {
+    const c2 = cs[i];
+    const p = c2.parent;
+    const fp = p >= 0 ? fresh.clusters[p] : null;
+    const old = mem.clusters[c2.key];
+    const oldP = p >= 0 ? mem.clusters[cs[p].key] : null;
+    const px = p >= 0 ? cs[p].x : 0, py = p >= 0 ? cs[p].y : 0;
+    const fx = fresh.clusters[i].x - (fp ? fp.x : 0), fy = fresh.clusters[i].y - (fp ? fp.y : 0);
+    if (old && (p < 0 || oldP)) {
+      const ox = old[0] - (oldP ? oldP[0] : 0), oy = old[1] - (oldP ? oldP[1] : 0);
+      if (keeps(fy, fp ? fp.r : freshTop, oy, oldP ? oldP[2] : oldTop)) {
+        c2.x = round(px + ox);
+        c2.y = round(py + oy);
+        c2.r = old[2];
+        continue;
+      }
+    }
+    c2.x = round(px + fx);
+    c2.y = round(py + fy);
+  }
+  const x = [...fresh.x];
+  const y = [...fresh.y];
+  const occ = new Occupancy();
+  const placed = new Uint8Array(nodes.length);
+  nodes.forEach((n, i) => {
+    const old = mem.nodes[n.name];
+    const c2 = fresh.cluster[i];
+    const key = c2 >= 0 ? cs[c2].key : "";
+    if (!old || old[2] !== key) return;
+    const oldC = c2 >= 0 ? mem.clusters[key] : null;
+    if (c2 >= 0 && !oldC) return;
+    const ox = old[0] - (oldC ? oldC[0] : 0), oy = old[1] - (oldC ? oldC[1] : 0);
+    const fc = c2 >= 0 ? fresh.clusters[c2] : null;
+    const fy = fresh.y[i] - (fc ? fc.y : 0);
+    if (!keeps(fy, fc ? fc.r : freshTop, oy, oldC ? oldC[2] : oldTop)) return;
+    x[i] = round((c2 >= 0 ? cs[c2].x : 0) + ox);
+    y[i] = round((c2 >= 0 ? cs[c2].y : 0) + oy);
+    occ.add(x[i], y[i]);
+    placed[i] = 1;
+  });
+  nodes.forEach((_, i) => {
+    if (placed[i]) return;
+    const c2 = fresh.cluster[i];
+    let tx = fresh.x[i];
+    let ty = fresh.y[i];
+    if (c2 >= 0) {
+      tx = cs[c2].x + (fresh.x[i] - fresh.clusters[c2].x);
+      ty = cs[c2].y + (fresh.y[i] - fresh.clusters[c2].y);
+    }
+    const discs = cs.filter((k) => k.parent === c2).map((k) => ({ x: k.x, y: k.y, r: k.r }));
+    [x[i], y[i]] = nearestFree(occ, tx, ty, discs).map(round);
+    occ.add(x[i], y[i]);
+    for (let k = c2; k >= 0; k = cs[k].parent) {
+      const d = Math.hypot(x[i] - cs[k].x, y[i] - cs[k].y) + LEAF_R + 4;
+      if (d > cs[k].r) cs[k].r = round(d);
+    }
+  });
+  return relax(withLocal({ x, y, lx: [], ly: [], cluster: fresh.cluster, clusters: cs }));
+}
+function relax(L, only) {
+  const cs = L.clusters;
+  const kidsC = cs.map(() => []);
+  const kidsN = cs.map(() => []);
+  const rootC = [];
+  const rootN = [];
+  cs.forEach((c2, i) => (c2.parent >= 0 ? kidsC[c2.parent] : rootC).push(i));
+  L.cluster.forEach((c2, i) => (c2 >= 0 ? kidsN[c2] : rootN).push(i));
+  const dcx = new Float64Array(cs.length), dcy = new Float64Array(cs.length);
+  const dnx = new Float64Array(L.x.length), dny = new Float64Array(L.x.length);
+  const separate = (kc, kn) => {
+    if (!kc.length) return 0;
+    const items = [...kc.map((c2) => ({ c: c2, i: -1, r: cs[c2].r })), ...kn.map((i) => ({ c: -1, i, r: LEAF_R }))];
+    const pos = (it) => it.c >= 0 ? [cs[it.c].lx, cs[it.c].ly] : [L.lx[it.i], L.ly[it.i]];
+    const shift = (it, dx, dy) => {
+      if (it.c >= 0) {
+        cs[it.c].lx += dx;
+        cs[it.c].ly += dy;
+        dcx[it.c] += dx;
+        dcy[it.c] += dy;
+      } else {
+        L.lx[it.i] += dx;
+        L.ly[it.i] += dy;
+        dnx[it.i] += dx;
+        dny[it.i] += dy;
+      }
+    };
+    let moved = 0;
+    for (let iter = 0; iter < 40; iter++) {
+      let any = false;
+      for (let a2 = 0; a2 < kc.length; a2++) {
+        for (let b = a2 + 1; b < items.length; b++) {
+          const A = items[a2], B = items[b];
+          const [ax, ay] = pos(A), [bx, by] = pos(B);
+          let dx = bx - ax, dy = by - ay;
+          let d = Math.hypot(dx, dy);
+          const need = A.r + B.r;
+          if (d >= need - 0.5) continue;
+          if (d < 1e-6) {
+            dx = 1;
+            dy = 0;
+            d = 1;
+          }
+          const push = need - d;
+          const wa = B.r * B.r / (A.r * A.r + B.r * B.r);
+          shift(A, -dx / d * push * wa, -dy / d * push * wa);
+          shift(B, dx / d * push * (1 - wa), dy / d * push * (1 - wa));
+          any = true;
+          moved++;
+        }
+      }
+      if (!any) break;
+    }
+    return moved;
+  };
+  const look = only ? new Set(only) : null;
+  for (let c2 = cs.length - 1; c2 >= 0; c2--) {
+    if (look && !look.has(c2)) continue;
+    if (separate(kidsC[c2], kidsN[c2]) === 0) continue;
+    let reach = 0;
+    for (const k of kidsC[c2]) reach = Math.max(reach, Math.hypot(cs[k].lx, cs[k].ly) + cs[k].r);
+    for (const i of kidsN[c2]) reach = Math.max(reach, Math.hypot(L.lx[i], L.ly[i]) + LEAF_R);
+    const was = cs[c2].r;
+    cs[c2].r = round(Math.max(cs[c2].r, reach + 6));
+    if (look && cs[c2].r !== was) look.add(cs[c2].parent);
+  }
+  if (!look || look.has(-1)) separate(rootC, rootN);
+  const wdx = new Float64Array(cs.length), wdy = new Float64Array(cs.length);
+  cs.forEach((c2, i) => {
+    wdx[i] = (c2.parent >= 0 ? wdx[c2.parent] : 0) + dcx[i];
+    wdy[i] = (c2.parent >= 0 ? wdy[c2.parent] : 0) + dcy[i];
+    if (wdx[i] || wdy[i]) {
+      c2.x = round(c2.x + wdx[i]);
+      c2.y = round(c2.y + wdy[i]);
+      c2.lx = round(c2.lx);
+      c2.ly = round(c2.ly);
+    }
+  });
+  for (let i = 0; i < L.x.length; i++) {
+    const c2 = L.cluster[i];
+    const dx = (c2 >= 0 ? wdx[c2] : 0) + dnx[i];
+    const dy = (c2 >= 0 ? wdy[c2] : 0) + dny[i];
+    if (dx || dy) {
+      L.x[i] = round(L.x[i] + dx);
+      L.y[i] = round(L.y[i] + dy);
+      L.lx[i] = round(L.lx[i]);
+      L.ly[i] = round(L.ly[i]);
+    }
+  }
+  return L;
+}
+
+// src/web/src/layoutworker.ts
+function layOut(a2) {
+  const nodes = a2.nodes;
+  return stabilize(computeLayout(a2.mode, nodes, a2.edges, a2.hidden), nodes, a2.mem);
+}
+var scope = globalThis;
+if (typeof scope.document === "undefined" && typeof globalThis.WorkerGlobalScope !== "undefined") {
+  scope.onmessage = (e) => {
+    const { id, ...ask } = e.data;
+    try {
+      scope.postMessage({ id, layout: layOut(ask) });
+    } catch (err) {
+      scope.postMessage({ id, error: err instanceof Error ? err.message : String(err) });
+    }
+  };
+}
+export {
+  layOut
+};