@polotno/pdf-import 0.0.1

package/lib/text-layout.js

@@ -0,0 +1,318 @@
+export function assignTextLayout(spans) {
+    // Assign line numbers by clustering Y positions
+    if (spans.length === 0)
+        return spans;
+    // Sort by Y then X
+    spans.sort((a, b) => a.y - b.y || a.x - b.x);
+    // Detect page columns first — spans that share the same Y line but are far apart
+    // horizontally belong to different columns and should be grouped independently
+    const columns = detectPageColumns(spans);
+    let lineNo = 0;
+    let blockNo = 0;
+    for (const colSpans of columns) {
+        // Assign line numbers within this column
+        colSpans.sort((a, b) => a.y - b.y || a.x - b.x);
+        let currentLineY = colSpans[0].y;
+        let lineMaxFontSize = colSpans[0].fontSize;
+        for (const span of colSpans) {
+            // Use the larger of current span's font size and line's max font size
+            // so superscripts/small caps don't break lines with large text
+            const tolerance = Math.max(span.fontSize, lineMaxFontSize) * 0.3;
+            // But if font sizes differ drastically (>3x ratio), treat as separate lines
+            // even if Y positions are close. This prevents e.g. a 20px label merging
+            // with a 232px heading that happens to be nearby.
+            const sizeRatio = Math.max(span.fontSize, lineMaxFontSize) /
+                Math.min(span.fontSize, lineMaxFontSize);
+            if (Math.abs(span.y - currentLineY) > tolerance || sizeRatio > 3) {
+                lineNo++;
+                currentLineY = span.y;
+                lineMaxFontSize = span.fontSize;
+            }
+            else {
+                // Update running Y to track the dominant baseline (weighted toward larger text)
+                if (span.fontSize >= lineMaxFontSize) {
+                    currentLineY = span.y;
+                    lineMaxFontSize = span.fontSize;
+                }
+            }
+            span.lineNo = lineNo;
+        }
+        lineNo++;
+        // Assign block numbers within this column
+        assignBlockNumbers(colSpans, blockNo);
+        // Find max block number assigned
+        let maxBlock = blockNo;
+        for (const s of colSpans) {
+            if (s.blockNo > maxBlock)
+                maxBlock = s.blockNo;
+        }
+        blockNo = maxBlock + 1;
+    }
+    return spans;
+}
+// Detect page columns by looking at left-edge X positions of text spans.
+// In a multi-column layout, spans cluster into distinct X-position ranges.
+function detectPageColumns(spans) {
+    if (spans.length <= 1)
+        return [spans];
+    // Find X range
+    let pageMinX = Infinity;
+    let pageMaxX = -Infinity;
+    for (const s of spans) {
+        if (s.x < pageMinX)
+            pageMinX = s.x;
+        const x1 = s.x + s.width;
+        if (x1 > pageMaxX)
+            pageMaxX = x1;
+    }
+    const pageW = pageMaxX - pageMinX;
+    if (pageW < 100)
+        return [spans];
+    // Group spans by Y-line
+    const yLines = [];
+    let currentY = spans[0].y;
+    let currentLine = [spans[0]];
+    for (let i = 1; i < spans.length; i++) {
+        const s = spans[i];
+        if (Math.abs(s.y - currentY) <= s.fontSize * 0.3) {
+            currentLine.push(s);
+        }
+        else {
+            yLines.push(currentLine);
+            currentLine = [s];
+            currentY = s.y;
+        }
+    }
+    yLines.push(currentLine);
+    // Build X histogram: for each X bucket, count how many Y-lines have text there
+    const BUCKET = 5;
+    const nBuckets = Math.ceil(pageW / BUCKET);
+    const hist = new Float32Array(nBuckets);
+    for (const line of yLines) {
+        const covered = new Uint8Array(nBuckets);
+        for (const s of line) {
+            const b0 = Math.max(0, Math.floor((s.x - pageMinX) / BUCKET));
+            const b1 = Math.min(nBuckets - 1, Math.floor((s.x + s.width - pageMinX) / BUCKET));
+            for (let b = b0; b <= b1; b++)
+                covered[b] = 1;
+        }
+        for (let b = 0; b < nBuckets; b++)
+            hist[b] += covered[b];
+    }
+    // Find gutters: runs of low-coverage buckets (empty in most lines)
+    const threshold = yLines.length * 0.15;
+    const gutterXs = [];
+    let runStart = -1;
+    for (let b = 0; b <= nBuckets; b++) {
+        const val = b < nBuckets ? hist[b] : threshold + 1;
+        if (val <= threshold) {
+            if (runStart < 0)
+                runStart = b;
+        }
+        else if (runStart >= 0) {
+            const startX = pageMinX + runStart * BUCKET;
+            const endX = pageMinX + b * BUCKET;
+            const width = endX - startX;
+            if (width >= 10 && startX > pageMinX + 20 && endX < pageMaxX - 20) {
+                gutterXs.push((startX + endX) / 2);
+            }
+            runStart = -1;
+        }
+    }
+    if (gutterXs.length === 0)
+        return [spans];
+    // Split spans into columns at gutter positions.
+    // Process by Y-line and split at gutters to keep justified text together.
+    const nCols = gutterXs.length + 1;
+    const columns = Array.from({ length: nCols }, () => []);
+    for (const line of yLines) {
+        const sorted = [...line].sort((a, b) => a.x - b.x);
+        // Split into groups at gutter boundaries
+        const groups = [[]];
+        for (const span of sorted) {
+            const lastGroup = groups[groups.length - 1];
+            if (lastGroup.length > 0) {
+                const prevEnd = lastGroup[lastGroup.length - 1].x +
+                    lastGroup[lastGroup.length - 1].width;
+                let crosses = false;
+                for (const gx of gutterXs) {
+                    if (prevEnd < gx && span.x >= gx) {
+                        crosses = true;
+                        break;
+                    }
+                }
+                if (crosses)
+                    groups.push([span]);
+                else
+                    lastGroup.push(span);
+            }
+            else {
+                lastGroup.push(span);
+            }
+        }
+        // Assign each group to column
+        for (const group of groups) {
+            if (group.length === 0)
+                continue;
+            let col = 0;
+            for (let g = 0; g < gutterXs.length; g++) {
+                if (group[0].x >= gutterXs[g])
+                    col = g + 1;
+            }
+            for (const span of group)
+                columns[col].push(span);
+        }
+    }
+    return columns.filter((c) => c.length > 0);
+}
+function assignBlockNumbers(spans, startBlockNo = 0) {
+    if (spans.length === 0)
+        return;
+    // Group spans by line
+    const lines = new Map();
+    for (const span of spans) {
+        const arr = lines.get(span.lineNo) || [];
+        arr.push(span);
+        lines.set(span.lineNo, arr);
+    }
+    const lineGapCandidates = new Map();
+    const lineSpansByNo = new Map();
+    const sortedLineNos = [...lines.keys()].sort((a, b) => a - b);
+    for (const ln of sortedLineNos) {
+        const ls = [...lines.get(ln)].sort((a, b) => a.x - b.x);
+        lineSpansByNo.set(ln, ls);
+        const avgFontSize = ls.reduce((sum, s) => sum + s.fontSize, 0) / ls.length;
+        if (avgFontSize < 12) {
+            lineGapCandidates.set(ln, []);
+            continue;
+        }
+        const splitGap = Math.max(avgFontSize * 3, 40);
+        const splitPositions = [];
+        for (let i = 1; i < ls.length; i++) {
+            const prev = ls[i - 1];
+            const curr = ls[i];
+            const gap = curr.x - (prev.x + prev.width);
+            const fontRatio = Math.max(prev.fontSize, curr.fontSize) /
+                Math.min(prev.fontSize, curr.fontSize);
+            // When font size clearly differs, spans are separate visual elements even if
+            // close together (e.g. bold heading label next to body text list). Use a
+            // smaller gap threshold for such cases.
+            const fontSizeDiffers = fontRatio > 1.1;
+            const effectiveSplitGap = fontSizeDiffers ? Math.max(avgFontSize * 0.5, 8) : splitGap;
+            if (gap > effectiveSplitGap) {
+                const forceSplit = prev.color !== curr.color ||
+                    prev.fontName !== curr.fontName ||
+                    fontSizeDiffers;
+                splitPositions.push({ x: curr.x, force: forceSplit });
+            }
+        }
+        lineGapCandidates.set(ln, splitPositions);
+    }
+    const lineBounds = [];
+    for (const ln of sortedLineNos) {
+        const ls = lineSpansByNo.get(ln);
+        const splitCandidates = lineGapCandidates.get(ln);
+        const avgFontSize = ls.reduce((sum, s) => sum + s.fontSize, 0) / ls.length;
+        const tolerance = Math.max(avgFontSize, 20);
+        const repeatedSplits = splitCandidates
+            .filter((candidate) => {
+            if (candidate.force)
+                return true;
+            return sortedLineNos.some((otherLn) => {
+                if (otherLn === ln)
+                    return false;
+                if (Math.abs(otherLn - ln) > 2)
+                    return false;
+                return (lineGapCandidates.get(otherLn) || []).some((otherPos) => Math.abs(otherPos.x - candidate.x) <= tolerance);
+            });
+        })
+            .map((candidate) => candidate.x);
+        const segments = [[]];
+        for (const span of ls) {
+            if (segments[segments.length - 1].length > 0 &&
+                repeatedSplits.some((pos) => span.x >= pos - 5)) {
+                const prevEnd = segments[segments.length - 1][segments[segments.length - 1].length - 1].x +
+                    segments[segments.length - 1][segments[segments.length - 1].length - 1].width;
+                const crossingSplit = repeatedSplits.some((pos) => prevEnd < pos && span.x >= pos - 5);
+                if (crossingSplit) {
+                    segments.push([span]);
+                    continue;
+                }
+            }
+            segments[segments.length - 1].push(span);
+        }
+        for (const segment of segments) {
+            lineBounds.push({
+                lineNo: ln,
+                spans: segment,
+                x0: Math.min(...segment.map((s) => s.x)),
+                x1: Math.max(...segment.map((s) => s.x + s.width)),
+                y0: Math.min(...segment.map((s) => s.y)),
+                y1: Math.max(...segment.map((s) => s.y + s.height)),
+            });
+        }
+    }
+    // Merge consecutive lines into blocks if they overlap in X and are close in Y
+    let blockNo = startBlockNo;
+    let currentBlock = [lineBounds[0]];
+    function assignBlock(lbs, bn) {
+        for (const lb of lbs) {
+            for (const span of lb.spans) {
+                span.blockNo = bn;
+            }
+        }
+    }
+    for (let i = 1; i < lineBounds.length; i++) {
+        const prev = currentBlock[currentBlock.length - 1];
+        const curr = lineBounds[i];
+        // Check Y gap
+        const yGap = curr.y0 - prev.y1;
+        const prevFontSize = prev.spans[0].fontSize;
+        const currFontSize = curr.spans[0].fontSize;
+        const avgFontSize = (prevFontSize + currFontSize) / 2;
+        // A significant font size change signals a new section (e.g., heading → body)
+        // Only apply across different lines — within the same line, font size changes
+        // are usually small caps or superscripts, not section breaks
+        const fontSizeRatio = Math.max(prevFontSize, currFontSize) /
+            Math.min(prevFontSize, currFontSize);
+        const onSameLine = prev.spans[0].lineNo === curr.spans[0].lineNo;
+        const fontSizeChanged = !onSameLine && fontSizeRatio > 1.15;
+        // Color change between lines signals different text elements (e.g. diagram
+        // labels in different colors: gray "Force control signal" vs black "Inter-neurons").
+        // Only split on color when X overlap is weak — paragraph lines have strong overlap
+        // even if color extraction is noisy (e.g. 6.pdf body text on dark background).
+        const prevLineSpans = prev.spans;
+        const currLineSpans = curr.spans;
+        const prevColor = prevLineSpans.reduce((a, b) => a.text.length > b.text.length ? a : b).color;
+        const currColor = currLineSpans.reduce((a, b) => a.text.length > b.text.length ? a : b).color;
+        // Check X overlap
+        const xOverlap = Math.min(prev.x1, curr.x1) - Math.max(prev.x0, curr.x0);
+        const narrowerWidth = Math.min(prev.x1 - prev.x0, curr.x1 - curr.x0);
+        const colorChanged = !onSameLine &&
+            prevColor !== currColor &&
+            xOverlap < narrowerWidth * 0.5;
+        const prevCenter = (prev.x0 + prev.x1) / 2;
+        const currCenter = (curr.x0 + curr.x1) / 2;
+        const largeSingleSpanDisplayShift = !onSameLine &&
+            avgFontSize >= 80 &&
+            prevLineSpans.length === 1 &&
+            currLineSpans.length === 1 &&
+            Math.abs(prev.x0 - curr.x0) > avgFontSize * 0.2 &&
+            Math.abs(prev.x1 - curr.x1) > avgFontSize * 0.2 &&
+            Math.abs(prevCenter - currCenter) > avgFontSize * 0.2;
+        if (!fontSizeChanged &&
+            !colorChanged &&
+            !largeSingleSpanDisplayShift &&
+            yGap < avgFontSize * 0.5 &&
+            (xOverlap > 0 || Math.abs(prev.x0 - curr.x0) < avgFontSize * 2)) {
+            currentBlock.push(curr);
+        }
+        else {
+            assignBlock(currentBlock, blockNo);
+            blockNo++;
+            currentBlock = [curr];
+        }
+    }
+    assignBlock(currentBlock, blockNo);
+}
+//# sourceMappingURL=text-layout.js.map

