@knowvah/dot-engine 1.6.0 → 1.6.1

package/dist/render.js

@@ -21470,7 +21470,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;
 }
@@ -24494,204 +24494,591 @@ function dotPosition(g) {
   return 0;
 }
 
-// src/pathplan/solvers.ts
-var EPS2 = 1e-7;
-var Solver = class _Solver {
-  static aeq0(x) {
-    return x < EPS2 && x > -EPS2;
+// 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 };
   }
-  static solve1(c, r) {
-    if (_Solver.aeq0(c[1])) return _Solver.aeq0(c[0]) ? 4 : 0;
-    r[0] = -c[0] / c[1];
-    return 1;
+  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;
+    }
   }
-  static solve2(c, r) {
-    if (_Solver.aeq0(c[2])) return _Solver.solve1(c, r);
-    const b2a = c[1] / (2 * c[2]);
-    const disc = b2a * b2a - c[0] / c[2];
-    if (disc < 0) return 0;
-    if (disc > 0) {
-      r[0] = -b2a + Math.sqrt(disc);
-      r[1] = -2 * b2a - r[0];
-      return 2;
+  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;
     }
-    r[0] = -b2a;
-    return 1;
   }
-  static solve3neg(disc, q, b3a, r) {
-    const rr = 0.5 * Math.sqrt(-disc + q * q);
-    const theta = Math.atan2(Math.sqrt(-disc), -q);
-    const temp = 2 * Math.cbrt(rr);
-    r[0] = temp * Math.cos(theta / 3) - b3a;
-    r[1] = temp * Math.cos((theta + 2 * Math.PI) / 3) - b3a;
-    r[2] = temp * Math.cos((theta - 2 * Math.PI) / 3) - b3a;
-    return 3;
+  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);
   }
-  static solve3pos(disc, q, b3a, r) {
-    const al = 0.5 * (Math.sqrt(disc) - q);
-    r[0] = Math.cbrt(al) + Math.cbrt(-q - al) - b3a;
-    if (disc > 0) return 1;
-    r[1] = r[2] = -0.5 * (r[0] + b3a) - b3a;
-    return 3;
+}
+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);
   }
-  static solve3(c, r) {
-    const a = c[3], b = c[2], cv = c[1], d = c[0];
-    if (_Solver.aeq0(a)) return _Solver.solve2(c, r);
-    const b3a = b / (3 * a), p0 = b3a * b3a;
-    const q = 2 * b3a * p0 - b3a * cv / a + d / a;
-    const p = cv / (3 * a) - p0;
-    const disc = q * q + 4 * p * p * p;
-    return disc < 0 ? _Solver.solve3neg(disc, q, b3a, r) : _Solver.solve3pos(disc, q, b3a, r);
+}
+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 solve3(coeff, roots) {
-  return Solver.solve3(coeff, roots);
 }
-
-// src/pathplan/route.ts
-var EPSILON1 = 1e-3;
-var EPSILON2 = 1e-6;
-var RouteHelper = class _RouteHelper {
-  static B0(t) {
-    const u = 1 - t;
-    return u * u * u;
+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;
   }
-  static B1(t) {
-    const u = 1 - t;
-    return 3 * t * u * u;
+  return false;
+}
+function graphHasSametail(g) {
+  for (const e of g.edges) {
+    if (e.info.sametail !== void 0) return true;
   }
-  static B2(t) {
-    const u = 1 - t;
-    return 3 * t * t * u;
+  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);
   }
-  static B3(t) {
-    return t * t * t;
+  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);
   }
-  static B01(t) {
-    const u = 1 - t;
-    return u * u * (u + 3 * t);
+  return same;
+}
+function applyGroupsToNode(n, groups, ranksep) {
+  for (const grp of groups) {
+    if (grp.edges.length > 1) sameport(n, grp.edges, ranksep);
   }
-  static B23(t) {
-    const u = 1 - t;
-    return t * t * (3 * u + t);
+}
+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);
   }
-  static normv(v) {
-    const d = v.x * v.x + v.y * v.y;
-    if (d > 1e-6) {
-      const s = Math.sqrt(d);
-      return { x: v.x / s, y: v.y / s };
+}
+
+// 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;
+      }
     }
-    return v;
   }
-  static ptAdd(a, b) {
-    return { x: a.x + b.x, y: a.y + b.y };
+  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);
+    }
   }
-  static ptSub(a, b) {
-    return { x: a.x - b.x, y: a.y - b.y };
+  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]);
   }
-  static ptScale(p, c) {
-    return { x: p.x * c, y: p.y * c };
+  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;
+    }
   }
-  static ptDot(a, b) {
-    return a.x * b.x + a.y * b.y;
+  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;
   }
-  static ptDist(a, b) {
-    return Math.hypot(a.x - b.x, a.y - b.y);
+}
+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 };
   }
-  static distN(pts) {
-    let rv = 0;
-    for (let i = 1; i < pts.length; i++) rv += _RouteHelper.ptDist(pts[i], pts[i - 1]);
-    return rv;
+}
+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];
+    }
   }
-  static points2coeff(v0, v1, v2, v3, c) {
-    c[3] = v3 + 3 * v1 - (v0 + 3 * v2);
-    c[2] = 3 * v0 + 3 * v2 - 6 * v1;
-    c[1] = 3 * (v1 - v0);
-    c[0] = v0;
+  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;
   }
-  static addRoot(root, acc) {
-    if (root >= 0 && root <= 1) {
-      acc.roots[acc.n] = root;
-      acc.n++;
-    }
+  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;
   }
-  static silBothZero(sps, lc, acc) {
-    const sc = [0, 0, 0, 0], xr = [0, 0, 0], yr = [0, 0, 0];
-    _RouteHelper.points2coeff(sps[0].x, sps[1].x, sps[2].x, sps[3].x, sc);
-    sc[0] -= lc.xc0;
-    const xn = solve3(sc, xr);
-    _RouteHelper.points2coeff(sps[0].y, sps[1].y, sps[2].y, sps[3].y, sc);
-    sc[0] -= lc.yc0;
-    const yn = solve3(sc, yr);
-    if (xn === 4) {
-      if (yn === 4) return 4;
-      for (let j = 0; j < yn; j++) _RouteHelper.addRoot(yr[j], acc);
-    } else if (yn === 4) {
-      for (let i = 0; i < xn; i++) _RouteHelper.addRoot(xr[i], acc);
-    } else {
-      for (let i = 0; i < xn; i++)
-        for (let j = 0; j < yn; j++)
-          if (xr[i] === yr[j]) _RouteHelper.addRoot(xr[i], acc);
-    }
-    return acc.n;
+}
+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;
   }
-  static silXzeroYnonzero(sps, lc, acc) {
-    const sc = [0, 0, 0, 0], xr = [0, 0, 0];
-    _RouteHelper.points2coeff(sps[0].x, sps[1].x, sps[2].x, sps[3].x, sc);
-    sc[0] -= lc.xc0;
-    const xn = solve3(sc, xr);
-    if (xn === 4) return 4;
-    for (let i = 0; i < xn; i++) {
-      const tv = xr[i];
-      if (tv >= 0 && tv <= 1) {
-        _RouteHelper.points2coeff(sps[0].y, sps[1].y, sps[2].y, sps[3].y, sc);
-        const sv = (sc[0] + tv * (sc[1] + tv * (sc[2] + tv * sc[3])) - lc.yc0) / lc.yc1;
-        if (sv >= 0 && sv <= 1) _RouteHelper.addRoot(tv, acc);
-      }
-    }
-    return acc.n;
+}
+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;
   }
-  static silGeneral(sps, lc, acc) {
-    const sc = [0, 0, 0, 0], xr = [0, 0, 0];
-    const rat = lc.yc1 / lc.xc1;
-    _RouteHelper.points2coeff(
-      sps[0].y - rat * sps[0].x,
-      sps[1].y - rat * sps[1].x,
-      sps[2].y - rat * sps[2].x,
-      sps[3].y - rat * sps[3].x,
-      sc
-    );
-    sc[0] += rat * lc.xc0 - lc.yc0;
-    const xn = solve3(sc, xr);
-    if (xn === 4) return 4;
-    for (let i = 0; i < xn; i++) {
-      const tv = xr[i];
-      if (tv >= 0 && tv <= 1) {
-        _RouteHelper.points2coeff(sps[0].x, sps[1].x, sps[2].x, sps[3].x, sc);
-        const sv = (sc[0] + tv * (sc[1] + tv * (sc[2] + tv * sc[3])) - lc.xc0) / lc.xc1;
-        if (sv >= 0 && sv <= 1) _RouteHelper.addRoot(tv, acc);
-      }
-    }
-    return acc.n;
+}
+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;
   }
