@knowvah/dot-engine 2.6.10 → 2.6.12

package/dist/render.js

@@ -5079,6 +5079,57 @@ 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";
+var PREFIX_SEP = ": ";
+var DEL = 127;
+var LAST_CNTRL = 31;
+var WHITESPACE = /* @__PURE__ */ new Set([9, 10, 11, 12, 13]);
+var OCTAL_WIDTH = 3;
+var OCTAL_RADIX = 8;
+var lastLevel = "warning";
+registerRenderState(() => {
+  lastLevel = "warning";
+});
+function escapeControl(message) {
+  let out = "";
+  for (const ch of message) {
+    const c = ch.codePointAt(0);
+    if ((c <= LAST_CNTRL || c === DEL) && !WHITESPACE.has(c)) {
+      out += `\\${c.toString(OCTAL_RADIX).padStart(OCTAL_WIDTH, "0")}`;
+    } else out += ch;
+  }
+  return out;
+}
+function agerrLineOn(channel, line) {
+  if (channel === "warn") console.warn(escapeControl(line));
+  else console.error(escapeControl(line));
+}
+function agerr(level, msg, channel) {
+  if (level === "prev") {
+    agerrLineOn(channel ?? (lastLevel === "warning" ? "warn" : "error"), msg);
+    return;
+  }
+  lastLevel = level;
+  const prefix = level === "error" ? PREFIX_ERROR : PREFIX_WARNING;
+  agerrLineOn(channel ?? (level === "warning" ? "warn" : "error"), `${prefix}${PREFIX_SEP}${msg}`);
+}
+var agerrorf = (msg, channel) => agerr("error", msg, channel);
+var agwarningf = (msg, channel) => agerr("warning", msg, channel);
+function agerrFinished(line, channel) {
+  agerrLineOn(channel ?? (line.startsWith(PREFIX_WARNING) ? "warn" : "error"), line);
+}
+
 // src/common/textmeasure-lookup.ts
 var TIMES_FALLBACK = ALL_FONT_METRICS[0];
 function normalizeFontName(name) {
@@ -5092,6 +5143,7 @@ function normalizeFontName(name) {
   return result;
 }
 var warnedFontNames = /* @__PURE__ */ new Set();
+registerRenderState(() => warnedFontNames.clear());
 function getFamilyMetrics(fontName) {
   const key = normalizeFontName(fontName);
   for (const family of ALL_FONT_METRICS) {
@@ -5099,8 +5151,8 @@ function getFamilyMetrics(fontName) {
   }
   if (!warnedFontNames.has(fontName)) {
     warnedFontNames.add(fontName);
-    console.warn(
-      `Warning: no hard-coded metrics for '${fontName}'.  Falling back to 'Times' metrics`
+    agwarningf(
+      `no hard-coded metrics for '${fontName}'.  Falling back to 'Times' metrics`
     );
   }
   return TIMES_FALLBACK;
@@ -5285,10 +5337,37 @@ function getVariantWidths(family, bold, italic) {
   return family.regular;
 }
 var SPACE_CHAR_CODE = 32;
+var FIRST_NON_ASCII = 128;
+var warned = /* @__PURE__ */ new Set();
+var NON_ASCII_FLAG = "non-ascii";
+var ASCII_FLAG = "ascii";
+registerRenderState(() => warned.clear());
+function warnNonAscii(character) {
+  if (warned.has(NON_ASCII_FLAG)) return;
+  warned.add(NON_ASCII_FLAG);
+  agwarningf(
+    `Warning: no value for width of non-ASCII character ${character}. Falling back to width of space character`
+  );
+}
+function warnAscii(character) {
+  if (warned.has(ASCII_FLAG)) return;
+  warned.add(ASCII_FLAG);
+  agwarningf(
+    `Warning: no value for width of ASCII character ${character}. Falling back to 0`
+  );
+}
 function charWidthUnits(widths, charCode) {
-  const code = charCode >= 128 ? SPACE_CHAR_CODE : charCode;
+  let code = charCode;
+  if (code >= FIRST_NON_ASCII) {
+    warnNonAscii(code);
+    code = SPACE_CHAR_CODE;
+  }
   const w = widths[code] ?? -1;
-  return w < 0 ? 0 : w;
+  if (w < 0) {
+    warnAscii(code);
+    return 0;
+  }
+  return w;
 }
 var utf8Encoder = new TextEncoder();
 function utf8Bytes(text) {
@@ -5665,10 +5744,7 @@ var StderrLines = class {
     this.pending = "";
   }
 };
-var consoleLine = (line) => {
-  if (line.startsWith("Warning")) console.warn(line);
-  else console.error(line);
-};
+var consoleLine = (line) => agerrFinished(line);
 var labelStderr = () => new StderrLines(consoleLine);
 var agerrLine = (out, msg) => {
   if (out === void 0) consoleLine(msg);
@@ -5955,28 +6031,46 @@ var HTML_ENTITIES = {
   "zwj": 8205,
   "zwnj": 8204
 };
-var BASIC_ENTITIES = {
-  amp: 38,
-  lt: 60,
-  gt: 62,
-  quot: 34,
-  apos: 39
-};
-function numericEntityValue(body) {
-  const hex = body[1] === "x" || body[1] === "X";
-  const v = hex ? parseInt(body.slice(2), 16) : parseInt(body.slice(1), 10);
-  return Number.isFinite(v) && v > 0 && v <= 1114111 ? v : null;
+var ENTITY_NAME_LENGTH_MAX = 8;
+function numericEntity(s, at) {
+  const hex = s[at + 1] === "x" || s[at + 1] === "X";
+  const digit = hex ? /^[0-9A-Fa-f]$/ : /^[0-9]$/;
+  let n = 0;
+  let i = hex ? 2 : 1;
+  for (; i < 8; i++) {
+    const c = s[at + i] ?? "";
+    if (!digit.test(c)) break;
+    n = n * (hex ? 16 : 10) + parseInt(c, 16);
+  }
+  if (i < 8 && s[at + i] === ";") return { value: n, next: at + i + 1 };
+  return { value: 0, next: at };
+}
+function namedEntity(s, at) {
+  for (let i = 0; i < ENTITY_NAME_LENGTH_MAX; i++) {
+    const c = s[at + i];
+    if (c === void 0 || c === "\0") break;
+    if (c === ";") {
+      const key = s.slice(at, at + i);
+      if (Object.hasOwn(HTML_ENTITIES, key)) return { value: HTML_ENTITIES[key], next: at + i + 1 };
+      break;
+    }
+  }
+  return { value: 0, next: at };
 }
-function entityValue(body) {
-  if (body[0] === "#") return numericEntityValue(body);
-  return BASIC_ENTITIES[body] ?? HTML_ENTITIES[body] ?? null;
+function htmlEntity(s, at) {
+  return s[at] === "#" ? numericEntity(s, at) : namedEntity(s, at);
 }
 function htmlEntityUTF8(s) {
-  if (s.indexOf("&") < 0) return s;
-  return s.replace(/&(#x[0-9a-fA-F]+|#[0-9]+|[A-Za-z]+);/g, (m, body) => {
-    const v = entityValue(body);
-    return v === null ? m : String.fromCodePoint(v);
-  });
+  let amp = s.indexOf("&");
+  if (amp < 0) return s;
+  let out = "";
+  let from = 0;
+  for (; amp >= 0; amp = s.indexOf("&", from)) {
+    const e = htmlEntity(s, amp + 1);
+    out += s.slice(from, amp) + (e.value ? String.fromCodePoint(e.value) : "&");
+    from = e.next;
+  }
+  return out + s.slice(from);
 }
 
 // src/common/htmltable-lex-attvalue.ts
@@ -6110,14 +6204,14 @@ function tagEdge(text, i) {
   if (i + 1 >= text.length) return PARTIAL;
   return text[i + 1] === ">" ? COMPLETE_END(i + 2) : void 0;
 }
-function storeAttError(text, p, at, pair, seen) {
-  if (seen.has(pair.name)) return { message: XML_ERROR_DUPLICATE_ATTRIBUTE, offset: at };
-  seen.add(pair.name);
+function storeAttError(text, p, at, pair, seen2) {
+  if (seen2.has(pair.name)) return { message: XML_ERROR_DUPLICATE_ATTRIBUTE, offset: at };
+  seen2.add(pair.name);
   const err = attValueError(text.slice(pair.value.start, pair.value.end), pair.value.start);
   return err === void 0 ? void 0 : { message: err.message, offset: err.offset ?? p };
 }
 function scanAttributes(text, p, from) {
-  const seen = /* @__PURE__ */ new Set();
+  const seen2 = /* @__PURE__ */ new Set();
   let attError;
   let i = skipSpace(text, from);
   for (; ; ) {
@@ -6126,7 +6220,7 @@ function scanAttributes(text, p, from) {
     if (edge !== void 0) return edge;
     const pair = scanPair(text, i);
     if ("kind" in pair) return pair;
-    attError ??= storeAttError(text, p, i, pair, seen);
+    attError ??= storeAttError(text, p, i, pair, seen2);
     i = pair.next;
   }
 }
@@ -6194,9 +6288,11 @@ function scanCdata(text, p, base, dataOf, tokens) {
 }
 function scanText(text, p, base, tokens) {
   const e = text.indexOf("<", p);
-  const end = e < 0 ? text.length : e;
-  tokens.push({ kind: "text", start: base + p, end: base + end });
-  return end;
+  const slice = text.slice(p, e < 0 ? text.length : e);
+  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 });
+  return { at: end, held: from !== void 0 };
 }
 function scanContent(text, base, inCdata, dataOf) {
   const tokens = [];
@@ -6211,7 +6307,9 @@ function scanContent(text, base, inCdata, dataOf) {
       continue;
     }
     if (text[p] !== "<") {
-      p = scanText(text, p, base, tokens);
+      const scanned = scanText(text, p, base, tokens);
+      if (scanned.held) return { tokens, consumed: scanned.at, inCdata: false };
+      p = scanned.at;
       continue;
     }
     const { scan, kind } = scanMarkup(text, p);
@@ -6311,24 +6409,44 @@ var ExpatFeed = class {
   }
 };
 var XML_PREDEFINED_ENTITIES = /* @__PURE__ */ new Set(["lt", "gt", "amp", "quot", "apos"]);
-var ENTITY_NAME = /^[A-Za-z_:][\w.:-]*$/;
-var CHAR_REF = /^&#(?:x[0-9A-Fa-f]+|[0-9]+);/;
-function textRefError(text) {
-  for (let t = text.indexOf("&"); t >= 0; t = text.indexOf("&", t + 1)) {
-    if (text[t + 1] === "#") {
-      const ref = CHAR_REF.exec(text.slice(t))?.[0];
-      if (ref !== void 0 && charRefNumber(ref) < 0) return { message: XML_ERROR_BAD_CHAR_REF, offset: t };
-      continue;
+var SCANNED_ENTITY = /^&([^;&<]*);/;
+function contentRef(text, t) {
+  const semi = text.indexOf(";", t);
+  const ref = text.slice(t, semi < 0 ? text.length : semi + 1);
+  const scan = scanAttValue(`"${ref}"`, 0);
+  if ("close" in scan) return { end: t + scan.close - 1 };
+  return { invalid: "invalid" in scan ? t + scan.invalid - 1 : text.length };
+}
+function firstRefProblem(text) {
+  let t = text.indexOf("&");
+  while (t >= 0) {
+    if (text[t + 1] !== "#") {
+      const name = SCANNED_ENTITY.exec(text.slice(t))?.[1];
+      if (name !== void 0 && name.length >= 2 && Object.hasOwn(HTML_ENTITIES, name)) {
+        t = text.indexOf("&", t + name.length + 2);
+        continue;
+      }
     }
-    const semi = text.indexOf(";", t + 1);
-    if (semi < 0) continue;
-    const key = text.slice(t + 1, semi);
-    if (ENTITY_NAME.test(key) && !Object.hasOwn(HTML_ENTITIES, key) && !XML_PREDEFINED_ENTITIES.has(key)) {
-      return { message: XML_ERROR_UNDEFINED_ENTITY, offset: t };
+    const ref = contentRef(text, t);
+    if ("invalid" in ref) return { message: XML_ERROR_INVALID_TOKEN, offset: ref.invalid, from: t };
+    const key = text.slice(t + 1, ref.end - 1);
+    if (text[t + 1] === "#") {
+      if (charRefNumber(`&${key};`) < 0) return { message: XML_ERROR_BAD_CHAR_REF, offset: t, from: t };
+    } else if (!XML_PREDEFINED_ENTITIES.has(key)) {
+      return { message: XML_ERROR_UNDEFINED_ENTITY, offset: t, from: t };
     }
+    t = text.indexOf("&", ref.end);
   }
   return void 0;
 }
+function textRefError(text) {
+  const problem = firstRefProblem(text);
+  return problem === void 0 ? void 0 : { message: problem.message, offset: problem.offset };
+}
+function heldRefStart(text) {
+  const problem = firstRefProblem(text);
+  return problem?.message === XML_ERROR_INVALID_TOKEN && problem.offset === text.length ? problem.from : void 0;
+}
 function parseTagChunk(chunk) {
   if (!chunk.endsWith(">")) return void 0;
   const body = chunk.slice(1, -1);
@@ -6370,8 +6488,26 @@ function releaseXb(st, first) {
 function cleanText(decoded) {
   return decoded.replace(/[\x00-\x1f]/g, "");
 }
+var XML_PREDEFINED = { lt: "<", gt: ">", amp: "&", quot: '"', apos: "'" };
+var SCAN_ENTITY_MIN = 2;
+var SCAN_ENTITY_MAX = 8;
+var TEXT_REF = /&(#x[0-9A-Fa-f]+|#[0-9]+|[^&;]+);/g;
+function textRefValue(ref, body) {
+  if (body[0] === "#") {
+    const v = charRefNumber(ref);
+    return v < 0 ? ref : String.fromCodePoint(v);
+  }
+  const n = body.length;
+  if (n >= SCAN_ENTITY_MIN && n <= SCAN_ENTITY_MAX && Object.hasOwn(HTML_ENTITIES, body)) {
+    return String.fromCodePoint(HTML_ENTITIES[body]);
+  }
+  return Object.hasOwn(XML_PREDEFINED, body) ? XML_PREDEFINED[body] : ref;
+}
+function decodeTextRefs(raw) {
+  return raw.indexOf("&") < 0 ? raw : raw.replace(TEXT_REF, textRefValue);
+}
 function textTokens(raw) {
-  return charDataTokens(htmlEntityUTF8(raw));
+  return charDataTokens(decodeTextRefs(raw));
 }
 function charDataTokens(decoded) {
   const clean = cleanText(decoded);
@@ -7337,30 +7473,23 @@ var splitSizedLines = (texts, measurer, env) => {
   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 = (texts, env) => {
+var htmlTextIsSimple = (lines, env) => {
   let prevFs = -1;
   let prevFace = null;
-  let count = 0;
-  for (const txt of texts) {
-    for (const item of txt.items) {
-      if (item.br) {
-        count = 0;
-        continue;
-      }
-      if (item.text === void 0) continue;
-      if (++count > 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;
-    }
+  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(texts, env);
+  const simple = htmlTextIsSimple(lines, env);
   let w = 0;
   let h = 0;
   for (const ln of lines) {
@@ -8940,10 +9069,10 @@ var SMALL = 1e-10;
 function ptToLine2(a, b, p) {
   const dx = b.x - a.x;
   const dy = b.y - a.y;
-  let a2 = (p.y - a.y) * dx - (p.x - a.x) * dy;
+  let a2 = fma(p.y - a.y, dx, -(dy * (p.x - a.x)));
   a2 *= a2;
   if (a2 < SMALL) return 0;
-  return a2 / (dx * dx + dy * dy);
+  return a2 / fma(dx, dx, dy * dy);
 }
 function checkControlPoints(cp) {
   const dis1 = ptToLine2(cp[0], cp[3], cp[1]);
@@ -9434,10 +9563,14 @@ function cubicHalf(c, rightHalf) {
 function curveControlPoints(p, v, w, flag) {
   const AF0 = { x: p.x + v.x + w.x, y: p.y + v.y + w.y };
   const AF3 = { x: p.x - v.x + w.x, y: p.y - v.y + w.y };
-  const s = flag & ARR_MOD_INV ? 1 : -1;
-  const AF1 = { x: p.x + 0.95 * v.x + w.x + s * w.x * (4 / 3), y: AF0.y + s * w.y * (4 / 3) };
-  const AF2 = { x: p.x - 0.95 * v.x + w.x + s * w.x * (4 / 3), y: AF3.y + s * w.y * (4 / 3) };
-  return [AF0, AF1, AF2, AF3];
+  const bulgeX = w.x * 4 / 3;
+  const bulgeY = w.y * 4 / 3;
+  const x1 = fma(v.x, 0.95, p.x) + w.x;
+  const x2 = fma(v.x, -0.95, p.x) + w.x;
+  if (flag & ARR_MOD_INV) {
+    return [AF0, { x: x1 + bulgeX, y: AF0.y + bulgeY }, { x: x2 + bulgeX, y: AF3.y + bulgeY }, AF3];
+  }
+  return [AF0, { x: x1 - bulgeX, y: AF0.y - bulgeY }, { x: x2 - bulgeX, y: AF3.y - bulgeY }, AF3];
 }
 function genCurve(p0, u, _arrowsize, penwidth, flag, rankdir = 0) {
   if (rankdir !== 0) {
@@ -9740,13 +9873,14 @@ function bezierClipNode(sp, cx, cy, insideFn, leftInside) {
     y: p.y + cy
   }));
 }
+function distFused(p, q) {
+  const dx = p.x - q.x;
+  const dy = p.y - q.y;
+  return Math.sqrt(fma(dx, dx, dy * dy));
+}
 function arrowEndClip(path4, arrowTip, elen) {
-  if (elen <= 0) return path4;
   const sp = [arrowTip, path4[2], path4[1], path4[0]];
-  const insideSphere = (lx, ly) => Math.hypot(lx, ly) <= elen;
-  const spRel = sp.map((p) => ({ x: p.x - arrowTip.x, y: p.y - arrowTip.y }));
-  const clippedRel = bezierClipLocal(spRel, insideSphere, true);
-  const clipped = clippedRel.map((p) => ({ x: p.x + arrowTip.x, y: p.y + arrowTip.y }));
+  const clipped = elen > 0 ? bezierClipNode(sp, 0, 0, (x, y) => distFused({ x, y }, arrowTip) <= elen, true) : sp;
   return [clipped[3], clipped[2], clipped[1], clipped[0]];
 }
 function arrowClipLength(arrowName, arrowsize, penwidth) {
@@ -11408,6 +11542,7 @@ function resetHtmlAnchorIds() {
   anchorEnv.objLabel = null;
   anchorEnv.imgscale = "false";
 }
+registerRenderState(resetHtmlAnchorIds);
 function initHtmlAnchor(data, box, renderer, job) {
   if (data.href === void 0 && data.title === void 0 && data.target === void 0) {
     return false;
@@ -12534,7 +12669,7 @@ function polyInit(n, g, measurer) {
   const shapefile = nodeAttr(n, g, "shapefile");
   n.info.shape = bindShape(shapeName2, shapefile);
   if (shapefile !== void 0 && shapefile !== "" && shapeName2 !== "epsf") {
-    console.error(`Warning: No or improper shapefile="${shapefile}" for node "${n.name}"`);
+    agwarningf(`No or improper shapefile="${shapefile}" for node "${n.name}"`, "error");
   }
   if (n.info.shape.kind === 2 /* SH_RECORD */) {
     if (n.info.shape_info === void 0) recordNodeInit(n, g, measurer);
@@ -15160,6 +15295,9 @@ var COLOR_LIB = [
 
 // src/common/color.ts
 var colorScheme = "";
+registerRenderState(() => {
+  colorScheme = "";
+});
 function setColorScheme(scheme) {
   colorScheme = scheme;
 }
@@ -15289,18 +15427,28 @@ function setBlackOpaque(color, targetType) {
   if (targetType === "rgba") setRgba(color, 0, 0, 0, 255);
   else if (targetType === "hsva") setHsvaDirect(color, 0, 0, 0, 1);
 }
+var SSCANF_SPACE = /* @__PURE__ */ new Set([" ", "	", "\n", "\v", "\f", "\r"]);
+function scanHexGroups(p, width2, max) {
+  const out = [];
+  if (p.charAt(0) !== "#") return out;
+  let i = 1;
+  while (out.length < max) {
+    while (SSCANF_SPACE.has(p.charAt(i))) i++;
+    let j = i;
+    while (j < p.length && j - i < width2 && /[0-9a-fA-F]/.test(p.charAt(j))) j++;
+    if (j === i) break;
+    out.push(parseInt(p.slice(i, j), 16));
+    i = j;
+  }
+  return out;
+}
 function parseHexColor(p) {
-  if (p.charAt(0) !== "#") return null;
-  const m8 = /^#([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/.exec(p);
-  if (m8) return { r: parseInt(m8[1], 16), g: parseInt(m8[2], 16), b: parseInt(m8[3], 16), a: parseInt(m8[4], 16) };
-  const m6 = /^#([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/.exec(p);
-  if (m6) return { r: parseInt(m6[1], 16), g: parseInt(m6[2], 16), b: parseInt(m6[3], 16), a: 255 };
-  const m3 = /^#([0-9a-fA-F])([0-9a-fA-F])([0-9a-fA-F])$/.exec(p);
-  if (!m3) return null;
-  const r = parseInt(m3[1], 16);
-  const g = parseInt(m3[2], 16);
-  const b = parseInt(m3[3], 16);
-  return { r: r | r << 4, g: g | g << 4, b: b | b << 4, a: 255 };
+  const g = scanHexGroups(p, 2, 4);
+  if (g.length >= 3) return { r: g[0], g: g[1], b: g[2], a: g[3] ?? 255 };
+  const short = p.length === 4 ? scanHexGroups(p, 1, 3) : [];
+  if (short.length !== 3) return null;
+  const [r, gg, b] = short;
+  return { r: r | r << 4, g: gg | gg << 4, b: b | b << 4, a: 255 };
 }
 function clamp01(x) {
   return Math.max(0, Math.min(1, x));
@@ -15346,6 +15494,17 @@ function colorxlate(str, color, targetType) {
   return 1 /* ColorUnknown */;
 }
 
+// src/common/emit-once.ts
+var seen = /* @__PURE__ */ new Set();
+registerRenderState(() => {
+  seen.clear();
+});
+function emitOnce(str) {
+  if (seen.has(str)) return false;
+  seen.add(str);
+  return true;
+}
+
 // src/render/color-resolve.ts
 var SVG_KNOWN_COLORS = [
   "aliceblue",
@@ -15498,12 +15657,33 @@ var SVG_KNOWN_COLORS = [
   "yellowgreen"
 ];
 var KNOWN_COLORS = new Set(SVG_KNOWN_COLORS);
-function resolveRenderColor(raw) {
+var rendererColors = { hasKnownList: true };
+registerRenderState(() => {
+  rendererColors.hasKnownList = true;
+});
+function setRendererKnownColors(hasList) {
+  rendererColors.hasKnownList = hasList;
+}
+function firstColor(name) {
+  const i = name.indexOf(":");
+  return i < 0 ? name : name.slice(0, i);
+}
+function resolveRenderColor(raw, report = true) {
   if (raw === "" || raw === "none") return { type: "none" };
-  if (KNOWN_COLORS.has(raw.toLowerCase())) return { type: "string", s: raw };
+  const known = KNOWN_COLORS.has(raw.toLowerCase());
+  if (known && (rendererColors.hasKnownList || !report)) return { type: "string", s: raw };
   const color = { type: "rgba", r: 0, g: 0, b: 0, a: 0 };
-  colorxlate(raw, color, "rgba");
-  return color;
+  const rc = colorxlate(raw, color, "rgba");
+  if (report) reportColorxlate(raw, rc);
+  return known ? { type: "string", s: raw } : color;
+}
+function reportColorxlate(name, rc) {
+  if (rc === 0 /* ColorOk */) return;
+  if (rc === 1 /* ColorUnknown */) {
+    if (emitOnce(`color ${name}`)) agwarningf(`${name} is not a known color.`);
+  } else {
+    agerrorf("error in colorxlate()");
+  }
 }
 function withColorScheme(scheme, fn) {
   const prev = getColorScheme();
@@ -15550,6 +15730,72 @@ function textFillAttrs(fontColor) {
   if (byte < 255) out += ' fill-opacity="' + (byte / 255).toFixed(6) + '"';
   return out;
 }
+var DEFAULT_COLOR2 = "black";
+var SEG_EPS = 1e-5;
+function reportColorNames(names) {
+  for (const name of names) resolveRenderColor(firstColor(name));
+}
+function countChar(s, ch) {
+  return s.split(ch).length - 1;
+}
+function multicolorNames(color, arrows) {
+  const { segs, error } = parseSegs(color);
+  if (error === 1 || error === 2) return null;
+  const out = [];
+  const front = segs[0]?.color ?? null;
+  for (const bz of arrows) {
+    let endcolor = null;
+    for (const seg2 of segs) {
+      if (seg2.color === null) break;
+      if (Math.abs(seg2.t) < SEG_EPS) continue;
+      out.push(seg2.color);
+      endcolor = seg2.color;
+    }
+    if (bz.sflag && front !== null) out.push(front);
+    if (bz.eflag && endcolor !== null) out.push(endcolor);
+  }
+  return out;
+}
+function taperedNames(color, fillcolor, hasFill) {
+  const pen = color === "" ? DEFAULT_COLOR2 : color;
+  return hasFill ? [pen, fillcolor === "" ? DEFAULT_COLOR2 : fillcolor] : [pen];
+}
+function edgeGraphicsColors(spec) {
+  const numc = countChar(spec.color, ":");
+  let color = spec.color;
+  if (countChar(color, ";") > 0 && numc > 0) {
+    const multi = multicolorNames(color, spec.arrows);
+    if (multi !== null) return multi;
+    color = DEFAULT_COLOR2;
+  }
+  const hasFill = spec.fillcolor !== "";
+  const early = hasFill ? [spec.fillcolor] : [];
+  if (spec.tapered) return [...early, ...taperedNames(color, spec.fillcolor, hasFill)];
+  if (numc > 0) return [...early, ...color.split(":").filter((c) => c !== "")];
+  const fill = hasFill ? spec.fillcolor : color;
+  if (color !== "") return [...early, color, fill];
+  return [...early, DEFAULT_COLOR2, fill !== "" ? fill : DEFAULT_COLOR2];
+}
+function reportEdgeColors(e) {
+  const spl = e.info.spl;
+  if (!spl) return;
+  const color = e.attrs.get("color") ?? "";
+  reportColorNames(edgeGraphicsColors({
+    color,
+    fillcolor: e.attrs.get("fillcolor") ?? "",
+    tapered: styleTokens2(e.attrs.get("style")).includes("tapered"),
+    arrows: spl.list.map((bz) => ({ sflag: bz.sflag !== 0, eflag: bz.eflag !== 0 }))
+  }));
+}
+function backgroundColors(bgcolor, truecolor) {
+  let str = bgcolor !== void 0 && bgcolor !== "" ? bgcolor : "white";
+  if (str === "transparent") {
+    if (truecolor) return [];
+    str = "white";
+  }
+  const stop = findStopColor(str);
+  return stop === null ? [str, "transparent"] : [stop.fillColor, "transparent", stop.stopColor];
+}
 
 // src/render/svg-multicolor.ts
 var THIN_LINE = 0.5;
@@ -15910,20 +16156,36 @@ function applyClusterObjState(sg, job) {
   if (job.obj === null) return false;
   const obj = job.obj;
   return withColorScheme(clusterAttr(sg, "colorscheme"), () => {
+    const filled = applyClusterFill(obj, fillRes);
     applyClusterPenState(obj, sg);
-    if (fillRes.kind === "none") {
-      obj.fill = 0 /* None */;
-      return false;
-    }
-    if (fillRes.kind === "solid") {
-      obj.fill = 1 /* Solid */;
-      obj.fillColor = resolveRenderColor(fillRes.color);
-      return true;
-    }
-    applyClusterGradient(obj, fillRes);
-    return true;
+    reportColorNames(stripedClusterColors(sg));
+    return filled;
   });
 }
+function stripedClusterColors(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);
+  if (error === 1 || error === 2) return [];
+  return segs.flatMap((seg2) => seg2.color !== null && seg2.t > 0 ? [seg2.color] : []);
+}
+function applyClusterFill(obj, fillRes) {
+  if (fillRes.kind === "none") {
+    obj.fill = 0 /* None */;
+    return false;
+  }
+  if (fillRes.kind === "solid") {
+    obj.fill = 1 /* Solid */;
+    obj.fillColor = resolveRenderColor(fillRes.color);
+    return true;
+  }
+  applyClusterGradient(obj, fillRes);
+  return true;
+}
 
 // src/render/svg-id.ts
 function svgClass(kind, classAttr) {
@@ -16011,6 +16273,7 @@ function renderPeripheries(poly, coord, filled, ctx) {
 }
 function renderLabel(label, coord, renderer, job) {
   if (label.u.kind !== "txt" || label.u.nspans < 1) return;
+  reportColorNames([label.fontcolor]);
   label.pos = coord;
   label.set = true;
   const VALIGN_TOP2 = "t".charCodeAt(0);
@@ -16030,6 +16293,7 @@ function renderNodeLabel(n, coord, renderer, job) {
     label.pos = coord;
     label.set = true;
     const html = label.u.html;
+    reportColorNames(htmlLabelColors(html));
     withLabelEmitState(job, () => emitHtmlLabel(html, coord, renderer, job));
   } else {
     renderLabel(label, coord, renderer, job);
@@ -16109,8 +16373,13 @@ 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");
+  const penwidth = nodeAttr(n, n.root, "penwidth");
+  if (n.info.shape?.kind === 2 /* SH_RECORD */) {
+    applyPenState(obj, styleAttr, colorAttr, penwidth);
+    return applyFillState(obj, n, job);
+  }
   const filled = applyFillState(obj, n, job);
-  applyPenState(obj, styleAttr, colorAttr, nodeAttr(n, n.root, "penwidth"));
+  applyPenState(obj, styleAttr, colorAttr, penwidth);
   return filled;
 }
 function prepareDrawPoly(poly, filled, obj) {
@@ -16390,6 +16659,9 @@ function decompSearch(g, start, cmark) {
   }
 }
 var _dc = { cmark: 0 };
+registerRenderState(() => {
+  _dc.cmark = 0;
+});
 function resolveNode(n, pass) {
   if (pass > 0) {
     const subg = n.info.clust;
@@ -16622,6 +16894,9 @@ function makeInterclustChain(from, to, orig) {
 
 // src/layout/dot/mincross-cross.ts
 var reMincross = false;
+registerRenderState(() => {
+  reMincross = false;
+});
 function setReMincross(b) {
   reMincross = b;
 }
@@ -17138,6 +17413,9 @@ function allocateRanks(g) {
   g.info.rank = rt;
 }
 var fillSeq = 0;
+registerRenderState(() => {
+  fillSeq = 0;
+});
 function makeFillNode(sg, rank3, seq2) {
   const n = agnode(sg, `__fill_${rank3}_${seq2}`, true);
   agsubnode(sg, n, true);
@@ -17495,7 +17773,7 @@ function pruneForeignClusterNodes(par, clust) {
 }
 function markClusterNode(clust, n, g) {
   if ((n.info.ranktype ?? 0) !== 0) {
-    console.error(`Warning: ${n.name} was already in a rankset, deleted from cluster ${g.name}`);
+    agwarningf(`${n.name} was already in a rankset, deleted from cluster ${g.name}`, "error");
     agDeleteFromCluster(clust, n);
     return;
   }
@@ -18074,7 +18352,7 @@ function findCharset(g) {
   }
   if (p === "big-5" || p === "big5") return CHAR_BIG5;
   if (p === "utf-8" || p === "utf8") return CHAR_UTF8;
-  console.error(`Warning: Unsupported charset "${raw}" - assuming utf-8`);
+  agwarningf(`Unsupported charset "${raw}" - assuming utf-8`, "error");
   return CHAR_UTF8;
 }
 function maptoken(p, names, vals) {
@@ -19723,7 +20001,7 @@ function advanceTmpList(tmplist, offlist) {
 // src/render/svg-parallel-edge.ts
 var PENWIDTH_NORMAL2 = 1;
 var PENWIDTH_THRESHOLD2 = 5e-3;
-var DEFAULT_COLOR2 = "black";
+var DEFAULT_COLOR3 = "black";
 function emitOffsetBezier(tmplist, job, color) {
   const obj = job.obj;
   const resolved = resolveRenderColor(color);
@@ -19765,11 +20043,11 @@ 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_COLOR2);
+  const colors = parseSegs(colorList).segs.map((s) => s.color ?? DEFAULT_COLOR3);
   emitColorPasses(segData, colors, job);
   return {
-    headColor: colors[0] ?? DEFAULT_COLOR2,
-    tailColor: colors[1] ?? colors[0] ?? DEFAULT_COLOR2
+    headColor: colors[0] ?? DEFAULT_COLOR3,
+    tailColor: colors[1] ?? colors[0] ?? DEFAULT_COLOR3
   };
 }
 
@@ -20281,7 +20559,6 @@ function beginAnchorIf(renderer, job) {
 }
 var DFLT_SAMPLE = 20;
 var MAP_HW = 2;
-var MAP_SMALL = 1e-10;
 function mapTransform(p, ctx) {
   return {
     x: (p.x + ctx.pad.x - ctx.bb.ll.x) * ctx.scale + ctx.marginOff.x,
@@ -20398,16 +20675,8 @@ function computeLabelRectMap(lab, obj, ctx) {
     mapTransform({ x: lab.pos.x + dx, y: lab.pos.y + dy }, ctx)
   ];
 }
-function ptToLine22(a, b, p) {
-  const dx = b.x - a.x;
-  const dy = b.y - a.y;
-  let a2 = (p.y - a.y) * dx - (p.x - a.x) * dy;
-  a2 *= a2;
-  if (a2 < MAP_SMALL) return 0;
-  return a2 / (dx * dx + dy * dy);
-}
 function checkControlPoints2(cp) {
-  return ptToLine22(cp[0], cp[3], cp[1]) < MAP_HW * MAP_HW && ptToLine22(cp[0], cp[3], cp[2]) < MAP_HW * MAP_HW;
+  return ptToLine2(cp[0], cp[3], cp[1]) < MAP_HW * MAP_HW && ptToLine2(cp[0], cp[3], cp[2]) < MAP_HW * MAP_HW;
 }
 function bezierHalf(v) {
   const left2 = [];
@@ -20642,9 +20911,20 @@ function labelSpanX(lp, just) {
   if (just === "r") return lp.pos.x + lp.space.x / 2;
   return lp.pos.x;
 }
+function labelColorNames(lp) {
+  if (lp.html) return lp.u.kind === "html" ? htmlLabelColors(lp.u.html) : [];
+  return lp.u.kind === "txt" && lp.u.nspans >= 1 ? [lp.fontcolor] : [];
+}
+function reportEdgeLabelColors(e) {
+  const labels = [e.info.label, e.info.xlabel, e.info.head_label, e.info.tail_label];
+  for (const lp of labels) {
+    if (lp?.set) reportColorNames(labelColorNames(lp));
+  }
+}
 function renderOneLabel(lp, renderer, job, requireSet = true) {
   if (!lp) return;
   if (requireSet && !lp.set) return;
+  reportColorNames(labelColorNames(lp));
   if (lp.html) {
     if (lp.u.kind === "html") {
       const html = lp.u.html;
@@ -20753,7 +21033,7 @@ function setEdgePen(e, job) {
   const flags = parseStyleFlags(e.attrs.get("style"));
   obj.penColor = withColorScheme(
     e.attrs.get("colorscheme"),
-    () => resolveRenderColor(resolvePenColor(e.attrs.get("color")))
+    () => resolveRenderColor(resolvePenColor(e.attrs.get("color")), false)
   );
   obj.pen = resolvePenType(flags);
   obj.penWidth = resolvePenWidth(flags, e.attrs.get("penwidth"));
@@ -20772,6 +21052,8 @@ function renderEdge(e, renderer, job) {
     resolveEdgeAnchor(e, svgEdgeId(e, job), obj);
     withColorScheme(e.attrs.get("colorscheme"), () => {
       renderer.beginEdge(e, job);
+      reportEdgeColors(e);
+      reportEdgeLabelColors(e);
       renderer.endEdge(e, job);
     });
   } finally {
@@ -20855,8 +21137,11 @@ function renderPage(g, renderer, job, info) {
     resolveObjAnchor(g, labelTextOf2(g.info.label), svgGraphId(g, job), job.obj);
   }
   const anchored = beginAnchorIf(renderer, job);
-  renderer.pageBackground?.(g, job);
-  renderGraphLabel(g, renderer, job);
+  withColorScheme(g.attrs.get("colorscheme"), () => {
+    reportColorNames(backgroundColors(g.attrs.get("bgcolor"), renderer.type === "svg"));
+    renderer.pageBackground?.(g, job);
+    renderGraphLabel(g, renderer, job);
+  });
   if (anchored) renderer.endAnchor?.(job);
   const clustersLast = (job.flags & EMIT_CLUSTERS_LAST) !== 0;
   if (!clustersLast) renderClusters(g, renderer, job);
@@ -20888,6 +21173,7 @@ function render(ctx, g, format, inlineImages = false) {
   job.scale = { x: z * dpiScale, y: z * dpiScale };
   job.rotation = parseLandscape(g) ? 90 : 0;
   job.renderer = renderer;
+  setRendererKnownColors(renderer.type === "svg");
   resetHtmlAnchorIds();
   for (const n of g.nodes.values()) polyInit(n, g, job.measurer);
   return renderGraph(g, job, renderer);
@@ -20956,6 +21242,7 @@ function htmlFillPenWidth() {
 function resetHtmlFillPenWidth() {
   htmlFillPen = 1;
 }
+registerRenderState(resetHtmlFillPenWidth);
 function penTypeOf(style2) {
   const st = htmlStyle(style2);
   if (st.dashed) return 1 /* Dashed */;
@@ -21084,9 +21371,34 @@ function emitSidedPolylines(sides2, corners, renderer, job) {
     renderer.polyline(seq2.map((i) => corners[i]), job);
   }
 }
+var HTML_DEFAULT_COLOR = "black";
+function bgNames(bgcolor) {
+  const spec = parseGradientSpec(bgcolor);
+  return spec === null ? [bgcolor] : [spec[0], spec[1]];
+}
+function cellNames(cell2) {
+  if (htmlStyle(cell2.style).invisible) return [];
+  const out = cell2.bgcolor !== void 0 ? bgNames(cell2.bgcolor) : [];
+  if (cell2.border > 0) out.push(cell2.color ?? HTML_DEFAULT_COLOR);
+  if (cell2.nested !== void 0) out.push(...tableNames(cell2.nested));
+  else for (const line of cell2.lines) if (line.fontColor !== null) out.push(line.fontColor);
+  return out;
+}
+function tableNames(tbl) {
+  if (htmlStyle(tbl.style).invisible) return [];
+  const out = tbl.bgcolor !== void 0 ? bgNames(tbl.bgcolor) : [];
+  const color = tbl.color ?? HTML_DEFAULT_COLOR;
+  if (tbl.cells.some((c) => c.vruled === true || c.hruled === true)) out.push(color);
+  if (tbl.border > 0) out.push(color);
+  for (const cell2 of tbl.cells) out.push(...cellNames(cell2));
+  return out;
+}
+function htmlLabelColors(label) {
+  return [label.color ?? HTML_DEFAULT_COLOR, ...tableNames(label)];
+}
 
 // src/common/style-resolve.ts
-var DEFAULT_COLOR3 = "black";
+var DEFAULT_COLOR4 = "black";
 var DEFAULT_FILL = "lightgrey";
 var PENWIDTH_BOLD2 = 2;
 var TOKEN_FLAG = {
@@ -21202,7 +21514,7 @@ function resolvePenWidth(flags, penwidthAttr) {
   return 1;
 }
 function resolvePenColor(colorAttr) {
-  if (!colorAttr || colorAttr.length === 0) return DEFAULT_COLOR3;
+  if (!colorAttr || colorAttr.length === 0) return DEFAULT_COLOR4;
   return firstSolidColor(colorAttr);
 }
 function clusterColorAttrs(attrs) {
@@ -21228,7 +21540,7 @@ function findStopColor(colorlist) {
   const seg1 = segs[1];
   if (seg0.color === null) return null;
   const fillColor = seg0.color;
-  const stopColor = seg1.color ?? DEFAULT_COLOR3;
+  const stopColor = seg1.color ?? DEFAULT_COLOR4;
   const frac = seg0.hasFraction ? seg0.t : seg1.hasFraction ? 1 - seg1.t : 0;
   return { fillColor, stopColor, frac };
 }
@@ -23896,6 +24208,9 @@ var clType = LOCAL;
 function setClType(t) {
   clType = t;
 }
+registerRenderState(() => {
+  clType = LOCAL;
+});
 function mapbool2(s) {
   if (!s || s === "") return false;
   const l = s.toLowerCase();
@@ -25479,20 +25794,20 @@ function fillRankVlist(g, r, root) {
   const rankArr = g.info.rank;
   const lead = g.info.rankleader[r];
   if (lead === void 0 || lead === null) {
-    console.error(`Error: rebuild_vlists: lead is null for rank ${r}`);
+    agerrorf(`rebuild_vlists: lead is null for rank ${r}`);
     return -1;
   }
   const rootRank = root.info.rank[r];
   if (rootRank.v[lead.info.order ?? 0] !== lead) {
-    console.error(
-      `Error: rebuild_vlists: rank lead ${lead.name} not in order ${lead.info.order ?? 0} of rank ${r}`
+    agerrorf(
+      `rebuild_vlists: rank lead ${lead.name} not in order ${lead.info.order ?? 0} of rank ${r}`
     );
     return -1;
   }
   rankArr[r].v = rootRank.v;
   rankArr[r].vStart = lead.info.order ?? 0;
   const maxi = computeMaxi(g, r);
-  if (maxi === -1) console.error(`Warning: degenerate concentrated rank ${g.name},${r}`);
+  if (maxi === -1) agwarningf(`degenerate concentrated rank ${g.name},${r}`, "error");
   rankArr[r].n = maxi + 1;
   return 0;
 }
@@ -25581,7 +25896,7 @@ function dotConcentrate(g) {
   const clust = g.info.clust ?? [];
   for (let c = 0; c < nCluster; c++) {
     if (rebuildVlists(clust[c]) !== 0) {
-      console.error("concentrate=true may not work correctly.");
+      agerr("prev", "concentrate=true may not work correctly.");
       return -1;
     }
   }
@@ -28311,7 +28626,7 @@ function routeSplinesInternal(pp, polyline) {
   ];
   const pl = shortestPath(poly, eps);
   if (pl === null) {
-    console.warn("in routesplines, Pshortestpath failed");
+    agerrLineOn("warn", "in routesplines, Pshortestpath failed");
     return null;
   }
   emitDump("S3_POLY", dumpNames, () => ({
@@ -30630,6 +30945,10 @@ function addXLabels(gp) {
 var IGNORED_EDGE = 6;
 var Rankdir = 0;
 var Offset = { x: 0, y: 0 };
+registerRenderState(() => {
+  Rankdir = 0;
+  Offset = { x: 0, y: 0 };
+});
 function mapPoint(p) {
   const r = ccwrotatepf(p, Rankdir * 90);
   return { x: r.x - Offset.x, y: r.y - Offset.y };
@@ -30717,7 +31036,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) {
-          console.warn(`lost ${e.tail.name} ${e.head.name} edge`);
+          agerrLineOn("warn", `lost ${e.tail.name} ${e.head.name} edge`);
         }
         continue;
       }
@@ -31830,7 +32149,11 @@ var A = BigInt("0x5deece66d");
 var C = BigInt("0xb");
 var MASK48 = (1n << 48n) - 1n;
 var TWO48 = 2 ** 48;
-var state = 0x330en;
+var UNSEEDED_STATE = 0x1234abcd330en;
+var state = UNSEEDED_STATE;
+registerRenderState(() => {
+  state = UNSEEDED_STATE;
+});
 function srand48(seed) {
   const s = BigInt(Math.trunc(seed)) & 0xffffffffn;
   state = (s << 16n | 0x330en) & MASK48;
@@ -34017,7 +34340,8 @@ function ensureDummyNodes(sg, gstart) {
 }
 function orthoEdges(g, useLbls, clipAndInstall2) {
   if (useLbls) {
-    console.warn(
+    agerrLineOn(
+      "warn",
       "Orthogonal edges do not currently handle edge labels. Try using xlabels.\n"
     );
     useLbls = false;
@@ -34377,12 +34701,12 @@ function origSeq(e) {
   return resolveOrigEdge(e).seq;
 }
 function dedupByOrig(group) {
-  const seen = /* @__PURE__ */ new Set();
+  const seen2 = /* @__PURE__ */ new Set();
   const out = [];
   for (const e of group) {
     const o = resolveOrigEdge(e);
-    if (seen.has(o)) continue;
-    seen.add(o);
+    if (seen2.has(o)) continue;
+    seen2.add(o);
     out.push(o);
   }
   return out;
@@ -34699,7 +35023,7 @@ function orthoDispatch(g) {
 function curvedTop(g) {
   resetRW(g);
   if (((g.root.info.has_labels ?? 0) & EDGE_LABEL) !== 0) {
-    console.warn("edge labels with splines=curved not supported in dot - use xlabels\n");
+    agerrLineOn("warn", "edge labels with splines=curved not supported in dot - use xlabels\n");
   }
 }
 function finalizeSplines(g, et, normalize) {
@@ -36347,7 +36671,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) {
-    console.warn(`bad edge len "${s}" in ${g.name} - setting to ${DEFAULT_EDGE_LEN.toFixed(2)}`);
+    agerrLineOn("warn", `bad edge len "${s}" in ${g.name} - setting to ${DEFAULT_EDGE_LEN.toFixed(2)}`);
     return DEFAULT_EDGE_LEN;
   }
   return len;
@@ -36444,7 +36768,10 @@ var START_KEYWORDS = [
 ];
 var WARN_POS_IGNORED = "node positions are ignored unless start=random";
 var WARN_SELF_IGNORED = "start=0 not supported with mode=self - ignored";
-var selfWarned = /* @__PURE__ */ new WeakSet();
+var selfOnce = { warned: false };
+registerRenderState(() => {
+  selfOnce.warned = false;
+});
 var circuitWarned = /* @__PURE__ */ new WeakSet();
 function parseStart(p, dflt) {
   let init = dflt;
@@ -36475,7 +36802,7 @@ function initRegular(g, nG) {
 function checkStart(g, nG = g.nodes.size, dflt = INIT_RANDOM) {
   const { init, seed } = parseStart(g.root.attrs.get("start"), dflt);
   if (init !== INIT_RANDOM && [...g.nodes.values()].some((n) => n.attrs.has("pos"))) {
-    console.warn(WARN_POS_IGNORED);
+    agerrLineOn("warn", WARN_POS_IGNORED);
   }
   if (init === INIT_REGULAR) initRegular(g, nG);
   srand48(seed);
@@ -36508,7 +36835,7 @@ function neatoMode(g) {
   if (str === void 0 || str === "") return MODE_MAJOR;
   const mode = modeByName().get(str);
   if (mode !== void 0) return mode;
-  console.warn(`Illegal value ${str} for attribute "mode" in graph ${g.root.name} - ignored`);
+  agerrLineOn("warn", `Illegal value ${str} for attribute "mode" in graph ${g.root.name} - ignored`);
   return MODE_MAJOR;
 }
 function checkMode(g, mode) {
@@ -36522,9 +36849,9 @@ function checkStartAttr(g, mode) {
   const value = g.root.attrs.get("start");
   if (parseStart(value, INIT_RANDOM).init !== INIT_SELF) return;
   if (mode === MODE_MAJOR || mode === MODE_IPSEP) unsupported("start", value ?? "", "smart initialisation");
-  if ((mode === MODE_KK || mode === MODE_SGD) && !selfWarned.has(g.root)) {
-    selfWarned.add(g.root);
-    console.warn(WARN_SELF_IGNORED);
+  if ((mode === MODE_KK || mode === MODE_SGD) && !selfOnce.warned) {
+    selfOnce.warned = true;
+    agerrLineOn("warn", WARN_SELF_IGNORED);
   }
 }
 function isConnected(g) {
@@ -36535,15 +36862,15 @@ function isConnected(g) {
     adj.get(e.tail)?.push(e.head);
     adj.get(e.head)?.push(e.tail);
   }
-  const seen = /* @__PURE__ */ new Set([nodes[0]]);
+  const seen2 = /* @__PURE__ */ new Set([nodes[0]]);
   const stack = [nodes[0]];
   for (let n = stack.pop(); n !== void 0; n = stack.pop()) {
-    for (const m of adj.get(n) ?? []) if (!seen.has(m)) {
-      seen.add(m);
+    for (const m of adj.get(n) ?? []) if (!seen2.has(m)) {
+      seen2.add(m);
       stack.push(m);
     }
   }
-  return seen.size === nodes.length;
+  return seen2.size === nodes.length;
 }
 function kkCircuitFallsBack(g) {
   const packed = getPack(g.root, -1, 0) >= 0 || (g.root.attrs.get("packmode") ?? "") !== "";
@@ -36552,7 +36879,8 @@ function kkCircuitFallsBack(g) {
 function warnCircuitDisconnected(g) {
   if (circuitWarned.has(g.root)) return;
   circuitWarned.add(g.root);
-  console.warn(
+  agerrLineOn(
+    "warn",
     `graph ${g.root.name} is disconnected. Hence, the circuit model
 is undefined. Reverting to the shortest path model.
 Alternatively, consider running neato using -Gpack=true or decomposing
@@ -36771,13 +37099,15 @@ function buildUnfixed(g, n) {
 }
 function resolveModel(model) {
   if (model === MODEL_CIRCUIT2) {
-    console.warn(
+    agerrLineOn(
+      "warn",
       "circuit model not yet supported in Gmode=sgd, reverting to shortpath model"
     );
     return MODEL_SHORTPATH;
   }
   if (model === MODEL_MDS) {
-    console.warn(
+    agerrLineOn(
+      "warn",
       "mds model not yet supported in Gmode=sgd, reverting to shortpath model"
     );
     return MODEL_SHORTPATH;
@@ -37162,7 +37492,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) {
-    console.warn(`Max. iterations (${st.maxIter}) reached on graph ${g.name}`);
+    agerrLineOn("warn", `Max. iterations (${st.maxIter}) reached on graph ${g.name}`);
   }
 }
 function mdsEdges(g, nodes, lens) {
@@ -37621,6 +37951,7 @@ var MODE_MAJOR = 1;
 var MODE_HIER = 2;
 var MODE_IPSEP = 3;
 var MODE_SGD = 4;
+var SGD_ITERATIONS = 30;
 var MODEL_SHORTPATH2 = 0;
 var MODEL_CIRCUIT = 1;
 var MODEL_SUBSET = 2;
@@ -37660,6 +37991,11 @@ function assignNodeIds2(g) {
   }
   return nodeList;
 }
+function neatoMaxIter(maxiter, mode, n) {
+  if (maxiter !== void 0) return parseInt(maxiter, 10) || 0;
+  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);
@@ -37667,7 +38003,7 @@ function runMajorization(g, mode, model) {
   const haveLen = graphHasLen(g);
   const vtx = makeGraphDataC(g, nodeList, haveLen, mode === MODE_HIER || mode === MODE_IPSEP);
   checkStart(g);
-  const maxi = lateDouble(g.attrs.get("maxiter"), DFLT_ITERATIONS, 0);
+  const maxi = neatoMaxIter(g.attrs.get("maxiter"), mode, n);
   const epsilon = lateDouble(g.attrs.get("epsilon"), 1e-4, 0);
   const weighted = haveLen && mode !== MODE_IPSEP;
   const Dij = weighted ? computeWeightedApspPacked2(vtx, n) : computeApspPacked2(vtx, n);
@@ -37697,18 +38033,18 @@ function makeGraphDataC(g, nodeList, haveLen, haveDir) {
   for (const np of nodeList) {
     const i = np.info.id;
     const entry = vtx[i];
-    const seen = /* @__PURE__ */ new Map();
+    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 = seen.get(vid);
+      const idx = seen2.get(vid);
       if (idx !== void 0) {
         if (haveLen) entry.ewgts[idx] = Math.max(entry.ewgts[idx], dist4);
         continue;
       }
-      seen.set(vid, entry.nedges);
+      seen2.set(vid, entry.nedges);
       entry.edges.push(vid);
       if (haveLen || haveDir) entry.ewgts.push(dist4);
       entry.nedges++;
@@ -38055,15 +38391,15 @@ function delaunayTri(xv, yv, n) {
     for (let i = 1; i < n; i++) edges2.push(vs[i - 1], vs[i]);
     return edges2;
   }
-  const seen = /* @__PURE__ */ new Set();
+  const seen2 = /* @__PURE__ */ new Set();
   const pairs = [];
   for (const t of tris) {
     for (const [u, v] of [[t.a, t.b], [t.b, t.c], [t.c, t.a]]) {
       const i = Math.min(u, v);
       const j = Math.max(u, v);
       const key = i * 1048576 + j;
-      if (!seen.has(key)) {
-        seen.add(key);
+      if (!seen2.has(key)) {
+        seen2.add(key);
         pairs.push([i, j]);
       }
     }
@@ -38348,8 +38684,8 @@ var Cdt = class {
       const en = this.edgeOrNew(v3, v4);
       this.removeFace(f1);
       this.removeFace(f2);
-      const f3 = this.addFace([v4, v2, v3], [e5, e2, en]);
-      const f4 = this.addFace([v1, v4, v3], [e4, en, e3]);
+      const f3 = this.addFace([v3, v4, v2], [en, e5, e2]);
+      const f4 = this.addFace([v4, v3, v1], [en, e3, e4]);
       this.swapIfInCircle(f3, v4, v2, v3, e5, e2, en);
       this.swapIfInCircle(f4, v1, v4, v3, e4, en, e3);
     }
@@ -38651,10 +38987,7 @@ function sharedEdge(faces, p3, q3) {
   return { i: p1, j: p2 };
 }
 function addTriEdge(g, t, h, seg2) {
-  const dist4 = Math.hypot(
-    g.nodes[t].ctr.x - g.nodes[h].ctr.x,
-    g.nodes[t].ctr.y - g.nodes[h].ctr.y
-  );
+  const dist4 = 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.nodes[t].edges.push(idx);
@@ -38981,7 +39314,7 @@ var SEP = 15;
 function bisectorTarget(v, cosTheta, sinTheta) {
   return { x: fma(cosTheta, 100, v.x), y: fma(sinTheta, 100, v.y) };
 }
-function distFused(p, q) {
+function distFused2(p, q) {
   const dx = p.x - q.x;
   const dy = p.y - q.y;
   return Math.sqrt(fma(dx, dx, dy * dy));
@@ -39006,7 +39339,7 @@ function mkCtrlPts(s, mult, prev, v, nxt, trip) {
   }
   const q = triPoint(trip, idx, v, w);
   if (q === null) return null;
-  const d = distFused(q, v);
+  const d = distFused2(q, v);
   const sep = d >= mult * SEP ? SEP : d / mult;
   const ps = new Array(mult);
   if (idx < s) {
@@ -39135,8 +39468,8 @@ function chainOf(e) {
   return list;
 }
 function warnNoControlPoints(e) {
-  console.warn(
-    `Warning: Could not create control points for multiple spline for edge (${e.tail.name},${e.head.name})`
+  agwarningf(
+    `Could not create control points for multiple spline for edge (${e.tail.name},${e.head.name})`
   );
   return 1;
 }
@@ -41799,7 +42132,11 @@ function armPow(x, y) {
 
 // src/common/crand.ts
 var C_RAND_MAX = 2147483647;
-var state2 = 1;
+var UNSEEDED_STATE2 = 1;
+var state2 = UNSEEDED_STATE2;
+registerRenderState(() => {
+  state2 = UNSEEDED_STATE2;
+});
 function csrand(seed) {
   state2 = seed;
 }
@@ -43739,7 +44076,7 @@ function makeAddPoly(n, xmargin, ymargin) {
     case 3 /* SH_POINT */:
       return finishPoly(genRound(n, xmargin, ymargin), POLY_CIRCLE);
     default:
-      console.error(`Error: makeAddPoly: unknown shape type ${shapeName(n)}
+      agerrorf(`makeAddPoly: unknown shape type ${shapeName(n)}
 `);
       return null;
   }
@@ -43772,7 +44109,7 @@ function baseShape(n) {
     case 3 /* SH_POINT */:
       return { verts: genRound(n, 0, 0), kind: POLY_CIRCLE };
     default:
-      console.error(`Error: makePoly: unknown shape type ${shapeName(n)}
+      agerrorf(`makePoly: unknown shape type ${shapeName(n)}
 `);
       return null;
   }
@@ -45154,7 +45491,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;
-  console.warn(`Unrecognized overlap value "${flag}" - using false`);
+  agerrLineOn("warn", `Unrecognized overlap value "${flag}" - using false`);
 }
 function getAdjustMode(flag) {
   warnUnrecognizedOverlap(flag);
@@ -45187,7 +45524,7 @@ function adjustLate(g, am) {
     case AM_VPSC:
       return vpscAdjust(g);
     default:
-      console.warn(`Unhandled adjust option ${am.print}`);
+      agerrLineOn("warn", `Unhandled adjust option ${am.print}`);
       return 0;
   }
 }
@@ -45406,20 +45743,20 @@ function setSubtreeSize(g) {
     walkAncestorChain(n);
   }
 }
-function applySpanToChild(g, n, next, ratio, seen) {
+function applySpanToChild(g, n, next, ratio, seen2) {
   const nd2 = rdata(next);
-  if (nd2.parent !== n || nd2.span !== 0 || seen.has(next)) return;
-  seen.add(next);
+  if (nd2.parent !== n || nd2.span !== 0 || seen2.has(next)) return;
+  seen2.add(next);
   nd2.span = ratio * nd2.subtreeSize;
   if (nd2.nChildren > 0) setChildSubtreeSpans(g, next);
 }
 function setChildSubtreeSpans(g, n) {
   const nd = rdata(n);
   const ratio = nd.span / nd.subtreeSize;
-  const seen = /* @__PURE__ */ new Set();
+  const seen2 = /* @__PURE__ */ new Set();
   for (const ep of incidentEdges2(g, n)) {
     const next = neighborOf(ep, n);
-    if (next !== null) applySpanToChild(g, n, next, ratio, seen);
+    if (next !== null) applySpanToChild(g, n, next, ratio, seen2);
   }
 }
 function setSubtreeSpans(sg, center) {
@@ -45688,7 +46025,7 @@ var fdpParms = {
    *  equivalent). @see lib/fdpgen/fdp.h:fdpParms_s.Mlimit */
   Mlimit: Infinity
 };
-var parms = {
+var PARMS_INIT = {
   useGrid: 0,
   useNew: 0,
   seed: 0,
@@ -45706,6 +46043,10 @@ var parms = {
   pass1: 0,
   loopcnt: 0
 };
+var parms = { ...PARMS_INIT };
+registerRenderState(() => {
+  Object.assign(parms, PARMS_INIT);
+});
 function cool(t) {
   return parms.T0 * (parms.maxIters - t) / parms.maxIters;
 }
@@ -46350,14 +46691,19 @@ function fdpTLayout(g, xpms) {
 // src/layout/fdp/xlayout.ts
 var DFLT_OVERLAP = "9:prism";
 var PS2INCH3 = (x) => x / 72;
-var xParams = {
+var XPARAMS_INIT = {
   numIters: 60,
   T0: 0,
   K: 0.3,
   C: 1.5,
   loopcnt: 0
 };
+var xParams = { ...XPARAMS_INIT };
 var xMarg = { x: 0, y: 0, doAdd: false };
+registerRenderState(() => {
+  Object.assign(xParams, XPARAMS_INIT);
+  xMarg = { x: 0, y: 0, doAdd: false };
+});
 function wd2(n) {
   return xMarg.doAdd ? n.info.width / 2 + xMarg.x : n.info.width * xMarg.x / 2;
 }
@@ -47219,7 +47565,7 @@ function fdpSplines(g) {
       );
     }
     if (g.info.n_cluster_edges) {
-      console.warn(CLUSTER_EDGE_WARNING);
+      agerrLineOn("warn", CLUSTER_EDGE_WARNING);
       et = EDGETYPE_LINE;
     } else {
       splineEdges1(g, et);
@@ -48641,7 +48987,7 @@ function buildDerivedGraph(g) {
 }
 function buildDerivedEdges(g, dg) {
   const edges = [];
-  const seen = /* @__PURE__ */ new Set();
+  const seen2 = /* @__PURE__ */ new Set();
   for (const n of nodesInSeq(g)) {
     for (const e of n.outEdges(g)) {
       if (e.tail === e.head) continue;
@@ -48649,8 +48995,8 @@ function buildDerivedEdges(g, dg) {
       const head = dg.nodes.get(e.head.name);
       if (!tail || !head) continue;
       const key = [tail.name, head.name].sort().join("\0");
-      if (seen.has(key)) continue;
-      seen.add(key);
+      if (seen2.has(key)) continue;
+      seen2.add(key);
       edges.push({ tail, head, order: 0, origEdge: e });
     }
   }
@@ -49494,12 +49840,12 @@ function svgEndCluster(job) {
 }
 
 // src/render/svg-edge-split.ts
-var DEFAULT_COLOR4 = "black";
+var DEFAULT_COLOR5 = "black";
 var PENWIDTH_NORMAL4 = 1;
 var PENWIDTH_THRESHOLD4 = 5e-3;
 var EPS3 = 1e-5;
 function dist3(a, b) {
-  return Math.hypot(a.x - b.x, a.y - b.y);
+  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]);
@@ -49548,7 +49894,7 @@ function emitCurve(list, color, job) {
 }
 function stepSegment(list, s, st, out) {
   if (Math.abs(s.t) < EPS3) return;
-  const color = s.color ?? DEFAULT_COLOR4;
+  const color = s.color ?? DEFAULT_COLOR5;
   st.left -= s.t;
   st.endColor = color;
   if (st.first) {
@@ -49567,7 +49913,7 @@ function stepSegment(list, s, st, out) {
   }
 }
 function splitSplineByColor(list, segs) {
-  const st = { left: 1, first: true, bzR: list, done: false, endColor: DEFAULT_COLOR4 };
+  const st = { left: 1, first: true, bzR: list, done: false, endColor: DEFAULT_COLOR5 };
   const curves = [];
   for (const s of segs) {
     stepSegment(list, s, st, curves);
@@ -49582,16 +49928,16 @@ function drawSplitSpline(list, segs, job) {
 }
 function emitSplitEdgePaths(e, job, colorList) {
   const segs = parseSegs(colorList).segs;
-  const firstColor = segs[0]?.color ?? DEFAULT_COLOR4;
+  const firstColor2 = segs[0]?.color ?? DEFAULT_COLOR5;
   const spl = e.info.spl;
-  let endColor = firstColor;
-  if (spl === void 0) return { firstColor, endColor };
+  let endColor = firstColor2;
+  if (spl === void 0) return { firstColor: firstColor2, endColor };
   for (let si = 0; si < spl.size; si++) {
     const bz = spl.list[si];
     if (bz === void 0 || bz.size < 4) continue;
     endColor = drawSplitSpline(bz.list, segs, job);
   }
-  return { firstColor, endColor };
+  return { firstColor: firstColor2, endColor };
 }
 
 // src/common/taper.ts
@@ -51036,7 +51382,7 @@ var DotWriterBase = class {
 };
 
 // src/render/dot/edge-draw.ts
-var DEFAULT_COLOR5 = "black";
+var DEFAULT_COLOR6 = "black";
 var DEFAULT_LINE_STYLE = ["solid", "setlinewidth(1)"];
 function emitArrowOp(buf, op, pen) {
   switch (op.kind) {
@@ -51129,8 +51475,8 @@ var EdgeDrawBase = class extends DotWriterBase {
    */
   emitSplitSpline(bzList, colorAttr, edraw, job) {
     const segs = parseSegs(colorAttr).segs;
-    const firstColor = segs[0]?.color ?? DEFAULT_COLOR5;
-    let endColor = firstColor;
+    const firstColor2 = segs[0]?.color ?? DEFAULT_COLOR6;
+    let endColor = firstColor2;
     for (const bz of bzList) {
       if (bz === void 0 || bz.size < 4) continue;
       const split = splitSplineByColor(bz.list.slice(0, bz.size), segs);
@@ -51139,7 +51485,7 @@ var EdgeDrawBase = class extends DotWriterBase {
         edraw.push(this.styleOp(job), xdotPenColor(resolveRenderColor(c.color)), xdotPoints("B", c.points));
       }
     }
-    return { firstColor, endColor };
+    return { firstColor: firstColor2, endColor };
   }
   /**
    * Emit the parallel-multicolor edge spline: one offset Bézier per color,
@@ -51151,7 +51497,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_COLOR5);
+    const colors = parseSegs(colorAttr).segs.map((s) => s.color ?? DEFAULT_COLOR6);
     for (const color of colors) {
       const pen = xdotPenColor(resolveRenderColor(color));
       for (const sd of segData) {
@@ -51161,8 +51507,8 @@ var EdgeDrawBase = class extends DotWriterBase {
       }
     }
     return {
-      headColor: colors[0] ?? DEFAULT_COLOR5,
-      tailColor: colors[1] ?? colors[0] ?? DEFAULT_COLOR5
+      headColor: colors[0] ?? DEFAULT_COLOR6,
+      tailColor: colors[1] ?? colors[0] ?? DEFAULT_COLOR6
     };
   }
   /** Emit one arrow's primitive ops into `buf` (pen/fill from the edge color).
@@ -51673,8 +52019,8 @@ var SvgRenderer = class {
     const numc = (colorAttr.match(/:/g) ?? []).length;
     const numsemi = (colorAttr.match(/;/g) ?? []).length;
     if (numsemi > 0 && numc > 0) {
-      const { firstColor, endColor } = emitSplitEdgePaths(e, job, colorAttr);
-      emitMulticolorArrows(e, job, endColor, firstColor);
+      const { firstColor: firstColor2, endColor } = emitSplitEdgePaths(e, job, colorAttr);
+      emitMulticolorArrows(e, job, endColor, firstColor2);
     } else if (edgeIsTapered(e)) {
       svgTaperedEdge(e, job);
     } else if (numc > 0) {
@@ -52018,7 +52364,7 @@ function peg$parse(input, options) {
     return s;
   }
   function peg$f13(t, m, attrs) {
-    if (m) console.error("Warning: attribute macros not implemented");
+    if (m) agwarningf("attribute macros not implemented", "error");
     return { type: "attr", target: t, attrs };
   }
   function peg$f14(a) {
@@ -55452,8 +55798,8 @@ var StmtProcessor = class _StmtProcessor {
   resolveEndpoint(item, root, scope, directed) {
     if ("type" in item && item.type === "subgraph") {
       this.processSubgraph(item, scope, root, directed);
-      const seen = /* @__PURE__ */ new Set();
-      const nodes = NameCollector.fromStmts(item.stmts).map((n) => this.registry.ensure(n, root, scope)).filter((nd) => seen.has(nd.id) ? false : (seen.add(nd.id), true));
+      const seen2 = /* @__PURE__ */ new Set();
+      const nodes = NameCollector.fromStmts(item.stmts).map((n) => this.registry.ensure(n, root, scope)).filter((nd) => seen2.has(nd.id) ? false : (seen2.add(nd.id), true));
       return nodes.sort((a, b) => a.id - b.id);
     }
     return [this.registry.ensure(item.id, root, scope)];
@@ -55697,22 +56043,22 @@ function countNewlines(s, from, to) {
   return n;
 }
 var HEADER_KEYWORDS = ["strict", "graph", "digraph"];
-function isTruncatedHeaderKeyword(src, step, offset, seen) {
-  if (offset !== src.length || step.end !== offset || seen.length > 1) return false;
-  if (seen.length === 1 && seen[0].toLowerCase() !== "strict") return false;
+function isTruncatedHeaderKeyword(src, step, offset, seen2) {
+  if (offset !== src.length || step.end !== offset || seen2.length > 1) return false;
+  if (seen2.length === 1 && seen2[0].toLowerCase() !== "strict") return false;
   const word = step.text.toLowerCase();
   return HEADER_KEYWORDS.some((k) => k.length > word.length && k.startsWith(word));
 }
-function reachesOffset(src, step, offset, seen) {
+function reachesOffset(src, step, offset, seen2) {
   if (step.end > offset) return true;
-  if (isTruncatedHeaderKeyword(src, step, offset, seen)) return true;
+  if (isTruncatedHeaderKeyword(src, step, offset, seen2)) return true;
   if (step.text !== "-" && step.text !== ".") return false;
   return offset <= step.end + (step.text === "-" && src[step.end] === "." ? 1 : 0);
 }
 function scanAtError(src, offset) {
   let line = 1;
   let i = 0;
-  const seen = [];
+  const seen2 = [];
   while (i < src.length) {
     const step = lexStep(src, i);
     if (step.kind === "open") {
@@ -55721,10 +56067,10 @@ function scanAtError(src, offset) {
     }
     if (step.kind === "skip" && step.line !== void 0) line = step.line;
     line += countNewlines(src, i, step.end);
-    if (step.kind === "token" && reachesOffset(src, step, offset, seen)) {
+    if (step.kind === "token" && reachesOffset(src, step, offset, seen2)) {
       return { state: "INITIAL", text: step.text, line, buffer: "" };
     }
-    if (step.kind === "token") seen.push(step.text);
+    if (step.kind === "token") seen2.push(step.text);
     i = step.end;
   }
   return { state: "INITIAL", text: "", line, buffer: "" };
@@ -55917,7 +56263,7 @@ function isPeggyError(err) {
 function warnNumberAmbiguities(src, upTo) {
   for (const a of scanNumberAmbiguities(src, Stripper.strip(src))) {
     if (a.offset > upTo) break;
-    console.error(numberAmbiguityMessage(a));
+    agerrFinished(numberAmbiguityMessage(a), "error");
   }
 }
 function parse(src) {
@@ -55931,7 +56277,7 @@ function parse(src) {
     if (isPeggyError(err)) {
       const start = err.location.start;
       warnNumberAmbiguities(src, start.offset);
-      console.error(syntaxErrorMessage(src, start.offset));
+      agerrFinished(syntaxErrorMessage(src, start.offset));
       const code = err.found === null ? "SYNTAX_UNEXPECTED_EOF" : "SYNTAX_ERROR";
       throw new ParseError(
         err instanceof Error ? err.message : String(err),
@@ -55956,7 +56302,7 @@ function parse(src) {
     const offset = err instanceof ParseError ? err.location.offset : void 0;
     if (offset !== void 0) {
       warnNumberAmbiguities(src, offset);
-      console.error(syntaxErrorMessage(src, offset));
+      agerrFinished(syntaxErrorMessage(src, offset));
     }
     throw err;
   }
@@ -56799,6 +57145,7 @@ function checkRenderArgs(g, format, opts) {
 }
 function render2(g, format, opts) {
   checkRenderArgs(g, format, opts);
+  resetRenderState();
   const engine = opts?.engine ?? "dot";
   const inlineImages = opts?.inlineImages ?? false;
   const ctx = createDefaultContext();
@@ -56995,6 +57342,7 @@ async function renderAsync(g, format, opts) {
   const engine = opts?.engine ?? "dot";
   try {
     const { fontIssues, sizes, bytes } = await prefetchAll(g, opts);
+    resetRenderState();
     const ctx = createDefaultContext();
     if (opts?.imageSizer !== void 0) {
       const sizer = (src) => sizes.get(src) ?? null;
@@ -57059,6 +57407,7 @@ function layoutAndRenderXdot(g, engine) {
 }
 function getDrawOps(g, opts) {
   checkDrawOpsArgs(g, opts);
+  resetRenderState();
   const engine = opts?.engine ?? DEFAULT_DRAW_ENGINE;
   return collectGraphOps(parse(layoutAndRenderXdot(g, engine)));
 }