@knowvah/dot-engine 2.6.6 → 2.6.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knowvah/dot-engine",
-  "version": "2.6.6",
+  "version": "2.6.7",
   "description": "Faithful TypeScript port of Graphviz (dot, neato, fdp, sfdp, circo, twopi, osage, patchwork) — no C: no native binary, no WASM. Oracle-verified against the C implementation, runs in the browser.",
   "keywords": [
     "graphviz",

package/src/common/htmltable-lex-chardata.ts

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * The htmllex state characterData reads: `ctx->inCell`, which the element
+ * handlers set, and `ctx->xb`, the buffer it appends to. Every handler assigns
+ * `ctx->tok`, so when one `XML_Parse` call fires several events only the last
+ * token reaches the parser, but characters an earlier event appended stay in
+ * xb: they lead the next string the parser reduces, or count in the table
+ * rule's nonSpace check.
+ *
+ * @see lib/common/htmllex.c:startElement
+ * @see lib/common/htmllex.c:endElement
+ * @see lib/common/htmllex.c:characterData
+ */
+
+import { htmlEntityUTF8 } from './html-entities.js';
+import type { TagChunk } from './htmltable-lex-expat.js';
+import type { Token } from './htmltable-types.js';
+
+/** `ctx->inCell`, and the text in `ctx->xb` that no token carried to the parser. */
+export interface CharDataState {
+  inCell: boolean;
+  xb: string;
+}
+
+/** initHTMLlexer: text is kept until the first TABLE or TR. @see lib/common/htmllex.c:initHTMLlexer */
+export const initialCharData = (): CharDataState => ({ inCell: true, xb: '' });
+
+/** startElement's assignment to inCell for element `name` (upper case). */
+function startInCell(name: string, inCell: boolean): boolean {
+  if (name === 'TABLE' || name === 'TR' || name === 'TH') return false;
+  return name === 'TD' ? true : inCell;
+}
+
+/** endElement's assignment to inCell for element `name` (upper case). */
+function endInCell(name: string, inCell: boolean): boolean {
+  if (name === 'TABLE') return true;
+  return name === 'TD' ? false : inCell;
+}
+
+/** Run a tag's element handlers on inCell; `<X/>` runs startElement, then endElement. */
+export function tagInCell(st: CharDataState, tag: TagChunk): void {
+  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);
+}
+
+/** Keep the text of tokens a later event in the same call overwrote. */
+export function keepLostText(st: CharDataState, lost: readonly Token[]): void {
+  for (const t of lost) if (t.type === 'text') st.xb += t.value;
+}
+
+/**
+ * Hand xb's kept text to the token the parser is about to get: a string
+ * starts with it, and a TABLE carries it for the table rule's nonSpace check.
+ * Any other token leaves it in xb for the next of those.
+ * @see lib/common/htmlparse.y:table
+ */
+export function releaseXb(st: CharDataState, first: Token): void {
+  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 = '';
+}
+
+/**
+ * characterData keeps each byte `>= ' '` of the text expat decoded: anything
+ * below 0x20 goes (tab, LF and CR too, from the source or a character
+ * reference); DEL and non-ASCII stay.
+ * @see lib/common/htmllex.c:characterData
+ */
+function cleanText(decoded: string) {
+  return decoded.replace(/[\x00-\x1f]/g, '');
+}
+
+/** The text token of a text run, if anything is left after cleaning. */
+export function textTokens(raw: string): Token[] {
+  // Decode XML/HTML entities in the text run. C's HTML lexer resolves entities
+  // via expat during tokenization (htmllex.c), so both sizing and emit see the
+  // decoded UTF-8 text. Skipping this measured the raw "&#91;el..." (9-10 chars)
+  // instead of "[el..." (6 chars), inflating edge-label vnodes and shifting
+  // layout (corpus 1949: +18.7px). Plain-string labels already decode via the
+  // make_label path, so only HTML-delimited labels diverged.
+  return charDataTokens(htmlEntityUTF8(raw));
+}
+
+/** characterData on what expat decoded: a T_string when any character survives. */
+export function charDataTokens(decoded: string): Token[] {
+  const clean = cleanText(decoded);
+  return clean.length > 0 ? [{ type: 'text', value: clean }] : [];
+}

