@cj-tech-master/excelts 9.4.1 → 9.4.2

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

@@ -396,38 +396,49 @@ function computeRowHeights(sheet, scaleFactor, printRange, fontManager, options)
             height = row.height;
         }
         else if (row?.height) {
-            // Excel auto-calculated height — trust it as-is
-            height = row.height;
+            // Excel auto-calculated height — use it as a baseline, but ensure
+            // the row is tall enough for wrapped text.  The stored height may be
+            // stale when columns are narrower in the PDF layout or when the PDF
+            // uses different font metrics than the original Excel file.
+            height = Math.max(row.height, autoRowHeight(row, scaleFactor, sheet, fontManager, options));
         }
         else {
             // No height info: auto-size based on cell content
-            height = DEFAULT_ROW_HEIGHT;
-            if (row) {
-                for (const cell of row.cells.values()) {
-                    const fontSize = getCellFontSize(cell);
-                    const wrapLineCount = countWrapLines(cell, fontSize, scaleFactor, sheet, fontManager, options);
-                    const lineHeight = fontSize * constants_1.LINE_HEIGHT_FACTOR;
-                    // Account for border width: half of each border extends inward
-                    const borderTop = cell.style?.border?.top?.style
-                        ? (0, style_converter_1.borderStyleToLineWidth)(cell.style.border.top.style) / 2
-                        : 0;
-                    const borderBottom = cell.style?.border?.bottom?.style
-                        ? (0, style_converter_1.borderStyleToLineWidth)(cell.style.border.bottom.style) / 2
-                        : 0;
-                    const neededHeight = fontSize +
-                        (wrapLineCount - 1) * lineHeight +
-                        (constants_1.CELL_PADDING_V + borderTop + borderBottom) * 2;
-                    if (neededHeight > height) {
-                        height = neededHeight;
-                    }
-                }
-            }
+            height = autoRowHeight(row, scaleFactor, sheet, fontManager, options);
         }
         rowHeights.push(height * scaleFactor);
         visibleRows.push(r);
     }
     return { rowHeights, visibleRows };
 }
+/**
+ * Compute the minimum row height required to display wrapped cell content.
+ * Returns at least `DEFAULT_ROW_HEIGHT`.
+ */
+function autoRowHeight(row, scaleFactor, sheet, fontManager, options) {
+    let height = DEFAULT_ROW_HEIGHT;
+    if (row) {
+        for (const cell of row.cells.values()) {
+            const fontSize = getCellFontSize(cell);
+            const wrapLineCount = countWrapLines(cell, fontSize, scaleFactor, sheet, fontManager, options);
+            const lineHeight = fontSize * constants_1.LINE_HEIGHT_FACTOR;
+            // Account for border width: half of each border extends inward
+            const borderTop = cell.style?.border?.top?.style
+                ? (0, style_converter_1.borderStyleToLineWidth)(cell.style.border.top.style) / 2
+                : 0;
+            const borderBottom = cell.style?.border?.bottom?.style
+                ? (0, style_converter_1.borderStyleToLineWidth)(cell.style.border.bottom.style) / 2
+                : 0;
+            const neededHeight = fontSize +
+                (wrapLineCount - 1) * lineHeight +
+                (constants_1.CELL_PADDING_V + borderTop + borderBottom) * 2;
+            if (neededHeight > height) {
+                height = neededHeight;
+            }
+        }
+    }
+    return height;
+}
 /**
  * Get the largest font size for a cell, checking rich text runs.
  */
