@uurtech/jdf-cli 0.2.4 → 0.2.6

package/dist/index.js

@@ -765,12 +765,13 @@ function columnBands(rows) {
   const countOf = /* @__PURE__ */ new Map();
   for (const m of body) countOf.set(m.r, (countOf.get(m.r) ?? 0) + 1);
   const maxCount = Math.max(...countOf.values());
-  const anchorRows = new Set(rows.filter((r) => countOf.get(r) === maxCount));
+  let anchorRows = new Set(rows.filter((r) => countOf.get(r) === maxCount));
   let bands = clusterCells(body.filter((m) => anchorRows.has(m.r)));
   if (hasConflict(bands)) {
     const first = rows.find((r) => anchorRows.has(r));
     bands = clusterCells(body.filter((m) => m.r === first));
     if (hasConflict(bands)) return null;
+    anchorRows = /* @__PURE__ */ new Set([first]);
   }
   for (const m of body) {
     if (anchorRows.has(m.r)) continue;
@@ -893,7 +894,8 @@ function detectTables(runs, shapes, pageWidthMm, gutters = []) {
       y0: blockRows[0].y - blockRows[0].h * 2.5,
       y1: blockRows[blockRows.length - 1].y + blockRows[blockRows.length - 1].h * 3
     } : null;
-    const gridShapes = bbox ? shapes.map((s, k) => ({ s, k })).filter(({ s }) => s.x >= bbox.x0 - 1 && s.x + s.width <= bbox.x1 + 1 && s.y >= bbox.y0 - 1 && s.y + s.height <= bbox.y1 + 1 && (s.kind === "line" || s.kind === "rect")) : [];
+    const thinH = (s) => (s.kind === "line" || s.kind === "rect") && s.height < 0.6 && s.width >= s.height && !!(s.fill || s.stroke);
+    const gridShapes = bbox ? shapes.map((s, k) => ({ s, k })).filter(({ s }) => s.y >= bbox.y0 - 1 && s.y + s.height <= bbox.y1 + 1 && (s.kind === "line" || s.kind === "rect") && (thinH(s) ? Math.min(s.x + s.width, bbox.x1) - Math.max(s.x, bbox.x0) >= s.width * 0.5 : s.x >= bbox.x0 - 1 && s.x + s.width <= bbox.x1 + 1)) : [];
     const tableW = bbox ? bbox.x1 - bbox.x0 : 0;
     const isRule = (s) => s.kind === "line" || s.kind === "rect" && (s.height < 0.6 || s.width < 0.6) && !!(s.fill || s.stroke);
     const ruleYs = gridShapes.filter(({ s }) => isRule(s) && s.width >= s.height && s.width >= tableW * 0.45).map(({ s }) => s.y + s.height / 2).sort((a, b) => a - b);
@@ -978,10 +980,29 @@ function detectTables(runs, shapes, pageWidthMm, gutters = []) {
     for (let r = 1; r < blockRows.length; r++) pitches.push(blockRows[r].y - blockRows[r - 1].y);
     const medPitch = pitches.length ? pitches.slice().sort((a, b) => a - b)[Math.floor(pitches.length / 2)] : blockRows[0].h * 1.3;
     let pendingLabel = null;
+    const pendingCells = /* @__PURE__ */ new Map();
+    const flushPendingCells = () => {
+      if (!pendingCells.size) return;
+      const cells = bands.map(() => "");
+      let row = null;
+      for (const [b, pc] of pendingCells) {
+        cells[b] = pc.text;
+        lineIdx.push(...pc.idx);
+        row = row ?? pc.row;
+      }
+      grid.push(cells);
+      gridRows.push(row);
+      pendingCells.clear();
+    };
     const flushPending = () => {
       if (!pendingLabel) return;
       const cells = bands.map(() => "");
       cells[0] = pendingLabel.text;
+      for (const [b, pc] of pendingCells) {
+        cells[b] = pc.text;
+        lineIdx.push(...pc.idx);
+      }
+      pendingCells.clear();
       grid.push(cells);
       gridRows.push(pendingLabel.row);
       lineIdx.push(...pendingLabel.idx);
@@ -993,6 +1014,15 @@ function detectTables(runs, shapes, pageWidthMm, gutters = []) {
         const c = row.cells[0];
         const b = assign.get(c) ?? bands.findIndex((bb) => overlaps(c, bb));
         if (b > 0) {
+          const prevRow2 = gridRows[gridRows.length - 1];
+          if (denseRules && prevRow2 && ruleBetween(prevRow2, row) && !pendingLabel) {
+            const pc = pendingCells.get(b);
+            if (pc) {
+              pc.text = `${pc.text} ${c.run.text.trim()}`.trim();
+              pc.idx.push(...cellIdx(c));
+            } else pendingCells.set(b, { text: c.run.text.trim(), idx: cellIdx(c), row });
+            continue;
+          }
           flushPending();
           grid[grid.length - 1][b] = (grid[grid.length - 1][b] + " " + c.run.text.trim()).trim();
           lineIdx.push(...cellIdx(c));
@@ -1018,7 +1048,16 @@ function detectTables(runs, shapes, pageWidthMm, gutters = []) {
         continue;
       }
       const prevRow = gridRows[gridRows.length - 1];
-      if (prevRow && !pendingLabel && row.y - prevRow.y > medPitch * 1.7 && grid.length) {
+      const prevLastY = (() => {
+        let y = prevRow?.y ?? row.y;
+        for (let q = r - 1; q >= 0 && blockRows[q] !== prevRow; q--) {
+          if (blockRows[q].cells.length === 1) {
+            y = Math.max(y, blockRows[q].y);
+          } else break;
+        }
+        return y;
+      })();
+      if (prevRow && !pendingLabel && !pendingCells.size && row.y - prevLastY > medPitch * 1.7 && grid.length) {
         grid.push(bands.map(() => ""));
         gridRows.push(row);
       }
@@ -1028,11 +1067,24 @@ function detectTables(runs, shapes, pageWidthMm, gutters = []) {
         lineIdx.push(...pendingLabel.idx);
         pendingLabel = null;
       }
+      if (pendingCells.size) {
+        gridRows[gridRows.length - 1];
+        const pcRow = [...pendingCells.values()][0].row;
+        if (denseRules && ruleBetween(pcRow, row)) flushPendingCells();
+        else {
+          for (const [b, pc] of pendingCells) {
+            cells[b] = `${pc.text} ${cells[b]}`.trim();
+            lineIdx.push(...pc.idx);
+          }
+          pendingCells.clear();
+        }
+      }
       grid.push(cells);
       gridRows.push(row);
       for (const c of row.cells) lineIdx.push(...cellIdx(c));
     }
     flushPending();
+    flushPendingCells();
     for (let r = 1; r < grid.length; r++) {
       const cur2 = grid[r], prev = grid[r - 1];
       if (cur2[0] !== "" || !prev[0] || !prev.some(Boolean) || !cur2.some(Boolean)) continue;
@@ -1066,6 +1118,13 @@ function detectTables(runs, shapes, pageWidthMm, gutters = []) {
       i++;
       continue;
     }
+    const fillRatio = grid.flat().filter(Boolean).length / Math.max(1, grid.length * bands.length);
+    const multiFilled = grid.filter((r) => r.filter(Boolean).length >= 2).length;
+    if (grid.length <= 3 && fillRatio < 0.6 || fillRatio < 0.5 && multiFilled <= 2 || bands.length >= 6 && fillRatio < 0.3) {
+      dbg("reject sparse block", grid[0]);
+      i++;
+      continue;
+    }
     const first = blockRows[0];
     const headerBg = rowFill(first);
     const firstBold = first.cells.every((c) => c.run.bold);
@@ -1082,7 +1141,8 @@ function detectTables(runs, shapes, pageWidthMm, gutters = []) {
       const firstRule = ruleYs.find((y) => y > gridRows[0].y + gridRows[0].h * 0.5);
       if (firstRule != null) {
         const above = gridRows.filter((r) => r.y + r.h * 0.5 < firstRule).length;
-        if (above >= 1 && above <= 5 && gridRows.length - above >= 2) headerRows = Math.max(headerRows, above);
+        const figuresAbove = grid.slice(0, above).some((row) => row.some((v, k) => isNumCol[k] && v && numeric(v)));
+        if (above >= 1 && above <= 5 && gridRows.length - above >= 2 && !figuresAbove) headerRows = Math.max(headerRows, above);
       }
     }
     if (numCols > 0) {
@@ -1099,17 +1159,77 @@ function detectTables(runs, shapes, pageWidthMm, gutters = []) {
       headerRows = Math.max(headerRows, h);
     }
     if (headerRows > 0 && grid.length - headerRows < 1) headerRows = 0;
-    const columns = bands.map((b, k) => {
+    const shortVerticals = gridShapes.filter(({ s }) => isRule(s) && s.height > s.width).length;
+    const hasGrid = verticalRules >= 2 || shortVerticals >= 2 && denseRules && ruleYs.length >= 2;
+    const anyVertical = shortVerticals >= 2;
+    if (hasGrid || anyVertical) {
+      const bx0 = Math.min(...bands.map((b) => b.x0)), bx1 = Math.max(...bands.map((b) => b.x1));
+      const partial = gridShapes.filter(({ s }) => isRule(s) && s.width >= s.height && s.width >= tableW * 0.3 && (s.x > bx0 + 3 || s.x + s.width < bx1 - 3)).length;
+      if (partial >= 2) {
+        dbg("reject rowspan grid", grid[0]);
+        i++;
+        continue;
+      }
+    }
+    let colBands = bands;
+    let colGrid = grid;
+    let colNum = isNumCol;
+    let edges = null;
+    if (hasGrid) {
+      const acc = /* @__PURE__ */ new Map();
+      const blockH = blockRows[blockRows.length - 1].y + blockRows[blockRows.length - 1].h - blockRows[0].y;
+      for (const { s } of gridShapes) {
+        if (!(isRule(s) && s.height > s.width)) continue;
+        const cx = s.x + s.width / 2;
+        const key = [...acc.keys()].find((x) => Math.abs(x - cx) < 1) ?? cx;
+        acc.set(key, (acc.get(key) ?? 0) + s.height);
+      }
+      const xs = [...acc.entries()].filter(([, h]) => h >= blockH * 0.5).map(([x]) => x).sort((a, b) => a - b);
+      dbg(`grid rules x=${xs.map((x) => x.toFixed(1)).join(",")} bands=${bands.length}`);
+      if (xs.length >= 3) {
+        const bandCol = bands.map((b) => {
+          const c = (b.x0 + b.x1) / 2;
+          return xs.findIndex((x, k) => k < xs.length - 1 && c > x && c < xs[k + 1]);
+        });
+        const straddles = (c) => xs.some((x) => c.x0 < x - 1.5 && c.x1 > x + 1.5);
+        const crowded = bandCol.some((c, k) => c >= 0 && bandCol.indexOf(c) !== k);
+        const inside = !crowded && !blockRows.some((row) => row.cells.some(straddles));
+        if (!inside) {
+          dbg("reject merged-cell grid", grid[0]);
+          i++;
+          continue;
+        }
+        if (xs.length - 1 >= bands.length && bandCol.every((c) => c >= 0) && new Set(bandCol).size === bandCol.length) {
+          edges = xs;
+          colBands = xs.slice(0, -1).map((x, k) => ({ x0: x, x1: xs[k + 1] }));
+          colGrid = grid.map((row) => {
+            const out2 = colBands.map(() => "");
+            row.forEach((v, k) => {
+              out2[bandCol[k]] = v;
+            });
+            return out2;
+          });
+          colNum = colBands.map((_, k) => {
+            const b = bandCol.indexOf(k);
+            return b >= 0 && isNumCol[b];
+          });
+        }
+      }
+    }
+    const columns = colBands.map((b, k) => {
       const col = { width: Math.round((b.x1 - b.x0) * 10) / 10 };
-      if (isNumCol[k]) col.align = "right";
+      if (colNum[k]) col.align = "right";
       return col;
     });
-    const x0 = Math.max(0, bands[0].x0 - 2.5);
-    const x1 = Math.min(pageW, bands[bands.length - 1].x1 + 2.5);
-    const edges = [x0];
-    for (let k = 1; k < bands.length; k++) edges.push(Math.max(edges[k - 1] + 2, Math.min((bands[k - 1].x1 + bands[k].x0) / 2, x1 - 2 * (bands.length - k))));
-    edges.push(Math.max(edges[edges.length - 1] + 2, x1));
-    for (let k = 0; k < bands.length; k++) columns[k].width = Math.round((edges[k + 1] - edges[k]) * 10) / 10;
+    const x0 = edges ? edges[0] : Math.max(0, bands[0].x0 - 2.5);
+    const x1 = edges ? edges[edges.length - 1] : Math.min(pageW, bands[bands.length - 1].x1 + 2.5);
+    if (!edges) {
+      edges = [x0];
+      for (let k = 1; k < bands.length; k++) edges.push(Math.max(edges[k - 1] + 2, Math.min((bands[k - 1].x1 + bands[k].x0) / 2, x1 - 2 * (bands.length - k))));
+      edges.push(Math.max(edges[edges.length - 1] + 2, x1));
+    }
+    for (let k = 0; k < colBands.length; k++) columns[k].width = Math.round((edges[k + 1] - edges[k]) * 10) / 10;
+    const colOfBand = colBands === bands ? bands.map((_, k) => k) : bands.map((b) => colBands.findIndex((cb) => (b.x0 + b.x1) / 2 > cb.x0 && (b.x0 + b.x1) / 2 < cb.x1));
     const bodyRows = gridRows.slice(headerRows).filter((r, k, arr) => grid[headerRows + k]?.some(Boolean));
     const rowFills = bodyRows.map(rowFill).map((f) => f?.fill ?? null);
     const odd = rowFills.filter((_, k) => k % 2 === 1), even = rowFills.filter((_, k) => k % 2 === 0);
@@ -1118,7 +1238,6 @@ function detectTables(runs, shapes, pageWidthMm, gutters = []) {
     const altColor = oddAlt || evenAlt;
     const borderShape = gridShapes.find(({ s }) => isRule(s));
     const borderColor = borderShape ? borderShape.s.stroke || borderShape.s.fill : void 0;
-    const hasGrid = verticalRules >= 2;
     const sizeChars = /* @__PURE__ */ new Map();
     for (const row of blockRows) for (const c of row.cells) {
       const k = Math.round(c.run.fontSize * 2) / 2;
@@ -1129,26 +1248,74 @@ function detectTables(runs, shapes, pageWidthMm, gutters = []) {
     const padV = Math.max(0.2, Math.min(2.5, (medPitch - lineMm) / 2));
     const padH = Math.max(0.5, Math.min(3, fontSize * PT_TO_MM * 0.35));
     const y0 = headerBg ? Math.min(...headerBg.rects.map(({ s }) => s.y)) : first.y - padV;
+    const tally = (pick) => {
+      const m = /* @__PURE__ */ new Map();
+      for (const row of blockRows) for (const c of row.cells) {
+        const k = pick(c);
+        if (k) m.set(k, (m.get(k) ?? 0) + c.run.text.trim().length);
+      }
+      return [...m.entries()].sort((a, b) => b[1] - a[1])[0]?.[0];
+    };
+    const tableFamily = tally((c) => c.run.family);
+    const tableColor = tally((c) => c.run.color) ?? "#000000";
+    const runsAt = (r, b) => {
+      const src = gridRows[r];
+      if (!src) return [];
+      const own = src.cells.filter((c) => assign.get(c) === b).map((c) => c.run);
+      if (own.length || b !== 0) return own;
+      const at = blockRows.indexOf(src);
+      for (let q = at - 1; q >= Math.max(0, at - 3); q--) {
+        const row = blockRows[q];
+        if (row.cells.length !== 1) break;
+        if ((assign.get(row.cells[0]) ?? 0) === 0) return [row.cells[0].run];
+      }
+      return [];
+    };
+    const styledCell = (text, runs2) => {
+      if (!text || !runs2.length) return text;
+      const st = {};
+      const chars = (f) => runs2.filter(f).reduce((a, r) => a + r.text.trim().length, 0) / Math.max(1, runs2.reduce((a, r) => a + r.text.trim().length, 0));
+      if (chars((r) => !!r.bold) >= 0.5) st.fontWeight = "bold";
+      if (chars((r) => !!r.italic) >= 0.5) st.fontStyle = "italic";
+      const color = runs2.slice().sort((a, b) => b.text.trim().length - a.text.trim().length)[0].color;
+      if (color && color !== tableColor) st.color = color;
+      const fam = runs2.slice().sort((a, b) => b.text.trim().length - a.text.trim().length)[0].family;
+      if (fam && tableFamily && fam !== tableFamily) st.fontFamily = fam;
+      const size = Math.round(runs2[0].fontSize * 2) / 2;
+      if (Math.abs(size - fontSize) >= 1) st.fontSize = size;
+      return Object.keys(st).length ? { content: text, style: st } : text;
+    };
+    const bodyStart = (() => {
+      let k = headerRows;
+      while (k < colGrid.length - 1 && colGrid[k].every((c) => !c)) k++;
+      return k;
+    })();
+    const styledRows = colGrid.slice(bodyStart).map((row, ri) => {
+      const r = bodyStart + ri;
+      return row.map((text, col) => {
+        const b = colOfBand.indexOf(col);
+        return styledCell(text, b >= 0 ? runsAt(r, b) : []);
+      });
+    });
+    const tableStyle = { fontSize, lineHeight: 1.2, padding: `${Math.round(padV * 100) / 100}mm ${Math.round(padH * 100) / 100}mm` };
+    if (tableFamily) tableStyle.fontFamily = tableFamily;
+    if (tableColor !== "#000000") tableStyle.color = tableColor;
     const element = {
       type: "table",
       position: { x: Math.round(x0 * 100) / 100, y: Math.round(Math.max(0, y0) * 100) / 100 },
       width: Math.round((x1 - x0) * 100) / 100,
       columns,
-      rows: (() => {
-        const body = grid.slice(headerRows);
-        while (body.length > 1 && body[0].every((c) => !c)) body.shift();
-        return body;
-      })(),
-      style: { fontSize, lineHeight: 1.2, padding: `${Math.round(padV * 100) / 100}mm ${Math.round(padH * 100) / 100}mm` }
+      rows: styledRows,
+      style: tableStyle
     };
     if (headerRows > 0) {
-      element.headers = bands.map((_, k) => grid.slice(0, headerRows).map((r) => r[k]).filter(Boolean).join(" ").trim());
+      element.headers = colBands.map((_, k) => colGrid.slice(0, headerRows).map((r) => r[k]).filter(Boolean).join(" ").trim());
       const hs = { fontWeight: "bold" };
       if (headerBg) hs.backgroundColor = headerBg.fill;
       if (headerBg) {
-        const tally = /* @__PURE__ */ new Map();
-        for (const c of blockRows.slice(0, headerRows).flatMap((r) => r.cells)) tally.set(c.run.color, (tally.get(c.run.color) ?? 0) + c.run.text.length);
-        const hc = [...tally.entries()].sort((a, b) => b[1] - a[1])[0]?.[0];
+        const tally2 = /* @__PURE__ */ new Map();
+        for (const c of blockRows.slice(0, headerRows).flatMap((r) => r.cells)) tally2.set(c.run.color, (tally2.get(c.run.color) ?? 0) + c.run.text.length);
+        const hc = [...tally2.entries()].sort((a, b) => b[1] - a[1])[0]?.[0];
         if (hc && hc !== "#000000") hs.color = hc;
       }
       element.headerStyle = hs;
@@ -1163,13 +1330,13 @@ function detectTables(runs, shapes, pageWidthMm, gutters = []) {
     if (headerBg) for (const { k } of headerBg.rects) fillRects.add(k);
     if (headerRows > 0) {
       const hy0 = gridRows[0].y - gridRows[0].h * 0.5, hy1 = gridRows[headerRows - 1].y + gridRows[headerRows - 1].h * 1.2;
-      for (const { s, k } of gridShapes) if (s.kind === "rect" && s.fill && s.fill.toLowerCase() !== "#ffffff" && !isRule(s) && s.y < hy1 && s.y + s.height > hy0 && s.y >= hy0 - gridRows[0].h) fillRects.add(k);
+      for (const { s, k } of gridShapes) if (s.kind === "rect" && s.fill && s.fill.toLowerCase() !== "#ffffff" && !isRule(s) && s.width >= tableW * 0.5 && s.y < hy1 && s.y + s.height > hy0 && s.y >= hy0 - gridRows[0].h) fillRects.add(k);
     }
     if (altColor) for (const row of blockRows) {
       const f = rowFill(row);
       if (f) for (const { k } of f.rects) fillRects.add(k);
     }
-    const consumedShapes = gridShapes.filter(({ s, k }) => isRule(s) || fillRects.has(k)).map(({ k }) => k);
+    const consumedShapes = gridShapes.filter(({ s, k }) => hasGrid && isRule(s) || fillRects.has(k)).map(({ k }) => k);
     dbg(`table ${grid.length} rows \xD7 ${bands.length} cols at y=${element.position.y}`, element.headers ?? grid[0]);
     for (const k of lineIdx) used.add(k);
     out.push({ element, lineIdx, shapeIdx: consumedShapes });
@@ -1317,9 +1484,12 @@ function merge(para, meta, pageWmm) {
   const pitch = (last.position.y - first.position.y) / (para.length - 1);
   const width = Math.min(pageWmm - x, (right - x) * 1.2 + lineH * 0.4);
   const joiner = () => "\n";
-  const style = { ...first.style ?? {}, lineHeight: Math.round(pitch / lineH * 100) / 100, ...indent > 0.5 ? { textIndent: Math.round(indent * 100) / 100 } : {} };
+  const lineHeight = Math.round(pitch / lineH * 100) / 100;
+  const style = { ...first.style ?? {}, lineHeight, ...indent > 0.5 ? { textIndent: Math.round(indent * 100) / 100 } : {} };
   const allText = para.every((e) => e.type === "text" && !e.link);
-  const base = { position: { x, y: first.position.y }, width: Math.round(width * 100) / 100, style };
+  const y = Math.max(0, first.position.y - (lineHeight - 1) / 2 * lineH);
+  const height = Math.round(para.length * lineHeight * lineH * 100) / 100;
+  const base = { position: { x, y: Math.round(y * 100) / 100 }, width: Math.round(width * 100) / 100, height, style };
   if (allText) {
     const content = para.map((e) => String(e.content ?? "").trim().replace(/[ \t]+/g, " ")).join(joiner());
     const { height: _hh2, ...firstRest } = first;
@@ -1337,18 +1507,123 @@ function merge(para, meta, pageWmm) {
 
 // ../../packages/jdf-pdf-import/src/core.ts
 var PT_TO_MM3 = 0.352778;
-function classifyFont(name) {
-  const n = (name || "").toLowerCase();
-  const bold = /bold|black|heavy|semibold|demibold|extrabold/.test(n);
-  const italic = /italic|oblique/.test(n);
-  let family = "Inter, Helvetica, Arial, sans-serif";
-  if (n.includes("times") || n.includes("serif") || n.includes("roman") || n.includes("georgia") || n.includes("garamond") || n.includes("baskerville")) {
-    family = "Times New Roman, serif";
-  } else if (n.includes("courier") || n.includes("mono") || n.includes("consolas") || n.includes("menlo") || n.includes("source code") || n.includes("fira code")) {
-    family = "JetBrains Mono, ui-monospace, monospace";
-  } else if (n.includes("helvetica") || n.includes("arial") || n.includes("sans") || n.includes("roboto") || n.includes("inter") || n.includes("noto")) {
-    family = "Inter, Helvetica, Arial, sans-serif";
+var SYMBOL_PUA = {
+  61623: "\u2022",
+  61607: "\u25AA",
+  61608: "\u25FB",
+  61618: "\u25A0",
+  61600: "\u25E6",
+  61616: "\u25E6",
+  61558: "\u2756",
+  61656: "\u27A2",
+  61692: "\u2713",
+  61694: "\u2611",
+  61603: "\u2610",
+  61680: "\u21E8",
+  61664: "\u2192",
+  61614: "\u2192",
+  61613: "\u2190",
+  61622: "\xB6",
+  61485: "\u2212",
+  61630: "\u2015",
+  61655: "\u2022",
+  61604: "\u25C6",
+  61686: "\u2716",
+  61691: "\u2717",
+  61672: "\u21D2",
+  61648: "\u2014"
+};
+function mapSymbolGlyphs(str) {
+  let out = "";
+  for (const ch of str) {
+    const c = ch.codePointAt(0);
+    if (c >= 57344 && c <= 63743) {
+      const m = SYMBOL_PUA[c];
+      out += m ?? "\u2022";
+    } else out += ch;
+  }
+  return out;
+}
+function probeFontProgram(data) {
+  if (!(data instanceof Uint8Array) || data.length < 12) return null;
+  try {
+    const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    let off = 0;
+    if (dv.getUint32(0) === 1953784678) off = dv.getUint32(12);
+    const numTables = dv.getUint16(off + 4);
+    if (numTables > 64) return null;
+    const out = { flags: {} };
+    let found = false;
+    for (let i = 0; i < numTables; i++) {
+      const rec = off + 12 + i * 16;
+      if (rec + 16 > data.length) break;
+      const tag = String.fromCharCode(dv.getUint8(rec), dv.getUint8(rec + 1), dv.getUint8(rec + 2), dv.getUint8(rec + 3));
+      const toff = dv.getUint32(rec + 8), tlen = dv.getUint32(rec + 12);
+      if (toff + tlen > data.length) continue;
+      if (tag === "name") {
+        const count = dv.getUint16(toff + 2), strOff = dv.getUint16(toff + 4);
+        for (let k = 0; k < count; k++) {
+          const r = toff + 6 + k * 12;
+          if (r + 12 > data.length) break;
+          const pid = dv.getUint16(r), nid = dv.getUint16(r + 6), len = dv.getUint16(r + 8), so = dv.getUint16(r + 10);
+          if (nid !== 1 && nid !== 2) continue;
+          const start = toff + strOff + so;
+          if (start + len > data.length) continue;
+          let str = "";
+          if (pid === 3 || pid === 0) {
+            for (let j = 0; j + 1 < len; j += 2) str += String.fromCharCode(dv.getUint16(start + j));
+          } else {
+            for (let j = 0; j < len; j++) str += String.fromCharCode(dv.getUint8(start + j));
+          }
+          str = str.replace(/\0/g, "").trim();
+          if (!str) continue;
+          if (nid === 1 && !out.family) out.family = str;
+          if (nid === 2 && !out.subfamily) out.subfamily = str;
+          found = true;
+        }
+      } else if (tag === "OS/2" && tlen >= 42) {
+        const p = Array.from(data.subarray(toff + 32, toff + 42));
+        const familyClass = dv.getUint8(toff + 30);
+        if (p[0] === 2) {
+          if (p[1] >= 11 && p[1] <= 15) out.flags.serif = false;
+          else if (p[1] >= 2 && p[1] <= 10) out.flags.serif = true;
+          if (p[2] >= 7) out.flags.bold = true;
+          if (p[3] === 9) out.flags.monospace = true;
+          if (p[7] >= 9 && p[7] <= 15) out.flags.italic = true;
+          found = true;
+        } else if (familyClass >= 1 && familyClass <= 7) {
+          out.flags.serif = true;
+          found = true;
+        } else if (familyClass === 8) {
+          out.flags.serif = false;
+          found = true;
+        }
+      }
+    }
+    if (out.family && (/^[A-Z]{6}\+/.test(out.family) || /^\d+$/.test(out.family))) out.family = void 0;
+    return found ? out : null;
+  } catch {
+    return null;
   }
+}
+function classifyFont(name, flags = {}) {
+  const n = (name || "").toLowerCase().replace(/[\s_-]+/g, "");
+  const bold = flags.bold || /bold|black|heavy|semibold|demibold|extrabold/.test(n);
+  const italic = flags.italic || /italic|oblique/.test(n);
+  let family;
+  if (n.includes("calibri") || n.includes("carlito")) family = "Carlito, Calibri, sans-serif";
+  else if (n.includes("cambria")) family = "Caladea, Cambria, serif";
+  else if (n.includes("georgia")) family = "Gelasio, Georgia, serif";
+  else if (n.includes("courier") || n.includes("mono") || n.includes("consolas") || n.includes("menlo") || n.includes("sourcecode") || n.includes("firacode")) family = "Cousine, 'Courier New', JetBrains Mono, monospace";
+  else if (n.includes("times") || n.includes("roman") || n.includes("garamond") || n.includes("baskerville") || n.includes("bookantiqua") || n.includes("palatino") || n.includes("minion")) family = "Tinos, 'Times New Roman', serif";
+  else if (n.includes("plexsans")) family = "'IBM Plex Sans', Arimo, sans-serif";
+  else if (n.includes("plexserif")) family = "'IBM Plex Serif', Tinos, serif";
+  else if (n.includes("arial") || n.includes("helvetica") || n.includes("liberationsans") || n.includes("arimo")) family = "Arimo, Arial, Helvetica, sans-serif";
+  else if (n.includes("segoe") || n.includes("verdana") || n.includes("tahoma") || n.includes("roboto") || n.includes("inter") || n.includes("noto") || n.includes("opensans") || n.includes("lato") || n.includes("aptos") || n.includes("sans")) family = "Arimo, Arial, Helvetica, sans-serif";
+  else if (n.includes("serif")) family = "Tinos, 'Times New Roman', serif";
+  else if (flags.monospace) family = "Cousine, 'Courier New', monospace";
+  else if (flags.serif === true) family = "Tinos, 'Times New Roman', serif";
+  else family = "Arimo, Arial, Helvetica, sans-serif";
   return {
     family,
     weight: bold ? "bold" : void 0,
@@ -1417,6 +1692,33 @@ function averageStops(stops) {
   }
   return n ? rgbToHex(r / n, g / n, b / n) : null;
 }
+function irToGradient(ir, toVp, m) {
+  if (!Array.isArray(ir) || ir[0] !== "RadialAxial" || !Array.isArray(ir[3])) return null;
+  const stops = ir[3].filter((st) => Array.isArray(st) && typeof st[1] === "string").map((st) => ({ offset: Math.round(st[0] * 1e3) / 1e3, color: st[1] }));
+  if (stops.length < 2) return null;
+  const type = ir[2] === 3 ? "radial" : "linear";
+  const g = { type, stops };
+  if (type === "linear" && Array.isArray(ir[4]) && Array.isArray(ir[5])) {
+    const p = (pt) => {
+      const q = m ? tx(m, pt[0], pt[1]) : { x: pt[0], y: pt[1] };
+      return toVp(q.x, q.y);
+    };
+    const a = p(ir[4]), b = p(ir[5]);
+    g.angle = Math.round((Math.atan2(b.x - a.x, -(b.y - a.y)) * 180 / Math.PI + 360) % 360);
+  }
+  return g;
+}
+function patternIR(page, arg) {
+  if (!Array.isArray(arg) || arg[0] !== "Shading") return null;
+  const id = arg[1];
+  try {
+    const store = typeof id === "string" && id.startsWith("g_") ? page.commonObjs : page.objs;
+    if (typeof store?.has === "function" && !store.has(id)) return null;
+    return store.get(id);
+  } catch {
+    return null;
+  }
+}
 function patternToColor(page, arg) {
   if (!Array.isArray(arg)) return null;
   if (arg[0] === "TilingPattern") {
@@ -1456,10 +1758,21 @@ async function walkOps(page, OPS, viewport) {
   const opList = await page.getOperatorList({ annotationMode: annotationModeDisable });
   const fnArr = opList.fnArray;
   const argsArr = opList.argsArray;
+  let opIndex = 0;
   const gs = {
     ctm: [1, 0, 0, 1, 0, 0],
+    // Gradient behind the current fill colour (a shading pattern set with scn);
+    // `fill` keeps the average colour so exporters without gradients still paint.
+    fillGradient: void 0,
+    // Clip path in viewport space (set by W / W*); `sh` paints exactly this area.
+    clip: void 0,
     fill: "#000000",
     stroke: "#000000",
+    // Blend mode from the ExtGState (BM). JDF has no blend modes; a multiply /
+    // darken layer is approximated by opacity ∝ how dark it is (a light-grey
+    // "light streak" over a blue banner becomes nearly transparent instead of
+    // an opaque grey blob), a screen / lighten layer by how light it is.
+    blend: "normal",
     lineWidth: 1,
     fillAlpha: 1,
     strokeAlpha: 1,
@@ -1473,6 +1786,24 @@ async function walkOps(page, OPS, viewport) {
     rise: 0
   };
   const snapshot = () => ({ ...gs, ctm: [...gs.ctm] });
+  const luma = (hex) => {
+    const m = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i.exec(hex || "");
+    return m ? (0.2126 * parseInt(m[1], 16) + 0.7152 * parseInt(m[2], 16) + 0.0722 * parseInt(m[3], 16)) / 255 : 0.5;
+  };
+  const groupStack = [];
+  const isNormal = (b) => b === "normal" || b === "source-over" || b === "compatible";
+  const fillOpacity = (color) => {
+    let alpha = gs.fillAlpha;
+    let b = gs.blend;
+    for (let q = groupStack.length - 1; q >= 0; q--) {
+      alpha *= groupStack[q].alpha;
+      if (isNormal(b)) b = groupStack[q].blend;
+    }
+    const l = luma(color ?? gs.fill);
+    if (b === "multiply" || b === "darken" || b === "color-burn" || b === "colorburn") return alpha * Math.max(0.08, 1 - l);
+    if (b === "screen" || b === "lighten" || b === "color-dodge" || b === "colordodge") return alpha * Math.max(0.08, l);
+    return alpha;
+  };
   const stack = [];
   const textOps = [];
   const shapes = [];
@@ -1486,6 +1817,7 @@ async function walkOps(page, OPS, viewport) {
     const minX = Math.min(...xs), maxX = Math.max(...xs);
     const minY = Math.min(...ys), maxY = Math.max(...ys);
     imagePositions.push({
+      seq: opIndex,
       name,
       x: minX * PT_TO_MM3,
       y: minY * PT_TO_MM3,
@@ -1500,20 +1832,55 @@ async function walkOps(page, OPS, viewport) {
   let pathRects = [];
   let pathStart = null;
   let pathLast = null;
+  function clipFromPath() {
+    const rects = [...pathRects, ...pathRect ? [pathRect] : []];
+    const pts = [];
+    let d = "";
+    if (pathSegments.length) {
+      let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+      const vp = pathSegments.map((seg) => {
+        if (seg.type === "Z") return seg;
+        const out = [];
+        for (let k = 0; k < seg.pts.length; k += 2) {
+          const v = toViewport(seg.pts[k], seg.pts[k + 1]);
+          out.push(v.x, v.y);
+          if (v.x < minX) minX = v.x;
+          if (v.x > maxX) maxX = v.x;
+          if (v.y < minY) minY = v.y;
+          if (v.y > maxY) maxY = v.y;
+        }
+        return { type: seg.type, pts: out };
+      });
+      if (!isFinite(minX)) return void 0;
+      d = vp.map((seg) => seg.type === "Z" ? "Z" : `${seg.type} ${Array.from({ length: seg.pts.length / 2 }, (_, k) => `${((seg.pts[2 * k] - minX) * PT_TO_MM3).toFixed(2)} ${((seg.pts[2 * k + 1] - minY) * PT_TO_MM3).toFixed(2)}`).join(" ")}`).join(" ");
+      return { d, x: minX, y: minY, w: maxX - minX, h: maxY - minY };
+    }
+    if (rects.length) {
+      for (const r of rects) {
+        const a = toViewport(r.x, r.y), b = toViewport(r.x + r.w, r.y + r.h);
+        pts.push([Math.min(a.x, b.x), Math.min(a.y, b.y), Math.max(a.x, b.x), Math.max(a.y, b.y)]);
+      }
+      const x0 = Math.min(...pts.map((p) => p[0])), y0 = Math.min(...pts.map((p) => p[1])), x1 = Math.max(...pts.map((p) => p[2])), y1 = Math.max(...pts.map((p) => p[3]));
+      return { d: "", x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
+    }
+    return void 0;
+  }
   function flushPath(isFill, isStroke) {
     for (const r of pathRects) {
       const tl = toViewport(r.x, r.y + r.h);
       const br = toViewport(r.x + r.w, r.y);
       shapes.push({
+        seq: opIndex,
         kind: "rect",
         x: Math.min(tl.x, br.x) * PT_TO_MM3,
         y: Math.min(tl.y, br.y) * PT_TO_MM3,
         width: Math.abs(br.x - tl.x) * PT_TO_MM3,
         height: Math.abs(br.y - tl.y) * PT_TO_MM3,
         fill: isFill ? gs.fill : void 0,
+        gradient: isFill ? gs.fillGradient : void 0,
         stroke: isStroke ? gs.stroke : void 0,
         strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM3 : void 0,
-        opacity: isFill ? gs.fillAlpha : gs.strokeAlpha
+        opacity: isFill ? fillOpacity() : gs.strokeAlpha
       });
     }
     pathRects = [];
@@ -1525,15 +1892,17 @@ async function walkOps(page, OPS, viewport) {
       const w = Math.abs(br.x - tl.x);
       const h = Math.abs(br.y - tl.y);
       shapes.push({
+        seq: opIndex,
         kind: "rect",
         x: x * PT_TO_MM3,
         y: y * PT_TO_MM3,
         width: w * PT_TO_MM3,
         height: h * PT_TO_MM3,
         fill: isFill ? gs.fill : void 0,
+        gradient: isFill ? gs.fillGradient : void 0,
         stroke: isStroke ? gs.stroke : void 0,
         strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM3 : void 0,
-        opacity: isFill ? gs.fillAlpha : gs.strokeAlpha
+        opacity: isFill ? fillOpacity() : gs.strokeAlpha
       });
     } else if (pathSegments.length === 2 && pathSegments[0].type === "M" && pathSegments[1].type === "L") {
       const a = pathSegments[0].pts;
@@ -1555,6 +1924,7 @@ async function walkOps(page, OPS, viewport) {
       const axisAligned = dx < 0.5 || dy < 0.5;
       if (axisAligned) {
         shapes.push({
+          seq: opIndex,
           kind: "line",
           x: minX * PT_TO_MM3,
           y: minY * PT_TO_MM3,
@@ -1566,6 +1936,7 @@ async function walkOps(page, OPS, viewport) {
         });
       } else {
         shapes.push({
+          seq: opIndex,
           kind: "path",
           x: minX * PT_TO_MM3,
           y: minY * PT_TO_MM3,
@@ -1610,17 +1981,21 @@ async function walkOps(page, OPS, viewport) {
           }
           return `${seg.type} ${p.join(" ")}`;
         }).join(" ");
+        const straight = vpSegments.every((seg) => seg.type === "M" || seg.type === "L" || seg.type === "Z");
+        const thin = isFill && straight && Math.min(bw, bh) * PT_TO_MM3 < 0.6 && Math.max(bw, bh) * PT_TO_MM3 >= 1;
         shapes.push({
-          kind: "path",
+          seq: opIndex,
+          kind: thin ? "rect" : "path",
           x: minX * PT_TO_MM3,
           y: minY * PT_TO_MM3,
           width: bw * PT_TO_MM3,
           height: bh * PT_TO_MM3,
           fill: isFill ? gs.fill : void 0,
+          gradient: isFill ? gs.fillGradient : void 0,
           stroke: isStroke ? gs.stroke : void 0,
           strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM3 : void 0,
-          opacity: isFill ? gs.fillAlpha : gs.strokeAlpha,
-          path: d
+          opacity: isFill ? fillOpacity() : gs.strokeAlpha,
+          path: thin ? void 0 : d
         });
       }
     }
@@ -1630,6 +2005,7 @@ async function walkOps(page, OPS, viewport) {
     pathLast = null;
   }
   for (let i = 0; i < fnArr.length; i++) {
+    opIndex = i;
     const fn = fnArr[i];
     const args = argsArr[i] || [];
     if (fn === OPS.save) {
@@ -1639,11 +2015,15 @@ async function walkOps(page, OPS, viewport) {
       if (s) Object.assign(gs, s);
     } else if (fn === OPS.paintFormXObjectBegin) {
       stack.push(snapshot());
+      groupStack.push({ blend: gs.blend, alpha: gs.fillAlpha });
+      gs.blend = "normal";
+      gs.fillAlpha = 1;
       const matrix = args[0];
       if (Array.isArray(matrix) && matrix.length === 6) gs.ctm = multiplyCtm(matrix, gs.ctm);
     } else if (fn === OPS.paintFormXObjectEnd) {
       const s = stack.pop();
       if (s) Object.assign(gs, s);
+      groupStack.pop();
     } else if (fn === OPS.beginText) {
       tm = [1, 0, 0, 1, 0, 0];
       tlm = [1, 0, 0, 1, 0, 0];
@@ -1675,6 +2055,9 @@ async function walkOps(page, OPS, viewport) {
     } else if (fn === OPS.setFillColorN) {
       const c = patternToColor(page, args[0]);
       if (c) gs.fill = c;
+      const ir = patternIR(page, args[0]);
+      const pm = Array.isArray(args[0]) && Array.isArray(args[0][2]) ? args[0][2] : void 0;
+      gs.fillGradient = ir ? irToGradient(ir, toViewport, pm) ?? void 0 : void 0;
     } else if (fn === OPS.setStrokeColorN) {
       const c = patternToColor(page, args[0]);
       if (c) gs.stroke = c;
@@ -1682,10 +2065,12 @@ async function walkOps(page, OPS, viewport) {
       gs.ctm = multiplyCtm(args, gs.ctm);
     } else if (fn === OPS.setFillRGBColor) {
       gs.fill = rgbToHex(args[0], args[1], args[2]);
+      gs.fillGradient = void 0;
     } else if (fn === OPS.setStrokeRGBColor) {
       gs.stroke = rgbToHex(args[0], args[1], args[2]);
     } else if (fn === OPS.setFillGray) {
       gs.fill = rgbToHex(args[0], args[0], args[0]);
+      gs.fillGradient = void 0;
     } else if (fn === OPS.setStrokeGray) {
       gs.stroke = rgbToHex(args[0], args[0], args[0]);
     } else if (fn === OPS.setFillCMYKColor || fn === OPS.setStrokeCMYKColor) {
@@ -1694,8 +2079,10 @@ async function walkOps(page, OPS, viewport) {
       const g = (1 - m) * (1 - k) * 255;
       const b = (1 - y) * (1 - k) * 255;
       const hex = rgbToHex(r, g, b);
-      if (fn === OPS.setFillCMYKColor) gs.fill = hex;
-      else gs.stroke = hex;
+      if (fn === OPS.setFillCMYKColor) {
+        gs.fill = hex;
+        gs.fillGradient = void 0;
+      } else gs.stroke = hex;
     } else if (fn === OPS.setLineWidth) {
       gs.lineWidth = args[0];
     } else if (fn === OPS.setTextRenderingMode) {
@@ -1709,6 +2096,7 @@ async function walkOps(page, OPS, viewport) {
           if (key === "LW") gs.lineWidth = val;
           else if (key === "ca") gs.fillAlpha = val;
           else if (key === "CA") gs.strokeAlpha = val;
+          else if (key === "BM") gs.blend = String(Array.isArray(val) ? val[0] : val).toLowerCase();
         }
       }
     } else if (fn === OPS.showText) {
@@ -1793,11 +2181,50 @@ async function walkOps(page, OPS, viewport) {
       const isStroke = fn === OPS.stroke || fn === OPS.fillStroke || fn === OPS.eoFillStroke || fn === OPS.closeFillStroke || fn === OPS.closeStroke || fn === OPS.closeEOFillStroke;
       flushPath(isFill, isStroke);
     } else if (fn === OPS.endPath || fn === OPS.clip || fn === OPS.eoClip) {
+      if (fn !== OPS.endPath) {
+        const c = clipFromPath();
+        const prev = gs.clip;
+        if (c && prev) {
+          const x0 = Math.max(c.x, prev.x), y0 = Math.max(c.y, prev.y);
+          const x1 = Math.min(c.x + c.w, prev.x + prev.w), y1 = Math.min(c.y + c.h, prev.y + prev.h);
+          if (x1 <= x0 || y1 <= y0) gs.clip = { d: "", x: x0, y: y0, w: 0, h: 0 };
+          else if (c.d || !prev.d) gs.clip = c.d ? c : { d: "", x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
+          else gs.clip = prev;
+        } else gs.clip = c ?? prev;
+      }
       pathSegments = [];
       pathRects = [];
       pathRect = null;
       pathStart = null;
       pathLast = null;
+    } else if (fn === OPS.shadingFill) {
+      let ir = args[0];
+      if (typeof ir === "string") {
+        try {
+          const store = ir.startsWith("g_") ? page.commonObjs : page.objs;
+          ir = typeof store?.has === "function" && store.has(ir) ? store.get(ir) : null;
+        } catch {
+          ir = null;
+        }
+      }
+      const g = irToGradient(ir, (x, y) => toViewport(...Object.values(tx(gs.ctm, x, y))));
+      const avg = Array.isArray(ir) && ir[0] === "RadialAxial" ? averageStops(ir[3]) : null;
+      const clipArea = gs.clip;
+      if ((g || avg) && !(clipArea && (clipArea.w < 0.5 || clipArea.h < 0.5))) {
+        const area = clipArea ?? { d: "", x: 0, y: 0, w: viewport.width, h: viewport.height };
+        shapes.push({
+          seq: opIndex,
+          kind: area.d ? "path" : "rect",
+          x: area.x * PT_TO_MM3,
+          y: area.y * PT_TO_MM3,
+          width: Math.max(0.1, area.w * PT_TO_MM3),
+          height: Math.max(0.1, area.h * PT_TO_MM3),
+          fill: avg ?? (g ? g.stops[0].color : void 0),
+          gradient: g ?? void 0,
+          opacity: fillOpacity(avg ?? g?.stops[0].color),
+          path: area.d || void 0
+        });
+      }
     } else if (fn === OPS.paintImageXObject) {
       pushImage(String(args[0]), gs.ctm);
     } else if (fn === OPS.paintImageXObjectRepeat) {
@@ -2108,6 +2535,9 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
     // newer Node. Browser entry leaves this unset (= false = real worker
     // via GlobalWorkerOptions.workerSrc); node entry sets `true`.
     disableWorker: runtime.disableWorker === true,
+    // Keep font flags (serif / monospace / bold / italic) on the font objects
+    // so classifyFont can pick a metric-compatible family for unknown names.
+    fontExtraProperties: true,
     isEvalSupported: false,
     // Keep going past malformed content streams instead of failing the page.
     stopAtErrors: false,
@@ -2186,6 +2616,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
     for (const k of Object.keys(textContent.styles || {})) {
       const s = textContent.styles[k];
       let realName = s.fontFamily || k;
+      const flags = {};
       try {
         const has = typeof page.commonObjs.has === "function" ? page.commonObjs.has(k) : false;
         if (has) {
@@ -2201,6 +2632,15 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
               page.commonObjs.get(k, (font) => {
                 if (font?.name) realName = font.name;
                 else if (font?.loadedName) realName = font.loadedName;
+                if (font) {
+                  const probe = probeFontProgram(font.data);
+                  const anonymous = /^(?:[A-Z]{6}\+)?(?:CIDFont\+)?F\d+$/i.test(String(font.name || "")) || !/[a-z]{3}/i.test(String(font.name || "").replace(/^[A-Z]{6}\+/, ""));
+                  if (probe?.family && anonymous) realName = probe.family + (probe.subfamily ? " " + probe.subfamily : "");
+                  else if (probe?.subfamily && /bold|italic|oblique/i.test(probe.subfamily) && !/bold|italic|oblique/i.test(realName)) realName += " " + probe.subfamily;
+                  if (probe) Object.assign(flags, probe.flags);
+                  if (flags.monospace == null && font.isMonospace) flags.monospace = true;
+                  if (flags.serif == null && !font.isSymbolicFont && font.isSerifFont) flags.serif = true;
+                }
                 done();
               });
             } catch {
@@ -2211,7 +2651,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         }
       } catch {
       }
-      const cls = classifyFont(realName);
+      const cls = classifyFont(realName, flags);
       if (!cls.weight && /bold/i.test(s.fontFamily || "")) cls.weight = "bold";
       if (!cls.style && /italic|oblique/i.test(s.fontFamily || "")) cls.style = "italic";
       fontMap.set(k, cls);
@@ -2287,11 +2727,15 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       if (mode === 7) return;
       const invisible = mode === 3;
       if (invisible && !keepInvisible) return;
-      const ascent = it.height ? safeNum(it.height, fontSize) * 0.78 : fontSize * 0.78;
+      const ascent = fontSize * 0.846;
       const yTop = vy - ascent;
       const w = safeNum(it.width, 0);
+      const skew = fontSize > 0 && Math.abs(safeNum(tr?.[2], 0)) / fontSize > 0.1 && Math.abs(safeNum(tr?.[1], 0)) / fontSize < 0.1;
+      const rotated = fontSize > 0 && Math.abs(safeNum(tr?.[1], 0)) / fontSize > 0.1;
       runs.push({
-        text: it.str,
+        text: mapSymbolGlyphs(it.str),
+        ...skew ? { italic: true } : {},
+        ...rotated ? { rotated: true } : {},
         x: safeNum(vx * PT_TO_MM3, 0),
         y: safeNum(yTop * PT_TO_MM3, 0),
         fontSize: safeNum(fontSize, 10),
@@ -2331,7 +2775,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         continue;
       }
       const sameLine = Math.abs(last.y - r.y) <= Y_TOL;
-      const sameStyle = Math.abs(last.fontSize - r.fontSize) < 0.4 && (last.fontName === r.fontName || fontKey(last.fontName) === fontKey(r.fontName)) && last.color === r.color && Math.abs(last.opacity - r.opacity) < 0.05;
+      const sameStyle = Math.abs(last.fontSize - r.fontSize) < 0.4 && (last.fontName === r.fontName || fontKey(last.fontName) === fontKey(r.fontName)) && last.color === r.color && !!last.italic === !!r.italic && !!last.rotated === !!r.rotated && Math.abs(last.opacity - r.opacity) < 0.05;
       const emMm = r.fontSize * PT_TO_MM3;
       const gapMm = r.x - (last.x + extent(last));
       const symAfterNumber = /^[$€£¥]$/.test(r.text.trim()) && /[\d)]\s*$/.test(last.text);
@@ -2352,7 +2796,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       for (const l of lines) {
         const t = l.text.trim();
         const recent = keep.slice(-40);
-        const dup = t.length ? recent.find((k) => Math.abs(k.y - l.y) <= 0.6 && Math.abs(k.x - l.x) <= 0.8 && Math.abs(k.fontSize - l.fontSize) < 0.6 && k.text.trim() === t) : void 0;
+        const dup = t.length ? recent.find((k) => Math.abs(k.y - l.y) <= 0.9 && Math.abs(k.x - l.x) <= 1.3 && Math.abs(k.fontSize - l.fontSize) < 0.6 && k.text.trim() === t) : void 0;
         if (dup) {
           dup.bold = true;
           continue;
@@ -2366,7 +2810,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
     const lineMeta = /* @__PURE__ */ new WeakMap();
     const tRuns = lines.map((l) => {
       const cls = fontMap.get(l.fontName) || classifyFont(l.fontName || "");
-      return { text: l.text, x: l.x, y: l.y, width: extent(l), height: l.height, fontSize: l.fontSize, fontName: l.fontName, color: l.color, bold: cls.weight === "bold" || !!l.bold };
+      return { text: l.text, x: l.x, y: l.y, width: extent(l), height: l.height, fontSize: l.fontSize, fontName: l.fontName, color: l.color, bold: cls.weight === "bold" || !!l.bold, italic: cls.style === "italic" || !!l.italic, family: cls.family };
     });
     const sizeChars = /* @__PURE__ */ new Map();
     for (const l of lines) {
@@ -2376,7 +2820,8 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
     const bodyFontSize = [...sizeChars.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? 0;
     const gutters = options.readingOrder === false ? [] : detectGutters(lines.map((l) => ({ text: l.text, x: l.x, y: l.y, width: l.width, fontSize: l.fontSize })), bodyFontSize, pageW * PT_TO_MM3);
     const pageShapes = mergeCollinearShapes(ops.shapes);
-    const detected = options.detectTables === false ? [] : detectTables(tRuns, pageShapes, pageW * PT_TO_MM3, gutters);
+    const isFormPage = formWidgets.length >= 5;
+    const detected = options.detectTables === false || isFormPage ? [] : detectTables(tRuns, pageShapes, pageW * PT_TO_MM3, gutters);
     const consumedLines = /* @__PURE__ */ new Set();
     const consumedShapes = /* @__PURE__ */ new Set();
     const tableAtLine = /* @__PURE__ */ new Map();
@@ -2386,6 +2831,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       tableAtLine.set(Math.min(...t.lineIdx), t.element);
     }
     const pageWmm = pageW * PT_TO_MM3, pageHmm = pageH * PT_TO_MM3;
+    const paintSeq = /* @__PURE__ */ new WeakMap();
     pageShapes.forEach((sh, shapeIdx) => {
       if (consumedShapes.has(shapeIdx)) return;
       if (sh.width < 0.3 && sh.height < 0.3) return;
@@ -2400,6 +2846,8 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         height: Math.max(0.1, Math.round(sh.height * 100) / 100)
       };
       if (sh.fill) shape.fill = sh.fill;
+      if (sh.gradient) shape.gradient = sh.gradient;
+      paintSeq.set(shape, sh.seq ?? 0);
       if (sh.stroke) shape.stroke = { color: sh.stroke, width: sh.strokeWidth || 0.3 };
       if (shapeType === "path" && sh.path) shape.path = sh.path;
       if (sh.opacity != null && sh.opacity < 0.999) {
@@ -2420,15 +2868,18 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
           data: base64
         };
       }
-      elements.push({
+      const imgEl = {
         type: "image",
         resource: resourceKey,
         position: { x: Math.round(pos.x * 100) / 100, y: Math.round(pos.y * 100) / 100 },
         width: Math.max(1, Math.round(pos.w * 100) / 100),
         height: Math.max(1, Math.round(pos.h * 100) / 100),
         fit: "fill"
-      });
+      };
+      paintSeq.set(imgEl, pos.seq ?? 0);
+      elements.push(imgEl);
     }
+    elements.sort((a, b) => (paintSeq.get(a) ?? 0) - (paintSeq.get(b) ?? 0));
     const rowOf = /* @__PURE__ */ new Map();
     const rowStartOf = /* @__PURE__ */ new Map();
     const nextOnRow = /* @__PURE__ */ new Map();
@@ -2440,7 +2891,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         for (let b = 0; b < order.length; b++) {
           const j = order[b], lj = lines[j];
           const tolY = Math.max(0.6, Math.max(li.fontSize, lj.fontSize) * PT_TO_MM3 * 0.5);
-          if (j === i || Math.abs(lj.y - li.y) > tolY || lj.x <= li.x) continue;
+          if (j === i || lj.rotated || li.rotated || Math.abs(lj.y - li.y) > tolY || lj.x <= li.x) continue;
           if (lj.x < bestX) {
             bestX = lj.x;
             bestNext = j;
@@ -2448,19 +2899,27 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         }
         if (bestNext >= 0) nextOnRow.set(i, bestNext);
       }
-      const seen = /* @__PURE__ */ new Set();
+      const joinsLeft = (cur, j) => {
+        const lc = lines[cur], lj = lines[j];
+        const em = Math.min(lc.fontSize, lj.fontSize) * PT_TO_MM3;
+        const gap = lj.x - (lc.x + extent(lc));
+        const prose = (a, b) => /\s$/.test(a.text) && /^[a-zà-ÿ]/.test(b.text.trim()) && a.text.trim().length >= 3 && b.text.trim().length >= 12 && !/\d[\d,.]*$/.test(a.text.trim());
+        const maxGap = prose(lc, lj) ? em * 2 : em * 0.6;
+        return !(gap < -em * 0.3 || gap > maxGap);
+      };
+      const joined = /* @__PURE__ */ new Set();
+      for (const i of order) {
+        const j = nextOnRow.get(i);
+        if (j != null && joinsLeft(i, j)) joined.add(j);
+      }
       for (const i of order) {
-        if (seen.has(i)) continue;
+        if (joined.has(i)) continue;
         const row = [i];
-        seen.add(i);
         let cur = i;
         while (nextOnRow.has(cur)) {
-          const j = nextOnRow.get(cur), lc = lines[cur], lj = lines[j];
-          const em = Math.min(lc.fontSize, lj.fontSize) * PT_TO_MM3;
-          const gap = lj.x - (lc.x + extent(lc));
-          if (gap < -em * 0.3 || gap > em * 0.6) break;
+          const j = nextOnRow.get(cur);
+          if (!joinsLeft(cur, j)) break;
           row.push(j);
-          seen.add(j);
           cur = j;
         }
         rowOf.set(i, row);
@@ -2469,12 +2928,19 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
     }
     const runStyle = (l) => {
       const cls = fontMap.get(l.fontName) || classifyFont(l.fontName || "");
-      return { cls, bold: cls.weight === "bold" || !!l.bold, italic: cls.style === "italic" };
+      return { cls, bold: cls.weight === "bold" || !!l.bold, italic: cls.style === "italic" || !!l.italic };
+    };
+    const underWidgetValue = (l) => {
+      const t = l.text.trim();
+      if (!t) return false;
+      const cx = l.x + extent(l) / 2, cy = l.y + l.height / 2;
+      return formWidgets.some((w) => !w.pushButton && typeof w.fieldValue === "string" && w.fieldValue.trim() === t && cx >= w.rectMm.x && cx <= w.rectMm.x + w.rectMm.w && cy >= w.rectMm.y - 1 && cy <= w.rectMm.y + w.rectMm.h + 1);
     };
     lines.forEach((l, lineIdx) => {
       const tableEl = tableAtLine.get(lineIdx);
       if (tableEl) elements.push(tableEl);
       if (consumedLines.has(lineIdx)) return;
+      if (underWidgetValue(l)) return;
       const row = rowOf.get(lineIdx);
       if (!row) return;
       if (row.length > 1) {
@@ -2504,13 +2970,15 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
           if (lk) run.link = lk.url ? lk.url : lk.destPage != null ? { type: "internal", target: `#page-${lk.destPage + 1}` } : void 0;
           runs2.push(run);
         });
-        const style2 = { fontSize: Math.round(first.fontSize * 10) / 10, fontFamily: base.cls.family };
+        const style2 = { fontSize: Math.round(first.fontSize * 10) / 10, fontFamily: base.cls.family, lineHeight: 1 };
+        const rowHeight = Math.round(first.fontSize * PT_TO_MM3 * 100) / 100;
         if (first.opacity < 0.999) style2.opacity = Math.round(first.opacity * 100) / 100;
         const rt = {
           type: "richtext",
           runs: runs2,
           position: { x: Math.max(0, Math.round(first.x * 100) / 100), y: Math.max(0, Math.round(Math.min(...row.map((i) => lines[i].y)) * 100) / 100) },
           width: Math.max(2, Math.round(Math.max(first.fontSize * PT_TO_MM3, Math.min(measuredW, cap2)) * 100) / 100),
+          height: rowHeight,
           style: style2
         };
         const dominant = row.map((i) => lines[i]).sort((a, b) => b.text.trim().length - a.text.trim().length)[0];
@@ -2521,10 +2989,11 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       const cls = fontMap.get(l.fontName) || classifyFont(l.fontName || "");
       const style = {
         fontSize: Math.round(l.fontSize * 10) / 10,
-        fontFamily: cls.family
+        fontFamily: cls.family,
+        lineHeight: 1
       };
       if (cls.weight === "bold" || l.bold) style.fontWeight = "bold";
-      if (cls.style === "italic") style.fontStyle = "italic";
+      if (cls.style === "italic" || l.italic) style.fontStyle = "italic";
       if (l.color !== "#000000") style.color = l.color;
       if (l.opacity < 0.999) style.opacity = Math.round(l.opacity * 100) / 100;
       const link = findLinkForRun2(l);
@@ -2538,6 +3007,8 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         content: l.text,
         position: { x: Math.max(0, Math.round(l.x * 100) / 100), y: Math.max(0, Math.round(l.y * 100) / 100) },
         width: Math.max(2, Math.round(elWidth * 100) / 100),
+        // One line at lineHeight 1: the box is exactly one em tall.
+        height: Math.round(l.fontSize * PT_TO_MM3 * 100) / 100,
         style
       };
       if ((cls.weight === "bold" || l.bold) && l.text.trim().length <= 120 && !consumedLines.has(lineIdx)) {
@@ -2556,6 +3027,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         prev.content = `${prev.content} ${text.content}`.replace(/\s+/g, " ");
         prev.tocEntry = prev.content;
         prev.width = Math.max(prev.width ?? 0, text.width ?? 0);
+        prev.height = Math.round((text.position.y + (text.height ?? 0) - prev.position.y) * 100) / 100;
         return;
       }
       lineMeta.set(text, { w: Math.max(l.fontSize * PT_TO_MM3, extent(l)), size: l.fontSize, face: fontKey(l.fontName) });
@@ -2604,6 +3076,9 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         elements.push({ type: "signature", ...baseEl, value: "" });
       }
     }
+    elements.forEach((e, k) => {
+      if (e.id == null) e.id = `p${pi}-e${k + 1}`;
+    });
     pages.push({
       id: `page-${pi}`,
       pageSize: { width: Math.round(pageW * PT_TO_MM3 * 100) / 100, height: Math.round(pageH * PT_TO_MM3 * 100) / 100 },

package/dist/jdf-schema.json

@@ -203,7 +203,7 @@
       "type": "object",
       "required": ["type", "name"],
       "properties": {
-        "type": { "const": "input" },
+        "type": { "const": "input" }, "id": { "type": "string" },
         "name": { "type": "string", "minLength": 1 },
         "inputType": { "type": "string", "enum": ["text","number","email","url","tel","date","time","datetime-local","password","color"] },
         "value": { "type": "string" },
@@ -222,7 +222,7 @@
       "type": "object",
       "required": ["type", "name"],
       "properties": {
-        "type": { "const": "textarea" },
+        "type": { "const": "textarea" }, "id": { "type": "string" },
         "name": { "type": "string", "minLength": 1 },
         "value": { "type": "string" },
         "placeholder": { "type": "string" },
@@ -240,7 +240,7 @@
       "type": "object",
       "required": ["type", "name"],
       "properties": {
-        "type": { "const": "checkbox" },
+        "type": { "const": "checkbox" }, "id": { "type": "string" },
         "name": { "type": "string", "minLength": 1 },
         "checked": { "type": "boolean" },
         "label": { "type": "string" },
@@ -256,7 +256,7 @@
       "type": "object",
       "required": ["type", "name", "options"],
       "properties": {
-        "type": { "const": "select" },
+        "type": { "const": "select" }, "id": { "type": "string" },
         "name": { "type": "string", "minLength": 1 },
         "options": {
           "type": "array",
@@ -285,7 +285,7 @@
       "type": "object",
       "required": ["type", "name"],
       "properties": {
-        "type": { "const": "signature" },
+        "type": { "const": "signature" }, "id": { "type": "string" },
         "name": { "type": "string", "minLength": 1 },
         "value": { "type": "string" },
         "label": { "type": "string" },
@@ -301,7 +301,7 @@
       "type": "object",
       "required": ["type", "content"],
       "properties": {
-        "type": { "const": "text" },
+        "type": { "const": "text" }, "id": { "type": "string" },
         "content": { "type": "string" },
         "style": { "$ref": "#/definitions/StyleRef" },
         "position": { "$ref": "#/definitions/Position" },
@@ -318,7 +318,7 @@
       "type": "object",
       "required": ["type", "runs"],
       "properties": {
-        "type": { "const": "richtext" },
+        "type": { "const": "richtext" }, "id": { "type": "string" },
         "runs": {
           "type": "array",
           "items": {
@@ -395,7 +395,7 @@
       "type": "object",
       "required": ["type", "rows"],
       "properties": {
-        "type": { "const": "table" },
+        "type": { "const": "table" }, "id": { "type": "string" },
         "columns": {
           "type": "array",
           "items": { "type": "object", "properties": { "width": { "oneOf": [{ "type": "string" }, { "type": "number" }] }, "header": { "type": "string" }, "align": { "type": "string", "enum": ["left","center","right","justify"] } } }
@@ -418,7 +418,7 @@
       "type": "object",
       "required": ["type", "items"],
       "properties": {
-        "type": { "const": "list" },
+        "type": { "const": "list" }, "id": { "type": "string" },
         "items": {
           "type": "array",
           "items": { "type": "object", "required": ["content"], "properties": { "content": { "type": "string" }, "style": { "$ref": "#/definitions/StyleRef" }, "children": { "type": "array", "items": { "$ref": "#/definitions/ListElement/properties/items/items" } }, "listType": { "type": "string", "enum": ["ordered","unordered"] } } }
@@ -433,13 +433,25 @@
       "type": "object",
       "required": ["type", "shape"],
       "properties": {
-        "type": { "const": "shape" },
+        "type": { "const": "shape" }, "id": { "type": "string" },
         "shape": { "type": "string", "enum": ["rect","circle","ellipse","line","path"] },
         "position": { "$ref": "#/definitions/Position" }, "width": { "type": "number" }, "height": { "type": "number" },
         "fill": { "type": "string" },
         "stroke": { "oneOf": [{ "type": "string" }, { "type": "object", "properties": { "color": { "type": "string" }, "width": { "type": "number" } } }] },
         "strokeWidth": { "type": "number" }, "borderRadius": { "type": "number" }, "path": { "type": "string" },
         "points": { "type": "array", "items": { "$ref": "#/definitions/Position" } },
+        "gradient": {
+          "type": "object",
+          "required": ["type", "stops"],
+          "properties": {
+            "type": { "type": "string", "enum": ["linear", "radial"] },
+            "angle": { "type": "number" },
+            "stops": {
+              "type": "array", "minItems": 2,
+              "items": { "type": "object", "required": ["offset", "color"], "properties": { "offset": { "type": "number" }, "color": { "type": "string" } } }
+            }
+          }
+        },
         "style": { "$ref": "#/definitions/StyleRef" }
       }
     },
@@ -447,7 +459,7 @@
       "type": "object",
       "required": ["type", "title", "elements"],
       "properties": {
-        "type": { "const": "collapsible" },
+        "type": { "const": "collapsible" }, "id": { "type": "string" },
         "title": { "type": "string" },
         "elements": { "type": "array", "items": { "$ref": "#/definitions/Element" } },
         "expanded": { "type": "boolean" },
@@ -459,7 +471,7 @@
       "type": "object",
       "required": ["type"],
       "properties": {
-        "type": { "const": "toc" }, "title": { "type": "string" },
+        "type": { "const": "toc" }, "id": { "type": "string" }, "title": { "type": "string" },
         "position": { "$ref": "#/definitions/Position" }, "width": { "type": "number" },
         "depth": { "type": "integer", "minimum": 1, "maximum": 6 },
         "style": { "$ref": "#/definitions/StyleRef" }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uurtech/jdf-cli",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Command-line tool for the JDF (JSON Document Format) — validate and convert documents.",
   "license": "MIT",
   "author": "Ugur Kazdal",