@polotno/pdf-export 0.1.37 → 0.1.39

package/lib/text/fonts.js

@@ -1,82 +0,0 @@
-import { srcToBuffer } from '../utils.js';
-import getUrls from 'get-urls';
-import fetch from 'node-fetch';
-const fontUrlRegistry = {};
-export function registerFontUrl(fontFamily, url) {
-    fontUrlRegistry[fontFamily] = url;
-}
-/**
- * Get font weight string based on bold/italic state
- */
-export function getFontWeight(bold, italic, baseFontWeight) {
-    if (bold) {
-        return 'bold';
-    }
-    return baseFontWeight || 'normal';
-}
-/**
- * Get font key for caching
- */
-export 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;
-}
-/**
- * Load font for a text element or segment
- */
-export 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;
-    // 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]) {
-        let src;
-        if (fontUrlRegistry[fontFamily]) {
-            src = fontUrlRegistry[fontFamily];
-        }
-        else {
-            const weight = getFontWeight(bold, italic, element.fontWeight);
-            src = await getGoogleFontPath(fontFamily, weight, italic);
-        }
-        try {
-            doc.registerFont(fontKey, await srcToBuffer(src));
-        }
-        catch (error) {
-            throw new Error(`Failed to load font "${fontFamily}" from ${src}: ${error.message}`);
-        }
-        fonts[fontKey] = true;
-    }
-    doc.font(fontKey);
-    return fontKey;
-}
-// Alias for backward compatibility
-export async function loadFontIfNeeded(doc, element, fonts) {
-    return loadFontForSegment(doc, null, element, fonts);
-}

package/lib/text/index.d.ts

@@ -1,8 +0,0 @@
-import { TextElement, RenderAttrs } from './types.js';
-export * from './types.js';
-export { loadFontIfNeeded } from './fonts.js';
-export { normalizeRichText, parseHTMLToSegments } from './parser.js';
-/**
- * Main text rendering function
- */
-export declare function renderText(doc: PDFKit.PDFDocument, element: TextElement, fonts: Record<string, boolean>, attrs?: RenderAttrs): Promise<void>;

package/lib/text/index.js