@@ -658,6 +669,8 @@ function buildLayoutCell(cell, x, y, width, height, colSpan, rowSpan, options, f
     else {
         const pdfFontName = (0, font_manager_1.resolvePdfFontName)(fontProps.fontFamily, fontProps.bold, fontProps.italic);
         fontManager.ensureFont(pdfFontName);
+        // Track non-WinAnsi code points for Type3 fallback font generation
+        fontManager.trackText(text);
     }
     // Rich text runs
     const richText = buildRichTextRuns(cell, options, fontManager, scaleFactor);

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

@@ -12,6 +12,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderPage = renderPage;
+exports.emitTextWithMatrix = emitTextWithMatrix;
 exports.alphaGsName = alphaGsName;
 exports.computeTextStartY = computeTextStartY;
 exports.computeTextX = computeTextX;
@@ -266,23 +267,14 @@ function drawCellText(stream, cell, fontManager, alphaValues, scaleFactor = 1) {
     const totalTextHeight = lines.length * lineHeight;
     const textStartY = computeTextStartY(verticalAlign, rect, totalTextHeight, ascent, pad.top, pad.bottom);
     stream.setFillColor(cell.textColor);
-    stream.beginText();
-    stream.setFont(resourceName, fontSize);
+    const useType3 = fontManager.hasType3Fonts() && !isEmbedded;
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         const lineY = textStartY - i * lineHeight;
         const textWidth = measure(line);
         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) {
-            stream.showTextHex(hexEncoded);
-        }
-        else {
-            stream.showText(line);
-        }
+        emitTextWithType3(stream, line, textX, lineY, resourceName, fontSize, fontManager, useType3);
     }
-    stream.endText();
     drawTextDecorations(stream, cell, lines, lineHeight, textStartY, measure, resourceName, fontManager, indentPts, pad);
     stream.restore();
 }
@@ -367,21 +359,11 @@ function drawRichText(stream, cell, fontManager, indentPts, scaleFactor = 1) {
                 lineWidth += fontManager.measureText(seg.text, seg.resourceName, seg.run.fontSize);
             }
             let textX = computeTextX(horizontalAlign, rect, lineWidth, indentPts, pad.left, pad.right);
