@polotno/pdf-import 0.0.2 → 0.0.4

package/lib/font-registry.js

@@ -1,5 +1,5 @@
 import opentype from 'opentype.js';
-import { mapPdfFont, isKnownWebFont } from './font-mapper.js';
+import { mapPdfFont, isKnownWebFont, extractWeightFromName, extractStyleFromName, } from './font-mapper.js';
 import { findClosestGoogleFont } from './font-matcher.js';
 import { mergeSubsetFonts } from './font-merger.js';
 export class FontRegistry {
@@ -35,19 +35,35 @@ export class FontRegistry {
             return;
         const mappedFamily = mapPdfFont(fontObj.name);
         const isGoogleFont = isKnownWebFont(fontObj.name);
+        const hasEmbeddedData = fontObj.data && fontObj.data.length > 0;
         const shouldEmbed = embedAllFonts || !isGoogleFont;
         // When embedding a known Google Font, rename to avoid Polotno loading
         // the Google version instead of the embedded subset.
-        const fontFamily = embedAllFonts && isGoogleFont ? `${mappedFamily} (PDF)` : mappedFamily;
+        // Only rename if the font actually has embedded data — standard PDF fonts
+        // (Helvetica, Times, Courier, etc.) have no data, so they won't appear
+        // in the fonts[] array (all doc fonts must be declared there). Without an
+        // entry in fonts[], there's no collision risk, and keeping the original
+        // name lets Polotno load the font normally.
+        const fontFamily = embedAllFonts && isGoogleFont && hasEmbeddedData
+            ? `${mappedFamily} (PDF)`
+            : mappedFamily;
         // Track the rename so text elements can use the correct fontFamily
         if (fontFamily !== mappedFamily) {
             this.renameMap.set(fontObj.name, fontFamily);
         }
-        // Collect font binary data
+        // Detect weight/style from the PDF font name
+        const fontWeight = extractWeightFromName(fontObj.name);
+        const fontStyle = extractStyleFromName(fontObj.name);
+        // Collect font binary data with weight/style info
         if (shouldEmbed && fontObj.data && fontObj.data.length > 0) {
             const mime = fontObj.mimetype || 'font/opentype';
             const arr = this.fontDataMap.get(fontFamily) || [];
-            arr.push({ mime, data: new Uint8Array(fontObj.data) });
+            arr.push({
+                mime,
+                data: new Uint8Array(fontObj.data),
+                fontWeight,
+                fontStyle,
+            });
             this.fontDataMap.set(fontFamily, arr);
         }
         // Collect font metrics for unknown fonts (for Google Font matching)
@@ -93,30 +109,59 @@ export class FontRegistry {
             return fonts;
         }
         // 'embed' strategy: embed font data as base64 data URIs.
-        // When multiple subsets exist, merge them into a single font.
         for (const [fontFamily, blobs] of this.fontDataMap) {
-            let fontData;
-            let mime;
-            if (blobs.length === 1) {
-                fontData = blobs[0].data;
-                mime = blobs[0].mime;
-            }
-            else {
-                fontData = mergeSubsetFonts(blobs.map((b) => b.data));
-                mime = blobs[0].mime;
+            // Group blobs by weight+style variant
+            const variantMap = new Map();
+            for (const blob of blobs) {
+                const key = `${blob.fontWeight}|${blob.fontStyle}`;
+                const arr = variantMap.get(key) || [];
+                arr.push(blob);
+                variantMap.set(key, arr);
             }
-            let b64;
-            if (typeof Buffer !== 'undefined') {
-                b64 = Buffer.from(fontData).toString('base64');
+            // When multiple subsets exist for the same variant, merge them.
+            const variants = [];
+            for (const [, variantBlobs] of variantMap) {
+                let fontData;
+                if (variantBlobs.length === 1) {
+                    fontData = variantBlobs[0].data;
+                }
+                else {
+                    fontData = mergeSubsetFonts(variantBlobs.map((b) => b.data));
+                }
+                variants.push({
+                    fontWeight: variantBlobs[0].fontWeight,
+                    fontStyle: variantBlobs[0].fontStyle,
+                    data: fontData,
+                    mime: variantBlobs[0].mime,
+                });
             }
-            else {
+            function toBase64(data) {
+                if (typeof Buffer !== 'undefined') {
+                    return Buffer.from(data).toString('base64');
+                }
                 let binary = '';
-                for (let bi = 0; bi < fontData.length; bi++) {
-                    binary += String.fromCharCode(fontData[bi]);
+                for (let bi = 0; bi < data.length; bi++) {
+                    binary += String.fromCharCode(data[bi]);
                 }
-                b64 = btoa(binary);
+                return btoa(binary);
+            }
+            if (variants.length === 1 && variants[0].fontWeight === 'normal' && variants[0].fontStyle === 'normal') {
+                // Single normal variant — use simple url format
+                const b64 = toBase64(variants[0].data);
+                fonts.push({ fontFamily, url: `data:${variants[0].mime};base64,${b64}` });
+            }
+            else {
+                // Multiple variants — use styles array
+                const styles = variants.map((v) => {
+                    const b64 = toBase64(v.data);
+                    return {
+                        src: `url("data:${v.mime};base64,${b64}")`,
+                        fontWeight: v.fontWeight,
+                        fontStyle: v.fontStyle,
+                    };
+                });
+                fonts.push({ fontFamily, styles });
             }
-            fonts.push({ fontFamily, url: `data:${mime};base64,${b64}` });
         }
         return fonts;
     }

package/lib/index.js

@@ -1 +1 @@
-import{getDocument as x,GlobalWorkerOptions as m}from"pdfjs-dist/legacy/build/pdf.mjs";import{parsePage as R}from"./page-parser.js";import{FontRegistry as I}from"./font-registry.js";import{buildJpegIndex as O}from"./pdf-image-extractor.js";import{workerSource as k}from"./generated/pdf-worker-source.js";let A=0;function C(){return`el_${Date.now()}_${++A}`}async function L({pdf:e,fontStrategy:s="embed"}){if(typeof window<"u"&&!m.workerSrc){const r=new Blob([k],{type:"application/javascript"});m.workerSrc=URL.createObjectURL(r)}const i=new Uint8Array(e instanceof ArrayBuffer?e:e.buffer.slice(e.byteOffset,e.byteOffset+e.byteLength)),d=O(i),o=await x({data:i,useSystemFonts:!0,disableFontFace:!0,fontExtraProperties:!0}).promise,c=new I;let g=612,p=792;const f=await o.getPage(1),u=f.getViewport({scale:1});g=u.width,p=u.height;const w=3,n=new Array(o.numPages);for(let r=0;r<o.numPages;r+=w){const h=Math.min(r+w,o.numPages),l=[];for(let t=r;t<h;t++)l.push((async()=>{const a=t===0?f:await o.getPage(t+1),{parsedPage:P}=await R({page:a,pageIdx:t,fontRegistry:c,generateId:C,jpegIndex:d,fontStrategy:s});return{parsedPage:P,pageIdx:t}})());const y=await Promise.all(l);for(const{parsedPage:t,pageIdx:a}of y)n[a]=t}await o.destroy();const b=c.finalize(s,n);return{width:g,height:p,fonts:b,pages:n,unit:"px",dpi:72}}export{L as pdfToJson};
+import{getDocument as I,GlobalWorkerOptions as b}from"pdfjs-dist/legacy/build/pdf.mjs";import{parsePage as O}from"./page-parser.js";import{FontRegistry as k}from"./font-registry.js";import{buildJpegIndex as A}from"./pdf-image-extractor.js";import{workerSource as C}from"./generated/pdf-worker-source.js";let E=0;function F(){return`el_${Date.now()}_${++E}`}async function _({pdf:e,fontStrategy:g="embed"}){if(typeof window<"u"&&!b.workerSrc){const r=new Blob([C],{type:"application/javascript"});b.workerSrc=URL.createObjectURL(r)}const p=new Uint8Array(e instanceof ArrayBuffer?e:e.buffer.slice(e.byteOffset,e.byteOffset+e.byteLength)),y=A(p),o=await I({data:p,useSystemFonts:!0,disableFontFace:!0,fontExtraProperties:!0}).promise,f=new k;let n=612,a=792;const u=await o.getPage(1),w=u.getViewport({scale:1});n=w.width,a=w.height;const d=3,i=new Array(o.numPages);for(let r=0;r<o.numPages;r+=d){const x=Math.min(r+d,o.numPages),h=[];for(let t=r;t<x;t++)h.push((async()=>{const s=t===0?u:await o.getPage(t+1),{parsedPage:c,pageWidth:l,pageHeight:m}=await O({page:s,pageIdx:t,fontRegistry:f,generateId:F,jpegIndex:y,fontStrategy:g});return(l!==n||m!==a)&&(c.width=l,c.height=m),{parsedPage:c,pageIdx:t}})());const R=await Promise.all(h);for(const{parsedPage:t,pageIdx:s}of R)i[s]=t}await o.destroy();const P=f.finalize(g,i);return{width:n,height:a,fonts:P,pages:i,unit:"px",dpi:72}}export{_ as pdfToJson};

package/lib/page-parser.js

@@ -27,8 +27,8 @@ export async function parsePage({ page, pageIdx, fontRegistry, generateId, jpegI
         buildImageElements(page, imageRefs, pageIdx, generateId, jpegIndex),
         collectPageFonts(page, fontRefs, fontRegistry, fontStrategy === 'embed'),
     ]);
-    const pageBackground = detectPageBackground(drawings, pageWidth, pageHeight);
-    const svgElements = buildSvgElements(drawings, pageWidth, pageHeight, generateId);
+    const { color: pageBackground, bgDrawingIndices } = detectPageBackground(drawings, pageWidth, pageHeight);
+    const svgElements = buildSvgElements(drawings, pageWidth, pageHeight, generateId, bgDrawingIndices);
     const textElements = await buildTextElements({
         page,
         pageWidth,
@@ -113,26 +113,86 @@ async function resolveDrawingGradients(page, drawings) {
     }
 }
 function detectPageBackground(drawings, pageWidth, pageHeight) {
+    const bgDrawingIndices = new Set();
     let pageBackground = '#FFFFFF';
-    for (const drawing of drawings) {
+    for (let i = 0; i < drawings.length; i++) {
+        const drawing = drawings[i];
         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) {
+            if (dw >= pageWidth * 0.95 && dh >= pageHeight * 0.95) {
                 const [r, g, b] = drawing.fill;
                 pageBackground = rgbTupleToHex(r, g, b);
+                bgDrawingIndices.add(i);
             }
         }
     }
-    return pageBackground;
+    return { color: pageBackground, bgDrawingIndices };
+}
+/**
+ * Detect crop/bleed mark drawings (full-page, stroke-only, short edge lines)
+ * and split them into individual per-line SVGs so they don't block clicks.
+ */
+function trySplitCropMarks(drawing, pageWidth, pageHeight) {
+    if (drawing.fill !== null)
+        return null;
+    if (!drawing.stroke)
+        return null;
+    const dw = drawing.rect[2] - drawing.rect[0];
+    const dh = drawing.rect[3] - drawing.rect[1];
+    if (dw < pageWidth * 0.8 || dh < pageHeight * 0.8)
+        return null;
+    const lines = drawing.items.filter((it) => it.kind === 'l');
+    if (lines.length === 0)
+        return null;
+    // All line items must be short and near page edges
+    const edgeThreshold = Math.min(pageWidth, pageHeight) * 0.15;
+    for (const item of drawing.items) {
+        if (item.kind === 'm')
+            continue;
+        if (item.kind !== 'l')
+            return null;
+        const len = Math.hypot(item.x2 - item.x1, item.y2 - item.y1);
+        if (len > edgeThreshold)
+            return null;
+        const nearEdge = item.x1 < edgeThreshold || item.x1 > pageWidth - edgeThreshold ||
+            item.y1 < edgeThreshold || item.y1 > pageHeight - edgeThreshold;
+        if (!nearEdge)
+            return null;
+    }
+    // Build one small SVG per line segment
+    const strokeHex = rgbTupleToHex(...drawing.stroke);
+    const sw = drawing.strokeWidth || 1;
+    const results = [];
+    for (const line of lines) {
+        const x0 = Math.min(line.x1, line.x2);
+        const y0 = Math.min(line.y1, line.y2);
+        const x1 = Math.max(line.x1, line.x2);
+        const y1 = Math.max(line.y1, line.y2);
+        const half = sw / 2;
+        const bx = x0 - half;
+        const by = y0 - half;
+        const bw = Math.max(x1 - x0 + sw, sw + 1);
+        const bh = Math.max(y1 - y0 + sw, sw + 1);
+        const lx1 = line.x1 - bx;
+        const ly1 = line.y1 - by;
+        const lx2 = line.x2 - bx;
+        const ly2 = line.y2 - by;
+        const svg = `<svg viewBox="0 0 ${bw} ${bh}" xmlns="http://www.w3.org/2000/svg"><line x1="${lx1}" y1="${ly1}" x2="${lx2}" y2="${ly2}" stroke="${strokeHex}" stroke-width="${sw}"/></svg>`;
+        results.push({ svg, x: bx, y: by, width: bw, height: bh });
+    }
+    return results;
 }
-function buildSvgElements(drawings, pageWidth, pageHeight, generateId) {
+function buildSvgElements(drawings, pageWidth, pageHeight, generateId, bgDrawingIndices) {
     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;
+        // Skip drawings used as the page background
+        if (bgDrawingIndices?.has(idx))
+            continue;
         if (isMergeableClipRunDrawing(drawing)) {
             const run = [drawing];
             while (idx + 1 < drawings.length &&
@@ -161,6 +221,27 @@ function buildSvgElements(drawings, pageWidth, pageHeight, generateId) {
                 }
             }
         }
+        // Split full-page crop/bleed marks into per-segment SVGs so they don't
+        // block clicks on the entire page in the editor.
+        const splitResults = trySplitCropMarks(drawing, pageWidth, pageHeight);
+        if (splitResults) {
+            for (const seg of splitResults) {
+                svgElements.push({
+                    type: 'svg',
+                    id: generateId(),
+                    x: seg.x,
+                    y: seg.y,
+                    width: seg.width,
+                    height: seg.height,
+                    rotation: 0,
+                    opacity: drawing.opacity,
+                    src: svgToDataUri(seg.svg),
+                    name: '',
+                    _order: drawing.orderIndex,
+                });
+            }
+            continue;
+        }
         const result = drawingToSvg(drawing, pageWidth, pageHeight);
         if (result) {
             svgElements.push({
@@ -558,7 +639,7 @@ async function buildTextElements({ page, pageWidth, yFlipOffset, positionColors,
         // Find dominant span (longest text)
         const dominant = block.spans.reduce((a, b) => a.text.length > b.text.length ? a : b);
         const fontFamily = fontRegistry.getFontFamily(dominant.fontName);
-        const align = detectAlignment(block.spans, pageWidth, leftMargin, rightMargin);
+        const align = detectAlignment(block.spans, pageWidth, leftMargin, rightMargin, blocks.map((b) => ({ x: b.x, width: b.width })));
         const lineHeight = computeLineHeight(block.spans);
         // Build text content with line breaks
         const lineMap = new Map();
@@ -641,10 +722,14 @@ async function buildTextElements({ page, pageWidth, yFlipOffset, positionColors,
         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.
+        // Polotno rotates text around the top-left corner. For vertical text we need
+        // to convert PDF baseline coordinates into Polotno element coordinates.
+        // The element's y-axis maps to the visual x-axis after rotation, so the
+        // half-leading and ascent offsets that normally adjust elemY must instead
+        // adjust elemX.
         if (dominant.rotation <= -45 && dominant.rotation >= -135) {
-            elemX -= elemHeight;
+            const ascentPx = dominant.baselineY - dominant.y;
+            elemX = block.x - ascentPx - halfLeading;
             elemY = dominant.baselineY;
         }
         else if (dominant.rotation >= 45 && dominant.rotation <= 135) {
@@ -671,14 +756,8 @@ async function buildTextElements({ page, pageWidth, yFlipOffset, positionColors,
             text: textContent2,
             fontSize: dominant.fontSize,
             fontFamily,
-            // When embedding fonts, the subset file IS the specific variant (bold,
-            // italic, etc.), so use "normal" to avoid Polotno synthesizing on top.
-            fontWeight: fontStrategy === 'embed'
-                ? 'normal'
-                : dominant.fontWeight || extractWeightFromName(dominant.fontName),
-            fontStyle: fontStrategy === 'embed'
-                ? 'normal'
-                : dominant.fontStyle || extractStyleFromName(dominant.fontName),
+            fontWeight: dominant.fontWeight || extractWeightFromName(dominant.fontName),
+            fontStyle: dominant.fontStyle || extractStyleFromName(dominant.fontName),
             fill: dominant.color || '#000000',
             align,
             lineHeight,

package/lib/svg-builder.js

@@ -30,8 +30,8 @@ function computeDrawingBounds(drawing, pageWidth, pageHeight) {
     if (drawing.fill !== null &&
         pageWidth > 0 &&
         pageHeight > 0 &&
-        width >= pageWidth * 0.9 &&
-        height >= pageHeight * 0.9) {
+        width >= pageWidth * 0.95 &&
+        height >= pageHeight * 0.95) {
         return null;
     }
     return { x0, y0, width, height };
@@ -86,6 +86,28 @@ function buildPathData(items, originX, originY, shouldCloseFill, closePath) {
     }
     return pathParts.join(' ');
 }
+/**
+ * Check if a clip path is a simple axis-aligned rectangle,
+ * regardless of whether it's represented as `re` or `m`/`l` segments.
+ */
+function isRectangularClipPath(items) {
+    if (items.length === 1 && items[0].kind === 're')
+        return true;
+    // Check if it's 4 line segments (plus optional move) forming a rectangle
+    const lines = items.filter(it => it.kind === 'l');
+    if (lines.length < 4)
+        return false;
+    // All lines must be axis-aligned (horizontal or vertical)
+    for (const line of lines) {
+        if (line.kind !== 'l')
+            continue;
+        const dx = Math.abs(line.x2 - line.x1);
+        const dy = Math.abs(line.y2 - line.y1);
+        if (dx > 0.5 && dy > 0.5)
+            return false; // diagonal line = not rect
+    }
+    return true;
+}
 export function drawingToSvg(drawing, pageWidth, pageHeight) {
     const bounds = computeDrawingBounds(drawing, pageWidth, pageHeight);
     if (!bounds)
@@ -150,7 +172,39 @@ export function drawingToSvg(drawing, pageWidth, pageHeight) {
             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>`;
+    // Apply clip path if the drawing has a non-trivial one
+    let clipDef = '';
+    let clipAttr = '';
+    if (drawing.clipPath && drawing.clipRect) {
+        const [cx0, cy0, cx1, cy1] = drawing.clipRect;
+        const cw = cx1 - cx0;
+        const ch = cy1 - cy0;
+        // Only clip if it meaningfully reduces the visible area.
+        // A clip rect that covers 90%+ of the drawing in both dimensions is trivial.
+        const insetX = Math.max(0, cx0 - x0) + Math.max(0, (x0 + w) - cx1);
+        const insetY = Math.max(0, cy0 - y0) + Math.max(0, (y0 + h) - cy1);
+        const significantClip = cw > 0 && ch > 0 &&
+            (insetX > w * 0.1 || insetY > h * 0.1);
+        if (significantClip) {
+            // Check if clip is a simple axis-aligned rectangle (re or 4 line segments)
+            const isRectClip = isRectangularClipPath(drawing.clipPath);
+            if (!isRectClip) {
+                const clipD = buildPathData(drawing.clipPath, x0, y0, true, true);
+                clipDef = `<defs><clipPath id="c"><path d="${clipD}"/></clipPath></defs>`;
+                clipAttr = ' clip-path="url(#c)"';
+                // If both gradient defs and clip defs are needed, merge them
+                if (defs) {
+                    clipDef = defs.replace('</defs>', '') + `<clipPath id="c"><path d="${clipD}"/></clipPath></defs>`;
+                    defs = '';
+                }
+            }
+        }
+    }
+    const allDefs = clipDef || defs;
+    const pathEl = `<path d="${dAttr}" fill="${fillValue}" ${strokeAttr}${fillRule}/>`;
+    const svgStr = clipAttr
+        ? `<svg viewBox="0 0 ${w} ${h}" xmlns="http://www.w3.org/2000/svg">${allDefs}<g${clipAttr}>${pathEl}</g></svg>`
+        : `<svg viewBox="0 0 ${w} ${h}" xmlns="http://www.w3.org/2000/svg">${allDefs}${pathEl}</svg>`;
     return { svg: svgStr, x: x0, y: y0, width: w, height: h };
 }
 export function clippedDrawingsToSvg(drawings) {

package/lib/text-blocks.d.ts

@@ -1,6 +1,9 @@
 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 detectAlignment(blockSpans: TextSpan[], pageWidth: number, leftMargin: number, rightMargin: number, allBlocks?: {
+    x: number;
+    width: 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

@@ -152,7 +152,7 @@ function splitSpansAtPositions(spans, splitPositions) {
     return columns.filter((c) => c.length > 0);
 }
 // Alignment detection
-export function detectAlignment(blockSpans, pageWidth, leftMargin, rightMargin) {
+export function detectAlignment(blockSpans, pageWidth, leftMargin, rightMargin, allBlocks) {
     const lines = new Map();
     for (const span of blockSpans) {
         const arr = lines.get(span.lineNo) || [];
@@ -185,10 +185,16 @@ export function detectAlignment(blockSpans, pageWidth, leftMargin, rightMargin)
         // 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.
+        // Additional guard: if other blocks share this left edge, the text is in a
+        // left-aligned column and just happens to reach the right margin.
         const lineWidth = x1 - x0;
+        const hasAlignedNeighbors = allBlocks &&
+            allBlocks.filter((b) => Math.abs(b.x - x0) < 3 && b.width !== lineWidth)
+                .length >= 2;
         if (Math.abs(x1 - rightMargin) < rightTol &&
             x0 > leftMargin + centerTol &&
-            lineWidth < textWidth * 0.6)
+            lineWidth < textWidth * 0.6 &&
+            !hasAlignedNeighbors)
             return 'right';
         return 'left';
     }
@@ -204,6 +210,11 @@ export function detectAlignment(blockSpans, pageWidth, leftMargin, rightMargin)
     const rightStd = stddev(rightEdges);
     const midStd = stddev(midpoints);
     const THRESHOLD = 3.0;
+    // For center detection, scale threshold with font size. A fixed 3px is fine
+    // for 12px text but too tight for large display text (e.g. 55px "BENEFIT OF"
+    // / "WAXING" has midpoint stddev 3.2 — clearly centered but misses 3.0).
+    const dominantFontSize = blockSpans.reduce((a, b) => a.text.length > b.text.length ? a : b).fontSize;
+    const centerThreshold = Math.max(THRESHOLD, dominantFontSize * 0.1);
     if (leftStd < THRESHOLD && rightStd < THRESHOLD)
         return 'justify';
     // Justify detection with tolerance for short lines: last lines of paragraphs,
@@ -219,7 +230,7 @@ export function detectAlignment(blockSpans, pageWidth, leftMargin, rightMargin)
                 return 'justify';
         }
     }
-    if (midStd < THRESHOLD && midStd <= leftStd && midStd <= rightStd)
+    if (midStd < centerThreshold && midStd <= leftStd && midStd <= rightStd)
         return 'center';
     if (rightStd < THRESHOLD && rightStd < leftStd)
         return 'right';

package/lib/text-layout.js

@@ -197,8 +197,11 @@ function assignBlockNumbers(spans, startBlockNo = 0) {
             // 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 fontNameDiffers = prev.fontName !== curr.fontName;
             const fontSizeDiffers = fontRatio > 1.1;
-            const effectiveSplitGap = fontSizeDiffers ? Math.max(avgFontSize * 0.5, 8) : splitGap;
+            const effectiveSplitGap = (fontSizeDiffers || fontNameDiffers)
+                ? Math.max(avgFontSize * 0.5, 8)
+                : splitGap;
             if (gap > effectiveSplitGap) {
                 const forceSplit = prev.color !== curr.color ||
                     prev.fontName !== curr.fontName ||
@@ -276,7 +279,7 @@ function assignBlockNumbers(spans, startBlockNo = 0) {
         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;
+        const fontSizeChanged = !onSameLine && fontSizeRatio > 1.08;
         // 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
@@ -303,7 +306,7 @@ function assignBlockNumbers(spans, startBlockNo = 0) {
         if (!fontSizeChanged &&
             !colorChanged &&
             !largeSingleSpanDisplayShift &&
-            yGap < avgFontSize * 0.5 &&
+            yGap <= avgFontSize * 0.5 &&
             (xOverlap > 0 || Math.abs(prev.x0 - curr.x0) < avgFontSize * 2)) {
             currentBlock.push(curr);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polotno/pdf-import",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Convert PDF files into Polotno JSON format",
   "type": "module",
   "main": "./lib/index.js",
@@ -28,19 +28,19 @@
     "pdfjs-dist": "^4.10.38"
   },
   "devDependencies": {
-    "@types/node": "^25.3.3",
+    "@types/node": "^25.5.0",
     "@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",
+    "@vitejs/plugin-react": "^6.0.1",
+    "esbuild": "^0.27.4",
+    "polotno": "^2.38.2",
+    "polotno-node": "^2.15.15",
     "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"
+    "vite": "^8.0.0",
+    "vitest": "^4.1.0"
   }
 }