@cj-tech-master/excelts 9.1.0 → 9.2.0

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

@@ -17,10 +17,18 @@ exports.computeTextStartY = computeTextStartY;
 exports.computeTextX = computeTextX;
 exports.wrapTextLines = wrapTextLines;
 exports.renderWatermark = renderWatermark;
-exports.parseImageDimensions = parseImageDimensions;
 const pdf_stream_1 = require("../core/pdf-stream");
 const font_manager_1 = require("../font/font-manager");
 const constants_1 = require("./constants");
+const image_utils_1 = require("../builder/image-utils");
+function computeCellPadding(cell, scaleFactor = 1) {
+    return {
+        left: (constants_1.CELL_PADDING_H + cell.borderInsets.left) * scaleFactor,
+        right: (constants_1.CELL_PADDING_H + cell.borderInsets.right) * scaleFactor,
+        top: (constants_1.CELL_PADDING_V + cell.borderInsets.top) * scaleFactor,
+        bottom: (constants_1.CELL_PADDING_V + cell.borderInsets.bottom) * scaleFactor
+    };
+}
 /**
  * Render a single page to a PDF content stream.
  */
@@ -196,10 +204,9 @@ function drawCellText(stream, cell, fontManager, alphaValues, scaleFactor = 1) {
     if (!text && !cell.richText) {
         return;
     }
-    const padH = constants_1.CELL_PADDING_H * scaleFactor;
-    const padV = constants_1.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;
     }
@@ -257,7 +264,7 @@ function drawCellText(stream, cell, fontManager, alphaValues, scaleFactor = 1) {
     const lineHeight = fontSize * constants_1.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);
@@ -265,7 +272,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) {
@@ -276,7 +283,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();
 }
 // =============================================================================
@@ -285,8 +292,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 = constants_1.CELL_PADDING_H * scaleFactor;
-    const padV = constants_1.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) {
@@ -303,7 +309,7 @@ function drawRichText(stream, cell, fontManager, indentPts, scaleFactor = 1) {
         : fontManager.ensureFont((0, font_manager_1.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;
         }
@@ -322,7 +328,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;
@@ -360,7 +366,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);
@@ -403,8 +409,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];
@@ -441,8 +447,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 = constants_1.CELL_PADDING_H * scaleFactor;
-    const padV = constants_1.CELL_PADDING_V * scaleFactor;
+    const pad = computeCellPadding(cell, scaleFactor);
     const isEmbedded = fontManager.hasEmbeddedFont();
     const resourceName = isEmbedded
         ? fontManager.getEmbeddedResourceName()
@@ -454,8 +459,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) {
@@ -503,11 +508,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
@@ -515,7 +520,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)
@@ -524,11 +529,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];
@@ -539,16 +544,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);
@@ -557,7 +562,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
@@ -566,11 +571,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];
@@ -581,16 +586,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);
@@ -601,8 +606,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 = constants_1.CELL_PADDING_H;
-    const padV = constants_1.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) {
@@ -622,10 +627,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)
@@ -638,10 +643,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)
@@ -678,8 +683,7 @@ function emitText(stream, fontManager, text, resourceName) {
  */
 function drawVerticalStackedText(stream, cell, fontManager, _indentPts, scaleFactor = 1) {
     const { rect, text, fontSize, horizontalAlign, verticalAlign } = cell;
-    const padH = constants_1.CELL_PADDING_H * scaleFactor;
-    const padV = constants_1.CELL_PADDING_V * scaleFactor;
+    const pad = computeCellPadding(cell, scaleFactor);
     const isEmbedded = fontManager.hasEmbeddedFont();
     const resourceName = isEmbedded
         ? fontManager.getEmbeddedResourceName()
@@ -696,11 +700,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++) {
@@ -713,14 +717,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);
@@ -747,60 +751,60 @@ function alphaGsName(alpha) {
 // =============================================================================
 // Text Layout Helpers
 // =============================================================================
-function computeTextStartY(verticalAlign, rect, totalTextHeight, ascent, padV = constants_1.CELL_PADDING_V) {
+function computeTextStartY(verticalAlign, rect, totalTextHeight, ascent, padVTop = constants_1.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;
 }
-function computeTextX(align, rect, textWidth, indentPts = 0, padH = constants_1.CELL_PADDING_H) {
+function computeTextX(align, rect, textWidth, indentPts = 0, padHLeft = constants_1.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);
         }
     }
@@ -810,7 +814,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);
         }
     }