@@ -1,42 +0,0 @@
-import { normalizeRichText } from './parser.js';
-import { calculateTextMetrics, calculateVerticalAlignment, fitTextToHeight, } from './layout.js';
-import { renderTextBackground, renderPDFX1aStroke, renderStandardStroke, renderTextFill, } from './render.js';
-export * from './types.js';
-export { loadFontIfNeeded } from './fonts.js';
-export { normalizeRichText, parseHTMLToSegments } from './parser.js';
-/**
- * Main text rendering function
- */
-export async function renderText(doc, element, fonts, attrs = {}) {
-    let elementToRender = element;
-    if (typeof element.text === 'string') {
-        const normalizedText = normalizeRichText(element.text);
-        if (normalizedText !== element.text) {
-            elementToRender = { ...element, text: normalizedText };
-        }
-    }
-    doc.fontSize(elementToRender.fontSize);
-    const hasStroke = elementToRender.strokeWidth > 0;
-    const isPDFX1a = attrs.pdfx1a;
-    // Calculate text metrics and line positioning
-    const metrics = calculateTextMetrics(doc, elementToRender);
-    const verticalAlignmentOffset = calculateVerticalAlignment(doc, elementToRender, metrics.textOptions);
-    // Fit text to element height if needed
-    fitTextToHeight(doc, elementToRender, metrics.textOptions);
-    // Calculate final vertical offset
-    const finalYOffset = verticalAlignmentOffset + metrics.baselineOffset;
-    // Render background if enabled
-    renderTextBackground(doc, elementToRender, 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);
-    }
-    else {
-        // Standard rendering: stroke first, then fill
-        if (hasStroke) {
-            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/lib/text/layout.d.ts

@@ -1,22 +0,0 @@
-import { TextElement, TextLine, TextMetrics, RenderSegment, TabExpansionSegment } from './types.js';
-/**
- * Expand tabs in text with word spacing adjustment for accurate visual alignment.
- */
-export declare function expandTabsWithWordSpacing(text: string, doc: PDFKit.PDFDocument, textOptions: PDFKit.Mixins.TextOptions, tabSizeInSpaces?: number, currentWidth?: number): {
-    segments: TabExpansionSegment[];
-    finalWidth: number;
-};
-export declare function buildRenderSegmentsForLine(doc: PDFKit.PDFDocument, element: TextElement, lineText: string, textOptions: PDFKit.Mixins.TextOptions, fonts: Record<string, boolean>): Promise<RenderSegment[]>;
-export declare function splitTextIntoLines(doc: PDFKit.PDFDocument, element: TextElement, props: PDFKit.Mixins.TextOptions): TextLine[];
-export declare function calculateTextMetrics(doc: PDFKit.PDFDocument, element: TextElement): TextMetrics;
-export declare function calculateVerticalAlignment(doc: PDFKit.PDFDocument, element: TextElement, textOptions: PDFKit.Mixins.TextOptions): number;
-export declare function fitTextToHeight(doc: PDFKit.PDFDocument, element: TextElement, textOptions: PDFKit.Mixins.TextOptions): void;
-/**
- * Calculate X offset for list markers (not used for text content positioning)
- */
-export declare function calculateLineXOffset(element: TextElement, line: TextLine): number;
-export declare function calculateTextContentXOffset(element: TextElement, line: TextLine): number;
-/**
- * Calculate effective width for text rendering, considering justify and underline constraints
- */
-export declare function calculateEffectiveWidth(element: TextElement, line: TextLine, widthOption: number | undefined, hasUnderline: boolean): number | undefined;

package/lib/text/layout.js

@@ -1,522 +0,0 @@
-import { stripHtml } from 'string-strip-html';
-import { tokenizeHTML, parseHtmlToParagraphs, tokensToHTML, decodeHtmlEntities, parseHTMLToSegments, } from './parser.js';
-import { loadFontForSegment } from './fonts.js';
-/**
- * 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.
- */
-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;
-}
-/**
- * Expand tabs in text with word spacing adjustment for accurate visual alignment.
- */
-export function expandTabsWithWordSpacing(text, doc, textOptions, tabSizeInSpaces = 8, currentWidth = 0) {
-    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 tabStopWidth = Math.max(spaceWidth * tabSizeInSpaces, spaceWidth || 1);
-    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;
-            // 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 };
-}
-export 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);
-            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;
-}
-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 encodeHtmlEntities(text) {
-    return text
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
-export function splitTextIntoLines(doc, element, props) {
-    const lines = [];
-    const rawText = typeof element.text === 'string'
-        ? element.text
-        : String(element.text ?? '');
-    const paragraphs = parseHtmlToParagraphs(rawText);
-    const lineHeightPx = element.lineHeight * element.fontSize;
-    // Calculate max allowed lines. Ensure at least 1 line is allowed.
-    // Use a very large number if height check is disabled or infinite
-    // If element.height is very large (like in 8.json which is a page), we should treat it as effectively infinite for text
-    // But wait, the element in 8.json has specific height:
-    // "height": 60 for title, 40 for subtitle, 40 for chapter title, 600 for content text.
-    // The content text has height 600 and font size 14. Line height 1.5 -> 21px per line.
-    // 600 / 21 = ~28 lines.
-    // So maxLines is finite.
-    const maxLines = element.height > 0
-        ? Math.max(1, Math.round(element.height / lineHeightPx))
-        : Infinity;
-    if (paragraphs.length === 0) {
-        paragraphs.push({ html: '' });
-    }
-    for (const paragraph of paragraphs) {
-        // Tokenize the paragraph
-        const tokens = tokenizeHTML(paragraph.html);
-        // 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 paragraphWidth = doc.widthOfString(plainText, props);
-        let showMarkerForLine = baseMeta?.showMarker ?? false;
-        // Justify alignment using native pdfkit instruments
-        if (paragraphWidth <= availableWidth || 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,
-            });
-        }
-        else {
-            // Need to split paragraph into multiple lines
-            let currentLineDecoded = '';
-            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
-                // 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;
-                        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,
-                        });
-                    }
-                    else {
-                        // Line is too long, save current line and start new one
-                        // Check if we can add a new line (wrapping).
-                        // If we wrap, we push the current line and start a new one.
-                        // So we will have lines.length + 1 lines + the new one we are starting.
-                        // We can wrap only if lines.length + 1 <= maxLines.
-                        if (lines.length < maxLines - 1) {
-                            // Case 1: Line has content, so we wrap to next line
-                            if (currentLineDecoded.length > 0) {
-                                const result = tokensToHTML(currentTokens, openTags);
-                                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;
-                                // Handle the current word on the new line
-                                currentLineDecoded = decodedWord;
-                                // Expand tabs for accurate width measurement
-                                const decodedWordExpanded = expandTabsToTabStops(decodedWord, 8);
-                                currentWidth = doc.widthOfString(decodedWordExpanded, props);
-                                currentTokens.push({
-                                    type: 'text',
-                                    content: rawWord,
-                                    decodedContent: decodedWord,
-                                });
-                            }
-                            else {
-                                // Case 2: Line is empty (start of line), but word is too big for line
-                                // Since we can wrap (have height), but the word itself is wider than line width,
-                                // we must split the word across lines.
-                                // The original logic for splitting word was inside "else if (currentLineDecoded.length === 0)" block
-                                // which is technically this else block if lines.length check was outside.
-                                const word = decodedWord;
-                                // logic for splitting word...
-                                let processedWord = '';
-                                let processedWidth = 0;
-                                for (const char of word) {
-                                    const testChunk = processedWord + char;
-                                    const testChunkExpanded = expandTabsToTabStops(testChunk, 8);
-                                    const testChunkWidth = doc.widthOfString(testChunkExpanded, props);
-                                    if (testChunkWidth > availableWidth) {
-                                        if (processedWord.length > 0 &&
-                                            lines.length < maxLines - 1) {
-                                            const chunkContent = encodeHtmlEntities(processedWord);
-                                            currentTokens.push({
-                                                type: 'text',
-                                                content: chunkContent,
-                                                decodedContent: processedWord,
-                                            });
-                                            const result = tokensToHTML(currentTokens, openTags);
-                                            const listMeta = cloneListMetaForLine(baseMeta, showMarkerForLine);
-                                            lines.push({
-                                                text: result.html,
-                                                width: processedWidth,
-                                                fullWidth: processedWidth +
-                                                    (listMeta ? listMeta.textStartPx : 0),
-                                                listMeta,
-                                            });
-                                            openTags = result.openTags;
-                                            currentTokens = [];
-                                            showMarkerForLine = false;
-                                            processedWord = char;
-                                            processedWidth = doc.widthOfString(expandTabsToTabStops(char, 8), props);
-                                        }
-                                        else {
-                                            processedWord += char;
-                                            processedWidth = testChunkWidth;
-                                        }
-                                    }
-                                    else {
-                                        processedWord += char;
-                                        processedWidth = testChunkWidth;
-                                    }
-                                }
-                                currentLineDecoded = processedWord;
-                                currentWidth = processedWidth;
-                                const chunkContent = encodeHtmlEntities(processedWord);
-                                currentTokens.push({
-                                    type: 'text',
-                                    content: chunkContent,
-                                    decodedContent: processedWord,
-                                });
-                            }
-                        }
-                        else {
-                            // Cannot wrap anymore (max lines reached).
-                            // Append to current line regardless of width.
-                            if (currentLineDecoded.length > 0) {
-                                currentLineDecoded = testLineDecoded;
-                                currentWidth = testWidth;
-                                const rawContent = separator.length > 0 ? `${separator}${rawWord}` : rawWord;
-                                const decodedContent = separator.length > 0
-                                    ? `${separator}${decodedWord}`
-                                    : decodedWord;
-                                currentTokens.push({
-                                    type: 'text',
-                                    content: rawContent,
-                                    decodedContent: decodedContent,
-                                });
-                            }
-                            else {
-                                // Edge case: Start of line, can't wrap, but word is too big.
-                                // Since we can't wrap, we just force it in.
-                                currentLineDecoded = decodedWord;
-                                const decodedWordExpanded = expandTabsToTabStops(decodedWord, 8);
-                                currentWidth = doc.widthOfString(decodedWordExpanded, props);
-                                currentTokens.push({
-                                    type: 'text',
-                                    content: rawWord,
-                                    decodedContent: decodedWord,
-                                });
-                            }
-                        }
-                    }
-                }
-            }
-            // Add the last line
-            if (currentLineDecoded.length > 0) {
-                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,
-                });
-            }
-        }
-    }
-    return lines;
-}
-export 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,
-    };
-}
-export 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') {
-        return (element.height - textHeight) / 2;
-    }
-    else if (element.verticalAlign === 'bottom') {
-        return element.height - textHeight;
-    }
-    return 0;
-}
-export 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;
-        }
-    }
-}
-/**
- * Calculate X offset for list markers (not used for text content positioning)
- */
-export 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
-    const align = element.align;
-    const targetWidth = line.width;
-    if (align === 'right') {
-        return element.width - targetWidth;
-    }
-    else if (align === 'center') {
-        return (element.width - targetWidth) / 2;
-    }
-    // left or justify: markers at position 0
-    return 0;
-}
-export 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
- */
-export function calculateEffectiveWidth(element, line, widthOption, hasUnderline) {
-    if (widthOption !== undefined) {
-        return widthOption;
-    }
-    if (hasUnderline) {
-        return element.width;
-    }
-    return undefined;
-}