@polotno/pdf-import 0.0.1

package/lib/pdf-image-extractor.js

@@ -0,0 +1,91 @@
+// Extract raw image streams (e.g. JPEG) directly from PDF binary,
+// avoiding pdfjs's decode-to-pixels path which loses compression.
+/**
+ * Build a lookup from PDF object number to its raw JPEG stream data.
+ * Only indexes image XObjects with DCTDecode (JPEG) filter.
+ */
+export function buildJpegIndex(pdfBytes) {
+    const result = new Map();
+    const latin1 = uint8ToLatin1(pdfBytes);
+    // Find each "N 0 obj <<" and parse the dictionary with proper nesting
+    const objStartRegex = /(\d+) 0 obj\s*<</g;
+    let match;
+    while ((match = objStartRegex.exec(latin1)) !== null) {
+        const objNum = parseInt(match[1], 10);
+        const dictStart = match.index + match[0].length;
+        // Walk forward handling nested << >> to find the closing >>
+        let depth = 1;
+        let pos = dictStart;
+        while (depth > 0 && pos < latin1.length - 1) {
+            if (latin1[pos] === '<' && latin1[pos + 1] === '<') {
+                depth++;
+                pos += 2;
+            }
+            else if (latin1[pos] === '>' && latin1[pos + 1] === '>') {
+                depth--;
+                pos += 2;
+            }
+            else {
+                pos++;
+            }
+        }
+        const dict = latin1.substring(dictStart, pos - 2);
+        // Check if "stream" follows the closing >>
+        const afterDict = latin1.substring(pos, pos + 20);
+        const streamMatch = afterDict.match(/^\s*stream\r?\n/);
+        if (!streamMatch)
+            continue;
+        // Only care about image XObjects with DCTDecode filter
+        if (!dict.includes('/Subtype /Image'))
+            continue;
+        if (!dict.includes('/DCTDecode'))
+            continue;
+        // Extract /Length value (may be a direct number or indirect ref "N 0 R")
+        const lengthMatch = dict.match(/\/Length\s+(\d+)(\s+0\s+R)?/);
+        if (!lengthMatch)
+            continue;
+        let length;
+        if (lengthMatch[2]) {
+            // Indirect reference — resolve by finding the referenced object
+            const refObjNum = lengthMatch[1];
+            const refMatch = latin1.match(new RegExp(refObjNum + '\\s+0\\s+obj\\s+(\\d+)'));
+            if (!refMatch)
+                continue;
+            length = parseInt(refMatch[1], 10);
+        }
+        else {
+            length = parseInt(lengthMatch[1], 10);
+        }
+        // Stream data starts right after "stream\r\n" or "stream\n"
+        const streamStart = pos + streamMatch[0].length;
+        const streamData = pdfBytes.slice(streamStart, streamStart + length);
+        // Verify JPEG magic bytes (FFD8)
+        if (streamData[0] !== 0xff || streamData[1] !== 0xd8)
+            continue;
+        result.set(objNum, {
+            data: streamData,
+            mimeType: 'image/jpeg',
+        });
+    }
+    return result;
+}
+/**
+ * Parse a pdfjs ref string like "44R" to extract the object number.
+ */
+export function parseRef(ref) {
+    const m = ref.match(/^(\d+)R$/);
+    return m ? parseInt(m[1], 10) : null;
+}
+function uint8ToLatin1(bytes) {
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(bytes).toString('latin1');
+    }
+    const chunks = [];
+    const chunkSize = 65536;
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+        const slice = bytes.subarray(i, Math.min(i + chunkSize, bytes.length));
+        chunks.push(String.fromCharCode(...slice));
+    }
+    return chunks.join('');
+}
+//# sourceMappingURL=pdf-image-extractor.js.map

package/lib/svg-builder.d.ts

