@knowvah/dot-engine 2.6.6 → 2.6.8

package/dist/index.js

@@ -10358,9 +10358,11 @@ var StderrLines = class {
   writeLine;
   pending = "";
   write(text) {
-    const parts = (this.pending + text).split("\n");
-    this.pending = parts.pop() ?? "";
-    for (const line of parts) this.writeLine(line);
+    this.pending += text;
+    if (!this.pending.endsWith("\n")) return;
+    const line = this.pending.slice(0, -1);
+    this.pending = "";
+    this.writeLine(line);
   }
   flush() {
     if (this.pending === "") return;
@@ -10368,6 +10370,16 @@ var StderrLines = class {
     this.pending = "";
   }
 };
+var consoleLine = (line) => {
+  if (line.startsWith("Warning")) console.warn(line);
+  else console.error(line);
+};
+var labelStderr = () => new StderrLines(consoleLine);
+var agerrLine = (out, msg) => {
+  if (out === void 0) consoleLine(msg);
+  else out.write(`${msg}
+`);
+};
 
 // src/common/htmltable-parse-state.ts
 var peek = (s) => s.tokens[s.pos];
@@ -10672,11 +10684,87 @@ function htmlEntityUTF8(s) {
   });
 }
 
+// src/common/htmltable-lex-attvalue.ts
+var XML_ERROR_UNDEFINED_ENTITY = "undefined entity";
+var XML_ERROR_BAD_CHAR_REF = "reference to invalid character number";
+var NAME_START = /[A-Za-z_:\u0080-￿]/;
+var NAME_CHAR = /[\w.:\u0080-￿-]/;
+var DEC_DIGIT = /[0-9]/;
+var HEX_DIGIT = /[0-9A-Fa-f]/;
+var NON_XML = /[\x00-\x08\x0b\x0c\x0e-\x1f]/;
+function scanDigits(text, i, digit) {
+  if (i >= text.length) return { partial: true };
+  if (!digit.test(text[i])) return { invalid: i };
+  for (let k = i + 1; k < text.length; k++) {
+    if (text[k] === ";") return k + 1;
+    if (!digit.test(text[k])) return { invalid: k };
+  }
+  return { partial: true };
+}
+function scanRef(text, i) {
+  const c = text[i];
+  if (c === void 0) return { partial: true };
+  if (c === "#") return text[i + 1] === "x" ? scanDigits(text, i + 2, HEX_DIGIT) : scanDigits(text, i + 1, DEC_DIGIT);
+  if (!NAME_START.test(c)) return { invalid: i };
+  for (let k = i + 1; k < text.length; k++) {
+    if (text[k] === ";") return k + 1;
+    if (!NAME_CHAR.test(text[k])) return { invalid: k };
+  }
+  return { partial: true };
+}
+function scanAttValue(text, j) {
+  const q = text[j];
+  let k = j + 1;
+  for (; ; ) {
+    const c = text[k];
+    if (c === void 0) return { partial: true };
+    if (c === q) return { close: k };
+    if (c === "<" || NON_XML.test(c)) return { invalid: k };
+    if (c !== "&") {
+      k++;
+      continue;
+    }
+    const r = scanRef(text, k + 1);
+    if (typeof r !== "number") return r;
+    k = r;
+  }
+}
+function charRefNumber(ref) {
+  const hex = ref.startsWith("&#x");
+  const n = parseInt(ref.slice(hex ? 3 : 2, -1), hex ? 16 : 10);
+  if (n >= 1114112) return -1;
+  if (n >= 55296 && n <= 57343) return -1;
+  if (n < 32 && NON_XML.test(String.fromCharCode(n))) return -1;
+  return n === 65534 || n === 65535 ? -1 : n;
+}
+var PREDEFINED = { lt: "<", gt: ">", amp: "&", quot: '"', apos: "'" };
+var VALUE_PIECE = /&#x?[0-9A-Fa-f]+;|&[^;]+;|\r\n|[\t\n\r]/g;
+function attValueError(raw, base) {
+  for (const m of raw.matchAll(VALUE_PIECE)) {
+    const ref = m[0];
+    if (!ref.startsWith("&")) continue;
+    if (ref.startsWith("&#")) {
+      if (charRefNumber(ref) < 0) return { message: XML_ERROR_BAD_CHAR_REF, offset: base + m.index };
+    } else if (!Object.hasOwn(PREDEFINED, ref.slice(1, -1))) {
+      return { message: XML_ERROR_UNDEFINED_ENTITY };
+    }
+  }
+  return void 0;
+}
+function decodeAttValue(raw) {
+  return raw.replace(VALUE_PIECE, (m) => {
+    if (!m.startsWith("&")) return " ";
+    if (m.startsWith("&#")) return String.fromCodePoint(charRefNumber(m));
+    return PREDEFINED[m.slice(1, -1)];
+  });
+}
+
 // src/common/htmltable-lex-expat.ts
 var XML_ERROR_INVALID_TOKEN = "not well-formed (invalid token)";
 var XML_CONTEXT_BYTES = 1024;
 var INIT_BUFFER_SIZE = 1024;
-var COMPLETE_END = (end, dup) => dup === void 0 ? { kind: "complete", end } : { kind: "complete", end, dup };
+var XML_ERROR_DUPLICATE_ATTRIBUTE = "duplicate attribute";
+var COMPLETE_END = (end, attError) => attError === void 0 ? { kind: "complete", end } : { kind: "complete", end, attError };
 var PARTIAL = { kind: "partial" };
 var INVALID = (offset) => ({ kind: "invalid", offset });
 var XML_NAME = /^[A-Za-z_:\u0080-\uFFFF][\w.:\u0080-\uFFFF-]*/;
