@knowvah/dot-engine 2.6.7 → 2.6.9

package/src/common/htmltable-parse.ts

@@ -219,13 +219,11 @@ const rejectTableAfterTag = (s: ParseState, start: number): void => {
 // Cell content helpers — mirrors htmlparse.y cell rule
 // ---------------------------------------------------------------------------
 
-const parseImgContent = (
-  s: ParseState, t: OpenToken, cellAttrs: Record<string, string>,
-): HtmlImage => {
+const parseImgContent = (s: ParseState, t: OpenToken): HtmlImage => {
   consume(s);
   const img: HtmlImage = {
     kind: 'image',
-    src: cellAttrs['src'] ?? t.attrs['src'] ?? '',
+    src: t.attrs['src'] ?? '',
     scale: t.attrs['scale'],
   };
   consumeClose(s, 'IMG');
@@ -272,17 +270,15 @@ const scanAfterTable = (s: ParseState, t: Token, st: CellScan): HtmlCellContent[
 };
 
 /** `image` as the cell's only child. */
-const scanCellImage = (
-  s: ParseState, t: OpenToken, cellAttrs: Record<string, string>, st: CellScan,
-): HtmlCellContent[] => {
+const scanCellImage = (s: ParseState, t: OpenToken, st: CellScan): HtmlCellContent[] => {
   if (st.kind !== 'none') throw parseError(s, t, MSG_SYNTAX_ERROR);
   st.kind = 'image';
-  return [parseImgContent(s, t, cellAttrs)];
+  return [parseImgContent(s, t)];
 };
 
 /** One step of `cell: T_cell (fonttable | fonttext | image) T_end_cell`. */
 const scanCellItem = (
-  s: ParseState, t: Token, cellAttrs: Record<string, string>, fontStack: FontState[], st: CellScan,
+  s: ParseState, t: Token, fontStack: FontState[], st: CellScan,
 ): HtmlCellContent[] => {
   if (st.kind === 'fonttable') throw parseError(s, t, MSG_SYNTAX_ERROR);
   if (st.kind === 'table') return scanAfterTable(s, t, st);
@@ -292,7 +288,7 @@ const scanCellItem = (
     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);
 };
@@ -305,14 +301,12 @@ const endsCell = (s: ParseState, t: Token, st: CellScan): boolean => {
   throw parseError(s, t, afterText ? MSG_TEXT_AFTER_TABLE : MSG_SYNTAX_ERROR);
 };
 
-const parseCellContent = (
-  s: ParseState, cellAttrs: Record<string, string>, fontStack: FontState[],
-): HtmlCellContent[] => {
+const parseCellContent = (s: ParseState, fontStack: FontState[]): HtmlCellContent[] => {
   const content: HtmlCellContent[] = [];
   const st: CellScan = { kind: 'none', textNonSpace: false, afterNonSpace: false };
   for (let t = peek(s); t !== undefined; 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);
@@ -327,7 +321,7 @@ const parseCellContent = (
 /** @see lib/common/htmlparse.y:cell rule / lib/common/htmllex.c:mkCell */
 const parseCell = (
   s: ParseState, attrs: Record<string, string>, fontStack: FontState[],
-): HtmlCell => buildCell(parseCellContent(s, attrs, fontStack), attrs);
+): HtmlCell => buildCell(parseCellContent(s, fontStack), attrs);
 
 // ---------------------------------------------------------------------------
 // parseRow — parses <TR>...</TR>
@@ -560,21 +554,16 @@ export interface ParsedHtmlLabel {
 }
 
 /**
- * Parse an HTML-like label string, printing the lexer's warnings (one
- * `writeLine` per stderr line, `console.warn` by default) as the parser reaches
- * their tokens. Input is the content between the outer `<` `>` delimiters
- * (already stripped).
+ * Parse an HTML-like label string, writing the lexer's warnings to `stderr` as
+ * the parser reaches their tokens. The caller owns `stderr` and flushes it: a
+ * warning without a newline continues into the caller's next write. Input is
+ * the content between the outer `<` `>` delimiters (already stripped).
  *
  * @see lib/common/htmlparse.y:parseHTML
  */
-export const parseHtmlLabelRv = (
-  src: string,
-  writeLine: (line: string) => void = (line) => console.warn(line),
-): ParsedHtmlLabel => {
+export const parseHtmlLabelRv = (src: string, stderr: StderrLines): ParsedHtmlLabel => {
   const { tokens, error, eof } = tokenizeDeferred(`<HTML>${src}</HTML>`, { start: 6, end: 6 + src.length });
-  const s: ParseState = {
-    tokens, pos: 0, pending: error, stderr: new StderrLines(writeLine), emitted: new WeakSet(), warn: false, eof,
-  };
+  const s: ParseState = { tokens, pos: 0, pending: error, stderr, emitted: new WeakSet(), warn: false, eof };
   try {
     const label = parseTokens(s);
     if (error !== undefined) throw error;
@@ -583,8 +572,6 @@ export const parseHtmlLabelRv = (
     // Running off the truncated stream means C's lexer would have hit the error.
     if (error !== undefined && s.pos >= tokens.length) { emitEof(s); throw error; }
     throw e;
-  } finally {
-    s.stderr?.flush();
   }
 };
 
@@ -594,4 +581,4 @@ export const parseHtmlLabelRv = (
  * the sync pass prints.
  */
 export const parseHtmlLabel = (src: string): HtmlLabel =>
-  parseHtmlLabelRv(src, () => undefined).label;
+  parseHtmlLabelRv(src, new StderrLines(() => undefined)).label;

package/src/common/htmltable-pos.ts

@@ -16,14 +16,11 @@
  */
 
 import type { Box } from '../model/geom.js';
-import type { TextlabelT } from './types.js';
 import type { TextMeasurer } from './textmeasure.js';
-import type { HtmlCell, HtmlImage, HtmlLabel, HtmlTable, HtmlText, ImageSizer } from './htmltable-types.js';
+import type { HtmlCell, HtmlImage, HtmlLabel, HtmlTable, HtmlText } from './htmltable-types.js';
 import {
-  layoutHtmlTable, cellPad, cellBorder, sizeHtmlLabel, parseHtmlLabelRv, inheritTablePenColor, withTableFont,
+  layoutHtmlTable, cellPad, cellBorder, withTableFont,
 } from './htmltable.js';
-import { makeLabel } from './make-label.js';
-import { HtmlLexError } from './htmltable-lex.js';
 import { TOP, BOTTOM, LEFT, RIGHT } from './splines-constants.js';
 import type { PlacedLine, HtmlFontInfo } from './htmltable-pos-runs.js';
 import {
@@ -171,15 +168,14 @@ export interface PlacedHtml {
  * of pos_html_cell: LEFT flushes the box right edge in (`ur.x -= delx`), RIGHT
  * flushes the left edge in, default splits (center); VALIGN BOTTOM/TOP flush,
  * default centers on BOTH axes. Parallels the existing `alignImageBox`, but
- * text default-centers vertically where an image does not.
- * (`parseAlign` never yields HALIGN_TEXT, so the cell box always shrinks here —
- * exactly what C does for every non-TEXT cell.)
+ * text default-centers vertically where an image does not. ALIGN="TEXT" keeps
+ * the box's width: lines then align across the whole cell.
  * @see lib/common/htmltable.c:pos_html_cell (text branch, :1487-1526)
  */
 export function alignContentBox(box: Box, cell: HtmlCell, w: number, h: number): Box {
   const out: Box = { ll: { ...box.ll }, ur: { ...box.ur } };
   const delx = out.ur.x - out.ll.x - w;
-  if (delx > 0) {
+  if (delx > 0 && cell.align !== 'text') {
     if (cell.align === 'left') out.ur.x -= delx;
     else if (cell.align === 'right') out.ll.x += delx;
     else { out.ll.x += delx / 2; out.ur.x -= delx / 2; }
@@ -520,82 +516,3 @@ export function posHtmlLabel(
   if (label.kind === 'table') return withTableFont(env, label.table.font, 'emit', () => posHtmlTable(label.table, env, measurer));
   return posTextLabel(label, finfo, measurer);
 }
-
-/** parseHTML's rv for a label that failed to parse (`ctx->error`). */
-const HTML_PARSE_FATAL = 3;
-
-/** A built HTML label plus make_html_label's "problem" return value. */
-export interface HtmlLabelResult {
-  label: TextlabelT;
-  rv: number;
-}
-
-/**
- * make_html_label: parse, size and position an HTML-like label. Returns C's
- * rv too (nonzero: the caller appends `in label of ...`, labels.c:make_label).
- * Parse diagnostics print here, once per label, as parseHTML does. The
- * optional `imageSizer` resolves `<IMG SRC>`; absent means C's missing image.
- * @see lib/common/htmltable.c:make_html_label
- */
-export function makeHtmlLabelRv(
-  content: string,
-  finfo: HtmlFontInfo & { imageSizer?: ImageSizer; pencolor?: string },
-  measurer: TextMeasurer,
-): HtmlLabelResult {
-  const { fontname, fontsize, fontcolor, imageSizer, pencolor } = finfo;
-  let lbl: HtmlLabel, lexWarn: boolean; // lexWarn: htmllex.c's ctx->warn, rv bit 1
-  try {
-    ({ label: lbl, warn: lexWarn } = parseHtmlLabelRv(content));
-  } catch (e) {
-    // C aborts the HTML parse on a syntax error (YYABORT): parseHTML returns
-    // rv 3 (ctx->error) with no label, and make_html_label returns it with
-    // lp->html cleared and no spans, so the label renders empty.
-    // @see lib/common/htmltable.c:1880 (rv == 3), htmlparse.y (YYABORT)
-    if (e instanceof HtmlLexError) for (const line of e.diagnostics) console.error(line);
-    return { label: makeLabel('', fontname, fontsize, fontcolor, measurer), rv: HTML_PARSE_FATAL };
-  }
-  // A top-level table with no explicit COLOR inherits the object's pen color,
-  // which then flows table->cell->nested-table.
-  // @see lib/common/htmltable.c:1911 (getPenColor), :1406/:1556 (inheritance)
-  if (lbl.kind === 'table') inheritTablePenColor(lbl.table, pencolor);
-  const rv = Number(lexWarn) | sizeHtmlLabel(lbl, measurer, {
-    fontsize, fontname, imageSizer,
-  });
-  const placed = posHtmlLabel(lbl, { fontname, fontsize, fontcolor }, measurer);
-  const dim = lbl.dimen ?? { w: 0, h: 0 };
-  // C replaces table-label text: "this may be used for the title and
-  // alt fields in image maps" — anchors inherit it as default tooltip.
-  // @see lib/common/htmltable.c:make_html_label (line 1935)
-  const text = lbl.kind === 'table' ? '<TABLE>' : content;
-  return { label: htmlTextLabel(text, { fontname, fontsize, fontcolor }, placed, dim), rv };
-}
-
-/** {@link makeHtmlLabelRv} without the problem flag. */
-export function makeHtmlLabel(
-  content: string,
-  finfo: HtmlFontInfo & { imageSizer?: ImageSizer; pencolor?: string },
-  measurer: TextMeasurer,
-): TextlabelT {
-  return makeHtmlLabelRv(content, finfo, measurer).label;
-}
-
-/** Build the TextlabelT wrapper around a positioned HTML label. */
-function htmlTextLabel(
-  text: string,
-  finfo: HtmlFontInfo,
-  placed: PlacedHtml,
-  dim: { w: number; h: number },
-): TextlabelT {
-  return {
-    text,
-    fontname: finfo.fontname, fontcolor: finfo.fontcolor, charset: 0,
-    fontsize: finfo.fontsize,
-    dimen: { x: dim.w, y: dim.h },
-    space: { x: dim.w, y: dim.h },
-    pos: { x: 0, y: 0 },
-    u: { kind: 'html', html: placed },
-    valign: 'c'.charCodeAt(0),
-    set: false,
-    html: true,
-  };
-}

package/src/common/htmltable-types.ts

@@ -40,6 +40,9 @@ export class HtmlParseError extends DotEngineError {
 /** @see lib/common/htmltable.h HALIGN_* flags */
 export type HtmlAlign = 'left' | 'center' | 'right';
 
+/** A cell's ALIGN: TEXT (HALIGN_TEXT) leaves the text block the cell's width. @see lib/common/htmllex.c:cell_halignfn */
+export type HtmlCellAlign = HtmlAlign | 'text';
+
 /** @see lib/common/htmltable.h VALIGN_* flags */
 export type HtmlVAlign = 'top' | 'middle' | 'bottom';
 
@@ -132,7 +135,7 @@ export interface HtmlCell {
    */
   vruled?: boolean;
   port?: string;
-  align?: HtmlAlign;
+  align?: HtmlCellAlign;
   valign?: HtmlVAlign;
   balign?: HtmlAlign;
   bgcolor?: string;

package/src/common/htmltable.ts

@@ -20,13 +20,13 @@ export type { TextMeasurer } from './textmeasure.js';
 
 import type {
   HtmlCell, HtmlCellContent, HtmlImage, HtmlLabel, HtmlTable, HtmlText,
-  HtmlTextItem,
+  HtmlTextItem, ImageSizer,
 } from './htmltable-types.js';
-import type { ImageSizer } from './htmltable-types.js';
 import { findImageSize } from '../gvc/usershape.js';
 import { PointSet } from './pointset.js';
 import type { TextMeasurer } from './textmeasure.js';
 import { withTableFont } from './htmltable-fontinfo.js';
+import { agerrLine, type StderrLines } from './htmltable-attr-warn.js';
 
 export { withTableFont } from './htmltable-fontinfo.js';
 
@@ -85,6 +85,7 @@ export interface HtmlSizeEnv {
   fontsize: number;
   fontname: string;
   imageSizer?: ImageSizer;
+  stderr?: StderrLines; // the label's stderr; none: straight to the console
 }
 
 const defaultSizeEnv = (): HtmlSizeEnv => ({ fontsize: DEFAULT_FONTSIZE, fontname: '' });
@@ -230,21 +231,20 @@ const sizeTextContent = (
 /** Images whose sizing failed: size_html_img's rv = 1 on every later call. */
 const missingImages = new WeakSet<HtmlImage>();
 
-const sizeHtmlImg = (img: HtmlImage, imageSizer?: ImageSizer): number => {
+const sizeHtmlImg = (img: HtmlImage, { imageSizer, stderr }: HtmlSizeEnv): number => {
   // C sizes each image once (processTbl); the port's size and pos passes
   // share layoutHtmlTable, so guard against re-sizing (and re-warning). The
   // returned rv still follows C on every call.
   if (img.width !== undefined && img.height !== undefined) return missingImages.has(img) ? 1 : 0;
   const sz = imageSizer !== undefined ? imageSizer(img.src) : findImageSize(img.src);
   if (sz !== null) {
-    img.width = sz.w;
-    img.height = sz.h;
+    img.width = sz.w; img.height = sz.h;
     return 0;
   }
   // Missing-image: zero size + warning.
   // C: agerrorf("No or improper image file=\"%s\"\n", img->src) — agerr
   // prefixes "Error: " on stderr.
-  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);
@@ -262,7 +262,7 @@ const sizeContentItem = (
     return { ...(item.dimen !== undefined ? 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 };
@@ -327,15 +327,15 @@ const sizeWarned = new WeakSet<object>();
  * @see lib/common/htmltable.c:1141 (size_html_cell FIXED_FLAG)
  */
 const fixedCellCheck = (
-  cell: HtmlCell, sz: { w: number; h: number }, warn: boolean,
+  cell: HtmlCell, sz: { w: number; h: number }, warn: boolean, out: StderrLines | undefined,
 ): { rv: number; zero: boolean } => {
   if (!cell.fixedsize) return { rv: 0, zero: false };
   if (cell.width && cell.height) {
     const small = (cell.width < sz.w || cell.height < sz.h) && cell.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 };
 };
 
@@ -360,7 +360,7 @@ const getCellSize = (
   let szy = ch + margin;
   const warn = !sizeWarned.has(cell);
   sizeWarned.add(cell);
-  const fixed = fixedCellCheck(cell, { w: szx, h: szy }, warn);
+  const fixed = fixedCellCheck(cell, { w: szx, h: szy }, warn, env.stderr);
   rv |= fixed.rv;
   if (fixed.zero) { szx = 0; szy = 0; }
   const bw = cell.width !== undefined ? cell.width : 0;
@@ -504,16 +504,16 @@ export const layoutHtmlTable = (
  * table, the returned `rv = 1` follows C on every call.
  * @see lib/common/htmltable.c:size_html_tbl (:1683, :1689)
  */
-const warnFixedTable = (tbl: HtmlTable, dims: { wd: number; ht: number }): number => {
+const warnFixedTable = (tbl: HtmlTable, dims: { wd: number; ht: number }, out: StderrLines | undefined): number => {
   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;
 };
 
@@ -525,7 +525,7 @@ const sizeTableBody = (
 ): number => {
   const { entries, widths, heights, spacing, border, rv } = layoutHtmlTable(tbl, measurer, env);
   if (entries.length === 0) {
-    const fixed = warnFixedTable(tbl, sumTableDims({ widths, heights, ncols: 0, nrows: 0, spacing, border }));
+    const fixed = warnFixedTable(tbl, sumTableDims({ widths, heights, ncols: 0, nrows: 0, spacing, border }), env.stderr);
     tbl.dimen = { w: 0, h: 0 };
     return rv | fixed;
   }
@@ -535,7 +535,7 @@ const sizeTableBody = (
   const { wd, ht } = sumTableDims({ widths, heights, ncols, nrows, spacing, border });
   const baseWd = tbl.width !== undefined ? tbl.width : 0;
   const baseHt = tbl.height !== undefined ? tbl.height : 0;
-  const fixed = warnFixedTable(tbl, { wd, ht });
+  const fixed = warnFixedTable(tbl, { wd, ht }, env.stderr);
   // C zeroes only the CONTENT-derived term for a FIXEDSIZE table that has BOTH
   // width and height, so the box becomes fmax(0, width)=width / fmax(0,height)=
   // height (the explicit size). A fixed table missing a dimension warns and

package/src/common/make-label.ts

@@ -12,7 +12,8 @@
 import type { TextlabelT } from './types.js';
 import type { TextMeasurer, TextSize } from './textmeasure.js';
 import type { TextSpan } from './emit-types.js';
-import { makeHtmlLabelRv } from './htmltable-pos.js';
+import { makeHtmlLabelTo } from './htmltable-label.js';
+import { labelStderr } from './htmltable-attr-warn.js';
 import { substObj, type GraphObj } from './subst.js';
 import { Edge } from '../model/edge.js';
 import { Graph } from '../model/graph.js';
@@ -205,8 +206,12 @@ export function makeAnyLabel(
     // it (htmltable.c:1911 getPenColor). @see getPenColor
     // ADR-2: a per-context sizer (when set) wins over the global one.
     const imageSizer = obj !== undefined ? rootOf(obj).info.gvc?.imageSizer : undefined;
-    const { label, rv } = makeHtmlLabelRv(content, { ...font, pencolor: getPenColor(obj), imageSizer }, measurer);
-    if (rv !== 0 && obj !== undefined) console.error(inLabelOf(obj));
+    // One stderr for the label: doInt's unterminated warning runs into the
+    // next write, `in label of ...` included (agerr AGPREV).
+    const stderr = labelStderr();
+    const { label, rv } = makeHtmlLabelTo(content, { ...font, pencolor: getPenColor(obj), imageSizer }, measurer, stderr);
+    if (rv !== 0 && obj !== undefined) stderr.write(`${inLabelOf(obj)}\n`);
+    stderr.flush();
     return label;
   }
   // Plain path: resolve \G \N \E \T \H \L against the owning object

package/src/common/poly-gencode.ts

@@ -22,7 +22,7 @@ import { FillType } from '../gvc/context.js';
 import { emitHtmlLabel } from './htmltable-emit.js';
 import { transformPoint } from '../gvc/device.js';
 import { nodeAttr } from './poly-init.js';
-import { substObjAnchor, interpretCRNL } from './subst.js';
+import { substObjAnchor, preprocessTooltip } from './subst.js';
 import type { ResolvedFill, PolyStyleFlags } from './style-resolve.js';
 import {
   parseStyleFlags,
@@ -245,7 +245,7 @@ function anchorAttr(n: Node, key: string): string | undefined {
 
 /** Resolve tooltip string: explicit attr, or fall back to label text. */
 function resolveTooltip(n: Node, tooltip: string | undefined): string {
-  if (tooltip !== undefined) return substObjAnchor(interpretCRNL(tooltip), n);
+  if (tooltip !== undefined) return substObjAnchor(preprocessTooltip(tooltip), n);
   const label = n.info.label as TextlabelT | undefined;
   return label?.text ?? '';
 }

package/src/common/subst.ts

@@ -14,6 +14,7 @@ import { Node } from '../model/node.js';
 import { Edge } from '../model/edge.js';
 import { Graph } from '../model/graph.js';
 import type { TextlabelT } from './types.js';
+import { htmlEntityUTF8 } from './html-entities.js';
 
 export type GraphObj = Node | Edge | Graph;
 
@@ -124,3 +125,14 @@ export function interpretCRNL(str: string): string {
   }
   return out;
 }
+
+/**
+ * Tooltip preprocessing: decode HTML entities to UTF-8, then interpret
+ * \n \l \r. C picks latin1ToUTF8 or htmlEntityUTF8 by GD_charset; both decode
+ * entities via htmlEntity, and the port's Latin-1 bytes are already decoded
+ * at input, so one branch serves both (as in make_label).
+ * @see lib/common/emit.c:preprocessTooltip
+ */
+export function preprocessTooltip(s: string): string {
+  return interpretCRNL(htmlEntityUTF8(s));
+}

package/src/gvc/anchor.ts

@@ -17,7 +17,7 @@ import type { Node } from '../model/node.js';
 import type { Point, Box, Spline, Bezier } from '../model/geom.js';
 import type { TextlabelT, PolygonT } from '../common/types.js';
 import type { GraphObj } from '../common/subst.js';
-import { substObjAnchor, interpretCRNL } from '../common/subst.js';
+import { substObjAnchor, preprocessTooltip } from '../common/subst.js';
 import { parseStyleFlags } from '../common/style-resolve.js';
 import { nodeAttr } from '../common/poly-init.js';
 import { bezier } from '../common/bezier.js';
@@ -36,12 +36,13 @@ function subst(s: string, obj: GraphObj): string {
 }
 
 /**
- * preprocessTooltip + strdup_and_subst_obj: interpret \n\l\r escapes, then
- * object substitution — matching the node tooltip path (poly-gencode.ts).
+ * preprocessTooltip + strdup_and_subst_obj: decode entities and interpret
+ * \n\l\r escapes, then object substitution — matching the node tooltip path
+ * (poly-gencode.ts).
  * @see lib/common/emit.c:preprocessTooltip
  */
 function tip(s: string, obj: GraphObj): string {
-  return substObjAnchor(interpretCRNL(s), obj);
+  return substObjAnchor(preprocessTooltip(s), obj);
 }
 
 /** Label text of a textlabel, or null. @see device.ts:labelTextOf */
@@ -71,7 +72,7 @@ function pickEdge(e: Edge, keys: string[]): Picked {
   return pickFirst(e.attrs, keys, (s) => subst(s, e));
 }
 
-/** pickFirst with tooltip preprocessing (interpretCRNL + subst). */
+/** pickFirst with tooltip preprocessing (preprocessTooltip + subst). */
 function pickEdgeTip(e: Edge, keys: string[]): Picked {
   return pickFirst(e.attrs, keys, (s) => tip(s, e));
 }

package/src/render/xml-escape.ts

@@ -1,29 +1,25 @@
 // SPDX-License-Identifier: EPL-2.0
 //
-// XML escaping faithful to graphviz's gv_xml_escape (lib/util/xml.c). '<', '>',
-// '"', and "'" are always escaped; '&' is escaped to &amp; only when it does
-// not begin a valid entity (&name; / &#NNN; / &#xHH;). The text/tooltip variant
-// additionally honors the {raw, dash, nbsp} flags used by the SVG plugin.
+// The SVG renderer's three gv_xml_escape flag sets (lib/util/xml.c), as presets
+// over the faithful port in util/xml.ts. '<', '>', '"' and "'" are always
+// escaped; '&' is escaped only when it does not begin an entity
+// (xml_isentity), except under raw, which escapes every '&'.
 
-// Regexes for quote chars: /"/g and /'/g break Lizard's quote-tracker.
-// Use these named patterns instead to avoid the parser bug.
-const RE_DQUOTE = new RegExp('"', 'g');
-const RE_SQUOTE = new RegExp("'", 'g');
-// A bare '&' that does NOT begin a valid entity (&name; / &#NNN; / &#xHH;).
-// Mirrors xml_isentity (lib/util/xml.c): only such '&' are escaped to &amp;.
-const RE_AMP_NONENTITY = /&(?![A-Za-z]+;|#[0-9]+;|#x[0-9A-Fa-f]+;)/g;
+import { gvXmlEscape, type XmlFlags } from '../util/xml.js';
+
+/** flags {0}. @see plugin/core/gvrender_core_svg.c:svg_begin_anchor (href) */
+const FLAGS_BASE: XmlFlags = { raw: false, dash: false, nbsp: false, utf8: false };
+/** gvputs_xml's flags. @see lib/gvc/gvdevice.c:gvputs_xml */
+const FLAGS_TITLE: XmlFlags = { raw: false, dash: true, nbsp: true, utf8: false };
+/** @see plugin/core/gvrender_core_svg.c:svg_textspan, svg_begin_anchor (tooltip) */
+const FLAGS_TEXT: XmlFlags = { raw: true, dash: true, nbsp: true, utf8: false };
 
 /**
- * Base XML escape (gv_xml_escape with flags {0}): ids, titles, hrefs.
- * @see lib/util/xml.c gv_xml_escape / xml_core / xml_isentity
+ * Base XML escape (gv_xml_escape with flags {0}): ids, hrefs.
+ * @see lib/util/xml.c:gv_xml_escape
  */
 export function escapeXml(s: string): string {
-  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);
 }
 
 /**
@@ -34,23 +30,17 @@ export function escapeXml(s: string): string {
  * @see lib/gvc/gvdevice.c:gvputs_xml, lib/util/xml.c:xml_core
  */
 export function escapeXmlTitle(s: string): string {
-  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);
 }
 
 /**
- * Text/tooltip XML escape (gv_xml_escape with flags {raw, dash, nbsp}):
- * additionally escapes '-'→&#45;, newline/CR→&#10;/&#13;, and 2nd+ consecutive
- * spaces→&#160;. Used for textspans and tooltips.
- * @see plugin/core/gvrender_core_svg.c:546 (svg_textspan flags)
+ * Text/tooltip XML escape (gv_xml_escape with flags {raw, dash, nbsp}): raw
+ * escapes every '&' -- entity-looking or not -- and newline/CR to
+ * &#10;/&#13;; also '-'→&#45; and 2nd+ consecutive spaces→&#160;. Used for
+ * textspans and xlink:title.
+ * @see plugin/core/gvrender_core_svg.c:svg_textspan, svg_begin_anchor
+ * @see lib/util/xml.c:xml_core (`flags.raw || !xml_isentity(s)`)
  */
 export function escapeXmlText(s: string): string {
-  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);
 }