@knowvah/dot-engine 2.6.12 → 2.7.0

package/dist/render.js

@@ -1,3 +1,12 @@
+// src/common/render-state.ts
+var resets = [];
+function registerRenderState(reset2) {
+  resets.push(reset2);
+}
+function resetRenderState() {
+  for (const reset2 of resets) reset2();
+}
+
 // src/errors.ts
 var FRIENDLY_MESSAGES = {
   SYNTAX_ERROR: "There is a syntax error in the DOT source.",
@@ -214,6 +223,12 @@ var GvcContext = class {
    * rendering happens in between and must see the layout state
    * (e.g. cluster arrays).
    *
+   * Contract (AD-4/AD-8): first resets the C process state (RNG streams,
+   * sequence counters, once-only warnings), so each `layout` call behaves
+   * as one native run — drive one graph per `layout`. Caller-installed hooks
+   * (setTextMeasurer, setImageSizer, setImageResolver, the per-context
+   * measurer/sizer/resolver) are configuration and are not reset.
+   *
    * @throws TypeError (ERR_INVALID_ARG_TYPE / ERR_INVALID_ARG_VALUE) for a
    *   bad `g`, or an engine argument that is not registered
    * @throws RenderError (UNKNOWN_LAYOUT) if the `layout` attribute names no
@@ -224,6 +239,7 @@ var GvcContext = class {
    * @see lib/gvc/gvlayout.c:gvLayoutJobs
    */
   layout(g, engineName) {
+    resetRenderState();
     const selected = this.checkLayoutArgs(g, engineName);
     const attr2 = g.attrs?.get("layout");
     let engine = selected;
@@ -5079,15 +5095,6 @@ var ALL_FONT_METRICS = [
   CALIBRI_FAMILY
 ];
 
-// src/common/render-state.ts
-var resets = [];
-function registerRenderState(reset2) {
-  resets.push(reset2);
-}
-function resetRenderState() {
-  for (const reset2 of resets) reset2();
-}
-
 // src/common/agerr.ts
 var PREFIX_ERROR = "Error";
 var PREFIX_WARNING = "Warning";
@@ -5152,7 +5159,7 @@ function getFamilyMetrics(fontName) {
   if (!warnedFontNames.has(fontName)) {
     warnedFontNames.add(fontName);
     agwarningf(
-      `no hard-coded metrics for '${fontName}'.  Falling back to 'Times' metrics`
+      `Warning: no hard-coded metrics for '${fontName}'.  Falling back to 'Times' metrics`
     );
   }
   return TIMES_FALLBACK;
@@ -6286,9 +6293,15 @@ function scanCdata(text, p, base, dataOf, tokens) {
   if (end > p) tokens.push({ kind: "cdata", start: base + p, end: base + end, data: dataOf(base + p, base + end) });
   return close < 0 ? -1 : close + CDATA_CLOSE.length;
 }
+var CONTENT_NON_XML = /[\x00-\x08\x0b\x0c\x0e-\x1f\ufffe\uffff]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/;
 function scanText(text, p, base, tokens) {
   const e = text.indexOf("<", p);
   const slice = text.slice(p, e < 0 ? text.length : e);
+  const bad = CONTENT_NON_XML.exec(slice)?.index;
+  if (bad !== void 0) {
+    if (bad > 0) tokens.push({ kind: "text", start: base + p, end: base + p + bad });
+    return { at: p + bad, held: false, invalid: p + bad };
+  }
   const from = e < 0 ? heldRefStart(slice) : void 0;
   const end = from === void 0 ? p + slice.length : p + from;
   if (end > p) tokens.push({ kind: "text", start: base + p, end: base + end });
@@ -6308,6 +6321,7 @@ function scanContent(text, base, inCdata, dataOf) {
     }
     if (text[p] !== "<") {
       const scanned = scanText(text, p, base, tokens);
+      if (scanned.invalid !== void 0) return { tokens, consumed: scanned.at, invalid: base + scanned.invalid, inCdata: false };
       if (scanned.held) return { tokens, consumed: scanned.at, inCdata: false };
       p = scanned.at;
       continue;
@@ -7314,11 +7328,79 @@ var parseHtmlLabelRv = (src, stderr) => {
 };
 var parseHtmlLabel = (src) => parseHtmlLabelRv(src, new StderrLines(() => void 0)).label;
 
+// src/gvc/image-resolver.ts
+var activeResolver = null;
+var EXT_MIME = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  svg: "image/svg+xml",
+  webp: "image/webp"
+};
+var FALLBACK_MIME = "application/octet-stream";
+function inferMimeFromSrc(src) {
+  const dot = src.lastIndexOf(".");
+  if (dot < 0 || dot === src.length - 1) return FALLBACK_MIME;
+  const ext = src.slice(dot + 1).toLowerCase();
+  return EXT_MIME[ext] ?? FALLBACK_MIME;
+}
+function findImageBytes(src, resolver) {
+  const active = resolver ?? activeResolver;
+  if (active === null) return null;
+  const result = active(src);
+  if (result === null) return null;
+  if (result instanceof Uint8Array) {
+    return { bytes: result, mime: inferMimeFromSrc(src) };
+  }
+  return { bytes: result.bytes, mime: result.mime ?? inferMimeFromSrc(src) };
+}
+var B64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function base64Encode(bytes) {
+  const len = bytes.length;
+  const out = [];
+  let i = 0;
+  for (; i + 2 < len; i += 3) {
+    const n = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+    out.push(
+      B64_CHARS[n >> 18 & 63],
+      B64_CHARS[n >> 12 & 63],
+      B64_CHARS[n >> 6 & 63],
+      B64_CHARS[n & 63]
+    );
+  }
+  const remaining = len - i;
+  if (remaining === 1) {
+    const n = bytes[i] << 16;
+    out.push(B64_CHARS[n >> 18 & 63], B64_CHARS[n >> 12 & 63], "==");
+  } else if (remaining === 2) {
+    const n = bytes[i] << 16 | bytes[i + 1] << 8;
+    out.push(
+      B64_CHARS[n >> 18 & 63],
+      B64_CHARS[n >> 12 & 63],
+      B64_CHARS[n >> 6 & 63],
+      "="
+    );
+  }
+  return out.join("");
+}
+function toDataUri(bytes, mime) {
+  return "data:" + mime + ";base64," + base64Encode(bytes);
+}
+
 // src/gvc/usershape.ts
 var activeSizer = null;
 function findImageSize(src) {
   return activeSizer !== null ? activeSizer(src) : null;
 }
+var STRERROR_ENOENT = "No such file or directory";
+function imageIsSupplied(name, sizer, resolver) {
+  const size = sizer !== void 0 ? sizer(name) : findImageSize(name);
+  return size !== null || findImageBytes(name, resolver) !== null;
+}
+function imageOpenWarning(name) {
+  return `${STRERROR_ENOENT} while opening ${name}`;
+}
 
 // src/common/pointset.ts
 function cmpPair(a, b) {
@@ -7371,6 +7453,173 @@ var PointSet = class {
   }
 };
 
+// src/common/emit-types.ts
+var PS2INCH = 1 / 72;
+var HTML_BF = 1 << 0;
+var HTML_IF = 1 << 1;
+var HTML_UL = 1 << 2;
+var HTML_SUP = 1 << 3;
+var HTML_SUB = 1 << 4;
+var HTML_S = 1 << 5;
+var HTML_OL = 1 << 6;
+
+// src/common/htmltable-pos-runs.ts
+function itemFontFlags(item) {
+  let f = 0;
+  if (item.bold) f |= HTML_BF;
+  if (item.italic) f |= HTML_IF;
+  if (item.underline) f |= HTML_UL;
+  if (item.superscript) f |= HTML_SUP;
+  if (item.subscript) f |= HTML_SUB;
+  if (item.strikethrough) f |= HTML_S;
+  if (item.overline) f |= HTML_OL;
+  return f;
+}
+function itemFace(item, finfo) {
+  return {
+    fs: item.fontSize !== void 0 ? item.fontSize : finfo.fontsize,
+    face: item.fontFace !== void 0 ? item.fontFace : finfo.fontname
+  };
+}
+function measureItem(item, finfo, measurer) {
+  if (item.text === void 0) return null;
+  const { fs, face } = itemFace(item, finfo);
+  const flags = itemFontFlags(item);
+  const sz = measurer.measure(
+    item.text,
+    face,
+    fs,
+    { bold: !!(flags & HTML_BF), italic: !!(flags & HTML_IF) }
+  );
+  return { w: sz.w, h: sz.h, fs, yoffsetCenterline: sz.yoffsetCenterline, yoffsetLayout: sz.yoffsetLayout };
+}
+function newRun() {
+  return { items: [], width: 0, fontSize: 0, height: 0, maxOffset: 0, maxLayout: 0 };
+}
+function runLeftX(run, box, centerX) {
+  if (run.just === "left") return box.ll.x;
+  if (run.just === "right") return box.ur.x - run.width;
+  return centerX - run.width / 2;
+}
+function accumulateItem(cur, item, m) {
+  cur.items.push(item);
+  cur.width += m.w;
+  cur.fontSize = Math.max(cur.fontSize, m.fs);
+  cur.height = Math.max(cur.height, m.h);
+  cur.maxOffset = Math.max(cur.maxOffset, m.yoffsetCenterline ?? 0.05 * m.fs);
+  cur.maxLayout = Math.max(cur.maxLayout, m.yoffsetLayout ?? 0);
+}
+function buildLineRuns(texts, finfo, measurer) {
+  const runs = [];
+  let cur = newRun();
+  const flush = (br) => {
+    if (cur.items.length === 0 && br !== void 0) {
+      const { br: _b, brAlign: _a, ...fontProps } = br;
+      const empty = { text: "", ...fontProps };
+      const m = measureItem(empty, finfo, measurer);
+      if (m !== null) accumulateItem(cur, empty, m);
+    }
+    cur.just = br?.brAlign;
+    runs.push(cur);
+    cur = newRun();
+  };
+  for (const txt of texts) {
+    for (const item of txt.items) {
+      if (item.br) {
+        flush(item);
+        continue;
+      }
+      const m = measureItem(item, finfo, measurer);
+      if (m !== null) accumulateItem(cur, item, m);
+    }
+    if (cur.items.length > 0) flush();
+  }
+  return runs;
+}
+function runSimpleKey(run, finfo) {
+  if (run.items.length > 1) return null;
+  const item = run.items[0];
+  if (item === void 0) return void 0;
+  if (itemFontFlags(item) !== 0) return null;
+  return itemFace(item, finfo);
+}
+function runsAreSimple(runs, finfo) {
+  let prevFs = -1;
+  let prevFace = null;
+  for (const run of runs) {
+    const key = runSimpleKey(run, finfo);
+    if (key === null) return false;
+    if (key === void 0) continue;
+    if (prevFs < 0) prevFs = key.fs;
+    else if (key.fs !== prevFs) return false;
+    if (prevFace === null) prevFace = key.face;
+    else if (key.face !== prevFace) return false;
+  }
+  return true;
+}
+function placeRunItems(run, startX, baseline, finfo, measurer) {
+  const lines = [];
+  let x = startX;
+  for (const item of run.items) {
+    const { fs, face } = itemFace(item, finfo);
+    const flags = itemFontFlags(item);
+    const sz = measurer.measure(
+      item.text,
+      face,
+      fs,
+      { bold: !!(flags & HTML_BF), italic: !!(flags & HTML_IF) }
+    );
+    lines.push({
+      text: item.text,
+      x,
+      baseline,
+      width: sz.w,
+      fontSize: fs,
+      fontName: face,
+      fontColor: item.fontColor ?? finfo.fontcolor,
+      fontFlags: flags
+    });
+    x += sz.w;
+  }
+  return lines;
+}
+function placeTextRuns(runs, box, finfo, measurer) {
+  if (runsAreSimple(runs, finfo)) {
+    return placeSimpleRuns(runs, box, finfo, measurer);
+  }
+  return placeComplexRuns(runs, box, finfo, measurer);
+}
+function placeSimpleRuns(runs, box, finfo, measurer) {
+  const centerX = (box.ll.x + box.ur.x) / 2;
+  const lines = [];
+  let baseline = box.ur.y;
+  for (let i = 0; i < runs.length; i++) {
+    const run = runs[i];
+    const ascent = run.maxLayout > 0 ? run.maxLayout : freetypeAscent(run.fontSize, finfo.fontname);
+    baseline -= i === 0 ? ascent : run.height;
+    lines.push(...placeRunItems(run, runLeftX(run, box, centerX), baseline, finfo, measurer));
+  }
+  return lines;
+}
+function placeComplexRuns(runs, box, finfo, measurer) {
+  const centerX = (box.ll.x + box.ur.x) / 2;
+  const lines = [];
+  let curbline = 0;
+  let ysize = 0;
+  for (let i = 0; i < runs.length; i++) {
+    const run = runs[i];
+    const lfsize = i === 0 ? run.fontSize - run.maxOffset : run.fontSize + ysize - curbline - run.maxOffset;
+    curbline += lfsize;
+    ysize += run.fontSize;
+    const baseline = box.ur.y - curbline;
+    for (const pl of placeRunItems(run, runLeftX(run, box, centerX), baseline, finfo, measurer)) {
+      pl.yoffsetCenterline = 1;
+      lines.push(pl);
+    }
+  }
+  return lines;
+}
+
 // src/common/htmltable-fontinfo.ts
 var SIZE_SAVEF = { fontsize: 0 };
 var EMIT_SAVEF = { fontsize: 0 };
@@ -7432,87 +7681,33 @@ var findCol = (ps, row, startCol, colspan, rowspan) => {
   return col;
 };
 var defaultSizeEnv = () => ({ fontsize: DEFAULT_FONTSIZE, fontname: "" });
-var itemFont = (item, env) => ({
-  fs: item.fontSize !== void 0 ? item.fontSize : env.fontsize,
-  face: item.fontFace !== void 0 ? item.fontFace : env.fontname
-});
-var measureItem = (item, measurer, env) => {
-  const { fs, face } = itemFont(item, env);
-  const flags = item.bold === true || item.italic === true ? { bold: item.bold === true, italic: item.italic === true } : void 0;
-  return measurer.measure(item.text ?? "", face, fs, flags);
-};
-var splitSizedLines = (texts, measurer, env) => {
-  const lines = [];
-  let cur = { items: [], width: 0, mxysize: 0, mxfsize: 0 };
-  const accumulate = (item) => {
-    const sz = measureItem(item, measurer, env);
-    cur.items.push(item);
-    cur.width += sz.w;
-    cur.mxysize = Math.max(cur.mxysize, sz.h);
-    cur.mxfsize = Math.max(cur.mxfsize, itemFont(item, env).fs);
-  };
-  const flush = (br) => {
-    if (cur.items.length === 0 && br !== void 0) {
-      const { br: _b, brAlign: _a, ...fontProps } = br;
-      accumulate({ text: "", ...fontProps });
-    }
-    lines.push(cur);
-    cur = { items: [], width: 0, mxysize: 0, mxfsize: 0 };
-  };
-  for (const txt of texts) {
-    for (const item of txt.items) {
-      if (item.br) {
-        flush(item);
-        continue;
-      }
-      if (item.text === void 0) continue;
-      accumulate(item);
-    }
-    if (cur.items.length > 0) flush();
-  }
-  return lines;
-};
-var itemHasFlags = (i) => i.bold === true || i.italic === true || i.underline === true || i.strikethrough === true || i.overline === true || i.subscript === true || i.superscript === true;
-var htmlTextIsSimple = (lines, env) => {
-  let prevFs = -1;
-  let prevFace = null;
-  for (const ln of lines) {
-    const item = ln.items[0];
-    if (ln.items.length > 1 || itemHasFlags(item)) return false;
-    const { fs, face } = itemFont(item, env);
-    if (prevFs < 0) prevFs = fs;
-    else if (fs !== prevFs) return false;
-    if (prevFace === null) prevFace = face;
-    else if (face !== prevFace) return false;
-  }
-  return true;
-};
 var sizeTextContent = (texts, measurer, env = defaultSizeEnv()) => {
-  const lines = splitSizedLines(texts, measurer, env);
-  const simple = htmlTextIsSimple(lines, env);
+  const lines = buildLineRuns(texts, env, measurer);
+  const simple = runsAreSimple(lines, env);
   let w = 0;
   let h = 0;
   for (const ln of lines) {
     w = Math.max(w, ln.width);
-    const lsize = simple ? ln.mxysize : ln.mxfsize;
+    const lsize = simple ? ln.height : ln.fontSize;
     h += ln.items.length > 0 ? lsize : DEFAULT_FONTSIZE;
   }
-  if (lines.length === 1) h = lines[0].items.length > 0 ? lines[0].mxysize : DEFAULT_FONTSIZE;
+  if (lines.length === 1) h = lines[0].items.length > 0 ? lines[0].height : DEFAULT_FONTSIZE;
   return { w, h };
 };
-var missingImages = /* @__PURE__ */ new WeakSet();
+var missingImages = { set: /* @__PURE__ */ new WeakSet() };
 var sizeHtmlImg = (img, { imageSizer, stderr }) => {
-  if (img.width !== void 0 && img.height !== void 0) return missingImages.has(img) ? 1 : 0;
+  if (img.width !== void 0 && img.height !== void 0) return missingImages.set.has(img) ? 1 : 0;
   const sz = imageSizer !== void 0 ? imageSizer(img.src) : findImageSize(img.src);
   if (sz !== null) {
     img.width = sz.w;
     img.height = sz.h;
     return 0;
   }
+  if (!imageIsSupplied(img.src, imageSizer)) agerrLine(stderr, `Warning: ${imageOpenWarning(img.src)}`);
   agerrLine(stderr, `Error: No or improper image file="${img.src}"`);
   img.width = 0;
   img.height = 0;
-  missingImages.add(img);
+  missingImages.set.add(img);
   return 1;
 };
 var sizeContentItem = (item, measurer, env) => {
@@ -7551,7 +7746,11 @@ var WARN_CELL_TOO_SMALL = "Warning: cell size too small for content";
 var WARN_CELL_UNSPECIFIED = "Warning: fixed cell size with unspecified width or height";
 var WARN_TABLE_TOO_SMALL = "Warning: table size too small for content";
 var WARN_TABLE_UNSPECIFIED = "Warning: fixed table size with unspecified width or height";
-var sizeWarned = /* @__PURE__ */ new WeakSet();
+var sizeWarned = { set: /* @__PURE__ */ new WeakSet() };
+registerRenderState(() => {
+  missingImages.set = /* @__PURE__ */ new WeakSet();
+  sizeWarned.set = /* @__PURE__ */ new WeakSet();
+});
 var fixedCellCheck = (cell2, sz, warn, out) => {
   if (!cell2.fixedsize) return { rv: 0, zero: false };
   if (cell2.width && cell2.height) {
@@ -7573,8 +7772,8 @@ var getCellSize = (cell2, tbl, measurer, env) => {
   }
   let szx = cw + margin;
   let szy = ch + margin;
-  const warn = !sizeWarned.has(cell2);
-  sizeWarned.add(cell2);
+  const warn = !sizeWarned.set.has(cell2);
+  sizeWarned.set.add(cell2);
   const fixed = fixedCellCheck(cell2, { w: szx, h: szy }, warn, env.stderr);
   rv |= fixed.rv;
   if (fixed.zero) {
@@ -7670,8 +7869,8 @@ var layoutHtmlTable = (tbl, measurer, env = defaultSizeEnv()) => {
   return { entries, widths, heights, spacing, border: border2, rv };
 };
 var warnFixedTable = (tbl, dims, out) => {
-  const warn = !sizeWarned.has(tbl);
-  sizeWarned.add(tbl);
+  const warn = !sizeWarned.set.has(tbl);
+  sizeWarned.set.add(tbl);
   if (tbl.fixedsize !== true) return 0;
   if (tbl.width && tbl.height) {
     if (tbl.width >= dims.wd && tbl.height >= dims.ht) return 0;
@@ -7728,173 +7927,6 @@ var INIT_DELTA = 10;
 var LOOP_TRIES = 15;
 var ROUTESPL_FUDGE = 1e-4;
 
-// src/common/emit-types.ts
-var PS2INCH = 1 / 72;
-var HTML_BF = 1 << 0;
-var HTML_IF = 1 << 1;
-var HTML_UL = 1 << 2;
-var HTML_SUP = 1 << 3;
-var HTML_SUB = 1 << 4;
-var HTML_S = 1 << 5;
-var HTML_OL = 1 << 6;
-
-// src/common/htmltable-pos-runs.ts
-function itemFontFlags(item) {
-  let f = 0;
-  if (item.bold) f |= HTML_BF;
-  if (item.italic) f |= HTML_IF;
-  if (item.underline) f |= HTML_UL;
-  if (item.superscript) f |= HTML_SUP;
-  if (item.subscript) f |= HTML_SUB;
-  if (item.strikethrough) f |= HTML_S;
-  if (item.overline) f |= HTML_OL;
-  return f;
-}
-function itemFace(item, finfo) {
-  return {
-    fs: item.fontSize !== void 0 ? item.fontSize : finfo.fontsize,
-    face: item.fontFace !== void 0 ? item.fontFace : finfo.fontname
-  };
-}
-function measureItem2(item, finfo, measurer) {
-  if (item.text === void 0) return null;
-  const { fs, face } = itemFace(item, finfo);
-  const flags = itemFontFlags(item);
-  const sz = measurer.measure(
-    item.text,
-    face,
-    fs,
-    { bold: !!(flags & HTML_BF), italic: !!(flags & HTML_IF) }
-  );
-  return { w: sz.w, h: sz.h, fs, yoffsetCenterline: sz.yoffsetCenterline, yoffsetLayout: sz.yoffsetLayout };
-}
-function newRun() {
-  return { items: [], width: 0, fontSize: 0, height: 0, maxOffset: 0, maxLayout: 0 };
-}
-function runLeftX(run, box, centerX) {
-  if (run.just === "left") return box.ll.x;
-  if (run.just === "right") return box.ur.x - run.width;
-  return centerX - run.width / 2;
-}
-function accumulateItem(cur, item, m) {
-  cur.items.push(item);
-  cur.width += m.w;
-  cur.fontSize = Math.max(cur.fontSize, m.fs);
-  cur.height = Math.max(cur.height, m.h);
-  cur.maxOffset = Math.max(cur.maxOffset, m.yoffsetCenterline ?? 0.05 * m.fs);
-  cur.maxLayout = Math.max(cur.maxLayout, m.yoffsetLayout ?? 0);
-}
-function buildLineRuns(texts, finfo, measurer) {
-  const runs = [];
-  let cur = newRun();
-  const flush = (br) => {
-    if (cur.items.length === 0 && br !== void 0) {
-      const { br: _b, brAlign: _a, ...fontProps } = br;
-      const empty = { text: "", ...fontProps };
-      const m = measureItem2(empty, finfo, measurer);
-      if (m !== null) accumulateItem(cur, empty, m);
-    }
-    cur.just = br?.brAlign;
-    runs.push(cur);
-    cur = newRun();
-  };
-  for (const txt of texts) {
-    for (const item of txt.items) {
-      if (item.br) {
-        flush(item);
-        continue;
-      }
-      const m = measureItem2(item, finfo, measurer);
-      if (m !== null) accumulateItem(cur, item, m);
-    }
-    if (cur.items.length > 0) flush();
-  }
-  return runs;
-}
-function runSimpleKey(run, finfo) {
-  if (run.items.length > 1) return null;
-  const item = run.items[0];
-  if (item === void 0) return void 0;
-  if (itemFontFlags(item) !== 0) return null;
-  return itemFace(item, finfo);
-}
-function runsAreSimple(runs, finfo) {
-  let prevFs = -1;
-  let prevFace = null;
-  for (const run of runs) {
-    const key = runSimpleKey(run, finfo);
-    if (key === null) return false;
-    if (key === void 0) continue;
-    if (prevFs < 0) prevFs = key.fs;
-    else if (key.fs !== prevFs) return false;
-    if (prevFace === null) prevFace = key.face;
-    else if (key.face !== prevFace) return false;
-  }
-  return true;
-}
-function placeRunItems(run, startX, baseline, finfo, measurer) {
-  const lines = [];
-  let x = startX;
-  for (const item of run.items) {
-    const { fs, face } = itemFace(item, finfo);
-    const flags = itemFontFlags(item);
-    const sz = measurer.measure(
-      item.text,
-      face,
-      fs,
-      { bold: !!(flags & HTML_BF), italic: !!(flags & HTML_IF) }
-    );
-    lines.push({
-      text: item.text,
-      x,
-      baseline,
-      width: sz.w,
-      fontSize: fs,
-      fontName: face,
-      fontColor: item.fontColor ?? finfo.fontcolor,
-      fontFlags: flags
-    });
-    x += sz.w;
-  }
-  return lines;
-}
-function placeTextRuns(runs, box, finfo, measurer) {
-  if (runsAreSimple(runs, finfo)) {
-    return placeSimpleRuns(runs, box, finfo, measurer);
-  }
-  return placeComplexRuns(runs, box, finfo, measurer);
-}
-function placeSimpleRuns(runs, box, finfo, measurer) {
-  const centerX = (box.ll.x + box.ur.x) / 2;
-  const lines = [];
-  let baseline = box.ur.y;
-  for (let i = 0; i < runs.length; i++) {
-    const run = runs[i];
-    const ascent = run.maxLayout > 0 ? run.maxLayout : freetypeAscent(run.fontSize, finfo.fontname);
-    baseline -= i === 0 ? ascent : run.height;
-    lines.push(...placeRunItems(run, runLeftX(run, box, centerX), baseline, finfo, measurer));
-  }
-  return lines;
-}
-function placeComplexRuns(runs, box, finfo, measurer) {
-  const centerX = (box.ll.x + box.ur.x) / 2;
-  const lines = [];
-  let curbline = 0;
-  let ysize = 0;
-  for (let i = 0; i < runs.length; i++) {
-    const run = runs[i];
-    const lfsize = i === 0 ? run.fontSize - run.maxOffset : run.fontSize + ysize - curbline - run.maxOffset;
-    curbline += lfsize;
-    ysize += run.fontSize;
-    const baseline = box.ur.y - curbline;
-    for (const pl of placeRunItems(run, runLeftX(run, box, centerX), baseline, finfo, measurer)) {
-      pl.yoffsetCenterline = 1;
-      lines.push(pl);
-    }
-  }
-  return lines;
-}
-
 // src/common/htmltable-pos.ts
 function alignContentBox(box, cell2, w, h) {
   const out = { ll: { ...box.ll }, ur: { ...box.ur } };
@@ -8196,6 +8228,20 @@ function htmlTextLabel(text, finfo, placed, dim) {
   };
 }
 
+// src/model/lazy-attrs.ts
+var SharedEmptyAttrs = class extends Map {
+  set(key, _value) {
+    throw new Error(`attrs.set("${key}") on a shared empty map; use ownAttrs()`);
+  }
+  delete(key) {
+    throw new Error(`attrs.delete("${key}") on a shared empty map; use ownAttrs()`);
+  }
+  clear() {
+    throw new Error("attrs.clear() on a shared empty map; use ownAttrs()");
+  }
+};
+var EMPTY_ATTRS = new SharedEmptyAttrs();
+
 // src/model/algData.ts
 var THETA_UNSET = 10;
 
@@ -8298,10 +8344,10 @@ var Node = class {
    */
   nodeDefaultsSnapshot;
   /** @see lib/cgraph/node.c:agnode */
-  constructor(id, name, root) {
+  constructor(id, name, root, lazyAttrs = false) {
     this.id = id;
     this.name = name;
-    this.attrs = /* @__PURE__ */ new Map();
+    this.attrs = lazyAttrs ? EMPTY_ATTRS : /* @__PURE__ */ new Map();
     this.info = makeNodeInfo();
     this.root = root;
   }
@@ -8471,12 +8517,12 @@ var Edge = class _Edge {
    */
   info;
   /** @see lib/cgraph/edge.c:agedge */
-  constructor(tail, head, name) {
+  constructor(tail, head, name, lazyAttrs = false) {
     this.seq = _Edge._nextSeq++;
     this.tail = tail;
     this.head = head;
     this.name = name;
-    this.attrs = /* @__PURE__ */ new Map();
+    this.attrs = lazyAttrs ? EMPTY_ATTRS : /* @__PURE__ */ new Map();
     this.info = makeEdgeInfo(makePort(), makePort());
   }
 };
@@ -8900,7 +8946,7 @@ function copyVirtualEdgeInfo(e, orig) {
   e.seq = orig.seq;
 }
 function newVirtualEdge(u, v, orig) {
-  const e = new Edge(u, v, "");
+  const e = new Edge(u, v, "", true);
   e.info.edge_type = VIRTUAL;
   if (orig) {
     copyVirtualEdgeInfo(e, orig);
@@ -9001,7 +9047,7 @@ function removeFromRank(g, n) {
   }
 }
 function virtualNode(g) {
-  const n = new Node(0, "", g.root);
+  const n = new Node(0, "", g.root, true);
   n.info.node_type = VIRTUAL;
   n.info.lw = 1;
   n.info.rw = 1;
@@ -9313,10 +9359,10 @@ var ARROW_EPSILON = 1e-4;
 var vsub = (p, q) => ({ x: p.x - q.x, y: p.y - q.y });
 var vadd = (p, q) => ({ x: p.x + q.x, y: p.y + q.y });
 var vscale = (c, p) => ({ x: c * p.x, y: c * p.y });
-var negUnit = (u, dist4) => {
+var negUnit = (u, dist5) => {
   if (u.x === 0 && u.y === 0) return { x: 0, y: 0 };
   const h = Math.hypot(u.x, u.y);
-  return { x: dist4 * (-u.x / h), y: dist4 * (-u.y / h) };
+  return { x: dist5 * (-u.x / h), y: dist5 * (-u.y / h) };
 };
 var backwardDelta = (u, penwidth) => negUnit(u, penwidth / 2);
 function axialProjection(phiSrc, from, to, sign2) {
@@ -9899,9 +9945,9 @@ function makeEllipseInsideFn(rx, ry, penwidth = DEFAULT_NODEPENWIDTH) {
   return (lx, ly) => lx * lx / (erx * erx) + ly * ly / (ery * ery) < 1;
 }
 function tailArrowEndClip(path4, tailTip, elen) {
-  if (elen <= 0) return path4;
-  const inside = (lx, ly) => Math.hypot(lx, ly) <= elen;
-  return bezierClipNode(path4, tailTip.x, tailTip.y, inside, true);
+  const sp = [path4[3], path4[2], path4[1], tailTip];
+  const clipped = elen > 0 ? bezierClipNode(sp, 0, 0, (x, y) => distFused({ x, y }, tailTip) <= elen, false) : sp;
+  return [clipped[3], clipped[2], clipped[1], clipped[0]];
 }
 
 // src/layout/dot/edge-route-geom.ts
@@ -11598,11 +11644,12 @@ function emitHtmlLine(line, pos, renderer, job) {
 }
 function bgFillPaint(ctx) {
   const penWidth = htmlFillPenWidth();
-  const spec = parseGradientSpec(ctx.bgcolor);
+  const spec = findHtmlStopColor(ctx.bgcolor);
   if (spec === null) return { fill: ctx.bgcolor, penWidth };
   return {
-    fill: spec[0],
-    stop: spec[1],
+    fill: spec.fill,
+    stop: spec.stop ?? "black",
+    gradientFrac: spec.frac,
     gradientAngle: ctx.gradientangle ?? 0,
     radial: htmlStyle(ctx.style).radial,
     penWidth
@@ -12032,7 +12079,7 @@ function transformUnitVertex(R2, g, c, bb) {
   const r = libmHypot(D.x, D.y);
   return { x: r * Math.cos(alpha) * bb.x, y: r * Math.sin(alpha) * bb.y };
 }
-function polygonVertices(bb, g, isBox3) {
+function polygonVertices(bb, g, isBox4) {
   const sectorangle = 2 * Math.PI / g.sides;
   const sidelength = Math.sin(sectorangle / 2);
   const c = {
@@ -12050,7 +12097,7 @@ function polygonVertices(bb, g, isBox3) {
     R2.y = fma(sidelength, Math.sin(angle), R2.y);
     const P = transformUnitVertex(R2, g, c, bb);
     verts.push(P);
-    if (isBox3) {
+    if (isBox4) {
       verts.push({ x: -P.x, y: P.y }, { x: -P.x, y: -P.y }, { x: P.x, y: -P.y });
       break;
     }
@@ -12141,14 +12188,14 @@ function starVertexGen(bb) {
   }
   return { verts: starVertices(bb.x, bb.y), xmax: sz.x / 2, ymax: sz.y / 2 };
 }
-function polygonBB(bb, minSize, p, sides2, isBox3) {
+function polygonBB(bb, minSize, p, sides2, isBox4) {
   const geom = {
     sides: sides2,
     orientation: p.orientation,
     distortion: p.distortion,
     skew: p.skew
   };
-  const { verts, xmax, ymax } = p.optionShape === STAR ? starVertexGen(bb) : polygonVertices(bb, geom, isBox3);
+  const { verts, xmax, ymax } = p.optionShape === STAR ? starVertexGen(bb) : polygonVertices(bb, geom, isBox4);
   const xmax2 = 2 * xmax;
   const ymax2 = 2 * ymax;
   const nbb = { x: Math.max(minSize.x, xmax2), y: Math.max(minSize.y, ymax2) };
@@ -12160,7 +12207,7 @@ function polygonBB(bb, minSize, p, sides2, isBox3) {
     v.x *= scalex;
     v.y *= scaley;
   }
-  return { ...polygonPeripheryBB(verts, isBox3 ? 4 : sides2, p, nbb), base: nbb };
+  return { ...polygonPeripheryBB(verts, isBox4 ? 4 : sides2, p, nbb), base: nbb };
 }
 function gvNodesize(widthPts, heightPts, flip) {
   if (flip) return { lw: heightPts / 2, rw: heightPts / 2, ht: widthPts };
@@ -12185,9 +12232,9 @@ function applySizeConstraints(p, bb0, width0, height0) {
 function polySize(p) {
   const init = initialSizePts(p);
   const dimen = quantize(padLabelDimen(p.labelDimen, p.margin, p.isPlain), p.quantumIn);
-  const { sides: sides2, isBox: isBox3 } = effectiveShape(p);
+  const { sides: sides2, isBox: isBox4 } = effectiveShape(p);
   let bb = { x: dimen.x, y: dimen.y };
-  if (isBox3) {
+  if (isBox4) {
   } else if (p.optionShape === STAR) {
     bb = starSize(bb);
   } else if (p.optionShape === CYLINDER) {
@@ -12199,16 +12246,16 @@ function polySize(p) {
   const c = applySizeConstraints(p, bb, init.width, init.height);
   const penwidth = p.penwidth ?? 1;
   const hasOutline = penwidth > 0 || p.peripheries < 1;
-  const grown = sides2 < 3 ? { ...ellipsePeripheryBB(c.bb, p.peripheries, penwidth, hasOutline), base: c.bb } : polygonBB(c.bb, { x: c.width, y: c.height }, { ...p, penwidth, hasOutline }, sides2, isBox3);
+  const grown = sides2 < 3 ? { ...ellipsePeripheryBB(c.bb, p.peripheries, penwidth, hasOutline), base: c.bb } : polygonBB(c.bb, { x: c.width, y: c.height }, { ...p, penwidth, hasOutline }, sides2, isBox4);
   const result = assembleResult(p, dimen, grown, c.fixedshape);
-  return { ...result, ...labelSpace(p, dimen, c.bb, minBb, isBox3, c.fixedshape) };
+  return { ...result, ...labelSpace(p, dimen, c.bb, minBb, isBox4, c.fixedshape) };
 }
-function labelSpace(p, dimen, bb, minBb, isBox3, fixedshape) {
+function labelSpace(p, dimen, bb, minBb, isBox4, fixedshape) {
   const spacex = dimen.x - p.labelDimen.x;
   let spaceX;
   if (p.nojustify) {
     spaceX = dimen.x - spacex;
-  } else if (isBox3) {
+  } else if (isBox4) {
     spaceX = Math.max(dimen.x, bb.x) - spacex;
   } else if (dimen.y < bb.y) {
     spaceX = Math.max(dimen.x, bb.x * Math.sqrt(1 - dimen.y * dimen.y / (bb.y * bb.y))) - spacex;
@@ -12221,8 +12268,8 @@ function labelSpace(p, dimen, bb, minBb, isBox3, fixedshape) {
 function effectiveShape(p) {
   let sides2 = p.sides;
   if (sides2 <= 2 && (p.distortion !== 0 || p.skew !== 0)) sides2 = 120;
-  const isBox3 = sides2 === 4 && Math.abs(p.orientation % 90) < 0.5 && p.distortion === 0 && p.skew === 0;
-  return { sides: sides2, isBox: isBox3 };
+  const isBox4 = sides2 === 4 && Math.abs(p.orientation % 90) < 0.5 && p.distortion === 0 && p.skew === 0;
+  return { sides: sides2, isBox: isBox4 };
 }
 function labelValign(p) {
   const ll = p.labelloc?.[0];
@@ -12664,17 +12711,27 @@ function buildNodeLabel(n, g, measurer) {
   const content = isHtml ? htmlValueContent(labelAttr) : labelAttr ?? n.name;
   n.info.label = makeAnyLabel(content, isHtml, font, measurer, n);
 }
+function warnMissingImage(n, g, shapefile) {
+  if (shapefile !== void 0 && shapefile !== "" && nodeAttr(n, g, "shape") !== "epsf") return;
+  const image = nodeAttr(n, g, "image");
+  if (image === void 0 || image === "") return;
+  const gvc = g.root.info.gvc;
+  if (imageIsSupplied(image, gvc?.imageSizer, gvc?.imageResolver)) return;
+  agwarningf(imageOpenWarning(image));
+  agwarningf(`No or improper image="${image}" for node "${n.name}"`);
+}
 function polyInit(n, g, measurer) {
   const shapeName2 = nodeAttr(n, g, "shape") ?? "ellipse";
   const shapefile = nodeAttr(n, g, "shapefile");
   n.info.shape = bindShape(shapeName2, shapefile);
   if (shapefile !== void 0 && shapefile !== "" && shapeName2 !== "epsf") {
-    agwarningf(`No or improper shapefile="${shapefile}" for node "${n.name}"`, "error");
+    agwarningf(`No or improper shapefile="${shapefile}" for node "${n.name}"`);
   }
   if (n.info.shape.kind === 2 /* SH_RECORD */) {
     if (n.info.shape_info === void 0) recordNodeInit(n, g, measurer);
     return;
   }
+  warnMissingImage(n, g, shapefile);
   buildNodeLabel(n, g, measurer);
   if (n.info.shape_info !== void 0) return;
   const polyDesc = n.info.shape.polygon;
@@ -12682,6 +12739,16 @@ function polyInit(n, g, measurer) {
 }
 
 // src/common/multicolor.ts
+var parseSegsState = { warned: false };
+registerRenderState(() => {
+  parseSegsState.warned = false;
+});
+function claimWarned() {
+  if (parseSegsState.warned) return false;
+  parseSegsState.warned = true;
+  return true;
+}
+var claimNever = () => false;
 var EPS = 1e-5;
 function aeq0(x) {
   return x < EPS && x > -EPS;
@@ -12695,17 +12762,14 @@ function getSegLen(token) {
   const parsed = parseFloat(rest);
   return !isNaN(parsed) && parsed >= 0 ? { color, v: parsed } : { color, v: -1 };
 }
-function appendSeg(token, left2, segs, warnedExceeded) {
+function appendSeg(token, left2, segs, claim) {
   const { color, v } = getSegLen(token);
   if (v < 0) return null;
   let t = v;
   let rval = 0;
   const del = t - left2;
   if (del > 0) {
-    if (!aeq0(del) && !warnedExceeded.v) {
-      warnedExceeded.v = true;
-      rval = 3;
-    }
+    if (!aeq0(del) && claim()) rval = 3;
     t = left2;
   }
   left2 -= t;
@@ -12729,19 +12793,13 @@ function trimTrailing(segs) {
     segs.pop();
   }
 }
-function parseSegs(colorlist) {
+function scanSegs(colorlist, claim) {
   const segs = [];
   let left2 = 1;
   let rval = 0;
-  let badFloatCount = 0;
-  const warnedExceeded = { v: false };
   for (const token of colorlist.split(":")) {
-    const result = appendSeg(token, left2, segs, warnedExceeded);
-    if (result === null) {
-      const errCode = badFloatCount === 0 ? 2 : 1;
-      badFloatCount++;
-      return { segs: [], error: errCode };
-    }
+    const result = appendSeg(token, left2, segs, claim);
+    if (result === null) return { segs: [], error: claim() ? 2 : 1 };
     if (result.rval === 3) rval = 3;
     left2 = result.left;
     if (aeq0(left2)) {
@@ -12753,6 +12811,91 @@ function parseSegs(colorlist) {
   trimTrailing(segs);
   return { segs, error: rval };
 }
+function parseSegs(colorlist, context) {
+  const result = scanSegs(colorlist, claimWarned);
+  if (result.error === 3) {
+    const tail = context === void 0 ? "" : context();
+    agwarningf(`Total size > 1 in "${colorlist}" color spec ${tail}`);
+  } else if (result.error === 2) {
+    agerrorf(`Illegal value in "${colorlist}" color attribute; float expected after ';'`);
+    if (context !== void 0) agerr("prev", context());
+  }
+  return result;
+}
+function parseSegsSilent(colorlist) {
+  return scanSegs(colorlist, claimNever);
+}
+function edgeSegsContext(e) {
+  return () => {
+    const directed = !e.tail.root.kind.endsWith("undirected");
+    return `in edge ${e.tail.name}${directed ? " -> " : " -- "}${e.head.name}`;
+  };
+}
+
+// src/gvc/gvrender-set-style.ts
+var SUPPORTED_STYLES = /* @__PURE__ */ new Set([
+  "solid",
+  "dashed",
+  "dotted",
+  "invis",
+  "invisible",
+  "bold",
+  "setlinewidth",
+  "filled",
+  "unfilled",
+  "tapered"
+]);
+var BOX_ORIENTATION_TOLERANCE = 0.5;
+var BOX_ORIENTATION_STEP = 90;
+var BOX_SIDES = 4;
+var ELLIPSE_MAX_SIDES = 2;
+function styleName(token) {
+  const paren = token.indexOf("(");
+  return paren < 0 ? token : token.slice(0, paren);
+}
+function gvrenderSetStyle(styles) {
+  if (styles === null) return;
+  for (const token of styles) {
+    const name = styleName(token);
+    if (!SUPPORTED_STYLES.has(name)) {
+      agwarningf(`gvrender_set_style: unsupported style ${name} - ignoring`);
+    }
+  }
+}
+function isBox(p) {
+  if (p === null) return false;
+  return p.sides === BOX_SIDES && Math.abs(p.orientation % BOX_ORIENTATION_STEP) < BOX_ORIENTATION_TOLERANCE && p.distortion === 0 && p.skew === 0;
+}
+function isEllipse(p) {
+  return p !== null && p.sides <= ELLIPSE_MAX_SIDES;
+}
+function checkStyleTokens(styles, shape) {
+  return styles.filter((p) => {
+    if (p === "rounded" || p === "diagonals" || p === "radial") return false;
+    if (p === "striped") return !isBox(shape);
+    if (p === "wedged") return !isEllipse(shape);
+    return true;
+  });
+}
+function checkClusterStyleTokens(styles) {
+  return styles.filter((p) => p !== "radial" && p !== "striped" && p !== "rounded");
+}
+function countChar(s, ch) {
+  return [...s].filter((c) => c === ch).length;
+}
+function multicolorTaken(color) {
+  if (countChar(color, ";") === 0 || countChar(color, ":") === 0) return false;
+  const { error } = parseSegsSilent(color);
+  return error !== 1 && error !== 2;
+}
+function edgeStyleResets(e, styles) {
+  const spl = e.info.spl;
+  if (spl === void 0 || spl.size <= 1 || styles.length === 0) return 0;
+  const color = e.attrs.get("color") ?? "";
+  const otherBranch = styles.includes("tapered") || countChar(color, ":") > 0;
+  if (otherBranch && !multicolorTaken(color)) return 0;
+  return spl.list.filter((bz) => bz.sflag !== 0 || bz.eflag !== 0).length;
+}
 
 // src/util/math.ts
 var INT32_MAX = 2147483647;
@@ -15735,11 +15878,11 @@ var SEG_EPS = 1e-5;
 function reportColorNames(names) {
   for (const name of names) resolveRenderColor(firstColor(name));
 }
-function countChar(s, ch) {
+function countChar2(s, ch) {
   return s.split(ch).length - 1;
 }
 function multicolorNames(color, arrows) {
-  const { segs, error } = parseSegs(color);
+  const { segs, error } = parseSegsSilent(color);
   if (error === 1 || error === 2) return null;
   const out = [];
   const front = segs[0]?.color ?? null;
@@ -15761,9 +15904,9 @@ function taperedNames(color, fillcolor, hasFill) {
   return hasFill ? [pen, fillcolor === "" ? DEFAULT_COLOR2 : fillcolor] : [pen];
 }
 function edgeGraphicsColors(spec) {
-  const numc = countChar(spec.color, ":");
+  const numc = countChar2(spec.color, ":");
   let color = spec.color;
-  if (countChar(color, ";") > 0 && numc > 0) {
+  if (countChar2(color, ";") > 0 && numc > 0) {
     const multi = multicolorNames(color, spec.arrows);
     if (multi !== null) return multi;
     color = DEFAULT_COLOR2;
@@ -15916,8 +16059,8 @@ function drawWedge(seg2, e, ctx) {
   ctx.renderer.bezier(ptsUp.map((p) => ({ x: p.x, y: -p.y })), true, ctx.job);
   return angle1;
 }
-function wedgedEllipse(job, pf, clrs, renderer) {
-  const { segs, error } = parseSegs(clrs);
+function wedgedEllipse(job, pf, clrs, renderer, context) {
+  const { segs, error } = parseSegs(clrs, context);
   if (error === 1 || error === 2) return error;
   const ctrX = (pf[0].x + pf[1].x) / 2;
   const ctrY = (pf[0].y + pf[1].y) / 2;
@@ -15949,8 +16092,8 @@ function drawBand(p, seg2, ctx) {
   ctx.renderer.polygon([...p], true, ctx.job);
   p[0].x = p[3].x = p[1].x;
 }
-function stripedBox(job, pts, clrs, rotate, renderer) {
-  const { segs, error } = parseSegs(clrs);
+function stripedBox(job, pts, clrs, rotate, renderer, context) {
+  const { segs, error } = parseSegs(clrs, context);
   if (error === 1 || error === 2) return error;
   const p = rotate ? [{ ...pts[2] }, { ...pts[3] }, { ...pts[0] }, { ...pts[1] }] : [{ ...pts[0] }, { ...pts[1] }, { ...pts[2] }, { ...pts[3] }];
   const lastx = p[1].x;
@@ -16108,6 +16251,27 @@ function escapeXmlText(s) {
   return gvXmlEscape(s, FLAGS_TEXT);
 }
 
+// src/gvc/device-transform.ts
+function transformPoint(p, job) {
+  if ((job.flags & GVRENDER_DOES_TRANSFORM) !== 0) {
+    return p;
+  }
+  const sx = job.zoom * job.devscale.x;
+  const sy = job.zoom * job.devscale.y;
+  const tx = job.translation.x;
+  const ty = job.translation.y;
+  return applyScale(p, tx, ty, sx, sy);
+}
+function applyScale(p, tx, ty, sx, sy) {
+  const x = (p.x + tx) * sx;
+  const y = (p.y + ty) * sy;
+  return buildPoint(x, y);
+}
+function buildPoint(x, y) {
+  const pt = { x, y };
+  return pt;
+}
+
 // src/gvc/device-cluster.ts
 function applyClusterGradient(obj, fill) {
   obj.fill = fill.kind === "radial" ? 3 /* Radial */ : 2 /* Linear */;
@@ -16155,6 +16319,7 @@ function applyClusterObjState(sg, job) {
   const fillRes = resolveClusterFillEx(clusterAttrsOf(sg));
   if (job.obj === null) return false;
   const obj = job.obj;
+  gvrenderSetStyle(checkClusterStyleTokens(styleTokens2(clusterStyle(sg))));
   return withColorScheme(clusterAttr(sg, "colorscheme"), () => {
     const filled = applyClusterFill(obj, fillRes);
     applyClusterPenState(obj, sg);
@@ -16162,17 +16327,47 @@ function applyClusterObjState(sg, job) {
     return filled;
   });
 }
-function stripedClusterColors(sg) {
+function isStripedCluster(sg) {
+  const flags = parseStyleFlags(clusterStyle(sg));
+  return flags.striped && !flags.rounded;
+}
+function stripedFillSpec(sg) {
   const flags = parseStyleFlags(clusterStyle(sg));
-  if (!flags.striped || flags.rounded) return [];
   const color = clusterAttr(sg, "color") ?? "";
   let fill = clusterAttr(sg, "fillcolor") || color;
   const bg = clusterAttr(sg, "bgcolor") ?? "";
   if ((!flags.filled || fill === "") && bg !== "") fill = bg;
-  const { segs, error } = parseSegs(fill === "" ? "lightgrey" : fill);
+  return fill === "" ? "lightgrey" : fill;
+}
+function stripedClusterColors(sg) {
+  if (!isStripedCluster(sg)) return [];
+  const { segs, error } = parseSegs(stripedFillSpec(sg), () => `in cluster ${sg.name}`);
   if (error === 1 || error === 2) return [];
   return segs.flatMap((seg2) => seg2.color !== null && seg2.t > 0 ? [seg2.color] : []);
 }
+function renderStripedClusterBox(sg, renderer, job) {
+  withColorScheme(clusterAttr(sg, "colorscheme"), () => {
+    const { ll, ur } = sg.info.bb;
+    const af = [
+      { x: ll.x, y: ll.y },
+      { x: ur.x, y: ll.y },
+      { x: ur.x, y: ur.y },
+      { x: ll.x, y: ur.y }
+    ].map((p) => transformPoint(p, job));
+    const obj = job.obj;
+    const savedFill = obj?.fill;
+    if (obj !== null && savedFill !== void 0) obj.fill = 1 /* Solid */;
+    stripedBox(job, af, stripedFillSpec(sg), false, renderer, () => `in cluster ${sg.name}`);
+    if (obj !== null && savedFill !== void 0) obj.fill = savedFill;
+    const rawPts = [
+      { x: ll.x, y: ll.y },
+      { x: ll.x, y: ur.y },
+      { x: ur.x, y: ur.y },
+      { x: ur.x, y: ll.y }
+    ];
+    renderer.polygon(rawPts.map((p) => transformPoint(p, job)), false, job);
+  });
+}
 function applyClusterFill(obj, fillRes) {
   if (fillRes.kind === "none") {
     obj.fill = 0 /* None */;
@@ -16238,7 +16433,7 @@ function renderEllipseRing(ring, coord, filled, j, ctx) {
     const pf = ring.map(
       (v) => transformPoint({ x: v.x + coord.x, y: v.y + coord.y }, ctx.job)
     );
-    wedgedEllipse(ctx.job, pf, ctx.fillcolor, ctx.renderer);
+    wedgedEllipse(ctx.job, pf, ctx.fillcolor, ctx.renderer, () => `in node ${ctx.nodeName}`);
     renderEllipse(ring, coord, ctx.renderer, ctx.job, false);
   } else {
     renderEllipse(ring, coord, ctx.renderer, ctx.job, filled);
@@ -16247,7 +16442,7 @@ function renderEllipseRing(ring, coord, filled, j, ctx) {
 }
 function renderStripedRing(ring, coord, ctx) {
   const af = ring.map((v) => transformPoint({ x: v.x + coord.x, y: v.y + coord.y }, ctx.job));
-  stripedBox(ctx.job, af, ctx.fillcolor, true, ctx.renderer);
+  stripedBox(ctx.job, af, ctx.fillcolor, true, ctx.renderer, () => `in node ${ctx.nodeName}`);
   renderPolygon(ring, coord, ctx.renderer, ctx.job, false);
 }
 function renderPolyRing(ring, coord, filled, j, ctx) {
@@ -16373,6 +16568,10 @@ function applyPenState(obj, styleAttr, colorAttr, penwidthAttr) {
 function applyNodeStyle(obj, n, job) {
   const styleAttr = nodeAttr(n, n.root, "style");
   const colorAttr = nodeAttr(n, n.root, "color");
+  if (!isPointNode(n)) {
+    const shape = n.info.shape;
+    gvrenderSetStyle(checkStyleTokens(styleTokens2(styleAttr), shape?.polygon ?? null));
+  }
   const penwidth = nodeAttr(n, n.root, "penwidth");
   if (n.info.shape?.kind === 2 /* SH_RECORD */) {
     applyPenState(obj, styleAttr, colorAttr, penwidth);
@@ -16384,7 +16583,7 @@ function applyNodeStyle(obj, n, job) {
 }
 function prepareDrawPoly(poly, filled, obj) {
   if (poly.peripheries !== 0 || !filled) return poly;
-  obj.penColor = { type: "string", s: "transparent" };
+  obj.penColor = resolveRenderColor("transparent");
   return { ...poly, peripheries: 1 };
 }
 function vertexScale(n, poly) {
@@ -16414,6 +16613,7 @@ function resolveNodeDrawCtx(job, n) {
     job,
     style: styleFlags,
     fillcolor: nodeAttr(n, n.root, "fillcolor") ?? "",
+    nodeName: n.name,
     ...specialCornerFlags(drawPoly.option, styleFlags)
   };
   return { poly: drawPoly, coord, filled, ringCtx };
@@ -17773,7 +17973,7 @@ function pruneForeignClusterNodes(par, clust) {
 }
 function markClusterNode(clust, n, g) {
   if ((n.info.ranktype ?? 0) !== 0) {
-    agwarningf(`${n.name} was already in a rankset, deleted from cluster ${g.name}`, "error");
+    agwarningf(`${n.name} was already in a rankset, deleted from cluster ${g.name}`);
     agDeleteFromCluster(clust, n);
     return;
   }
@@ -18352,7 +18552,7 @@ function findCharset(g) {
   }
   if (p === "big-5" || p === "big5") return CHAR_BIG5;
   if (p === "utf-8" || p === "utf8") return CHAR_UTF8;
-  agwarningf(`Unsupported charset "${raw}" - assuming utf-8`, "error");
+  agwarningf(`Unsupported charset "${raw}" - assuming utf-8`);
   return CHAR_UTF8;
 }
 function maptoken(p, names, vals) {
@@ -18570,7 +18770,7 @@ function portToTbl(tbl, id) {
 }
 
 // src/common/compass-port.ts
-function isBox(n) {
+function isBox2(n) {
   return n.info.shape?.polygon === P_BOX;
 }
 function gdRankdir(n) {
@@ -18761,7 +18961,7 @@ function compassPort(n, args, pp) {
   const { bp, compass, sides: sides2 } = args;
   const { b, p, defined: defBp } = compassBbox(n, bp);
   const dir = compassDirection(compass, b, p, sides2);
-  if (bp === null && !isBox(n)) applyIctxt(n, dir, b, p);
+  if (bp === null && !isBox2(n)) applyIctxt(n, dir, b, p);
   const defFinal = dir.rv === 1 ? defBp : dir.defined || defBp;
   applyDir(pp, bp, dir, gdRankdir(n), defFinal);
   return dir.rv;
@@ -20043,7 +20243,7 @@ function emitParallelEdgePaths(e, job, colorList) {
   const spl = e.info.spl;
   const numc = (colorList.match(/:/g) ?? []).length;
   const segData = buildSegData(spl?.list ?? [], (2 + numc) / 2);
-  const colors = parseSegs(colorList).segs.map((s) => s.color ?? DEFAULT_COLOR3);
+  const colors = parseSegsSilent(colorList).segs.map((s) => s.color ?? DEFAULT_COLOR3);
   emitColorPasses(segData, colors, job);
   return {
     headColor: colors[0] ?? DEFAULT_COLOR3,
@@ -20875,25 +21075,14 @@ function walkNodesAndEdges(g, renderer, job, info) {
   }
 }
 
-// src/gvc/device-transform.ts
-function transformPoint(p, job) {
-  if ((job.flags & GVRENDER_DOES_TRANSFORM) !== 0) {
-    return p;
-  }
-  const sx = job.zoom * job.devscale.x;
-  const sy = job.zoom * job.devscale.y;
-  const tx = job.translation.x;
-  const ty = job.translation.y;
-  return applyScale(p, tx, ty, sx, sy);
-}
-function applyScale(p, tx, ty, sx, sy) {
-  const x = (p.x + tx) * sx;
-  const y = (p.y + ty) * sy;
-  return buildPoint(x, y);
-}
-function buildPoint(x, y) {
-  const pt = { x, y };
-  return pt;
+// src/gvc/first-layer.ts
+var NATIVE_LANGNAME = /* @__PURE__ */ new Map([
+  ["cmapx-np", "cmapx_np"],
+  ["imap-np", "imap_np"]
+]);
+function warnLayersUnsupported(format, numLayers, doesLayers) {
+  if (numLayers <= 1 || doesLayers) return;
+  agwarningf(`layers not supported in ${NATIVE_LANGNAME.get(format) ?? format} output`);
 }
 
 // src/gvc/device-labels.ts
@@ -21038,6 +21227,7 @@ function setEdgePen(e, job) {
   obj.pen = resolvePenType(flags);
   obj.penWidth = resolvePenWidth(flags, e.attrs.get("penwidth"));
   obj.rawStyle = styleTokens2(e.attrs.get("style"));
+  if (e.info.spl !== void 0) gvrenderSetStyle(obj.rawStyle);
 }
 function renderEdge(e, renderer, job) {
   emitEdgeComments(e, renderer, job);
@@ -21053,6 +21243,8 @@ function renderEdge(e, renderer, job) {
     withColorScheme(e.attrs.get("colorscheme"), () => {
       renderer.beginEdge(e, job);
       reportEdgeColors(e);
+      const styles = styleTokens2(e.attrs.get("style"));
+      for (let i = edgeStyleResets(e, styles); i > 0; i--) gvrenderSetStyle(styles);
       reportEdgeLabelColors(e);
       renderer.endEdge(e, job);
     });
@@ -21066,6 +21258,10 @@ function renderGraphLabel(g, renderer, job) {
 }
 function renderClusterBox(sg, filled, renderer, job) {
   const { ll, ur } = sg.info.bb;
+  if (isStripedCluster(sg)) {
+    renderStripedClusterBox(sg, renderer, job);
+    return;
+  }
   if (parseStyleFlags(clusterStyle(sg)).rounded) {
     const af = [{ x: ll.x, y: ll.y }, { x: ur.x, y: ll.y }, { x: ur.x, y: ur.y }, { x: ll.x, y: ur.y }];
     emitRoundedBezier(af, { x: 0, y: 0 }, filled, { renderer, job });
@@ -21089,7 +21285,7 @@ function renderOneCluster(sg, renderer, job) {
       resolveObjAnchor(sg, labelTextOf2(sg.info.label), svgClusterId(sg, job), job.obj);
     }
     const anchored = beginAnchorIf(renderer, job);
-    if ((clusterPeripheries(sg) !== 0 || filled) && job.obj?.pen !== 0 /* None */) {
+    if ((clusterPeripheries(sg) !== 0 || filled || isStripedCluster(sg)) && job.obj?.pen !== 0 /* None */) {
       renderClusterBox(sg, filled, renderer, job);
     }
     renderClusterLabel(sg, renderer, job);
@@ -21119,6 +21315,7 @@ function renderGraph(g, job, renderer) {
     job.numLayers = layered ? info.numLayers : 1;
     job.layerIDs = info.layerIDs;
     renderer.beginGraph(g, job);
+    warnLayersUnsupported(job.format, info.numLayers, renderer.beginLayer !== void 0);
     for (let ln = 1; ln <= job.numLayers; ln++) {
       job.layerNum = ln;
       if (layered) renderer.beginLayer(info.layerIDs[ln], job);
@@ -21180,13 +21377,21 @@ function render(ctx, g, format, inlineImages = false) {
 }
 
 // src/common/htmltable-emit-fill.ts
+var MSG_MANY_COLORS = "More than 2 colors specified for a gradient - ignoring remaining";
+function findHtmlStopColor(color, silent = false) {
+  const { segs, error } = silent ? parseSegsSilent(color) : parseSegs(color);
+  const first = segs[0];
+  const second = segs[1];
+  if (error !== 0 || first === void 0 || second === void 0 || first.color === null) {
+    return null;
+  }
+  if (segs.length > 2 && !silent) agwarningf(MSG_MANY_COLORS);
+  const frac = first.hasFraction ? first.t : second.hasFraction ? 1 - second.t : 0;
+  return { fill: first.color, stop: second.color, frac };
+}
 function parseGradientSpec(color) {
-  const idx = color.indexOf(":");
-  if (idx < 1) return null;
-  const c0 = color.slice(0, idx).trim();
-  const c1 = color.slice(idx + 1).trim();
-  if (c0.length === 0) return null;
-  return [c0, c1.length > 0 ? c1 : "black"];
+  const spec = findHtmlStopColor(color, true);
+  return spec === null ? null : [spec.fill, spec.stop ?? "black"];
 }
 var paintObj = {
   parent: null,
@@ -21243,6 +21448,12 @@ function resetHtmlFillPenWidth() {
   htmlFillPen = 1;
 }
 registerRenderState(resetHtmlFillPenWidth);
+var DEFAULT_LINE_STYLE = ["solid", "setlinewidth(1)"];
+function htmlBorderStyle(pen) {
+  if (pen === 1 /* Dashed */) return ["dashed"];
+  if (pen === 2 /* Dotted */) return ["dotted"];
+  return DEFAULT_LINE_STYLE;
+}
 function penTypeOf(style2) {
   const st = htmlStyle(style2);
   if (st.dashed) return 1 /* Dashed */;
@@ -21250,12 +21461,13 @@ function penTypeOf(style2) {
   return 3 /* Solid */;
 }
 function withHtmlPaint(paint, job, drawFn) {
-  paintObj.fillColor = paint.fill !== void 0 ? resolveRenderColor(paint.fill) : { type: "none" };
+  paintObj.fillColor = paint.fill !== void 0 ? resolveRenderColor(firstColor(paint.fill)) : { type: "none" };
   paintObj.penColor = paint.pen !== void 0 ? resolveRenderColor(paint.pen) : { type: "string", s: "transparent" };
   applyHtmlFill(paint);
   paintObj.pen = penTypeOf(paint.penStyle);
   paintObj.penWidth = paint.penWidth !== void 0 ? paint.penWidth : 1;
   paintObj.rawStyle = paintObj.pen === 3 /* Solid */ ? ["solid"] : [];
+  gvrenderSetStyle(htmlBorderStyle(paintObj.pen));
   paintObj.emitState = job.obj?.emitState ?? 8 /* NDraw */;
   job.pushObj(paintObj);
   try {
@@ -21269,7 +21481,7 @@ function applyHtmlFill(paint) {
     paintObj.fill = paint.radial === true ? 3 /* Radial */ : 2 /* Linear */;
     paintObj.stopColor = resolveRenderColor(paint.stop);
     paintObj.gradientAngle = paint.gradientAngle ?? 0;
-    paintObj.gradientFrac = 0;
+    paintObj.gradientFrac = paint.gradientFrac ?? 0;
     return;
   }
   paintObj.fill = paint.fill !== void 0 ? 1 /* Solid */ : 0 /* None */;
@@ -21572,6 +21784,7 @@ function resolveClusterFillEx(attrs) {
 
 // src/common/splines-clip.ts
 var ARR_NORM = 1;
+var dist = distFused;
 var SplineClipHelper = class _SplineClipHelper {
   static makeEmptySpl() {
     return { list: [], size: 0, bb: { ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } } };
@@ -21664,15 +21877,11 @@ var SplineClipHelper = class _SplineClipHelper {
     if (j) return [eflag, sflag];
     return [sflag, eflag];
   }
-  /** DIST(p, q). */
-  static dist(p, q) {
-    return Math.hypot(p.x - q.x, p.y - q.y);
-  }
   /** Sphere inside-fn around `tip` with radius `r` for bezierClip. */
   static sphereCtx(tip2, r) {
     return {
       ctx: { nodeCoord: { x: 0, y: 0 }, rw: 0, bp: null },
-      fn: (_c, p) => _SplineClipHelper.dist(p, tip2) <= r
+      fn: (_c, p) => dist(p, tip2) <= r
     };
   }
   /**
@@ -21704,7 +21913,7 @@ var SplineClipHelper = class _SplineClipHelper {
     );
     spl.eflag = eflag;
     spl.ep = ps[endp + 3];
-    if (endp > startp && _SplineClipHelper.dist(ps[endp], ps[endp + 3]) < elen) {
+    if (endp > startp && dist(ps[endp], ps[endp + 3]) < elen) {
       endp -= 3;
     }
     const sp = [spl.ep, ps[endp + 2], ps[endp + 1], ps[endp]];
@@ -21731,7 +21940,7 @@ var SplineClipHelper = class _SplineClipHelper {
     );
     spl.sflag = sflag;
     spl.sp = ps[startp];
-    if (endp > startp && _SplineClipHelper.dist(ps[startp], ps[startp + 3]) < slen) {
+    if (endp > startp && dist(ps[startp], ps[startp + 3]) < slen) {
       startp += 3;
     }
     const sp = [ps[startp + 3], ps[startp + 2], ps[startp + 1], spl.sp];
@@ -21832,7 +22041,7 @@ var SplineClipHelper = class _SplineClipHelper {
     if (sflag && eflag && endp === startp) {
       const p = ps[endp];
       const q = ps[endp + 3];
-      const d = _SplineClipHelper.dist(p, q);
+      const d = dist(p, q);
       let hlen = hlen0;
       let tlen = tlen0;
       if (hlen + tlen >= d) {
@@ -21875,7 +22084,7 @@ var SplineClipHelper = class _SplineClipHelper {
       let hlen = hlen0;
       const p = ps[endp];
       const q = ps[endp + 3];
-      const maxd = 0.9 * _SplineClipHelper.dist(p, q);
+      const maxd = 0.9 * dist(p, q);
       if (hlen >= maxd) hlen = maxd;
       const r = { x: p.x, y: p.y };
       if (p.y === q.y) {
@@ -21895,7 +22104,7 @@ var SplineClipHelper = class _SplineClipHelper {
       let tlen = tlen0;
       const p = ps[startp];
       const q = ps[startp + 3];
-      const maxd = 0.9 * _SplineClipHelper.dist(p, q);
+      const maxd = 0.9 * dist(p, q);
       if (tlen >= maxd) tlen = maxd;
       const r = { x: p.x, y: p.y };
       if (p.y === q.y) {
@@ -24029,13 +24238,13 @@ function dfsNode(Xg, v, frames) {
   frames.push({ v, edges: v.outEdges(Xg).slice(), i: 0 });
 }
 function dfsStep2(Xg, frames) {
-  const fr3 = frames[frames.length - 1];
-  if (fr3.i < fr3.edges.length) {
-    const e = fr3.edges[fr3.i++];
+  const fr7 = frames[frames.length - 1];
+  if (fr7.i < fr7.edges.length) {
+    const e = fr7.edges[fr7.i++];
     if (e.head.info.onstack) reverseEdge2(Xg, e);
     else if (!e.head.info.mark) dfsNode(Xg, e.head, frames);
   } else {
-    fr3.v.info.onstack = 0;
+    fr7.v.info.onstack = 0;
     frames.pop();
   }
 }
@@ -25807,7 +26016,7 @@ function fillRankVlist(g, r, root) {
   rankArr[r].v = rootRank.v;
   rankArr[r].vStart = lead.info.order ?? 0;
   const maxi = computeMaxi(g, r);
-  if (maxi === -1) agwarningf(`degenerate concentrated rank ${g.name},${r}`, "error");
+  if (maxi === -1) agwarningf(`degenerate concentrated rank ${g.name},${r}`);
   rankArr[r].n = maxi + 1;
   return 0;
 }
@@ -28626,7 +28835,7 @@ function routeSplinesInternal(pp, polyline) {
   ];
   const pl = shortestPath(poly, eps);
   if (pl === null) {
-    agerrLineOn("warn", "in routesplines, Pshortestpath failed");
+    agerrorf("in routesplines, Pshortestpath failed");
     return null;
   }
   emitDump("S3_POLY", dumpNames, () => ({
@@ -30632,9 +30841,9 @@ function writePortlabelPos(l, pe, pf, angleStr, distanceStr) {
   const angleDeg = lateDouble(angleStr, PORT_LABEL_ANGLE, -180);
   const angle = Math.atan2(pf.y - pe.y, pf.x - pe.x) + RADIANS(angleDeg);
   const distMult = lateDouble(distanceStr || void 0, 1, 0);
-  const dist4 = PORT_LABEL_DISTANCE * distMult;
-  l.pos.x = pe.x + dist4 * Math.cos(angle);
-  l.pos.y = pe.y + dist4 * Math.sin(angle);
+  const dist5 = PORT_LABEL_DISTANCE * distMult;
+  l.pos.x = pe.x + dist5 * Math.cos(angle);
+  l.pos.y = pe.y + dist5 * Math.sin(angle);
   l.set = true;
 }
 function updateBB(g, l) {
@@ -31036,7 +31245,7 @@ function translateDrawing(g) {
       if (e.tail !== v) continue;
       if (e.info.spl === void 0) {
         if (!(g.info.concentrate ?? false) && (e.info.edge_type ?? 0) !== IGNORED_EDGE) {
-          agerrLineOn("warn", `lost ${e.tail.name} ${e.head.name} edge`);
+          agerrorf(`lost ${e.tail.name} ${e.head.name} edge`);
         }
         continue;
       }
@@ -31799,9 +32008,14 @@ function nodeInsideFn2(box) {
 function clipToNodes(bezier2, tailBox, headBox, penwidth = DEFAULT_NODEPENWIDTH, clip = CLIP_BOTH) {
   const step1 = clip.tail ? bezierClipNode(bezier2, tailBox.center.x, tailBox.center.y, nodeInsideFn2(tailBox), true) : bezier2;
   const step2 = clip.head ? bezierClipNode(step1, headBox.center.x, headBox.center.y, nodeInsideFn2(headBox), false) : step1;
-  const arrowTip = step2[3];
+  const startp = 0;
+  let endp = 0;
+  const arrowTip = step2[endp + 3];
   const elen = normalArrowLen(penwidth);
-  const clipped = arrowEndClip(step2, arrowTip, elen);
+  if (endp > startp && distFused(step2[endp], step2[endp + 3]) < elen) {
+    endp -= 3;
+  }
+  const clipped = arrowEndClip(step2.slice(endp, endp + 4), arrowTip, elen);
   const arrowDir = normalizeVec({
     x: clipped[3].x - arrowTip.x,
     y: clipped[3].y - arrowTip.y
@@ -34340,8 +34554,7 @@ function ensureDummyNodes(sg, gstart) {
 }
 function orthoEdges(g, useLbls, clipAndInstall2) {
   if (useLbls) {
-    agerrLineOn(
-      "warn",
+    agwarningf(
       "Orthogonal edges do not currently handle edge labels. Try using xlabels.\n"
     );
     useLbls = false;
@@ -34476,7 +34689,7 @@ function dispatchOrthoEdges(g, useLbls) {
 }
 
 // src/common/arrows-geometry.ts
-function dist(a, b) {
+function dist3(a, b) {
   return Math.hypot(a.x - b.x, a.y - b.y);
 }
 
@@ -34580,7 +34793,7 @@ function getCycleCentroid(g, edge) {
 }
 function bend(spl, centroid) {
   const midpt = midPointf(spl[0], spl[3]);
-  const distVal = dist(spl[3], spl[0]);
+  const distVal = dist3(spl[3], spl[0]);
   const r = distVal / 5;
   const vX = centroid.x - midpt.x;
   const vY = centroid.y - midpt.y;
@@ -35193,7 +35406,7 @@ function arrowEndClipIdx(state3, endp) {
   const elen = arrowClipLength(edgeArrowName(e, "head"), edgeArrowsize(e), edgePenwidthAttr(e));
   bez.eflag = bez.eflag || 1;
   bez.ep = { ...bez.list[endp + 3] };
-  if (endp > state3.starti && dist(bez.list[endp], bez.list[endp + 3]) < elen) endp -= 3;
+  if (endp > state3.starti && distFused(bez.list[endp], bez.list[endp + 3]) < elen) endp -= 3;
   const seg2 = [bez.list[endp], bez.list[endp + 1], bez.list[endp + 2], bez.list[endp + 3]];
   const clipped = arrowEndClip(seg2, bez.ep, elen);
   for (let k = 0; k < 4; k++) bez.list[endp + k] = clipped[k];
@@ -35204,7 +35417,7 @@ function arrowStartClipIdx(state3, startp, endp) {
   const slen = arrowClipLength(edgeArrowName(e, "tail"), edgeArrowsize(e), edgePenwidthAttr(e));
   bez.sflag = bez.sflag || 1;
   bez.sp = { ...bez.list[startp] };
-  if (endp > startp && dist(bez.list[startp], bez.list[startp + 3]) < slen) startp += 3;
+  if (endp > startp && distFused(bez.list[startp], bez.list[startp + 3]) < slen) startp += 3;
   const seg2 = [bez.list[startp], bez.list[startp + 1], bez.list[startp + 2], bez.list[startp + 3]];
   const clipped = tailArrowEndClip(seg2, bez.sp, slen);
   for (let k = 0; k < 4; k++) bez.list[startp + k] = clipped[k];
@@ -36473,120 +36686,522 @@ var DOT_LAYOUT_ENGINE = {
 };
 
 // src/layout/neato/dijkstra.ts
-function heapPush(heap, dist4, idx) {
-  let pos = heap.length;
-  heap.push(idx);
-  while (pos > 0) {
-    const parent2 = pos - 1 >> 1;
-    if (dist4[heap[parent2]] <= dist4[heap[pos]]) break;
-    const tmp = heap[parent2];
-    heap[parent2] = heap[pos];
-    heap[pos] = tmp;
-    pos = parent2;
-  }
-}
-function heapSiftDown2(heap, dist4) {
-  let pos = 0;
+var FLT_MAX = 34028234663852886e22;
+function greaterPriorityF(h, i, j, dist5) {
+  return dist5[h.data[i]] < dist5[h.data[j]];
+}
+function heapifyF(h, start, dist5) {
+  let i = start;
   for (; ; ) {
-    const l = 2 * pos + 1;
-    const r = 2 * pos + 2;
-    let smallest = pos;
-    if (l < heap.length && dist4[heap[l]] < dist4[heap[smallest]]) smallest = l;
-    if (r < heap.length && dist4[heap[r]] < dist4[heap[smallest]]) smallest = r;
-    if (smallest === pos) break;
-    const tmp = heap[smallest];
-    heap[smallest] = heap[pos];
-    heap[pos] = tmp;
-    pos = smallest;
-  }
-}
-function heapPop(heap, dist4) {
-  const top = heap[0];
-  const last = heap.pop();
-  if (heap.length === 0) return top;
-  heap[0] = last;
-  heapSiftDown2(heap, dist4);
-  return top;
-}
-function heapBuildExcluding(src, n, dist4) {
-  const heap = [];
+    const l = ngLeft(i);
+    const r = ngRight(i);
+    let largest = ngInsideHeap(h, l) && greaterPriorityF(h, l, i, dist5) ? l : i;
+    if (ngInsideHeap(h, r) && greaterPriorityF(h, r, largest, dist5)) largest = r;
+    if (largest === i) break;
+    ngExchange(h, largest, i);
+    i = largest;
+  }
+}
+function initHeapF(startVertex, dist5, n) {
+  const h = {
+    data: new Array(Math.max(n - 1, 0)).fill(0),
+    heapSize: n - 1,
+    index: new Int32Array(n)
+  };
+  let count = 0;
   for (let i = 0; i < n; i++) {
-    if (i !== src) heapPush(heap, dist4, i);
+    if (i !== startVertex) {
+      h.data[count] = i;
+      h.index[i] = count;
+      count++;
+    }
   }
-  return heap;
+  for (let j = Math.trunc((n - 1) / 2); j >= 0; j--) heapifyF(h, j, dist5);
+  return h;
+}
+function extractMaxF(h, dist5) {
+  if (h.heapSize === 0) return -1;
+  const max = h.data[0];
+  h.data[0] = h.data[h.heapSize - 1];
+  h.index[h.data[0]] = 0;
+  h.heapSize--;
+  heapifyF(h, 0, dist5);
+  return max;
+}
+function increaseKeyF(h, increasedVertex, newDist, dist5) {
+  if (dist5[increasedVertex] <= newDist) return;
+  let i = h.index[increasedVertex];
+  dist5[increasedVertex] = newDist;
+  while (i > 0 && dist5[h.data[ngParent(i)]] > newDist) {
+    ngAssign(h, i, ngParent(i));
+    i = ngParent(i);
+  }
+  h.data[i] = increasedVertex;
+  h.index[increasedVertex] = i;
+}
+function dijkstra(vertex, graph, n, dist5) {
+  for (let i = 0; i < n; i++) dist5[i] = FLT_MAX;
+  dist5[vertex] = 0;
+  const vd = graph[vertex];
+  for (let i = 1; i < vd.nedges; i++) dist5[vd.edges[i]] = vd.ewgts[i];
+  const h = initHeapF(vertex, dist5, n);
+  for (let closest = extractMaxF(h, dist5); closest >= 0; closest = extractMaxF(h, dist5)) {
+    const closestDist = dist5[closest];
+    if (closestDist === FLT_MAX) break;
+    const cd = graph[closest];
+    for (let i = 1; i < cd.nedges; i++) {
+      increaseKeyF(h, cd.edges[i], Math.fround(closestDist + Math.fround(cd.ewgts[i])), dist5);
+    }
+  }
+}
+var MAX_DIST = 2147483647;
+function ngLeft(i) {
+  return 2 * i;
 }
-function dijkstraInitDist(src, graph, n, dist4) {
-  for (let i = 0; i < n; i++) dist4[i] = Infinity;
-  dist4[src] = 0;
-  const v = graph[src];
-  for (let i = 1; i < v.nedges; i++) dist4[v.edges[i]] = v.ewgts[i];
+function ngRight(i) {
+  return 2 * i + 1;
 }
-function dijkstraRelax(closest, closestDist, graph, dist4, heap) {
-  const cv = graph[closest];
-  for (let i = 1; i < cv.nedges; i++) {
-    const nb = cv.edges[i];
-    const nd = closestDist + cv.ewgts[i];
-    if (nd < dist4[nb]) {
-      dist4[nb] = nd;
-      heapPush(heap, dist4, nb);
+function ngParent(i) {
+  return Math.trunc(i / 2);
+}
+function ngInsideHeap(h, i) {
+  return i < h.heapSize;
+}
+function ngGreaterPriority(h, i, j, dist5) {
+  return dist5[h.data[i]] < dist5[h.data[j]];
+}
+function ngAssign(h, i, j) {
+  h.data[i] = h.data[j];
+  h.index[h.data[i]] = i;
+}
+function ngExchange(h, i, j) {
+  const t = h.data[i];
+  h.data[i] = h.data[j];
+  h.data[j] = t;
+  h.index[h.data[i]] = i;
+  h.index[h.data[j]] = j;
+}
+function ngHeapify(h, start, dist5) {
+  let i = start;
+  for (; ; ) {
+    const l = ngLeft(i);
+    const r = ngRight(i);
+    let largest = ngInsideHeap(h, l) && ngGreaterPriority(h, l, i, dist5) ? l : i;
+    if (ngInsideHeap(h, r) && ngGreaterPriority(h, r, largest, dist5)) largest = r;
+    if (largest === i) break;
+    ngExchange(h, largest, i);
+    i = largest;
+  }
+}
+function ngInitHeap(startVertex, dist5, n) {
+  const h = {
+    data: new Array(Math.max(n - 1, 0)).fill(0),
+    heapSize: n - 1,
+    index: new Int32Array(n)
+  };
+  let count = 0;
+  for (let i = 0; i < n; i++) {
+    if (i !== startVertex) {
+      h.data[count] = i;
+      h.index[i] = count;
+      count++;
     }
   }
+  for (let j = Math.trunc((n - 1) / 2); j >= 0; j--) ngHeapify(h, j, dist5);
+  return h;
+}
+function ngExtractMax(h, dist5) {
+  if (h.heapSize === 0) return -1;
+  const max = h.data[0];
+  h.data[0] = h.data[h.heapSize - 1];
+  h.index[h.data[0]] = 0;
+  h.heapSize--;
+  ngHeapify(h, 0, dist5);
+  return max;
 }
-function dijkstra(src, graph, n, dist4) {
-  dijkstraInitDist(src, graph, n, dist4);
-  const heap = heapBuildExcluding(src, n, dist4);
-  while (heap.length > 0) {
-    const closest = heapPop(heap, dist4);
-    const closestDist = dist4[closest];
-    if (!isFinite(closestDist)) break;
-    dijkstraRelax(closest, closestDist, graph, dist4, heap);
+function ngIncreaseKey(h, increasedVertex, newDist, dist5) {
+  if (dist5[increasedVertex] <= newDist) return;
+  let i = h.index[increasedVertex];
+  dist5[increasedVertex] = newDist;
+  while (i > 0 && dist5[h.data[ngParent(i)]] > newDist) {
+    ngAssign(h, i, ngParent(i));
+    i = ngParent(i);
+  }
+  h.data[i] = increasedVertex;
+  h.index[increasedVertex] = i;
+}
+function toDistType(w) {
+  return Math.trunc(Math.fround(w));
+}
+function ngdijkstra(vertex, graph, n, dist5) {
+  let prevClosestDist = MAX_DIST;
+  for (let i = 0; i < n; i++) dist5[i] = MAX_DIST;
+  dist5[vertex] = 0;
+  const vd = graph[vertex];
+  for (let i = 1; i < vd.nedges; i++) dist5[vd.edges[i]] = toDistType(vd.ewgts[i]);
+  const h = ngInitHeap(vertex, dist5, n);
+  for (let closest = ngExtractMax(h, dist5); closest >= 0; closest = ngExtractMax(h, dist5)) {
+    const closestDist = dist5[closest];
+    if (closestDist === MAX_DIST) break;
+    const cd = graph[closest];
+    for (let i = 1; i < cd.nedges; i++) {
+      ngIncreaseKey(h, cd.edges[i], closestDist + toDistType(cd.ewgts[i]) | 0, dist5);
+    }
+    prevClosestDist = closestDist;
+  }
+  for (let i = 0; i < n; i++) {
+    if (dist5[i] === MAX_DIST) {
+      dist5[i] = MAX_DIST - prevClosestDist < 10 ? MAX_DIST : prevClosestDist + 10;
+    }
   }
 }
 
 // src/layout/neato/bfs.ts
-function bfsInit(src, n, dist4) {
-  for (let i = 0; i < n; i++) dist4[i] = -1;
-  dist4[src] = 0;
+function bfsInit(src, n, dist5) {
+  for (let i = 0; i < n; i++) dist5[i] = -1;
+  dist5[src] = 0;
   return [src];
 }
-function bfsFixDisconnected(n, dist4, closestDist) {
+function bfsFixDisconnected(n, dist5, closestDist) {
   for (let i = 0; i < n; i++) {
-    if (dist4[i] < 0) dist4[i] = closestDist + 10;
+    if (dist5[i] < 0) dist5[i] = closestDist + 10;
   }
 }
-function bfsVisitNeighbors(vertex, graph, dist4, queue) {
+function bfsVisitNeighbors(vertex, graph, dist5, queue) {
   const vd = graph[vertex];
-  const d = dist4[vertex];
+  const d = dist5[vertex];
   const unit = graph[0].ewgts.length === 0;
   for (let i = 1; i < vd.nedges; i++) {
     const nb = vd.edges[i];
-    if (dist4[nb] < 0) {
-      dist4[nb] = d + (unit ? 1 : Math.trunc(Math.fround(vd.ewgts[i])));
+    if (dist5[nb] < 0) {
+      dist5[nb] = d + (unit ? 1 : Math.trunc(Math.fround(vd.ewgts[i])));
       queue.push(nb);
     }
   }
   return d;
 }
-function bfs(src, graph, n, dist4) {
-  const queue = bfsInit(src, n, dist4);
+function bfs(src, graph, n, dist5) {
+  const queue = bfsInit(src, n, dist5);
   let closestDist = 0;
   let head = 0;
   while (head < queue.length) {
     const vertex = queue[head++];
-    closestDist = bfsVisitNeighbors(vertex, graph, dist4, queue);
+    closestDist = bfsVisitNeighbors(vertex, graph, dist5, queue);
+  }
+  bfsFixDisconnected(n, dist5, closestDist);
+}
+function packedIndex(i, j, n) {
+  return i * (2 * n - i - 1) / 2 + j;
+}
+function computeWeightedApspPacked(graph, n) {
+  const result = new Float32Array(n * (n + 1) / 2);
+  const di = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    dijkstra(i, graph, n, di);
+    for (let j = i; j < n; j++) result[packedIndex(i, j, n)] = di[j];
+  }
+  return result;
+}
+
+// src/common/crand.ts
+var C_RAND_MAX = 2147483647;
+var UNSEEDED_STATE2 = 1;
+var state2 = UNSEEDED_STATE2;
+registerRenderState(() => {
+  state2 = UNSEEDED_STATE2;
+});
+function csrand(seed) {
+  state2 = seed;
+}
+function crand() {
+  state2 = state2 * 16807 % 2147483647;
+  return state2;
+}
+function cdrand() {
+  return crand() / C_RAND_MAX;
+}
+function gvRandom(bound) {
+  const discardThreshold = C_RAND_MAX - 2147483648 % bound;
+  let r;
+  do {
+    r = crand();
+  } while (r > discardThreshold);
+  return r % bound;
+}
+function gvPermutation(bound) {
+  if (bound <= 0) return [];
+  const p = [];
+  for (let i = 0; i < bound; i++) p.push(i);
+  for (let i = bound - 1; i > 0; --i) {
+    const j = gvRandom(i + 1);
+    const t = p[i];
+    p[i] = p[j];
+    p[j] = t;
+  }
+  return p;
+}
+
+// src/layout/neato/matrix-ops.ts
+var fr = Math.fround;
+function fma2(a, b, c) {
+  const p = a * b;
+  return Number.isFinite(p) && Number.isFinite(c) ? fma(a, b, c) : p + c;
+}
+function orthog1(n, vec) {
+  let sum = 0;
+  for (let i = 0; i < n; i++) sum += vec[i];
+  sum /= n;
+  for (let i = 0; i < n; i++) vec[i] = vec[i] - sum;
+}
+function orthog1f(n, vec) {
+  let sum = fr(0);
+  for (let i = 0; i < n; i++) sum = fr(sum + vec[i]);
+  sum = fr(sum / n);
+  for (let i = 0; i < n; i++) vec[i] = vec[i] - sum;
+}
+function rightMultWithVectorFF(m, n, vector, result) {
+  for (let i = 0; i < n; i++) result[i] = 0;
+  let index = 0;
+  for (let i = 0; i < n; i++) {
+    const vi = vector[i];
+    let res = fr(m[index++] * vi);
+    for (let j = i + 1; j < n; j++, index++) {
+      res = fr(res + fr(m[index] * vector[j]));
+      result[j] = result[j] + fr(m[index] * vi);
+    }
+    result[i] = result[i] + res;
+  }
+}
+function vectorsSubtractionF(n, v1, v2, result) {
+  for (let i = 0; i < n; i++) result[i] = v1[i] - v2[i];
+}
+function vectorsMultAdditionF(n, v1, alpha, v2) {
+  const a = fr(alpha);
+  for (let i = 0; i < n; i++) v1[i] = v1[i] + fr(a * v2[i]);
+}
+function vectorsInnerProductF(n, v1, v2) {
+  let result = 0;
+  for (let i = 0; i < n; i++) result += fr(v1[i] * v2[i]);
+  return result;
+}
+function copyVectorF(n, src, dst) {
+  for (let i = 0; i < n; i++) dst[i] = src[i];
+}
+function maxAbsF(n, vec) {
+  let max = fr(-1e30);
+  for (let i = 0; i < n; i++) {
+    const a = fr(Math.abs(vec[i]));
+    if (a > max) max = a;
+  }
+  return max;
+}
+function squareVec(n, vec) {
+  for (let i = 0; i < n; i++) vec[i] = vec[i] * vec[i];
+}
+function invertVec(n, vec) {
+  for (let i = 0; i < n; i++) {
+    if (vec[i] !== 0) vec[i] = 1 / vec[i];
+  }
+}
+function sqrtVecF(n, source, target) {
+  for (let i = 0; i < n; i++) {
+    if (source[i] >= 0) target[i] = fr(Math.sqrt(source[i]));
+  }
+}
+function invertSqrtVec(n, vec) {
+  for (let i = 0; i < n; i++) {
+    if (vec[i] > 0) vec[i] = 1 / fr(Math.sqrt(vec[i]));
+  }
+}
+var BLOCK_NONE = 1;
+function innerProduct(n, v1, v2, block) {
+  let result = 0;
+  const blocked = block === BLOCK_NONE ? 0 : n - n % block;
+  let i = 0;
+  for (; i < blocked; i++) result += v1[i] * v2[i];
+  for (; i < n; i++) result = fma2(v1[i], v2[i], result);
+  return result;
+}
+function scadd(vec1, end, fac, vec2) {
+  for (let i = 0; i <= end; i++) vec1[i] = fma2(fac, vec2[i], vec1[i]);
+}
+function norm(vec, end, block) {
+  return Math.sqrt(innerProduct(end + 1, vec, vec, block));
+}
+function vectorsScalarMult(n, vector, alpha, result) {
+  for (let i = 0; i < n; i++) result[i] = vector[i] * alpha;
+}
+function copyVector(n, source, dest) {
+  for (let i = 0; i < n; i++) dest[i] = source[i];
+}
+function vectorsAddition(n, v1, v2, result) {
+  for (let i = 0; i < n; i++) result[i] = v1[i] + v2[i];
+}
+function vectorsSubtraction(n, v1, v2, result) {
+  for (let i = 0; i < n; i++) result[i] = v1[i] - v2[i];
+}
+function maxAbs(n, vector) {
+  let maxVal = -1e50;
+  for (let i = 0; i < n; i++) {
+    const a = Math.abs(vector[i]);
+    if (a > maxVal) maxVal = a;
+  }
+  return maxVal;
+}
+function rightMultWithVectorF(matrix, n, vector, result, block) {
+  const blocked = block === BLOCK_NONE ? 0 : n - n % block;
+  for (let i = 0; i < n; i++) {
+    const row = matrix[i];
+    let res = 0;
+    let j = 0;
+    for (; j < blocked; j++) res += row[j] * vector[j];
+    for (; j < n; j++) res = fma2(row[j], vector[j], res);
+    result[i] = res;
+  }
+}
+function rightMultWithVector(matrix, n, vector, result) {
+  for (let i = 0; i < n; i++) {
+    let res = 0;
+    const row = matrix[i];
+    for (let j = 0; j < row.nedges; j++) res = fma2(row.ewgts[j], vector[row.edges[j]], res);
+    result[i] = res;
+  }
+}
+var RANGE = 500;
+function initVecOrth1(n, vec) {
+  for (let i = 0; i < n; i++) vec[i] = crand() % RANGE;
+  orthog1(n, vec);
+}
+
+// src/layout/neato/conjgrad.ts
+var BLOCK_INITIAL_RR = 4;
+var BLOCK_P_AP = 8;
+function cgNextDirection(n, w, alpha, rR) {
+  vectorsScalarMult(n, w.Ap, alpha, w.Ap);
+  vectorsSubtraction(n, w.r, w.Ap, w.r);
+  const rRNew = innerProduct(n, w.r, w.r, BLOCK_NONE);
+  if (rR === 0) {
+    agerrorf("conjugate_gradient: unexpected length 0 vector\n");
+    return null;
+  }
+  const beta = rRNew / rR;
+  vectorsScalarMult(n, w.p, beta, w.p);
+  vectorsAddition(n, w.r, w.p, w.p);
+  return rRNew;
+}
+function cgStart(A3, x, b, n) {
+  const w = {
+    r: new Float64Array(n),
+    p: new Float64Array(n),
+    Ap: new Float64Array(n),
+    alphap: new Float64Array(n)
+  };
+  const Ax = new Float64Array(n);
+  const orthB = Float64Array.from(b.subarray(0, n));
+  orthog1(n, orthB);
+  orthog1(n, x);
+  rightMultWithVector(A3, n, x, Ax);
+  vectorsSubtraction(n, orthB, Ax, w.r);
+  w.p.set(w.r.subarray(0, n));
+  return w;
+}
+function conjugateGradient(A3, x, b, n, tol, maxIterations) {
+  const w = cgStart(A3, x, b, n);
+  let rR = innerProduct(n, w.r, w.r, BLOCK_INITIAL_RR);
+  for (let i = 0; i < maxIterations && maxAbs(n, w.r) > tol; i++) {
+    rightMultWithVector(A3, n, w.p, w.Ap);
+    const pAp = innerProduct(n, w.p, w.Ap, BLOCK_P_AP);
+    if (pAp === 0) break;
+    const alpha = rR / pAp;
+    vectorsScalarMult(n, w.p, alpha, w.alphap);
+    vectorsAddition(n, x, w.alphap, x);
+    if (i < maxIterations - 1) {
+      const next = cgNextDirection(n, w, alpha, rR);
+      if (next === null) return 1;
+      rR = next;
+    }
+  }
+  return 0;
+}
+var CGF_BLOCK_AX = 4;
+var CGF_BLOCK_AP = 4;
+var CGF_BLOCK_INITIAL_RR = 4;
+var CGF_BLOCK_P_AP = 8;
+function cgfInit(A3, x, b, n, ortho1) {
+  const orthB = new Float64Array(n);
+  copyVector(n, b, orthB);
+  if (ortho1) {
+    orthog1(n, orthB);
+    orthog1(n, x);
+  }
+  const Ax = new Float64Array(n);
+  rightMultWithVectorF(A3, n, x, Ax, CGF_BLOCK_AX);
+  const r = new Float64Array(n);
+  vectorsSubtraction(n, orthB, Ax, r);
+  const p = new Float64Array(n);
+  copyVector(n, r, p);
+  return {
+    r,
+    p,
+    Ap: new Float64Array(n),
+    alphap: new Float64Array(n),
+    rr: innerProduct(n, r, r, CGF_BLOCK_INITIAL_RR)
+  };
+}
+function cgfUpdate(n, alpha, st) {
+  vectorsScalarMult(n, st.Ap, alpha, st.Ap);
+  vectorsSubtraction(n, st.r, st.Ap, st.r);
+  const rrNew = innerProduct(n, st.r, st.r, BLOCK_NONE);
+  if (st.rr === 0) {
+    agerrorf("conjugate_gradient: unexpected length 0 vector\n");
+    return 1;
+  }
+  const beta = rrNew / st.rr;
+  st.rr = rrNew;
+  vectorsScalarMult(n, st.p, beta, st.p);
+  vectorsAddition(n, st.r, st.p, st.p);
+  return 0;
+}
+function conjugateGradientF(A3, x, b, n, opts) {
+  const { tol, maxIterations, ortho1 } = opts;
+  const st = cgfInit(A3, x, b, n, ortho1);
+  for (let i = 0; i < maxIterations && maxAbs(n, st.r) > tol; i++) {
+    rightMultWithVectorF(A3, n, st.p, st.Ap, CGF_BLOCK_AP);
+    const pAp = innerProduct(n, st.p, st.Ap, CGF_BLOCK_P_AP);
+    if (pAp === 0) break;
+    const alpha = st.rr / pAp;
+    vectorsScalarMult(n, st.p, alpha, st.alphap);
+    vectorsAddition(n, x, st.alphap, x);
+    if (i < maxIterations - 1 && cgfUpdate(n, alpha, st) === 1) return 1;
   }
-  bfsFixDisconnected(n, dist4, closestDist);
+  return 0;
 }
 
 // src/layout/neato/stress.ts
+var TOLERANCE_CG = 1e-3;
 var DFLT_ITERATIONS = 200;
+var OPT_SMART_INIT = 4;
+function mdsModel(graph, nG) {
+  if (graph[0].ewgts.length === 0) return null;
+  const Dij = computeWeightedApspPacked(graph, nG);
+  let shift = 0;
+  for (let i = 0; i < nG; i++) {
+    shift += i;
+    for (let e = 1; e < graph[i].nedges; e++) {
+      const j = graph[i].edges[e];
+      if (j < i) continue;
+      Dij[i * nG + j - shift] = graph[i].ewgts[e];
+    }
+  }
+  return Dij;
+}
 
 // src/layout/neato/sgd-dijkstra.ts
-var FLT_MAX = 34028234663852886e22;
+var FLT_MAX2 = 34028234663852886e22;
 var left = (i) => 2 * i;
 var right = (i) => 2 * i + 1;
 var parent = (i) => Math.trunc(i / 2);
-var greaterPriority = (h, i, j, dist4) => dist4[h.data[i]] < dist4[h.data[j]];
+var greaterPriority = (h, i, j, dist5) => dist5[h.data[i]] < dist5[h.data[j]];
 function exchange2(h, i, j) {
   const t = h.data[i];
   h.data[i] = h.data[j];
@@ -36594,19 +37209,19 @@ function exchange2(h, i, j) {
   h.index[h.data[i]] = i;
   h.index[h.data[j]] = j;
 }
-function heapify(h, start, dist4) {
+function heapify(h, start, dist5) {
   let i = start;
   for (; ; ) {
     const l = left(i);
     const r = right(i);
-    let largest = l < h.heapSize && greaterPriority(h, l, i, dist4) ? l : i;
-    if (r < h.heapSize && greaterPriority(h, r, largest, dist4)) largest = r;
+    let largest = l < h.heapSize && greaterPriority(h, l, i, dist5) ? l : i;
+    if (r < h.heapSize && greaterPriority(h, r, largest, dist5)) largest = r;
     if (largest === i) break;
     exchange2(h, largest, i);
     i = largest;
   }
 }
-function initHeap(startVertex, dist4, n) {
+function initHeap(startVertex, dist5, n) {
   const h = {
     data: new Int32Array(Math.max(n - 1, 0)),
     heapSize: n - 1,
@@ -36618,23 +37233,23 @@ function initHeap(startVertex, dist4, n) {
     h.data[count] = i;
     h.index[i] = count++;
   }
-  for (let j = Math.trunc((n - 1) / 2); j >= 0; j--) heapify(h, j, dist4);
+  for (let j = Math.trunc((n - 1) / 2); j >= 0; j--) heapify(h, j, dist5);
   return h;
 }
-function extractMax(h, dist4) {
+function extractMax(h, dist5) {
   if (h.heapSize === 0) return -1;
   const max = h.data[0];
   h.data[0] = h.data[h.heapSize - 1];
   h.index[h.data[0]] = 0;
   h.heapSize--;
-  heapify(h, 0, dist4);
+  heapify(h, 0, dist5);
   return max;
 }
-function increaseKey(h, v, newDist, dist4) {
-  if (dist4[v] <= newDist) return;
-  dist4[v] = newDist;
+function increaseKey(h, v, newDist, dist5) {
+  if (dist5[v] <= newDist) return;
+  dist5[v] = newDist;
   let i = h.index[v];
-  while (i > 0 && dist4[h.data[parent(i)]] > newDist) {
+  while (i > 0 && dist5[h.data[parent(i)]] > newDist) {
     h.data[i] = h.data[parent(i)];
     h.index[h.data[i]] = i;
     i = parent(i);
@@ -36643,7 +37258,7 @@ function increaseKey(h, v, newDist, dist4) {
   h.index[v] = i;
 }
 function dijkstraSgd(graph, source, terms) {
-  const dists = new Float32Array(graph.n).fill(FLT_MAX);
+  const dists = new Float32Array(graph.n).fill(FLT_MAX2);
   dists[source] = 0;
   for (let i = graph.sources[source]; i < graph.sources[source + 1]; i++) {
     dists[graph.targets[i]] = graph.weights[i];
@@ -36652,7 +37267,7 @@ function dijkstraSgd(graph, source, terms) {
   let offset = 0;
   for (let closest = extractMax(h, dists); closest >= 0; closest = extractMax(h, dists)) {
     const d = dists[closest];
-    if (d === FLT_MAX) break;
+    if (d === FLT_MAX2) break;
     if (graph.pinneds[closest] || closest < source) {
       terms[offset++] = { i: source, j: closest, d, w: Math.fround(1 / Math.fround(d * d)) };
     }
@@ -36671,7 +37286,7 @@ function lenattr(ep, g) {
   const val2 = /^\s*[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?/.exec(s);
   const len = val2 === null ? Number.NaN : parseFloat(val2[0]);
   if (Number.isNaN(len) || len < 0 || len === 0) {
-    agerrLineOn("warn", `bad edge len "${s}" in ${g.name} - setting to ${DEFAULT_EDGE_LEN.toFixed(2)}`);
+    agwarningf(`bad edge len "${s}" in ${g.name} - setting to ${DEFAULT_EDGE_LEN.toFixed(2)}`);
     return DEFAULT_EDGE_LEN;
   }
   return len;
@@ -36835,12 +37450,11 @@ function neatoMode(g) {
   if (str === void 0 || str === "") return MODE_MAJOR;
   const mode = modeByName().get(str);
   if (mode !== void 0) return mode;
-  agerrLineOn("warn", `Illegal value ${str} for attribute "mode" in graph ${g.root.name} - ignored`);
+  agwarningf(`Illegal value ${str} for attribute "mode" in graph ${g.root.name} - ignored`);
   return MODE_MAJOR;
 }
 function checkMode(g, mode) {
-  const value = g.root.attrs.get("mode") || (mode === MODE_HIER ? "hier" : "ipsep");
-  if (mode === MODE_HIER) unsupported("mode", value, "hierarchical stress majorization");
+  const value = g.root.attrs.get("mode") || "ipsep";
   if (mode === MODE_IPSEP && ipsepHasConstraints(g)) {
     unsupported("mode", value, "constrained (ipsep) majorization");
   }
@@ -37193,10 +37807,10 @@ function solve(a, b, c, n) {
 }
 
 // src/layout/neato/kk-paths.ts
-function newPathState(n, dist4, adj, initialDist2) {
+function newPathState(n, dist5, adj, initialDist2) {
   return {
     n,
-    dist: dist4,
+    dist: dist5,
     adj,
     initialDist: initialDist2,
     heap: new Int32Array(n + 1),
@@ -37274,10 +37888,10 @@ function s1(s, src) {
 function shortestPath2(s) {
   for (let v = 0; v < s.n; v++) s1(s, v);
 }
-function mdsModel(dist4, n, edges) {
+function mdsModel2(dist5, n, edges) {
   for (const { tailSeq: i, headSeq: j, len } of edges) {
     if (i === j) continue;
-    for (const k of [i * n + j, j * n + i]) if (k < dist4.length) dist4[k] = len;
+    for (const k of [i * n + j, j * n + i]) if (k < dist5.length) dist5[k] = len;
   }
 }
 
@@ -37370,12 +37984,12 @@ function initialPositions2(g, st) {
   }
 }
 function distvec(p0, p1, del) {
-  let dist4 = 0;
+  let dist5 = 0;
   for (let k = 0; k < NDIM; k++) {
     del[k] = p0[k] - p1[k];
-    dist4 += del[k] * del[k];
+    dist5 += del[k] * del[k];
   }
-  return Math.sqrt(dist4);
+  return Math.sqrt(dist5);
 }
 function springFactors(g) {
   const byEnds = /* @__PURE__ */ new Map();
@@ -37392,9 +38006,9 @@ function fillRow(st, i, del) {
   const vi = st.nodes[i];
   for (let j = 0; j < st.n; j++) {
     if (i === j) continue;
-    const dist4 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
+    const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
     for (let k = 0; k < NDIM; k++) {
-      const v = st.spring[i * st.n + j] * (del[k] - st.dist[i * st.n + j] * del[k] / dist4);
+      const v = st.spring[i * st.n + j] * (del[k] - st.dist[i * st.n + j] * del[k] / dist5);
       st.t[(i * st.n + j) * NDIM + k] = v;
       st.sumT[i * NDIM + k] += v;
     }
@@ -37423,9 +38037,9 @@ function updateArrays(st, i) {
   for (let k = 0; k < NDIM; k++) st.sumT[i * NDIM + k] = 0;
   for (let j = 0; j < n; j++) {
     if (i === j) continue;
-    const dist4 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
+    const dist5 = distvec(vi.info.pos, st.nodes[j].info.pos, del);
     for (let k = 0; k < NDIM; k++) {
-      const tij = st.spring[i * n + j] * (del[k] - st.dist[i * n + j] * del[k] / dist4);
+      const tij = st.spring[i * n + j] * (del[k] - st.dist[i * n + j] * del[k] / dist5);
       st.t[(i * n + j) * NDIM + k] = tij;
       st.sumT[i * NDIM + k] += tij;
       const old = st.t[(j * n + i) * NDIM + k];
@@ -37492,7 +38106,7 @@ function moveNode(st, m) {
 function solveModel(g, st) {
   for (let m = chooseNode(st); m >= 0; m = chooseNode(st)) moveNode(st, m);
   if (st.move === st.maxIter) {
-    agerrLineOn("warn", `Max. iterations (${st.maxIter}) reached on graph ${g.name}`);
+    agwarningf(`Max. iterations (${st.maxIter}) reached on graph ${g.name}`);
   }
 }
 function mdsEdges(g, nodes, lens) {
@@ -37505,84 +38119,852 @@ function kkNeato(g, nG, model) {
   if (nG < 2 || maxIter < 0) return;
   const { st, adj, ini, lens } = scanGraphMode(g, maxIter);
   shortestPath2(newPathState(st.n, st.dist, adj, ini));
-  if (model === MODEL_MDS2) mdsModel(st.dist, st.n, mdsEdges(g, st.nodes, lens));
+  if (model === MODEL_MDS2) mdsModel2(st.dist, st.n, mdsEdges(g, st.nodes, lens));
   initialPositions2(g, st);
   diffeqModel(g, st);
   solveModel(g, st);
 }
 
-// src/layout/neato/matrix-ops.ts
-var fr = Math.fround;
-function orthog1(n, vec) {
-  let sum = 0;
-  for (let i = 0; i < n; i++) sum += vec[i];
-  sum /= n;
-  for (let i = 0; i < n; i++) vec[i] = vec[i] - sum;
+// src/layout/neato/make-graph-data.ts
+var MODE_IPSEP2 = 3;
+var EDIST_IN = 1;
+var EDIST_OUT = -1;
+var EDIST_NONE = 0;
+function graphHasLen(g) {
+  for (const e of g.edges) {
+    if (e.attrs.has("len")) return true;
+  }
+  return false;
 }
-function orthog1f(n, vec) {
-  let sum = fr(0);
-  for (let i = 0; i < n; i++) sum = fr(sum + vec[i]);
-  sum = fr(sum / n);
-  for (let i = 0; i < n; i++) vec[i] = vec[i] - sum;
+var edistsOf = (v) => v.edists;
+function reverseBackEdge(graph, i, e, mode) {
+  const node = graph[i];
+  const j = node.edges[e];
+  edistsOf(node)[e] = mode === MODE_IPSEP2 ? EDIST_OUT : EDIST_IN;
+  const target = graph[j];
+  let f = 1;
+  while (f < target.nedges && target.edges[f] !== i) f++;
+  if (f >= target.nedges) throw new Error(`neato: edge ${i}-${j} has no reverse entry`);
+  edistsOf(target)[f] = EDIST_OUT;
+}
+function dfsCycle(graph, start, st) {
+  const { mode, mark, onstack } = st;
+  const stack = [{ i: start, e: 1 }];
+  mark[start] = 1;
+  onstack[start] = 1;
+  for (let frame = stack.at(-1); frame !== void 0; frame = stack.at(-1)) {
+    const { i } = frame;
+    const node = graph[i];
+    if (frame.e >= node.nedges) {
+      onstack[i] = 0;
+      stack.pop();
+      continue;
+    }
+    const e = frame.e++;
+    if (edistsOf(node)[e] === EDIST_IN) continue;
+    const j = node.edges[e];
+    if (onstack[j]) {
+      reverseBackEdge(graph, i, e, mode);
+    } else if (!mark[j]) {
+      mark[j] = 1;
+      onstack[j] = 1;
+      stack.push({ i: j, e: 1 });
+    }
+  }
 }
-function rightMultWithVectorFF(m, n, vector, result) {
+function acyclic2(graph, nv, mode) {
+  const st = { mode, mark: new Uint8Array(nv), onstack: new Uint8Array(nv) };
+  for (let i = 0; i < nv; i++) {
+    if (st.mark[i]) continue;
+    dfsCycle(graph, i, st);
+  }
+}
+function edgeDist2(dir, np, head) {
+  if (dir !== void 0 && dir.startsWith("none")) return EDIST_NONE;
+  return np === head ? EDIST_IN : EDIST_OUT;
+}
+function addNeighbours(g, np, entry, o) {
+  const seen2 = /* @__PURE__ */ new Map();
+  for (const ep of [...np.outEdges(g), ...np.inEdges(g)]) {
+    if (ep.head === ep.tail) continue;
+    const vp = ep.tail === np ? ep.head : ep.tail;
+    const vid = vp.info.id;
+    const dist5 = o.haveLen ? lateDouble(ep.attrs.get("len"), 1, 0) : 1;
+    const idx = seen2.get(vid);
+    if (idx !== void 0) {
+      if (o.haveLen) entry.ewgts[idx] = Math.max(entry.ewgts[idx], dist5);
+      continue;
+    }
+    seen2.set(vid, entry.nedges);
+    entry.edges.push(vid);
+    if (o.haveLen || o.haveDir) entry.ewgts.push(dist5);
+    if (o.haveDir) edistsOf(entry).push(edgeDist2(ep.attrs.get("dir"), np, ep.head));
+    entry.nedges++;
+  }
+}
+function makeGraphDataC(g, nodeList, haveLen, haveDir, mode = -1) {
+  const vtx = nodeList.map((_, i) => ({
+    nedges: 1,
+    edges: [i],
+    ewgts: haveLen || haveDir ? [0] : [],
+    ...haveDir ? { edists: [0] } : {}
+  }));
+  for (const np of nodeList) addNeighbours(g, np, vtx[np.info.id], { haveLen, haveDir });
+  if (haveDir) acyclic2(vtx, nodeList.length, mode);
+  return vtx;
+}
+
+// src/layout/neato/kkutils.ts
+function compareKeys(a, b) {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+function gvSortByPlace(place, ordering, first, count) {
+  const slice = Array.from(ordering.subarray(first, first + count));
+  gvQsort(slice, (x, y) => compareKeys(place[x], place[y]));
+  for (let i = 0; i < count; i++) ordering[first + i] = slice[i];
+}
+function quicksortPlace(place, ordering, size) {
+  gvSortByPlace(place, ordering, 0, size);
+}
+function quicksortPlacef(place, ordering, first, last) {
+  if (first < last) {
+    gvSortByPlace(place, ordering, first, last - first + 1);
+  }
+}
+function computeApspDijkstra(graph, n) {
+  const dij = [];
+  for (let i = 0; i < n; i++) dij.push(new Int32Array(n));
+  for (let i = 0; i < n; i++) ngdijkstra(i, graph, n, dij[i]);
+  return dij;
+}
+function computeApspSimple(graph, n) {
+  const dij = [];
+  for (let i = 0; i < n; i++) dij.push(new Int32Array(n));
+  for (let i = 0; i < n; i++) bfs(i, graph, n, dij[i]);
+  return dij;
+}
+function computeApsp(graph, n) {
+  return graph[0].ewgts.length > 0 ? computeApspDijkstra(graph, n) : computeApspSimple(graph, n);
+}
+
+// src/layout/neato/quad-prog-solve.ts
+var fr2 = Math.fround;
+var TOLERANCE = fr2(0.01);
+var BOUND = 1e9;
+var BLOCK_EPSILON = 1e-9;
+var NO_SPLIT = -1;
+var BITS = new DataView(new ArrayBuffer(8));
+function oddNeighbour(s, awayFromZero) {
+  BITS.setFloat64(0, s);
+  const hi = BITS.getUint32(0);
+  const lo = BITS.getUint32(4);
+  if (awayFromZero) {
+    BITS.setUint32(4, lo + 1);
+  } else if (lo === 0) {
+    BITS.setUint32(0, hi - 1);
+    BITS.setUint32(4, 4294967295);
+  } else {
+    BITS.setUint32(4, lo - 1);
+  }
+  return BITS.getFloat64(0);
+}
+function fmaf(a, b, c) {
+  const p = a * b;
+  const s = p + c;
+  const bv = s - p;
+  const err = p - (s - bv) + (c - bv);
+  if (err === 0 || !Number.isFinite(s)) return fr2(s);
+  BITS.setFloat64(0, s);
+  if ((BITS.getUint32(4) & 1) !== 0) return fr2(s);
+  return fr2(oddNeighbour(s, err > 0 === s > 0));
+}
+function blockPlaceNumerator(blockDeg, desPlaceBlock, negLapTimesDesired, toBlockConnectivity, curPlace) {
+  const t = fmaf(blockDeg, desPlaceBlock, negLapTimesDesired);
+  return fmaf(toBlockConnectivity, curPlace, t);
+}
+function equals(a, b) {
+  return Math.abs(fr2(a - b)) < TOLERANCE;
+}
+function fminf(a, b) {
+  if (Number.isNaN(a)) return b;
+  if (Number.isNaN(b)) return a;
+  return a < b ? a : b;
+}
+function fmaxf(a, b) {
+  if (Number.isNaN(a)) return b;
+  if (Number.isNaN(b)) return a;
+  return a > b ? a : b;
+}
+function unpackMatrix(packedMat, n) {
+  const flat = new Float32Array(n * n);
+  const mat = new Array(n);
+  for (let i = 0; i < n; i++) mat[i] = flat.subarray(i * n, (i + 1) * n);
+  for (let i = 0, k = 0; i < n; i++) {
+    for (let j = i; j < n; j++, k++) {
+      mat[j][i] = mat[i][j] = packedMat[k];
+    }
+  }
+  return mat;
+}
+function ensureMonotonicOrderingWithGaps(place, n, ordering, levels, numLevels, levelsGap) {
+  let lowerBound = fr2(-1e9);
+  let level = -1;
+  let maxInLevel = 0;
+  for (let i = 0; i < n; i++) {
+    if (i >= maxInLevel) {
+      level++;
+      maxInLevel = level === numLevels ? n : levels[level];
+      lowerBound = i > 0 ? fr2(place[ordering[i - 1]] + levelsGap) : fr2(-1e9);
+      quicksortPlacef(place, ordering, i, maxInLevel - 1);
+    }
+    const node = ordering[i];
+    if (place[node] < lowerBound) place[node] = lowerBound;
+  }
+}
+function computeNodeLevels(e) {
+  const lev = new Int32Array(e.n);
+  let level = -1;
+  let maxInLevel = 0;
+  for (let i = 0; i < e.n; i++) {
+    if (i >= maxInLevel) {
+      level++;
+      maxInLevel = level === e.numLevels ? e.n : e.levels[level];
+    }
+    lev[e.ordering[i]] = level;
+  }
+  return lev;
+}
+function growBlock(c, left2, curPlace) {
+  const { place, lev, levelsGap, e } = c;
+  const gap = e.fArray4;
+  let targetPlace = curPlace;
+  gap[e.ordering[left2]] = 0;
+  let right2;
+  for (right2 = left2 + 1; right2 < e.n; right2++) {
+    if (lev[right2] > lev[right2 - 1]) {
+      targetPlace = fr2(targetPlace + levelsGap);
+    }
+    const node = e.ordering[right2];
+    if (Math.abs(fr2(place[node] - targetPlace)) > BLOCK_EPSILON) break;
+    gap[node] = fr2(place[node] - curPlace);
+  }
+  return right2;
+}
+function computeDesiredPlaces(c, left2, right2) {
+  const { e, place, b } = c;
+  for (let i = left2; i < right2; i++) {
+    const node = e.ordering[i];
+    let newPlaceI = -b[node];
+    const lapNode = e.A[node];
+    for (let j = 0; j < e.n; j++) {
+      if (j === node) continue;
+      newPlaceI = fmaf(lapNode[j], place[j], newPlaceI);
+    }
+    e.fArray1[node] = fr2(fr2(newPlaceI / -lapNode[node]) - e.fArray4[node]);
+  }
+}
+function collectWhere(c, from, to, test) {
+  for (let j = from; j < to; j++) {
+    const node = c.e.ordering[j];
+    if (test(c.e.fArray1[node])) c.block.push(node);
+  }
+}
+function orderBlockByLevels(c, left2, right2, curPlace) {
+  const { e } = c;
+  c.block.length = 0;
+  let firstNextLevel = 0;
+  for (let i = left2; i < right2; i = firstNextLevel) {
+    const level = c.lev[e.ordering[i]];
+    firstNextLevel = level === e.numLevels ? right2 : Math.min(right2, e.levels[level]);
+    collectWhere(c, i, firstNextLevel, (d) => d < curPlace);
+    collectWhere(c, i, firstNextLevel, (d) => d === curPlace);
+    collectWhere(c, i, firstNextLevel, (d) => d > curPlace);
+  }
+}
+function computePrefixDesiredPlaces(c, curPlace) {
+  const { e, block } = c;
+  let desPlaceBlock = 0;
+  let blockDeg = 0;
+  for (let i = 0; i < block.length; i++) {
+    const node = block[i];
+    let toBlockConnectivity = 0;
+    const lapNode = e.A[node];
+    for (let j = 0; j < i; j++) {
+      toBlockConnectivity = fr2(toBlockConnectivity - lapNode[block[j]]);
+    }
+    toBlockConnectivity = fr2(toBlockConnectivity * 2);
+    const num2 = blockPlaceNumerator(
+      blockDeg,
+      desPlaceBlock,
+      fr2(-lapNode[node] * e.fArray1[node]),
+      toBlockConnectivity,
+      curPlace
+    );
+    desPlaceBlock = fr2(num2 / fr2(fr2(blockDeg - lapNode[node]) + toBlockConnectivity));
+    e.fArray2[i] = desPlaceBlock;
+    blockDeg = fr2(blockDeg + fr2(toBlockConnectivity - lapNode[node]));
+  }
+  if (e.n >= 0 && block.length === e.n) {
+    e.fArray2[e.n - 1] = curPlace;
+  }
+}
+function computeSuffixDesiredPlaces(c, curPlace) {
+  const { e, block } = c;
+  let desPlaceBlock = 0;
+  let blockDeg = 0;
+  for (let i = block.length - 1; i >= 0; i--) {
+    const node = block[i];
+    let toBlockConnectivity = 0;
+    const lapNode = e.A[node];
+    for (let j = i + 1; j < block.length; j++) {
+      toBlockConnectivity = fr2(toBlockConnectivity - lapNode[block[j]]);
+    }
+    toBlockConnectivity = fr2(toBlockConnectivity * 2);
+    const num2 = blockPlaceNumerator(
+      blockDeg,
+      desPlaceBlock,
+      fr2(-lapNode[node] * e.fArray1[node]),
+      toBlockConnectivity,
+      curPlace
+    );
+    desPlaceBlock = fr2(num2 / fr2(fr2(blockDeg - lapNode[node]) + toBlockConnectivity));
+    e.fArray3[i] = desPlaceBlock;
+    blockDeg = fr2(blockDeg + fr2(toBlockConnectivity - lapNode[node]));
+  }
+  if (e.n >= 0 && block.length === e.n) {
+    e.fArray3[0] = curPlace;
+  }
+}
+var LIMITED = new Float64Array(2);
+function limitMoves(prefix, suffix, curPlace) {
+  if (suffix < prefix) {
+    if (suffix < curPlace) {
+      if (prefix > curPlace) prefix = curPlace;
+      suffix = prefix;
+    } else if (prefix > curPlace) {
+      prefix = suffix;
+    }
+  }
+  LIMITED[0] = prefix;
+  LIMITED[1] = suffix;
+}
+function findBestSplit(c, curPlace) {
+  const { e, block } = c;
+  let bestI = NO_SPLIT;
+  let maxMovement = 0;
+  for (let i = 0; i < block.length; i++) {
+    const suffixDesPlace = e.fArray3[i];
+    const prefixDesPlace = i > 0 ? e.fArray2[i - 1] : suffixDesPlace;
+    limitMoves(prefixDesPlace, suffixDesPlace, curPlace);
+    const movement = (block.length - i) * Math.abs(fr2(LIMITED[1] - curPlace)) + i * Math.abs(fr2(LIMITED[0] - curPlace));
+    if (movement > maxMovement) {
+      maxMovement = movement;
+      bestI = i;
+    }
+  }
+  return bestI;
+}
+function computeUpperBound(c, right2) {
+  const { e, place, lev, levelsGap, block } = c;
+  if (right2 >= e.n) return BOUND;
+  const lastGap = e.fArray4[block[block.length - 1]];
+  const nextPlace = place[e.ordering[right2]];
+  if (lev[e.ordering[right2]] > lev[e.ordering[right2 - 1]]) {
+    return fr2(fr2(nextPlace - levelsGap) - lastGap);
+  }
+  return fr2(nextPlace - lastGap);
+}
+function nextLowerBound(c, right2) {
+  const { e, place, lev, levelsGap, block } = c;
+  const last = place[block[block.length - 1]];
+  if (right2 < e.n && lev[e.ordering[right2]] > lev[e.ordering[right2 - 1]]) {
+    return fr2(last + levelsGap);
+  }
+  return last;
+}
+function moveSplitBlock(c, bestI, left2, right2, curPlace) {
+  const { e, place, block } = c;
+  let suffixDesPlace = e.fArray3[bestI];
+  let prefixDesPlace = bestI > 0 ? e.fArray2[bestI - 1] : suffixDesPlace;
+  suffixDesPlace = fminf(suffixDesPlace, computeUpperBound(c, right2));
+  prefixDesPlace = fmaxf(prefixDesPlace, c.lowerBound);
+  limitMoves(prefixDesPlace, suffixDesPlace, curPlace);
+  prefixDesPlace = LIMITED[0];
+  suffixDesPlace = LIMITED[1];
+  for (let i = 0; i < bestI; i++) {
+    place[block[i]] = fr2(prefixDesPlace + e.fArray4[block[i]]);
+  }
+  for (let i = bestI; i < block.length; i++) {
+    place[block[i]] = fr2(suffixDesPlace + e.fArray4[block[i]]);
+  }
+  c.lowerBound = nextLowerBound(c, right2);
+  for (let i = left2; i < right2; i++) e.ordering[i] = block[i - left2];
+  c.converged = c.converged && equals(prefixDesPlace, curPlace) && equals(suffixDesPlace, curPlace);
+}
+function processBlock(c, left2) {
+  const curPlace = c.place[c.e.ordering[left2]];
+  const right2 = growBlock(c, left2, curPlace);
+  computeDesiredPlaces(c, left2, right2);
+  orderBlockByLevels(c, left2, right2, curPlace);
+  computePrefixDesiredPlaces(c, curPlace);
+  computeSuffixDesiredPlaces(c, curPlace);
+  const bestI = findBestSplit(c, curPlace);
+  if (bestI !== NO_SPLIT) {
+    moveSplitBlock(c, bestI, left2, right2, curPlace);
+  } else {
+    c.lowerBound = nextLowerBound(c, right2);
+  }
+  return right2;
+}
+function constrainedMajorizationNewWithGaps(e, b, coords, curAxis, maxIterations, levelsGap) {
+  const place = coords[curAxis];
+  if (maxIterations <= 0) return;
+  const gap = fr2(levelsGap);
+  ensureMonotonicOrderingWithGaps(place, e.n, e.ordering, e.levels, e.numLevels, gap);
+  const c = {
+    e,
+    place,
+    b,
+    lev: computeNodeLevels(e),
+    levelsGap: gap,
+    block: [],
+    lowerBound: fr2(-BOUND),
+    converged: false
+  };
+  for (let counter = 0; counter < maxIterations && !c.converged; counter++) {
+    c.converged = true;
+    c.lowerBound = fr2(-BOUND);
+    for (let left2 = 0, right2; left2 < e.n; left2 = right2) {
+      right2 = processBlock(c, left2);
+    }
+    orthog1f(e.n, place);
+  }
+}
+function initConstrainedMajorization(packedMat, n, ordering, levels, numLevels) {
+  return {
+    A: unpackMatrix(packedMat, n),
+    n,
+    fArray1: new Float32Array(n),
+    fArray2: new Float32Array(n),
+    fArray3: new Float32Array(n),
+    fArray4: new Float32Array(n),
+    ordering,
+    levels,
+    numLevels
+  };
+}
+
+// src/layout/neato/conjgrad-mkernel.ts
+var fr3 = Math.fround;
+var RIGHT_MULT_BLOCK = 16;
+var ZERO_LENGTH_MESSAGE = "conjugate_gradient: unexpected length 0 vector\n";
+function rightMultWithVectorFFFused(m, n, vector, result) {
   for (let i = 0; i < n; i++) result[i] = 0;
   let index = 0;
   for (let i = 0; i < n; i++) {
     const vi = vector[i];
-    let res = fr(m[index++] * vi);
+    let res = fmaf(m[index++], vi, 0);
+    const len = n - i - 1;
+    const blockEnd = i + 1 + (len - len % RIGHT_MULT_BLOCK);
     for (let j = i + 1; j < n; j++, index++) {
-      res = fr(res + fr(m[index] * vector[j]));
-      result[j] = result[j] + fr(m[index] * vi);
+      const mij = m[index];
+      res = j < blockEnd ? fr3(res + fr3(mij * vector[j])) : fmaf(mij, vector[j], res);
+      result[j] = fmaf(mij, vi, result[j]);
     }
     result[i] = result[i] + res;
   }
 }
-function vectorsSubtractionF(n, v1, v2, result) {
-  for (let i = 0; i < n; i++) result[i] = v1[i] - v2[i];
+function vectorsMultAdditionFused(n, v1, alpha, v2) {
+  for (let i = 0; i < n; i++) v1[i] = fmaf(alpha, v2[i], v1[i]);
 }
-function vectorsMultAdditionF(n, v1, alpha, v2) {
-  const a = fr(alpha);
-  for (let i = 0; i < n; i++) v1[i] = v1[i] + fr(a * v2[i]);
+var CgStep = { CONTINUE: 0, STOP: 1, ERROR: 2 };
+function initialState(A3, x, b, n) {
+  const Ax = new Float32Array(n);
+  const st = { n, r: new Float32Array(n), p: new Float32Array(n), Ap: new Float32Array(n), rR: 0 };
+  orthog1f(n, x);
+  orthog1f(n, b);
+  rightMultWithVectorFFFused(A3, n, x, Ax);
+  orthog1f(n, Ax);
+  vectorsSubtractionF(n, b, Ax, st.r);
+  copyVectorF(n, st.r, st.p);
+  st.rR = vectorsInnerProductF(n, st.r, st.r);
+  return st;
 }
-function vectorsInnerProductF(n, v1, v2) {
-  let result = 0;
-  for (let i = 0; i < n; i++) result += fr(v1[i] * v2[i]);
-  return result;
+function cgIteration(A3, x, st, last) {
+  const { n, r, p, Ap } = st;
+  orthog1f(n, p);
+  orthog1f(n, x);
+  orthog1f(n, r);
+  rightMultWithVectorFFFused(A3, n, p, Ap);
+  orthog1f(n, Ap);
+  const pAp = vectorsInnerProductF(n, p, Ap);
+  if (pAp === 0) return CgStep.STOP;
+  const alpha = st.rR / pAp;
+  vectorsMultAdditionFused(n, x, fr3(alpha), p);
+  if (last) return CgStep.CONTINUE;
+  vectorsMultAdditionFused(n, r, fr3(-alpha), Ap);
+  const rRNew = vectorsInnerProductF(n, r, r);
+  if (st.rR === 0) {
+    agerrorf(ZERO_LENGTH_MESSAGE);
+    return CgStep.ERROR;
+  }
+  const beta = fr3(rRNew / st.rR);
+  st.rR = rRNew;
+  for (let j = 0; j < n; j++) p[j] = fmaf(beta, p[j], r[j]);
+  return CgStep.CONTINUE;
+}
+function conjugateGradientMkernelFused(A3, x, b, n, o) {
+  const st = initialState(A3, x, b, n);
+  for (let i = 0; i < o.maxIterations && maxAbsF(n, st.r) > o.tol; i++) {
+    const step = cgIteration(A3, x, st, i >= o.maxIterations - 1);
+    if (step === CgStep.STOP) break;
+    if (step === CgStep.ERROR) return 1;
+  }
+  return 0;
 }
-function copyVectorF(n, src, dst) {
-  for (let i = 0; i < n; i++) dst[i] = src[i];
+
+// src/layout/neato/opt-arrangement.ts
+var HIERARCHY_CG_TOL = 1e-3;
+function constructB(graph, n, b) {
+  for (let i = 0; i < n; i++) {
+    if (graph[0].edists == null) continue;
+    let bI = 0;
+    const node = graph[i];
+    for (let j = 1; j < node.nedges; j++) {
+      bI += Math.fround(Math.fround(node.ewgts[j]) * node.edists[j]);
+    }
+    b[i] = bI;
+  }
 }
-function maxAbsF(n, vec) {
-  let max = fr(-1e30);
+function setUniformWeights(graph, n) {
+  const old = [];
   for (let i = 0; i < n; i++) {
-    const a = fr(Math.abs(vec[i]));
-    if (a > max) max = a;
+    const node = graph[i];
+    old.push(node.ewgts);
+    const weights = new Array(node.nedges).fill(1);
+    weights[0] = -(node.nedges - 1);
+    node.ewgts = weights;
   }
-  return max;
+  return old;
 }
-function squareVec(n, vec) {
-  for (let i = 0; i < n; i++) vec[i] = vec[i] * vec[i];
+function computeYCoords(graph, n, yCoords, maxIterations) {
+  let rv = 0;
+  const b = new Float64Array(n);
+  constructB(graph, n, b);
+  initVecOrth1(n, yCoords);
+  const oldEwgts = setUniformWeights(graph, n);
+  if (conjugateGradient(graph, yCoords, b, n, HIERARCHY_CG_TOL, maxIterations) < 0) {
+    rv = 1;
+  }
+  for (let i = 0; i < n; i++) graph[i].ewgts = oldEwgts[i];
+  return rv;
 }
-function invertVec(n, vec) {
+
+// src/layout/neato/compute-hierarchy.ts
+function countLevels(y, ordering, n, tol) {
+  let numLevels = 0;
+  for (let i = 1; i < n; i++) {
+    if (y[ordering[i]] - y[ordering[i - 1]] > tol) numLevels++;
+  }
+  return numLevels;
+}
+function fillLevels(y, ordering, n, tol, numLevels) {
+  if (numLevels === 0) {
+    const levels2 = new Int32Array(1);
+    levels2[0] = n;
+    return levels2;
+  }
+  const levels = new Int32Array(numLevels);
+  let count = 0;
+  for (let i = 1; i < n; i++) {
+    if (y[ordering[i]] - y[ordering[i - 1]] > tol) levels[count++] = i;
+  }
+  return levels;
+}
+function computeHierarchy(graph, n, absTol, relTol, given) {
+  let y;
+  if (given) {
+    y = given;
+  } else {
+    y = new Float64Array(n);
+    if (computeYCoords(graph, n, y, n)) return null;
+  }
+  const ordering = new Int32Array(n);
+  for (let i = 0; i < n; i++) ordering[i] = i;
+  quicksortPlace(y, ordering, n);
+  const hierarchySpan = y[ordering[n - 1]] - y[ordering[0]];
+  const relative = relTol * hierarchySpan / (n - 1);
+  const tol = absTol > relative ? absTol : relative;
+  const numLevels = countLevels(y, ordering, n, tol);
+  return { ordering, levels: fillLevels(y, ordering, n, tol, numLevels), numLevels };
+}
+
+// src/layout/neato/smart-ini-x.ts
+var fr4 = Math.fround;
+var SCALE_FACTOR = 256;
+var DBL_EPSILON = 2220446049250313e-31;
+var POWER_LENGTH_FLOOR = 1e-10;
+var BLOCK_STANDARDIZE_NORM = 4;
+var BLOCK_MAT_MULT_ROW = 4;
+var BLOCK_MAT_MULT_ORTHOG = 8;
+var BLOCK_GUESS_ORTHOG = 8;
+var BLOCK_GUESS_LEN = BLOCK_NONE;
+var BLOCK_LOOP_LEN = BLOCK_NONE;
+var BLOCK_ANGLE = 8;
+var BLOCK_UNIFORM_SUMS = 4;
+var BLOCK_AVGS = 4;
+function standardize(orthog, nvtxs) {
+  let avg = 0;
+  for (let i = 0; i < nvtxs; i++) avg += orthog[i];
+  avg /= nvtxs;
+  for (let i = 0; i < nvtxs; i++) orthog[i] = orthog[i] - avg;
+  const len = norm(orthog, nvtxs - 1, BLOCK_STANDARDIZE_NORM);
+  if (Math.abs(len) < DBL_EPSILON) return;
+  vectorsScalarMult(nvtxs, orthog, 1 / len, orthog);
+}
+function matMultVecOrthog(mat, dim, vec, result, orthog) {
+  const blocked = dim - dim % BLOCK_MAT_MULT_ROW;
+  for (let i = 0; i < dim; i++) {
+    const row = mat[i];
+    let sum = 0;
+    let j = 0;
+    for (; j < blocked; j++) sum += row[j] * vec[j];
+    for (; j < dim; j++) sum = fma2(row[j], vec[j], sum);
+    result[i] = sum;
+  }
+  const alpha = -innerProduct(dim, result, orthog, BLOCK_MAT_MULT_ORTHOG);
+  scadd(result, dim - 1, alpha, orthog);
+}
+function orthogonalizeAgainstEigs(p, vec, count, block) {
+  for (let j = 0; j < count; j++) {
+    const alpha = -innerProduct(p.n, p.eigs[j], vec, block);
+    scadd(vec, p.n - 1, alpha, p.eigs[j]);
+  }
+}
+function chooseStartVector(p, i) {
+  const curr = p.eigs[i];
+  for (; ; ) {
+    for (let j = 0; j < p.n; j++) curr[j] = crand() % 100;
+    const alpha = -innerProduct(p.n, p.orthog, curr, BLOCK_GUESS_ORTHOG);
+    scadd(curr, p.n - 1, alpha, p.orthog);
+    orthogonalizeAgainstEigs(p, curr, i, BLOCK_NONE);
+    const len = norm(curr, p.n - 1, BLOCK_GUESS_LEN);
+    if (len < POWER_LENGTH_FLOOR) continue;
+    vectorsScalarMult(p.n, curr, 1 / len, curr);
+    return;
+  }
+}
+function iterateEigenvector(p, i, tol, work) {
+  const curr = p.eigs[i];
+  for (; ; ) {
+    copyVector(p.n, curr, work.last);
+    matMultVecOrthog(p.mat, p.n, curr, work.tmp, p.orthog);
+    copyVector(p.n, work.tmp, curr);
+    orthogonalizeAgainstEigs(p, curr, i, BLOCK_NONE);
+    const len = norm(curr, p.n - 1, BLOCK_LOOP_LEN);
+    if (len < POWER_LENGTH_FLOOR) {
+      return { nullSpace: true, eval: 0 };
+    }
+    vectorsScalarMult(p.n, curr, 1 / len, curr);
+    const angle = innerProduct(p.n, curr, work.last, BLOCK_ANGLE);
+    if (!(Math.abs(angle) < tol)) {
+      return { nullSpace: false, eval: angle * len };
+    }
+  }
+}
+function fillNullSpaceEigenvectors(p, from, neigs) {
+  for (let i = from; i < neigs; i++) {
+    const curr = p.eigs[i];
+    for (let j = 0; j < p.n; j++) curr[j] = crand() % 100;
+    orthogonalizeAgainstEigs(p, curr, i, BLOCK_NONE);
+    const len = norm(curr, p.n - 1, BLOCK_NONE);
+    vectorsScalarMult(p.n, curr, 1 / len, curr);
+    p.evals[i] = 0;
+  }
+}
+function sortEigenvectors(p, neigs, tmp) {
+  for (let i = 0; i < neigs - 1; i++) {
+    let largestIndex = i;
+    let largestEval = p.evals[largestIndex];
+    for (let j = i + 1; j < neigs; j++) {
+      if (largestEval < p.evals[j]) {
+        largestIndex = j;
+        largestEval = p.evals[largestIndex];
+      }
+    }
+    if (largestIndex !== i) {
+      copyVector(p.n, p.eigs[i], tmp);
+      copyVector(p.n, p.eigs[largestIndex], p.eigs[i]);
+      copyVector(p.n, tmp, p.eigs[largestIndex]);
+      p.evals[largestIndex] = p.evals[i];
+      p.evals[i] = largestEval;
+    }
+  }
+}
+function powerIterationOrthog(p, neigsIn, pIterationThreshold) {
+  const work = { tmp: new Float64Array(p.n), last: new Float64Array(p.n) };
+  const tol = 1 - pIterationThreshold;
+  const neigs = neigsIn >= p.n ? p.n : neigsIn;
+  let i = 0;
+  for (; i < neigs; i++) {
+    chooseStartVector(p, i);
+    const res = iterateEigenvector(p, i, tol, work);
+    if (res.nullSpace) break;
+    p.evals[i] = res.eval;
+  }
+  fillNullSpaceEigenvectors(p, i, neigs);
+  sortEigenvectors(p, neigs, work.tmp);
+}
+function computeAvgs(Dij, n) {
+  const rowAvg = new Float32Array(n);
+  let sum = 0;
+  const blocked = n - n % BLOCK_AVGS;
   for (let i = 0; i < n; i++) {
-    if (vec[i] !== 0) vec[i] = 1 / vec[i];
+    let sumRow = 0;
+    const row = Dij[i];
+    let j = 0;
+    for (; j < blocked; j++) {
+      sum += row[j] * row[j];
+      sumRow += row[j] * row[j];
+    }
+    for (; j < n; j++) {
+      sum = fma2(row[j], row[j], sum);
+      sumRow = fma2(row[j], row[j], sumRow);
+    }
+    rowAvg[i] = fr4(fr4(sumRow) / n);
   }
+  return { rowAvg, allAvg: fr4(fr4(sum) / (n * n)) };
 }
-function sqrtVecF(n, source, target) {
+function computeBij(Dij, n) {
+  const Bij = [];
+  for (let i = 0; i < n; i++) Bij.push(new Float32Array(n));
+  const { rowAvg, allAvg } = computeAvgs(Dij, n);
   for (let i = 0; i < n; i++) {
-    if (source[i] >= 0) target[i] = fr(Math.sqrt(source[i]));
+    for (let j = 0; j <= i; j++) {
+      const fD = fr4(Dij[i][j]);
+      const t = fr4(fma2(-fD, fD, rowAvg[i]));
+      Bij[i][j] = fr4(fr4(t + rowAvg[j]) - allAvg);
+      Bij[j][i] = Bij[i][j];
+    }
+  }
+  return Bij;
+}
+function cmdsOrthog(n, dim, eigs, tol, input) {
+  const { orthog, Dij } = input;
+  const Bij = computeBij(Dij, n);
+  const evals = new Float64Array(dim);
+  const orthogAux = Float64Array.from(orthog.subarray(0, n));
+  standardize(orthogAux, n);
+  powerIterationOrthog({ mat: Bij, n, eigs, evals, orthog: orthogAux }, dim, tol);
+  for (let i = 0; i < dim; i++) {
+    for (let j = 0; j < n; j++) eigs[i][j] = eigs[i][j] * Math.sqrt(Math.abs(evals[i]));
   }
 }
-function invertSqrtVec(n, vec) {
+function scaleGivenCoords(Dij, n, x) {
+  let sum1 = 0;
+  let sum2 = 0;
+  for (let i = 1; i < n; i++) {
+    const blocked = i - i % BLOCK_UNIFORM_SUMS;
+    for (let j = 0; j < i; j++) {
+      const d = Dij[i][j];
+      const f = Math.abs(x[i] - x[j]);
+      const t1 = 1 / d;
+      const t2 = 1 / Math.imul(d, d) * f;
+      if (j < blocked) {
+        sum1 += t1 * f;
+        sum2 += t2 * f;
+      } else {
+        sum1 = fma2(t1, f, sum1);
+        sum2 = fma2(t2, f, sum2);
+      }
+    }
+  }
+  const uniLength = Math.abs(sum2) === Infinity ? 0 : sum1 / sum2;
+  for (let i = 0; i < n; i++) x[i] = x[i] * uniLength;
+  return uniLength;
+}
+function computeLaplacian(Dij, n) {
+  const lap = [];
   for (let i = 0; i < n; i++) {
-    if (vec[i] > 0) vec[i] = 1 / fr(Math.sqrt(vec[i]));
+    const row = new Float32Array(n);
+    let degree = fr4(0);
+    for (let j = 0; j < n; j++) {
+      if (j === i) continue;
+      const w = fr4(fr4(-1) / fr4(fr4(Dij[i][j]) * fr4(Dij[i][j])));
+      row[j] = w;
+      degree = fr4(degree - w);
+    }
+    row[i] = degree;
+    lap.push(row);
+  }
+  return lap;
+}
+function computeResidualDistances(Dij, n, x) {
+  for (let i = 1; i < n; i++) {
+    const posI = x[i];
+    for (let j = 0; j < i; j++) {
+      const t = posI - x[j];
+      const d = Dij[i][j];
+      const diff = fma2(d, d, -(t * t));
+      const v = diff > 0 ? Math.sqrt(diff) : 0;
+      Dij[i][j] = v;
+      Dij[j][i] = v;
+    }
   }
 }
+function balanceOf(i, n, y, ctx) {
+  const posI = y[i];
+  let b = 0;
+  for (let j = 0; j < n; j++) {
+    if (j === i) continue;
+    const term = fr4(fr4(ctx.Dij[i][j]) * -ctx.lap[i][j]);
+    if (posI >= y[j]) b += term;
+    else b -= term;
+  }
+  return b;
+}
+function solveBalanced(ctx, n, y, balance, convTol) {
+  let converged = false;
+  for (let iterations2 = 0; iterations2 < 200 && !converged; iterations2++) {
+    if (conjugateGradientF(ctx.lap, y, balance, n, { tol: convTol, maxIterations: n, ortho1: true }) < 0) return 1;
+    converged = true;
+    for (let i = 0; i < n; i++) {
+      const b = balanceOf(i, n, y, ctx);
+      if (b !== balance[i] && Math.abs(1 - b / balance[i]) > 1e-5) {
+        converged = false;
+        balance[i] = b;
+      }
+    }
+  }
+  return 0;
+}
+function imdsGivenDim(graph, n, givenCoords, newCoords, conjTol) {
+  const x = givenCoords;
+  const y = newCoords;
+  const Dij = computeApsp(graph, n);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) Dij[i][j] = Dij[i][j] * SCALE_FACTOR;
+  }
+  const uniLength = scaleGivenCoords(Dij, n, x);
+  cmdsOrthog(n, 1, [y], conjTol, { orthog: x, Dij });
+  const lap = computeLaplacian(Dij, n);
+  computeResidualDistances(Dij, n, x);
+  const ctx = { Dij, lap };
+  const balance = new Float64Array(n);
+  for (let i = 0; i < n; i++) balance[i] = balanceOf(i, n, y, ctx);
+  if (solveBalanced(ctx, n, y, balance, conjTol) === 1) return 1;
+  for (let i = 0; !(Math.abs(uniLength) < DBL_EPSILON) && i < n; i++) {
+    x[i] = x[i] / uniLength;
+    y[i] = y[i] / uniLength;
+  }
+  return 0;
+}
 
 // src/layout/neato/stress-kernel.ts
-var fr2 = Math.fround;
-var TOLERANCE_CG = 1e-3;
+var fr5 = Math.fround;
+var TOLERANCE_CG2 = 1e-3;
 var OPT_EXP_FLAG = 2;
 function computeApspPacked2(graph, n) {
   const Dij = new Float32Array(n * (n + 1) / 2);
@@ -37642,9 +39024,9 @@ function cgStep(st, last) {
     vectorsMultAdditionF(n, st.r, -alpha, st.Ap);
     const rRNew = vectorsInnerProductF(n, st.r, st.r);
     if (st.rR === 0) return false;
-    const betaF = fr2(rRNew / st.rR);
+    const betaF = fr5(rRNew / st.rR);
     st.rR = rRNew;
-    for (let j = 0; j < n; j++) st.p[j] = fr2(betaF * st.p[j]) + st.r[j];
+    for (let j = 0; j < n; j++) st.p[j] = fr5(betaF * st.p[j]) + st.r[j];
   }
   return true;
 }
@@ -37706,8 +39088,8 @@ function buildLap1(lap1, lap2, coords, shape) {
     for (let k = 0; k < dim; k++) {
       const ck = coords[k];
       for (let x = 0; x < len; x++) {
-        const tmp = fr2(ck[i] + fr2(-1 * ck[i + 1 + x]));
-        distAccumulator[x] = distAccumulator[x] + fr2(tmp * tmp);
+        const tmp = fr5(ck[i] + fr5(-1 * ck[i + 1 + x]));
+        distAccumulator[x] = distAccumulator[x] + fr5(tmp * tmp);
       }
     }
     invertSqrtVec(len, distAccumulator);
@@ -37719,7 +39101,7 @@ function buildLap1(lap1, lap2, coords, shape) {
     let degree = 0;
     if (exp === 2) {
       for (let j = 0; j < len; j++, count++) {
-        const val2 = lap1[count] = fr2(lap1[count] * distAccumulator[j]);
+        const val2 = lap1[count] = fr5(lap1[count] * distAccumulator[j]);
         degree += val2;
         degrees[i + j + 1] = degrees[i + j + 1] - val2;
       }
@@ -37753,10 +39135,10 @@ function computeStress(st) {
 }
 function solveAxis(st, k, havePinned, nodes) {
   if (!havePinned) {
-    return conjugateGradientMkernel2(st.lap2, st.coords[k], st.b[k], st.n, TOLERANCE_CG, st.n);
+    return conjugateGradientMkernel2(st.lap2, st.coords[k], st.b[k], st.n, TOLERANCE_CG2, st.n);
   }
   copyVectorF(st.n, st.coords[k], st.tmpCoords);
-  const rc = conjugateGradientMkernel2(st.lap2, st.tmpCoords, st.b[k], st.n, TOLERANCE_CG, st.n);
+  const rc = conjugateGradientMkernel2(st.lap2, st.tmpCoords, st.b[k], st.n, TOLERANCE_CG2, st.n);
   if (rc < 0) return rc;
   for (let i = 0; i < st.n; i++) {
     if (!isFixed(nodes[i])) st.coords[k][i] = st.tmpCoords[i];
@@ -37772,10 +39154,10 @@ function stressMajorizationKDMkernel(Dij, n, dCoords, nodes, o) {
   const coords = [];
   for (let i = 0; i < dim; i++) {
     const c = new Float32Array(n);
-    for (let j = 0; j < n; j++) c[j] = fr2(dCoords[i][j]);
+    for (let j = 0; j < n; j++) c[j] = fr5(dCoords[i][j]);
     coords.push(c);
   }
-  const constantTerm = fr2(n * (n - 1) / 2);
+  const constantTerm = fr5(n * (n - 1) / 2);
   const lap2 = Dij;
   buildLap2(lap2, n, exp);
   const lapLength = n * (n + 1) / 2;
@@ -37810,6 +39192,261 @@ function stressMajorizationKDMkernel(Dij, n, dCoords, nodes, o) {
   return iterations;
 }
 
+// src/layout/neato/constrained-majorization.ts
+var fr6 = Math.fround;
+var LOCAL_CONSTR_MAJOR_ITERATIONS = 15;
+var LEVELS_SEP_TOL = 0.1;
+var ABS_TOL = 0.01;
+var SUBSPACE_ITERATIONS = 15;
+var FLT_MAX3 = 34028234663852886e22;
+var DBL_MAX = Number.MAX_VALUE;
+var MIN_LEVELS = 1;
+var Y_AXIS = 1;
+function unsupported2(what) {
+  throw new RenderError(`hierarchical stress majorization: ${what} is not supported yet`, "UNSUPPORTED_FEATURE");
+}
+function modelDistances(graph, n, model) {
+  if (model === MODEL_SUBSET) unsupported2("the subset distance model");
+  if (model === MODEL_CIRCUIT) unsupported2("the circuit distance model");
+  return model === MODEL_MDS2 ? mdsModel(graph, n) : null;
+}
+function unconstrainedMajorization(graph, n, dCoords, nodes, o) {
+  if (o.maxi < 0) return 0;
+  const weighted = (graph[0]?.ewgts.length ?? 0) > 0;
+  const Dij = modelDistances(graph, n, o.model) ?? (weighted ? computeWeightedApspPacked2(graph, n) : computeApspPacked2(graph, n));
+  if ((o.opts & OPT_SMART_INIT) !== 0 && n > 1) unsupported2("the smart initial layout");
+  return stressMajorizationKDMkernel(Dij, n, dCoords, nodes, {
+    dim: o.dim,
+    opts: o.opts,
+    maxi: o.maxi,
+    epsilon: o.epsilon
+  });
+}
+function hasDirectionality(graph, n) {
+  if (!graph[0]?.edists) return false;
+  let directionalityExist = false;
+  for (let i = 0; i < n; i++) {
+    const edists = graph[i].edists;
+    for (let j = 1; j < graph[i].nedges; j++) {
+      directionalityExist ||= edists[j] !== 0;
+    }
+  }
+  return directionalityExist;
+}
+function separateLevels(y, h, n, levelsGap) {
+  const { ordering, levels, numLevels } = h;
+  let displacement = 0;
+  for (let i = 0; i < numLevels; i++) {
+    const shortfall = levelsGap - (y[ordering[levels[i]]] + displacement - y[ordering[levels[i] - 1]]);
+    displacement += 0 > shortfall ? 0 : shortfall;
+    const stop = i < numLevels - 1 ? levels[i + 1] : n;
+    for (let j = levels[i]; j < stop; j++) y[ordering[j]] += displacement;
+  }
+}
+function smartInitLayers(graph, n, dCoords, nodes, o) {
+  const { dim } = o;
+  if (dim > 2) {
+    const sub = { dim: dim - 1, opts: o.opts, model: o.model, maxi: SUBSPACE_ITERATIONS, epsilon: o.epsilon };
+    if (unconstrainedMajorization(graph, n, dCoords.slice(1), nodes, sub) < 0) return -1;
+    dCoords[dim - 1].set(dCoords[1].subarray(0, n));
+  }
+  const x = dCoords[0];
+  const y = dCoords[1];
+  if (computeYCoords(graph, n, y, n)) return -1;
+  const h = computeHierarchy(graph, n, ABS_TOL, LEVELS_SEP_TOL, y);
+  if (h === null) return -1;
+  if (h.numLevels < MIN_LEVELS) {
+    return unconstrainedMajorization(graph, n, dCoords, nodes, o);
+  }
+  if (o.levelsGap > 0) separateLevels(y, h, n, o.levelsGap);
+  if (dim === 2 && imdsGivenDim(graph, n, y, x, o.epsilon)) return -1;
+  return h;
+}
+function plainInitLayers(graph, n, dCoords, nodes, dim) {
+  initLayout(n, dim, dCoords, nodes);
+  const h = computeHierarchy(graph, n, ABS_TOL, LEVELS_SEP_TOL, null);
+  return h === null ? -1 : h;
+}
+function distanceKD(coords, dim, i, j) {
+  let sum = 0;
+  for (let k = 0; k < dim; k++) {
+    const d = coords[k][i] - coords[k][j];
+    sum = fma2(d, d, sum);
+  }
+  return Math.sqrt(sum);
+}
+function scaleDownLayout(dCoords, n, dim) {
+  let max = 1;
+  for (let i = 0; i < dim; i++) {
+    for (let j = 0; j < n; j++) {
+      const a = Math.abs(dCoords[i][j]);
+      if (a > max) max = a;
+    }
+  }
+  for (let i = 0; i < dim; i++) {
+    for (let j = 0; j < n; j++) dCoords[i][j] *= 10 / max;
+  }
+}
+function scaleDistances(Dij, dCoords, n, dim) {
+  const length = n + Math.trunc(n * (n - 1) / 2);
+  const sum1 = Math.trunc(n * (n - 1) / 2);
+  let sum2 = 0;
+  for (let count = 0, i = 0; i < n - 1; i++) {
+    count++;
+    for (let j = i + 1; j < n; j++, count++) {
+      sum2 += distanceKD(dCoords, dim, i, j) / Dij[count];
+    }
+  }
+  const scaleRatio = fr6(sum2 / sum1);
+  for (let i = 0; i < length; i++) Dij[i] = Dij[i] * scaleRatio;
+}
+function centerLayout(dCoords, n, dim) {
+  for (let i = 0; i < dim; i++) orthog1(n, dCoords[i]);
+  const y0 = dCoords[Y_AXIS][0];
+  for (let i = 0; i < n; i++) dCoords[Y_AXIS][i] -= y0;
+}
+function negatedDegrees(lap2, n) {
+  const degrees = new Float64Array(n);
+  for (let i = 0, count = 0; i < n - 1; i++) {
+    let degree = 0;
+    count++;
+    for (let j = 1; j < n - i; j++, count++) {
+      const val2 = lap2[count];
+      degree += val2;
+      degrees[i + j] -= val2;
+    }
+    degrees[i] -= degree;
+  }
+  return degrees;
+}
+function buildLap22(lap2, n) {
+  const lapLength = n + Math.trunc(n * (n - 1) / 2);
+  squareVec(lapLength, lap2);
+  invertVec(lapLength, lap2);
+  const degrees = negatedDegrees(lap2, n);
+  for (let step = n, count = 0, i = 0; i < n; i++, count += step, step--) {
+    lap2[count] = degrees[i];
+  }
+}
+function inverseDistances(st, i, len) {
+  const { coords, tmpCoords, distAccumulator } = st;
+  distAccumulator.fill(0, 0, st.n);
+  for (let k = 0; k < st.dim; k++) {
+    const ck = coords[k];
+    for (let j = 0; j < len; j++) tmpCoords[j] = ck[i] - ck[i + 1 + j];
+    for (let j = 0; j < len; j++) tmpCoords[j] = tmpCoords[j] * tmpCoords[j];
+    for (let j = 0; j < len; j++) distAccumulator[j] = tmpCoords[j] + distAccumulator[j];
+  }
+  invertSqrtVec(len, distAccumulator);
+  for (let j = 0; j < len; j++) {
+    if (distAccumulator[j] >= FLT_MAX3 || distAccumulator[j] < 0) distAccumulator[j] = 0;
+  }
+}
+function buildLap12(st) {
+  const { n, lap1, lap2, degrees, distAccumulator } = st;
+  degrees.fill(0);
+  sqrtVecF(n + Math.trunc(n * (n - 1) / 2), lap2, lap1);
+  let count = 0;
+  for (let i = 0; i < n - 1; i++) {
+    const len = n - i - 1;
+    inverseDistances(st, i, len);
+    count++;
+    let degree = 0;
+    for (let j = 0; j < len; j++, count++) {
+      const val2 = fr6(lap1[count] * distAccumulator[j]);
+      lap1[count] = val2;
+      degree += val2;
+      degrees[i + j + 1] -= val2;
+    }
+    degrees[i] -= degree;
+  }
+  for (let step = n, count2 = 0, i = 0; i < n; i++, count2 += step, step--) {
+    lap1[count2] = degrees[i];
+  }
+}
+function computeNewStress(st, constantTerm) {
+  const { n, dim, lap1, lap2, coords, b, tmpCoords } = st;
+  for (let k = 0; k < dim; k++) rightMultWithVectorFFFused(lap1, n, coords[k], b[k]);
+  let newStress = 0;
+  for (let k = 0; k < dim; k++) newStress += vectorsInnerProductF(n, coords[k], b[k]);
+  newStress *= 2;
+  newStress += constantTerm;
+  for (let k = 0; k < dim; k++) {
+    rightMultWithVectorFFFused(lap2, n, coords[k], tmpCoords);
+    newStress -= vectorsInnerProductF(n, coords[k], tmpCoords);
+  }
+  return newStress;
+}
+function solveAxes(st, ctx) {
+  for (let k = 0; k < st.dim; k++) {
+    if (k === Y_AXIS) {
+      constrainedMajorizationNewWithGaps(
+        ctx.cMajEnv,
+        st.b[k],
+        st.coords,
+        k,
+        LOCAL_CONSTR_MAJOR_ITERATIONS,
+        ctx.levelsGap
+      );
+    } else if (conjugateGradientMkernelFused(st.lap2, st.coords[k], st.b[k], st.n, { tol: TOLERANCE_CG, maxIterations: st.n })) {
+      return true;
+    }
+  }
+  return false;
+}
+function majorize(st, ctx, dCoords) {
+  const constantTerm = Math.trunc(st.n * (st.n - 1) / 2);
+  let oldStress = DBL_MAX;
+  let iterations = 0;
+  for (let converged = false; iterations < ctx.maxi && !converged; iterations++) {
+    buildLap12(st);
+    const newStress = computeNewStress(st, constantTerm);
+    converged = Math.abs(newStress - oldStress) / Math.abs(oldStress + 1e-10) < ctx.epsilon;
+    converged ||= iterations > 1 && newStress > oldStress;
+    oldStress = newStress;
+    if (solveAxes(st, ctx)) return -1;
+  }
+  for (let i = 0; i < st.dim; i++) {
+    for (let j = 0; j < st.n; j++) dCoords[i][j] = st.coords[i][j];
+  }
+  return iterations;
+}
+function toFloatCoords(dCoords, n, dim) {
+  const coords = [];
+  for (let i = 0; i < dim; i++) coords.push(Float32Array.from(dCoords[i].subarray(0, n)));
+  return coords;
+}
+function newLoopState(lap2, coords, n) {
+  const dim = coords.length;
+  return {
+    n,
+    dim,
+    lap2,
+    coords,
+    lap1: new Float32Array(n + Math.trunc(n * (n - 1) / 2)),
+    b: Array.from({ length: dim }, () => new Float32Array(n)),
+    tmpCoords: new Float32Array(n),
+    distAccumulator: new Float32Array(n),
+    degrees: new Float64Array(n)
+  };
+}
+function stressMajorizationWithHierarchy(graph, n, dCoords, nodes, o) {
+  if (!hasDirectionality(graph, n)) return unconstrainedMajorization(graph, n, dCoords, nodes, o);
+  const smartIni = (o.opts & OPT_SMART_INIT) !== 0;
+  const layers = smartIni ? smartInitLayers(graph, n, dCoords, nodes, o) : plainInitLayers(graph, n, dCoords, nodes, o.dim);
+  if (typeof layers === "number") return layers;
+  if (n === 1) return 0;
+  if (o.maxi === 0) return 0;
+  const Dij = modelDistances(graph, n, o.model) ?? computeApspPacked2(graph, n);
+  if (!smartIni) scaleDownLayout(dCoords, n, o.dim);
+  if (o.levelsGap > 0) scaleDistances(Dij, dCoords, n, o.dim);
+  centerLayout(dCoords, n, o.dim);
+  const st = newLoopState(Dij, toFloatCoords(dCoords, n, o.dim), n);
+  buildLap22(Dij, n);
+  const cMajEnv = initConstrainedMajorization(Dij, n, layers.ordering, layers.levels, layers.numLevels);
+  return majorize(st, { cMajEnv, levelsGap: o.levelsGap, maxi: o.maxi, epsilon: o.epsilon }, dCoords);
+}
+
 // src/common/utils-inputscale.ts
 var POINTS_PER_INCH3 = 72;
 function getInputscale(g) {
@@ -37996,61 +39633,47 @@ function neatoMaxIter(maxiter, mode, n) {
   if (mode === MODE_MAJOR) return DFLT_ITERATIONS;
   return mode === MODE_SGD ? SGD_ITERATIONS : 100 * n;
 }
-function runMajorization(g, mode, model) {
-  void model;
-  const nodeList = assignNodeIds2(g);
+var levelsGapOf = (g) => lateDouble(g.root.attrs.get("levelsgap"), 0, -Number.MAX_VALUE);
+function solveStress(c, vtx, dCoords, nodeList) {
+  const { g, mode, model, haveLen, opts } = c;
   const n = nodeList.length;
-  const haveLen = graphHasLen(g);
-  const vtx = makeGraphDataC(g, nodeList, haveLen, mode === MODE_HIER || mode === MODE_IPSEP);
-  checkStart(g);
   const maxi = neatoMaxIter(g.attrs.get("maxiter"), mode, n);
   const epsilon = lateDouble(g.attrs.get("epsilon"), 1e-4, 0);
+  if (mode === MODE_HIER) {
+    return stressMajorizationWithHierarchy(vtx, n, dCoords, nodeList, {
+      dim: DFLT_DIM,
+      opts,
+      model,
+      maxi,
+      epsilon,
+      levelsGap: levelsGapOf(g)
+    });
+  }
   const weighted = haveLen && mode !== MODE_IPSEP;
   const Dij = weighted ? computeWeightedApspPacked2(vtx, n) : computeApspPacked2(vtx, n);
-  const dCoords = [new Float64Array(n), new Float64Array(n)];
-  stressMajorizationKDMkernel(Dij, n, dCoords, nodeList, {
+  return stressMajorizationKDMkernel(Dij, n, dCoords, nodeList, {
     dim: DFLT_DIM,
-    opts: OPT_EXP_FLAG,
+    opts,
     maxi,
     epsilon
   });
-  for (let i = 0; i < n; i++) {
-    nodeList[i].info.pos = [dCoords[0][i], dCoords[1][i]];
-  }
 }
-function graphHasLen(g) {
-  for (const e of g.edges) {
-    if (e.attrs.has("len")) return true;
+function runMajorization(g, mode, model) {
+  const nodeList = assignNodeIds2(g);
+  const n = nodeList.length;
+  const haveLen = graphHasLen(g);
+  const init = checkStart(g, n, mode === MODE_HIER ? INIT_SELF : INIT_RANDOM);
+  const opts = init === INIT_SELF ? OPT_EXP_FLAG | OPT_SMART_INIT : OPT_EXP_FLAG;
+  const haveDir = mode === MODE_HIER || mode === MODE_IPSEP;
+  const vtx = makeGraphDataC(g, nodeList, haveLen, haveDir, mode);
+  const dCoords = [new Float64Array(n), new Float64Array(n)];
+  if (solveStress({ g, mode, model, haveLen, opts }, vtx, dCoords, nodeList) < 0) {
+    agerr("prev", "layout aborted");
+    return;
   }
-  return false;
-}
-function makeGraphDataC(g, nodeList, haveLen, haveDir) {
-  const vtx = nodeList.map((_, i) => ({
-    nedges: 1,
-    edges: [i],
-    ewgts: haveLen || haveDir ? [0] : []
-  }));
-  for (const np of nodeList) {
-    const i = np.info.id;
-    const entry = vtx[i];
-    const seen2 = /* @__PURE__ */ new Map();
-    for (const ep of [...np.outEdges(g), ...np.inEdges(g)]) {
-      if (ep.head === ep.tail) continue;
-      const vp = ep.tail === np ? ep.head : ep.tail;
-      const vid = vp.info.id;
-      const dist4 = haveLen ? lateDouble(ep.attrs.get("len"), 1, 0) : 1;
-      const idx = seen2.get(vid);
-      if (idx !== void 0) {
-        if (haveLen) entry.ewgts[idx] = Math.max(entry.ewgts[idx], dist4);
-        continue;
-      }
-      seen2.set(vid, entry.nedges);
-      entry.edges.push(vid);
-      if (haveLen || haveDir) entry.ewgts.push(dist4);
-      entry.nedges++;
-    }
+  for (let i = 0; i < n; i++) {
+    nodeList[i].info.pos = [dCoords[0][i], dCoords[1][i]];
   }
-  return vtx;
 }
 function solveModel2(g, mode, model) {
   if (g.nodes.size < 2) return;
@@ -38242,6 +39865,25 @@ function esepFactor(g) {
   return { x: SEPFACT * DFLT_MARGIN, y: SEPFACT * DFLT_MARGIN, doAdd: true };
 }
 
+// src/common/libm-trig.ts
+var OCTAGON_TRIG = /* @__PURE__ */ new Map([
+  [-0.39269908169872414, [0.9238795325112867, -0.3826834323650898]],
+  [0.39269908169872414, [0.9238795325112867, 0.3826834323650898]],
+  [1.1780972450961724, [0.38268343236508984, 0.9238795325112867]],
+  [1.9634954084936207, [-0.3826834323650897, 0.9238795325112867]],
+  [2.748893571891069, [-0.9238795325112867, 0.3826834323650899]],
+  [3.5342917352885173, [-0.9238795325112868, -0.38268343236508967]],
+  [4.319689898685965, [-0.38268343236509034, -0.9238795325112865]],
+  [5.105088062083414, [0.38268343236509, -0.9238795325112866]],
+  [5.890486225480862, [0.9238795325112865, -0.3826834323650904]]
+]);
+function libmCos(x) {
+  return OCTAGON_TRIG.get(x)?.[0] ?? Math.cos(x);
+}
+function libmSin(x) {
+  return OCTAGON_TRIG.get(x)?.[1] ?? Math.sin(x);
+}
+
 // src/layout/neato/delaunay.ts
 var ICCERRBOUND_A = (10 + 96 * 2 ** -53) * 2 ** -53;
 function ulpExp(v) {
@@ -38410,6 +40052,32 @@ function delaunayTri(xv, yv, n) {
   return edges;
 }
 
+// src/layout/neato/gts-triangle.ts
+var SQRT3 = 1.73205080757;
+function gtsTriangleEnclosing(px, py, n, scale) {
+  let xmin = px[0];
+  let xmax = px[0];
+  let ymin = py[0];
+  let ymax = py[0];
+  for (let i = 1; i < n; i++) {
+    if (px[i] > xmax) xmax = px[i];
+    else if (px[i] < xmin) xmin = px[i];
+    if (py[i] > ymax) ymax = py[i];
+    else if (py[i] < ymin) ymin = py[i];
+  }
+  const xo = (xmax + xmin) / 2;
+  const yo = (ymax + ymin) / 2;
+  const dx = xmax - xo;
+  const dy = ymax - yo;
+  let r = scale * Math.sqrt(fma(dx, dx, dy * dy));
+  if (r === 0) r = scale;
+  return [
+    [fma(r, SQRT3, xo), yo - r],
+    [xo, fma(r, 2, yo)],
+    [fma(-r, SQRT3, xo), yo - r]
+  ];
+}
+
 // src/layout/neato/cdt-surface.ts
 var pairKey = (u, v) => u < v ? u * 1048576 + v : v * 1048576 + u;
 var Cdt = class {
@@ -38920,27 +40588,15 @@ var Cdt = class {
     return { nfaces: kept.length, faces, neigh };
   }
 };
-var SQRT3 = 1.7320508075688772;
 function mkSurface(x, y, n, segs, nsegs) {
   const px = x.slice(0, n);
   const py = y.slice(0, n);
-  let xmin = px[0];
-  let xmax = px[0];
-  let ymin = py[0];
-  let ymax = py[0];
-  for (let i = 1; i < n; i++) {
-    if (px[i] > xmax) xmax = px[i];
-    else if (px[i] < xmin) xmin = px[i];
-    if (py[i] > ymax) ymax = py[i];
-    else if (py[i] < ymin) ymin = py[i];
-  }
-  const xo = (xmax + xmin) / 2;
-  const yo = (ymax + ymin) / 2;
-  let r = 100 * Math.hypot(xmax - xo, ymax - yo);
-  if (r === 0) r = 100;
   const s0 = n;
-  px.push(xo + r * SQRT3, xo, xo - r * SQRT3);
-  py.push(yo - r, yo + 2 * r, yo - r);
+  const enc = gtsTriangleEnclosing(px, py, n, 100);
+  for (const [ex, ey] of enc) {
+    px.push(ex);
+    py.push(ey);
+  }
   const cdt = new Cdt(px, py);
   const cons = [];
   for (let k = 0; k < nsegs; k++) {
@@ -38987,9 +40643,9 @@ function sharedEdge(faces, p3, q3) {
   return { i: p1, j: p2 };
 }
 function addTriEdge(g, t, h, seg2) {
-  const dist4 = Math.sqrt(dist2(g.nodes[t].ctr, g.nodes[h].ctr));
+  const dist5 = Math.sqrt(dist2(g.nodes[t].ctr, g.nodes[h].ctr));
   const idx = g.edges.length;
-  g.edges.push({ t, h, seg: seg2, dist: dist4 });
+  g.edges.push({ t, h, seg: seg2, dist: dist5 });
   g.nodes[t].edges.push(idx);
   g.nodes[h].edges.push(idx);
 }
@@ -39793,8 +41449,8 @@ function ellipseTangentSlope(a, b, p) {
 function circumscribedCorner(a, b, i, nsides) {
   const angle0 = 2 * Math.PI * (i - 0.5) / nsides;
   const angle1 = 2 * Math.PI * (i + 0.5) / nsides;
-  const p0 = { x: a * Math.cos(angle0), y: b * Math.sin(angle0) };
-  const p1 = { x: a * Math.cos(angle1), y: b * Math.sin(angle1) };
+  const p0 = { x: a * libmCos(angle0), y: b * libmSin(angle0) };
+  const p1 = { x: a * libmCos(angle1), y: b * libmSin(angle1) };
   const m0 = ellipseTangentSlope(a, b, p0);
   const m1 = ellipseTangentSlope(a, b, p1);
   const x = (fms(p1.x, m1, fma(m0, p0.x, -p0.y)) + p1.y) / (m0 - m1);
@@ -42130,52 +43786,14 @@ function armPow(x, y) {
   return expInline(ehi, elo, signBias);
 }
 
-// src/common/crand.ts
-var C_RAND_MAX = 2147483647;
-var UNSEEDED_STATE2 = 1;
-var state2 = UNSEEDED_STATE2;
-registerRenderState(() => {
-  state2 = UNSEEDED_STATE2;
-});
-function csrand(seed) {
-  state2 = seed;
-}
-function crand() {
-  state2 = state2 * 16807 % 2147483647;
-  return state2;
-}
-function cdrand() {
-  return crand() / C_RAND_MAX;
-}
-function gvRandom(bound) {
-  const discardThreshold = C_RAND_MAX - 2147483648 % bound;
-  let r;
-  do {
-    r = crand();
-  } while (r > discardThreshold);
-  return r % bound;
-}
-function gvPermutation(bound) {
-  if (bound <= 0) return [];
-  const p = [];
-  for (let i = 0; i < bound; i++) p.push(i);
-  for (let i = bound - 1; i > 0; --i) {
-    const j = gvRandom(i + 1);
-    const t = p[i];
-    p[i] = p[j];
-    p[j] = t;
-  }
-  return p;
-}
-
 // src/layout/sfdp/quadtree.ts
 function pointDistance(p1, o1, p2, o2, dim) {
-  let dist4 = 0;
+  let dist5 = 0;
   for (let i = 0; i < dim; i++) {
     const d = p1[o1 + i] - p2[o2 + i];
-    dist4 = fma(d, d, dist4);
+    dist5 = fma(d, d, dist5);
   }
-  return Math.sqrt(dist4);
+  return Math.sqrt(dist5);
 }
 function quadTreeNew(dim, center, width2, maxLevel) {
   return {
@@ -42310,8 +43928,8 @@ function getSupernodesInternal(qt, bh, pt, ptOff, nodeid, out) {
     l = l.next;
   }
   if (qt.qts !== null) {
-    const dist4 = pointDistance(qt.center, 0, pt, ptOff, dim);
-    if (qt.width < bh * dist4) {
+    const dist5 = pointDistance(qt.center, 0, pt, ptOff, dim);
+    if (qt.width < bh * dist5) {
       for (let i = 0; i < dim; i++) {
         out.center[dim * out.nsuper + i] = qt.average[i];
       }
@@ -42409,12 +44027,12 @@ function onedOptimizerTrain(opt, work) {
   else optHill(opt, i);
 }
 function distance(x, dim, i, j) {
-  let dist4 = 0;
+  let dist5 = 0;
   for (let k = 0; k < dim; k++) {
     const d = x[i * dim + k] - x[j * dim + k];
-    dist4 = fma(d, d, dist4);
+    dist5 = fma(d, d, dist5);
   }
-  return Math.sqrt(dist4);
+  return Math.sqrt(dist5);
 }
 function distanceCropped(x, dim, i, j) {
   return Math.max(distance(x, dim, i, j), MINDIST);
@@ -42422,16 +44040,16 @@ function distanceCropped(x, dim, i, j) {
 function gatherLeaves(A3, p, checked, x, dim) {
   const { ia, ja } = A3;
   const leaves = [];
-  let dist4 = 0;
+  let dist5 = 0;
   for (let j = ia[p]; j < ia[p + 1]; j++) {
     const c = ja[j];
     if (ia[c + 1] - ia[c] === 1) {
       checked[c] = true;
-      dist4 += distance(x, dim, p, c);
+      dist5 += distance(x, dim, p, c);
       leaves.push(c);
     }
   }
-  return { leaves, avgDist: dist4 / leaves.length };
+  return { leaves, avgDist: dist5 / leaves.length };
 }
 function beautifyLeaves(dim, A3, x) {
   const { ia, ja, m } = A3;
@@ -42454,7 +44072,7 @@ function beautifyLeaves(dim, A3, x) {
   }
 }
 function averageEdgeLength(A3, dim, coord) {
-  let dist4 = 0;
+  let dist5 = 0;
   const { ia, ja } = A3;
   if (ia[A3.m] === 0) return 1;
   for (let i = 0; i < A3.m; i++) {
@@ -42464,10 +44082,10 @@ function averageEdgeLength(A3, dim, coord) {
         const dd = coord[dim * i + k] - coord[dim * ja[j]];
         d = fma(dd, dd, d);
       }
-      dist4 += Math.sqrt(d);
+      dist5 += Math.sqrt(d);
     }
   }
-  return dist4 / ia[A3.m];
+  return dist5 / ia[A3.m];
 }
 function updateStep(adaptiveCooling, step, fnorm, fnorm0) {
   if (!adaptiveCooling) return COOL * step;
@@ -42478,18 +44096,18 @@ function updateStep(adaptiveCooling, step, fnorm, fnorm0) {
   }
   return 0.99 * step / COOL;
 }
-function repulsivePow(dist4, p) {
-  return armPow(dist4, 1 - p);
+function repulsivePow(dist5, p) {
+  return armPow(dist5, 1 - p);
 }
 function attractiveForce(ctx, i) {
   const { A: A3, x, dim, fp, f } = ctx;
   const { ia, ja } = A3;
   for (let j = ia[i]; j < ia[i + 1]; j++) {
     if (ja[j] === i) continue;
-    const dist4 = distance(x, dim, i, ja[j]);
+    const dist5 = distance(x, dim, i, ja[j]);
     for (let k = 0; k < dim; k++) {
       const t = fp.CRK * (x[i * dim + k] - x[ja[j] * dim + k]);
-      f[k] = fma(-t, dist4, f[k]);
+      f[k] = fma(-t, dist5, f[k]);
     }
   }
 }
@@ -42497,9 +44115,9 @@ function repulsiveForceDirect(ctx, i) {
   const { x, dim, n, fp, f } = ctx;
   for (let j = 0; j < n; j++) {
     if (j === i) continue;
-    const dist4 = distanceCropped(x, dim, i, j);
+    const dist5 = distanceCropped(x, dim, i, j);
     for (let k = 0; k < dim; k++) {
-      f[k] += fp.KP * (x[i * dim + k] - x[j * dim + k]) / repulsivePow(dist4, fp.p);
+      f[k] += fp.KP * (x[i * dim + k] - x[j * dim + k]) / repulsivePow(dist5, fp.p);
     }
   }
 }
@@ -42509,9 +44127,9 @@ function repulsiveForceQT(ctx, qt, i, acc) {
   acc.countsAvg += counts;
   acc.nsuperAvg += nsuper;
   for (let j = 0; j < nsuper; j++) {
-    const dist4 = Math.max(distances[j], MINDIST);
+    const dist5 = Math.max(distances[j], MINDIST);
     for (let k = 0; k < dim; k++) {
-      f[k] += supernodeWgts[j] * fp.KP * (x[i * dim + k] - center[j * dim + k]) / repulsivePow(dist4, fp.p);
+      f[k] += supernodeWgts[j] * fp.KP * (x[i * dim + k] - center[j * dim + k]) / repulsivePow(dist5, fp.p);
     }
   }
 }
@@ -42767,7 +44385,7 @@ function diagPreconNew(A3) {
   }
   return diag;
 }
-function conjugateGradient(A3, precon, n, x, rhs, tol, maxit) {
+function conjugateGradient2(A3, precon, n, x, rhs, tol, maxit) {
   let rho = 0;
   let rhoOld = 1;
   let iter = 0;
@@ -42808,7 +44426,7 @@ function smSolve(A3, dim, x0, rhs, tol, maxit) {
       x[i] = x0[i * dim + k];
       b[i] = rhs[i * dim + k];
     }
-    res += conjugateGradient(A3, precond, n, x, b, tol, maxit);
+    res += conjugateGradient2(A3, precond, n, x, b, tol, maxit);
     for (let i = 0; i < n; i++) {
       rhs[i * dim + k] = x[i];
     }
@@ -43162,7 +44780,7 @@ function idealDistanceAvoidOverlap(dim, A3, x, width2, idealDistance) {
     for (let j = ia[i]; j < ia[i + 1]; j++) {
       const jj = ja[j];
       if (jj === i) continue;
-      const dist4 = distance(x, dim, i, jj);
+      const dist5 = distance(x, dim, i, jj);
       const dx = Math.abs(x[i * dim] - x[jj * dim]);
       const dy = Math.abs(x[i * dim + 1] - x[jj * dim + 1]);
       const wx = width2[i * dim] + width2[jj * dim];
@@ -43185,9 +44803,9 @@ function idealDistanceAvoidOverlap(dim, A3, x, width2, idealDistance) {
         t = Math.min(expandmax, t);
         t = Math.max(expandmin, t);
         if (t > 1) {
-          idealDistance[j] = t * dist4;
+          idealDistance[j] = t * dist5;
         } else {
-          idealDistance[j] = -t * dist4;
+          idealDistance[j] = -t * dist5;
         }
       }
     }
@@ -43282,9 +44900,9 @@ function overlapSmootherNew(m, dim, x, width2, neighborhoodOnly, shrink) {
         w[j] = -1 / d[j] / d[j];
         d[j] = -d[j];
       }
-      const dist4 = d[j];
+      const dist5 = d[j];
       diagW += w[j];
-      d[j] = w[j] * dist4;
+      d[j] = w[j] * dist5;
       diagD += d[j];
     }
     w[jdiag] = -diagW;
@@ -43295,11 +44913,11 @@ function overlapSmootherNew(m, dim, x, width2, neighborhoodOnly, shrink) {
 function totalDistance(m, dim, x, y) {
   let total = 0;
   for (let i = 0; i < m; i++) {
-    let dist4 = 0;
+    let dist5 = 0;
     for (let j = 0; j < dim; j++) {
-      dist4 += (y[i * dim + j] - x[i * dim + j]) * (y[i * dim + j] - x[i * dim + j]);
+      dist5 += (y[i * dim + j] - x[i * dim + j]) * (y[i * dim + j] - x[i * dim + j]);
     }
-    total += Math.sqrt(dist4);
+    total += Math.sqrt(dist5);
   }
   return total;
 }
@@ -43332,18 +44950,18 @@ function stressMajorizationSmooth(sm, dim, x, maxitSm) {
           idiag = j;
           continue;
         }
-        let dist4 = distance(x, dim, i, jd[j]);
+        let dist5 = distance(x, dim, i, jd[j]);
         if (d[j] === 0) {
           dd[j] = 0;
         } else {
-          if (dist4 === 0) {
+          if (dist5 === 0) {
             const dij = d[j] / Lw.a[j];
             for (let k = 0; k < dim; k++) {
               x[jd[j] * dim + k] += 1e-4 * (cdrand() + 1e-4) * dij;
             }
-            dist4 = distance(x, dim, i, jd[j]);
+            dist5 = distance(x, dim, i, jd[j]);
           }
-          dd[j] = d[j] / dist4;
+          dd[j] = d[j] / dist5;
         }
         diag += dd[j];
       }
@@ -43362,9 +44980,9 @@ function stressMajorizationSmooth(sm, dim, x, maxitSm) {
   return diff;
 }
 function scaleToEdgeLength(dim, A3, x, avgLabelSize) {
-  let dist4 = averageEdgeLength(A3, dim, x);
-  dist4 = avgLabelSize / Math.max(dist4, MACHINEACC);
-  for (let i = 0; i < dim * A3.m; i++) x[i] *= dist4;
+  let dist5 = averageEdgeLength(A3, dim, x);
+  dist5 = avgLabelSize / Math.max(dist5, MACHINEACC);
+  for (let i = 0; i < dim * A3.m; i++) x[i] *= dist5;
 }
 function removeOverlapPrism(dim, A3, x, labelSizes, ntry, initialScaling, doShrinking) {
   if (!labelSizes) return;
@@ -43731,7 +45349,7 @@ function makeHasEdge(g) {
   }
   return (a, b) => pairs.get(a)?.has(b) === true || undirected && pairs.get(b)?.has(a) === true;
 }
-function mkNConstraintG(g, list, intersect, dist4) {
+function mkNConstraintG(g, list, intersect, dist5) {
   const cg = newCg();
   const flat = flatten(list);
   let lastn;
@@ -43748,7 +45366,7 @@ function mkNConstraintG(g, list, intersect, dist4) {
       const nxp = flat[j];
       if (!intersect(p, nxp)) continue;
       const e = cgEdge(cg, cnodeOf(p), cnodeOf(nxp));
-      e.info.minlen = dist4(p.bb, nxp.bb);
+      e.info.minlen = dist5(p.bb, nxp.bb);
       e.info.weight = hasEdge(p.np, nxp.np) ? 100 : 1;
       created.push(e);
     }
@@ -43795,12 +45413,12 @@ function buildVisibility(flat, intersect) {
   }
   return vg;
 }
-function mapGraphs(vg, flat, cg, dist4) {
+function mapGraphs(vg, flat, cg, dist5) {
   for (let i = 0; i < flat.length; i++) {
     const tp = flat[i];
     for (const j of vg[i]) {
       const hp = flat[j];
-      const delta2 = dist4(tp.bb, hp.bb);
+      const delta2 = dist5(tp.bb, hp.bb);
       const ce = cgEdge(cg, cnodeOf(tp), cnodeOf(hp));
       ce.info.weight = 1;
       if ((ce.info.minlen ?? 0) < delta2) {
@@ -43810,15 +45428,15 @@ function mapGraphs(vg, flat, cg, dist4) {
     }
   }
 }
-function mkConstraintG(list, intersect, dist4) {
+function mkConstraintG(list, intersect, dist5) {
   const cg = newCg();
   const flat = flatten(list);
   buildChain(cg, flat);
-  mapGraphs(buildVisibility(flat, intersect), flat, cg, dist4);
+  mapGraphs(buildVisibility(flat, intersect), flat, cg, dist5);
   return cg;
 }
-function buildConstraintGraph(g, list, ifn, dist4, ortho) {
-  return ortho ? mkConstraintG(list, ifn, dist4) : mkNConstraintG(g, list, ifn, dist4);
+function buildConstraintGraph(g, list, ifn, dist5, ortho) {
+  return ortho ? mkConstraintG(list, ifn, dist5) : mkNConstraintG(g, list, ifn, dist5);
 }
 function newItems() {
   return new DtBag((p) => p.val, cmpitem);
@@ -43959,7 +45577,7 @@ function inflatePts(verts, xmargin, ymargin) {
     v.y *= ymargin;
   }
 }
-function isBox2(verts) {
+function isBox3(verts) {
   if (verts.length !== 4) return false;
   const [v0, v1, v2, v3] = verts;
   if (v0.y === v1.y) {
@@ -44019,7 +45637,7 @@ function clusterVerts(n, xmargin, ymargin) {
 function polyKind(n, poly, verts) {
   const name = shapeName(n);
   if (name === "box") return POLY_BOX;
-  if (name === "polygon" && isBox2(verts)) return POLY_BOX;
+  if (name === "polygon" && isBox3(verts)) return POLY_BOX;
   if (poly.sides < 3 && poly.regular) return POLY_CIRCLE;
   return 0;
 }
@@ -44527,7 +46145,7 @@ function heapSiftUp(h, i) {
     i = parent2;
   }
 }
-function heapSiftDown3(h, i) {
+function heapSiftDown2(h, i) {
   const n = h.length;
   for (; ; ) {
     let smallest = i;
@@ -44544,7 +46162,7 @@ function heapSiftDown3(h, i) {
 }
 function makeHeap(h) {
   for (let i = (h.length >> 1) - 1; i >= 0; i--) {
-    heapSiftDown3(h, i);
+    heapSiftDown2(h, i);
   }
 }
 function heapFindMin(h) {
@@ -44553,7 +46171,7 @@ function heapFindMin(h) {
 function heapDeleteMin(h) {
   h[0] = h[h.length - 1];
   h.pop();
-  if (h.length > 0) heapSiftDown3(h, 0);
+  if (h.length > 0) heapSiftDown2(h, 0);
 }
 function heapInsert(h, c) {
   h.push(c);
@@ -44637,27 +46255,27 @@ var Block = class _Block {
    * @see lib/vpsc/block.cpp: Block::merge(Block* b, Constraint* c)
    */
   mergeTwoArg(b, c) {
-    const dist4 = c.right.offset - c.left.offset - c.gap;
+    const dist5 = c.right.offset - c.left.offset - c.gap;
     let l = c.left.block;
     let r = c.right.block;
     if (this.vars.length < b.vars.length) {
-      r.mergeInto(l, c, dist4);
+      r.mergeInto(l, c, dist5);
     } else {
-      l.mergeInto(r, c, -dist4);
+      l.mergeInto(r, c, -dist5);
     }
   }
   /**
    * Merge block b into this across constraint c by dist.
    * @see lib/vpsc/block.cpp: Block::merge(Block *b, Constraint *c, double dist)
    */
-  mergeInto(b, c, dist4) {
+  mergeInto(b, c, dist5) {
     c.active = true;
-    this.wposn += b.wposn - dist4 * b.weight;
+    this.wposn += b.wposn - dist5 * b.weight;
     this.weight += b.weight;
     this.posn = this.wposn / this.weight;
     for (const v of b.vars) {
       v.block = this;
-      v.offset += dist4;
+      v.offset += dist5;
       this.vars.push(v);
     }
     b.deleted = true;
@@ -44946,13 +46564,13 @@ var Blocks = class {
       r.deleteMinInConstraint();
       let l = c.left.block;
       if (l.in.length === 0) l.setUpInConstraints();
-      let dist4 = c.right.offset - c.left.offset - c.gap;
+      let dist5 = c.right.offset - c.left.offset - c.gap;
       if (r.vars.length < l.vars.length) {
-        dist4 = -dist4;
+        dist5 = -dist5;
         [l, r] = [r, l];
       }
       this.timeCtr.value++;
-      r.mergeInto(l, c, dist4);
+      r.mergeInto(l, c, dist5);
       r.mergeIn(l);
       r.timeStamp = this.timeCtr.value;
       this.removeBlock(l);
@@ -44970,12 +46588,12 @@ var Blocks = class {
       l.deleteMinOutConstraint();
       let r = c.right.block;
       r.setUpOutConstraints();
-      let dist4 = c.left.offset + c.gap - c.right.offset;
+      let dist5 = c.left.offset + c.gap - c.right.offset;
       if (l.vars.length > r.vars.length) {
-        dist4 = -dist4;
+        dist5 = -dist5;
         [l, r] = [r, l];
       }
-      l.mergeInto(r, c, dist4);
+      l.mergeInto(r, c, dist5);
       l.mergeOut(r);
       this.removeBlock(r);
       c = l.findMinOutConstraint();
@@ -45491,7 +47109,7 @@ function warnUnrecognizedOverlap(flag) {
   const s = flag.toLowerCase();
   if (s.startsWith("prism") || NAMED_MODES.has(s)) return;
   if (mapBoolDflt(flag, false) === mapBoolDflt(flag, true)) return;
-  agerrLineOn("warn", `Unrecognized overlap value "${flag}" - using false`);
+  agwarningf(`Unrecognized overlap value "${flag}" - using false`);
 }
 function getAdjustMode(flag) {
   warnUnrecognizedOverlap(flag);
@@ -45524,7 +47142,7 @@ function adjustLate(g, am) {
     case AM_VPSC:
       return vpscAdjust(g);
     default:
-      agerrLineOn("warn", `Unhandled adjust option ${am.print}`);
+      agwarningf(`Unhandled adjust option ${am.print}`);
       return 0;
   }
 }
@@ -46498,20 +48116,20 @@ function coincidentDelta() {
   } while (xdelta === 0 && ydelta === 0);
   return { xdelta, ydelta };
 }
-function doRep(p, q, xdelta, ydelta, dist4) {
+function doRep(p, q, xdelta, ydelta, dist5) {
   let force;
-  if (!(dist4 > 0)) {
+  if (!(dist5 > 0)) {
     const d = coincidentDelta();
     xdelta = d.xdelta;
     ydelta = d.ydelta;
-    dist4 = libmHypot(xdelta, ydelta);
+    dist5 = libmHypot(xdelta, ydelta);
   }
-  if (dist4 > fdpParms.Mlimit) {
+  if (dist5 > fdpParms.Mlimit) {
     force = 0;
   } else if (parms.useNew) {
-    force = parms.K * parms.K / (dist4 * dist4 * dist4);
+    force = parms.K * parms.K / (dist5 * dist5 * dist5);
   } else {
-    force = parms.K * parms.K / (dist4 * dist4);
+    force = parms.K * parms.K / (dist5 * dist5);
   }
   if (isPort(p) && isPort(q)) force *= 10;
   const dq = disp(q);
@@ -46533,8 +48151,8 @@ function doNeighbor(grid2, i, j, nodes) {
     for (const q of cellp.nodes) {
       const xdelta = q.info.pos[0] - p.info.pos[0];
       const ydelta = q.info.pos[1] - p.info.pos[1];
-      const dist4 = libmHypot(xdelta, ydelta);
-      if (dist4 < parms.Cell) doRep(p, q, xdelta, ydelta, dist4);
+      const dist5 = libmHypot(xdelta, ydelta);
+      if (dist5 < parms.Cell) doRep(p, q, xdelta, ydelta, dist5);
     }
   }
 }
@@ -46566,12 +48184,12 @@ function applyAttr(p, q, e) {
     ydelta = d.ydelta;
     dist22 = fma(xdelta, xdelta, ydelta * ydelta);
   }
-  const dist4 = Math.sqrt(dist22);
+  const dist5 = Math.sqrt(dist22);
   let force;
   if (parms.useNew) {
-    force = (e.info.factor ?? 1) * (dist4 - (e.info.dist ?? 1)) / dist4;
+    force = (e.info.factor ?? 1) * (dist5 - (e.info.dist ?? 1)) / dist5;
   } else {
-    force = (e.info.factor ?? 1) * dist4 / (e.info.dist ?? 1);
+    force = (e.info.factor ?? 1) * dist5 / (e.info.dist ?? 1);
   }
   const dq = disp(q);
   const dp = disp(p);
@@ -46746,16 +48364,16 @@ function cntOverlaps(g) {
 function applyRep2(p, q, rs) {
   let xdelta = q.info.pos[0] - p.info.pos[0];
   let ydelta = q.info.pos[1] - p.info.pos[1];
-  let dist4 = libmHypot(xdelta, ydelta);
-  if (!(dist4 > 0)) {
+  let dist5 = libmHypot(xdelta, ydelta);
+  if (!(dist5 > 0)) {
     const d = coincidentDelta();
     xdelta = d.xdelta;
     ydelta = d.ydelta;
-    dist4 = libmHypot(xdelta, ydelta);
+    dist5 = libmHypot(xdelta, ydelta);
   }
   const ov = overlap4(p, q) ? 1 : 0;
-  let force = ov ? rs.ov / (dist4 * dist4) : rs.nonov / (dist4 * dist4);
-  if (dist4 > fdpParms.Mlimit) force = 0;
+  let force = ov ? rs.ov / (dist5 * dist5) : rs.nonov / (dist5 * dist5);
+  if (dist5 > fdpParms.Mlimit) force = 0;
   const dq = disp(q);
   const dp = disp(p);
   dq[0] = fma(xdelta, force, dq[0]);
@@ -46768,10 +48386,10 @@ function applyAttr2(p, q) {
   if (overlap4(p, q)) return;
   const xdelta = q.info.pos[0] - p.info.pos[0];
   const ydelta = q.info.pos[1] - p.info.pos[1];
-  const dist4 = libmHypot(xdelta, ydelta);
+  const dist5 = libmHypot(xdelta, ydelta);
   const din = rad(p) + rad(q);
-  const dout = dist4 - din;
-  const force = dout * dout / ((xParams.K + din) * dist4);
+  const dout = dist5 - din;
+  const force = dout * dout / ((xParams.K + din) * dist5);
   const dq = disp(q);
   const dp = disp(p);
   dq[0] = fms(xdelta, force, dq[0]);
@@ -47926,9 +49544,9 @@ function pcpRotate(n, dim, x) {
     axis[0] = -(-y[0] + y[3] - Math.sqrt(radicand)) / (2 * y[1]);
     axis[1] = 1;
   }
-  const dist4 = Math.sqrt(fma(axis[0], axis[0], 1));
-  axis[0] = axis[0] / dist4;
-  axis[1] = axis[1] / dist4;
+  const dist5 = Math.sqrt(fma(axis[0], axis[0], 1));
+  axis[0] = axis[0] / dist5;
+  axis[1] = axis[1] / dist5;
   for (let i = 0; i < n; i++) {
     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]);
@@ -48341,10 +49959,10 @@ function buildSpanTree(nodes, edges) {
   }
   return map;
 }
-function measureDist(leaf, anc, dist4, change) {
+function measureDist(leaf, anc, dist5, change) {
   const p = anc.tparent;
   if (!p) return;
-  const d = dist4 + 1;
+  const d = dist5 + 1;
   if (p.distone === 0) {
     p.leafone = leaf;
     p.distone = d;
@@ -49844,11 +51462,11 @@ var DEFAULT_COLOR5 = "black";
 var PENWIDTH_NORMAL4 = 1;
 var PENWIDTH_THRESHOLD4 = 5e-3;
 var EPS3 = 1e-5;
-function dist3(a, b) {
+function dist4(a, b) {
   return Math.sqrt(dist2(a, b));
 }
 function approxLen(list, off) {
-  return dist3(list[off], list[off + 1]) + dist3(list[off + 1], list[off + 2]) + dist3(list[off + 2], list[off + 3]);
+  return dist4(list[off], list[off + 1]) + dist4(list[off + 1], list[off + 2]) + dist4(list[off + 2], list[off + 3]);
 }
 function splitCubic(v, t) {
   const left2 = [];
@@ -49927,7 +51545,7 @@ function drawSplitSpline(list, segs, job) {
   return endColor;
 }
 function emitSplitEdgePaths(e, job, colorList) {
-  const segs = parseSegs(colorList).segs;
+  const segs = parseSegs(colorList, edgeSegsContext(e)).segs;
   const firstColor2 = segs[0]?.color ?? DEFAULT_COLOR5;
   const spl = e.info.spl;
   let endColor = firstColor2;
@@ -49948,8 +51566,8 @@ var forfunc = (cur, total, init) => (1 - cur / total) * init / 2;
 var revfunc = (cur, total, init) => cur / total * init / 2;
 var nonefunc = (_cur, _total, init) => init / 2;
 var bothfunc = (cur, total, init) => {
-  const fr3 = cur / total;
-  return fr3 <= 0.5 ? fr3 * init : (1 - fr3) * init;
+  const fr7 = cur / total;
+  return fr7 <= 0.5 ? fr7 * init : (1 - fr7) * init;
 };
 function taperfun(dir, directed) {
   if (dir === "forward") return forfunc;
@@ -51383,7 +53001,7 @@ var DotWriterBase = class {
 
 // src/render/dot/edge-draw.ts
 var DEFAULT_COLOR6 = "black";
-var DEFAULT_LINE_STYLE = ["solid", "setlinewidth(1)"];
+var DEFAULT_LINE_STYLE2 = ["solid", "setlinewidth(1)"];
 function emitArrowOp(buf, op, pen) {
   switch (op.kind) {
     case "polygon":
@@ -51418,8 +53036,9 @@ var EdgeDrawBase = class extends DotWriterBase {
    */
   attachmentPolyline(pts, pencolor, job) {
     const obj = job.obj;
+    gvrenderSetStyle(DEFAULT_LINE_STYLE2);
     if (obj !== null) {
-      obj.rawStyle = [...DEFAULT_LINE_STYLE];
+      obj.rawStyle = [...DEFAULT_LINE_STYLE2];
       obj.pen = 3 /* Solid */;
       obj.penWidth = 1;
       obj.penColor = resolveRenderColor(pencolor.split(":")[0]);
@@ -51473,8 +53092,8 @@ var EdgeDrawBase = class extends DotWriterBase {
    * under that segment's pen. Reuses the same split geometry
    * (splitSplineByColor) as the SVG path. @see lib/common/emit.c:1975 multicolor
    */
-  emitSplitSpline(bzList, colorAttr, edraw, job) {
-    const segs = parseSegs(colorAttr).segs;
+  emitSplitSpline(bzList, e, colorAttr, edraw, job) {
+    const segs = parseSegs(colorAttr, edgeSegsContext(e)).segs;
     const firstColor2 = segs[0]?.color ?? DEFAULT_COLOR6;
     let endColor = firstColor2;
     for (const bz of bzList) {
@@ -51497,7 +53116,7 @@ var EdgeDrawBase = class extends DotWriterBase {
     const segData = bzList.map(
       (bz) => bz !== void 0 && bz.size >= 4 ? buildOffsetLists(bz.list, (2 + numc) / 2) : { offlist: [], tmplist: [] }
     );
-    const colors = parseSegs(colorAttr).segs.map((s) => s.color ?? DEFAULT_COLOR6);
+    const colors = parseSegsSilent(colorAttr).segs.map((s) => s.color ?? DEFAULT_COLOR6);
     for (const color of colors) {
       const pen = xdotPenColor(resolveRenderColor(color));
       for (const sd of segData) {
@@ -51653,7 +53272,7 @@ var XdotRenderer = class extends EdgeDrawBase {
     let tailArrowColor;
     let headArrowColor;
     if (numsemi > 0 && numc > 0) {
-      const c = this.emitSplitSpline(spl.list, colorAttr, edraw, job);
+      const c = this.emitSplitSpline(spl.list, e, colorAttr, edraw, job);
       tailArrowColor = c.firstColor;
       headArrowColor = c.endColor;
     } else if (edgeIsTapered(e)) {
@@ -51889,66 +53508,6 @@ function svgTaperedEdge(e, job) {
   svgArrowPolygons(e, job);
 }
 
-// src/gvc/image-resolver.ts
-var activeResolver = null;
-var EXT_MIME = {
-  png: "image/png",
-  jpg: "image/jpeg",
-  jpeg: "image/jpeg",
-  gif: "image/gif",
-  svg: "image/svg+xml",
-  webp: "image/webp"
-};
-var FALLBACK_MIME = "application/octet-stream";
-function inferMimeFromSrc(src) {
-  const dot = src.lastIndexOf(".");
-  if (dot < 0 || dot === src.length - 1) return FALLBACK_MIME;
-  const ext = src.slice(dot + 1).toLowerCase();
-  return EXT_MIME[ext] ?? FALLBACK_MIME;
-}
-function findImageBytes(src, resolver) {
-  const active = resolver ?? activeResolver;
-  if (active === null) return null;
-  const result = active(src);
-  if (result === null) return null;
-  if (result instanceof Uint8Array) {
-    return { bytes: result, mime: inferMimeFromSrc(src) };
-  }
-  return { bytes: result.bytes, mime: result.mime ?? inferMimeFromSrc(src) };
-}
-var B64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-function base64Encode(bytes) {
-  const len = bytes.length;
-  const out = [];
-  let i = 0;
-  for (; i + 2 < len; i += 3) {
-    const n = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
-    out.push(
-      B64_CHARS[n >> 18 & 63],
-      B64_CHARS[n >> 12 & 63],
-      B64_CHARS[n >> 6 & 63],
-      B64_CHARS[n & 63]
-    );
-  }
-  const remaining = len - i;
-  if (remaining === 1) {
-    const n = bytes[i] << 16;
-    out.push(B64_CHARS[n >> 18 & 63], B64_CHARS[n >> 12 & 63], "==");
-  } else if (remaining === 2) {
-    const n = bytes[i] << 16 | bytes[i + 1] << 8;
-    out.push(
-      B64_CHARS[n >> 18 & 63],
-      B64_CHARS[n >> 12 & 63],
-      B64_CHARS[n >> 6 & 63],
-      "="
-    );
-  }
-  return out.join("");
-}
-function toDataUri(bytes, mime) {
-  return "data:" + mime + ";base64," + base64Encode(bytes);
-}
-
 // src/render/svg.ts
 function emitMulticolorArrows(e, job, headColor, tailColor) {
   const obj = job.obj;
@@ -52364,7 +53923,7 @@ function peg$parse(input, options) {
     return s;
   }
   function peg$f13(t, m, attrs) {
-    if (m) agwarningf("attribute macros not implemented", "error");
+    if (m) agwarningf("attribute macros not implemented");
     return { type: "attr", target: t, attrs };
   }
   function peg$f14(a) {
@@ -56263,7 +57822,7 @@ function isPeggyError(err) {
 function warnNumberAmbiguities(src, upTo) {
   for (const a of scanNumberAmbiguities(src, Stripper.strip(src))) {
     if (a.offset > upTo) break;
-    agerrFinished(numberAmbiguityMessage(a), "error");
+    agerrFinished(numberAmbiguityMessage(a));
   }
 }
 function parse(src) {