@knowvah/dot-engine 2.6.1 → 2.6.3

package/dist/index.js

@@ -4302,11 +4302,11 @@ function lexToken(s, i) {
 function scanNumberAmbiguities(src, stripped) {
   const out = [];
   let line = 1;
-  let lineAt = 0;
+  let lineAt2 = 0;
   for (let i = 0; i < stripped.length; ) {
     const { next, bad } = lexToken(stripped, i);
     if (bad !== null) {
-      for (; lineAt < i; lineAt++) if (src[lineAt] === "\n") line++;
+      for (; lineAt2 < i; lineAt2++) if (src[lineAt2] === "\n") line++;
       out.push({ text: bad, line, offset: i });
     }
     i = next;
@@ -10341,16 +10341,152 @@ function parseOpenToken(inner) {
   checkTag(tag);
   return { type: "open", tag: normalizeTag(tag), attrs: parseAttrs(inner.slice(sp + 1)) };
 }
-function tokenize(src) {
+var XML_ERROR_UNDEFINED_ENTITY = "undefined entity";
+var XML_ERROR_TAG_MISMATCH = "mismatched tag";
+var XML_ERROR_INVALID_TOKEN = "not well-formed (invalid token)";
+var XML_ERROR_DUPLICATE_ATTRIBUTE = "duplicate attribute";
+var XML_PREDEFINED_ENTITIES = /* @__PURE__ */ new Set(["lt", "gt", "amp", "quot", "apos"]);
+var XML_NAME = /^[A-Za-z_:][\w.:-]*$/;
+var HtmlLexError = class extends HtmlParseError {
+  diagnostics;
+  constructor(tag, message, diagnostics) {
+    super(tag);
+    this.message = message;
+    this.diagnostics = diagnostics;
+  }
+};
+function htmlErrorInLine(message, line, context) {
+  const text = `${message} in line ${line} `;
+  return new HtmlLexError(message, text, [`Error: ${text}`, `... ${context} ...`]);
+}
+var chunkInfo = /* @__PURE__ */ new WeakMap();
+function lineAt(src, pos) {
+  let line = 1;
+  for (let k = 0; k < pos; k++) {
+    if (src[k] === "\n" || src[k] === "\r" && src[k + 1] !== "\n") line++;
+  }
+  return line;
+}
+function chunkLine(info) {
+  if (info.src[info.pos] === "<") return lineAt(info.src, info.pos);
+  const last = info.src.lastIndexOf("\n", info.end - 1);
+  if (last < info.pos) return lineAt(info.src, info.pos);
+  return lineAt(info.src, last === info.end - 1 ? last : last + 1);
+}
+function htmlErrorAtToken(message, tok) {
+  const info = tok === void 0 ? void 0 : chunkInfo.get(tok);
+  if (info === void 0) return void 0;
+  return htmlErrorInLine(message, chunkLine(info), info.context);
+}
+function chunkEnd(src, i) {
+  const j = src[i] === "<" ? src.indexOf(">", i + 1) : src.indexOf("<", i);
+  if (j < 0) return src.length;
+  return src[i] === "<" ? j + 1 : j;
+}
+function findUndefinedEntity(text) {
+  for (let t = text.indexOf("&"); t >= 0; t = text.indexOf("&", t + 1)) {
+    if (text[t + 1] === "#") continue;
+    const semi = text.indexOf(";", t + 1);
+    if (semi < 0) continue;
+    const key = text.slice(t + 1, semi);
+    if (XML_NAME.test(key) && !Object.hasOwn(HTML_ENTITIES, key) && !XML_PREDEFINED_ENTITIES.has(key)) {
+      return t;
+    }
+  }
+  return -1;
+}
+function parseTagChunk(chunk) {
+  if (!chunk.endsWith(">")) return void 0;
+  const body = chunk.slice(1, -1);
+  if (body.startsWith("!")) return void 0;
+  const close = body.startsWith("/");
+  const name = /^[^\s/>]*/.exec(close ? body.slice(1) : body)?.[0] ?? "";
+  return { close, selfClose: !close && body.endsWith("/"), name };
+}
+var ATTR_NAME = /^[A-Za-z_:][\w.:-]*/;
+var isSpace = (c) => c !== void 0 && /\s/.test(c);
+var invalidToken = (offset) => ({ message: XML_ERROR_INVALID_TOKEN, offset });
+function skipSpace(chunk, i) {
+  let j = i;
+  while (isSpace(chunk[j])) j++;
+  return j;
+}
+function readAttrPair(chunk, i) {
+  const name = ATTR_NAME.exec(chunk.slice(i))?.[0];
+  if (name === void 0) return invalidToken(i);
+  let j = skipSpace(chunk, i + name.length);
+  if (chunk[j] !== "=") return invalidToken(j);
+  j = skipSpace(chunk, j + 1);
+  const q = chunk[j];
+  if (q !== '"' && q !== "'") return invalidToken(j);
+  const end = chunk.indexOf(q, j + 1);
+  return end < 0 ? void 0 : { name, next: end + 1 };
+}
+function findAttrError(chunk, from) {
+  const seen = /* @__PURE__ */ new Set();
+  let dup;
+  let i = skipSpace(chunk, from);
+  while (chunk[i] !== ">" && !(chunk[i] === "/" && chunk[i + 1] === ">")) {
+    const pair = readAttrPair(chunk, i);
+    if (pair === void 0) return void 0;
+    if ("message" in pair) return pair;
+    if (seen.has(pair.name) && dup === void 0) dup = { message: XML_ERROR_DUPLICATE_ATTRIBUTE, offset: i };
+    seen.add(pair.name);
+    i = skipSpace(chunk, pair.next);
+  }
+  return dup;
+}
+function checkTagChunk(src, start, st) {
+  const tag = parseTagChunk(st.curr);
+  if (tag === void 0) return;
+  if (tag.close) {
+    if (st.stack.length > 0 && st.stack.pop() !== tag.name) {
+      throw htmlErrorInLine(XML_ERROR_TAG_MISMATCH, lineAt(src, start), st.prev + st.curr);
+    }
+  } else {
+    const bad = findAttrError(st.curr, 1 + tag.name.length);
+    if (bad !== void 0) {
+      throw htmlErrorInLine(bad.message, lineAt(src, start + bad.offset), st.prev + st.curr);
+    }
+    if (!tag.selfClose) st.stack.push(tag.name);
+  }
+  if (KNOWN_TAGS.has(tag.name.toUpperCase())) return;
+  const text = `Unknown HTML element <${tag.name}> on line ${lineAt(src, start)} `;
+  throw new HtmlLexError(tag.name.toUpperCase(), text, [`Error: ${text}`]);
+}
+function checkChunk(src, start, st) {
+  if (st.curr.startsWith("<")) {
+    checkTagChunk(src, start, st);
+    return;
+  }
+  const off = findUndefinedEntity(st.curr);
+  if (off >= 0) {
+    throw htmlErrorInLine(XML_ERROR_UNDEFINED_ENTITY, lineAt(src, start + off), st.prev + st.curr);
+  }
+}
+function tokenizeDeferred(src) {
   const tokens = [];
+  const st = { stack: [], prev: "", curr: "" };
   let i = 0;
-  while (i < src.length) {
-    i = src[i] === "<" ? scanTag(src, i, tokens) : scanText(src, i, tokens);
+  try {
+    while (i < src.length) {
+      const first = tokens.length;
+      const start = i;
+      st.prev = st.curr;
+      st.curr = src.slice(i, chunkEnd(src, i));
+      checkChunk(src, i, st);
+      i = src[i] === "<" ? scanTag(src, i, tokens) : scanText(src, i, tokens);
+      const info = { src, pos: start, end: i, context: st.prev + st.curr };
+      for (let k = first; k < tokens.length; k++) chunkInfo.set(tokens[k], info);
+    }
+  } catch (e) {
+    if (e instanceof HtmlParseError) return { tokens, error: e };
+    throw e;
   }
-  return tokens;
+  return { tokens };
 }
 
-// src/common/htmltable-parse.ts
+// src/common/htmltable-parse-attrs.ts
 function anchorAttr(v) {
   return v === void 0 ? void 0 : htmlEntityUTF8(v);
 }
@@ -10373,6 +10509,81 @@ var num = (s) => {
   const n = parseInt(s, 10);
   return isNaN(n) ? void 0 : n;
 };
+var parseFixedSize = (a) => a["fixedsize"]?.toUpperCase() === "TRUE" ? true : void 0;
+var parseTitle = (a) => a["title"] !== void 0 ? a["title"] : a["tooltip"];
+var parseSides = (v) => {
+  if (v === void 0) return void 0;
+  let flags = 0;
+  for (const c of v.toLowerCase()) {
+    if (c === "l") flags |= BORDER_LEFT;
+    else if (c === "t") flags |= BORDER_TOP;
+    else if (c === "r") flags |= BORDER_RIGHT;
+    else if (c === "b") flags |= BORDER_BOTTOM;
+  }
+  if (flags === 0 || flags === BORDER_MASK) return void 0;
+  return flags;
+};
+var parseGradientAngle = (v) => {
+  if (v === void 0) return void 0;
+  const n = parseInt(v, 10);
+  if (isNaN(n) || String(n) !== v.trim()) return void 0;
+  if (n < 0 || n > 360) return void 0;
+  return n;
+};
+var parseColumns = (v) => v === "*" ? true : void 0;
+var parseRows = (v) => v === "*" ? true : void 0;
+var buildCell = (content, a) => ({
+  kind: "cell",
+  content,
+  port: a["port"],
+  align: parseAlign(a["align"] !== void 0 ? a["align"] : ""),
+  valign: parseVAlign(a["valign"] !== void 0 ? a["valign"] : ""),
+  balign: parseAlign(a["balign"] !== void 0 ? a["balign"] : ""),
+  bgcolor: a["bgcolor"],
+  color: a["color"],
+  border: num(a["border"]),
+  cellpadding: num(a["cellpadding"]),
+  cellspacing: num(a["cellspacing"]),
+  sides: parseSides(a["sides"]),
+  gradientangle: parseGradientAngle(a["gradientangle"]),
+  style: a["style"],
+  width: num(a["width"]),
+  height: num(a["height"]),
+  fixedsize: parseFixedSize(a),
+  colspan: num(a["colspan"]),
+  rowspan: num(a["rowspan"]),
+  href: anchorAttr(a["href"]),
+  title: parseTitle(a),
+  target: anchorAttr(a["target"]),
+  id: a["id"]
+});
+var buildTable = (rows, a) => ({
+  kind: "table",
+  rows,
+  border: num(a["border"]),
+  cellborder: num(a["cellborder"]),
+  cellspacing: num(a["cellspacing"]),
+  cellpadding: num(a["cellpadding"]),
+  bgcolor: a["bgcolor"],
+  color: a["color"],
+  style: a["style"],
+  align: parseAlign(a["align"] !== void 0 ? a["align"] : ""),
+  valign: parseVAlign(a["valign"] !== void 0 ? a["valign"] : ""),
+  fixedsize: parseFixedSize(a),
+  width: num(a["width"]),
+  height: num(a["height"]),
+  href: anchorAttr(a["href"]),
+  title: parseTitle(a),
+  target: anchorAttr(a["target"]),
+  id: a["id"],
+  port: a["port"],
+  sides: parseSides(a["sides"]),
+  gradientangle: parseGradientAngle(a["gradientangle"]),
+  vrule: parseColumns(a["columns"]),
+  hrule: parseRows(a["rows"])
+});
+
+// src/common/htmltable-parse.ts
 var definedOf = (s) => Object.fromEntries(
   Object.entries(s).filter(([, v]) => v !== void 0)
 );
@@ -10396,6 +10607,11 @@ var fontItemProps = (f) => {
   if (f.fontSize !== void 0) out.fontSize = f.fontSize;
   return out;
 };
+var MSG_SYNTAX_ERROR = "syntax error";
+var MSG_TEXT_BEFORE_TABLE = "Syntax error: non-space string used before <TABLE>";
+var MSG_TEXT_AFTER_TABLE = "Syntax error: non-space string used after </TABLE>";
+var nonSpace = (text) => /[^ \t\n\r]/.test(text);
+var parseError = (s, tok, message) => (tok === void 0 ? s.pending : htmlErrorAtToken(message, tok)) ?? new HtmlParseError(message);
 var peek = (s) => s.tokens[s.pos];
 var consume = (s) => {
   const t = s.tokens[s.pos];
@@ -10414,12 +10630,20 @@ var inlineFontState = (tag, _attrs) => {
   if (tag === "SUP") fs.superscript = true;
   return fs;
 };
+var consumeClose = (s, tag) => {
+  const nxt = peek(s);
+  if (nxt === void 0) return;
+  if (nxt.type === "close" && nxt.tag === tag) {
+    consume(s);
+    return;
+  }
+  throw parseError(s, nxt, MSG_SYNTAX_ERROR);
+};
 var applyBrTag = (s, t, fontStack, items) => {
   consume(s);
   const font = fontStack[fontStack.length - 1] ?? {};
   items.push({ br: true, brAlign: parseAlign(t.attrs["align"] ?? ""), ...fontItemProps(font) });
-  const nxt = peek(s);
-  if (nxt?.type === "close" && nxt.tag === "BR") consume(s);
+  consumeClose(s, "BR");
 };
 var applyFontTag = (s, t, fontStack, items) => {
   consume(s);
@@ -10476,12 +10700,6 @@ var parseText = (s, fontStack) => {
   }
   return { kind: "text", items };
 };
-var parseHrContent = (s) => {
-  consume(s);
-  const nxt = peek(s);
-  if (nxt?.type === "close" && nxt.tag === "HR") consume(s);
-  return { kind: "hr" };
-};
 var parseImgContent = (s, t, cellAttrs) => {
   consume(s);
   const img = {
@@ -10489,24 +10707,54 @@ var parseImgContent = (s, t, cellAttrs) => {
     src: cellAttrs["src"] ?? t.attrs["src"] ?? "",
     scale: t.attrs["scale"]
   };
-  const nxt = peek(s);
-  if (nxt?.type === "close" && nxt.tag === "IMG") consume(s);
+  consumeClose(s, "IMG");
   return img;
 };
-var parseCellItem = (s, t, cellAttrs, fontStack) => {
-  if (t.type === "open" && t.tag === "TABLE") return [parseTable(s, fontStack)];
-  if (t.type === "open" && t.tag === "IMG") return [parseImgContent(s, t, cellAttrs)];
-  if (t.type === "open" && t.tag === "HR") return [parseHrContent(s)];
+var scanCellTable = (s, t, fontStack, st) => {
+  if (st.kind === "image" || st.kind === "table") throw parseError(s, t, MSG_SYNTAX_ERROR);
+  if (st.textNonSpace) throw parseError(s, t, MSG_TEXT_BEFORE_TABLE);
+  const tbl = parseTable(s, fontStack);
+  st.kind = "table";
+  return [tbl];
+};
+var scanCellText = (s, t, fontStack, st) => {
+  const start = s.pos;
   const txt = parseText(s, fontStack);
+  if (s.pos === start) throw parseError(s, t, MSG_SYNTAX_ERROR);
+  if (txt.items.some((i) => i.text !== void 0 && nonSpace(i.text))) st.textNonSpace = true;
+  st.kind = "text";
   return txt.items.length > 0 ? [txt] : [];
 };
+var scanAfterTable = (s, t, st) => {
+  if (t.type !== "text") throw parseError(s, t, st.afterNonSpace ? MSG_TEXT_AFTER_TABLE : MSG_SYNTAX_ERROR);
+  consume(s);
+  if (nonSpace(t.value)) st.afterNonSpace = true;
+  return [];
+};
+var scanCellImage = (s, t, cellAttrs, st) => {
+  if (st.kind !== "none") throw parseError(s, t, MSG_SYNTAX_ERROR);
+  st.kind = "image";
+  return [parseImgContent(s, t, cellAttrs)];
+};
+var scanCellItem = (s, t, cellAttrs, fontStack, st) => {
+  if (st.kind === "table") return scanAfterTable(s, t, st);
+  if (t.type === "open" && t.tag === "TABLE") return scanCellTable(s, t, fontStack, st);
+  if (t.type === "open" && t.tag === "IMG") return scanCellImage(s, t, cellAttrs, st);
+  if (st.kind === "image") throw parseError(s, t, MSG_SYNTAX_ERROR);
+  return scanCellText(s, t, fontStack, st);
+};
+var endsCell = (s, t, st) => {
+  if (t.type !== "close") return false;
+  const afterText = st.kind === "table" && st.afterNonSpace;
+  if (t.tag === "TD" && !afterText) return true;
+  throw parseError(s, t, afterText ? MSG_TEXT_AFTER_TABLE : MSG_SYNTAX_ERROR);
+};
 var parseCellContent = (s, cellAttrs, fontStack) => {
   const content = [];
-  while (s.pos < s.tokens.length) {
-    const t = peek(s);
-    if (!t) break;
-    if (t.type === "close" && t.tag === "TD") break;
-    content.push(...parseCellItem(s, t, cellAttrs, fontStack));
+  const st = { kind: "none", textNonSpace: false, afterNonSpace: false };
+  for (let t = peek(s); t !== void 0; t = peek(s)) {
+    if (endsCell(s, t, st)) break;
+    content.push(...scanCellItem(s, t, cellAttrs, fontStack, st));
   }
   const nxt = peek(s);
   if (nxt?.type === "close" && nxt.tag === "TD") consume(s);
@@ -10514,134 +10762,85 @@ var parseCellContent = (s, cellAttrs, fontStack) => {
   if (tbl !== void 0) return [tbl];
   return content;
 };
-var parseFixedSize = (a) => a["fixedsize"]?.toUpperCase() === "TRUE" ? true : void 0;
-var parseTitle = (a) => a["title"] !== void 0 ? a["title"] : a["tooltip"];
-var parseSides = (v) => {
-  if (v === void 0) return void 0;
-  let flags = 0;
-  for (const c of v.toLowerCase()) {
-    if (c === "l") flags |= BORDER_LEFT;
-    else if (c === "t") flags |= BORDER_TOP;
-    else if (c === "r") flags |= BORDER_RIGHT;
-    else if (c === "b") flags |= BORDER_BOTTOM;
-  }
-  if (flags === 0 || flags === BORDER_MASK) return void 0;
-  return flags;
-};
-var parseGradientAngle = (v) => {
-  if (v === void 0) return void 0;
-  const n = parseInt(v, 10);
-  if (isNaN(n) || String(n) !== v.trim()) return void 0;
-  if (n < 0 || n > 360) return void 0;
-  return n;
-};
-var parseColumns = (v) => v === "*" ? true : void 0;
-var parseRows = (v) => v === "*" ? true : void 0;
-var buildCell = (content, a) => ({
-  kind: "cell",
-  content,
-  port: a["port"],
-  align: parseAlign(a["align"] !== void 0 ? a["align"] : ""),
-  valign: parseVAlign(a["valign"] !== void 0 ? a["valign"] : ""),
-  balign: parseAlign(a["balign"] !== void 0 ? a["balign"] : ""),
-  bgcolor: a["bgcolor"],
-  color: a["color"],
-  border: num(a["border"]),
-  cellpadding: num(a["cellpadding"]),
-  cellspacing: num(a["cellspacing"]),
-  sides: parseSides(a["sides"]),
-  gradientangle: parseGradientAngle(a["gradientangle"]),
-  style: a["style"],
-  width: num(a["width"]),
-  height: num(a["height"]),
-  fixedsize: parseFixedSize(a),
-  colspan: num(a["colspan"]),
-  rowspan: num(a["rowspan"]),
-  href: anchorAttr(a["href"]),
-  title: parseTitle(a),
-  target: anchorAttr(a["target"]),
-  id: a["id"]
-});
 var parseCell = (s, attrs, fontStack) => buildCell(parseCellContent(s, attrs, fontStack), attrs);
-var processRowToken = (s, t, cells, fontStack) => {
+var parseRowVr = (s, t, cells) => {
+  const prev = cells[cells.length - 1];
+  if (prev === void 0) throw parseError(s, t, MSG_SYNTAX_ERROR);
+  consume(s);
+  consumeClose(s, "VR");
+  prev.vruled = true;
+};
+var scanRowCell = (s, t, fontStack, rs) => {
   if (t.type === "open" && t.tag === "TD") {
     consume(s);
-    cells.push(parseCell(s, t.attrs, fontStack));
-    return;
+    rs.cells.push(parseCell(s, t.attrs, fontStack));
+    rs.needCell = false;
+  } else if (t.type === "open" && t.tag === "VR" && !rs.needCell) {
+    parseRowVr(s, t, rs.cells);
+    rs.needCell = true;
+  } else {
+    throw parseError(s, t, MSG_SYNTAX_ERROR);
   }
-  if (t.type === "open" && t.tag === "VR") {
+};
+var scanRowToken = (s, t, fontStack, rs) => {
+  if (t.type === "text") {
     consume(s);
-    const nxt = peek(s);
-    if (nxt?.type === "close" && nxt.tag === "VR") consume(s);
-    const prev = cells[cells.length - 1];
-    if (prev === void 0) throw new HtmlParseError("VR");
-    prev.vruled = true;
-    return;
+    return false;
   }
-  consume(s);
+  if (t.type !== "close" || t.tag !== "TR") {
+    scanRowCell(s, t, fontStack, rs);
+    return false;
+  }
+  if (rs.cells.length === 0 || rs.needCell) throw parseError(s, t, MSG_SYNTAX_ERROR);
+  return true;
 };
 var parseRow = (s, fontStack) => {
-  const cells = [];
-  while (s.pos < s.tokens.length) {
-    const t = peek(s);
-    if (!t) break;
-    if (t.type === "close" && t.tag === "TR") break;
-    processRowToken(s, t, cells, fontStack);
+  const rs = { cells: [], needCell: false };
+  for (let t = peek(s); t !== void 0; t = peek(s)) {
+    if (scanRowToken(s, t, fontStack, rs)) break;
   }
   const nxt = peek(s);
   if (nxt?.type === "close" && nxt.tag === "TR") consume(s);
-  return { cells };
+  return { cells: rs.cells };
+};
+var scanTableRow = (s, t, fontStack, ts) => {
+  if (t.type === "open" && t.tag === "TR") {
+    consume(s);
+    ts.rows.push(parseTableRow(s, fontStack, ts));
+    ts.needRow = false;
+  } else if (t.type === "open" && t.tag === "HR" && ts.rows.length > 0 && !ts.needRow) {
+    consumeRowHr(s, ts.rows);
+    ts.needRow = true;
+  } else {
+    throw parseError(s, t, MSG_SYNTAX_ERROR);
+  }
+};
+var scanTableToken = (s, t, fontStack, ts) => {
+  if (t.type === "text") {
+    consume(s);
+    return false;
+  }
+  if (t.type !== "close" || t.tag !== "TABLE") {
+    scanTableRow(s, t, fontStack, ts);
+    return false;
+  }
+  if (ts.rows.length === 0 || ts.needRow) throw parseError(s, t, MSG_SYNTAX_ERROR);
+  consume(s);
+  return true;
 };
-var buildTable = (rows, a) => ({
-  kind: "table",
-  rows,
-  border: num(a["border"]),
-  cellborder: num(a["cellborder"]),
-  cellspacing: num(a["cellspacing"]),
-  cellpadding: num(a["cellpadding"]),
-  bgcolor: a["bgcolor"],
-  color: a["color"],
-  style: a["style"],
-  align: parseAlign(a["align"] !== void 0 ? a["align"] : ""),
-  valign: parseVAlign(a["valign"] !== void 0 ? a["valign"] : ""),
-  fixedsize: parseFixedSize(a),
-  width: num(a["width"]),
-  height: num(a["height"]),
-  href: anchorAttr(a["href"]),
-  title: parseTitle(a),
-  target: anchorAttr(a["target"]),
-  id: a["id"],
-  port: a["port"],
-  sides: parseSides(a["sides"]),
-  gradientangle: parseGradientAngle(a["gradientangle"]),
-  vrule: parseColumns(a["columns"]),
-  hrule: parseRows(a["rows"])
-});
 var parseTable = (s, fontStack) => {
   const open = consume(s);
   if (open.type !== "open" || open.tag !== "TABLE") throw new HtmlParseError("TABLE");
-  const hrule = parseRows(open.attrs["rows"]) === true;
-  const vrule = parseColumns(open.attrs["columns"]) === true;
-  const rows = [];
-  while (s.pos < s.tokens.length) {
-    const t = peek(s);
-    if (!t) break;
-    if (t.type === "close" && t.tag === "TABLE") {
-      consume(s);
-      break;
-    }
-    if (t.type === "open" && t.tag === "TR") {
-      consume(s);
-      rows.push(parseTableRow(s, fontStack, { hrule, vrule }));
-      continue;
-    }
-    if (t.type === "open" && t.tag === "HR") {
-      consumeRowHr(s, rows);
-      continue;
-    }
-    consume(s);
+  const ts = {
+    rows: [],
+    needRow: false,
+    hrule: parseRows(open.attrs["rows"]) === true,
+    vrule: parseColumns(open.attrs["columns"]) === true
+  };
+  for (let t = peek(s); t !== void 0; t = peek(s)) {
+    if (scanTableToken(s, t, fontStack, ts)) break;
   }
-  return buildTable(rows, open.attrs);
+  return buildTable(ts.rows, open.attrs);
 };
 var parseTableRow = (s, fontStack, opts) => {
   const row = parseRow(s, fontStack);
@@ -10651,11 +10850,9 @@ var parseTableRow = (s, fontStack, opts) => {
 };
 var consumeRowHr = (s, rows) => {
   consume(s);
-  const nxt = peek(s);
-  if (nxt?.type === "close" && nxt.tag === "HR") consume(s);
+  consumeClose(s, "HR");
   const prev = rows[rows.length - 1];
-  if (prev === void 0) throw new HtmlParseError("HR");
-  prev.ruled = true;
+  if (prev !== void 0) prev.ruled = true;
 };
 var findFirstRealToken = (tokens, start) => {
   for (let i = start; i < tokens.length; i++) {
@@ -10671,34 +10868,61 @@ var skipLeadingWs = (s) => {
     consume(s);
   }
 };
+var finishTableLabel = (s) => {
+  let afterNonSpace = false;
+  for (let t = peek(s); t?.type === "text"; t = peek(s)) {
+    consume(s);
+    if (nonSpace(t.value)) afterNonSpace = true;
+  }
+  const nxt = peek(s);
+  if (nxt === void 0) return;
+  if (afterNonSpace) throw parseError(s, nxt, MSG_TEXT_AFTER_TABLE);
+  if (nxt.type !== "close" || nxt.tag !== "HTML") throw parseError(s, nxt, MSG_SYNTAX_ERROR);
+  consume(s);
+};
 var parseTableLabel = (s, fontStack) => {
   skipLeadingWs(s);
   const table = parseTable(s, fontStack);
-  const nxt = peek(s);
-  if (nxt?.type === "close" && nxt.tag === "HTML") consume(s);
+  finishTableLabel(s);
   return { kind: "table", table };
 };
-var parseHtmlLabel = (src) => {
-  const wrapped = `<HTML>${src}</HTML>`;
-  const tokens = tokenize(wrapped);
-  const s = { tokens, pos: 0 };
-  const fontStack = [{}];
-  const htmlOpen = consume(s);
-  if (htmlOpen.type !== "open" || htmlOpen.tag !== "HTML") throw new HtmlParseError("HTML");
-  const firstReal = findFirstRealToken(tokens, s.pos);
-  if (firstReal?.type === "open" && firstReal.tag === "TABLE") {
-    return parseTableLabel(s, fontStack);
-  }
+var parseTextLabel = (s, fontStack) => {
   const texts = [];
   const txt = parseText(s, fontStack);
   if (txt.items.length > 0) texts.push(txt);
   const nxt = peek(s);
-  if (nxt?.type === "open" && nxt.tag === "TABLE") {
-    throw new HtmlParseError("non-space string used before <TABLE>");
+  if (nxt === void 0) return { kind: "text", texts };
+  if (nxt.type === "open" && nxt.tag === "TABLE") {
+    if (txt.items.some((i) => i.text !== void 0 && nonSpace(i.text))) {
+      throw parseError(s, nxt, MSG_TEXT_BEFORE_TABLE);
+    }
+    throw new HtmlParseError("TABLE");
   }
-  if (nxt?.type === "close" && nxt.tag === "HTML") consume(s);
+  if (nxt.type !== "close" || nxt.tag !== "HTML") throw parseError(s, nxt, MSG_SYNTAX_ERROR);
+  consume(s);
   return { kind: "text", texts };
 };
+var parseTokens = (s) => {
+  const fontStack = [{}];
+  const htmlOpen = consume(s);
+  if (htmlOpen.type !== "open" || htmlOpen.tag !== "HTML") throw new HtmlParseError("HTML");
+  const firstReal = findFirstRealToken(s.tokens, s.pos);
+  if (firstReal?.type === "open" && firstReal.tag === "TABLE") return parseTableLabel(s, fontStack);
+  return parseTextLabel(s, fontStack);
+};
+var parseHtmlLabel = (src) => {
+  const { tokens, error } = tokenizeDeferred(`<HTML>${src}</HTML>`);
+  const s = { tokens, pos: 0, pending: error };
+  let label;
+  try {
+    label = parseTokens(s);
+  } catch (e) {
+    if (error !== void 0 && s.pos >= tokens.length) throw error;
+    throw e;
+  }
+  if (error !== void 0) throw error;
+  return label;
+};
 
 // src/gvc/usershape.ts
 var activeSizer = null;
@@ -10712,28 +10936,80 @@ function findImageSize(src) {
   return activeSizer !== null ? activeSizer(src) : null;
 }
 
+// src/common/pointset.ts
+function cmpPair(a, b) {
+  if (a.x > b.x) return 1;
+  if (a.x < b.x) return -1;
+  if (a.y > b.y) return 1;
+  if (a.y < b.y) return -1;
+  return 0;
+}
+var PointSet = class {
+  byX = /* @__PURE__ */ new Map();
+  n = 0;
+  /**
+   * Insert (x, y). A duplicate keeps the point inserted first, as `dtinsert`
+   * returns the existing object and the new one is freed.
+   * @see lib/common/pointset.c:addPS
+   */
+  addPS(x, y) {
+    let col = this.byX.get(x);
+    if (col === void 0) {
+      col = /* @__PURE__ */ new Map();
+      this.byX.set(x, col);
+    }
+    if (col.has(y)) return;
+    col.set(y, { x, y });
+    this.n++;
+  }
+  /** @see lib/common/pointset.c:inPS */
+  inPS(pt) {
+    return this.byX.get(pt.x)?.has(pt.y) ?? false;
+  }
+  /** @see lib/common/pointset.c:isInPS */
+  isInPS(x, y) {
+    return this.byX.get(x)?.has(y) ?? false;
+  }
+  /** @see lib/common/pointset.c:sizeOf */
+  sizeOf() {
+    return this.n;
+  }
+  /**
+   * The points in dictionary order (`dtflatten` walks the ordered set).
+   * @see lib/common/pointset.c:pointsOf
+   */
+  pointsOf() {
+    const pts = [];
+    for (const col of this.byX.values()) {
+      for (const p of col.values()) pts.push({ x: p.x, y: p.y });
+    }
+    return pts.sort(cmpPair);
+  }
+};
+
 // src/common/htmltable.ts
 var DEFAULT_BORDER = 1;
 var DEFAULT_CELLPADDING = 2;
 var DEFAULT_CELLSPACING = 2;
 var DEFAULT_FONTSIZE = 14;
-var findCol = (used, row, startCol, colspan, rowspan) => {
+var findCol = (ps, row, startCol, colspan, rowspan) => {
   let col = startCol;
-  for (; ; ) {
-    let conflict = false;
-    for (let c = col; c < col + colspan && !conflict; c++) {
-      for (let r = row; r < row + rowspan && !conflict; r++) {
-        if (used.has(`${c},${r}`)) {
-          conflict = true;
-          col = c + 1;
-        }
-      }
+  let notFound = true;
+  const end = colspan - 1;
+  while (notFound) {
+    const lastc = col + end;
+    let c;
+    for (c = lastc; c >= col; c--) {
+      if (ps.isInPS(c, row)) break;
+    }
+    if (c >= col) col = c + 1;
+    else notFound = false;
+  }
+  for (let j = col; j < col + colspan; j++) {
+    for (let i = row; i < row + rowspan; i++) {
+      ps.addPS(j, i);
     }
-    if (!conflict) break;
   }
-  for (let c = col; c < col + colspan; c++)
-    for (let r = row; r < row + rowspan; r++)
-      used.add(`${c},${r}`);
   return col;
 };
 var DEFAULT_SIZE_ENV = { fontsize: DEFAULT_FONTSIZE, fontname: "" };
@@ -10812,29 +11088,32 @@ var sizeTextContent = (texts, measurer, env = DEFAULT_SIZE_ENV) => {
   if (lines.length === 1) h = lines[0].items.length > 0 ? lines[0].mxysize : DEFAULT_FONTSIZE;
   return { w, h };
 };
+var missingImages = /* @__PURE__ */ new WeakSet();
 var sizeHtmlImg = (img, imageSizer) => {
-  if (img.width !== void 0 && img.height !== void 0) return;
+  if (img.width !== void 0 && img.height !== void 0) return missingImages.has(img) ? 1 : 0;
   const sz = imageSizer !== void 0 ? imageSizer(img.src) : findImageSize(img.src);
   if (sz !== null) {
     img.width = sz.w;
     img.height = sz.h;
-    return;
+    return 0;
   }
   console.error(`Error: No or improper image file="${img.src}"`);
   img.width = 0;
   img.height = 0;
+  missingImages.add(img);
+  return 1;
 };
 var sizeContentItem = (item, measurer, env) => {
-  if (item.kind === "text") return sizeTextContent([item], measurer, env);
+  if (item.kind === "text") return { ...sizeTextContent([item], measurer, env), rv: 0 };
   if (item.kind === "table") {
-    sizeTableInner(item, measurer, env);
-    return item.dimen !== void 0 ? item.dimen : { w: 0, h: 0 };
+    const rv = sizeTableInner(item, measurer, env);
+    return { ...item.dimen !== void 0 ? item.dimen : { w: 0, h: 0 }, rv };
   }
   if (item.kind === "image") {
-    sizeHtmlImg(item, env.imageSizer);
-    return { w: item.width ?? 0, h: item.height ?? 0 };
+    const rv = sizeHtmlImg(item, env.imageSizer);
+    return { w: item.width ?? 0, h: item.height ?? 0, rv };
   }
-  return { w: 0, h: 0 };
+  return { w: 0, h: 0, rv: 0 };
 };
 var cellPad = (cell2, tbl) => cell2.cellpadding !== void 0 ? cell2.cellpadding : tbl.cellpadding !== void 0 ? tbl.cellpadding : DEFAULT_CELLPADDING;
 var cellBorder = (cell2, tbl) => {
@@ -10844,27 +11123,60 @@ var cellBorder = (cell2, tbl) => {
   if (tbl.border !== void 0) return tbl.border;
   return DEFAULT_BORDER;
 };
+function inheritTablePenColor(tbl, parentColor) {
+  if (tbl.color === void 0) tbl.color = parentColor;
+  const tblColor = tbl.color;
+  for (const row of tbl.rows) {
+    for (const cell2 of row.cells) {
+      if (cell2.color === void 0) cell2.color = tblColor;
+      for (const item of cell2.content) {
+        if (item.kind === "table") inheritTablePenColor(item, cell2.color);
+      }
+    }
+  }
+}
+var WARN_CELL_TOO_SMALL = "Warning: cell size too small for content";
+var WARN_CELL_UNSPECIFIED = "Warning: fixed cell size with unspecified width or height";
+var WARN_TABLE_TOO_SMALL = "Warning: table size too small for content";
+var WARN_TABLE_UNSPECIFIED = "Warning: fixed table size with unspecified width or height";
+var sizeWarned = /* @__PURE__ */ new WeakSet();
+var fixedCellCheck = (cell2, sz, warn) => {
+  if (!cell2.fixedsize) return { rv: 0, zero: false };
+  if (cell2.width && cell2.height) {
+    const small = (cell2.width < sz.w || cell2.height < sz.h) && cell2.content[0]?.kind !== "image";
+    if (small && warn) console.warn(WARN_CELL_TOO_SMALL);
+    return { rv: small ? 1 : 0, zero: true };
+  }
+  if (warn) console.warn(WARN_CELL_UNSPECIFIED);
+  return { rv: 1, zero: false };
+};
 var getCellSize = (cell2, tbl, measurer, env) => {
   const margin = 2 * (cellPad(cell2, tbl) + cellBorder(cell2, tbl));
-  let cw = 0, ch = 0;
+  let cw = 0, ch = 0, rv = 0;
   for (const item of cell2.content) {
     const s = sizeContentItem(item, measurer, env);
     cw = Math.max(cw, s.w);
     ch += s.h;
+    rv |= s.rv;
   }
   let szx = cw + margin;
   let szy = ch + margin;
-  if (cell2.fixedsize && cell2.width && cell2.height) {
+  const warn = !sizeWarned.has(cell2);
+  sizeWarned.add(cell2);
+  const fixed = fixedCellCheck(cell2, { w: szx, h: szy }, warn);
+  rv |= fixed.rv;
+  if (fixed.zero) {
     szx = 0;
     szy = 0;
   }
   const bw = cell2.width !== void 0 ? cell2.width : 0;
   const bh = cell2.height !== void 0 ? cell2.height : 0;
-  return { w: Math.max(szx, bw), h: Math.max(szy, bh) };
+  return { w: Math.max(szx, bw), h: Math.max(szy, bh), rv };
 };
 var buildLayouts = (tbl, measurer, env) => {
   const entries = [];
-  const used = /* @__PURE__ */ new Set();
+  let rv = 0;
+  const ps = new PointSet();
   let rowIdx = 0;
   for (const row of tbl.rows) {
     let col = 0;
@@ -10874,14 +11186,15 @@ var buildLayouts = (tbl, measurer, env) => {
       }
       const colspan = c.colspan !== void 0 ? c.colspan : 1;
       const rowspan = c.rowspan !== void 0 ? c.rowspan : 1;
-      const { w, h } = getCellSize(c, tbl, measurer, env);
-      col = findCol(used, rowIdx, col, colspan, rowspan);
+      const { w, h, rv: cellRv } = getCellSize(c, tbl, measurer, env);
+      rv |= cellRv;
+      col = findCol(ps, rowIdx, col, colspan, rowspan);
       entries.push({ cell: c, row: rowIdx, col, colspan, rowspan, w, h });
       col += colspan;
     }
     rowIdx++;
   }
-  return entries;
+  return { entries, rv };
 };
 var setColWidths = (entries, ncols, spacing) => {
   const widths = new Array(ncols + 1).fill(0);
@@ -10934,21 +11247,34 @@ var sumTableDims = (a) => {
 var layoutHtmlTable = (tbl, measurer, env = DEFAULT_SIZE_ENV) => {
   const spacing = getSpacing(tbl);
   const border = getBorder(tbl);
-  const entries = buildLayouts(tbl, measurer, env);
+  const { entries, rv } = buildLayouts(tbl, measurer, env);
   if (entries.length === 0) {
-    return { entries, widths: [], heights: [], spacing, border };
+    return { entries, widths: [], heights: [], spacing, border, rv };
   }
   const ncols = Math.max(...entries.map((e) => e.col + e.colspan));
   const nrows = Math.max(...entries.map((e) => e.row + e.rowspan));
   const widths = setColWidths(entries, ncols, spacing);
   const heights = setRowHeights(entries, nrows, spacing);
-  return { entries, widths, heights, spacing, border };
+  return { entries, widths, heights, spacing, border, rv };
+};
+var warnFixedTable = (tbl, dims) => {
+  const warn = !sizeWarned.has(tbl);
+  sizeWarned.add(tbl);
+  if (tbl.fixedsize !== true) return 0;
+  if (tbl.width && tbl.height) {
+    if (tbl.width >= dims.wd && tbl.height >= dims.ht) return 0;
+    if (warn) console.warn(WARN_TABLE_TOO_SMALL);
+    return 1;
+  }
+  if (warn) console.warn(WARN_TABLE_UNSPECIFIED);
+  return 1;
 };
 var sizeTableInner = (tbl, measurer, env) => {
-  const { entries, widths, heights, spacing, border } = layoutHtmlTable(tbl, measurer, env);
+  const { entries, widths, heights, spacing, border, rv } = layoutHtmlTable(tbl, measurer, env);
   if (entries.length === 0) {
+    const fixed2 = warnFixedTable(tbl, sumTableDims({ widths, heights, ncols: 0, nrows: 0, spacing, border }));
     tbl.dimen = { w: 0, h: 0 };
-    return;
+    return rv | fixed2;
   }
   const ncols = Math.max(...entries.map((e) => e.col + e.colspan));
   const nrows = Math.max(...entries.map((e) => e.row + e.rowspan));
@@ -10956,19 +11282,22 @@ var sizeTableInner = (tbl, measurer, env) => {
   const { wd, ht } = sumTableDims({ widths, heights, ncols, nrows, spacing, border });
   const baseWd = tbl.width !== void 0 ? tbl.width : 0;
   const baseHt = tbl.height !== void 0 ? tbl.height : 0;
+  const fixed = warnFixedTable(tbl, { wd, ht });
   const zeroContent = isTblFixed(tbl) && baseWd !== 0 && baseHt !== 0;
   tbl.dimen = {
     w: Math.max(zeroContent ? 0 : wd, baseWd),
     h: Math.max(zeroContent ? 0 : ht, baseHt)
   };
+  return rv | fixed;
 };
 var sizeHtmlLabel = (label, measurer, env = DEFAULT_SIZE_ENV) => {
   if (label.kind === "table") {
-    sizeTableInner(label.table, measurer, env);
+    const rv = sizeTableInner(label.table, measurer, env);
     label.dimen = label.table.dimen;
-  } else {
-    label.dimen = sizeTextContent(label.texts, measurer, env);
+    return rv;
   }
+  label.dimen = sizeTextContent(label.texts, measurer, env);
+  return 0;
 };
 
 // src/common/splines-constants.ts
@@ -16538,28 +16867,18 @@ function posHtmlLabel(label, finfo, measurer) {
   if (label.kind === "table") return posHtmlTable(label.table, finfo, measurer);
   return posTextLabel(label, finfo, measurer);
 }
-function inheritTablePenColor(tbl, parentColor) {
-  if (tbl.color === void 0) tbl.color = parentColor;
-  const tblColor = tbl.color;
-  for (const row of tbl.rows) {
-    for (const cell2 of row.cells) {
-      if (cell2.color === void 0) cell2.color = tblColor;
-      for (const item of cell2.content) {
-        if (item.kind === "table") inheritTablePenColor(item, cell2.color);
-      }
-    }
-  }
-}
-function makeHtmlLabel(content, finfo, measurer) {
+var HTML_PARSE_FATAL = 3;
+function makeHtmlLabelRv(content, finfo, measurer) {
   const { fontname, fontsize, fontcolor, imageSizer, pencolor } = finfo;
   let lbl;
   try {
     lbl = parseHtmlLabel(content);
-  } catch {
-    return makeLabel("", fontname, fontsize, fontcolor, measurer);
+  } catch (e) {
+    if (e instanceof HtmlLexError) for (const line of e.diagnostics) console.error(line);
+    return { label: makeLabel("", fontname, fontsize, fontcolor, measurer), rv: HTML_PARSE_FATAL };
   }
   if (lbl.kind === "table") inheritTablePenColor(lbl.table, pencolor);
-  sizeHtmlLabel(lbl, measurer, {
+  const rv = sizeHtmlLabel(lbl, measurer, {
     fontsize,
     fontname,
     imageSizer
@@ -16567,7 +16886,7 @@ function makeHtmlLabel(content, finfo, measurer) {
   const placed = posHtmlLabel(lbl, { fontname, fontsize, fontcolor }, measurer);
   const dim = lbl.dimen ?? { w: 0, h: 0 };
   const text = lbl.kind === "table" ? "<TABLE>" : content;
-  return htmlTextLabel(text, { fontname, fontsize, fontcolor }, placed, dim);
+  return { label: htmlTextLabel(text, { fontname, fontsize, fontcolor }, placed, dim), rv };
 }
 function htmlTextLabel(text, finfo, placed, dim) {
   return {
@@ -16686,6 +17005,14 @@ function getPenColor(obj) {
 function rootOf(obj) {
   return obj instanceof Edge ? obj.tail.root : obj.root;
 }
+function inLabelOf(obj) {
+  if (obj instanceof Edge) {
+    const sep = obj.head.root.kind.endsWith("undirected") ? "--" : "->";
+    return `in label of edge ${obj.tail.name} ${sep} ${obj.head.name}`;
+  }
+  if (obj instanceof Graph) return `in label of graph ${obj.name}`;
+  return `in label of node ${obj.name}`;
+}
 function buildSpan(text, font, measured) {
   return {
     str: text,
@@ -16753,7 +17080,9 @@ function makeLabel(text, fontname, fontsize, fontcolor, measurer) {
 function makeAnyLabel(content, isHtml, font, measurer, obj) {
   if (isHtml && content !== "") {
     const imageSizer = obj !== void 0 ? rootOf(obj).info.gvc?.imageSizer : void 0;
-    return makeHtmlLabel(content, { ...font, pencolor: getPenColor(obj), imageSizer }, measurer);
+    const { label, rv } = makeHtmlLabelRv(content, { ...font, pencolor: getPenColor(obj), imageSizer }, measurer);
+    if (rv !== 0 && obj !== void 0) console.error(inLabelOf(obj));
+    return label;
   }
   const subst2 = obj !== void 0 ? substObj(content, obj, false) : content;
   const text = htmlEntityUTF8(subst2);
@@ -29053,18 +29382,22 @@ function dotSameports(g) {
 function dist2(p, q) {
   const dx = p.x - q.x;
   const dy = p.y - q.y;
-  return dx * dx + dy * dy;
+  return fma(dx, dx, dy * dy);
 }
 function distPt(p, q) {
   return Math.sqrt(dist2(p, q));
 }
-function evalBez4(pts, t) {
+function bezier(v, t) {
   const u = 1 - t;
-  const [p0, p1, p2, p3] = pts;
-  return {
-    x: u * u * u * p0.x + 3 * u * u * t * p1.x + 3 * u * t * t * p2.x + t * t * t * p3.x,
-    y: u * u * u * p0.y + 3 * u * u * t * p1.y + 3 * u * t * t * p2.y + t * t * t * p3.y
-  };
+  const x = [v[0].x, v[1].x, v[2].x, v[3].x];
+  const y = [v[0].y, v[1].y, v[2].y, v[3].y];
+  for (let i = 1; i <= 3; i++) {
+    for (let j = 0; j <= 3 - i; j++) {
+      x[j] = fma(x[j], u, t * x[j + 1]);
+      y[j] = fma(y[j], u, t * y[j + 1]);
+    }
+  }
+  return { x: x[0], y: y[0] };
 }
 function dotneatoClosest(spl, pt) {
   let besti = 0;
@@ -29094,7 +29427,7 @@ function dotneatoClosest(spl, pt) {
   let pt2;
   for (; ; ) {
     const t = (lo + hi) / 2;
-    pt2 = evalBez4(c, t);
+    pt2 = bezier(c, t);
     if (Math.abs(dlo2 - dhi2) < 1 || Math.abs(hi - lo) < 1e-5) break;
     if (dlo2 < dhi2) {
       hi = t;
@@ -30006,9 +30339,19 @@ var ShortestHelper = class _ShortestHelper {
     _ShortestHelper.connectAll(tris);
     const ftrii = _ShortestHelper.findTri(tris, eps[0]);
     const ltrii = _ShortestHelper.findTri(tris, eps[1]);
-    if (ftrii === NO_TRI || ltrii === NO_TRI) return null;
+    if (ftrii === NO_TRI) {
+      console.warn("source point not in any triangle");
+      return null;
+    }
+    if (ltrii === NO_TRI) {
+      console.warn("destination point not in any triangle");
+      return null;
+    }
     if (ftrii === ltrii) return [eps[0], eps[1]];
-    if (!_ShortestHelper.markPath(tris, ftrii, ltrii)) return [eps[0], eps[1]];
+    if (!_ShortestHelper.markPath(tris, ftrii, ltrii)) {
+      console.warn("cannot find triangle path");
+      return [eps[0], eps[1]];
+    }
     const epnls = [{ pp: eps[0], link: null }, { pp: eps[1], link: null }];
     const dq = _ShortestHelper.initDeque(pnlps.length);
     _ShortestHelper.add2dq(dq, DQ_FRONT, epnls[0]);
@@ -31990,7 +32333,7 @@ function nodeCover(n) {
   for (let i = 0; i < NODECARD; i++) {
     if (n.branch[i].child !== null) {
       if (flag) {
-        r = n.branch[i].rect;
+        r = { boundary: [...n.branch[i].rect.boundary] };
         flag = false;
       } else {
         r = combineRect(r, n.branch[i].rect);
@@ -34256,8 +34599,8 @@ function nodeInsideFn2(box) {
   const pw = box.penwidth ?? DEFAULT_NODEPENWIDTH;
   return box.isEllipse ? makeEllipseInsideFn(halfW, halfH, pw) : makeBoxInsideFn(halfW, halfH, pw);
 }
-function clipToNodes(bezier, tailBox, headBox, penwidth = DEFAULT_NODEPENWIDTH, clip = CLIP_BOTH) {
-  const step1 = clip.tail ? bezierClipNode(bezier, tailBox.center.x, tailBox.center.y, nodeInsideFn2(tailBox), true) : bezier;
+function clipToNodes(bezier2, tailBox, headBox, penwidth = DEFAULT_NODEPENWIDTH, clip = CLIP_BOTH) {
+  const step1 = clip.tail ? bezierClipNode(bezier2, tailBox.center.x, tailBox.center.y, nodeInsideFn2(tailBox), true) : bezier2;
   const step2 = clip.head ? bezierClipNode(step1, headBox.center.x, headBox.center.y, nodeInsideFn2(headBox), false) : step1;
   const arrowTip = step2[3];
   const elen = normalArrowLen(penwidth);
@@ -34271,9 +34614,9 @@ function clipToNodes(bezier, tailBox, headBox, penwidth = DEFAULT_NODEPENWIDTH,
 function routeWithRank(tailBox, headBox, rank3, penwidth = DEFAULT_NODEPENWIDTH, port) {
   const corridor = port ? { tailP: port.tailP, headP: port.headP } : void 0;
   const { startPt, endPt, boxes } = buildRankCorridor(tailBox, headBox, rank3, corridor);
-  const bezier = computeSpline(boxes, startPt, endPt);
+  const bezier2 = computeSpline(boxes, startPt, endPt);
   const clip = port ? { tail: port.clipTail, head: port.clipHead } : CLIP_BOTH;
-  const { clipped, arrowTip, arrowDir } = clipToNodes(bezier, tailBox, headBox, penwidth, clip);
+  const { clipped, arrowTip, arrowDir } = clipToNodes(bezier2, tailBox, headBox, penwidth, clip);
   return { bezierPts: clipped, arrowTip, arrowDir };
 }
 function routeSimple(tailBox, headBox, routeBezierFn) {
@@ -36866,24 +37209,27 @@ function buildNodes(nodeArr) {
     ysize: n.info.ht
   }));
 }
+function isConcentrateDup(ps, e) {
+  const ti = e.tail.id;
+  const hi = e.head.id;
+  const lo = ti <= hi ? ti : hi;
+  const up = ti <= hi ? hi : ti;
+  if (ps.isInPS(lo, up)) return true;
+  ps.addPS(lo, up);
+  return false;
+}
 function buildEdges(g, nodeArr, orthoNodes) {
   const concentrate = dotRoot(g).info.concentrate ?? false;
   const nodeIndex = /* @__PURE__ */ new Map();
   nodeArr.forEach((n, i) => nodeIndex.set(n, i));
   const outIndex = buildOutEdgeIndex(g);
-  const seen = /* @__PURE__ */ new Set();
+  const ps = concentrate ? new PointSet() : null;
   const result = [];
   for (const n of nodeArr) {
     const oes = outIndex.get(n);
     if (oes === void 0) continue;
     for (const e of oes) {
-      if (concentrate) {
-        const ti = e.tail.id;
-        const hi = e.head.id;
-        const key = ti <= hi ? `${ti},${hi}` : `${hi},${ti}`;
-        if (seen.has(key)) continue;
-        seen.add(key);
-      }
+      if (ps !== null && isConcentrateDup(ps, e)) continue;
       result.push({
         tail: orthoNodes[nodeIndex.get(e.tail)],
         head: orthoNodes[nodeIndex.get(e.head)],
@@ -37971,15 +38317,6 @@ function spiralSearch(info, ctx, wide) {
 
 // src/layout/pack/poly-pack.ts
 var C2 = 100;
-function psKey(x, y) {
-  return `${cround(x)},${cround(y)}`;
-}
-function inPS(ps, p) {
-  return ps.has(psKey(p.x, p.y));
-}
-function insertPS(ps, p) {
-  ps.add(psKey(p.x, p.y));
-}
 function computeStep(ng, bbs, margin) {
   let b = 0;
   let c = 0;
@@ -38026,14 +38363,14 @@ function genBox2(p) {
 function hasCollision(cells, dx, dy, ps) {
   for (let i = 0; i < cells.length; i++) {
     const cell2 = cells[i];
-    if (cell2 !== void 0 && inPS(ps, { x: cell2.x + dx, y: cell2.y + dy })) return true;
+    if (cell2 !== void 0 && ps.inPS({ x: cell2.x + dx, y: cell2.y + dy })) return true;
   }
   return false;
 }
 function markCells(cells, dx, dy, ps) {
   for (let i = 0; i < cells.length; i++) {
     const cell2 = cells[i];
-    if (cell2 !== void 0) insertPS(ps, { x: cell2.x + dx, y: cell2.y + dy });
+    if (cell2 !== void 0) ps.addPS(cell2.x + dx, cell2.y + dy);
   }
 }
 function fits(x, y, info, ctx) {
@@ -38078,7 +38415,7 @@ function polyRects(ng, bbs, pinfo) {
     infos.push(genBox2({ bb, ssize: step, margin: pinfo.margin, idx: i }));
   }
   const sorted = gvQsort([...infos], cmpByGPerimeter);
-  const ctx = { ps: /* @__PURE__ */ new Set(), step, bbs };
+  const ctx = { ps: new PointSet(), step, bbs };
   const places = new Array(ng).fill({ x: 0, y: 0 });
   for (let i = 0; i < sorted.length; i++) {
     const info = sorted[i];
@@ -38099,21 +38436,6 @@ function cval2(v, s) {
 function cell(p, s) {
   return { x: cval2(p.x, s), y: cval2(p.y, s) };
 }
-var PointSet = class {
-  m = /* @__PURE__ */ new Map();
-  add(x, y) {
-    this.m.set(`${x},${y}`, { x, y });
-  }
-  has(p) {
-    return this.m.has(`${p.x},${p.y}`);
-  }
-  points() {
-    return [...this.m.values()];
-  }
-  get size() {
-    return this.m.size;
-  }
-};
 function computeStep2(bbs, margin) {
   const a = C_AVG * bbs.length - 1;
   let b = 0;
@@ -38131,7 +38453,7 @@ function computeStep2(bbs, margin) {
 function lineXDominant(st, ps) {
   let d = st.ay - (st.ax >> 1);
   for (; ; ) {
-    ps.add(st.x, st.y);
+    ps.addPS(st.x, st.y);
     if (st.x === st.x2) return;
     if (d >= 0) {
       st.y += st.sy;
@@ -38144,7 +38466,7 @@ function lineXDominant(st, ps) {
 function lineYDominant(st, ps) {
   let d = st.ax - (st.ay >> 1);
   for (; ; ) {
-    ps.add(st.x, st.y);
+    ps.addPS(st.x, st.y);
     if (st.y === st.y2) return;
     if (d >= 0) {
       st.x += st.sx;
@@ -38176,7 +38498,7 @@ function fillLine(p, q, ps) {
 }
 function fillRect(LL, UR, ps) {
   for (let x = LL.x; x <= UR.x; x++) {
-    for (let y = LL.y; y <= UR.y; y++) ps.add(x, y);
+    for (let y = LL.y; y <= UR.y; y++) ps.addPS(x, y);
   }
 }
 function roundedCell(p, ssize) {
@@ -38228,7 +38550,7 @@ function genBox3(bb0, ssize, margin, center) {
   const UR = roundedCell({ x: center.x + bbW + margin, y: center.y + bbH + margin }, ssize);
   fillRect(LL, UR, ps);
   return {
-    cells: ps.points(),
+    cells: ps.pointsOf(),
     perim: grid(bb0.ur.x - bb0.ll.x + 2 * margin, ssize) + grid(bb0.ur.y - bb0.ll.y + 2 * margin, ssize),
     index: 0
   };
@@ -38260,42 +38582,38 @@ function genPoly(root, g, bb, ssize, pinfo, center) {
   };
   for (const n of g.nodes.values()) coverNode(n, ctx);
   return {
-    cells: ps.points(),
+    cells: ps.pointsOf(),
     perim: grid(bb.ur.x - bb.ll.x + 2 * pinfo.margin, ssize) + grid(bb.ur.y - bb.ll.y + 2 * pinfo.margin, ssize),
     index: 0
   };
 }
 function fits2(x, y, info, ctx) {
   for (const c of info.cells) {
-    if (ctx.ps.has({ x: c.x + x, y: c.y + y })) return false;
+    if (ctx.ps.isInPS(c.x + x, c.y + y)) return false;
   }
   const bb = ctx.bbs[info.index];
   const LL = { x: cround(bb.ll.x), y: cround(bb.ll.y) };
   ctx.places[info.index] = { x: Math.imul(ctx.step, x) - LL.x, y: Math.imul(ctx.step, y) - LL.y };
-  for (const c of info.cells) ctx.ps.add(c.x + x, c.y + y);
+  for (const c of info.cells) ctx.ps.addPS(c.x + x, c.y + y);
   return true;
 }
-function* ringWide(bnd) {
-  let x = 0;
-  let y = -bnd;
-  for (; x < bnd; x++) yield [x, y];
-  for (; y < bnd; y++) yield [x, y];
-  for (; x > -bnd; x--) yield [x, y];
-  for (; y > -bnd; y--) yield [x, y];
-  for (; x < 0; x++) yield [x, y];
-}
-function* ringTall(bnd) {
-  let y = 0;
-  let x = -bnd;
-  for (; y > -bnd; y--) yield [x, y];
-  for (; x < bnd; x++) yield [x, y];
-  for (; y < bnd; y++) yield [x, y];
-  for (; x > -bnd; x--) yield [x, y];
-  for (; y > 0; y--) yield [x, y];
+function leg(c, dx, dy, end, info, ctx) {
+  for (; (dx !== 0 ? c.x : c.y) !== end; c.x += dx, c.y += dy) {
+    if (fits2(c.x, c.y, info, ctx)) return true;
+  }
+  return false;
+}
+function ringWide(bnd, info, ctx) {
+  const c = { x: 0, y: -bnd };
+  return leg(c, 1, 0, bnd, info, ctx) || leg(c, 0, 1, bnd, info, ctx) || leg(c, -1, 0, -bnd, info, ctx) || leg(c, 0, -1, -bnd, info, ctx) || leg(c, 1, 0, 0, info, ctx);
+}
+function ringTall(bnd, info, ctx) {
+  const c = { x: -bnd, y: 0 };
+  return leg(c, 0, -1, -bnd, info, ctx) || leg(c, 1, 0, bnd, info, ctx) || leg(c, 0, 1, bnd, info, ctx) || leg(c, -1, 0, -bnd, info, ctx) || leg(c, 0, -1, 0, info, ctx);
 }
 function placeFixed(info, ctx, center) {
   ctx.places[info.index] = { x: -center.x, y: -center.y };
-  for (const c of info.cells) ctx.ps.add(c.x, c.y);
+  for (const c of info.cells) ctx.ps.addPS(c.x, c.y);
 }
 function placeGraph2(i, info, ctx) {
   const bb = ctx.bbs[info.index];
@@ -38307,10 +38625,7 @@ function placeGraph2(i, info, ctx) {
   if (fits2(0, 0, info, ctx)) return;
   const wide = Math.ceil(bb.ur.x - bb.ll.x) >= Math.ceil(bb.ur.y - bb.ll.y);
   for (let bnd = 1; ; bnd++) {
-    const ring = wide ? ringWide(bnd) : ringTall(bnd);
-    for (const [x, y] of ring) {
-      if (fits2(x, y, info, ctx)) return;
-    }
+    if (wide ? ringWide(bnd, info, ctx) : ringTall(bnd, info, ctx)) return;
   }
 }
 function polyGraphs(gs, root, pinfo, bbs) {
@@ -41950,6 +42265,12 @@ 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})`
+  );
+  return 1;
+}
 function genroute(g, trip, t, e, doPolyline) {
   const eps = [
     { x: trip.ps[0].x, y: trip.ps[0].y },
@@ -41959,7 +42280,7 @@ function genroute(g, trip, t, e, doPolyline) {
   const mult = e.info.count ?? 1;
   const head = e.head;
   const pl = shortestPath({ ps: trip.ps }, eps);
-  if (pl === null) return 1;
+  if (pl === null) return warnNoControlPoints(e);
   if (pl.length === 2) {
     const chain = chainOf(e);
     makeStraightEdges(g, chain, chain.length, doPolyline ? 1 : 0, MSINFO);
@@ -41967,7 +42288,7 @@ function genroute(g, trip, t, e, doPolyline) {
   }
   if (mult === 1 || concentrate) {
     const spl = routeMember(trip.ps, t, pl, doPolyline);
-    if (spl === null) return 1;
+    if (spl === null) return warnNoControlPoints(e);
     finishEdge(e, spl, e.head !== head);
     return 0;
   }
@@ -41975,7 +42296,7 @@ function genroute(g, trip, t, e, doPolyline) {
   const cpts = [];
   for (let i = 0; i + 2 < pl.length; i++) {
     const cp = mkCtrlPts(t, mult + 1, pl[i], pl[i + 1], pl[i + 2], trip);
-    if (cp === null) return 1;
+    if (cp === null) return warnNoControlPoints(e);
     cpts.push(cp);
   }
   let cur = e;
@@ -41990,9 +42311,9 @@ function genroute(g, trip, t, e, doPolyline) {
       poly[pn - j] = cpts[j - 1][i + 1];
     }
     const mmpl = shortestPath({ ps: poly }, eps);
-    if (mmpl === null) return 1;
+    if (mmpl === null) return warnNoControlPoints(cur);
     const spl = routeMember(poly, pl.length - 1, mmpl, doPolyline);
-    if (spl === null) return 1;
+    if (spl === null) return warnNoControlPoints(cur);
     finishEdge(cur, spl, cur.head !== head);
     cur = cur.info.to_virt;
   }
@@ -51216,22 +51537,22 @@ function freeBlocktree(bp) {
 
 // src/layout/circo/position-helpers.ts
 function rotatePoint(x, y, cosR, sinR) {
-  return [x * cosR - y * sinR, x * sinR + y * cosR];
+  return [fma(x, cosR, -sinR * y), fma(x, sinR, cosR * y)];
 }
 function nodePsi(n) {
   return n.info.alg?.psi ?? 0;
 }
 function rotFromParentPos(sn, theta) {
-  let r = theta + Math.PI - sn.parentPos;
+  let r = theta + (Math.PI - sn.parentPos);
   if (r < 0) r += 2 * Math.PI;
   return r;
 }
 function closestNode(sn, x, y, skip) {
   let best = skip;
-  let bestDist = Math.hypot(skip.info.pos[0] + x, skip.info.pos[1] + y);
+  let bestDist = libmHypot(skip.info.pos[0] + x, skip.info.pos[1] + y);
   for (const dn of sn.subGraph.nodes) {
     if (dn.orig === skip) continue;
-    const d = Math.hypot(dn.orig.info.pos[0] + x, dn.orig.info.pos[1] + y);
+    const d = libmHypot(dn.orig.info.pos[0] + x, dn.orig.info.pos[1] + y);
     if (d < bestDist) {
       bestDist = d;
       best = dn.orig;
@@ -51244,22 +51565,19 @@ function rotCoalesced(sn, x, y, nbr, theta) {
   const r = sn.radius - rho;
   const nx = nbr.info.pos[0];
   const ny = nbr.info.pos[1];
-  if (-r >= nx) {
-    const phi2 = Math.atan2(ny, nx);
-    return theta + Math.PI - phi2 - nodePsi(nbr);
-  }
-  const R2 = Math.hypot(x, y);
+  const R2 = libmHypot(x, y);
   const phi = Math.atan2(ny, nx + r);
   const l = r - rho / Math.cos(phi);
-  return theta + Math.PI / 2 - phi - Math.asin(l / R2 * Math.cos(phi));
+  return theta + (Math.PI / 2 - phi - Math.asin(l / R2 * Math.cos(phi)));
 }
 function rotGeneral(sn, x, y, nbr, theta) {
   if (closestNode(sn, x, y, nbr) === nbr) return 0;
-  if (isCoalesced(sn)) return rotCoalesced(sn, x, y, nbr, theta);
+  const r = sn.radius - sn.rad0;
+  if (isCoalesced(sn) && -r < nbr.info.pos[0]) return rotCoalesced(sn, x, y, nbr, theta);
   const phi = Math.atan2(nbr.info.pos[1], nbr.info.pos[0]);
-  let r = theta + Math.PI - phi - nodePsi(nbr);
-  if (r > 2 * Math.PI) r -= 2 * Math.PI;
-  return r;
+  let t = theta + (Math.PI - phi - nodePsi(nbr));
+  if (t > 2 * Math.PI) t -= 2 * Math.PI;
+  return t;
 }
 function applyDelta(sn, x, y, rotate) {
   const cosR = Math.cos(rotate);
@@ -51302,7 +51620,7 @@ function getInfo(pi, stp, minDist) {
 }
 function setInfo(p0, p1, delta2) {
   const t = Math.max(
-    (p0.diameter * p1.minRadius + p1.diameter * p0.minRadius) / (2 * delta2 * p0.minRadius * p1.minRadius),
+    fma(p0.diameter, p1.minRadius, p1.diameter * p0.minRadius) / (2 * delta2 * p0.minRadius * p1.minRadius),
     1
   );
   p0.scale = Math.max(p0.scale, t);
@@ -51312,7 +51630,13 @@ function placeChild(child, ca, ctx) {
   const dx = ctx.childRadius * Math.cos(ca);
   const dy = ctx.childRadius * Math.sin(ca);
   applyDelta(child, dx, dy, getRotation(child, dx, dy, ca));
-  return ctx.length === 1 ? ca + ctx.incAngle + ctx.mindistAngle : ca + ctx.incAngle + ctx.mindistAngle / 2;
+  return nextChildAngle(ca, ctx.incAngle, ctx.mindistAngle, ctx.length);
+}
+function nextChildAngle(ca, inc2, mda, length) {
+  return length === 1 ? ca + (inc2 + mda) : ca + (inc2 + mda / 2);
+}
+function leftoverArc(childRadius, diameter) {
+  return fma(2 * Math.PI, childRadius, -diameter);
 }
 function advanceAngleL1(ca, inc2, total, cnt, stp) {
   const next = cnt === 0 ? 0 : total === 2 ? Math.PI : ca + inc2;
@@ -51322,7 +51646,7 @@ function advanceAngleL1(ca, inc2, total, cnt, stp) {
 }
 function advanceAngleLN(ca, inc2, mda, total, theta) {
   if (total === 1) return theta;
-  return ca + inc2 + mda / 2;
+  return ca + (inc2 + mda / 2);
 }
 function maybeWritePsi(n, stp, ca, isMid) {
   if (isMid && n === stp.neighbor) {
@@ -51337,7 +51661,7 @@ function positionChildren(pi, stp, length, minDist) {
   let md = minDist;
   if (length === 1) {
     cr = Math.max(cr, pi.diameter / (2 * Math.PI));
-    const d = 2 * Math.PI * cr - pi.diameter;
+    const d = leftoverArc(cr, pi.diameter);
     if (d > 0) md += d / pi.childCount;
   }
   stp.subtreeR = Math.max(stp.subtreeR, cr + pi.maxRadius);