@cj-tech-master/excelts 9.1.0 → 9.2.0

package/dist/browser/modules/pdf/render/page-renderer.js

@@ -12,6 +12,15 @@
 import { PdfContentStream } from "../core/pdf-stream.js";
 import { resolvePdfFontName } from "../font/font-manager.js";
 import { CELL_PADDING_H, CELL_PADDING_V, LINE_HEIGHT_FACTOR, INDENT_WIDTH } from "./constants.js";
+import { parseImageDimensions } from "../builder/image-utils.js";
+function computeCellPadding(cell, scaleFactor = 1) {
+    return {
+        left: (CELL_PADDING_H + cell.borderInsets.left) * scaleFactor,
+        right: (CELL_PADDING_H + cell.borderInsets.right) * scaleFactor,
+        top: (CELL_PADDING_V + cell.borderInsets.top) * scaleFactor,
+        bottom: (CELL_PADDING_V + cell.borderInsets.bottom) * scaleFactor
+    };
+}
 /**
  * Render a single page to a PDF content stream.
  */
@@ -187,10 +196,9 @@ function drawCellText(stream, cell, fontManager, alphaValues, scaleFactor = 1) {
     if (!text && !cell.richText) {
         return;
     }
-    const padH = CELL_PADDING_H * scaleFactor;
-    const padV = CELL_PADDING_V * scaleFactor;
-    const availWidth = rect.width - padH * 2;
-    const availHeight = rect.height - padV * 2;
+    const pad = computeCellPadding(cell, scaleFactor);
+    const availWidth = rect.width - pad.left - pad.right;
+    const availHeight = rect.height - pad.top - pad.bottom;
     if (availWidth <= 0 || availHeight <= 0) {
         return;
     }
@@ -248,7 +256,7 @@ function drawCellText(stream, cell, fontManager, alphaValues, scaleFactor = 1) {
     const lineHeight = fontSize * LINE_HEIGHT_FACTOR;
     const ascent = fontManager.getFontAscent(resourceName, fontSize);
     const totalTextHeight = lines.length * lineHeight;
-    const textStartY = computeTextStartY(verticalAlign, rect, totalTextHeight, ascent, padV);
+    const textStartY = computeTextStartY(verticalAlign, rect, totalTextHeight, ascent, pad.top, pad.bottom);
     stream.setFillColor(cell.textColor);
     stream.beginText();
     stream.setFont(resourceName, fontSize);
@@ -256,7 +264,7 @@ function drawCellText(stream, cell, fontManager, alphaValues, scaleFactor = 1) {
         const line = lines[i];
         const lineY = textStartY - i * lineHeight;
         const textWidth = measure(line);
-        const textX = computeTextX(horizontalAlign, rect, textWidth, indentPts, padH);
+        const textX = computeTextX(horizontalAlign, rect, textWidth, indentPts, pad.left, pad.right);
         stream.setTextMatrix(1, 0, 0, 1, textX, lineY);
         const hexEncoded = fontManager.encodeText(line, resourceName);
         if (hexEncoded) {
@@ -267,7 +275,7 @@ function drawCellText(stream, cell, fontManager, alphaValues, scaleFactor = 1) {
         }
     }
     stream.endText();
-    drawTextDecorations(stream, cell, lines, lineHeight, textStartY, measure, resourceName, fontManager, indentPts);
+    drawTextDecorations(stream, cell, lines, lineHeight, textStartY, measure, resourceName, fontManager, indentPts, pad);
     stream.restore();
 }
 // =============================================================================
@@ -276,8 +284,7 @@ function drawCellText(stream, cell, fontManager, alphaValues, scaleFactor = 1) {
 function drawRichText(stream, cell, fontManager, indentPts, scaleFactor = 1) {
     const { rect, horizontalAlign, verticalAlign, wrapText } = cell;
     const runs = cell.richText;
-    const padH = CELL_PADDING_H * scaleFactor;
-    const padV = CELL_PADDING_V * scaleFactor;
+    const pad = computeCellPadding(cell, scaleFactor);
     // Use the largest font size across all runs for line height calculation
     let maxFontSize = cell.fontSize;
     for (const run of runs) {
@@ -294,7 +301,7 @@ function drawRichText(stream, cell, fontManager, indentPts, scaleFactor = 1) {
         : fontManager.ensureFont(resolvePdfFontName(run.fontFamily, run.bold, run.italic));
     // --- Wrapping path ---
     if (wrapText) {
-        const availWidth = rect.width - padH * 2 - indentPts;
+        const availWidth = rect.width - pad.left - pad.right - indentPts;
         if (availWidth <= 0) {
             return;
         }
@@ -313,7 +320,7 @@ function drawRichText(stream, cell, fontManager, indentPts, scaleFactor = 1) {
         const primaryResourceName = runResource(runs[0]);
         const ascent = fontManager.getFontAscent(primaryResourceName, primaryFontSize);
         const totalTextHeight = lines.length * lineHeight;
-        const textStartY = computeTextStartY(verticalAlign, rect, totalTextHeight, ascent, padV);
+        const textStartY = computeTextStartY(verticalAlign, rect, totalTextHeight, ascent, pad.top, pad.bottom);
         let charPos = 0;
         for (let li = 0; li < lines.length; li++) {
             const lineY = textStartY - li * lineHeight;
@@ -351,7 +358,7 @@ function drawRichText(stream, cell, fontManager, indentPts, scaleFactor = 1) {
             for (const seg of segments) {
                 lineWidth += fontManager.measureText(seg.text, seg.resourceName, seg.run.fontSize);
             }
-            let textX = computeTextX(horizontalAlign, rect, lineWidth, indentPts, padH);
+            let textX = computeTextX(horizontalAlign, rect, lineWidth, indentPts, pad.left, pad.right);
             for (const seg of segments) {
                 const { run, text, resourceName } = seg;
                 const segWidth = fontManager.measureText(text, resourceName, run.fontSize);
@@ -394,8 +401,8 @@ function drawRichText(stream, cell, fontManager, indentPts, scaleFactor = 1) {
     }
     const primaryResourceName = runMetrics[0]?.resourceName ?? "F1";
     const ascent = fontManager.getFontAscent(primaryResourceName, primaryFontSize);
-    const textStartY = computeTextStartY(verticalAlign, rect, lineHeight, ascent, padV);
-    let textX = computeTextX(horizontalAlign, rect, totalWidth, indentPts, padH);
+    const textStartY = computeTextStartY(verticalAlign, rect, lineHeight, ascent, pad.top, pad.bottom);
+    let textX = computeTextX(horizontalAlign, rect, totalWidth, indentPts, pad.left, pad.right);
     for (let i = 0; i < runs.length; i++) {
         const run = runs[i];
         const { resourceName } = runMetrics[i];
@@ -432,8 +439,7 @@ function drawRichText(stream, cell, fontManager, indentPts, scaleFactor = 1) {
 function drawRotatedText(stream, cell, fontManager, indentPts, scaleFactor = 1) {
     const { rect, wrapText } = cell;
     let { fontSize } = cell;
-    const padH = CELL_PADDING_H * scaleFactor;
-    const padV = CELL_PADDING_V * scaleFactor;
+    const pad = computeCellPadding(cell, scaleFactor);
     const isEmbedded = fontManager.hasEmbeddedFont();
     const resourceName = isEmbedded
         ? fontManager.getEmbeddedResourceName()
@@ -445,8 +451,8 @@ function drawRotatedText(stream, cell, fontManager, indentPts, scaleFactor = 1)
     const sin = Math.sin(radians);
     const absSin = Math.abs(sin);
     const absCos = Math.abs(cos);
-    const maxWidth = rect.width - padH * 2;
-    const maxHeight = rect.height - padV * 2;
+    const maxWidth = rect.width - pad.left - pad.right;
+    const maxHeight = rect.height - pad.top - pad.bottom;
     // Available length along the text flow direction for wrapping
     let availTextLength;
     if (absSin > 0.01 && absCos > 0.01) {
@@ -494,11 +500,11 @@ function drawRotatedText(stream, cell, fontManager, indentPts, scaleFactor = 1)
     stream.setFillColor(cell.textColor);
     if (is90) {
         // Text reads bottom-to-top. Each line becomes a column drawn left-to-right.
-        drawRotated90(stream, cell, lines, fontManager, resourceName, fontSize, scaledLineHeight, ascent, padH, padV);
+        drawRotated90(stream, cell, lines, fontManager, resourceName, fontSize, scaledLineHeight, ascent, pad);
     }
     else if (isMinus90) {
         // Text reads top-to-bottom. Each line becomes a column drawn right-to-left.
-        drawRotatedMinus90(stream, cell, lines, fontManager, resourceName, fontSize, scaledLineHeight, ascent, padH, padV);
+        drawRotatedMinus90(stream, cell, lines, fontManager, resourceName, fontSize, scaledLineHeight, ascent, pad);
     }
     else {
         // General rotation — center multi-line text block in cell
@@ -506,7 +512,7 @@ function drawRotatedText(stream, cell, fontManager, indentPts, scaleFactor = 1)
     }
 }
 /** 90° CCW: text reads bottom-to-top, lines stack left-to-right. */
-function drawRotated90(stream, cell, lines, fontManager, resourceName, fontSize, lineHeight, ascent, padH, padV) {
+function drawRotated90(stream, cell, lines, fontManager, resourceName, fontSize, lineHeight, ascent, pad) {
     const { rect, horizontalAlign, verticalAlign } = cell;
     const totalColumnsWidth = lines.length * lineHeight;
     // horizontalAlign controls X placement of line columns (same visual axis)
@@ -515,11 +521,11 @@ function drawRotated90(stream, cell, lines, fontManager, resourceName, fontSize,
         startX = rect.x + rect.width / 2 - totalColumnsWidth / 2 + ascent;
     }
     else if (horizontalAlign === "right") {
-        startX = rect.x + rect.width - padH - totalColumnsWidth + ascent;
+        startX = rect.x + rect.width - pad.right - totalColumnsWidth + ascent;
     }
     else {
         // left (default)
-        startX = rect.x + padH + ascent;
+        startX = rect.x + pad.left + ascent;
     }
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
@@ -530,16 +536,16 @@ function drawRotated90(stream, cell, lines, fontManager, resourceName, fontSize,
         let ty;
         if (verticalAlign === "top") {
             // text at top → text end near top → ty starts at bottom so text reaches top
-            ty = rect.y + rect.height - padV - lineWidth;
+            ty = rect.y + rect.height - pad.top - lineWidth;
         }
         else if (verticalAlign === "middle") {
             ty = rect.y + (rect.height - lineWidth) / 2;
         }
         else {
             // bottom (default) → text at bottom → ty near bottom
-            ty = rect.y + padV;
+            ty = rect.y + pad.bottom;
         }
-        ty = Math.max(ty, rect.y + padV);
+        ty = Math.max(ty, rect.y + pad.bottom);
         stream.beginText();
         stream.setFont(resourceName, fontSize);
         stream.setTextMatrix(0, 1, -1, 0, colX, ty);
@@ -548,7 +554,7 @@ function drawRotated90(stream, cell, lines, fontManager, resourceName, fontSize,
     }
 }
 /** -90° (270° CW): text reads top-to-bottom, lines stack right-to-left. */
-function drawRotatedMinus90(stream, cell, lines, fontManager, resourceName, fontSize, lineHeight, ascent, padH, padV) {
+function drawRotatedMinus90(stream, cell, lines, fontManager, resourceName, fontSize, lineHeight, ascent, pad) {
     const { rect, horizontalAlign, verticalAlign } = cell;
     const totalColumnsWidth = lines.length * lineHeight;
     // horizontalAlign controls X placement: lines stack right-to-left
@@ -557,11 +563,11 @@ function drawRotatedMinus90(stream, cell, lines, fontManager, resourceName, font
         startX = rect.x + rect.width / 2 + totalColumnsWidth / 2 - lineHeight + ascent;
     }
     else if (horizontalAlign === "right") {
-        startX = rect.x + rect.width - padH - lineHeight + ascent;
+        startX = rect.x + rect.width - pad.right - lineHeight + ascent;
     }
     else {
         // left (default)
-        startX = rect.x + padH + totalColumnsWidth - lineHeight + ascent;
+        startX = rect.x + pad.left + totalColumnsWidth - lineHeight + ascent;
     }
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
@@ -572,16 +578,16 @@ function drawRotatedMinus90(stream, cell, lines, fontManager, resourceName, font
         let ty;
         if (verticalAlign === "top") {
             // text at top → ty near top (high PDF y)
-            ty = rect.y + rect.height - padV;
+            ty = rect.y + rect.height - pad.top;
         }
         else if (verticalAlign === "middle") {
             ty = rect.y + (rect.height + lineWidth) / 2;
         }
         else {
             // bottom (default) → text at bottom → ty so text ends at bottom
-            ty = rect.y + padV + lineWidth;
+            ty = rect.y + pad.bottom + lineWidth;
         }
-        ty = Math.min(ty, rect.y + rect.height - padV);
+        ty = Math.min(ty, rect.y + rect.height - pad.top);
         stream.beginText();
         stream.setFont(resourceName, fontSize);
         stream.setTextMatrix(0, -1, 1, 0, colX, ty);
@@ -592,8 +598,8 @@ function drawRotatedMinus90(stream, cell, lines, fontManager, resourceName, font
 /** General rotation — center a multi-line text block in the cell. */
 function drawRotatedGeneral(stream, cell, lines, fontManager, resourceName, fontSize, lineHeight, ascent, cos, sin, indentPts) {
     const { rect, horizontalAlign, verticalAlign } = cell;
-    const padH = CELL_PADDING_H;
-    const padV = CELL_PADDING_V;
+    // Use border-aware padding (no scaleFactor — font size is already scaled by caller)
+    const pad = computeCellPadding(cell);
     // Compute the rotated bounding box of the text block
     let maxLineWidth = 0;
     for (const line of lines) {
@@ -613,10 +619,10 @@ function drawRotatedGeneral(stream, cell, lines, fontManager, resourceName, font
     const indentOffset = horizontalAlign === "left" ? indentPts / 2 : horizontalAlign === "right" ? -indentPts / 2 : 0;
     let cy;
     if (verticalAlign === "top") {
-        cy = rect.y + rect.height - padV - rotatedHeight / 2;
+        cy = rect.y + rect.height - pad.top - rotatedHeight / 2;
     }
     else if (verticalAlign === "bottom") {
-        cy = rect.y + padV + rotatedHeight / 2;
+        cy = rect.y + pad.bottom + rotatedHeight / 2;
     }
     else {
         // middle (default)
@@ -629,10 +635,10 @@ function drawRotatedGeneral(stream, cell, lines, fontManager, resourceName, font
     const slantAtCy = slantShift * 2 * verticalRatio; // slantShift*2 = full slantOffset
     let cx;
     if (horizontalAlign === "right") {
-        cx = rect.x + rect.width - padH - rotatedWidth / 2 + indentOffset + slantAtCy;
+        cx = rect.x + rect.width - pad.right - rotatedWidth / 2 + indentOffset + slantAtCy;
     }
     else if (horizontalAlign === "left") {
-        cx = rect.x + padH + rotatedWidth / 2 + indentOffset + slantAtCy;
+        cx = rect.x + pad.left + rotatedWidth / 2 + indentOffset + slantAtCy;
     }
     else {
         // center (default for rotated)
@@ -669,8 +675,7 @@ function emitText(stream, fontManager, text, resourceName) {
  */
 function drawVerticalStackedText(stream, cell, fontManager, _indentPts, scaleFactor = 1) {
     const { rect, text, fontSize, horizontalAlign, verticalAlign } = cell;
-    const padH = CELL_PADDING_H * scaleFactor;
-    const padV = CELL_PADDING_V * scaleFactor;
+    const pad = computeCellPadding(cell, scaleFactor);
     const isEmbedded = fontManager.hasEmbeddedFont();
     const resourceName = isEmbedded
         ? fontManager.getEmbeddedResourceName()
@@ -687,11 +692,11 @@ function drawVerticalStackedText(stream, cell, fontManager, _indentPts, scaleFac
         startX = rect.x + rect.width / 2 - totalColumnsWidth / 2 + columnWidth / 2;
     }
     else if (horizontalAlign === "right") {
-        startX = rect.x + rect.width - padH - totalColumnsWidth + columnWidth / 2;
+        startX = rect.x + rect.width - pad.right - totalColumnsWidth + columnWidth / 2;
     }
     else {
         // left (default)
-        startX = rect.x + padH + columnWidth / 2;
+        startX = rect.x + pad.left + columnWidth / 2;
     }
     stream.setFillColor(cell.textColor);
     for (let colIdx = 0; colIdx < columns.length; colIdx++) {
@@ -704,14 +709,14 @@ function drawVerticalStackedText(stream, cell, fontManager, _indentPts, scaleFac
             currentY = rect.y + rect.height / 2 + totalTextHeight / 2 - ascent;
         }
         else if (verticalAlign === "bottom") {
-            currentY = rect.y + padV + totalTextHeight - ascent;
+            currentY = rect.y + pad.bottom + totalTextHeight - ascent;
         }
         else {
             // top (default)
-            currentY = rect.y + rect.height - padV - ascent;
+            currentY = rect.y + rect.height - pad.top - ascent;
         }
         for (const ch of colText) {
-            if (currentY < rect.y + padV) {
+            if (currentY < rect.y + pad.bottom) {
                 break;
             }
             const charWidth = fontManager.measureText(ch, resourceName, fontSize);
@@ -738,60 +743,60 @@ export function alphaGsName(alpha) {
 // =============================================================================
 // Text Layout Helpers
 // =============================================================================
-export function computeTextStartY(verticalAlign, rect, totalTextHeight, ascent, padV = CELL_PADDING_V) {
+export function computeTextStartY(verticalAlign, rect, totalTextHeight, ascent, padVTop = CELL_PADDING_V, padVBottom = padVTop) {
     let y;
     switch (verticalAlign) {
         case "top":
-            y = rect.y + rect.height - padV - ascent;
+            y = rect.y + rect.height - padVTop - ascent;
             break;
         case "middle":
             y = rect.y + rect.height / 2 + totalTextHeight / 2 - ascent;
             break;
         case "bottom":
         default:
-            y = rect.y + padV + (totalTextHeight - ascent);
+            y = rect.y + padVBottom + (totalTextHeight - ascent);
             break;
     }
     // Clamp: ensure text ascent doesn't exceed the cell top
-    const maxY = rect.y + rect.height - padV - ascent;
+    const maxY = rect.y + rect.height - padVTop - ascent;
     if (y > maxY) {
         y = maxY;
     }
     // Clamp: ensure text descent doesn't go below cell bottom
-    const minY = rect.y + padV;
+    const minY = rect.y + padVBottom;
     if (y < minY) {
         y = minY;
     }
     return y;
 }
-export function computeTextX(align, rect, textWidth, indentPts = 0, padH = CELL_PADDING_H) {
+export function computeTextX(align, rect, textWidth, indentPts = 0, padHLeft = CELL_PADDING_H, padHRight = padHLeft) {
     let x;
     switch (align) {
         case "center":
             x = rect.x + (rect.width - textWidth) / 2;
             break;
         case "right":
-            x = rect.x + rect.width - padH - textWidth;
+            x = rect.x + rect.width - padHRight - textWidth;
             break;
         default:
-            x = rect.x + padH + indentPts;
+            x = rect.x + padHLeft + indentPts;
             break;
     }
     // Clamp: don't start before cell left edge
-    const minX = rect.x + padH;
+    const minX = rect.x + padHLeft;
     if (x < minX) {
         x = minX;
     }
     return x;
 }
-function drawTextDecorations(stream, cell, lines, lineHeight, textStartY, measure, resourceName, fontManager, indentPts) {
+function drawTextDecorations(stream, cell, lines, lineHeight, textStartY, measure, resourceName, fontManager, indentPts, pad) {
     if (cell.strike) {
         const descent = fontManager.getFontDescent(resourceName, cell.fontSize);
         const strikeY = textStartY + descent + cell.fontSize * 0.3;
         for (let i = 0; i < lines.length; i++) {
             const lineY = strikeY - i * lineHeight;
             const lw = measure(lines[i]);
-            const startX = computeTextX(cell.horizontalAlign, cell.rect, lw, indentPts);
+            const startX = computeTextX(cell.horizontalAlign, cell.rect, lw, indentPts, pad?.left, pad?.right);
             stream.drawLine(startX, lineY, startX + lw, lineY, cell.textColor, 0.5);
         }
     }
@@ -801,7 +806,7 @@ function drawTextDecorations(stream, cell, lines, lineHeight, textStartY, measur
         for (let i = 0; i < lines.length; i++) {
             const lineY = textStartY - i * lineHeight + underlineOffset;
             const lw = measure(lines[i]);
-            const startX = computeTextX(cell.horizontalAlign, cell.rect, lw, indentPts);
+            const startX = computeTextX(cell.horizontalAlign, cell.rect, lw, indentPts, pad?.left, pad?.right);
             stream.drawLine(startX, lineY, startX + lw, lineY, cell.textColor, 0.5);
         }
     }
@@ -1070,52 +1075,6 @@ function renderImageWatermark(stream, page, watermark) {
 /**
  * Parse image dimensions from raw JPEG or PNG data without a full decode.
  */
-export function parseImageDimensions(data, format) {
-    if (format === "png") {
-        return parsePngDimensions(data);
-    }
-    return parseJpegDimensions(data);
-}
-/** Read width/height from a PNG IHDR chunk (bytes 16-23). */
-function parsePngDimensions(data) {
-    // PNG header: 8 byte signature, then IHDR chunk: 4 byte length, 4 byte type, 4 byte width, 4 byte height
-    if (data.length >= 24 &&
-        data[12] === 0x49 &&
-        data[13] === 0x48 &&
-        data[14] === 0x44 &&
-        data[15] === 0x52) {
-        const width = (data[16] << 24) | (data[17] << 16) | (data[18] << 8) | data[19];
-        const height = (data[20] << 24) | (data[21] << 16) | (data[22] << 8) | data[23];
-        return { width, height };
-    }
-    return { width: 1, height: 1 };
-}
-/** Read width/height from JPEG SOF marker. */
-function parseJpegDimensions(data) {
-    let offset = 2; // skip SOI marker
-    while (offset < data.length - 1) {
-        while (offset < data.length && data[offset] === 0xff && data[offset + 1] === 0xff) {
-            offset++;
-        }
-        if (offset >= data.length - 1 || data[offset] !== 0xff) {
-            break;
-        }
-        const marker = data[offset + 1];
-        const isSof = marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc;
-        if (isSof && offset + 8 < data.length) {
-            return {
-                width: (data[offset + 7] << 8) | data[offset + 8],
-                height: (data[offset + 5] << 8) | data[offset + 6]
-            };
-        }
-        if (offset + 3 >= data.length) {
-            break;
-        }
-        const segLen = (data[offset + 2] << 8) | data[offset + 3];
-        offset += 2 + segLen;
-    }
-    return { width: 1, height: 1 };
-}
 /**
  * Resolve the center position for a watermark on a given page.
  */

package/dist/browser/modules/pdf/render/pdf-exporter.js

@@ -14,8 +14,8 @@ import { FontManager, resolvePdfFontName } from "../font/font-manager.js";
 import { parseTtf } from "../font/ttf-parser.js";
 import { initEncryption } from "../core/encryption.js";
 import { layoutSheet } from "./layout-engine.js";
-import { renderPage, alphaGsName, renderWatermark, parseImageDimensions } from "./page-renderer.js";
-import { decodePng } from "./png-decoder.js";
+import { renderPage, alphaGsName, renderWatermark } from "./page-renderer.js";
+import { writeImageXObject } from "../builder/image-utils.js";
 import { PdfError, PdfRenderError } from "../errors.js";
 import { PageSizes } from "../types.js";
 import { argbToPdfColor } from "./style-converter.js";
@@ -500,62 +500,3 @@ function isWatermarkApplicable(watermark, page) {
     }
     return true;
 }
-// =============================================================================
-// Image XObject
-// =============================================================================
-/**
- * Write a JPEG or PNG image as a PDF XObject Image.
- */
-function writeImageXObject(writer, data, format) {
-    if (format === "png") {
-        return writePngImageXObject(writer, data);
-    }
-    return writeJpegImageXObject(writer, data);
-}
-/**
- * Write a JPEG image using DCTDecode (raw JPEG data embedded directly).
- */
-function writeJpegImageXObject(writer, data) {
-    const objNum = writer.allocObject();
-    const dims = parseImageDimensions(data, "jpeg");
-    const dict = new PdfDict()
-        .set("Type", "/XObject")
-        .set("Subtype", "/Image")
-        .set("Width", pdfNumber(dims.width))
-        .set("Height", pdfNumber(dims.height))
-        .set("ColorSpace", "/DeviceRGB")
-        .set("BitsPerComponent", "8")
-        .set("Filter", "/DCTDecode");
-    writer.addStreamObject(objNum, dict, data);
-    return objNum;
-}
-/**
- * Write a PNG image: decode to raw RGB, create SMask for alpha if needed.
- */
-function writePngImageXObject(writer, data) {
-    const png = decodePng(data);
-    const objNum = writer.allocObject();
-    const dict = new PdfDict()
-        .set("Type", "/XObject")
-        .set("Subtype", "/Image")
-        .set("Width", pdfNumber(png.width))
-        .set("Height", pdfNumber(png.height))
-        .set("ColorSpace", "/DeviceRGB")
-        .set("BitsPerComponent", pdfNumber(png.bitsPerComponent));
-    // If the image has an alpha channel, create a soft mask XObject
-    if (png.alpha) {
-        const smaskObjNum = writer.allocObject();
-        const smaskDict = new PdfDict()
-            .set("Type", "/XObject")
-            .set("Subtype", "/Image")
-            .set("Width", pdfNumber(png.width))
-            .set("Height", pdfNumber(png.height))
-            .set("ColorSpace", "/DeviceGray")
-            .set("BitsPerComponent", "8");
-        writer.addStreamObject(smaskObjNum, smaskDict, png.alpha);
-        dict.set("SMask", pdfRef(smaskObjNum));
-    }
-    // RGB pixel data — compression handled by addStreamObject
-    writer.addStreamObject(objNum, dict, png.pixels);
-    return objNum;
-}

package/dist/browser/modules/pdf/render/style-converter.d.ts

@@ -53,6 +53,10 @@ export declare function extractFontProperties(font: Partial<PdfFontStyle> | unde
  * Other patterns are approximated or ignored.
  */
 export declare function excelFillToPdfColor(fill: PdfFillData | undefined): PdfColor | null;
+/**
+ * Map border styles to PDF line widths.
+ */
+export declare function borderStyleToLineWidth(style: string): number;
 /**
  * Convert border data to PDF LayoutBorders.
  */

package/dist/browser/modules/pdf/render/style-converter.js

@@ -179,7 +179,7 @@ export function excelFillToPdfColor(fill) {
 /**
  * Map border styles to PDF line widths.
  */
-function borderStyleToLineWidth(style) {
+export function borderStyleToLineWidth(style) {
     switch (style) {
         case "thin":
             return 0.25;

package/dist/browser/modules/pdf/types.d.ts

@@ -655,8 +655,21 @@ export interface LayoutCell {
     verticalAlign: "top" | "middle" | "bottom";
     /** Whether text wrapping is enabled */
     wrapText: boolean;
-    /** Border definitions for this cell */
+    /** Border definitions for this cell (after shared-edge resolution: only edges this cell draws) */
     borders: LayoutBorders;
+    /**
+     * Effective border insets in points for text padding.
+     *
+     * On a shared edge the border line is drawn by only one of the two cells,
+     * but it still visually intrudes into both.  These values record the actual
+     * half-width intrusion on each side regardless of which cell draws the line.
+     */
+    borderInsets: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
     /** Number of columns this cell spans (for merged cells) */
     colSpan: number;
     /** Number of rows this cell spans (for merged cells) */

package/dist/browser/modules/stream/browser/readable.js

@@ -232,7 +232,10 @@ export class Readable extends EventEmitter {
             err.code = "ERR_INVALID_ARG_TYPE";
             throw err;
         }
-        const readable = new Readable({ ...options, objectMode: options?.objectMode ?? true });
+        const readable = new Readable({
+            ...options,
+            objectMode: options?.objectMode ?? true
+        });
         const iter = iterable;
         // Node.js treats strings as a single chunk, not as Iterable<char>.
         // Match that behavior by wrapping strings in an array.
@@ -1738,7 +1741,10 @@ export class Readable extends EventEmitter {
                 }
             }
             else {
-                for await (const item of _mapWithConcurrency(this, async (chunk) => ({ chunk, match: await fn(chunk, { signal: innerSignal }) }), concurrency, signal)) {
+                for await (const item of _mapWithConcurrency(this, async (chunk) => ({
+                    chunk,
+                    match: await fn(chunk, { signal: innerSignal })
+                }), concurrency, signal)) {
                     if (item.match) {
                         this.destroy();
                         return item.chunk;

package/dist/browser/utils/crypto.browser.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Cryptographic primitives — Browser version.
+ *
+ * Uses pure JavaScript for synchronous operations (SHA-256, MD5, AES-CBC, RC4)
+ * since Web Crypto API is async-only and cannot replace synchronous call sites.
+ *
+ * Uses Web Crypto API for:
+ * - `randomBytes` (crypto.getRandomValues — truly random)
+ * - `rsaVerify` / `rsaSign` (SubtleCrypto — hardware-accelerated)
+ *
+ * Exports the same API as `crypto.ts` (Node.js version).
+ */
+export declare function aesCbcEncrypt(plaintext: Uint8Array, key: Uint8Array, iv: Uint8Array): Uint8Array;
+export declare function aesCbcDecrypt(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array): Uint8Array;
+export declare function aesCbcDecryptRaw(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array): Uint8Array;
+export declare function aesCbcEncryptRaw(plaintext: Uint8Array, key: Uint8Array, iv: Uint8Array): Uint8Array;
+export declare function aesEcbEncrypt(block: Uint8Array, key: Uint8Array): Uint8Array;
+export declare function sha256(input: Uint8Array): Uint8Array;
+export declare function md5(input: Uint8Array): Uint8Array;
+/**
+ * RC4 stream cipher.
+ * @deprecated Only used for reading legacy encrypted PDFs.
+ */
+export declare function rc4(key: Uint8Array, data: Uint8Array): Uint8Array;
+/**
+ * Generate cryptographically secure random bytes.
+ * Uses crypto.getRandomValues (available in all modern browsers).
+ */
+export declare function randomBytes(length: number): Uint8Array;
+/**
+ * Compute a hash digest using Web Crypto API.
+ *
+ * NOTE: In the browser, this is async. The Node.js version is sync.
+ * For callers that need sync hashing, use `sha256()` or `md5()` directly.
+ *
+ * @param algorithm - Hash algorithm name (e.g., "SHA-256", "SHA-512", "SHA-1").
+ * @param data - Data to hash
+ * @returns The digest bytes
+ */
+export declare function hashAsync(algorithm: string, data: Uint8Array): Promise<Uint8Array>;
+/**
+ * Compute a hash digest synchronously (pure JS — SHA-256 and MD5 only).
+ *
+ * @param algorithm - "SHA-256" or "MD5" (case-insensitive, hyphens optional)
+ * @param data - Data to hash
+ * @returns The digest bytes
+ * @throws If algorithm is not SHA-256 or MD5
+ */
+export declare function hash(algorithm: string, data: Uint8Array): Uint8Array;
+/**
+ * Verify an RSA PKCS#1 v1.5 signature.
+ *
+ * @param publicKeyDer - DER-encoded SubjectPublicKeyInfo
+ * @param signature - The signature bytes
+ * @param data - The signed data (will be hashed with SHA-256)
+ */
+export declare function rsaVerify(publicKeyDer: Uint8Array, signature: Uint8Array, data: Uint8Array): Promise<boolean>;
+/**
+ * Create an RSA PKCS#1 v1.5 signature.
+ *
+ * @param privateKeyDer - DER-encoded PKCS#8 private key
+ * @param data - The data to sign (will be hashed with SHA-256)
+ */
+export declare function rsaSign(privateKeyDer: Uint8Array, data: Uint8Array): Promise<Uint8Array>;