+            const useType3 = fontManager.hasType3Fonts() && !isEmbedded;
             for (const seg of segments) {
                 const { run, text, resourceName } = seg;
-                const segWidth = fontManager.measureText(text, resourceName, run.fontSize);
                 stream.setFillColor(run.textColor);
-                stream.beginText();
-                stream.setFont(resourceName, run.fontSize);
-                stream.setTextMatrix(1, 0, 0, 1, textX, lineY);
-                const hex = fontManager.encodeText(text, resourceName);
-                if (hex) {
-                    stream.showTextHex(hex);
-                }
-                else {
-                    stream.showText(text);
-                }
-                stream.endText();
+                const segWidth = emitTextWithType3(stream, text, textX, lineY, resourceName, run.fontSize, fontManager, useType3);
                 if (run.strike) {
                     const descent = fontManager.getFontDescent(resourceName, run.fontSize);
                     const y = lineY + descent + run.fontSize * 0.3;
@@ -411,23 +393,13 @@ function drawRichText(stream, cell, fontManager, indentPts, scaleFactor = 1) {
     const ascent = fontManager.getFontAscent(primaryResourceName, primaryFontSize);
     const textStartY = computeTextStartY(verticalAlign, rect, lineHeight, ascent, pad.top, pad.bottom);
     let textX = computeTextX(horizontalAlign, rect, totalWidth, indentPts, pad.left, pad.right);
+    const useType3 = fontManager.hasType3Fonts() && !isEmbedded;
     for (let i = 0; i < runs.length; i++) {
         const run = runs[i];
         const { resourceName } = runMetrics[i];
         stream.setFillColor(run.textColor);
-        stream.beginText();
-        stream.setFont(resourceName, run.fontSize);
-        stream.setTextMatrix(1, 0, 0, 1, textX, textStartY);
-        const hexEncoded = fontManager.encodeText(run.text, resourceName);
-        if (hexEncoded) {
-            stream.showTextHex(hexEncoded);
-        }
-        else {
-            stream.showText(run.text);
-        }
-        stream.endText();
+        const runWidth = emitTextWithType3(stream, run.text, textX, textStartY, resourceName, run.fontSize, fontManager, useType3);
         // Draw per-run decorations (strikethrough, underline)
-        const runWidth = runMetrics[i].width;
         if (run.strike) {
             const descent = fontManager.getFontDescent(resourceName, run.fontSize);
             const y = textStartY + descent + run.fontSize * 0.3;
@@ -438,7 +410,7 @@ function drawRichText(stream, cell, fontManager, indentPts, scaleFactor = 1) {
             const y = textStartY + descent * 0.5;
             stream.drawLine(textX, y, textX + runWidth, y, run.textColor, 0.5);
         }
-        textX += runMetrics[i].width;
+        textX += runWidth;
     }
 }
 // =============================================================================
@@ -535,6 +507,7 @@ function drawRotated90(stream, cell, lines, fontManager, resourceName, fontSize,
         // left (default)
         startX = rect.x + pad.left + ascent;
     }
+    const useType3 = fontManager.hasType3Fonts() && !fontManager.hasEmbeddedFont();
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         const lineWidth = fontManager.measureText(line, resourceName, fontSize);
@@ -554,11 +527,7 @@ function drawRotated90(stream, cell, lines, fontManager, resourceName, fontSize,
             ty = rect.y + pad.bottom;
         }
         ty = Math.max(ty, rect.y + pad.bottom);
-        stream.beginText();
-        stream.setFont(resourceName, fontSize);
-        stream.setTextMatrix(0, 1, -1, 0, colX, ty);
-        emitText(stream, fontManager, line, resourceName);
-        stream.endText();
+        emitTextWithMatrix(stream, line, 0, 1, -1, 0, colX, ty, resourceName, fontSize, fontManager, useType3);
     }
 }
 /** -90° (270° CW): text reads top-to-bottom, lines stack right-to-left. */
@@ -577,6 +546,7 @@ function drawRotatedMinus90(stream, cell, lines, fontManager, resourceName, font
         // left (default)
         startX = rect.x + pad.left + totalColumnsWidth - lineHeight + ascent;
     }
+    const useType3 = fontManager.hasType3Fonts() && !fontManager.hasEmbeddedFont();
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         const lineWidth = fontManager.measureText(line, resourceName, fontSize);
@@ -596,11 +566,7 @@ function drawRotatedMinus90(stream, cell, lines, fontManager, resourceName, font
             ty = rect.y + pad.bottom + lineWidth;
         }
         ty = Math.min(ty, rect.y + rect.height - pad.top);
-        stream.beginText();
-        stream.setFont(resourceName, fontSize);
-        stream.setTextMatrix(0, -1, 1, 0, colX, ty);
-        emitText(stream, fontManager, line, resourceName);
-        stream.endText();
+        emitTextWithMatrix(stream, line, 0, -1, 1, 0, colX, ty, resourceName, fontSize, fontManager, useType3);
     }
 }
 /** General rotation — center a multi-line text block in the cell. */
@@ -652,6 +618,7 @@ function drawRotatedGeneral(stream, cell, lines, fontManager, resourceName, font
         // center (default for rotated)
         cx = rect.x + rect.width / 2 + indentOffset + slantAtCy;
     }
+    const useType3 = fontManager.hasType3Fonts() && !fontManager.hasEmbeddedFont();
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         const lineWidth = fontManager.measureText(line, resourceName, fontSize);
@@ -660,11 +627,7 @@ function drawRotatedGeneral(stream, cell, lines, fontManager, resourceName, font
         const offsetY = -ascent / 2 - lineOffset;
         const tx = cx + offsetX * cos - offsetY * sin;
         const ty = cy + offsetX * sin + offsetY * cos;
-        stream.beginText();
-        stream.setFont(resourceName, fontSize);
-        stream.setTextMatrix(cos, sin, -sin, cos, tx, ty);
-        emitText(stream, fontManager, line, resourceName);
-        stream.endText();
+        emitTextWithMatrix(stream, line, cos, sin, -sin, cos, tx, ty, resourceName, fontSize, fontManager, useType3);
     }
 }
 /** Emit a text string with hex encoding if available. */
@@ -677,6 +640,97 @@ function emitText(stream, fontManager, text, resourceName) {
         stream.showText(text);
     }
 }
