@knowvah/dot-engine 2.3.0 → 2.4.0

package/dist/render.js

@@ -5086,8 +5086,8 @@ function normalizeFontName(name) {
   for (let i = 0; i < name.length; i++) {
     const ch = name[i];
     const code = ch.charCodeAt(0);
-    const isLetter = code >= 65 && code <= 90 || code >= 97 && code <= 122;
-    if (isLetter) result += ch.toLowerCase();
+    const isLetter2 = code >= 65 && code <= 90 || code >= 97 && code <= 122;
+    if (isLetter2) result += ch.toLowerCase();
   }
   return result;
 }
@@ -7338,7 +7338,7 @@ function interpretCRNL(str) {
 
 // src/common/make-label.ts
 var DEFAULT_FONTSIZE2 = 14;
-var DEFAULT_FONTNAME = "Times,serif";
+var DEFAULT_FONTNAME = "Times-Roman";
 var DEFAULT_COLOR = "black";
 function getPenColor(obj) {
   if (obj === void 0) return void 0;
@@ -8765,6 +8765,10 @@ var RenderJob = class {
   format;
   bb = { ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } };
   pad = { x: 0, y: 0 };
+  /** Current page clip in graph units, as setup_page computes it from the
+   * viewport focus/view (see setupPageClip). Read by the SVG page translate and
+   * background. @see lib/gvc/gvcjob.h:GVJ_s.clip; lib/common/emit.c:setup_page */
+  clip = { ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } };
   /** Graph-level `margin=` (init_job_margin); page-pagination margin, distinct
    * from node/cluster label margin. @see lib/common/emit.c:3309-3331 */
   margin = { x: 0, y: 0 };
@@ -10317,11 +10321,11 @@ function emitHtmlLabel(placed, pos, renderer, job) {
         style: placed.style
       });
     }
-    for (const cell2 of placed.cells) emitHtmlCell(cell2, pos, renderer, job);
     emitTableRules(placed, pos, renderer, job);
     if (placed.border > 0) {
       emitBorder({ box: placed.box, pos, border: placed.border, color: placed.color, sides: placed.sides, style: placed.style }, renderer, job);
     }
