@polotno/pdf-export 0.1.24 → 0.1.26

package/lib/text.js

@@ -194,6 +194,251 @@ function tokenizeHTML(html) {
     }
     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
@@ -240,22 +485,79 @@ 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 paragraphs = element.text.split('\n');
+    const rawText = typeof element.text === 'string'
+        ? element.text
+        : String(element.text ?? '');
+    const paragraphs = parseHtmlToParagraphs(rawText);
+    if (paragraphs.length === 0) {
+        paragraphs.push({ html: '' });
+    }
     for (const paragraph of paragraphs) {
         // Tokenize the paragraph
-        const tokens = tokenizeHTML(paragraph);
+        const tokens = tokenizeHTML(paragraph.html);
         // Extract plain text for width calculation
         const plainText = tokens
             .filter((t) => t.type === 'text')
             .map((t) => t.content)
             .join('');
+        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 paragraphWidth = doc.widthOfString(plainText, props);
+        let showMarkerForLine = baseMeta?.showMarker ?? false;
         // Justify alignment using native pdfkit instruments
-        if (paragraphWidth <= element.width || element.align === 'justify') {
+        if (paragraphWidth <= availableWidth || element.align === 'justify') {
             // Paragraph fits on one line
-            lines.push({ text: paragraph, width: paragraphWidth });
+            const listMeta = cloneListMetaForLine(baseMeta, showMarkerForLine);
+            lines.push({
+                text: paragraph.html,
+                width: paragraphWidth,
+                fullWidth: paragraphWidth + (listMeta ? listMeta.textStartPx : 0),
+                listMeta,
+            });
         }
         else {
             // Need to split paragraph into multiple lines
@@ -276,7 +578,7 @@ function splitTextIntoLines(doc, element, props) {
                         ? `${currentLine}${i > 0 ? ' ' : ''}${word}`
                         : word;
                     const testWidth = doc.widthOfString(testLine, props);
-                    if (testWidth <= element.width) {
+                    if (testWidth <= availableWidth) {
                         currentLine = testLine;
                         currentWidth = testWidth;
                         // Add text token (with space if not first word in token)
@@ -298,9 +600,16 @@ function splitTextIntoLines(doc, element, props) {
                         // 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 });
+                            const listMeta = cloneListMetaForLine(baseMeta, showMarkerForLine);
+                            lines.push({
+                                text: result.html,
+                                width: currentWidth,
+                                fullWidth: currentWidth + (listMeta ? listMeta.textStartPx : 0),
+                                listMeta,
+                            });
                             openTags = result.openTags;
                             currentTokens = [];
+                            showMarkerForLine = false;
                         }
                         currentLine = word;
                         currentWidth = doc.widthOfString(word, props);
@@ -314,7 +623,23 @@ function splitTextIntoLines(doc, element, props) {
             // Add the last line
             if (currentLine) {
                 const result = tokensToHTML(currentTokens, openTags);
-                lines.push({ text: result.html, width: currentWidth });
+                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,
+                });
             }
         }
     }
@@ -326,21 +651,49 @@ function splitTextIntoLines(doc, element, props) {
  * @param lineWidth - Width of the current line
  * @returns X offset for positioning the line
  */
-function calculateLineXOffset(element, lineWidth) {
+function calculateLineXOffset(element, line) {
+    if (line.listMeta) {
+        return 0;
+    }
     const align = element.align;
+    const targetWidth = line.width;
     if (align === 'right') {
-        return element.width - lineWidth;
+        return element.width - targetWidth;
     }
     else if (align === 'center') {
-        return (element.width - lineWidth) / 2;
+        return (element.width - targetWidth) / 2;
     }
     else if (align === 'justify') {
-        // Justify alignment is handled by PDFKit's align property
         return 0;
     }
-    // Default: left alignment
     return 0;
 }
+function calculateTextContentXOffset(element, line) {
+    const align = element.align;
+    const textWidth = line.width;
+    if (!line.listMeta) {
+        if (align === 'right') {
+            return element.width - textWidth;
+        }
+        else if (align === 'center') {
+            return (element.width - textWidth) / 2;
+        }
+        else {
+            return 0;
+        }
+    }
+    const baseStart = line.listMeta.textStartPx;
+    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);
+    }
+    else {
+        return baseStart;
+    }
+}
 /**
  * Calculate text rendering metrics including line height and baseline offset
  */
@@ -441,10 +794,42 @@ 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)
  */
-function renderPDFX1aStroke(doc, element, textLines, yOffset, lineHeightPx, textOptions) {
+async function renderPDFX1aStroke(doc, element, textLines, yOffset, lineHeightPx, textOptions, fonts) {
     const strokeColor = parseColor(element.stroke).hex;
     const strokeWidth = element.strokeWidth;
     const isJustify = element.align === 'justify';
@@ -462,56 +847,89 @@ function renderPDFX1aStroke(doc, element, textLines, yOffset, lineHeightPx, text
     doc.fillColor(strokeColor, element.opacity);
     for (let i = 0; i < textLines.length; i++) {
         const line = textLines[i];
-        const lineXOffset = calculateLineXOffset(element, line.width);
+        const markerXOffset = calculateLineXOffset(element, line);
         const lineYOffset = yOffset + i * lineHeightPx;
+        const contentStartX = calculateTextContentXOffset(element, line);
+        const widthOption = isJustify
+            ? Math.max(element.width - (line.listMeta ? line.listMeta.textStartPx : 0), 1)
+            : undefined;
+        if (line.listMeta?.showMarker) {
+            await drawListMarker(doc, element, line, markerXOffset, lineYOffset, fonts, strokeColor, element.opacity, 'fill', textOptions);
+            doc.fillColor(strokeColor, element.opacity);
+        }
         for (const offset of offsets) {
-            doc.text(line.text, lineXOffset + offset.x, lineYOffset + offset.y, {
-                ...textOptions,
-                width: isJustify ? element.width : undefined,
-                stroke: false,
+            doc.text('', contentStartX + offset.x, lineYOffset + offset.y, {
+                height: 0,
+                width: 0,
             });
+            const segments = parseHTMLToSegments(line.text, element);
+            for (let segmentIndex = 0; segmentIndex < segments.length; segmentIndex++) {
+                const segment = segments[segmentIndex];
+                const fontKey = await loadFontForSegment(doc, segment, element, fonts);
+                doc.font(fontKey);
+                doc.fontSize(element.fontSize);
+                doc.text(segment.text, {
+                    ...textOptions,
+                    width: widthOption,
+                    stroke: false,
+                    fill: true,
+                    continued: segmentIndex !== segments.length - 1,
+                    underline: segment.underline || textOptions.underline || false,
+                    lineBreak: !!segment.underline,
+                });
+            }
         }
     }
     doc.restore();
-    // 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,
-        });
-    }
+    await renderTextFill(doc, element, textLines, yOffset, lineHeightPx, textOptions, fonts);
 }
 /**
  * Render text stroke using standard PDF stroke
  */
-function renderStandardStroke(doc, element, textLines, yOffset, lineHeightPx, textOptions) {
+async function renderStandardStroke(doc, element, textLines, yOffset, lineHeightPx, textOptions, fonts) {
     const isJustify = element.align === 'justify';
+    const strokeParsedColor = parseColor(element.stroke);
     doc.save();
     doc.lineWidth(element.strokeWidth);
     doc.lineCap('round').lineJoin('round');
-    doc.strokeColor(parseColor(element.stroke).hex, element.opacity);
+    doc.strokeColor(strokeParsedColor.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 markerXOffset = calculateLineXOffset(element, line);
         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,
-        });
+        const contentStartX = calculateTextContentXOffset(element, line);
+        const widthOption = isJustify
+            ? Math.max(element.width - (line.listMeta ? line.listMeta.textStartPx : 0), 1)
+            : undefined;
+        if (line.listMeta?.showMarker) {
+            await drawListMarker(doc, element, line, markerXOffset, lineYOffset, fonts, strokeParsedColor.hex, element.opacity, 'stroke', textOptions);
+            doc.strokeColor(strokeParsedColor.hex, element.opacity);
+        }
+        doc.text('', contentStartX, lineYOffset, { height: 0, width: 0 });
+        const segments = parseHTMLToSegments(line.text, element);
+        for (let segmentIndex = 0; segmentIndex < segments.length; segmentIndex++) {
+            const segment = segments[segmentIndex];
+            const fontKey = await loadFontForSegment(doc, segment, element, fonts);
+            doc.font(fontKey);
+            doc.fontSize(element.fontSize);
+            doc.strokeColor(strokeParsedColor.hex, element.opacity);
+            doc.text(segment.text, {
+                ...textOptions,
+                width: widthOption,
+                height: heightOfLine,
+                continued: segmentIndex !== segments.length - 1,
+                stroke: true,
+                fill: false,
+                underline: segment.underline || textOptions.underline || false,
+                lineBreak: !!segment.underline,
+            });
+        }
     }
     doc.restore();
 }
@@ -529,15 +947,23 @@ async function renderTextFill(doc, element, textLines, yOffset, lineHeightPx, te
     let cumulativeYOffset = 0;
     for (let i = 0; i < textLines.length; i++) {
         const line = textLines[i];
-        const lineXOffset = calculateLineXOffset(element, line.width);
+        const markerXOffset = calculateLineXOffset(element, line);
         const lineYOffset = yOffset + cumulativeYOffset;
         const strippedLineText = stripHtml(line.text).result;
         const heightOfLine = line.text === ''
             ? lineHeightPx
             : doc.heightOfString(strippedLineText, textOptions);
         cumulativeYOffset += heightOfLine;
+        const contentStartX = calculateTextContentXOffset(element, line);
+        const widthOption = isJustify
+            ? Math.max(element.width - (line.listMeta ? line.listMeta.textStartPx : 0), 1)
+            : undefined;
+        if (line.listMeta?.showMarker) {
+            await drawListMarker(doc, element, line, markerXOffset, lineYOffset, fonts, baseParsedColor.hex, baseOpacity, 'fill', textOptions);
+            doc.fillColor(baseParsedColor.hex, baseOpacity);
+        }
         // Position cursor at line start
-        doc.text('', lineXOffset, lineYOffset, { height: 0, width: 0 });
+        doc.text('', contentStartX, lineYOffset, { height: 0, width: 0 });
         // Parse line into styled segments
         const segments = parseHTMLToSegments(line.text, element);
         // Render each segment with its own styling
@@ -559,7 +985,7 @@ async function renderTextFill(doc, element, textLines, yOffset, lineHeightPx, te
             // Render segment text
             doc.text(segment.text, {
                 ...textOptions,
-                width: isJustify ? element.width : undefined,
+                width: widthOption,
                 height: heightOfLine,
                 continued: !isLastSegment,
                 underline: segment.underline || textOptions.underline || false,
@@ -595,12 +1021,12 @@ export async function renderText(doc, element, fonts, attrs = {}) {
     // Render text based on stroke and PDF/X-1a requirements
     if (hasStroke && isPDFX1a) {
         // PDF/X-1a mode: simulate stroke with offset fills
-        renderPDFX1aStroke(doc, elementToRender, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions);
+        await renderPDFX1aStroke(doc, elementToRender, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions, fonts);
     }
     else {
         // Standard rendering: stroke first, then fill
         if (hasStroke) {
-            renderStandardStroke(doc, elementToRender, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions);
+            await renderStandardStroke(doc, elementToRender, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions, fonts);
         }
         await renderTextFill(doc, elementToRender, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions, fonts);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polotno/pdf-export",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "description": "Convert Polotno JSON into vector PDF",
   "type": "module",
   "main": "./lib/index.js",