@polotno/pdf-export 0.1.37 → 0.1.38

package/lib/text.js

@@ -1,221 +1,13 @@
-import { parseColor, srcToBuffer } from './utils.js';
+import { parseColor, srcToBuffer, fetchWithTimeout } from './utils.js';
 import getUrls from 'get-urls';
-import fetch from 'node-fetch';
-import { stripHtml } from 'string-strip-html';
-import { decode as decodeEntities } from 'html-entities';
-/**
- * Expand tabs to spaces based on character positions (every 8 characters by default).
- * This is a lightweight character-based approximation used for line-breaking calculations.
- *
- * NOTE: This is NOT used for actual rendering! The rendering functions use visual width
- * measurements and manual cursor positioning for accurate tab alignment in proportional fonts.
- * This function is only used in splitTextIntoLines() to approximate text widths for wrapping.
- *
- * @param text - Text containing tabs to expand
- * @param tabSize - Size of tab stops in characters (default 8)
- * @param startPosition - Starting character position for tab stop calculation (default 0)
- * @returns Text with tabs expanded to spaces (character-based approximation)
- */
-function expandTabsToTabStops(text, tabSize = 8, startPosition = 0) {
-    if (!text) {
-        return text;
-    }
-    let result = '';
-    let position = startPosition; // Current character position
-    for (let i = 0; i < text.length; i++) {
-        const char = text[i];
-        if (char === '\t') {
-            // Calculate how many spaces needed to reach next tab stop
-            const spacesNeeded = tabSize - (position % tabSize);
-            result += ' '.repeat(spacesNeeded);
-            position += spacesNeeded;
-        }
-        else if (char === '\n') {
-            // Reset position on newline (tab stops reset at line start)
-            result += char;
-            position = 0;
-        }
-        else {
-            result += char;
-            position++;
-        }
-    }
-    return result;
-}
-function isTabDebuggingEnabled() {
-    return typeof process !== 'undefined' && process.env?.DEBUG_TABS === '1';
-}
-function getEffectiveTabSize(tabSizeInSpaces) {
-    if (typeof process === 'undefined') {
-        return tabSizeInSpaces;
-    }
-    const envValue = process.env?.POLOTNO_TAB_SIZE;
-    if (!envValue) {
-        return tabSizeInSpaces;
-    }
-    const parsed = parseInt(envValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : tabSizeInSpaces;
-}
-function formatTabDebugLabel(context) {
-    if (!context) {
-        return 'unknown';
-    }
-    if (context.elementId) {
-        return context.elementId;
-    }
-    if (context.elementName) {
-        return context.elementName;
-    }
-    return 'unknown';
-}
-function formatSegmentPreview(text) {
-    if (!text) {
-        return '';
-    }
-    return text.replace(/\s+/g, ' ').trim().slice(0, 80);
-}
-function getTabDebugContext(element, segment) {
-    if (!isTabDebuggingEnabled()) {
-        return undefined;
-    }
-    const elementWithMeta = element;
-    return {
-        elementId: elementWithMeta.id,
-        elementName: elementWithMeta.name,
-        segmentPreview: segment.text,
-    };
-}
-/**
- * Expand tabs in text with word spacing adjustment for accurate visual alignment.
- * This splits text at tab boundaries and calculates the wordSpacing needed to make
- * the replacement spaces render at exactly the right width to reach tab stops.
- *
- * @param text - Text containing tabs to expand
- * @param doc - PDFKit document for measuring text width
- * @param textOptions - PDFKit text options (font, size, etc.)
- * @param tabSizeInSpaces - Number of spaces per tab stop (default 8)
- * @param currentWidth - Current text width in points (default 0)
- * @returns Array of segments with expanded text and wordSpacing adjustments
- */
-function expandTabsWithWordSpacing(text, doc, textOptions, tabSizeInSpaces = 8, currentWidth = 0, debugContext) {
-    if (!text || !text.includes('\t')) {
-        // No tabs, return as-is
-        const width = currentWidth + doc.widthOfString(text, textOptions);
-        return {
-            segments: [{ type: 'text', text, wordSpacing: 0 }],
-            finalWidth: width,
-        };
-    }
-    // Measure the width of one space character (for rendering tab spaces)
-    const spaceWidth = doc.widthOfString(' ', textOptions);
-    const effectiveTabSize = getEffectiveTabSize(tabSizeInSpaces);
-    const tabStopWidth = Math.max(spaceWidth * effectiveTabSize, spaceWidth || 1);
-    const shouldLog = isTabDebuggingEnabled() && !!debugContext;
-    const segments = [];
-    let width = currentWidth;
-    let currentSegment = '';
-    for (let i = 0; i < text.length; i++) {
-        const char = text[i];
-        if (char === '\t') {
-            // Flush current segment if any
-            if (currentSegment) {
-                const segmentWidth = doc.widthOfString(currentSegment, textOptions);
-                segments.push({ type: 'text', text: currentSegment, wordSpacing: 0 });
-                width += segmentWidth;
-                currentSegment = '';
-            }
-            // Calculate the exact distance to next tab stop
-            const currentTabPosition = width % tabStopWidth;
-            const targetWidth = tabStopWidth - currentTabPosition;
-            const widthBeforeTab = width;
-            // Use a reasonable number of spaces (at least 1, usually 2-8)
-            const spacesNeeded = Math.max(1, Math.round(targetWidth / spaceWidth));
-            const spaces = ' '.repeat(spacesNeeded);
-            // Calculate the natural width of those spaces
-            const naturalWidth = doc.widthOfString(spaces, textOptions);
-            // Calculate wordSpacing adjustment to make spaces fill exact target width
-            // wordSpacing is added between words, and spaces count as word separators
-            // For N spaces, we have N-1 word boundaries, but PDFKit applies wordSpacing
-            // to each space character in the context of word separation
-            const wordSpacingAdjustment = spacesNeeded > 1
-                ? (targetWidth - naturalWidth) / (spacesNeeded - 1)
-                : 0;
-            if (shouldLog) {
-                console.log(`[polotno-tabs] element=${formatTabDebugLabel(debugContext)} text="${formatSegmentPreview(debugContext?.segmentPreview)}" startWidth=${widthBeforeTab.toFixed(2)} targetStop=${(widthBeforeTab + targetWidth).toFixed(2)} spaces=${spacesNeeded} naturalWidth=${naturalWidth.toFixed(2)} wordSpacing=${wordSpacingAdjustment.toFixed(4)}`);
-            }
-            // Emit a tab instruction so the renderer can manually reposition the cursor.
-            segments.push({
-                type: 'tab',
-                advanceWidth: widthBeforeTab + targetWidth,
-            });
-            width += targetWidth;
-        }
-        else if (char === '\n') {
-            // Flush current segment and add newline
-            if (currentSegment) {
-                const segmentWidth = doc.widthOfString(currentSegment, textOptions);
-                segments.push({ type: 'text', text: currentSegment, wordSpacing: 0 });
-                width += segmentWidth;
-                currentSegment = '';
-            }
-            segments.push({ type: 'text', text: '\n', wordSpacing: 0 });
-            width = 0; // Reset width on newline
-        }
-        else {
-            currentSegment += char;
-        }
-    }
-    // Flush remaining segment
-    if (currentSegment) {
-        const segmentWidth = doc.widthOfString(currentSegment, textOptions);
-        segments.push({ type: 'text', text: currentSegment, wordSpacing: 0 });
-        width += segmentWidth;
-    }
-    return { segments, finalWidth: width };
-}
-function decodeHtmlEntities(text) {
-    if (!text) {
-        return text;
-    }
-    const decoded = decodeEntities(text);
-    // Don't replace tabs here - we'll handle them with expandTabsToTabStops
-    return decoded;
-}
+import { stripHtml } from "string-strip-html";
 /**
  * Check if text contains HTML tags
  */
 function containsHTML(text) {
-    const htmlTagRegex = /<\/?(?:strong|b|em|i|u|span|p|br)[^>]*>/i;
+    const htmlTagRegex = /<\/?(?:strong|b|em|i|u|span)[^>]*>/i;
     return htmlTagRegex.test(text);
 }
-/**
- * Normalize rich text HTML by converting block-level line breaks into newline characters
- * while preserving inline formatting tags.
- */
-function normalizeRichText(text) {
-    if (!text) {
-        return text;
-    }
-    let normalized = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
-    // Convert explicit HTML break tags into newline characters
-    normalized = normalized.replace(/<br\s*\/?>/gi, '\n');
-    // Treat paragraph boundaries as newlines and drop opening tags
-    normalized = normalized.replace(/<\/p\s*>/gi, '\n');
-    normalized = normalized.replace(/<p[^>]*>/gi, '');
-    // Collapse excessive consecutive newlines produced by HTML cleanup
-    normalized = normalized.replace(/\n{3,}/g, '\n\n');
-    // Trim stray leading/trailing newlines introduced by paragraph conversion
-    normalized = normalized.replace(/^\n+/, '').replace(/\n+$/, '');
-    // NOTE: We do NOT expand tabs here anymore!
-    // Tab expansion is now handled in the rendering functions (renderTextFill, renderPDFX1aStroke, renderStandardStroke)
-    // using visual width measurements and wordSpacing adjustments for accurate alignment in proportional fonts.
-    // The old character-based expandTabsToTabStops() was incorrect for proportional fonts.
-    // Decode common HTML non-breaking space entities into their unicode counterpart
-    normalized = normalized.replace(/&(nbsp|#160|#xA0);/gi, '\u00A0');
-    // Strip zero-width characters that can create missing-glyph boxes in PDF output
-    normalized = normalized.replace(/[\u200B\u200C\u200D\uFEFF\u2060]/g, '');
-    return normalized;
-}
 /**
  * Parse HTML text into styled segments
  */
@@ -228,7 +20,7 @@ function parseHTMLToSegments(html, baseElement) {
     while ((match = regex.exec(html)) !== null) {
         if (match[4]) {
             // Text content
-            const text = decodeHtmlEntities(match[4]);
+            const text = match[4];
             // Calculate current styles from tag stack
             let bold = false;
             let italic = false;
@@ -249,7 +41,7 @@ function parseHTMLToSegments(html, baseElement) {
                 bold,
                 italic,
                 underline,
-                color,
+                color
             });
         }
         else {
@@ -259,7 +51,7 @@ function parseHTMLToSegments(html, baseElement) {
             const attributes = match[3];
             if (isClosing) {
                 // Remove from stack
-                const index = tagStack.findIndex((t) => t.tag === tagName);
+                const index = tagStack.findIndex(t => t.tag === tagName);
                 if (index !== -1) {
                     tagStack.splice(index, 1);
                 }
@@ -301,7 +93,7 @@ export async function getGoogleFontPath(fontFamily, fontWeight = 'normal', itali
     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);
+    const req = await fetchWithTimeout(url);
     if (!req.ok) {
         if (weight !== '400' || italic) {
             // Fallback: try normal weight without italic
@@ -313,18 +105,30 @@ export async function getGoogleFontPath(fontFamily, fontWeight = 'normal', itali
     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 text element or segment
+ * Load font for a rich text segment
  */
 async function loadFontForSegment(doc, segment, element, fonts) {
     const fontFamily = element.fontFamily;
-    // Determine bold/italic from segment or element
-    const bold = segment
-        ? segment.bold || element.fontWeight == 'bold' || false
-        : element.fontWeight == 'bold';
-    const italic = segment
-        ? segment.italic || element.fontStyle?.indexOf('italic') >= 0 || false
-        : element.fontStyle?.indexOf('italic') >= 0 || false;
+    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);
@@ -340,55 +144,6 @@ async function loadFontForSegment(doc, segment, element, fonts) {
     doc.font(fontKey);
     return fontKey;
 }
-// Alias for backward compatibility
-export async function loadFontIfNeeded(doc, element, fonts) {
-    return loadFontForSegment(doc, null, element, fonts);
-}
-async function buildRenderSegmentsForLine(doc, element, lineText, textOptions, fonts) {
-    const parsedSegments = parseHTMLToSegments(lineText, element);
-    let currentLineWidth = 0;
-    const renderSegments = [];
-    for (const segment of parsedSegments) {
-        const fontKey = await loadFontForSegment(doc, segment, element, fonts);
-        doc.font(fontKey);
-        doc.fontSize(element.fontSize);
-        if (segment.text.includes('\t')) {
-            const expanded = expandTabsWithWordSpacing(segment.text, doc, textOptions, 8, currentLineWidth, getTabDebugContext(element, segment));
-            currentLineWidth = expanded.finalWidth;
-            for (const tabSegment of expanded.segments) {
-                if (tabSegment.type === 'tab') {
-                    renderSegments.push({
-                        segment,
-                        fontKey,
-                        type: 'tab',
-                        advanceWidth: tabSegment.advanceWidth,
-                    });
-                }
-                else {
-                    renderSegments.push({
-                        segment,
-                        fontKey,
-                        type: 'text',
-                        text: tabSegment.text,
-                        wordSpacing: tabSegment.wordSpacing,
-                    });
-                }
-            }
-        }
-        else {
-            const segmentWidth = doc.widthOfString(segment.text, textOptions);
-            currentLineWidth += segmentWidth;
-            renderSegments.push({
-                segment,
-                fontKey,
-                type: 'text',
-                text: segment.text,
-                wordSpacing: 0,
-            });
-        }
-    }
-    return renderSegments;
-}
 /**
  * Parse HTML into tokens (text and tags)
  */
@@ -399,11 +154,9 @@ function tokenizeHTML(html) {
     while ((match = regex.exec(html)) !== null) {
         if (match[4]) {
             // Text content
-            const decodedContent = decodeHtmlEntities(match[4]);
             tokens.push({
                 type: 'text',
-                content: match[4],
-                decodedContent,
+                content: match[4]
             });
         }
         else {
@@ -414,257 +167,12 @@ function tokenizeHTML(html) {
                 type: 'tag',
                 content: match[0],
                 tagName: tagName,
-                isClosing: isClosing,
+                isClosing: isClosing
             });
         }
     }
     return tokens;
 }
-const VOID_ELEMENTS = new Set(['br']);
-function parseAttributes(raw) {
-    const attributes = {};
-    const attrRegex = /([^\s=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
-    let attrMatch;
-    while ((attrMatch = attrRegex.exec(raw)) !== null) {
-        const name = attrMatch[1].toLowerCase();
-        const value = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4] ?? '';
-        attributes[name] = value;
-    }
-    return attributes;
-}
-function parseSimpleHTML(html) {
-    const root = {
-        type: 'element',
-        tagName: 'root',
-        attributes: {},
-        children: [],
-    };
-    const stack = [root];
-    const tagRegex = /<\/?([a-zA-Z0-9:-]+)([^>]*)>/g;
-    let lastIndex = 0;
-    let match;
-    while ((match = tagRegex.exec(html)) !== null) {
-        if (match.index > lastIndex) {
-            const textContent = html.slice(lastIndex, match.index);
-            if (textContent) {
-                stack[stack.length - 1].children.push({
-                    type: 'text',
-                    content: textContent,
-                });
-            }
-        }
-        const fullMatch = match[0];
-        const isClosing = fullMatch.startsWith('</');
-        const tagName = match[1].toLowerCase();
-        const attrChunk = match[2] || '';
-        if (isClosing) {
-            for (let i = stack.length - 1; i >= 0; i--) {
-                if (stack[i].tagName === tagName) {
-                    stack.length = i;
-                    break;
-                }
-            }
-        }
-        else {
-            const attributes = parseAttributes(attrChunk);
-            const elementNode = {
-                type: 'element',
-                tagName,
-                attributes,
-                children: [],
-            };
-            const parent = stack[stack.length - 1];
-            parent.children.push(elementNode);
-            const selfClosing = fullMatch.endsWith('/>') || VOID_ELEMENTS.has(tagName);
-            if (!selfClosing) {
-                stack.push(elementNode);
-            }
-        }
-        lastIndex = tagRegex.lastIndex;
-    }
-    if (lastIndex < html.length) {
-        const remaining = html.slice(lastIndex);
-        if (remaining) {
-            stack[stack.length - 1].children.push({
-                type: 'text',
-                content: remaining,
-            });
-        }
-    }
-    return root;
-}
-function serializeAttributes(attributes) {
-    const entries = Object.entries(attributes);
-    if (!entries.length) {
-        return '';
-    }
-    return (' ' +
-        entries
-            .map(([key, value]) => value === '' ? key : `${key}="${value.replace(/"/g, '&quot;')}"`)
-            .join(' '));
-}
-function shouldSkipNode(node) {
-    if (node.type === 'element' && node.tagName === 'span') {
-        const classAttr = node.attributes['class'] || node.attributes['className'] || '';
-        if (/\bql-cursor\b/.test(classAttr)) {
-            return true;
-        }
-    }
-    return false;
-}
-function serializeNodes(nodes) {
-    return nodes
-        .map((node) => {
-        if (shouldSkipNode(node)) {
-            return '';
-        }
-        if (node.type === 'text') {
-            return node.content.replace(/\uFEFF/g, '');
-        }
-        const attrs = serializeAttributes(node.attributes);
-        if (VOID_ELEMENTS.has(node.tagName)) {
-            return `<${node.tagName}${attrs}>`;
-        }
-        return `<${node.tagName}${attrs}>${serializeNodes(node.children)}</${node.tagName}>`;
-    })
-        .join('');
-}
-function getIndentLevelFromAttributes(attributes) {
-    const classAttr = attributes['class'] || attributes['className'] || '';
-    const match = classAttr.match(/ql-indent-(\d+)/);
-    return match ? parseInt(match[1], 10) : 0;
-}
-function detectIndentLevel(node) {
-    const directIndent = getIndentLevelFromAttributes(node.attributes);
-    if (directIndent > 0) {
-        return directIndent;
-    }
-    for (const child of node.children) {
-        if (child.type === 'element' &&
-            child.tagName !== 'ul' &&
-            child.tagName !== 'ol') {
-            const childIndent = detectIndentLevel(child);
-            if (childIndent > 0) {
-                return childIndent;
-            }
-        }
-    }
-    return 0;
-}
-function nodesToParagraphs(nodes, baseIndentLevel = 0) {
-    const paragraphs = [];
-    let pendingInline = [];
-    const flushInline = () => {
-        if (pendingInline.length === 0) {
-            return;
-        }
-        const html = serializeNodes(pendingInline);
-        paragraphs.push({ html });
-        pendingInline = [];
-    };
-    for (const node of nodes) {
-        if (shouldSkipNode(node)) {
-            continue;
-        }
-        if (node.type === 'text') {
-            const newlineRegex = /\n+/g;
-            let lastIndex = 0;
-            let match;
-            while ((match = newlineRegex.exec(node.content)) !== null) {
-                const chunk = node.content.slice(lastIndex, match.index);
-                if (chunk.length > 0) {
-                    pendingInline.push({
-                        type: 'text',
-                        content: chunk,
-                    });
-                }
-                flushInline();
-                const extraBreaks = match[0].length - 1;
-                for (let extra = 0; extra < extraBreaks; extra++) {
-                    paragraphs.push({ html: '' });
-                }
-                lastIndex = newlineRegex.lastIndex;
-            }
-            const rest = node.content.slice(lastIndex);
-            if (rest.length > 0) {
-                pendingInline.push({
-                    type: 'text',
-                    content: rest,
-                });
-            }
-            continue;
-        }
-        if (node.tagName === 'p') {
-            flushInline();
-            const html = serializeNodes(node.children);
-            paragraphs.push({
-                html,
-            });
-            continue;
-        }
-        if (node.tagName === 'br') {
-            flushInline();
-            paragraphs.push({ html: '' });
-            continue;
-        }
-        if (node.tagName === 'ul' || node.tagName === 'ol') {
-            flushInline();
-            paragraphs.push(...collectListParagraphs(node, baseIndentLevel));
-            continue;
-        }
-        pendingInline.push(node);
-    }
-    flushInline();
-    return paragraphs;
-}
-function collectListParagraphs(listNode, baseIndentLevel) {
-    const paragraphs = [];
-    const listIndent = baseIndentLevel + getIndentLevelFromAttributes(listNode.attributes);
-    let counter = 1;
-    for (const child of listNode.children) {
-        if (child.type !== 'element' || child.tagName !== 'li') {
-            continue;
-        }
-        const liIndentFromAttribute = getIndentLevelFromAttributes(child.attributes);
-        const detectedIndent = detectIndentLevel(child);
-        const indentLevel = liIndentFromAttribute > 0
-            ? listIndent + liIndentFromAttribute
-            : listIndent + detectedIndent;
-        const itemParagraphs = nodesToParagraphs(child.children, indentLevel);
-        let markerAssigned = false;
-        for (const paragraph of itemParagraphs) {
-            if (!paragraph.listMeta) {
-                paragraph.listMeta = {
-                    type: listNode.tagName,
-                    index: counter,
-                    indentLevel,
-                    displayMarker: !markerAssigned,
-                };
-                markerAssigned = true;
-            }
-            paragraphs.push(paragraph);
-        }
-        if (!markerAssigned) {
-            paragraphs.push({
-                html: '',
-                listMeta: {
-                    type: listNode.tagName,
-                    index: counter,
-                    indentLevel,
-                    displayMarker: true,
-                },
-            });
-        }
-        if (listNode.tagName === 'ol') {
-            counter += 1;
-        }
-    }
-    return paragraphs;
-}
-function parseHtmlToParagraphs(html) {
-    const root = parseSimpleHTML(html);
-    return nodesToParagraphs(root.children);
-}
 /**
  * Reconstruct HTML from tokens while maintaining proper tag nesting across line breaks
  * @param tokens - Array of parsed HTML tokens
@@ -687,7 +195,7 @@ function tokensToHTML(tokens, openTags) {
             html += token.content;
             if (token.isClosing) {
                 // Remove from stack
-                const idx = tagStack.findIndex((t) => t.name === token.tagName);
+                const idx = tagStack.findIndex(t => t.name === token.tagName);
                 if (idx !== -1) {
                     tagStack.splice(idx, 1);
                 }
@@ -696,7 +204,7 @@ function tokensToHTML(tokens, openTags) {
                 // Add to stack
                 tagStack.push({
                     name: token.tagName,
-                    fullTag: token.content,
+                    fullTag: token.content
                 });
             }
         }
@@ -711,84 +219,26 @@ function tokensToHTML(tokens, openTags) {
  * 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 cloneListMetaForLine(meta, showMarker) {
-    if (!meta) {
-        return undefined;
-    }
-    return {
-        ...meta,
-        showMarker,
-    };
-}
-function createListLineMeta(doc, element, props, paragraphMeta) {
-    const indentPx = paragraphMeta.indentLevel * element.fontSize * 0.5;
-    const markerText = paragraphMeta.type === 'ul' ? '•' : `${paragraphMeta.index.toString()}.`;
-    const previousFontSize = doc._fontSize !== undefined
-        ? doc._fontSize
-        : element.fontSize;
-    const markerFontSize = paragraphMeta.type === 'ul' ? element.fontSize * 1.2 : element.fontSize;
-    doc.fontSize(markerFontSize);
-    const markerLabelWidth = doc.widthOfString(markerText, {
-        ...props,
-        width: undefined,
-    });
-    doc.fontSize(previousFontSize);
-    const markerGapPx = element.fontSize * (paragraphMeta.type === 'ul' ? 1.5 : 0.8);
-    const markerBoxMinPx = element.fontSize * (paragraphMeta.type === 'ul' ? 2.5 : 2.8);
-    const markerBoxWidth = Math.max(markerLabelWidth + markerGapPx, markerBoxMinPx);
-    const textStartPx = indentPx + markerBoxWidth;
-    return {
-        type: paragraphMeta.type,
-        markerText,
-        indentPx,
-        markerBoxWidth,
-        markerFontSize,
-        markerAlignment: paragraphMeta.type === 'ul' ? 'center' : 'right',
-        showMarker: paragraphMeta.displayMarker,
-        textStartPx,
-    };
-}
 function splitTextIntoLines(doc, element, props) {
     const lines = [];
-    const rawText = typeof element.text === 'string'
-        ? element.text
-        : String(element.text ?? '');
-    const paragraphs = parseHtmlToParagraphs(rawText);
-    if (paragraphs.length === 0) {
-        paragraphs.push({ html: '' });
-    }
+    const paragraphs = element.text.split('\n');
     for (const paragraph of paragraphs) {
         // Tokenize the paragraph
-        const tokens = tokenizeHTML(paragraph.html);
+        const tokens = tokenizeHTML(paragraph);
         // Extract plain text for width calculation
-        // Expand tabs to tab stops for accurate width measurement
-        const plainText = expandTabsToTabStops(tokens
-            .filter((t) => t.type === 'text')
-            .map((t) => t.decodedContent ?? decodeHtmlEntities(t.content))
-            .join(''), 8);
-        const baseMeta = paragraph.listMeta
-            ? createListLineMeta(doc, element, props, paragraph.listMeta)
-            : undefined;
-        const availableWidthRaw = element.width - (baseMeta ? baseMeta.textStartPx : 0);
-        const availableWidth = element.align === 'justify'
-            ? Math.max(availableWidthRaw, 1)
-            : Math.max(availableWidthRaw, element.width * 0.1, 1);
+        const plainText = tokens
+            .filter(t => t.type === 'text')
+            .map(t => t.content)
+            .join('');
         const paragraphWidth = doc.widthOfString(plainText, props);
-        let showMarkerForLine = baseMeta?.showMarker ?? false;
         // Justify alignment using native pdfkit instruments
-        if (paragraphWidth <= availableWidth || element.align === 'justify') {
+        if (paragraphWidth <= element.width || element.align === 'justify') {
             // Paragraph fits on one line
-            const listMeta = cloneListMetaForLine(baseMeta, showMarkerForLine);
-            lines.push({
-                text: paragraph.html,
-                width: paragraphWidth,
-                fullWidth: paragraphWidth + (listMeta ? listMeta.textStartPx : 0),
-                listMeta,
-            });
+            lines.push({ text: paragraph, width: paragraphWidth });
         }
         else {
             // Need to split paragraph into multiple lines
-            let currentLineDecoded = '';
+            let currentLine = '';
             let currentWidth = 0;
             let currentTokens = [];
             let openTags = [];
@@ -798,215 +248,75 @@ function splitTextIntoLines(doc, element, props) {
                     continue;
                 }
                 // Text token - split by words
-                // Don't expand tabs here - we need to preserve tabs for proper alignment
-                const rawWords = token.content.split(' ');
-                const decodedText = token.decodedContent ?? decodeHtmlEntities(token.content);
-                const decodedWords = decodedText.split(' ');
-                for (let i = 0; i < rawWords.length; i++) {
-                    const rawWord = rawWords[i];
-                    const decodedWord = decodedWords[i] ?? decodeHtmlEntities(rawWord);
-                    const separator = i > 0 ? ' ' : '';
-                    const hasCurrentLine = currentLineDecoded.length > 0;
-                    const testLineDecoded = hasCurrentLine
-                        ? `${currentLineDecoded}${separator}${decodedWord}`
-                        : decodedWord;
-                    // Expand tabs in test line for accurate width measurement
-                    // Tabs are expanded based on the full line position, maintaining tab stop alignment
-                    const testLineExpanded = expandTabsToTabStops(testLineDecoded, 8);
-                    const testWidth = doc.widthOfString(testLineExpanded, props);
-                    if (testWidth <= availableWidth) {
-                        currentLineDecoded = testLineDecoded;
+                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)
-                        const rawContent = separator.length > 0 ? `${separator}${rawWord}` : rawWord;
-                        const decodedContent = separator.length > 0 ? `${separator}${decodedWord}` : decodedWord;
-                        currentTokens.push({
-                            type: 'text',
-                            content: rawContent,
-                            decodedContent,
-                        });
+                        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 (currentLineDecoded.length > 0) {
+                        if (currentLine) {
                             const result = tokensToHTML(currentTokens, openTags);
-                            const listMeta = cloneListMetaForLine(baseMeta, showMarkerForLine);
-                            lines.push({
-                                text: result.html,
-                                width: currentWidth,
-                                fullWidth: currentWidth + (listMeta ? listMeta.textStartPx : 0),
-                                listMeta,
-                            });
+                            lines.push({ text: result.html, width: currentWidth });
                             openTags = result.openTags;
                             currentTokens = [];
-                            showMarkerForLine = false;
                         }
-                        currentLineDecoded = decodedWord;
-                        // Expand tabs for accurate width measurement
-                        const decodedWordExpanded = expandTabsToTabStops(decodedWord, 8);
-                        currentWidth = doc.widthOfString(decodedWordExpanded, props);
+                        currentLine = word;
+                        currentWidth = doc.widthOfString(word, props);
                         currentTokens.push({
                             type: 'text',
-                            content: rawWord,
-                            decodedContent: decodedWord,
+                            content: word
                         });
                     }
                 }
             }
             // Add the last line
-            if (currentLineDecoded.length > 0) {
+            if (currentLine) {
                 const result = tokensToHTML(currentTokens, openTags);
-                const listMeta = cloneListMetaForLine(baseMeta, showMarkerForLine);
-                lines.push({
-                    text: result.html,
-                    width: currentWidth,
-                    fullWidth: currentWidth + (listMeta ? listMeta.textStartPx : 0),
-                    listMeta,
-                });
-            }
-            else if (currentTokens.length === 0) {
-                // Handle case when paragraph becomes empty after wrapping logic
-                const listMeta = cloneListMetaForLine(baseMeta, showMarkerForLine);
-                lines.push({
-                    text: '',
-                    width: 0,
-                    fullWidth: listMeta ? listMeta.textStartPx : 0,
-                    listMeta,
-                });
+                lines.push({ text: result.html, width: currentWidth });
             }
         }
     }
     return lines;
 }
 /**
- * Calculate X offset for list markers (not used for text content positioning)
+ * 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, line) {
-    // Markers are always at the left edge, regardless of text alignment
-    if (line.listMeta) {
-        return 0;
-    }
-    // For non-list lines, markers follow text alignment
+function calculateLineXOffset(element, lineWidth) {
     const align = element.align;
-    const targetWidth = line.width;
     if (align === 'right') {
-        return element.width - targetWidth;
+        return element.width - lineWidth;
     }
     else if (align === 'center') {
-        return (element.width - targetWidth) / 2;
-    }
-    // left or justify: markers at position 0
-    return 0;
-}
-function calculateTextContentXOffset(element, line) {
-    const align = element.align;
-    const textWidth = line.width;
-    const baseStart = line.listMeta?.textStartPx ?? 0;
-    const availableWidth = Math.max(element.width - baseStart, 0);
-    if (align === 'right') {
-        return baseStart + Math.max(availableWidth - textWidth, 0);
-    }
-    else if (align === 'center') {
-        return baseStart + Math.max((availableWidth - textWidth) / 2, 0);
-    }
-    return baseStart;
-}
-/**
- * Calculate effective width for text rendering, considering justify and underline constraints
- */
-function calculateEffectiveWidth(element, line, widthOption, hasUnderline) {
-    if (widthOption !== undefined) {
-        return widthOption;
-    }
-    if (hasUnderline) {
-        return element.width;
+        return (element.width - lineWidth) / 2;
     }
-    return undefined;
-}
-/**
- * Prepare rendering context for a line (calculates positions, widths, handles markers)
- */
-async function prepareLineForRendering(doc, element, line, lineIndex, yOffset, lineHeightPx, cumulativeYOffset, textOptions, fonts, markerColor, markerOpacity, markerMode) {
-    const markerXOffset = calculateLineXOffset(element, line);
-    const lineYOffset = yOffset + cumulativeYOffset;
-    const strippedLineText = stripHtml(line.text).result;
-    const heightOfLine = line.text === ''
-        ? lineHeightPx
-        : doc.heightOfString(strippedLineText, textOptions);
-    const contentStartX = calculateTextContentXOffset(element, line);
-    const isJustify = element.align === 'justify';
-    // Disable justification if line contains tabs - tabs position content precisely,
-    // and justification would interfere by spreading spaces
-    const hasTabs = line.text.includes('\t');
-    const widthOption = isJustify && !hasTabs
-        ? Math.max(element.width - (line.listMeta ? line.listMeta.textStartPx : 0), 1)
-        : undefined;
-    // Handle list markers if needed
-    if (line.listMeta?.showMarker) {
-        await drawListMarker(doc, element, line, markerXOffset, lineYOffset, fonts, markerColor, markerOpacity, markerMode, textOptions);
-        // Restore color after drawing marker (marker may have changed the color state)
-        if (markerMode === 'fill') {
-            doc.fillColor(markerColor, markerOpacity);
-        }
-        else {
-            doc.strokeColor(markerColor, markerOpacity);
-        }
-    }
-    return {
-        markerXOffset,
-        lineYOffset,
-        contentStartX,
-        widthOption,
-        heightOfLine,
-    };
-}
-/**
- * Render segments for a line with flexible options for different rendering modes
- */
-async function renderSegmentsForLine(doc, element, line, renderSegments, context, textOptions, options) {
-    const { mode, color, opacity = element.opacity, heightOfLine, offsetX = 0, offsetY = 0, applySegmentColor, } = options;
-    const totalTextSegments = renderSegments.filter((seg) => seg.type === 'text').length;
-    let processedTextSegments = 0;
-    // Position cursor at line start (with optional offset)
-    doc.x = context.contentStartX + offsetX;
-    doc.y = context.lineYOffset + offsetY;
-    for (const renderSegment of renderSegments) {
-        if (renderSegment.type === 'tab') {
-            const advanceWidth = renderSegment.advanceWidth ?? 0;
-            doc.x = context.contentStartX + advanceWidth + offsetX;
-            continue;
-        }
-        const { segment, text = '', wordSpacing = 0, fontKey } = renderSegment;
-        processedTextSegments += 1;
-        const isLastSegment = processedTextSegments === totalTextSegments;
-        doc.font(fontKey);
-        doc.fontSize(element.fontSize);
-        // Apply color (either segment-specific or global)
-        if (applySegmentColor) {
-            applySegmentColor(segment);
-        }
-        else if (color) {
-            if (mode === 'fill') {
-                doc.fillColor(color, opacity);
-            }
-            else {
-                doc.strokeColor(color, opacity);
-            }
-        }
-        const hasUnderline = segment.underline || textOptions.underline || false;
-        const effectiveWidth = calculateEffectiveWidth(element, line, context.widthOption, hasUnderline);
-        doc.text(text, {
-            ...textOptions,
-            width: effectiveWidth,
-            height: heightOfLine,
-            continued: !isLastSegment,
-            underline: hasUnderline,
-            lineBreak: hasUnderline,
-            stroke: mode === 'stroke',
-            fill: mode === 'fill',
-            wordSpacing,
-        });
+    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
@@ -1023,15 +333,14 @@ function calculateTextMetrics(doc, element) {
             : 0,
         lineBreak: false,
         stroke: false,
-        fill: 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;
+    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;
@@ -1040,7 +349,7 @@ function calculateTextMetrics(doc, element) {
         textOptions,
         lineHeightPx: lineHeight,
         baselineOffset,
-        textLines,
+        textLines
     };
 }
 /**
@@ -1082,8 +391,7 @@ function renderTextBackground(doc, element, verticalAlignmentOffset, textOptions
     }
     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 cornerRadius = element.backgroundCornerRadius * (element.fontSize * element.lineHeight * 0.5);
     const textWidth = doc.widthOfString(strippedContent, {
         ...textOptions,
         width: element.width,
@@ -1108,45 +416,14 @@ function renderTextBackground(doc, element, verticalAlignmentOffset, textOptions
     doc.fill();
     doc.fillColor(parseColor(element.fill).hex, element.opacity);
 }
-async function drawListMarker(doc, element, line, lineXOffset, lineYOffset, fonts, color, opacity, mode, textOptions) {
-    if (!line.listMeta || !line.listMeta.showMarker) {
-        return;
-    }
-    const markerSegment = {
-        text: line.listMeta.markerText,
-    };
-    const fontKey = await loadFontForSegment(doc, markerSegment, element, fonts);
-    const previousFontSize = doc._fontSize !== undefined
-        ? doc._fontSize
-        : element.fontSize;
-    doc.font(fontKey);
-    doc.fontSize(line.listMeta.markerFontSize);
-    if (mode === 'fill') {
-        doc.fillColor(color, opacity);
-    }
-    else {
-        doc.strokeColor(color, opacity);
-    }
-    doc.text(line.listMeta.markerText, lineXOffset + line.listMeta.indentPx, lineYOffset, {
-        ...textOptions,
-        width: line.listMeta.markerBoxWidth,
-        align: line.listMeta.markerAlignment,
-        continued: false,
-        lineBreak: false,
-        underline: false,
-        characterSpacing: 0,
-        stroke: mode === 'stroke',
-        fill: mode === 'fill',
-    });
-    doc.fontSize(previousFontSize);
-}
 /**
  * Render text stroke using PDF/X-1a compatible method (multiple offset fills)
  */
-async function renderPDFX1aStroke(doc, element, textLines, yOffset, lineHeightPx, textOptions, fonts) {
+function renderPDFX1aStroke(doc, element, textLines, yOffset, lineHeightPx, textOptions) {
     const strokeColor = parseColor(element.stroke).hex;
     const strokeWidth = element.strokeWidth;
-    // Generate stroke offsets in a circle pattern (8 directions)
+    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;
@@ -1160,46 +437,55 @@ async function renderPDFX1aStroke(doc, element, textLines, yOffset, lineHeightPx
     doc.fillColor(strokeColor, element.opacity);
     for (let i = 0; i < textLines.length; i++) {
         const line = textLines[i];
-        const context = await prepareLineForRendering(doc, element, line, i, yOffset, lineHeightPx, i * lineHeightPx, textOptions, fonts, strokeColor, element.opacity, 'fill');
-        const renderSegments = await buildRenderSegmentsForLine(doc, element, line.text, textOptions, fonts);
-        // Render with each offset to create stroke effect
+        const lineXOffset = calculateLineXOffset(element, line.width);
+        const lineYOffset = yOffset + (i * lineHeightPx);
         for (const offset of offsets) {
-            doc.text('', context.contentStartX + offset.x, context.lineYOffset + offset.y, {
-                height: 0,
-                width: 0,
-            });
-            await renderSegmentsForLine(doc, element, line, renderSegments, context, textOptions, {
-                mode: 'fill',
-                color: strokeColor,
-                opacity: element.opacity,
-                offsetX: offset.x,
-                offsetY: offset.y,
+            doc.text(line.text, lineXOffset + offset.x, lineYOffset + offset.y, {
+                ...textOptions,
+                width: isJustify ? element.width : undefined,
+                stroke: false,
             });
         }
     }
     doc.restore();
-    await renderTextFill(doc, element, textLines, yOffset, lineHeightPx, textOptions, fonts);
+    // Render fill layer on top
+    doc.fillColor(parseColor(element.fill).hex, element.opacity);
+    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
  */
-async function renderStandardStroke(doc, element, textLines, yOffset, lineHeightPx, textOptions, fonts) {
-    const strokeParsedColor = parseColor(element.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(strokeParsedColor.hex, element.opacity);
+    doc.strokeColor(parseColor(element.stroke).hex, element.opacity);
     let cumulativeYOffset = 0;
     for (let i = 0; i < textLines.length; i++) {
         const line = textLines[i];
-        const context = await prepareLineForRendering(doc, element, line, i, yOffset, lineHeightPx, cumulativeYOffset, textOptions, fonts, strokeParsedColor.hex, element.opacity, 'stroke');
-        cumulativeYOffset += context.heightOfLine;
-        const renderSegments = await buildRenderSegmentsForLine(doc, element, line.text, textOptions, fonts);
-        await renderSegmentsForLine(doc, element, line, renderSegments, context, textOptions, {
-            mode: 'stroke',
-            color: strokeParsedColor.hex,
-            opacity: element.opacity,
-            heightOfLine: context.heightOfLine,
+        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();
@@ -1214,14 +500,29 @@ async function renderTextFill(doc, element, textLines, yOffset, lineHeightPx, te
     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 context = await prepareLineForRendering(doc, element, line, i, yOffset, lineHeightPx, cumulativeYOffset, textOptions, fonts, baseParsedColor.hex, baseOpacity, 'fill');
-        cumulativeYOffset += context.heightOfLine;
-        const renderSegments = await buildRenderSegmentsForLine(doc, element, line.text, textOptions, fonts);
-        // Apply segment-specific colors for rich text
-        const applySegmentColor = (segment) => {
+        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;
@@ -1230,48 +531,46 @@ async function renderTextFill(doc, element, textLines, yOffset, lineHeightPx, te
                 : parseColor(element.fill);
             const segmentOpacity = Math.min(segmentParsedColor.rgba[3] ?? 1, element.opacity, 1);
             doc.fillColor(segmentColor, segmentOpacity);
-        };
-        await renderSegmentsForLine(doc, element, line, renderSegments, context, textOptions, {
-            mode: 'fill',
-            heightOfLine: context.heightOfLine,
-            applySegmentColor,
-        });
+            // 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 = {}) {
-    const normalizedText = typeof element.text === 'string'
-        ? normalizeRichText(element.text)
-        : element.text;
-    const elementToRender = typeof element.text === 'string' && normalizedText !== element.text
-        ? { ...element, text: normalizedText }
-        : element;
-    doc.fontSize(elementToRender.fontSize);
-    const hasStroke = elementToRender.strokeWidth > 0;
+    doc.fontSize(element.fontSize);
+    const hasStroke = element.strokeWidth > 0;
     const isPDFX1a = attrs.pdfx1a;
     // Calculate text metrics and line positioning
-    const metrics = calculateTextMetrics(doc, elementToRender);
-    const verticalAlignmentOffset = calculateVerticalAlignment(doc, elementToRender, metrics.textOptions);
+    const metrics = calculateTextMetrics(doc, element);
+    const verticalAlignmentOffset = calculateVerticalAlignment(doc, element, metrics.textOptions);
     // Fit text to element height if needed
-    fitTextToHeight(doc, elementToRender, metrics.textOptions);
+    fitTextToHeight(doc, element, metrics.textOptions);
     // Calculate final vertical offset
     const finalYOffset = verticalAlignmentOffset + metrics.baselineOffset;
     // Render background if enabled
-    renderTextBackground(doc, elementToRender, verticalAlignmentOffset, metrics.textOptions);
+    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
-        await renderPDFX1aStroke(doc, elementToRender, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions, fonts);
+        renderPDFX1aStroke(doc, element, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions);
     }
     else {
         // Standard rendering: stroke first, then fill
         if (hasStroke) {
-            await renderStandardStroke(doc, elementToRender, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions, fonts);
+            renderStandardStroke(doc, element, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions);
         }
-        await renderTextFill(doc, elementToRender, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions, fonts);
+        await renderTextFill(doc, element, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions, fonts);
     }
 }
-// Internal exports for testing
-export { normalizeRichText as __normalizeRichTextForTests, parseHTMLToSegments as __parseHTMLToSegmentsForTests, };