-  static splineIntersectsLine(sps, lps, roots) {
-    const lc = {
-      xc0: lps[0].x,
-      xc1: lps[1].x - lps[0].x,
-      yc0: lps[0].y,
-      yc1: lps[1].y - lps[0].y
-    };
-    const acc = { roots, n: 0 };
-    if (lc.xc1 === 0) {
-      if (lc.yc1 === 0) return _RouteHelper.silBothZero(sps, lc, acc);
-      return _RouteHelper.silXzeroYnonzero(sps, lc, acc);
-    }
-    return _RouteHelper.silGeneral(sps, lc, acc);
+}
+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;
   }
-  static splineIsInside(barriers, sps) {
-    const roots = [0, 0, 0, 0];
-    for (let ei = 0; ei < barriers.length; ei++) {
-      const lps = [barriers[ei].a, barriers[ei].b];
+}
+
+// src/pathplan/solvers.ts
+var EPS2 = 1e-7;
+var Solver = class _Solver {
+  static aeq0(x) {
+    return x < EPS2 && x > -EPS2;
+  }
+  static solve1(c, r) {
+    if (_Solver.aeq0(c[1])) return _Solver.aeq0(c[0]) ? 4 : 0;
+    r[0] = -c[0] / c[1];
+    return 1;
+  }
+  static solve2(c, r) {
+    if (_Solver.aeq0(c[2])) return _Solver.solve1(c, r);
+    const b2a = c[1] / (2 * c[2]);
+    const disc = b2a * b2a - c[0] / c[2];
+    if (disc < 0) return 0;
+    if (disc > 0) {
+      r[0] = -b2a + Math.sqrt(disc);
+      r[1] = -2 * b2a - r[0];
+      return 2;
+    }
+    r[0] = -b2a;
+    return 1;
+  }
+  static solve3neg(disc, q, b3a, r) {
+    const rr = 0.5 * Math.sqrt(-disc + q * q);
+    const theta = Math.atan2(Math.sqrt(-disc), -q);
+    const temp = 2 * Math.cbrt(rr);
+    r[0] = temp * Math.cos(theta / 3) - b3a;
+    r[1] = temp * Math.cos((theta + 2 * Math.PI) / 3) - b3a;
+    r[2] = temp * Math.cos((theta - 2 * Math.PI) / 3) - b3a;
+    return 3;
+  }
+  static solve3pos(disc, q, b3a, r) {
+    const al = 0.5 * (Math.sqrt(disc) - q);
+    r[0] = Math.cbrt(al) + Math.cbrt(-q - al) - b3a;
+    if (disc > 0) return 1;
+    r[1] = r[2] = -0.5 * (r[0] + b3a) - b3a;
+    return 3;
+  }
+  static solve3(c, r) {
+    const a = c[3], b = c[2], cv = c[1], d = c[0];
+    if (_Solver.aeq0(a)) return _Solver.solve2(c, r);
+    const b3a = b / (3 * a), p0 = b3a * b3a;
+    const q = 2 * b3a * p0 - b3a * cv / a + d / a;
+    const p = cv / (3 * a) - p0;
+    const disc = q * q + 4 * p * p * p;
+    return disc < 0 ? _Solver.solve3neg(disc, q, b3a, r) : _Solver.solve3pos(disc, q, b3a, r);
+  }
+};
+function solve3(coeff, roots) {
+  return Solver.solve3(coeff, roots);
+}
+
+// src/pathplan/route.ts
+var EPSILON1 = 1e-3;
+var EPSILON2 = 1e-6;
+var RouteHelper = class _RouteHelper {
+  static B0(t) {
+    const u = 1 - t;
+    return u * u * u;
+  }
+  static B1(t) {
+    const u = 1 - t;
+    return 3 * t * u * u;
+  }
+  static B2(t) {
+    const u = 1 - t;
+    return 3 * t * t * u;
+  }
+  static B3(t) {
+    return t * t * t;
+  }
+  static B01(t) {
+    const u = 1 - t;
+    return u * u * (u + 3 * t);
+  }
+  static B23(t) {
+    const u = 1 - t;
+    return t * t * (3 * u + t);
+  }
+  static normv(v) {
+    const d = v.x * v.x + v.y * v.y;
+    if (d > 1e-6) {
+      const s = Math.sqrt(d);
+      return { x: v.x / s, y: v.y / s };
+    }
+    return v;
+  }
+  static ptAdd(a, b) {
+    return { x: a.x + b.x, y: a.y + b.y };
+  }
+  static ptSub(a, b) {
+    return { x: a.x - b.x, y: a.y - b.y };
+  }
+  static ptScale(p, c) {
+    return { x: p.x * c, y: p.y * c };
+  }
+  static ptDot(a, b) {
+    return a.x * b.x + a.y * b.y;
+  }
+  static ptDist(a, b) {
+    return Math.hypot(a.x - b.x, a.y - b.y);
+  }
+  static distN(pts) {
+    let rv = 0;
+    for (let i = 1; i < pts.length; i++) rv += _RouteHelper.ptDist(pts[i], pts[i - 1]);
+    return rv;
+  }
+  static points2coeff(v0, v1, v2, v3, c) {
+    c[3] = v3 + 3 * v1 - (v0 + 3 * v2);
+    c[2] = 3 * v0 + 3 * v2 - 6 * v1;
+    c[1] = 3 * (v1 - v0);
+    c[0] = v0;
+  }
+  static addRoot(root, acc) {
+    if (root >= 0 && root <= 1) {
+      acc.roots[acc.n] = root;
+      acc.n++;
+    }
+  }
+  static silBothZero(sps, lc, acc) {
+    const sc = [0, 0, 0, 0], xr = [0, 0, 0], yr = [0, 0, 0];
+    _RouteHelper.points2coeff(sps[0].x, sps[1].x, sps[2].x, sps[3].x, sc);
+    sc[0] -= lc.xc0;
+    const xn = solve3(sc, xr);
+    _RouteHelper.points2coeff(sps[0].y, sps[1].y, sps[2].y, sps[3].y, sc);
+    sc[0] -= lc.yc0;
+    const yn = solve3(sc, yr);
+    if (xn === 4) {
+      if (yn === 4) return 4;
+      for (let j = 0; j < yn; j++) _RouteHelper.addRoot(yr[j], acc);
+    } else if (yn === 4) {
+      for (let i = 0; i < xn; i++) _RouteHelper.addRoot(xr[i], acc);
+    } else {
+      for (let i = 0; i < xn; i++)
+        for (let j = 0; j < yn; j++)
+          if (xr[i] === yr[j]) _RouteHelper.addRoot(xr[i], acc);
+    }
+    return acc.n;
+  }
+  static silXzeroYnonzero(sps, lc, acc) {
+    const sc = [0, 0, 0, 0], xr = [0, 0, 0];
+    _RouteHelper.points2coeff(sps[0].x, sps[1].x, sps[2].x, sps[3].x, sc);
+    sc[0] -= lc.xc0;
+    const xn = solve3(sc, xr);
+    if (xn === 4) return 4;
+    for (let i = 0; i < xn; i++) {
+      const tv = xr[i];
+      if (tv >= 0 && tv <= 1) {
+        _RouteHelper.points2coeff(sps[0].y, sps[1].y, sps[2].y, sps[3].y, sc);
+        const sv = (sc[0] + tv * (sc[1] + tv * (sc[2] + tv * sc[3])) - lc.yc0) / lc.yc1;
+        if (sv >= 0 && sv <= 1) _RouteHelper.addRoot(tv, acc);
+      }
+    }
+    return acc.n;
+  }
+  static silGeneral(sps, lc, acc) {
+    const sc = [0, 0, 0, 0], xr = [0, 0, 0];
+    const rat = lc.yc1 / lc.xc1;
+    _RouteHelper.points2coeff(
+      sps[0].y - rat * sps[0].x,
+      sps[1].y - rat * sps[1].x,
+      sps[2].y - rat * sps[2].x,
+      sps[3].y - rat * sps[3].x,
+      sc
+    );
+    sc[0] += rat * lc.xc0 - lc.yc0;
+    const xn = solve3(sc, xr);
+    if (xn === 4) return 4;
+    for (let i = 0; i < xn; i++) {
+      const tv = xr[i];
+      if (tv >= 0 && tv <= 1) {
+        _RouteHelper.points2coeff(sps[0].x, sps[1].x, sps[2].x, sps[3].x, sc);
+        const sv = (sc[0] + tv * (sc[1] + tv * (sc[2] + tv * sc[3])) - lc.xc0) / lc.xc1;
+        if (sv >= 0 && sv <= 1) _RouteHelper.addRoot(tv, acc);
+      }
+    }
+    return acc.n;
+  }
+  static splineIntersectsLine(sps, lps, roots) {
+    const lc = {
+      xc0: lps[0].x,
+      xc1: lps[1].x - lps[0].x,
+      yc0: lps[0].y,
+      yc1: lps[1].y - lps[0].y
+    };
+    const acc = { roots, n: 0 };
+    if (lc.xc1 === 0) {
+      if (lc.yc1 === 0) return _RouteHelper.silBothZero(sps, lc, acc);
+      return _RouteHelper.silXzeroYnonzero(sps, lc, acc);
+    }
+    return _RouteHelper.silGeneral(sps, lc, acc);
+  }
+  static splineIsInside(barriers, sps) {
+    const roots = [0, 0, 0, 0];
+    for (let ei = 0; ei < barriers.length; ei++) {
+      const lps = [barriers[ei].a, barriers[ei].b];
       const rootn = _RouteHelper.splineIntersectsLine(sps, lps, roots);
       if (rootn === 4) continue;
       for (let ri = 0; ri < rootn; ri++) {
@@ -24792,1057 +25179,496 @@ var RouteHelper = class _RouteHelper {
       }
       a = a > 0.01 ? a / 2 : 0;
     }
-    return 0;
-  }
-  static reallyRoute(state3, inps, ev0, ev1) {
-    const tnas = _RouteHelper.initTnas(inps, ev0, ev1);
-    const ends = _RouteHelper.mkspline(inps, tnas, ev0, ev1);
-    if (_RouteHelper.splineFits(state3, ends, inps)) return true;
-    const maxi = _RouteHelper.findMaxDev(inps, tnas, ends);
-    const sv1 = _RouteHelper.normv(_RouteHelper.ptSub(inps[maxi], inps[maxi - 1]));
-    const sv2 = _RouteHelper.normv(_RouteHelper.ptSub(inps[maxi + 1], inps[maxi]));
-    const splitv = _RouteHelper.normv(_RouteHelper.ptAdd(sv1, sv2));
-    if (!_RouteHelper.reallyRoute(state3, inps.slice(0, maxi + 1), ev0, splitv)) return false;
-    if (!_RouteHelper.reallyRoute(state3, inps.slice(maxi), splitv, ev1)) return false;
-    return true;
-  }
-  static run(barriers, route, slopes) {
-    const state3 = { ops: [], barriers };
-    const ev0 = _RouteHelper.normv(slopes[0]);
-    const ev1 = _RouteHelper.normv(slopes[1]);
-    state3.ops.push(route[0]);
-    _RouteHelper.reallyRoute(state3, route, ev0, ev1);
-    return state3.ops;
-  }
-};
-function routeSpline(barriers, route, slopes) {
-  return RouteHelper.run(barriers, route, slopes);
-}
-function polyBarriers(polys) {
-  const out = [];
-  for (const poly of polys) {
-    const n = poly.ps.length;
-    for (let j = 0; j < n; j++) out.push({ a: poly.ps[j], b: poly.ps[(j + 1) % n] });
-  }
-  return out;
-}
-function makePolyline(pts) {
-  const out = [];
-  out.push(pts[0], pts[0]);
-  for (let i = 1; i + 1 < pts.length; i++) out.push(pts[i], pts[i], pts[i]);
-  out.push(pts[pts.length - 1], pts[pts.length - 1]);
-  return out;
-}
-
-// src/pathplan/triang.ts
-var ISCCW = 1;
-var ISCW = 2;
-var ISON = 3;
-var SPLIT2 = 134217729;
-function twoProductErr(a, b, P) {
-  const ac = SPLIT2 * a;
-  const ahi = ac - (ac - a);
-  const alo = a - ahi;
-  const bc = SPLIT2 * b;
-  const bhi = bc - (bc - b);
-  const blo = b - bhi;
-  return ahi * bhi - P + ahi * blo + alo * bhi + alo * blo;
-}
-function twoDiffTail(P, D, s) {
-  const bvirt = P - s;
-  const avirt = s + bvirt;
-  const bround = bvirt - D;
-  const around = P - avirt;
-  return around + bround;
-}
-var dyadicView = new DataView(new ArrayBuffer(8));
-function dyadic(x) {
-  if (x === 0) return { m: 0n, e: 0 };
-  dyadicView.setFloat64(0, x);
-  const hi = dyadicView.getUint32(0);
-  const lo = dyadicView.getUint32(4);
-  const sign2 = hi >>> 31 ? -1n : 1n;
-  const biasedExp = hi >>> 20 & 2047;
-  let mant = BigInt(hi & 1048575) << 32n | BigInt(lo);
-  let e;
-  if (biasedExp === 0) {
-    e = -1074;
-  } else {
-    mant |= 1n << 52n;
-    e = biasedExp - 1075;
-  }
-  return { m: sign2 * mant, e };
-}
-function signOfSum3(a, b, c) {
-  const da = dyadic(a);
-  const db = dyadic(b);
-  const dc = dyadic(c);
-  const e = Math.min(da.e, db.e, dc.e);
-  const sum = (da.m << BigInt(da.e - e)) + (db.m << BigInt(db.e - e)) + (dc.m << BigInt(dc.e - e));
-  return sum > 0n ? 1 : sum < 0n ? -1 : 0;
-}
-var TriangHelper = class _TriangHelper {
-  static ccw(p1, p2, p3) {
-    const a = p1.y - p2.y;
-    const b = p3.x - p2.x;
-    const c = p3.y - p2.y;
-    const e = p1.x - p2.x;
-    const P = a * b;
-    const D = c * e;
-    const d = P - D;
-    const bound = 23e-17 * (Math.abs(P) + Math.abs(D));
-    if (d > bound) return ISCW;
-    if (d < -bound) return ISCCW;
-    const err = twoProductErr(a, b, P);
-    const s = P - D;
-    const tail = twoDiffTail(P, D, s);
-    const sign2 = signOfSum3(s, tail, err);
-    return sign2 > 0 ? ISCW : sign2 < 0 ? ISCCW : ISON;
-  }
-  /** Is pc on segment [pa, pb]? */
-  static between(pa, pb, pc) {
-    if (_TriangHelper.ccw(pa, pb, pc) !== ISON) return false;
-    const pba = { x: pb.x - pa.x, y: pb.y - pa.y };
-    const pca = { x: pc.x - pa.x, y: pc.y - pa.y };
-    return pca.x * pba.x + pca.y * pba.y >= 0 && pca.x * pca.x + pca.y * pca.y <= pba.x * pba.x + pba.y * pba.y;
-  }
-  static anyCollinear(pa, pb, pc, pd) {
-    const c = _TriangHelper.ccw;
-    return c(pa, pb, pc) === ISON || c(pa, pb, pd) === ISON || c(pc, pd, pa) === ISON || c(pc, pd, pb) === ISON;
-  }
-  static collinearIntersects(pa, pb, pc, pd) {
-    const b = _TriangHelper.between;
-    return b(pa, pb, pc) || b(pa, pb, pd) || b(pc, pd, pa) || b(pc, pd, pb);
-  }
-  static crossIntersects(pa, pb, pc, pd) {
-    const c = _TriangHelper.ccw;
-    const c1 = c(pa, pb, pc) === ISCCW ? 1 : 0;
-    const c2 = c(pa, pb, pd) === ISCCW ? 1 : 0;
-    const c3 = c(pc, pd, pa) === ISCCW ? 1 : 0;
-    const c4 = c(pc, pd, pb) === ISCCW ? 1 : 0;
-    return (c1 ^ c2) !== 0 && (c3 ^ c4) !== 0;
-  }
-  static intersects(pa, pb, pc, pd) {
-    if (_TriangHelper.anyCollinear(pa, pb, pc, pd))
-      return _TriangHelper.collinearIntersects(pa, pb, pc, pd);
-    return _TriangHelper.crossIntersects(pa, pb, pc, pd);
-  }
-  static isdiagNeighborhood(i, ip2, get, pointn) {
-    const ip1 = (i + 1) % pointn;
-    const im1 = (i + pointn - 1) % pointn;
-    const c = _TriangHelper.ccw;
-    if (c(get(im1), get(i), get(ip1)) === ISCCW) {
-      return c(get(i), get(ip2), get(im1)) === ISCCW && c(get(ip2), get(i), get(ip1)) === ISCCW;
-    }
-    return c(get(i), get(ip2), get(ip1)) === ISCW;
-  }
-  static isdiagonal(i, ip2, get, pointn) {
-    if (!_TriangHelper.isdiagNeighborhood(i, ip2, get, pointn)) return false;
-    for (let j = 0; j < pointn; j++) {
-      const jp1 = (j + 1) % pointn;
-      if (j !== i && jp1 !== i && j !== ip2 && jp1 !== ip2) {
-        if (_TriangHelper.intersects(get(i), get(ip2), get(j), get(jp1)))
-          return false;
-      }
-    }
-    return true;
-  }
-  static triangulateInner(pts, fn) {
-    let cur = pts;
-    while (cur.length > 3) {
-      const n = cur.length;
-      let cut = -1;
-      for (let i = 0; i < n; i++) {
-        const ip2 = (i + 2) % n;
-        if (_TriangHelper.isdiagonal(i, ip2, (k) => cur[k], n)) {
-          fn([cur[i], cur[(i + 1) % n], cur[ip2]]);
-          cut = (i + 1) % n;
-          break;
-        }
-      }
-      if (cut === -1) return false;
-      cur = cur.filter((_, idx) => idx !== cut);
-    }
-    fn([cur[0], cur[1], cur[2]]);
-    return true;
-  }
-};
-function ccw(p1, p2, p3) {
-  return TriangHelper.ccw(p1, p2, p3);
-}
-function isdiagonal(i, ip2, get, pointn) {
-  return TriangHelper.isdiagonal(i, ip2, get, pointn);
-}
-
-// src/pathplan/shortest.ts
-var NO_TRI = -1;
-var DQ_FRONT = 1;
-var DQ_BACK = 2;
-var ShortestHelper = class _ShortestHelper {
-  static buildTri(a, b, c) {
-    const mk = (p0, p1) => ({ pnl0: p0, pnl1: p1, rightIndex: NO_TRI });
-    return { mark: 0, e: [mk(a, b), mk(b, c), mk(c, a)] };
-  }
-  static triInner(pnlps, tris) {
-    let pts = pnlps;
-    while (pts.length > 3) {
-      const n = pts.length;
-      let cut = -1;
-      for (let i = 0; i < n; i++) {
-        const ip2 = (i + 2) % n;
-        if (isdiagonal(i, ip2, (k) => pts[k].pp, n)) {
-          tris.push(_ShortestHelper.buildTri(pts[i], pts[(i + 1) % n], pts[ip2]));
-          cut = (i + 1) % n;
-          break;
-        }
-      }
-      if (cut === -1) return false;
-      pts = pts.filter((_, j) => j !== cut);
-    }
-    tris.push(_ShortestHelper.buildTri(pts[0], pts[1], pts[2]));
-    return true;
-  }
-  static connectTri(i, j, tris) {
-    const t1 = tris[i], t2 = tris[j];
-    for (let ei = 0; ei < 3; ei++) {
-      for (let ej = 0; ej < 3; ej++) {
-        const e1 = t1.e[ei], e2 = t2.e[ej];
-        if (e1.pnl0 === e2.pnl0 && e1.pnl1 === e2.pnl1 || e1.pnl0 === e2.pnl1 && e1.pnl1 === e2.pnl0)
-          e1.rightIndex = j, e2.rightIndex = i;
-      }
-    }
-  }
-  static connectAll(tris) {
-    for (let i = 0; i < tris.length; i++)
-      for (let j = i + 1; j < tris.length; j++)
-        _ShortestHelper.connectTri(i, j, tris);
-  }
-  static pointInTri(tri, p) {
-    let sum = 0;
-    for (let ei = 0; ei < 3; ei++)
-      if (ccw(tri.e[ei].pnl0.pp, tri.e[ei].pnl1.pp, p) !== ISCW) sum++;
-    return sum === 3 || sum === 0;
-  }
-  static markPath(tris, trii, trij) {
-    if (tris[trii].mark) return false;
-    tris[trii].mark = 1;
-    if (trii === trij) return true;
-    for (let ei = 0; ei < 3; ei++) {
-      const ri = tris[trii].e[ei].rightIndex;
-      if (ri !== NO_TRI && _ShortestHelper.markPath(tris, ri, trij)) return true;
-    }
-    tris[trii].mark = 0;
-    return false;
-  }
-  static findTri(tris, p) {
-    for (let i = 0; i < tris.length; i++)
-      if (_ShortestHelper.pointInTri(tris[i], p)) return i;
-    return NO_TRI;
-  }
-  static findMinX(ps) {
-    let minx = Infinity, minpi = 0;
-    for (let i = 0; i < ps.length; i++)
-      if (ps[i].x < minx) {
-        minx = ps[i].x;
-        minpi = i;
-      }
-    return minpi;
-  }
-  static isPolyCW(ps, minpi) {
-    const pn = ps.length;
-    const p2 = ps[minpi];
-    const p1 = ps[minpi === 0 ? pn - 1 : minpi - 1];
-    const p3 = ps[(minpi + 1) % pn];
-    if (p1.x === p2.x && p2.x === p3.x && p3.y > p2.y) return true;
-    return ccw(p1, p2, p3) !== ISCCW;
-  }
-  static loadForward(ps) {
-    const r = [];
-    for (let i = 0; i < ps.length; i++) {
-      if (i > 0 && ps[i].x === ps[i - 1].x && ps[i].y === ps[i - 1].y) continue;
-      r.push({ pp: ps[i], link: null });
-    }
-    return r;
-  }
-  static loadReverse(ps) {
-    const r = [];
-    for (let i = ps.length - 1; i >= 0; i--) {
-      if (i < ps.length - 1 && ps[i].x === ps[i + 1].x && ps[i].y === ps[i + 1].y) continue;
-      r.push({ pp: ps[i], link: null });
-    }
-    return r;
-  }
-  static loadPoints(poly) {
-    const ps = poly.ps;
-    return _ShortestHelper.isPolyCW(ps, _ShortestHelper.findMinX(ps)) ? _ShortestHelper.loadReverse(ps) : _ShortestHelper.loadForward(ps);
-  }
-  static initDeque(pnll) {
-    const pnlpn = pnll * 2;
-    const pnlps = new Array(pnlpn).fill(null);
-    const fpnlpi = Math.floor(pnlpn / 2);
-    return { pnlps, pnlpn, fpnlpi, lpnlpi: fpnlpi - 1, apex: 0 };
-  }
-  static add2dq(dq, side, pnl) {
-    if (side === DQ_FRONT) {
-      if (dq.lpnlpi >= dq.fpnlpi) pnl.link = dq.pnlps[dq.fpnlpi];
-      dq.fpnlpi--;
-      dq.pnlps[dq.fpnlpi] = pnl;
-    } else {
-      if (dq.lpnlpi >= dq.fpnlpi) pnl.link = dq.pnlps[dq.lpnlpi];
-      dq.lpnlpi++;
-      dq.pnlps[dq.lpnlpi] = pnl;
-    }
-  }
-  static splitdq(dq, side, index) {
-    if (side === DQ_FRONT) dq.lpnlpi = index;
-    else dq.fpnlpi = index;
-  }
-  static finddqsplit(dq, pnl) {
-    for (let idx = dq.fpnlpi; idx < dq.apex; idx++)
-      if (ccw(dq.pnlps[idx + 1].pp, dq.pnlps[idx].pp, pnl.pp) === ISCCW) return idx;
-    for (let idx = dq.lpnlpi; idx > dq.apex; idx--)
-      if (ccw(dq.pnlps[idx - 1].pp, dq.pnlps[idx].pp, pnl.pp) === ISCW) return idx;
-    return dq.apex;
-  }
-  static fuFindEi(trip, tris) {
-    for (let ei = 0; ei < 3; ei++) {
-      const ri = trip.e[ei].rightIndex;
-      if (ri !== NO_TRI && tris[ri].mark === 1) return ei;
-    }
-    return 3;
-  }
-  static fuNextTri(trip, tris) {
-    for (let ei = 0; ei < 3; ei++) {
-      const ri = trip.e[ei].rightIndex;
-      if (ri !== NO_TRI && tris[ri].mark === 1) return ri;
-    }
-    return NO_TRI;
-  }
-  static fuGetPairLast(epnl1, dq) {
-    if (ccw(epnl1.pp, dq.pnlps[dq.fpnlpi].pp, dq.pnlps[dq.lpnlpi].pp) === ISCCW)
-      return [dq.pnlps[dq.lpnlpi], epnl1];
-    return [epnl1, dq.pnlps[dq.lpnlpi]];
-  }
-  static fuGetPairNormal(trip, ei) {
-    const e = trip.e[ei];
-    const pnl = trip.e[(ei + 1) % 3].pnl1;
-    if (ccw(e.pnl0.pp, pnl.pp, e.pnl1.pp) === ISCCW) return [e.pnl1, e.pnl0];
-    return [e.pnl0, e.pnl1];
-  }
-  static fuUpdateRight(dq, r) {
-    const si = _ShortestHelper.finddqsplit(dq, r);
-    _ShortestHelper.splitdq(dq, DQ_BACK, si);
-    _ShortestHelper.add2dq(dq, DQ_FRONT, r);
-    if (si > dq.apex) dq.apex = si;
-  }
-  static fuUpdateLeft(dq, l) {
-    const si = _ShortestHelper.finddqsplit(dq, l);
-    _ShortestHelper.splitdq(dq, DQ_FRONT, si);
-    _ShortestHelper.add2dq(dq, DQ_BACK, l);
-    if (si < dq.apex) dq.apex = si;
-  }
-  static fuUpdate(dq, l, r, isFirst) {
-    if (isFirst) {
-      _ShortestHelper.add2dq(dq, DQ_BACK, l);
-      _ShortestHelper.add2dq(dq, DQ_FRONT, r);
-      return;
-    }
-    if (dq.pnlps[dq.fpnlpi] !== r && dq.pnlps[dq.lpnlpi] !== r)
-      _ShortestHelper.fuUpdateRight(dq, r);
-    else
-      _ShortestHelper.fuUpdateLeft(dq, l);
-  }
-  static fuLoop(tris, dq, epnls, ftrii) {
-    let trii = ftrii;
-    while (trii !== NO_TRI) {
-      const trip = tris[trii];
-      trip.mark = 2;
-      const ei = _ShortestHelper.fuFindEi(trip, tris);
-      const [l, r] = ei === 3 ? _ShortestHelper.fuGetPairLast(epnls[1], dq) : _ShortestHelper.fuGetPairNormal(trip, ei);
-      _ShortestHelper.fuUpdate(dq, l, r, trii === ftrii);
-      trii = _ShortestHelper.fuNextTri(trip, tris);
-    }
-  }
-  static extractPath(epnl1) {
-    const pts = [];
-    for (let p = epnl1; p !== null; p = p.link) pts.push(p.pp);
-    pts.reverse();
-    return pts;
-  }
-  static run(poly, eps) {
-    const pnlps = _ShortestHelper.loadPoints(poly);
-    const tris = [];
-    if (!_ShortestHelper.triInner(pnlps.slice(), tris)) {
-      console.warn("triangulation failed");
-    }
-    _ShortestHelper.connectAll(tris);
-    const ftrii = _ShortestHelper.findTri(tris, eps[0]);
-    const ltrii = _ShortestHelper.findTri(tris, eps[1]);
-    if (ftrii === NO_TRI || ltrii === NO_TRI) return null;
-    if (ftrii === ltrii) return [eps[0], eps[1]];
-    if (!_ShortestHelper.markPath(tris, ftrii, ltrii)) return [eps[0], eps[1]];
-    const epnls = [{ pp: eps[0], link: null }, { pp: eps[1], link: null }];
-    const dq = _ShortestHelper.initDeque(pnlps.length);
-    _ShortestHelper.add2dq(dq, DQ_FRONT, epnls[0]);
-    dq.apex = dq.fpnlpi;
-    _ShortestHelper.fuLoop(tris, dq, epnls, ftrii);
-    return _ShortestHelper.extractPath(epnls[1]);
-  }
-};
-function shortestPath(poly, eps) {
-  return ShortestHelper.run(poly, eps);
-}
-
-// src/layout/dot/edge-route-poly.ts
-function fwdDirs(boxes, bi) {
-  const n = boxes.length;
-  const prev = bi > 0 ? boxes[bi].ll.y > boxes[bi - 1].ll.y ? -1 : 1 : 0;
-  const next = bi + 1 < n ? boxes[bi + 1].ll.y > boxes[bi].ll.y ? 1 : -1 : 0;
-  return { prev, next };
-}
-function emitFwdBox(b, prev, next, pts) {
-  if (prev !== next) {
-    if (next === -1 || prev === 1) {
-      pts.push({ x: b.ll.x, y: b.ur.y }, { x: b.ll.x, y: b.ll.y });
-    } else {
-      pts.push({ x: b.ur.x, y: b.ll.y }, { x: b.ur.x, y: b.ur.y });
-    }
-  } else if (prev === 0) {
-    pts.push({ x: b.ll.x, y: b.ur.y }, { x: b.ll.x, y: b.ll.y });
-  }
-}
-function addForwardPolyPts(boxes, pts) {
-  for (let bi = 0; bi < boxes.length; bi++) {
-    const { prev, next } = fwdDirs(boxes, bi);
-    emitFwdBox(boxes[bi], prev, next, pts);
-  }
-}
-function revDirs(boxes, bi) {
-  const n = boxes.length;
-  const prev = bi + 1 < n ? boxes[bi].ll.y > boxes[bi + 1].ll.y ? -1 : 1 : 0;
-  const next = bi > 0 ? boxes[bi - 1].ll.y > boxes[bi].ll.y ? 1 : -1 : 0;
-  return { prev, next };
-}
-function emitAllCorners(b, pts) {
-  pts.push(
-    { x: b.ur.x, y: b.ll.y },
-    { x: b.ur.x, y: b.ur.y },
-    { x: b.ll.x, y: b.ur.y },
-    { x: b.ll.x, y: b.ll.y }
-  );
-}
-function emitRevBox(b, prev, next, pts) {
-  if (prev !== next) {
-    if (next === -1 || prev === 1) {
-      pts.push({ x: b.ll.x, y: b.ur.y }, { x: b.ll.x, y: b.ll.y });
-    } else {
-      pts.push({ x: b.ur.x, y: b.ll.y }, { x: b.ur.x, y: b.ur.y });
-    }
-  } else if (prev === 0) {
-    pts.push({ x: b.ur.x, y: b.ll.y }, { x: b.ur.x, y: b.ur.y });
-  } else {
-    emitAllCorners(b, pts);
-  }
-}
-function addReversePolyPts(boxes, pts) {
-  for (let bi = boxes.length - 1; bi >= 0; bi--) {
-    const { prev, next } = revDirs(boxes, bi);
-    emitRevBox(boxes[bi], prev, next, pts);
-  }
-}
-function boxesToPolygon(boxes) {
-  if (boxes.length === 0) return [];
-  const pts = [];
-  addForwardPolyPts(boxes, pts);
-  addReversePolyPts(boxes, pts);
-  return pts;
-}
-function polyEdgesFromPts(polygon) {
-  const n = polygon.length;
-  return polygon.map((a, i) => ({ a, b: polygon[(i + 1) % n] }));
-}
-function linearBezier(p0, p3) {
-  return [
-    p0,
-    { x: p0.x + (p3.x - p0.x) / 3, y: p0.y + (p3.y - p0.y) / 3 },
-    { x: p0.x + 2 * (p3.x - p0.x) / 3, y: p0.y + 2 * (p3.y - p0.y) / 3 },
-    p3
-  ];
-}
-function tryRouteSpline(barriers, wpts) {
-  const zero = { x: 0, y: 0 };
-  const raw = routeSpline(barriers, wpts, [zero, zero]);
-  if (raw.length < 4) return null;
-  return [raw[0], raw[1], raw[2], raw[3]];
-}
-function computeSpline(boxes, startPt, endPt) {
-  const polygon = boxesToPolygon(boxes);
-  if (polygon.length < 3) return linearBezier(startPt, endPt);
-  const wpts = shortestPath({ ps: polygon }, [startPt, endPt]);
-  if (wpts === null || wpts.length < 2) return linearBezier(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 };
+    return 0;
   }
-  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
-    };
+  static reallyRoute(state3, inps, ev0, ev1) {
+    const tnas = _RouteHelper.initTnas(inps, ev0, ev1);
+    const ends = _RouteHelper.mkspline(inps, tnas, ev0, ev1);
+    if (_RouteHelper.splineFits(state3, ends, inps)) return true;
+    const maxi = _RouteHelper.findMaxDev(inps, tnas, ends);
+    const sv1 = _RouteHelper.normv(_RouteHelper.ptSub(inps[maxi], inps[maxi - 1]));
+    const sv2 = _RouteHelper.normv(_RouteHelper.ptSub(inps[maxi + 1], inps[maxi]));
+    const splitv = _RouteHelper.normv(_RouteHelper.ptAdd(sv1, sv2));
+    if (!_RouteHelper.reallyRoute(state3, inps.slice(0, maxi + 1), ev0, splitv)) return false;
+    if (!_RouteHelper.reallyRoute(state3, inps.slice(maxi), splitv, ev1)) return false;
+    return true;
   }
-  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
-  };
+  static run(barriers, route, slopes) {
+    const state3 = { ops: [], barriers };
+    const ev0 = _RouteHelper.normv(slopes[0]);
+    const ev1 = _RouteHelper.normv(slopes[1]);
+    state3.ops.push(route[0]);
+    _RouteHelper.reallyRoute(state3, route, ev0, ev1);
+    return state3.ops;
+  }
+};
+function routeSpline(barriers, route, slopes) {
+  return RouteHelper.run(barriers, route, slopes);
 }