package/lib/text-span-extractor.d.ts

@@ -0,0 +1,5 @@
+import type { PositionColor } from './operator-list.js';
+import type { TextSpan } from './text-types.js';
+export declare function extractTextSpans(items: any[], // pdfjs TextItem[]
+yFlipOffset: number, positionColors: PositionColor[], fontNameMap?: Map<string, string>, fontAscentMap?: Map<string, number>): TextSpan[];
+//# sourceMappingURL=text-span-extractor.d.ts.map

package/lib/text-span-extractor.js

@@ -0,0 +1,271 @@
+function hasSyntheticItalic(a, b, c, d) {
+    const xAxisLength = Math.hypot(a, b);
+    const yAxisLength = Math.hypot(c, d);
+    if (xAxisLength < 0.001 || yAxisLength < 0.001)
+        return false;
+    // Pure rotation keeps the text axes orthogonal. Synthetic italic skews them
+    // so the transformed X/Y axes stop being perpendicular.
+    const orthogonality = Math.abs(a * c + b * d) / (xAxisLength * yAxisLength);
+    return orthogonality > 0.15;
+}
+export function extractTextSpans(items, // pdfjs TextItem[]
+yFlipOffset, positionColors, fontNameMap, fontAscentMap) {
+    const spans = [];
+    // Pre-index positionColors by fontName for O(1) lookup instead of O(n) filter
+    const pcByFont = new Map();
+    for (const pc of positionColors) {
+        let arr = pcByFont.get(pc.fontName);
+        if (!arr) {
+            arr = [];
+            pcByFont.set(pc.fontName, arr);
+        }
+        arr.push(pc);
+    }
+    for (const item of items) {
+        if (!item.str || !item.str.trim())
+            continue;
+        if (!item.transform)
+            continue;
+        const [a, b, c, d, tx, ty] = item.transform;
+        const fontSize = Math.sqrt(a * a + b * b);
+        if (fontSize < 4)
+            continue;
+        const x = tx;
+        const w = item.width;
+        // ty is baseline in PDF coords (bottom-up). Convert to top-left Y (top-down).
+        // Use font ascent to find glyph top (distance from baseline to top of glyphs).
+        // pdfjs item.height = fontSize, but the visual top is ascent * fontSize above baseline.
+        const loadedNameForAscent = item.fontName || '';
+        const ascent = fontAscentMap?.get(loadedNameForAscent) ?? 1.0;
+        const ascentPx = fontSize * Math.max(ascent, 0.5);
+        const y = yFlipOffset - ty - ascentPx;
+        const baselineY = y + ascentPx;
+        const h = item.height || fontSize;
+        const rawRotation = (-Math.atan2(b, a) * 180) / Math.PI;
+        const rotation = Math.abs(rawRotation) < 2 ? 0 : rawRotation;
+        // Resolve real PDF font name from pdfjs internal loadedName
+        const loadedName = item.fontName || '';
+        const fontName = fontNameMap?.get(loadedName) || loadedName;
+        // Find closest color and orderIndex from operator list.
+        // Match by font name + size first, then font name only, then any.
+        let color = '#000000';
+        let orderIndex = 0;
+        if (positionColors.length > 0) {
+            const sameFontCandidates = pcByFont.get(loadedName) || [];
+            const sameFontAndSize = sameFontCandidates.filter((pc) => Math.abs(pc.fontSize - fontSize) < fontSize * 0.1);
+            const pickBest = (candidates) => fontSize < 18
+                ? selectClosestXPositionColor(candidates, x)
+                : selectBestPositionColor(candidates, x, baselineY, fontSize);
+            const bestMatch = pickBest(sameFontAndSize) ??
+                pickBest(sameFontCandidates) ??
+                pickBest(positionColors);
+            if (bestMatch) {
+                color = bestMatch.color;
+            }
+            const orderMatch = selectClosestXPositionColor(sameFontCandidates, x) ??
+                selectClosestXPositionColor(positionColors, x);
+            if (orderMatch)
+                orderIndex = orderMatch.orderIndex;
+        }
+        // Detect weight/style from font name
+        const lower = fontName.toLowerCase();
+        // Google Fonts variable font naming: Arimo_700wght
+        const wghtMatch = lower.match(/_(\d+)wght/);
+        const fontWeight = wghtMatch
+            ? (parseInt(wghtMatch[1], 10) >= 600 ? 'bold' : 'normal')
+            : (lower.includes('bold') ||
+                lower.includes('heavy') ||
+                lower.includes('black'))
+                ? 'bold'
+                : 'normal';
+        // Detect italic: from font name OR from non-orthogonal text axes
+        // (synthetic italic). Pure rotation should not count as italic.
+        const hasShear = hasSyntheticItalic(a, b, c, d);
+        const fontStyle = lower.includes('italic') || lower.includes('oblique') || hasShear
+            ? 'italic'
+            : 'normal';
+        spans.push({
+            text: item.str,
+            fontName,
+            fontSize,
+            x,
+            y,
+            baselineY,
+            rotation,
+            width: w,
+            height: h,
+            color,
+            fontWeight,
+            fontStyle,
+            blockNo: -1, // assigned during grouping
+            lineNo: -1,
+            orderIndex,
+        });
+    }
+    // Remove exact duplicate spans — some PDFs paint the same text twice at the
+    // same position (e.g. fill + stroke, or accessibility overlay).
+    deduplicateSpans(spans);
+    dedupeOrderIndices(spans, positionColors);
+    return spans;
+}
+/**
+ * Remove duplicate/overlapping spans painted multiple times at the same position.
+ * Handles both exact duplicates and overlapping text passes (e.g. "LA · L" then
+ * "LA · LV" at nearly the same X/Y) — keeps only the longest span.
+ */
+function deduplicateSpans(spans) {
+    const removed = new Set();
+    // Group by rounded Y + fontSize to find co-located spans
+    const byLine = new Map();
+    for (let i = 0; i < spans.length; i++) {
+        const key = `${Math.round(spans[i].y)}|${Math.round(spans[i].fontSize)}`;
+        const arr = byLine.get(key) || [];
+        arr.push(i);
+        byLine.set(key, arr);
+    }
+    for (const indices of byLine.values()) {
+        for (let a = 0; a < indices.length; a++) {
+            if (removed.has(indices[a]))
+                continue;
+            const sa = spans[indices[a]];
+            const aEnd = sa.x + sa.width;
+            for (let b = a + 1; b < indices.length; b++) {
+                if (removed.has(indices[b]))
+                    continue;
+                const sb = spans[indices[b]];
+                const bEnd = sb.x + sb.width;
+                // Check if one span's X range is fully contained within the other's
+                const aContainsB = sb.x >= sa.x - 1 && bEnd <= aEnd + 1;
+                const bContainsA = sa.x >= sb.x - 1 && aEnd <= bEnd + 1;
+                if (!aContainsB && !bContainsA)
+                    continue;
+                // Exact duplicate or one text contains/matches the other
+                if (sa.text === sb.text || (aContainsB && sa.text.includes(sb.text))) {
+                    removed.add(indices[b]);
+                }
+                else if (bContainsA && sb.text.includes(sa.text)) {
+                    removed.add(indices[a]);
+                    break; // sa is removed, stop comparing it
+                }
+            }
+        }
+    }
+    if (removed.size === 0)
+        return;
+    let write = 0;
+    for (let i = 0; i < spans.length; i++) {
+        if (!removed.has(i))
+            spans[write++] = spans[i];
+    }
+    spans.length = write;
+}
+function selectBestPositionColor(candidates, x, y, fontSize) {
+    if (candidates.length === 0)
+        return null;
+    let bestXDist = Infinity;
+    for (const pc of candidates) {
+        bestXDist = Math.min(bestXDist, Math.abs(pc.x - x));
+    }
+    const xMatches = candidates.filter((pc) => Math.abs(pc.x - x) <= bestXDist + 1);
+    const xTrustLimit = fontSize >= 40 ? fontSize * 0.5 : fontSize * 1.5;
+    const yTrustLimit = fontSize * 1.5;
+    if (xMatches.length === 1 &&
+        bestXDist <= xTrustLimit &&
+        Math.abs(xMatches[0].y - y) <= yTrustLimit) {
+        return xMatches[0];
+    }
+    if (xMatches.length > 1 && bestXDist <= xTrustLimit) {
+        if (fontSize < 18) {
+            return xMatches[0];
+        }
+        const saneXMatches = xMatches.filter((pc) => Math.abs(pc.y - y) <= yTrustLimit);
+        if (saneXMatches.length === 1) {
+            return saneXMatches[0];
+        }
+        if (saneXMatches.length > 1) {
+            let bestYDist = Infinity;
+            for (const pc of saneXMatches) {
+                bestYDist = Math.min(bestYDist, Math.abs(pc.y - y));
+            }
+            const tolerance = Math.max(fontSize * 0.3, 4);
+            const nearMatches = saneXMatches.filter((pc) => Math.abs(pc.y - y) <= bestYDist + tolerance);
+            return nearMatches.reduce((best, current) => Math.abs(current.y - y) < Math.abs(best.y - y) ? current : best);
+        }
+    }
+    let bestScore = Infinity;
+    let best = null;
+    const scored = [];
+    for (const pc of candidates) {
+        const xDist = Math.abs(pc.x - x);
+        const yDist = Math.abs(pc.y - y);
+        const score = xDist + yDist * 3;
+        scored.push({ pc, score });
+        if (score < bestScore) {
+            bestScore = score;
+            best = pc;
+        }
+    }
+    if (!best)
+        return null;
+    // PDFs sometimes paint the same text multiple times at nearly the same position
+    // (e.g. fill + shadow/overlay). For near-equivalent matches, prefer the last
+    // painted candidate since that's what ends up visually on top.
+    const tolerance = Math.max(fontSize * 0.3, 4);
+    const nearMatches = scored
+        .filter(({ score }) => score <= bestScore + tolerance)
+        .map(({ pc }) => pc);
+    return nearMatches.reduce((latest, current) => current.orderIndex > latest.orderIndex ? current : latest);
+}
+function selectClosestXPositionColor(candidates, x) {
+    if (candidates.length === 0)
+        return null;
+    let best = null;
+    let bestXDist = Infinity;
+    for (const pc of candidates) {
+        const xDist = Math.abs(pc.x - x);
+        if (xDist < bestXDist) {
+            bestXDist = xDist;
+            best = pc;
+        }
+    }
+    return best;
+}
+function dedupeOrderIndices(spans, positionColors) {
+    // Deduplicate orderIndex: when multiple spans share the same orderIndex AND
+    // nearly identical X (within 1px), they're stacked texts that all matched the
+    // same positionColor. Reassign using Y-sorted positionColors with same font/X.
+    if (positionColors.length === 0)
+        return;
+    const byOrder = new Map(); // orderIndex → span indices
+    for (let si = 0; si < spans.length; si++) {
+        const oi = spans[si].orderIndex;
+        const arr = byOrder.get(oi) || [];
+        arr.push(si);
+        byOrder.set(oi, arr);
+    }
+    for (const [oi, indices] of byOrder) {
+        if (indices.length <= 1)
+            continue;
+        // Check that all spans in this group have nearly identical X (stacked column)
+        const xs = indices.map((i) => spans[i].x);
+        const xRange = Math.max(...xs) - Math.min(...xs);
+        if (xRange > 1)
+            continue; // Not truly stacked — different X positions
+        // Find the matched positionColor
+        const matchedPC = positionColors.find((pc) => pc.orderIndex === oi);
+        if (!matchedPC)
+            continue;
+        // Find nearby positionColors: same font, X within 1px of matched PC
+        const nearbyPCs = positionColors
+            .filter((pc) => pc.fontName === matchedPC.fontName && Math.abs(pc.x - matchedPC.x) < 1)
+            .sort((a, b) => a.y - b.y);
+        if (nearbyPCs.length < indices.length)
+            continue;
+        // Sort spans by Y and assign positionColors in Y order
+        indices.sort((a, b) => spans[a].y - spans[b].y);
+        for (let k = 0; k < indices.length; k++) {
+            spans[indices[k]].orderIndex = nearbyPCs[k].orderIndex;
+        }
+    }
+}
+//# sourceMappingURL=text-span-extractor.js.map