@@ -10687,25 +10775,25 @@ function skipSpace(text, i) {
   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) => {
+function fedText(piece, endsUnit) {
+  const text = piece.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);
+  return endsUnit && text.endsWith("]") ? `${text.slice(0, -1)}&#93;` : text;
+}
+function fedBytes(unit, isText) {
+  return byteLength(isText ? fedText(unit, true) : unit);
 }
 function scanValue(text, j) {
   const q = text[j];
   if (q !== '"' && q !== "'") return INVALID(j);
-  const close = text.indexOf(q, j + 1);
-  if (close < 0) {
-    const lt = text.indexOf("<", j + 1);
-    return lt >= 0 ? INVALID(lt) : PARTIAL;
-  }
+  const v = scanAttValue(text, j);
+  if ("partial" in v) return PARTIAL;
+  if ("invalid" in v) return INVALID(v.invalid);
+  const close = v.close;
   const next = skipSpace(text, close + 1);
   if (next === close + 1 && !">/".includes(text[next] ?? ">")) return INVALID(next);
-  return next;
+  return close;
 }
 function scanPair(text, i) {
   const name = XML_NAME.exec(text.slice(i))?.[0];
@@ -10715,8 +10803,9 @@ function scanPair(text, i) {
   if (text[eq] !== "=") return INVALID(eq);
   const j = skipSpace(text, eq + 1);
   if (j >= text.length) return PARTIAL;
-  const next = scanValue(text, j);
-  return typeof next === "number" ? { name, next } : next;
+  const close = scanValue(text, j);
+  if (typeof close !== "number") return close;
+  return { name, next: skipSpace(text, close + 1), value: { start: j + 1, end: close } };
 }
 function tagEdge(text, i) {
   const c = text[i];
@@ -10726,18 +10815,23 @@ function tagEdge(text, i) {
   if (i + 1 >= text.length) return PARTIAL;
   return text[i + 1] === ">" ? COMPLETE_END(i + 2) : void 0;
 }
-function scanAttributes(text, from) {
+function storeAttError(text, p, at, pair, seen) {
+  if (seen.has(pair.name)) return { message: XML_ERROR_DUPLICATE_ATTRIBUTE, offset: at };
+  seen.add(pair.name);
+  const err = attValueError(text.slice(pair.value.start, pair.value.end), pair.value.start);
+  return err === void 0 ? void 0 : { message: err.message, offset: err.offset ?? p };
+}
+function scanAttributes(text, p, from) {
   const seen = /* @__PURE__ */ new Set();
-  let dup;
+  let attError;
   let i = skipSpace(text, from);
   for (; ; ) {
     const edge = tagEdge(text, i);
-    if (edge?.kind === "complete") return COMPLETE_END(edge.end, dup);
+    if (edge?.kind === "complete") return COMPLETE_END(edge.end, attError);
     if (edge !== void 0) return edge;
     const pair = scanPair(text, i);
     if ("kind" in pair) return pair;
-    if (seen.has(pair.name)) dup ??= i;
-    seen.add(pair.name);
+    attError ??= storeAttError(text, p, i, pair, seen);
     i = pair.next;
   }
 }
@@ -10752,7 +10846,7 @@ function scanStartTag(text, p) {
   const c = text[name.next];
   if (c === void 0) return PARTIAL;
   if (!isSpace(c) && c !== ">" && c !== "/") return INVALID(name.next);
-  return scanAttributes(text, name.next);
+  return scanAttributes(text, p, name.next);
 }
 function scanEndTag(text, p) {
   const name = scanName(text, p + 2);
@@ -10795,26 +10889,45 @@ function scanMarkup(text, p) {
   if (c === "!") return { scan: scanDeclaration(text, p), kind: "tag" };
   return { scan: scanStartTag(text, p), kind: "tag" };
 }
-function scanContent(text, base) {
+var CDATA_OPEN = "<![CDATA[";
+var CDATA_CLOSE = "]]>";
+function scanCdata(text, p, base, dataOf, tokens) {
+  const close = text.indexOf(CDATA_CLOSE, p);
+  const end = close < 0 ? text.length : close;
+  if (end > p) tokens.push({ kind: "cdata", start: base + p, end: base + end, data: dataOf(base + p, base + end) });
+  return close < 0 ? -1 : close + CDATA_CLOSE.length;
+}
+function scanText(text, p, base, tokens) {
+  const e = text.indexOf("<", p);
+  const end = e < 0 ? text.length : e;
+  tokens.push({ kind: "text", start: base + p, end: base + end });
+  return end;
+}
+function scanContent(text, base, inCdata, dataOf) {
   const tokens = [];
   let p = 0;
+  let inSection = inCdata;
   while (p < text.length) {
+    if (inSection || text.startsWith(CDATA_OPEN, p)) {
+      const after2 = scanCdata(text, inSection ? p : p + CDATA_OPEN.length, base, dataOf, tokens);
+      if (after2 < 0) return { tokens, consumed: text.length, inCdata: true };
+      inSection = false;
+      p = after2;
+      continue;
+    }
     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;
+      p = scanText(text, p, base, tokens);
       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 };
+    if (scan.kind === "invalid") return { tokens, consumed: p, invalid: base + scan.offset, inCdata: false };
+    if (scan.kind === "partial") return { tokens, consumed: p, inCdata: false };
     const tok = { kind, start: base + p, end: base + scan.end };
-    if (scan.dup !== void 0) tok.dup = base + scan.dup;
+    if (scan.attError !== void 0) tok.attError = { ...scan.attError, offset: base + scan.attError.offset };
     tokens.push(tok);
     p = scan.end;
   }
-  return { tokens, consumed: p };
+  return { tokens, consumed: p, inCdata: inSection };
 }
 var InputBuffer = class {
   size = 0;
@@ -10865,38 +10978,61 @@ var ExpatFeed = class {
   buffer = new InputBuffer();
   heldStart = 0;
   fedEnd = 0;
+  inCdata = false;
+  /** Source ranges of the text units fed so far: their bytes went through findNext's rewrite. */
+  textUnits = [];
   /** 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);
+  /** One `XML_Parse(parser, src[start, end), nbytes, 0)`; `isText` for a text unit. */
+  feed(start, end, isText) {
+    if (isText) this.textUnits.push([start, end]);
+    this.buffer.append(fedBytes(this.src.slice(start, end), isText));
     this.fedEnd = end;
     if (!this.buffer.enough) return { tokens: [] };
     const text = this.src.slice(this.heldStart, end);
-    const scan = scanContent(text, this.heldStart);
+    const scan = scanContent(text, this.heldStart, this.inCdata, (a, b) => this.fedBetween(a, b));
     if (scan.invalid !== void 0) {
       return { tokens: scan.tokens, invalid: { message: XML_ERROR_INVALID_TOKEN, offset: scan.invalid } };
     }
+    this.inCdata = scan.inCdata;
     this.heldStart += scan.consumed;
     this.buffer.consumedTo(byteLength(this.src.slice(this.heldStart, end)), scan.consumed > 0);
     return { tokens: scan.tokens };
   }
+  /** What expat read for source offsets [start, end): text-unit pieces as findNext rewrote them. */
+  fedBetween(start, end) {
+    let out = "";
+    let p = start;
+    for (const [us, ue] of this.textUnits) {
+      if (ue <= p || us >= end) continue;
+      if (us > p) out += this.src.slice(p, us);
+      const e = Math.min(ue, end);
+      out += fedText(this.src.slice(Math.max(us, p), e), e === ue);
+      p = e;
+    }
+    return out + this.src.slice(p, end);
+  }
 };
 var XML_PREDEFINED_ENTITIES = /* @__PURE__ */ new Set(["lt", "gt", "amp", "quot", "apos"]);
 var ENTITY_NAME = /^[A-Za-z_:][\w.:-]*$/;
-function findUndefinedEntity(text) {
+var CHAR_REF = /^&#(?:x[0-9A-Fa-f]+|[0-9]+);/;
+function textRefError(text) {
   for (let t = text.indexOf("&"); t >= 0; t = text.indexOf("&", t + 1)) {
-    if (text[t + 1] === "#") continue;
+    if (text[t + 1] === "#") {
+      const ref = CHAR_REF.exec(text.slice(t))?.[0];
+      if (ref !== void 0 && charRefNumber(ref) < 0) return { message: XML_ERROR_BAD_CHAR_REF, offset: t };
+      continue;
+    }
     const semi = text.indexOf(";", t + 1);
     if (semi < 0) continue;
     const key = text.slice(t + 1, semi);
     if (ENTITY_NAME.test(key) && !Object.hasOwn(HTML_ENTITIES, key) && !XML_PREDEFINED_ENTITIES.has(key)) {
-      return t;
+      return { message: XML_ERROR_UNDEFINED_ENTITY, offset: t };
     }
   }
-  return -1;
+  return void 0;
 }
 function parseTagChunk(chunk) {
   if (!chunk.endsWith(">")) return void 0;
@@ -10907,6 +11043,46 @@ function parseTagChunk(chunk) {
   return { close, selfClose: !close && body.endsWith("/"), name };
 }
 
+// src/common/htmltable-lex-chardata.ts
+var initialCharData = () => ({ inCell: true, xb: "" });
+function startInCell(name, inCell) {
+  if (name === "TABLE" || name === "TR" || name === "TH") return false;
+  return name === "TD" ? true : inCell;
+}
+function endInCell(name, inCell) {
+  if (name === "TABLE") return true;
+  return name === "TD" ? false : inCell;
+}
+function tagInCell(st, tag) {
+  const name = tag.name.toUpperCase();
+  if (tag.close) {
+    st.inCell = endInCell(name, st.inCell);
+    return;
+  }
+  st.inCell = startInCell(name, st.inCell);
+  if (tag.selfClose) st.inCell = endInCell(name, st.inCell);
+}
+function keepLostText(st, lost) {
+  for (const t of lost) if (t.type === "text") st.xb += t.value;
+}
+function releaseXb(st, first) {
+  if (st.xb === "") return;
+  if (first.type === "text") first.value = st.xb + first.value;
+  else if (first.type === "open" && first.tag === "TABLE") first.heldText = st.xb;
+  else return;
+  st.xb = "";
+}
+function cleanText(decoded) {
+  return decoded.replace(/[\x00-\x1f]/g, "");
+}
+function textTokens(raw) {
+  return charDataTokens(htmlEntityUTF8(raw));
+}
+function charDataTokens(decoded) {
+  const clean = cleanText(decoded);
+  return clean.length > 0 ? [{ type: "text", value: clean }] : [];
+}
+
 // 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";
@@ -10996,7 +11172,7 @@ function parseAttrPairs(raw) {
     if (q !== '"' && q !== "'") throw new HtmlParseError(name);
     const end = raw.indexOf(q, i + 1);
     if (end < 0) throw new HtmlParseError(name);
-    out.push([name, raw.slice(i + 1, end)]);
+    out.push([name, decodeAttValue(raw.slice(i + 1, end))]);
     i = end + 1;
   }
   return out;
@@ -11011,20 +11187,17 @@ function parseCloseToken(inner) {
   checkTag(tag);
   return { type: "close", tag: normalizeTag(tag) };
 }
-function cleanText(raw) {
-  const isKeep = (c) => c === " " || c === "	" || c === "\n" || c === "\r";
-  return raw.replace(/[\x00-\x1f\x7f]/g, (c) => isKeep(c) ? c : "");
-}
-function textTokens(raw) {
-  const clean = htmlEntityUTF8(cleanText(raw));
-  return clean.length > 0 ? [{ type: "text", value: clean }] : [];
-}
+var EMPTY_ELEMENTS = /* @__PURE__ */ new Set(["BR", "HR", "VR", "IMG"]);
 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());
-    return [open, { type: "close", tag: open.tag }];
+    if (EMPTY_ELEMENTS.has(open.tag)) return [open, { type: "close", tag: open.tag }];
+    const close = { type: "close", tag: open.tag };
+    if (open.warnings !== void 0) close.warnings = open.warnings;
+    if (open.warn === true) close.warn = true;
+    return [close];
   }
   return [parseOpenToken(inner)];
 }
@@ -11041,9 +11214,7 @@ function parseOpenToken(inner) {
   checkTag(tag);
   return openToken(normalizeTag(tag), sp === -1 ? "" : inner.slice(sp + 1));
 }
-var XML_ERROR_UNDEFINED_ENTITY = "undefined entity";
 var XML_ERROR_TAG_MISMATCH = "mismatched tag";
-var XML_ERROR_DUPLICATE_ATTRIBUTE = "duplicate attribute";
 var SYNTAX_ERROR = "syntax error";
 var HtmlLexError = class extends HtmlParseError {
   diagnostics;
@@ -11086,7 +11257,8 @@ function checkTagToken(site) {
       throw htmlErrorInLine(XML_ERROR_TAG_MISMATCH, lineAt(src, tok.start), context);
     }
   } else {
-    if (tok.dup !== void 0) throw htmlErrorInLine(XML_ERROR_DUPLICATE_ATTRIBUTE, lineAt(src, tok.dup), context);
+    const err = tok.attError;
+    if (err !== void 0) throw htmlErrorInLine(err.message, lineAt(src, err.offset), context);
     if (!tag.selfClose) st.stack.push(tag.name);
   }
   if (KNOWN_TAGS.has(tag.name.toUpperCase())) return;
@@ -11097,14 +11269,13 @@ 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 === "cdata") return charDataTokens(tok.data ?? "");
   if (tok.kind === "tag") {
     checkTagToken(site);
     return tagTokens(text);
   }
-  const off = findUndefinedEntity(text);
-  if (off >= 0) {
-    throw htmlErrorInLine(XML_ERROR_UNDEFINED_ENTITY, lineAt(src, tok.start + off), st.prev + st.curr);
-  }
+  const err = textRefError(text);
+  if (err !== void 0) throw htmlErrorInLine(err.message, lineAt(src, tok.start + err.offset), st.prev + st.curr);
   return textTokens(text);
 }
 function attachCarry(carry, first) {
@@ -11122,7 +11293,13 @@ function absorb(carry, lost) {
 function eventGroups(run, res) {
   const groups = [];
   for (const tok of res.tokens) {
-    const tokens = eventTokens({ src: run.src, tok, st: run.st });
+    let tokens = eventTokens({ src: run.src, tok, st: run.st });
+    if (tok.kind === "tag") {
+      const tag = parseTagChunk(run.src.slice(tok.start, tok.end));
+      if (tag !== void 0) tagInCell(run.cd, tag);
+    } else if (!run.cd.inCell) {
+      tokens = [];
+    }
     if (tokens.length > 0) groups.push({ tokens, tok });
   }
   if (res.invalid !== void 0) {
@@ -11133,6 +11310,7 @@ function eventGroups(run, res) {
 }
 function deliver(run, last) {
   const first = last.tokens[0];
+  releaseXb(run.cd, first);
   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);
@@ -11147,7 +11325,10 @@ function deliver(run, last) {
 function runEvents(run, res) {
   const groups = eventGroups(run, res);
   const last = groups.pop();
-  for (const g of groups) absorb(run.carry, g.tokens);
+  for (const g of groups) {
+    absorb(run.carry, g.tokens);
+    keepLostText(run.cd, g.tokens);
+  }
   if (last !== void 0) deliver(run, last);
 }
 function appendString(into, more) {
@@ -11178,7 +11359,8 @@ function tokenizeDeferred(src, label = { start: 0, end: src.length }) {
     tokens: [],
     st: { stack: [], prev: "", curr: "" },
     expat: new ExpatFeed(src),
-    carry: { warnings: [], warn: false }
+    carry: { warnings: [], warn: false },
+    cd: initialCharData()
   };
   let error;
   try {
@@ -11187,8 +11369,7 @@ function tokenizeDeferred(src, label = { start: 0, end: src.length }) {
       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));
+      runEvents(run, run.expat.feed(u.start, u.end, !run.st.curr.startsWith("<")));
     }
     const held = run.expat.held;
     if (held !== void 0) error = unfinishedError(run, held);
@@ -11204,9 +11385,6 @@ function tokenizeDeferred(src, label = { start: 0, end: src.length }) {
 }
 
 // src/common/htmltable-parse-attrs.ts
-function anchorAttr(v) {
-  return v === void 0 ? void 0 : htmlEntityUTF8(v);
-}
 var parseAlign = (v) => {
   const u = v.toUpperCase();
   if (u === "LEFT") return "left";
@@ -11214,6 +11392,7 @@ var parseAlign = (v) => {
   if (u === "CENTER") return "center";
   return void 0;
 };
+var parseCellAlign = (v) => v.toUpperCase() === "TEXT" ? "text" : parseAlign(v);
 var parseVAlign = (v) => {
   const u = v.toUpperCase();
   if (u === "TOP") return "top";
@@ -11247,7 +11426,7 @@ var buildCell = (content, a) => ({
   kind: "cell",
   content,
   port: a["port"],
-  align: parseAlign(a["align"] !== void 0 ? a["align"] : ""),
+  align: parseCellAlign(a["align"] !== void 0 ? a["align"] : ""),
   valign: parseVAlign(a["valign"] !== void 0 ? a["valign"] : ""),
   balign: parseAlign(a["balign"] !== void 0 ? a["balign"] : ""),
   bgcolor: a["bgcolor"],
@@ -11263,9 +11442,9 @@ var buildCell = (content, a) => ({
   fixedsize: parseFixedSize(a),
   colspan: num(a["colspan"]),
   rowspan: num(a["rowspan"]),
-  href: anchorAttr(a["href"]),
+  href: a["href"],
   title: parseTitle(a),
-  target: anchorAttr(a["target"]),
+  target: a["target"],
   id: a["id"]
 });
 var buildTable = (rows, a) => ({
@@ -11283,9 +11462,9 @@ var buildTable = (rows, a) => ({
   fixedsize: parseFixedSize(a),
   width: num(a["width"]),
   height: num(a["height"]),
-  href: anchorAttr(a["href"]),
+  href: a["href"],
   title: parseTitle(a),
-  target: anchorAttr(a["target"]),
+  target: a["target"],
   id: a["id"],
   port: a["port"],
   sides: parseSides(a["sides"]),
@@ -11353,7 +11532,8 @@ var tableFont = (fontStack) => {
 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 nonSpace = (text) => /[^ ]/.test(text);
+var heldNonSpace = (tbl) => tbl?.type === "open" && nonSpace(tbl.heldText ?? "");
 var parseError = (s, tok, message) => {
   if (tok !== void 0) emitWarnings(s, tok);
   else emitEof(s);
@@ -11374,41 +11554,29 @@ var applyBrTag = (s, t, fontStack, items) => {
   items.push({ br: true, brAlign: parseAlign(t.attrs["align"] ?? ""), ...fontItemProps(font) });
   consumeClose(s, "BR");
 };
-var applyFontTag = (s, t, fontStack, items) => {
-  consume(s);
-  const font = fontStack[fontStack.length - 1] ?? {};
-  fontStack.push(mergeFontState(font, {
-    fontColor: t.attrs["color"],
-    fontFace: t.attrs["face"],
-    fontSize: num(t.attrs["point-size"])
-  }));
+var parseStyledText = (s, tag, fontStack, items) => {
   const inner = parseText(s, fontStack);
   fontStack.pop();
-  items.push(...inner.items);
   const nxt = peek(s);
-  if (nxt?.type === "close" && nxt.tag === "FONT") consume(s);
+  if (inner.items.length === 0 || nxt?.type !== "close" || nxt.tag !== tag) {
+    throw parseError(s, nxt, MSG_SYNTAX_ERROR);
+  }
+  items.push(...inner.items);
+  consume(s);
 };
-var applyInlineTag = (s, t, fontStack, items) => {
+var applyStyleTag = (s, t, fontStack, items) => {
   consume(s);
-  const font = fontStack[fontStack.length - 1] ?? {};
-  fontStack.push(mergeFontState(font, inlineFontState(t.tag, t.attrs)));
-  const inner = parseText(s, fontStack);
-  fontStack.pop();
-  items.push(...inner.items);
-  const nxt = peek(s);
-  if (nxt?.type === "close" && nxt.tag === t.tag) consume(s);
+  const own = t.tag === "FONT" ? { fontColor: t.attrs["color"], fontFace: t.attrs["face"], fontSize: num(t.attrs["point-size"]) } : inlineFontState(t.tag, t.attrs);
+  fontStack.push(mergeFontState(fontStack[fontStack.length - 1] ?? {}, own));
+  parseStyledText(s, t.tag, fontStack, items);
 };
 var applyOpenTag = (s, t, fontStack, items) => {
   if (t.tag === "BR") {
     applyBrTag(s, t, fontStack, items);
     return true;
   }
-  if (t.tag === "FONT") {
-    applyFontTag(s, t, fontStack, items);
-    return true;
-  }
-  if (isInlineTag(t.tag)) {
-    applyInlineTag(s, t, fontStack, items);
+  if (t.tag === "FONT" || isInlineTag(t.tag)) {
+    applyStyleTag(s, t, fontStack, items);
     return true;
   }
   return false;
@@ -11451,7 +11619,7 @@ var parseFontTable = (s, open, fontStack) => {
   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);
+  if ((textBefore || heldNonSpace(tblTok)) && tblTok !== void 0) throw parseError(s, tblTok, MSG_TEXT_BEFORE_TABLE);
   const table = parseTable(s, fontStack);
   const textAfter = skipStrings(s);
   const close = peek(s);
@@ -11468,11 +11636,11 @@ var rejectTableAfterTag = (s, start) => {
     throw parseError(s, nxt, MSG_SYNTAX_ERROR);
   }
 };
-var parseImgContent = (s, t, cellAttrs) => {
+var parseImgContent = (s, t) => {
   consume(s);
   const img = {
     kind: "image",
-    src: cellAttrs["src"] ?? t.attrs["src"] ?? "",
+    src: t.attrs["src"] ?? "",
     scale: t.attrs["scale"]
   };
   consumeClose(s, "IMG");
@@ -11480,7 +11648,7 @@ var parseImgContent = (s, t, cellAttrs) => {
 };
 var scanCellTable = (s, t, fontStack, st) => {
   if (st.kind === "image" || st.kind === "table") throw parseError(s, t, MSG_SYNTAX_ERROR);
-  if (st.textNonSpace) throw parseError(s, t, MSG_TEXT_BEFORE_TABLE);
+  if (st.textNonSpace || heldNonSpace(t)) throw parseError(s, t, MSG_TEXT_BEFORE_TABLE);
   const tbl = parseTable(s, fontStack);
   st.kind = "table";
   return [tbl];
@@ -11500,12 +11668,12 @@ var scanAfterTable = (s, t, st) => {
   if (nonSpace(t.value)) st.afterNonSpace = true;
   return [];
 };
-var scanCellImage = (s, t, cellAttrs, st) => {
+var scanCellImage = (s, t, st) => {
   if (st.kind !== "none") throw parseError(s, t, MSG_SYNTAX_ERROR);
   st.kind = "image";
-  return [parseImgContent(s, t, cellAttrs)];
+  return [parseImgContent(s, t)];
 };
-var scanCellItem = (s, t, cellAttrs, fontStack, st) => {
+var scanCellItem = (s, t, fontStack, st) => {
   if (st.kind === "fonttable") throw parseError(s, t, MSG_SYNTAX_ERROR);
   if (st.kind === "table") return scanAfterTable(s, t, st);
   const wrapper = st.kind === "none" ? fontTableWrapper(s) : void 0;
@@ -11514,7 +11682,7 @@ var scanCellItem = (s, t, cellAttrs, fontStack, st) => {
     return [parseFontTable(s, wrapper, fontStack)];
   }
   if (t.type === "open" && t.tag === "TABLE") return scanCellTable(s, t, fontStack, st);
-  if (t.type === "open" && t.tag === "IMG") return scanCellImage(s, t, cellAttrs, st);
+  if (t.type === "open" && t.tag === "IMG") return scanCellImage(s, t, st);
   if (st.kind === "image") throw parseError(s, t, MSG_SYNTAX_ERROR);
   return scanCellText(s, t, fontStack, st);
 };
@@ -11524,12 +11692,12 @@ var endsCell = (s, t, st) => {
   if (t.tag === "TD" && !afterText) return true;
   throw parseError(s, t, afterText ? MSG_TEXT_AFTER_TABLE : MSG_SYNTAX_ERROR);
 };
-var parseCellContent = (s, cellAttrs, fontStack) => {
+var parseCellContent = (s, fontStack) => {
   const content = [];
   const st = { kind: "none", textNonSpace: false, afterNonSpace: false };
   for (let t = peek(s); t !== void 0; t = peek(s)) {
     if (endsCell(s, t, st)) break;
-    content.push(...scanCellItem(s, t, cellAttrs, fontStack, st));
+    content.push(...scanCellItem(s, t, fontStack, st));
   }
   const nxt = peek(s);
   if (nxt?.type === "close" && nxt.tag === "TD") consume(s);
@@ -11537,7 +11705,7 @@ var parseCellContent = (s, cellAttrs, fontStack) => {
   if (tbl !== void 0) return [tbl];
   return content;
 };
-var parseCell = (s, attrs, fontStack) => buildCell(parseCellContent(s, attrs, fontStack), attrs);
+var parseCell = (s, attrs, fontStack) => buildCell(parseCellContent(s, fontStack), attrs);
 var parseRowVr = (s, t, cells) => {
   const prev = cells[cells.length - 1];
   if (prev === void 0) throw parseError(s, t, MSG_SYNTAX_ERROR);
@@ -11635,14 +11803,14 @@ var consumeRowHr = (s, rows) => {
 var findFirstRealToken = (tokens, start) => {
   for (let i = start; i < tokens.length; i++) {
     const tk = tokens[i];
-    if (tk.type !== "text" || tk.value.trim() !== "") return tk;
+    if (tk.type !== "text" || nonSpace(tk.value)) return tk;
   }
   return void 0;
 };
 var skipLeadingWs = (s) => {
   while (true) {
     const nxt = peek(s);
-    if (!nxt || nxt.type !== "text" || nxt.value.trim() !== "") break;
+    if (!nxt || nxt.type !== "text" || nonSpace(nxt.value)) break;
     consume(s);
   }
 };
@@ -11668,6 +11836,7 @@ var parseFontTableLabel = (s, open, fontStack) => {
 };
 var parseTableLabel = (s, fontStack) => {
   skipLeadingWs(s);
+  if (heldNonSpace(peek(s))) throw parseError(s, peek(s), MSG_TEXT_BEFORE_TABLE);
   const table = parseTable(s, fontStack);
   finishTableLabel(s);
   return { kind: "table", table };
@@ -11697,17 +11866,9 @@ var parseTokens = (s) => {
   if (firstReal?.type === "open" && firstReal.tag === "TABLE") return parseTableLabel(s, fontStack);
   return parseTextLabel(s, fontStack);
 };
-var parseHtmlLabelRv = (src, writeLine = (line) => console.warn(line)) => {
+var parseHtmlLabelRv = (src, stderr) => {
   const { tokens, error, eof } = tokenizeDeferred(`<HTML>${src}</HTML>`, { start: 6, end: 6 + src.length });
-  const s = {
-    tokens,
-    pos: 0,
-    pending: error,
-    stderr: new StderrLines(writeLine),
-    emitted: /* @__PURE__ */ new WeakSet(),
-    warn: false,
-    eof
-  };
+  const s = { tokens, pos: 0, pending: error, stderr, emitted: /* @__PURE__ */ new WeakSet(), warn: false, eof };
   try {
     const label = parseTokens(s);
     if (error !== void 0) throw error;
@@ -11718,11 +11879,9 @@ var parseHtmlLabelRv = (src, writeLine = (line) => console.warn(line)) => {
       throw error;
     }
     throw e;
-  } finally {
-    s.stderr?.flush();
   }
 };
-var parseHtmlLabel = (src) => parseHtmlLabelRv(src, () => void 0).label;
+var parseHtmlLabel = (src) => parseHtmlLabelRv(src, new StderrLines(() => void 0)).label;
 
 // src/gvc/usershape.ts
 var activeSizer = null;
@@ -11924,7 +12083,7 @@ var sizeTextContent = (texts, measurer, env = defaultSizeEnv()) => {
   return { w, h };
 };
 var missingImages = /* @__PURE__ */ new WeakSet();
-var sizeHtmlImg = (img, imageSizer) => {
+var sizeHtmlImg = (img, { imageSizer, stderr }) => {
   if (img.width !== void 0 && img.height !== void 0) return missingImages.has(img) ? 1 : 0;
   const sz = imageSizer !== void 0 ? imageSizer(img.src) : findImageSize(img.src);
   if (sz !== null) {
@@ -11932,7 +12091,7 @@ var sizeHtmlImg = (img, imageSizer) => {
     img.height = sz.h;
     return 0;
   }
-  console.error(`Error: No or improper image file="${img.src}"`);
+  agerrLine(stderr, `Error: No or improper image file="${img.src}"`);
   img.width = 0;
   img.height = 0;
   missingImages.add(img);
@@ -11945,7 +12104,7 @@ var sizeContentItem = (item, measurer, env) => {
     return { ...item.dimen !== void 0 ? item.dimen : { w: 0, h: 0 }, rv };
   }
   if (item.kind === "image") {
-    const rv = sizeHtmlImg(item, env.imageSizer);
+    const rv = sizeHtmlImg(item, env);
     return { w: item.width ?? 0, h: item.height ?? 0, rv };
   }
   return { w: 0, h: 0, rv: 0 };
@@ -11975,14 +12134,14 @@ var WARN_CELL_UNSPECIFIED = "Warning: fixed cell size with unspecified width or
 var WARN_TABLE_TOO_SMALL = "Warning: table size too small for content";
 var WARN_TABLE_UNSPECIFIED = "Warning: fixed table size with unspecified width or height";
 var sizeWarned = /* @__PURE__ */ new WeakSet();
-var fixedCellCheck = (cell2, sz, warn) => {
+var fixedCellCheck = (cell2, sz, warn, out) => {
   if (!cell2.fixedsize) return { rv: 0, zero: false };
   if (cell2.width && cell2.height) {
     const small = (cell2.width < sz.w || cell2.height < sz.h) && cell2.content[0]?.kind !== "image";
-    if (small && warn) console.warn(WARN_CELL_TOO_SMALL);
+    if (small && warn) agerrLine(out, WARN_CELL_TOO_SMALL);
     return { rv: small ? 1 : 0, zero: true };
   }
-  if (warn) console.warn(WARN_CELL_UNSPECIFIED);
+  if (warn) agerrLine(out, WARN_CELL_UNSPECIFIED);
   return { rv: 1, zero: false };
 };
 var getCellSize = (cell2, tbl, measurer, env) => {
@@ -11998,7 +12157,7 @@ var getCellSize = (cell2, tbl, measurer, env) => {
   let szy = ch + margin;
   const warn = !sizeWarned.has(cell2);
   sizeWarned.add(cell2);
-  const fixed = fixedCellCheck(cell2, { w: szx, h: szy }, warn);
+  const fixed = fixedCellCheck(cell2, { w: szx, h: szy }, warn, env.stderr);
   rv |= fixed.rv;
   if (fixed.zero) {
     szx = 0;
@@ -12092,22 +12251,22 @@ var layoutHtmlTable = (tbl, measurer, env = defaultSizeEnv()) => {
   const heights = setRowHeights(entries, nrows, spacing);
   return { entries, widths, heights, spacing, border: border2, rv };
 };
-var warnFixedTable = (tbl, dims) => {
+var warnFixedTable = (tbl, dims, out) => {
   const warn = !sizeWarned.has(tbl);
   sizeWarned.add(tbl);
   if (tbl.fixedsize !== true) return 0;
   if (tbl.width && tbl.height) {
     if (tbl.width >= dims.wd && tbl.height >= dims.ht) return 0;
-    if (warn) console.warn(WARN_TABLE_TOO_SMALL);
+    if (warn) agerrLine(out, WARN_TABLE_TOO_SMALL);
     return 1;
   }
-  if (warn) console.warn(WARN_TABLE_UNSPECIFIED);
+  if (warn) agerrLine(out, WARN_TABLE_UNSPECIFIED);
   return 1;
 };
 var sizeTableBody = (tbl, measurer, env) => {
   const { entries, widths, heights, spacing, border: border2, rv } = layoutHtmlTable(tbl, measurer, env);
   if (entries.length === 0) {
-    const fixed2 = warnFixedTable(tbl, sumTableDims({ widths, heights, ncols: 0, nrows: 0, spacing, border: border2 }));
+    const fixed2 = warnFixedTable(tbl, sumTableDims({ widths, heights, ncols: 0, nrows: 0, spacing, border: border2 }), env.stderr);
     tbl.dimen = { w: 0, h: 0 };
     return rv | fixed2;
   }
@@ -12117,7 +12276,7 @@ var sizeTableBody = (tbl, measurer, env) => {
   const { wd, ht } = sumTableDims({ widths, heights, ncols, nrows, spacing, border: border2 });
   const baseWd = tbl.width !== void 0 ? tbl.width : 0;
   const baseHt = tbl.height !== void 0 ? tbl.height : 0;
-  const fixed = warnFixedTable(tbl, { wd, ht });
+  const fixed = warnFixedTable(tbl, { wd, ht }, env.stderr);
   const zeroContent = isTblFixed(tbl) && baseWd !== 0 && baseHt !== 0;
   tbl.dimen = {
     w: Math.max(zeroContent ? 0 : wd, baseWd),
@@ -17449,7 +17608,7 @@ function placeComplexRuns(runs, box, finfo, measurer) {
 function alignContentBox(box, cell2, w, h) {
   const out = { ll: { ...box.ll }, ur: { ...box.ur } };
   const delx = out.ur.x - out.ll.x - w;
-  if (delx > 0) {
+  if (delx > 0 && cell2.align !== "text") {
     if (cell2.align === "left") out.ur.x -= delx;
     else if (cell2.align === "right") out.ll.x += delx;
     else {
@@ -17704,21 +17863,25 @@ function posHtmlLabel(label, finfo, measurer) {
   if (label.kind === "table") return withTableFont(env, label.table.font, "emit", () => posHtmlTable(label.table, env, measurer));
   return posTextLabel(label, finfo, measurer);
 }
+
+// src/common/htmltable-label.ts
 var HTML_PARSE_FATAL = 3;
-function makeHtmlLabelRv(content, finfo, measurer) {
+function makeHtmlLabelTo(content, finfo, measurer, stderr) {
   const { fontname, fontsize, fontcolor, imageSizer, pencolor } = finfo;
   let lbl, lexWarn;
   try {
-    ({ label: lbl, warn: lexWarn } = parseHtmlLabelRv(content));
+    ({ label: lbl, warn: lexWarn } = parseHtmlLabelRv(content, stderr));
   } catch (e) {
-    if (e instanceof HtmlLexError) for (const line of e.diagnostics) console.error(line);
+    if (e instanceof HtmlLexError) for (const line of e.diagnostics) stderr.write(`${line}
+`);
     return { label: makeLabel("", fontname, fontsize, fontcolor, measurer), rv: HTML_PARSE_FATAL };
   }
   if (lbl.kind === "table") inheritTablePenColor(lbl.table, pencolor);
   const rv = Number(lexWarn) | sizeHtmlLabel(lbl, measurer, {
     fontsize,
     fontname,
-    imageSizer
+    imageSizer,
+    stderr
   });
   const placed = posHtmlLabel(lbl, { fontname, fontsize, fontcolor }, measurer);
   const dim = lbl.dimen ?? { w: 0, h: 0 };
@@ -17917,8 +18080,11 @@ function makeLabel(text, fontname, fontsize, fontcolor, measurer) {
 function makeAnyLabel(content, isHtml, font, measurer, obj) {
   if (isHtml && content !== "") {
     const imageSizer = obj !== void 0 ? rootOf(obj).info.gvc?.imageSizer : void 0;
-    const { label, rv } = makeHtmlLabelRv(content, { ...font, pencolor: getPenColor(obj), imageSizer }, measurer);
-    if (rv !== 0 && obj !== void 0) console.error(inLabelOf(obj));
+    const stderr = labelStderr();
+    const { label, rv } = makeHtmlLabelTo(content, { ...font, pencolor: getPenColor(obj), imageSizer }, measurer, stderr);
+    if (rv !== 0 && obj !== void 0) stderr.write(`${inLabelOf(obj)}
+`);
+    stderr.flush();
     return label;
   }
   const subst2 = obj !== void 0 ? substObj(content, obj, false) : content;
@@ -24886,7 +25052,7 @@ function renderNodeLabel(n, coord, renderer, job) {
     renderLabel(label, coord, renderer, job);
   }
 }
-function anchorAttr2(n, key) {
+function anchorAttr(n, key) {
   const v = nodeAttr(n, n.root, key);
   return v !== void 0 && v !== "" ? v : void 0;
 }
@@ -24896,13 +25062,13 @@ function resolveTooltip(n, tooltip) {
   return label?.text ?? "";
 }
 function beginNodeAnchor(n, renderer, job) {
-  const url = anchorAttr2(n, "href") ?? anchorAttr2(n, "URL");
-  const tooltip = anchorAttr2(n, "tooltip");
+  const url = anchorAttr(n, "href") ?? anchorAttr(n, "URL");
+  const tooltip = anchorAttr(n, "tooltip");
   if (url === void 0 && tooltip === void 0) return false;
   renderer.beginAnchor?.(
     url !== void 0 ? substObjAnchor(url, n) : "",
     resolveTooltip(n, tooltip),
-    anchorAttr2(n, "target") ?? "",
+    anchorAttr(n, "target") ?? "",
     svgNodeId(n, job),
     job
   );