-function edgeRenderPenwidth(e) {
-  return resolvePenWidth(parseStyleFlags(e.attrs.get("style")), e.attrs.get("penwidth"));
+function polyBarriers(polys) {
+  const out = [];
+  for (const poly of polys) {
+    const n = poly.ps.length;
+    for (let j = 0; j < n; j++) out.push({ a: poly.ps[j], b: poly.ps[(j + 1) % n] });
+  }
+  return out;
 }
-function edgePenwidthAttr(e) {
-  const pw = parseFloat(e.attrs.get("penwidth") ?? "");
-  return isNaN(pw) ? 1 : pw;
+function makePolyline(pts) {
+  const out = [];
+  out.push(pts[0], pts[0]);
+  for (let i = 1; i + 1 < pts.length; i++) out.push(pts[i], pts[i], pts[i]);
+  out.push(pts[pts.length - 1], pts[pts.length - 1]);
+  return out;
 }
-function makeBezierRecord(bezierPts, arrowTip) {
-  return {
-    list: bezierPts,
-    size: bezierPts.length,
-    sflag: 0,
-    eflag: 1,
-    sp: bezierPts[0] ?? { x: 0, y: 0 },
-    ep: arrowTip
-  };
+
+// src/pathplan/triang.ts
+var ISCCW = 1;
+var ISCW = 2;
+var ISON = 3;
+var SPLIT2 = 134217729;
+function twoProductErr(a, b, P) {
+  const ac = SPLIT2 * a;
+  const ahi = ac - (ac - a);
+  const alo = a - ahi;
+  const bc = SPLIT2 * b;
+  const bhi = bc - (bc - b);
+  const blo = b - bhi;
+  return ahi * bhi - P + ahi * blo + alo * bhi + alo * blo;
 }
-function makeSplineRecord(bz) {
-  return { list: [bz], size: 1, bb: { ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } } };
+function twoDiffTail(P, D, s) {
+  const bvirt = P - s;
+  const avirt = s + bvirt;
+  const bround = bvirt - D;
+  const around = P - avirt;
+  return around + bround;
 }
-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]]);
-    }
+var dyadicView = new DataView(new ArrayBuffer(8));
+function dyadic(x) {
+  if (x === 0) return { m: 0n, e: 0 };
+  dyadicView.setFloat64(0, x);
+  const hi = dyadicView.getUint32(0);
+  const lo = dyadicView.getUint32(4);
+  const sign2 = hi >>> 31 ? -1n : 1n;
+  const biasedExp = hi >>> 20 & 2047;
+  let mant = BigInt(hi & 1048575) << 32n | BigInt(lo);
+  let e;
+  if (biasedExp === 0) {
+    e = -1074;
+  } else {
+    mant |= 1n << 52n;
+    e = biasedExp - 1075;
   }
+  return { m: sign2 * mant, e };
 }
