@knowvah/dot-engine 2.6.3 → 2.6.5

package/src/common/htmltable-parse-state.ts

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Cursor state of the HTML-like label parser and the consume step that prints
+ * a token's lexer warnings. C lexes a token when the parser reaches it, so the
+ * warnings of a token the parser never gets to print nothing; T9's lexer
+ * warnings ride on the same `warnings` array.
+ *
+ * @see lib/common/htmllex.c:doAttrs
+ * @see lib/common/htmllex.c:clearHTMLlexer
+ */
+
+import type { HtmlParseError, LexerOutput, Token } from './htmltable-types.js';
+import type { StderrLines } from './htmltable-attr-warn.js';
+
+export interface ParseState {
+  tokens: Token[];
+  pos: number;
+  /** Lexical error found after the last token: C reports it when the parser asks for more. */
+  pending?: HtmlParseError;
+  /** Where lexer warnings go as tokens are reached (C's stderr, line by line); none: silent. */
+  stderr?: StderrLines;
+  /** Tokens whose warnings are already out (a token is lexed once). */
+  emitted?: WeakSet<Token>;
+  /** `ctx->warn`: a reached token's warning made the label's rv 1. */
+  warn?: boolean;
+  /** What the lexer wrote after its last token, printed when the parser asks for more. */
+  eof?: LexerOutput;
+}
+
+export const peek = (s: ParseState): Token | undefined => s.tokens[s.pos];
+
+/**
+ * Print what the C lexer wrote while lexing `tok`, once, and fold its `warn`
+ * into the label's rv.
+ */
+export const emitWarnings = (s: ParseState, tok: Token): void => {
+  if (s.stderr === undefined || s.emitted?.has(tok) === true) return;
+  s.emitted?.add(tok);
+  emitOutput(s, tok);
+};
+
+const emitOutput = (s: ParseState, out: LexerOutput): void => {
+  for (const text of out.warnings ?? []) s.stderr?.write(text);
+  if (out.warn === true) s.warn = true;
+};
+
+/**
+ * The parser ran off the last token: C lexes the rest now, so what it wrote
+ * after that token (warnings of units that produced none) prints once.
+ */
+export const emitEof = (s: ParseState): void => {
+  if (s.stderr === undefined || s.eof === undefined) return;
+  const out = s.eof;
+  delete s.eof;
+  emitOutput(s, out);
+};
+
+/** Take the token at the cursor; its warnings print now. */
+export const consume = (s: ParseState): Token => {
+  const t = s.tokens[s.pos];
+  s.pos++;
+  if (t !== undefined) emitWarnings(s, t);
+  return t;
+};

package/src/common/htmltable-parse.ts

@@ -20,7 +20,14 @@ import type {
   OpenToken,
 } from './htmltable-types.js';
 import { HtmlParseError } from './htmltable-types.js';
+import { StderrLines } from './htmltable-attr-warn.js';
+import type { ParseState } from './htmltable-parse-state.js';
+import { consume, emitEof, emitWarnings, peek } from './htmltable-parse-state.js';
 import { htmlErrorAtToken, tokenizeDeferred } from './htmltable-lex.js';
