@knowvah/dot-engine 2.6.6 → 2.6.8

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

@@ -15,6 +15,9 @@
  */
 
 import { HTML_ENTITIES } from './html-entities.js';
+import {
+  attValueError, charRefNumber, scanAttValue, XML_ERROR_BAD_CHAR_REF, XML_ERROR_UNDEFINED_ENTITY, type AttValueError,
+} from './htmltable-lex-attvalue.js';
 
 /** expat `XML_ErrorString(XML_ERROR_INVALID_TOKEN)`. */
 export const XML_ERROR_INVALID_TOKEN = 'not well-formed (invalid token)';
@@ -26,11 +29,13 @@ 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;
-  /** Offset of the second occurrence of an attribute name in a start tag. */
-  dup?: number;
+  /** A `cdata` token's character data, as expat reports it (no entity decoding). */
+  data?: string;
+  /** A start tag's first storeAtts error: a duplicate name or a bad value. */
+  attError?: AttValueError & { offset: number };
 }
 
 /** The first well-formedness error of a parse call. */
@@ -45,13 +50,18 @@ export interface ExpatResult {
   invalid?: ExpatInvalid;
 }
 
+/** expat `XML_ErrorString(XML_ERROR_DUPLICATE_ATTRIBUTE)`. */
+const XML_ERROR_DUPLICATE_ATTRIBUTE = 'duplicate attribute';
+
+type AttError = AttValueError & { offset: number };
+
 type Scan =
-  | { kind: 'complete'; end: number; dup?: number }
+  | { kind: 'complete'; end: number; attError?: AttError }
   | { kind: 'partial' }
   | { kind: 'invalid'; offset: number };
 
-const COMPLETE_END = (end: number, dup?: number): Scan =>
-  dup === undefined ? { kind: 'complete', end } : { kind: 'complete', end, dup };
+const COMPLETE_END = (end: number, attError?: AttError): Scan =>
+  attError === undefined ? { kind: 'complete', end } : { kind: 'complete', end, attError };
 const PARTIAL: Scan = { kind: 'partial' };
 const INVALID = (offset: number): Scan => ({ kind: 'invalid', offset });
 
@@ -69,38 +79,45 @@ 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 {
   name: string;
   next: number;
+  /** The value between its quotes. */
+  value: { start: number; end: number };
 }
 
-/** The quoted value opening at `j`: the index after it and any white space, or how scanning stops. */
+/** The quoted value opening at `j`: its closing quote, or how scanning stops. */
 function scanValue(text: string, j: number): number | Scan {
   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);
   // Attributes are separated by white space.
   if (next === close + 1 && !'>/'.includes(text[next] ?? '>')) return INVALID(next);
-  return next;
+  return close;
 }
 
 /** The `name = "value"` pair at `i`, or how expat's tokenizer stops there. */
@@ -112,8 +129,9 @@ function scanPair(text: string, i: number): Pair | Scan {
   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 } };
 }
 
 /** `>` or `/>` at `i` ends the tag; end of data leaves it partial; otherwise more attributes. */
@@ -126,19 +144,30 @@ function tagEdge(text: string, i: number): Scan | undefined {
   return text[i + 1] === '>' ? COMPLETE_END(i + 2) : undefined;
 }
 
-/** The pairs of a start tag from `from`; a duplicate only counts once the tag tokenizes whole. */
-function scanAttributes(text: string, from: number): Scan {
+/**
+ * storeAtts on one attribute: a repeated name, else its value's error. Its
+ * undefined-entity error leaves the event pointer at the tag (`p`).
+ * @see expat lib/xmlparse.c:storeAtts
+ */
+function storeAttError(text: string, p: number, at: number, pair: Pair, seen: Set<string>): AttError | undefined {
+  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 === undefined ? undefined : { message: err.message, offset: err.offset ?? p };
+}
+
+/** The pairs of the start tag at `p` from `from`; storeAtts' errors only count once the tag tokenizes whole. */
+function scanAttributes(text: string, p: number, from: number): Scan {
   const seen = new Set<string>();
-  let dup: number | undefined;
+  let attError: AttError | undefined;
   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 !== undefined) 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;
   }
 }
@@ -157,7 +186,7 @@ function scanStartTag(text: string, p: number): Scan {
   const c = text[name.next];
   if (c === undefined) return PARTIAL;
   if (!isSpace(c) && c !== '>' && c !== '/') return INVALID(name.next);
-  return scanAttributes(text, name.next);
+  return scanAttributes(text, p, name.next);
 }
 
 /** An end tag at `p`: a name, optional white space, `>`. */
@@ -219,29 +248,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;
+    if (scan.attError !== undefined) 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 };
 }
 
 /**
@@ -297,6 +362,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 +373,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. */
@@ -326,18 +410,29 @@ const XML_PREDEFINED_ENTITIES = new Set(['lt', 'gt', 'amp', 'quot', 'apos']);
 
 const ENTITY_NAME = /^[A-Za-z_:][\w.:-]*$/;
 