-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);
+function signOfSum3(a, b, c) {
+  const da = dyadic(a);
+  const db = dyadic(b);
+  const dc = dyadic(c);
+  const e = Math.min(da.e, db.e, dc.e);
+  const sum = (da.m << BigInt(da.e - e)) + (db.m << BigInt(db.e - e)) + (dc.m << BigInt(dc.e - e));
+  return sum > 0n ? 1 : sum < 0n ? -1 : 0;
 }
-
-// src/layout/dot/sameport.ts
-function sameedge(same, e, id) {
-  for (const grp of same) {
-    if (grp.id === id) {
-      grp.edges.push(e);
-      return;
+var TriangHelper = class _TriangHelper {
+  static ccw(p1, p2, p3) {
+    const a = p1.y - p2.y;
+    const b = p3.x - p2.x;
+    const c = p3.y - p2.y;
+    const e = p1.x - p2.x;
+    const P = a * b;
+    const D = c * e;
+    const d = P - D;
+    const bound = 23e-17 * (Math.abs(P) + Math.abs(D));
+    if (d > bound) return ISCW;
+    if (d < -bound) return ISCCW;
+    const err = twoProductErr(a, b, P);
+    const s = P - D;
+    const tail = twoDiffTail(P, D, s);
+    const sign2 = signOfSum3(s, tail, err);
+    return sign2 > 0 ? ISCW : sign2 < 0 ? ISCCW : ISON;
+  }
+  /** Is pc on segment [pa, pb]? */
+  static between(pa, pb, pc) {
+    if (_TriangHelper.ccw(pa, pb, pc) !== ISON) return false;
+    const pba = { x: pb.x - pa.x, y: pb.y - pa.y };
+    const pca = { x: pc.x - pa.x, y: pc.y - pa.y };
+    return pca.x * pba.x + pca.y * pba.y >= 0 && pca.x * pca.x + pca.y * pca.y <= pba.x * pba.x + pba.y * pba.y;
+  }
+  static anyCollinear(pa, pb, pc, pd) {
+    const c = _TriangHelper.ccw;
+    return c(pa, pb, pc) === ISON || c(pa, pb, pd) === ISON || c(pc, pd, pa) === ISON || c(pc, pd, pb) === ISON;
+  }
+  static collinearIntersects(pa, pb, pc, pd) {
+    const b = _TriangHelper.between;
+    return b(pa, pb, pc) || b(pa, pb, pd) || b(pc, pd, pa) || b(pc, pd, pb);
+  }
+  static crossIntersects(pa, pb, pc, pd) {
+    const c = _TriangHelper.ccw;
+    const c1 = c(pa, pb, pc) === ISCCW ? 1 : 0;
+    const c2 = c(pa, pb, pd) === ISCCW ? 1 : 0;
+    const c3 = c(pc, pd, pa) === ISCCW ? 1 : 0;
+    const c4 = c(pc, pd, pb) === ISCCW ? 1 : 0;
+    return (c1 ^ c2) !== 0 && (c3 ^ c4) !== 0;
+  }
+  static intersects(pa, pb, pc, pd) {
+    if (_TriangHelper.anyCollinear(pa, pb, pc, pd))
+      return _TriangHelper.collinearIntersects(pa, pb, pc, pd);
+    return _TriangHelper.crossIntersects(pa, pb, pc, pd);
+  }
+  static isdiagNeighborhood(i, ip2, get, pointn) {
+    const ip1 = (i + 1) % pointn;
+    const im1 = (i + pointn - 1) % pointn;
+    const c = _TriangHelper.ccw;
+    if (c(get(im1), get(i), get(ip1)) === ISCCW) {
+      return c(get(i), get(ip2), get(im1)) === ISCCW && c(get(ip2), get(i), get(ip1)) === ISCCW;
     }
+    return c(get(i), get(ip2), get(ip1)) === ISCW;
   }
-  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;
+  static isdiagonal(i, ip2, get, pointn) {
+    if (!_TriangHelper.isdiagNeighborhood(i, ip2, get, pointn)) return false;
+    for (let j = 0; j < pointn; j++) {
+      const jp1 = (j + 1) % pointn;
+      if (j !== i && jp1 !== i && j !== ip2 && jp1 !== ip2) {
+        if (_TriangHelper.intersects(get(i), get(ip2), get(j), get(jp1)))
+          return false;
+      }
+    }
+    return true;
+  }
+  static triangulateInner(pts, fn) {
+    let cur = pts;
+    while (cur.length > 3) {
+      const n = cur.length;
+      let cut = -1;
+      for (let i = 0; i < n; i++) {
+        const ip2 = (i + 2) % n;
+        if (_TriangHelper.isdiagonal(i, ip2, (k) => cur[k], n)) {
+          fn([cur[i], cur[(i + 1) % n], cur[ip2]]);
+          cut = (i + 1) % n;
+          break;
+        }
+      }
+      if (cut === -1) return false;
+      cur = cur.filter((_, idx) => idx !== cut);
     }
+    fn([cur[0], cur[1], cur[2]]);
+    return true;
   }
-  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 ccw(p1, p2, p3) {
+  return TriangHelper.ccw(p1, p2, p3);
 }
-function assignHeadIfMatch(f, u, prt) {
-  if (f.head === u) f.info.head_port = prt;
-  if (f.tail === u) f.info.tail_port = prt;
+function isdiagonal(i, ip2, get, pointn) {
+  return TriangHelper.isdiagonal(i, ip2, get, pointn);
 }
-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);
+
+// src/pathplan/shortest.ts
+var NO_TRI = -1;
+var DQ_FRONT = 1;
+var DQ_BACK = 2;
+var ShortestHelper = class _ShortestHelper {
+  static buildTri(a, b, c) {
+    const mk = (p0, p1) => ({ pnl0: p0, pnl1: p1, rightIndex: NO_TRI });
+    return { mark: 0, e: [mk(a, b), mk(b, c), mk(c, a)] };
   }
-}
-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);
+  static triInner(pnlps, tris) {
+    let pts = pnlps;
+    while (pts.length > 3) {
+      const n = pts.length;
+      let cut = -1;
+      for (let i = 0; i < n; i++) {
+        const ip2 = (i + 2) % n;
+        if (isdiagonal(i, ip2, (k) => pts[k].pp, n)) {
+          tris.push(_ShortestHelper.buildTri(pts[i], pts[(i + 1) % n], pts[ip2]));
+          cut = (i + 1) % n;
+          break;
+        }
+      }
+      if (cut === -1) return false;
+      pts = pts.filter((_, j) => j !== cut);
+    }
+    tris.push(_ShortestHelper.buildTri(pts[0], pts[1], pts[2]));
+    return true;
   }
-}
-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);
+  static connectTri(i, j, tris) {
+    const t1 = tris[i], t2 = tris[j];
+    for (let ei = 0; ei < 3; ei++) {
+      for (let ej = 0; ej < 3; ej++) {
+        const e1 = t1.e[ei], e2 = t2.e[ej];
+        if (e1.pnl0 === e2.pnl0 && e1.pnl1 === e2.pnl1 || e1.pnl0 === e2.pnl1 && e1.pnl1 === e2.pnl0)
+          e1.rightIndex = j, e2.rightIndex = i;
+      }
+    }
   }
-}
-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;
+  static connectAll(tris) {
+    for (let i = 0; i < tris.length; i++)
+      for (let j = i + 1; j < tris.length; j++)
+        _ShortestHelper.connectTri(i, j, tris);
   }
