@polotno/pdf-import 0.0.1

package/lib/page-parser.js

@@ -0,0 +1,674 @@
+import { extractTextPositionColors, extractDrawingsAndImages, } from './operator-list.js';
+import { groupTextItems, groupSpansByBlock, detectAlignment, estimatePageMargins, computeLineHeight, } from './text-grouper.js';
+import { mapPdfFont, isKnownWebFont, extractWeightFromName, extractStyleFromName, } from './font-mapper.js';
+import { drawingToSvg, svgToDataUri, clippedDrawingsToSvg, clipPathToSvg, } from './svg-builder.js';
+import { imageDataToDataUri } from './image-encoder.js';
+import { rgbTupleToHex } from './color-utils.js';
+import { MIN_TEXT_WIDTH, MIN_TEXT_HEIGHT, MIN_IMAGE_WIDTH, MIN_IMAGE_HEIGHT, } from './constants.js';
+import { parseRef } from './pdf-image-extractor.js';
+import { imageBytesToDataUri } from './image-encoder.js';
+export async function parsePage({ page, pageIdx, fontRegistry, generateId, jpegIndex, }) {
+    const viewport = page.getViewport({ scale: 1 });
+    const pageWidth = viewport.width;
+    const pageHeight = viewport.height;
+    // The viewport transform y-offset accounts for CropBox position within MediaBox.
+    // Use it for coordinate flipping instead of pageHeight to avoid offset errors.
+    const yFlipOffset = viewport.transform[5];
+    // Get operator list for drawings, images, and text colors
+    const ops = await page.getOperatorList();
+    // Extract text colors from operator list (also collects fontRefs)
+    const positionColors = extractTextPositionColors(ops, yFlipOffset);
+    const fontRefs = positionColors.fontRefs || new Set();
+    // Extract drawings and image references from operator list
+    const { drawings, imageRefs } = extractDrawingsAndImages(ops, yFlipOffset);
+    // Run independent async operations in parallel
+    const [, imageElements, { fontNameMap, fontAscentMap, fontOtMap }] = await Promise.all([
+        resolveDrawingGradients(page, drawings),
+        buildImageElements(page, imageRefs, pageIdx, generateId, jpegIndex),
+        collectPageFonts(page, fontRefs, fontRegistry),
+    ]);
+    const pageBackground = detectPageBackground(drawings, pageWidth, pageHeight);
+    const svgElements = buildSvgElements(drawings, pageWidth, pageHeight, generateId);
+    const textElements = await buildTextElements({
+        page,
+        pageWidth,
+        yFlipOffset,
+        positionColors,
+        fontNameMap,
+        fontAscentMap,
+        fontOtMap,
+        generateId,
+    });
+    // Assemble page: all elements sorted by PDF paint order
+    const allElements = [...svgElements, ...imageElements, ...textElements].sort((a, b) => a._order - b._order);
+    const children = allElements.map(({ _order, ...rest }) => rest);
+    return {
+        parsedPage: {
+            id: generateId(),
+            children,
+            background: pageBackground,
+        },
+        pageWidth,
+        pageHeight,
+    };
+}
+async function resolveDrawingGradients(page, drawings) {
+    for (const drawing of drawings) {
+        if (drawing._shadingNames && drawing._shadingNames.length > 0) {
+            // Resolve the first (primary) shading — this is the color gradient
+            const shadingName = drawing._shadingNames[0];
+            try {
+                const shading = await new Promise((resolve, reject) => {
+                    const timeout = setTimeout(() => reject(new Error('timeout')), 3000);
+                    page.objs.get(shadingName, (data) => {
+                        clearTimeout(timeout);
+                        if (data)
+                            resolve(data);
+                        else
+                            reject(new Error('no data'));
+                    });
+                });
+                // shading[0] = "RadialAxial", [1] = type, [3] = stops, [4] = start, [5] = end
+                // For radial: [6] = startRadius, [7] = endRadius
+                if (shading && shading[1]) {
+                    const type = shading[1] === 'radial' ? 'radial' : 'linear';
+                    const stops = [];
+                    if (Array.isArray(shading[3])) {
+                        for (const [offset, color] of shading[3]) {
+                            stops.push({ offset, color });
+                        }
+                    }
+                    if (type === 'linear') {
+                        drawing.gradient = {
+                            type: 'linear',
+                            stops,
+                            x1: shading[4]?.[0] ?? 0,
+                            y1: shading[4]?.[1] ?? 0,
+                            x2: shading[5]?.[0] ?? 0,
+                            y2: shading[5]?.[1] ?? 0,
+                        };
+                    }
+                    else {
+                        drawing.gradient = {
+                            type: 'radial',
+                            stops,
+                            cx: shading[4]?.[0] ?? 0,
+                            cy: shading[4]?.[1] ?? 0,
+                            r0: shading[6] ?? 0,
+                            r1: shading[7] ?? 0,
+                        };
+                    }
+                    // Mark drawing as having a gradient fill
+                    if (!drawing.fill) {
+                        drawing.fill = [0, 0, 0]; // placeholder so it's not skipped
+                    }
+                }
+            }
+            catch {
+                // Couldn't resolve shading — leave as-is
+            }
+        }
+    }
+}
+function detectPageBackground(drawings, pageWidth, pageHeight) {
+    let pageBackground = '#FFFFFF';
+    for (const drawing of drawings) {
+        if (drawing.fill !== null) {
+            const dw = drawing.rect[2] - drawing.rect[0];
+            const dh = drawing.rect[3] - drawing.rect[1];
+            if (dw >= pageWidth * 0.9 && dh >= pageHeight * 0.9) {
+                const [r, g, b] = drawing.fill;
+                pageBackground = rgbTupleToHex(r, g, b);
+            }
+        }
+    }
+    return pageBackground;
+}
+function buildSvgElements(drawings, pageWidth, pageHeight, generateId) {
+    const svgElements = [];
+    for (let idx = 0; idx < drawings.length; idx++) {
+        const drawing = drawings[idx];
+        // Skip fully transparent drawings (e.g. accessibility marker rectangles)
+        if (drawing.opacity <= 0)
+            continue;
+        if (isMergeableClipRunDrawing(drawing)) {
+            const run = [drawing];
+            while (idx + 1 < drawings.length &&
+                isMergeableClipRunDrawing(drawings[idx + 1]) &&
+                isSameClipRun(run[0], drawings[idx + 1])) {
+                run.push(drawings[idx + 1]);
+                idx++;
+            }
+            if (run.length >= 4) {
+                const merged = clippedDrawingsToSvg(run);
+                if (merged) {
+                    svgElements.push({
+                        type: 'svg',
+                        id: generateId(),
+                        x: merged.x,
+                        y: merged.y,
+                        width: merged.width,
+                        height: merged.height,
+                        rotation: 0,
+                        opacity: run[0].opacity,
+                        src: svgToDataUri(merged.svg),
+                        name: '',
+                        _order: run[0].orderIndex,
+                    });
+                    continue;
+                }
+            }
+        }
+        const result = drawingToSvg(drawing, pageWidth, pageHeight);
+        if (result) {
+            svgElements.push({
+                type: 'svg',
+                id: generateId(),
+                x: result.x,
+                y: result.y,
+                width: result.width,
+                height: result.height,
+                rotation: 0,
+                opacity: drawing.opacity,
+                src: svgToDataUri(result.svg),
+                name: '',
+                _order: drawing.orderIndex,
+            });
+        }
+    }
+    return svgElements;
+}
+function hasMeaningfulClip(drawing) {
+    return (!!drawing.clipRect &&
+        Math.max(drawing.clipRect[0] - drawing.rect[0], drawing.clipRect[1] - drawing.rect[1], drawing.rect[2] - drawing.clipRect[2], drawing.rect[3] - drawing.clipRect[3]) > 20);
+}
+function isMergeableClipRunDrawing(drawing) {
+    return (drawing.opacity > 0 &&
+        !!drawing.clipPath &&
+        hasMeaningfulClip(drawing) &&
+        drawing.items.length === 4 &&
+        !drawing.stroke &&
+        !drawing.gradient);
+}
+function serializeDrawingItems(items) {
+    return items
+        .map((item) => Object.entries(item)
+        .map(([key, value]) => typeof value === 'number'
+        ? `${key}:${value.toFixed(3)}`
+        : `${key}:${String(value)}`)
+        .join(','))
+        .join('|');
+}
+function isSameClipRun(a, b) {
+    // Direct element comparison instead of JSON.stringify for numeric arrays
+    const af = a.fill, bf = b.fill;
+    const sameFill = af[0] === bf[0] && af[1] === bf[1] && af[2] === bf[2] &&
+        a.opacity === b.opacity &&
+        a.evenOdd === b.evenOdd;
+    if (!sameFill)
+        return false;
+    const ac = a.clipRect, bc = b.clipRect;
+    const sameClipRect = ac[0] === bc[0] && ac[1] === bc[1] && ac[2] === bc[2] && ac[3] === bc[3];
+    return (sameClipRect &&
+        serializeDrawingItems(a.clipPath) === serializeDrawingItems(b.clipPath));
+}
+async function buildImageElements(page, imageRefs, pageIdx, generateId, jpegIndex) {
+    const imageElements = [];
+    for (let imgIdx = 0; imgIdx < imageRefs.length; imgIdx++) {
+        const ref = imageRefs[imgIdx];
+        if (ref.width < MIN_IMAGE_WIDTH || ref.height < MIN_IMAGE_HEIGHT)
+            continue;
+        try {
+            const imgData = await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => reject(new Error('Timeout waiting for image data')), 10000);
+                page.objs.get(ref.name, (data) => {
+                    clearTimeout(timeout);
+                    if (data)
+                        resolve(data);
+                    else
+                        reject(new Error('No image data'));
+                });
+            });
+            let src;
+            // Try to use original JPEG bytes from the PDF stream
+            const objNum = imgData.ref ? parseRef(imgData.ref) : null;
+            const rawStream = objNum != null ? jpegIndex.get(objNum) : undefined;
+            if (rawStream) {
+                src = imageBytesToDataUri(rawStream.data, rawStream.mimeType);
+            }
+            else if (imgData.data) {
+                // Raw pixel data — re-encode as PNG
+                src = imageDataToDataUri(imgData.data, imgData.width, imgData.height, imgData.kind || 3);
+            }
+            else if (imgData.src) {
+                // Already a URL or data URI
+                src = imgData.src;
+            }
+            else if (imgData.bitmap) {
+                const canvas = document.createElement('canvas');
+                canvas.width = imgData.bitmap.width;
+                canvas.height = imgData.bitmap.height;
+                const ctx = canvas.getContext('2d');
+                ctx.drawImage(imgData.bitmap, 0, 0);
+                src = canvas.toDataURL('image/png');
+            }
+            else {
+                continue;
+            }
+            // Generate clip path SVG if available
+            let clipSrc = '';
+            // Compute crop from clip rect: constrain element to visible clip area
+            let elemX = ref.x;
+            let elemY = ref.y;
+            let elemW = ref.width;
+            let elemH = ref.height;
+            let cropX = 0;
+            let cropY = 0;
+            let cropWidth = 1;
+            let cropHeight = 1;
+            const rotDeg = ref.rotation || 0;
+            const hasRotation = Math.abs(rotDeg) > 0.5;
+            if (ref.clipRect && ref.width > 0 && ref.height > 0) {
+                const [cx0, cy0, cx1, cy1] = ref.clipRect;
+                if (hasRotation) {
+                    // For rotated images: transform clip rect into image-local space
+                    // (origin at image top-left, x along top edge, y along left edge)
+                    const rotRad = (rotDeg * Math.PI) / 180;
+                    const cosNeg = Math.cos(-rotRad);
+                    const sinNeg = Math.sin(-rotRad);
+                    // Transform clip rect corners: screen → image-local (origin=TL, unrotated)
+                    const clipScreenCorners = [
+                        [cx0, cy0],
+                        [cx1, cy0],
+                        [cx1, cy1],
+                        [cx0, cy1],
+                    ];
+                    const localCorners = clipScreenCorners.map(([sx, sy]) => {
+                        const dx = sx - ref.x;
+                        const dy = sy - ref.y;
+                        return [dx * cosNeg - dy * sinNeg, dx * sinNeg + dy * cosNeg];
+                    });
+                    // AABB of clip in local space, clamped to [0, width] × [0, height]
+                    const visMinX = Math.max(Math.min(...localCorners.map((c) => c[0])), 0);
+                    const visMinY = Math.max(Math.min(...localCorners.map((c) => c[1])), 0);
+                    const visMaxX = Math.min(Math.max(...localCorners.map((c) => c[0])), ref.width);
+                    const visMaxY = Math.min(Math.max(...localCorners.map((c) => c[1])), ref.height);
+                    const visW = visMaxX - visMinX;
+                    const visH = visMaxY - visMinY;
+                    if (visW > MIN_IMAGE_WIDTH && visH > MIN_IMAGE_HEIGHT) {
+                        cropX = visMinX / ref.width;
+                        cropY = visMinY / ref.height;
+                        cropWidth = visW / ref.width;
+                        cropHeight = visH / ref.height;
+                        elemW = visW;
+                        elemH = visH;
+                        // Element position: transform crop top-left from local back to screen
+                        // (polotno rotates around top-left)
+                        const cosPos = Math.cos(rotRad);
+                        const sinPos = Math.sin(rotRad);
+                        elemX = ref.x + visMinX * cosPos - visMinY * sinPos;
+                        elemY = ref.y + visMinX * sinPos + visMinY * cosPos;
+                    }
+                }
+                else {
+                    // Non-rotated: simple axis-aligned intersection
+                    const visX0 = Math.max(cx0, ref.x);
+                    const visY0 = Math.max(cy0, ref.y);
+                    const visX1 = Math.min(cx1, ref.x + ref.width);
+                    const visY1 = Math.min(cy1, ref.y + ref.height);
+                    const visW = visX1 - visX0;
+                    const visH = visY1 - visY0;
+                    if (visW > MIN_IMAGE_WIDTH && visH > MIN_IMAGE_HEIGHT) {
+                        cropX = (visX0 - ref.x) / ref.width;
+                        cropY = (visY0 - ref.y) / ref.height;
+                        cropWidth = visW / ref.width;
+                        cropHeight = visH / ref.height;
+                        elemX = visX0;
+                        elemY = visY0;
+                        elemW = visW;
+                        elemH = visH;
+                    }
+                }
+            }
+            // Polotno renders images with uniform scaling (maintaining natural aspect ratio).
+            // PDFs can non-uniformly scale images (different scaleX/scaleY). Adjust cropHeight
+            // so that cropH/cropW = (elemH/elemW) × (naturalW/naturalH), keeping horizontal
+            // extent correct and adjusting vertical to match polotno's uniform scale model.
+            const naturalW = imgData.width || 0;
+            const naturalH = imgData.height || 0;
+            if (naturalW > 0 &&
+                naturalH > 0 &&
+                elemW > 0 &&
+                elemH > 0 &&
+                cropWidth > 0) {
+                const requiredRatio = (elemH / elemW) * (naturalW / naturalH);
+                cropHeight = cropWidth * requiredRatio;
+            }
+            if (ref.clipPath) {
+                // Skip clipSrc for simple rectangular clips — crop values already handle the clipping.
+                // Only generate clipSrc for non-rectangular shapes (circles, curves, etc.)
+                const isSimpleRect = ref.clipPath.length === 1 && ref.clipPath[0].kind === 're';
+                if (!isSimpleRect) {
+                    const clipSvg = clipPathToSvg(ref.clipPath, elemX, elemY, elemW, elemH);
+                    if (clipSvg) {
+                        clipSrc = svgToDataUri(clipSvg);
+                    }
+                }
+            }
+            imageElements.push({
+                type: 'image',
+                id: generateId(),
+                x: elemX,
+                y: elemY,
+                width: elemW,
+                height: elemH,
+                rotation: ref.rotation || 0,
+                opacity: 1,
+                visible: true,
+                selectable: true,
+                removable: true,
+                src,
+                cropX,
+                cropY,
+                cropWidth,
+                cropHeight,
+                clipSrc,
+                name: `image_${pageIdx}_${imgIdx}`,
+                _order: ref.orderIndex,
+            });
+        }
+        catch (e) {
+            console.warn(`Failed to extract image ${ref.name}:`, e);
+        }
+    }
+    return imageElements;
+}
+async function collectPageFonts(page, fontRefs, fontRegistry) {
+    // Build font name map: loadedName (g_d0_f1) → real PDF name (CZZZZZ+Roboto-Regular)
+    // Also build font ascent map for accurate Y positioning (glyph top vs baseline)
+    const fontNameMap = new Map();
+    const fontAscentMap = new Map();
+    // Map loadedName → parsed opentype.js Font for letter spacing computation
+    const fontOtMap = new Map();
+    for (const ref of fontRefs) {
+        try {
+            const fontObj = await new Promise((resolve, reject) => {
+                page.commonObjs.get(ref, (data) => {
+                    if (data)
+                        resolve(data);
+                    else
+                        reject();
+                });
+            });
+            if (fontObj.name) {
+                fontNameMap.set(ref, fontObj.name);
+                if (fontObj.ascent != null) {
+                    fontAscentMap.set(ref, fontObj.ascent);
+                }
+                fontRegistry.recordFont(fontObj);
+                // Parse font binary with opentype.js for per-character width computation
+                // Uses FontRegistry cache to avoid re-parsing the same font across pages
+                if (fontObj.data && fontObj.data.length > 0) {
+                    const otFont = fontRegistry.parseOpentype(ref, fontObj.data);
+                    if (otFont) {
+                        fontOtMap.set(ref, otFont);
+                    }
+                }
+            }
+        }
+        catch { }
+    }
+    return { fontNameMap, fontAscentMap, fontOtMap };
+}
+/**
+ * Compute letter spacing for a text block by comparing the PDF's actual span
+ * widths against the expected widths from the embedded font's character metrics
+ * (via opentype.js). Returns a ratio of fontSize (Polotno's letterSpacing unit).
+ *
+ * For each span we compute:
+ *   pdfWidth  = span.width (exact advance width from PDF)
+ *   fontWidth = sum of opentype advanceWidth for each character, scaled to fontSize
+ *   perCharDelta = (pdfWidth - fontWidth) / span.text.length
+ *
+ * We average across all spans in the block and express as ratio of fontSize.
+ */
+function computeBlockLetterSpacing(fullText, blockWidth, spans, fontSize, dominantFontName, fontOtByName) {
+    if (fontSize < 1)
+        return 0;
+    const isSingleLine = !fullText.includes('\n');
+    // For single-line text, compare the font's full rendering width against the
+    // PDF block width. For embedded (non-web) fonts the browser uses the same
+    // subset we parsed, so .notdef space width is correct. For known web fonts
+    // the browser uses the real font (not the subset), so .notdef space width
+    // is wrong — bail out and use the per-span path instead.
+    if (isSingleLine) {
+        const otFont = fontOtByName.get(dominantFontName);
+        if (otFont) {
+            const fontIsEmbedded = !isKnownWebFont(dominantFontName);
+            const scale = fontSize / otFont.unitsPerEm;
+            const notdefGlyph = otFont.glyphs.get(0);
+            let fontWidth = 0;
+            let charCount = 0;
+            let valid = true;
+            for (const ch of fullText) {
+                const glyph = otFont.charToGlyph(ch);
+                if (glyph === notdefGlyph || !glyph.advanceWidth) {
+                    // For embedded fonts, .notdef space is what the browser will render.
+                    // For web fonts, .notdef space width is wrong — bail out.
+                    if (ch === ' ' && fontIsEmbedded) {
+                        fontWidth += (glyph.advanceWidth || 0) * scale;
+                        charCount++;
+                        continue;
+                    }
+                    valid = false;
+                    break;
+                }
+                fontWidth += glyph.advanceWidth * scale;
+                charCount++;
+            }
+            if (valid && fontWidth > 1 && charCount >= 2) {
+                const perCharRatio = (blockWidth - fontWidth) / charCount / fontSize;
+                const rounded = Math.round(perCharRatio * 1000) / 1000;
+                // If the value is extreme (>10% of fontSize), this likely indicates
+                // merged labels with a large spatial gap, not real letter spacing.
+                // Fall through to the safer per-span computation.
+                if (Math.abs(rounded) < 0.1) {
+                    const totalPxImpact = Math.abs(rounded) * fontSize * charCount;
+                    if (totalPxImpact >= 1)
+                        return rounded;
+                    return 0;
+                }
+            }
+        }
+    }
+    // For multi-line text (or when single-line full-text fails), use per-span
+    // comparison. This is safer because it avoids the unpredictable .notdef
+    // space width that varies wildly between subset fonts.
+    let totalDelta = 0;
+    let totalChars = 0;
+    for (const span of spans) {
+        if (span.text.length < 2)
+            continue;
+        const otFont = fontOtByName.get(span.fontName);
+        if (!otFont)
+            continue;
+        const scale = span.fontSize / otFont.unitsPerEm;
+        const notdefGlyph = otFont.glyphs.get(0);
+        let fontWidth = 0;
+        let validChars = 0;
+        let hasInvalidGlyph = false;
+        for (const ch of span.text) {
+            const glyph = otFont.charToGlyph(ch);
+            if (glyph === notdefGlyph || !glyph.advanceWidth) {
+                hasInvalidGlyph = true;
+                break;
+            }
+            fontWidth += glyph.advanceWidth * scale;
+            validChars++;
+        }
+        if (hasInvalidGlyph || fontWidth < 1)
+            continue;
+        const delta = span.width - fontWidth;
+        totalDelta += delta;
+        totalChars += validChars;
+    }
+    if (totalChars < 2)
+        return 0;
+    const perCharRatio = totalDelta / totalChars / fontSize;
+    const rounded = Math.round(perCharRatio * 1000) / 1000;
+    // Threshold: ignore if the total pixel impact is < 1px.
+    // At small fonts (12pt, 10 chars) 0.005 ratio = 0.6px total → skip.
+    // At large fonts (615pt, 9 chars) 0.003 ratio = 16px total → keep.
+    const totalPxImpact = Math.abs(rounded) * fontSize * totalChars;
+    return totalPxImpact < 1 ? 0 : rounded;
+}
+async function buildTextElements({ page, pageWidth, yFlipOffset, positionColors, fontNameMap, fontAscentMap, fontOtMap, generateId, }) {
+    // Extract text
+    const textContent = await page.getTextContent();
+    const textSpans = groupTextItems(textContent.items, textContent.styles || {}, yFlipOffset, positionColors, fontNameMap, fontAscentMap);
+    // Re-key opentype fonts by real PDF name (spans store real names, not loadedNames)
+    const fontOtByName = new Map();
+    for (const [loadedName, otFont] of fontOtMap) {
+        const realName = fontNameMap.get(loadedName) || loadedName;
+        fontOtByName.set(realName, otFont);
+    }
+    // Group into blocks and create text elements
+    const textElements = [];
+    const blocks = groupSpansByBlock(textSpans);
+    // Estimate page margins for alignment detection
+    const [leftMargin, rightMargin] = estimatePageMargins(textSpans);
+    for (const block of blocks) {
+        if (block.spans.length === 0)
+            continue;
+        if (block.width < MIN_TEXT_WIDTH || block.height < MIN_TEXT_HEIGHT)
+            continue;
+        // Find dominant span (longest text)
+        const dominant = block.spans.reduce((a, b) => a.text.length > b.text.length ? a : b);
+        const fontFamily = mapPdfFont(dominant.fontName);
+        const align = detectAlignment(block.spans, pageWidth, leftMargin, rightMargin);
+        const lineHeight = computeLineHeight(block.spans);
+        // Build text content with line breaks
+        const lineMap = new Map();
+        for (const span of block.spans) {
+            const arr = lineMap.get(span.lineNo) || [];
+            arr.push(span);
+            lineMap.set(span.lineNo, arr);
+        }
+        const sortedLineNos = [...lineMap.keys()].sort((a, b) => a - b);
+        // Compute each line's text and width for join decisions
+        const lineTexts = [];
+        for (let i = 0; i < sortedLineNos.length; i++) {
+            const lineSpans = lineMap.get(sortedLineNos[i]);
+            lineSpans.sort((a, b) => a.x - b.x);
+            const parts = [];
+            for (let j = 0; j < lineSpans.length; j++) {
+                if (j > 0) {
+                    const prevEnd = lineSpans[j - 1].x + lineSpans[j - 1].width;
+                    const gap = lineSpans[j].x - prevEnd;
+                    if (gap > Math.min(lineSpans[j].fontSize * 0.15, 5)) {
+                        parts.push(' ');
+                    }
+                }
+                parts.push(lineSpans[j].text);
+            }
+            const lineWidth = lineSpans[lineSpans.length - 1].x +
+                lineSpans[lineSpans.length - 1].width -
+                lineSpans[0].x;
+            lineTexts.push({ text: parts.join(''), width: lineWidth });
+        }
+        // For justified text, join word-wrapped lines with spaces instead of \n
+        // so Polotno's justify can re-flow them. Only insert \n at real paragraph
+        // breaks (where the preceding line is significantly shorter than block width).
+        const textParts = [];
+        for (let i = 0; i < lineTexts.length; i++) {
+            if (i > 0) {
+                if (align === 'justify') {
+                    const prevWidth = lineTexts[i - 1].width;
+                    const isShortLine = prevWidth < block.width * 0.85;
+                    textParts.push(isShortLine ? '\n' : ' ');
+                }
+                else {
+                    textParts.push('\n');
+                }
+            }
+            textParts.push(lineTexts[i].text);
+        }
+        const textContent2 = textParts.join('').trim();
+        if (!textContent2)
+            continue;
+        const isMultiLine = textContent2.includes('\n');
+        // Justified text fills the full element width, so any extra makes lines
+        // wider than the PDF intended. Use 0 extra for justify.
+        const extraWidth = align === 'justify'
+            ? 0
+            : isMultiLine
+                ? block.width * 0.05 + 10
+                : block.width * 0.15 + 10;
+        const elemWidth = block.width + extraWidth;
+        // CSS line-height half-leading: the browser distributes extra space equally
+        // above and below the font's content area. The content area height is
+        // (ascent + |descent|) * fontSize / unitsPerEm, NOT simply fontSize.
+        // Using the correct content area from the embedded font gives a more
+        // accurate half-leading offset.
+        const otFont = fontOtByName.get(dominant.fontName);
+        const contentAreaRatio = otFont
+            ? (otFont.ascender - otFont.descender) / otFont.unitsPerEm
+            : 1.0;
+        // halfLeading can be negative when the font's content area exceeds the
+        // line-height. Negative means the content overflows above the line box,
+        // so we must push elemY down to compensate.
+        const halfLeading = (lineHeight - contentAreaRatio) * dominant.fontSize / 2;
+        const elemHeight = block.height + Math.abs(halfLeading) * 2 + 5;
+        // Adjust x so added padding doesn't shift visible text
+        let elemX = block.x;
+        let elemY = block.y - halfLeading;
+        if (align === 'center') {
+            elemX -= extraWidth / 2;
+        }
+        else if (align === 'right') {
+            elemX -= extraWidth;
+        }
+        // Polotno rotates text around the top-left corner. For vertical text, anchor
+        // against the baseline/right edge so the rotated box stays in the same place.
+        if (dominant.rotation <= -45 && dominant.rotation >= -135) {
+            elemX -= elemHeight;
+            elemY = dominant.baselineY;
+        }
+        else if (dominant.rotation >= 45 && dominant.rotation <= 135) {
+            elemY = dominant.baselineY - elemWidth;
+        }
+        // Use minimum orderIndex from spans for z-ordering
+        const blockOrder = Math.min(...block.spans.map((s) => s.orderIndex));
+        // Compute letter spacing by comparing PDF advance widths with opentype.js
+        // character widths. The difference (per char, as ratio of fontSize) tells us
+        // how much extra spacing the PDF applies vs browser default rendering.
+        const letterSpacing = computeBlockLetterSpacing(textContent2, block.width, block.spans, dominant.fontSize, dominant.fontName, fontOtByName);
+        textElements.push({
+            type: 'text',
+            id: generateId(),
+            x: elemX,
+            y: elemY,
+            width: elemWidth,
+            height: elemHeight,
+            rotation: dominant.rotation || 0,
+            opacity: 1,
+            visible: true,
+            selectable: true,
+            removable: true,
+            text: textContent2,
+            fontSize: dominant.fontSize,
+            fontFamily,
+            fontWeight: dominant.fontWeight || extractWeightFromName(dominant.fontName),
+            fontStyle: dominant.fontStyle || extractStyleFromName(dominant.fontName),
+            fill: dominant.color || '#000000',
+            align,
+            lineHeight,
+            letterSpacing,
+            name: '',
+            placeholder: '',
+            _order: blockOrder,
+        });
+    }
+    return textElements;
+}
+//# sourceMappingURL=page-parser.js.map

package/lib/pdf-image-extractor.d.ts

@@ -0,0 +1,14 @@
+export interface RawImageStream {
+    data: Uint8Array;
+    mimeType: string;
+}
+/**
+ * Build a lookup from PDF object number to its raw JPEG stream data.
+ * Only indexes image XObjects with DCTDecode (JPEG) filter.
+ */
+export declare function buildJpegIndex(pdfBytes: Uint8Array): Map<number, RawImageStream>;
+/**
+ * Parse a pdfjs ref string like "44R" to extract the object number.
+ */
+export declare function parseRef(ref: string): number | null;
+//# sourceMappingURL=pdf-image-extractor.d.ts.map