@cj-tech-master/excelts 9.1.0 → 9.2.0

package/dist/browser/modules/pdf/reader/table-extractor.js

@@ -0,0 +1,365 @@
+/**
+ * Table extraction from PDF pages using text fragment positioning.
+ *
+ * Detects tabular structures by analyzing the spatial layout of text fragments.
+ * Since PDF content streams typically render tables as positioned text (with or
+ * without drawn grid lines), this module uses a text-only heuristic:
+ *
+ * 1. Group fragments into lines by Y proximity
+ * 2. Detect column boundaries from consistent X-position clusters
+ * 3. Identify contiguous blocks of multi-column lines as tables
+ * 4. Map fragments to cells based on column/line membership
+ *
+ * @see content-interpreter.ts for TextFragment extraction
+ * @see text-reconstruction.ts for line grouping logic
+ */
+// =============================================================================
+// Constants
+// =============================================================================
+/**
+ * Minimum number of columns required to consider a block of lines as a table.
+ */
+const MIN_TABLE_COLUMNS = 2;
+/**
+ * Minimum number of consecutive multi-column lines to form a table.
+ */
+const MIN_TABLE_ROWS = 2;
+// =============================================================================
+// Public API
+// =============================================================================
+/**
+ * Extract tables from a page's text fragments.
+ *
+ * Uses text positioning heuristics to detect tabular structures without
+ * relying on drawn lines or grid paths.
+ *
+ * @param fragments - Text fragments from `extractTextFromPage`
+ * @param pageWidth - Page width in points
+ * @param pageHeight - Page height in points
+ * @returns Array of detected tables
+ */
+export function extractTables(fragments, pageWidth, pageHeight) {
+    if (fragments.length === 0) {
+        return [];
+    }
+    // Filter to horizontal text only (vertical CJK tables are not handled here)
+    const horizontal = fragments.filter(f => !f.isVertical && f.text.trim().length > 0);
+    if (horizontal.length < MIN_TABLE_COLUMNS * MIN_TABLE_ROWS) {
+        return [];
+    }
+    // Step 1: Group fragments into lines by Y proximity
+    const lines = groupFragmentsIntoLines(horizontal);
+    if (lines.length < MIN_TABLE_ROWS) {
+        return [];
+    }
+    // Step 2: Detect column boundaries across lines
+    const columns = detectColumnBoundaries(lines, pageWidth);
+    if (columns.length < MIN_TABLE_COLUMNS) {
+        return [];
+    }
+    // Step 3: Identify contiguous runs of lines that form tables
+    const tableRanges = findTableRanges(lines, columns);
+    // Step 4: Build table structures
+    const tables = [];
+    for (const range of tableRanges) {
+        const table = buildTable(lines, columns, range.start, range.end, pageHeight);
+        if (table) {
+            tables.push(table);
+        }
+    }
+    return tables;
+}
+// =============================================================================
+// Step 1: Group Fragments into Lines
+// =============================================================================
+/**
+ * Group text fragments into horizontal lines based on Y proximity.
+ * Returns lines sorted top-to-bottom (descending Y in PDF coordinates).
+ */
+function groupFragmentsIntoLines(fragments) {
+    // Sort fragments top-to-bottom, then left-to-right
+    const sorted = [...fragments].sort((a, b) => {
+        const dy = b.y - a.y;
+        if (Math.abs(dy) > 1) {
+            return dy;
+        }
+        return a.x - b.x;
+    });
+    const lines = [];
+    let currentFragments = [sorted[0]];
+    let currentY = sorted[0].y;
+    for (let i = 1; i < sorted.length; i++) {
+        const f = sorted[i];
+        const avgFontSize = (currentFragments[0].fontSize + f.fontSize) / 2;
+        const threshold = Math.max(avgFontSize * 0.4, 2);
+        if (Math.abs(f.y - currentY) <= threshold) {
+            currentFragments.push(f);
+        }
+        else {
+            // Finalize previous line
+            currentFragments.sort((a, b) => a.x - b.x);
+            lines.push({
+                y: currentY,
+                fragments: currentFragments,
+                fontSize: currentFragments[0].fontSize
+            });
+            currentFragments = [f];
+            currentY = f.y;
+        }
+    }
+    // Finalize last line
+    if (currentFragments.length > 0) {
+        currentFragments.sort((a, b) => a.x - b.x);
+        lines.push({
+            y: currentY,
+            fragments: currentFragments,
+            fontSize: currentFragments[0].fontSize
+        });
+    }
+    return lines;
+}
+// =============================================================================
+// Step 2: Detect Column Boundaries
+// =============================================================================
+/**
+ * Detect column boundaries by analyzing fragment positions across lines.
+ *
+ * Algorithm:
+ * 1. For each line, compute gaps between consecutive fragments
+ * 2. Find vertical divider positions that consistently fall in gaps across lines
+ * 3. When gaps don't perfectly align (e.g. right-aligned numbers), use
+ *    fragment start positions to infer column boundaries
+ *
+ * This approach handles mixed alignment (left-aligned text headers with
+ * right-aligned numeric data) by looking at both gaps and start positions.
+ */
+function detectColumnBoundaries(lines, _pageWidth) {
+    // Strategy: for each pair of lines, find the set of divider positions
+    // that would produce the same column count. Then pick the most common
+    // column count and find divider positions that work best.
+    // Step A: Determine the most common fragment count per line
+    const fragCounts = lines.map(l => l.fragments.length);
+    const countFreq = new Map();
+    for (const c of fragCounts) {
+        if (c >= MIN_TABLE_COLUMNS) {
+            countFreq.set(c, (countFreq.get(c) ?? 0) + 1);
+        }
+    }
+    if (countFreq.size === 0) {
+        return [];
+    }
+    // Find the most common fragment count (the "expected" number of columns)
+    let bestCount = 0;
+    let bestFreq = 0;
+    for (const [count, freq] of countFreq) {
+        if (freq > bestFreq || (freq === bestFreq && count > bestCount)) {
+            bestCount = count;
+            bestFreq = freq;
+        }
+    }
+    if (bestCount < MIN_TABLE_COLUMNS || bestFreq < MIN_TABLE_ROWS) {
+        return [];
+    }
+    // Step B: From lines with the expected fragment count, extract divider positions.
+    // For each such line, dividers are placed between consecutive fragments.
+    // Divider position = midpoint between fragment[i].rightEdge and fragment[i+1].x
+    // (or just the gap midpoint if there's a real gap; if they overlap, use the start
+    // of the next fragment).
+    const linesWithExpectedCount = lines.filter(l => l.fragments.length === bestCount);
+    // Collect divider positions for each gap index (0..bestCount-2)
+    // For each gap between column i and column i+1, we need a divider that:
+    // - Is to the right of all fragment[i] right-edges (across all lines)
+    // - Is to the left of all fragment[i+1] left-edges (across all lines)
+    // We compute the max right-edge of fragment[i] and min left-edge of fragment[i+1]
+    // across all matching lines, then place the divider at the midpoint.
+    const maxRightByIndex = Array.from({ length: bestCount - 1 }, () => -Infinity);
+    const minLeftByIndex = Array.from({ length: bestCount - 1 }, () => Infinity);
+    for (const line of linesWithExpectedCount) {
+        const frags = line.fragments;
+        for (let i = 0; i + 1 < frags.length; i++) {
+            const rightEdge = frags[i].x + frags[i].width;
+            const nextStart = frags[i + 1].x;
+            maxRightByIndex[i] = Math.max(maxRightByIndex[i], rightEdge);
+            minLeftByIndex[i] = Math.min(minLeftByIndex[i], nextStart);
+        }
+    }
+    // Place each divider between the max right of column i and min left of column i+1
+    const medianDividers = [];
+    for (let i = 0; i < bestCount - 1; i++) {
+        const maxRight = maxRightByIndex[i];
+        const minLeft = minLeftByIndex[i];
+        if (minLeft > maxRight) {
+            // Clean gap — place divider at midpoint
+            medianDividers.push((maxRight + minLeft) / 2);
+        }
+        else {
+            // Overlap — place divider at the left-edge of the next column's fragment
+            // (this handles right-aligned numbers that extend into the next column's space)
+            medianDividers.push(minLeft);
+        }
+    }
+    if (medianDividers.length < 1) {
+        return [];
+    }
+    // Step C: Build column boundaries from dividers
+    let globalLeft = Infinity;
+    let globalRight = -Infinity;
+    for (const line of lines) {
+        for (const f of line.fragments) {
+            globalLeft = Math.min(globalLeft, f.x);
+            globalRight = Math.max(globalRight, f.x + f.width);
+        }
+    }
+    const columns = [];
+    let prevRight = globalLeft;
+    for (const divider of medianDividers) {
+        columns.push({ left: prevRight, right: divider });
+        prevRight = divider;
+    }
+    columns.push({ left: prevRight, right: globalRight });
+    return columns.length >= MIN_TABLE_COLUMNS ? columns : [];
+}
+// =============================================================================
+// Step 3: Find Contiguous Table Ranges
+// =============================================================================
+/**
+ * Identify contiguous runs of lines where most columns have content.
+ * Returns ranges of line indices that form table blocks.
+ */
+function findTableRanges(lines, columns) {
+    // For each line, count how many columns contain at least one fragment
+    const lineColumnCounts = [];
+    for (const line of lines) {
+        const occupiedColumns = new Set();
+        for (const f of line.fragments) {
+            const colIdx = findColumnIndex(f.x, columns);
+            if (colIdx >= 0) {
+                occupiedColumns.add(colIdx);
+            }
+        }
+        lineColumnCounts.push(occupiedColumns.size);
+    }
+    // A line is "tabular" if it has fragments in at least 2 columns
+    const ranges = [];
+    let rangeStart = -1;
+    for (let i = 0; i < lineColumnCounts.length; i++) {
+        const isTabular = lineColumnCounts[i] >= MIN_TABLE_COLUMNS;
+        if (isTabular && rangeStart === -1) {
+            rangeStart = i;
+        }
+        else if (!isTabular && rangeStart !== -1) {
+            if (i - rangeStart >= MIN_TABLE_ROWS) {
+                ranges.push({ start: rangeStart, end: i - 1 });
+            }
+            rangeStart = -1;
+        }
+    }
+    // Close any open range
+    if (rangeStart !== -1 && lines.length - rangeStart >= MIN_TABLE_ROWS) {
+        ranges.push({ start: rangeStart, end: lines.length - 1 });
+    }
+    return ranges;
+}
+/**
+ * Find which column a given X position belongs to.
+ * Returns -1 if the position doesn't fall within any column.
+ */
+function findColumnIndex(x, columns) {
+    for (let i = columns.length - 1; i >= 0; i--) {
+        if (x >= columns[i].left - 1) {
+            return i;
+        }
+    }
+    return -1;
+}
+// =============================================================================
+// Step 4: Build Table Structure
+// =============================================================================
+/**
+ * Build a PdfTable from a range of lines and column boundaries.
+ */
+function buildTable(lines, columns, startLine, endLine, _pageHeight) {
+    const rows = [];
+    for (let li = startLine; li <= endLine; li++) {
+        const line = lines[li];
+        const row = buildRow(line, columns, lines, li, startLine, endLine);
+        rows.push(row);
+    }
+    if (rows.length === 0) {
+        return null;
+    }
+    // Calculate table bounding box
+    const tableLines = lines.slice(startLine, endLine + 1);
+    const topY = tableLines[0].y;
+    const bottomY = tableLines[tableLines.length - 1].y;
+    const bottomFontSize = tableLines[tableLines.length - 1].fontSize;
+    const allX = [];
+    const allRightEdges = [];
+    for (const line of tableLines) {
+        for (const f of line.fragments) {
+            allX.push(f.x);
+            allRightEdges.push(f.x + f.width);
+        }
+    }
+    const tableX = allX.length > 0 ? Math.min(...allX) : 0;
+    const tableRight = allRightEdges.length > 0 ? Math.max(...allRightEdges) : 0;
+    const tableWidth = tableRight - tableX;
+    // Height: from top of first line to bottom of last line (including font height)
+    const tableHeight = topY - bottomY + bottomFontSize;
+    return {
+        rows,
+        x: tableX,
+        y: topY,
+        width: tableWidth,
+        height: tableHeight
+    };
+}
+/**
+ * Build a single table row by mapping fragments to columns.
+ */
+function buildRow(line, columns, _allLines, _lineIdx, _startLine, _endLine) {
+    // Group fragments by column
+    const columnFragments = new Map();
+    for (const f of line.fragments) {
+        const colIdx = findColumnIndex(f.x, columns);
+        if (colIdx >= 0) {
+            const existing = columnFragments.get(colIdx) ?? [];
+            existing.push(f);
+            columnFragments.set(colIdx, existing);
+        }
+    }
+    // Build cells for each column
+    const cells = [];
+    for (let colIdx = 0; colIdx < columns.length; colIdx++) {
+        const col = columns[colIdx];
+        const frags = columnFragments.get(colIdx);
+        if (frags && frags.length > 0) {
+            // Concatenate text from all fragments in this cell
+            const text = frags.map(f => f.text).join(" ");
+            const cellX = frags[0].x;
+            const cellY = line.y;
+            const lastFrag = frags[frags.length - 1];
+            const cellRight = lastFrag.x + lastFrag.width;
+            const cellWidth = cellRight - cellX;
+            const cellHeight = line.fontSize;
+            cells.push({
+                text: text.trim(),
+                x: cellX,
+                y: cellY,
+                width: cellWidth,
+                height: cellHeight
+            });
+        }
+        else {
+            // Empty cell
+            cells.push({
+                text: "",
+                x: col.left,
+                y: line.y,
+                width: col.right - col.left,
+                height: line.fontSize
+            });
+        }
+    }
+    return { cells };
+}