-  return false;
-}
-function graphHasSametail(g) {
-  for (const e of g.edges) {
-    if (e.info.sametail !== void 0) return true;
+  static pointInTri(tri, p) {
+    let sum = 0;
+    for (let ei = 0; ei < 3; ei++)
+      if (ccw(tri.e[ei].pnl0.pp, tri.e[ei].pnl1.pp, p) !== ISCW) sum++;
+    return sum === 3 || sum === 0;
   }
-  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);
+  static markPath(tris, trii, trij) {
+    if (tris[trii].mark) return false;
+    tris[trii].mark = 1;
+    if (trii === trij) return true;
+    for (let ei = 0; ei < 3; ei++) {
+      const ri = tris[trii].e[ei].rightIndex;
+      if (ri !== NO_TRI && _ShortestHelper.markPath(tris, ri, trij)) return true;
+    }
+    tris[trii].mark = 0;
+    return false;
   }
-  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);
+  static findTri(tris, p) {
+    for (let i = 0; i < tris.length; i++)
+      if (_ShortestHelper.pointInTri(tris[i], p)) return i;
+    return NO_TRI;
   }
-  return same;
-}
-function applyGroupsToNode(n, groups, ranksep) {
-  for (const grp of groups) {
-    if (grp.edges.length > 1) sameport(n, grp.edges, ranksep);
+  static findMinX(ps) {
+    let minx = Infinity, minpi = 0;
+    for (let i = 0; i < ps.length; i++)
+      if (ps[i].x < minx) {
+        minx = ps[i].x;
+        minpi = i;
+      }
+    return minpi;
   }
-}
-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);
+  static isPolyCW(ps, minpi) {
+    const pn = ps.length;
+    const p2 = ps[minpi];
+    const p1 = ps[minpi === 0 ? pn - 1 : minpi - 1];
+    const p3 = ps[(minpi + 1) % pn];
+    if (p1.x === p2.x && p2.x === p3.x && p3.y > p2.y) return true;
+    return ccw(p1, p2, p3) !== ISCCW;
   }
