@knowvah/dot-engine 2.6.10 → 2.6.12

package/dist/index.js

@@ -1,3 +1,54 @@
+// 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/parser/dot.js
 var peg$SyntaxError = class extends SyntaxError {
   constructor(message, expected, found, location) {
@@ -248,7 +299,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) {
@@ -4221,8 +4272,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)];
@@ -4466,22 +4517,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") {
@@ -4490,10 +4541,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: "" };
@@ -4803,7 +4854,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) {
@@ -4817,7 +4868,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),
@@ -4842,7 +4893,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;
   }
@@ -8542,6 +8593,9 @@ var COLOR_LIB = [
 
 // src/common/color.ts
 var colorScheme = "";
+registerRenderState(() => {
+  colorScheme = "";
+});
 function setColorScheme(scheme) {
   colorScheme = scheme;
 }
@@ -8671,18 +8725,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));
@@ -8728,6 +8792,263 @@ function colorxlate(str, color, targetType) {
   return 1 /* ColorUnknown */;
 }
 
+// src/common/multicolor.ts
+var EPS = 1e-5;
+function aeq0(x) {
+  return x < EPS && x > -EPS;
+}
+function getSegLen(token) {
+  const semi = token.indexOf(";");
+  if (semi === -1) return { color: token, v: 0 };
+  const color = token.slice(0, semi);
+  const rest = token.slice(semi + 1);
+  if (rest.length === 0) return { color, v: -1 };
+  const parsed = parseFloat(rest);
+  return !isNaN(parsed) && parsed >= 0 ? { color, v: parsed } : { color, v: -1 };
+}
+function appendSeg(token, left2, segs, warnedExceeded) {
+  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;
+    }
+    t = left2;
+  }
+  left2 -= t;
+  segs.push({ color: color.length > 0 ? color : null, t, hasFraction: t > 0 && v > 0 });
+  return { left: left2, rval };
+}
+function distributeLeft(segs, left2) {
+  if (left2 <= 0) return;
+  const zeroCount = segs.filter((s) => s.t <= 0).length;
+  if (zeroCount > 0) {
+    const delta2 = left2 / zeroCount;
+    for (const s of segs) {
+      if (s.t <= 0) s.t = delta2;
+    }
+  } else if (segs.length > 0) {
+    segs[segs.length - 1].t += left2;
+  }
+}
+function trimTrailing(segs) {
+  while (segs.length > 0 && (segs[segs.length - 1]?.t ?? 0) <= 0) {
+    segs.pop();
+  }
+}
+function parseSegs(colorlist) {
+  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 };
+    }
+    if (result.rval === 3) rval = 3;
+    left2 = result.left;
+    if (aeq0(left2)) {
+      left2 = 0;
+      break;
+    }
+  }
+  distributeLeft(segs, left2);
+  trimTrailing(segs);
+  return { segs, error: rval };
+}
+
+// src/common/style-resolve.ts
+var DEFAULT_COLOR = "black";
+var DEFAULT_FILL = "lightgrey";
+var PENWIDTH_BOLD = 2;
+var TOKEN_FLAG = {
+  filled: "filled",
+  dashed: "dashed",
+  dotted: "dotted",
+  bold: "bold",
+  invis: "invis",
+  diagonals: "diagonals",
+  rounded: "rounded",
+  striped: "striped",
+  wedged: "wedged",
+  underline: "underline"
+};
+function zeroFlags() {
+  return {
+    filled: false,
+    dashed: false,
+    dotted: false,
+    bold: false,
+    invis: false,
+    diagonals: false,
+    rounded: false,
+    radial: false,
+    striped: false,
+    wedged: false,
+    underline: false,
+    setLineWidth: null
+  };
+}
+var FUNLIMIT = 64;
+function styleTokens(style2) {
+  if (!style2) return [];
+  const out = [];
+  let fun = 0;
+  for (const raw of style2.split(",")) {
+    const token = raw.trim();
+    if (token.length === 0) continue;
+    if (fun === FUNLIMIT - 1) return [];
+    fun++;
+    out.push(token);
+  }
+  return out;
+}
+function parseSetLineWidth(token) {
+  const m = /^setlinewidth\s*\(\s*([^)]*)\)\s*$/.exec(token);
+  if (m === null) return null;
+  const v = parseFloat(m[1]);
+  return Number.isNaN(v) ? 0 : v;
+}
+function applyToken(flags, token) {
+  if (token === "radial") {
+    flags.radial = true;
+    flags.filled = true;
+    return;
+  }
+  const key = TOKEN_FLAG[token];
+  if (key !== void 0) flags[key] = true;
+}
+function nonEmpty(s) {
+  return s !== void 0 && s.length > 0;
+}
+function orElse(s, fallback) {
+  return nonEmpty(s) ? s : fallback;
+}
+function firstSolidColor(raw) {
+  const grad = parseGradientSpec(raw);
+  return grad !== null ? grad[0] : raw;
+}
+function parseStyleFlags(style2) {
+  const flags = zeroFlags();
+  if (!style2) return flags;
+  let fun = 0;
+  for (const raw of style2.split(",")) {
+    const token = raw.trim();
+    if (token.length === 0) continue;
+    if (fun === FUNLIMIT - 1) return zeroFlags();
+    fun++;
+    const lw = parseSetLineWidth(token);
+    if (lw !== null) {
+      flags.setLineWidth = lw;
+      continue;
+    }
+    if (!token.includes("(")) applyToken(flags, token);
+  }
+  return flags;
+}
+function styleHasInvisibleAlias(style2) {
+  if (!style2) return false;
+  let fun = 0;
+  for (const raw of style2.split(",")) {
+    const token = raw.trim();
+    if (token.length === 0) continue;
+    if (fun === FUNLIMIT - 1) return false;
+    fun++;
+    if (token === "invisible") return true;
+  }
+  return false;
+}
+function resolvePenType(flags) {
+  if (flags.invis) return 0 /* None */;
+  if (flags.dashed) return 1 /* Dashed */;
+  if (flags.dotted) return 2 /* Dotted */;
+  return 3 /* Solid */;
+}
+function resolvePenWidth(flags, penwidthAttr) {
+  if (penwidthAttr && penwidthAttr.length > 0) {
+    const v = parseFloat(penwidthAttr);
+    if (isFinite(v)) return v;
+  }
+  if (flags.setLineWidth !== null) return flags.setLineWidth;
+  if (flags.bold) return PENWIDTH_BOLD;
+  return 1;
+}
+function resolvePenColor(colorAttr) {
+  if (!colorAttr || colorAttr.length === 0) return DEFAULT_COLOR;
+  return firstSolidColor(colorAttr);
+}
+function clusterColorAttrs(attrs) {
+  const base = nonEmpty(attrs.color) ? attrs.color : void 0;
+  const pencolor = orElse(attrs.pencolor, base ?? "");
+  const fillcolor = orElse(attrs.fillcolor, base ?? "");
+  return {
+    fillcolor: nonEmpty(fillcolor) ? fillcolor : void 0,
+    pencolor: nonEmpty(pencolor) ? pencolor : void 0
+  };
+}
+function applyBgcolor(attrs, filled, fillcolor) {
+  if ((!filled || !fillcolor) && nonEmpty(attrs.bgcolor)) {
+    return { filled: true, fillcolor: attrs.bgcolor };
+  }
+  return { filled, fillcolor };
+}
+function findStopColor(colorlist) {
+  const { segs, error } = parseSegs(colorlist);
+  if (error === 1 || error === 2) return null;
+  if (segs.length < 2) return null;
+  const seg0 = segs[0];
+  const seg1 = segs[1];
+  if (seg0.color === null) return null;
+  const fillColor = seg0.color;
+  const stopColor = seg1.color ?? DEFAULT_COLOR;
+  const frac = seg0.hasFraction ? seg0.t : seg1.hasFraction ? 1 - seg1.t : 0;
+  return { fillColor, stopColor, frac };
+}
+function parseAngle(gradientangle2) {
+  if (!gradientangle2 || gradientangle2.length === 0) return 0;
+  const v = parseInt(gradientangle2, 10);
+  return isFinite(v) ? v : 0;
+}
+function buildResolvedFill(rawColor, flags, angle) {
+  const stop = findStopColor(rawColor);
+  if (stop === null) return { kind: "solid", color: rawColor };
+  const kind = flags.radial ? "radial" : "linear";
+  return { kind, fillColor: stop.fillColor, stopColor: stop.stopColor, frac: stop.frac, angle };
+}
+function resolveNodeFillEx(attrs) {
+  const flags = parseStyleFlags(attrs.style);
+  if (!flags.filled) return { kind: "none" };
+  const raw = nonEmpty(attrs.fillcolor) ? attrs.fillcolor : nonEmpty(attrs.color) ? attrs.color : DEFAULT_FILL;
+  return buildResolvedFill(raw, flags, parseAngle(attrs.gradientangle));
+}
+function resolveClusterFillEx(attrs) {
+  const flags = parseStyleFlags(attrs.style);
+  const colors = clusterColorAttrs(attrs);
+  const bg = applyBgcolor(attrs, flags.filled, colors.fillcolor);
+  if (!bg.filled) return { kind: "none" };
+  const raw = bg.fillcolor ?? DEFAULT_FILL;
+  return buildResolvedFill(raw, flags, parseAngle(attrs.gradientangle));
+}
+
+// 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",
@@ -8880,12 +9201,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();
@@ -8932,6 +9274,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: styleTokens(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/common/poly-shapes-util.ts
 var RBCONST = 12;
@@ -9543,6 +9951,7 @@ function htmlFillPenWidth() {
 function resetHtmlFillPenWidth() {
   htmlFillPen = 1;
 }
+registerRenderState(resetHtmlFillPenWidth);
 function penTypeOf(style2) {
   const st = htmlStyle(style2);
   if (st.dashed) return 1 /* Dashed */;
@@ -9671,6 +10080,31 @@ 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/htmltable-emit-rules.ts
 function emitHtmlRules(ctx) {
@@ -9757,6 +10191,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;
@@ -10011,7 +10446,7 @@ var sides = (v) => {
 };
 var STYLE_WORDS = ["rounded", "radial", "solid", "invisible", "invis", "dotted", "dashed"];
 var STYLE_DELIM = " ,";
-function styleTokens(v) {
+function styleTokens2(v) {
   const out = [];
   const span = (from, member) => {
     let i = from;
@@ -10030,7 +10465,7 @@ function styleTokens(v) {
 var style = (v) => {
   const legal = [];
   const text = [];
-  for (const tk of styleTokens(v)) {
+  for (const tk of styleTokens2(v)) {
     if (STYLE_WORDS.includes(lower(tk))) legal.push(tk);
     else text.push(warning(`Illegal value ${tk} for STYLE - ignored
 `));
@@ -10149,10 +10584,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);
@@ -10439,28 +10871,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
@@ -10594,14 +11044,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 (; ; ) {
@@ -10610,7 +11060,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;
   }
 }
@@ -10678,9 +11128,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 = [];
@@ -10695,7 +11147,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);
@@ -10795,24 +11249,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);
@@ -10854,8 +11328,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);
@@ -11827,30 +12319,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) {
@@ -16922,6 +17407,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) {
@@ -16929,8 +17415,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;
@@ -17089,10 +17575,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) {
@@ -17775,7 +18288,7 @@ function preprocessTooltip(s) {
 // src/common/make-label.ts
 var DEFAULT_FONTSIZE2 = 14;
 var DEFAULT_FONTNAME = "Times-Roman";
-var DEFAULT_COLOR = "black";
+var DEFAULT_COLOR3 = "black";
 function getPenColor(obj) {
   if (obj === void 0) return void 0;
   const pc = obj.attrs.get("pencolor");
@@ -18397,252 +18910,6 @@ function assembleResult(p, dimen, grown, fixedshape) {
   };
 }
 
-// src/common/multicolor.ts
-var EPS = 1e-5;
-function aeq0(x) {
-  return x < EPS && x > -EPS;
-}
-function getSegLen(token) {
-  const semi = token.indexOf(";");
-  if (semi === -1) return { color: token, v: 0 };
-  const color = token.slice(0, semi);
-  const rest = token.slice(semi + 1);
-  if (rest.length === 0) return { color, v: -1 };
-  const parsed = parseFloat(rest);
-  return !isNaN(parsed) && parsed >= 0 ? { color, v: parsed } : { color, v: -1 };
-}
-function appendSeg(token, left2, segs, warnedExceeded) {
-  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;
-    }
-    t = left2;
-  }
-  left2 -= t;
-  segs.push({ color: color.length > 0 ? color : null, t, hasFraction: t > 0 && v > 0 });
-  return { left: left2, rval };
-}
-function distributeLeft(segs, left2) {
-  if (left2 <= 0) return;
-  const zeroCount = segs.filter((s) => s.t <= 0).length;
-  if (zeroCount > 0) {
-    const delta2 = left2 / zeroCount;
-    for (const s of segs) {
-      if (s.t <= 0) s.t = delta2;
-    }
-  } else if (segs.length > 0) {
-    segs[segs.length - 1].t += left2;
-  }
-}
-function trimTrailing(segs) {
-  while (segs.length > 0 && (segs[segs.length - 1]?.t ?? 0) <= 0) {
-    segs.pop();
-  }
-}
-function parseSegs(colorlist) {
-  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 };
-    }
-    if (result.rval === 3) rval = 3;
-    left2 = result.left;
-    if (aeq0(left2)) {
-      left2 = 0;
-      break;
-    }
-  }
-  distributeLeft(segs, left2);
-  trimTrailing(segs);
-  return { segs, error: rval };
-}
-
-// src/common/style-resolve.ts
-var DEFAULT_COLOR2 = "black";
-var DEFAULT_FILL = "lightgrey";
-var PENWIDTH_BOLD = 2;
-var TOKEN_FLAG = {
-  filled: "filled",
-  dashed: "dashed",
-  dotted: "dotted",
-  bold: "bold",
-  invis: "invis",
-  diagonals: "diagonals",
-  rounded: "rounded",
-  striped: "striped",
-  wedged: "wedged",
-  underline: "underline"
-};
-function zeroFlags() {
-  return {
-    filled: false,
-    dashed: false,
-    dotted: false,
-    bold: false,
-    invis: false,
-    diagonals: false,
-    rounded: false,
-    radial: false,
-    striped: false,
-    wedged: false,
-    underline: false,
-    setLineWidth: null
-  };
-}
-var FUNLIMIT = 64;
-function styleTokens2(style2) {
-  if (!style2) return [];
-  const out = [];
-  let fun = 0;
-  for (const raw of style2.split(",")) {
-    const token = raw.trim();
-    if (token.length === 0) continue;
-    if (fun === FUNLIMIT - 1) return [];
-    fun++;
-    out.push(token);
-  }
-  return out;
-}
-function parseSetLineWidth(token) {
-  const m = /^setlinewidth\s*\(\s*([^)]*)\)\s*$/.exec(token);
-  if (m === null) return null;
-  const v = parseFloat(m[1]);
-  return Number.isNaN(v) ? 0 : v;
-}
-function applyToken(flags, token) {
-  if (token === "radial") {
-    flags.radial = true;
-    flags.filled = true;
-    return;
-  }
-  const key = TOKEN_FLAG[token];
-  if (key !== void 0) flags[key] = true;
-}
-function nonEmpty(s) {
-  return s !== void 0 && s.length > 0;
-}
-function orElse(s, fallback) {
-  return nonEmpty(s) ? s : fallback;
-}
-function firstSolidColor(raw) {
-  const grad = parseGradientSpec(raw);
-  return grad !== null ? grad[0] : raw;
-}
-function parseStyleFlags(style2) {
-  const flags = zeroFlags();
-  if (!style2) return flags;
-  let fun = 0;
-  for (const raw of style2.split(",")) {
-    const token = raw.trim();
-    if (token.length === 0) continue;
-    if (fun === FUNLIMIT - 1) return zeroFlags();
-    fun++;
-    const lw = parseSetLineWidth(token);
-    if (lw !== null) {
-      flags.setLineWidth = lw;
-      continue;
-    }
-    if (!token.includes("(")) applyToken(flags, token);
-  }
-  return flags;
-}
-function styleHasInvisibleAlias(style2) {
-  if (!style2) return false;
-  let fun = 0;
-  for (const raw of style2.split(",")) {
-    const token = raw.trim();
-    if (token.length === 0) continue;
-    if (fun === FUNLIMIT - 1) return false;
-    fun++;
-    if (token === "invisible") return true;
-  }
-  return false;
-}
-function resolvePenType(flags) {
-  if (flags.invis) return 0 /* None */;
-  if (flags.dashed) return 1 /* Dashed */;
-  if (flags.dotted) return 2 /* Dotted */;
-  return 3 /* Solid */;
-}
-function resolvePenWidth(flags, penwidthAttr) {
-  if (penwidthAttr && penwidthAttr.length > 0) {
-    const v = parseFloat(penwidthAttr);
-    if (isFinite(v)) return v;
-  }
-  if (flags.setLineWidth !== null) return flags.setLineWidth;
-  if (flags.bold) return PENWIDTH_BOLD;
-  return 1;
-}
-function resolvePenColor(colorAttr) {
-  if (!colorAttr || colorAttr.length === 0) return DEFAULT_COLOR2;
-  return firstSolidColor(colorAttr);
-}
-function clusterColorAttrs(attrs) {
-  const base = nonEmpty(attrs.color) ? attrs.color : void 0;
-  const pencolor = orElse(attrs.pencolor, base ?? "");
-  const fillcolor = orElse(attrs.fillcolor, base ?? "");
-  return {
-    fillcolor: nonEmpty(fillcolor) ? fillcolor : void 0,
-    pencolor: nonEmpty(pencolor) ? pencolor : void 0
-  };
-}
-function applyBgcolor(attrs, filled, fillcolor) {
-  if ((!filled || !fillcolor) && nonEmpty(attrs.bgcolor)) {
-    return { filled: true, fillcolor: attrs.bgcolor };
-  }
-  return { filled, fillcolor };
-}
-function findStopColor(colorlist) {
-  const { segs, error } = parseSegs(colorlist);
-  if (error === 1 || error === 2) return null;
-  if (segs.length < 2) return null;
-  const seg0 = segs[0];
-  const seg1 = segs[1];
-  if (seg0.color === null) return null;
-  const fillColor = seg0.color;
-  const stopColor = seg1.color ?? DEFAULT_COLOR2;
-  const frac = seg0.hasFraction ? seg0.t : seg1.hasFraction ? 1 - seg1.t : 0;
-  return { fillColor, stopColor, frac };
-}
-function parseAngle(gradientangle2) {
-  if (!gradientangle2 || gradientangle2.length === 0) return 0;
-  const v = parseInt(gradientangle2, 10);
-  return isFinite(v) ? v : 0;
-}
-function buildResolvedFill(rawColor, flags, angle) {
-  const stop = findStopColor(rawColor);
-  if (stop === null) return { kind: "solid", color: rawColor };
-  const kind = flags.radial ? "radial" : "linear";
-  return { kind, fillColor: stop.fillColor, stopColor: stop.stopColor, frac: stop.frac, angle };
-}
-function resolveNodeFillEx(attrs) {
-  const flags = parseStyleFlags(attrs.style);
-  if (!flags.filled) return { kind: "none" };
-  const raw = nonEmpty(attrs.fillcolor) ? attrs.fillcolor : nonEmpty(attrs.color) ? attrs.color : DEFAULT_FILL;
-  return buildResolvedFill(raw, flags, parseAngle(attrs.gradientangle));
-}
-function resolveClusterFillEx(attrs) {
-  const flags = parseStyleFlags(attrs.style);
-  const colors = clusterColorAttrs(attrs);
-  const bg = applyBgcolor(attrs, flags.filled, colors.fillcolor);
-  if (!bg.filled) return { kind: "none" };
-  const raw = bg.fillcolor ?? DEFAULT_FILL;
-  return buildResolvedFill(raw, flags, parseAngle(attrs.gradientangle));
-}
-
 // src/layout/dot/fastgr.ts
 var VIRTUAL = 1;
 var NORMAL = 0;
@@ -18859,10 +19126,10 @@ var SMALL2 = 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 < SMALL2) 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]);
@@ -19319,10 +19586,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) {
@@ -19625,13 +19896,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) {
@@ -20752,7 +21024,7 @@ function readFontParams(sg) {
   return {
     fontsize: parseFloat(graphAttrInherited(sg, "fontsize") ?? "") || DEFAULT_FONTSIZE2,
     fontname: graphAttrInherited(sg, "fontname") ?? DEFAULT_FONTNAME,
-    fontcolor: graphAttrInherited(sg, "fontcolor") ?? DEFAULT_COLOR
+    fontcolor: graphAttrInherited(sg, "fontcolor") ?? DEFAULT_COLOR3
   };
 }
 function applyLabelBorder(sg, dimen) {
@@ -20856,6 +21128,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;
@@ -22630,6 +22905,9 @@ function makeInterclustChain(from, to, orig) {
 
 // src/layout/dot/mincross-cross.ts
 var reMincross = false;
+registerRenderState(() => {
+  reMincross = false;
+});
 function setReMincross(b) {
   reMincross = b;
 }
@@ -23080,6 +23358,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);
@@ -23437,7 +23718,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;
   }
@@ -23902,6 +24183,9 @@ var clType = LOCAL;
 function setClType(t) {
   clType = t;
 }
+registerRenderState(() => {
+  clType = LOCAL;
+});
 function mapbool2(s) {
   if (!s || s === "") return false;
   const l = s.toLowerCase();
@@ -24669,7 +24953,7 @@ function readFontAttrs(n, g) {
   return {
     fontname: nodeAttr(n, g, "fontname") ?? DEFAULT_FONTNAME,
     fontsize: parseFloat(nodeAttr(n, g, "fontsize") ?? String(DEFAULT_FONTSIZE2)),
-    fontcolor: nodeAttr(n, g, "fontcolor") ?? DEFAULT_COLOR
+    fontcolor: nodeAttr(n, g, "fontcolor") ?? DEFAULT_COLOR3
   };
 }
 function assignShapeInfo(n, polyDesc) {
@@ -24694,7 +24978,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);
@@ -25065,20 +25349,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) {
@@ -25166,6 +25466,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);
@@ -25185,6 +25486,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);
@@ -25259,13 +25561,18 @@ function applyPenState(obj, styleAttr, colorAttr, penwidthAttr) {
   obj.penColor = resolveRenderColor(resolvePenColor(colorAttr));
   obj.pen = resolvePenType(flags);
   obj.penWidth = resolvePenWidth(flags, penwidthAttr);
-  obj.rawStyle = styleTokens2(styleAttr);
+  obj.rawStyle = styleTokens(styleAttr);
 }
 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) {
@@ -25482,7 +25789,7 @@ function initFontEdgeAttr(e) {
   return {
     fontsize: lateDouble(e.attrs.get("fontsize"), DEFAULT_FONTSIZE2, MIN_FONTSIZE),
     fontname: e.attrs.get("fontname") || DEFAULT_FONTNAME,
-    fontcolor: e.attrs.get("fontcolor") || DEFAULT_COLOR
+    fontcolor: e.attrs.get("fontcolor") || DEFAULT_COLOR3
   };
 }
 function initFontLabelEdgeAttr(e, fi) {
@@ -25608,7 +25915,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) {
@@ -27257,7 +27564,7 @@ function advanceTmpList(tmplist, offlist) {
 // src/render/svg-parallel-edge.ts
 var PENWIDTH_NORMAL2 = 1;
 var PENWIDTH_THRESHOLD2 = 5e-3;
-var DEFAULT_COLOR3 = "black";
+var DEFAULT_COLOR4 = "black";
 function emitOffsetBezier(tmplist, job, color) {
   const obj = job.obj;
   const resolved = resolveRenderColor(color);
@@ -27299,11 +27606,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_COLOR3);
+  const colors = parseSegs(colorList).segs.map((s) => s.color ?? DEFAULT_COLOR4);
   emitColorPasses(segData, colors, job);
   return {
-    headColor: colors[0] ?? DEFAULT_COLOR3,
-    tailColor: colors[1] ?? colors[0] ?? DEFAULT_COLOR3
+    headColor: colors[0] ?? DEFAULT_COLOR4,
+    tailColor: colors[1] ?? colors[0] ?? DEFAULT_COLOR4
   };
 }
 
@@ -27815,7 +28122,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,
@@ -27932,16 +28238,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 = [];
@@ -28176,9 +28474,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;
@@ -28287,11 +28596,11 @@ 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"));
-  obj.rawStyle = styleTokens2(e.attrs.get("style"));
+  obj.rawStyle = styleTokens(e.attrs.get("style"));
 }
 function renderEdge(e, renderer, job) {
   emitEdgeComments(e, renderer, job);
@@ -28306,6 +28615,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 {
@@ -28389,8 +28700,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);
@@ -28422,6 +28736,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);
@@ -29693,20 +30008,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;
 }
