@knowvah/dot-engine 2.6.7 → 2.6.9

package/dist/index.js

@@ -10358,9 +10358,11 @@ var StderrLines = class {
   writeLine;
   pending = "";
   write(text) {
-    const parts = (this.pending + text).split("\n");
-    this.pending = parts.pop() ?? "";
-    for (const line of parts) this.writeLine(line);
+    this.pending += text;
+    if (!this.pending.endsWith("\n")) return;
+    const line = this.pending.slice(0, -1);
+    this.pending = "";
+    this.writeLine(line);
   }
   flush() {
     if (this.pending === "") return;
@@ -10368,6 +10370,16 @@ var StderrLines = class {
     this.pending = "";
   }
 };
+var consoleLine = (line) => {
+  if (line.startsWith("Warning")) console.warn(line);
+  else console.error(line);
+};
+var labelStderr = () => new StderrLines(consoleLine);
+var agerrLine = (out, msg) => {
+  if (out === void 0) consoleLine(msg);
+  else out.write(`${msg}
+`);
+};
 
 // src/common/htmltable-parse-state.ts
 var peek = (s) => s.tokens[s.pos];
@@ -10672,11 +10684,87 @@ function htmlEntityUTF8(s) {
   });
 }
 
+// src/common/htmltable-lex-attvalue.ts
+var XML_ERROR_UNDEFINED_ENTITY = "undefined entity";
+var XML_ERROR_BAD_CHAR_REF = "reference to invalid character number";
+var NAME_START = /[A-Za-z_:\u0080-￿]/;
+var NAME_CHAR = /[\w.:\u0080-￿-]/;
+var DEC_DIGIT = /[0-9]/;
+var HEX_DIGIT = /[0-9A-Fa-f]/;
+var NON_XML = /[\x00-\x08\x0b\x0c\x0e-\x1f]/;
+function scanDigits(text, i, digit) {
+  if (i >= text.length) return { partial: true };
+  if (!digit.test(text[i])) return { invalid: i };
+  for (let k = i + 1; k < text.length; k++) {
+    if (text[k] === ";") return k + 1;
+    if (!digit.test(text[k])) return { invalid: k };
+  }
+  return { partial: true };
+}
+function scanRef(text, i) {
+  const c = text[i];
+  if (c === void 0) return { partial: true };
+  if (c === "#") return text[i + 1] === "x" ? scanDigits(text, i + 2, HEX_DIGIT) : scanDigits(text, i + 1, DEC_DIGIT);
+  if (!NAME_START.test(c)) return { invalid: i };
+  for (let k = i + 1; k < text.length; k++) {
+    if (text[k] === ";") return k + 1;
+    if (!NAME_CHAR.test(text[k])) return { invalid: k };
+  }
+  return { partial: true };
+}
+function scanAttValue(text, j) {
+  const q = text[j];
+  let k = j + 1;
+  for (; ; ) {
+    const c = text[k];
+    if (c === void 0) return { partial: true };
+    if (c === q) return { close: k };
+    if (c === "<" || NON_XML.test(c)) return { invalid: k };
+    if (c !== "&") {
+      k++;
+      continue;
+    }
+    const r = scanRef(text, k + 1);
+    if (typeof r !== "number") return r;
+    k = r;
+  }
+}
+function charRefNumber(ref) {
+  const hex = ref.startsWith("&#x");
+  const n = parseInt(ref.slice(hex ? 3 : 2, -1), hex ? 16 : 10);
+  if (n >= 1114112) return -1;
+  if (n >= 55296 && n <= 57343) return -1;
+  if (n < 32 && NON_XML.test(String.fromCharCode(n))) return -1;
+  return n === 65534 || n === 65535 ? -1 : n;
+}
+var PREDEFINED = { lt: "<", gt: ">", amp: "&", quot: '"', apos: "'" };
+var VALUE_PIECE = /&#x?[0-9A-Fa-f]+;|&[^;]+;|\r\n|[\t\n\r]/g;
+function attValueError(raw, base) {
+  for (const m of raw.matchAll(VALUE_PIECE)) {
+    const ref = m[0];
+    if (!ref.startsWith("&")) continue;
+    if (ref.startsWith("&#")) {
+      if (charRefNumber(ref) < 0) return { message: XML_ERROR_BAD_CHAR_REF, offset: base + m.index };
+    } else if (!Object.hasOwn(PREDEFINED, ref.slice(1, -1))) {
+      return { message: XML_ERROR_UNDEFINED_ENTITY };
+    }
+  }
+  return void 0;
+}
+function decodeAttValue(raw) {
+  return raw.replace(VALUE_PIECE, (m) => {
+    if (!m.startsWith("&")) return " ";
+    if (m.startsWith("&#")) return String.fromCodePoint(charRefNumber(m));
+    return PREDEFINED[m.slice(1, -1)];
+  });
+}
+
 // src/common/htmltable-lex-expat.ts
 var XML_ERROR_INVALID_TOKEN = "not well-formed (invalid token)";
 var XML_CONTEXT_BYTES = 1024;
 var INIT_BUFFER_SIZE = 1024;