@@ -1036,7 +1040,7 @@ function renderImageWatermark(stream, page, watermark) {
         imgHeight = watermark.height;
     }
     else {
-        const dims = parseImageDimensions(watermark.data, watermark.format);
+        const dims = (0, image_utils_1.parseImageDimensions)(watermark.data, watermark.format);
         const minDim = Math.min(page.width, page.height);
         const targetSize = minDim * scale;
         const maxDim = Math.max(dims.width, dims.height);
@@ -1079,52 +1083,6 @@ function renderImageWatermark(stream, page, watermark) {
 /**
  * Parse image dimensions from raw JPEG or PNG data without a full decode.
  */
-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/cjs/modules/pdf/render/pdf-exporter.js

@@ -18,7 +18,7 @@ const ttf_parser_1 = require("../font/ttf-parser");
 const encryption_1 = require("../core/encryption");
 const layout_engine_1 = require("./layout-engine");
 const page_renderer_1 = require("./page-renderer");
-const png_decoder_1 = require("./png-decoder");
+const image_utils_1 = require("../builder/image-utils");
 const errors_1 = require("../errors");
 const types_1 = require("../types");
 const style_converter_1 = require("./style-converter");
@@ -172,7 +172,7 @@ function renderSinglePage(page, fontManager, writer, fontObjectMap, totalPages,
             for (let imgIdx = 0; imgIdx < page.images.length; imgIdx++) {
                 const img = page.images[imgIdx];
                 const imgName = `Im${imgIdx + 1}`;
-                const imgObjNum = writeImageXObject(writer, img.data, img.format);
+                const imgObjNum = (0, image_utils_1.writeImageXObject)(writer, img.data, img.format);
                 imageXObjects.set(imgName, imgObjNum);
                 contentStream.drawImage(imgName, img.rect.x, img.rect.y, img.rect.width, img.rect.height);
             }
@@ -191,7 +191,7 @@ function renderSinglePage(page, fontManager, writer, fontObjectMap, totalPages,
             }
             // Register watermark image XObjects
             for (const wmImg of wmResult.imageXObjects) {
-                const imgObjNum = writeImageXObject(writer, wmImg.data, wmImg.format);
+                const imgObjNum = (0, image_utils_1.writeImageXObject)(writer, wmImg.data, wmImg.format);
                 imageXObjects.set(wmImg.name, imgObjNum);
             }
             // Write watermark content stream object
@@ -503,62 +503,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 = (0, page_renderer_1.parseImageDimensions)(data, "jpeg");
-    const dict = new pdf_object_1.PdfDict()
-        .set("Type", "/XObject")
-        .set("Subtype", "/Image")
-        .set("Width", (0, pdf_object_1.pdfNumber)(dims.width))
-        .set("Height", (0, pdf_object_1.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 = (0, png_decoder_1.decodePng)(data);
-    const objNum = writer.allocObject();
-    const dict = new pdf_object_1.PdfDict()
-        .set("Type", "/XObject")
-        .set("Subtype", "/Image")
-        .set("Width", (0, pdf_object_1.pdfNumber)(png.width))
-        .set("Height", (0, pdf_object_1.pdfNumber)(png.height))
-        .set("ColorSpace", "/DeviceRGB")
-        .set("BitsPerComponent", (0, pdf_object_1.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 pdf_object_1.PdfDict()
-            .set("Type", "/XObject")
-            .set("Subtype", "/Image")
-            .set("Width", (0, pdf_object_1.pdfNumber)(png.width))
-            .set("Height", (0, pdf_object_1.pdfNumber)(png.height))
-            .set("ColorSpace", "/DeviceGray")
-            .set("BitsPerComponent", "8");
-        writer.addStreamObject(smaskObjNum, smaskDict, png.alpha);
-        dict.set("SMask", (0, pdf_object_1.pdfRef)(smaskObjNum));
-    }
-    // RGB pixel data — compression handled by addStreamObject
-    writer.addStreamObject(objNum, dict, png.pixels);
-    return objNum;
-}

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

@@ -15,6 +15,7 @@ exports.excelColorToPdf = excelColorToPdf;
 exports.applyTint = applyTint;
 exports.extractFontProperties = extractFontProperties;
 exports.excelFillToPdfColor = excelFillToPdfColor;
+exports.borderStyleToLineWidth = borderStyleToLineWidth;
 exports.excelBordersToPdf = excelBordersToPdf;
 exports.excelHAlignToPdf = excelHAlignToPdf;
 exports.excelVAlignToPdf = excelVAlignToPdf;

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

@@ -237,7 +237,10 @@ class Readable extends event_emitter_1.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.
@@ -1743,7 +1746,10 @@ class Readable extends event_emitter_1.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;