@@ -29795,7 +30110,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;
     }
   }
@@ -32525,7 +32840,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, () => ({
@@ -34844,6 +35159,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 };
@@ -34931,7 +35250,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;
       }
@@ -36044,7 +36363,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;
@@ -38231,7 +38554,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;
@@ -38591,12 +38915,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;
@@ -38913,7 +39237,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) {
@@ -40561,7 +40885,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;
@@ -40658,7 +40982,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;
@@ -40689,7 +41016,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);
@@ -40722,7 +41049,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) {
@@ -40736,9 +41063,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) {
@@ -40749,15 +41076,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") ?? "") !== "";
@@ -40766,7 +41093,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
@@ -40985,13 +41313,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;
@@ -41376,7 +41706,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) {
@@ -41835,6 +42165,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;
@@ -41874,6 +42205,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);
@@ -41881,7 +42217,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);
@@ -41911,18 +42247,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++;
@@ -42269,15 +42605,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]);
       }
     }
@@ -42562,8 +42898,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);
     }
@@ -42865,10 +43201,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);
@@ -43195,7 +43528,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));
@@ -43220,7 +43553,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) {
@@ -43349,8 +43682,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;
 }
@@ -46013,7 +46346,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;
 }
@@ -47953,7 +48290,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;
   }
@@ -47986,7 +48323,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;
   }
@@ -49368,7 +49705,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);
@@ -49401,7 +49738,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;
   }
 }
@@ -49620,20 +49957,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) {
@@ -49902,7 +50239,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,
@@ -49920,6 +50257,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;
 }
@@ -50564,14 +50905,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;
 }
@@ -51433,7 +51779,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);
@@ -52855,7 +53201,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;
@@ -52863,8 +53209,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 });
     }
   }
@@ -53708,12 +54054,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]);
@@ -53762,7 +54108,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) {
@@ -53781,7 +54127,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);
@@ -53796,16 +54142,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
@@ -55250,7 +55596,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) {
@@ -55343,8 +55689,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);
@@ -55353,7 +55699,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,
@@ -55365,7 +55711,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) {
@@ -55375,8 +55721,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).
@@ -55893,8 +56239,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) {
@@ -57162,6 +57508,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();
@@ -57358,6 +57705,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;
@@ -57434,6 +57782,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)));
 }
@@ -57592,6 +57941,7 @@ function classifyError(err) {
 }
 function renderSvg(dotSource, engine) {
   checkRenderArgs2(dotSource, engine);
+  resetRenderState();
   const ctx = createDefaultContext();
   try {
     const g = parse(dotSource);