@@ -0,0 +1,23 @@
+import type { ExtractedDrawing, DrawingItem } from './operator-list.js';
+export declare function drawingToSvg(drawing: ExtractedDrawing, pageWidth: number, pageHeight: number): {
+    svg: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null;
+export declare function clippedDrawingsToSvg(drawings: ExtractedDrawing[]): {
+    svg: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null;
+/**
+ * Convert clip path items to an SVG string for use as clipSrc.
+ * Coordinates are made relative to the image's position (imgX, imgY).
+ * The viewBox matches the image dimensions so the clip aligns properly.
+ */
+export declare function clipPathToSvg(items: DrawingItem[], imgX: number, imgY: number, imageWidth: number, imageHeight: number): string;
+export declare function svgToDataUri(svg: string): string;
+//# sourceMappingURL=svg-builder.d.ts.map

package/lib/svg-builder.js

@@ -0,0 +1,213 @@
+import { rgbTupleToHex } from './color-utils.js';
+function computeDrawingBounds(drawing, pageWidth, pageHeight) {
+    let [x0, y0, x1, y1] = drawing.rect;
+    const sw = drawing.stroke ? drawing.strokeWidth || 1 : 0;
+    // Expand bounds by stroke width/2 so strokes aren't clipped at edges
+    if (sw > 0) {
+        const half = sw / 2;
+        x0 -= half;
+        y0 -= half;
+        x1 += half;
+        y1 += half;
+    }
+    // For stroked lines with zero/tiny width or height, expand to ensure visibility.
+    const minDim = Math.max(sw, 2); // at least 2px so lines are visible
+    if (x1 - x0 < minDim && sw > 0) {
+        const mid = (x0 + x1) / 2;
+        x0 = mid - minDim / 2;
+        x1 = mid + minDim / 2;
+    }
+    if (y1 - y0 < minDim && sw > 0) {
+        const mid = (y0 + y1) / 2;
+        y0 = mid - minDim / 2;
+        y1 = mid + minDim / 2;
+    }
+    const width = x1 - x0;
+    const height = y1 - y0;
+    if (width < 0.1 && height < 0.1)
+        return null;
+    // Skip full-page background rectangles
+    if (drawing.fill !== null &&
+        pageWidth > 0 &&
+        pageHeight > 0 &&
+        width >= pageWidth * 0.9 &&
+        height >= pageHeight * 0.9) {
+        return null;
+    }
+    return { x0, y0, width, height };
+}
+function buildPathData(items, originX, originY, shouldCloseFill, closePath) {
+    const pathParts = [];
+    let cur = null;
+    let subStart = null;
+    const EPS = 0.5;
+    function gap(px, py) {
+        return (cur === null || Math.abs(px - cur[0]) > EPS || Math.abs(py - cur[1]) > EPS);
+    }
+    function move(px, py) {
+        pathParts.push(`M ${px - originX} ${py - originY}`);
+        cur = [px, py];
+        subStart = [px, py];
+    }
+    for (const item of items) {
+        if (item.kind === 're') {
+            const rx = item.x - originX;
+            const ry = item.y - originY;
+            pathParts.push(`M ${rx} ${ry} h ${item.w} v ${item.h} h ${-item.w} Z`);
+            cur = [item.x, item.y];
+            subStart = cur;
+        }
+        else if (item.kind === 'm') {
+            move(item.x, item.y);
+        }
+        else if (item.kind === 'l') {
+            if (gap(item.x1, item.y1)) {
+                move(item.x1, item.y1);
+            }
+            pathParts.push(`L ${item.x2 - originX} ${item.y2 - originY}`);
+            cur = [item.x2, item.y2];
+        }
+        else if (item.kind === 'c') {
+            if (gap(item.x1, item.y1)) {
+                move(item.x1, item.y1);
+            }
+            pathParts.push(`C ${item.cpx1 - originX} ${item.cpy1 - originY} ${item.cpx2 - originX} ${item.cpy2 - originY} ${item.x2 - originX} ${item.y2 - originY}`);
+            cur = [item.x2, item.y2];
+        }
+    }
+    if (shouldCloseFill && subStart && cur) {
+        if (gap(subStart[0], subStart[1])) {
+            pathParts.push(`L ${subStart[0] - originX} ${subStart[1] - originY}`);
+        }
+        pathParts.push('Z');
+    }
+    else if (closePath) {
+        pathParts.push('Z');
+    }
+    return pathParts.join(' ');
+}
+export function drawingToSvg(drawing, pageWidth, pageHeight) {
+    const bounds = computeDrawingBounds(drawing, pageWidth, pageHeight);
+    if (!bounds)
+        return null;
+    const { x0, y0, width: w, height: h } = bounds;
+    const fillHex = drawing.fill ? rgbTupleToHex(...drawing.fill) : 'none';
+    const strokeHex = drawing.stroke
+        ? rgbTupleToHex(...drawing.stroke)
+        : 'none';
+    const dAttr = buildPathData(drawing.items, x0, y0, fillHex !== 'none', drawing.closePath);
+    const strokeAttr = drawing.stroke
+        ? `stroke="${strokeHex}" stroke-width="${drawing.strokeWidth}"`
+        : 'stroke="none"';
+    const fillRule = drawing.evenOdd ? ' fill-rule="evenodd"' : '';
+    // Build SVG with optional gradient definition
+    let defs = '';
+    let fillValue = fillHex;
+    if (drawing.gradient && drawing.gradient.stops.length > 0) {
+        const g = drawing.gradient;
+        // Detect grayscale gradients (luminosity masks used as overlays in PDF).
+        // Convert them to alpha-based gradients: luminosity → stop-opacity, color → black.
+        const isGrayscale = g.stops.every((s) => {
+            const m = s.color.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
+            if (!m)
+                return false;
+            const r = parseInt(m[1], 16), gv = parseInt(m[2], 16), b = parseInt(m[3], 16);
+            return Math.abs(r - gv) <= 2 && Math.abs(gv - b) <= 2;
+        });
+        const stopsStr = g.stops
+            .map((s) => {
+            if (isGrayscale) {
+                const m = s.color.match(/^#([0-9a-f]{2})/i);
+                const luminosity = m ? parseInt(m[1], 16) / 255 : 0;
+                return `<stop offset="${s.offset}" stop-color="#000000" stop-opacity="${luminosity}"/>`;
+            }
+            return `<stop offset="${s.offset}" stop-color="${s.color}"/>`;
+        })
+            .join('');
+        if (g.type === 'linear') {
+            // Use objectBoundingBox units — normalize gradient direction to 0-1
+            // Determine primary direction from the raw gradient coordinates
+            const dx = (g.x2 ?? 0) - (g.x1 ?? 0);
+            const dy = (g.y2 ?? 0) - (g.y1 ?? 0);
+            const len = Math.sqrt(dx * dx + dy * dy);
+            // Normalize direction
+            let nx1 = 0, ny1 = 0.5, nx2 = 1, ny2 = 0.5; // default horizontal
+            if (len > 0) {
+                const ndx = dx / len;
+                const ndy = dy / len;
+                // Map direction to bounding box: 0,0 is top-left, 1,1 is bottom-right
+                nx1 = ndx < 0 ? 1 : 0;
+                ny1 = ndy < 0 ? 1 : 0;
+                nx2 = ndx < 0 ? 0 : (ndx > 0 ? 1 : nx1);
+                ny2 = ndy < 0 ? 0 : (ndy > 0 ? 1 : ny1);
+            }
+            defs = `<defs><linearGradient id="g" x1="${nx1}" y1="${ny1}" x2="${nx2}" y2="${ny2}">${stopsStr}</linearGradient></defs>`;
+            fillValue = 'url(#g)';
+        }
+        else {
+            // Radial gradient — use objectBoundingBox with center at 0.5,0.5
+            defs = `<defs><radialGradient id="g" cx="0.5" cy="0.5" r="0.5">${stopsStr}</radialGradient></defs>`;
+            fillValue = 'url(#g)';
+        }
+    }
+    const svgStr = `<svg viewBox="0 0 ${w} ${h}" xmlns="http://www.w3.org/2000/svg">${defs}<path d="${dAttr}" fill="${fillValue}" ${strokeAttr}${fillRule}/></svg>`;
+    return { svg: svgStr, x: x0, y: y0, width: w, height: h };
+}
+export function clippedDrawingsToSvg(drawings) {
+    if (drawings.length === 0 ||
+        !drawings[0].clipRect ||
+        !drawings[0].clipPath) {
+        return null;
+    }
+    const [x0, y0, x1, y1] = drawings[0].clipRect;
+    const width = x1 - x0;
+    const height = y1 - y0;
+    if (width < 0.1 || height < 0.1)
+        return null;
+    const clipD = buildPathData(drawings[0].clipPath, x0, y0, true, true);
+    const clipRule = drawings[0].evenOdd ? ' clip-rule="evenodd"' : '';
+    const body = drawings
+        .map((drawing) => {
+        const fillHex = drawing.fill ? rgbTupleToHex(...drawing.fill) : 'none';
+        const strokeHex = drawing.stroke
+            ? rgbTupleToHex(...drawing.stroke)
+            : 'none';
+        const dAttr = buildPathData(drawing.items, x0, y0, fillHex !== 'none', drawing.closePath);
+        const strokeAttr = drawing.stroke
+            ? `stroke="${strokeHex}" stroke-width="${drawing.strokeWidth}"`
+            : 'stroke="none"';
+        const fillRule = drawing.evenOdd ? ' fill-rule="evenodd"' : '';
+        return `<path d="${dAttr}" fill="${fillHex}" ${strokeAttr}${fillRule}/>`;
+    })
+        .join('');
+    const svgStr = `<svg viewBox="0 0 ${width} ${height}" xmlns="http://www.w3.org/2000/svg"><defs><clipPath id="clip"><path d="${clipD}"${clipRule}/></clipPath></defs><g clip-path="url(#clip)">${body}</g></svg>`;
+    return { svg: svgStr, x: x0, y: y0, width, height };
+}
+/**
+ * Convert clip path items to an SVG string for use as clipSrc.
+ * Coordinates are made relative to the image's position (imgX, imgY).
+ * The viewBox matches the image dimensions so the clip aligns properly.
+ */
+export function clipPathToSvg(items, imgX, imgY, imageWidth, imageHeight) {
+    if (items.length === 0)
+        return '';
+    const dAttr = buildPathData(items, imgX, imgY, true, true);
+    return `<svg viewBox="0 0 ${imageWidth} ${imageHeight}" xmlns="http://www.w3.org/2000/svg"><path d="${dAttr}" fill="white"/></svg>`;
+}
+export function svgToDataUri(svg) {
+    let b64;
+    if (typeof Buffer !== 'undefined') {
+        b64 = Buffer.from(svg, 'utf-8').toString('base64');
+    }
+    else {
+        // Browser: encode UTF-8 bytes then btoa
+        const bytes = new TextEncoder().encode(svg);
+        let binary = '';
+        for (let i = 0; i < bytes.length; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        b64 = btoa(binary);
+    }
+    return `data:image/svg+xml;base64,${b64}`;
+}
+//# sourceMappingURL=svg-builder.js.map

package/lib/text-blocks.d.ts

@@ -0,0 +1,6 @@
+import type { TextBlock, TextSpan } from './text-types.js';
+export declare function groupSpansByBlock(spans: TextSpan[]): TextBlock[];
+export declare function detectAlignment(blockSpans: TextSpan[], pageWidth: number, leftMargin: number, rightMargin: number): string;
+export declare function estimatePageMargins(spans: TextSpan[]): [number, number];
+export declare function computeLineHeight(blockSpans: TextSpan[]): number;
+//# sourceMappingURL=text-blocks.d.ts.map

package/lib/text-blocks.js

@@ -0,0 +1,294 @@
+import { DEFAULT_LINE_HEIGHT } from './constants.js';
+// Group spans into blocks
+export function groupSpansByBlock(spans) {
+    const blockMap = new Map();
+    for (const span of spans) {
+        const arr = blockMap.get(span.blockNo) || [];
+        arr.push(span);
+        blockMap.set(span.blockNo, arr);
+    }
+    const blocks = [];
+    for (const [, blockSpans] of [...blockMap.entries()].sort((a, b) => a[0] - b[0])) {
+        const columns = splitBlockByColumn(blockSpans);
+        for (const colSpans of columns) {
+            colSpans.sort((a, b) => a.lineNo - b.lineNo || a.x - b.x);
+            const x = Math.min(...colSpans.map((s) => s.x));
+            const y = Math.min(...colSpans.map((s) => s.y));
+            const x1 = Math.max(...colSpans.map((s) => s.x + s.width));
+            const y1 = Math.max(...colSpans.map((s) => s.y + s.height));
+            blocks.push({
+                spans: colSpans,
+                x,
+                y,
+                width: x1 - x,
+                height: y1 - y,
+            });
+        }
+    }
+    return blocks;
+}
+/**
+ * Split a block into columns if it looks like a table row.
+ * Two strategies:
+ * 1. Gap-based: gaps at identical X positions in 100% of multi-span lines (tight 2px tolerance)
+ * 2. X-range: spans form distinct non-overlapping X-range groups with clear gaps between them
+ */
+function splitBlockByColumn(spans) {
+    if (spans.length <= 1)
+        return [spans];
+    // Strategy 1: Gap-based detection (for rows where columns share lines)
+    const lines = new Map();
+    for (const s of spans) {
+        const arr = lines.get(s.lineNo) || [];
+        arr.push(s);
+        lines.set(s.lineNo, arr);
+    }
+    const multiSpanLines = new Map();
+    for (const [lineNo, lineSpans] of lines) {
+        if (lineSpans.length > 1) {
+            multiSpanLines.set(lineNo, lineSpans);
+        }
+    }
+    if (multiSpanLines.size >= 2) {
+        const gapPositions = [];
+        for (const [, lineSpans] of multiSpanLines) {
+            const sorted = [...lineSpans].sort((a, b) => a.x - b.x);
+            for (let i = 1; i < sorted.length; i++) {
+                const prevEnd = sorted[i - 1].x + sorted[i - 1].width;
+                const gap = sorted[i].x - prevEnd;
+                if (gap > sorted[i].fontSize * 0.3) {
+                    gapPositions.push(sorted[i].x);
+                }
+            }
+        }
+        if (gapPositions.length > 0) {
+            gapPositions.sort((a, b) => a - b);
+            const clusters = [
+                { x: gapPositions[0], count: 1 },
+            ];
+            for (let i = 1; i < gapPositions.length; i++) {
+                const last = clusters[clusters.length - 1];
+                if (gapPositions[i] - last.x < 2) {
+                    last.x =
+                        (last.x * last.count + gapPositions[i]) / (last.count + 1);
+                    last.count++;
+                }
+                else {
+                    clusters.push({ x: gapPositions[i], count: 1 });
+                }
+            }
+            const splitPositions = clusters
+                .filter((c) => c.count >= multiSpanLines.size)
+                .map((c) => c.x);
+            if (splitPositions.length > 0) {
+                return splitSpansAtPositions(spans, splitPositions);
+            }
+        }
+    }
+    // Strategy 2: X-range clustering (for rows where columns DON'T share lines)
+    // Group spans by their X start position into clusters
+    if (spans.length < 2)
+        return [spans];
+    const avgFontSize = spans.reduce((sum, s) => sum + s.fontSize, 0) / spans.length;
+    const sorted = [...spans].sort((a, b) => a.x - b.x);
+    const xGroups = [];
+    for (const s of sorted) {
+        const end = s.x + s.width;
+        const last = xGroups[xGroups.length - 1];
+        if (last && s.x < last.maxEnd + avgFontSize * 0.5) {
+            // Overlaps or nearly touches the current group
+            last.maxEnd = Math.max(last.maxEnd, end);
+            last.spans.push(s);
+        }
+        else {
+            xGroups.push({ minX: s.x, maxEnd: end, spans: [s] });
+        }
+    }
+    if (xGroups.length < 2)
+        return [spans];
+    // Verify clear gaps between groups (at least fontSize * 0.5)
+    let allClear = true;
+    for (let i = 1; i < xGroups.length; i++) {
+        const gap = xGroups[i].minX - xGroups[i - 1].maxEnd;
+        if (gap < avgFontSize * 0.5) {
+            allClear = false;
+            break;
+        }
+    }
+    if (!allClear)
+        return [spans];
+    // Single-line labels can be widely separated on the same row (diagram labels,
+    // navigation items). Split when gaps are much larger than normal word spacing.
+    if (lines.size === 1 && xGroups.length >= 2) {
+        const gaps = xGroups.slice(1).map((group, index) => {
+            return group.minX - xGroups[index].maxEnd;
+        });
+        if (gaps.every((gap) => gap >= avgFontSize * 3)) {
+            return xGroups.map((g) => g.spans);
+        }
+    }
+    // Strong signal: every X-range has repeated content across the block.
+    if (xGroups.every((g) => g.spans.length >= 2))
+        return xGroups.map((g) => g.spans);
+    // Diagram labels often mix stacked multi-line labels with nearby single-span
+    // labels on the same visual row. Keep a narrow fallback for these small-font,
+    // multi-line blocks so unrelated labels don't get merged into one text box.
+    if (lines.size >= 2 && avgFontSize <= 8 && xGroups.length >= 3) {
+        return xGroups.map((g) => g.spans);
+    }
+    return [spans];
+}
+function splitSpansAtPositions(spans, splitPositions) {
+    const nCols = splitPositions.length + 1;
+    const columns = Array.from({ length: nCols }, () => []);
+    for (const span of spans) {
+        let col = 0;
+        for (let i = 0; i < splitPositions.length; i++) {
+            if (span.x >= splitPositions[i] - 5)
+                col = i + 1;
+        }
+        columns[col].push(span);
+    }
+    return columns.filter((c) => c.length > 0);
+}
+// Alignment detection
+export function detectAlignment(blockSpans, pageWidth, leftMargin, rightMargin) {
+    const lines = new Map();
+    for (const span of blockSpans) {
+        const arr = lines.get(span.lineNo) || [];
+        arr.push(span);
+        lines.set(span.lineNo, arr);
+    }
+    if (lines.size === 0)
+        return 'left';
+    const lineBounds = [...lines.values()].map((ls) => ({
+        x0: Math.min(...ls.map((s) => s.x)),
+        x1: Math.max(...ls.map((s) => s.x + s.width)),
+    }));
+    let textWidth = rightMargin - leftMargin;
+    if (textWidth <= 0)
+        textWidth = pageWidth;
+    // Single-line block
+    if (lineBounds.length === 1) {
+        const { x0, x1 } = lineBounds[0];
+        const blockCenter = (x0 + x1) / 2;
+        const pageCenter = (leftMargin + rightMargin) / 2;
+        const centerTol = textWidth * 0.05;
+        const rightTol = textWidth * 0.05;
+        if (Math.abs(blockCenter - pageCenter) < centerTol)
+            return 'center';
+        // Only classify as right-aligned if the line is short relative to the text
+        // area — a near-full-width line that happens to align with the right margin
+        // is more likely a paragraph line than a right-aligned label.
+        const lineWidth = x1 - x0;
+        if (Math.abs(x1 - rightMargin) < rightTol &&
+            x0 > leftMargin + centerTol &&
+            lineWidth < textWidth * 0.6)
+            return 'right';
+        return 'left';
+    }
+    // Multi-line block
+    const leftEdges = lineBounds.map((b) => b.x0);
+    const rightEdges = lineBounds.map((b) => b.x1);
+    const midpoints = lineBounds.map((b) => (b.x0 + b.x1) / 2);
+    function stddev(values) {
+        const mean = values.reduce((a, b) => a + b, 0) / values.length;
+        return Math.sqrt(values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / values.length);
+    }
+    const leftStd = stddev(leftEdges);
+    const rightStd = stddev(rightEdges);
+    const midStd = stddev(midpoints);
+    const THRESHOLD = 3.0;
+    if (leftStd < THRESHOLD && rightStd < THRESHOLD)
+        return 'justify';
+    // Justify detection with tolerance for short lines: last lines of paragraphs,
+    // headers, or dates mixed into the block won't reach the right margin.
+    // Filter to "full-width" lines (≥80% of the widest) and re-check.
+    if (lineBounds.length >= 3) {
+        const maxWidth = Math.max(...lineBounds.map((b) => b.x1 - b.x0));
+        const fullLines = lineBounds.filter((b) => b.x1 - b.x0 >= maxWidth * 0.8);
+        if (fullLines.length >= 3) {
+            const fullLeftStd = stddev(fullLines.map((b) => b.x0));
+            const fullRightStd = stddev(fullLines.map((b) => b.x1));
+            if (fullLeftStd < THRESHOLD && fullRightStd < THRESHOLD)
+                return 'justify';
+        }
+    }
+    if (midStd < THRESHOLD && midStd <= leftStd && midStd <= rightStd)
+        return 'center';
+    if (rightStd < THRESHOLD && rightStd < leftStd)
+        return 'right';
+    return 'left';
+}
+// Estimate page margins
+export function estimatePageMargins(spans) {
+    if (spans.length === 0)
+        return [0, 0];
+    const blockX0 = new Map();
+    const blockX1 = new Map();
+    for (const s of spans) {
+        const bn = s.blockNo;
+        blockX0.set(bn, Math.min(blockX0.get(bn) ?? s.x, s.x));
+        blockX1.set(bn, Math.max(blockX1.get(bn) ?? s.x + s.width, s.x + s.width));
+    }
+    const leftEdges = [...blockX0.values()].sort((a, b) => a - b);
+    const rightEdges = [...blockX1.values()].sort((a, b) => a - b);
+    function percentile(values, p) {
+        const idx = Math.floor(values.length * p);
+        return values[Math.min(idx, values.length - 1)];
+    }
+    return [percentile(leftEdges, 0.1), percentile(rightEdges, 0.9)];
+}
+// Compute line height from baselines
+export function computeLineHeight(blockSpans) {
+    const lines = new Map();
+    for (const span of blockSpans) {
+        const arr = lines.get(span.lineNo) || [];
+        arr.push(span);
+        lines.set(span.lineNo, arr);
+    }
+    const sortedLineNos = [...lines.keys()].sort((a, b) => a - b);
+    if (sortedLineNos.length < 2)
+        return DEFAULT_LINE_HEIGHT;
+    function medianY(spans) {
+        const ys = spans.map((s) => s.y).sort((a, b) => a - b);
+        const mid = Math.floor(ys.length / 2);
+        return ys.length % 2 ? ys[mid] : (ys[mid - 1] + ys[mid]) / 2;
+    }
+    const baselineYs = sortedLineNos.map((ln) => medianY(lines.get(ln)));
+    const gaps = [];
+    for (let i = 0; i < baselineYs.length - 1; i++) {
+        const gap = baselineYs[i + 1] - baselineYs[i];
+        if (gap > 0)
+            gaps.push(gap);
+    }
+    if (gaps.length === 0)
+        return DEFAULT_LINE_HEIGHT;
+    // Use median gap instead of average — robust against outlier gaps from
+    // mixed font sizes (e.g. header lines with larger fontSize in the same block).
+    const sortedGaps = [...gaps].sort((a, b) => a - b);
+    const mid = Math.floor(sortedGaps.length / 2);
+    const medianGap = sortedGaps.length % 2
+        ? sortedGaps[mid]
+        : (sortedGaps[mid - 1] + sortedGaps[mid]) / 2;
+    // Use the most common fontSize (by text length), not the largest —
+    // blocks can mix header lines (larger font) with body text.
+    const fontSizeCounts = new Map();
+    for (const span of blockSpans) {
+        const key = Math.round(span.fontSize * 10); // group by ~0.1px
+        fontSizeCounts.set(key, (fontSizeCounts.get(key) || 0) + span.text.length);
+    }
+    let dominantFontSize = blockSpans[0].fontSize;
+    let maxCount = 0;
+    for (const [key, count] of fontSizeCounts) {
+        if (count > maxCount) {
+            maxCount = count;
+            dominantFontSize = key / 10;
+        }
+    }
+    if (dominantFontSize <= 0)
+        return DEFAULT_LINE_HEIGHT;
+    const ratio = medianGap / dominantFontSize;
+    return Math.max(0.8, Math.min(3.0, ratio));
+}
+//# sourceMappingURL=text-blocks.js.map

package/lib/text-grouper.d.ts

@@ -0,0 +1,11 @@
+export type { TextSpan, TextBlock } from './text-types.js';
+export { groupSpansByBlock, detectAlignment, estimatePageMargins, computeLineHeight, } from './text-blocks.js';
+export declare function groupTextItems(items: any[], // pdfjs TextItem[]
+styles: Record<string, any>, yFlipOffset: number, positionColors: {
+    x: number;
+    y: number;
+    color: string;
+    fontName: string;
+    orderIndex: number;
+}[], fontNameMap?: Map<string, string>, fontAscentMap?: Map<string, number>): import("./text-types.js").TextSpan[];
+//# sourceMappingURL=text-grouper.d.ts.map

package/lib/text-grouper.js

@@ -0,0 +1,11 @@
+import { extractTextSpans } from './text-span-extractor.js';
+import { assignTextLayout } from './text-layout.js';
+export { groupSpansByBlock, detectAlignment, estimatePageMargins, computeLineHeight, } from './text-blocks.js';
+// Group TextItems from pdfjs into logical blocks
+export function groupTextItems(items, // pdfjs TextItem[]
+styles, yFlipOffset, positionColors, fontNameMap, fontAscentMap) {
+    void styles;
+    const spans = extractTextSpans(items, yFlipOffset, positionColors, fontNameMap, fontAscentMap);
+    return assignTextLayout(spans);
+}
+//# sourceMappingURL=text-grouper.js.map

package/lib/text-layout.d.ts

@@ -0,0 +1,3 @@
+import type { TextSpan } from './text-types.js';
+export declare function assignTextLayout(spans: TextSpan[]): TextSpan[];
+//# sourceMappingURL=text-layout.d.ts.map