@polotno/pdf-export 0.1.18 → 0.1.20

package/lib/text.js

@@ -1,184 +1,577 @@
-const { parseColor, srcToBuffer } = require('./utils');
-const getUrls = require('get-urls').default;
-const fetch = require('node-fetch').default;
-
-async function getGoogleFontPath(fontFamily, fontWeight = 'normal') {
-  const weight = fontWeight === 'bold' ? '700' : '400';
-  const url = `https://fonts.googleapis.com/css?family=${fontFamily}:${weight}`;
-  const req = await fetch(url);
-  if (!req.ok) {
-    if (weight !== '400') {
-      return getGoogleFontPath(fontFamily, 'normal');
-    }
-    throw new Error(`Failed to fetch Google font: ${fontFamily}`);
-  }
-  const text = await req.text();
-  const urls = getUrls(text);
-  return urls.values().next().value;
-}
-
-async function loadFontIfNeeded(doc, element, fonts) {
-  // check if universal font is already defined
-  if (fonts[element.fontFamily]) {
-    doc.font(element.fontFamily);
-    return element.fontFamily;
-  }
-  const fontKey = `${element.fontFamily}-${element.fontWeight || 'normal'}`;
-  if (!fonts[fontKey]) {
-    const src = await getGoogleFontPath(element.fontFamily, element.fontWeight);
-    doc.registerFont(fontKey, await srcToBuffer(src));
-    fonts[fontKey] = true;
-  }
-  doc.font(fontKey);
-  return fontKey;
-}
-
-function renderText(doc, element, attrs = {}) {
-  doc.fontSize(element.fontSize);
-  doc.fillColor(parseColor(element.fill).hex, element.opacity);
-
-  // Handle stroked text differently for PDF/X-1a compatibility
-  const hasStroke = element.strokeWidth > 0;
-  const isPDFX1a = attrs.pdfx1a;
-
-  if (hasStroke && !isPDFX1a) {
-    // Standard PDF: use PDFKit's built-in stroke support
-    doc.lineWidth(element.strokeWidth / 2);
-    doc.strokeColor(parseColor(element.stroke).hex);
-  }
-
-  const props = {
-    align: element.align,
-    fill: element.fill,
-    baseline: 'top',
-    lineGap: 1,
-    width: element.width,
-    underline: element.textDecoration.indexOf('underline') >= 0,
-    characterSpacing: element.letterSpacing
-      ? element.letterSpacing * element.fontSize
-      : 0,
-    lineBreak: false,
-    stroke: hasStroke && !isPDFX1a, // Only use stroke for non-PDF/X-1a
-  };
-
-  const currentLineHeight = doc.heightOfString('A', props);
-  const lineHeight = element.lineHeight * element.fontSize;
-
-  const fontBoundingBoxAscent = (doc._font.ascender / 1000) * element.fontSize;
-  const fontBoundingBoxDescent =
-    (doc._font.descender / 1000) * element.fontSize;
-  const translateY = (fontBoundingBoxAscent - fontBoundingBoxDescent) / 2;
-
-  const diff = currentLineHeight - lineHeight;
-  props.lineGap = props.lineGap - diff;
-
-  let yOffset = 0;
-  if ((attrs.textVerticalResizeEnabled || true) && element.verticalAlign) {
-    const textHeight = doc.heightOfString(element.text, props);
+import { parseColor, srcToBuffer } from './utils.js';
+import getUrls from 'get-urls';
+import fetch from 'node-fetch';
+import { stripHtml } from "string-strip-html";
+/**
+ * Check if text contains HTML tags
+ */
+function containsHTML(text) {
+    const htmlTagRegex = /<\/?(?:strong|b|em|i|u|span)[^>]*>/i;
+    return htmlTagRegex.test(text);
+}
+/**
+ * Parse HTML text into styled segments
+ */
+function parseHTMLToSegments(html, baseElement) {
+    const segments = [];
+    const tagStack = [];
+    // Regex to match tags and text content
+    const regex = /<(\/?)(strong|b|em|i|u|span)([^>]*)>|([^<]+)/gi;
+    let match;
+    while ((match = regex.exec(html)) !== null) {
+        if (match[4]) {
+            // Text content
+            const text = match[4];
+            // Calculate current styles from tag stack
+            let bold = false;
+            let italic = false;
+            let underline = false;
+            let color = undefined;
+            for (const tag of tagStack) {
+                if (tag.tag === 'strong' || tag.tag === 'b')
+                    bold = true;
+                if (tag.tag === 'em' || tag.tag === 'i')
+                    italic = true;
+                if (tag.tag === 'u')
+                    underline = true;
+                if (tag.color)
+                    color = tag.color;
+            }
+            segments.push({
+                text,
+                bold,
+                italic,
+                underline,
+                color
+            });
+        }
+        else {
+            // Tag
+            const isClosing = match[1] === '/';
+            const tagName = match[2].toLowerCase();
+            const attributes = match[3];
+            if (isClosing) {
+                // Remove from stack
+                const index = tagStack.findIndex(t => t.tag === tagName);
+                if (index !== -1) {
+                    tagStack.splice(index, 1);
+                }
+            }
+            else {
+                // Add to stack
+                const tagData = { tag: tagName };
+                // Parse color from span style attribute
+                if (attributes) {
+                    const colorMatch = /style=["'](?:[^"']*)?color:\s*([^;"']+)/i.exec(attributes);
+                    if (colorMatch) {
+                        tagData.color = colorMatch[1].trim();
+                    }
+                }
+                tagStack.push(tagData);
+            }
+        }
+    }
+    return segments;
+}
+/**
+ * Get font weight string based on bold/italic state
+ */
+function getFontWeight(bold, italic, baseFontWeight) {
+    if (bold) {
+        return 'bold';
+    }
+    return baseFontWeight || 'normal';
+}
+/**
+ * Get font key for caching
+ */
+function getFontKey(fontFamily, bold, italic, baseFontWeight) {
+    const weight = getFontWeight(bold, italic, baseFontWeight);
+    const style = italic ? 'italic' : 'normal';
+    return `${fontFamily}-${weight}-${style}`;
+}
+export async function getGoogleFontPath(fontFamily, fontWeight = 'normal', italic = false) {
+    const weight = fontWeight === 'bold' ? '700' : '400';
+    const italicParam = italic ? 'italic' : '';
+    const url = `https://fonts.googleapis.com/css?family=${fontFamily}:${italicParam}${weight}`;
+    const req = await fetch(url);
+    if (!req.ok) {
+        if (weight !== '400' || italic) {
+            // Fallback: try normal weight without italic
+            return getGoogleFontPath(fontFamily, 'normal', false);
+        }
+        throw new Error(`Failed to fetch Google font: ${fontFamily}`);
+    }
+    const text = await req.text();
+    const urls = getUrls(text);
+    return urls.values().next().value;
+}
+export async function loadFontIfNeeded(doc, element, fonts) {
+    // check if universal font is already defined
+    if (fonts[element.fontFamily]) {
+        doc.font(element.fontFamily);
+        return element.fontFamily;
+    }
+    const isItalic = element.fontStyle?.indexOf('italic') >= 0;
+    const isBold = element.fontWeight == 'bold';
+    const fontKey = getFontKey(element.fontFamily, isBold, isItalic, element.fontWeight);
+    if (!fonts[fontKey]) {
+        const src = await getGoogleFontPath(element.fontFamily, element.fontWeight, isItalic);
+        doc.registerFont(fontKey, await srcToBuffer(src));
+        fonts[fontKey] = true;
+    }
+    doc.font(fontKey);
+    return fontKey;
+}
+/**
+ * Load font for a rich text segment
+ */
+async function loadFontForSegment(doc, segment, element, fonts) {
+    const fontFamily = element.fontFamily;
+    const bold = segment.bold || element.fontWeight == 'bold' || false;
+    const italic = segment.italic || element.fontStyle?.indexOf('italic') >= 0 || false;
+    // Check if universal font is already defined
+    if (fonts[fontFamily]) {
+        doc.font(fontFamily);
+        return fontFamily;
+    }
+    const fontKey = getFontKey(fontFamily, bold, italic, element.fontWeight);
+    if (!fonts[fontKey]) {
+        const weight = getFontWeight(bold, italic, element.fontWeight);
+        const src = await getGoogleFontPath(fontFamily, weight, italic);
+        doc.registerFont(fontKey, await srcToBuffer(src));
+        fonts[fontKey] = true;
+    }
+    doc.font(fontKey);
+    return fontKey;
+}
+/**
+ * Parse HTML into tokens (text and tags)
+ */
+function tokenizeHTML(html) {
+    const tokens = [];
+    const regex = /<(\/?)(strong|b|em|i|u|span)([^>]*)>|([^<]+)/gi;
+    let match;
+    while ((match = regex.exec(html)) !== null) {
+        if (match[4]) {
+            // Text content
+            tokens.push({
+                type: 'text',
+                content: match[4]
+            });
+        }
+        else {
+            // Tag
+            const isClosing = match[1] === '/';
+            const tagName = match[2].toLowerCase();
+            tokens.push({
+                type: 'tag',
+                content: match[0],
+                tagName: tagName,
+                isClosing: isClosing
+            });
+        }
+    }
+    return tokens;
+}
+/**
+ * Reconstruct HTML from tokens while maintaining proper tag nesting across line breaks
+ * @param tokens - Array of parsed HTML tokens
+ * @param openTags - Tags that were opened in previous lines and should be carried forward
+ * @returns Reconstructed HTML string and the updated list of open tags
+ */
+function tokensToHTML(tokens, openTags) {
+    let html = '';
+    const tagStack = [...openTags]; // Clone the open tags
+    // Prepend any open tags
+    for (const tag of openTags) {
+        html += tag.fullTag;
+    }
+    // Process tokens
+    for (const token of tokens) {
+        if (token.type === 'text') {
+            html += token.content;
+        }
+        else if (token.type === 'tag') {
+            html += token.content;
+            if (token.isClosing) {
+                // Remove from stack
+                const idx = tagStack.findIndex(t => t.name === token.tagName);
+                if (idx !== -1) {
+                    tagStack.splice(idx, 1);
+                }
+            }
+            else {
+                // Add to stack
+                tagStack.push({
+                    name: token.tagName,
+                    fullTag: token.content
+                });
+            }
+        }
+    }
+    // Close any remaining open tags for this line
+    for (let i = tagStack.length - 1; i >= 0; i--) {
+        html += `</${tagStack[i].name}>`;
+    }
+    return { html, openTags: tagStack };
+}
+/**
+ * Split text into lines that fit within the element width while preserving HTML formatting
+ * Handles word wrapping and ensures HTML tags are properly opened/closed across line breaks
+ */
+function splitTextIntoLines(doc, element, props) {
+    const lines = [];
+    const paragraphs = element.text.split('\n');
+    for (const paragraph of paragraphs) {
+        // Tokenize the paragraph
+        const tokens = tokenizeHTML(paragraph);
+        // Extract plain text for width calculation
+        const plainText = tokens
+            .filter(t => t.type === 'text')
+            .map(t => t.content)
+            .join('');
+        const paragraphWidth = doc.widthOfString(plainText, props);
+        // Justify alignment using native pdfkit instruments
+        if (paragraphWidth <= element.width || element.align === 'justify') {
+            // Paragraph fits on one line
+            lines.push({ text: paragraph, width: paragraphWidth });
+        }
+        else {
+            // Need to split paragraph into multiple lines
+            let currentLine = '';
+            let currentWidth = 0;
+            let currentTokens = [];
+            let openTags = [];
+            for (const token of tokens) {
+                if (token.type === 'tag') {
+                    currentTokens.push(token);
+                    continue;
+                }
+                // Text token - split by words
+                const textWords = token.content.split(' ');
+                for (let i = 0; i < textWords.length; i++) {
+                    const word = textWords[i];
+                    const testLine = currentLine ? `${currentLine}${i > 0 ? ' ' : ''}${word}` : word;
+                    const testWidth = doc.widthOfString(testLine, props);
+                    if (testWidth <= element.width) {
+                        currentLine = testLine;
+                        currentWidth = testWidth;
+                        // Add text token (with space if not first word in token)
+                        if (i > 0 || currentTokens.length > 0) {
+                            let content = (i > 0 ? ' ' : '') + word;
+                            currentTokens.push({
+                                type: 'text',
+                                content: content
+                            });
+                        }
+                        else {
+                            currentTokens.push({
+                                type: 'text',
+                                content: word
+                            });
+                        }
+                    }
+                    else {
+                        // Line is too long, save current line and start new one
+                        if (currentLine) {
+                            const result = tokensToHTML(currentTokens, openTags);
+                            lines.push({ text: result.html, width: currentWidth });
+                            openTags = result.openTags;
+                            currentTokens = [];
+                        }
+                        currentLine = word;
+                        currentWidth = doc.widthOfString(word, props);
+                        currentTokens.push({
+                            type: 'text',
+                            content: word
+                        });
+                    }
+                }
+            }
+            // Add the last line
+            if (currentLine) {
+                const result = tokensToHTML(currentTokens, openTags);
+                lines.push({ text: result.html, width: currentWidth });
+            }
+        }
+    }
+    return lines;
+}
+/**
+ * Calculate horizontal offset for a line of text based on alignment
+ * @param element - Text element with alignment settings
+ * @param lineWidth - Width of the current line
+ * @returns X offset for positioning the line
+ */
+function calculateLineXOffset(element, lineWidth) {
+    const align = element.align;
+    if (align === 'right') {
+        return element.width - lineWidth;
+    }
+    else if (align === 'center') {
+        return (element.width - lineWidth) / 2;
+    }
+    else if (align === 'justify') {
+        // Justify alignment is handled by PDFKit's align property
+        return 0;
+    }
+    // Default: left alignment
+    return 0;
+}
+/**
+ * Calculate text rendering metrics including line height and baseline offset
+ */
+function calculateTextMetrics(doc, element) {
+    const textOptions = {
+        align: element.align === 'justify' ? 'justify' : 'left',
+        baseline: 'alphabetic',
+        lineGap: 1,
+        width: element.width,
+        underline: element.textDecoration.indexOf('underline') >= 0,
+        characterSpacing: element.letterSpacing
+            ? element.letterSpacing * element.fontSize
+            : 0,
+        lineBreak: false,
+        stroke: false,
+        fill: false
+    };
+    const currentLineHeight = doc.heightOfString('A', textOptions);
+    const lineHeight = element.lineHeight * element.fontSize;
+    const fontBoundingBoxAscent = (doc._font.ascender / 1000) * element.fontSize;
+    const fontBoundingBoxDescent = (doc._font.descender / 1000) * element.fontSize;
+    // Calculate baseline offset based on font metrics (similar to Konva rendering)
+    const baselineOffset = (fontBoundingBoxAscent - Math.abs(fontBoundingBoxDescent)) / 2 + lineHeight / 2;
+    // Adjust line gap to match desired line height
+    const lineHeightDiff = currentLineHeight - lineHeight;
+    textOptions.lineGap = textOptions.lineGap - lineHeightDiff;
+    const textLines = splitTextIntoLines(doc, element, textOptions);
+    return {
+        textOptions,
+        lineHeightPx: lineHeight,
+        baselineOffset,
+        textLines
+    };
+}
+/**
+ * Calculate vertical alignment offset for text
+ */
+function calculateVerticalAlignment(doc, element, textOptions) {
+    if (!element.verticalAlign || element.verticalAlign === 'top') {
+        return 0;
+    }
+    const strippedContent = stripHtml(element.text).result;
+    const textHeight = doc.heightOfString(strippedContent, textOptions);
     if (element.verticalAlign === 'middle') {
-      yOffset = (element.height - textHeight) / 2;
-    } else if (element.verticalAlign === 'bottom') {
-      yOffset = element.height - textHeight;
-    }
-  }
-
-  for (var size = element.fontSize; size > 0; size -= 1) {
-    doc.fontSize(size);
-    const height = doc.heightOfString(element.text, {
-      ...props,
-    });
-    if (height <= element.height) {
-      break;
-    }
-  }
-
-  const halfLineHeight = ((element.lineHeight - 1) / 2) * element.fontSize;
-
-  if (element.backgroundEnabled) {
-    const backPadding =
-      element.backgroundPadding * (element.fontSize * element.lineHeight);
-    const cornerRadius =
-      element.backgroundCornerRadius *
-      (element.fontSize * element.lineHeight * 0.5);
-
-    const textWidth = doc.widthOfString(element.text, {
-      ...props,
-      width: element.width,
+        return (element.height - textHeight) / 2;
+    }
+    else if (element.verticalAlign === 'bottom') {
+        return element.height - textHeight;
+    }
+    return 0;
+}
+/**
+ * Reduce font size to fit text within element height
+ */
+function fitTextToHeight(doc, element, textOptions) {
+    const strippedContent = stripHtml(element.text).result;
+    for (let size = element.fontSize; size > 0; size -= 1) {
+        doc.fontSize(size);
+        const height = doc.heightOfString(strippedContent, textOptions);
+        if (height <= element.height) {
+            break;
+        }
+    }
+}
+/**
+ * Render text background box
+ */
+function renderTextBackground(doc, element, verticalAlignmentOffset, textOptions) {
+    if (!element.backgroundEnabled) {
+        return;
+    }
+    const strippedContent = stripHtml(element.text).result;
+    const padding = element.backgroundPadding * (element.fontSize * element.lineHeight);
+    const cornerRadius = element.backgroundCornerRadius * (element.fontSize * element.lineHeight * 0.5);
+    const textWidth = doc.widthOfString(strippedContent, {
+        ...textOptions,
+        width: element.width,
     });
-    const textHeight = doc.heightOfString(element.text, {
-      ...props,
-      width: element.width,
+    const textHeight = doc.heightOfString(strippedContent, {
+        ...textOptions,
+        width: element.width,
     });
-
-    let bgX = -backPadding / 2;
-    let bgY = -backPadding / 2;
-    let bgWidth = textWidth + backPadding;
-    let bgHeight = textHeight + backPadding;
-
+    let bgX = -padding / 2;
+    let bgY = verticalAlignmentOffset - padding / 2;
+    const bgWidth = textWidth + padding;
+    const bgHeight = textHeight + padding;
+    // Adjust horizontal position based on text alignment
     if (element.align === 'center') {
-      bgX = (element.width - textWidth) / 2 - backPadding / 2;
-    } else if (element.align === 'right') {
-      bgX = element.width - textWidth - backPadding / 2;
+        bgX = (element.width - textWidth) / 2 - padding / 2;
     }
-
-    if (element.verticalAlign === 'middle') {
-      bgY = (element.height - textHeight) / 2 - backPadding / 2;
-    } else if (element.verticalAlign === 'bottom') {
-      bgY = element.height - textHeight - backPadding / 2;
+    else if (element.align === 'right') {
+        bgX = element.width - textWidth - padding / 2;
     }
-
     doc.roundedRect(bgX, bgY, bgWidth, bgHeight, cornerRadius);
     doc.fillColor(parseColor(element.backgroundColor).hex);
     doc.fill();
     doc.fillColor(parseColor(element.fill).hex, element.opacity);
-  }
-
-  // Render text with PDF/X-1a compatible stroke simulation
-  if (hasStroke && isPDFX1a) {
-    // For PDF/X-1a: simulate stroke by drawing text multiple times
+}
+/**
+ * Render text stroke using PDF/X-1a compatible method (multiple offset fills)
+ */
+function renderPDFX1aStroke(doc, element, textLines, yOffset, lineHeightPx, textOptions) {
     const strokeColor = parseColor(element.stroke).hex;
     const strokeWidth = element.strokeWidth;
-
-    // Draw stroke by rendering text multiple times with offsets
+    const isJustify = element.align === 'justify';
+    // Generate stroke offsets in a circle pattern
     const offsets = [];
     for (let angle = 0; angle < 360; angle += 45) {
-      const radian = (angle * Math.PI) / 180;
-      offsets.push({
-        x: Math.cos(radian) * strokeWidth,
-        y: Math.sin(radian) * strokeWidth,
-      });
-    }
-
-    // Draw stroke layers
+        const radian = (angle * Math.PI) / 180;
+        offsets.push({
+            x: Math.cos(radian) * strokeWidth,
+            y: Math.sin(radian) * strokeWidth,
+        });
+    }
+    // Render stroke layer by drawing text multiple times with offsets
     doc.save();
     doc.fillColor(strokeColor, element.opacity);
-    for (const offset of offsets) {
-      doc.text(element.text, offset.x, yOffset + halfLineHeight + offset.y, {
-        ...props,
-        stroke: false, // Force no stroke for compatibility
-        height: element.height + element.fontSize,
-      });
+    for (let i = 0; i < textLines.length; i++) {
+        const line = textLines[i];
+        const lineXOffset = calculateLineXOffset(element, line.width);
+        const lineYOffset = yOffset + (i * lineHeightPx);
+        for (const offset of offsets) {
+            doc.text(line.text, lineXOffset + offset.x, lineYOffset + offset.y, {
+                ...textOptions,
+                width: isJustify ? element.width : undefined,
+                stroke: false,
+            });
+        }
     }
     doc.restore();
-
-    // Draw fill text on top
+    // Render fill layer on top
     doc.fillColor(parseColor(element.fill).hex, element.opacity);
-    doc.text(element.text, 0, yOffset + halfLineHeight, {
-      ...props,
-      stroke: false, // Force no stroke for compatibility
-      height: element.height + element.fontSize,
-    });
-  } else {
-    // Standard rendering
-    doc.text(element.text, 0, yOffset + halfLineHeight, {
-      ...props,
-      height: element.height + element.fontSize,
-    });
-  }
-}
-
-module.exports = {
-  getGoogleFontPath,
-  renderText,
-  loadFontIfNeeded,
-};
+    for (let i = 0; i < textLines.length; i++) {
+        const line = textLines[i];
+        const lineXOffset = calculateLineXOffset(element, line.width);
+        const lineYOffset = yOffset + (i * lineHeightPx);
+        doc.text(line.text, lineXOffset, lineYOffset, {
+            ...textOptions,
+            width: isJustify ? element.width : undefined,
+            stroke: false,
+        });
+    }
+}
+/**
+ * Render text stroke using standard PDF stroke
+ */
+function renderStandardStroke(doc, element, textLines, yOffset, lineHeightPx, textOptions) {
+    const isJustify = element.align === 'justify';
+    doc.save();
+    doc.lineWidth(element.strokeWidth);
+    doc.lineCap('round').lineJoin('round');
+    doc.strokeColor(parseColor(element.stroke).hex, element.opacity);
+    let cumulativeYOffset = 0;
+    for (let i = 0; i < textLines.length; i++) {
+        const line = textLines[i];
+        const lineXOffset = calculateLineXOffset(element, line.width);
+        const lineYOffset = yOffset + cumulativeYOffset;
+        const strippedLineText = stripHtml(line.text).result;
+        const heightOfLine = line.text === ''
+            ? lineHeightPx
+            : doc.heightOfString(strippedLineText, textOptions);
+        cumulativeYOffset += heightOfLine;
+        doc.text(line.text, lineXOffset, lineYOffset, {
+            ...textOptions,
+            width: isJustify ? element.width : undefined,
+            height: heightOfLine,
+            stroke: true,
+            fill: false
+        });
+    }
+    doc.restore();
+}
+/**
+ * Render text fill with rich text support (HTML segments)
+ */
+async function renderTextFill(doc, element, textLines, yOffset, lineHeightPx, textOptions, fonts) {
+    if (!element.fill) {
+        return;
+    }
+    const baseParsedColor = parseColor(element.fill);
+    const baseOpacity = Math.min(baseParsedColor.rgba[3] ?? 1, element.opacity, 1);
+    doc.fillColor(baseParsedColor.hex, baseOpacity);
+    const isJustify = element.align === 'justify';
+    let cumulativeYOffset = 0;
+    for (let i = 0; i < textLines.length; i++) {
+        const line = textLines[i];
+        const lineXOffset = calculateLineXOffset(element, line.width);
+        const lineYOffset = yOffset + cumulativeYOffset;
+        const strippedLineText = stripHtml(line.text).result;
+        const heightOfLine = line.text === ''
+            ? lineHeightPx
+            : doc.heightOfString(strippedLineText, textOptions);
+        cumulativeYOffset += heightOfLine;
+        // Position cursor at line start
+        doc.text('', lineXOffset, lineYOffset, { height: 0, width: 0 });
+        // Parse line into styled segments
+        const segments = parseHTMLToSegments(line.text, element);
+        // Render each segment with its own styling
+        for (let segmentIndex = 0; segmentIndex < segments.length; segmentIndex++) {
+            const segment = segments[segmentIndex];
+            const isLastSegment = segmentIndex === segments.length - 1;
+            // Load appropriate font for this segment
+            await loadFontForSegment(doc, segment, element, fonts);
+            doc.fontSize(element.fontSize);
+            // Apply segment color
+            const segmentColor = segment.color
+                ? parseColor(segment.color).hex
+                : parseColor(element.fill).hex;
+            const segmentParsedColor = segment.color
+                ? parseColor(segment.color)
+                : parseColor(element.fill);
+            const segmentOpacity = Math.min(segmentParsedColor.rgba[3] ?? 1, element.opacity, 1);
+            doc.fillColor(segmentColor, segmentOpacity);
+            // Render segment text
+            doc.text(segment.text, {
+                ...textOptions,
+                width: isJustify ? element.width : undefined,
+                height: heightOfLine,
+                continued: !isLastSegment,
+                underline: segment.underline || textOptions.underline || false,
+                lineBreak: !!segment.underline, // Workaround for pdfkit bug
+                stroke: false,
+                fill: true
+            });
+        }
+    }
+}
+/**
+ * Main text rendering function
+ */
+export async function renderText(doc, element, fonts, attrs = {}) {
+    doc.fontSize(element.fontSize);
+    const hasStroke = element.strokeWidth > 0;
+    const isPDFX1a = attrs.pdfx1a;
+    // Calculate text metrics and line positioning
+    const metrics = calculateTextMetrics(doc, element);
+    const verticalAlignmentOffset = calculateVerticalAlignment(doc, element, metrics.textOptions);
+    // Fit text to element height if needed
+    fitTextToHeight(doc, element, metrics.textOptions);
+    // Calculate final vertical offset
+    const finalYOffset = verticalAlignmentOffset + metrics.baselineOffset;
+    // Render background if enabled
+    renderTextBackground(doc, element, verticalAlignmentOffset, metrics.textOptions);
+    // Render text based on stroke and PDF/X-1a requirements
+    if (hasStroke && isPDFX1a) {
+        // PDF/X-1a mode: simulate stroke with offset fills
+        renderPDFX1aStroke(doc, element, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions);
+    }
+    else {
+        // Standard rendering: stroke first, then fill
+        if (hasStroke) {
+            renderStandardStroke(doc, element, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions);
+        }
+        await renderTextFill(doc, element, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions, fonts);
+    }
+}