-}
-
-// 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;
-      }
+  static loadForward(ps) {
+    const r = [];
+    for (let i = 0; i < ps.length; i++) {
+      if (i > 0 && ps[i].x === ps[i - 1].x && ps[i].y === ps[i - 1].y) continue;
+      r.push({ pp: ps[i], link: null });
+    }
+    return r;
+  }
+  static loadReverse(ps) {
+    const r = [];
+    for (let i = ps.length - 1; i >= 0; i--) {
+      if (i < ps.length - 1 && ps[i].x === ps[i + 1].x && ps[i].y === ps[i + 1].y) continue;
+      r.push({ pp: ps[i], link: null });
+    }
+    return r;
+  }
+  static loadPoints(poly) {
+    const ps = poly.ps;
+    return _ShortestHelper.isPolyCW(ps, _ShortestHelper.findMinX(ps)) ? _ShortestHelper.loadReverse(ps) : _ShortestHelper.loadForward(ps);
+  }
+  static initDeque(pnll) {
+    const pnlpn = pnll * 2;
+    const pnlps = new Array(pnlpn).fill(null);
+    const fpnlpi = Math.floor(pnlpn / 2);
+    return { pnlps, pnlpn, fpnlpi, lpnlpi: fpnlpi - 1, apex: 0 };
+  }
+  static add2dq(dq, side, pnl) {
+    if (side === DQ_FRONT) {
+      if (dq.lpnlpi >= dq.fpnlpi) pnl.link = dq.pnlps[dq.fpnlpi];
+      dq.fpnlpi--;
+      dq.pnlps[dq.fpnlpi] = pnl;
+    } else {
+      if (dq.lpnlpi >= dq.fpnlpi) pnl.link = dq.pnlps[dq.lpnlpi];
+      dq.lpnlpi++;
+      dq.pnlps[dq.lpnlpi] = pnl;
+    }
+  }
+  static splitdq(dq, side, index) {
+    if (side === DQ_FRONT) dq.lpnlpi = index;
+    else dq.fpnlpi = index;
+  }
+  static finddqsplit(dq, pnl) {
+    for (let idx = dq.fpnlpi; idx < dq.apex; idx++)
+      if (ccw(dq.pnlps[idx + 1].pp, dq.pnlps[idx].pp, pnl.pp) === ISCCW) return idx;
+    for (let idx = dq.lpnlpi; idx > dq.apex; idx--)
+      if (ccw(dq.pnlps[idx - 1].pp, dq.pnlps[idx].pp, pnl.pp) === ISCW) return idx;
+    return dq.apex;
+  }
+  static fuFindEi(trip, tris) {
+    for (let ei = 0; ei < 3; ei++) {
+      const ri = trip.e[ei].rightIndex;
+      if (ri !== NO_TRI && tris[ri].mark === 1) return ei;
+    }
+    return 3;
+  }
+  static fuNextTri(trip, tris) {
+    for (let ei = 0; ei < 3; ei++) {
+      const ri = trip.e[ei].rightIndex;
+      if (ri !== NO_TRI && tris[ri].mark === 1) return ri;
     }
+    return NO_TRI;
   }