package/lib/text-types.d.ts

@@ -0,0 +1,25 @@
+export interface TextSpan {
+    text: string;
+    fontName: string;
+    fontSize: number;
+    x: number;
+    y: number;
+    baselineY: number;
+    rotation: number;
+    width: number;
+    height: number;
+    color: string;
+    fontWeight: string;
+    fontStyle: string;
+    blockNo: number;
+    lineNo: number;
+    orderIndex: number;
+}
+export interface TextBlock {
+    spans: TextSpan[];
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+//# sourceMappingURL=text-types.d.ts.map

package/lib/text-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=text-types.js.map

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@polotno/pdf-import",
+  "version": "0.0.1",
+  "description": "Convert PDF files into Polotno JSON format",
+  "type": "module",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./lib/index.js",
+      "types": "./lib/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc && node build.js",
+    "test": "vitest run tests/index.test.ts",
+    "test:update": "vitest run tests/index.test.ts --update",
+    "test:visual": "node --max-old-space-size=4096 ./node_modules/.bin/vitest run --config vitest.visual.config.ts tests/visual-regression.test.ts",
+    "dev": "vite client"
+  },
+  "author": "Anton Lavrenov",
+  "files": [
+    "lib",
+    "README.md"
+  ],
+  "dependencies": {
+    "opentype.js": "^1.3.4",
+    "pdfjs-dist": "^4.10.38"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^5.1.4",
+    "esbuild": "^0.27.3",
+    "polotno": "^2.37.1",
+    "polotno-node": "^2.15.13",
+    "react": "^18.3.1",
+    "react-dom": "^18",
+    "sharp": "^0.34.5",
+    "ssim.js": "^3.5.0",
+    "typescript": "~5.9.3",
+    "vite": "^7.3.1",
+    "vitest": "^4.0.18"
+  }
+}