package/dist/browser/modules/pdf/render/layout-engine.d.ts

@@ -16,7 +16,7 @@
  * - Handle repeated header rows
  * - Skip hidden rows and columns
  */
-import type { PdfSheetData, ResolvedPdfOptions, LayoutPage } from "../types.js";
+import type { PdfSheetData, ResolvedPdfOptions, LayoutPage, LayoutCell, LayoutBorder } from "../types.js";
 import type { FontManager } from "../font/font-manager.js";
 /**
  * Compute the layout for a sheet across one or more PDF pages.
@@ -24,3 +24,23 @@ import type { FontManager } from "../font/font-manager.js";
  */
 export declare function layoutSheet(sheet: PdfSheetData, options: ResolvedPdfOptions, fontManager: FontManager): Promise<LayoutPage[]>;
 export declare function paginateRows(rowHeights: number[], availableHeight: number, repeatRowCount: number, rowBreaks: Set<number>): number[][];
+/**
+ * Border precedence weight.
+ *
+ * When two adjacent cells both declare a border on a shared edge the winning
+ * border is chosen by:  1. thicker wins,  2. solid beats dashed,
+ * 3. double beats single,  4. darker colour wins (tie-break).
+ *
+ * Returns a numeric score – higher score wins.
+ */
+export declare function borderPrecedence(b: LayoutBorder): number;
+/**
+ * Resolve shared borders between adjacent cells.
+ *
+ * For each shared edge, determine the winning border (by precedence), then:
+ * - The cell that "owns" the winning border keeps it in `borders` for drawing.
+ * - The losing cell has that border side set to `null` (it won't draw).
+ * - Both cells' `borderInsets` are updated to reflect the winning border's
+ *   half-width, so text padding accounts for the line that is actually there.
+ */
+export declare function resolveSharedBorders(cellGrid: Map<string, LayoutCell>, rowCount: number, colCount: number): void;