package/src/common/htmltable-lex-expat.ts

@@ -26,9 +26,11 @@ const INIT_BUFFER_SIZE = 1024;
 
 /** One complete expat token of the content: its extent in the label source. */
 export interface ExpatToken {
-  kind: 'text' | 'tag' | 'comment' | 'pi';
+  kind: 'text' | 'tag' | 'comment' | 'pi' | 'cdata';
   start: number;
   end: number;
+  /** A `cdata` token's character data, as expat reports it (no entity decoding). */
+  data?: string;
   /** Offset of the second occurrence of an attribute name in a start tag. */
   dup?: number;
 }
@@ -69,18 +71,24 @@ function skipSpace(text: string, i: number): number {
 const byteLength = (s: string): number => new TextEncoder().encode(s).length;
 
 /**
- * The number of bytes C passes to `XML_Parse` for a text unit: the buffer
- * `findNext` filled (named entities rewritten as `&#N;`, see `scanEntity`)
- * with a trailing `]` escaped (`protect_rsqb`). Other units go as written.
+ * What C passes to `XML_Parse` for (a piece of) a text unit: the buffer
+ * `findNext` filled (named entities rewritten as `&#N;`, see `scanEntity`),
+ * with a `]` that ends the unit escaped (`protect_rsqb`). Outside a CDATA
+ * section expat decodes both back to the characters written; inside one they
+ * stay as rewritten.
+ * @see lib/common/htmllex.c:findNext
  * @see lib/common/htmllex.c:protect_rsqb
  */
-export function fedBytes(unit: string, isText: boolean): number {
-  if (!isText) return byteLength(unit);
-  let text = unit.replace(/&([^;&<]*);/g, (m, name: string) => {
+function fedText(piece: string, endsUnit: boolean): string {
+  const text = piece.replace(/&([^;&<]*);/g, (m, name: string) => {
     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;
+}
+
+/** The number of bytes C passes to `XML_Parse` for a unit; other than text units go as written. */
+export function fedBytes(unit: string, isText: boolean): number {
+  return byteLength(isText ? fedText(unit, true) : unit);
 }
 
 interface Pair {
@@ -219,29 +227,65 @@ interface ContentScan {
   /** Offset where the unconsumed (partial) token starts. */
   consumed: number;
   invalid?: number;
+  /** Whether the scan ended inside a CDATA section. */
+  inCdata: boolean;
+}
+
+const CDATA_OPEN = '<![CDATA[';
+const CDATA_CLOSE = ']]>';
+
+/**
+ * Character data of a CDATA section from `p` up to its `]]>` (or the end of
+ * what was fed): one `cdata` token, then the index after the section, or -1
+ * while it is still open. Markup and `&` are data here. The fed bytes never
+ * end in a `]` (text units go through protect_rsqb, other units end in `>`),
+ * so expat holds no partial `]]>` back.
+ * @see expat xmltok_impl.c:PREFIX(cdataSectionTok)
+ */
+function scanCdata(text: string, p: number, base: number, dataOf: CdataText, tokens: ExpatToken[]): number {
+  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;
 }
 
+/** Character data at `p` up to the next `<`: one `text` token, then the index it ends at. */
+function scanText(text: string, p: number, base: number, tokens: ExpatToken[]): number {
+  const e = text.indexOf('<', p);
+  const end = e < 0 ? text.length : e;
+  tokens.push({ kind: 'text', start: base + p, end: base + end });
+  return end;
+}
+
+/** The fed text of the label source between two offsets. */
+type CdataText = (start: number, end: number) => string;
+
 /** Tokenize `text` (a label slice at `base`) as far as expat can: tokens, then partial or invalid. */
-function scanContent(text: string, base: number): ContentScan {
+function scanContent(text: string, base: number, inCdata: boolean, dataOf: CdataText): ContentScan {
   const tokens: ExpatToken[] = [];
   let p = 0;
+  let inSection = inCdata;
   while (p < text.length) {
+    if (inSection || text.startsWith(CDATA_OPEN, p)) {
+      const after = scanCdata(text, inSection ? p : p + CDATA_OPEN.length, base, dataOf, tokens);
+      if (after < 0) return { tokens, consumed: text.length, inCdata: true };
+      inSection = false;
+      p = after;
+      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: ExpatToken = { kind, start: base + p, end: base + scan.end };
     if (scan.dup !== undefined) tok.dup = base + scan.dup;
     tokens.push(tok);
     p = scan.end;
   }
-  return { tokens, consumed: p };
+  return { tokens, consumed: p, inCdata: inSection };
 }
 
 /**
@@ -297,6 +341,9 @@ export class ExpatFeed {
   private readonly buffer = new InputBuffer();
   private heldStart = 0;
   private fedEnd = 0;
+  private inCdata = false;
+  /** Source ranges of the text units fed so far: their bytes went through findNext's rewrite. */
+  private readonly textUnits: Array<readonly [number, number]> = [];
 
   constructor(private readonly src: string) {}
 
@@ -305,20 +352,36 @@ export class ExpatFeed {
     return this.heldStart < this.fedEnd ? this.heldStart : undefined;
   }
 
-  /** One `XML_Parse(parser, src[start, end), nbytes, 0)`. */
-  feed(start: number, end: number, nbytes: number): ExpatResult {
-    this.buffer.append(nbytes);
+  /** One `XML_Parse(parser, src[start, end), nbytes, 0)`; `isText` for a text unit. */
+  feed(start: number, end: number, isText: boolean): ExpatResult {
+    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 !== undefined) {
       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. */
+  private fedBetween(start: number, end: number): string {
+    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);
+  }
 }
 
 /** Entities expat knows without a DTD; `scanEntity` leaves them as written. */

package/src/common/htmltable-lex.ts

@@ -13,10 +13,11 @@
 
 import { HtmlParseError } from './htmltable-types.js';
 import type { LexerOutput, OpenToken, TextToken, Token } from './htmltable-types.js';
-import { htmlEntityUTF8 } from './html-entities.js';
 import { checkAttrs } from './htmltable-attr-warn.js';
 import type { AttrEntry } from './htmltable-attr-warn.js';
-import { ExpatFeed, fedBytes, findUndefinedEntity, parseTagChunk } from './htmltable-lex-expat.js';
+import { ExpatFeed, findUndefinedEntity, parseTagChunk } from './htmltable-lex-expat.js';
+import { charDataTokens, initialCharData, keepLostText, releaseXb, tagInCell, textTokens } from './htmltable-lex-chardata.js';
+import type { CharDataState } from './htmltable-lex-chardata.js';
 import type { ExpatResult, ExpatToken } from './htmltable-lex-expat.js';
 import { findNext } from './htmltable-lex-units.js';
 import type { Unit } from './htmltable-lex-units.js';
@@ -93,33 +94,25 @@ function parseCloseToken(inner: string) {
   return { type: 'close' as const, tag: normalizeTag(tag) };
 }
 
-/** @see lib/common/htmllex.c:characterData */
-function cleanText(raw: string) {
-  const isKeep = (c: string) => c === ' ' || c === '\t' || c === '\n' || c === '\r';
-  return raw.replace(/[\x00-\x1f\x7f]/g, (c) => isKeep(c) ? c : '');
-}
-
-/** The text token of a text run, if anything is left after cleaning. */
-function textTokens(raw: string): Token[] {
-  // Decode XML/HTML entities in the text run. C's HTML lexer resolves entities
-  // via expat during tokenization (htmllex.c), so both sizing and emit see the
-  // decoded UTF-8 text. Skipping this measured the raw "[el..." (9-10 chars)
-  // instead of "[el..." (6 chars), inflating edge-label vnodes and shifting
-  // layout (corpus 1949: +18.7px). Plain-string labels already decode via the
-  // make_label path, so only HTML-delimited labels diverged.
-  const clean = htmlEntityUTF8(cleanText(raw));
-  return clean.length > 0 ? [{ type: 'text', value: clean }] : [];
-}
+/** Elements whose `<X/>` endElement folds into one token. @see lib/common/htmllex.c:endElement */
+const EMPTY_ELEMENTS: ReadonlySet<string> = new Set(['BR', 'HR', 'VR', 'IMG']);
 
 /** The tokens of one complete `<..>` tag. */
 function tagTokens(text: string): Token[] {
   const inner = text.slice(1, -1).trim();
   if (inner.startsWith('/')) return [parseCloseToken(inner)];
-  // Self-closing <X/>: expat reports startElement then endElement.
-  // @see lib/common/htmllex.c (XML_SetElementHandler callbacks)
+  // Self-closing <X/>: expat reports startElement then endElement in one call,
+  // and endElement's `ctx->tok` overwrites startElement's. Only BR, HR, VR and
+  // IMG turn the pair into one token (T_BR etc.); any other element reaches the
+  // parser as its close tag alone, with what startElement printed.
+  // @see lib/common/htmllex.c:endElement
   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: Token = { type: 'close', tag: open.tag };
+    if (open.warnings !== undefined) close.warnings = open.warnings;
+    if (open.warn === true) close.warn = true;
+    return [close];
   }
   return [parseOpenToken(inner)];
 }
@@ -274,6 +267,8 @@ function eventTokens(site: TokenSite): Token[] {
   const { src, tok, st } = site;
   const text = src.slice(tok.start, tok.end);
   if (tok.kind === 'comment' || tok.kind === 'pi') return [];
+  // CDATA content is character data as is: no markup, no entity decoding.
+  if (tok.kind === 'cdata') return charDataTokens(tok.data ?? '');
   if (tok.kind === 'tag') {
     checkTagToken(site);
     return tagTokens(text);
@@ -298,6 +293,8 @@ interface LexRun {
   st: ChunkState;
   expat: ExpatFeed;
   carry: Carry;
+  /** `ctx->inCell` and `ctx->xb`. */
+  cd: CharDataState;
 }
 
 /** Move what `carry` holds onto `first`, the token the parser is about to get. */
@@ -326,7 +323,13 @@ interface EventGroup {
 function eventGroups(run: LexRun, res: ExpatResult): EventGroup[] {
   const groups: EventGroup[] = [];
   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 !== undefined) tagInCell(run.cd, tag);
+    } else if (!run.cd.inCell) {
+      tokens = []; // characterData appends only inside a cell
+    }
     if (tokens.length > 0) groups.push({ tokens, tok });
   }
   if (res.invalid !== undefined) {
@@ -343,6 +346,7 @@ function eventGroups(run: LexRun, res: ExpatResult): EventGroup[] {
  */
 function deliver(run: LexRun, last: EventGroup): void {
   const first = last.tokens[0]!;
+  releaseXb(run.cd, first);
   attachCarry(run.carry, first);
   const info: ChunkInfo = { src: run.src, pos: last.tok.start, end: last.tok.end, context: run.st.prev + run.st.curr };
   const prev = run.tokens.at(-1);
@@ -364,7 +368,10 @@ function deliver(run: LexRun, last: EventGroup): void {
 function runEvents(run: LexRun, res: ExpatResult): void {
   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 !== undefined) deliver(run, last);
 }
 
@@ -439,7 +446,7 @@ const eofOutput = (carry: Carry): LexerOutput | undefined => {
 export function tokenizeDeferred(src: string, label: LabelRange = { start: 0, end: src.length }): TokenizeResult {
   const run: LexRun = {
     src, tokens: [], st: { stack: [], prev: '', curr: '' }, expat: new ExpatFeed(src),
-    carry: { warnings: [], warn: false },
+    carry: { warnings: [], warn: false }, cd: initialCharData(),
   };
   let error: HtmlParseError | undefined;
   try {
@@ -448,8 +455,7 @@ export function tokenizeDeferred(src: string, label: LabelRange = { start: 0, en
       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 !== undefined) error = unfinishedError(run, held);

package/src/common/htmltable-parse.ts

@@ -44,12 +44,11 @@ const MSG_TEXT_BEFORE_TABLE = 'Syntax error: non-space string used before <TABLE
 /** @see lib/common/htmlparse.y:298 (table rule) */
 const MSG_TEXT_AFTER_TABLE = 'Syntax error: non-space string used after </TABLE>';
 
-/**
- * C's `nonSpace` on the lexer's text, which has already dropped control
- * characters; the port's tokens still carry tab, LF and CR.
- * @see lib/common/htmlparse.y:nonSpace
- */
-const nonSpace = (text: string): boolean => /[^ \t\n\r]/.test(text);
+/** Any character other than a space (the lexer already dropped control characters). @see lib/common/htmlparse.y:nonSpace */
+const nonSpace = (text: string): boolean => /[^ ]/.test(text);
+
+/** Text in `ctx->xb` that no token carried, which the table rule's nonSpace also reads. */
+const heldNonSpace = (tbl: Token | undefined): boolean => tbl?.type === 'open' && nonSpace(tbl.heldText ?? '');
 
 /**
  * The parse failure C reports through `htmlerror` when the lexer last returned
@@ -93,42 +92,40 @@ const applyBrTag = (
   consumeClose(s, 'BR');
 };
 
-const applyFontTag = (
-  s: ParseState, t: OpenToken, fontStack: FontState[], items: HtmlTextItem[],
-): void => {
-  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']),
-  }));
+/**
+ * `font text n_font` and the other font-style rules: `text` is one or more
+ * text items, and the matching close tag must follow it. Anything else, an
+ * empty element included, is a syntax error at the token found instead.
+ * @see lib/common/htmlparse.y:textitem
+ */
+const parseStyledText = (s: ParseState, tag: string, fontStack: FontState[], items: HtmlTextItem[]): void => {
   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);
 };
 
-const applyInlineTag = (
+/** `font text n_font` / `bold text n_bold` / ...: push the tag's font, parse its text, pop. */
+const applyStyleTag = (
   s: ParseState, t: OpenToken, fontStack: FontState[], items: HtmlTextItem[],
 ): void => {
   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);
 };
 
 const applyOpenTag = (
   s: ParseState, t: OpenToken, fontStack: FontState[], items: HtmlTextItem[],
 ): boolean => {
   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); return true; }
+  if (t.tag === 'FONT' || isInlineTag(t.tag)) { applyStyleTag(s, t, fontStack, items); return true; }
   return false;
 };
 
@@ -194,7 +191,7 @@ const parseFontTable = (s: ParseState, open: OpenToken, fontStack: FontState[]):
   fontStack.push(wrapperFont(open, fontStack));
   const textBefore = skipStrings(s);
   const tblTok = peek(s);
-  if (textBefore && tblTok !== undefined) throw parseError(s, tblTok, MSG_TEXT_BEFORE_TABLE);
+  if ((textBefore || heldNonSpace(tblTok)) && tblTok !== undefined) throw parseError(s, tblTok, MSG_TEXT_BEFORE_TABLE);
   const table = parseTable(s, fontStack);
   const textAfter = skipStrings(s);
   const close = peek(s);
@@ -249,7 +246,7 @@ const scanCellTable = (
   s: ParseState, t: Token, fontStack: FontState[], st: CellScan,
 ): HtmlCellContent[] => {
   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];
@@ -479,7 +476,7 @@ const consumeRowHr = (s: ParseState, rows: HtmlRow[]): void => {
 const findFirstRealToken = (tokens: Token[], start: number): Token | undefined => {
   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 undefined;
 };
@@ -487,7 +484,7 @@ const findFirstRealToken = (tokens: Token[], start: number): Token | undefined =
 const skipLeadingWs = (s: ParseState): void => {
   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);
   }
 };
@@ -518,6 +515,7 @@ const parseFontTableLabel = (s: ParseState, open: OpenToken, fontStack: FontStat
 
 const parseTableLabel = (s: ParseState, fontStack: FontState[]): HtmlLabel => {
   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 };

package/src/common/htmltable-types.ts

@@ -275,6 +275,8 @@ export interface OpenToken extends LexerOutput {
   type: 'open';
   tag: string;
   attrs: Record<string, string>;
+  /** On a TABLE: `ctx->xb` text no token carried, read by the table rule's nonSpace. */
+  heldText?: string;
 }
 
 /** @see lib/common/htmllex.c:endElement */