@knowvah/dot-engine 2.6.4 → 2.6.5

package/dist/index.js

@@ -4317,6 +4317,179 @@ function numberAmbiguityMessage(a) {
   return `Warning: syntax ambiguity - badly delimited number '${a.text}' in line ${a.line} of input splits into two tokens`;
 }
 
+// src/parser/scan-token.ts
+var YY_BUF_SIZE = 16384;
+var STRING_STARTING_BYTES = 80;
+var ASCII_DEL2 = 127;
+function isLetter2(c) {
+  if (c === void 0) return false;
+  return c >= "A" && c <= "Z" || c >= "a" && c <= "z" || c === "_" || c.charCodeAt(0) > ASCII_DEL2;
+}
+function isDigit2(c) {
+  return c !== void 0 && c >= "0" && c <= "9";
+}
+function startsNumber2(s, i) {
+  const c = s[i];
+  if (isDigit2(c)) return true;
+  if (c === ".") return isDigit2(s[i + 1]);
+  if (c !== "-") return false;
+  return isDigit2(s[i + 1]) || s[i + 1] === "." && isDigit2(s[i + 2]);
+}
+function matchNumber2(s, i) {
+  let j = s[i] === "-" ? i + 1 : i;
+  if (s[j] === ".") {
+    j++;
+    while (isDigit2(s[j])) j++;
+  } else {
+    while (isDigit2(s[j])) j++;
+    if (s[j] === ".") {
+      j++;
+      while (isDigit2(s[j])) j++;
+    }
+  }
+  if (s[j] === "." || isLetter2(s[j])) j++;
+  return j;
+}
+function badlyDelimited(text) {
+  const c = text[text.length - 1];
+  const dot = text.indexOf(".");
+  return !isDigit2(c) && c !== "." || c === "." && dot !== text.length - 1;
+}
+function lineEnd(s, i) {
+  const nl = s.indexOf("\n", i);
+  return nl === -1 ? s.length : nl;
+}
+function directiveLine(text) {
+  const rest = text.slice(1).replace(/^line/, "");
+  const m = /^\s*([+-]?\d+)/.exec(rest);
+  if (m === null) return void 0;
+  const lineno = Number.parseInt(m[1], 10);
+  return lineno <= 0 ? void 0 : lineno - 1;
+}
+function qstringBuffer(body) {
+  return body.replace(/\\\\|\\"|\\\n/g, (m) => m === '\\"' ? '"' : m === "\\\n" ? "" : m);
+}
+function lexQuoted(s, i) {
+  for (let j = i + 1; j < s.length; j++) {
+    if (s[j] === "\\" && j + 1 < s.length) j++;
+    else if (s[j] === '"') return { kind: "token", end: j + 1, text: '"' };
+  }
+  return { kind: "open", state: "qstring", buffer: qstringBuffer(s.slice(i + 1)) };
+}
+function lexHtml(s, i) {
+  let nest = 1;
+  for (let j = i + 1; j < s.length; j++) {
+    if (s[j] === "<") nest++;
+    else if (s[j] === ">" && --nest === 0) return { kind: "token", end: j + 1, text: ">" };
+  }
+  return { kind: "open", state: "hstring", buffer: s.slice(i + 1) };
+}
+function lexComment(s, i) {
+  const close = s.indexOf("*/", i + 2);
+  if (close === -1) return { kind: "open", state: "comment", buffer: "" };
+  return { kind: "skip", end: close + 2 };
+}
+function lexHash(s, i) {
+  const end = lineEnd(s, i);
+  const atLineStart = i === 0 || s[i - 1] === "\n";
+  const line = atLineStart ? directiveLine(s.slice(i, end)) : void 0;
+  return line === void 0 ? { kind: "skip", end } : { kind: "skip", end, line };
+}
+function lexAtom(s, i) {
+  if (isLetter2(s[i])) {
+    let j2 = i + 1;
+    while (isLetter2(s[j2]) || isDigit2(s[j2])) j2++;
+    const text = s.slice(i, j2);
+    return text === "\uFEFF" ? { kind: "skip", end: j2 } : { kind: "token", end: j2, text };
+  }
+  if (s[i] === "-" && (s[i + 1] === "-" || s[i + 1] === ">")) {
+    return { kind: "token", end: i + 2, text: s.slice(i, i + 2) };
+  }
+  if (!startsNumber2(s, i)) return { kind: "token", end: i + 1, text: s[i] };
+  const j = matchNumber2(s, i);
+  const end = badlyDelimited(s.slice(i, j)) ? j - 1 : j;
+  return { kind: "token", end, text: s.slice(i, end) };
+}
+function lexTrivia(s, i) {
+  const c = s[i];
+  if (c === "\n" || c === " " || c === "	" || c === "\r") return { kind: "skip", end: i + 1 };
+  if (c === "#") return lexHash(s, i);
+  if (c !== "/") return void 0;
+  if (s[i + 1] === "*") return lexComment(s, i);
+  if (s[i + 1] === "/") return { kind: "skip", end: lineEnd(s, i) };
+  return void 0;
+}
+function lexStep(s, i) {
+  const trivia = lexTrivia(s, i);
+  if (trivia !== void 0) return trivia;
+  if (s[i] === '"') return lexQuoted(s, i);
+  if (s[i] === "<") return lexHtml(s, i);
+  return lexAtom(s, i);
+}
+function countNewlines(s, from, to) {
+  let n = 0;
+  for (let i = s.indexOf("\n", from); i !== -1 && i < to; i = s.indexOf("\n", i + 1)) n++;
+  return n;
+}
+var HEADER_KEYWORDS = ["strict", "graph", "digraph"];
+function isTruncatedHeaderKeyword(src, step, offset, seen) {
+  if (offset !== src.length || step.end !== offset || seen.length > 1) return false;
+  if (seen.length === 1 && seen[0].toLowerCase() !== "strict") return false;
+  const word = step.text.toLowerCase();
+  return HEADER_KEYWORDS.some((k) => k.length > word.length && k.startsWith(word));
+}
+function reachesOffset(src, step, offset, seen) {
+  if (step.end > offset) return true;
+  if (isTruncatedHeaderKeyword(src, step, offset, seen)) return true;
+  if (step.text !== "-" && step.text !== ".") return false;
+  return offset <= step.end + (step.text === "-" && src[step.end] === "." ? 1 : 0);
+}
+function scanAtError(src, offset) {
+  let line = 1;
+  let i = 0;
+  const seen = [];
+  while (i < src.length) {
+    const step = lexStep(src, i);
+    if (step.kind === "open") {
+      line += countNewlines(src, i, src.length);
+      return { state: step.state, text: "", line, buffer: step.buffer };
+    }
+    if (step.kind === "skip" && step.line !== void 0) line = step.line;
+    line += countNewlines(src, i, step.end);
+    if (step.kind === "token" && reachesOffset(src, step, offset, seen)) {
+      return { state: "INITIAL", text: step.text, line, buffer: "" };
+    }
+    if (step.kind === "token") seen.push(step.text);
+    i = step.end;
+  }
+  return { state: "INITIAL", text: "", line, buffer: "" };
+}
+function firstBytes(s) {
+  const bytes = new TextEncoder().encode(s);
+  if (bytes.length <= STRING_STARTING_BYTES) return s;
+  return new TextDecoder().decode(bytes.subarray(0, STRING_STARTING_BYTES));
+}
+function stateNote(at) {
+  const start = at.buffer.length > 0 ? firstBytes(at.buffer) : "";
+  switch (at.state) {
+    case "qstring":
+      return ` scanning a quoted string (missing endquote? longer than ${YY_BUF_SIZE}?)` + (start === "" ? "" : `
+String starting:"${start}`);
+    case "hstring":
+      return ` scanning a HTML string (missing '>'? bad nesting? longer than ${YY_BUF_SIZE}?)` + (start === "" ? "" : `
+String starting:<${start}`);
+    case "comment":
+      return ` scanning a /*...*/ comment (missing '*/? longer than ${YY_BUF_SIZE}?)`;
+    case "INITIAL":
+      return "";
+  }
+}
+function syntaxErrorMessage(src, offset) {
+  const at = scanAtError(src, offset);
+  const where = `Error: syntax error in line ${at.line}`;
+  return at.text === "" ? where + stateNote(at) : `${where} near '${at.text}'`;
+}
+
 // src/errors.ts
 var FRIENDLY_MESSAGES = {
   SYNTAX_ERROR: "There is a syntax error in the DOT source.",
@@ -4497,9 +4670,9 @@ var Stripper = class _Stripper {
    */
   static blankLine(src, i, out) {
     const n = src.length;
-    const width = src[i] === "#" ? 1 : 2;
-    out.push(" ".repeat(width));
-    i += width;
+    const width2 = src[i] === "#" ? 1 : 2;
+    out.push(" ".repeat(width2));
+    i += width2;
     while (i < n && src[i] !== "\n") {
       out.push(" ");
       i++;
@@ -4610,6 +4783,7 @@ function parse(src) {
     if (isPeggyError(err)) {
       const start = err.location.start;
       warnNumberAmbiguities(src, start.offset);
+      console.error(syntaxErrorMessage(src, start.offset));
       const code = err.found === null ? "SYNTAX_UNEXPECTED_EOF" : "SYNTAX_ERROR";
       throw new ParseError(
         err instanceof Error ? err.message : String(err),
@@ -4627,8 +4801,17 @@ function parse(src) {
     }
     throw err;
   }
+  try {
+    validateEdgeOperators(src, ast.directed);
+  } catch (err) {
+    const offset = err instanceof ParseError ? err.location.offset : void 0;
+    if (offset !== void 0) {
+      warnNumberAmbiguities(src, offset);
+      console.error(syntaxErrorMessage(src, offset));
+    }
+    throw err;
+  }
   warnNumberAmbiguities(src, src.length);
-  validateEdgeOperators(src, ast.directed);
   return buildFromAst(ast);
 }
 
@@ -8745,20 +8928,20 @@ function rect(x, y, w, h) {
 function dnaY(af) {
   return af[2].y + (af[0].y - af[3].y) / 2;
 }
-function nextV(af, seg2, sides) {
-  return seg2 + 1 < sides ? af[seg2 + 1] : af[0];
+function nextV(af, seg2, sides2) {
+  return seg2 + 1 < sides2 ? af[seg2 + 1] : af[0];
 }
-function interpolationPoints(af, sides, shape, rounded = false) {
+function interpolationPoints(af, sides2, shape, rounded = false) {
   let rbconst = RBCONST;
-  for (let seg2 = 0; seg2 < sides; seg2++) {
+  for (let seg2 = 0; seg2 < sides2; seg2++) {
     const p0 = af[seg2];
-    const p1 = nextV(af, seg2, sides);
+    const p1 = nextV(af, seg2, sides2);
     rbconst = Math.min(rbconst, Math.hypot(p1.x - p0.x, p1.y - p0.y) / 3);
   }
   const b = [];
-  for (let seg2 = 0; seg2 < sides; seg2++) {
+  for (let seg2 = 0; seg2 < sides2; seg2++) {
     const p0 = af[seg2];
-    const p1 = nextV(af, seg2, sides);
+    const p1 = nextV(af, seg2, sides2);
     let t = rbconst / Math.hypot(p1.x - p0.x, p1.y - p0.y);
     if (shape === BOX3D || shape === COMPONENT) t /= 3;
     else if (shape === DOGEAR) t /= 2;
@@ -8795,28 +8978,28 @@ function drawCds(af, b, coord, filled, ctx) {
   renderShapePolygon(D, coord, ctx, filled);
 }
 function drawDogear(af, b, coord, filled, ctx) {
-  const sides = af.length;
-  const D = new Array(sides + 1);
-  for (let seg2 = 1; seg2 < sides; seg2++) D[seg2] = af[seg2];
-  D[0] = b[3 * (sides - 1) + 4];
-  D[sides] = b[3 * (sides - 1) + 2];
+  const sides2 = af.length;
+  const D = new Array(sides2 + 1);
+  for (let seg2 = 1; seg2 < sides2; seg2++) D[seg2] = af[seg2];
+  D[0] = b[3 * (sides2 - 1) + 4];
+  D[sides2] = b[3 * (sides2 - 1) + 2];
   renderShapePolygon(D, coord, ctx, filled);
-  const s = sides - 1;
+  const s = sides2 - 1;
   const c0 = b[3 * s + 2];
   const c2 = vadd(b[3 * s + 4], vsub(c0, b[3 * s + 3]));
   renderShapePolyline([b[3 * s + 4], c2], coord, ctx);
   renderShapePolyline([c0, c2], coord, ctx);
 }
 function drawTab(af, b, coord, filled, ctx) {
-  const sides = af.length;
+  const sides2 = af.length;
   const w = { x: (b[3].x - b[4].x) / 3, y: (b[3].y - b[4].y) / 3 };
   const D = [af[0], b[2], vadd(b[2], w), vadd(b[3], w)];
-  for (let seg2 = 4; seg2 < sides + 2; seg2++) D.push(af[seg2 - 2]);
+  for (let seg2 = 4; seg2 < sides2 + 2; seg2++) D.push(af[seg2 - 2]);
   renderShapePolygon(D, coord, ctx, filled);
   renderShapePolyline([b[3], b[2]], coord, ctx);
 }
 function drawFolder(af, b, coord, filled, ctx) {
-  const sides = af.length;
+  const sides2 = af.length;
   const dx = af[0].x - b[1].x;
   const wy = (b[3].y - b[4].y) / 3;
   const D = [
@@ -8825,7 +9008,7 @@ function drawFolder(af, b, coord, filled, ctx) {
     { x: af[0].x - 2 * dx, y: af[0].y + wy },
     { x: af[0].x - 2.25 * dx, y: b[3].y }
   ];
-  for (let seg2 = 4; seg2 < sides + 3; seg2++) D.push(af[seg2 - 3]);
+  for (let seg2 = 4; seg2 < sides2 + 3; seg2++) D.push(af[seg2 - 3]);
   renderShapePolygon(D, coord, ctx, filled);
 }
 function drawBox3d(af, b, coord, filled, ctx) {
@@ -9175,10 +9358,10 @@ function drawRoundCorners(ring, coord, filled, ctx) {
   else if (ctx.rounded) roundedDraw(ring, coord, filled, ctx);
 }
 function diagonalsDraw(ring, coord, filled, ctx) {
-  const sides = ring.length;
-  const b = interpolationPoints(ring, sides, 0);
+  const sides2 = ring.length;
+  const b = interpolationPoints(ring, sides2, 0);
   renderShapePolygon(ring, coord, ctx, filled);
-  for (let seg2 = 0; seg2 < sides; seg2++) {
+  for (let seg2 = 0; seg2 < sides2; seg2++) {
     renderShapePolyline([b[3 * seg2 + 2], b[3 * seg2 + 4]], coord, ctx);
   }
 }
@@ -9186,10 +9369,10 @@ function roundedDraw(ring, coord, filled, ctx) {
   emitRoundedBezier(ring, coord, filled, ctx);
 }
 function emitRoundedBezier(ring, coord, filled, ctx) {
-  const sides = ring.length;
-  const b = interpolationPoints(ring, sides, 0, true);
+  const sides2 = ring.length;
+  const b = interpolationPoints(ring, sides2, 0, true);
   const pts = [];
-  for (let seg2 = 0; seg2 < sides; seg2++) {
+  for (let seg2 = 0; seg2 < sides2; seg2++) {
     pts.push(b[4 * seg2], b[4 * seg2 + 1], b[4 * seg2 + 1], b[4 * seg2 + 2], b[4 * seg2 + 2], b[4 * seg2 + 3]);
   }
   pts.push(pts[0], pts[1]);
@@ -9319,11 +9502,11 @@ function zeroFlags() {
   };
 }
 var FUNLIMIT = 64;
-function styleTokens(style) {
-  if (!style) return [];
+function styleTokens(style2) {
+  if (!style2) return [];
   const out = [];
   let fun = 0;
-  for (const raw of style.split(",")) {
+  for (const raw of style2.split(",")) {
     const token = raw.trim();
     if (token.length === 0) continue;
     if (fun === FUNLIMIT - 1) return [];
@@ -9357,11 +9540,11 @@ function firstSolidColor(raw) {
   const grad = parseGradientSpec(raw);
   return grad !== null ? grad[0] : raw;
 }
-function parseStyleFlags(style) {
+function parseStyleFlags(style2) {
   const flags = zeroFlags();
-  if (!style) return flags;
+  if (!style2) return flags;
   let fun = 0;
-  for (const raw of style.split(",")) {
+  for (const raw of style2.split(",")) {
     const token = raw.trim();
     if (token.length === 0) continue;
     if (fun === FUNLIMIT - 1) return zeroFlags();
@@ -9375,10 +9558,10 @@ function parseStyleFlags(style) {
   }
   return flags;
 }
-function styleHasInvisibleAlias(style) {
-  if (!style) return false;
+function styleHasInvisibleAlias(style2) {
+  if (!style2) return false;
   let fun = 0;
-  for (const raw of style.split(",")) {
+  for (const raw of style2.split(",")) {
     const token = raw.trim();
     if (token.length === 0) continue;
     if (fun === FUNLIMIT - 1) return false;
@@ -9433,9 +9616,9 @@ function findStopColor(colorlist) {
   const frac = seg0.hasFraction ? seg0.t : seg1.hasFraction ? 1 - seg1.t : 0;
   return { fillColor, stopColor, frac };
 }
-function parseAngle(gradientangle) {
-  if (!gradientangle || gradientangle.length === 0) return 0;
-  const v = parseInt(gradientangle, 10);
+function parseAngle(gradientangle2) {
+  if (!gradientangle2 || gradientangle2.length === 0) return 0;
+  const v = parseInt(gradientangle2, 10);
   return isFinite(v) ? v : 0;
 }
 function buildResolvedFill(rawColor, flags, angle) {
@@ -9540,9 +9723,9 @@ function htmlFillPenWidth() {
 function resetHtmlFillPenWidth() {
   htmlFillPen = 1;
 }
-function penTypeOf(style) {
-  if (style !== void 0 && style.includes("dashed")) return 1 /* Dashed */;
-  if (style !== void 0 && style.includes("dotted")) return 2 /* Dotted */;
+function penTypeOf(style2) {
+  if (style2 !== void 0 && style2.includes("dashed")) return 1 /* Dashed */;
+  if (style2 !== void 0 && style2.includes("dotted")) return 2 /* Dotted */;
   return 3 /* Solid */;
 }
 function withHtmlPaint(paint, job, drawFn) {
@@ -9573,13 +9756,13 @@ function applyHtmlFill(paint) {
   paintObj.gradientAngle = 0;
   paintObj.gradientFrac = 0;
 }
-function mkPts(b, border, pos) {
+function mkPts(b, border2, pos) {
   let llx = b.ll.x + pos.x;
   let lly = b.ll.y + pos.y;
   let urx = b.ur.x + pos.x;
   let ury = b.ur.y + pos.y;
-  if (border > 1) {
-    const delta2 = border / 2;
+  if (border2 > 1) {
+    const delta2 = border2 / 2;
     llx += delta2;
     lly += delta2;
     urx -= delta2;
@@ -9606,26 +9789,26 @@ function doSide(p, wd, ht, renderer, job) {
   renderer.polygon(pts, true, job);
 }
 function doBorder(spec, renderer, job) {
-  const { box, pos, border, color, sides, style } = spec;
-  htmlFillPen = border;
-  withHtmlPaint({ pen: color, penWidth: border, penStyle: style }, job, () => {
-    if (parseStyleFlags(style).rounded) {
-      emitRoundedBezier(mkPts(box, border, pos), { x: 0, y: 0 }, false, { renderer, job });
+  const { box, pos, border: border2, color, sides: sides2, style: style2 } = spec;
+  htmlFillPen = border2;
+  withHtmlPaint({ pen: color, penWidth: border2, penStyle: style2 }, job, () => {
+    if (parseStyleFlags(style2).rounded) {
+      emitRoundedBezier(mkPts(box, border2, pos), { x: 0, y: 0 }, false, { renderer, job });
       return;
     }
-    const effSides = sides !== void 0 ? sides & BORDER_MASK : 0;
+    const effSides = sides2 !== void 0 ? sides2 & BORDER_MASK : 0;
     if (effSides !== 0) {
-      const corners = mkPts(box, border, pos).map((p) => transformPoint(p, job));
+      const corners = mkPts(box, border2, pos).map((p) => transformPoint(p, job));
       emitSidedPolylines(effSides, corners, renderer, job);
     } else {
-      emitFullBoxBorder(box, pos, border, renderer, job);
+      emitFullBoxBorder(box, pos, border2, renderer, job);
     }
   });
 }
-function emitFullBoxBorder(box, pos, border, renderer, job) {
-  const b2 = border > 1 ? {
-    ll: { x: box.ll.x + border / 2, y: box.ll.y + border / 2 },
-    ur: { x: box.ur.x - border / 2, y: box.ur.y - border / 2 }
+function emitFullBoxBorder(box, pos, border2, renderer, job) {
+  const b2 = border2 > 1 ? {
+    ll: { x: box.ll.x + border2 / 2, y: box.ll.y + border2 / 2 },
+    ur: { x: box.ur.x - border2 / 2, y: box.ur.y - border2 / 2 }
   } : box;
   const pts = [
     { x: b2.ll.x + pos.x, y: b2.ll.y + pos.y },
@@ -9660,8 +9843,8 @@ var SIDES_TABLE = /* @__PURE__ */ new Map([
   [T, [[NE, NW]]],
   [L, [[NW, SW]]]
 ]);
-function emitSidedPolylines(sides, corners, renderer, job) {
-  const seqs = SIDES_TABLE.get(sides & BORDER_MASK);
+function emitSidedPolylines(sides2, corners, renderer, job) {
+  const seqs = SIDES_TABLE.get(sides2 & BORDER_MASK);
   if (seqs === void 0) return;
   for (const seq2 of seqs) {
     renderer.polyline(seq2.map((i) => corners[i]), job);
@@ -9819,10 +10002,10 @@ function bgFillPaint(ctx) {
   };
 }
 function emitBgFill(ctx) {
-  const { box, pos, border, renderer, job } = ctx;
+  const { box, pos, border: border2, renderer, job } = ctx;
   withHtmlPaint(bgFillPaint(ctx), job, () => {
     if (parseStyleFlags(ctx.style).rounded) {
-      emitRoundedBezier(mkPts(box, border, pos), { x: 0, y: 0 }, true, { renderer, job });
+      emitRoundedBezier(mkPts(box, border2, pos), { x: 0, y: 0 }, true, { renderer, job });
       return;
     }
     const pts = [
@@ -9887,9 +10070,9 @@ function emitHtmlImg(img, pos, renderer, job) {
   }
   renderer.usershape?.(img.src, b, job);
 }
-function htmlStyleInvisible(style) {
-  if (style === void 0) return false;
-  return style.split(/[ ,]+/).some((tok) => {
+function htmlStyleInvisible(style2) {
+  if (style2 === void 0) return false;
+  return style2.split(/[ ,]+/).some((tok) => {
     const t = tok.toUpperCase();
     return t === "INVIS" || t === "INVISIBLE";
   });
@@ -9963,6 +10146,218 @@ function emitHtmlLabel(placed, pos, renderer, job) {
   }
 }
 
+// src/common/htmltable-attr-warn.ts
+var accepted = (v) => ({ keep: v, text: [], warn: false });
+var ignored = (text) => ({ keep: void 0, text: [text], warn: true });
+var warning = (msg) => `Warning: ${msg}`;
+var lower = (s) => s.replace(/[A-Z]/g, (c) => c.toLowerCase());
+var accept = accepted;
+var STRTOL = /^[ \t\n\v\f\r]*([+-]?\d+)/;
+function doInt(v, s, min, max) {
+  const m = STRTOL.exec(v);
+  if (m === null) return ignored(warning(`Improper ${s} value ${v} - ignored`));
+  const b = Number(m[1]);
+  if (b > max) return ignored(warning(`${s} value ${v} > ${max} - too large - ignored`));
+  if (b < min) return ignored(warning(`${s} value ${v} < ${min} - too small - ignored`));
+  return accepted(v);
+}
+var intHandler = (s, min, max) => (v) => doInt(v, s, min, max);
+var UCHAR_MAX = 255;
+var SCHAR_MIN = -128;
+var SCHAR_MAX = 127;
+var INT8_MAX = 127;
+var USHRT_MAX = 65535;
+var GRADIENT_MAX = 360;
+var spanHandler = (s) => (v) => {
+  const r = doInt(v, s, 0, USHRT_MAX);
+  if (r.keep === void 0 || Number(STRTOL.exec(v)?.[1]) !== 0) return r;
+  return ignored(warning(`${s} value cannot be 0 - ignored
+`));
+};
+var wordsHandler = (words, what) => (v) => words.includes(lower(v)) ? accepted(v) : ignored(warning(`Illegal value ${v} for ${what} - ignored
+`));
+var starHandler = (what) => (v) => v.startsWith("*") ? accepted(v) : ignored(warning(`Unknown value ${v} for ${what} - ignored
+`));
+var valign = wordsHandler(["bottom", "top", "middle"], "VALIGN");
+var fixedsize = wordsHandler(["true", "false"], "FIXEDSIZE");
+var tableAlign = wordsHandler(["left", "right", "center"], "ALIGN");
+var brAlign = tableAlign;
+var cellAlign = wordsHandler(["left", "right", "text", "center"], "ALIGN in TD");
+var balign = wordsHandler(["left", "right", "center"], "BALIGN in TD");
+var SIDES_LETTERS = "ltrb";
+var sides = (v) => {
+  const text = [];
+  for (const b of new TextEncoder().encode(v)) {
+    if (SIDES_LETTERS.includes(lower(String.fromCharCode(b)))) continue;
+    const code = b > SCHAR_MAX ? b - 256 : b;
+    text.push(warning(`Unrecognized character '${String.fromCharCode(b)}' (${code}) in sides attribute
+`));
+  }
+  return { keep: v, text, warn: false };
+};
+var STYLE_WORDS = ["rounded", "radial", "solid", "invisible", "invis", "dotted", "dashed"];
+var STYLE_DELIM = " ,";
+function styleTokens2(v) {
+  const out = [];
+  const span = (from, member) => {
+    let i = from;
+    while (i < v.length && STYLE_DELIM.includes(v[i]) === member) i++;
+    return i;
+  };
+  let end = span(0, false);
+  out.push(v.slice(0, end));
+  while (end < v.length) {
+    const start = span(end, true);
+    end = span(start, false);
+    out.push(v.slice(start, end));
+  }
+  return out;
+}
+var style = (v) => {
+  const legal = [];
+  const text = [];
+  for (const tk of styleTokens2(v)) {
+    if (STYLE_WORDS.includes(lower(tk))) legal.push(tk);
+    else text.push(warning(`Illegal value ${tk} for STYLE - ignored
+`));
+  }
+  return { keep: legal.length > 0 ? legal.join(" ") : void 0, text, warn: text.length > 0 };
+};
+var border = intHandler("BORDER", 0, UCHAR_MAX);
+var cellpadding = intHandler("CELLPADDING", 0, UCHAR_MAX);
+var cellspacing = intHandler("CELLSPACING", SCHAR_MIN, SCHAR_MAX);
+var gradientangle = intHandler("GRADIENTANGLE", 0, GRADIENT_MAX);
+var height = intHandler("HEIGHT", 0, USHRT_MAX);
+var width = intHandler("WIDTH", 0, USHRT_MAX);
+var TBL_ITEMS = /* @__PURE__ */ new Map([
+  ["align", tableAlign],
+  ["bgcolor", accept],
+  ["border", border],
+  ["cellborder", intHandler("CELLBORDER", 0, INT8_MAX)],
+  ["cellpadding", cellpadding],
+  ["cellspacing", cellspacing],
+  ["color", accept],
+  ["columns", starHandler("COLUMNS")],
+  ["fixedsize", fixedsize],
+  ["gradientangle", gradientangle],
+  ["height", height],
+  ["href", accept],
+  ["id", accept],
+  ["port", accept],
+  ["rows", starHandler("ROWS")],
+  ["sides", sides],
+  ["style", style],
+  ["target", accept],
+  ["title", accept],
+  ["tooltip", accept],
+  ["valign", valign],
+  ["width", width]
+]);
+var CELL_ITEMS = /* @__PURE__ */ new Map([
+  ["align", cellAlign],
+  ["balign", balign],
+  ["bgcolor", accept],
+  ["border", border],
+  ["cellpadding", cellpadding],
+  ["cellspacing", cellspacing],
+  ["color", accept],
+  ["colspan", spanHandler("COLSPAN")],
+  ["fixedsize", fixedsize],
+  ["gradientangle", gradientangle],
+  ["height", height],
+  ["href", accept],
+  ["id", accept],
+  ["port", accept],
+  ["rowspan", spanHandler("ROWSPAN")],
+  ["sides", sides],
+  ["style", style],
+  ["target", accept],
+  ["title", accept],
+  ["tooltip", accept],
+  ["valign", valign],
+  ["width", width]
+]);
+var FONT_ITEMS = /* @__PURE__ */ new Map([
+  ["color", accept],
+  ["face", accept],
+  ["point-size", intHandler("POINT-SIZE", 0, UCHAR_MAX)]
+]);
+var IMG_ITEMS = /* @__PURE__ */ new Map([["scale", accept], ["src", accept]]);
+var BR_ITEMS = /* @__PURE__ */ new Map([["align", brAlign]]);
+var ELEMENTS = /* @__PURE__ */ new Map([
+  ["TABLE", { items: TBL_ITEMS, name: "<TABLE>" }],
+  ["TD", { items: CELL_ITEMS, name: "<TD>" }],
+  ["FONT", { items: FONT_ITEMS, name: "<FONT>" }],
+  ["IMG", { items: IMG_ITEMS, name: "<IMG>" }],
+  ["BR", { items: BR_ITEMS, name: "<BR>" }]
+]);
+function checkAttrs(tag, pairs) {
+  const el = ELEMENTS.get(tag);
+  const attrs = {};
+  const warnings = [];
+  let warn = false;
+  for (const [name, value] of pairs) {
+    const key = lower(name);
+    if (el === void 0) {
+      attrs[key] = value;
+      continue;
+    }
+    const handler = el.items.get(key);
+    if (handler === void 0) {
+      warnings.push(warning(`Illegal attribute ${name} in ${el.name} - ignored
+`));
+      warn = true;
+      continue;
+    }
+    const r = handler(value);
+    warnings.push(...r.text);
+    warn ||= r.warn;
+    if (r.keep !== void 0) attrs[key] = r.keep;
+  }
+  return { attrs, warnings, warn };
+}
+var StderrLines = class {
+  constructor(writeLine) {
+    this.writeLine = writeLine;
+  }
+  writeLine;
+  pending = "";
+  write(text) {
+    const parts = (this.pending + text).split("\n");
+    this.pending = parts.pop() ?? "";
+    for (const line of parts) this.writeLine(line);
+  }
+  flush() {
+    if (this.pending === "") return;
+    this.writeLine(this.pending);
+    this.pending = "";
+  }
+};
+
+// src/common/htmltable-parse-state.ts
+var peek = (s) => s.tokens[s.pos];
+var emitWarnings = (s, tok) => {
+  if (s.stderr === void 0 || s.emitted?.has(tok) === true) return;
+  s.emitted?.add(tok);
+  emitOutput(s, tok);
+};
+var emitOutput = (s, out) => {
+  for (const text of out.warnings ?? []) s.stderr?.write(text);
+  if (out.warn === true) s.warn = true;
+};
+var emitEof = (s) => {
+  if (s.stderr === void 0 || s.eof === void 0) return;
+  const out = s.eof;
+  delete s.eof;
+  emitOutput(s, out);
+};
+var consume = (s) => {
+  const t = s.tokens[s.pos];
+  s.pos++;
+  if (t !== void 0) emitWarnings(s, t);
+  return t;
+};
+
 // src/common/html-entities.ts
 var HTML_ENTITIES = {
   "AElig": 198,
@@ -10242,6 +10637,286 @@ function htmlEntityUTF8(s) {
   });
 }
 
+// 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 PARTIAL = { kind: "partial" };
+var INVALID = (offset) => ({ kind: "invalid", offset });
+var XML_NAME = /^[A-Za-z_:\u0080-\uFFFF][\w.:\u0080-\uFFFF-]*/;
+var isSpace = (c) => c !== void 0 && /\s/.test(c);
+function skipSpace(text, i) {
+  let j = i;
+  while (isSpace(text[j])) j++;
+  return j;
+}
+var byteLength = (s) => new TextEncoder().encode(s).length;
+function fedBytes(unit, isText) {
+  if (!isText) return byteLength(unit);
+  let text = unit.replace(/&([^;&<]*);/g, (m, name) => {
+    return name.length >= 2 && Object.hasOwn(HTML_ENTITIES, name) ? `&#${HTML_ENTITIES[name]};` : m;
+  });
+  if (text.endsWith("]")) text = `${text.slice(0, -1)}&#93;`;
+  return byteLength(text);
+}
+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 next = skipSpace(text, close + 1);
+  if (next === close + 1 && !">/".includes(text[next] ?? ">")) return INVALID(next);
+  return next;
+}
+function scanPair(text, i) {
+  const name = XML_NAME.exec(text.slice(i))?.[0];
+  if (name === void 0) return INVALID(i);
+  const eq = skipSpace(text, i + name.length);
+  if (eq >= text.length) return PARTIAL;
+  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;
+}
+function tagEdge(text, i) {
+  const c = text[i];
+  if (c === void 0) return PARTIAL;
+  if (c === ">") return COMPLETE_END(i + 1);
+  if (c !== "/") return void 0;
+  if (i + 1 >= text.length) return PARTIAL;
+  return text[i + 1] === ">" ? COMPLETE_END(i + 2) : void 0;
+}
+function scanAttributes(text, from) {
+  const seen = /* @__PURE__ */ new Set();
+  let dup;
+  let i = skipSpace(text, from);
+  for (; ; ) {
+    const edge = tagEdge(text, i);
+    if (edge?.kind === "complete") return COMPLETE_END(edge.end, dup);
+    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);
+    i = pair.next;
+  }
+}
+function scanName(text, at) {
+  const name = XML_NAME.exec(text.slice(at))?.[0];
+  if (name === void 0) return at >= text.length ? PARTIAL : INVALID(at);
+  return { next: at + name.length };
+}
+function scanStartTag(text, p) {
+  const name = scanName(text, p + 1);
+  if ("kind" in name) return name;
+  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);
+}
+function scanEndTag(text, p) {
+  const name = scanName(text, p + 2);
+  if ("kind" in name) return name;
+  const i = skipSpace(text, name.next);
+  if (i >= text.length) return PARTIAL;
+  return text[i] === ">" ? COMPLETE_END(i + 1) : INVALID(i);
+}
+function scanPi(text, p) {
+  const e = text.indexOf("?>", p + 2);
+  return e < 0 ? PARTIAL : COMPLETE_END(e + 2);
+}
+function scanDeclaration(text, p) {
+  const cdata = "<![CDATA[".startsWith(text.slice(p, p + 9));
+  if (!cdata && text.length - p >= 3) return INVALID(p + 2);
+  for (let i = p + 1; i < text.length; i++) {
+    if (text[i] === ">") return COMPLETE_END(i + 1);
+    if (text[i] === "<") return INVALID(i);
+  }
+  return PARTIAL;
+}
+function scanComment(text, p) {
+  for (let i = p + 4; i < text.length; i++) {
+    if (text[i] !== "-") continue;
+    if (i + 1 >= text.length) return PARTIAL;
+    if (text[i + 1] !== "-") continue;
+    if (i + 2 >= text.length) return PARTIAL;
+    return text[i + 2] === ">" ? COMPLETE_END(i + 3) : INVALID(i + 2);
+  }
+  return PARTIAL;
+}
+function scanMarkup(text, p) {
+  const rest = text.slice(p, p + 4);
+  if (rest === "<!--") return { scan: scanComment(text, p), kind: "comment" };
+  if (text.length - p < 4 && "<!--".startsWith(rest)) return { scan: PARTIAL, kind: "comment" };
+  if (rest.startsWith("<!-")) return { scan: INVALID(p + 3), kind: "comment" };
+  const c = text[p + 1];
+  if (c === "/") return { scan: scanEndTag(text, p), kind: "tag" };
+  if (c === "?") return { scan: scanPi(text, p), kind: "pi" };
+  if (c === "!") return { scan: scanDeclaration(text, p), kind: "tag" };
+  return { scan: scanStartTag(text, p), kind: "tag" };
+}
+function scanContent(text, base) {
+  const tokens = [];
+  let p = 0;
+  while (p < text.length) {
+    if (text[p] !== "<") {
+      const e = text.indexOf("<", p);
+      const end = e < 0 ? text.length : e;
+      tokens.push({ kind: "text", start: base + p, end: base + end });
+      p = end;
+      continue;
+    }
+    const { scan, kind } = scanMarkup(text, p);
+    if (scan.kind === "invalid") return { tokens, consumed: p, invalid: base + scan.offset };
+    if (scan.kind === "partial") return { tokens, consumed: p };
+    const tok = { kind, start: base + p, end: base + scan.end };
+    if (scan.dup !== void 0) tok.dup = base + scan.dup;
+    tokens.push(tok);
+    p = scan.end;
+  }
+  return { tokens, consumed: p };
+}
+var InputBuffer = class {
+  size = 0;
+  ptr = 0;
+  end = 0;
+  lastRequest = 0;
+  /** Bytes the last attempt could not consume; 0 once something was. */
+  hadBefore = 0;
+  /** `XML_GetBuffer(len)` then the append of `len` bytes. */
+  append(len) {
+    this.lastRequest = len;
+    if (len > this.size - this.end) {
+      const keep = Math.min(this.ptr, XML_CONTEXT_BYTES);
+      const needed = len + (this.end - this.ptr) + keep;
+      if (needed > this.size) {
+        let grown = this.size;
+        if (grown === 0) grown = INIT_BUFFER_SIZE;
+        do
+          grown *= 2;
+        while (grown < needed);
+        this.size = grown;
+      }
+      this.end = this.end - this.ptr + keep;
+      this.ptr = keep;
+    }
+    this.end += len;
+  }
+  /** Bytes between the read pointer and the end of the data. */
+  get have() {
+    return this.end - this.ptr;
+  }
+  /** `callProcessor`: is it worth re-reading the partial token now? */
+  get enough() {
+    const available = this.ptr - Math.min(this.ptr, XML_CONTEXT_BYTES) + (this.size - this.end);
+    return this.have >= 2 * this.hadBefore || this.lastRequest > available;
+  }
+  /** After an attempt that left `remaining` bytes unconsumed. */
+  consumedTo(remaining, madeProgress) {
+    this.hadBefore = madeProgress ? 0 : this.have;
+    this.ptr = this.end - remaining;
+  }
+};
+var ExpatFeed = class {
+  constructor(src) {
+    this.src = src;
+  }
+  src;
+  buffer = new InputBuffer();
+  heldStart = 0;
+  fedEnd = 0;
+  /** Start of the token expat still holds, or undefined when it holds nothing. */
+  get held() {
+    return this.heldStart < this.fedEnd ? this.heldStart : void 0;
+  }
+  /** One `XML_Parse(parser, src[start, end), nbytes, 0)`. */
+  feed(start, end, nbytes) {
+    this.buffer.append(nbytes);
+    this.fedEnd = end;
+    if (!this.buffer.enough) return { tokens: [] };
+    const text = this.src.slice(this.heldStart, end);
+    const scan = scanContent(text, this.heldStart);
+    if (scan.invalid !== void 0) {
+      return { tokens: scan.tokens, invalid: { message: XML_ERROR_INVALID_TOKEN, offset: scan.invalid } };
+    }
+    this.heldStart += scan.consumed;
+    this.buffer.consumedTo(byteLength(this.src.slice(this.heldStart, end)), scan.consumed > 0);
+    return { tokens: scan.tokens };
+  }
+};
+var XML_PREDEFINED_ENTITIES = /* @__PURE__ */ new Set(["lt", "gt", "amp", "quot", "apos"]);
+var ENTITY_NAME = /^[A-Za-z_:][\w.:-]*$/;
+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 (ENTITY_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 };
+}
+
+// src/common/htmltable-lex-units.ts
+var UNCLOSED_COMMENT = "Warning: Unclosed comment\n";
+var LABEL_CLOSED = "Warning: Label closed before end of HTML element\n";
+function eatComment(label, p) {
+  let depth = 1;
+  let s = p;
+  while (depth > 0 && s < label.length) {
+    const c = label[s++];
+    if (c === "<") depth++;
+    else if (c === ">") depth--;
+  }
+  if (depth === 0) s--;
+  const warnings = [];
+  if (s < label.length) {
+    const t = s - 2;
+    if (t < p || !label.startsWith("--", t)) warnings.push(UNCLOSED_COMMENT);
+  }
+  return { at: s, warnings };
+}
+function findNext(label, s) {
+  let t = s + 1;
+  const warnings = [];
+  let warn = false;
+  if (label[s] === "<") {
+    if (label.startsWith("!--", t)) {
+      const eaten = eatComment(label, t + 3);
+      t = eaten.at;
+      warnings.push(...eaten.warnings);
+      warn = eaten.warnings.length > 0;
+    } else {
+      while (t < label.length && label[t] !== ">") t++;
+    }
+    if (label[t] !== ">") {
+      warnings.push(LABEL_CLOSED);
+      warn = true;
+    } else {
+      t++;
+    }
+  } else {
+    t = s;
+    while (t < label.length && label[t] !== "<") t++;
+  }
+  return { end: t, warnings, warn };
+}
+
 // src/common/htmltable-lex.ts
 var KNOWN_TAGS = /* @__PURE__ */ new Set([
   "TABLE",
@@ -10268,15 +10943,15 @@ function checkTag(tag) {
   }
 }
 var isWs = (c) => c === " " || c === "	" || c === "\n" || c === "\r";
-function parseAttrs(raw) {
-  const out = {};
+function parseAttrPairs(raw) {
+  const out = [];
   let i = 0;
   while (i < raw.length) {
     while (isWs(raw[i])) i++;
     if (i >= raw.length) break;
     const m = /^[\w-]+/.exec(raw.slice(i));
     if (m === null) throw new HtmlParseError(raw.slice(i, i + 10));
-    const name = m[0].toLowerCase();
+    const name = m[0];
     i += m[0].length;
     while (isWs(raw[i])) i++;
     if (raw[i] !== "=") throw new HtmlParseError(name);
@@ -10286,7 +10961,7 @@ function parseAttrs(raw) {
     if (q !== '"' && q !== "'") throw new HtmlParseError(name);
     const end = raw.indexOf(q, i + 1);
     if (end < 0) throw new HtmlParseError(name);
-    out[name] = raw.slice(i + 1, end);
+    out.push([name, raw.slice(i + 1, end)]);
     i = end + 1;
   }
   return out;
@@ -10305,48 +10980,36 @@ function cleanText(raw) {
   const isKeep = (c) => c === " " || c === "	" || c === "\n" || c === "\r";
   return raw.replace(/[\x00-\x1f\x7f]/g, (c) => isKeep(c) ? c : "");
 }
-function scanText(src, start, tokens) {
-  let j = start;
-  while (j < src.length && src[j] !== "<") j++;
-  const clean = htmlEntityUTF8(cleanText(src.slice(start, j)));
-  if (clean.length > 0) tokens.push({ type: "text", value: clean });
-  return j;
+function textTokens(raw) {
+  const clean = htmlEntityUTF8(cleanText(raw));
+  return clean.length > 0 ? [{ type: "text", value: clean }] : [];
 }
-function scanTag(src, start, tokens) {
-  let j = start + 1;
-  while (j < src.length && src[j] !== ">") j++;
-  const inner = src.slice(start + 1, j).trim();
-  const next = j + 1;
-  if (inner.startsWith("!--")) return next;
-  if (inner.startsWith("/")) {
-    tokens.push(parseCloseToken(inner));
-    return next;
-  }
+function tagTokens(text) {
+  const inner = text.slice(1, -1).trim();
+  if (inner.startsWith("/")) return [parseCloseToken(inner)];
   if (inner.endsWith("/")) {
     const open = parseOpenToken(inner.slice(0, -1).trim());
-    tokens.push(open, { type: "close", tag: open.tag });
-    return next;
+    return [open, { type: "close", tag: open.tag }];
   }
-  tokens.push(parseOpenToken(inner));
-  return next;
+  return [parseOpenToken(inner)];
+}
+function openToken(tag, raw) {
+  const { attrs, warnings, warn } = checkAttrs(tag, parseAttrPairs(raw));
+  const tok = { type: "open", tag, attrs };
+  if (warnings.length > 0) tok.warnings = warnings;
+  if (warn) tok.warn = true;
+  return tok;
 }
 function parseOpenToken(inner) {
   const sp = inner.search(/\s/);
-  if (sp === -1) {
-    const tag2 = inner.toUpperCase();
-    checkTag(tag2);
-    return { type: "open", tag: normalizeTag(tag2), attrs: parseAttrs("") };
-  }
-  const tag = inner.slice(0, sp).toUpperCase();
+  const tag = (sp === -1 ? inner : inner.slice(0, sp)).toUpperCase();
   checkTag(tag);
-  return { type: "open", tag: normalizeTag(tag), attrs: parseAttrs(inner.slice(sp + 1)) };
+  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_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 SYNTAX_ERROR = "syntax error";
 var HtmlLexError = class extends HtmlParseError {
   diagnostics;
   constructor(tag, message, diagnostics) {
@@ -10378,112 +11041,131 @@ function htmlErrorAtToken(message, 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);
+function checkTagToken(site) {
+  const { src, tok, st } = site;
+  const tag = parseTagChunk(src.slice(tok.start, tok.end));
   if (tag === void 0) return;
+  const context = st.prev + st.curr;
   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);
+      throw htmlErrorInLine(XML_ERROR_TAG_MISMATCH, lineAt(src, tok.start), context);
     }
   } 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 (tok.dup !== void 0) throw htmlErrorInLine(XML_ERROR_DUPLICATE_ATTRIBUTE, lineAt(src, tok.dup), context);
     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)} `;
+  const text = `Unknown HTML element <${tag.name}> on line ${lineAt(src, tok.start)} `;
   throw new HtmlLexError(tag.name.toUpperCase(), text, [`Error: ${text}`]);
 }
-function checkChunk(src, start, st) {
-  if (st.curr.startsWith("<")) {
-    checkTagChunk(src, start, st);
-    return;
+function eventTokens(site) {
+  const { src, tok, st } = site;
+  const text = src.slice(tok.start, tok.end);
+  if (tok.kind === "comment" || tok.kind === "pi") return [];
+  if (tok.kind === "tag") {
+    checkTagToken(site);
+    return tagTokens(text);
   }
-  const off = findUndefinedEntity(st.curr);
+  const off = findUndefinedEntity(text);
   if (off >= 0) {
-    throw htmlErrorInLine(XML_ERROR_UNDEFINED_ENTITY, lineAt(src, start + off), st.prev + st.curr);
+    throw htmlErrorInLine(XML_ERROR_UNDEFINED_ENTITY, lineAt(src, tok.start + off), st.prev + st.curr);
+  }
+  return textTokens(text);
+}
+function attachCarry(carry, first) {
+  if (carry.warnings.length > 0) first.warnings = [...carry.warnings, ...first.warnings ?? []];
+  if (carry.warn) first.warn = true;
+  carry.warnings = [];
+  carry.warn = false;
+}
+function absorb(carry, lost) {
+  for (const t of lost) {
+    carry.warnings.push(...t.warnings ?? []);
+    if (t.warn === true) carry.warn = true;
+  }
+}
+function eventGroups(run, res) {
+  const groups = [];
+  for (const tok of res.tokens) {
+    const tokens = eventTokens({ src: run.src, tok, st: run.st });
+    if (tokens.length > 0) groups.push({ tokens, tok });
+  }
+  if (res.invalid !== void 0) {
+    const { message, offset } = res.invalid;
+    throw htmlErrorInLine(message, lineAt(run.src, offset), run.st.prev + run.st.curr);
+  }
+  return groups;
+}
+function deliver(run, last) {
+  const first = last.tokens[0];
+  attachCarry(run.carry, first);
+  const info = { src: run.src, pos: last.tok.start, end: last.tok.end, context: run.st.prev + run.st.curr };
+  const prev = run.tokens.at(-1);
+  if (prev?.type === "text" && first.type === "text") {
+    appendString(prev, first);
+    chunkInfo.set(prev, { ...info, pos: chunkInfo.get(prev)?.pos ?? info.pos });
+    return;
   }
+  for (const t of last.tokens) chunkInfo.set(t, info);
+  run.tokens.push(...last.tokens);
 }
-function tokenizeDeferred(src) {
-  const tokens = [];
-  const st = { stack: [], prev: "", curr: "" };
-  let i = 0;
+function runEvents(run, res) {
+  const groups = eventGroups(run, res);
+  const last = groups.pop();
+  for (const g of groups) absorb(run.carry, g.tokens);
+  if (last !== void 0) deliver(run, last);
+}
+function appendString(into, more) {
+  into.value += more.value;
+  if (more.warnings !== void 0) into.warnings = [...into.warnings ?? [], ...more.warnings];
+  if (more.warn === true) into.warn = true;
+}
+function* lexUnits(src, label) {
+  if (label.start > 0) yield { start: 0, end: label.start, warnings: [], warn: false };
+  const text = src.slice(label.start, label.end);
+  for (let at = 0; at < text.length; ) {
+    const u = findNext(text, at);
+    yield { start: label.start + at, end: label.start + u.end, warnings: u.warnings, warn: u.warn };
+    at = u.end;
+  }
+  if (label.end < src.length) yield { start: label.end, end: src.length, warnings: [], warn: false };
+}
+function unfinishedError(run, held) {
+  return htmlErrorInLine(SYNTAX_ERROR, lineAt(run.src, held), run.st.prev + run.st.curr);
+}
+var eofOutput = (carry) => {
+  if (carry.warnings.length === 0 && !carry.warn) return void 0;
+  return carry.warn ? { warnings: carry.warnings, warn: true } : { warnings: carry.warnings };
+};
+function tokenizeDeferred(src, label = { start: 0, end: src.length }) {
+  const run = {
+    src,
+    tokens: [],
+    st: { stack: [], prev: "", curr: "" },
+    expat: new ExpatFeed(src),
+    carry: { warnings: [], warn: false }
+  };
+  let error;
   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);
-    }
+    for (const u of lexUnits(src, label)) {
+      run.st.prev = run.st.curr;
+      run.st.curr = src.slice(u.start, u.end);
+      run.carry.warnings.push(...u.warnings);
+      if (u.warn) run.carry.warn = true;
+      const nbytes = fedBytes(run.st.curr, !run.st.curr.startsWith("<"));
+      runEvents(run, run.expat.feed(u.start, u.end, nbytes));
+    }
+    const held = run.expat.held;
+    if (held !== void 0) error = unfinishedError(run, held);
   } catch (e) {
-    if (e instanceof HtmlParseError) return { tokens, error: e };
-    throw e;
+    if (!(e instanceof HtmlParseError)) throw e;
+    error = e;
   }
-  return { tokens };
+  const result = { tokens: run.tokens };
+  if (error !== void 0) result.error = error;
+  const eof = eofOutput(run.carry);
+  if (eof !== void 0) result.eof = eof;
+  return result;
 }
 
 // src/common/htmltable-parse-attrs.ts
@@ -10523,15 +11205,9 @@ var parseSides = (v) => {
   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 parseGradientAngle = (v) => num(v);
+var parseColumns = (v) => v?.startsWith("*") === true ? true : void 0;
+var parseRows = (v) => v?.startsWith("*") === true ? true : void 0;
 var buildCell = (content, a) => ({
   kind: "cell",
   content,
@@ -10583,7 +11259,7 @@ var buildTable = (rows, a) => ({
   hrule: parseRows(a["rows"])
 });
 
-// src/common/htmltable-parse.ts
+// src/common/htmltable-parse-font.ts
 var definedOf = (s) => Object.fromEntries(
   Object.entries(s).filter(([, v]) => v !== void 0)
 );
@@ -10607,17 +11283,6 @@ 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];
-  s.pos++;
-  return t;
-};
 var isInlineTag = (tag) => ["B", "I", "U", "O", "S", "SUB", "SUP"].includes(tag);
 var inlineFontState = (tag, _attrs) => {
   const fs = {};
@@ -10630,6 +11295,35 @@ var inlineFontState = (tag, _attrs) => {
   if (tag === "SUP") fs.superscript = true;
   return fs;
 };
+var wrapperFont = (t, fontStack) => {
+  const font = fontStack[fontStack.length - 1] ?? {};
+  if (t.tag !== "FONT") return mergeFontState(font, inlineFontState(t.tag, t.attrs));
+  return mergeFontState(font, {
+    fontColor: t.attrs["color"],
+    fontFace: t.attrs["face"],
+    fontSize: num(t.attrs["point-size"])
+  });
+};
+var tableFont = (fontStack) => {
+  if (fontStack.length < 2) return void 0;
+  const { fontColor, fontFace, fontSize } = fontStack[fontStack.length - 1];
+  const font = {};
+  if (fontColor !== void 0) font.fontColor = fontColor;
+  if (fontFace !== void 0) font.fontFace = fontFace;
+  if (fontSize !== void 0) font.fontSize = fontSize;
+  return font;
+};
+
+// src/common/htmltable-parse.ts
+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) => {
+  if (tok !== void 0) emitWarnings(s, tok);
+  else emitEof(s);
+  return (tok === void 0 ? s.pending : htmlErrorAtToken(message, tok)) ?? new HtmlParseError(message);
+};
 var consumeClose = (s, tag) => {
   const nxt = peek(s);
   if (nxt === void 0) return;
@@ -10700,6 +11394,45 @@ var parseText = (s, fontStack) => {
   }
   return { kind: "text", items };
 };
+var FONTTABLE_TAGS = ["FONT", "B", "I", "U", "O"];
+var fontTableWrapper = (s) => {
+  const open = peek(s);
+  if (open?.type !== "open" || !FONTTABLE_TAGS.includes(open.tag)) return void 0;
+  let i = s.pos + 1;
+  while (s.tokens[i]?.type === "text") i++;
+  const next = s.tokens[i];
+  return next?.type === "open" && next.tag === "TABLE" ? open : void 0;
+};
+var skipStrings = (s) => {
+  let found = false;
+  for (let t = peek(s); t?.type === "text"; t = peek(s)) {
+    consume(s);
+    if (nonSpace(t.value)) found = true;
+  }
+  return found;
+};
+var parseFontTable = (s, open, fontStack) => {
+  consume(s);
+  fontStack.push(wrapperFont(open, fontStack));
+  const textBefore = skipStrings(s);
+  const tblTok = peek(s);
+  if (textBefore && tblTok !== void 0) throw parseError(s, tblTok, MSG_TEXT_BEFORE_TABLE);
+  const table = parseTable(s, fontStack);
+  const textAfter = skipStrings(s);
+  const close = peek(s);
+  if (close !== void 0 && textAfter) throw parseError(s, close, MSG_TEXT_AFTER_TABLE);
+  if (close?.type !== "close" || close.tag !== open.tag) throw parseError(s, close, MSG_SYNTAX_ERROR);
+  consume(s);
+  fontStack.pop();
+  return table;
+};
+var rejectTableAfterTag = (s, start) => {
+  const nxt = peek(s);
+  if (nxt?.type !== "open" || nxt.tag !== "TABLE") return;
+  if (s.tokens.slice(start, s.pos).some((t) => t.type !== "text")) {
+    throw parseError(s, nxt, MSG_SYNTAX_ERROR);
+  }
+};
 var parseImgContent = (s, t, cellAttrs) => {
   consume(s);
   const img = {
@@ -10721,6 +11454,7 @@ 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);
+  rejectTableAfterTag(s, start);
   if (txt.items.some((i) => i.text !== void 0 && nonSpace(i.text))) st.textNonSpace = true;
   st.kind = "text";
   return txt.items.length > 0 ? [txt] : [];
@@ -10737,7 +11471,13 @@ var scanCellImage = (s, t, cellAttrs, st) => {
   return [parseImgContent(s, t, cellAttrs)];
 };
 var scanCellItem = (s, t, cellAttrs, 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;
+  if (wrapper !== void 0) {
+    st.kind = "fonttable";
+    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 (st.kind === "image") throw parseError(s, t, MSG_SYNTAX_ERROR);
@@ -10840,7 +11580,10 @@ var parseTable = (s, fontStack) => {
   for (let t = peek(s); t !== void 0; t = peek(s)) {
     if (scanTableToken(s, t, fontStack, ts)) break;
   }
-  return buildTable(ts.rows, open.attrs);
+  const table = buildTable(ts.rows, open.attrs);
+  const font = tableFont(fontStack);
+  if (font !== void 0) table.font = font;
+  return table;
 };
 var parseTableRow = (s, fontStack, opts) => {
   const row = parseRow(s, fontStack);
@@ -10880,6 +11623,14 @@ var finishTableLabel = (s) => {
   if (nxt.type !== "close" || nxt.tag !== "HTML") throw parseError(s, nxt, MSG_SYNTAX_ERROR);
   consume(s);
 };
+var parseFontTableLabel = (s, open, fontStack) => {
+  const table = parseFontTable(s, open, fontStack);
+  const nxt = peek(s);
+  if (nxt === void 0) return { kind: "table", table };
+  if (nxt.type !== "close" || nxt.tag !== "HTML") throw parseError(s, nxt, MSG_SYNTAX_ERROR);
+  consume(s);
+  return { kind: "table", table };
+};
 var parseTableLabel = (s, fontStack) => {
   skipLeadingWs(s);
   const table = parseTable(s, fontStack);
@@ -10888,17 +11639,16 @@ var parseTableLabel = (s, fontStack) => {
 };
 var parseTextLabel = (s, fontStack) => {
   const texts = [];
+  const start = s.pos;
   const txt = parseText(s, fontStack);
   if (txt.items.length > 0) texts.push(txt);
   const nxt = peek(s);
   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");
+    rejectTableAfterTag(s, start);
+    throw parseError(s, nxt, MSG_TEXT_BEFORE_TABLE);
   }
-  if (nxt.type !== "close" || nxt.tag !== "HTML") throw parseError(s, nxt, MSG_SYNTAX_ERROR);
+  if (nxt.type !== "close" || nxt.tag !== "HTML" || s.pos === start) throw parseError(s, nxt, MSG_SYNTAX_ERROR);
   consume(s);
   return { kind: "text", texts };
 };
@@ -10906,23 +11656,38 @@ var parseTokens = (s) => {
   const fontStack = [{}];
   const htmlOpen = consume(s);
   if (htmlOpen.type !== "open" || htmlOpen.tag !== "HTML") throw new HtmlParseError("HTML");
+  const wrapper = fontTableWrapper(s);
+  if (wrapper !== void 0) return parseFontTableLabel(s, wrapper, fontStack);
   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;
+var parseHtmlLabelRv = (src, writeLine = (line) => console.warn(line)) => {
+  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
+  };
   try {
-    label = parseTokens(s);
+    const label = parseTokens(s);
+    if (error !== void 0) throw error;
+    return { label, warn: s.warn === true };
   } catch (e) {
-    if (error !== void 0 && s.pos >= tokens.length) throw error;
+    if (error !== void 0 && s.pos >= tokens.length) {
+      emitEof(s);
+      throw error;
+    }
     throw e;
+  } finally {
+    s.stderr?.flush();
   }
-  if (error !== void 0) throw error;
-  return label;
 };
+var parseHtmlLabel = (src) => parseHtmlLabelRv(src, () => void 0).label;
 
 // src/gvc/usershape.ts
 var activeSizer = null;
@@ -10987,6 +11752,41 @@ var PointSet = class {
   }
 };
 
+// src/common/htmltable-fontinfo.ts
+var SIZE_SAVEF = { fontsize: 0 };
+var EMIT_SAVEF = { fontsize: 0 };
+var pushFontInfo = (env, fp, savp) => {
+  if (fp.fontFace !== void 0) {
+    savp.fontname = env.fontname;
+    env.fontname = fp.fontFace;
+  } else savp.fontname = void 0;
+  if (env.fontcolor !== void 0) {
+    if (fp.fontColor !== void 0) {
+      savp.fontcolor = env.fontcolor;
+      env.fontcolor = fp.fontColor;
+    } else savp.fontcolor = void 0;
+  }
+  if (env.fontsize >= 0) {
+    if (fp.fontSize !== void 0 && fp.fontSize >= 0) {
+      savp.fontsize = env.fontsize;
+      env.fontsize = fp.fontSize;
+    } else savp.fontsize = -1;
+  }
+};
+var popFontInfo = (env, savp) => {
+  if (savp.fontname !== void 0) env.fontname = savp.fontname;
+  if (savp.fontcolor !== void 0) env.fontcolor = savp.fontcolor;
+  if (savp.fontsize >= 0) env.fontsize = savp.fontsize;
+};
+var withTableFont = (env, font, slot, fn) => {
+  if (font === void 0) return fn();
+  const savp = slot === "size" ? SIZE_SAVEF : EMIT_SAVEF;
+  pushFontInfo(env, font, savp);
+  const r = fn();
+  popFontInfo(env, savp);
+  return r;
+};
+
 // src/common/htmltable.ts
 var DEFAULT_BORDER = 1;
 var DEFAULT_CELLPADDING = 2;
@@ -11012,7 +11812,7 @@ var findCol = (ps, row, startCol, colspan, rowspan) => {
   }
   return col;
 };
-var DEFAULT_SIZE_ENV = { fontsize: DEFAULT_FONTSIZE, fontname: "" };
+var defaultSizeEnv = () => ({ fontsize: DEFAULT_FONTSIZE, fontname: "" });
 var itemFont = (item, env) => ({
   fs: item.fontSize !== void 0 ? item.fontSize : env.fontsize,
   face: item.fontFace !== void 0 ? item.fontFace : env.fontname
@@ -11075,7 +11875,7 @@ var htmlTextIsSimple = (texts, env) => {
   }
   return true;
 };
-var sizeTextContent = (texts, measurer, env = DEFAULT_SIZE_ENV) => {
+var sizeTextContent = (texts, measurer, env = defaultSizeEnv()) => {
   const lines = splitSizedLines(texts, measurer, env);
   const simple = htmlTextIsSimple(texts, env);
   let w = 0;
@@ -11244,18 +12044,18 @@ var sumTableDims = (a) => {
   for (let i = 0; i < a.nrows; i++) ht += a.heights[i];
   return { wd, ht };
 };
-var layoutHtmlTable = (tbl, measurer, env = DEFAULT_SIZE_ENV) => {
+var layoutHtmlTable = (tbl, measurer, env = defaultSizeEnv()) => {
   const spacing = getSpacing(tbl);
-  const border = getBorder(tbl);
+  const border2 = getBorder(tbl);
   const { entries, rv } = buildLayouts(tbl, measurer, env);
   if (entries.length === 0) {
-    return { entries, widths: [], heights: [], spacing, border, rv };
+    return { entries, widths: [], heights: [], spacing, border: border2, 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, rv };
+  return { entries, widths, heights, spacing, border: border2, rv };
 };
 var warnFixedTable = (tbl, dims) => {
   const warn = !sizeWarned.has(tbl);
@@ -11269,17 +12069,17 @@ var warnFixedTable = (tbl, dims) => {
   if (warn) console.warn(WARN_TABLE_UNSPECIFIED);
   return 1;
 };
-var sizeTableInner = (tbl, measurer, env) => {
-  const { entries, widths, heights, spacing, border, rv } = layoutHtmlTable(tbl, measurer, env);
+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 }));
+    const fixed2 = warnFixedTable(tbl, sumTableDims({ widths, heights, ncols: 0, nrows: 0, spacing, border: border2 }));
     tbl.dimen = { w: 0, h: 0 };
     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));
   for (const e of entries) e.cell.dimen = { w: e.w, h: e.h };
-  const { wd, ht } = sumTableDims({ widths, heights, ncols, nrows, spacing, border });
+  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 });
@@ -11290,7 +12090,8 @@ var sizeTableInner = (tbl, measurer, env) => {
   };
   return rv | fixed;
 };
-var sizeHtmlLabel = (label, measurer, env = DEFAULT_SIZE_ENV) => {
+var sizeTableInner = (tbl, measurer, env) => withTableFont(env, tbl.font, "size", () => sizeTableBody(tbl, measurer, env));
+var sizeHtmlLabel = (label, measurer, env = defaultSizeEnv()) => {
   if (label.kind === "table") {
     const rv = sizeTableInner(label.table, measurer, env);
     label.dimen = label.table.dimen;
@@ -16142,8 +16943,8 @@ function normalizeFontName(name) {
   for (let i = 0; i < name.length; i++) {
     const ch = name[i];
     const code = ch.charCodeAt(0);
-    const isLetter2 = code >= 65 && code <= 90 || code >= 97 && code <= 122;
-    if (isLetter2) result += ch.toLowerCase();
+    const isLetter3 = code >= 65 && code <= 90 || code >= 97 && code <= 122;
+    if (isLetter3) result += ch.toLowerCase();
   }
   return result;
 }
@@ -16223,30 +17024,30 @@ function fontFamilyAttrs(fontName, mode = FontnameKind.NativeFonts) {
   if (a === null) return null;
   let family;
   let weight;
-  let style;
+  let style2;
   switch (mode) {
     case FontnameKind.PsFonts:
       family = a.name;
       weight = a.weight;
-      style = a.style;
+      style2 = a.style;
       break;
     case FontnameKind.SvgFonts:
       family = a.svgFontFamily;
       weight = a.svgFontWeight;
-      style = a.svgFontStyle;
+      style2 = a.svgFontStyle;
       break;
     default:
       family = a.family;
       weight = a.weight;
-      style = a.style;
+      style2 = a.style;
       break;
   }
   const fam = a.svgFontFamily !== family ? family + "," + a.svgFontFamily : family;
   let attrs = ' font-family="' + fam + '"';
   if (weight !== null) attrs += ' font-weight="' + weight + '"';
   if (a.stretch !== null) attrs += ' font-stretch="' + a.stretch + '"';
-  if (style !== null) attrs += ' font-style="' + style + '"';
-  return { attrs, weight: weight !== null, style: style !== null };
+  if (style2 !== null) attrs += ' font-style="' + style2 + '"';
+  return { attrs, weight: weight !== null, style: style2 !== null };
 }
 
 // src/common/css-font.ts
@@ -16635,8 +17436,8 @@ function alignContentBox(box, cell2, w, h) {
 var HTML_ALL_SIDES = TOP | BOTTOM | LEFT | RIGHT;
 function placeCellRuns(ctx) {
   const { cell: cell2, tbl, box, finfo, measurer } = ctx;
-  const border = cellBorder(cell2, tbl);
-  const inset = border + cellPad(cell2, tbl);
+  const border2 = cellBorder(cell2, tbl);
+  const inset = border2 + cellPad(cell2, tbl);
   const cbox = {
     ll: { x: box.ll.x + inset, y: box.ll.y + inset },
     ur: { x: box.ur.x - inset, y: box.ur.y - inset }
@@ -16685,17 +17486,17 @@ function placeCellNested(ctx) {
     ll: { x: box.ll.x + inset, y: box.ll.y + inset },
     ur: { x: box.ur.x - inset, y: box.ur.y - inset }
   };
-  return posHtmlTable(nested2, finfo, measurer, cbox, sidesMask);
+  return withTableFont(finfo, nested2.font, "emit", () => posHtmlTable(nested2, finfo, measurer, cbox, sidesMask));
 }
 function placeCell(ctx) {
   const { cell: cell2, tbl, box, col, row, colspan, rowspan } = ctx;
-  const border = cellBorder(cell2, tbl);
+  const border2 = cellBorder(cell2, tbl);
   const vruled = cell2.vruled;
   const nested2 = placeCellNested(ctx);
   const image = nested2 === void 0 ? placeCellImage(cell2, tbl, box) : void 0;
   return {
     box,
-    border,
+    border: border2,
     lines: nested2 === void 0 ? placeCellRuns(ctx) : [],
     image,
     nested: nested2,
@@ -16725,18 +17526,18 @@ function distributeExtra(sizes, del, count) {
   const plus = r >= 0 ? Math.floor(r + 0.5) : Math.ceil(r - 0.5);
   return sizes.map((w, i) => w + extra + (i < plus ? 1 : 0));
 }
-function buildColX(pos, border, spacing, widths) {
+function buildColX(pos, border2, spacing, widths) {
   const colX = [];
-  let x = pos.ll.x + border + spacing;
+  let x = pos.ll.x + border2 + spacing;
   for (let i = 0; i < widths.length; i++) {
     colX[i] = x;
     x += widths[i] + spacing;
   }
   return colX;
 }
-function buildRowY(pos, border, spacing, heights) {
+function buildRowY(pos, border2, spacing, heights) {
   const rowY = [];
-  let y = pos.ur.y - border - spacing;
+  let y = pos.ur.y - border2 - spacing;
   for (let i = 0; i < heights.length; i++) {
     rowY[i] = y;
     y -= heights[i] + spacing;
@@ -16756,14 +17557,14 @@ function tblDecoration(tbl) {
     gradientangle: tbl.gradientangle
   };
 }
-function cellSidesMask(e, ncols, nrows, sides) {
-  if (sides === 0) return 0;
+function cellSidesMask(e, ncols, nrows, sides2) {
+  if (sides2 === 0) return 0;
   let mask = 0;
   if (e.col === 0) mask |= LEFT;
   if (e.row === 0) mask |= TOP;
   if (e.col + e.colspan === ncols) mask |= RIGHT;
   if (e.row + e.rowspan === nrows) mask |= BOTTOM;
-  return sides & mask;
+  return sides2 & mask;
 }
 function ruledBoundaries(tbl) {
   const bits = /* @__PURE__ */ new Set();
@@ -16773,7 +17574,7 @@ function ruledBoundaries(tbl) {
   return bits;
 }
 function placeCells(ctx) {
-  const { tbl, entries, colX, rowY, spacing, ncols, nrows, sides, finfo, measurer } = ctx;
+  const { tbl, entries, colX, rowY, spacing, ncols, nrows, sides: sides2, finfo, measurer } = ctx;
   const boundaries = ruledBoundaries(tbl);
   return entries.map((e) => {
     const box = {
@@ -16790,19 +17591,19 @@ function placeCells(ctx) {
       row: e.row,
       colspan: e.colspan,
       rowspan: e.rowspan,
-      sidesMask: cellSidesMask(e, ncols, nrows, sides)
+      sidesMask: cellSidesMask(e, ncols, nrows, sides2)
     });
     if (boundaries.has(e.row + e.rowspan)) placed.hruled = true;
     return placed;
   });
 }
-function posHtmlTable(tbl, finfo, measurer, pos, sides = HTML_ALL_SIDES) {
+function posHtmlTable(tbl, finfo, measurer, pos, sides2 = HTML_ALL_SIDES) {
   const dim = tbl.dimen ?? { w: 0, h: 0 };
   const box = pos !== void 0 ? { ll: { ...pos.ll }, ur: { ...pos.ur } } : {
     ll: { x: -dim.w / 2, y: -dim.h / 2 },
     ur: { x: dim.w / 2, y: dim.h / 2 }
   };
-  const { entries, widths, heights, spacing, border } = layoutHtmlTable(tbl, measurer, {
+  const { entries, widths, heights, spacing, border: border2 } = layoutHtmlTable(tbl, measurer, {
     fontsize: finfo.fontsize,
     fontname: finfo.fontname
   });
@@ -16834,10 +17635,10 @@ function posHtmlTable(tbl, finfo, measurer, pos, sides = HTML_ALL_SIDES) {
       dely = 0;
     }
   }
-  const colX = buildColX(box, border, spacing, distributeExtra(widths, delx, ncols));
-  const rowY = buildRowY(box, border, spacing, distributeExtra(heights, dely, nrows));
-  const cells = placeCells({ tbl, entries, colX, rowY, spacing, ncols, nrows, sides, finfo, measurer });
-  return { box, border, cells, spacing, columnCount: ncols, rowCount: nrows, port: tbl.port, boundarySides: sides, ...tblDecoration(tbl) };
+  const colX = buildColX(box, border2, spacing, distributeExtra(widths, delx, ncols));
+  const rowY = buildRowY(box, border2, spacing, distributeExtra(heights, dely, nrows));
+  const cells = placeCells({ tbl, entries, colX, rowY, spacing, ncols, nrows, sides: sides2, finfo, measurer });
+  return { box, border: border2, cells, spacing, columnCount: ncols, rowCount: nrows, port: tbl.port, boundarySides: sides2, ...tblDecoration(tbl) };
 }
 function posTextLabel(label, finfo, measurer) {
   const dim = label.dimen ?? { w: 0, h: 0 };
@@ -16864,21 +17665,22 @@ function posTextLabel(label, finfo, measurer) {
   };
 }
 function posHtmlLabel(label, finfo, measurer) {
-  if (label.kind === "table") return posHtmlTable(label.table, finfo, measurer);
+  const env = { ...finfo };
+  if (label.kind === "table") return withTableFont(env, label.table.font, "emit", () => posHtmlTable(label.table, env, measurer));
   return posTextLabel(label, finfo, measurer);
 }
 var HTML_PARSE_FATAL = 3;
 function makeHtmlLabelRv(content, finfo, measurer) {
   const { fontname, fontsize, fontcolor, imageSizer, pencolor } = finfo;
-  let lbl;
+  let lbl, lexWarn;
   try {
-    lbl = parseHtmlLabel(content);
+    ({ label: lbl, warn: lexWarn } = parseHtmlLabelRv(content));
   } 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);
-  const rv = sizeHtmlLabel(lbl, measurer, {
+  const rv = Number(lexWarn) | sizeHtmlLabel(lbl, measurer, {
     fontsize,
     fontname,
     imageSizer
@@ -17228,7 +18030,7 @@ function starRings(box, peripheries) {
   return rings.flat();
 }
 function computeVertices(poly, w, h, base) {
-  const sides = poly.sides;
+  const sides2 = poly.sides;
   if (poly.option.fixedshape && base !== void 0) {
     w = base.w;
     h = base.h;
@@ -17236,10 +18038,10 @@ function computeVertices(poly, w, h, base) {
   if (poly.option.shape === CYLINDER) return cylinderVertices(w, h);
   const peripheries = Math.max(poly.peripheries, 1);
   if (poly.option.shape === STAR) return starRings({ w, h, base }, peripheries);
-  if (sides <= 2) {
+  if (sides2 <= 2) {
     return ellipseRings(w, h, peripheries, poly.option.fixedshape ? base : void 0);
   }
-  if (sides === 4 && Math.abs(poly.orientation % 90) < 0.5 && poly.distortion === 0 && poly.skew === 0) {
+  if (sides2 === 4 && Math.abs(poly.orientation % 90) < 0.5 && poly.distortion === 0 && poly.skew === 0) {
     return boxRings(w, h, peripheries, poly.orientation, base);
   }
   return generalPolyRings(poly, { w, h, base }, peripheries);
@@ -17364,17 +18166,17 @@ function starSize(bb) {
 function cylinderSize(bb) {
   return { x: bb.x, y: bb.y * 1.375 };
 }
-function expandForShape(bb, sides, heightPts, valign) {
+function expandForShape(bb, sides2, heightPts, valign2) {
   const b = { x: bb.x, y: bb.y };
   const temp = b.y * SQRT2;
-  if (heightPts > temp && valign === "c") {
+  if (heightPts > temp && valign2 === "c") {
     b.x *= Math.sqrt(1 / (1 - (b.y / heightPts) ** 2));
   } else {
     b.x *= SQRT2;
     b.y = temp;
   }
-  if (sides > 2) {
-    const c = Math.cos(Math.PI / sides);
+  if (sides2 > 2) {
+    const c = Math.cos(Math.PI / sides2);
     b.x /= c;
     b.y /= c;
   }
@@ -17429,21 +18231,21 @@ function vertexExtents(verts) {
   }
   return { xmax, ymax };
 }
-function initBisector(verts, sides) {
+function initBisector(verts, sides2) {
   const R2 = verts[0];
   let Q = R2;
-  for (let j = 1; j < sides; j++) {
-    Q = verts[(sides - j) % sides];
+  for (let j = 1; j < sides2; j++) {
+    Q = verts[(sides2 - j) % sides2];
     if (Q.x !== R2.x || Q.y !== R2.y) break;
   }
   return { beta: Math.atan2(R2.y - Q.y, R2.x - Q.x), Qprev: Q, sinx: 0, cosx: 0 };
 }
-function bisectorOffset(verts, sides, i, st) {
+function bisectorOffset(verts, sides2, i, st) {
   const V = verts[i];
   if (V.x !== st.Qprev.x || V.y !== st.Qprev.y) {
     let R2 = V;
-    for (let j = 1; j < sides; j++) {
-      R2 = verts[(i + j) % sides];
+    for (let j = 1; j < sides2; j++) {
+      R2 = verts[(i + j) % sides2];
       if (R2.x !== V.x || R2.y !== V.y) break;
     }
     const alpha = st.beta;
@@ -17455,32 +18257,32 @@ function bisectorOffset(verts, sides, i, st) {
   }
   st.Qprev = V;
 }
-function polygonRingOffsets(verts, sides) {
-  const st = initBisector(verts, sides);
+function polygonRingOffsets(verts, sides2) {
+  const st = initBisector(verts, sides2);
   const out = [];
-  for (let i = 0; i < sides; i++) {
-    bisectorOffset(verts, sides, i, st);
+  for (let i = 0; i < sides2; i++) {
+    bisectorOffset(verts, sides2, i, st);
     out.push({ x: st.cosx, y: st.sinx });
   }
   return out;
 }
-function polygonOutlineRing(verts, sides, penwidth) {
-  const st = initBisector(verts, sides);
+function polygonOutlineRing(verts, sides2, penwidth) {
+  const st = initBisector(verts, sides2);
   const out = [];
   const k = penwidth / 2 / GAP;
-  for (let i = 0; i < sides; i++) {
-    bisectorOffset(verts, sides, i, st);
+  for (let i = 0; i < sides2; i++) {
+    bisectorOffset(verts, sides2, i, st);
     const V = verts[i];
     out.push({ x: V.x + k * st.cosx, y: V.y + k * st.sinx });
   }
   return out;
 }
-function polygonPeripheryBB(verts, sides, p, bb) {
-  const st = initBisector(verts, sides);
+function polygonPeripheryBB(verts, sides2, p, bb) {
+  const st = initBisector(verts, sides2);
   const out = { x: bb.x, y: bb.y };
   const outl = { x: bb.x, y: bb.y };
-  for (let i = 0; i < sides; i++) {
-    bisectorOffset(verts, sides, i, st);
+  for (let i = 0; i < sides2; i++) {
+    bisectorOffset(verts, sides2, i, st);
     const off = p.peripheries - 1;
     const V = verts[i];
     const P = { x: V.x + off * st.cosx, y: V.y + off * st.sinx };
@@ -17504,9 +18306,9 @@ function starVertexGen(bb) {
   }
   return { verts: starVertices(bb.x, bb.y), xmax: sz.x / 2, ymax: sz.y / 2 };
 }
-function polygonBB(bb, minSize, p, sides, isBox3) {
+function polygonBB(bb, minSize, p, sides2, isBox3) {
   const geom = {
-    sides,
+    sides: sides2,
     orientation: p.orientation,
     distortion: p.distortion,
     skew: p.skew
@@ -17523,7 +18325,7 @@ function polygonBB(bb, minSize, p, sides, isBox3) {
     v.x *= scalex;
     v.y *= scaley;
   }
-  return { ...polygonPeripheryBB(verts, isBox3 ? 4 : sides, p, nbb), base: nbb };
+  return { ...polygonPeripheryBB(verts, isBox3 ? 4 : sides2, p, nbb), base: nbb };
 }
 function gvNodesize(widthPts, heightPts, flip) {
   if (flip) return { lw: heightPts / 2, rw: heightPts / 2, ht: widthPts };
@@ -17548,7 +18350,7 @@ function applySizeConstraints(p, bb0, width0, height0) {
 function polySize(p) {
   const init = initialSizePts(p);
   const dimen = quantize(padLabelDimen(p.labelDimen, p.margin, p.isPlain), p.quantumIn);
-  const { sides, isBox: isBox3 } = effectiveShape(p);
+  const { sides: sides2, isBox: isBox3 } = effectiveShape(p);
   let bb = { x: dimen.x, y: dimen.y };
   if (isBox3) {
   } else if (p.optionShape === STAR) {
@@ -17556,13 +18358,13 @@ function polySize(p) {
   } else if (p.optionShape === CYLINDER) {
     bb = cylinderSize(bb);
   } else {
-    bb = expandForShape(bb, sides, init.height, labelValign(p));
+    bb = expandForShape(bb, sides2, init.height, labelValign(p));
   }
   const minBb = bb;
   const c = applySizeConstraints(p, bb, init.width, init.height);
   const penwidth = p.penwidth ?? 1;
   const hasOutline = penwidth > 0 || p.peripheries < 1;
-  const grown = sides < 3 ? { ...ellipsePeripheryBB(c.bb, p.peripheries, penwidth, hasOutline), base: c.bb } : polygonBB(c.bb, { x: c.width, y: c.height }, { ...p, penwidth, hasOutline }, sides, isBox3);
+  const grown = sides2 < 3 ? { ...ellipsePeripheryBB(c.bb, p.peripheries, penwidth, hasOutline), base: c.bb } : polygonBB(c.bb, { x: c.width, y: c.height }, { ...p, penwidth, hasOutline }, sides2, isBox3);
   const result = assembleResult(p, dimen, grown, c.fixedshape);
   return { ...result, ...labelSpace(p, dimen, c.bb, minBb, isBox3, c.fixedshape) };
 }
@@ -17582,10 +18384,10 @@ function labelSpace(p, dimen, bb, minBb, isBox3, fixedshape) {
   return { space: { x: spaceX, y: spaceY }, valign: labelValign(p) };
 }
 function effectiveShape(p) {
-  let sides = p.sides;
-  if (sides <= 2 && (p.distortion !== 0 || p.skew !== 0)) sides = 120;
-  const isBox3 = sides === 4 && Math.abs(p.orientation % 90) < 0.5 && p.distortion === 0 && p.skew === 0;
-  return { sides, isBox: isBox3 };
+  let sides2 = p.sides;
+  if (sides2 <= 2 && (p.distortion !== 0 || p.skew !== 0)) sides2 = 120;
+  const isBox3 = sides2 === 4 && Math.abs(p.orientation % 90) < 0.5 && p.distortion === 0 && p.skew === 0;
+  return { sides: sides2, isBox: isBox3 };
 }
 function labelValign(p) {
   const ll = p.labelloc?.[0];
@@ -17796,33 +18598,33 @@ function otherEdge(e) {
   elistAppend(e.tail.info.other, e);
 }
 
+// src/common/bezier.ts
+function bezier(v, t, left2, right2) {
+  const degree = 3;
+  const u = 1 - t;
+  const tri = [[v[0], v[1], v[2], v[3]]];
+  for (let i = 1; i <= degree; i++) {
+    const prev = tri[i - 1];
+    const row = [];
+    for (let j = 0; j <= degree - i; j++) {
+      row.push({
+        x: fma(prev[j].x, u, t * prev[j + 1].x),
+        y: fma(prev[j].y, u, t * prev[j + 1].y)
+      });
+    }
+    tri.push(row);
+  }
+  if (left2 !== null) for (let j = 0; j <= degree; j++) left2[j] = tri[j][0];
+  if (right2 !== null) for (let j = 0; j <= degree; j++) right2[j] = tri[degree - j][j];
+  return tri[degree][0];
+}
+
 // src/common/splines-geom.ts
 function approxEqPt(p, q, tol) {
   const dx = p.x - q.x;
   const dy = p.y - q.y;
   return dx * dx + dy * dy < tol * tol;
 }
-function evalBezier(sp, t, left2, right2) {
-  const ab = { x: sp[0].x + t * (sp[1].x - sp[0].x), y: sp[0].y + t * (sp[1].y - sp[0].y) };
-  const bc = { x: sp[1].x + t * (sp[2].x - sp[1].x), y: sp[1].y + t * (sp[2].y - sp[1].y) };
-  const cd = { x: sp[2].x + t * (sp[3].x - sp[2].x), y: sp[2].y + t * (sp[3].y - sp[2].y) };
-  const abbc = { x: ab.x + t * (bc.x - ab.x), y: ab.y + t * (bc.y - ab.y) };
-  const bccd = { x: bc.x + t * (cd.x - bc.x), y: bc.y + t * (cd.y - bc.y) };
-  const pt = { x: abbc.x + t * (bccd.x - abbc.x), y: abbc.y + t * (bccd.y - abbc.y) };
-  if (left2 !== null) {
-    left2[0] = sp[0];
-    left2[1] = ab;
-    left2[2] = abbc;
-    left2[3] = pt;
-  }
-  if (right2 !== null) {
-    right2[0] = pt;
-    right2[1] = bccd;
-    right2[2] = cd;
-    right2[3] = sp[3];
-  }
-  return pt;
-}
 var HW = 2;
 var SMALL2 = 1e-10;
 function ptToLine2(a, b, p) {
@@ -17857,7 +18659,7 @@ function updateBbBz(bb, cp) {
   }
   const left2 = [];
   const right2 = [];
-  evalBezier(cp, 0.5, left2, right2);
+  bezier(cp, 0.5, left2, right2);
   updateBbBz(bb, left2);
   updateBbBz(bb, right2);
 }
@@ -17883,7 +18685,7 @@ function bezierClip(insideCtx, insideFn, sp, leftInside) {
   do {
     const opt = pt;
     const t = (high + low) / 2;
-    pt = evalBezier(sp, t, left2, right2);
+    pt = bezier(sp, t, left2, right2);
     if (insideFn(insideCtx, pt)) {
       if (leftInside) {
         low = t;
@@ -18280,15 +19082,10 @@ function arrowLengthTee(lenfact, arrowsize, penwidth) {
   if (extendStart > 0) length += extendEnd;
   return length;
 }
-var lerp = (a, b) => ({ x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 });
 function cubicHalf(c, rightHalf) {
-  const A3 = lerp(c[0], c[1]);
-  const B2 = lerp(c[1], c[2]);
-  const C6 = lerp(c[2], c[3]);
-  const D = lerp(A3, B2);
-  const E = lerp(B2, C6);
-  const M2 = lerp(D, E);
-  return rightHalf ? [M2, E, C6, c[3]] : [c[0], A3, D, M2];
+  const half = [];
+  bezier(c, 0.5, rightHalf ? null : half, rightHalf ? half : null);
+  return half;
 }
 function curveControlPoints(p, v, w, flag) {
   const AF0 = { x: p.x + v.x + w.x, y: p.y + v.y + w.y };
@@ -18561,29 +19358,11 @@ function arrowDrawOps(comps, tip2, dir, arrowsize, penwidth, rankdir = 0) {
 }
 
 // src/layout/dot/edge-route-clip.ts
-function deCasteljauTriangle(sp, t) {
-  const u = 1 - t;
-  const v = [
-    [sp[0], sp[1], sp[2], sp[3]],
-    [{ x: 0, y: 0 }, { x: 0, y: 0 }, { x: 0, y: 0 }, { x: 0, y: 0 }],
-    [{ x: 0, y: 0 }, { x: 0, y: 0 }, { x: 0, y: 0 }, { x: 0, y: 0 }],
-    [{ x: 0, y: 0 }, { x: 0, y: 0 }, { x: 0, y: 0 }, { x: 0, y: 0 }]
-  ];
-  for (let i = 1; i <= 3; i++) {
-    for (let j = 0; j <= 3 - i; j++) {
-      v[i][j] = {
-        x: u * v[i - 1][j].x + t * v[i - 1][j + 1].x,
-        y: u * v[i - 1][j].y + t * v[i - 1][j + 1].y
-      };
-    }
-  }
-  return v;
-}
 function bezierSubdivide(sp, t) {
-  const v = deCasteljauTriangle(sp, t);
-  const left2 = [v[0][0], v[1][0], v[2][0], v[3][0]];
-  const right2 = [v[3][0], v[2][1], v[1][2], v[0][3]];
-  return [left2, right2, v[3][0]];
+  const left2 = [];
+  const right2 = [];
+  const mid = bezier(sp, t, left2, right2);
+  return [left2, right2, mid];
 }
 function bisectStep(c, insideFn, leftInside, s) {
   const t = (s.high + s.low) / 2;
@@ -19214,10 +19993,10 @@ var SelfEdgeImpl = class _SelfEdgeImpl {
     const lbl = e.info.label;
     if (!lbl?.dimen) return 0;
     const flip = e.tail.root.info.flip === true;
-    const height = flip ? lbl.dimen.x : lbl.dimen.y;
-    lbl.pos = { x: a.x, y: a.y + a.sign * height / 2 };
+    const height2 = flip ? lbl.dimen.x : lbl.dimen.y;
+    lbl.pos = { x: a.x, y: a.y + a.sign * height2 / 2 };
     lbl.set = true;
-    return height;
+    return height2;
   }
   /** Place a left/right self-loop label; return the label width that governs
    *  the loop's widen. Under flip the label is rotated, so dimen.y is the
@@ -19226,10 +20005,10 @@ var SelfEdgeImpl = class _SelfEdgeImpl {
     const lbl = e.info.label;
     if (!lbl?.dimen) return 0;
     const flip = e.tail.root.info.flip === true;
-    const width = flip ? lbl.dimen.y : lbl.dimen.x;
-    lbl.pos = { x: a.x + a.sign * width / 2, y: a.y };
+    const width2 = flip ? lbl.dimen.y : lbl.dimen.x;
+    lbl.pos = { x: a.x + a.sign * width2 / 2, y: a.y };
     lbl.set = true;
-    return width;
+    return width2;
   }
   static bottomPts(a) {
     const { tp, hp, np, dx, dy, ty, hy } = a;
@@ -19559,11 +20338,11 @@ function processFlatEdge(g, u, e) {
   const isOrdered = nodeOrder(u) < nodeOrder(e.head);
   const t0 = isOrdered ? e.tail : e.head;
   const h0 = isOrdered ? e.head : e.tail;
-  const width = nodeRw(t0) + nodeLw(h0);
-  let m0 = Math.trunc(edgeMinlen(e) * nodesep + width);
+  const width2 = nodeRw(t0) + nodeLw(h0);
+  let m0 = Math.trunc(edgeMinlen(e) * nodesep + width2);
   const ex = findFastEdge(t0, h0);
   if (ex !== void 0) {
-    m0 = Math.trunc(Math.max(m0, width + nodesep + cround(edgeDist(e))));
+    m0 = Math.trunc(Math.max(m0, width2 + nodesep + cround(edgeDist(e))));
     ex.info.minlen = Math.max(ex.info.minlen ?? 1, m0);
     ex.info.weight = Math.max(ex.info.weight ?? 0, edgeWeight(e));
   } else if (!e.info.label) {
@@ -19618,9 +20397,9 @@ function selfWidth(u) {
 }
 function lrRankPair(g, r, u, v, last) {
   const nodesep = lrSep(g, r);
-  const width = nodeRw(u) + nodeLw(v) + nodesep;
-  makeAuxEdge(u, v, width, 0);
-  const next = Math.trunc(last + width);
+  const width2 = nodeRw(u) + nodeLw(v) + nodesep;
+  makeAuxEdge(u, v, width2, 0);
+  const next = Math.trunc(last + width2);
   v.info.rank = next;
   return next;
 }
@@ -22647,9 +23426,9 @@ function labelVnode(g, orig) {
   return v;
 }
 function incrWidth(g, v) {
-  const width = Math.floor((g.info.nodesep ?? 0) / 2);
-  v.info.lw = (v.info.lw ?? 0) + width;
-  v.info.rw = (v.info.rw ?? 0) + width;
+  const width2 = Math.floor((g.info.nodesep ?? 0) / 2);
+  v.info.lw = (v.info.lw ?? 0) + width2;
+  v.info.rw = (v.info.rw ?? 0) + width2;
 }
 function plainVnode(g) {
   const v = virtualNode(g);
@@ -23525,8 +24304,8 @@ function recSideMask(f, i, last) {
   if (i === 0) return i === last ? TOP2 | BOTTOM2 | RIGHT2 | LEFT2 : TOP2 | RIGHT2 | LEFT2;
   return i === last ? LEFT2 | BOTTOM2 | RIGHT2 : LEFT2 | RIGHT2;
 }
-function posReclbl(f, ul, sides) {
-  f.sides = sides;
+function posReclbl(f, ul, sides2) {
+  f.sides = sides2;
   f.b = {
     ll: { x: ul.x, y: ul.y - f.size.y },
     ur: { x: ul.x + f.size.x, y: ul.y }
@@ -23534,8 +24313,8 @@ function posReclbl(f, ul, sides) {
   const last = f.n_flds - 1;
   const pos = { x: ul.x, y: ul.y };
   for (let i = 0; i <= last; i++) {
-    const mask = sides ? recSideMask(f, i, last) : 0;
-    posReclbl(f.fld[i], { x: pos.x, y: pos.y }, sides & mask);
+    const mask = sides2 ? recSideMask(f, i, last) : 0;
+    posReclbl(f.fld[i], { x: pos.x, y: pos.y }, sides2 & mask);
     if (f.LR) pos.x += f.fld[i].size.x;
     else pos.y -= f.fld[i].size.y;
   }
@@ -24033,11 +24812,11 @@ function renderPolyRing(ring, coord, filled, j, ctx) {
   } else renderPolygon(ring, coord, ctx.renderer, ctx.job, filled);
 }
 function renderPeripheries(poly, coord, filled, ctx) {
-  const sides = poly.sides <= 2 ? 2 : poly.sides;
+  const sides2 = poly.sides <= 2 ? 2 : poly.sides;
   const verts = poly.vertices;
   for (let j = 0; j < poly.peripheries; j++) {
-    const ring = verts.slice(j * sides, (j + 1) * sides);
-    if (ring.length < sides) break;
+    const ring = verts.slice(j * sides2, (j + 1) * sides2);
+    if (ring.length < sides2) break;
     const ringFilled = j === 0 ? filled : false;
     if (poly.sides <= 2) {
       renderEllipseRing(ring, coord, ringFilled, j, ctx);
@@ -24186,12 +24965,12 @@ function resolveNodeDrawCtx(job, n) {
   };
   return { poly: drawPoly, coord, filled, ringCtx };
 }
-function specialCornerFlags(opt, style) {
+function specialCornerFlags(opt, style2) {
   return {
     shape: opt.shape,
-    diagonals: opt.diagonals || style.diagonals,
-    rounded: opt.rounded || style.rounded,
-    underline: opt.underline || style.underline
+    diagonals: opt.diagonals || style2.diagonals,
+    rounded: opt.rounded || style2.rounded,
+    underline: opt.underline || style2.underline
   };
 }
 function polyGencode(rawJob, rawNode) {
@@ -24264,22 +25043,22 @@ function insideScale(n, poly) {
     boxURy: oh / 2
   };
 }
-function polygonWalk(P, vertex, sides) {
+function polygonWalk(P, vertex, sides2) {
   const O = { x: 0, y: 0 };
   let i = 0;
-  let i1 = 1 % sides;
+  let i1 = 1 % sides2;
   const Q = vertex[i];
   const R2 = vertex[i1];
   if (!sameSide(P, O, Q, R2)) return false;
   const s = sameSide(P, Q, R2, O);
   if (s && sameSide(P, R2, O, Q)) return true;
-  for (let j = 1; j < sides; j++) {
+  for (let j = 1; j < sides2; j++) {
     if (s) {
       i = i1;
-      i1 = (i + 1) % sides;
+      i1 = (i + 1) % sides2;
     } else {
       i1 = i;
-      i = (i + sides - 1) % sides;
+      i = (i + sides2 - 1) % sides2;
     }
     if (!sameSide(P, O, vertex[i], vertex[i1])) return false;
   }
@@ -24321,15 +25100,15 @@ function starInside(ctx, p) {
   }
   const poly = n.info.shape_info;
   if (poly === void 0 || poly.vertices === null) return false;
-  const sides = poly.sides;
-  const outerStart = (Math.max(poly.peripheries, 1) - 1) * sides;
-  const outer = poly.vertices.slice(outerStart, outerStart + sides);
-  const ring = polygonOutlineRing(outer, sides, poly.penwidth ?? 1);
+  const sides2 = poly.sides;
+  const outerStart = (Math.max(poly.peripheries, 1) - 1) * sides2;
+  const outer = poly.vertices.slice(outerStart, outerStart + sides2);
+  const ring = polygonOutlineRing(outer, sides2, poly.penwidth ?? 1);
   const O = { x: 0, y: 0 };
   let outcnt = 0;
-  for (let i = 0; i < sides; i += 2) {
+  for (let i = 0; i < sides2; i += 2) {
     const Q = ring[i];
-    const R2 = ring[(i + 4) % sides];
+    const R2 = ring[(i + 4) % sides2];
     if (!sameSide(P, O, Q, R2)) outcnt++;
     if (outcnt === 2) return false;
   }
@@ -24475,7 +25254,7 @@ var DEFAULT_NODESEP = 0.25;
 var MIN_NODESEP = 0.02;
 var DEFAULT_RANKSEP = 0.5;
 var MIN_RANKSEP = 0.02;
-var UCHAR_MAX = 255;
+var UCHAR_MAX2 = 255;
 var CHAR_UTF8 = 0;
 var CHAR_LATIN1 = 1;
 var CHAR_BIG5 = 2;
@@ -24572,7 +25351,7 @@ function graphInit(g, useRankdir) {
     g.info.flip = false;
   }
   parseSepAttrs(g);
-  g.info.showboxes = Math.min(lateInt(g.attrs.get("showboxes"), 0, 0), UCHAR_MAX);
+  g.info.showboxes = Math.min(lateInt(g.attrs.get("showboxes"), 0, 0), UCHAR_MAX2);
   const fn = maptoken(g.attrs.get("fontnames"), FONTNAME_NAMES, fontnameCodes());
   if (fn !== -1) g.info.fontnames = fn;
   parseRatioDrawing(g);
@@ -24800,54 +25579,54 @@ function dirDefault(p) {
 function dirUnrecognized(p) {
   return { p, theta: 0, side: 0, constrain: false, clip: true, dyna: false, defined: false, rv: 1 };
 }
-function dirN(rest, b, ctr, sides) {
+function dirN(rest, b, ctr, sides2) {
   const base = { constrain: true, clip: false, dyna: false };
   switch (rest) {
     case "":
-      return { ...base, p: { x: ctr.x, y: b.ur.y }, theta: Math.PI * 0.5, side: sides & TOP, defined: true, rv: 0 };
+      return { ...base, p: { x: ctr.x, y: b.ur.y }, theta: Math.PI * 0.5, side: sides2 & TOP, defined: true, rv: 0 };
     case "e":
-      return { ...base, p: { x: b.ur.x, y: b.ur.y }, theta: Math.PI * 0.25, side: sides & (TOP | RIGHT), defined: true, rv: 0 };
+      return { ...base, p: { x: b.ur.x, y: b.ur.y }, theta: Math.PI * 0.25, side: sides2 & (TOP | RIGHT), defined: true, rv: 0 };
     case "w":
-      return { ...base, p: { x: b.ll.x, y: b.ur.y }, theta: Math.PI * 0.75, side: sides & (TOP | LEFT), defined: true, rv: 0 };
+      return { ...base, p: { x: b.ll.x, y: b.ur.y }, theta: Math.PI * 0.75, side: sides2 & (TOP | LEFT), defined: true, rv: 0 };
     default:
       return dirUnrecognized({ x: ctr.x, y: ctr.y });
   }
 }
-function dirS(rest, b, ctr, sides) {
+function dirS(rest, b, ctr, sides2) {
   const base = { constrain: true, clip: false, dyna: false };
   switch (rest) {
     case "":
-      return { ...base, p: { x: ctr.x, y: b.ll.y }, theta: -Math.PI * 0.5, side: sides & BOTTOM, defined: true, rv: 0 };
+      return { ...base, p: { x: ctr.x, y: b.ll.y }, theta: -Math.PI * 0.5, side: sides2 & BOTTOM, defined: true, rv: 0 };
     case "e":
-      return { ...base, p: { x: b.ur.x, y: b.ll.y }, theta: -Math.PI * 0.25, side: sides & (BOTTOM | RIGHT), defined: true, rv: 0 };
+      return { ...base, p: { x: b.ur.x, y: b.ll.y }, theta: -Math.PI * 0.25, side: sides2 & (BOTTOM | RIGHT), defined: true, rv: 0 };
     case "w":
-      return { ...base, p: { x: b.ll.x, y: b.ll.y }, theta: -Math.PI * 0.75, side: sides & (BOTTOM | LEFT), defined: true, rv: 0 };
+      return { ...base, p: { x: b.ll.x, y: b.ll.y }, theta: -Math.PI * 0.75, side: sides2 & (BOTTOM | LEFT), defined: true, rv: 0 };
     default:
       return dirUnrecognized({ x: ctr.x, y: ctr.y });
   }
 }
-function dirE(rest, b, ctr, sides) {
+function dirE(rest, b, ctr, sides2) {
   if (rest.length > 0) return dirUnrecognized(ctr);
-  return { p: { x: b.ur.x, y: ctr.y }, theta: 0, side: sides & RIGHT, constrain: true, clip: false, dyna: false, defined: true, rv: 0 };
+  return { p: { x: b.ur.x, y: ctr.y }, theta: 0, side: sides2 & RIGHT, constrain: true, clip: false, dyna: false, defined: true, rv: 0 };
 }
-function dirW(rest, b, ctr, sides) {
+function dirW(rest, b, ctr, sides2) {
   if (rest.length > 0) return dirUnrecognized(ctr);
-  return { p: { x: b.ll.x, y: ctr.y }, theta: Math.PI, side: sides & LEFT, constrain: true, clip: false, dyna: false, defined: true, rv: 0 };
+  return { p: { x: b.ll.x, y: ctr.y }, theta: Math.PI, side: sides2 & LEFT, constrain: true, clip: false, dyna: false, defined: true, rv: 0 };
 }
-function compassDirection(compass, b, ctr, sides) {
+function compassDirection(compass, b, ctr, sides2) {
   if (compass.length === 0) return dirDefault(ctr);
   const rest = compass.slice(1);
   switch (compass[0]) {
     case "n":
-      return dirN(rest, b, ctr, sides);
+      return dirN(rest, b, ctr, sides2);
     case "s":
-      return dirS(rest, b, ctr, sides);
+      return dirS(rest, b, ctr, sides2);
     case "e":
-      return dirE(rest, b, ctr, sides);
+      return dirE(rest, b, ctr, sides2);
     case "w":
-      return dirW(rest, b, ctr, sides);
+      return dirW(rest, b, ctr, sides2);
     case "_":
-      return { p: { ...ctr }, theta: 0, side: sides, constrain: false, clip: true, dyna: true, defined: false, rv: 0 };
+      return { p: { ...ctr }, theta: 0, side: sides2, constrain: false, clip: true, dyna: true, defined: false, rv: 0 };
     case "c":
       return dirDefault(ctr);
     default:
@@ -24896,31 +25675,31 @@ function applyIctxt(n, dir, b, ctr) {
   dir.p = compassPoint(n, insideFn, yArg, xArg, gdRankdir(n));
 }
 function compassPort(n, args, pp) {
-  const { bp, compass, sides } = args;
+  const { bp, compass, sides: sides2 } = args;
   const { b, p, defined: defBp } = compassBbox(n, bp);
-  const dir = compassDirection(compass, b, p, sides);
+  const dir = compassDirection(compass, b, p, sides2);
   if (bp === null && !isBox(n)) applyIctxt(n, dir, b, p);
   const defFinal = dir.rv === 1 ? defBp : dir.defined || defBp;
   applyDir(pp, bp, dir, gdRankdir(n), defFinal);
   return dir.rv;
 }
-function htmlPort(n, portname, sides) {
+function htmlPort(n, portname, sides2) {
   const label = n.info.label;
   const placed = label?.u?.kind === "html" ? label.u.html : void 0;
   if (placed === void 0) return null;
   const hit = portToTbl(placed, portname);
   if (hit === null) return null;
-  sides.value = hit.sides;
+  sides2.value = hit.sides;
   return hit.box;
 }
 function polyPort(n, portname, compass) {
   if (portname.length === 0) return makePort();
   const compassStr = compass.length === 0 ? "_" : compass;
-  const sides = BOTTOM | RIGHT | TOP | LEFT;
+  const sides2 = BOTTOM | RIGHT | TOP | LEFT;
   const rv = makePort();
   const label = n.info.label;
   if (label?.html === true) {
-    const sidesRef = { value: sides };
+    const sidesRef = { value: sides2 };
     const bp = htmlPort(n, portname, sidesRef);
     if (bp !== null) {
       compassPort(n, { bp, compass: compassStr, sides: sidesRef.value }, rv);
@@ -24928,7 +25707,7 @@ function polyPort(n, portname, compass) {
       return rv;
     }
   }
-  compassPort(n, { bp: null, compass: portname, sides }, rv);
+  compassPort(n, { bp: null, compass: portname, sides: sides2 }, rv);
   rv.name = null;
   return rv;
 }
@@ -25289,8 +26068,8 @@ function initNodeFromLabel(n, g, measurer) {
   return true;
 }
 function effectivePolygon(poly, p, fixedshape) {
-  let sides = p.sides;
-  if (sides <= 2 && (p.distortion !== 0 || p.skew !== 0)) sides = 120;
+  let sides2 = p.sides;
+  if (sides2 <= 2 && (p.distortion !== 0 || p.skew !== 0)) sides2 = 120;
   return {
     ...poly,
     // C: poly->option.fixedshape = true inside the fixedsize="shape" branch;
@@ -25298,7 +26077,7 @@ function effectivePolygon(poly, p, fixedshape) {
     option: { ...poly.option, fixedshape },
     regular: p.regular,
     peripheries: p.peripheries,
-    sides,
+    sides: sides2,
     orientation: p.orientation,
     distortion: p.distortion,
     skew: p.skew,
@@ -26440,8 +27219,8 @@ function orthoRoundedRadius(e, job) {
   if (e.head.root.attrs.get("splines") !== "ortho") return null;
   let wantRounded = false;
   let radius = 0;
-  const style = e.attrs.get("style");
-  if (style !== void 0 && style.split(",").map((s) => s.trim()).includes("rounded")) {
+  const style2 = e.attrs.get("style");
+  if (style2 !== void 0 && style2.split(",").map((s) => s.trim()).includes("rounded")) {
     wantRounded = true;
   }
   const radiusAttr = e.attrs.get("radius");
@@ -26826,20 +27605,10 @@ function checkControlPoints2(cp) {
   return ptToLine22(cp[0], cp[3], cp[1]) < MAP_HW * MAP_HW && ptToLine22(cp[0], cp[3], cp[2]) < MAP_HW * MAP_HW;
 }
 function bezierHalf(v) {
-  const t = 0.5;
-  const vt = [v.slice(0, 4)];
-  for (let i = 1; i <= 3; i++) {
-    vt[i] = [];
-    for (let j = 0; j <= 3 - i; j++) {
-      const a = vt[i - 1][j];
-      const b = vt[i - 1][j + 1];
-      vt[i][j] = { x: (1 - t) * a.x + t * b.x, y: (1 - t) * a.y + t * b.y };
-    }
-  }
-  return {
-    left: [vt[0][0], vt[1][0], vt[2][0], vt[3][0]],
-    right: [vt[3][0], vt[2][1], vt[1][2], vt[0][3]]
-  };
+  const left2 = [];
+  const right2 = [];
+  bezier(v, 0.5, left2, right2);
+  return { left: left2, right: right2 };
 }
 function approxBezier(cp, out) {
   if (checkControlPoints2(cp)) {
@@ -28397,9 +29166,9 @@ function setAspect2(g) {
 function placeLabelNonFlip(g) {
   const bb = g.info.bb;
   const labelPos2 = g.info.label_pos ?? 1;
-  const border = g.info.border;
+  const border2 = g.info.border;
   const zero = { x: 0, y: 0 };
-  const d = labelPos2 & 1 ? border?.[TOP_IX] ?? zero : border?.[BOTTOM_IX] ?? zero;
+  const d = labelPos2 & 1 ? border2?.[TOP_IX] ?? zero : border2?.[BOTTOM_IX] ?? zero;
   const py = labelPos2 & 1 ? bb.ur.y - d.y / 2 : bb.ll.y + d.y / 2;
   const px = labelPos2 & 4 ? bb.ur.x - d.x / 2 : labelPos2 & 2 ? bb.ll.x + d.x / 2 : (bb.ll.x + bb.ur.x) / 2;
   return { x: px, y: py };
@@ -28407,9 +29176,9 @@ function placeLabelNonFlip(g) {
 function placeLabelFlip(g) {
   const bb = g.info.bb;
   const labelPos2 = g.info.label_pos ?? 1;
-  const border = g.info.border;
+  const border2 = g.info.border;
   const zero = { x: 0, y: 0 };
-  const d = labelPos2 & 1 ? border?.[RIGHT_IX] ?? zero : border?.[LEFT_IX] ?? zero;
+  const d = labelPos2 & 1 ? border2?.[RIGHT_IX] ?? zero : border2?.[LEFT_IX] ?? zero;
   const px = labelPos2 & 1 ? bb.ur.x - d.x / 2 : bb.ll.x + d.x / 2;
   const py = labelPos2 & 4 ? bb.ll.y + d.y / 2 : labelPos2 & 2 ? bb.ur.y - d.y / 2 : (bb.ll.y + bb.ur.y) / 2;
   return { x: px, y: py };
@@ -29387,18 +30156,6 @@ function dist2(p, q) {
 function distPt(p, q) {
   return Math.sqrt(dist2(p, q));
 }
-function bezier(v, t) {
-  const u = 1 - t;
-  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;
   let bestj = -1;
@@ -29427,7 +30184,7 @@ function dotneatoClosest(spl, pt) {
   let pt2;
   for (; ; ) {
     const t = (lo + hi) / 2;
-    pt2 = bezier(c, t);
+    pt2 = bezier(c, t, null, null);
     if (Math.abs(dlo2 - dhi2) < 1 || Math.abs(hi - lo) < 1e-5) break;
     if (dlo2 < dhi2) {
       hi = t;
@@ -29518,8 +30275,8 @@ function faceMidpoint(b, ix) {
   return { x: b.ll.x, y: cy };
 }
 function closestSide(n, other, port) {
-  const sides = port.side;
-  if (sides === 0 || sides === ALL_SIDES2) return null;
+  const sides2 = port.side;
+  if (sides2 === 0 || sides2 === ALL_SIDES2) return null;
   const rkd = (n.root.info.rankdir ?? 0) & 3;
   const pt = cvtPt(n.info.coord, rkd);
   const opt = cvtPt(other.info.coord, rkd);
@@ -29527,7 +30284,7 @@ function closestSide(n, other, port) {
   let rv = null;
   let mind = 0;
   for (let i = 0; i < 4; i++) {
-    if ((sides & 1 << i) === 0) continue;
+    if ((sides2 & 1 << i) === 0) continue;
     const m = faceMidpoint(b, i);
     const d = dist2({ x: m.x + pt.x, y: m.y + pt.y }, opt);
     if (rv === null || d < mind) {
@@ -31244,17 +32001,20 @@ function checkPath(boxn, boxes, pp) {
   return false;
 }
 function deCasteljauPoint(p0, p1, p2, p3, t) {
-  const ax = p0.x + t * (p1.x - p0.x);
-  const ay = p0.y + t * (p1.y - p0.y);
-  const bx = p1.x + t * (p2.x - p1.x);
-  const by = p1.y + t * (p2.y - p1.y);
-  const cx = p2.x + t * (p3.x - p2.x);
-  const cy = p2.y + t * (p3.y - p2.y);
-  const dx = ax + t * (bx - ax);
-  const dy = ay + t * (by - ay);
-  const ex = bx + t * (cx - bx);
-  const ey = by + t * (cy - by);
-  return { x: dx + t * (ex - dx), y: dy + t * (ey - dy) };
+  let s0x = p0.x, s0y = p0.y, s1x = p1.x, s1y = p1.y, s2x = p2.x, s2y = p2.y;
+  s0x = fma(t, s1x - s0x, s0x);
+  s0y = fma(t, s1y - s0y, s0y);
+  s1x = fma(t, s2x - s1x, s1x);
+  s1y = fma(t, s2y - s1y, s1y);
+  s2x = fma(t, p3.x - s2x, s2x);
+  s2y = fma(t, p3.y - s2y, s2y);
+  s0x = fma(t, s1x - s0x, s0x);
+  s0y = fma(t, s1y - s0y, s0y);
+  s1x = fma(t, s2x - s1x, s1x);
+  s1y = fma(t, s2y - s1y, s1y);
+  s0x = fma(t, s1x - s0x, s0x);
+  s0y = fma(t, s1y - s0y, s0y);
+  return { x: s0x, y: s0y };
 }
 function updateBoxExtents(boxes, boxn, sp) {
   for (let bi = 0; bi < boxn; bi++) {
@@ -31275,7 +32035,7 @@ function sampleBezierSegment(boxes, boxn, pps, splinepi, numDiv) {
   }
 }
 function limitBoxes(boxes, boxn, pps, pn, delta2) {
-  const numDiv = Math.round(delta2 * boxn);
+  const numDiv = delta2 * boxn;
   for (let splinepi = 0; splinepi + 3 < pn; splinepi += 3) {
     sampleBezierSegment(boxes, boxn, pps, splinepi, numDiv);
   }
@@ -31941,15 +32701,15 @@ function leftOf(p1, p2, p3) {
 }
 function lineLabelPoints(g, startp, endp, label) {
   const flip = g.info.flip === true;
-  const width = flip ? label.dimen.y : label.dimen.x;
-  const height = flip ? label.dimen.x : label.dimen.y;
+  const width2 = flip ? label.dimen.y : label.dimen.x;
+  const height2 = flip ? label.dimen.x : label.dimen.y;
   const lp = { x: label.pos.x, y: label.pos.y };
   if (leftOf(endp, startp, lp)) {
-    lp.x += width / 2;
-    lp.y -= height / 2;
+    lp.x += width2 / 2;
+    lp.y -= height2 / 2;
   } else {
-    lp.x -= width / 2;
-    lp.y += height / 2;
+    lp.x -= width2 / 2;
+    lp.y += height2 / 2;
   }
   return [startp, startp, lp, lp, lp, endp, endp];
 }
@@ -33336,8 +34096,8 @@ function findNormalOutEdge(first) {
 }
 function labelXPos(n, l) {
   const flip = !!n.root?.info.flip;
-  const width = flip ? l.dimen.y : l.dimen.x;
-  return n.info.coord.x + width / 2;
+  const width2 = flip ? l.dimen.y : l.dimen.x;
+  return n.info.coord.x + width2 / 2;
 }
 function placeVnlabel(n) {
   if ((n.info.in?.size ?? 0) === 0) return;
@@ -33375,22 +34135,12 @@ function setEdgeLabelPos(g) {
 }
 var PORT_LABEL_DISTANCE = 10;
 var PORT_LABEL_ANGLE = -25;
-function cubicBezierAt(pts, t) {
-  const p0 = pts[0], p1 = pts[1], p2 = pts[2], p3 = pts[3];
-  const mt = 1 - t;
-  const q0 = { x: mt * p0.x + t * p1.x, y: mt * p0.y + t * p1.y };
-  const q1 = { x: mt * p1.x + t * p2.x, y: mt * p1.y + t * p2.y };
-  const q2 = { x: mt * p2.x + t * p3.x, y: mt * p2.y + t * p3.y };
-  const r0 = { x: mt * q0.x + t * q1.x, y: mt * q0.y + t * q1.y };
-  const r1 = { x: mt * q1.x + t * q2.x, y: mt * q1.y + t * q2.y };
-  return { x: mt * r0.x + t * r1.x, y: mt * r0.y + t * r1.y };
-}
 function tailEndpoints(bez) {
   if (bez.sflag) {
     return { pe: bez.sp, pf: bez.list[0] };
   }
   const pe = bez.list[0];
-  const pf = cubicBezierAt(bez.list, 0.1);
+  const pf = bezier(bez.list, 0.1, null, null);
   return { pe, pf };
 }
 function headEndpoints(bez) {
@@ -33399,7 +34149,7 @@ function headEndpoints(bez) {
   }
   const pe = bez.list[bez.size - 1];
   const last4 = bez.list.slice(bez.size - 4, bez.size);
-  const pf = cubicBezierAt(last4, 0.9);
+  const pf = bezier(last4, 0.9, null, null);
   return { pe, pf };
 }
 function placePortlabel(e, headP) {
@@ -36574,22 +37324,22 @@ function gcellWalk(pd, sx, sy, boundIsX, bound) {
   }
   return out;
 }
-function appendSide(sides, found, cp, cellIdx) {
+function appendSide(sides2, found, cp, cellIdx) {
   for (const np of found) {
-    sides.push(np);
+    sides2.push(np);
     np.cells[cellIdx] = cp;
   }
 }
 function attachGcellSides(mp, hdict, vdict) {
   let maxdeg = 0;
   for (const cp of mp.gcells) {
-    const sides = [];
-    appendSide(sides, gcellWalk(hdict, cp.bb.LL.x, cp.bb.LL.y, true, cp.bb.UR.x), cp, 1);
-    appendSide(sides, gcellWalk(vdict, cp.bb.LL.x, cp.bb.LL.y, false, cp.bb.UR.y), cp, 1);
-    appendSide(sides, gcellWalk(hdict, cp.bb.LL.x, cp.bb.UR.y, true, cp.bb.UR.x), cp, 0);
-    appendSide(sides, gcellWalk(vdict, cp.bb.UR.x, cp.bb.LL.y, false, cp.bb.UR.y), cp, 0);
-    cp.sides = sides;
-    cp.nsides = sides.length;
+    const sides2 = [];
+    appendSide(sides2, gcellWalk(hdict, cp.bb.LL.x, cp.bb.LL.y, true, cp.bb.UR.x), cp, 1);
+    appendSide(sides2, gcellWalk(vdict, cp.bb.LL.x, cp.bb.LL.y, false, cp.bb.UR.y), cp, 1);
+    appendSide(sides2, gcellWalk(hdict, cp.bb.LL.x, cp.bb.UR.y, true, cp.bb.UR.x), cp, 0);
+    appendSide(sides2, gcellWalk(vdict, cp.bb.UR.x, cp.bb.LL.y, false, cp.bb.UR.y), cp, 0);
+    cp.sides = sides2;
+    cp.nsides = sides2.length;
     if (cp.nsides > maxdeg) maxdeg = cp.nsides;
   }
   return maxdeg;
@@ -37871,21 +38621,10 @@ function inBoxf(p, bb) {
 function midPointf2(a, b) {
   return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
 }
-function casteljauStep(prev, t) {
-  const u = 1 - t;
-  return [
-    { x: u * prev[0].x + t * prev[1].x, y: u * prev[0].y + t * prev[1].y },
-    { x: u * prev[1].x + t * prev[2].x, y: u * prev[1].y + t * prev[2].y },
-    { x: u * prev[2].x + t * prev[3].x, y: u * prev[2].y + t * prev[3].y },
-    { x: 0, y: 0 }
-  ];
-}
 function subdivideBezier(v, t, side) {
-  const r0 = [{ ...v[0] }, { ...v[1] }, { ...v[2] }, { ...v[3] }];
-  const r1 = casteljauStep(r0, t);
-  const r2 = casteljauStep(r1, t);
-  const r3 = casteljauStep(r2, t);
-  return side === "left" ? [r0[0], r1[0], r2[0], r3[0]] : [r3[0], r2[1], r1[2], r0[3]];
+  const half = [];
+  bezier([...v], t, side === "left" ? half : null, side === "right" ? half : null);
+  return half;
 }
 function countVertCross(pts, xcoord) {
   let sign2 = fcmp(pts[0].x, xcoord);
@@ -39369,10 +40108,11 @@ function bfsFixDisconnected(n, dist4, closestDist) {
 function bfsVisitNeighbors(vertex, graph, dist4, queue) {
   const vd = graph[vertex];
   const d = dist4[vertex];
+  const unit = graph[0].ewgts.length === 0;
   for (let i = 1; i < vd.nedges; i++) {
     const nb = vd.edges[i];
     if (dist4[nb] < 0) {
-      dist4[nb] = d + 1;
+      dist4[nb] = d + (unit ? 1 : Math.trunc(Math.fround(vd.ewgts[i])));
       queue.push(nb);
     }
   }
@@ -40800,11 +41540,12 @@ function runMajorization(g, mode, model) {
   const nodeList = assignNodeIds2(g);
   const n = nodeList.length;
   const haveLen = graphHasLen(g);
-  const vtx = makeGraphDataC(g, nodeList, haveLen);
+  const vtx = makeGraphDataC(g, nodeList, haveLen, mode === MODE_HIER || mode === MODE_IPSEP);
   checkStart(g);
   const maxi = lateDouble(g.attrs.get("maxiter"), DFLT_ITERATIONS, 0);
   const epsilon = lateDouble(g.attrs.get("epsilon"), 1e-4, 0);
-  const Dij = haveLen ? computeWeightedApspPacked2(vtx, n) : computeApspPacked2(vtx, n);
+  const weighted = haveLen && mode !== MODE_IPSEP;
+  const Dij = weighted ? computeWeightedApspPacked2(vtx, n) : computeApspPacked2(vtx, n);
   const dCoords = [new Float64Array(n), new Float64Array(n)];
   stressMajorizationKDMkernel(Dij, n, dCoords, nodeList, {
     dim: DFLT_DIM,
@@ -40822,11 +41563,11 @@ function graphHasLen(g) {
   }
   return false;
 }
-function makeGraphDataC(g, nodeList, haveLen) {
+function makeGraphDataC(g, nodeList, haveLen, haveDir) {
   const vtx = nodeList.map((_, i) => ({
     nedges: 1,
     edges: [i],
-    ewgts: haveLen ? [0] : []
+    ewgts: haveLen || haveDir ? [0] : []
   }));
   for (const np of nodeList) {
     const i = np.info.id;
@@ -40844,7 +41585,7 @@ function makeGraphDataC(g, nodeList, haveLen) {
       }
       seen.set(vid, entry.nedges);
       entry.edges.push(vid);
-      if (haveLen) entry.ewgts.push(dist4);
+      if (haveLen || haveDir) entry.ewgts.push(dist4);
       entry.nedges++;
     }
   }
@@ -41905,7 +42646,7 @@ var RIGHT3 = 1 << 1;
 var TOP3 = 1 << 2;
 var LEFT3 = 1 << 3;
 var add = (p, q) => ({ x: p.x + q.x, y: p.y + q.y });
-function sideCone(p, sides) {
+function sideCone(p, sides2) {
   const north = { x: 0, y: 1 };
   const northeast = { x: 1, y: 1 };
   const east = { x: 1, y: 0 };
@@ -41914,7 +42655,7 @@ function sideCone(p, sides) {
   const southwest = { x: -1, y: -1 };
   const west = { x: -1, y: 0 };
   const northwest = { x: -1, y: 1 };
-  switch (sides) {
+  switch (sides2) {
     case TOP3:
       return [add(p, north), add(p, northwest), add(p, northeast)];
     case TOP3 | RIGHT3:
@@ -41935,17 +42676,17 @@ function sideCone(p, sides) {
       return [p, p, p];
   }
 }
-function addEndpoint(rtr, p, obsId, vId, sides) {
+function addEndpoint(rtr, p, obsId, vId, sides2) {
   const starti = rtr.obs[obsId];
   const endi = rtr.obs[obsId + 1];
   const pts = rtr.ps;
-  const [vr, v0, v1] = sideCone(p, sides);
+  const [vr, v0, v1] = sideCone(p, sides2);
   rtr.tg.nodes[vId].edges.length = 0;
   rtr.tg.nodes[vId].ctr = p;
   for (let i = starti; i < endi; i++) {
     const seg2 = { i, j: i < endi - 1 ? i + 1 : starti };
     const t = findMap(rtr.trimap, seg2.i, seg2.j);
-    if (sides !== 0 && !inCone(v0, p, v1, pts[seg2.i]) && !inCone(v0, p, v1, pts[seg2.j]) && !raySeg(p, vr, pts[seg2.i], pts[seg2.j])) {
+    if (sides2 !== 0 && !inCone(v0, p, v1, pts[seg2.i]) && !inCone(v0, p, v1, pts[seg2.j]) && !raySeg(p, vr, pts[seg2.i], pts[seg2.j])) {
       continue;
     }
     addTriEdge(rtr.tg, vId, t, seg2);
@@ -42609,7 +43350,7 @@ function boxCornerMargin(j, m) {
   return { x: m.x, y: -m.y };
 }
 function polyObstacle(n, poly, pmargin) {
-  const sides = poly.sides;
+  const sides2 = poly.sides;
   const stored = poly.vertices;
   if (stored == null) return null;
   const penwidth = poly.penwidth ?? 1;
@@ -42619,19 +43360,19 @@ function polyObstacle(n, poly, pmargin) {
   const storedRings = Math.max(poly.peripheries, 1);
   let verts;
   if (ringIdx < storedRings) {
-    verts = stored.slice(ringIdx * sides, (ringIdx + 1) * sides);
+    verts = stored.slice(ringIdx * sides2, (ringIdx + 1) * sides2);
   } else {
-    const outer = stored.slice((storedRings - 1) * sides, storedRings * sides);
-    verts = polygonOutlineRing(outer, sides, penwidth);
+    const outer = stored.slice((storedRings - 1) * sides2, storedRings * sides2);
+    verts = polygonOutlineRing(outer, sides2, penwidth);
   }
-  if (verts.length < sides) return null;
-  const ps = new Array(sides);
-  for (let j = 0; j < sides; j++) {
+  if (verts.length < sides2) return null;
+  const ps = new Array(sides2);
+  for (let j = 0; j < sides2; j++) {
     const v = verts[j];
     if (v === void 0) return null;
     let polyp;
     if (pmargin.doAdd) {
-      if (sides === 4) {
+      if (sides2 === 4) {
         const m = boxCornerMargin(j, { x: pmargin.x, y: pmargin.y });
         polyp = { x: v.x + m.x, y: v.y + m.y };
       } else {
@@ -42641,22 +43382,22 @@ function polyObstacle(n, poly, pmargin) {
     } else {
       polyp = { x: v.x * pmargin.x, y: v.y * pmargin.y };
     }
-    ps[sides - j - 1] = { x: polyp.x + n.info.coord.x, y: polyp.y + n.info.coord.y };
+    ps[sides2 - j - 1] = { x: polyp.x + n.info.coord.x, y: polyp.y + n.info.coord.y };
   }
   return { ps };
 }
 function ellipseObstacle(n, pmargin) {
-  const sides = 8;
-  const width = (n.info.outline_width ?? 0) > 0 ? n.info.outline_width * 72 : n.info.lw + n.info.rw;
-  const height = (n.info.outline_height ?? 0) > 0 ? n.info.outline_height * 72 : n.info.ht;
+  const sides2 = 8;
+  const width2 = (n.info.outline_width ?? 0) > 0 ? n.info.outline_width * 72 : n.info.lw + n.info.rw;
+  const height2 = (n.info.outline_height ?? 0) > 0 ? n.info.outline_height * 72 : n.info.ht;
   const mx = pmargin.doAdd ? pmargin.x : 0;
   const my = pmargin.doAdd ? pmargin.y : 0;
-  const a = (width + mx) / 2;
-  const b = (height + my) / 2;
-  const ps = new Array(sides);
-  for (let j = 0; j < sides; j++) {
-    const polyp = circumscribedCorner(a, b, j, sides);
-    ps[sides - j - 1] = { x: polyp.x + n.info.coord.x, y: polyp.y + n.info.coord.y };
+  const a = (width2 + mx) / 2;
+  const b = (height2 + my) / 2;
+  const ps = new Array(sides2);
+  for (let j = 0; j < sides2; j++) {
+    const polyp = circumscribedCorner(a, b, j, sides2);
+    ps[sides2 - j - 1] = { x: polyp.x + n.info.coord.x, y: polyp.y + n.info.coord.y };
   }
   return { ps };
 }
@@ -42733,10 +43474,10 @@ function makeOrthoObstacle(n, sep) {
     cy += (bb.ur.y + bb.ll.y) / 2;
     cx += 0;
   } else {
-    const width = info.lw + info.rw;
-    const outlineW = (info.outline_width ?? 0) > 0 ? info.outline_width * 72 : width;
+    const width2 = info.lw + info.rw;
+    const outlineW = (info.outline_width ?? 0) > 0 ? info.outline_width * 72 : width2;
     const outlineH = (info.outline_height ?? 0) > 0 ? info.outline_height * 72 : info.ht;
-    const outlineLw = width > 0 ? info.lw * outlineW / width : outlineW / 2;
+    const outlineLw = width2 > 0 ? info.lw * outlineW / width2 : outlineW / 2;
     lw = outlineLw;
     rw = outlineLw;
     hh = outlineH / 2;
@@ -42914,17 +43655,11 @@ var OrthoHelper = class _OrthoHelper {
   }
   static buildEdges(g, nodeArr, orthoNodes) {
     const concentrate = g.root.info.concentrate ?? false;
-    const seen = /* @__PURE__ */ new Set();
+    const ps = concentrate ? new PointSet() : null;
     const edges = [];
     for (const n of nodesInSeq(g)) {
       for (const e of n.outEdges(g)) {
-        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 && isConcentrateDup(ps, e)) continue;
         const tc = e.tail.info.coord;
         const hc = e.head.info.coord;
         const tp = e.info.tail_port.p;
@@ -44980,13 +45715,13 @@ function pointDistance(p1, o1, p2, o2, dim) {
   }
   return Math.sqrt(dist4);
 }
-function quadTreeNew(dim, center, width, maxLevel) {
+function quadTreeNew(dim, center, width2, maxLevel) {
   return {
     n: 0,
     totalWeight: 0,
     dim,
     center: center.slice(0, dim),
-    width,
+    width: width2,
     average: null,
     qts: null,
     l: null,
@@ -45004,15 +45739,15 @@ function getQuadrant(dim, center, coord, off) {
   }
   return d;
 }
-function newInQuadrant(dim, parentCenter, width, maxLevel, i) {
-  const qt = quadTreeNew(dim, parentCenter, width, maxLevel);
+function newInQuadrant(dim, parentCenter, width2, maxLevel, i) {
+  const qt = quadTreeNew(dim, parentCenter, width2, maxLevel);
   const center = qt.center;
   let ii = i;
   for (let k = 0; k < dim; k++) {
     if (ii % 2 === 0) {
-      center[k] -= width;
+      center[k] -= width2;
     } else {
-      center[k] += width;
+      center[k] += width2;
     }
     ii = (ii - ii % 2) / 2;
   }
@@ -45083,14 +45818,14 @@ function quadTreeNewFromPointList(dim, n, maxLevel, coord) {
       xmax[k] = Math.max(xmax[k], coord[i * dim + k]);
     }
   }
-  let width = xmax[0] - xmin[0];
+  let width2 = xmax[0] - xmin[0];
   for (let i = 0; i < dim; i++) {
     center[i] = (xmin[i] + xmax[i]) * 0.5;
-    width = Math.max(width, xmax[i] - xmin[i]);
+    width2 = Math.max(width2, xmax[i] - xmin[i]);
   }
-  width = Math.max(width, 1e-5);
-  width *= 0.52;
-  const qt = quadTreeNew(dim, center, width, maxLevel);
+  width2 = Math.max(width2, 1e-5);
+  width2 *= 0.52;
+  const qt = quadTreeNew(dim, center, width2, maxLevel);
   for (let i = 0; i < n; i++) {
     quadTreeAdd(qt, coord, i * dim, 1, i);
   }
@@ -45910,18 +46645,18 @@ function compScanPoints(p, q) {
   if (pp.node < qq.node) return -1;
   return 0;
 }
-function getOverlapGraph(dim, n, x, width, checkOverlapOnly) {
+function getOverlapGraph(dim, n, x, width2, checkOverlapOnly) {
   let A3 = smNew(n, n, MATRIX_TYPE_REAL, FORMAT_COORD);
   const scanpointsx = new Array(2 * n);
   for (let i = 0; i < n; i++) {
-    scanpointsx[2 * i] = { node: i, x: x[i * dim] - width[i * dim], status: INTV_OPEN };
-    scanpointsx[2 * i + 1] = { node: i + n, x: x[i * dim] + width[i * dim], status: INTV_CLOSE };
+    scanpointsx[2 * i] = { node: i, x: x[i * dim] - width2[i * dim], status: INTV_OPEN };
+    scanpointsx[2 * i + 1] = { node: i + n, x: x[i * dim] + width2[i * dim], status: INTV_CLOSE };
   }
   scanpointsx.sort(compScanPoints);
   const scanpointsy = new Array(2 * n);
   for (let i = 0; i < n; i++) {
-    scanpointsy[i] = { node: i, x: x[i * dim + 1] - width[i * dim + 1], status: INTV_OPEN };
-    scanpointsy[i + n] = { node: i, x: x[i * dim + 1] + width[i * dim + 1], status: INTV_CLOSE };
+    scanpointsy[i] = { node: i, x: x[i * dim + 1] - width2[i * dim + 1], status: INTV_OPEN };
+    scanpointsy[i + n] = { node: i, x: x[i * dim + 1] + width2[i * dim + 1], status: INTV_CLOSE };
   }
   const treey = rbTreeCreate(compScanPoints, () => void 0);
   outer:
@@ -45954,7 +46689,7 @@ function getOverlapGraph(dim, n, x, width, checkOverlapOnly) {
   A3 = smSymmetrize(B2, false);
   return A3;
 }
-function idealDistanceAvoidOverlap(dim, A3, x, width, idealDistance) {
+function idealDistanceAvoidOverlap(dim, A3, x, width2, idealDistance) {
   const ia = A3.ia;
   const ja = A3.ja;
   const expandmax = 1.5;
@@ -45968,8 +46703,8 @@ function idealDistanceAvoidOverlap(dim, A3, x, width, idealDistance) {
       const dist4 = distance(x, dim, i, jj);
       const dx = Math.abs(x[i * dim] - x[jj * dim]);
       const dy = Math.abs(x[i * dim + 1] - x[jj * dim + 1]);
-      const wx = width[i * dim] + width[jj * dim];
-      const wy = width[i * dim + 1] + width[jj * dim + 1];
+      const wx = width2[i * dim] + width2[jj * dim];
+      const wy = width2[i * dim + 1] + width2[jj * dim + 1];
       if (dx < MACHINEACC * wx && dy < MACHINEACC * wy) {
         idealDistance[j] = Math.hypot(wx, wy);
         tmax = 2;
@@ -46000,7 +46735,7 @@ function idealDistanceAvoidOverlap(dim, A3, x, width, idealDistance) {
 function scaleCoord(dim, m, x, scale) {
   for (let i = 0; i < dim * m; i++) x[i] *= scale;
 }
-function overlapScaling(dim, m, x, width, scaleStaIn, scaleStoIn, epsilon, maxiter) {
+function overlapScaling(dim, m, x, width2, scaleStaIn, scaleStoIn, epsilon, maxiter) {
   let scaleSta = scaleStaIn;
   let scaleSto = scaleStoIn;
   let iter = 0;
@@ -46008,7 +46743,7 @@ function overlapScaling(dim, m, x, width, scaleStaIn, scaleStoIn, epsilon, maxit
     scaleSta = 0;
   } else {
     scaleCoord(dim, m, x, scaleSta);
-    const C6 = getOverlapGraph(dim, m, x, width, true);
+    const C6 = getOverlapGraph(dim, m, x, width2, true);
     if (C6.nz === 0) return;
     scaleCoord(dim, m, x, 1 / scaleSta);
   }
@@ -46023,7 +46758,7 @@ function overlapScaling(dim, m, x, width, scaleStaIn, scaleStoIn, epsilon, maxit
     do {
       scaleSto *= 2;
       scaleCoord(dim, m, x, 2);
-      const C6 = getOverlapGraph(dim, m, x, width, true);
+      const C6 = getOverlapGraph(dim, m, x, width2, true);
       overlap5 = C6.nz > 0;
     } while (overlap5);
     scaleCoord(dim, m, x, 1 / scaleSto);
@@ -46032,7 +46767,7 @@ function overlapScaling(dim, m, x, width, scaleStaIn, scaleStoIn, epsilon, maxit
   while (iter++ < maxiter && scaleSto - scaleSta > epsilon) {
     const scale = 0.5 * (scaleSta + scaleSto);
     scaleCoord(dim, m, x, scale);
-    const C6 = getOverlapGraph(dim, m, x, width, true);
+    const C6 = getOverlapGraph(dim, m, x, width2, true);
     scaleCoord(dim, m, x, 1 / scale);
     const overlap5 = C6.nz > 0;
     if (overlap5) {
@@ -46043,7 +46778,7 @@ function overlapScaling(dim, m, x, width, scaleStaIn, scaleStoIn, epsilon, maxit
   }
   scaleCoord(dim, m, x, scaleBest);
 }
-function overlapSmootherNew(m, dim, x, width, neighborhoodOnly, shrink) {
+function overlapSmootherNew(m, dim, x, width2, neighborhoodOnly, shrink) {
   const sm = {
     Lw: null,
     Lwd: null,
@@ -46053,16 +46788,16 @@ function overlapSmootherNew(m, dim, x, width, neighborhoodOnly, shrink) {
   };
   let B2 = callTri(m, x);
   if (!neighborhoodOnly) {
-    const C6 = getOverlapGraph(dim, m, x, width, false);
+    const C6 = getOverlapGraph(dim, m, x, width2, false);
     B2 = smAdd(B2, C6);
   }
   sm.Lw = B2;
   sm.Lwd = smCopy(sm.Lw);
-  const { tmax, tmin } = idealDistanceAvoidOverlap(dim, sm.Lwd, x, width, sm.Lwd.a);
+  const { tmax, tmin } = idealDistanceAvoidOverlap(dim, sm.Lwd, x, width2, sm.Lwd.a);
   if (tmax < 1 && shrink) {
     const scaleSta = Math.min(1, tmax * 1.0001);
     const scaleSto = 1;
-    overlapScaling(dim, m, x, width, scaleSta, scaleSto, 1e-4, 15);
+    overlapScaling(dim, m, x, width2, scaleSta, scaleSto, 1e-4, 15);
     return { sm, maxOverlap: 1, minOverlap: tmin };
   }
   const iw = sm.Lw.ia;
@@ -46336,7 +47071,7 @@ function scAdjust(g, equal) {
 // src/layout/neato/simple-scale.ts
 var ISZERO = (d) => Math.abs(d) < 1e-9;
 var LF = /^\s*([+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)/;
-function scanPair(p) {
+function scanPair2(p) {
   const m1 = LF.exec(p);
   if (m1 === null) return [];
   const rest = p.slice(m1[0].length);
@@ -46347,7 +47082,7 @@ function scanPair(p) {
 function simpleScale(g) {
   const p = aggetGraph(g, "scale");
   if (p === void 0) return 0;
-  const sc = scanPair(p);
+  const sc = scanPair2(p);
   if (sc.length === 0) return 0;
   const x = sc[0];
   if (ISZERO(x)) return 0;
@@ -46671,16 +47406,16 @@ function overlaps(p) {
 function initItem(n, margin) {
   const x = cround(SCALE * (n.info.pos?.[0] ?? 0) * POINTS_PER_INCH6);
   const y = cround(SCALE * (n.info.pos?.[1] ?? 0) * POINTS_PER_INCH6);
-  const width = n.info.width ?? 0;
-  const height = n.info.height ?? 0;
+  const width2 = n.info.width ?? 0;
+  const height2 = n.info.height ?? 0;
   let w2;
   let h2;
   if (margin.doAdd) {
-    w2 = d2i(SCALE * (cround(width / 2 * POINTS_PER_INCH6) + margin.x));
-    h2 = d2i(SCALE * (cround(height / 2 * POINTS_PER_INCH6) + margin.y));
+    w2 = d2i(SCALE * (cround(width2 / 2 * POINTS_PER_INCH6) + margin.x));
+    h2 = d2i(SCALE * (cround(height2 / 2 * POINTS_PER_INCH6) + margin.y));
   } else {
-    w2 = cround(margin.x * SCALE2 * width * POINTS_PER_INCH6);
-    h2 = cround(margin.y * SCALE2 * height * POINTS_PER_INCH6);
+    w2 = cround(margin.x * SCALE2 * width2 * POINTS_PER_INCH6);
+    h2 = cround(margin.y * SCALE2 * height2 * POINTS_PER_INCH6);
   }
   return {
     val: 0,
@@ -46782,12 +47517,12 @@ function atoi2(s) {
 }
 function genRound(n, xm, ym) {
   const isides = atoi2(n.attrs.get("samplepoints"));
-  const sides = isides < MIN_SAMPLES ? DFLT_SAMPLE2 : isides;
+  const sides2 = isides < MIN_SAMPLES ? DFLT_SAMPLE2 : isides;
   const verts = [];
-  for (let i = 0; i < sides; i++) {
+  for (let i = 0; i < sides2; i++) {
     verts.push({
-      x: (n.info.width / 2 + xm) * Math.cos(i / sides * Math.PI * 2),
-      y: (n.info.height / 2 + ym) * Math.sin(i / sides * Math.PI * 2)
+      x: (n.info.width / 2 + xm) * Math.cos(i / sides2 * Math.PI * 2),
+      y: (n.info.height / 2 + ym) * Math.sin(i / sides2 * Math.PI * 2)
     });
   }
   return verts;
@@ -49205,30 +49940,30 @@ function boundaryFromBB(bb) {
     x: (bb.llx + bb.urx) / 2,
     y: (bb.lly + bb.ury) / 2
   };
-  const width = EXPFACTOR * (bb.urx - bb.llx);
-  const height = EXPFACTOR * (bb.ury - bb.lly);
-  sizeBoundary(width, height);
+  const width2 = EXPFACTOR * (bb.urx - bb.llx);
+  const height2 = EXPFACTOR * (bb.ury - bb.lly);
+  sizeBoundary(width2, height2);
   const alpha = Math.atan2(parms.Ht, parms.Wd);
   parms.Wd = parms.Wd / Math.cos(alpha);
   parms.Ht = parms.Ht / Math.sin(alpha);
   return ctr;
 }
-function sizeBoundary(width, height) {
+function sizeBoundary(width2, height2) {
   const area = 4 * parms.Wd * parms.Ht;
-  let quot = width * height / area;
+  let quot = width2 * height2 / area;
   if (quot >= 1) {
-    parms.Wd = width / 2;
-    parms.Ht = height / 2;
+    parms.Wd = width2 / 2;
+    parms.Ht = height2 / 2;
   } else if (quot > 0) {
     quot = 2 * Math.sqrt(quot);
-    parms.Wd = width / quot;
-    parms.Ht = height / quot;
-  } else if (width > 0) {
-    parms.Wd = width / 2;
-    parms.Ht = area / width / 2;
-  } else if (height > 0) {
-    parms.Wd = area / height / 2;
-    parms.Ht = height / 2;
+    parms.Wd = width2 / quot;
+    parms.Ht = height2 / quot;
+  } else if (width2 > 0) {
+    parms.Wd = width2 / 2;
+    parms.Ht = area / width2 / 2;
+  } else if (height2 > 0) {
+    parms.Wd = area / height2 / 2;
+    parms.Ht = height2 / 2;
   }
 }
 function placeWithPorts(g, pp, ctr) {
@@ -50151,7 +50886,7 @@ function finalCC(g, cc, pts, rg, infop) {
   };
 }
 function applyMarginAndBorder(rg, bb, margin) {
-  const border = rg.info.border ?? [
+  const border2 = rg.info.border ?? [
     { x: 0, y: 0 },
     { x: 0, y: 0 },
     { x: 0, y: 0 },
@@ -50159,12 +50894,12 @@ function applyMarginAndBorder(rg, bb, margin) {
   ];
   const pt = {
     x: -bb.ll.x + margin,
-    y: -bb.ll.y + margin + border[BOTTOM_IX].y
+    y: -bb.ll.y + margin + border2[BOTTOM_IX].y
   };
   bb.ll.x = 0;
   bb.ll.y = 0;
   bb.ur.x += pt.x + margin;
-  bb.ur.y += pt.y + margin + border[TOP_IX].y;
+  bb.ur.y += pt.y + margin + border2[TOP_IX].y;
   return pt;
 }
 function evalPositions(g, rootg) {
@@ -52072,9 +52807,9 @@ function applyLabelExpansion(g, total, rbb) {
 }
 function addMarginAndBorder(g, margin, rbb) {
   let { llx, lly, urx, ury } = rbb;
-  const border = g.info.border;
-  const bottomY = border ? border[BOTTOM_IX].y : 0;
-  const topY = border ? border[TOP_IX].y : 0;
+  const border2 = g.info.border;
+  const bottomY = border2 ? border2[BOTTOM_IX].y : 0;
+  const topY = border2 ? border2[TOP_IX].y : 0;
   llx -= margin;
   urx += margin;
   lly -= margin + bottomY;
@@ -52645,18 +53380,9 @@ function approxLen(list, off) {
   return dist3(list[off], list[off + 1]) + dist3(list[off + 1], list[off + 2]) + dist3(list[off + 2], list[off + 3]);
 }
 function splitCubic(v, t) {
-  const u = 1 - t;
-  const row = [v[0], v[1], v[2], v[3]];
-  const left2 = [row[0]];
-  const right2 = new Array(4);
-  right2[3] = row[3];
-  for (let i = 1; i <= 3; i++) {
-    for (let j = 0; j <= 3 - i; j++) {
-      row[j] = { x: u * row[j].x + t * row[j + 1].x, y: u * row[j].y + t * row[j + 1].y };
-    }
-    left2.push(row[0]);
-    right2[3 - i] = row[3 - i];
-  }
+  const left2 = [];
+  const right2 = [];
+  bezier(v, t, left2, right2);
   return { left: left2, right: right2 };
 }
 function splitBSpline(list, t) {
@@ -52776,17 +53502,6 @@ function mymod(original, modulus) {
 function l2dist(p0, p1) {
   return Math.hypot(p0.x - p1.x, p0.y - p1.y);
 }
-function bezierPoint(v, t) {
-  const vx = [v[0].x, v[1].x, v[2].x, v[3].x];
-  const vy = [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++) {
-      vx[j] = (1 - t) * vx[j] + t * vx[j + 1];
-      vy[j] = (1 - t) * vy[j] + t * vy[j + 1];
-    }
-  }
-  return { x: vx[0], y: vy[0] };
-}
 function pathtolines(bez) {
   const arr = [];
   const A3 = bez.list;
@@ -52802,7 +53517,7 @@ function pathtolines(bez) {
     for (let j = 1; j <= 3; j++) V[j] = A3[i + j];
     let p0 = V[0];
     for (let step = 1; step <= BEZIER_SUBDIVISION; step++) {
-      const p1 = bezierPoint(V, step / BEZIER_SUBDIVISION);
+      const p1 = bezier(V, step / BEZIER_SUBDIVISION, null, null);
       linelen += l2dist(p0, p1);
       push(p1, linelen);
       p0 = p1;
@@ -53027,9 +53742,9 @@ function agstrcanonText(arg) {
   if (needsQuotes || cnt === 1 && (first === 46 || first === 45)) {
     return new TextDecoder().decode(new Uint8Array(out));
   }
-  const lower = arg.toLowerCase();
+  const lower2 = arg.toLowerCase();
   for (const tok of CANON_KEYWORDS) {
-    if (tok === lower) return new TextDecoder().decode(new Uint8Array(out));
+    if (tok === lower2) return new TextDecoder().decode(new Uint8Array(out));
   }
   return arg;
 }
@@ -53113,9 +53828,9 @@ function writePlainEdge(e, extend, out) {
   if (lbl !== void 0) {
     out.push(" " + agstrcanonText(lbl.text) + " " + plainCoord(lbl.pos.x) + " " + plainCoord(lbl.pos.y));
   }
-  const style = lateNN(e.attrs.get("style"), "solid");
+  const style2 = lateNN(e.attrs.get("style"), "solid");
   const color = lateNN(e.attrs.get("color"), "black");
-  out.push(" " + style + " " + color + "\n");
+  out.push(" " + style2 + " " + color + "\n");
 }
 function writePlain(g, job, extend) {
   const w = plainCoord(g.info.bb.ur.x);
@@ -54682,9 +55397,9 @@ function createXdotRenderer() {
 
 // src/render/svg-tapered-edge.ts
 function edgeIsTapered(e) {
-  const style = e.attrs.get("style");
-  if (style === void 0 || style === "") return false;
-  return style.split(",").some((t) => t.trim() === "tapered");
+  const style2 = e.attrs.get("style");
+  if (style2 === void 0 || style2 === "") return false;
+  return style2.split(",").some((t) => t.trim() === "tapered");
 }
 function svgTaperedEdge(e, job) {
   const spl = e.info.spl;
@@ -54905,16 +55620,16 @@ var SvgRenderer = class {
    */
   usershape(src, b, job) {
     const g = (n) => String(parseFloat(n.toPrecision(6)));
-    const width = b.ur.x - b.ll.x;
-    const height = b.ur.y - b.ll.y;
-    const originx = (b.ur.x + b.ll.x - width) / 2;
-    const originy = (b.ur.y + b.ll.y + height) / 2;
+    const width2 = b.ur.x - b.ll.x;
+    const height2 = b.ur.y - b.ll.y;
+    const originx = (b.ur.x + b.ll.x - width2) / 2;
+    const originy = (b.ur.y + b.ll.y + height2) / 2;
     let href = src;
     if (job.inlineImages === true) {
       const found = findImageBytes(src, job.imageResolver);
       if (found !== null) href = toDataUri(found.bytes, found.mime);
     }
-    job.write('<image xlink:href="' + escapeXml(href) + '" width="' + g(width) + 'px" height="' + g(height) + 'px" preserveAspectRatio="xMinYMin meet" x="' + g(originx) + '" y="' + g(-originy) + '"/>\n');
+    job.write('<image xlink:href="' + escapeXml(href) + '" width="' + g(width2) + 'px" height="' + g(height2) + 'px" preserveAspectRatio="xMinYMin meet" x="' + g(originx) + '" y="' + g(-originy) + '"/>\n');
   }
   comment(text, job) {
     svgComment(text, job);