+import type { FontState } from './htmltable-parse-font.js';
+import {
+  fontItemProps, inlineFontState, isInlineTag, mergeFontState, tableFont, wrapperFont,
+} from './htmltable-parse-font.js';
 import {
   buildCell,
   buildTable,
@@ -30,59 +37,6 @@ import {
   parseRows,
 } from './htmltable-parse-attrs.js';
 
-// ---------------------------------------------------------------------------
-// Font-stack — mirrors pushFont / popFont in htmlparse.y
-// ---------------------------------------------------------------------------
-
-interface FontState {
-  bold?: boolean;
-  italic?: boolean;
-  underline?: boolean;
-  overline?: boolean;
-  strikethrough?: boolean;
-  subscript?: boolean;
-  superscript?: boolean;
-  fontColor?: string;
-  fontFace?: string;
-  fontSize?: number;
-}
-
-const definedOf = (s: FontState): Partial<FontState> =>
-  Object.fromEntries(
-    Object.entries(s).filter(([, v]) => v !== undefined),
-  ) as Partial<FontState>;
-
-const mergeFontState = (parent: FontState, child: FontState): FontState =>
-  ({ ...parent, ...definedOf(child) }) as FontState;
-
-const BOOL_FONT_KEYS = [
-  'bold', 'italic', 'underline', 'overline',
-  'strikethrough', 'subscript', 'superscript',
-] as const;
-type BoolFontKey = typeof BOOL_FONT_KEYS[number];
-
-const fontItemProps = (f: FontState): Partial<HtmlTextItem> => {
-  const out: Partial<HtmlTextItem> = {};
-  for (const k of BOOL_FONT_KEYS) {
-    if (f[k]) out[k as BoolFontKey] = true;
-  }
-  if (f.fontColor) out.fontColor = f.fontColor;
-  if (f.fontFace) out.fontFace = f.fontFace;
-  if (f.fontSize !== undefined) out.fontSize = f.fontSize;
-  return out;
-};
-
-// ---------------------------------------------------------------------------
-// Parser state
-// ---------------------------------------------------------------------------
-
-interface ParseState {
-  tokens: Token[];
-  pos: number;
-  /** Lexical error found after the last token: C reports it when the parser asks for more. */
-  pending?: HtmlParseError;
-}
-
 /** bison's default message for an unexpected token. @see lib/common/htmlparse.y */
 const MSG_SYNTAX_ERROR = 'syntax error';
 /** @see lib/common/htmlparse.y:288 (table rule) */
@@ -103,36 +57,17 @@ const nonSpace = (text: string): boolean => /[^ \t\n\r]/.test(text);
  * A token without a recorded chunk yields a plain, silent HtmlParseError.
  * @see lib/common/htmllex.c:htmlerror
  */
-const parseError = (s: ParseState, tok: Token | undefined, message: string): HtmlParseError =>
-  (tok === undefined ? s.pending : htmlErrorAtToken(message, tok)) ?? new HtmlParseError(message);
-
-const peek = (s: ParseState): Token | undefined => s.tokens[s.pos];
-
-const consume = (s: ParseState): Token => {
-  const t = s.tokens[s.pos];
-  s.pos++;
-  return t;
+const parseError = (s: ParseState, tok: Token | undefined, message: string): HtmlParseError => {
+  // The lexer already ran for the token the error is reported at.
+  if (tok !== undefined) emitWarnings(s, tok);
+  else emitEof(s);
+  return (tok === undefined ? s.pending : htmlErrorAtToken(message, tok)) ?? new HtmlParseError(message);
 };
 
 // ---------------------------------------------------------------------------
 // Inline-tag helpers — mirrors htmlparse.y fonttext / inline rules
 // ---------------------------------------------------------------------------
 
-const isInlineTag = (tag: string): boolean =>
-  ['B', 'I', 'U', 'O', 'S', 'SUB', 'SUP'].includes(tag);
-
-const inlineFontState = (tag: string, _attrs: Record<string, string>): FontState => {
-  const fs: FontState = {};
-  if (tag === 'B') fs.bold = true;
-  if (tag === 'I') fs.italic = true;
-  if (tag === 'U') fs.underline = true;
-  if (tag === 'O') fs.overline = true;
-  if (tag === 'S') fs.strikethrough = true;
-  if (tag === 'SUB') fs.subscript = true;
-  if (tag === 'SUP') fs.superscript = true;
-  return fs;
-};
-
 /**
  * `br: T_br T_end_br`, likewise image, HR and VR: the open tag must be
  * followed at once by its close (`<BR/>` yields both); anything else is a
@@ -219,6 +154,70 @@ export const parseText = (s: ParseState, fontStack: FontState[]): HtmlText => {
   return { kind: 'text', items };
 };
 
+// ---------------------------------------------------------------------------
+// fonttable — a <TABLE> wrapped in one font-like tag
+// ---------------------------------------------------------------------------
+
+/** Tags of `fonttable : font table n_font | italic ... | bold ...`. @see lib/common/htmlparse.y:307 */
+const FONTTABLE_TAGS: readonly string[] = ['FONT', 'B', 'I', 'U', 'O'];
+
+/**
+ * The wrapper tag when the tokens at the cursor open a `fonttable`: one of
+ * FONTTABLE_TAGS, then only strings (the table rule's opt_space), then TABLE.
+ */
+const fontTableWrapper = (s: ParseState): OpenToken | undefined => {
+  const open = peek(s);
+  if (open?.type !== 'open' || !FONTTABLE_TAGS.includes(open.tag)) return undefined;
+  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 : undefined;
+};
+
+/** Consume strings; true when any is non-space (the table rule's nonSpace check). */
+const skipStrings = (s: ParseState): boolean => {
+  let found = false;
+  for (let t = peek(s); t?.type === 'text'; t = peek(s)) {
+    consume(s);
+    if (nonSpace(t.value)) found = true;
+  }
+  return found;
+};
+
+/**
+ * `font table n_font` (and the I/U/O/B forms): the wrapper's font sits on the
+ * fontstack while the table parses, then pops at the closing tag.
+ * @see lib/common/htmlparse.y:fonttable
+ */
+const parseFontTable = (s: ParseState, open: OpenToken, fontStack: FontState[]): HtmlTable => {
+  consume(s);
+  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);
+  const table = parseTable(s, fontStack);
+  const textAfter = skipStrings(s);
+  const close = peek(s);
+  if (close !== undefined && 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;
+};
+
+/**
+ * A <TABLE> that follows a consumed tag can only be a syntax error: the table
+ * rule's opt_space admits strings alone.
+ * @see lib/common/htmlparse.y:287
+ */
+const rejectTableAfterTag = (s: ParseState, start: number): void => {
+  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);
+  }
+};
+
 // ---------------------------------------------------------------------------
 // Cell content helpers — mirrors htmlparse.y cell rule
 // ---------------------------------------------------------------------------