-/** Offset of the first `&name;` that scanEntity leaves for expat to reject. */
-export function findUndefinedEntity(text: string): number {
+const CHAR_REF = /^&#(?:x[0-9A-Fa-f]+|[0-9]+);/;
+
+/**
+ * The first reference of character data that expat rejects, at its offset: a
+ * `&name;` scanEntity leaves alone (neither an HTML entity nor predefined), or
+ * a character reference XML does not allow.
+ * @see expat lib/xmlparse.c:doContent (XML_TOK_ENTITY_REF, XML_TOK_CHAR_REF)
+ */
+export function textRefError(text: string): { message: string; offset: number } | undefined {
   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 !== undefined && 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 undefined;
 }
 
 export interface TagChunk {

package/src/common/htmltable-lex.ts

@@ -13,12 +13,14 @@
 
 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, parseTagChunk, textRefError } 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 { decodeAttValue } from './htmltable-lex-attvalue.js';
 import type { Unit } from './htmltable-lex-units.js';
 
 export type { Token } from './htmltable-types.js';
@@ -41,7 +43,8 @@ const isWs = (c: string | undefined): boolean =>
 /**
  * Parse key="value" attribute pairs. Values are consumed, never
  * re-scanned (the old scanner re-matched words inside quoted values as
- * phantom attributes). Bare or unquoted attributes are not well-formed
+ * phantom attributes), and decoded as expat hands them to startElement
+ * (`decodeAttValue`; storeAtts' errors were raised before this runs). Bare or unquoted attributes are not well-formed
  * XML — expat rejects the document and the label falls back to plain
  * text; throwing here reproduces that.
  * Names keep their source case (doAttrs prints them as written) and pairs
@@ -66,7 +69,7 @@ function parseAttrPairs(raw: string): AttrEntry[] {
     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;
@@ -93,33 +96,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 "&#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.
-  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)];
 }
@@ -152,9 +147,7 @@ function parseOpenToken(inner: string) {
  * with the graphviz sources.
  * @see lib/common/htmllex.c:htmllex (XML_ErrorString at the XML_Parse failure)
  */
-const XML_ERROR_UNDEFINED_ENTITY = 'undefined entity';
 const XML_ERROR_TAG_MISMATCH = 'mismatched tag';
-const XML_ERROR_DUPLICATE_ATTRIBUTE = 'duplicate attribute';
 /** yacc's message when the token stream ends inside an unfinished construct. */
 const SYNTAX_ERROR = 'syntax error';
 
@@ -261,7 +254,8 @@ function checkTagToken(site: TokenSite): void {
       throw htmlErrorInLine(XML_ERROR_TAG_MISMATCH, lineAt(src, tok.start), context);
     }
   } else {
-    if (tok.dup !== undefined) throw htmlErrorInLine(XML_ERROR_DUPLICATE_ATTRIBUTE, lineAt(src, tok.dup), context);
+    const err = tok.attError;
+    if (err !== undefined) 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;
@@ -274,14 +268,14 @@ 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);
   }
-  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 !== undefined) throw htmlErrorInLine(err.message, lineAt(src, tok.start + err.offset), st.prev + st.curr);
   return textTokens(text);
 }
 
@@ -298,6 +292,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 +322,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 +345,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 +367,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 +445,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 +454,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-attrs.ts

@@ -11,6 +11,7 @@
 import type {
   HtmlAlign,
   HtmlCell,
+  HtmlCellAlign,
   HtmlCellContent,
   HtmlRow,
   HtmlTable,
@@ -23,14 +24,6 @@ import {
   BORDER_BOTTOM,
   BORDER_MASK,
 } from './htmltable-types.js';
-import { htmlEntityUTF8 } from './html-entities.js';
-
-/** Decode XML/HTML entities in an anchor attribute value (href/target), as C's
- *  HTML parser does. The stored value is the real character (`&` → `&`), so
- *  imap emits it raw and cmapx re-escapes it. Undefined passes through. */
-function anchorAttr(v: string | undefined): string | undefined {
-  return v === undefined ? undefined : htmlEntityUTF8(v);
-}
 
 // ---------------------------------------------------------------------------
 // Attribute helpers
@@ -44,6 +37,10 @@ export const parseAlign = (v: string): HtmlAlign | undefined => {
   return undefined;
 };
 
+/** @see lib/common/htmllex.c:cell_halignfn */
+export const parseCellAlign = (v: string): HtmlCellAlign | undefined =>
+  v.toUpperCase() === 'TEXT' ? 'text' : parseAlign(v);
+
 export const parseVAlign = (v: string): HtmlVAlign | undefined => {
   const u = v.toUpperCase();
   if (u === 'TOP') return 'top';
@@ -112,7 +109,7 @@ export const buildCell = (content: HtmlCellContent[], a: Record<string, string>)
   kind: 'cell',
   content,
   port: a['port'],
-  align: parseAlign(a['align'] !== undefined ? a['align'] : ''),
+  align: parseCellAlign(a['align'] !== undefined ? a['align'] : ''),
   valign: parseVAlign(a['valign'] !== undefined ? a['valign'] : ''),
   balign: parseAlign(a['balign'] !== undefined ? a['balign'] : ''),
   bgcolor: a['bgcolor'],
@@ -128,9 +125,9 @@ export const buildCell = (content: HtmlCellContent[], a: Record<string, string>)
   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'],
 });
 
@@ -149,9 +146,9 @@ export const buildTable = (rows: HtmlRow[], a: Record<string, string>): HtmlTabl
   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']),