@knowvah/dot-engine 1.6.0 → 1.6.1

package/dist/index.js

@@ -19894,7 +19894,7 @@ function leaveEdge(ctx) {
   }
   if (j > 0) {
     ctx.sI = 0;
-    [rv, cnt] = leaveEdgeScan(ctx, j, cnt, rv);
+    [rv] = leaveEdgeScan(ctx, j, cnt, rv);
   }
   return rv;
 }
@@ -28461,6 +28461,393 @@ function dotPosition(g) {
   return 0;
 }
 
+// src/common/shape-clip.ts
+function shapeClip0(ctx, insidefn, n, curve, leftInside) {
+  const saveRealSize = n.info.rw;
+  const c = curve.map((p) => ({ x: p.x - n.info.coord.x, y: p.y - n.info.coord.y }));
+  bezierClip(ctx, insidefn, c, leftInside);
+  for (let i = 0; i < 4; i++) {
+    curve[i] = { x: c[i].x + n.info.coord.x, y: c[i].y + n.info.coord.y };
+  }
+  n.info.rw = saveRealSize;
+}
+function shapeClip(n, curve) {
+  const insidefn = n.info.shape?.fns?.insidefn ?? null;
+  if (insidefn === null) return;
+  const ctx = { nodeCoord: n.info.coord, rw: n.info.rw, bp: null, node: n };
+  const saveRealSize = n.info.rw;
+  const leftInside = insidefn(ctx, { x: curve[0].x - n.info.coord.x, y: curve[0].y - n.info.coord.y });
+  n.info.rw = saveRealSize;
+  shapeClip0(ctx, insidefn, n, curve, leftInside);
+}
+
+// src/layout/dot/sameport.ts
+function sameedge(same, e, id) {
+  for (const grp of same) {
+    if (grp.id === id) {
+      grp.edges.push(e);
+      return;
+    }
+  }
+  same.push({ id, edges: [e] });
+}
+function computeBoundaryOffset(u, x, y, ranksep) {
+  const r = Math.max(
+    (u.info.lw ?? 0) + (u.info.rw ?? 0),
+    (u.info.ht ?? 0) + ranksep
+  );
+  const x2 = x * r + u.info.coord.x;
+  const y2 = y * r + u.info.coord.y;
+  const curve = [
+    { x: u.info.coord.x, y: u.info.coord.y },
+    { x: (2 * u.info.coord.x + x2) / 3, y: (2 * u.info.coord.y + y2) / 3 },
+    { x: (2 * x2 + u.info.coord.x) / 3, y: (2 * y2 + u.info.coord.y) / 3 },
+    { x: x2, y: y2 }
+  ];
+  shapeClip(u, curve);
+  return {
+    x1: curve[0].x - u.info.coord.x,
+    y1: curve[0].y - u.info.coord.y
+  };
+}
+function averageDirection(u, edges) {
+  let sx = 0, sy = 0;
+  for (const e of edges) {
+    const v = e.head === u ? e.tail : e.head;
+    const dx = v.info.coord.x - u.info.coord.x;
+    const dy = v.info.coord.y - u.info.coord.y;
+    const r2 = Math.hypot(dx, dy);
+    if (r2 !== 0) {
+      sx += dx / r2;
+      sy += dy / r2;
+    }
+  }
+  const r = Math.hypot(sx, sy);
+  return r !== 0 ? { x: sx / r, y: sy / r } : { x: 0, y: 0 };
+}
+function buildSharedPort(u, edges, ranksep) {
+  const dir = averageDirection(u, edges);
+  const { x1, y1 } = computeBoundaryOffset(u, dir.x, dir.y, ranksep);
+  const px = cround(x1);
+  const py = cround(y1);
+  const lw = u.info.lw ?? 0;
+  const rw = u.info.rw ?? 0;
+  const order = lw + rw !== 0 ? MC_SCALE * (lw + px) / (lw + rw) : 0;
+  return {
+    p: { x: px, y: py },
+    theta: 0,
+    bp: null,
+    defined: true,
+    constrained: false,
+    clip: false,
+    dyna: false,
+    order,
+    side: 0,
+    name: null
+  };
+}
+function assignHeadIfMatch(f, u, prt) {
+  if (f.head === u) f.info.head_port = prt;
+  if (f.tail === u) f.info.tail_port = prt;
+}
+function assignPortForwardChain(e, u, prt) {
+  for (let f = e; f !== void 0; f = (f.info.edge_type ?? 0) === VIRTUAL && (f.head.info.node_type ?? 0) === VIRTUAL && (f.head.info.out?.size ?? 0) === 1 ? f.head.info.out.list[0] : void 0) {
+    assignHeadIfMatch(f, u, prt);
+  }
+}
+function assignPortBackwardChain(e, u, prt) {
+  for (let f = e; f !== void 0; f = (f.info.edge_type ?? 0) === VIRTUAL && (f.tail.info.node_type ?? 0) === VIRTUAL && (f.tail.info.in?.size ?? 0) === 1 ? f.tail.info.in.list[0] : void 0) {
+    assignHeadIfMatch(f, u, prt);
+  }
+}
+function assignPortToAllVirts(e, u, prt) {
+  for (let virt = e; virt !== void 0; virt = virt.info.to_virt) {
+    assignPortForwardChain(virt, u, prt);
+    assignPortBackwardChain(virt, u, prt);
+  }
+}
+function sameport(u, edges, ranksep) {
+  if (edges.length < 2) return;
+  const prt = buildSharedPort(u, edges, ranksep);
+  for (const e of edges) assignPortToAllVirts(e, u, prt);
+  u.info.has_port = true;
+}
+function graphHasSamehead(g) {
+  for (const e of g.edges) {
+    if (e.info.samehead !== void 0) return true;
+  }
+  return false;
+}
+function graphHasSametail(g) {
+  for (const e of g.edges) {
+    if (e.info.sametail !== void 0) return true;
+  }
+  return false;
+}
+function collectSamehead(n) {
+  const same = [];
+  for (const e of n.root.edges) {
+    if (e.head === n && e.tail === n) continue;
+    const id = e.head === n ? e.info.samehead : void 0;
+    if (id && id !== "") sameedge(same, e, id);
+  }
+  return same;
+}
+function collectSametail(n) {
+  const same = [];
+  for (const e of n.root.edges) {
+    if (e.head === n && e.tail === n) continue;
+    const id = e.tail === n ? e.info.sametail : void 0;
+    if (id && id !== "") sameedge(same, e, id);
+  }
+  return same;
+}
+function applyGroupsToNode(n, groups, ranksep) {
+  for (const grp of groups) {
+    if (grp.edges.length > 1) sameport(n, grp.edges, ranksep);
+  }
+}
+function dotSameports(g) {
+  const hasSH = graphHasSamehead(g);
+  const hasST = graphHasSametail(g);
+  if (!hasSH && !hasST) return;
+  const ranksep = g.info.ranksep ?? 0;
+  for (const n of nodesInSeq(g)) {
+    if (hasSH) applyGroupsToNode(n, collectSamehead(n), ranksep);
+    if (hasST) applyGroupsToNode(n, collectSametail(n), ranksep);
+  }
+}
+
+// src/common/spline-midpoint.ts
+function dist2(p, q) {
+  const dx = p.x - q.x;
+  const dy = p.y - q.y;
+  return dx * dx + dy * dy;
+}
+function distPt(p, q) {
+  return Math.sqrt(dist2(p, q));
+}
+function evalBez4(pts, t) {
+  const u = 1 - t;
+  const [p0, p1, p2, p3] = pts;
+  return {
+    x: u * u * u * p0.x + 3 * u * u * t * p1.x + 3 * u * t * t * p2.x + t * t * t * p3.x,
+    y: u * u * u * p0.y + 3 * u * u * t * p1.y + 3 * u * t * t * p2.y + t * t * t * p3.y
+  };
+}
+function dotneatoClosest(spl, pt) {
+  let besti = 0;
+  let bestj = -1;
+  let bestd2 = Number.MAX_VALUE;
+  for (let i = 0; i < spl.list.length; i++) {
+    const bz2 = spl.list[i];
+    const n = bz2.size ?? bz2.list.length;
+    for (let j2 = 0; j2 < n; j2++) {
+      const d2 = dist2(bz2.list[j2], pt);
+      if (bestj === -1 || d2 < bestd2) {
+        besti = i;
+        bestj = j2;
+        bestd2 = d2;
+      }
+    }
+  }
+  const bz = spl.list[besti];
+  const bzn = bz.size ?? bz.list.length;
+  let j = bestj === bzn - 1 ? bestj - 1 : bestj;
+  j = 3 * Math.floor(j / 3);
+  const c = [bz.list[j], bz.list[j + 1], bz.list[j + 2], bz.list[j + 3]];
+  let lo = 0;
+  let hi = 1;
+  let dlo2 = dist2(c[0], pt);
+  let dhi2 = dist2(c[3], pt);
+  let pt2;
+  for (; ; ) {
+    const t = (lo + hi) / 2;
+    pt2 = evalBez4(c, t);
+    if (Math.abs(dlo2 - dhi2) < 1 || Math.abs(hi - lo) < 1e-5) break;
+    if (dlo2 < dhi2) {
+      hi = t;
+      dhi2 = dist2(pt2, pt);
+    } else {
+      lo = t;
+      dlo2 = dist2(pt2, pt);
+    }
+  }
+  return pt2;
+}
+function polylineMidpoint(spl) {
+  let total = 0;
+  for (const bz of spl.list) {
+    for (let j = 0, k = 3; k < bz.list.length; j += 3, k += 3)
+      total += distPt(bz.list[j], bz.list[k]);
+  }
+  total /= 2;
+  for (const bz of spl.list) {
+    for (let j = 0, k = 3; k < bz.list.length; j += 3, k += 3) {
+      const pf = bz.list[j];
+      const qf = bz.list[k];
+      const d = distPt(pf, qf);
+      if (d >= total) {
+        return {
+          x: fma(qf.x, total, pf.x * (d - total)) / d,
+          y: fma(qf.y, total, pf.y * (d - total)) / d
+        };
+      }
+      total -= d;
+    }
+  }
+  const first = spl.list[0];
+  return first.sflag ? first.sp : first.list[0];
+}
+function splEndPoints(spl) {
+  const first = spl.list[0];
+  const p = first.sflag ? first.sp : first.list[0];
+  const last = spl.list[spl.list.length - 1];
+  const q = last.eflag ? last.ep : last.list[last.list.length - 1];
+  return { p, q };
+}
+
+// src/common/splines-path-shared.ts
+function addBox(P, b) {
+  if (b.ll.x < b.ur.x && b.ll.y < b.ur.y) {
+    P.boxes[P.nbox++] = b;
+  }
+}
+function concSlope(n) {
+  const inE = n.info.in;
+  const outE = n.info.out;
+  const cntIn = inE?.size ?? 0;
+  const cntOut = outE?.size ?? 0;
+  let sIn = 0;
+  let sOut = 0;
+  for (let i = 0; i < cntIn; i++) sIn += inE.list[i].tail.info.coord.x;
+  for (let i = 0; i < cntOut; i++) sOut += outE.list[i].head.info.coord.x;
+  const x1 = n.info.coord.x - sIn / cntIn;
+  const y1 = n.info.coord.y - inE.list[0].tail.info.coord.y;
+  const x2 = sOut / cntOut - n.info.coord.x;
+  const y2 = outE.list[0].head.info.coord.y - n.info.coord.y;
+  return (Math.atan2(y1, x1) + Math.atan2(y2, x2)) / 2;
+}
+var SIDE_PORT = ["s", "e", "n", "w"];
+var ALL_SIDES2 = TOP | BOTTOM | LEFT | RIGHT;
+function cvtPt(p, rankdir) {
+  switch (rankdir) {
+    case RANKDIR_BT:
+      return { x: p.x, y: -p.y };
+    case RANKDIR_LR:
+      return { x: -p.y, y: p.x };
+    case RANKDIR_RL:
+      return { x: p.y, y: p.x };
+    default:
+      return { x: p.x, y: p.y };
+  }
+}
+function nodeBoxLocal(n, flip) {
+  const lw = n.info.lw, ht22 = n.info.ht / 2;
+  return flip ? { ll: { x: -ht22, y: -lw }, ur: { x: ht22, y: lw } } : { ll: { x: -lw, y: -ht22 }, ur: { x: lw, y: ht22 } };
+}
+function faceMidpoint(b, ix) {
+  const cx = (b.ll.x + b.ur.x) / 2, cy = (b.ll.y + b.ur.y) / 2;
+  if (ix === BOTTOM_IX) return { x: cx, y: b.ll.y };
+  if (ix === RIGHT_IX) return { x: b.ur.x, y: cy };
+  if (ix === TOP_IX) return { x: cx, y: b.ur.y };
+  return { x: b.ll.x, y: cy };
+}
+function closestSide(n, other, port) {
+  const sides = port.side;
+  if (sides === 0 || sides === ALL_SIDES2) return null;
+  const rkd = (n.root.info.rankdir ?? 0) & 3;
+  const pt = cvtPt(n.info.coord, rkd);
+  const opt = cvtPt(other.info.coord, rkd);
+  const b = port.bp ?? nodeBoxLocal(n, rkd === RANKDIR_LR || rkd === RANKDIR_RL);
+  let rv = null;
+  let mind = 0;
+  for (let i = 0; i < 4; i++) {
+    if ((sides & 1 << i) === 0) continue;
+    const m = faceMidpoint(b, i);
+    const d = dist2({ x: m.x + pt.x, y: m.y + pt.y }, opt);
+    if (rv === null || d < mind) {
+      mind = d;
+      rv = SIDE_PORT[i];
+    }
+  }
+  return rv;
+}
+function resolvePort(n, other, port) {
+  if (!port.dyna) return port;
+  const compass = closestSide(n, other, port);
+  const rv = makePort();
+  rv.name = port.name;
+  compassPort(n, { bp: port.bp, compass: compass ?? "", sides: port.side }, rv);
+  return rv;
+}
+function walkToOrig(e) {
+  let cur = e;
+  while (cur.info.to_orig != null && cur.info.edge_type !== 0) {
+    cur = cur.info.to_orig;
+  }
+  return cur;
+}
+function clearClipForOrig(e, n, isTail) {
+  const orig = walkToOrig(e);
+  if (isTail) {
+    if (n === orig.tail) orig.info.tail_port.clip = false;
+    else orig.info.head_port.clip = false;
+  } else {
+    if (n === orig.head) orig.info.head_port.clip = false;
+    else orig.info.tail_port.clip = false;
+  }
+}
+function applyDefaultBoxes(P, et, endp) {
+  if (et === FLATEDGE) {
+    if (endp.sidemask === TOP) endp.boxes[0].ll.y = P.start.p.y;
+    else endp.boxes[0].ur.y = P.start.p.y;
+  } else {
+    endp.boxes[0].ur.y = P.start.p.y;
+    endp.sidemask = BOTTOM;
+    P.start.p.y -= 1;
+  }
+}
+function applyEndDefaultBoxes(P, et, endp) {
+  if (et === FLATEDGE) {
+    if (endp.sidemask === TOP) endp.boxes[0].ll.y = P.end.p.y;
+    else endp.boxes[0].ur.y = P.end.p.y;
+  } else {
+    endp.boxes[0].ll.y = P.end.p.y;
+    endp.sidemask = TOP;
+    P.end.p.y += 1;
+  }
+}
+function invokePboxfn(fns, n, port, side, endp) {
+  if (!fns?.pboxfn) return 0;
+  const kptr = [endp.boxn];
+  const mask = fns.pboxfn(n, port, side, endp.boxes, kptr);
+  endp.boxn = kptr[0];
+  return mask;
+}
+function setStartTheta(P, e, merge) {
+  if (merge) {
+    P.start.theta = concSlope(e.tail);
+    P.start.constrained = true;
+  } else if (e.info.tail_port.constrained) {
+    P.start.theta = e.info.tail_port.theta;
+    P.start.constrained = true;
+  } else {
+    P.start.constrained = false;
+  }
+}
+function setEndTheta(P, e, merge) {
+  if (merge) {
+    P.end.theta = concSlope(e.head) + Math.PI;
+    P.end.constrained = true;
+  } else if (e.info.head_port.constrained) {
+    P.end.theta = e.info.head_port.theta;
+    P.end.constrained = true;
+  } else {
+    P.end.constrained = false;
+  }
+}
+
 // src/pathplan/solvers.ts
 var EPS2 = 1e-7;
 var Solver = class _Solver {
@@ -29250,567 +29637,6 @@ function computeSpline(boxes, startPt, endPt) {
   return tryRouteSpline(polyEdgesFromPts(polygon), wpts) ?? linearBezier(startPt, endPt);
 }
 
-// src/layout/dot/edge-route-boxes.ts
-var FUDGE2 = 2;
-function makeTailBox(nb, startPy) {
-  return { ll: nb.ll, ur: { x: nb.ur.x, y: startPy } };
-}
-function makeHeadBox(nb, endPy) {
-  return { ll: { x: nb.ll.x, y: endPy }, ur: nb.ur };
-}
-function makeRankBox(p) {
-  return {
-    ll: { x: p.llx, y: p.headCy + p.headHt2 },
-    ur: { x: p.urx, y: p.tailCy - p.tailHt1 }
-  };
-}
-function makeMaximalBbox(box, ht1, ht22) {
-  return {
-    ll: { x: box.center.x - box.lw - FUDGE2, y: box.center.y - ht1 },
-    ur: { x: box.center.x + box.rw + FUDGE2, y: box.center.y + ht22 }
-  };
-}
-
-// src/layout/dot/edge-route-routing.ts
-var ARROW_LENGTH2 = 10;
-var CLIP_BOTH = { tail: true, head: true };
-function buildRankCorridor(tailBox, headBox, rank3, ports) {
-  const startPy = tailBox.center.y;
-  const endPy = headBox.center.y;
-  const tailNb = makeMaximalBbox(tailBox, rank3.tailHt1, rank3.tailHt2);
-  const headNb = makeMaximalBbox(headBox, rank3.headHt1, rank3.headHt2);
-  const rp = {
-    llx: rank3.leftBound,
-    urx: rank3.rightBound,
-    tailCy: tailBox.center.y,
-    tailHt1: rank3.tailHt1,
-    headCy: headBox.center.y,
-    headHt2: rank3.headHt2
-  };
-  return {
-    startPt: ports?.tailP ?? { x: tailBox.center.x, y: startPy - 1 },
-    endPt: ports?.headP ?? { x: headBox.center.x, y: endPy + 1 },
-    boxes: [makeTailBox(tailNb, startPy), makeRankBox(rp), makeHeadBox(headNb, endPy)]
-  };
-}
-function normalArrowLen(penwidth = DEFAULT_NODEPENWIDTH) {
-  const ARROWWIDTH = 0.35;
-  return ARROW_LENGTH2 + penwidth * Math.sqrt(1 + ARROWWIDTH * ARROWWIDTH) / (2 * ARROWWIDTH);
-}
-function nodeInsideFn2(box) {
-  const halfW = (box.lw + box.rw) / 2;
-  const halfH = box.ht / 2;
-  const pw = box.penwidth ?? DEFAULT_NODEPENWIDTH;
-  return box.isEllipse ? makeEllipseInsideFn(halfW, halfH, pw) : makeBoxInsideFn(halfW, halfH, pw);
-}
-function clipToNodes(bezier, tailBox, headBox, penwidth = DEFAULT_NODEPENWIDTH, clip = CLIP_BOTH) {
-  const step1 = clip.tail ? bezierClipNode(bezier, tailBox.center.x, tailBox.center.y, nodeInsideFn2(tailBox), true) : bezier;
-  const step2 = clip.head ? bezierClipNode(step1, headBox.center.x, headBox.center.y, nodeInsideFn2(headBox), false) : step1;
-  const arrowTip = step2[3];
-  const elen = normalArrowLen(penwidth);
-  const clipped = arrowEndClip(step2, arrowTip, elen);
-  const arrowDir = normalizeVec({
-    x: clipped[3].x - arrowTip.x,
-    y: clipped[3].y - arrowTip.y
-  });
-  return { clipped, arrowTip, arrowDir };
-}
-function routeWithRank(tailBox, headBox, rank3, penwidth = DEFAULT_NODEPENWIDTH, port) {
-  const corridor = port ? { tailP: port.tailP, headP: port.headP } : void 0;
-  const { startPt, endPt, boxes } = buildRankCorridor(tailBox, headBox, rank3, corridor);
-  const bezier = computeSpline(boxes, startPt, endPt);
-  const clip = port ? { tail: port.clipTail, head: port.clipHead } : CLIP_BOTH;
-  const { clipped, arrowTip, arrowDir } = clipToNodes(bezier, tailBox, headBox, penwidth, clip);
-  return { bezierPts: clipped, arrowTip, arrowDir };
-}
-function routeSimple(tailBox, headBox, routeBezierFn) {
-  const dir = normalizeVec({
-    x: headBox.center.x - tailBox.center.x,
-    y: headBox.center.y - tailBox.center.y
-  });
-  const headToTail = negateVec(dir);
-  const tailClip = clipToNodeBox(tailBox, dir);
-  const arrowTip = clipToNodeBox(headBox, headToTail);
-  return {
-    bezierPts: routeBezierFn(tailClip, offsetPoint(arrowTip, headToTail, ARROW_LENGTH2)),
-    arrowTip,
-    arrowDir: headToTail
-  };
-}
-
-// src/layout/dot/edge-route-helpers.ts
-function defaultEdgeDir(g) {
-  return g.kind === "directed" || g.kind === "strict-directed" ? "forward" : "none";
-}
-var ELLIPSE_SHAPES = /* @__PURE__ */ new Set([
-  "ellipse",
-  "oval",
-  "circle",
-  "egg",
-  "doublecircle",
-  "Mcircle",
-  "point"
-]);
-function recordClipBox(n) {
-  const f = n.info.shape_info;
-  if (!f?.b) return void 0;
-  const halfW = (f.b.ur.x - f.b.ll.x) / 2;
-  return { lw: halfW, rw: halfW, ht: f.b.ur.y - f.b.ll.y };
-}
-function nodePenwidthOf(n, g) {
-  const v = nodeAttr(n, g, "penwidth");
-  const pw = v !== void 0 ? parseFloat(v) : NaN;
-  return Number.isFinite(pw) && pw >= 0 ? pw : DEFAULT_NODEPENWIDTH;
-}
-function nodeBoxOf(n, g) {
-  const shapeName = nodeAttr(n, g, "shape") ?? "ellipse";
-  const penwidth = nodePenwidthOf(n, g);
-  if (shapeName === "record" || shapeName === "Mrecord") {
-    const rb = recordClipBox(n);
-    if (rb) return { center: n.info.coord, ...rb, isEllipse: false, penwidth };
-  }
-  const si = n.info.shape_info;
-  if (si?.option?.fixedshape === true && si.vertices) {
-    const ext = fixedShapeSize(si);
-    const flip = g.root.info.flip === true;
-    const w = flip ? ext.h : ext.w;
-    const h = flip ? ext.w : ext.h;
-    return {
-      center: n.info.coord,
-      lw: w / 2,
-      rw: w / 2,
-      ht: h,
-      isEllipse: ELLIPSE_SHAPES.has(shapeName),
-      penwidth: 0
-    };
-  }
-  return {
-    center: n.info.coord,
-    lw: n.info.lw > 0 ? n.info.lw : 27,
-    rw: n.info.rw > 0 ? n.info.rw : 27,
-    ht: n.info.ht > 0 ? n.info.ht : 36,
-    isEllipse: ELLIPSE_SHAPES.has(shapeName),
-    penwidth
-  };
-}
-function edgeRenderPenwidth(e) {
-  return resolvePenWidth(parseStyleFlags(e.attrs.get("style")), e.attrs.get("penwidth"));
-}
-function edgePenwidthAttr(e) {
-  const pw = parseFloat(e.attrs.get("penwidth") ?? "");
-  return isNaN(pw) ? 1 : pw;
-}
-function makeBezierRecord(bezierPts, arrowTip) {
-  return {
-    list: bezierPts,
-    size: bezierPts.length,
-    sflag: 0,
-    eflag: 1,
-    sp: bezierPts[0] ?? { x: 0, y: 0 },
-    ep: arrowTip
-  };
-}
-function makeSplineRecord(bz) {
-  return { list: [bz], size: 1, bb: { ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } } };
-}
-function installEdgeSpline(e, bezierPts, arrowTip) {
-  e.info.spl = makeSplineRecord(makeBezierRecord(bezierPts, arrowTip));
-  const bb = e.tail.root.info.bb;
-  if (bb != null) {
-    for (let i = 0; i + 3 < bezierPts.length; i += 3) {
-      updateBbBz(bb, [bezierPts[i], bezierPts[i + 1], bezierPts[i + 2], bezierPts[i + 3]]);
-    }
-  }
-}
-function isUsableSpline(raw) {
-  if (raw.length < 4) return false;
-  const p0 = raw[0];
-  const p1 = raw[1];
-  return p0.x !== p1.x || p0.y !== p1.y;
-}
-function routeBezier(from, to) {
-  const noBarriers = [];
-  const zero = { x: 0, y: 0 };
-  const raw = routeSpline(noBarriers, [from, to], [zero, zero]);
-  if (!isUsableSpline(raw)) return linearBezier(from, to);
-  return [raw[0], raw[1], raw[2], raw[3]];
-}
-function straightEdgeSplineWithRank(tailBox, headBox, rankInfo, penwidth = 1, port) {
-  return rankInfo !== void 0 ? routeWithRank(tailBox, headBox, rankInfo, penwidth, port) : routeSimple(tailBox, headBox, routeBezier);
-}
-
-// src/layout/dot/sameport.ts
-function sameedge(same, e, id) {
-  for (const grp of same) {
-    if (grp.id === id) {
-      grp.edges.push(e);
-      return;
-    }
-  }
-  same.push({ id, edges: [e] });
-}
-function shapeClip(u, curve) {
-  const box = nodeBoxOf(u, u.root);
-  const clipped = bezierClipNode(curve, box.center.x, box.center.y, nodeInsideFn2(box), true);
-  for (let i = 0; i < curve.length && i < clipped.length; i++) curve[i] = clipped[i];
-}
-function computeBoundaryOffset(u, x, y, ranksep) {
-  const r = Math.max(
-    (u.info.lw ?? 0) + (u.info.rw ?? 0),
-    (u.info.ht ?? 0) + ranksep
-  );
-  const x2 = x * r + u.info.coord.x;
-  const y2 = y * r + u.info.coord.y;
-  const curve = [
-    { x: u.info.coord.x, y: u.info.coord.y },
-    { x: (2 * u.info.coord.x + x2) / 3, y: (2 * u.info.coord.y + y2) / 3 },
-    { x: (2 * x2 + u.info.coord.x) / 3, y: (2 * y2 + u.info.coord.y) / 3 },
-    { x: x2, y: y2 }
-  ];
-  shapeClip(u, curve);
-  return {
-    x1: curve[0].x - u.info.coord.x,
-    y1: curve[0].y - u.info.coord.y
-  };
-}
-function averageDirection(u, edges) {
-  let sx = 0, sy = 0;
-  for (const e of edges) {
-    const v = e.head === u ? e.tail : e.head;
-    const dx = v.info.coord.x - u.info.coord.x;
-    const dy = v.info.coord.y - u.info.coord.y;
-    const r2 = Math.hypot(dx, dy);
-    if (r2 !== 0) {
-      sx += dx / r2;
-      sy += dy / r2;
-    }
-  }
-  const r = Math.hypot(sx, sy);
-  return r !== 0 ? { x: sx / r, y: sy / r } : { x: 0, y: 0 };
-}
-function buildSharedPort(u, edges, ranksep) {
-  const dir = averageDirection(u, edges);
-  const { x1, y1 } = computeBoundaryOffset(u, dir.x, dir.y, ranksep);
-  const px = cround(x1);
-  const py = cround(y1);
-  const lw = u.info.lw ?? 0;
-  const rw = u.info.rw ?? 0;
-  const order = lw + rw !== 0 ? MC_SCALE * (lw + px) / (lw + rw) : 0;
-  return {
-    p: { x: px, y: py },
-    theta: 0,
-    bp: null,
-    defined: true,
-    constrained: false,
-    clip: false,
-    dyna: false,
-    order,
-    side: 0,
-    name: null
-  };
-}
-function assignHeadIfMatch(f, u, prt) {
-  if (f.head === u) f.info.head_port = prt;
-  if (f.tail === u) f.info.tail_port = prt;
-}
-function assignPortForwardChain(e, u, prt) {
-  for (let f = e; f !== void 0; f = (f.info.edge_type ?? 0) === VIRTUAL && (f.head.info.node_type ?? 0) === VIRTUAL && (f.head.info.out?.size ?? 0) === 1 ? f.head.info.out.list[0] : void 0) {
-    assignHeadIfMatch(f, u, prt);
-  }
-}
-function assignPortBackwardChain(e, u, prt) {
-  for (let f = e; f !== void 0; f = (f.info.edge_type ?? 0) === VIRTUAL && (f.tail.info.node_type ?? 0) === VIRTUAL && (f.tail.info.in?.size ?? 0) === 1 ? f.tail.info.in.list[0] : void 0) {
-    assignHeadIfMatch(f, u, prt);
-  }
-}
-function assignPortToAllVirts(e, u, prt) {
-  for (let virt = e; virt !== void 0; virt = virt.info.to_virt) {
-    assignPortForwardChain(virt, u, prt);
-    assignPortBackwardChain(virt, u, prt);
-  }
-}
-function sameport(u, edges, ranksep) {
-  if (edges.length < 2) return;
-  const prt = buildSharedPort(u, edges, ranksep);
-  for (const e of edges) assignPortToAllVirts(e, u, prt);
-  u.info.has_port = true;
-}
-function graphHasSamehead(g) {
-  for (const e of g.edges) {
-    if (e.info.samehead !== void 0) return true;
-  }
-  return false;
-}
-function graphHasSametail(g) {
-  for (const e of g.edges) {
-    if (e.info.sametail !== void 0) return true;
-  }
-  return false;
-}
-function collectSamehead(n) {
-  const same = [];
-  for (const e of n.root.edges) {
-    if (e.head === n && e.tail === n) continue;
-    const id = e.head === n ? e.info.samehead : void 0;
-    if (id && id !== "") sameedge(same, e, id);
-  }
-  return same;
-}
-function collectSametail(n) {
-  const same = [];
-  for (const e of n.root.edges) {
-    if (e.head === n && e.tail === n) continue;
-    const id = e.tail === n ? e.info.sametail : void 0;
-    if (id && id !== "") sameedge(same, e, id);
-  }
-  return same;
-}
-function applyGroupsToNode(n, groups, ranksep) {
-  for (const grp of groups) {
-    if (grp.edges.length > 1) sameport(n, grp.edges, ranksep);
-  }
-}
-function dotSameports(g) {
-  const hasSH = graphHasSamehead(g);
-  const hasST = graphHasSametail(g);
-  if (!hasSH && !hasST) return;
-  const ranksep = g.info.ranksep ?? 0;
-  for (const n of nodesInSeq(g)) {
-    if (hasSH) applyGroupsToNode(n, collectSamehead(n), ranksep);
-    if (hasST) applyGroupsToNode(n, collectSametail(n), ranksep);
-  }
-}
-
-// src/common/spline-midpoint.ts
-function dist2(p, q) {
-  const dx = p.x - q.x;
-  const dy = p.y - q.y;
-  return dx * dx + dy * dy;
-}
-function distPt(p, q) {
-  return Math.sqrt(dist2(p, q));
-}
-function evalBez4(pts, t) {
-  const u = 1 - t;
-  const [p0, p1, p2, p3] = pts;
-  return {
-    x: u * u * u * p0.x + 3 * u * u * t * p1.x + 3 * u * t * t * p2.x + t * t * t * p3.x,
-    y: u * u * u * p0.y + 3 * u * u * t * p1.y + 3 * u * t * t * p2.y + t * t * t * p3.y
-  };
-}
-function dotneatoClosest(spl, pt) {
-  let besti = 0;
-  let bestj = -1;
-  let bestd2 = Number.MAX_VALUE;
-  for (let i = 0; i < spl.list.length; i++) {
-    const bz2 = spl.list[i];
-    const n = bz2.size ?? bz2.list.length;
-    for (let j2 = 0; j2 < n; j2++) {
-      const d2 = dist2(bz2.list[j2], pt);
-      if (bestj === -1 || d2 < bestd2) {
-        besti = i;
-        bestj = j2;
-        bestd2 = d2;
-      }
-    }
-  }
-  const bz = spl.list[besti];
-  const bzn = bz.size ?? bz.list.length;
-  let j = bestj === bzn - 1 ? bestj - 1 : bestj;
-  j = 3 * Math.floor(j / 3);
-  const c = [bz.list[j], bz.list[j + 1], bz.list[j + 2], bz.list[j + 3]];
-  let lo = 0;
-  let hi = 1;
-  let dlo2 = dist2(c[0], pt);
-  let dhi2 = dist2(c[3], pt);
-  let pt2 = c[0];
-  for (; ; ) {
-    const t = (lo + hi) / 2;
-    pt2 = evalBez4(c, t);
-    if (Math.abs(dlo2 - dhi2) < 1 || Math.abs(hi - lo) < 1e-5) break;
-    if (dlo2 < dhi2) {
-      hi = t;
-      dhi2 = dist2(pt2, pt);
-    } else {
-      lo = t;
-      dlo2 = dist2(pt2, pt);
-    }
-  }
-  return pt2;
-}
-function polylineMidpoint(spl) {
-  let total = 0;
-  for (const bz of spl.list) {
-    for (let j = 0, k = 3; k < bz.list.length; j += 3, k += 3)
-      total += distPt(bz.list[j], bz.list[k]);
-  }
-  total /= 2;
-  for (const bz of spl.list) {
-    for (let j = 0, k = 3; k < bz.list.length; j += 3, k += 3) {
-      const pf = bz.list[j];
-      const qf = bz.list[k];
-      const d = distPt(pf, qf);
-      if (d >= total) {
-        return {
-          x: fma(qf.x, total, pf.x * (d - total)) / d,
-          y: fma(qf.y, total, pf.y * (d - total)) / d
-        };
-      }
-      total -= d;
-    }
-  }
-  const first = spl.list[0];
-  return first.sflag ? first.sp : first.list[0];
-}
-function splEndPoints(spl) {
-  const first = spl.list[0];
-  const p = first.sflag ? first.sp : first.list[0];
-  const last = spl.list[spl.list.length - 1];
-  const q = last.eflag ? last.ep : last.list[last.list.length - 1];
-  return { p, q };
-}
-
-// src/common/splines-path-shared.ts
-function addBox(P, b) {
-  if (b.ll.x < b.ur.x && b.ll.y < b.ur.y) {
-    P.boxes[P.nbox++] = b;
-  }
-}
-function concSlope(n) {
-  const inE = n.info.in;
-  const outE = n.info.out;
-  const cntIn = inE?.size ?? 0;
-  const cntOut = outE?.size ?? 0;
-  let sIn = 0;
-  let sOut = 0;
-  for (let i = 0; i < cntIn; i++) sIn += inE.list[i].tail.info.coord.x;
-  for (let i = 0; i < cntOut; i++) sOut += outE.list[i].head.info.coord.x;
-  const x1 = n.info.coord.x - sIn / cntIn;
-  const y1 = n.info.coord.y - inE.list[0].tail.info.coord.y;
-  const x2 = sOut / cntOut - n.info.coord.x;
-  const y2 = outE.list[0].head.info.coord.y - n.info.coord.y;
-  return (Math.atan2(y1, x1) + Math.atan2(y2, x2)) / 2;
-}
-var SIDE_PORT = ["s", "e", "n", "w"];
-var ALL_SIDES2 = TOP | BOTTOM | LEFT | RIGHT;
-function cvtPt(p, rankdir) {
-  switch (rankdir) {
-    case RANKDIR_BT:
-      return { x: p.x, y: -p.y };
-    case RANKDIR_LR:
-      return { x: -p.y, y: p.x };
-    case RANKDIR_RL:
-      return { x: p.y, y: p.x };
-    default:
-      return { x: p.x, y: p.y };
-  }
-}
-function nodeBoxLocal(n, flip) {
-  const lw = n.info.lw, ht22 = n.info.ht / 2;
-  return flip ? { ll: { x: -ht22, y: -lw }, ur: { x: ht22, y: lw } } : { ll: { x: -lw, y: -ht22 }, ur: { x: lw, y: ht22 } };
-}
-function faceMidpoint(b, ix) {
-  const cx = (b.ll.x + b.ur.x) / 2, cy = (b.ll.y + b.ur.y) / 2;
-  if (ix === BOTTOM_IX) return { x: cx, y: b.ll.y };
-  if (ix === RIGHT_IX) return { x: b.ur.x, y: cy };
-  if (ix === TOP_IX) return { x: cx, y: b.ur.y };
-  return { x: b.ll.x, y: cy };
-}
-function closestSide(n, other, port) {
-  const sides = port.side;
-  if (sides === 0 || sides === ALL_SIDES2) return null;
-  const rkd = (n.root.info.rankdir ?? 0) & 3;
-  const pt = cvtPt(n.info.coord, rkd);
-  const opt = cvtPt(other.info.coord, rkd);
-  const b = port.bp ?? nodeBoxLocal(n, rkd === RANKDIR_LR || rkd === RANKDIR_RL);
-  let rv = null;
-  let mind = 0;
-  for (let i = 0; i < 4; i++) {
-    if ((sides & 1 << i) === 0) continue;
-    const m = faceMidpoint(b, i);
-    const d = dist2({ x: m.x + pt.x, y: m.y + pt.y }, opt);
-    if (rv === null || d < mind) {
-      mind = d;
-      rv = SIDE_PORT[i];
-    }
-  }
-  return rv;
-}
-function resolvePort(n, other, port) {
-  if (!port.dyna) return port;
-  const compass = closestSide(n, other, port);
-  const rv = makePort();
-  rv.name = port.name;
-  compassPort(n, { bp: port.bp, compass: compass ?? "", sides: port.side }, rv);
-  return rv;
-}
-function walkToOrig(e) {
-  let cur = e;
-  while (cur.info.to_orig != null && cur.info.edge_type !== 0) {
-    cur = cur.info.to_orig;
-  }
-  return cur;
-}
-function clearClipForOrig(e, n, isTail) {
-  const orig = walkToOrig(e);
-  if (isTail) {
-    if (n === orig.tail) orig.info.tail_port.clip = false;
-    else orig.info.head_port.clip = false;
-  } else {
-    if (n === orig.head) orig.info.head_port.clip = false;
-    else orig.info.tail_port.clip = false;
-  }
-}
-function applyDefaultBoxes(P, et, endp) {
-  if (et === FLATEDGE) {
-    if (endp.sidemask === TOP) endp.boxes[0].ll.y = P.start.p.y;
-    else endp.boxes[0].ur.y = P.start.p.y;
-  } else {
-    endp.boxes[0].ur.y = P.start.p.y;
-    endp.sidemask = BOTTOM;
-    P.start.p.y -= 1;
-  }
-}
-function applyEndDefaultBoxes(P, et, endp) {
-  if (et === FLATEDGE) {
-    if (endp.sidemask === TOP) endp.boxes[0].ll.y = P.end.p.y;
-    else endp.boxes[0].ur.y = P.end.p.y;
-  } else {
-    endp.boxes[0].ll.y = P.end.p.y;
-    endp.sidemask = TOP;
-    P.end.p.y += 1;
-  }
-}
-function invokePboxfn(fns, n, port, side, endp) {
-  if (!fns?.pboxfn) return 0;
-  const kptr = [endp.boxn];
-  const mask = fns.pboxfn(n, port, side, endp.boxes, kptr);
-  endp.boxn = kptr[0];
-  return mask;
-}
-function setStartTheta(P, e, merge) {
-  if (merge) {
-    P.start.theta = concSlope(e.tail);
-    P.start.constrained = true;
-  } else if (e.info.tail_port.constrained) {
-    P.start.theta = e.info.tail_port.theta;
-    P.start.constrained = true;
-  } else {
-    P.start.constrained = false;
-  }
-}
-function setEndTheta(P, e, merge) {
-  if (merge) {
-    P.end.theta = concSlope(e.head) + Math.PI;
-    P.end.constrained = true;
-  } else if (e.info.head_port.constrained) {
-    P.end.theta = e.info.head_port.theta;
-    P.end.constrained = true;
-  } else {
-    P.end.constrained = false;
-  }
-}
-
 // src/layout/dot/edge-route-rank.ts
 var MINW = 16;
 function computeLeftBound(g) {
@@ -30865,7 +30691,7 @@ function rankY(g, r) {
   return g.info.rank[r].v[0].info.coord?.y ?? 0;
 }
 function sizeyAtMaxrank(g, n, r) {
-  if (r > 0) return rankY(g, r - 1) - (n.info.coord?.y ?? 0);
+  if (r - (g.info.abomShift ?? 0) > 0) return rankY(g, r - 1) - (n.info.coord?.y ?? 0);
   return n.info.ht ?? 0;
 }
 function sizeyAtMinrank(g, n, r) {
@@ -33702,7 +33528,7 @@ function makeFlatLabeledEdge(g, e) {
   const et = edgeType(g);
   if (et === EDGETYPE_LINE) {
     const ps2 = flatLabeledLinePoints(e.tail, e.head, e);
-    if (ps2 !== null && ps2.length !== 0) clipAndInstall(e, e.head, ps2, ps2.length, buildDotSinfo());
+    clipAndInstall(e, e.head, ps2, ps2.length, buildDotSinfo());
     return true;
   }
   const tailIsLeft = (e.tail.info.order ?? 0) <= (e.head.info.order ?? 0);
@@ -33886,6 +33712,195 @@ function makeAdjFlatNoPortEdge(g, e) {
   return true;
 }
 
+// src/layout/dot/edge-route-boxes.ts
+var FUDGE2 = 2;
+function makeTailBox(nb, startPy) {
+  return { ll: nb.ll, ur: { x: nb.ur.x, y: startPy } };
+}
+function makeHeadBox(nb, endPy) {
+  return { ll: { x: nb.ll.x, y: endPy }, ur: nb.ur };
+}
+function makeRankBox(p) {
+  return {
+    ll: { x: p.llx, y: p.headCy + p.headHt2 },
+    ur: { x: p.urx, y: p.tailCy - p.tailHt1 }
+  };
+}
+function makeMaximalBbox(box, ht1, ht22) {
+  return {
+    ll: { x: box.center.x - box.lw - FUDGE2, y: box.center.y - ht1 },
+    ur: { x: box.center.x + box.rw + FUDGE2, y: box.center.y + ht22 }
+  };
+}
+
+// src/layout/dot/edge-route-routing.ts
+var ARROW_LENGTH2 = 10;
+var CLIP_BOTH = { tail: true, head: true };
+function buildRankCorridor(tailBox, headBox, rank3, ports) {
+  const startPy = tailBox.center.y;
+  const endPy = headBox.center.y;
+  const tailNb = makeMaximalBbox(tailBox, rank3.tailHt1, rank3.tailHt2);
+  const headNb = makeMaximalBbox(headBox, rank3.headHt1, rank3.headHt2);
+  const rp = {
+    llx: rank3.leftBound,
+    urx: rank3.rightBound,
+    tailCy: tailBox.center.y,
+    tailHt1: rank3.tailHt1,
+    headCy: headBox.center.y,
+    headHt2: rank3.headHt2
+  };
+  return {
+    startPt: ports?.tailP ?? { x: tailBox.center.x, y: startPy - 1 },
+    endPt: ports?.headP ?? { x: headBox.center.x, y: endPy + 1 },
+    boxes: [makeTailBox(tailNb, startPy), makeRankBox(rp), makeHeadBox(headNb, endPy)]
+  };
+}
+function normalArrowLen(penwidth = DEFAULT_NODEPENWIDTH) {
+  const ARROWWIDTH = 0.35;
+  return ARROW_LENGTH2 + penwidth * Math.sqrt(1 + ARROWWIDTH * ARROWWIDTH) / (2 * ARROWWIDTH);
+}
+function nodeInsideFn2(box) {
+  const halfW = (box.lw + box.rw) / 2;
+  const halfH = box.ht / 2;
+  const pw = box.penwidth ?? DEFAULT_NODEPENWIDTH;
+  return box.isEllipse ? makeEllipseInsideFn(halfW, halfH, pw) : makeBoxInsideFn(halfW, halfH, pw);
+}
+function clipToNodes(bezier, tailBox, headBox, penwidth = DEFAULT_NODEPENWIDTH, clip = CLIP_BOTH) {
+  const step1 = clip.tail ? bezierClipNode(bezier, tailBox.center.x, tailBox.center.y, nodeInsideFn2(tailBox), true) : bezier;
+  const step2 = clip.head ? bezierClipNode(step1, headBox.center.x, headBox.center.y, nodeInsideFn2(headBox), false) : step1;
+  const arrowTip = step2[3];
+  const elen = normalArrowLen(penwidth);
+  const clipped = arrowEndClip(step2, arrowTip, elen);
+  const arrowDir = normalizeVec({
+    x: clipped[3].x - arrowTip.x,
+    y: clipped[3].y - arrowTip.y
+  });
+  return { clipped, arrowTip, arrowDir };
+}
+function routeWithRank(tailBox, headBox, rank3, penwidth = DEFAULT_NODEPENWIDTH, port) {
+  const corridor = port ? { tailP: port.tailP, headP: port.headP } : void 0;
+  const { startPt, endPt, boxes } = buildRankCorridor(tailBox, headBox, rank3, corridor);
+  const bezier = computeSpline(boxes, startPt, endPt);
+  const clip = port ? { tail: port.clipTail, head: port.clipHead } : CLIP_BOTH;
+  const { clipped, arrowTip, arrowDir } = clipToNodes(bezier, tailBox, headBox, penwidth, clip);
+  return { bezierPts: clipped, arrowTip, arrowDir };
+}
+function routeSimple(tailBox, headBox, routeBezierFn) {
+  const dir = normalizeVec({
+    x: headBox.center.x - tailBox.center.x,
+    y: headBox.center.y - tailBox.center.y
+  });
+  const headToTail = negateVec(dir);
+  const tailClip = clipToNodeBox(tailBox, dir);
+  const arrowTip = clipToNodeBox(headBox, headToTail);
+  return {
+    bezierPts: routeBezierFn(tailClip, offsetPoint(arrowTip, headToTail, ARROW_LENGTH2)),
+    arrowTip,
+    arrowDir: headToTail
+  };
+}
+
+// src/layout/dot/edge-route-helpers.ts
+function defaultEdgeDir(g) {
+  return g.kind === "directed" || g.kind === "strict-directed" ? "forward" : "none";
+}
+var ELLIPSE_SHAPES = /* @__PURE__ */ new Set([
+  "ellipse",
+  "oval",
+  "circle",
+  "egg",
+  "doublecircle",
+  "Mcircle",
+  "point"
+]);
+function recordClipBox(n) {
+  const f = n.info.shape_info;
+  if (!f?.b) return void 0;
+  const halfW = (f.b.ur.x - f.b.ll.x) / 2;
+  return { lw: halfW, rw: halfW, ht: f.b.ur.y - f.b.ll.y };
+}
+function nodePenwidthOf(n, g) {
+  const v = nodeAttr(n, g, "penwidth");
+  const pw = v !== void 0 ? parseFloat(v) : NaN;
+  return Number.isFinite(pw) && pw >= 0 ? pw : DEFAULT_NODEPENWIDTH;
+}
+function nodeBoxOf(n, g) {
+  const shapeName = nodeAttr(n, g, "shape") ?? "ellipse";
+  const penwidth = nodePenwidthOf(n, g);
+  if (shapeName === "record" || shapeName === "Mrecord") {
+    const rb = recordClipBox(n);
+    if (rb) return { center: n.info.coord, ...rb, isEllipse: false, penwidth };
+  }
+  const si = n.info.shape_info;
+  if (si?.option?.fixedshape === true && si.vertices) {
+    const ext = fixedShapeSize(si);
+    const flip = g.root.info.flip === true;
+    const w = flip ? ext.h : ext.w;
+    const h = flip ? ext.w : ext.h;
+    return {
+      center: n.info.coord,
+      lw: w / 2,
+      rw: w / 2,
+      ht: h,
+      isEllipse: ELLIPSE_SHAPES.has(shapeName),
+      penwidth: 0
+    };
+  }
+  return {
+    center: n.info.coord,
+    lw: n.info.lw > 0 ? n.info.lw : 27,
+    rw: n.info.rw > 0 ? n.info.rw : 27,
+    ht: n.info.ht > 0 ? n.info.ht : 36,
+    isEllipse: ELLIPSE_SHAPES.has(shapeName),
+    penwidth
+  };
+}
+function edgeRenderPenwidth(e) {
+  return resolvePenWidth(parseStyleFlags(e.attrs.get("style")), e.attrs.get("penwidth"));
+}
+function edgePenwidthAttr(e) {
+  const pw = parseFloat(e.attrs.get("penwidth") ?? "");
+  return isNaN(pw) ? 1 : pw;
+}
+function makeBezierRecord(bezierPts, arrowTip) {
+  return {
+    list: bezierPts,
+    size: bezierPts.length,
+    sflag: 0,
+    eflag: 1,
+    sp: bezierPts[0] ?? { x: 0, y: 0 },
+    ep: arrowTip
+  };
+}
+function makeSplineRecord(bz) {
+  return { list: [bz], size: 1, bb: { ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } } };
+}
+function installEdgeSpline(e, bezierPts, arrowTip) {
+  e.info.spl = makeSplineRecord(makeBezierRecord(bezierPts, arrowTip));
+  const bb = e.tail.root.info.bb;
+  if (bb != null) {
+    for (let i = 0; i + 3 < bezierPts.length; i += 3) {
+      updateBbBz(bb, [bezierPts[i], bezierPts[i + 1], bezierPts[i + 2], bezierPts[i + 3]]);
+    }
+  }
+}
+function isUsableSpline(raw) {
+  if (raw.length < 4) return false;
+  const p0 = raw[0];
+  const p1 = raw[1];
+  return p0.x !== p1.x || p0.y !== p1.y;
+}
+function routeBezier(from, to) {
+  const noBarriers = [];
+  const zero = { x: 0, y: 0 };
+  const raw = routeSpline(noBarriers, [from, to], [zero, zero]);
+  if (!isUsableSpline(raw)) return linearBezier(from, to);
+  return [raw[0], raw[1], raw[2], raw[3]];
+}
+function straightEdgeSplineWithRank(tailBox, headBox, rankInfo, penwidth = 1, port) {
+  return rankInfo !== void 0 ? routeWithRank(tailBox, headBox, rankInfo, penwidth, port) : routeSimple(tailBox, headBox, routeBezier);
+}
+
 // src/layout/dot/edge-route.ts
 function coordsDefined(e) {
   return e.tail.info.coord !== void 0 && e.head.info.coord !== void 0;
@@ -33989,8 +34004,14 @@ function hasSidePort(e) {
   const hp = resolvePort(e.head, e.tail, e.info.head_port);
   return (tp.side ?? 0) !== 0 || (hp.side ?? 0) !== 0;
 }
+function hasDefinedPort(e) {
+  return e.info.tail_port.defined || e.info.head_port.defined;
+}
+function isAdjacentPortFlat(e, g) {
+  return e.tail.info.rank !== void 0 && e.tail.info.rank === e.head.info.rank && isFlatAdjacent(g, e) && hasDefinedPort(e);
+}
 function isGroupableFlat(x, g) {
-  return x.info.spl === void 0 && x.tail.info.rank === x.head.info.rank && isFlatAdjacent(g, x) && hasSidePort(x);
+  return x.info.spl === void 0 && isAdjacentPortFlat(x, g);
 }
 function collectAdjacentFlatGroup(e, g) {
   const u = e.tail, v = e.head;
@@ -34031,7 +34052,7 @@ function routeFlatEdge(e, g) {
   if (isLostFlatAdjRecordEdge(g, e)) return true;
   if (makeFlatLabeledEdge(g, e)) return true;
   if (makeAdjFlatNoPortEdge(g, e)) return true;
-  if (hasSidePort(e) && routeFaithfulSidePort(e, g)) return true;
+  if ((hasSidePort(e) || isAdjacentPortFlat(e, g)) && routeFaithfulSidePort(e, g)) return true;
   if (e.tail.info.rank !== void 0 && e.tail.info.rank === e.head.info.rank && e.info.label === void 0 && !isFlatAdjacent(g, e)) {
     const group = collectNonAdjacentFlatGroup(e, g);
     if (group.length > 0 && routeFlatEdgeGroupFaithful(g, group, group.length) && e.info.spl !== void 0) return true;
@@ -34085,8 +34106,8 @@ var M_LEFT = 2;
 var M_BOTTOM = 3;
 
 // src/common/random.ts
-var A = 0x5deece66dn;
-var C = 0xbn;
+var A = BigInt("0x5deece66d");
+var C = BigInt("0xb");
 var MASK48 = (1n << 48n) - 1n;
 var TWO48 = 2 ** 48;
 var state = 0x330en;
@@ -36628,8 +36649,11 @@ function dispatchEdgeGroup(g, group, ctx) {
     }
     return;
   }
-  if (nodeRankOf(e0.tail) === nodeRankOf(e0.head)) return;
   const uniq = dedupByOrig(group);
+  if (nodeRankOf(e0.tail) === nodeRankOf(e0.head)) {
+    for (const e of uniq) routeLoneEdge(e, g);
+    return;
+  }
   if (uniq.length <= 1) {
     const runOrig = routeEntryRun(g, e0);
     if (runOrig !== null) {
@@ -40941,7 +40965,6 @@ var Cdt = class {
       v1 = r.v1;
       v2 = r.v2;
       v3 = r.v3;
-      prev = r.e1;
       e2 = r.e2;
       e3 = r.e3;
     }
@@ -44282,9 +44305,9 @@ var POW_LOG_TABLE_BITS = 7;
 var N_LOG = 1 << POW_LOG_TABLE_BITS;
 var EXP_TABLE_BITS = 7;
 var N_EXP = 1 << EXP_TABLE_BITS;
-var OFF = 0x3fe6955500000000n;
-var INF_BITS = 0x7ff0000000000000n;
-var ONE_BITS = 0x3ff0000000000000n;
+var OFF = BigInt("0x3fe6955500000000");
+var INF_BITS = BigInt("0x7ff0000000000000");
+var ONE_BITS = BigInt("0x3ff0000000000000");
 var SIGN_BIAS = 2048 << EXP_TABLE_BITS;
 var C22 = EC[0];
 var C3 = EC[1];
@@ -49363,7 +49386,7 @@ function circoLayout(g) {
   dg.components = comps;
   let blockCount = 0;
   if (comps.length === 1) {
-    blockCount = circularLayout(comps[0], g, blockCount, allEdges3);
+    circularLayout(comps[0], g, blockCount, allEdges3);
     copyPositions(comps[0]);
     adjustNodesFull(g);
   } else {
@@ -53433,10 +53456,8 @@ function snapshotEdge(edge, flipY) {
     head: edge.head.name,
     points: collectEdgePoints(edge, flipY)
   };
-  const lbl = edge.info.label;
-  if (lbl !== void 0) {
-    geom.label = { x: lbl.pos.x, y: flipY(lbl.pos.y) };
-  }
+  const label = placedLabelPos(edge.info.label, flipY);
+  if (label !== void 0) geom.label = label;
   const tailLabel = placedLabelPos(edge.info.tail_label, flipY);
   if (tailLabel !== void 0) geom.tailLabel = tailLabel;
   const headLabel = placedLabelPos(edge.info.head_label, flipY);