@geml/geml 1.0.0

package/dist/serialize.js

@@ -0,0 +1,187 @@
+// GEML serializer (§ round-trip): document model -> GEML source.
+//
+// This is the inverse of `parse`: given a Document (or its Block[]), emit GEML
+// text that parses back to the *same model*. It does not try to reproduce the
+// original bytes — whitespace, attribute quoting, fence length, and footnote
+// shorthand are normalized — so `serialize(parse(src))` is also a canonical
+// formatter (`geml fmt`). The guarantee it is built to keep is model stability:
+//
+//     parse(serialize(parse(src)))  ≅  parse(src)
+//
+// verified over the conformance corpus by test/roundtrip.test.mjs.
+import { parseInline } from "./inline.js";
+// ---------------------------------------------------------------------------
+// Values & attributes (§4)
+// ---------------------------------------------------------------------------
+// True when a bare string would be re-read by `coerce` as a non-string (a
+// boolean or a number) — in which case it must be quoted to stay a string.
+function looksTyped(s) {
+    return (s === "true" ||
+        s === "false" ||
+        /^[+-]?\d+$/.test(s) ||
+        (/^[+-]?(\d+\.\d*|\.\d+|\d+)([eE][+-]?\d+)?$/.test(s) && /[.eE]/.test(s)));
+}
+// One `key=value` / `key` / `.class` / `#id` token of an attribute object.
+function serAttrValue(v) {
+    if (v === true)
+        return ""; // caller emits the bare key (a flag)
+    if (v === false)
+        return "false";
+    if (typeof v === "number")
+        return String(v);
+    return `"${v}"`; // always quote strings: parses back 1:1
+}
+// `{#id .class key="val" flag}` — or "" when there is nothing to emit.
+function serAttrs(a) {
+    const parts = [];
+    if (a.id !== undefined)
+        parts.push(`#${a.id}`);
+    for (const c of a.classes ?? [])
+        parts.push(`.${c}`);
+    for (const [k, v] of Object.entries(a.attrs ?? {})) {
+        parts.push(v === true ? k : `${k}=${serAttrValue(v)}`);
+    }
+    return parts.length ? `{${parts.join(" ")}}` : "";
+}
+// A `data`-mode (meta) value: a bare word unless quoting is needed to keep it a
+// string. `coerce` takes the whole rest-of-line, so spaces need no quoting.
+function serDataValue(v) {
+    if (typeof v === "boolean")
+        return String(v);
+    if (typeof v === "number")
+        return String(v);
+    return looksTyped(v) || v.trim() !== v ? `"${v}"` : v;
+}
+// ---------------------------------------------------------------------------
+// Inline (§5)
+// ---------------------------------------------------------------------------
+// Escape every character that could open an inline construct, so a literal text
+// run re-parses verbatim. An escaped punctuation byte parses back to that same
+// literal byte (§5.3(1)). Used only on escalation (see serInlines).
+function escText(s) {
+    return s.replace(/[\\`*~$\[\]]/g, (c) => "\\" + c);
+}
+function longestRun(s, ch) {
+    let max = 0;
+    let run = 0;
+    for (const c of s) {
+        if (c === ch) {
+            run++;
+            if (run > max)
+                max = run;
+        }
+        else
+            run = 0;
+    }
+    return max;
+}
+function linkDest(n) {
+    if (n.href !== undefined)
+        return n.href;
+    if (n.doc !== undefined)
+        return n.anchor !== undefined ? `${n.doc}#${n.anchor}` : n.doc;
+    if (n.anchor !== undefined)
+        return `#${n.anchor}`;
+    return "";
+}
+// `esc` controls whether literal text runs are backslash-escaped. The default
+// pass emits them verbatim — the parser re-literalizes most stray delimiters on
+// its own (an unpaired `*`, a lone `~`), and escaping them would split the run
+// and break a surrounding emphasis span. serInlines escalates to esc=true only
+// when the verbatim form does not round-trip.
+function serInline(n, esc) {
+    switch (n.type) {
+        case "text": return esc ? escText(n.value) : n.value;
+        case "emph": return `*${serSeq(n.children, esc)}*`;
+        case "strong": return `**${serSeq(n.children, esc)}**`;
+        case "strike": return `~~${serSeq(n.children, esc)}~~`;
+        case "code": {
+            const f = "`".repeat(longestRun(n.value, "`") + 1);
+            return f + n.value + f;
+        }
+        case "math": return `$${n.value}$`;
+        case "break": return "\\\n";
+        case "image": return `![${n.alt}](${n.src})${serAttrs({ attrs: n.attrs })}`;
+        case "link": return `[${serSeq(n.children, esc)}](${linkDest(n)})${serAttrs({ attrs: n.attrs })}`;
+        case "autoref": return `[[${n.doc !== undefined ? `${n.doc}#${n.anchor}` : `#${n.anchor}`}]]`;
+        case "footnote": return `[^${n.ref}]`;
+    }
+}
+function serSeq(ns, esc) {
+    return ns.map((n) => serInline(n, esc)).join("");
+}
+// Serialize an inline sequence so it re-parses to the same tree. Emit verbatim
+// first; if re-parsing that disagrees with the model (a stray delimiter that
+// would spuriously pair, e.g. text `*lit*`), fall back to escaping. The check is
+// what makes this exact rather than heuristic.
+function serInlines(ns) {
+    const lazy = serSeq(ns, false);
+    if (JSON.stringify(parseInline(lazy, 0, { refs: [] })) === JSON.stringify(ns))
+        return lazy;
+    return serSeq(ns, true);
+}
+// ---------------------------------------------------------------------------
+// Blocks
+// ---------------------------------------------------------------------------
+function serList(list, indent) {
+    const out = [];
+    const start = list.start ?? 1;
+    list.items.forEach((item, k) => {
+        const marker = list.ordered ? `${start + k}. ` : "- ";
+        const task = item.checked === undefined ? "" : item.checked ? "[x] " : "[ ] ";
+        out.push(indent + marker + task + serInlines(item.inlines));
+        for (const child of item.children ?? []) {
+            out.push(child.kind === "list" ? serList(child, indent + "  ") : serBlock(child));
+        }
+        if (list.loose && k < list.items.length - 1)
+            out.push(""); // blank => loose
+    });
+    return out.join("\n");
+}
+function serTypedBlock(b) {
+    let body;
+    if (b.mode === "flow") {
+        body = (b.children ?? []).map(serBlock).join("\n\n").split("\n");
+    }
+    else if (b.mode === "data") {
+        body = Object.entries(b.data ?? {}).map(([k, v]) => `${k} = ${serDataValue(v)}`);
+    }
+    else {
+        body = b.raw ?? [];
+    }
+    // Pick a fence longer than any bare `=` run in the body, so a body line (or a
+    // nested block's close) can never close this block early (§3 longer-fence
+    // nesting). The close is the same length, the convention the parser expects.
+    let maxEq = 2;
+    for (const ln of body) {
+        const m = /^(=+)[ \t]*$/.exec(ln);
+        if (m)
+            maxEq = Math.max(maxEq, m[1].length);
+    }
+    const fence = "=".repeat(Math.max(3, maxEq + 1));
+    const attrs = serAttrs({ id: b.id, classes: b.classes, attrs: b.attrs });
+    const open = fence + " " + b.type + (attrs ? " " + attrs : "");
+    return [open, ...body, fence].join("\n");
+}
+function serBlock(b) {
+    switch (b.kind) {
+        case "heading": {
+            // The id is always emitted explicitly: it pins the heading's anchor
+            // regardless of how the rendered text slugs, and it shields any `{...}`
+            // inside the heading text from being read as a trailing attribute object.
+            const attrs = serAttrs({ id: b.id, classes: b.classes, attrs: b.attrs });
+            return "#".repeat(b.level) + " " + serInlines(b.inlines) + (attrs ? " " + attrs : "");
+        }
+        case "paragraph": return serInlines(b.inlines);
+        case "hidden": return "%%" + (b.text ? " " + b.text : "");
+        case "list": return serList(b, "");
+        case "block": return serTypedBlock(b);
+    }
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+export function serialize(doc) {
+    const blocks = Array.isArray(doc) ? doc : doc.children;
+    return blocks.map(serBlock).join("\n\n") + "\n";
+}

package/dist/table.d.ts

@@ -0,0 +1,32 @@
+import { type Value } from "./attrs.js";
+import { type Inline, type RefSink } from "./inline.js";
+export type Align = "left" | "right" | "center";
+export interface TableCell {
+    text: string;
+    inlines: Inline[];
+    align?: Align;
+    value?: number;
+    computed?: boolean;
+    span?: {
+        rows: number;
+        cols: number;
+    };
+}
+export interface TableModel {
+    caption?: string;
+    header: boolean;
+    columns: string[];
+    align: (Align | undefined)[];
+    rows: TableCell[][];
+    summary?: TableCell[];
+    src?: string;
+}
+export interface TableDiag {
+    severity: "error" | "warning";
+    message: string;
+}
+export interface TableResult {
+    model: TableModel;
+    diagnostics: TableDiag[];
+}
+export declare function parseTable(body: string[], attrs: Record<string, Value>, line: number, sink: RefSink): TableResult;

package/dist/table.js

@@ -0,0 +1,469 @@
+// GEML reference parser — Milestone 3: tables (§6).
+//
+// A `table` block has two interchangeable body forms that parse to the SAME
+// model: a visual pipe grid, or a data form (`format=csv`/`tsv`). The model
+// carries column names, per-column alignment, body cells (inline-parsed),
+// merged-cell spans (`span="r2c1:2x1"`), and columns produced by `compute`
+// formulas (per-row arithmetic over columns, with sum/avg/min/max/count
+// aggregates). See §6.
+import { coerce } from "./attrs.js";
+import { parseInline } from "./inline.js";
+// ---------------------------------------------------------------------------
+// Body-form parsing
+// ---------------------------------------------------------------------------
+const SEP_CELL = /^:?-+:?$/;
+function alignOf(sep) {
+    const l = sep.startsWith(":");
+    const r = sep.endsWith(":");
+    if (l && r)
+        return "center";
+    if (r)
+        return "right";
+    if (l)
+        return "left";
+    return undefined;
+}
+// Split a visual table row `| a | b |` into trimmed cell strings.
+function splitPipes(line) {
+    let s = line.trim();
+    if (s.startsWith("|"))
+        s = s.slice(1);
+    if (s.endsWith("|"))
+        s = s.slice(0, -1);
+    return s.split("|").map((c) => c.trim());
+}
+function parseVisual(body) {
+    const rows = body.filter((l) => l.trim() !== "").map(splitPipes);
+    let sepIdx = -1;
+    for (let r = 0; r < rows.length; r++) {
+        if (rows[r].length > 0 && rows[r].every((c) => SEP_CELL.test(c))) {
+            sepIdx = r;
+            break;
+        }
+    }
+    if (sepIdx >= 0) {
+        const headerRow = sepIdx > 0 ? rows[sepIdx - 1] : [];
+        const align = rows[sepIdx].map(alignOf);
+        const cells = rows.slice(sepIdx + 1);
+        const columns = headerRow.length ? headerRow : letters(cells[0]?.length ?? align.length);
+        return { columns, align, header: headerRow.length > 0, cells };
+    }
+    // No separator: headerless, columns are letters.
+    const width = rows.reduce((m, r) => Math.max(m, r.length), 0);
+    return { columns: letters(width), align: [], header: false, cells: rows };
+}
+function parseDelimited(body, sep, header) {
+    const rows = body.filter((l) => l.trim() !== "").map((l) => l.split(sep).map((c) => c.trim()));
+    if (header && rows.length) {
+        return { columns: rows[0], align: [], header: true, cells: rows.slice(1) };
+    }
+    const width = rows.reduce((m, r) => Math.max(m, r.length), 0);
+    return { columns: letters(width), align: [], header: false, cells: rows };
+}
+function letters(n) {
+    const out = [];
+    for (let i = 0; i < n; i++)
+        out.push(String.fromCharCode(65 + i));
+    return out;
+}
+const AGGS = new Set(["sum", "avg", "min", "max", "count"]);
+function lexExpr(s) {
+    const out = [];
+    let i = 0;
+    while (i < s.length) {
+        const c = s[i];
+        if (/\s/.test(c)) {
+            i++;
+            continue;
+        }
+        if ("+-*/".includes(c)) {
+            out.push({ t: "op", v: c });
+            i++;
+            continue;
+        }
+        if (c === "(") {
+            out.push({ t: "lp", v: c });
+            i++;
+            continue;
+        }
+        if (c === ")") {
+            out.push({ t: "rp", v: c });
+            i++;
+            continue;
+        }
+        if (c === ",") {
+            out.push({ t: "comma", v: c });
+            i++;
+            continue;
+        }
+        if (/[0-9.]/.test(c)) {
+            let j = i;
+            while (j < s.length && /[0-9.]/.test(s[j]))
+                j++;
+            out.push({ t: "num", v: s.slice(i, j) });
+            i = j;
+            continue;
+        }
+        // quoted column name: 'Unit Price' (single quotes — the GEML attribute
+        // value is already double-quoted and has no escape syntax, §4).
+        if (c === "'") {
+            let j = i + 1;
+            while (j < s.length && s[j] !== "'")
+                j++;
+            out.push({ t: "name", v: s.slice(i + 1, j) });
+            i = j + 1;
+            continue;
+        }
+        // identifier: column name or function — run of non-operator chars
+        let j = i;
+        while (j < s.length && !/[\s+\-*/(),]/.test(s[j]))
+            j++;
+        out.push({ t: "name", v: s.slice(i, j) });
+        i = j;
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Display format: a `[printf]` spec bound to a column/cell name (§6).
+//   `FY [%.1f]` → name "FY", fmt "%.1f";  `YoY [%.1f%%]` → "%.1f%%"
+// ---------------------------------------------------------------------------
+function splitName(lhs) {
+    const m = /^(.*?)\s*\[([^\]]*)\]\s*$/.exec(lhs.trim());
+    let name = (m ? m[1] : lhs).trim();
+    if (name.startsWith('"') && name.endsWith('"'))
+        name = name.slice(1, -1);
+    return m ? { name, fmt: m[2] } : { name };
+}
+// Default rendering for an unformatted computed number: drop IEEE-754 display
+// noise (0.1+0.2 → "0.3", sum of 1-dp inputs → "263.6") without altering the
+// stored numeric value.
+function defaultNum(v) {
+    return String(parseFloat(v.toPrecision(12)));
+}
+// Minimal printf for a single numeric value: handles %f/%e/%d/%g with optional
+// precision, and `%%` as a literal percent. Width/flags are not padded.
+function applyFormat(fmt, v) {
+    return fmt.replace(/%%|%[-+ 0]*\d*(?:\.\d+)?[fFeEgGd]/g, (m) => {
+        if (m === "%%")
+            return "%";
+        const mm = /^%[-+ 0]*\d*(?:\.(\d+))?([fFeEgGd])$/.exec(m);
+        if (!mm)
+            return m;
+        const prec = mm[1] !== undefined ? parseInt(mm[1], 10) : undefined;
+        const type = mm[2];
+        if (type === "d")
+            return String(Math.round(v));
+        if (type === "e" || type === "E")
+            return v.toExponential(prec);
+        if (type === "g" || type === "G")
+            return String(v);
+        return v.toFixed(prec ?? 6); // f / F
+    });
+}
+// Recursive-descent evaluator restricted to + - * / ( ) and aggregate funcs.
+function evalExpr(toks, row, col, agg) {
+    let p = 0;
+    const peek = () => toks[p];
+    const next = () => toks[p++];
+    function parseExpr() {
+        let v = parseTerm();
+        while (peek() && peek().t === "op" && (peek().v === "+" || peek().v === "-")) {
+            const op = next().v;
+            const r = parseTerm();
+            v = op === "+" ? v + r : v - r;
+        }
+        return v;
+    }
+    function parseTerm() {
+        let v = parseFactor();
+        while (peek() && peek().t === "op" && (peek().v === "*" || peek().v === "/")) {
+            const op = next().v;
+            const r = parseFactor();
+            v = op === "*" ? v * r : v / r;
+        }
+        return v;
+    }
+    function parseFactor() {
+        const tk = peek();
+        if (!tk)
+            throw new Error("unexpected end of formula");
+        if (tk.t === "op" && tk.v === "-") {
+            next();
+            return -parseFactor();
+        }
+        if (tk.t === "lp") {
+            next();
+            const v = parseExpr();
+            if (peek()?.t !== "rp")
+                throw new Error("missing )");
+            next();
+            return v;
+        }
+        if (tk.t === "num") {
+            next();
+            return parseFloat(tk.v);
+        }
+        if (tk.t === "name") {
+            next();
+            if (peek()?.t === "lp" && AGGS.has(tk.v.toLowerCase())) {
+                next();
+                const arg = peek();
+                if (arg?.t !== "name")
+                    throw new Error(`bad argument to ${tk.v}()`);
+                next();
+                if (peek()?.t !== "rp")
+                    throw new Error("missing )");
+                next();
+                const a = agg(tk.v.toLowerCase(), arg.v);
+                if (a === null)
+                    throw new Error(`unknown column \`${arg.v}\``);
+                return a;
+            }
+            const cv = col(tk.v, row);
+            if (cv === null)
+                throw new Error(`unknown column \`${tk.v}\``);
+            return cv;
+        }
+        throw new Error(`unexpected token \`${tk.v}\``);
+    }
+    const v = parseExpr();
+    if (p !== toks.length)
+        throw new Error("trailing tokens in formula");
+    return v;
+}
+// ---------------------------------------------------------------------------
+// Spans
+// ---------------------------------------------------------------------------
+// Parse `r2c1:2x1` → target cell (1-based row/col over body) + size.
+function parseSpan(s) {
+    const m = /^r(\d+)c(\d+):(\d+)x(\d+)$/.exec(s.trim());
+    if (!m)
+        return null;
+    return { row: +m[1], col: +m[2], rows: +m[3], cols: +m[4] };
+}
+// ---------------------------------------------------------------------------
+// Public entry
+// ---------------------------------------------------------------------------
+export function parseTable(body, attrs, line, sink) {
+    const diagnostics = [];
+    const fmt = typeof attrs["format"] === "string" ? attrs["format"] : undefined;
+    // External data source (§6): `src=` points at a CSV/TSV file or URL, loaded at
+    // render time — not read here. So compute/chart column-name checking for an
+    // src table also happens at render time, and the inline body must be empty.
+    const src = typeof attrs["src"] === "string" ? attrs["src"] : undefined;
+    if (src !== undefined) {
+        if (body.some((l) => l.trim() !== "")) {
+            diagnostics.push({ severity: "error", message: "table has both `src` and an inline body; provide one, not both" });
+        }
+        const headerAttr = attrs["header"];
+        const header = headerAttr === undefined ? true : headerAttr === true || headerAttr === 1 || headerAttr === "1";
+        const model = { header, columns: [], align: [], rows: [], src };
+        const caption = attrs["caption"];
+        if (typeof caption === "string")
+            model.caption = caption;
+        return { model, diagnostics };
+    }
+    let raw;
+    if (fmt === "csv" || fmt === "tsv") {
+        const headerAttr = attrs["header"];
+        const header = headerAttr === undefined ? true : headerAttr === true || headerAttr === 1 || headerAttr === "1";
+        raw = parseDelimited(body, fmt === "tsv" ? "\t" : ",", header);
+    }
+    else {
+        if (fmt !== undefined)
+            diagnostics.push({ severity: "warning", message: `unknown table format \`${fmt}\`; parsed as visual grid` });
+        raw = parseVisual(body);
+    }
+    const columns = [...raw.columns];
+    const model = { header: raw.header, columns, align: raw.align, rows: [] };
+    const caption = attrs["caption"];
+    if (typeof caption === "string")
+        model.caption = caption;
+    // Build body cells with inline content and numeric values.
+    for (const r of raw.cells) {
+        const row = [];
+        for (let c = 0; c < columns.length; c++) {
+            const text = r[c] ?? "";
+            const cell = { text, inlines: parseInline(text, line, sink) };
+            const align = raw.align[c];
+            if (align)
+                cell.align = align;
+            const v = coerce(text);
+            if (typeof v === "number")
+                cell.value = v;
+            row.push(cell);
+        }
+        model.rows.push(row);
+    }
+    // Column lookup by header name or single letter (A=0).
+    const colIndex = (name) => {
+        const byName = columns.indexOf(name);
+        if (byName >= 0)
+            return byName;
+        if (/^[A-Z]$/.test(name))
+            return name.charCodeAt(0) - 65;
+        return -1;
+    };
+    const cellNum = (ci, row) => {
+        const v = model.rows[row]?.[ci]?.value;
+        return typeof v === "number" ? v : null;
+    };
+    const colResolve = (name, row) => {
+        const ci = colIndex(name);
+        return ci < 0 ? null : cellNum(ci, row);
+    };
+    const aggResolve = (fn, name) => {
+        const ci = colIndex(name);
+        if (ci < 0)
+            return null;
+        const vals = [];
+        for (let r = 0; r < model.rows.length; r++) {
+            const v = cellNum(ci, r);
+            if (v !== null)
+                vals.push(v);
+        }
+        if (fn === "count")
+            return vals.length;
+        if (vals.length === 0)
+            return 0;
+        if (fn === "sum")
+            return vals.reduce((a, b) => a + b, 0);
+        if (fn === "avg")
+            return vals.reduce((a, b) => a + b, 0) / vals.length;
+        if (fn === "min")
+            return Math.min(...vals);
+        if (fn === "max")
+            return Math.max(...vals);
+        return null;
+    };
+    // `compute="Name = expr; Name2 = expr2"` — `;`-separated; may also appear as
+    // compute, compute2, … Each formula adds/overwrites a per-row column.
+    const formulas = Object.entries(attrs)
+        .filter(([k]) => k === "compute" || /^compute\d+$/.test(k))
+        .map(([, v]) => v)
+        .filter((v) => typeof v === "string")
+        .flatMap((v) => v.split(";"))
+        .map((f) => f.trim())
+        .filter((f) => f !== "");
+    for (const f of formulas) {
+        const eq = f.indexOf("=");
+        if (eq <= 0) {
+            diagnostics.push({ severity: "error", message: `bad compute formula \`${f}\` (want \`Name = expr\`)` });
+            continue;
+        }
+        const { name, fmt } = splitName(f.slice(0, eq));
+        const expr = f.slice(eq + 1).trim();
+        let toks;
+        try {
+            toks = lexExpr(expr);
+        }
+        catch {
+            diagnostics.push({ severity: "error", message: `cannot lex formula \`${f}\`` });
+            continue;
+        }
+        // Target is a header name (never a letter reference): match by name only.
+        let ci = columns.indexOf(name);
+        if (ci < 0) {
+            columns.push(name);
+            ci = columns.length - 1;
+        }
+        let failed = false;
+        for (let r = 0; r < model.rows.length && !failed; r++) {
+            try {
+                const v = evalExpr(toks, r, colResolve, aggResolve);
+                const cell = ensureCell(model.rows[r], ci);
+                if (Number.isFinite(v)) {
+                    const text = fmt ? applyFormat(fmt, v) : defaultNum(v);
+                    cell.value = v;
+                    cell.text = text;
+                    cell.computed = true;
+                    cell.inlines = [{ type: "text", value: text }];
+                }
+            }
+            catch (e) {
+                diagnostics.push({ severity: "error", message: `compute \`${name}\`: ${e.message}` });
+                failed = true;
+            }
+        }
+    }
+    // `summary="Cell = value; …"` — one foot row. Each value is a string/number
+    // literal (a label) or arithmetic over aggregates (the only cross-row op).
+    const summaryDecls = Object.entries(attrs)
+        .filter(([k]) => k === "summary" || /^summary\d+$/.test(k))
+        .map(([, v]) => v)
+        .filter((v) => typeof v === "string")
+        .flatMap((v) => v.split(";"))
+        .map((s) => s.trim())
+        .filter((s) => s !== "");
+    if (summaryDecls.length > 0) {
+        const summary = columns.map(() => ({ text: "", inlines: [] }));
+        // In the summary row a bare column has no value: only aggregates resolve.
+        const noRow = () => null;
+        for (const s of summaryDecls) {
+            const eq = s.indexOf("=");
+            if (eq <= 0) {
+                diagnostics.push({ severity: "error", message: `bad summary \`${s}\` (want \`Cell = value\`)` });
+                continue;
+            }
+            const { name, fmt } = splitName(s.slice(0, eq));
+            const rhs = s.slice(eq + 1).trim();
+            const ci = colIndex(name);
+            if (ci < 0) {
+                diagnostics.push({ severity: "error", message: `summary targets unknown column \`${name}\`` });
+                continue;
+            }
+            // String label: `Cell = 'Total'`.
+            if (rhs.startsWith("'") && rhs.endsWith("'") && rhs.length >= 2) {
+                const text = rhs.slice(1, -1);
+                summary[ci] = { text, inlines: [{ type: "text", value: text }] };
+                continue;
+            }
+            // Otherwise an aggregate expression.
+            let toks;
+            try {
+                toks = lexExpr(rhs);
+            }
+            catch {
+                diagnostics.push({ severity: "error", message: `cannot lex summary \`${s}\`` });
+                continue;
+            }
+            try {
+                const v = evalExpr(toks, 0, noRow, aggResolve);
+                if (Number.isFinite(v)) {
+                    const text = fmt ? applyFormat(fmt, v) : defaultNum(v);
+                    summary[ci] = { text, inlines: [{ type: "text", value: text }], value: v, computed: true };
+                }
+            }
+            catch (e) {
+                const msg = /unknown column `(.+)`/.exec(e.message);
+                const hint = msg ? `summary \`${name}\`: column \`${msg[1]}\` must be reduced by an aggregate (e.g. sum(${msg[1]}))` : `summary \`${name}\`: ${e.message}`;
+                diagnostics.push({ severity: "error", message: hint });
+            }
+        }
+        model.summary = summary;
+    }
+    // Spans: `span="r2c1:2x1"` (one or many: span, span2, …).
+    const spanDecls = Object.entries(attrs)
+        .filter(([k]) => k === "span" || /^span\d+$/.test(k))
+        .map(([, v]) => v)
+        .filter((v) => typeof v === "string");
+    for (const sd of spanDecls) {
+        const sp = parseSpan(sd);
+        if (!sp) {
+            diagnostics.push({ severity: "error", message: `bad span \`${sd}\` (want \`rNcM:RxC\`)` });
+            continue;
+        }
+        const cell = model.rows[sp.row - 1]?.[sp.col - 1];
+        if (!cell) {
+            diagnostics.push({ severity: "warning", message: `span \`${sd}\` targets a cell outside the table` });
+            continue;
+        }
+        cell.span = { rows: sp.rows, cols: sp.cols };
+    }
+    return { model, diagnostics };
+}
+function ensureCell(row, ci) {
+    while (row.length <= ci)
+        row.push({ text: "", inlines: [] });
+    return row[ci];
+}

package/dist/to-md.d.ts

@@ -0,0 +1,5 @@
+import type { Document } from "./geml.js";
+export declare function gemlToMd(doc: Document): {
+    md: string;
+    notes: string[];
+};