+/**
+ * Render a text string with a custom text matrix, using Type3-aware splitting
+ * when needed.  For each sub-run the matrix origin is advanced along the
+ * text direction (cos, sin) by the rendered width.
+ *
+ * When `useType3` is false this collapses to a single BT/ET pair — identical
+ * to the old `emitText()` path but wrapped in begin/end for convenience.
+ */
+function emitTextWithMatrix(stream, text, a, b, c, d, tx, ty, type1ResourceName, fontSize, fontManager, useType3) {
+    if (!useType3) {
+        stream.beginText();
+        stream.setFont(type1ResourceName, fontSize);
+        stream.setTextMatrix(a, b, c, d, tx, ty);
+        emitText(stream, fontManager, text, type1ResourceName);
+        stream.endText();
+        return;
+    }
+    // Type3 path: split into runs and advance origin along text direction
+    const runs = splitTextRuns(text, fontManager);
+    let curTx = tx;
+    let curTy = ty;
+    for (const run of runs) {
+        stream.beginText();
+        if (run.type3) {
+            stream.setFont(run.type3.resourceName, fontSize);
+            stream.setTextMatrix(a, b, c, d, curTx, curTy);
+            stream.showTextHex(run.type3.hex);
+        }
+        else {
+            stream.setFont(type1ResourceName, fontSize);
+            stream.setTextMatrix(a, b, c, d, curTx, curTy);
+            emitText(stream, fontManager, run.text, type1ResourceName);
+        }
+        stream.endText();
+        const w = fontManager.measureText(run.text, run.type3?.resourceName ?? type1ResourceName, fontSize);
+        // Advance along the text direction (first column of the matrix)
+        curTx += a * w;
+        curTy += b * w;
+    }
+}
+/**
+ * Split a line of text into runs of consecutive WinAnsi and non-WinAnsi
+ * characters.  Each non-WinAnsi character becomes its own Type3 run (since
+ * different code points may map to different Type3 fonts).  Consecutive
+ * WinAnsi characters are merged into a single Type1 run.
+ */
+function splitTextRuns(text, fontManager) {
+    const runs = [];
+    let winAnsiBuffer = "";
+    const flushWinAnsi = () => {
+        if (winAnsiBuffer) {
+            runs.push({ text: winAnsiBuffer, type3: null });
+            winAnsiBuffer = "";
+        }
+    };
+    for (let i = 0; i < text.length; i++) {
+        const cp = text.codePointAt(i);
+        const ch = String.fromCodePoint(cp);
+        if (cp > 0xffff) {
+            i++; // skip low surrogate
+        }
+        if (fontManager.needsType3(cp)) {
+            flushWinAnsi();
+            const t3 = fontManager.resolveType3(cp);
+            if (t3) {
+                const hex = fontManager.encodeType3Char(cp);
+                runs.push({
+                    text: ch,
+                    type3: { resourceName: t3.resourceName, hex: hex ?? "<00>" }
+                });
+            }
+            else {
+                // Character tracked but Type3 not yet written — render as space
+                runs.push({ text: ch, type3: null });
+            }
+        }
+        else {
+            winAnsiBuffer += ch;
+        }
+    }
+    flushWinAnsi();
+    return runs;
+}
+/**
+ * Render a text string at (textX, textY) using Type3-aware splitting when needed.
+ * Returns the rendered width so the caller can advance textX.
+ */
+function emitTextWithType3(stream, text, textX, textY, type1ResourceName, fontSize, fontManager, useType3) {
+    emitTextWithMatrix(stream, text, 1, 0, 0, 1, textX, textY, type1ResourceName, fontSize, fontManager, useType3);
+    return fontManager.measureText(text, type1ResourceName, fontSize);
+}
 /**
  * Draw vertical stacked text (each character top-to-bottom).
  * Newlines (\n) start a new column to the right.
@@ -707,6 +761,7 @@ function drawVerticalStackedText(stream, cell, fontManager, _indentPts, scaleFac
         startX = rect.x + pad.left + columnWidth / 2;
     }
     stream.setFillColor(cell.textColor);
+    const useType3 = fontManager.hasType3Fonts() && !isEmbedded;
     for (let colIdx = 0; colIdx < columns.length; colIdx++) {
         const colText = columns[colIdx];
         const colX = startX + colIdx * columnWidth;
@@ -728,11 +783,7 @@ function drawVerticalStackedText(stream, cell, fontManager, _indentPts, scaleFac
                 break;
             }
             const charWidth = fontManager.measureText(ch, resourceName, fontSize);
-            stream.beginText();
-            stream.setFont(resourceName, fontSize);
-            stream.setTextMatrix(1, 0, 0, 1, colX - charWidth / 2, currentY);
-            emitText(stream, fontManager, ch, resourceName);
-            stream.endText();
+            emitTextWithMatrix(stream, ch, 1, 0, 0, 1, colX - charWidth / 2, currentY, resourceName, fontSize, fontManager, useType3);
             currentY -= charHeight;
         }
     }
@@ -873,17 +924,8 @@ function drawPageHeader(stream, page, options, fontManager) {
     const y = page.height - options.margins.top + 5;
     stream.save();
     stream.setFillColor({ r: 0.3, g: 0.3, b: 0.3 });
-    stream.beginText();
-    stream.setFont(resourceName, headerFontSize);
-    stream.setTextMatrix(1, 0, 0, 1, x, y);
-    const hex = fontManager.encodeText(headerText, resourceName);
-    if (hex) {
-        stream.showTextHex(hex);
-    }
-    else {
-        stream.showText(headerText);
-    }
-    stream.endText();
+    const useType3 = fontManager.hasType3Fonts() && !fontManager.hasEmbeddedFont();
+    emitTextWithMatrix(stream, headerText, 1, 0, 0, 1, x, y, resourceName, headerFontSize, fontManager, useType3);
     stream.restore();
 }
 function drawPageFooter(stream, page, options, fontManager, totalPages) {
@@ -988,6 +1030,7 @@ function renderTextWatermark(stream, page, watermark, fontManager) {
     const sin = Math.sin(radians);
     const needsAlpha = opacity < 1;
     const gsName = needsAlpha ? alphaGsName(opacity) : "";
+    const useType3 = fontManager.hasType3Fonts() && !isEmbedded;
     const drawSingleWatermark = (cx, cy) => {
         // Center the text at (cx, cy), compensating for both width and ascent height
         const halfW = textWidth / 2;
@@ -999,17 +1042,7 @@ function renderTextWatermark(stream, page, watermark, fontManager) {
             stream.setGraphicsState(gsName);
         }
         stream.setFillColor(color);
-        stream.beginText();
-        stream.setFont(resourceName, fontSize);
-        stream.setTextMatrix(cos, sin, -sin, cos, tx, ty);
-        const hex = fontManager.encodeText(watermark.text, resourceName);
-        if (hex) {
-            stream.showTextHex(hex);
-        }
-        else {
-            stream.showText(watermark.text);
-        }
-        stream.endText();
+        emitTextWithMatrix(stream, watermark.text, cos, sin, -sin, cos, tx, ty, resourceName, fontSize, fontManager, useType3);
         stream.restore();
     };
     if (watermark.repeat) {

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

@@ -18,6 +18,7 @@ const pdf_stream_1 = require("../core/pdf-stream");
 const pdf_writer_1 = require("../core/pdf-writer");
 const errors_1 = require("../errors");
 const font_manager_1 = require("../font/font-manager");
+const system_fonts_1 = require("../font/system-fonts");
 const ttf_parser_1 = require("../font/ttf-parser");
 const types_1 = require("../types");
 const layout_engine_1 = require("./layout-engine");
@@ -53,13 +54,39 @@ function prepareExport(workbook, options) {
     }
     const fontManager = new font_manager_1.FontManager();
     const writer = new pdf_writer_1.PdfWriter();
-    if (options?.font) {
+    // Determine font data: user-provided > auto-discovered system font
+    let fontData = options?.font ?? null;
+    if (!fontData) {
+        // Collect non-WinAnsi code points from the document (single pass)
+        const nonWinAnsi = collectNonWinAnsiCodePoints(sheets);
+        if (nonWinAnsi.size > 0) {
+            // Try system font candidates in preference order until one covers all chars
+            for (const candidate of (0, system_fonts_1.discoverSystemFontCandidates)()) {
+                try {
+                    const testTtf = (0, ttf_parser_1.parseTtf)(candidate);
+                    const allCovered = [...nonWinAnsi].every(cp => testTtf.cmap.has(cp));
+                    if (allCovered) {
+                        fontData = candidate;
+                        break;
+                    }
+                }
+                catch {
+                    // Parse failed — try next candidate
+                }
+            }
+        }
+    }
+    if (fontData) {
         try {
-            const ttf = (0, ttf_parser_1.parseTtf)(options.font);
+            const ttf = (0, ttf_parser_1.parseTtf)(fontData);
             fontManager.registerEmbeddedFont(ttf);
         }
         catch (err) {
-            throw new errors_1.PdfRenderError("Failed to parse TrueType font", { cause: err });
+            if (options?.font) {
+                // Only throw if the user explicitly provided a font
+                throw new errors_1.PdfRenderError("Failed to parse TrueType font", { cause: err });
+            }
+            // Auto-discovered font failed to parse — silently fall back to Type1 + Type3
         }
     }
     return { sheets, fontManager, writer, allPages: [] };
@@ -503,3 +530,44 @@ function isWatermarkApplicable(watermark, page) {
     }
     return true;
 }
+// =============================================================================
+// Non-WinAnsi Detection
+// =============================================================================
+/**
+ * Collect all non-WinAnsi code points from sheet text (single pass).
+ * Returns an empty set if all text is WinAnsi-representable.
+ */
+function collectNonWinAnsiCodePoints(sheets) {
+    const result = new Set();
+    for (const sheet of sheets) {
+        for (const row of sheet.rows.values()) {
+            for (const cell of row.cells.values()) {
+                collectFromText(cell.text, result);
+                if (cell.type === types_1.PdfCellType.RichText &&
+                    cell.value &&
+                    typeof cell.value === "object" &&
+                    "richText" in cell.value) {
+                    const runs = cell.value.richText;
+                    for (const run of runs) {
+                        collectFromText(run.text, result);
+                    }
+                }
+            }
+        }
+    }
+    return result;
+}
+function collectFromText(text, out) {
+    if (!text) {
+        return;
+    }
+    for (let i = 0; i < text.length; i++) {
+        const cp = text.codePointAt(i);
+        if (cp > 0xffff) {
+            i++;
+        }
+        if (!(0, pdf_stream_1.isWinAnsiCodePoint)(cp)) {
+            out.add(cp);
+        }
+    }
+}