-var COMPLETE_END = (end, dup) => dup === void 0 ? { kind: "complete", end } : { kind: "complete", end, dup };
+var XML_ERROR_DUPLICATE_ATTRIBUTE = "duplicate attribute";
+var COMPLETE_END = (end, attError) => attError === void 0 ? { kind: "complete", end } : { kind: "complete", end, attError };
 var PARTIAL = { kind: "partial" };
 var INVALID = (offset) => ({ kind: "invalid", offset });
 var XML_NAME = /^[A-Za-z_:\u0080-\uFFFF][\w.:\u0080-\uFFFF-]*/;
@@ -10699,14 +10787,13 @@ function fedBytes(unit, isText) {
 function scanValue(text, j) {
   const q = text[j];
   if (q !== '"' && q !== "'") return INVALID(j);
-  const close = text.indexOf(q, j + 1);
-  if (close < 0) {
-    const lt = text.indexOf("<", j + 1);
-    return lt >= 0 ? INVALID(lt) : PARTIAL;
-  }
+  const v = scanAttValue(text, j);
+  if ("partial" in v) return PARTIAL;
+  if ("invalid" in v) return INVALID(v.invalid);
+  const close = v.close;
   const next = skipSpace(text, close + 1);
   if (next === close + 1 && !">/".includes(text[next] ?? ">")) return INVALID(next);
-  return next;
+  return close;
 }
 function scanPair(text, i) {
   const name = XML_NAME.exec(text.slice(i))?.[0];
@@ -10716,8 +10803,9 @@ function scanPair(text, i) {
   if (text[eq] !== "=") return INVALID(eq);
   const j = skipSpace(text, eq + 1);
   if (j >= text.length) return PARTIAL;
-  const next = scanValue(text, j);
-  return typeof next === "number" ? { name, next } : next;
+  const close = scanValue(text, j);
+  if (typeof close !== "number") return close;
+  return { name, next: skipSpace(text, close + 1), value: { start: j + 1, end: close } };
 }
 function tagEdge(text, i) {
   const c = text[i];
@@ -10727,18 +10815,23 @@ function tagEdge(text, i) {
   if (i + 1 >= text.length) return PARTIAL;
   return text[i + 1] === ">" ? COMPLETE_END(i + 2) : void 0;
 }
-function scanAttributes(text, from) {
+function storeAttError(text, p, at, pair, seen) {
+  if (seen.has(pair.name)) return { message: XML_ERROR_DUPLICATE_ATTRIBUTE, offset: at };
+  seen.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();
-  let dup;
+  let attError;
   let i = skipSpace(text, from);
   for (; ; ) {
     const edge = tagEdge(text, i);
-    if (edge?.kind === "complete") return COMPLETE_END(edge.end, dup);
+    if (edge?.kind === "complete") return COMPLETE_END(edge.end, attError);
     if (edge !== void 0) return edge;
     const pair = scanPair(text, i);
     if ("kind" in pair) return pair;
-    if (seen.has(pair.name)) dup ??= i;
-    seen.add(pair.name);
+    attError ??= storeAttError(text, p, i, pair, seen);
     i = pair.next;
   }
 }
@@ -10753,7 +10846,7 @@ function scanStartTag(text, p) {
   const c = text[name.next];
   if (c === void 0) return PARTIAL;
   if (!isSpace(c) && c !== ">" && c !== "/") return INVALID(name.next);
-  return scanAttributes(text, name.next);
+  return scanAttributes(text, p, name.next);
 }
 function scanEndTag(text, p) {
   const name = scanName(text, p + 2);
@@ -10830,7 +10923,7 @@ function scanContent(text, base, inCdata, dataOf) {
     if (scan.kind === "invalid") return { tokens, consumed: p, invalid: base + scan.offset, inCdata: false };
     if (scan.kind === "partial") return { tokens, consumed: p, inCdata: false };
     const tok = { kind, start: base + p, end: base + scan.end };
-    if (scan.dup !== void 0) tok.dup = base + scan.dup;
+    if (scan.attError !== void 0) tok.attError = { ...scan.attError, offset: base + scan.attError.offset };
     tokens.push(tok);
     p = scan.end;
   }
@@ -10924,17 +11017,22 @@ var ExpatFeed = class {
 };
 var XML_PREDEFINED_ENTITIES = /* @__PURE__ */ new Set(["lt", "gt", "amp", "quot", "apos"]);
 var ENTITY_NAME = /^[A-Za-z_:][\w.:-]*$/;
-function findUndefinedEntity(text) {
+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] === "#") continue;
+    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;
+    }
     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 t;
+      return { message: XML_ERROR_UNDEFINED_ENTITY, offset: t };
     }
   }
-  return -1;
+  return void 0;
 }
 function parseTagChunk(chunk) {
   if (!chunk.endsWith(">")) return void 0;
@@ -11074,7 +11172,7 @@ function parseAttrPairs(raw) {
     if (q !== '"' && q !== "'") throw new HtmlParseError(name);
     const end = raw.indexOf(q, i + 1);
     if (end < 0) throw new HtmlParseError(name);
-    out.push([name, raw.slice(i + 1, end)]);
+    out.push([name, decodeAttValue(raw.slice(i + 1, end))]);
     i = end + 1;
   }
   return out;
@@ -11116,9 +11214,7 @@ function parseOpenToken(inner) {
   checkTag(tag);
   return openToken(normalizeTag(tag), sp === -1 ? "" : inner.slice(sp + 1));
 }
-var XML_ERROR_UNDEFINED_ENTITY = "undefined entity";
 var XML_ERROR_TAG_MISMATCH = "mismatched tag";
-var XML_ERROR_DUPLICATE_ATTRIBUTE = "duplicate attribute";
 var SYNTAX_ERROR = "syntax error";
 var HtmlLexError = class extends HtmlParseError {
   diagnostics;
@@ -11161,7 +11257,8 @@ function checkTagToken(site) {
       throw htmlErrorInLine(XML_ERROR_TAG_MISMATCH, lineAt(src, tok.start), context);
     }
   } else {
-    if (tok.dup !== void 0) throw htmlErrorInLine(XML_ERROR_DUPLICATE_ATTRIBUTE, lineAt(src, tok.dup), context);
+    const err = tok.attError;
+    if (err !== void 0) throw htmlErrorInLine(err.message, lineAt(src, err.offset), context);
     if (!tag.selfClose) st.stack.push(tag.name);
   }
   if (KNOWN_TAGS.has(tag.name.toUpperCase())) return;
@@ -11177,10 +11274,8 @@ function eventTokens(site) {
     checkTagToken(site);
     return tagTokens(text);
   }
-  const off = findUndefinedEntity(text);
-  if (off >= 0) {
-    throw htmlErrorInLine(XML_ERROR_UNDEFINED_ENTITY, lineAt(src, tok.start + off), st.prev + st.curr);
-  }
+  const err = textRefError(text);
+  if (err !== void 0) throw htmlErrorInLine(err.message, lineAt(src, tok.start + err.offset), st.prev + st.curr);
   return textTokens(text);
 }
 function attachCarry(carry, first) {
@@ -11290,9 +11385,6 @@ function tokenizeDeferred(src, label = { start: 0, end: src.length }) {
 }
 
 // src/common/htmltable-parse-attrs.ts
-function anchorAttr(v) {
-  return v === void 0 ? void 0 : htmlEntityUTF8(v);
-}
 var parseAlign = (v) => {
   const u = v.toUpperCase();
   if (u === "LEFT") return "left";
@@ -11300,6 +11392,7 @@ var parseAlign = (v) => {
   if (u === "CENTER") return "center";
   return void 0;
 };
+var parseCellAlign = (v) => v.toUpperCase() === "TEXT" ? "text" : parseAlign(v);
 var parseVAlign = (v) => {
   const u = v.toUpperCase();
   if (u === "TOP") return "top";
@@ -11333,7 +11426,7 @@ var buildCell = (content, a) => ({
   kind: "cell",
   content,
   port: a["port"],
-  align: parseAlign(a["align"] !== void 0 ? a["align"] : ""),
+  align: parseCellAlign(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"],
@@ -11349,9 +11442,9 @@ var buildCell = (content, a) => ({
   fixedsize: parseFixedSize(a),
   colspan: num(a["colspan"]),
   rowspan: num(a["rowspan"]),
-  href: anchorAttr(a["href"]),
+  href: a["href"],
   title: parseTitle(a),
-  target: anchorAttr(a["target"]),
+  target: a["target"],
   id: a["id"]
 });
 var buildTable = (rows, a) => ({
@@ -11369,9 +11462,9 @@ var buildTable = (rows, a) => ({
   fixedsize: parseFixedSize(a),
   width: num(a["width"]),
   height: num(a["height"]),
-  href: anchorAttr(a["href"]),
+  href: a["href"],
   title: parseTitle(a),
-  target: anchorAttr(a["target"]),
+  target: a["target"],
   id: a["id"],
   port: a["port"],
   sides: parseSides(a["sides"]),
@@ -11543,11 +11636,11 @@ var rejectTableAfterTag = (s, start) => {
     throw parseError(s, nxt, MSG_SYNTAX_ERROR);
   }
 };
-var parseImgContent = (s, t, cellAttrs) => {
+var parseImgContent = (s, t) => {
   consume(s);
   const img = {
     kind: "image",
-    src: cellAttrs["src"] ?? t.attrs["src"] ?? "",
+    src: t.attrs["src"] ?? "",
     scale: t.attrs["scale"]
   };
   consumeClose(s, "IMG");
@@ -11575,12 +11668,12 @@ var scanAfterTable = (s, t, st) => {
   if (nonSpace(t.value)) st.afterNonSpace = true;
   return [];
 };
-var scanCellImage = (s, t, cellAttrs, st) => {
+var scanCellImage = (s, t, st) => {
   if (st.kind !== "none") throw parseError(s, t, MSG_SYNTAX_ERROR);
   st.kind = "image";
-  return [parseImgContent(s, t, cellAttrs)];
+  return [parseImgContent(s, t)];
 };
-var scanCellItem = (s, t, cellAttrs, fontStack, st) => {
+var scanCellItem = (s, t, fontStack, st) => {
   if (st.kind === "fonttable") throw parseError(s, t, MSG_SYNTAX_ERROR);
   if (st.kind === "table") return scanAfterTable(s, t, st);
   const wrapper = st.kind === "none" ? fontTableWrapper(s) : void 0;
@@ -11589,7 +11682,7 @@ var scanCellItem = (s, t, cellAttrs, fontStack, st) => {
     return [parseFontTable(s, wrapper, fontStack)];
   }
   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 (t.type === "open" && t.tag === "IMG") return scanCellImage(s, t, st);
   if (st.kind === "image") throw parseError(s, t, MSG_SYNTAX_ERROR);
   return scanCellText(s, t, fontStack, st);
 };
@@ -11599,12 +11692,12 @@ var endsCell = (s, t, st) => {
   if (t.tag === "TD" && !afterText) return true;
   throw parseError(s, t, afterText ? MSG_TEXT_AFTER_TABLE : MSG_SYNTAX_ERROR);
 };
-var parseCellContent = (s, cellAttrs, fontStack) => {
+var parseCellContent = (s, fontStack) => {
   const content = [];
   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));
+    content.push(...scanCellItem(s, t, fontStack, st));
   }
   const nxt = peek(s);
   if (nxt?.type === "close" && nxt.tag === "TD") consume(s);
@@ -11612,7 +11705,7 @@ var parseCellContent = (s, cellAttrs, fontStack) => {
   if (tbl !== void 0) return [tbl];
   return content;
 };
-var parseCell = (s, attrs, fontStack) => buildCell(parseCellContent(s, attrs, fontStack), attrs);
+var parseCell = (s, attrs, fontStack) => buildCell(parseCellContent(s, fontStack), attrs);
 var parseRowVr = (s, t, cells) => {
   const prev = cells[cells.length - 1];
   if (prev === void 0) throw parseError(s, t, MSG_SYNTAX_ERROR);
@@ -11773,17 +11866,9 @@ var parseTokens = (s) => {
   if (firstReal?.type === "open" && firstReal.tag === "TABLE") return parseTableLabel(s, fontStack);
   return parseTextLabel(s, fontStack);
 };
-var parseHtmlLabelRv = (src, writeLine = (line) => console.warn(line)) => {
+var parseHtmlLabelRv = (src, stderr) => {
   const { tokens, error, eof } = tokenizeDeferred(`<HTML>${src}</HTML>`, { start: 6, end: 6 + src.length });
-  const s = {
-    tokens,
-    pos: 0,
-    pending: error,
-    stderr: new StderrLines(writeLine),
-    emitted: /* @__PURE__ */ new WeakSet(),
-    warn: false,
-    eof
-  };
+  const s = { tokens, pos: 0, pending: error, stderr, emitted: /* @__PURE__ */ new WeakSet(), warn: false, eof };
   try {
     const label = parseTokens(s);
     if (error !== void 0) throw error;
@@ -11794,11 +11879,9 @@ var parseHtmlLabelRv = (src, writeLine = (line) => console.warn(line)) => {
       throw error;
     }
     throw e;
-  } finally {
-    s.stderr?.flush();
   }
 };
-var parseHtmlLabel = (src) => parseHtmlLabelRv(src, () => void 0).label;
+var parseHtmlLabel = (src) => parseHtmlLabelRv(src, new StderrLines(() => void 0)).label;
 
 // src/gvc/usershape.ts
 var activeSizer = null;
@@ -12000,7 +12083,7 @@ var sizeTextContent = (texts, measurer, env = defaultSizeEnv()) => {
   return { w, h };
 };
 var missingImages = /* @__PURE__ */ new WeakSet();
-var sizeHtmlImg = (img, imageSizer) => {
+var sizeHtmlImg = (img, { imageSizer, stderr }) => {
   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) {
@@ -12008,7 +12091,7 @@ var sizeHtmlImg = (img, imageSizer) => {
     img.height = sz.h;
     return 0;
   }
-  console.error(`Error: No or improper image file="${img.src}"`);
+  agerrLine(stderr, `Error: No or improper image file="${img.src}"`);
   img.width = 0;
   img.height = 0;
   missingImages.add(img);
@@ -12021,7 +12104,7 @@ var sizeContentItem = (item, measurer, env) => {
     return { ...item.dimen !== void 0 ? item.dimen : { w: 0, h: 0 }, rv };
   }
   if (item.kind === "image") {
-    const rv = sizeHtmlImg(item, env.imageSizer);
+    const rv = sizeHtmlImg(item, env);
     return { w: item.width ?? 0, h: item.height ?? 0, rv };
   }
   return { w: 0, h: 0, rv: 0 };
@@ -12051,14 +12134,14 @@ var WARN_CELL_UNSPECIFIED = "Warning: fixed cell size with unspecified width or
 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) => {
+var fixedCellCheck = (cell2, sz, warn, out) => {
   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);
+    if (small && warn) agerrLine(out, WARN_CELL_TOO_SMALL);
     return { rv: small ? 1 : 0, zero: true };
   }
-  if (warn) console.warn(WARN_CELL_UNSPECIFIED);
+  if (warn) agerrLine(out, WARN_CELL_UNSPECIFIED);
   return { rv: 1, zero: false };
 };
 var getCellSize = (cell2, tbl, measurer, env) => {
@@ -12074,7 +12157,7 @@ var getCellSize = (cell2, tbl, measurer, env) => {
   let szy = ch + margin;
   const warn = !sizeWarned.has(cell2);
   sizeWarned.add(cell2);
-  const fixed = fixedCellCheck(cell2, { w: szx, h: szy }, warn);
+  const fixed = fixedCellCheck(cell2, { w: szx, h: szy }, warn, env.stderr);
   rv |= fixed.rv;
   if (fixed.zero) {
     szx = 0;
@@ -12168,22 +12251,22 @@ var layoutHtmlTable = (tbl, measurer, env = defaultSizeEnv()) => {
   const heights = setRowHeights(entries, nrows, spacing);
   return { entries, widths, heights, spacing, border: border2, rv };
 };
-var warnFixedTable = (tbl, dims) => {
+var warnFixedTable = (tbl, dims, out) => {
   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);
+    if (warn) agerrLine(out, WARN_TABLE_TOO_SMALL);
     return 1;
   }
-  if (warn) console.warn(WARN_TABLE_UNSPECIFIED);
+  if (warn) agerrLine(out, WARN_TABLE_UNSPECIFIED);
   return 1;
 };
 var sizeTableBody = (tbl, measurer, env) => {
   const { entries, widths, heights, spacing, border: border2, rv } = layoutHtmlTable(tbl, measurer, env);
   if (entries.length === 0) {
-    const fixed2 = warnFixedTable(tbl, sumTableDims({ widths, heights, ncols: 0, nrows: 0, spacing, border: border2 }));
+    const fixed2 = warnFixedTable(tbl, sumTableDims({ widths, heights, ncols: 0, nrows: 0, spacing, border: border2 }), env.stderr);
     tbl.dimen = { w: 0, h: 0 };
     return rv | fixed2;
   }
@@ -12193,7 +12276,7 @@ var sizeTableBody = (tbl, measurer, env) => {
   const { wd, ht } = sumTableDims({ widths, heights, ncols, nrows, spacing, border: border2 });
   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 fixed = warnFixedTable(tbl, { wd, ht }, env.stderr);
   const zeroContent = isTblFixed(tbl) && baseWd !== 0 && baseHt !== 0;
   tbl.dimen = {
     w: Math.max(zeroContent ? 0 : wd, baseWd),
@@ -17525,7 +17608,7 @@ function placeComplexRuns(runs, box, finfo, measurer) {
 function alignContentBox(box, cell2, w, h) {
   const out = { ll: { ...box.ll }, ur: { ...box.ur } };
   const delx = out.ur.x - out.ll.x - w;
-  if (delx > 0) {
+  if (delx > 0 && cell2.align !== "text") {
     if (cell2.align === "left") out.ur.x -= delx;
     else if (cell2.align === "right") out.ll.x += delx;
     else {
@@ -17780,21 +17863,25 @@ function posHtmlLabel(label, finfo, measurer) {
   if (label.kind === "table") return withTableFont(env, label.table.font, "emit", () => posHtmlTable(label.table, env, measurer));
   return posTextLabel(label, finfo, measurer);
 }
+
+// src/common/htmltable-label.ts
 var HTML_PARSE_FATAL = 3;
-function makeHtmlLabelRv(content, finfo, measurer) {
+function makeHtmlLabelTo(content, finfo, measurer, stderr) {
   const { fontname, fontsize, fontcolor, imageSizer, pencolor } = finfo;
   let lbl, lexWarn;
   try {
-    ({ label: lbl, warn: lexWarn } = parseHtmlLabelRv(content));
+    ({ label: lbl, warn: lexWarn } = parseHtmlLabelRv(content, stderr));
   } catch (e) {
-    if (e instanceof HtmlLexError) for (const line of e.diagnostics) console.error(line);
+    if (e instanceof HtmlLexError) for (const line of e.diagnostics) stderr.write(`${line}
+`);
     return { label: makeLabel("", fontname, fontsize, fontcolor, measurer), rv: HTML_PARSE_FATAL };
   }
   if (lbl.kind === "table") inheritTablePenColor(lbl.table, pencolor);
   const rv = Number(lexWarn) | sizeHtmlLabel(lbl, measurer, {
     fontsize,
     fontname,
-    imageSizer
+    imageSizer,
+    stderr
   });
   const placed = posHtmlLabel(lbl, { fontname, fontsize, fontcolor }, measurer);
   const dim = lbl.dimen ?? { w: 0, h: 0 };
@@ -17902,6 +17989,9 @@ function interpretCRNL(str) {
   }
   return out;
 }
+function preprocessTooltip(s) {
+  return interpretCRNL(htmlEntityUTF8(s));
+}
 
 // src/common/make-label.ts
 var DEFAULT_FONTSIZE2 = 14;
@@ -17993,8 +18083,11 @@ 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;
-    const { label, rv } = makeHtmlLabelRv(content, { ...font, pencolor: getPenColor(obj), imageSizer }, measurer);
-    if (rv !== 0 && obj !== void 0) console.error(inLabelOf(obj));
+    const stderr = labelStderr();
+    const { label, rv } = makeHtmlLabelTo(content, { ...font, pencolor: getPenColor(obj), imageSizer }, measurer, stderr);
+    if (rv !== 0 && obj !== void 0) stderr.write(`${inLabelOf(obj)}
+`);
+    stderr.flush();
     return label;
   }
   const subst2 = obj !== void 0 ? substObj(content, obj, false) : content;
@@ -24762,31 +24855,141 @@ function stripedBox(job, pts, clrs, rotate, renderer) {
   return error;
 }
 
+// src/util/xml.ts
+function gvXmlEscape(s, flags) {
+  return XmlEscaper.escape(s, flags);
+}
+var XmlEscaper = class _XmlEscaper {
+  static escape(s, flags) {
+    let result = "";
+    let previous = "";
+    let pos = 0;
+    while (pos < s.length) {
+      const prev = s[pos];
+      const [fragment, consumed] = _XmlEscaper.core(previous, s, pos, flags);
+      result += fragment;
+      previous = prev;
+      pos += consumed;
+    }
+    return result;
+  }
+  /**
+   * Escape one character/codepoint at s[pos].
+   * Returns [escaped_fragment, characters_consumed].
+   * Delegates to focused helpers to stay within CCN limit.
+   * @see lib/util/xml.c:xml_core
+   */
+  static core(previous, s, pos, flags) {
+    const special = _XmlEscaper.coreSpecial(previous, s, pos, flags);
+    if (special !== null) return special;
+    const code = s.charCodeAt(pos);
+    if (code > 127 && flags.utf8) return _XmlEscaper.utf8Entity(s, pos);
+    return [s[pos], 1];
+  }
+  /**
+   * Handle all the fixed-escape cases (& < > - space " ' \n \r).
+   * Returns null when none of those cases applies.
+   * @see lib/util/xml.c:xml_core
+   */
+  static coreSpecial(previous, s, pos, flags) {
+    const c = s[pos];
+    if (c === "&" && (flags.raw || !_XmlEscaper.isEntity(s, pos))) {
+      return ["&amp;", 1];
+    }
+    if (c === "<") return ["&lt;", 1];
+    if (c === ">") return ["&gt;", 1];
+    if (c === '"') return ["&quot;", 1];
+    if (c === "'") return ["&#39;", 1];
+    if (c === "-" && flags.dash) return ["&#45;", 1];
+    if (c === " " && previous === " " && flags.nbsp) return ["&#160;", 1];
+    if (c === "\n" && flags.raw) return ["&#10;", 1];
+    if (c === "\r" && flags.raw) return ["&#13;", 1];
+    return null;
+  }
+  /**
+   * Return true if s[pos] (which is '&') starts a valid XML entity:
+   *   &[A-Za-z]+;      e.g. &Ccedil;
+   *   &#[0-9]*;        e.g. &#38;
+   *   &#x[0-9a-fA-F]*; e.g. &#x6C34;
+   * @see lib/util/xml.c:xml_isentity
+   */
+  static isEntity(s, pos) {
+    let i = pos + 1;
+    if (i >= s.length || s[i] === ";") return false;
+    i = s[i] === "#" ? _XmlEscaper.scanNumericRef(s, i) : _XmlEscaper.scanNamedRef(s, i);
+    return i < s.length && s[i] === ";";
+  }
+  /** Scan a numeric entity body starting just after the '#'. */
+  static scanNumericRef(s, hashPos) {
+    let i = hashPos + 1;
+    if (i < s.length && (s[i] === "x" || s[i] === "X")) {
+      i++;
+      while (i < s.length && _XmlEscaper.isXDigit(s[i])) i++;
+    } else {
+      while (i < s.length && _XmlEscaper.isDecDigit(s[i])) i++;
+    }
+    return i;
+  }
+  /** Scan a named entity body (alpha chars after the '&'). */
+  static scanNamedRef(s, start) {
+    let i = start;
+    while (i < s.length && _XmlEscaper.isAlpha(s[i])) i++;
+    return i;
+  }
+  /**
+   * Emit &#xNNNN; for the Unicode code point at s[pos]. JS strings are
+   * UTF-16, so the code point (what C decodes from UTF-8) comes from
+   * codePointAt, and an astral character consumes two units.
+   * @see lib/util/xml.c:xml_core (UTF-8 block)
+   */
+  static utf8Entity(s, pos) {
+    const cp = _XmlEscaper.decodeUtf8(s, pos);
+    const consumed = _XmlEscaper.utf8ByteLen(cp);
+    return [`&#x${cp.toString(16)};`, consumed];
+  }
+  /**
+   * Return the code point at s[pos]. A lone surrogate is the analogue of
+   * malformed UTF-8, where C reports an error and exits (xml.c:135).
+   * @see lib/util/xml.c:xml_core (fprintf + graphviz_exit at xml.c:135)
+   */
+  static decodeUtf8(s, pos) {
+    const cp = s.codePointAt(pos);
+    if (cp >= 55296 && cp <= 57343) {
+      throw new RenderError(`gvXmlEscape: malformed UTF-8 at position ${pos}`, "RENDER_ERROR");
+    }
+    return cp;
+  }
+  /**
+   * Return how many UTF-16 units encode the code point (C: the UTF-8 byte
+   * length from the leading byte).
+   * @see lib/util/xml.c:xml_core (length computation)
+   */
+  static utf8ByteLen(cp) {
+    return cp > 65535 ? 2 : 1;
+  }
+  static isDecDigit(c) {
+    return c >= "0" && c <= "9";
+  }
+  static isAlpha(c) {
+    return c >= "a" && c <= "z" || c >= "A" && c <= "Z";
+  }
+  static isXDigit(c) {
+    return _XmlEscaper.isDecDigit(c) || c >= "a" && c <= "f" || c >= "A" && c <= "F";
+  }
+};
+
 // src/render/xml-escape.ts
-var RE_DQUOTE = new RegExp('"', "g");
-var RE_SQUOTE = new RegExp("'", "g");
-var RE_AMP_NONENTITY = /&(?![A-Za-z]+;|#[0-9]+;|#x[0-9A-Fa-f]+;)/g;
+var FLAGS_BASE = { raw: false, dash: false, nbsp: false, utf8: false };
+var FLAGS_TITLE = { raw: false, dash: true, nbsp: true, utf8: false };
+var FLAGS_TEXT = { raw: true, dash: true, nbsp: true, utf8: false };
 function escapeXml(s) {
-  let r = s.replace(RE_AMP_NONENTITY, "&amp;");
-  r = r.replace(/</g, "&lt;");
-  r = r.replace(/>/g, "&gt;");
-  r = r.replace(RE_DQUOTE, "&quot;");
-  r = r.replace(RE_SQUOTE, "&#39;");
-  return r;
+  return gvXmlEscape(s, FLAGS_BASE);
 }
 function escapeXmlTitle(s) {
-  let r = escapeXml(s);
-  r = r.replace(/-/g, "&#45;");
-  r = r.replace(/ {2,}/g, (m) => " " + "&#160;".repeat(m.length - 1));
-  return r;
+  return gvXmlEscape(s, FLAGS_TITLE);
 }
 function escapeXmlText(s) {
-  let r = escapeXml(s);
-  r = r.replace(/-/g, "&#45;");
-  r = r.replace(/\n/g, "&#10;");
-  r = r.replace(/\r/g, "&#13;");
-  r = r.replace(/ {2,}/g, (m) => " " + "&#160;".repeat(m.length - 1));
-  return r;
+  return gvXmlEscape(s, FLAGS_TEXT);
 }
 
 // src/gvc/device-cluster.ts
@@ -24962,23 +25165,23 @@ function renderNodeLabel(n, coord, renderer, job) {
     renderLabel(label, coord, renderer, job);
   }
 }
-function anchorAttr2(n, key) {
+function anchorAttr(n, key) {
   const v = nodeAttr(n, n.root, key);
   return v !== void 0 && v !== "" ? v : void 0;
 }
 function resolveTooltip(n, tooltip) {
-  if (tooltip !== void 0) return substObjAnchor(interpretCRNL(tooltip), n);
+  if (tooltip !== void 0) return substObjAnchor(preprocessTooltip(tooltip), n);
   const label = n.info.label;
   return label?.text ?? "";
 }
 function beginNodeAnchor(n, renderer, job) {
-  const url = anchorAttr2(n, "href") ?? anchorAttr2(n, "URL");
-  const tooltip = anchorAttr2(n, "tooltip");
+  const url = anchorAttr(n, "href") ?? anchorAttr(n, "URL");
+  const tooltip = anchorAttr(n, "tooltip");
   if (url === void 0 && tooltip === void 0) return false;
   renderer.beginAnchor?.(
     url !== void 0 ? substObjAnchor(url, n) : "",
     resolveTooltip(n, tooltip),
-    anchorAttr2(n, "target") ?? "",
+    anchorAttr(n, "target") ?? "",
     svgNodeId(n, job),
     job
   );
@@ -27484,7 +27687,7 @@ function subst(s, obj) {
   return substObjAnchor(s, obj);
 }
 function tip(s, obj) {
-  return substObjAnchor(interpretCRNL(s), obj);
+  return substObjAnchor(preprocessTooltip(s), obj);
 }
 function textOf(lp) {
   return lp?.text ?? null;