dom-docx 0.1.0

package/dist/converter/table.js

@@ -0,0 +1,745 @@
+import { AlignmentType, BorderStyle, LineRuleType, Paragraph, ShadingType, Table, TableCell, TableRow, TextRun, WidthType, } from "docx";
+import { BODY_LINE_EXACT_TWIPS, HEADING_FONT_HALF_POINTS } from "./constants.js";
+import { cssToBlockTypography, inheritedFontFamily, isHiddenElement, mapTextAlign, pxToTwips, } from "./css.js";
+import { INLINE_STYLE_RESOLVER } from "./style-resolver.js";
+import { collectInlineRunsFromNodes } from "./inline.js";
+import { estimateTextWidthTwips, minContentWidthTwips, } from "./text-metrics.js";
+import { DEFAULT_VISITOR_CONTEXT } from "./types.js";
+// Runtime-only cycle with visitor.ts (function declarations hoist): cells reuse
+// the body list-numbering path for `<ul>`/`<ol>` children.
+import { processList } from "./visitor.js";
+/** Usable content width: 8.5" page − 2 × 1" margins = 6.5" → 9360 twips. */
+const CONTENT_WIDTH_TWIPS = 9360;
+// Chromium renders `border="1"` collapsed cell borders as a 1px #eee hairline;
+// 0.5pt strokes rasterize 2px wide in LibreOffice and double the border ink.
+const BORDER_COLOR = "eeeeee";
+const BORDER_SIZE = 2;
+function parseColspan(cell) {
+    return Math.max(1, parseInt(cell.attribs?.colspan ?? "1", 10) || 1);
+}
+function parseRowspan(cell) {
+    return Math.max(1, parseInt(cell.attribs?.rowspan ?? "1", 10) || 1);
+}
+/**
+ * Resolve each cell's grid column, skipping columns occupied by rowspanning
+ * cells from earlier rows (HTML grid placement).
+ */
+function placeCells(rows) {
+    const placedRows = [];
+    const carry = [];
+    let maxColumns = 1;
+    for (const row of rows) {
+        const occupied = new Set();
+        for (const c of carry) {
+            if (c.rowsLeft > 0)
+                for (let i = 0; i < c.span; i++)
+                    occupied.add(c.col + i);
+        }
+        const placed = [];
+        const newCarries = [];
+        let col = 0;
+        for (const cell of row) {
+            while (occupied.has(col))
+                col += 1;
+            placed.push({ cell, columnIndex: col });
+            if (cell.rowspan > 1) {
+                newCarries.push({ col, span: cell.colspan, rowsLeft: cell.rowspan - 1 });
+            }
+            col += cell.colspan;
+        }
+        maxColumns = Math.max(maxColumns, col, ...[...occupied].map((c) => c + 1));
+        placedRows.push(placed);
+        // Decrement only pre-existing spans — a span opened THIS row still covers
+        // all of its rowspan-1 following rows.
+        for (const c of carry)
+            c.rowsLeft -= 1;
+        carry.push(...newCarries);
+    }
+    return { placedRows, maxColumns };
+}
+function collectRowElements($, table) {
+    const trElements = [];
+    for (const child of $(table).children("thead, tbody, tfoot, tr").toArray()) {
+        if (child.name.toLowerCase() === "tr") {
+            trElements.push(child);
+        }
+        else {
+            trElements.push(...$(child).children("tr").toArray());
+        }
+    }
+    return trElements;
+}
+function parseRows($, trElements, table, styleResolver) {
+    return trElements
+        .filter((tr) => !isHiddenElement(tr, styleResolver))
+        .map((tr) => $(tr)
+        .children("td, th")
+        .toArray()
+        .filter((cell) => !isHiddenElement(cell, styleResolver))
+        .map((cell) => ({
+        element: cell,
+        row: tr,
+        table,
+        colspan: parseColspan(cell),
+        rowspan: parseRowspan(cell),
+    })));
+}
+/** Cell styles override row, row overrides inherited table styles (font, color, bg). */
+function resolveCellCss(cell, styleResolver) {
+    const tableCss = styleResolver.getCss(cell.table);
+    const rowCss = styleResolver.getCss(cell.row);
+    const cellCss = styleResolver.getCss(cell.element);
+    return {
+        ...rowCss,
+        ...cellCss,
+        color: cellCss.color ?? rowCss.color ?? tableCss.color,
+        fontSize: cellCss.fontSize ?? rowCss.fontSize ?? tableCss.fontSize,
+        fontWeight: cellCss.fontWeight ?? rowCss.fontWeight ?? tableCss.fontWeight,
+        fontStyle: cellCss.fontStyle ?? rowCss.fontStyle ?? tableCss.fontStyle,
+        textAlign: cellCss.textAlign ?? rowCss.textAlign ?? tableCss.textAlign,
+        // Table background shows through cells with no fill of their own.
+        backgroundColor: cellCss.backgroundColor ?? rowCss.backgroundColor ?? tableCss.backgroundColor,
+    };
+}
+function cellTypography(cell, styleResolver) {
+    const typography = cssToBlockTypography(resolveCellCss(cell, styleResolver));
+    if (!typography.font) {
+        // Walks cell → row → table → wrapper (CSS font-family inheritance).
+        const font = inheritedFontFamily(cell.element, styleResolver);
+        if (font)
+            typography.font = font;
+    }
+    if (cell.element.name.toLowerCase() === "th") {
+        typography.bold = true;
+    }
+    return typography;
+}
+function cellShading(cell, styleResolver) {
+    const { backgroundColor } = resolveCellCss(cell, styleResolver);
+    if (!backgroundColor)
+        return undefined;
+    return {
+        type: ShadingType.CLEAR,
+        fill: backgroundColor,
+        color: "auto",
+    };
+}
+function elementPlainText(element) {
+    const parts = [];
+    function walk(nodes) {
+        for (const node of nodes) {
+            if (node.type === "text")
+                parts.push(node.data ?? "");
+            else if (node.type === "tag")
+                walk(node.children ?? []);
+        }
+    }
+    walk(element.children ?? []);
+    return parts.join("").replace(/\s+/g, " ").trim();
+}
+function cellContentIsBold(cell, styleResolver) {
+    if (cell.element.name.toLowerCase() === "th")
+        return true;
+    const css = resolveCellCss(cell, styleResolver);
+    if (css.fontWeight === "bold" || Number(css.fontWeight) >= 600)
+        return true;
+    return Boolean(cell.element.children?.some((node) => node.type === "tag" && node.name.toLowerCase() === "strong"));
+}
+function cellTextMeasureOptions(cell, styleResolver) {
+    const css = resolveCellCss(cell, styleResolver);
+    const bold = cellContentIsBold(cell, styleResolver) ||
+        css.fontWeight === "bold" ||
+        Number(css.fontWeight) >= 600;
+    return {
+        bold,
+        fontSizeHalfPoints: css.fontSize,
+    };
+}
+/** Minimal width for layout-only columns (Word/LibreOffice reject true zero-width grid cols). */
+const LAYOUT_GUTTER_TWIPS = pxToTwips(2);
+function estimateCellTextWidthTwips(cell, styleResolver) {
+    const text = elementPlainText(cell.element);
+    return Math.max(minContentWidthTwips(), estimateTextWidthTwips(text, cellTextMeasureOptions(cell, styleResolver)));
+}
+function estimateCellContentWidthTwips(cell, styleResolver, cellPadding) {
+    const padX = cellPadding ? cellPadding * 2 : pxToTwips(16);
+    return padX + estimateCellTextWidthTwips(cell, styleResolver);
+}
+/**
+ * Empty cells used only for table-layout alignment (vote gutters, rank columns,
+ * indent spacers). Collapse unless the author declared a width via CSS or attrs.
+ */
+function isDecorativeSpacerCell(cell) {
+    if (elementPlainText(cell.element).length > 0)
+        return false;
+    return !cell.element.children?.some((node) => node.type === "tag" && node.name.toLowerCase() === "table");
+}
+function columnsWithContent(placedRows) {
+    let maxCol = 0;
+    for (const row of placedRows) {
+        for (const { cell, columnIndex } of row) {
+            maxCol = Math.max(maxCol, columnIndex + cell.colspan);
+        }
+    }
+    const has = Array.from({ length: maxCol }, () => false);
+    for (const row of placedRows) {
+        for (const { cell, columnIndex } of row) {
+            if (isDecorativeSpacerCell(cell))
+                continue;
+            for (let i = 0; i < cell.colspan; i++)
+                has[columnIndex + i] = true;
+        }
+    }
+    return has;
+}
+/** Explicit `width` on a single-column cell (style px/% or legacy attr) → pinned column twips. */
+function explicitCellWidthTwips(cell, styleResolver, contentWidthTwips) {
+    if (cell.colspan !== 1)
+        return undefined;
+    const css = styleResolver.getCss(cell.element);
+    if (css.widthTwips !== undefined)
+        return css.widthTwips;
+    if (css.widthPercent !== undefined) {
+        return Math.round((css.widthPercent / 100) * contentWidthTwips);
+    }
+    const attr = cell.element.attribs?.width?.trim();
+    if (attr) {
+        const percent = attr.match(/^(\d+(?:\.\d+)?)%$/);
+        if (percent)
+            return Math.round((parseFloat(percent[1]) / 100) * contentWidthTwips);
+        const px = parseFloat(attr);
+        if (Number.isFinite(px))
+            return pxToTwips(px);
+    }
+    return undefined;
+}
+/**
+ * Pinned columns keep their explicit width; the rest share the remaining width
+ * by content weight. Falls back to pure content weighting when the pins leave
+ * no room for the unpinned columns.
+ */
+function distributeWithPinnedColumns(weights, pinned, total) {
+    const unpinnedIdx = pinned
+        .map((p, i) => (p === undefined ? i : -1))
+        .filter((i) => i >= 0);
+    if (unpinnedIdx.length === weights.length)
+        return distributeColumnWidths(weights, total);
+    if (unpinnedIdx.length === 0) {
+        return distributeColumnWidths(pinned.map((p) => p ?? 0), total);
+    }
+    const pinnedSum = pinned.reduce((acc, p) => acc + (p ?? 0), 0);
+    const free = total - pinnedSum;
+    if (free < unpinnedIdx.length * pxToTwips(32)) {
+        return distributeColumnWidths(weights, total);
+    }
+    const freeWidths = distributeColumnWidths(unpinnedIdx.map((i) => weights[i]), free);
+    const out = pinned.map((p) => p ?? 0);
+    unpinnedIdx.forEach((i, k) => {
+        out[i] = freeWidths[k];
+    });
+    return out;
+}
+/** Scale column weights to exactly `total` twips (table is width:100%). */
+function distributeColumnWidths(weights, total) {
+    if (weights.length === 0)
+        return [];
+    const sum = weights.reduce((acc, w) => acc + w, 0);
+    if (sum <= 0) {
+        const base = Math.floor(total / weights.length);
+        const equal = Array.from({ length: weights.length }, () => base);
+        for (let i = 0; i < total - base * weights.length; i++) {
+            equal[i] += 1;
+        }
+        return equal;
+    }
+    const scaled = weights.map((w) => (w / sum) * total);
+    const columnWidths = scaled.map((w) => Math.floor(w));
+    let remainder = total - columnWidths.reduce((acc, w) => acc + w, 0);
+    const fractional = scaled
+        .map((w, index) => ({ index, fraction: w - Math.floor(w) }))
+        .sort((a, b) => b.fraction - a.fraction);
+    for (let i = 0; remainder > 0; i++, remainder--) {
+        columnWidths[fractional[i % fractional.length].index] += 1;
+    }
+    return columnWidths;
+}
+/** Pass 1 — derive max grid columns and content-weighted column widths. */
+function analyzeGrid(rows, styleResolver, cellPadding, contentWidthTwips, declaredWidthTwips, fillParent = false) {
+    const { placedRows, maxColumns } = placeCells(rows);
+    const columnHasContent = columnsWithContent(placedRows);
+    const columnMinWidths = Array.from({ length: maxColumns }, (_, i) => columnHasContent[i] ? pxToTwips(32) : LAYOUT_GUTTER_TWIPS);
+    const pinnedWidths = Array.from({ length: maxColumns }, () => undefined);
+    for (const row of placedRows) {
+        for (const { cell, columnIndex } of row) {
+            const span = cell.colspan;
+            const explicit = explicitCellWidthTwips(cell, styleResolver, contentWidthTwips);
+            if (explicit !== undefined) {
+                pinnedWidths[columnIndex] = Math.max(pinnedWidths[columnIndex] ?? 0, explicit);
+            }
+            if (isDecorativeSpacerCell(cell))
+                continue;
+            const need = estimateCellContentWidthTwips(cell, styleResolver, cellPadding);
+            const currentSpanWidth = sumColumnWidths(columnMinWidths, columnIndex, span);
+            if (need > currentSpanWidth) {
+                const perCol = (need - currentSpanWidth) / span;
+                for (let i = 0; i < span; i++) {
+                    columnMinWidths[columnIndex + i] += perCol;
+                }
+            }
+        }
+    }
+    // HTML tables shrink-to-fit by default — only a declared width stretches
+    // them (agent HTML habitually writes width:100%; wild HTML often doesn't).
+    const naturalWidth = Math.round(columnMinWidths.reduce((sum, w, i) => sum + (pinnedWidths[i] ?? w), 0));
+    const totalWidth = Math.min(contentWidthTwips, declaredWidthTwips ?? (fillParent ? contentWidthTwips : naturalWidth));
+    const columnWidths = distributeWithPinnedColumns(columnMinWidths, pinnedWidths, totalWidth);
+    return { maxColumns, placedRows, columnWidths, totalWidth };
+}
+function sumColumnWidths(columnWidths, start, span) {
+    return columnWidths.slice(start, start + span).reduce((total, w) => total + w, 0);
+}
+function parseCellPadding(table) {
+    const cellpadding = table.attribs?.cellpadding;
+    if (!cellpadding)
+        return undefined;
+    const px = parseFloat(cellpadding);
+    return Number.isFinite(px) ? pxToTwips(px) : undefined;
+}
+/** Declared table width from CSS or the legacy `width` attribute. */
+function tableDeclaredWidth(table, styleResolver) {
+    const css = styleResolver.getCss(table);
+    if (css.widthPercent !== undefined)
+        return { percent: css.widthPercent };
+    if (css.widthTwips !== undefined)
+        return { twips: css.widthTwips };
+    const maxWidth = css.maxWidthTwips;
+    const attr = table.attribs?.width?.trim();
+    if (attr) {
+        const pct = attr.match(/^(\d+(?:\.\d+)?)%$/);
+        if (pct)
+            return { percent: parseFloat(pct[1]) };
+        const px = parseFloat(attr);
+        if (Number.isFinite(px))
+            return { twips: pxToTwips(px) };
+    }
+    // Email idiom: fluid width capped by max-width (`width:100%;max-width:600px`
+    // parses as percent above; bare max-width acts as the effective width).
+    if (maxWidth !== undefined)
+        return { twips: maxWidth };
+    return {};
+}
+/** Table positioning: `align` attribute or CSS auto margins. */
+function tableAlignment(table) {
+    const align = table.attribs?.align?.trim().toLowerCase();
+    if (align === "center")
+        return AlignmentType.CENTER;
+    if (align === "right")
+        return AlignmentType.RIGHT;
+    const style = table.attribs?.style ?? "";
+    const leftAuto = /margin-left\s*:\s*auto/i.test(style);
+    const rightAuto = /margin-right\s*:\s*auto/i.test(style);
+    const shorthandAuto = /margin\s*:\s*[^;]*\bauto\b/i.test(style);
+    if (shorthandAuto || (leftAuto && rightAuto))
+        return AlignmentType.CENTER;
+    if (leftAuto)
+        return AlignmentType.RIGHT;
+    return undefined;
+}
+/** `border` attribute ≥ 1 → Chromium paints every cell border (full grid). */
+function hasAttrGrid(table) {
+    const borderAttr = table.attribs?.border;
+    return borderAttr !== undefined && borderAttr !== "0";
+}
+/**
+ * HTML separate-borders model: without `border-collapse:collapse`, cells sit
+ * 2px apart (UA border-spacing) unless `cellspacing` says otherwise, and the
+ * page background shows through — visible as white lines across shaded rows.
+ * (Word's native w:tblCellSpacing is ignored by LibreOffice, so the gaps are
+ * emulated with white borders instead.)
+ */
+function separateBorderSpacingPx(table, styleResolver) {
+    if (styleResolver.getCss(table).borderCollapse === "collapse")
+        return 0;
+    // Layout tables (`border="0"`) have no visible cell grid in browsers even when
+    // cellspacing defaults to 2 — emulating gaps as white borders shows as gridlines
+    // on shaded backgrounds (HN, email templates).
+    if (table.attribs?.border === "0")
+        return 0;
+    const spacingAttr = table.attribs?.cellspacing;
+    if (spacingAttr !== undefined)
+        return parseFloat(spacingAttr) || 0;
+    return 2;
+}
+const NO_BORDER = { style: BorderStyle.NONE, size: 0, color: "auto" };
+/**
+ * Border plan: the `border` attr means a full hairline cell grid; CSS borders on
+ * the table element style only the OUTER frame (per-side width/color), never the
+ * inside gridlines.
+ */
+function tableBorderPlan(table, styleResolver) {
+    const css = styleResolver.getCss(table);
+    const gridColor = css.borderColor ?? css.border?.color ?? BORDER_COLOR;
+    if (hasAttrGrid(table)) {
+        const side = { style: BorderStyle.SINGLE, size: BORDER_SIZE, color: gridColor };
+        return {
+            grid: true,
+            gridColor,
+            borders: {
+                top: side,
+                bottom: side,
+                left: side,
+                right: side,
+                insideHorizontal: side,
+                insideVertical: side,
+            },
+        };
+    }
+    const toSide = (b) => b
+        ? {
+            style: BorderStyle.SINGLE,
+            size: Math.max(2, Math.round(b.widthPx * 6)),
+            color: b.color ?? css.borderColor ?? "000000",
+        }
+        : undefined;
+    const frame = {
+        top: toSide(css.borderTop ?? css.border),
+        right: toSide(css.borderRight ?? css.border),
+        bottom: toSide(css.borderBottom ?? css.border),
+        left: toSide(css.borderLeft ?? css.border),
+    };
+    const spacingPx = separateBorderSpacingPx(table, styleResolver);
+    const hasVisibleFrame = Boolean(frame.top || frame.right || frame.bottom || frame.left);
+    const gap = spacingPx > 0 && (hasAttrGrid(table) || hasVisibleFrame)
+        ? {
+            style: BorderStyle.SINGLE,
+            size: Math.max(2, Math.round(spacingPx * 6)),
+            color: "FFFFFF",
+        }
+        : NO_BORDER;
+    return {
+        grid: false,
+        gridColor,
+        borders: {
+            top: frame.top ?? gap,
+            right: frame.right ?? gap,
+            bottom: frame.bottom ?? gap,
+            left: frame.left ?? gap,
+            insideHorizontal: gap,
+            insideVertical: gap,
+        },
+    };
+}
+/** EXACT line twips for a font size (half-points): px × 1.4 line-height × 15. */
+function exactLineForFontSize(fontSizeHalfPoints) {
+    if (!fontSizeHalfPoints)
+        return BODY_LINE_EXACT_TWIPS;
+    return Math.round(fontSizeHalfPoints * 14);
+}
+/** EXACT line boxes clip inline images — image-bearing paragraphs need AUTO. */
+function nodesContainImage(nodes) {
+    for (const node of nodes) {
+        if (node.type !== "tag")
+            continue;
+        const el = node;
+        if (el.name.toLowerCase() === "img")
+            return true;
+        if (nodesContainImage(el.children ?? []))
+            return true;
+    }
+    return false;
+}
+function cellParagraph(cell, styleResolver, nodes) {
+    const css = resolveCellCss(cell, styleResolver);
+    const typography = cellTypography(cell, styleResolver);
+    const content = nodes ?? cell.element.children ?? [];
+    const children = content.length
+        ? collectInlineRunsFromNodes(content, typography, undefined, styleResolver)
+        : [new TextRun("")];
+    const hasImage = nodesContainImage(content);
+    return new Paragraph({
+        ...(css.textAlign ? { alignment: mapTextAlign(css.textAlign) } : {}),
+        spacing: hasImage
+            ? { before: 0, after: 0 }
+            : {
+                before: 0,
+                after: 0,
+                line: exactLineForFontSize(typography.fontSize),
+                lineRule: LineRuleType.EXACT,
+            },
+        children,
+    });
+}
+/**
+ * Block child of a cell (`<p>`, `<h1>`–`<h6>`) → its own paragraph with the
+ * block's typography, margins, and a line box sized to ITS font (a 28px heading
+ * squeezed into the body EXACT line overlaps the paragraph above).
+ */
+function cellBlockParagraph(cell, styleResolver, element) {
+    const cellCss = resolveCellCss(cell, styleResolver);
+    const blockCss = styleResolver.getCss(element);
+    const tag = element.name.toLowerCase();
+    const isHeading = /^h[1-6]$/.test(tag);
+    const fontSize = blockCss.fontSize ??
+        (isHeading ? HEADING_FONT_HALF_POINTS[tag] : undefined) ??
+        cellCss.fontSize;
+    const typography = {
+        ...cellTypography(cell, styleResolver),
+        ...cssToBlockTypography(blockCss),
+        ...(isHeading ? { bold: true } : {}),
+        fontSize,
+    };
+    const align = blockCss.textAlign ?? cellCss.textAlign;
+    const hasImage = nodesContainImage(element.children ?? []);
+    return new Paragraph({
+        ...(align ? { alignment: mapTextAlign(align) } : {}),
+        spacing: hasImage
+            ? { before: blockCss.marginTop ?? 0, after: blockCss.marginBottom ?? 0 }
+            : {
+                before: blockCss.marginTop ?? 0,
+                after: blockCss.marginBottom ?? 0,
+                line: exactLineForFontSize(fontSize),
+                lineRule: LineRuleType.EXACT,
+            },
+        children: collectInlineRunsFromNodes(element.children ?? [], typography, undefined, styleResolver),
+    });
+}
+const DEFAULT_BAR_HEIGHT_TWIPS = pxToTwips(12);
+/**
+ * Empty block with a background fill and an explicit height/width — a CSS "trend bar"
+ * (e.g. `<div style="background:#457b9d;height:14px;width:76%">`). These carry no text,
+ * so the inline-run path drops them; render as a shaded band instead.
+ */
+function colorBarCss(node, styleResolver) {
+    if (node.type !== "tag")
+        return null;
+    const element = node;
+    if (elementPlainText(element).length > 0)
+        return null;
+    if (element.children?.some((child) => child.type === "tag"))
+        return null;
+    const css = styleResolver.getCss(element);
+    if (!css.backgroundColor)
+        return null;
+    if (css.heightTwips === undefined &&
+        css.widthPercent === undefined &&
+        css.widthTwips === undefined) {
+        return null;
+    }
+    return css;
+}
+/**
+ * Shaded band sized like the source bar: EXACT line height from CSS `height`, and the
+ * paragraph's right indent trims the shading to `width` (percent of the cell's content
+ * width, capped by `max-width`). Same pattern as the SVG bar renderer — native
+ * paragraph shading, no nested layout tables.
+ */
+function barParagraph(css, contentWidthTwips) {
+    const height = css.heightTwips ?? DEFAULT_BAR_HEIGHT_TWIPS;
+    let barWidth = css.widthPercent !== undefined
+        ? Math.round((css.widthPercent / 100) * contentWidthTwips)
+        : (css.widthTwips ?? contentWidthTwips);
+    if (css.maxWidthTwips !== undefined)
+        barWidth = Math.min(barWidth, css.maxWidthTwips);
+    barWidth = Math.max(0, Math.min(barWidth, contentWidthTwips));
+    return new Paragraph({
+        shading: { type: ShadingType.CLEAR, fill: css.backgroundColor, color: "auto" },
+        indent: { right: contentWidthTwips - barWidth },
+        spacing: { before: 0, after: 0, line: height, lineRule: LineRuleType.EXACT },
+        children: [new TextRun("")],
+    });
+}
+function nodeHasInlineContent(node) {
+    if (node.type === "text")
+        return (node.data ?? "").trim().length > 0;
+    return node.type === "tag";
+}
+/** Cell content: inline runs, shaded bars, nested tables, and explicit `<p>` blocks. */
+function cellBlocks($, cell, columnIndex, columnWidths, styleResolver, cellPadding) {
+    const nodes = cell.element.children ?? [];
+    const hasBars = nodes.some((node) => colorBarCss(node, styleResolver) !== null);
+    const hasNestedTable = nodes.some((node) => node.type === "tag" && node.name.toLowerCase() === "table");
+    const hasBlockChildren = nodes.some((node) => node.type === "tag" && /^(?:p|h[1-6]|ul|ol)$/.test(node.name.toLowerCase()));
+    if (!hasBars && !hasNestedTable && !hasBlockChildren) {
+        return [cellParagraph(cell, styleResolver)];
+    }
+    const cellWidth = sumColumnWidths(columnWidths, columnIndex, cell.colspan);
+    const contentWidth = Math.max(0, cellWidth - (cellPadding ?? 0) * 2);
+    const blocks = [];
+    let pending = [];
+    const flushInline = () => {
+        if (pending.some(nodeHasInlineContent)) {
+            blocks.push(cellParagraph(cell, styleResolver, pending));
+        }
+        pending = [];
+    };
+    for (const node of nodes) {
+        if (node.type === "tag") {
+            const tag = node.name.toLowerCase();
+            if (tag === "table") {
+                flushInline();
+                blocks.push(convertTable($, node, styleResolver, contentWidth, true));
+                continue;
+            }
+            if (/^(?:p|h[1-6])$/.test(tag)) {
+                flushInline();
+                blocks.push(cellBlockParagraph(cell, styleResolver, node));
+                continue;
+            }
+            if (tag === "ul" || tag === "ol") {
+                flushInline();
+                blocks.push(...processList($, node, { ...DEFAULT_VISITOR_CONTEXT, styleResolver }));
+                continue;
+            }
+        }
+        const barCss = colorBarCss(node, styleResolver);
+        if (barCss) {
+            flushInline();
+            blocks.push(barParagraph(barCss, contentWidth));
+        }
+        else {
+            pending.push(node);
+        }
+    }
+    flushInline();
+    return blocks.length > 0 ? blocks : [cellParagraph(cell, styleResolver)];
+}
+/** Explicit style borders on the cell itself (e.g. `border-right:1px solid #e2e8f0`). */
+function cellStyleBorders(cell, styleResolver) {
+    // Computed styles report UA-default cell borders (`border="1"` tables) as
+    // concrete near-black values on EVERY cell — the table-level grid already
+    // paints those edges. Only honor borders the author declared on the cell.
+    if (styleResolver.source === "computed") {
+        const inline = cell.element.attribs?.style ?? "";
+        if (!/\bborder(?:-top|-right|-bottom|-left)?\s*:/i.test(inline))
+            return undefined;
+    }
+    const css = styleResolver.getCss(cell.element);
+    const toSide = (b) => b
+        ? {
+            style: BorderStyle.SINGLE,
+            size: Math.max(2, Math.round(b.widthPx * 6)),
+            color: b.color ?? css.borderColor ?? "000000",
+        }
+        : undefined;
+    const sides = {
+        top: toSide(css.borderTop ?? css.border),
+        right: toSide(css.borderRight ?? css.border),
+        bottom: toSide(css.borderBottom ?? css.border),
+        left: toSide(css.borderLeft ?? css.border),
+    };
+    const declared = Object.fromEntries(Object.entries(sides).filter(([, side]) => side !== undefined));
+    return Object.keys(declared).length > 0 ? declared : undefined;
+}
+function buildTableCell($, cell, columnIndex, columnWidths, styleResolver, cellPadding) {
+    const span = cell.colspan;
+    const borders = cellStyleBorders(cell, styleResolver);
+    return new TableCell({
+        columnSpan: span > 1 ? span : undefined,
+        rowSpan: cell.rowspan > 1 ? cell.rowspan : undefined,
+        width: {
+            size: sumColumnWidths(columnWidths, columnIndex, span),
+            type: WidthType.DXA,
+        },
+        margins: cellPadding
+            ? { top: cellPadding, bottom: cellPadding, left: cellPadding, right: cellPadding }
+            : undefined,
+        shading: cellShading(cell, styleResolver),
+        ...(borders ? { borders } : {}),
+        children: cellBlocks($, cell, columnIndex, columnWidths, styleResolver, cellPadding),
+    });
+}
+function buildPaddingCell(columnIndex, columnWidths, cellPadding, edges) {
+    // Browsers leave missing-cell regions as borderless "holes" while still
+    // painting the table's outer frame. Suppress the grid inside the hole and
+    // keep only the frame edges this cell sits on.
+    const none = { style: BorderStyle.NONE, size: 0, color: "auto" };
+    const frame = { style: BorderStyle.SINGLE, size: BORDER_SIZE, color: edges.gridColor };
+    return new TableCell({
+        width: { size: columnWidths[columnIndex], type: WidthType.DXA },
+        margins: cellPadding
+            ? { top: cellPadding, bottom: cellPadding, left: cellPadding, right: cellPadding }
+            : undefined,
+        ...(edges.bordered
+            ? {
+                borders: {
+                    top: edges.isFirstRow ? frame : none,
+                    bottom: edges.isLastRow ? frame : none,
+                    left: none,
+                    right: edges.isLastColumn ? frame : none,
+                },
+            }
+            : {}),
+        children: [new Paragraph({ children: [new TextRun("")] })],
+    });
+}
+/** Pass 2 — emit docx rows aligned to the grid matrix with explicit spans and widths. */
+function buildTableRows($, analysis, styleResolver, cellPadding, bordered, gridColor) {
+    const { maxColumns, placedRows, columnWidths } = analysis;
+    // Columns covered by a rowspan from an earlier row: the docx library emits the
+    // vertical-merge continuation cells itself, so those columns must stay empty.
+    const occupied = placedRows.map(() => new Set());
+    placedRows.forEach((row, rowIndex) => {
+        for (const { cell, columnIndex } of row) {
+            const lastRow = Math.min(rowIndex + cell.rowspan, placedRows.length);
+            for (let r = rowIndex + 1; r < lastRow; r++) {
+                for (let i = 0; i < cell.colspan; i++)
+                    occupied[r].add(columnIndex + i);
+            }
+        }
+    });
+    return placedRows.map((row, rowIndex) => {
+        const byColumn = new Map(row.map((p) => [p.columnIndex, p.cell]));
+        const docxCells = [];
+        let columnIndex = 0;
+        while (columnIndex < maxColumns) {
+            const cell = byColumn.get(columnIndex);
+            if (cell) {
+                docxCells.push(buildTableCell($, cell, columnIndex, columnWidths, styleResolver, cellPadding));
+                columnIndex += cell.colspan;
+                continue;
+            }
+            if (occupied[rowIndex].has(columnIndex)) {
+                columnIndex += 1;
+                continue;
+            }
+            docxCells.push(buildPaddingCell(columnIndex, columnWidths, cellPadding, {
+                bordered,
+                gridColor,
+                isFirstRow: rowIndex === 0,
+                isLastRow: rowIndex === placedRows.length - 1,
+                isLastColumn: columnIndex === maxColumns - 1,
+            }));
+            columnIndex += 1;
+        }
+        return new TableRow({ children: docxCells });
+    });
+}
+export function convertTable($, table, styleResolver = INLINE_STYLE_RESOLVER, contentWidthTwips = CONTENT_WIDTH_TWIPS, fillParent = false) {
+    const trElements = collectRowElements($, table);
+    const parsedRows = parseRows($, trElements, table, styleResolver);
+    const cellPadding = parseCellPadding(table);
+    const declared = tableDeclaredWidth(table, styleResolver);
+    const declaredTwips = declared.percent !== undefined
+        ? Math.round((declared.percent / 100) * contentWidthTwips)
+        : declared.twips;
+    const analysis = analyzeGrid(parsedRows, styleResolver, cellPadding, contentWidthTwips, declaredTwips, fillParent);
+    const plan = tableBorderPlan(table, styleResolver);
+    const alignment = tableAlignment(table);
+    return new Table({
+        width: declared.percent !== undefined
+            ? { size: declared.percent, type: WidthType.PERCENTAGE }
+            : { size: analysis.totalWidth, type: WidthType.DXA },
+        // Positioning only matters when the table is narrower than its container.
+        ...(alignment && analysis.totalWidth < contentWidthTwips ? { alignment } : {}),
+        columnWidths: analysis.columnWidths,
+        layout: "fixed",
+        // `borders: undefined` means docx-library defaults (a black grid) — always
+        // pass an explicit plan (grid, frame-only, or all-NONE).
+        borders: plan.borders,
+        rows: buildTableRows($, analysis, styleResolver, cellPadding, plan.grid, plan.gridColor),
+    });
+}
+export function convertTableBlock($, table, styleResolver = INLINE_STYLE_RESOLVER) {
+    return convertTable($, table, styleResolver);
+}
+//# sourceMappingURL=table.js.map