-  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);
-    }
+  static fuGetPairLast(epnl1, dq) {
+    if (ccw(epnl1.pp, dq.pnlps[dq.fpnlpi].pp, dq.pnlps[dq.lpnlpi].pp) === ISCCW)
+      return [dq.pnlps[dq.lpnlpi], epnl1];
+    return [epnl1, dq.pnlps[dq.lpnlpi]];
   }
-  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]);
+  static fuGetPairNormal(trip, ei) {
+    const e = trip.e[ei];
+    const pnl = trip.e[(ei + 1) % 3].pnl1;
+    if (ccw(e.pnl0.pp, pnl.pp, e.pnl1.pp) === ISCCW) return [e.pnl1, e.pnl0];
+    return [e.pnl0, e.pnl1];
   }
-  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;
+  static fuUpdateRight(dq, r) {
+    const si = _ShortestHelper.finddqsplit(dq, r);
+    _ShortestHelper.splitdq(dq, DQ_BACK, si);
+    _ShortestHelper.add2dq(dq, DQ_FRONT, r);
+    if (si > dq.apex) dq.apex = si;
+  }
+  static fuUpdateLeft(dq, l) {
+    const si = _ShortestHelper.finddqsplit(dq, l);
+    _ShortestHelper.splitdq(dq, DQ_FRONT, si);
+    _ShortestHelper.add2dq(dq, DQ_BACK, l);
+    if (si < dq.apex) dq.apex = si;
+  }
+  static fuUpdate(dq, l, r, isFirst) {
+    if (isFirst) {
+      _ShortestHelper.add2dq(dq, DQ_BACK, l);
+      _ShortestHelper.add2dq(dq, DQ_FRONT, r);
+      return;
     }
+    if (dq.pnlps[dq.fpnlpi] !== r && dq.pnlps[dq.lpnlpi] !== r)
+      _ShortestHelper.fuUpdateRight(dq, r);
+    else
+      _ShortestHelper.fuUpdateLeft(dq, l);
   }