@@ -238,7 +237,7 @@ const parseImgContent = (
 
 /** What a cell holds so far: C's cell has exactly one child. */
 interface CellScan {
-  kind: 'none' | 'text' | 'table' | 'image';
+  kind: 'none' | 'text' | 'table' | 'fonttable' | 'image';
   /** Non-space text before the nested table (checked when the table opens). */
   textNonSpace: boolean;
   /** Non-space text after the nested table (checked when the run ends). */
@@ -261,6 +260,7 @@ const scanCellText = (s: ParseState, t: Token, fontStack: FontState[], st: CellS
   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 !== undefined && nonSpace(i.text))) st.textNonSpace = true;
   st.kind = 'text';
   return txt.items.length > 0 ? [txt] : [];
@@ -287,7 +287,13 @@ const scanCellImage = (
 const scanCellItem = (
   s: ParseState, t: Token, cellAttrs: Record<string, string>, fontStack: FontState[], st: CellScan,
 ): HtmlCellContent[] => {
+  if (st.kind === 'fonttable') throw parseError(s, t, MSG_SYNTAX_ERROR);
   if (st.kind === 'table') return scanAfterTable(s, t, st);
+  const wrapper = st.kind === 'none' ? fontTableWrapper(s) : undefined;
+  if (wrapper !== undefined) {
+    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);
@@ -438,7 +444,10 @@ export const parseTable = (s: ParseState, fontStack: FontState[]): HtmlTable =>
   for (let t = peek(s); t !== undefined; 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 !== undefined) table.font = font;
+  return table;
 };
 
 /** Parse one row, applying table-level rule defaults. @see lib/common/htmlparse.y addRow/setCell */
@@ -497,6 +506,16 @@ const finishTableLabel = (s: ParseState): void => {
   consume(s);
 };
 
+/** `html : T_html fonttable T_end_html` with a font-like wrapper. */
+const parseFontTableLabel = (s: ParseState, open: OpenToken, fontStack: FontState[]): HtmlLabel => {
+  const table = parseFontTable(s, open, fontStack);
+  const nxt = peek(s);
+  if (nxt === undefined) return { kind: 'table', table };
+  if (nxt.type !== 'close' || nxt.tag !== 'HTML') throw parseError(s, nxt, MSG_SYNTAX_ERROR);
+  consume(s);
+  return { kind: 'table', table };
+};
+
 const parseTableLabel = (s: ParseState, fontStack: FontState[]): HtmlLabel => {
   skipLeadingWs(s);
   const table = parseTable(s, fontStack);
@@ -504,25 +523,22 @@ const parseTableLabel = (s: ParseState, fontStack: FontState[]): HtmlLabel => {
   return { kind: 'table', table };
 };
 
-/** `html : T_html fonttext T_end_html`; a `<TABLE>` after text is the table rule's error. */
+/** `html : T_html fonttext T_end_html` (a textitem is required); a `<TABLE>` after text is the table rule's error. */
 const parseTextLabel = (s: ParseState, fontStack: FontState[]): HtmlLabel => {
   const texts: HtmlText[] = [];
+  const start = s.pos;
   const txt = parseText(s, fontStack);
   if (txt.items.length > 0) texts.push(txt);
   const nxt = peek(s);
   if (nxt === undefined) return { kind: 'text', texts };
   if (nxt.type === 'open' && nxt.tag === 'TABLE') {
     // C's `table` rule aborts the whole label when non-space text precedes a
-    // top-level <TABLE>. Text that is only blanks means a font-wrapped table
-    // (`fonttable`), which this parser does not model: rejected without a
-    // message rather than with a wrong one.
+    // top-level <TABLE>; after any tag it is a plain syntax error.
     // @see lib/common/htmlparse.y:288 (table rule nonSpace check)
-    if (txt.items.some((i) => i.text !== undefined && 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 };
 };
@@ -532,28 +548,52 @@ const parseTokens = (s: ParseState): HtmlLabel => {
   const fontStack: FontState[] = [{}];
   const htmlOpen = consume(s);
   if (htmlOpen.type !== 'open' || htmlOpen.tag !== 'HTML') throw new HtmlParseError('HTML');
+  const wrapper = fontTableWrapper(s);
+  if (wrapper !== undefined) 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);
 };
 
+/** A parsed label and `ctx->warn`, which `make_html_label` ORs into its rv. */
+export interface ParsedHtmlLabel {
+  label: HtmlLabel;
+  warn: boolean;
+}
+
 /**
- * Parse an HTML-like label string.
- * Input is the content between the outer `<` `>` delimiters (already stripped).
+ * Parse an HTML-like label string, printing the lexer's warnings (one
+ * `writeLine` per stderr line, `console.warn` by default) as the parser reaches
+ * their tokens. Input is the content between the outer `<` `>` delimiters
+ * (already stripped).
  *
  * @see lib/common/htmlparse.y:parseHTML
  */
-export const parseHtmlLabel = (src: string): HtmlLabel => {
-  const { tokens, error } = tokenizeDeferred(`<HTML>${src}</HTML>`);
-  const s: ParseState = { tokens, pos: 0, pending: error };
-  let label: HtmlLabel;
+export const parseHtmlLabelRv = (
+  src: string,
+  writeLine: (line: string) => void = (line) => console.warn(line),
+): ParsedHtmlLabel => {
+  const { tokens, error, eof } = tokenizeDeferred(`<HTML>${src}</HTML>`, { start: 6, end: 6 + src.length });
+  const s: ParseState = {
+    tokens, pos: 0, pending: error, stderr: new StderrLines(writeLine), emitted: new WeakSet(), warn: false, eof,
+  };
   try {
-    label = parseTokens(s);
+    const label = parseTokens(s);
+    if (error !== undefined) throw error;
+    return { label, warn: s.warn === true };
   } catch (e) {
     // Running off the truncated stream means C's lexer would have hit the error.
-    if (error !== undefined && s.pos >= tokens.length) throw error;
+    if (error !== undefined && s.pos >= tokens.length) { emitEof(s); throw error; }
     throw e;
+  } finally {
+    s.stderr?.flush();
   }
-  if (error !== undefined) throw error;
-  return label;
 };
+
+/**
+ * {@link parseHtmlLabelRv} without printing: callers that only inspect the
+ * label (the async font/image collection pass) must not repeat the warnings
+ * the sync pass prints.
+ */
+export const parseHtmlLabel = (src: string): HtmlLabel =>
+  parseHtmlLabelRv(src, () => undefined).label;

package/src/common/htmltable-pos.ts

@@ -20,7 +20,7 @@ import type { TextlabelT } from './types.js';
 import type { TextMeasurer } from './textmeasure.js';
 import type { HtmlCell, HtmlImage, HtmlLabel, HtmlTable, HtmlText, ImageSizer } from './htmltable-types.js';
 import {
-  layoutHtmlTable, cellPad, cellBorder, sizeHtmlLabel, parseHtmlLabel, inheritTablePenColor,
+  layoutHtmlTable, cellPad, cellBorder, sizeHtmlLabel, parseHtmlLabelRv, inheritTablePenColor, withTableFont,
 } from './htmltable.js';
 import { makeLabel } from './make-label.js';
 import { HtmlLexError } from './htmltable-lex.js';
@@ -292,8 +292,8 @@ function alignImageBox(cbox: Box, cell: HtmlCell, iw: number, ih: number): void
   }
 }
 
-/** Position a nested <TABLE> child inside the cell's inset content box.
- * @see lib/common/htmltable.c:pos_html_cell (HTML_TBL branch) */
+/** Position a nested <TABLE> child inside the cell's inset content box; its font push
+ * plays emit_html_tbl's role. @see htmltable.c:pos_html_cell (HTML_TBL branch), emit_html_tbl */
 function placeCellNested(ctx: CellPlaceCtx): PlacedHtml | undefined {
   const { cell, tbl, box, finfo, measurer, sidesMask } = ctx;
   const nested = cell.content.find((c): c is HtmlTable => c.kind === 'table');
@@ -303,7 +303,7 @@ function placeCellNested(ctx: CellPlaceCtx): PlacedHtml | undefined {
     ll: { x: box.ll.x + inset, y: box.ll.y + inset },
     ur: { x: box.ur.x - inset, y: box.ur.y - inset },
   };
-  return posHtmlTable(nested, finfo, measurer, cbox, sidesMask);
+  return withTableFont(finfo, nested.font, 'emit', () => posHtmlTable(nested, finfo, measurer, cbox, sidesMask));
 }
 
 /** Position one cell's text inside its box, copying decoration metadata. @see pos_html_cell */
@@ -516,7 +516,8 @@ export function posHtmlLabel(
   finfo: HtmlFontInfo,
   measurer: TextMeasurer,
 ): PlacedHtml {
-  if (label.kind === 'table') return posHtmlTable(label.table, finfo, measurer);
+  const env = { ...finfo }; // copied: the emit-side savef leak must not outlive the label
+  if (label.kind === 'table') return withTableFont(env, label.table.font, 'emit', () => posHtmlTable(label.table, env, measurer));
   return posTextLabel(label, finfo, measurer);
 }
 
@@ -542,9 +543,9 @@ export function makeHtmlLabelRv(
   measurer: TextMeasurer,
 ): HtmlLabelResult {
   const { fontname, fontsize, fontcolor, imageSizer, pencolor } = finfo;
-  let lbl: HtmlLabel;
+  let lbl: HtmlLabel, lexWarn: boolean; // lexWarn: htmllex.c's ctx->warn, rv bit 1
   try {
-    lbl = parseHtmlLabel(content);
+    ({ label: lbl, warn: lexWarn } = parseHtmlLabelRv(content));
   } catch (e) {
     // C aborts the HTML parse on a syntax error (YYABORT): parseHTML returns
     // rv 3 (ctx->error) with no label, and make_html_label returns it with
@@ -557,7 +558,7 @@ export function makeHtmlLabelRv(
   // which then flows table->cell->nested-table.
   // @see lib/common/htmltable.c:1911 (getPenColor), :1406/:1556 (inheritance)
   if (lbl.kind === 'table') inheritTablePenColor(lbl.table, pencolor);
-  const rv = sizeHtmlLabel(lbl, measurer, {
+  const rv = Number(lexWarn) | sizeHtmlLabel(lbl, measurer, {
     fontsize, fontname, imageSizer,
   });
   const placed = posHtmlLabel(lbl, { fontname, fontsize, fontcolor }, measurer);

package/src/common/htmltable-types.ts

@@ -176,10 +176,24 @@ export interface HtmlRow {
   ruled?: boolean;
 }
 
+/**
+ * The font a `fonttable` wrapper (or an enclosing one) gives a table: the
+ * name, color and size `pushFontInfo` swaps into the environment.
+ * @see lib/common/htmltable.h:htmltbl_t.font
+ * @see lib/common/htmltable.c:pushFontInfo
+ */
+export interface HtmlTableFont {
+  fontColor?: string;
+  fontFace?: string;
+  fontSize?: number;
+}
+
 /** @see lib/common/htmltable.h:htmltbl_t */
 export interface HtmlTable {
   kind: 'table';
   rows: HtmlRow[];
+  /** Set only inside a `fonttable` wrapper. @see lib/common/htmlparse.y:294 */
+  font?: HtmlTableFont;
   border?: number;
   cellborder?: number;
   cellspacing?: number;
@@ -238,21 +252,39 @@ export type HtmlLabel =
 // the lex file's function boundaries when it encounters `|` union syntax.
 // ---------------------------------------------------------------------------
 
+/**
+ * What the C lexer wrote to stderr while producing a token, and the `ctx->warn`
+ * it set. Any token can carry it: a unit that yields no token (a comment) or
+ * an event lost to a later one in the same `XML_Parse` call still wrote.
+ * @see lib/common/htmllex.c:htmllex
+ */
+export interface LexerOutput {
+  /**
+   * Exact text per write, including any trailing newline (a message without
+   * one runs into the next write). The parser prints it when it consumes the
+   * token.
+   * @see lib/common/htmllex.c:doAttrs
+   */
+  warnings?: string[];
+  /** Some handler set `ctx->warn`: the label's `rv` becomes 1. */
+  warn?: true;
+}
+
 /** @see lib/common/htmllex.c:startElement */
-export interface OpenToken {
+export interface OpenToken extends LexerOutput {
   type: 'open';
   tag: string;
   attrs: Record<string, string>;
 }
 
 /** @see lib/common/htmllex.c:endElement */
-export interface CloseToken {
+export interface CloseToken extends LexerOutput {
   type: 'close';
   tag: string;
 }
 
 /** @see lib/common/htmllex.c:characterData */
-export interface TextToken {
+export interface TextToken extends LexerOutput {
   type: 'text';
   value: string;
 }

package/src/common/htmltable.ts

@@ -12,10 +12,10 @@ export { HtmlParseError } from './htmltable-types.js';
 export type {
   HtmlAlign, HtmlVAlign,
   HtmlHR, HtmlImage, HtmlTextItem, HtmlText,
-  HtmlCellContent, HtmlCell, HtmlRow, HtmlTable, HtmlLabel,
+  HtmlCellContent, HtmlCell, HtmlRow, HtmlTable, HtmlTableFont, HtmlLabel,
   ImageSizer,
 } from './htmltable-types.js';
-export { parseHtmlLabel } from './htmltable-parse.js';
+export { parseHtmlLabel, parseHtmlLabelRv } from './htmltable-parse.js';
 export type { TextMeasurer } from './textmeasure.js';
 
 import type {
@@ -26,6 +26,9 @@ import type { ImageSizer } from './htmltable-types.js';
 import { findImageSize } from '../gvc/usershape.js';
 import { PointSet } from './pointset.js';
 import type { TextMeasurer } from './textmeasure.js';
+import { withTableFont } from './htmltable-fontinfo.js';
+
+export { withTableFont } from './htmltable-fontinfo.js';
 
 const DEFAULT_BORDER = 1;
 const DEFAULT_CELLPADDING = 2;
@@ -84,7 +87,7 @@ export interface HtmlSizeEnv {
   imageSizer?: ImageSizer;
 }
 
-const DEFAULT_SIZE_ENV: HtmlSizeEnv = { fontsize: DEFAULT_FONTSIZE, fontname: '' };
+const defaultSizeEnv = (): HtmlSizeEnv => ({ fontsize: DEFAULT_FONTSIZE, fontname: '' });
 
 /** One measured text line (a C "span"). @see size_html_txt */
 interface SizedLine {
@@ -196,7 +199,7 @@ export const htmlTextIsSimple = (texts: HtmlText[], env: HtmlSizeEnv): boolean =
 const sizeTextContent = (
   texts: HtmlText[],
   measurer: TextMeasurer,
-  env: HtmlSizeEnv = DEFAULT_SIZE_ENV,
+  env: HtmlSizeEnv = defaultSizeEnv(),
 ): { w: number; h: number } => {
   const lines = splitSizedLines(texts, measurer, env);
   const simple = htmlTextIsSimple(texts, env);
@@ -481,7 +484,7 @@ export interface HtmlTableLayout {
 export const layoutHtmlTable = (
   tbl: HtmlTable,
   measurer: TextMeasurer,
-  env: HtmlSizeEnv = DEFAULT_SIZE_ENV,
+  env: HtmlSizeEnv = defaultSizeEnv(),
 ): HtmlTableLayout => {
   const spacing = getSpacing(tbl);
   const border = getBorder(tbl);
@@ -515,7 +518,7 @@ const warnFixedTable = (tbl: HtmlTable, dims: { wd: number; ht: number }): numbe
 };
 
 /** @see lib/common/htmltable.c:size_html_tbl */
-const sizeTableInner = (
+const sizeTableBody = (
   tbl: HtmlTable,
   measurer: TextMeasurer,
   env: HtmlSizeEnv,
@@ -546,6 +549,10 @@ const sizeTableInner = (
   return rv | fixed;
 };
 
+/** @see lib/common/htmltable.c:size_html_tbl (pushFontInfo ... popFontInfo around the body) */
+const sizeTableInner = (tbl: HtmlTable, measurer: TextMeasurer, env: HtmlSizeEnv): number =>
+  withTableFont(env, tbl.font, 'size', () => sizeTableBody(tbl, measurer, env));
+
 /**
  * Compute and write `dimen` onto all cells and the label.
  *
@@ -559,7 +566,7 @@ const sizeTableInner = (
 export const sizeHtmlLabel = (
   label: HtmlLabel,
   measurer: TextMeasurer,
-  env: HtmlSizeEnv = DEFAULT_SIZE_ENV,
+  env: HtmlSizeEnv = defaultSizeEnv(),
 ): number => {
   if (label.kind === 'table') {
     const rv = sizeTableInner(label.table, measurer, env);

package/src/common/spline-midpoint.ts

@@ -9,6 +9,7 @@
  */
 
 import type { Point } from '../model/geom.js';
+import { bezier } from './bezier.js';
 import { fma } from './fma.js';
 
 type BezLike = { list: Point[]; sflag: number; eflag: number; sp: Point; ep: Point; size?: number };
@@ -30,27 +31,6 @@ export function dist2(p: Point, q: Point): number {
 /** DIST: sqrt of the fused DIST2 (`fmadd` then `fsqrt`). @see lib/common/geom.h:DIST */
 function distPt(p: Point, q: Point): number { return Math.sqrt(dist2(p, q)); }
 
-/**
- * Point at t on a cubic: C's de Casteljau triangle. Each
- * `(1.0 - t) * a + t * b` compiles to `fmul v, b, t; fmla v, a, 1-t`, i.e.
- * fma(a, 1 - t, t * b), both in Bezier itself and where dotneato_closest
- * inlines it (libgvc 16.1 disassembly). The Left/Right halves are not needed
- * here, so only the apex is kept.
- * @see lib/common/utils.c:Bezier
- */
-function bezier(v: Point[], t: number): Point {
-  const u = 1.0 - 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] };
-}
-
 /** @see lib/common/utils.c:dotneato_closest */
 export function dotneatoClosest(spl: SplLike, pt: Point): Point {
   let besti = 0; let bestj = -1; let bestd2 = Number.MAX_VALUE;
@@ -76,7 +56,7 @@ export function dotneatoClosest(spl: SplLike, pt: Point): Point {
   let pt2: Point;
   for (;;) {
     const t = (lo + hi) / 2.0;
-    pt2 = bezier(c, t);
+    pt2 = bezier(c, t, null, null);
     if (Math.abs(dlo2 - dhi2) < 1.0 || Math.abs(hi - lo) < 0.00001) break;
     if (dlo2 < dhi2) { hi = t; dhi2 = dist2(pt2, pt); }
     else { lo = t; dlo2 = dist2(pt2, pt); }