postext 0.3.28 → 0.3.30

package/dist/pipeline/resourceLayout.d.ts

@@ -23,7 +23,12 @@
  *    the caption is above, otherwise under the caption.
  *
  * Resource + caption + note are measured as one group; `totalHeight` is what
- * goes to placement (resources paginate atomically — no mid-split for v1).
+ * goes to placement. Figures paginate atomically; a table taller than the
+ * page can be laid out as a *slice* of its rows (`ResourceLayoutInput.slice`)
+ * — a continuation repeats the header rows and suffixes the caption, and a
+ * slice that goes on sets a marker under it and holds the note back for the
+ * last one. {@link planTableSlice} picks the rows a slice can carry from the
+ * row metrics the full-table layout reports.
  */
 import type { InlineSpan } from '../parse';
 import type { Resource, ResourceType, TableModel } from '../types';
@@ -40,6 +45,35 @@ export interface ResourceLayoutInput {
     resourceNumbering: ResourceNumberingMap;
     resourceTypes: ResourceType[];
     resources: Resource[];
+    /** Lay out only these rows of a table (a slice of a table split across
+     *  pages). Ignored for figures. */
+    slice?: TableSliceSpec;
+}
+/** The rows a table slice carries. `startRow > 0` makes it a continuation:
+ *  the header rows are repeated above `startRow` and the caption gets the
+ *  continued suffix. `continues` sets the marker under the slice (and holds
+ *  the note back). */
+export interface TableSliceSpec {
+    startRow: number;
+    /** Exclusive. */
+    endRow: number;
+    continues: boolean;
+}
+/** Per-row metrics of a table laid out in full at some width, from which
+ *  {@link planTableSlice} decides where a slice can end. Row heights are
+ *  exact for any slice at the same width: every row is measured at the same
+ *  column edges, and rowspans never straddle a break. */
+export interface TableRowMetrics {
+    /** Height of each model row in px (rowspan overflow already distributed). */
+    rowHeights: number[];
+    /** Leading header rows, repeated at the top of every continuation. */
+    headerRowCount: number;
+    /** Whether a slice may end after row `i` — no rowspan crosses the edge
+     *  between `i` and `i + 1`. */
+    breakableAfter: boolean[];
+    /** Rows that head the rows below them (a single cell across every column,
+     *  or all header cells): a slice never ends on one when it can help it. */
+    groupHeaderRow: boolean[];
 }
 /** Build a label for an inline `:ref` to a resource, honouring its `style` and
  *  optional override `text`. Mirrors the caption-prefix conventions. */
@@ -58,6 +92,23 @@ export declare function resolveRefSpans(spans: InlineSpan[], resourceNumbering:
  * non-positive / non-finite weight falls back to an equal split.
  */
 export declare function computeColumnEdges(model: TableModel, columnWidth: number): number[];
+/** Number of leading header rows of a table: `headerRowCount` when the
+ *  model declares it, else the leading run of rows whose visible cells are
+ *  all header cells. Never the whole table — a continuation needs at least
+ *  one body row to carry. */
+export declare function tableHeaderRowCount(model: TableModel): number;
+/** The model rows a slice lays out, in order: the header rows (repeated on a
+ *  continuation) followed by the slice's own rows. */
+export declare function tableSliceRows(model: TableModel, slice: TableSliceSpec): number[];
+/**
+ * Where a slice starting at `startRow` can end so that its rows (plus the
+ * repeated header rows of a continuation) stay within `bodyBudget` px: the
+ * furthest row edge no rowspan straddles, backed off a group-header row so
+ * the heading opens the rows it heads on the next page. Returns the
+ * exclusive end row — `startRow` when not even one row fits, the row count
+ * when the whole rest fits.
+ */
+export declare function planTableSlice(metrics: TableRowMetrics, startRow: number, bodyBudget: number): number;
 /**
  * Measure a resource block (image / svg / table) plus its caption into a
  * placement-ready {@link ResolvedResourceBlock}. Returns the block and its
@@ -67,5 +118,8 @@ export declare function computeColumnEdges(model: TableModel, columnWidth: numbe
 export declare function layoutResourceBlock(input: ResourceLayoutInput): {
     block: ResolvedResourceBlock;
     totalHeight: number;
+    /** Row metrics of a table laid out in full (no `slice`), for
+     *  {@link planTableSlice}. */
+    tableRows?: TableRowMetrics;
 };
 //# sourceMappingURL=resourceLayout.d.ts.map