-  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;
+  static fuLoop(tris, dq, epnls, ftrii) {
+    let trii = ftrii;
+    while (trii !== NO_TRI) {
+      const trip = tris[trii];
+      trip.mark = 2;
+      const ei = _ShortestHelper.fuFindEi(trip, tris);
+      const [l, r] = ei === 3 ? _ShortestHelper.fuGetPairLast(epnls[1], dq) : _ShortestHelper.fuGetPairNormal(trip, ei);
+      _ShortestHelper.fuUpdate(dq, l, r, trii === ftrii);
+      trii = _ShortestHelper.fuNextTri(trip, tris);
+    }
   }
-}
-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 };
+  static extractPath(epnl1) {
+    const pts = [];
+    for (let p = epnl1; p !== null; p = p.link) pts.push(p.pp);
+    pts.reverse();
+    return pts;
   }
-}
-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];
+  static run(poly, eps) {
+    const pnlps = _ShortestHelper.loadPoints(poly);
+    const tris = [];
+    if (!_ShortestHelper.triInner(pnlps.slice(), tris)) {
+      console.warn("triangulation failed");
     }
+    _ShortestHelper.connectAll(tris);
+    const ftrii = _ShortestHelper.findTri(tris, eps[0]);
+    const ltrii = _ShortestHelper.findTri(tris, eps[1]);
+    if (ftrii === NO_TRI || ltrii === NO_TRI) return null;
+    if (ftrii === ltrii) return [eps[0], eps[1]];
+    if (!_ShortestHelper.markPath(tris, ftrii, ltrii)) return [eps[0], eps[1]];
+    const epnls = [{ pp: eps[0], link: null }, { pp: eps[1], link: null }];
+    const dq = _ShortestHelper.initDeque(pnlps.length);
+    _ShortestHelper.add2dq(dq, DQ_FRONT, epnls[0]);
+    dq.apex = dq.fpnlpi;
+    _ShortestHelper.fuLoop(tris, dq, epnls, ftrii);
+    return _ShortestHelper.extractPath(epnls[1]);
   }
-  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 shortestPath(poly, eps) {
+  return ShortestHelper.run(poly, eps);
 }
-function walkToOrig(e) {
-  let cur = e;
-  while (cur.info.to_orig != null && cur.info.edge_type !== 0) {
-    cur = cur.info.to_orig;
-  }
-  return cur;
+
+// src/layout/dot/edge-route-poly.ts
+function fwdDirs(boxes, bi) {
+  const n = boxes.length;
+  const prev = bi > 0 ? boxes[bi].ll.y > boxes[bi - 1].ll.y ? -1 : 1 : 0;
+  const next = bi + 1 < n ? boxes[bi + 1].ll.y > boxes[bi].ll.y ? 1 : -1 : 0;
+  return { prev, next };
 }
-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 emitFwdBox(b, prev, next, pts) {
+  if (prev !== next) {
+    if (next === -1 || prev === 1) {
+      pts.push({ x: b.ll.x, y: b.ur.y }, { x: b.ll.x, y: b.ll.y });
+    } else {
+      pts.push({ x: b.ur.x, y: b.ll.y }, { x: b.ur.x, y: b.ur.y });
+    }
+  } else if (prev === 0) {
+    pts.push({ x: b.ll.x, y: b.ur.y }, { x: b.ll.x, y: b.ll.y });
   }
 }
-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 addForwardPolyPts(boxes, pts) {
+  for (let bi = 0; bi < boxes.length; bi++) {
+    const { prev, next } = fwdDirs(boxes, bi);
+    emitFwdBox(boxes[bi], prev, next, pts);
   }
 }
-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 revDirs(boxes, bi) {
+  const n = boxes.length;
+  const prev = bi + 1 < n ? boxes[bi].ll.y > boxes[bi + 1].ll.y ? -1 : 1 : 0;
+  const next = bi > 0 ? boxes[bi - 1].ll.y > boxes[bi].ll.y ? 1 : -1 : 0;
+  return { prev, next };
 }
-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 emitAllCorners(b, pts) {
+  pts.push(
+    { x: b.ur.x, y: b.ll.y },
+    { x: b.ur.x, y: b.ur.y },
+    { x: b.ll.x, y: b.ur.y },
+    { x: b.ll.x, y: b.ll.y }
+  );
 }
-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;
+function emitRevBox(b, prev, next, pts) {
+  if (prev !== next) {
+    if (next === -1 || prev === 1) {
+      pts.push({ x: b.ll.x, y: b.ur.y }, { x: b.ll.x, y: b.ll.y });
+    } else {
+      pts.push({ x: b.ur.x, y: b.ll.y }, { x: b.ur.x, y: b.ur.y });
+    }
+  } else if (prev === 0) {
+    pts.push({ x: b.ur.x, y: b.ll.y }, { x: b.ur.x, y: b.ur.y });
   } else {
-    P.start.constrained = false;
+    emitAllCorners(b, pts);
   }
 }
-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;
+function addReversePolyPts(boxes, pts) {
+  for (let bi = boxes.length - 1; bi >= 0; bi--) {
+    const { prev, next } = revDirs(boxes, bi);
+    emitRevBox(boxes[bi], prev, next, pts);
   }
 }
+function boxesToPolygon(boxes) {
+  if (boxes.length === 0) return [];
+  const pts = [];
+  addForwardPolyPts(boxes, pts);
+  addReversePolyPts(boxes, pts);
+  return pts;
+}
+function polyEdgesFromPts(polygon) {
+  const n = polygon.length;
+  return polygon.map((a, i) => ({ a, b: polygon[(i + 1) % n] }));
+}
+function linearBezier(p0, p3) {
+  return [
+    p0,
+    { x: p0.x + (p3.x - p0.x) / 3, y: p0.y + (p3.y - p0.y) / 3 },
+    { x: p0.x + 2 * (p3.x - p0.x) / 3, y: p0.y + 2 * (p3.y - p0.y) / 3 },
+    p3
+  ];
+}
+function tryRouteSpline(barriers, wpts) {
+  const zero = { x: 0, y: 0 };
+  const raw = routeSpline(barriers, wpts, [zero, zero]);
+  if (raw.length < 4) return null;
+  return [raw[0], raw[1], raw[2], raw[3]];
+}
+function computeSpline(boxes, startPt, endPt) {
+  const polygon = boxesToPolygon(boxes);
+  if (polygon.length < 3) return linearBezier(startPt, endPt);
+  const wpts = shortestPath({ ps: polygon }, [startPt, endPt]);
+  if (wpts === null || wpts.length < 2) return linearBezier(startPt, endPt);
+  return tryRouteSpline(polyEdgesFromPts(polygon), wpts) ?? linearBezier(startPt, endPt);
+}
 
 // src/layout/dot/edge-route-rank.ts
 var MINW = 16;
@@ -26898,7 +26724,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) {
@@ -29735,7 +29561,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);
@@ -29919,6 +29745,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;
@@ -30022,8 +30037,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;
@@ -30064,7 +30085,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;
@@ -30118,8 +30139,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;
@@ -32661,8 +32682,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) {
@@ -36974,7 +36998,6 @@ var Cdt = class {
       v1 = r.v1;
       v2 = r.v2;
       v3 = r.v3;
-      prev = r.e1;
       e2 = r.e2;
       e3 = r.e3;
     }
@@ -40315,9 +40338,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];
@@ -45396,7 +45419,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 {