package/dist/esm/modules/pdf/builder/document-builder.js

@@ -25,7 +25,7 @@ import { PdfWriter } from "../core/pdf-writer.js";
 import { writePdfAMetadata, writePdfAOutputIntent } from "../core/pdfa.js";
 import { FontManager } from "../font/font-manager.js";
 import { parseTtf } from "../font/ttf-parser.js";
-import { wrapTextLines } from "../render/page-renderer.js";
+import { wrapTextLines, emitTextWithMatrix } from "../render/page-renderer.js";
 import { writeImageXObject } from "./image-utils.js";
 // =============================================================================
 // Constants
@@ -87,8 +87,8 @@ export class PdfPageBuilder {
         const fontFamily = options.fontFamily ?? "Helvetica";
         // Resolve font
         const resourceName = this._fontManager.resolveFont(fontFamily, bold, italic);
-        const encodedText = this._fontManager.encodeText(text, resourceName);
         this._fontManager.trackText(text);
+        const useType3 = this._fontManager.hasType3Fonts() && !this._fontManager.hasEmbeddedFont();
         if (options.maxWidth) {
             // Word-wrap (reuses the shared wrapTextLines from page-renderer)
             const measure = (s) => this._fontManager.measureText(s, resourceName, fontSize);
@@ -96,36 +96,17 @@ export class PdfPageBuilder {
             const leading = fontSize * lineHeightFactor;
             this._stream.save();
             this._stream.setFillColor(color);
-            this._stream.beginText();
-            this._stream.setFont(resourceName, fontSize);
             for (let i = 0; i < lines.length; i++) {
                 const lineY = options.y - i * leading;
-                this._stream.setTextMatrix(1, 0, 0, 1, options.x, lineY);
-                const lineEncoded = this._fontManager.encodeText(lines[i], resourceName);
-                if (lineEncoded) {
-                    this._stream.showTextHex(lineEncoded);
-                }
-                else {
-                    this._stream.showText(lines[i]);
-                }
+                emitTextWithMatrix(this._stream, lines[i], 1, 0, 0, 1, options.x, lineY, resourceName, fontSize, this._fontManager, useType3);
             }
-            this._stream.endText();
             this._stream.restore();
         }
         else {
             // Single line
             this._stream.save();
             this._stream.setFillColor(color);
-            this._stream.beginText();
-            this._stream.setFont(resourceName, fontSize);
-            this._stream.setTextMatrix(1, 0, 0, 1, options.x, options.y);
-            if (encodedText) {
-                this._stream.showTextHex(encodedText);
-            }
-            else {
-                this._stream.showText(text);
-            }
-            this._stream.endText();
+            emitTextWithMatrix(this._stream, text, 1, 0, 0, 1, options.x, options.y, resourceName, fontSize, this._fontManager, useType3);
             this._stream.restore();
         }
         return this;

package/dist/esm/modules/pdf/core/pdf-stream.js

@@ -26,6 +26,17 @@ export class PdfContentStream {
         this.parts = [];
     }
     // ===========================================================================
+    // Raw Operator
+    // ===========================================================================
+    /**
+     * Append a raw PDF operator string to the content stream.
+     * Use this for operators not covered by the typed API (e.g. `d1` for Type3 glyphs).
+     */
+    raw(operator) {
+        this.parts.push(operator);
+        return this;
+    }
+    // ===========================================================================
     // Graphics State
     // ===========================================================================
     /**
@@ -502,7 +513,9 @@ const UNICODE_TO_WINANSI = new Map([
 ]);
 /**
  * Convert a Unicode code point to a WinAnsi byte value.
- * Returns 0x3F ('?') for unmappable characters.
+ * Returns 0x20 (space) for unmappable characters — standard Type1 fonts
+ * do not contain glyphs outside the WinAnsi repertoire, so a space is
+ * less misleading than a literal '?'.
  */
 function unicodeToWinAnsi(cp) {
     // Direct mapping for Latin-1 range (0x00-0xFF), excluding 0x80-0x9F
@@ -517,6 +530,37 @@ function unicodeToWinAnsi(cp) {
     if (mapped !== undefined) {
         return mapped;
     }
-    // Unmappable — use '?'
-    return 0x3f;
+    // Unmappable — use space instead of '?' to avoid misleading output.
+    // Full Unicode support requires an embedded TrueType font (the `font`
+    // option in PdfExportOptions).
+    return 0x20;
+}
+/**
+ * Check whether a single code point is representable in WinAnsi encoding.
+ */
+export function isWinAnsiCodePoint(cp) {
+    if (cp < 0x80) {
+        return true;
+    }
+    if (cp >= 0xa0 && cp <= 0xff) {
+        return true;
+    }
+    return UNICODE_TO_WINANSI.has(cp);
+}
+/**
+ * Check whether a string contains characters outside the WinAnsi repertoire.
+ * When true, standard Type1 fonts cannot render those characters and an
+ * embedded TrueType font is required for correct output.
+ */
+export function hasNonWinAnsiChars(text) {
+    for (let i = 0; i < text.length; i++) {
+        const cp = text.codePointAt(i);
+        if (cp > 0xffff) {
+            i++;
+        }
+        if (!isWinAnsiCodePoint(cp)) {
+            return true;
+        }
+    }
+    return false;
 }