+    for (const cell2 of placed.cells) emitHtmlCell(cell2, pos, renderer, job);
   }
   if (inAnchor) endHtmlAnchor(renderer, job);
   if (clustersLast && initHtmlAnchor(anchorData, tblBox, renderer, job)) {
@@ -10509,6 +10513,18 @@ function fms(a, b, c) {
 function cround(v) {
   return v >= 0 ? Math.floor(v + 0.5) : Math.ceil(v - 0.5);
 }
+var INT64_MAX = 2n ** 63n - 1n;
+var INT64_MIN = -(2n ** 63n);
+var TWO_POW_63 = 2 ** 63;
+function croundNarrow32(v) {
+  const r = cround(v);
+  let i64;
+  if (Number.isNaN(r)) i64 = 0n;
+  else if (r >= TWO_POW_63) i64 = INT64_MAX;
+  else if (r < -TWO_POW_63) i64 = INT64_MIN;
+  else i64 = BigInt(r);
+  return Number(BigInt.asIntN(32, i64));
+}
 function RADIANS(deg) {
   return deg / 180 * Math.PI;
 }
@@ -11346,6 +11362,8 @@ function parseSegs(colorlist) {
 }
 
 // src/util/math.ts
+var INT32_MAX = 2147483647;
+var INT32_MIN = -2147483648;
 function isExactlyEqual(a, b) {
   const buf = new ArrayBuffer(16);
   const dv = new DataView(buf);
@@ -11357,6 +11375,11 @@ function isExactlyEqual(a, b) {
   }
   return true;
 }
+function d2i(v) {
+  if (v > INT32_MAX) return INT32_MAX;
+  if (v < INT32_MIN) return INT32_MIN;
+  return Math.trunc(v);
+}
 
 // src/common/colorData.ts
 var COLOR_LIB = [
@@ -14568,9 +14591,12 @@ function isMulticolor(fillcolor) {
   return fillcolor.includes(":");
 }
 function renderEllipse(ring, coord, renderer, job, filled) {
-  const rx = Math.abs((ring[1].x - ring[0].x) / 2);
-  const ry = Math.abs((ring[1].y - ring[0].y) / 2);
-  const center = transformPoint(coord, job);
+  const af0 = { x: ring[0].x + coord.x, y: ring[0].y + coord.y };
+  const af1 = { x: ring[1].x + coord.x, y: ring[1].y + coord.y };
+  const mid = { x: (af0.x + af1.x) / 2, y: (af0.y + af1.y) / 2 };
+  const rx = af1.x - mid.x;
+  const ry = af1.y - mid.y;
+  const center = transformPoint(mid, job);
   renderer.ellipse(center, rx, ry, filled, job);
 }
 function renderPolygon(ring, coord, renderer, job, filled) {
@@ -18173,7 +18199,7 @@ var BGCOLOR_TRANSPARENT = "\0transparent";
 function formatG(n) {
   return String(parseFloat(n.toPrecision(6)));
 }
-function emitSvgTag(job) {
+function emitSvgTag(job, svgid = "") {
   const bb = job.bb;
   const szx = bb.ur.x - bb.ll.x + 2 * job.pad.x;
   const szy = bb.ur.y - bb.ll.y + 2 * job.pad.y;
@@ -18182,16 +18208,20 @@ function emitSvgTag(job) {
   const rotated = job.rotation !== 0;
   const pageX = rotated ? viewY : viewX;
   const pageY = rotated ? viewX : viewY;
-  const w = cround(pageX + 2 * job.margin.x);
-  const h = cround(pageY + 2 * job.margin.y);
+  const w = croundNarrow32(pageX + 2 * job.margin.x);
+  const h = croundNarrow32(pageY + 2 * job.margin.y);
   job.write('<svg width="' + String(w) + 'pt" height="' + String(h) + 'pt"\n');
-  const vbLLx = cround(job.margin.x);
-  const vbLLy = cround(job.margin.y);
-  const vbURx = cround(job.margin.x + pageX);
-  const vbURy = cround(job.margin.y + pageY);
+  const vbLLx = croundNarrow32(job.margin.x);
+  const vbLLy = croundNarrow32(job.margin.y);
+  const vbURx = croundNarrow32(job.margin.x + pageX);
+  const vbURy = croundNarrow32(job.margin.y + pageY);
   job.write('     viewBox="' + String(vbLLx) + ".00 " + String(vbLLy) + ".00 " + String(vbURx) + ".00 " + String(vbURy) + '.00"\n');
   job.write('     xmlns="http://www.w3.org/2000/svg"');
-  job.write(' xmlns:xlink="http://www.w3.org/1999/xlink">\n');
+  job.write(' xmlns:xlink="http://www.w3.org/1999/xlink"');
+  if (svgid !== void 0 && svgid.length > 0) {
+    job.write(' id="' + escapeXmlTitle(svgid) + '"');
+  }
+  job.write(">\n");
 }
 function emitGraphGroupOpen(graphId, classStr, tx, ty, job) {
   const sx = formatG(job.scale.x);
@@ -18215,12 +18245,12 @@ function resolveGraphBgcolor(bgcolorAttr) {
   const solid = grad !== null ? grad[0] : bgcolorAttr;
   return colorPaint(resolveRenderColor(solid));
 }
-function emitGraphBackground(bb, resolvedColor, job) {
+function emitGraphBackground(clip, resolvedColor, job) {
   if (resolvedColor === BGCOLOR_TRANSPARENT) return;
-  const left2 = bb.ll.x - job.pad.x;
-  const right2 = bb.ur.x + job.pad.x;
-  const top = -(bb.ur.y + job.pad.y);
-  const bottom = -(bb.ll.y - job.pad.y);
+  const left2 = clip.ll.x;
+  const right2 = clip.ur.x;
+  const top = -clip.ur.y;
+  const bottom = -clip.ll.y;
   const corners = [
     [left2, bottom],
     [left2, top],
@@ -18237,11 +18267,11 @@ function emitGraphBackground(bb, resolvedColor, job) {
   });
   job.write('"/>\n');
 }
-function bgGradientPts(bb, pad) {
-  const left2 = bb.ll.x - pad.x;
-  const right2 = bb.ur.x + pad.x;
-  const bottom = bb.ll.y - pad.y;
-  const top = bb.ur.y + pad.y;
+function bgGradientPts(clip) {
+  const left2 = clip.ll.x;
+  const right2 = clip.ur.x;
+  const bottom = clip.ll.y;
+  const top = clip.ur.y;
   return [
     { x: left2, y: bottom },
     { x: left2, y: top },
@@ -18249,11 +18279,11 @@ function bgGradientPts(bb, pad) {
     { x: right2, y: bottom }
   ];
 }
-function writeGradientPolygon(bb, id, job) {
-  const left2 = bb.ll.x - job.pad.x;
-  const right2 = bb.ur.x + job.pad.x;
-  const top = -(bb.ur.y + job.pad.y);
-  const bottom = -(bb.ll.y - job.pad.y);
+function writeGradientPolygon(clip, id, job) {
+  const left2 = clip.ll.x;
+  const right2 = clip.ur.x;
+  const top = -clip.ur.y;
+  const bottom = -clip.ll.y;
   const corners = [
     [left2, bottom],
     [left2, top],
@@ -18270,7 +18300,7 @@ function writeGradientPolygon(bb, id, job) {
   });
   job.write('"/>\n');
 }
-function emitGradientBackground(bb, spec, job) {
+function emitGradientBackground(clip, spec, job) {
   const obj = createObjState(0 /* RootGraph */);
   obj.id = "graph0";
   obj.fillColor = resolveRenderColor(spec.fillColor);
@@ -18285,10 +18315,10 @@ function emitGradientBackground(bb, spec, job) {
     emitRadialGradient(job, gid);
   } else {
     gid = gradientId("graph0", "l", job.linearGradId++);
-    emitLinearGradient(job, bgGradientPts(bb, job.pad), gid);
+    emitLinearGradient(job, bgGradientPts(clip), gid);
   }
   job.popObj();
-  writeGradientPolygon(bb, gid, job);
+  writeGradientPolygon(clip, gid, job);
 }
 function resolveBgGradientSpec(g, bgcolorAttr) {
   const stop = findStopColor(bgcolorAttr);
@@ -18298,17 +18328,17 @@ function resolveBgGradientSpec(g, bgcolorAttr) {
   const angle = angleStr ? parseInt(angleStr, 10) || 0 : 0;
   return { fillColor: stop.fillColor, stopColor: stop.stopColor, frac: stop.frac, angle, radial: flags.radial };
 }
-function emitBgcolorBackground(g, bb, bgcolorAttr, job) {
+function emitBgcolorBackground(g, clip, bgcolorAttr, job) {
   if (!bgcolorAttr || bgcolorAttr.length === 0 || bgcolorAttr === "transparent") {
-    emitGraphBackground(bb, resolveGraphBgcolor(bgcolorAttr), job);
+    emitGraphBackground(clip, resolveGraphBgcolor(bgcolorAttr), job);
     return;
   }
   const spec = resolveBgGradientSpec(g, bgcolorAttr);
   if (spec !== null) {
-    emitGradientBackground(bb, spec, job);
+    emitGradientBackground(clip, spec, job);
     return;
   }
-  emitGraphBackground(bb, resolveGraphBgcolor(bgcolorAttr), job);
+  emitGraphBackground(clip, resolveGraphBgcolor(bgcolorAttr), job);
 }
 function svgBeginGraph(g, job) {
   job.devscale = { x: 1, y: -1 };
@@ -18322,13 +18352,23 @@ function svgBeginGraph(g, job) {
   }
   job.write(SVG_DOCTYPE);
   job.write(SVG_GENERATOR_COMMENT);
-  emitSvgTag(job);
+  const comment = g.attrs.get("comment");
+  if (comment !== void 0 && comment.length > 0) svgComment(comment, job);
+  emitTitlePagesComment(g, job);
+  emitSvgTag(job, g.attrs.get("svgid"));
+}
+function emitTitlePagesComment(g, job) {
+  job.write("<!--");
+  if (g.name.length > 0 && g.name[0] !== "%") {
+    job.write(" Title: " + escapeXmlTitle(g.name));
+  }
+  job.write(" Pages: 1 -->\n");
 }
 function svgBeginPage(g, job) {
-  const bb = job.bb;
+  const clip = job.clip;
   const z = job.scale.x;
-  const tx = job.rotation !== 0 ? -(bb.ur.x + job.pad.x) - job.margin.x / z : job.pad.x + job.margin.x / z;
-  const ty = bb.ur.y + job.pad.y + job.margin.y / z;
+  const tx = job.rotation !== 0 ? -clip.ur.x - job.margin.x / z : -clip.ll.x + job.margin.x / z;
+  const ty = clip.ur.y + job.margin.y / z;
   emitGraphGroupOpen(
     job.idLayerPrefix() + svgGraphId(g, job),
     svgGraphClass(g),
@@ -18339,7 +18379,7 @@ function svgBeginPage(g, job) {
   emitGraphTitle(g, job);
 }
 function svgPageBackground(g, job) {
-  emitBgcolorBackground(g, job.bb, g.attrs.get("bgcolor"), job);
+  emitBgcolorBackground(g, job.clip, g.attrs.get("bgcolor"), job);
 }
 function svgEndPage(job) {
   job.write("</g>\n");
@@ -18675,7 +18715,7 @@ function svgPolyline(pts, job) {
   job.write('"/>\n');
 }
 function svgComment(text, job) {
-  job.write("<!-- " + escapeXml(text) + " -->\n");
+  job.write("<!-- " + escapeXmlTitle(text) + " -->\n");
 }
 function svgEdgePath(e, job) {
   const spl = e.info.spl;
@@ -18862,6 +18902,22 @@ function initJobViewportZoom(bb, size, pad) {
   if (drawingNeedsFit(size, szx, szy)) return Math.min(size.x / szx, size.y / szy);
   return 1;
 }
+function setupPageClip(bb, size, pad, z) {
+  const jbLL = { x: bb.ll.x - pad.x, y: bb.ll.y - pad.y };
+  const jbUR = { x: bb.ur.x + pad.x, y: bb.ur.y + pad.y };
+  const sz = { x: jbUR.x - jbLL.x, y: jbUR.y - jbLL.y };
+  if (size !== null && size.x > 1e-3 && size.y > 1e-3) {
+    if (sz.x <= 1e-3) sz.x = size.x;
+    if (sz.y <= 1e-3) sz.y = size.y;
+  }
+  const focus = { x: 0.5 * (bb.ll.x + bb.ur.x), y: 0.5 * (bb.ll.y + bb.ur.y) };
+  const pageSize = { x: z * sz.x / z, y: z * sz.y / z };
+  const ll = {
+    x: focus.x + pageSize.x * (0 - 1 / 2),
+    y: focus.y + pageSize.y * (0 - 1 / 2)
+  };
+  return { ll, ur: { x: ll.x + pageSize.x, y: ll.y + pageSize.y } };
+}
 
 // src/gvc/anchor.ts
 function attr(attrs, key) {
@@ -19373,10 +19429,22 @@ function renderClusterLabel(sg, renderer, job) {
   renderOneLabel(sg.info.label, renderer, job, false);
 }
 
-// src/gvc/device.ts
-function labelTextOf2(lp) {
-  return lp?.text ?? null;
+// src/common/edge-in-box.ts
+function overlapLabel(lp, b) {
+  const sx = lp.dimen.x / 2;
+  const sy = lp.dimen.y / 2;
+  const bb = {
+    ll: { x: lp.pos.x - sx, y: lp.pos.y - sy },
+    ur: { x: lp.pos.x + sx, y: lp.pos.y + sy }
+  };
+  return boxOverlap(b, bb);
+}
+function edgeHasDrawableContent(e, clip) {
+  const i = e.info;
+  return i.spl !== void 0 || i.label !== void 0 && i.label.set && overlapLabel(i.label, clip) || i.xlabel !== void 0 || i.head_label !== void 0 || i.tail_label !== void 0;
 }
+
+// src/gvc/emit-gates.ts
 function nodeBBox(n) {
   const { coord, lw, rw, ht } = n.info;
   return {
@@ -19391,6 +19459,26 @@ function nodeInBox(n, job) {
   };
   return boxOverlap(nodeBBox(n), clip);
 }
+function gvrenderComment(renderer, job, str) {
+  if (str === void 0 || str.length === 0) return;
+  renderer.comment?.(str, job);
+}
+function emitNodeComments(n, renderer, job) {
+  gvrenderComment(renderer, job, n.name);
+  gvrenderComment(renderer, job, nodeAttr(n, n.root, "comment"));
+}
+function emitEdgeComments(e, renderer, job) {
+  if (!edgeHasDrawableContent(e, job.bb)) return;
+  const kind = e.head.root.kind;
+  const op = kind === "directed" || kind === "strict-directed" ? "->" : "--";
+  gvrenderComment(renderer, job, e.tail.name + op + e.head.name);
+  gvrenderComment(renderer, job, e.attrs.get("comment"));
+}
+
+// src/gvc/device.ts
+function labelTextOf2(lp) {
+  return lp?.text ?? null;
+}
 function emitNodeBody(n, renderer, job) {
   setHtmlAnchorObj(svgNodeId(n, job), labelTextOf2(n.info.label), job.obj ?? void 0);
   setHtmlObjImgscale(nodeAttr(n, n.root, "imagescale"));
@@ -19406,6 +19494,7 @@ function renderNode(n, renderer, job, done) {
   if (done.has(n)) return;
   done.add(n);
   if (!nodeInBox(n, job)) return;
+  emitNodeComments(n, renderer, job);
   const nodeStyle = nodeAttr(n, n.root, "style");
   if (parseStyleFlags(nodeStyle).invis) return;
   if (!isPointNode(n) && styleHasInvisibleAlias(nodeStyle)) return;
@@ -19431,6 +19520,7 @@ function setEdgePen(e, job) {
   obj.rawStyle = styleTokens(e.attrs.get("style"));
 }
 function renderEdge(e, renderer, job) {
+  emitEdgeComments(e, renderer, job);
   const edgeStyle = e.attrs.get("style");
   if (parseStyleFlags(edgeStyle).invis || styleHasInvisibleAlias(edgeStyle)) return;
   const obj = createObjState(3 /* Edge */);
@@ -19544,7 +19634,9 @@ function render(ctx, g, format, inlineImages = false) {
   job.bb = g.info.bb;
   job.pad = parseGraphPad(g.attrs.get("pad"));
   job.margin = parseGraphMargin(g.attrs.get("margin"));
-  const z = initJobViewportZoom(job.bb, parseDrawingSize(g.attrs.get("size")), job.pad);
+  const drawingSize = parseDrawingSize(g.attrs.get("size"));
+  const z = initJobViewportZoom(job.bb, drawingSize, job.pad);
+  job.clip = setupPageClip(job.bb, drawingSize, job.pad, z);
   const drawingDpi = lateDouble(
     g.attrs.get("dpi"),
     lateDouble(g.attrs.get("resolution"), 0, 0),
@@ -25162,56 +25254,63 @@ function setEndTheta(P, e, merge) {
 
 // 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);
+function aeq02(x) {
+  return x < EPS2 && x > -EPS2;
+}
+function solve3(coeff, roots) {
+  const a = coeff[3], b = coeff[2], c = coeff[1], d = coeff[0];
+  if (aeq02(a)) return solve2(coeff, roots);
+  const bOver3a = b / (3 * a), cOverA = c / a, dOverA = d / a;
+  let p = bOver3a * bOver3a;
+  const q = dOverA + fma(2 * bOver3a, p, -(bOver3a * cOverA));
+  p = cOverA / 3 - p;
+  const disc = fma(q, q, 4 * p * p * p);
+  let rootn;
+  if (disc < 0) {
+    const r = 0.5 * Math.sqrt(fma(q, q, -disc));
     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 temp = 2 * Math.cbrt(r);
+    roots[0] = temp * Math.cos(theta / 3);
+    roots[1] = temp * Math.cos((theta + Math.PI + Math.PI) / 3);
+    roots[2] = temp * Math.cos((theta - Math.PI - Math.PI) / 3);
+    rootn = 3;
+  } else {
+    const alpha = 0.5 * (Math.sqrt(disc) - q);
+    const beta = -q - alpha;
+    roots[0] = Math.cbrt(alpha) + Math.cbrt(beta);
+    if (disc > 0) rootn = 1;
+    else {
+      roots[1] = roots[2] = -0.5 * roots[0];
+      rootn = 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;
+  for (let i = 0; i < rootn; i++) roots[i] -= bOver3a;
+  return rootn;
+}
+function solve2(coeff, roots) {
+  const a = coeff[2], b = coeff[1], c = coeff[0];
+  if (aeq02(a)) return solve1(coeff, roots);
+  const bOver2a = b / (2 * a);
+  const cOverA = c / a;
+  const disc = fma(bOver2a, bOver2a, -cOverA);
+  if (disc < 0) {
+    return 0;
+  } else if (disc > 0) {
+    roots[0] = -bOver2a + Math.sqrt(disc);
+    roots[1] = fma(-2, bOver2a, -roots[0]);
+    return 2;
   }
-  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);
+  roots[0] = -bOver2a;
+  return 1;
+}
+function solve1(coeff, roots) {
+  const a = coeff[1], b = coeff[0];
+  if (aeq02(a)) {
+    if (aeq02(b)) return 4;
+    return 0;
   }
-};
-function solve3(coeff, roots) {
-  return Solver.solve3(coeff, roots);
+  roots[0] = -b / a;
+  return 1;
 }
 
 // src/pathplan/route.ts
@@ -25233,16 +25332,19 @@ var RouteHelper = class _RouteHelper {
   static B3(t) {
     return t * t * t;
   }
+  /** @see lib/pathplan/route.c:B01 */
   static B01(t) {
     const u = 1 - t;
-    return u * u * (u + 3 * t);
+    return u * u * fma(3, t, u);
   }
+  /** @see lib/pathplan/route.c:B23 */
   static B23(t) {
     const u = 1 - t;
-    return t * t * (3 * u + t);
+    return t * t * fma(3, u, t);
   }
+  /** @see lib/pathplan/route.c:normv */
   static normv(v) {
-    const d = v.x * v.x + v.y * v.y;
+    const d = fma(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 };
@@ -25258,20 +25360,28 @@ var RouteHelper = class _RouteHelper {
   static ptScale(p, c) {
     return { x: p.x * c, y: p.y * c };
   }
+  /** @see lib/pathplan/route.c:dot */
   static ptDot(a, b) {
-    return a.x * b.x + a.y * b.y;
+    return fma(a.x, b.x, a.y * b.y);
   }
+  /** @see lib/pathplan/route.c:dist (libm hypot, no contraction) */
   static ptDist(a, b) {
-    return Math.hypot(a.x - b.x, a.y - b.y);
+    return libmHypot(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;
   }
+  /**
+   * The cubic's coefficients come out of catastrophic cancellation when the
+   * spline is tangent to a barrier (tests/2646.dot), so clang's contraction
+   * here decides solve3's root count; mirror it exactly.
+   * @see lib/pathplan/route.c:points2coeff
+   */
   static points2coeff(v0, v1, v2, v3, c) {
-    c[3] = v3 + 3 * v1 - (v0 + 3 * v2);
-    c[2] = 3 * v0 + 3 * v2 - 6 * v1;
+    c[3] = fma(3, v1, v3) - fma(3, v2, v0);
+    c[2] = fma(-6, v1, fma(3, v0, 3 * v2));
     c[1] = 3 * (v1 - v0);
     c[0] = v0;
   }
@@ -25311,7 +25421,7 @@ var RouteHelper = class _RouteHelper {
       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;
+        const sv = (fma(tv, fma(tv, fma(tv, sc[3], sc[2]), sc[1]), sc[0]) - lc.yc0) / lc.yc1;
         if (sv >= 0 && sv <= 1) _RouteHelper.addRoot(tv, acc);
       }
     }
@@ -25321,25 +25431,26 @@ var RouteHelper = class _RouteHelper {
     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,
+      fms(rat, sps[0].x, sps[0].y),
+      fms(rat, sps[1].x, sps[1].y),
+      fms(rat, sps[2].x, sps[2].y),
+      fms(rat, sps[3].x, sps[3].y),
       sc
     );
-    sc[0] += rat * lc.xc0 - lc.yc0;
+    sc[0] += fma(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;
+        const sv = (fma(tv, fma(tv, fma(tv, sc[3], sc[2]), sc[1]), sc[0]) - lc.xc0) / lc.xc1;
         if (sv >= 0 && sv <= 1) _RouteHelper.addRoot(tv, acc);
       }
     }
     return acc.n;
   }
+  /** @see lib/pathplan/route.c:splineintersectsline */
   static splineIntersectsLine(sps, lps, roots) {
     const lc = {
       xc0: lps[0].x,
@@ -25390,8 +25501,9 @@ var RouteHelper = class _RouteHelper {
       x0 += _RouteHelper.ptDot(tnas[i].a[0], tmp);
       x1 += _RouteHelper.ptDot(tnas[i].a[1], tmp);
     }
-    const det01 = c00 * c11 - c01 * c01;
-    const detX1 = x0 * c11 - x1 * c01, det0X = c00 * x1 - c01 * x0;
+    const det01 = fma(c00, c11, -(c01 * c01));
+    const det0X = fma(c00, x1, -(c01 * x0));
+    const detX1 = fma(x0, c11, -(x1 * c01));
     if (Math.abs(det01) >= 1e-6) {
       scale0 = detX1 / det01;
       scale3 = det0X / det01;
@@ -25415,6 +25527,27 @@ var RouteHelper = class _RouteHelper {
     }
     return tnas;
   }
+  /**
+   * The max-deviation split of `reallyroutespline` (route.c:130-143): the
+   * interior polyline point farthest from the fitted bezier.
+   *
+   * Faithful contract. On a geometrically symmetric channel two interior
+   * deviations tie to within an ulp, so the split point (and the whole
+   * spline) is decided by C's exact arithmetic, which this mirrors bit for
+   * bit against the native arm64 oracle:
+   * - `dist` is libm `hypot` (route.c:448) -> `libmHypot` via `ptDist`;
+   * - the test is C's strict `(d = dist(p, inps[i])) > maxd` (route.c:139),
+   *   so an exact tie keeps the first index;
+   * - clang's default `-ffp-contract=on` fuses the bezier eval at
+   *   route.c:137-138 as `fma(B3,p2, fma(B2,cp2, fma(B0,p1, B1*cp1)))`; the
+   *   B0..B3 weights and cp1/cp2 (route.c:130-131) are not fused. Fusing the
+   *   other product first is NOT equivalent (flips pt-issue-23-w9 and 32).
+   * C is therefore not translation-equivariant on such ties (the winner
+   * depends on absolute-coordinate rounding), and neither is this port.
+   * This supersedes the former tolerant tie-break (accepted divergence A3).
+   * Contraction map: .agent-notes/pathplan-fma-contraction-map.md.
+   * @see lib/pathplan/route.c:reallyroutespline
+   */
   static findMaxDev(inps, tnas, ends) {
     const { p0, v0, p1, v1 } = ends;
     const cp1 = _RouteHelper.ptAdd(p0, _RouteHelper.ptScale(v0, 1 / 3));
@@ -25422,10 +25555,12 @@ var RouteHelper = class _RouteHelper {
     let maxi = -1, maxd = -1;
     for (let i = 1; i < inps.length - 1; i++) {
       const t = tnas[i].t;
-      const px = _RouteHelper.B0(t) * p0.x + _RouteHelper.B1(t) * cp1.x + _RouteHelper.B2(t) * cp2.x + _RouteHelper.B3(t) * p1.x;
-      const py = _RouteHelper.B0(t) * p0.y + _RouteHelper.B1(t) * cp1.y + _RouteHelper.B2(t) * cp2.y + _RouteHelper.B3(t) * p1.y;
+      const b0 = _RouteHelper.B0(t), b1 = _RouteHelper.B1(t);
+      const b2 = _RouteHelper.B2(t), b3 = _RouteHelper.B3(t);
+      const px = fma(b3, p1.x, fma(b2, cp2.x, fma(b0, p0.x, b1 * cp1.x)));
+      const py = fma(b3, p1.y, fma(b2, cp2.y, fma(b0, p0.y, b1 * cp1.y)));
       const d = _RouteHelper.ptDist({ x: px, y: py }, inps[i]);
-      if (d > maxd * (1 + 1e-10) + 1e-10) {
+      if (d > maxd) {
         maxd = d;
         maxi = i;
       }
@@ -27156,7 +27291,7 @@ function routeMultiRankEdgeFaithful(g, e) {
   }
   const segs = chainSegments(e);
   if (segs.length === 0 || segs[segs.length - 1].head !== e.head) return null;
-  return routeChainSegmented(g, segs[0], segs[segs.length - 1], segs);
+  return routeChainSegmented(g, segs[0], segs[segs.length - 1], segs) ?? "lost";
 }
 function entryRunSegments(e) {
   const segs = [e];
@@ -27228,7 +27363,10 @@ function routeBackEdge(e, _tailBox, _headBox, g) {
   if (segs.length < 2 || segs[segs.length - 1].head !== e.tail) return;
   const fwdEdge = makeFwdEdge(e);
   const fwd = routeChainSegmented(g, segs[0], segs[segs.length - 1], segs);
-  if (fwd === null) return;
+  if (fwd === null) {
+    e.info.lost = true;
+    return;
+  }
   clipAndInstall(fwdEdge, fwdEdge.head, fwd, fwd.length, buildDotSinfo());
   if (swapEndsP(e)) swapEdgeSpline(e);
 }
@@ -27380,7 +27518,7 @@ function baseSplineForGroup(g, e0) {
   const orig = resolveOrigEdge(e0);
   const fe = isBackEdgeMember(orig) ? makeFwdEdge(orig) : orig;
   const pts = routeRegularEdgeFaithful(g, fe);
-  if (pts === "lost") return null;
+  if (pts === "lost") return "lost";
   return pts ?? routeMultiRankEdgeFaithful(g, fe);
 }
 function isBackEdgeMember(e) {
@@ -27409,6 +27547,10 @@ function routeParallelEdgeGroup(g, edges, multisep) {
     return o.info.head_port?.defined || o.info.tail_port?.defined;
   }) ?? edges[0];
   const base = baseSplineForGroup(g, baseEdge);
+  if (base === "lost") {
+    for (const e of edges) resolveOrigEdge(e).info.lost = true;
+    return;
+  }
   if (base === null) return;
   if (cnt === 1) {
     installShiftedEdge(edges[0], base);
@@ -29576,8 +29718,9 @@ function normalizeCopiedFlatSpline(orig, auxe) {
   if (orig.info.spl === void 0) return;
   if (swapEndsP(auxe) !== swapEndsP(orig)) swapEdgeSpline(orig);
 }
-function makeFlatAdjEdges(g, edges, cnt, _et) {
+function makeFlatAdjEdges(g, edges, cnt, et) {
   const aux = buildFlatAux(g, edges, cnt);
+  aux.auxg.info.flags = aux.auxg.info.flags & ~15 | et & 15;
   dotInitNodeEdge(aux.auxg);
   dotRank(aux.auxg);
   if (dotMincross(aux.auxg) !== 0) return 1;
@@ -29688,88 +29831,6 @@ function assembleFlatPath(P, tend, hend, mid) {
   for (let i = hend.boxn - 1; i >= 0; i--) addBox(P, hend.boxes[i]);
 }
 
-// src/layout/dot/splines-flat-multi.ts
-function portEq2(a, b) {
-  if (!a.defined && !b.defined) return true;
-  if (!a.defined || !b.defined) return false;
-  return a.p.x === b.p.x && a.p.y === b.p.y;
-}
-function flatPortKey(e, lo) {
-  return e.tail === lo ? { loP: e.info.tail_port, hiP: e.info.head_port } : { loP: e.info.head_port, hiP: e.info.tail_port };
-}
-function isNonAdjGroupable(x, g) {
-  return x.info.spl === void 0 && x.tail.info.rank !== void 0 && x.tail.info.rank === x.head.info.rank && !isFlatAdjacent(g, x);
-}
-function samePortsAs(x, lo, key) {
-  const k = flatPortKey(x, lo);
-  return portEq2(k.loP, key.loP) && portEq2(k.hiP, key.hiP);
-}
-function collectNonAdjacentFlatGroup(e, g) {
-  const u = e.tail, v = e.head;
-  const lo = (u.info.order ?? 0) <= (v.info.order ?? 0) ? u : v;
-  const key = flatPortKey(e, lo);
-  const sharesPair = (x) => x.tail === u && x.head === v || x.tail === v && x.head === u;
-  const group = g.edges.filter(
-    (x) => sharesPair(x) && isNonAdjGroupable(x, g) && samePortsAs(x, lo, key) && x.info.label === e.info.label
-  );
-  group.sort((a, b) => Number(b.tail === lo) - Number(a.tail === lo) || a.seq - b.seq);
-  return group;
-}
-function copyPathEnd(end) {
-  return {
-    ...end,
-    boxes: end.boxes.map((b) => ({ ll: { ...b.ll }, ur: { ...b.ur } }))
-  };
-}
-function routeGroupEdge(e, i, c) {
-  c.P.nbox = 0;
-  const endStepX = (i + 1) * c.stepx;
-  const endStepY = (i + 1) * c.stepy;
-  const mid = c.bottom ? bottomBoxes(c.tlast, c.hlast, endStepX, endStepY, c.stepy) : topBoxes(c.tlast, c.hlast, endStepX, endStepY, c.stepy);
-  assembleFlatPath(c.P, copyPathEnd(c.tend), copyPathEnd(c.hend), mid);
-  const pts = routeSplines(c.P);
-  if (pts === null || pts.length === 0) return false;
-  if (e.tail !== c.leftNode) pts.reverse();
-  clipAndInstall(e, e.head, pts, pts.length, { ...buildDotSinfo(), ignoreSwap: true });
-  return true;
-}
-function routeFlatEdgeGroupFaithful(g, edges, cnt) {
-  const lead = edges[0];
-  if (g.info.rank === void 0 || lead.tail.info.rank === void 0 || lead.head.info.rank !== lead.tail.info.rank) return false;
-  const tailIsLeft = (lead.tail.info.order ?? 0) <= (lead.head.info.order ?? 0);
-  const leftNode = tailIsLeft ? lead.tail : lead.head;
-  const rightNode = tailIsLeft ? lead.head : lead.tail;
-  const sample = tailIsLeft ? lead : {
-    ...lead,
-    tail: leftNode,
-    head: rightNode,
-    info: { ...lead.info, tail_port: lead.info.head_port, head_port: lead.info.tail_port }
-  };
-  const { bottom, side } = flatSide(sample);
-  const ctx = flatBboxCtx(g);
-  const ranksep = graphRanksep(g);
-  const P = freshFlatPath();
-  const tend = makeFlatEndBox({ ctx, P, e: sample, n: leftNode, side, ranksep, isBegin: true });
-  const hend = makeFlatEndBox({ ctx, P, e: sample, n: rightNode, side, ranksep, isBegin: false });
-  const stepx = (g.info.nodesep ?? 18) / (cnt + 1);
-  const stepy = flatVspace(g, leftNode, !bottom) / (cnt + 1);
-  const rc = {
-    P,
-    tend,
-    hend,
-    tlast: tend.boxes[tend.boxn - 1],
-    hlast: hend.boxes[hend.boxn - 1],
-    bottom,
-    stepx,
-    stepy,
-    leftNode
-  };
-  for (let i = 0; i < cnt; i++) {
-    if (!routeGroupEdge(edges[i], i, rc)) return false;
-  }
-  return true;
-}
-
 // src/layout/dot/splines-flat-labeled.ts
 var LBL_SPACE = 6;
 function findLabelNode(e) {
@@ -30024,6 +30085,93 @@ function makeAdjFlatNoPortEdge(g, e) {
   return true;
 }
 
+// src/layout/dot/splines-flat-multi.ts
+function portEq2(a, b) {
+  if (!a.defined && !b.defined) return true;
+  if (!a.defined || !b.defined) return false;
+  return a.p.x === b.p.x && a.p.y === b.p.y;
+}
+function flatPortKey(e, lo) {
+  return e.tail === lo ? { loP: e.info.tail_port, hiP: e.info.head_port } : { loP: e.info.head_port, hiP: e.info.tail_port };
+}
+function isNonAdjGroupable(x, g) {
+  return x.info.spl === void 0 && x.tail.info.rank !== void 0 && x.tail.info.rank === x.head.info.rank && !isFlatAdjacent(g, x);
+}
+function samePortsAs(x, lo, key) {
+  const k = flatPortKey(x, lo);
+  return portEq2(k.loP, key.loP) && portEq2(k.hiP, key.hiP);
+}
+function collectNonAdjacentFlatGroup(e, g) {
+  const u = e.tail, v = e.head;
+  const lo = (u.info.order ?? 0) <= (v.info.order ?? 0) ? u : v;
+  const key = flatPortKey(e, lo);
+  const sharesPair = (x) => x.tail === u && x.head === v || x.tail === v && x.head === u;
+  const group = g.edges.filter(
+    (x) => sharesPair(x) && isNonAdjGroupable(x, g) && samePortsAs(x, lo, key) && x.info.label === e.info.label
+  );
+  group.sort((a, b) => Number(b.tail === lo) - Number(a.tail === lo) || a.seq - b.seq);
+  return group;
+}
+function copyPathEnd(end) {
+  return {
+    ...end,
+    boxes: end.boxes.map((b) => ({ ll: { ...b.ll }, ur: { ...b.ur } }))
+  };
+}
+function routeGroupEdge(e, i, c) {
+  c.P.nbox = 0;
+  const endStepX = (i + 1) * c.stepx;
+  const endStepY = (i + 1) * c.stepy;
+  const mid = c.bottom ? bottomBoxes(c.tlast, c.hlast, endStepX, endStepY, c.stepy) : topBoxes(c.tlast, c.hlast, endStepX, endStepY, c.stepy);
+  assembleFlatPath(c.P, copyPathEnd(c.tend), copyPathEnd(c.hend), mid);
+  const pts = c.et === EDGETYPE_SPLINE ? routeSplines(c.P) : routePolylines(c.P);
+  if (pts === null || pts.length === 0) return false;
+  if (e.tail !== c.leftNode) pts.reverse();
+  clipAndInstall(e, e.head, pts, pts.length, { ...buildDotSinfo(), ignoreSwap: true });
+  return true;
+}
+function routeFlatEdgeGroupFaithful(g, edges, cnt, et) {
+  const lead = edges[0];
+  if (g.info.rank === void 0 || lead.tail.info.rank === void 0 || lead.head.info.rank !== lead.tail.info.rank) return false;
+  if (et === EDGETYPE_LINE) {
+    makeSimpleFlat(edges, et);
+    return true;
+  }
+  const tailIsLeft = (lead.tail.info.order ?? 0) <= (lead.head.info.order ?? 0);
+  const leftNode = tailIsLeft ? lead.tail : lead.head;
+  const rightNode = tailIsLeft ? lead.head : lead.tail;
+  const sample = tailIsLeft ? lead : {
+    ...lead,
+    tail: leftNode,
+    head: rightNode,
+    info: { ...lead.info, tail_port: lead.info.head_port, head_port: lead.info.tail_port }
+  };
+  const { bottom, side } = flatSide(sample);
+  const ctx = flatBboxCtx(g);
+  const ranksep = graphRanksep(g);
+  const P = freshFlatPath();
+  const tend = makeFlatEndBox({ ctx, P, e: sample, n: leftNode, side, ranksep, isBegin: true });
+  const hend = makeFlatEndBox({ ctx, P, e: sample, n: rightNode, side, ranksep, isBegin: false });
+  const stepx = (g.info.nodesep ?? 18) / (cnt + 1);
+  const stepy = flatVspace(g, leftNode, !bottom) / (cnt + 1);
+  const rc = {
+    P,
+    tend,
+    hend,
+    tlast: tend.boxes[tend.boxn - 1],
+    hlast: hend.boxes[hend.boxn - 1],
+    bottom,
+    et,
+    stepx,
+    stepy,
+    leftNode
+  };
+  for (let i = 0; i < cnt; i++) {
+    if (!routeGroupEdge(edges[i], i, rc)) return false;
+  }
+  return true;
+}
+
 // src/layout/dot/edge-route-boxes.ts
 var FUDGE2 = 2;
 function makeTailBox(nb, startPy) {
@@ -30308,6 +30456,10 @@ function routeOneEdge(e, g) {
 function routeFaithfulMultiRank(e, g) {
   const pts = routeMultiRankEdgeFaithful(g, e);
   if (pts === null) return false;
+  if (pts === "lost") {
+    e.info.lost = true;
+    return true;
+  }
   clipAndInstall(e, e.head, pts, pts.length, buildDotSinfo());
   return true;
 }
@@ -30323,7 +30475,10 @@ 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 && isAdjacentPortFlat(x, g);
+  return x.info.spl === void 0 && x.tail.info.rank !== void 0 && x.tail.info.rank === x.head.info.rank && isFlatAdjacent(g, x);
+}
+function joinsPortedFlatGroup(e, g) {
+  return isAdjFlatCandidate(e) && isGroupableFlat(e, g) && collectAdjacentFlatGroup(e, g).some(hasDefinedPort);
 }
 function collectAdjacentFlatGroup(e, g) {
   const u = e.tail, v = e.head;
@@ -30338,11 +30493,11 @@ function routeFaithfulSidePort(e, g) {
   const sameRank = e.tail.info.rank !== void 0 && e.tail.info.rank === e.head.info.rank;
   if (sameRank && isFlatAdjacent(g, e)) {
     const group = collectAdjacentFlatGroup(e, g);
-    return makeFlatAdjEdges(g, group, group.length, EDGETYPE_SPLINE) === 0 && e.info.spl !== void 0;
+    return makeFlatAdjEdges(g, group, group.length, edgeType(g)) === 0 && e.info.spl !== void 0;
   }
   if (sameRank) {
     const group = collectNonAdjacentFlatGroup(e, g);
-    return routeFlatEdgeGroupFaithful(g, group, group.length) && e.info.spl !== void 0;
+    return routeFlatEdgeGroupFaithful(g, group, group.length, edgeType(g)) && e.info.spl !== void 0;
   }
   const pts = routeRegularEdgeFaithful(g, e);
   if (pts === null) return false;
@@ -30363,11 +30518,12 @@ function isLostFlatAdjRecordEdge(g, e) {
 function routeFlatEdge(e, g) {
   if (isLostFlatAdjRecordEdge(g, e)) return true;
   if (makeFlatLabeledEdge(g, e)) return true;
+  if (joinsPortedFlatGroup(e, g) && routeFaithfulSidePort(e, g)) return true;
   if (makeAdjFlatNoPortEdge(g, e)) 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;
+    if (group.length > 0 && routeFlatEdgeGroupFaithful(g, group, group.length, edgeType(g)) && e.info.spl !== void 0) return true;
   }
   return false;
 }
@@ -30812,24 +30968,28 @@ function addSegment(segnum, seg2, tr, qs) {
     swapSegEndpoints(s);
     isSwapped = true;
   }
-  let tfirst;
-  if (!inserted(segnum, seg2, isSwapped ? LASTPT : FIRSTPT)) {
-    tfirst = insertV0(s, seg2, tr, qs, segnum);
-  } else {
-    tfirst = locateEndpoint(s.v0, s.v1, s.root0, seg2, qs);
+  const ctx = { s, seg: seg2, tr, qs, segnum, tribot: false, isSwapped };
+  const tfirst = firstTrap(ctx);
+  const tlast = lastTrap(ctx);
+  if (threadSegment(ctx, tfirst, tlast) !== 0) return -1;
+  seg2[segnum].isInserted = true;
+  return 0;
+}
+function firstTrap(c) {
+  if (!inserted(c.segnum, c.seg, c.isSwapped ? LASTPT : FIRSTPT)) {
+    return insertV0(c.s, c.seg, c.tr, c.qs, c.segnum);
   }
-  let tlast;
-  let tribot = false;
-  if (!inserted(segnum, seg2, isSwapped ? FIRSTPT : LASTPT)) {
-    tlast = insertV1(s, seg2, tr, qs, segnum);
-  } else {
-    tlast = locateEndpoint(s.v1, s.v0, s.root1, seg2, qs);
-    tribot = true;
+  return locateEndpoint(c.s.v0, c.s.v1, c.s.root0, c.seg, c.qs);
+}
+function lastTrap(c) {
+  if (!inserted(c.segnum, c.seg, c.isSwapped ? FIRSTPT : LASTPT)) {
+    return insertV1(c.s, c.seg, c.tr, c.qs, c.segnum);
   }
-  threadSegment(s, seg2, tr, qs, segnum, tfirst, tlast, tribot, isSwapped);
-  seg2[segnum].isInserted = true;
+  c.tribot = true;
+  return locateEndpoint(c.s.v1, c.s.v0, c.s.root1, c.seg, c.qs);
 }
-function threadSegment(s, seg2, tr, qs, segnum, tfirst, tlast, tribot, isSwapped) {
+function threadSegment(c, tfirst, tlast) {
+  const { s, seg: seg2, tr, qs, segnum, tribot, isSwapped } = c;
   let tfirstr = INVALID_TRAP;
   let tlastr = INVALID_TRAP;
   let t = tfirst;
@@ -30856,17 +31016,20 @@ function threadSegment(s, seg2, tr, qs, segnum, tfirst, tlast, tribot, isSwapped
     if (equalTo(tr[t].lo, tr[tlast].lo)) tlastr = tn;
     const tSav = t;
     const tnSav = tn;
+    if (!isValidTrap(tr[t].d0) && !isValidTrap(tr[t].d1)) {
+      console.error("trapezoid segment construction failed");
+      return -1;
+    }
     t = advanceT(s, seg2, tr, t, tn, tlast, segnum, isSwapped, tribot);
     tr[tSav].rseg = segnum;
     tr[tnSav].lseg = segnum;
   }
   mergeTrapezoids(segnum, tfirst, tlast, S_LEFT, tr, qs);
   mergeTrapezoids(segnum, tfirstr, tlastr, S_RIGHT, tr, qs);
+  return 0;
 }
 function advanceT(s, seg2, tr, t, tn, tlast, segnum, isSwapped, tribot) {
-  if (!isValidTrap(tr[t].d0) && !isValidTrap(tr[t].d1)) {
-    return INVALID_TRAP;
-  } else if (isValidTrap(tr[t].d0) && !isValidTrap(tr[t].d1)) {
+  if (isValidTrap(tr[t].d0) && !isValidTrap(tr[t].d1)) {
     handleD0Only(s, seg2, tr, t, tn, tlast, segnum, isSwapped, tribot);
     return tr[t].d0;
   } else if (!isValidTrap(tr[t].d0) && isValidTrap(tr[t].d1)) {
@@ -30886,33 +31049,16 @@ function findNewRoots(segnum, seg2, tr, qs) {
 // src/ortho/trapezoid.ts
 function constructTrapezoids(nseg, seg2, permute) {
   const qs = [];
-  const tr = [];
-  tr.push({
-    lseg: 0,
-    rseg: 0,
-    hi: { x: 0, y: 0 },
-    lo: { x: 0, y: 0 },
-    u0: 0,
-    u1: 0,
-    d0: 0,
-    d1: 0,
-    sink: 0,
-    usave: 0,
-    uside: 0,
-    isValid: false
-  });
+  const tr = [sentinelTrap()];
   let segi = 0;
   const root = initQueryStructure(permute[segi++], seg2, tr, qs);
-  for (let i = 1; i <= nseg; i++) {
-    seg2[i].root0 = root;
-    seg2[i].root1 = root;
-  }
+  seedRoots(nseg, seg2, root);
   const logstar = mathLogstarN(nseg);
   for (let h = 1; h <= logstar; h++) {
     const lo = mathN(nseg, h - 1) + 1;
     const hi = mathN(nseg, h);
     for (let i = lo; i <= hi; i++) {
-      addSegment(permute[segi++], seg2, tr, qs);
+      if (addSegment(permute[segi++], seg2, tr, qs) !== 0) return [];
     }
     for (let i = 1; i <= nseg; i++) {
       findNewRoots(i, seg2, tr, qs);
@@ -30920,10 +31066,32 @@ function constructTrapezoids(nseg, seg2, permute) {
   }
   const remaining = mathN(nseg, logstar) + 1;
   for (let i = remaining; i <= nseg; i++) {
-    addSegment(permute[segi++], seg2, tr, qs);
+    if (addSegment(permute[segi++], seg2, tr, qs) !== 0) return [];
   }
   return tr;
 }
+function sentinelTrap() {
+  return {
+    lseg: 0,
+    rseg: 0,
+    hi: { x: 0, y: 0 },
+    lo: { x: 0, y: 0 },
+    u0: 0,
+    u1: 0,
+    d0: 0,
+    d1: 0,
+    sink: 0,
+    usave: 0,
+    uside: 0,
+    isValid: false
+  };
+}
+function seedRoots(nseg, seg2, root) {
+  for (let i = 1; i <= nseg; i++) {
+    seg2[i].root0 = root;
+    seg2[i].root1 = root;
+  }
+}
 function initQueryStructure(segnum, seg2, tr, qs) {
   const s = seg2[segnum];
   const i1 = newQNode(qs);
@@ -31227,10 +31395,18 @@ function partition(cells, bb) {
   const hSeg = h.genSegments(cells, bb, false);
   const hPerm = h.generateRandomOrdering(nsegs);
   const hTr = constructTrapezoids(nsegs, hSeg, hPerm);
+  if (hTr.length === 0) {
+    console.error("horizontal trapezoid construction failed");
+    return null;
+  }
   const hDecomp = h.monotonateTrapezoids(hTr, hSeg, false);
   const vSeg = h.genSegments(cells, bb, true);
   const vPerm = h.generateRandomOrdering(nsegs);
   const vTr = constructTrapezoids(nsegs, vSeg, vPerm);
+  if (vTr.length === 0) {
+    console.error("vertical trapezoid construction failed");
+    return null;
+  }
   const vDecomp = h.monotonateTrapezoids(vTr, vSeg, true);
   const result = [];
   for (const v of vDecomp) {
@@ -31239,7 +31415,7 @@ function partition(cells, bb) {
       if (isect) result.push(isect);
     }
   }
-  return result;
+  return result.length === 0 ? null : result;
 }
 
 // src/ortho/rawgraph.ts
@@ -32087,6 +32263,7 @@ function mkMaze(g) {
     UR: { x: BB.UR.x + MARGIN, y: BB.UR.y + MARGIN }
   };
   const rects = partition(gcells, BB);
+  if (rects === null) return null;
   const cells = rects.map((bb) => ({
     flags: 0,
     nedges: 0,
@@ -32568,6 +32745,24 @@ function buildSpline(e, rte, mp) {
   pts.push({ ...p });
   return pts;
 }
+function ensureDummyNodes(sg, gstart) {
+  while (sg.nodes.length < gstart + 2) {
+    sg.nodes.push({
+      nVal: 0,
+      nIdx: 0,
+      nDad: null,
+      nEdge: null,
+      nAdj: 0,
+      saveNAdj: 0,
+      cells: [null, null],
+      adjEdgeList: [],
+      index: sg.nodes.length,
+      isVert: false,
+      x: 0,
+      y: 0
+    });
+  }
+}
 function orthoEdges(g, useLbls, clipAndInstall2) {
   if (useLbls) {
     console.warn(
@@ -32577,6 +32772,7 @@ function orthoEdges(g, useLbls, clipAndInstall2) {
   }
   void useLbls;
   const mp = mkMaze(g);
+  if (mp === null) return -1;
   const sg = mp.sg;
   const es = g.edges.map((e) => ({ e, d: edgeLen(e) }));
   gvQsort(es, edgeCmp);
@@ -32586,22 +32782,7 @@ function orthoEdges(g, useLbls, clipAndInstall2) {
   const pq = pqGenForGraph(sg);
   const sn = sg.nodes[gstart];
   const dn = sg.nodes[gstart + 1];
-  while (sg.nodes.length < gstart + 2) {
-    sg.nodes.push({
-      nVal: 0,
-      nIdx: 0,
-      nDad: null,
-      nEdge: null,
-      nAdj: 0,
-      saveNAdj: 0,
-      cells: [null, null],
-      adjEdgeList: [],
-      index: sg.nodes.length,
-      isVert: false,
-      x: 0,
-      y: 0
-    });
-  }
+  ensureDummyNodes(sg, gstart);
   for (let i = 0; i < nEdges; i++) {
     const e = es[i].e;
     const start = mp.gcells[g.nodes.indexOf(e.tail)];
@@ -32615,7 +32796,7 @@ function orthoEdges(g, useLbls, clipAndInstall2) {
     if (shortPath(pq, sg, dn, sn) !== 0) {
       pqFree(pq);
       freeMaze(mp);
-      return;
+      return 0;
     }
     routeList[i] = convertSPtoRoute(sg, sn, dn);
     reset(sg);
@@ -32626,7 +32807,7 @@ function orthoEdges(g, useLbls, clipAndInstall2) {
   assignSegs(routeList, mp);
   if (assignTracks(mp) !== 0) {
     freeMaze(mp);
-    return;
+    return 0;
   }
   if (clipAndInstall2) {
     for (let i = 0; i < nEdges; i++) {
@@ -32637,6 +32818,7 @@ function orthoEdges(g, useLbls, clipAndInstall2) {
     }
   }
   freeMaze(mp);
+  return 0;
 }
 
 // src/layout/dot/ortho-adapter.ts
@@ -32664,7 +32846,6 @@ function buildEdges(g, nodeArr, orthoNodes) {
     const oes = outIndex.get(n);
     if (oes === void 0) continue;
     for (const e of oes) {
-      if (e.tail === e.head) continue;
       if (concentrate) {
         const ti = e.tail.id;
         const hi = e.head.id;
@@ -32708,7 +32889,7 @@ function installOrthoResult(oe, pts) {
   clipAndInstall(origEdge, origEdge.head, pts, pts.length, ORTHO_SINFO);
 }
 function dispatchOrthoEdges(g, useLbls) {
-  orthoEdges(
+  return orthoEdges(
     buildOrthoGraph(g),
     useLbls,
     (_og, oe, pts) => installOrthoResult(oe, pts)
@@ -33245,12 +33426,12 @@ function resetRW(g) {
 }
 function orthoDispatch(g) {
   resetRW(g);
+  let rc;
   if (((g.root.info.has_labels ?? 0) & EDGE_LABEL) !== 0) {
     setEdgeLabelPos(g);
-    dispatchOrthoEdges(g, true);
-  } else {
-    dispatchOrthoEdges(g, false);
-  }
+    rc = dispatchOrthoEdges(g, true);
+  } else rc = dispatchOrthoEdges(g, false);
+  if (rc !== 0) return rc;
   placePortLabels(g);
   g.info.edgeLabelsDone = true;
   return 0;
@@ -33906,7 +34087,7 @@ function computeStep2(bbs, margin) {
     c -= W * H;
   }
   const r = Math.sqrt(b * b - 4 * a * c);
-  const root = Math.trunc((-b + r) / (2 * a));
+  const root = d2i((-b + r) / (2 * a));
   return root === 0 ? 1 : root;
 }
 function lineXDominant(st, ps) {
@@ -34052,7 +34233,7 @@ function fits2(x, y, info, ctx) {
   }
   const bb = ctx.bbs[info.index];
   const LL = { x: cround(bb.ll.x), y: cround(bb.ll.y) };
-  ctx.places[info.index] = { x: ctx.step * x - LL.x, y: ctx.step * y - LL.y };
+  ctx.places[info.index] = { x: Math.imul(ctx.step, x) - LL.x, y: Math.imul(ctx.step, y) - LL.y };
   for (const c of info.cells) ctx.ps.add(c.x + x, c.y + y);
   return true;
 }
@@ -34538,7 +34719,7 @@ function dotLayoutComponent(sg, root) {
   dotRank(sg);
   dotMincross(sg);
   dotPosition(sg);
-  dotPhasePostNoFinish(sg);
+  return dotPhasePostNoFinish(sg);
 }
 function mapClust(clone, origOf) {
   const orig = origOf.get(clone);
@@ -34624,7 +34805,9 @@ function packComponentsClusterAware(root, comps, pinfo) {
 }
 function layoutAndPack(root, comps, pinfo, origOf) {
   dotGraphInit(root);
-  for (const sg of comps) dotLayoutComponent(sg, root);
+  for (const sg of comps) {
+    if (dotLayoutComponent(sg, root) !== 0) return;
+  }
   packComponentsClusterAware(root, comps, pinfo);
   copyClusterInfo(comps, root, origOf);
   expandRootBbForClusters(root);
@@ -34656,11 +34839,13 @@ function dotPhaseInit(g) {
 function dotPhasePostNoFinish(g) {
   removeFill(g);
   dotSameports(g);
-  dotSplines(g);
+  const r = dotSplines(g);
+  if (r !== 0) return r;
   if (mapbool2(g.attrs.get("compound") ?? g.root.attrs.get("compound"))) dotCompoundEdges(g);
+  return 0;
 }
 function dotPhasePost(g) {
-  dotPhasePostNoFinish(g);
+  if (dotPhasePostNoFinish(g) !== 0) return;
   gvPostprocess(g);
 }
 function graphPhase(g) {
@@ -37546,10 +37731,10 @@ function raySegIntersect(v, w, a, b) {
   const mv = { x: w.x - v.x, y: w.y - v.y };
   const lv = { x: b.x - a.x, y: b.y - a.y };
   const ln = { x: -lv.y, y: lv.x };
-  const lc = -(ln.x * a.x + ln.y * a.y);
-  const dt = ln.x * mv.x + ln.y * mv.y;
+  const lc = -fma(ln.x, a.x, ln.y * a.y);
+  const dt = fma(ln.x, mv.x, ln.y * mv.y);
   if (Math.abs(dt) < SMALL3) return null;
-  const s = (ln.x * v.x + ln.y * v.y + lc) / dt;
+  const s = (fma(ln.x, v.x, ln.y * v.y) + lc) / dt;
   return { x: v.x - s * mv.x, y: v.y - s * mv.y };
 }
 function triPoint(trip, vx, v, w) {
@@ -37567,36 +37752,44 @@ function ctrlPtIdx(v, ps) {
   return -1;
 }
 var SEP = 15;
+function bisectorTarget(v, cosTheta, sinTheta) {
+  return { x: fma(cosTheta, 100, v.x), y: fma(sinTheta, 100, v.y) };
+}
+function distFused(p, q) {
+  const dx = p.x - q.x;
+  const dy = p.y - q.y;
+  return Math.sqrt(fma(dx, dx, dy * dy));
+}
 function mkCtrlPts(s, mult, prev, v, nxt, trip) {
   const idx = ctrlPtIdx(v, trip.ps);
   if (idx < 0) return null;
   const theta = bisect(prev, v, nxt);
   let sinTheta = Math.sin(theta);
   let cosTheta = Math.cos(theta);
-  let w = { x: v.x + 100 * cosTheta, y: v.y + 100 * sinTheta };
+  let w = bisectorTarget(v, cosTheta, sinTheta);
   if (idx > s) {
     if (wind(prev, v, w) !== 1) {
       sinTheta *= -1;
       cosTheta *= -1;
-      w = { x: v.x + 100 * cosTheta, y: v.y + 100 * sinTheta };
+      w = bisectorTarget(v, cosTheta, sinTheta);
     }
   } else if (wind(prev, v, w) !== -1) {
     sinTheta *= -1;
     cosTheta *= -1;
-    w = { x: v.x + 100 * cosTheta, y: v.y + 100 * sinTheta };
+    w = bisectorTarget(v, cosTheta, sinTheta);
   }
   const q = triPoint(trip, idx, v, w);
   if (q === null) return null;
-  const d = Math.hypot(q.x - v.x, q.y - v.y);
+  const d = distFused(q, v);
   const sep = d >= mult * SEP ? SEP : d / mult;
   const ps = new Array(mult);
   if (idx < s) {
     for (let i = 0; i < mult; i++) {
-      ps[i] = { x: v.x + i * sep * cosTheta, y: v.y + i * sep * sinTheta };
+      ps[i] = { x: fma(i * sep, cosTheta, v.x), y: fma(i * sep, sinTheta, v.y) };
     }
   } else {
     for (let i = 0; i < mult; i++) {
-      ps[mult - i - 1] = { x: v.x + i * sep * cosTheta, y: v.y + i * sep * sinTheta };
+      ps[mult - i - 1] = { x: fma(i * sep, cosTheta, v.x), y: fma(i * sep, sinTheta, v.y) };
     }
   }
   return ps;
@@ -38030,7 +38223,7 @@ var ObstacleHelper = class {
 };
 function ellipseTangentSlope(a, b, p) {
   const signY = p.y >= 0 ? 1 : -1;
-  return -signY * (b * p.x) / (a * Math.sqrt(a * a - p.x * p.x));
+  return -signY * (b * p.x) / (a * Math.sqrt(fma(a, a, -(p.x * p.x))));
 }
 function circumscribedCorner(a, b, i, nsides) {
   const angle0 = 2 * Math.PI * (i - 0.5) / nsides;
@@ -38039,8 +38232,8 @@ function circumscribedCorner(a, b, i, nsides) {
   const p1 = { x: a * Math.cos(angle1), y: b * Math.sin(angle1) };
   const m0 = ellipseTangentSlope(a, b, p0);
   const m1 = ellipseTangentSlope(a, b, p1);
-  const x = (m0 * p0.x - p0.y - m1 * p1.x + p1.y) / (m0 - m1);
-  const y = p0.y + m0 * (x - p0.x);
+  const x = (fms(p1.x, m1, fma(m0, p0.x, -p0.y)) + p1.y) / (m0 - m1);
+  const y = fma(m0, x - p0.x, p0.y);
   return { x, y };
 }
 function boxCornerMargin(j, m) {
@@ -42117,8 +42310,8 @@ function initItem(n, margin) {
   let w2;
   let h2;
   if (margin.doAdd) {
-    w2 = Math.trunc(SCALE * (cround(width / 2 * POINTS_PER_INCH6) + margin.x));
-    h2 = Math.trunc(SCALE * (cround(height / 2 * POINTS_PER_INCH6) + margin.y));
+    w2 = d2i(SCALE * (cround(width / 2 * POINTS_PER_INCH6) + margin.x));
+    h2 = d2i(SCALE * (cround(height / 2 * POINTS_PER_INCH6) + margin.y));
   } else {
     w2 = cround(margin.x * SCALE2 * width * POINTS_PER_INCH6);
     h2 = cround(margin.y * SCALE2 * height * POINTS_PER_INCH6);
@@ -44217,11 +44410,11 @@ function addClusters(g) {
   g.info.clust = clusters;
   g.info.n_cluster = clusters.length;
 }
-function layoutComponents(g, comps, solve2, pinned) {
+function layoutComponents(g, comps, solve4, pinned) {
   for (const gc of comps) {
     setEdgeTypeFromAttr(gc, EDGETYPE_LINE);
-    solveModel2(gc, solve2.mode, solve2.model);
-    maybeRemoveOverlap(gc, solve2.am);
+    solveModel2(gc, solve4.mode, solve4.model);
+    maybeRemoveOverlap(gc, solve4.am);
     splineEdgesShifted(gc);
   }
   const pinfo = {
@@ -46126,6 +46319,20 @@ function powerLawGraph(A3) {
   }
   return mask[1] > 0.8 * max && mask[1] > 0.3 * m;
 }
+var PCP_COVARIANCE_LANES = 4;
+function pcpCovariance(n, dim, x, y) {
+  const nUnfused = n - n % PCP_COVARIANCE_LANES;
+  for (let i = 0; i < n; i++) {
+    for (let k = 0; k < dim; k++) {
+      for (let l = 0; l < dim; l++) {
+        const a = x[i * dim + k];
+        const b = x[i * dim + l];
+        const acc = y[dim * k + l];
+        y[dim * k + l] = i < nUnfused ? acc + a * b : fma(a, b, acc);
+      }
+    }
+  }
+}
 function pcpRotate(n, dim, x) {
   const y = [0, 0, 0, 0];
   const center = [0, 0];
@@ -46136,24 +46343,23 @@ function pcpRotate(n, dim, x) {
   for (let i = 0; i < n; i++) {
     for (let k = 0; k < dim; k++) x[dim * i + k] -= center[k];
   }
-  for (let i = 0; i < n; i++) {
-    for (let k = 0; k < dim; k++) {
-      for (let l = 0; l < dim; l++) {
-        y[dim * k + l] = fma(x[i * dim + k], x[i * dim + l], y[dim * k + l]);
-      }
-    }
-  }
+  pcpCovariance(n, dim, x, y);
   const axis = [0, 1];
   if (y[1] !== 0) {
-    axis[0] = -(-y[0] + y[3] - Math.sqrt(y[0] * y[0] + 4 * y[1] * y[1] - 2 * y[0] * y[3] + y[3] * y[3])) / (2 * y[1]);
+    const radicand = fma(
+      y[3],
+      y[3],
+      fma(-2 * y[0], y[3], fma(y[0], y[0], 4 * y[1] * y[1]))
+    );
+    axis[0] = -(-y[0] + y[3] - Math.sqrt(radicand)) / (2 * y[1]);
     axis[1] = 1;
   }
-  const dist4 = Math.sqrt(1 + axis[0] * axis[0]);
+  const dist4 = Math.sqrt(fma(axis[0], axis[0], 1));
   axis[0] = axis[0] / dist4;
   axis[1] = axis[1] / dist4;
   for (let i = 0; i < n; i++) {
-    const x0 = x[dim * i] * axis[0] + x[dim * i + 1] * axis[1];
-    const x1 = -x[dim * i] * axis[1] + x[dim * i + 1] * axis[0];
+    const x0 = fma(x[dim * i], axis[0], x[dim * i + 1] * axis[1]);
+    const x1 = fma(-x[dim * i], axis[1], x[dim * i + 1] * axis[0]);
     x[dim * i] = x0;
     x[dim * i + 1] = x1;
   }
@@ -46416,16 +46622,7 @@ function makeCData(dn) {
   };
 }
 
-// src/layout/circo/blockpath.ts
-function blockGraph(allEdges3, sn) {
-  const ns = new Set(sn.subGraph.nodes);
-  for (const n of sn.subGraph.nodes) {
-    for (const e of allEdges3) {
-      if (e.tail === n && ns.has(e.head) && !sn.subGraph.edges.includes(e))
-        sn.subGraph.edges.push(e);
-    }
-  }
-}
+// src/layout/circo/crossings.ts
 function derivedOf(n) {
   return n.info.alg?.derivedNode ?? null;
 }
@@ -46436,27 +46633,51 @@ function closeOpenEdge(e, d, opened) {
   }
   return cross2;
 }
-function openEdgesAt(d, edges, opened, order) {
+function agfstedgeLists(edges) {
+  const seq2 = /* @__PURE__ */ new Map();
+  edges.forEach((e, i) => seq2.set(e, i));
+  const by = (end) => (a, b) => end(a).orig.id - end(b).orig.id || seq2.get(a) - seq2.get(b);
+  const out = /* @__PURE__ */ new Map();
+  const inn = /* @__PURE__ */ new Map();
   for (const e of edges) {
-    if (e.order === 0 && (e.tail === d || e.head === d)) {
-      e.order = order;
-      opened.push(e);
-    }
+    out.set(e.tail, [...out.get(e.tail) ?? [], e]);
+    inn.set(e.head, [...inn.get(e.head) ?? [], e]);
+  }
+  const lists = /* @__PURE__ */ new Map();
+  for (const d of /* @__PURE__ */ new Set([...out.keys(), ...inn.keys()])) {
+    const o = (out.get(d) ?? []).sort(by((e) => e.head));
+    const i = (inn.get(d) ?? []).sort(by((e) => e.tail));
+    lists.set(d, [...o, ...i]);
   }
+  return lists;
 }
 function countCrossings(list, edges) {
   for (const e of edges) e.order = 0;
-  const opened = [];
+  const incident = agfstedgeLists(edges);
+  const opened = /* @__PURE__ */ new Map();
   let crossings = 0;
   let order = 1;
   for (const n of list) {
     const d = derivedOf(n);
     if (!d) continue;
-    for (const e of edges) {
-      if (e.order > 0 && (e.tail === d || e.head === d))
-        crossings += closeOpenEdge(e, d, opened);
+    const es = incident.get(d) ?? [];
+    crossings += closeEdgesAt(d, es, opened);
+    for (const e of es) {
+      if (e.order === 0) {
+        e.order = order;
+        opened.set(e, d);
+      }
     }
-    openEdgesAt(d, edges, opened, order++);
+    order++;
+  }
+  return crossings;
+}
+function closeEdgesAt(d, es, opened) {
+  let crossings = 0;
+  for (const e of es) {
+    if (e.order === 0) continue;
+    crossings += closeOpenEdge(e, d, opened.keys());
+    if (opened.get(e) === d) opened.delete(e);
   }
   return crossings;
 }
@@ -46509,6 +46730,17 @@ function spanIncident(dn, edges, ord, seq2) {
   const inn = edges.filter((e) => e.head === dn).sort((a, b) => (ord.get(a.tail) ?? 0) - (ord.get(b.tail) ?? 0) || (seq2.get(a) ?? 0) - (seq2.get(b) ?? 0));
   return [...out, ...inn];
 }
+
+// src/layout/circo/blockpath.ts
+function blockGraph(allEdges3, sn) {
+  const ns = new Set(sn.subGraph.nodes);
+  for (const n of sn.subGraph.nodes) {
+    for (const e of allEdges3) {
+      if (e.tail === n && ns.has(e.head) && !sn.subGraph.edges.includes(e))
+        sn.subGraph.edges.push(e);
+    }
+  }
+}
 function dfsSpan(sn, map, edges, ord, seq2) {
   sn.visited = true;
   for (const e of spanIncident(sn.dn, edges, ord, seq2)) {
@@ -47987,17 +48219,30 @@ function renderEdgeLabels(e, renderer, job) {
 }
 function emitEdgeLabel(lp, id, hs, renderer, job, spl, emitState) {
   if (!lp?.set) return;
-  const open = hs.url !== null || hs.explicit;
-  if (open) openAnchorWith(renderer, job, hs.url, hs.tooltip, hs.target, id);
-  const savedOverride = job.labelEmitOverride;
-  if (emitState !== void 0) job.labelEmitOverride = emitState;
-  try {
-    renderOneLabel(lp, renderer, job);
-  } finally {
-    job.labelEmitOverride = savedOverride;
+  withObjEmitState(job, emitState ?? 11 /* ELabel */, () => {
+    const open = hs.url !== null || hs.explicit;
+    if (open) openAnchorWith(renderer, job, hs.url, hs.tooltip, hs.target, id);
+    const savedOverride = job.labelEmitOverride;
+    if (emitState !== void 0) job.labelEmitOverride = emitState;
+    try {
+      renderOneLabel(lp, renderer, job);
+    } finally {
+      job.labelEmitOverride = savedOverride;
+    }
+    if (spl) emitAttachment(lp, spl, renderer, job);
+    if (open) renderer.endAnchor?.(job);
+  });
+}
+function withObjEmitState(job, lkind, fn) {
+  const obj = job.obj;
+  if (obj === null) {
+    fn();
+    return;
   }
-  if (spl) emitAttachment(lp, spl, renderer, job);
-  if (open) renderer.endAnchor?.(job);
+  const oldEmitState = obj.emitState;
+  obj.emitState = lkind;
+  fn();
+  obj.emitState = oldEmitState;
 }
 function emitAttachment(lp, spl, renderer, job) {
   if (!lp?.set) return;
@@ -49583,6 +49828,7 @@ var DotWriterBase = class {
 
 // src/render/dot/edge-draw.ts
 var DEFAULT_COLOR5 = "black";
+var DEFAULT_LINE_STYLE = ["solid", "setlinewidth(1)"];
 function emitArrowOp(buf, op, pen) {
   switch (op.kind) {
     case "polygon":
@@ -49606,6 +49852,25 @@ function emitArrowOp(buf, op, pen) {
 var EdgeDrawBase = class extends DotWriterBase {
   /** setlinewidth state per emit_state. @see gvrender_core_dot.c penwidth[] */
   penwidth = new Array(12).fill(1);
+  /**
+   * emit_attachment's draw calls (decorate=true): gvrender_set_style with the
+   * default line style sets the obj's rawstyle/pen/penwidth (setlinewidth 1),
+   * gvrender_set_pencolor sets the pen to the label fontcolor (first entry of
+   * a color list), then gvrender_polyline → xdot_polyline emits the style ops
+   * (`S 5 -solid`; setlinewidth is filtered), the pen color and `L 3`.
+   * @see lib/common/emit.c:emit_attachment (1886-1893)
+   * @see lib/gvc/gvrender.c:gvrender_set_style / gvrender_set_pencolor
+   */
+  attachmentPolyline(pts, pencolor, job) {
+    const obj = job.obj;
+    if (obj !== null) {
+      obj.rawStyle = [...DEFAULT_LINE_STYLE];
+      obj.pen = 3 /* Solid */;
+      obj.penWidth = 1;
+      obj.penColor = resolveRenderColor(pencolor.split(":")[0]);
+    }
+    this.polyline(pts, job);
+  }
   /**
    * The plain single-colour spline branch of beginEdge — lifted verbatim so the
    * four-way spline-kind chain above stays readable; no branch was reordered or
@@ -50139,19 +50404,6 @@ function emitMulticolorArrows(e, job, headColor, tailColor) {
     emitArrowOps(headOps, headColor, job, pw, colorOpacity(resolveRenderColor(headColor)));
   }
 }
-function overlapLabel(lp, b) {
-  const sx = lp.dimen.x / 2;
-  const sy = lp.dimen.y / 2;
-  const bb = {
-    ll: { x: lp.pos.x - sx, y: lp.pos.y - sy },
-    ur: { x: lp.pos.x + sx, y: lp.pos.y + sy }
-  };
-  return boxOverlap(b, bb);
-}
-function edgeHasDrawableContent(e, clip) {
-  const i = e.info;
-  return i.spl !== void 0 || i.label !== void 0 && i.label.set && overlapLabel(i.label, clip) || i.xlabel !== void 0 || i.head_label !== void 0 || i.tail_label !== void 0;
-}
 var SvgRenderer = class {
   type = "svg";
   /** @see plugin/core/gvplugin_core.c registration table */
@@ -50416,9 +50668,9 @@ function peg$parse(input, options) {
   const peg$c0 = "{";
   const peg$c1 = "}";
   const peg$c2 = ";";
-  const peg$c3 = "[";
-  const peg$c4 = "]";
-  const peg$c5 = "=";
+  const peg$c3 = "=";
+  const peg$c4 = "[";
+  const peg$c5 = "]";
   const peg$c6 = ":";
   const peg$c7 = "->";
   const peg$c8 = "--";
@@ -50442,32 +50694,30 @@ function peg$parse(input, options) {
   const peg$r3 = /^[A-Za-z_\x80-\uFFFF]/;
   const peg$r4 = /^[A-Za-z_0-9\x80-\uFFFF]/;
   const peg$r5 = /^[0-9]/;
-  const peg$r6 = /^[eE]/;
-  const peg$r7 = /^[+\-]/;
-  const peg$r8 = /^[Ss]/;
-  const peg$r9 = /^[Tt]/;
-  const peg$r10 = /^[Rr]/;
-  const peg$r11 = /^[Ii]/;
-  const peg$r12 = /^[Cc]/;
-  const peg$r13 = /^[Gg]/;
-  const peg$r14 = /^[Aa]/;
-  const peg$r15 = /^[Pp]/;
-  const peg$r16 = /^[Hh]/;
-  const peg$r17 = /^[Dd]/;
-  const peg$r18 = /^[Nn]/;
-  const peg$r19 = /^[Oo]/;
-  const peg$r20 = /^[Ee]/;
-  const peg$r21 = /^[Uu]/;
-  const peg$r22 = /^[Bb]/;
-  const peg$r23 = /^[ \t\r\n]/;
-  const peg$r24 = /^[^\n]/;
+  const peg$r6 = /^[Ss]/;
+  const peg$r7 = /^[Tt]/;
+  const peg$r8 = /^[Rr]/;
+  const peg$r9 = /^[Ii]/;
+  const peg$r10 = /^[Cc]/;
+  const peg$r11 = /^[Gg]/;
+  const peg$r12 = /^[Aa]/;
+  const peg$r13 = /^[Pp]/;
+  const peg$r14 = /^[Hh]/;
+  const peg$r15 = /^[Dd]/;
+  const peg$r16 = /^[Nn]/;
+  const peg$r17 = /^[Oo]/;
+  const peg$r18 = /^[Ee]/;
+  const peg$r19 = /^[Uu]/;
+  const peg$r20 = /^[Bb]/;
+  const peg$r21 = /^[ \t\r\n]/;
+  const peg$r22 = /^[^\n]/;
   const peg$e0 = peg$literalExpectation("{", false);
   const peg$e1 = peg$literalExpectation("}", false);
   const peg$e2 = peg$literalExpectation(";", false);
-  const peg$e3 = peg$literalExpectation("[", false);
-  const peg$e4 = peg$literalExpectation("]", false);
-  const peg$e5 = peg$classExpectation([";", ","], false, false, false);
-  const peg$e6 = peg$literalExpectation("=", false);
+  const peg$e3 = peg$literalExpectation("=", false);
+  const peg$e4 = peg$literalExpectation("[", false);
+  const peg$e5 = peg$literalExpectation("]", false);
+  const peg$e6 = peg$classExpectation([";", ","], false, false, false);
   const peg$e7 = peg$literalExpectation(":", false);
   const peg$e8 = peg$otherExpectation("edge operator");
   const peg$e9 = peg$literalExpectation("->", false);
@@ -50487,30 +50737,28 @@ function peg$parse(input, options) {
   const peg$e23 = peg$literalExpectation("-", false);
   const peg$e24 = peg$classExpectation([["0", "9"]], false, false, false);
   const peg$e25 = peg$literalExpectation(".", false);
-  const peg$e26 = peg$classExpectation(["e", "E"], false, false, false);
-  const peg$e27 = peg$classExpectation(["+", "-"], false, false, false);
-  const peg$e28 = peg$classExpectation(["S", "s"], false, false, false);
-  const peg$e29 = peg$classExpectation(["T", "t"], false, false, false);
-  const peg$e30 = peg$classExpectation(["R", "r"], false, false, false);
-  const peg$e31 = peg$classExpectation(["I", "i"], false, false, false);
-  const peg$e32 = peg$classExpectation(["C", "c"], false, false, false);
-  const peg$e33 = peg$classExpectation(["G", "g"], false, false, false);
-  const peg$e34 = peg$classExpectation(["A", "a"], false, false, false);
-  const peg$e35 = peg$classExpectation(["P", "p"], false, false, false);
-  const peg$e36 = peg$classExpectation(["H", "h"], false, false, false);
-  const peg$e37 = peg$classExpectation(["D", "d"], false, false, false);
-  const peg$e38 = peg$classExpectation(["N", "n"], false, false, false);
-  const peg$e39 = peg$classExpectation(["O", "o"], false, false, false);
-  const peg$e40 = peg$classExpectation(["E", "e"], false, false, false);
-  const peg$e41 = peg$classExpectation(["U", "u"], false, false, false);
-  const peg$e42 = peg$classExpectation(["B", "b"], false, false, false);
-  const peg$e43 = peg$classExpectation([" ", "	", "\r", "\n"], false, false, false);
-  const peg$e44 = peg$literalExpectation("/*", false);
-  const peg$e45 = peg$literalExpectation("*/", false);
-  const peg$e46 = peg$literalExpectation("//", false);
-  const peg$e47 = peg$classExpectation(["\n"], true, false, false);
-  const peg$e48 = peg$literalExpectation("\n", false);
-  const peg$e49 = peg$literalExpectation("#", false);
+  const peg$e26 = peg$classExpectation(["S", "s"], false, false, false);
+  const peg$e27 = peg$classExpectation(["T", "t"], false, false, false);
+  const peg$e28 = peg$classExpectation(["R", "r"], false, false, false);
+  const peg$e29 = peg$classExpectation(["I", "i"], false, false, false);
+  const peg$e30 = peg$classExpectation(["C", "c"], false, false, false);
+  const peg$e31 = peg$classExpectation(["G", "g"], false, false, false);
+  const peg$e32 = peg$classExpectation(["A", "a"], false, false, false);
+  const peg$e33 = peg$classExpectation(["P", "p"], false, false, false);
+  const peg$e34 = peg$classExpectation(["H", "h"], false, false, false);
+  const peg$e35 = peg$classExpectation(["D", "d"], false, false, false);
+  const peg$e36 = peg$classExpectation(["N", "n"], false, false, false);
+  const peg$e37 = peg$classExpectation(["O", "o"], false, false, false);
+  const peg$e38 = peg$classExpectation(["E", "e"], false, false, false);
+  const peg$e39 = peg$classExpectation(["U", "u"], false, false, false);
+  const peg$e40 = peg$classExpectation(["B", "b"], false, false, false);
+  const peg$e41 = peg$classExpectation([" ", "	", "\r", "\n"], false, false, false);
+  const peg$e42 = peg$literalExpectation("/*", false);
+  const peg$e43 = peg$literalExpectation("*/", false);
+  const peg$e44 = peg$literalExpectation("//", false);
+  const peg$e45 = peg$classExpectation(["\n"], true, false, false);
+  const peg$e46 = peg$literalExpectation("\n", false);
+  const peg$e47 = peg$literalExpectation("#", false);
   function peg$f0(s, t, id, stmts) {
     return {
       type: "graph",
@@ -50553,40 +50801,44 @@ function peg$parse(input, options) {
   function peg$f11(s) {
     return s;
   }
-  function peg$f12(t, attrs) {
+  function peg$f12(t, m, attrs) {
+    if (m) console.error("Warning: attribute macros not implemented");
     return { type: "attr", target: t, attrs };
   }
   function peg$f13(a) {
     return { type: "assign", key: a.key, value: a.value };
   }
   function peg$f14() {
-    return "graph";
+    return true;
   }
   function peg$f15() {
-    return "node";
+    return false;
   }
   function peg$f16() {
+    return "graph";
+  }
+  function peg$f17() {
+    return "node";
+  }
+  function peg$f18() {
     return "edge";
   }
-  function peg$f17(defs, rest) {
+  function peg$f19(defs, rest) {
     return defs.concat(rest);
   }
-  function peg$f18(defs) {
-    return defs;
-  }
-  function peg$f19() {
+  function peg$f20() {
     return [];
   }
-  function peg$f20(a) {
+  function peg$f21(a) {
     return a;
   }
-  function peg$f21(pairs) {
+  function peg$f22(pairs) {
     return pairs;
   }
-  function peg$f22(k, v) {
+  function peg$f23(k, v) {
     return { key: k, value: v };
   }
-  function peg$f23(head, chain, attrs) {
+  function peg$f24(head, chain, attrs) {
     if (chain.length > 0) {
       const nodes = [head].concat(chain);
       return { type: "edge", nodes, attrs };
@@ -50597,70 +50849,70 @@ function peg$parse(input, options) {
       return { type: "node", id: head, attrs };
     }
   }
-  function peg$f24(s) {
+  function peg$f25(s) {
     return s;
   }
-  function peg$f25(n) {
+  function peg$f26(n) {
     return n;
   }
-  function peg$f26(id, port, compass) {
+  function peg$f27(id, port, compass) {
     return { id, port, compass };
   }
-  function peg$f27(id, port) {
+  function peg$f28(id, port) {
     return { id, port, compass: null };
   }
-  function peg$f28(id) {
+  function peg$f29(id) {
     return { id, port: null, compass: null };
   }
-  function peg$f29(s, rest) {
+  function peg$f30(s, rest) {
     return [s].concat(rest);
   }
-  function peg$f30() {
+  function peg$f31() {
     return [];
   }
-  function peg$f31(id, stmts) {
+  function peg$f32(id, stmts) {
     return { type: "subgraph", id, stmts };
   }
-  function peg$f32(stmts) {
+  function peg$f33(stmts) {
     return { type: "subgraph", id: null, stmts };
   }
-  function peg$f33(stmts) {
+  function peg$f34(stmts) {
     return { type: "subgraph", id: null, stmts };
   }
-  function peg$f34(first, s) {
+  function peg$f35(first, s) {
     return s;
   }
-  function peg$f35(first, rest) {
+  function peg$f36(first, rest) {
     return rest.length > 0 ? first + rest.join("") : first;
   }
-  function peg$f36(chars) {
+  function peg$f37(chars) {
     return chars.join("");
   }
-  function peg$f37() {
+  function peg$f38() {
     return '"';
   }
-  function peg$f38() {
+  function peg$f39() {
     return "";
   }
-  function peg$f39(c) {
+  function peg$f40(c) {
     return "\\" + c;
   }
-  function peg$f40(content) {
+  function peg$f41(content) {
     return "
" + content;
   }
-  function peg$f41(chars) {
+  function peg$f42(chars) {
     return chars.join("");
   }
-  function peg$f42(nested2, content) {
+  function peg$f43(nested2, content) {
     return "<" + content + ">";
   }
-  function peg$f43(n) {
+  function peg$f44(n) {
     return n;
   }
-  function peg$f44(first, rest) {
+  function peg$f45(first, rest) {
     return first + rest.join("");
   }
-  function peg$f45(s) {
+  function peg$f46(s) {
     return Array.isArray(s) ? s.flat(Infinity).filter((x) => x !== null && x !== void 0).join("") : String(s);
   }
   let peg$currPos = options.peg$currPos | 0;
@@ -51031,15 +51283,21 @@ function peg$parse(input, options) {
     return s0;
   }
   function peg$parseAttrStmt() {
-    let s0, s12, s2, s3;
+    let s0, s12, s2, s3, s4;
     s0 = peg$currPos;
     s12 = peg$parseAttrType();
     if (s12 !== peg$FAILED) {
       s2 = peg$parse_();
-      s3 = peg$parseAttrList();
+      s3 = peg$parseOptMacroName();
       if (s3 !== peg$FAILED) {
-        peg$savedPos = s0;
-        s0 = peg$f12(s12, s3);
+        s4 = peg$parseAttrListReq();
+        if (s4 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f12(s12, s3, s4);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -51059,13 +51317,49 @@ function peg$parse(input, options) {
     }
     return s0;
   }
+  function peg$parseOptMacroName() {
+    let s0, s12, s2, s3, s4;
+    s0 = peg$currPos;
+    s12 = peg$parseAtom();
+    if (s12 !== peg$FAILED) {
+      s2 = peg$parse_();
+      if (input.charCodeAt(peg$currPos) === 61) {
+        s3 = peg$c3;
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e3);
+        }
+      }
+      if (s3 !== peg$FAILED) {
+        s4 = peg$parse_();
+        peg$savedPos = s0;
+        s0 = peg$f14();
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s12 = "";
+      peg$savedPos = s0;
+      s12 = peg$f15();
+      s0 = s12;
+    }
+    return s0;
+  }
   function peg$parseAttrType() {
     let s0, s12;
     s0 = peg$currPos;
     s12 = peg$parseGraphKw();
     if (s12 !== peg$FAILED) {
       peg$savedPos = s0;
-      s12 = peg$f14();
+      s12 = peg$f16();
     }
     s0 = s12;
     if (s0 === peg$FAILED) {
@@ -51073,7 +51367,7 @@ function peg$parse(input, options) {
       s12 = peg$parseNodeKw();
       if (s12 !== peg$FAILED) {
         peg$savedPos = s0;
-        s12 = peg$f15();
+        s12 = peg$f17();
       }
       s0 = s12;
       if (s0 === peg$FAILED) {
@@ -51081,24 +51375,24 @@ function peg$parse(input, options) {
         s12 = peg$parseEdgeKw();
         if (s12 !== peg$FAILED) {
           peg$savedPos = s0;
-          s12 = peg$f16();
+          s12 = peg$f18();
         }
         s0 = s12;
       }
     }
     return s0;
   }
-  function peg$parseAttrList() {
+  function peg$parseAttrListReq() {
     let s0, s12, s2, s3, s4, s5, s6, s7;
     s0 = peg$currPos;
     s12 = peg$parse_();
     if (input.charCodeAt(peg$currPos) === 91) {
-      s2 = peg$c3;
+      s2 = peg$c4;
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e3);
+        peg$fail(peg$e4);
       }
     }
     if (s2 !== peg$FAILED) {
@@ -51106,19 +51400,19 @@ function peg$parse(input, options) {
       s4 = peg$parseAttrDefs();
       s5 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 93) {
-        s6 = peg$c4;
+        s6 = peg$c5;
         peg$currPos++;
       } else {
         s6 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e4);
+          peg$fail(peg$e5);
         }
       }
       if (s6 !== peg$FAILED) {
         s7 = peg$parseAttrList();
         if (s7 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f17(s4, s7);
+          s0 = peg$f19(s4, s7);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -51131,49 +51425,17 @@ function peg$parse(input, options) {
       peg$currPos = s0;
       s0 = peg$FAILED;
     }
+    return s0;
+  }
+  function peg$parseAttrList() {
+    let s0, s12;
+    s0 = peg$parseAttrListReq();
     if (s0 === peg$FAILED) {
       s0 = peg$currPos;
-      s12 = peg$parse_();
-      if (input.charCodeAt(peg$currPos) === 91) {
-        s2 = peg$c3;
-        peg$currPos++;
-      } else {
-        s2 = peg$FAILED;
-        if (peg$silentFails === 0) {
-          peg$fail(peg$e3);
-        }
-      }
-      if (s2 !== peg$FAILED) {
-        s3 = peg$parse_();
-        s4 = peg$parseAttrDefs();
-        s5 = peg$parse_();
-        if (input.charCodeAt(peg$currPos) === 93) {
-          s6 = peg$c4;
-          peg$currPos++;
-        } else {
-          s6 = peg$FAILED;
-          if (peg$silentFails === 0) {
-            peg$fail(peg$e4);
-          }
-        }
-        if (s6 !== peg$FAILED) {
-          peg$savedPos = s0;
-          s0 = peg$f18(s4);
-        } else {
-          peg$currPos = s0;
-          s0 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s0;
-        s0 = peg$FAILED;
-      }
-      if (s0 === peg$FAILED) {
-        s0 = peg$currPos;
-        s12 = "";
-        peg$savedPos = s0;
-        s12 = peg$f19();
-        s0 = s12;
-      }
+      s12 = "";
+      peg$savedPos = s0;
+      s12 = peg$f20();
+      s0 = s12;
     }
     return s0;
   }
@@ -51192,7 +51454,7 @@ function peg$parse(input, options) {
       } else {
         s6 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e5);
+          peg$fail(peg$e6);
         }
       }
       if (s6 !== peg$FAILED) {
@@ -51207,7 +51469,7 @@ function peg$parse(input, options) {
         s5 = null;
       }
       peg$savedPos = s2;
-      s2 = peg$f20(s3);
+      s2 = peg$f21(s3);
     } else {
       peg$currPos = s2;
       s2 = peg$FAILED;
@@ -51225,7 +51487,7 @@ function peg$parse(input, options) {
         } else {
           s6 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e5);
+            peg$fail(peg$e6);
           }
         }
         if (s6 !== peg$FAILED) {
@@ -51240,14 +51502,14 @@ function peg$parse(input, options) {
           s5 = null;
         }
         peg$savedPos = s2;
-        s2 = peg$f20(s3);
+        s2 = peg$f21(s3);
       } else {
         peg$currPos = s2;
         s2 = peg$FAILED;
       }
     }
     peg$savedPos = s0;
-    s12 = peg$f21(s12);
+    s12 = peg$f22(s12);
     s0 = s12;
     return s0;
   }
@@ -51258,12 +51520,12 @@ function peg$parse(input, options) {
     if (s12 !== peg$FAILED) {
       s2 = peg$parse_();
       if (input.charCodeAt(peg$currPos) === 61) {
-        s3 = peg$c5;
+        s3 = peg$c3;
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e6);
+          peg$fail(peg$e3);
         }
       }
       if (s3 !== peg$FAILED) {
@@ -51271,7 +51533,7 @@ function peg$parse(input, options) {
         s5 = peg$parseAtom();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f22(s12, s5);
+          s0 = peg$f23(s12, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -51298,7 +51560,7 @@ function peg$parse(input, options) {
         s5 = peg$parseAttrList();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f23(s12, s3, s5);
+          s0 = peg$f24(s12, s3, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -51319,7 +51581,7 @@ function peg$parse(input, options) {
     s12 = peg$parseSubgraph();
     if (s12 !== peg$FAILED) {
       peg$savedPos = s0;
-      s12 = peg$f24(s12);
+      s12 = peg$f25(s12);
     }
     s0 = s12;
     if (s0 === peg$FAILED) {
@@ -51327,7 +51589,7 @@ function peg$parse(input, options) {
       s12 = peg$parseNode();
       if (s12 !== peg$FAILED) {
         peg$savedPos = s0;
-        s12 = peg$f25(s12);
+        s12 = peg$f26(s12);
       }
       s0 = s12;
     }
@@ -51367,7 +51629,7 @@ function peg$parse(input, options) {
             s9 = peg$parseAtom();
             if (s9 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f26(s12, s5, s9);
+              s0 = peg$f27(s12, s5, s9);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -51407,7 +51669,7 @@ function peg$parse(input, options) {
           s5 = peg$parseAtom();
           if (s5 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f27(s12, s5);
+            s0 = peg$f28(s12, s5);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -51425,7 +51687,7 @@ function peg$parse(input, options) {
         s12 = peg$parseAtom();
         if (s12 !== peg$FAILED) {
           peg$savedPos = s0;
-          s12 = peg$f28(s12);
+          s12 = peg$f29(s12);
         }
         s0 = s12;
       }
@@ -51444,7 +51706,7 @@ function peg$parse(input, options) {
         s5 = peg$parseEdgeChain();
         if (s5 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f29(s3, s5);
+          s0 = peg$f30(s3, s5);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -51461,7 +51723,7 @@ function peg$parse(input, options) {
       s0 = peg$currPos;
       s12 = "";
       peg$savedPos = s0;
-      s12 = peg$f30();
+      s12 = peg$f31();
       s0 = s12;
     }
     return s0;
@@ -51532,7 +51794,7 @@ function peg$parse(input, options) {
             }
             if (s9 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f31(s3, s7);
+              s0 = peg$f32(s3, s7);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -51583,7 +51845,7 @@ function peg$parse(input, options) {
             }
             if (s7 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f32(s5);
+              s0 = peg$f33(s5);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -51627,7 +51889,7 @@ function peg$parse(input, options) {
             }
             if (s5 !== peg$FAILED) {
               peg$savedPos = s0;
-              s0 = peg$f33(s3);
+              s0 = peg$f34(s3);
             } else {
               peg$currPos = s0;
               s0 = peg$FAILED;
@@ -51666,7 +51928,7 @@ function peg$parse(input, options) {
         s7 = peg$parseQAtom();
         if (s7 !== peg$FAILED) {
           peg$savedPos = s3;
-          s3 = peg$f34(s12, s7);
+          s3 = peg$f35(s12, s7);
         } else {
           peg$currPos = s3;
           s3 = peg$FAILED;
@@ -51693,7 +51955,7 @@ function peg$parse(input, options) {
           s7 = peg$parseQAtom();
           if (s7 !== peg$FAILED) {
             peg$savedPos = s3;
-            s3 = peg$f34(s12, s7);
+            s3 = peg$f35(s12, s7);
           } else {
             peg$currPos = s3;
             s3 = peg$FAILED;
@@ -51704,7 +51966,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f35(s12, s2);
+      s0 = peg$f36(s12, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -51752,7 +52014,7 @@ function peg$parse(input, options) {
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f36(s2);
+        s0 = peg$f37(s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -51777,7 +52039,7 @@ function peg$parse(input, options) {
     }
     if (s12 !== peg$FAILED) {
       peg$savedPos = s0;
-      s12 = peg$f37();
+      s12 = peg$f38();
     }
     s0 = s12;
     if (s0 === peg$FAILED) {
@@ -51793,7 +52055,7 @@ function peg$parse(input, options) {
       }
       if (s12 !== peg$FAILED) {
         peg$savedPos = s0;
-        s12 = peg$f38();
+        s12 = peg$f39();
       }
       s0 = s12;
       if (s0 === peg$FAILED) {
@@ -51819,7 +52081,7 @@ function peg$parse(input, options) {
           }
           if (s2 !== peg$FAILED) {
             peg$savedPos = s0;
-            s0 = peg$f39(s2);
+            s0 = peg$f40(s2);
           } else {
             peg$currPos = s0;
             s0 = peg$FAILED;
@@ -51868,7 +52130,7 @@ function peg$parse(input, options) {
       }
       if (s3 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f40(s2);
+        s0 = peg$f41(s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -51889,7 +52151,7 @@ function peg$parse(input, options) {
       s2 = peg$parseHtmlChar();
     }
     peg$savedPos = s0;
-    s12 = peg$f41(s12);
+    s12 = peg$f42(s12);
     s0 = s12;
     return s0;
   }
@@ -51919,7 +52181,7 @@ function peg$parse(input, options) {
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f42(s12, s2);
+          s0 = peg$f43(s12, s2);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -51964,7 +52226,7 @@ function peg$parse(input, options) {
         s2 = peg$parseName();
         if (s2 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f43(s2);
+          s0 = peg$f44(s2);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -52012,7 +52274,7 @@ function peg$parse(input, options) {
         }
       }
       peg$savedPos = s0;
-      s0 = peg$f44(s12, s2);
+      s0 = peg$f45(s12, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -52162,70 +52424,7 @@ function peg$parse(input, options) {
       }
     }
     if (s3 !== peg$FAILED) {
-      s4 = peg$currPos;
-      s5 = input.charAt(peg$currPos);
-      if (peg$r6.test(s5)) {
-        peg$currPos++;
-      } else {
-        s5 = peg$FAILED;
-        if (peg$silentFails === 0) {
-          peg$fail(peg$e26);
-        }
-      }
-      if (s5 !== peg$FAILED) {
-        s6 = input.charAt(peg$currPos);
-        if (peg$r7.test(s6)) {
-          peg$currPos++;
-        } else {
-          s6 = peg$FAILED;
-          if (peg$silentFails === 0) {
-            peg$fail(peg$e27);
-          }
-        }
-        if (s6 === peg$FAILED) {
-          s6 = null;
-        }
-        s7 = [];
-        s8 = input.charAt(peg$currPos);
-        if (peg$r5.test(s8)) {
-          peg$currPos++;
-        } else {
-          s8 = peg$FAILED;
-          if (peg$silentFails === 0) {
-            peg$fail(peg$e24);
-          }
-        }
-        if (s8 !== peg$FAILED) {
-          while (s8 !== peg$FAILED) {
-            s7.push(s8);
-            s8 = input.charAt(peg$currPos);
-            if (peg$r5.test(s8)) {
-              peg$currPos++;
-            } else {
-              s8 = peg$FAILED;
-              if (peg$silentFails === 0) {
-                peg$fail(peg$e24);
-              }
-            }
-          }
-        } else {
-          s7 = peg$FAILED;
-        }
-        if (s7 !== peg$FAILED) {
-          s5 = [s5, s6, s7];
-          s4 = s5;
-        } else {
-          peg$currPos = s4;
-          s4 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s4;
-        s4 = peg$FAILED;
-      }
-      if (s4 === peg$FAILED) {
-        s4 = null;
-      }
-      s2 = [s2, s3, s4];
+      s2 = [s2, s3];
       s12 = s2;
     } else {
       peg$currPos = s12;
@@ -52233,7 +52432,7 @@ function peg$parse(input, options) {
     }
     if (s12 !== peg$FAILED) {
       peg$savedPos = s0;
-      s12 = peg$f45(s12);
+      s12 = peg$f46(s12);
     }
     s0 = s12;
     return s0;
@@ -52242,62 +52441,62 @@ function peg$parse(input, options) {
     let s0, s12, s2, s3, s4, s5, s6, s7, s8;
     s0 = peg$currPos;
     s12 = input.charAt(peg$currPos);
-    if (peg$r8.test(s12)) {
+    if (peg$r6.test(s12)) {
       peg$currPos++;
     } else {
       s12 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e28);
+        peg$fail(peg$e26);
       }
     }
     if (s12 !== peg$FAILED) {
       s2 = input.charAt(peg$currPos);
-      if (peg$r9.test(s2)) {
+      if (peg$r7.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e29);
+          peg$fail(peg$e27);
         }
       }
       if (s2 !== peg$FAILED) {
         s3 = input.charAt(peg$currPos);
-        if (peg$r10.test(s3)) {
+        if (peg$r8.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e30);
+            peg$fail(peg$e28);
           }
         }
         if (s3 !== peg$FAILED) {
           s4 = input.charAt(peg$currPos);
-          if (peg$r11.test(s4)) {
+          if (peg$r9.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e31);
+              peg$fail(peg$e29);
             }
           }
           if (s4 !== peg$FAILED) {
             s5 = input.charAt(peg$currPos);
-            if (peg$r12.test(s5)) {
+            if (peg$r10.test(s5)) {
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
               if (peg$silentFails === 0) {
-                peg$fail(peg$e32);
+                peg$fail(peg$e30);
               }
             }
             if (s5 !== peg$FAILED) {
               s6 = input.charAt(peg$currPos);
-              if (peg$r9.test(s6)) {
+              if (peg$r7.test(s6)) {
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
                 if (peg$silentFails === 0) {
-                  peg$fail(peg$e29);
+                  peg$fail(peg$e27);
                 }
               }
               if (s6 !== peg$FAILED) {
@@ -52348,52 +52547,52 @@ function peg$parse(input, options) {
     let s0, s12, s2, s3, s4, s5, s6, s7;
     s0 = peg$currPos;
     s12 = input.charAt(peg$currPos);
-    if (peg$r13.test(s12)) {
+    if (peg$r11.test(s12)) {
       peg$currPos++;
     } else {
       s12 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e33);
+        peg$fail(peg$e31);
       }
     }
     if (s12 !== peg$FAILED) {
       s2 = input.charAt(peg$currPos);
-      if (peg$r10.test(s2)) {
+      if (peg$r8.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e30);
+          peg$fail(peg$e28);
         }
       }
       if (s2 !== peg$FAILED) {
         s3 = input.charAt(peg$currPos);
-        if (peg$r14.test(s3)) {
+        if (peg$r12.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e34);
+            peg$fail(peg$e32);
           }
         }
         if (s3 !== peg$FAILED) {
           s4 = input.charAt(peg$currPos);
-          if (peg$r15.test(s4)) {
+          if (peg$r13.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e35);
+              peg$fail(peg$e33);
             }
           }
           if (s4 !== peg$FAILED) {
             s5 = input.charAt(peg$currPos);
-            if (peg$r16.test(s5)) {
+            if (peg$r14.test(s5)) {
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
               if (peg$silentFails === 0) {
-                peg$fail(peg$e36);
+                peg$fail(peg$e34);
               }
             }
             if (s5 !== peg$FAILED) {
@@ -52440,72 +52639,72 @@ function peg$parse(input, options) {
     let s0, s12, s2, s3, s4, s5, s6, s7, s8, s9;
     s0 = peg$currPos;
     s12 = input.charAt(peg$currPos);
-    if (peg$r17.test(s12)) {
+    if (peg$r15.test(s12)) {
       peg$currPos++;
     } else {
       s12 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e37);
+        peg$fail(peg$e35);
       }
     }
     if (s12 !== peg$FAILED) {
       s2 = input.charAt(peg$currPos);
-      if (peg$r11.test(s2)) {
+      if (peg$r9.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e31);
+          peg$fail(peg$e29);
         }
       }
       if (s2 !== peg$FAILED) {
         s3 = input.charAt(peg$currPos);
-        if (peg$r13.test(s3)) {
+        if (peg$r11.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e33);
+            peg$fail(peg$e31);
           }
         }
         if (s3 !== peg$FAILED) {
           s4 = input.charAt(peg$currPos);
-          if (peg$r10.test(s4)) {
+          if (peg$r8.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e30);
+              peg$fail(peg$e28);
             }
           }
           if (s4 !== peg$FAILED) {
             s5 = input.charAt(peg$currPos);
-            if (peg$r14.test(s5)) {
+            if (peg$r12.test(s5)) {
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
               if (peg$silentFails === 0) {
-                peg$fail(peg$e34);
+                peg$fail(peg$e32);
               }
             }
             if (s5 !== peg$FAILED) {
               s6 = input.charAt(peg$currPos);
-              if (peg$r15.test(s6)) {
+              if (peg$r13.test(s6)) {
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
                 if (peg$silentFails === 0) {
-                  peg$fail(peg$e35);
+                  peg$fail(peg$e33);
                 }
               }
               if (s6 !== peg$FAILED) {
                 s7 = input.charAt(peg$currPos);
-                if (peg$r16.test(s7)) {
+                if (peg$r14.test(s7)) {
                   peg$currPos++;
                 } else {
                   s7 = peg$FAILED;
                   if (peg$silentFails === 0) {
-                    peg$fail(peg$e36);
+                    peg$fail(peg$e34);
                   }
                 }
                 if (s7 !== peg$FAILED) {
@@ -52560,42 +52759,42 @@ function peg$parse(input, options) {
     let s0, s12, s2, s3, s4, s5, s6;
     s0 = peg$currPos;
     s12 = input.charAt(peg$currPos);
-    if (peg$r18.test(s12)) {
+    if (peg$r16.test(s12)) {
       peg$currPos++;
     } else {
       s12 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e38);
+        peg$fail(peg$e36);
       }
     }
     if (s12 !== peg$FAILED) {
       s2 = input.charAt(peg$currPos);
-      if (peg$r19.test(s2)) {
+      if (peg$r17.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e39);
+          peg$fail(peg$e37);
         }
       }
       if (s2 !== peg$FAILED) {
         s3 = input.charAt(peg$currPos);
-        if (peg$r17.test(s3)) {
+        if (peg$r15.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e37);
+            peg$fail(peg$e35);
           }
         }
         if (s3 !== peg$FAILED) {
           s4 = input.charAt(peg$currPos);
-          if (peg$r20.test(s4)) {
+          if (peg$r18.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e40);
+              peg$fail(peg$e38);
             }
           }
           if (s4 !== peg$FAILED) {
@@ -52638,42 +52837,42 @@ function peg$parse(input, options) {
     let s0, s12, s2, s3, s4, s5, s6;
     s0 = peg$currPos;
     s12 = input.charAt(peg$currPos);
-    if (peg$r20.test(s12)) {
+    if (peg$r18.test(s12)) {
       peg$currPos++;
     } else {
       s12 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e40);
+        peg$fail(peg$e38);
       }
     }
     if (s12 !== peg$FAILED) {
       s2 = input.charAt(peg$currPos);
-      if (peg$r17.test(s2)) {
+      if (peg$r15.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e37);
+          peg$fail(peg$e35);
         }
       }
       if (s2 !== peg$FAILED) {
         s3 = input.charAt(peg$currPos);
-        if (peg$r13.test(s3)) {
+        if (peg$r11.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e33);
+            peg$fail(peg$e31);
           }
         }
         if (s3 !== peg$FAILED) {
           s4 = input.charAt(peg$currPos);
-          if (peg$r20.test(s4)) {
+          if (peg$r18.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e40);
+              peg$fail(peg$e38);
             }
           }
           if (s4 !== peg$FAILED) {
@@ -52716,82 +52915,82 @@ function peg$parse(input, options) {
     let s0, s12, s2, s3, s4, s5, s6, s7, s8, s9, s10;
     s0 = peg$currPos;
     s12 = input.charAt(peg$currPos);
-    if (peg$r8.test(s12)) {
+    if (peg$r6.test(s12)) {
       peg$currPos++;
     } else {
       s12 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e28);
+        peg$fail(peg$e26);
       }
     }
     if (s12 !== peg$FAILED) {
       s2 = input.charAt(peg$currPos);
-      if (peg$r21.test(s2)) {
+      if (peg$r19.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e41);
+          peg$fail(peg$e39);
         }
       }
       if (s2 !== peg$FAILED) {
         s3 = input.charAt(peg$currPos);
-        if (peg$r22.test(s3)) {
+        if (peg$r20.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e42);
+            peg$fail(peg$e40);
           }
         }
         if (s3 !== peg$FAILED) {
           s4 = input.charAt(peg$currPos);
-          if (peg$r13.test(s4)) {
+          if (peg$r11.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e33);
+              peg$fail(peg$e31);
             }
           }
           if (s4 !== peg$FAILED) {
             s5 = input.charAt(peg$currPos);
-            if (peg$r10.test(s5)) {
+            if (peg$r8.test(s5)) {
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
               if (peg$silentFails === 0) {
-                peg$fail(peg$e30);
+                peg$fail(peg$e28);
               }
             }
             if (s5 !== peg$FAILED) {
               s6 = input.charAt(peg$currPos);
-              if (peg$r14.test(s6)) {
+              if (peg$r12.test(s6)) {
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
                 if (peg$silentFails === 0) {
-                  peg$fail(peg$e34);
+                  peg$fail(peg$e32);
                 }
               }
               if (s6 !== peg$FAILED) {
                 s7 = input.charAt(peg$currPos);
-                if (peg$r15.test(s7)) {
+                if (peg$r13.test(s7)) {
                   peg$currPos++;
                 } else {
                   s7 = peg$FAILED;
                   if (peg$silentFails === 0) {
-                    peg$fail(peg$e35);
+                    peg$fail(peg$e33);
                   }
                 }
                 if (s7 !== peg$FAILED) {
                   s8 = input.charAt(peg$currPos);
-                  if (peg$r16.test(s8)) {
+                  if (peg$r14.test(s8)) {
                     peg$currPos++;
                   } else {
                     s8 = peg$FAILED;
                     if (peg$silentFails === 0) {
-                      peg$fail(peg$e36);
+                      peg$fail(peg$e34);
                     }
                   }
                   if (s8 !== peg$FAILED) {
@@ -52864,62 +53063,62 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s12 = peg$currPos;
     s2 = input.charAt(peg$currPos);
-    if (peg$r8.test(s2)) {
+    if (peg$r6.test(s2)) {
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e28);
+        peg$fail(peg$e26);
       }
     }
     if (s2 !== peg$FAILED) {
       s3 = input.charAt(peg$currPos);
-      if (peg$r9.test(s3)) {
+      if (peg$r7.test(s3)) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e29);
+          peg$fail(peg$e27);
         }
       }
       if (s3 !== peg$FAILED) {
         s4 = input.charAt(peg$currPos);
-        if (peg$r10.test(s4)) {
+        if (peg$r8.test(s4)) {
           peg$currPos++;
         } else {
           s4 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e30);
+            peg$fail(peg$e28);
           }
         }
         if (s4 !== peg$FAILED) {
           s5 = input.charAt(peg$currPos);
-          if (peg$r11.test(s5)) {
+          if (peg$r9.test(s5)) {
             peg$currPos++;
           } else {
             s5 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e31);
+              peg$fail(peg$e29);
             }
           }
           if (s5 !== peg$FAILED) {
             s6 = input.charAt(peg$currPos);
-            if (peg$r12.test(s6)) {
+            if (peg$r10.test(s6)) {
               peg$currPos++;
             } else {
               s6 = peg$FAILED;
               if (peg$silentFails === 0) {
-                peg$fail(peg$e32);
+                peg$fail(peg$e30);
               }
             }
             if (s6 !== peg$FAILED) {
               s7 = input.charAt(peg$currPos);
-              if (peg$r9.test(s7)) {
+              if (peg$r7.test(s7)) {
                 peg$currPos++;
               } else {
                 s7 = peg$FAILED;
                 if (peg$silentFails === 0) {
-                  peg$fail(peg$e29);
+                  peg$fail(peg$e27);
                 }
               }
               if (s7 !== peg$FAILED) {
@@ -52952,72 +53151,72 @@ function peg$parse(input, options) {
     if (s12 === peg$FAILED) {
       s12 = peg$currPos;
       s2 = input.charAt(peg$currPos);
-      if (peg$r17.test(s2)) {
+      if (peg$r15.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e37);
+          peg$fail(peg$e35);
         }
       }
       if (s2 !== peg$FAILED) {
         s3 = input.charAt(peg$currPos);
-        if (peg$r11.test(s3)) {
+        if (peg$r9.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e31);
+            peg$fail(peg$e29);
           }
         }
         if (s3 !== peg$FAILED) {
           s4 = input.charAt(peg$currPos);
-          if (peg$r13.test(s4)) {
+          if (peg$r11.test(s4)) {
             peg$currPos++;
           } else {
             s4 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e33);
+              peg$fail(peg$e31);
             }
           }
           if (s4 !== peg$FAILED) {
             s5 = input.charAt(peg$currPos);
-            if (peg$r10.test(s5)) {
+            if (peg$r8.test(s5)) {
               peg$currPos++;
             } else {
               s5 = peg$FAILED;
               if (peg$silentFails === 0) {
-                peg$fail(peg$e30);
+                peg$fail(peg$e28);
               }
             }
             if (s5 !== peg$FAILED) {
               s6 = input.charAt(peg$currPos);
-              if (peg$r14.test(s6)) {
+              if (peg$r12.test(s6)) {
                 peg$currPos++;
               } else {
                 s6 = peg$FAILED;
                 if (peg$silentFails === 0) {
-                  peg$fail(peg$e34);
+                  peg$fail(peg$e32);
                 }
               }
               if (s6 !== peg$FAILED) {
                 s7 = input.charAt(peg$currPos);
-                if (peg$r15.test(s7)) {
+                if (peg$r13.test(s7)) {
                   peg$currPos++;
                 } else {
                   s7 = peg$FAILED;
                   if (peg$silentFails === 0) {
-                    peg$fail(peg$e35);
+                    peg$fail(peg$e33);
                   }
                 }
                 if (s7 !== peg$FAILED) {
                   s8 = input.charAt(peg$currPos);
-                  if (peg$r16.test(s8)) {
+                  if (peg$r14.test(s8)) {
                     peg$currPos++;
                   } else {
                     s8 = peg$FAILED;
                     if (peg$silentFails === 0) {
-                      peg$fail(peg$e36);
+                      peg$fail(peg$e34);
                     }
                   }
                   if (s8 !== peg$FAILED) {
@@ -53054,52 +53253,52 @@ function peg$parse(input, options) {
       if (s12 === peg$FAILED) {
         s12 = peg$currPos;
         s2 = input.charAt(peg$currPos);
-        if (peg$r13.test(s2)) {
+        if (peg$r11.test(s2)) {
           peg$currPos++;
         } else {
           s2 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e33);
+            peg$fail(peg$e31);
           }
         }
         if (s2 !== peg$FAILED) {
           s3 = input.charAt(peg$currPos);
-          if (peg$r10.test(s3)) {
+          if (peg$r8.test(s3)) {
             peg$currPos++;
           } else {
             s3 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e30);
+              peg$fail(peg$e28);
             }
           }
           if (s3 !== peg$FAILED) {
             s4 = input.charAt(peg$currPos);
-            if (peg$r14.test(s4)) {
+            if (peg$r12.test(s4)) {
               peg$currPos++;
             } else {
               s4 = peg$FAILED;
               if (peg$silentFails === 0) {
-                peg$fail(peg$e34);
+                peg$fail(peg$e32);
               }
             }
             if (s4 !== peg$FAILED) {
               s5 = input.charAt(peg$currPos);
-              if (peg$r15.test(s5)) {
+              if (peg$r13.test(s5)) {
                 peg$currPos++;
               } else {
                 s5 = peg$FAILED;
                 if (peg$silentFails === 0) {
-                  peg$fail(peg$e35);
+                  peg$fail(peg$e33);
                 }
               }
               if (s5 !== peg$FAILED) {
                 s6 = input.charAt(peg$currPos);
-                if (peg$r16.test(s6)) {
+                if (peg$r14.test(s6)) {
                   peg$currPos++;
                 } else {
                   s6 = peg$FAILED;
                   if (peg$silentFails === 0) {
-                    peg$fail(peg$e36);
+                    peg$fail(peg$e34);
                   }
                 }
                 if (s6 !== peg$FAILED) {
@@ -53128,42 +53327,42 @@ function peg$parse(input, options) {
         if (s12 === peg$FAILED) {
           s12 = peg$currPos;
           s2 = input.charAt(peg$currPos);
-          if (peg$r18.test(s2)) {
+          if (peg$r16.test(s2)) {
             peg$currPos++;
           } else {
             s2 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e38);
+              peg$fail(peg$e36);
             }
           }
           if (s2 !== peg$FAILED) {
             s3 = input.charAt(peg$currPos);
-            if (peg$r19.test(s3)) {
+            if (peg$r17.test(s3)) {
               peg$currPos++;
             } else {
               s3 = peg$FAILED;
               if (peg$silentFails === 0) {
-                peg$fail(peg$e39);
+                peg$fail(peg$e37);
               }
             }
             if (s3 !== peg$FAILED) {
               s4 = input.charAt(peg$currPos);
-              if (peg$r17.test(s4)) {
+              if (peg$r15.test(s4)) {
                 peg$currPos++;
               } else {
                 s4 = peg$FAILED;
                 if (peg$silentFails === 0) {
-                  peg$fail(peg$e37);
+                  peg$fail(peg$e35);
                 }
               }
               if (s4 !== peg$FAILED) {
                 s5 = input.charAt(peg$currPos);
-                if (peg$r20.test(s5)) {
+                if (peg$r18.test(s5)) {
                   peg$currPos++;
                 } else {
                   s5 = peg$FAILED;
                   if (peg$silentFails === 0) {
-                    peg$fail(peg$e40);
+                    peg$fail(peg$e38);
                   }
                 }
                 if (s5 !== peg$FAILED) {
@@ -53188,42 +53387,42 @@ function peg$parse(input, options) {
           if (s12 === peg$FAILED) {
             s12 = peg$currPos;
             s2 = input.charAt(peg$currPos);
-            if (peg$r20.test(s2)) {
+            if (peg$r18.test(s2)) {
               peg$currPos++;
             } else {
               s2 = peg$FAILED;
               if (peg$silentFails === 0) {
-                peg$fail(peg$e40);
+                peg$fail(peg$e38);
               }
             }
             if (s2 !== peg$FAILED) {
               s3 = input.charAt(peg$currPos);
-              if (peg$r17.test(s3)) {
+              if (peg$r15.test(s3)) {
                 peg$currPos++;
               } else {
                 s3 = peg$FAILED;
                 if (peg$silentFails === 0) {
-                  peg$fail(peg$e37);
+                  peg$fail(peg$e35);
                 }
               }
               if (s3 !== peg$FAILED) {
                 s4 = input.charAt(peg$currPos);
-                if (peg$r13.test(s4)) {
+                if (peg$r11.test(s4)) {
                   peg$currPos++;
                 } else {
                   s4 = peg$FAILED;
                   if (peg$silentFails === 0) {
-                    peg$fail(peg$e33);
+                    peg$fail(peg$e31);
                   }
                 }
                 if (s4 !== peg$FAILED) {
                   s5 = input.charAt(peg$currPos);
-                  if (peg$r20.test(s5)) {
+                  if (peg$r18.test(s5)) {
                     peg$currPos++;
                   } else {
                     s5 = peg$FAILED;
                     if (peg$silentFails === 0) {
-                      peg$fail(peg$e40);
+                      peg$fail(peg$e38);
                     }
                   }
                   if (s5 !== peg$FAILED) {
@@ -53248,82 +53447,82 @@ function peg$parse(input, options) {
             if (s12 === peg$FAILED) {
               s12 = peg$currPos;
               s2 = input.charAt(peg$currPos);
-              if (peg$r8.test(s2)) {
+              if (peg$r6.test(s2)) {
                 peg$currPos++;
               } else {
                 s2 = peg$FAILED;
                 if (peg$silentFails === 0) {
-                  peg$fail(peg$e28);
+                  peg$fail(peg$e26);
                 }
               }
               if (s2 !== peg$FAILED) {
                 s3 = input.charAt(peg$currPos);
-                if (peg$r21.test(s3)) {
+                if (peg$r19.test(s3)) {
                   peg$currPos++;
                 } else {
                   s3 = peg$FAILED;
                   if (peg$silentFails === 0) {
-                    peg$fail(peg$e41);
+                    peg$fail(peg$e39);
                   }
                 }
                 if (s3 !== peg$FAILED) {
                   s4 = input.charAt(peg$currPos);
-                  if (peg$r22.test(s4)) {
+                  if (peg$r20.test(s4)) {
                     peg$currPos++;
                   } else {
                     s4 = peg$FAILED;
                     if (peg$silentFails === 0) {
-                      peg$fail(peg$e42);
+                      peg$fail(peg$e40);
                     }
                   }
                   if (s4 !== peg$FAILED) {
                     s5 = input.charAt(peg$currPos);
-                    if (peg$r13.test(s5)) {
+                    if (peg$r11.test(s5)) {
                       peg$currPos++;
                     } else {
                       s5 = peg$FAILED;
                       if (peg$silentFails === 0) {
-                        peg$fail(peg$e33);
+                        peg$fail(peg$e31);
                       }
                     }
                     if (s5 !== peg$FAILED) {
                       s6 = input.charAt(peg$currPos);
-                      if (peg$r10.test(s6)) {
+                      if (peg$r8.test(s6)) {
                         peg$currPos++;
                       } else {
                         s6 = peg$FAILED;
                         if (peg$silentFails === 0) {
-                          peg$fail(peg$e30);
+                          peg$fail(peg$e28);
                         }
                       }
                       if (s6 !== peg$FAILED) {
                         s7 = input.charAt(peg$currPos);
-                        if (peg$r14.test(s7)) {
+                        if (peg$r12.test(s7)) {
                           peg$currPos++;
                         } else {
                           s7 = peg$FAILED;
                           if (peg$silentFails === 0) {
-                            peg$fail(peg$e34);
+                            peg$fail(peg$e32);
                           }
                         }
                         if (s7 !== peg$FAILED) {
                           s8 = input.charAt(peg$currPos);
-                          if (peg$r15.test(s8)) {
+                          if (peg$r13.test(s8)) {
                             peg$currPos++;
                           } else {
                             s8 = peg$FAILED;
                             if (peg$silentFails === 0) {
-                              peg$fail(peg$e35);
+                              peg$fail(peg$e33);
                             }
                           }
                           if (s8 !== peg$FAILED) {
                             s9 = input.charAt(peg$currPos);
-                            if (peg$r16.test(s9)) {
+                            if (peg$r14.test(s9)) {
                               peg$currPos++;
                             } else {
                               s9 = peg$FAILED;
                               if (peg$silentFails === 0) {
-                                peg$fail(peg$e36);
+                                peg$fail(peg$e34);
                               }
                             }
                             if (s9 !== peg$FAILED) {
@@ -53395,24 +53594,24 @@ function peg$parse(input, options) {
     s0 = [];
     s12 = [];
     s2 = input.charAt(peg$currPos);
-    if (peg$r23.test(s2)) {
+    if (peg$r21.test(s2)) {
       peg$currPos++;
     } else {
       s2 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e43);
+        peg$fail(peg$e41);
       }
     }
     if (s2 !== peg$FAILED) {
       while (s2 !== peg$FAILED) {
         s12.push(s2);
         s2 = input.charAt(peg$currPos);
-        if (peg$r23.test(s2)) {
+        if (peg$r21.test(s2)) {
           peg$currPos++;
         } else {
           s2 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e43);
+            peg$fail(peg$e41);
           }
         }
       }
@@ -53432,24 +53631,24 @@ function peg$parse(input, options) {
       s0.push(s12);
       s12 = [];
       s2 = input.charAt(peg$currPos);
-      if (peg$r23.test(s2)) {
+      if (peg$r21.test(s2)) {
         peg$currPos++;
       } else {
         s2 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e43);
+          peg$fail(peg$e41);
         }
       }
       if (s2 !== peg$FAILED) {
         while (s2 !== peg$FAILED) {
           s12.push(s2);
           s2 = input.charAt(peg$currPos);
-          if (peg$r23.test(s2)) {
+          if (peg$r21.test(s2)) {
             peg$currPos++;
           } else {
             s2 = peg$FAILED;
             if (peg$silentFails === 0) {
-              peg$fail(peg$e43);
+              peg$fail(peg$e41);
             }
           }
         }
@@ -53477,7 +53676,7 @@ function peg$parse(input, options) {
     } else {
       s12 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e44);
+        peg$fail(peg$e42);
       }
     }
     if (s12 !== peg$FAILED) {
@@ -53491,7 +53690,7 @@ function peg$parse(input, options) {
       } else {
         s5 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e45);
+          peg$fail(peg$e43);
         }
       }
       peg$silentFails--;
@@ -53533,7 +53732,7 @@ function peg$parse(input, options) {
         } else {
           s5 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e45);
+            peg$fail(peg$e43);
           }
         }
         peg$silentFails--;
@@ -53571,7 +53770,7 @@ function peg$parse(input, options) {
       } else {
         s3 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e45);
+          peg$fail(peg$e43);
         }
       }
       if (s3 !== peg$FAILED) {
@@ -53596,29 +53795,29 @@ function peg$parse(input, options) {
     } else {
       s12 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e46);
+        peg$fail(peg$e44);
       }
     }
     if (s12 !== peg$FAILED) {
       s2 = [];
       s3 = input.charAt(peg$currPos);
-      if (peg$r24.test(s3)) {
+      if (peg$r22.test(s3)) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e47);
+          peg$fail(peg$e45);
         }
       }
       while (s3 !== peg$FAILED) {
         s2.push(s3);
         s3 = input.charAt(peg$currPos);
-        if (peg$r24.test(s3)) {
+        if (peg$r22.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e47);
+            peg$fail(peg$e45);
           }
         }
       }
@@ -53628,7 +53827,7 @@ function peg$parse(input, options) {
       } else {
         s3 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e48);
+          peg$fail(peg$e46);
         }
       }
       if (s3 === peg$FAILED) {
@@ -53673,29 +53872,29 @@ function peg$parse(input, options) {
     } else {
       s12 = peg$FAILED;
       if (peg$silentFails === 0) {
-        peg$fail(peg$e49);
+        peg$fail(peg$e47);
       }
     }
     if (s12 !== peg$FAILED) {
       s2 = [];
       s3 = input.charAt(peg$currPos);
-      if (peg$r24.test(s3)) {
+      if (peg$r22.test(s3)) {
         peg$currPos++;
       } else {
         s3 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e47);
+          peg$fail(peg$e45);
         }
       }
       while (s3 !== peg$FAILED) {
         s2.push(s3);
         s3 = input.charAt(peg$currPos);
-        if (peg$r24.test(s3)) {
+        if (peg$r22.test(s3)) {
           peg$currPos++;
         } else {
           s3 = peg$FAILED;
           if (peg$silentFails === 0) {
-            peg$fail(peg$e47);
+            peg$fail(peg$e45);
           }
         }
       }
@@ -53705,7 +53904,7 @@ function peg$parse(input, options) {
       } else {
         s3 = peg$FAILED;
         if (peg$silentFails === 0) {
-          peg$fail(peg$e48);
+          peg$fail(peg$e46);
         }
       }
       if (s3 === peg$FAILED) {
@@ -54068,6 +54267,75 @@ function buildFromAst(ast) {
   return graph;
 }
 
+// src/parser/number-scan.ts
+var ASCII_DEL = 127;
+function isLetter(c) {
+  if (c === void 0) return false;
+  return c >= "A" && c <= "Z" || c >= "a" && c <= "z" || c === "_" || c.charCodeAt(0) > ASCII_DEL;
+}
+function isDigit(c) {
+  return c !== void 0 && c >= "0" && c <= "9";
+}
+function startsNumber(s, i) {
+  const c = s[i];
+  if (isDigit(c)) return true;
+  if (c === ".") return isDigit(s[i + 1]);
+  if (c !== "-") return false;
+  return isDigit(s[i + 1]) || s[i + 1] === "." && isDigit(s[i + 2]);
+}
+function matchNumber(s, i) {
+  let j = s[i] === "-" ? i + 1 : i;
+  if (s[j] === ".") {
+    j++;
+    while (isDigit(s[j])) j++;
+  } else {
+    while (isDigit(s[j])) j++;
+    if (s[j] === ".") {
+      j++;
+      while (isDigit(s[j])) j++;
+    }
+  }
+  if (s[j] === "." || isLetter(s[j])) j++;
+  return j;
+}
+function twoDots(text) {
+  const dot = text.indexOf(".");
+  return dot !== -1 && dot !== text.length - 1;
+}
+function chkNum(text) {
+  const c = text[text.length - 1];
+  return !isDigit(c) && c !== "." || c === "." && twoDots(text);
+}
+function lexToken(s, i) {
+  if (isLetter(s[i])) {
+    let j2 = i + 1;
+    while (isLetter(s[j2]) || isDigit(s[j2])) j2++;
+    return { next: j2, bad: null };
+  }
+  if (s[i] === "-" && (s[i + 1] === "-" || s[i + 1] === ">")) return { next: i + 2, bad: null };
+  if (!startsNumber(s, i)) return { next: i + 1, bad: null };
+  const j = matchNumber(s, i);
+  const text = s.slice(i, j);
+  return chkNum(text) ? { next: j - 1, bad: text } : { next: j, bad: null };
+}
+function scanNumberAmbiguities(src, stripped) {
+  const out = [];
+  let line = 1;
+  let lineAt = 0;
+  for (let i = 0; i < stripped.length; ) {
+    const { next, bad } = lexToken(stripped, i);
+    if (bad !== null) {
+      for (; lineAt < i; lineAt++) if (src[lineAt] === "\n") line++;
+      out.push({ text: bad, line, offset: i });
+    }
+    i = next;
+  }
+  return out;
+}
+function numberAmbiguityMessage(a) {
+  return `Warning: syntax ambiguity - badly delimited number '${a.text}' in line ${a.line} of input splits into two tokens`;
+}
+
 // src/parser/index.ts
 var ParseError = class extends DotEngineError {
   type = "syntax";
@@ -54227,6 +54495,12 @@ function isPeggyError(err) {
   if (typeof e["location"] !== "object" || e["location"] === null) return false;
   return "start" in e["location"];
 }
+function warnNumberAmbiguities(src, upTo) {
+  for (const a of scanNumberAmbiguities(src, Stripper.strip(src))) {
+    if (a.offset > upTo) break;
+    console.error(numberAmbiguityMessage(a));
+  }
+}
 function parse(src) {
   if (typeof src !== "string") {
     throw invalidArgType("dotSource", "string", src);
@@ -54237,6 +54511,7 @@ function parse(src) {
   } catch (err) {
     if (isPeggyError(err)) {
       const start = err.location.start;
+      warnNumberAmbiguities(src, start.offset);
       const code = err.found === null ? "SYNTAX_UNEXPECTED_EOF" : "SYNTAX_ERROR";
       throw new ParseError(
         err instanceof Error ? err.message : String(err),
@@ -54254,6 +54529,7 @@ function parse(src) {
     }
     throw err;
   }
+  warnNumberAmbiguities(src, src.length);
   validateEdgeOperators(src, ast.directed);
   return buildFromAst(ast);
 }
@@ -54262,6 +54538,7 @@ function parse(src) {
 var XDOT_PARSE_ERROR = 1;
 
 // src/xdot/parse.ts
+var ULONG_MAX = 0xffffffffffffffffn;
 var XdotParser = class _XdotParser {
   static isWs(c) {
     return c === " " || c === "	" || c === "\n" || c === "\r";
@@ -54305,12 +54582,23 @@ var XdotParser = class _XdotParser {
     if (i === digStart) return null;
     return { val: parseInt(s.slice(start, i), 10), pos: i };
   }
+  /**
+   * strtoul(s, &endp, 10) cast to unsigned int: optional sign, a leading "-"
+   * negates modulo 2^64, magnitude overflow saturates to ULONG_MAX, and the
+   * result keeps the low 32 bits.
+   * @see lib/xdot/xdot.c:parseUInt
+   */
   static parseUInt_(s, pos) {
     const i = _XdotParser.skipWs(s, pos);
-    const start = i;
-    const end = _XdotParser.consumeDigits(s, i);
+    let start = i;
+    const negative = i < s.length && s[i] === "-";
+    if (i < s.length && (s[i] === "-" || s[i] === "+")) start++;
+    const end = _XdotParser.consumeDigits(s, start);
     if (end === start) return null;
-    return { val: parseInt(s.slice(start, end), 10), pos: end };
+    const mag = BigInt(s.slice(start, end));
+    const clamped = mag > ULONG_MAX ? ULONG_MAX : mag;
+    const wrapped = negative && mag <= ULONG_MAX ? BigInt.asUintN(64, -clamped) : clamped;
+    return { val: Number(BigInt.asUintN(32, wrapped)), pos: end };
   }
   static parseRect(s, pos) {
     const rx = _XdotParser.parseReal(s, pos);
@@ -54407,7 +54695,7 @@ var XdotParser = class _XdotParser {
     if (!rx1) return null;
     const ry1 = _XdotParser.parseReal(s, rx1.pos);
     if (!ry1) return null;
-    const rn = _XdotParser.parseInt_(s, ry1.pos);
+    const rn = _XdotParser.parseUInt_(s, ry1.pos);
     if (!rn) return null;
     const rs = _XdotParser.parseStops(s, rn.pos, rn.val);
     if (!rs) return null;
@@ -54426,7 +54714,7 @@ var XdotParser = class _XdotParser {
     if (!ry1) return null;
     const rr1 = _XdotParser.parseReal(s, ry1.pos);
     if (!rr1) return null;
-    const rn = _XdotParser.parseInt_(s, rr1.pos);
+    const rn = _XdotParser.parseUInt_(s, rr1.pos);
     if (!rn) return null;
     const rs = _XdotParser.parseStops(s, rn.pos, rn.val);
     if (!rs) return null;