package/dist/browser/modules/pdf/render/layout-engine.js

@@ -18,7 +18,7 @@
  */
 import { PdfCellType } from "../types.js";
 import { resolvePdfFontName } from "../font/font-manager.js";
-import { extractFontProperties, excelFillToPdfColor, excelBordersToPdf, excelHAlignToPdf, excelVAlignToPdf } from "./style-converter.js";
+import { extractFontProperties, excelFillToPdfColor, excelBordersToPdf, excelHAlignToPdf, excelVAlignToPdf, borderStyleToLineWidth } from "./style-converter.js";
 import { wrapTextLines } from "./page-renderer.js";
 import { CELL_PADDING_H, CELL_PADDING_V, LINE_HEIGHT_FACTOR, INDENT_WIDTH, MAX_DIGIT_WIDTH_PX, EXCEL_COLUMN_PADDING_PX, PX_TO_PT } from "./constants.js";
 import { yieldToEventLoop } from "../../../utils/utils.base.js";
@@ -240,6 +240,9 @@ function buildPageLayout(ctx, rowPage, colGroup, currentPageCount, sheet, option
             cellGrid.set(`${ri}:${gci}`, layoutCell);
         }
     }
+    // Resolve shared borders: on each shared edge between adjacent cells, keep
+    // only the winning border for drawing but preserve insets for both cells.
+    resolveSharedBorders(cellGrid, rowPage.length, colGroup.length);
     // Compute text overflow widths for non-wrapped cells
     computeTextOverflows(cellGrid, rowPage, colGroup, visibleRows, visibleCols, groupColWidths, mergeMap, fontManager);
     return {
@@ -398,7 +401,16 @@ function computeRowHeights(sheet, scaleFactor, printRange, fontManager, options)
                     const fontSize = getCellFontSize(cell);
                     const wrapLineCount = countWrapLines(cell, fontSize, scaleFactor, sheet, fontManager, options);
                     const lineHeight = fontSize * LINE_HEIGHT_FACTOR;
-                    const neededHeight = fontSize + (wrapLineCount - 1) * lineHeight + CELL_PADDING_V * 2;
+                    // Account for border width: half of each border extends inward
+                    const borderTop = cell.style?.border?.top?.style
+                        ? borderStyleToLineWidth(cell.style.border.top.style) / 2
+                        : 0;
+                    const borderBottom = cell.style?.border?.bottom?.style
+                        ? borderStyleToLineWidth(cell.style.border.bottom.style) / 2
+                        : 0;
+                    const neededHeight = fontSize +
+                        (wrapLineCount - 1) * lineHeight +
+                        (CELL_PADDING_V + borderTop + borderBottom) * 2;
                     if (neededHeight > height) {
                         height = neededHeight;
                     }
@@ -443,7 +455,13 @@ function countWrapLines(cell, fontSize, scaleFactor, sheet, fontManager, options
     const colWidth = col?.width ?? DEFAULT_COLUMN_WIDTH;
     const scaledColPts = (colWidth * MAX_DIGIT_WIDTH_PX + EXCEL_COLUMN_PADDING_PX) * PX_TO_PT * scaleFactor;
     const indent = cell.style.alignment.indent ?? 0;
-    const padding = CELL_PADDING_H * 2 + indent * INDENT_WIDTH;
+    const borderLeft = cell.style?.border?.left?.style
+        ? borderStyleToLineWidth(cell.style.border.left.style) / 2
+        : 0;
+    const borderRight = cell.style?.border?.right?.style
+        ? borderStyleToLineWidth(cell.style.border.right.style) / 2
+        : 0;
+    const padding = CELL_PADDING_H + borderLeft + (CELL_PADDING_H + borderRight) + indent * INDENT_WIDTH;
     const effectiveWidth = Math.max(scaledColPts - padding, 1);
     const scaledFontSize = fontSize * scaleFactor;
     const fontProps = extractFontProperties(cell.style.font, options.defaultFontFamily, options.defaultFontSize);
@@ -637,6 +655,7 @@ function buildLayoutCell(cell, x, y, width, height, colSpan, rowSpan, options, f
     }
     // Rich text runs
     const richText = buildRichTextRuns(cell, options, fontManager, scaleFactor);
+    const borders = excelBordersToPdf(style.border);
     return {
         text,
         rect: { x, y, width, height },
@@ -651,7 +670,13 @@ function buildLayoutCell(cell, x, y, width, height, colSpan, rowSpan, options, f
         horizontalAlign: resolveHorizontalAlign(style.alignment, cell?.type, cell?.result),
         verticalAlign: excelVAlignToPdf(style.alignment),
         wrapText: style.alignment?.wrapText ?? false,
-        borders: excelBordersToPdf(style.border),
+        borders,
+        borderInsets: {
+            top: (borders.top?.width ?? 0) / 2,
+            right: (borders.right?.width ?? 0) / 2,
+            bottom: (borders.bottom?.width ?? 0) / 2,
+            left: (borders.left?.width ?? 0) / 2
+        },
         colSpan,
         rowSpan,
         hyperlink: cell?.hyperlink ?? null,
@@ -662,6 +687,84 @@ function buildLayoutCell(cell, x, y, width, height, colSpan, rowSpan, options, f
     };
 }
 // =============================================================================
+// Shared-Edge Border Resolution
+// =============================================================================
+/**
+ * Border precedence weight.
+ *
+ * When two adjacent cells both declare a border on a shared edge the winning
+ * border is chosen by:  1. thicker wins,  2. solid beats dashed,
+ * 3. double beats single,  4. darker colour wins (tie-break).
+ *
+ * Returns a numeric score – higher score wins.
+ */
+export function borderPrecedence(b) {
+    let score = b.width * 1000; // width dominates
+    if (b.dashPattern.length === 0) {
+        score += 100; // solid beats dashed
+    }
+    if (b.isDouble) {
+        score += 50; // double beats single
+    }
+    // Darker colour = lower sum of RGB → higher score
+    const brightness = b.color.r + b.color.g + b.color.b;
+    score += (3 - brightness) * 10; // max RGB sum = 3 → adds up to 30
+    return score;
+}
+/**
+ * Resolve shared borders between adjacent cells.
+ *
+ * For each shared edge, determine the winning border (by precedence), then:
+ * - The cell that "owns" the winning border keeps it in `borders` for drawing.
+ * - The losing cell has that border side set to `null` (it won't draw).
+ * - Both cells' `borderInsets` are updated to reflect the winning border's
+ *   half-width, so text padding accounts for the line that is actually there.
+ */
+export function resolveSharedBorders(cellGrid, rowCount, colCount) {
+    for (let ri = 0; ri < rowCount; ri++) {
+        for (let gci = 0; gci < colCount; gci++) {
+            const cell = cellGrid.get(`${ri}:${gci}`);
+            if (!cell) {
+                continue;
+            }
+            // Horizontal shared edge: this cell's right border vs right neighbour's left
+            if (cell.borders.right) {
+                const rightNeighbor = cellGrid.get(`${ri}:${gci + 1}`);
+                if (rightNeighbor?.borders.left) {
+                    const myScore = borderPrecedence(cell.borders.right);
+                    const theirScore = borderPrecedence(rightNeighbor.borders.left);
+                    if (theirScore > myScore) {
+                        // Neighbour wins — this cell stops drawing, but its inset = winner's half-width
+                        cell.borderInsets.right = rightNeighbor.borders.left.width / 2;
+                        cell.borders.right = null;
+                    }
+                    else {
+                        // This cell wins (or tie) — neighbour stops drawing
+                        rightNeighbor.borderInsets.left = cell.borders.right.width / 2;
+                        rightNeighbor.borders.left = null;
+                    }
+                }
+            }
+            // Vertical shared edge: this cell's bottom border vs below neighbour's top
+            if (cell.borders.bottom) {
+                const belowNeighbor = cellGrid.get(`${ri + 1}:${gci}`);
+                if (belowNeighbor?.borders.top) {
+                    const myScore = borderPrecedence(cell.borders.bottom);
+                    const theirScore = borderPrecedence(belowNeighbor.borders.top);
+                    if (theirScore > myScore) {
+                        cell.borderInsets.bottom = belowNeighbor.borders.top.width / 2;
+                        cell.borders.bottom = null;
+                    }
+                    else {
+                        belowNeighbor.borderInsets.top = cell.borders.bottom.width / 2;
+                        belowNeighbor.borders.top = null;
+                    }
+                }
+            }
+        }
+    }
+}
+// =============================================================================
 // Image Placement
 // =============================================================================
 /**
@@ -742,6 +845,7 @@ function propagateMergeBorders(layoutCell, mergeInfo, wsRowNumber, wsColNumber,
             const converted = excelBordersToPdf({ right: rightCellData.style.border.right });
             if (converted.right) {
                 layoutCell.borders.right = converted.right;
+                layoutCell.borderInsets.right = converted.right.width / 2;
             }
         }
     }
@@ -752,6 +856,7 @@ function propagateMergeBorders(layoutCell, mergeInfo, wsRowNumber, wsColNumber,
             const converted = excelBordersToPdf({ bottom: bottomCellData.style.border.bottom });
             if (converted.bottom) {
                 layoutCell.borders.bottom = converted.bottom;
+                layoutCell.borderInsets.bottom = converted.bottom.width / 2;
             }
         }
     }
@@ -781,7 +886,9 @@ function computeTextOverflows(cellGrid, rowPage, colGroup, visibleRows, visibleC
                 ? fontManager.getEmbeddedResourceName()
                 : fontManager.ensureFont(resolvePdfFontName(cell.fontFamily, cell.bold, cell.italic));
             const textWidth = fontManager.measureText(cell.text, resourceName, cell.fontSize);
-            const cellContentWidth = cell.rect.width - CELL_PADDING_H * 2;
+            const cellContentWidth = cell.rect.width -
+                (CELL_PADDING_H + cell.borderInsets.left) -
+                (CELL_PADDING_H + cell.borderInsets.right);
             if (textWidth <= cellContentWidth) {
                 continue;
             }

package/dist/browser/modules/pdf/render/page-renderer.d.ts

@@ -30,11 +30,11 @@ export declare function renderPage(page: LayoutPage, options: ResolvedPdfOptions
  * E.g. alpha=0.504 → "GS5040", alpha=0.506 → "GS5060"
  */
 export declare function alphaGsName(alpha: number): string;
-export declare function computeTextStartY(verticalAlign: "top" | "middle" | "bottom", rect: PdfRect, totalTextHeight: number, ascent: number, padV?: number): number;
+export declare function computeTextStartY(verticalAlign: "top" | "middle" | "bottom", rect: PdfRect, totalTextHeight: number, ascent: number, padVTop?: number, padVBottom?: number): number;
 export declare function computeTextX(align: "left" | "center" | "right", rect: {
     x: number;
     width: number;
-}, textWidth: number, indentPts?: number, padH?: number): number;
+}, textWidth: number, indentPts?: number, padHLeft?: number, padHRight?: number): number;
 /**
  * Wrap text into lines that fit within the given width.
  * Uses a greedy word-wrap algorithm.
@@ -61,10 +61,3 @@ export interface WatermarkRenderResult {
  * watermark sits behind everything (under-content).
  */
 export declare function renderWatermark(stream: PdfContentStream, page: LayoutPage, watermark: PdfWatermark, fontManager: FontManager): WatermarkRenderResult;
-/**
- * Parse image dimensions from raw JPEG or PNG data without a full decode.
- */
-export declare function parseImageDimensions(data: Uint8Array, format: "jpeg" | "png"): {
-    width: number;
-    height: number;
-};