package/dist/pipeline/resourceLayout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resourceLayout.d.ts","sourceRoot":"","sources":["../../src/pipeline/resourceLayout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAW,MAAM,UAAU,CAAC;AACpD,OAAO,KAAK,EAEV,QAAQ,EACR,YAAY,EACZ,UAAU,EAIX,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EAItB,MAAM,QAAQ,CAAC;AAUhB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAMhE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,YAAY,GAAG,SAAS,CAAC;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,cAAc,CAAC;IACzB,oCAAoC;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,iBAAiB,EAAE,oBAAoB,CAAC;IACxC,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,SAAS,EAAE,QAAQ,EAAE,CAAC;CACvB;AAED;wEACwE;AACxE,wBAAgB,eAAe,CAC7B,GAAG,EAAE,WAAW,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,EACnC,iBAAiB,EAAE,oBAAoB,EACvC,aAAa,EAAE,YAAY,EAAE,EAC7B,SAAS,EAAE,QAAQ,EAAE,GACpB,MAAM,CAcR;AAmBD;;6EAE6E;AAC7E,wBAAgB,eAAe,CAC7B,KAAK,EAAE,UAAU,EAAE,EACnB,iBAAiB,EAAE,oBAAoB,EACvC,aAAa,EAAE,YAAY,EAAE,EAC7B,SAAS,EAAE,QAAQ,EAAE,EACrB,QAAQ,CAAC,EAAE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GAC5C,UAAU,EAAE,CAcd;AAuDD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAsBnF;AAkJD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,mBAAmB,GAAG;IAC/D,KAAK,EAAE,qBAAqB,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;CACrB,CAiQA"}
+{"version":3,"file":"resourceLayout.d.ts","sourceRoot":"","sources":["../../src/pipeline/resourceLayout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAW,MAAM,UAAU,CAAC;AACpD,OAAO,KAAK,EAEV,QAAQ,EACR,YAAY,EAEZ,UAAU,EAIX,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EAOtB,MAAM,QAAQ,CAAC;AAUhB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAMhE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,YAAY,GAAG,SAAS,CAAC;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,cAAc,CAAC;IACzB,oCAAoC;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,iBAAiB,EAAE,oBAAoB,CAAC;IACxC,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB;uCACmC;IACnC,KAAK,CAAC,EAAE,cAAc,CAAC;CACxB;AAED;;;sBAGsB;AACtB,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;yDAGyD;AACzD,MAAM,WAAW,eAAe;IAC9B,6EAA6E;IAC7E,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,sEAAsE;IACtE,cAAc,EAAE,MAAM,CAAC;IACvB;mCAC+B;IAC/B,cAAc,EAAE,OAAO,EAAE,CAAC;IAC1B;+EAC2E;IAC3E,cAAc,EAAE,OAAO,EAAE,CAAC;CAC3B;AAED;wEACwE;AACxE,wBAAgB,eAAe,CAC7B,GAAG,EAAE,WAAW,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,EACnC,iBAAiB,EAAE,oBAAoB,EACvC,aAAa,EAAE,YAAY,EAAE,EAC7B,SAAS,EAAE,QAAQ,EAAE,GACpB,MAAM,CAcR;AAmBD;;6EAE6E;AAC7E,wBAAgB,eAAe,CAC7B,KAAK,EAAE,UAAU,EAAE,EACnB,iBAAiB,EAAE,oBAAoB,EACvC,aAAa,EAAE,YAAY,EAAE,EAC7B,SAAS,EAAE,QAAQ,EAAE,EACrB,QAAQ,CAAC,EAAE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GAC5C,UAAU,EAAE,CAcd;AAgPD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAsBnF;AAED;;;6BAG6B;AAC7B,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAe7D;AAMD;sDACsD;AACtD,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,cAAc,GAAG,MAAM,EAAE,CAajF;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAuBrG;AA4ND;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,mBAAmB,GAAG;IAC/D,KAAK,EAAE,qBAAqB,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB;kCAC8B;IAC9B,SAAS,CAAC,EAAE,eAAe,CAAC;CAC7B,CA4TA"}

package/dist/pipeline/resourceLayout.js

@@ -23,10 +23,15 @@
  *    the caption is above, otherwise under the caption.
  *
  * Resource + caption + note are measured as one group; `totalHeight` is what
- * goes to placement (resources paginate atomically — no mid-split for v1).
+ * goes to placement. Figures paginate atomically; a table taller than the
+ * page can be laid out as a *slice* of its rows (`ResourceLayoutInput.slice`)
+ * — a continuation repeats the header rows and suffixes the caption, and a
+ * slice that goes on sets a marker under it and holds the note back for the
+ * last one. {@link planTableSlice} picks the rows a slice can carry from the
+ * row metrics the full-table layout reports.
  */
 import { createBoundingBox } from '../vdt';
-import { measureRichBlock, buildFontString } from '../measure';
+import { measureRichBlock, measureTextWidth, buildFontString } from '../measure';
 import { dimensionToPx } from '../units';
 // Caption / table-cell / note content is parsed with the shared snippet
 // parser so measurement and the sandbox's glyph→snippet mapping agree on
@@ -112,6 +117,157 @@ function fitWidth(intrinsicW, intrinsicH, columnWidth) {
     const height = (intrinsicH / intrinsicW) * width;
     return { width, height };
 }
+/** Markers a cell paragraph may open with: bullets, dashes, a number with
+ *  its dot or bracket — followed by whitespace and some text. */
+const CELL_ITEM_MARKER = /^(\s*)([•·◦○▪‣\-*–—]|\d{1,3}[.)])(\s+)(?=\S)/;
+/** Split a cell's spans into paragraphs at hard line breaks (`\n`). The
+ *  break characters are dropped; an empty paragraph (a blank line) is kept
+ *  out — the measurer would skip it as whitespace anyway. */
+function splitCellParagraphs(spans) {
+    const out = [];
+    let current = [];
+    const flush = () => {
+        if (current.some((sp) => sp.text.trim().length > 0))
+            out.push(current);
+        current = [];
+    };
+    for (const span of spans) {
+        if (span.ref || span.math || !span.text.includes('\n')) {
+            current.push(span);
+            continue;
+        }
+        const pieces = span.text.split('\n');
+        pieces.forEach((piece, i) => {
+            if (i > 0)
+                flush();
+            if (piece.length > 0)
+                current.push({ ...span, text: piece });
+        });
+    }
+    flush();
+    return out;
+}
+/** Detach a list marker from the head of a paragraph, when it opens with
+ *  one. Returns the marker and the spans with it stripped. */
+function takeCellItemMarker(spans) {
+    const first = spans[0];
+    if (!first || first.ref || first.math)
+        return null;
+    const m = CELL_ITEM_MARKER.exec(first.text);
+    if (!m)
+        return null;
+    const [whole, indent, text, ws] = m;
+    const rest = first.text.slice(whole.length);
+    const stripped = rest.length > 0 ? [{ ...first, text: rest }, ...spans.slice(1)] : spans.slice(1);
+    return { marker: { text, ws, level: Math.min(5, 1 + Math.floor(indent.length / 2)) }, spans: stripped };
+}
+/**
+ * Measure a cell's content: paragraphs separated by hard line breaks, each
+ * either plain text or a list item. An item hangs its text off its marker —
+ * the marker is painted as authored ("•", "–", "1."), the text starts after
+ * `listGapPx`, and wrapped lines align with the text — nested two spaces per
+ * level. Every plain character of the content survives in the produced
+ * segments (the marker and its whitespace included), so the sandbox's
+ * glyph → snippet mapping stays exact.
+ */
+function measureCellContent(spans, set, width, textAlign, listGapPx) {
+    const paragraphs = splitCellParagraphs(spans);
+    const lines = [];
+    let y = 0;
+    const measure = (ps, w) => measureRichBlock(ps, set.fontString, set.boldFontString, set.italicFontString, set.boldItalicFontString, Math.max(1, w), set.lineHeightPx, { textAlign: 'left' });
+    // Plain paragraphs follow the cell's horizontal alignment: the measurer
+    // sets every line flush left at its natural width, so a centred or
+    // right-aligned line is pushed over by the slack. List items stay flush
+    // left (their markers align).
+    const slack = (line) => textAlign === 'center' ? Math.max(0, (width - line.bbox.width) / 2)
+        : textAlign === 'right' ? Math.max(0, width - line.bbox.width)
+            : 0;
+    for (const paragraph of paragraphs) {
+        const item = takeCellItemMarker(paragraph);
+        if (!item) {
+            const m = measure(paragraph, width);
+            lines.push(...m.lines.map((line) => shiftLines([line], slack(line), y)[0]));
+            y += m.lines.length * set.lineHeightPx;
+            continue;
+        }
+        const markerWidth = measureTextWidth(item.marker.text, set.fontString);
+        const indentPx = markerWidth + listGapPx;
+        const levelOffset = (item.marker.level - 1) * indentPx;
+        const textX = levelOffset + indentPx;
+        const m = measure(item.spans, width - textX);
+        m.lines.forEach((line, i) => {
+            if (i === 0) {
+                const head = [
+                    { kind: 'text', text: item.marker.text, width: markerWidth },
+                    { kind: 'space', text: item.marker.ws, width: indentPx - markerWidth },
+                ];
+                lines.push({
+                    ...line,
+                    text: `${item.marker.text}${item.marker.ws}${line.text}`,
+                    bbox: createBoundingBox(levelOffset, line.bbox.y + y, indentPx + line.bbox.width, line.bbox.height),
+                    baseline: line.baseline + y,
+                    segments: [...head, ...(line.segments ?? [])],
+                });
+            }
+            else {
+                lines.push({
+                    ...line,
+                    bbox: createBoundingBox(textX + line.bbox.x, line.bbox.y + y, line.bbox.width, line.bbox.height),
+                    baseline: line.baseline + y,
+                });
+            }
+        });
+        y += m.lines.length * set.lineHeightPx;
+    }
+    return { lines, totalHeight: y };
+}
+/**
+ * Resolve `TableCell.image` against the document's resources and size it:
+ * the image takes `image.width` of the cell's inner width (all of it by
+ * default) with its aspect ratio kept — a bitmap narrower than that keeps
+ * its intrinsic size, like a floated figure — and sits at the cell's
+ * horizontal alignment. An id that matches no bitmap / SVG resource, or a
+ * payload without a file, yields null and the cell lays out text-only.
+ */
+function fitCellImage(image, align, innerWidth, resources) {
+    if (!image)
+        return null;
+    const resource = resources.find((r) => r.id === image.resourceId);
+    if (!resource)
+        return null;
+    const fraction = image.width !== undefined && Number.isFinite(image.width) && image.width > 0
+        ? Math.min(1, image.width)
+        : 1;
+    const target = Math.max(1, innerWidth * fraction);
+    let fileId;
+    let format;
+    let kind;
+    let width;
+    let height;
+    if (resource.kind === 'bitmap' && resource.bitmap) {
+        kind = 'bitmap';
+        fileId = resource.bitmap.fileId;
+        format = resource.bitmap.format;
+        const fit = fitWidth(resource.bitmap.width, resource.bitmap.height, target);
+        width = fit.width;
+        height = fit.height;
+    }
+    else if (resource.kind === 'svg' && resource.svg) {
+        kind = 'svg';
+        fileId = resource.svg.fileId;
+        const iw = resource.svg.width ?? 0;
+        const ih = resource.svg.height ?? 0;
+        width = target;
+        height = iw > 0 && ih > 0 ? target * (ih / iw) : target * 0.75;
+    }
+    else {
+        return null;
+    }
+    if (!fileId)
+        return null;
+    const x = align === 'center' ? (innerWidth - width) / 2 : align === 'right' ? innerWidth - width : 0;
+    return { resourceId: resource.id, kind, fileId, format, x: Math.max(0, x), width, height };
+}
 /** Smallest border thickness (px) we let through: thinner rules would vanish
  *  on screen, but 0.5pt (≈0.67px at 96dpi) hairlines must survive intact —
  *  the previous `max(1, round(px))` rounded them up to a full pixel. */
@@ -147,46 +303,168 @@ export function computeColumnEdges(model, columnWidth) {
     edges[colCount] = columnWidth;
     return edges;
 }
+/** Number of leading header rows of a table: `headerRowCount` when the
+ *  model declares it, else the leading run of rows whose visible cells are
+ *  all header cells. Never the whole table — a continuation needs at least
+ *  one body row to carry. */
+export function tableHeaderRowCount(model) {
+    const rowCount = model.rows.length;
+    if (rowCount === 0)
+        return 0;
+    const declared = model.headerRowCount ?? 0;
+    let count = 0;
+    if (declared > 0) {
+        count = declared;
+    }
+    else {
+        for (const row of model.rows) {
+            const visible = row.filter((c) => !c.hiddenBy);
+            if (visible.length === 0 || !visible.every((c) => c.isHeader))
+                break;
+            count++;
+        }
+    }
+    return Math.max(0, Math.min(count, rowCount - 1));
+}
+/** Whether a table cell is painted as a header cell. */
+const cellIsHeader = (cell, row, model) => cell.isHeader ?? row < (model.headerRowCount ?? 0);
+/** The model rows a slice lays out, in order: the header rows (repeated on a
+ *  continuation) followed by the slice's own rows. */
+export function tableSliceRows(model, slice) {
+    const headerRows = tableHeaderRowCount(model);
+    const rowCount = model.rows.length;
+    const start = Math.max(0, Math.min(slice.startRow, rowCount));
+    const end = Math.max(start, Math.min(slice.endRow, rowCount));
+    const rows = [];
+    if (start > 0) {
+        for (let r = 0; r < headerRows; r++)
+            rows.push(r);
+        for (let r = Math.max(start, headerRows); r < end; r++)
+            rows.push(r);
+    }
+    else {
+        for (let r = start; r < end; r++)
+            rows.push(r);
+    }
+    return rows;
+}
+/**
+ * Where a slice starting at `startRow` can end so that its rows (plus the
+ * repeated header rows of a continuation) stay within `bodyBudget` px: the
+ * furthest row edge no rowspan straddles, backed off a group-header row so
+ * the heading opens the rows it heads on the next page. Returns the
+ * exclusive end row — `startRow` when not even one row fits, the row count
+ * when the whole rest fits.
+ */
+export function planTableSlice(metrics, startRow, bodyBudget) {
+    const { rowHeights, headerRowCount, breakableAfter, groupHeaderRow } = metrics;
+    const rowCount = rowHeights.length;
+    const start = Math.max(0, Math.min(startRow, rowCount));
+    // A continuation carries the header rows again; the first slice includes
+    // them as ordinary leading rows.
+    const firstBody = start > 0 ? Math.max(start, headerRowCount) : start;
+    let acc = 0;
+    if (start > 0)
+        for (let r = 0; r < headerRowCount; r++)
+            acc += rowHeights[r] ?? 0;
+    let best = start;
+    for (let r = firstBody; r < rowCount; r++) {
+        acc += rowHeights[r] ?? 0;
+        if (acc > bodyBudget + 0.01)
+            break;
+        if (breakableAfter[r] ?? true)
+            best = r + 1;
+    }
+    // The first slice must carry a body row past the header; a continuation
+    // at least its first row. Below that floor the caller decides.
+    const floor = (start > 0 ? firstBody : headerRowCount) + 1;
+    // Back off group heads left at the cut, but only when a row that is not
+    // one remains: a run of nothing but heads is not a heading at all.
+    let cut = best;
+    while (cut > floor && groupHeaderRow[cut - 1])
+        cut--;
+    return cut > floor || best <= floor ? cut : best;
+}
 /** Lay out an HTML-table resource: weighted column split (see
  *  {@link computeColumnEdges}), per-cell rich-text measurement, row height =
  *  max measured cell height. Rowspans reserve their primary cell's full
- *  vertical extent. */
-function layoutTable(model, columnWidth, style, resourceNumbering, resourceTypes, resources, refStyle) {
+ *  vertical extent. `selection` restricts the layout to those model rows
+ *  (in order) for a slice; cells keep their model row index. The row metrics
+ *  are reported for a full layout only. */
+function layoutTable(model, columnWidth, style, resourceNumbering, resourceTypes, resources, refStyle, selection) {
     const { body, header, borderColor, borderWidthPx, cellPaddingPx } = style;
-    const rowCount = model.rows.length;
-    const colCount = rowCount > 0 ? Math.max(...model.rows.map((r) => r.length)) : 0;
+    const modelRowCount = model.rows.length;
+    const rows = selection ?? model.rows.map((_r, i) => i);
+    const rowCount = rows.length;
+    /** Slice index of each laid-out model row. */
+    const sliceIndexOf = new Map();
+    rows.forEach((r, i) => sliceIndexOf.set(r, i));
+    const colCount = modelRowCount > 0 ? Math.max(...model.rows.map((r) => r.length)) : 0;
     const columnEdges = computeColumnEdges(model, columnWidth);
     const spanWidth = (col, colSpan) => (columnEdges[Math.min(col + colSpan, colCount)] ?? columnWidth) - (columnEdges[col] ?? 0);
+    /** Rows a primary cell at model row `r` spanning `rowSpan` rows covers
+     *  within this layout: the run of its spanned rows that sit consecutively
+     *  after it in the selection. */
+    const spanInSlice = (si, r, rowSpan) => {
+        let n = 1;
+        while (n < rowSpan && rows[si + n] === r + n)
+            n++;
+        return n;
+    };
     const measured = [];
     const rowMinHeight = new Array(rowCount).fill(body.lineHeightPx);
-    for (let r = 0; r < rowCount; r++) {
+    for (let si = 0; si < rowCount; si++) {
+        const r = rows[si];
         const row = model.rows[r];
+        if (!row)
+            continue;
         for (let c = 0; c < row.length; c++) {
-            const cell = row[c];
-            if (cell.hiddenBy)
-                continue;
+            let cell = row[c];
+            if (cell.hiddenBy) {
+                // Covered by a merge whose primary is laid out here and reaches this
+                // row: skip. A primary left out of the slice (a rowspan running from
+                // the header into the body) leaves an empty cell so the grid closes.
+                const p = cell.hiddenBy;
+                const primary = model.rows[p.row]?.[p.col];
+                const psi = sliceIndexOf.get(p.row);
+                const covered = primary !== undefined && psi !== undefined && psi <= si
+                    && spanInSlice(psi, p.row, Math.max(1, primary.rowSpan ?? 1)) > si - psi
+                    && c >= p.col && c < p.col + Math.max(1, primary.colSpan ?? 1);
+                if (covered)
+                    continue;
+                cell = { content: '', isHeader: cellIsHeader(primary ?? cell, p.row, model) };
+            }
             const colSpan = Math.max(1, cell.colSpan ?? 1);
-            const rowSpan = Math.max(1, cell.rowSpan ?? 1);
-            const isHeader = cell.isHeader ?? r < (model.headerRowCount ?? 0);
+            const rowSpan = spanInSlice(si, r, Math.max(1, cell.rowSpan ?? 1));
+            const isHeader = cellIsHeader(cell, r, model);
             const set = isHeader ? header : body;
             const cellWidth = spanWidth(c, colSpan) - cellPaddingPx * 2;
             const spans = resolveRefSpans(parseRefAwareSpans(cell.content), resourceNumbering, resourceTypes, resources, refStyle);
-            const m = measureRichBlock(spans, set.fontString, set.boldFontString, set.italicFontString, set.boldItalicFontString, Math.max(1, cellWidth), set.lineHeightPx, { textAlign: cell.align === 'center' ? 'center' : cell.align === 'right' ? 'left' : 'left' });
-            const contentHeight = Math.max(set.lineHeightPx, m.totalHeight) + cellPaddingPx * 2;
+            const m = measureCellContent(spans, set, Math.max(1, cellWidth), cell.align ?? 'left', style.listGapPx);
+            // An embedded image sits at the top of the cell; the text (when
+            // there is any) runs under it, a padding's worth below.
+            const image = cell.hiddenBy ? null : fitCellImage(cell.image, cell.align ?? 'left', Math.max(1, cellWidth), resources);
+            const textHeight = m.totalHeight;
+            const textY = image ? image.height + (textHeight > 0 ? cellPaddingPx : 0) : 0;
+            const lines = image && textHeight > 0 ? shiftLines(m.lines, 0, textY) : m.lines;
+            const stackHeight = image ? textY + textHeight : textHeight;
+            const contentHeight = Math.max(set.lineHeightPx, stackHeight) + cellPaddingPx * 2;
             measured.push({
                 row: r,
+                sliceRow: si,
                 col: c,
                 colSpan,
                 rowSpan,
                 isHeader,
                 align: cell.align ?? 'left',
                 verticalAlign: cell.verticalAlign ?? 'top',
-                lines: m.lines,
+                lines,
                 contentHeight,
+                image,
             });
             // Single-row cells drive their row's minimum height directly.
             if (rowSpan === 1) {
-                rowMinHeight[r] = Math.max(rowMinHeight[r], contentHeight);
+                rowMinHeight[si] = Math.max(rowMinHeight[si], contentHeight);
             }
         }
     }
@@ -195,27 +473,64 @@ function layoutTable(model, columnWidth, style, resourceNumbering, resourceTypes
         if (m.rowSpan <= 1)
             continue;
         let spannedHeight = 0;
-        for (let r = m.row; r < m.row + m.rowSpan && r < rowCount; r++) {
-            spannedHeight += rowMinHeight[r];
+        for (let si = m.sliceRow; si < m.sliceRow + m.rowSpan && si < rowCount; si++) {
+            spannedHeight += rowMinHeight[si];
         }
         if (m.contentHeight > spannedHeight) {
-            const lastRow = Math.min(m.row + m.rowSpan - 1, rowCount - 1);
+            const lastRow = Math.min(m.sliceRow + m.rowSpan - 1, rowCount - 1);
             rowMinHeight[lastRow] = rowMinHeight[lastRow] + (m.contentHeight - spannedHeight);
         }
     }
     const rowEdges = [0];
-    for (let r = 0; r < rowCount; r++)
-        rowEdges.push(rowEdges[r] + rowMinHeight[r]);
+    for (let si = 0; si < rowCount; si++)
+        rowEdges.push(rowEdges[si] + rowMinHeight[si]);
     const tableHeight = rowEdges[rowCount] ?? 0;
+    // Row metrics for slice planning (full layouts only — a slice's rows are
+    // a subset, so its heights say nothing about the rest).
+    let metrics;
+    if (!selection) {
+        const breakableAfter = new Array(rowCount).fill(true);
+        const groupHeaderRow = new Array(rowCount).fill(false);
+        const primaries = new Array(rowCount).fill(0);
+        const allHeader = new Array(rowCount).fill(true);
+        const fullSpan = new Array(rowCount).fill(false);
+        for (const m of measured) {
+            for (let r = m.row; r < m.row + m.rowSpan - 1; r++)
+                breakableAfter[r] = false;
+            primaries[m.row] = (primaries[m.row] ?? 0) + 1;
+            if (!m.isHeader)
+                allHeader[m.row] = false;
+            if (m.colSpan >= colCount)
+                fullSpan[m.row] = true;
+        }
+        const headerRowCount = tableHeaderRowCount(model);
+        for (let r = headerRowCount; r < rowCount; r++) {
+            const p = primaries[r] ?? 0;
+            // A single cell across every column heads the rows below it — in a
+            // multi-column table. Every row of a one-column (boxed) table spans
+            // it, and none of them is a heading.
+            groupHeaderRow[r] = p > 0 && ((p === 1 && fullSpan[r] === true && colCount > 1) || allHeader[r] === true);
+        }
+        metrics = { rowHeights: [...rowMinHeight], headerRowCount, breakableAfter, groupHeaderRow };
+    }
     const cells = measured.map((m) => {
         const x0 = columnEdges[m.col] ?? 0;
         const x1 = columnEdges[Math.min(m.col + m.colSpan, colCount)] ?? columnWidth;
-        const y0 = rowEdges[m.row] ?? 0;
-        const y1 = rowEdges[Math.min(m.row + m.rowSpan, rowCount)] ?? tableHeight;
+        const y0 = rowEdges[m.sliceRow] ?? 0;
+        const y1 = rowEdges[Math.min(m.sliceRow + m.rowSpan, rowCount)] ?? tableHeight;
         const rect = createBoundingBox(x0, y0, x1 - x0, y1 - y0);
         // Place lines inside the cell with padding; horizontal alignment is applied
         // by the renderer via the cell rect + align flag.
         const placed = shiftLines(m.lines, x0 + cellPaddingPx, y0 + cellPaddingPx);
+        const image = m.image
+            ? {
+                resourceId: m.image.resourceId,
+                kind: m.image.kind,
+                fileId: m.image.fileId,
+                ...(m.image.format !== undefined ? { format: m.image.format } : {}),
+                rect: createBoundingBox(x0 + cellPaddingPx + m.image.x, y0 + cellPaddingPx, m.image.width, m.image.height),
+            }
+            : undefined;
         return {
             row: m.row,
             col: m.col,
@@ -226,6 +541,7 @@ function layoutTable(model, columnWidth, style, resourceNumbering, resourceTypes
             verticalAlign: m.verticalAlign,
             rect,
             lines: placed,
+            ...(image ? { image } : {}),
         };
     });
     const layout = {
@@ -248,7 +564,7 @@ function layoutTable(model, columnWidth, style, resourceNumbering, resourceTypes
         rowEdges,
         rules: style.rules,
     };
-    return { layout, height: tableHeight };
+    return metrics ? { layout, height: tableHeight, metrics } : { layout, height: tableHeight };
 }
 /**
  * Measure a resource block (image / svg / table) plus its caption into a
@@ -258,6 +574,18 @@ function layoutTable(model, columnWidth, style, resourceNumbering, resourceTypes
  */
 export function layoutResourceBlock(input) {
     const { resource, resourceType, number, resolved, columnWidth, resourceNumbering, resourceTypes, resources, } = input;
+    // A slice only applies to tables; a slice covering the whole table from
+    // row 0 is the full table (no continuation marks).
+    const model = resource.kind === 'table' ? resource.table?.model : undefined;
+    const slice = model && input.slice
+        && (input.slice.startRow > 0 || input.slice.endRow < model.rows.length || input.slice.continues)
+        ? {
+            startRow: Math.max(0, Math.min(input.slice.startRow, model.rows.length)),
+            endRow: Math.max(0, Math.min(input.slice.endRow, model.rows.length)),
+            continued: input.slice.startRow > 0,
+            continues: input.slice.continues,
+        }
+        : undefined;
     const bodyStyle = resolveBodyStyle(resolved);
     const dpi = resolved.page.dpi;
     // Normal / bold weights reused for table + caption font sets.
@@ -273,6 +601,7 @@ export function layoutResourceBlock(input) {
     let bodyWidth = columnWidth;
     let bodyHeight = 0;
     let table;
+    let tableRows;
     let fileId;
     let format;
     if (resource.kind === 'bitmap' && resource.bitmap) {
@@ -327,9 +656,11 @@ export function layoutResourceBlock(input) {
             headerBackground: ts.headerBackgroundEnabled ? ts.headerBackground.hex : undefined,
             bodyBackground: ts.bodyBackgroundEnabled ? ts.bodyBackground.hex : undefined,
             rules: ts.rules,
+            listGapPx: dimensionToPx(resolved.unorderedLists.gap, dpi, bodyFontPx),
         };
-        const { layout, height } = layoutTable(resource.table.model, columnWidth, style, resourceNumbering, resourceTypes, resources, refStyle);
+        const { layout, height, metrics } = layoutTable(resource.table.model, columnWidth, style, resourceNumbering, resourceTypes, resources, refStyle, slice ? tableSliceRows(resource.table.model, slice) : undefined);
         table = layout;
+        tableRows = metrics;
         bodyWidth = columnWidth;
         bodyHeight = height;
     }
@@ -363,9 +694,15 @@ export function layoutResourceBlock(input) {
         const descSpans = cs.descriptionItalic
             ? resolvedSpans.map((s) => ({ ...s, italic: s.italic || true }))
             : resolvedSpans;
+        // A continued table slice: "Table 6-4. Title (cont.)" — the suffix is
+        // set in italics after the description, glued to it by a plain space.
+        const suffix = slice?.continued ? resolved.tableStyle.continuedSuffix.trim() : '';
+        const suffixSpans = suffix.length > 0
+            ? [{ text: `${descSpans.length > 0 ? ' ' : ''}${suffix}`, bold: false, italic: true }]
+            : [];
         const allSpans = prefixText.length > 0
-            ? [{ text: prefixText, bold: cs.labelBold, italic: cs.labelItalic, captionLabel: true }, ...descSpans]
-            : descSpans;
+            ? [{ text: prefixText, bold: cs.labelBold, italic: cs.labelItalic, captionLabel: true }, ...descSpans, ...suffixSpans]
+            : [...descSpans, ...suffixSpans];
         const measured = measureRichBlock(allSpans, captionFontString, captionBoldFontString, captionItalicFontString, captionBoldItalicFontString, Math.max(1, columnWidth - captionPaddingPx * 2), captionLineHeightPx, { textAlign: cs.align });
         measuredCaption = measured.lines;
     }
@@ -385,7 +722,9 @@ export function layoutResourceBlock(input) {
     const noteBoldItalicFontString = buildFontString(cs.fontFamily, noteFontPx, boldWeight, 'italic');
     let measuredNote = [];
     const noteText = resource.note ?? '';
-    if (noteText.trim().length > 0) {
+    // The note closes the table: a slice that continues holds it back for
+    // the last slice.
+    if (noteText.trim().length > 0 && !slice?.continues) {
         const noteSpans = resolveRefSpans(parseRefAwareSpans(noteText), resourceNumbering, resourceTypes, resources, refStyle);
         const slanted = cs.note.italic
             ? noteSpans.map((s) => ({ ...s, italic: s.italic || true }))
@@ -396,6 +735,24 @@ export function layoutResourceBlock(input) {
     const noteHeight = measuredNote.length > 0
         ? measuredNote.length * noteLineHeightPx + noteGapPx
         : 0;
+    // --- Continues marker --------------------------------------------------
+    // "Continued" under a slice that goes on: the note's typeface and size,
+    // italic, flush right — where the note would sit.
+    let measuredContinues = [];
+    const ts = resolved.tableStyle;
+    const markerText = slice?.continues && ts.continuesMarkerEnabled ? ts.continuesMarker.trim() : '';
+    if (markerText.length > 0) {
+        const measured = measureRichBlock([{ text: markerText, bold: false, italic: true }], noteFontString, noteBoldFontString, noteItalicFontString, noteBoldItalicFontString, Math.max(1, columnWidth), noteLineHeightPx, { textAlign: 'left' });
+        // Flush right: the measurer has no right alignment, so each line is
+        // pushed to the block's right edge by its own width.
+        measuredContinues = measured.lines.map((line) => ({
+            ...line,
+            bbox: createBoundingBox(columnWidth - line.bbox.width, line.bbox.y, line.bbox.width, line.bbox.height),
+        }));
+    }
+    const continuesHeight = measuredContinues.length > 0
+        ? measuredContinues.length * noteLineHeightPx + noteGapPx
+        : 0;
     // --- Vertical stacking -------------------------------------------------
     // above: [caption band] gap [body] noteGap [note]
     // below: [body] gap [caption band] noteGap [note]
@@ -412,6 +769,9 @@ export function layoutResourceBlock(input) {
                 ...cell,
                 rect: createBoundingBox(cell.rect.x, cell.rect.y + bodyY, cell.rect.width, cell.rect.height),
                 lines: shiftLines(cell.lines, 0, bodyY),
+                ...(cell.image
+                    ? { image: { ...cell.image, rect: createBoundingBox(cell.image.rect.x, cell.image.rect.y + bodyY, cell.image.rect.width, cell.image.rect.height) } }
+                    : {}),
             })),
         };
     }
@@ -428,10 +788,13 @@ export function layoutResourceBlock(input) {
         : undefined;
     const noteY = (captionAbove ? bodyY + bodyHeight : bodyHeight + captionHeight) + noteGapPx;
     const noteLines = shiftLines(measuredNote, 0, noteY);
-    const totalHeight = bodyHeight + captionHeight + noteHeight;
+    // The marker takes the note's slot (a continuing slice has no note).
+    const continuesLines = shiftLines(measuredContinues, 0, noteY);
+    const totalHeight = bodyHeight + captionHeight + noteHeight + continuesHeight;
     const block = {
         resource,
         kind: resource.kind,
+        ...(slice ? { slice } : {}),
         number,
         captionPrefix,
         bodyRect,
@@ -453,7 +816,8 @@ export function layoutResourceBlock(input) {
         noteItalicFontString,
         noteBoldItalicFontString,
         noteColor: cs.note.color.hex,
+        continuesLines,
     };
-    return { block, totalHeight };
+    return tableRows ? { block, totalHeight, tableRows } : { block, totalHeight };
 }
 //# sourceMappingURL=resourceLayout.js.map