@uurtech/jdf-cli 0.2.2 → 0.2.4

package/dist/index.js

@@ -656,6 +656,14 @@ function textExtent(r, k, stretched) {
   if (stretched) return Math.max(em * 0.5, Math.min(r.width, est));
   return Math.max(em * 0.5, r.width > est * 1.4 ? est : r.width);
 }
+var numeric = (s) => {
+  const t = s.trim();
+  if (!t) return false;
+  if (/^[—–\-]+$/.test(t)) return true;
+  const core = t.replace(/[\s$€£¥(),%]/g, "").replace(/^[+\-−–]/, "");
+  return /^\d+(\.\d+)?(ms|s|k|m|b|M|K|B|x|×)?$/.test(core);
+};
+var isCurrencySymbol = (s) => /^[$€£¥]$/.test(s.trim());
 function groupRows(runs, skip) {
   const k = calibrateGlyphWidth(runs);
   const stretched = hasStretchedSpaces(runs, k);
@@ -677,179 +685,658 @@ function groupRows(runs, skip) {
   for (const row of rows) {
     row.cells.sort((a, b) => a.x0 - b.x0);
     const merged = [];
-    for (const c of row.cells) {
+    let pendingSym = null;
+    const pushCell = (c) => {
       const last = merged[merged.length - 1];
       const em = c.run.fontSize * PT_TO_MM;
-      if (last && c.x0 - last.x1 <= em * 1) {
+      const limit = last && numeric(last.run.text) && numeric(c.run.text) ? em * 0.35 : em * 1;
+      if (last && c.x0 - last.x1 <= limit) {
+        last.parts = [
+          ...last.parts ?? [{ text: last.run.text, x0: last.x0, x1: last.x1, idx: [last.idx, ...last.extra ?? []] }],
+          { text: c.run.text, x0: c.x0, x1: c.x1, idx: [c.idx, ...c.extra ?? []] }
+        ];
         last.x1 = Math.max(last.x1, c.x1);
         last.run = { ...last.run, text: `${last.run.text.replace(/\s+$/, "")} ${c.run.text.replace(/^\s+/, "")}`, width: last.x1 - last.x0 };
-        last.extra = [...last.extra ?? [], c.idx];
+        last.extra = [...last.extra ?? [], c.idx, ...c.extra ?? []];
       } else merged.push({ ...c });
+    };
+    for (const c of row.cells) {
+      if (isCurrencySymbol(c.run.text)) {
+        if (pendingSym) merged.push(pendingSym);
+        pendingSym = { ...c };
+        continue;
+      }
+      if (pendingSym) {
+        const em = c.run.fontSize * PT_TO_MM;
+        if (numeric(c.run.text) && c.x0 - pendingSym.x1 <= em * 8) {
+          const cell = { ...c, run: { ...c.run, text: `${pendingSym.run.text.trim()} ${c.run.text.trim()}` } };
+          cell.extra = [...c.extra ?? [], pendingSym.idx, ...pendingSym.extra ?? []];
+          pendingSym = null;
+          pushCell(cell);
+          continue;
+        }
+        merged.push(pendingSym);
+        pendingSym = null;
+      }
+      pushCell(c);
     }
+    if (pendingSym) merged.push(pendingSym);
     row.cells = merged;
   }
   return rows;
 }
-function columnBands(rows) {
-  const cells = rows.flatMap((r) => r.cells);
-  const sorted = cells.slice().sort((a, b) => a.x0 - b.x0);
+var overlaps = (c, b) => c.x0 < b.x1 - 0.2 && c.x1 > b.x0 + 0.2;
+function clusterCells(cells) {
+  const sorted = cells.slice().sort((a, b) => a.c.x0 - b.c.x0);
   const bands = [];
-  for (const c of sorted) {
+  for (const m of sorted) {
     const last = bands[bands.length - 1];
-    if (last && c.x0 <= last.x1 - 0.2) {
-      last.x1 = Math.max(last.x1, c.x1);
-      last.members.push(c);
-    } else bands.push({ x0: c.x0, x1: c.x1, members: [c] });
+    if (last && m.c.x0 <= last.x1 - 0.2) {
+      last.x1 = Math.max(last.x1, m.c.x1);
+      last.members.push(m);
+    } else bands.push({ x0: m.c.x0, x1: m.c.x1, members: [m] });
   }
+  return bands;
+}
+function hasConflict(bands) {
   for (const b of bands) {
-    const rowsSeen = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set();
     for (const m of b.members) {
-      const row = rows.find((r) => r.cells.includes(m));
-      if (rowsSeen.has(row)) return null;
-      rowsSeen.add(row);
+      if (seen.has(m.r)) return true;
+      seen.add(m.r);
+    }
+  }
+  return false;
+}
+function columnBands(rows) {
+  const all = rows.flatMap((r) => r.cells.map((c) => ({ c, r })));
+  if (!all.length) return null;
+  const firstOf = new Set(rows.map((r) => r.cells[0]));
+  const others = all.filter((m) => !firstOf.has(m.c));
+  const othersMin = others.length ? Math.min(...others.map((m) => m.c.x0)) : Infinity;
+  const leftOf = (m) => m.c.x0 < othersMin - Math.max(1, m.c.run.fontSize * PT_TO_MM * 1.5);
+  const textLabels = all.filter((m) => firstOf.has(m.c) && leftOf(m) && !numeric(m.c.run.text));
+  const labelX = textLabels.length ? Math.min(...textLabels.map((m) => m.c.x0)) : Infinity;
+  const isLabel = (m) => firstOf.has(m.c) && leftOf(m) && (!numeric(m.c.run.text) || m.c.x0 <= labelX + m.c.run.fontSize * PT_TO_MM * 3);
+  const body = all.filter((m) => !isLabel(m));
+  const labels = all.filter(isLabel);
+  if (!body.length) return null;
+  const assign = /* @__PURE__ */ new Map();
+  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 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;
+  }
+  for (const m of body) {
+    if (anchorRows.has(m.r)) continue;
+    let bi = -1, bestOv = 0;
+    bands.forEach((b, k) => {
+      if (b.members.some((o) => o.r === m.r)) return;
+      const ov = Math.min(m.c.x1, b.x1) - Math.max(m.c.x0, b.x0);
+      if (ov > bestOv) {
+        bestOv = ov;
+        bi = k;
+      }
+    });
+    if (bi < 0) {
+      const w = m.c.x1 - m.c.x0;
+      if (bands.some((b) => Math.min(m.c.x1, b.x1) - Math.max(m.c.x0, b.x0) > w * 0.5)) return null;
+      bands.push({ x0: m.c.x0, x1: m.c.x1, members: [m] });
+      continue;
     }
+    bands[bi].members.push(m);
+    const touched = bands.filter((b) => overlaps(m.c, b)).length;
+    if (touched <= 1) {
+      bands[bi].x0 = Math.min(bands[bi].x0, m.c.x0);
+      bands[bi].x1 = Math.max(bands[bi].x1, m.c.x1);
+    }
+  }
+  bands.sort((a, b) => a.x0 - b.x0);
+  for (let k = 0; k + 1 < bands.length; ) {
+    const a = bands[k], b = bands[k + 1];
+    const shareRow = a.members.some((m) => b.members.some((o) => o.r === m.r));
+    const em = Math.min(...[...a.members, ...b.members].map((m) => m.c.run.fontSize)) * PT_TO_MM;
+    if (!shareRow && b.x0 - a.x1 <= em * 1.5) {
+      bands.splice(k, 2, { x0: a.x0, x1: Math.max(a.x1, b.x1), members: [...a.members, ...b.members] });
+    } else k++;
   }
-  return bands.map(({ x0, x1 }) => ({ x0, x1 }));
+  const out = [];
+  if (labels.length) {
+    const lx0 = Math.min(...labels.map((m) => m.c.x0));
+    const lx1 = Math.min(Math.max(...labels.map((m) => m.c.x1)), bands[0].x0 - 0.2);
+    out.push({ x0: lx0, x1: Math.max(lx1, lx0 + 1) });
+    for (const m of labels) assign.set(m.c, 0);
+  }
+  const off = out.length;
+  bands.forEach((b, k) => {
+    out.push({ x0: b.x0, x1: b.x1 });
+    for (const m of b.members) assign.set(m.c, k + off);
+  });
+  return { bands: out, assign };
 }
-var numeric = (s) => /^[\s$€£¥+\-−–]*[\d.,]+\s*(%|ms|s|k|m|b|M|K|B|x|×)?\s*(\/\w+)?$/i.test(s.trim()) || /^[+\-−]?\d/.test(s.trim()) && /\d$/.test(s.trim().replace(/[%)]$/, ""));
-function detectTables(runs, shapes, pageWidthMm) {
+var dbg = (...a) => {
+  if (typeof process !== "undefined" && process.env?.JDF_TABLE_DEBUG) console.error("[tables]", ...a);
+};
+function detectTables(runs, shapes, pageWidthMm, gutters = []) {
   const out = [];
   const used = /* @__PURE__ */ new Set();
   const rows = groupRows(runs, () => false);
   const pageW = pageWidthMm;
+  const emOf = (c) => c.run.fontSize * PT_TO_MM;
   let i = 0;
   while (i < rows.length) {
     if (rows[i].cells.length < 2) {
       i++;
       continue;
     }
+    dbg(`block from "${rows[i].cells.map((c) => c.run.text.slice(0, 14)).join(" | ")}"`);
     let j = i;
     let cur = columnBands([rows[i]]);
     let best = null;
+    let loneStreak = 0;
     while (j + 1 < rows.length && cur) {
       const next = rows[j + 1];
       const gap = next.y - (rows[j].y + rows[j].h);
       const rowH = Math.max(rows[j].h, next.h);
-      if (gap > rowH * 2.2) break;
+      const established = !!best && best.j - i >= 2;
+      if (gap > rowH * (established ? 3.4 : 2.2)) {
+        dbg(`break: gap ${gap.toFixed(1)} after "${rows[j].cells[0].run.text.slice(0, 30)}"`);
+        break;
+      }
+      const bands2 = cur.bands;
       if (next.cells.length === 1) {
         const c = next.cells[0];
-        const inBand = cur.findIndex((b) => c.x0 < b.x1 - 0.2 && c.x1 > b.x0 + 0.2);
-        const spansSeveral = cur.filter((b) => c.x0 < b.x1 - 0.2 && c.x1 > b.x0 + 0.2).length > 1;
-        if (inBand <= 0 || spansSeveral) break;
-        j++;
-        continue;
+        const inBands = bands2.filter((b) => overlaps(c, b));
+        const inBand = inBands.length ? bands2.indexOf(inBands[0]) : -1;
+        const spansSeveral = inBands.length > 1;
+        if (inBand > 0 && !spansSeveral) {
+          j++;
+          continue;
+        }
+        const isLabel = c.x1 <= bands2[bands2.length - 1].x0 - 0.5 && (c.x0 <= bands2[0].x0 + emOf(c) * 3 || c.x1 < bands2[0].x0 - 0.5);
+        if (isLabel && loneStreak < 4) {
+          loneStreak++;
+          j++;
+          continue;
+        }
+        dbg(`break: lone line "${c.run.text.slice(0, 40)}" inBand=${inBand} spans=${spansSeveral} label=${isLabel} streak=${loneStreak}`);
+        break;
       }
+      loneStreak = 0;
       const nb = columnBands(rows.slice(i, j + 2));
-      if (!nb || nb.length < 2) break;
-      if (nb.length > cur.length && j - i >= 2) break;
+      if (!nb || nb.bands.length < 2) {
+        dbg(`break: no bands at "${next.cells.map((c) => c.run.text.slice(0, 15)).join(" | ")}"`);
+        break;
+      }
+      if (nb.bands.length > bands2.length && j - i >= 2) {
+        const fresh = nb.bands.filter((b) => !bands2.some((o) => overlaps(b, o)) && b.x0 > bands2[0].x0);
+        if (fresh.some((b) => b.x1 - b.x0 > 20)) {
+          dbg(`break: wide fresh band at "${next.cells.map((c) => c.run.text.slice(0, 15)).join(" | ")}"`);
+          break;
+        }
+      }
       cur = nb;
       j++;
-      if (cur.length >= 2) best = { j, bands: cur };
+      if (cur.bands.length >= 2) best = { j, res: cur };
     }
-    const multiRows = best ? rows.slice(i, best.j + 1).filter((r) => r.cells.length >= 2).length : 0;
     const blockRows = best ? rows.slice(i, best.j + 1) : [];
+    const multiRows = blockRows.filter((r) => r.cells.length >= 2).length;
     const bbox = blockRows.length ? {
-      x0: Math.min(...best.bands.map((b) => b.x0)) - 5,
-      x1: Math.max(...best.bands.map((b) => b.x1)) + 5,
+      x0: Math.min(...best.res.bands.map((b) => b.x0)) - 5,
+      x1: Math.max(...best.res.bands.map((b) => b.x1)) + 5,
       // Cell padding puts backgrounds/borders well above the first baseline and below the last.
       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 hasLattice = gridShapes.length >= 3;
-    if (!best || multiRows < (hasLattice ? 2 : 3) || best.bands.length < 2) {
+    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);
+    const verticalRules = blockRows.length ? gridShapes.filter(({ s }) => isRule(s) && s.height > s.width && s.height >= blockRows[0].h * 1.5).length : 0;
+    const rowFill = (row) => {
+      const cy = row.y + row.h * 0.5;
+      const rects = gridShapes.filter(({ s }) => s.kind === "rect" && s.fill && s.fill.toLowerCase() !== "#ffffff" && s.height >= row.h * 0.6 && s.height < row.h * 4.5 && s.y <= cy && s.y + s.height >= cy);
+      const covered = rects.reduce((a, { s }) => a + s.width, 0);
+      if (!rects.length || covered < tableW * 0.5) return null;
+      const counts2 = /* @__PURE__ */ new Map();
+      for (const { s } of rects) counts2.set(s.fill, (counts2.get(s.fill) ?? 0) + s.width);
+      const fill = [...counts2.entries()].sort((a, b) => b[1] - a[1])[0][0];
+      return { fill, rects };
+    };
+    const filledRows = blockRows.filter((r) => rowFill(r)).length;
+    const hasLattice = verticalRules >= 2 || ruleYs.length >= 3 || filledRows >= 2;
+    if (!best || multiRows < (hasLattice ? 2 : 3) || best.res.bands.length < 2) {
+      if (best) dbg(`reject: ${multiRows} multi rows from "${rows[i].cells[0].run.text.slice(0, 30)}"`);
       i++;
       continue;
     }
-    const bands = best.bands;
-    const cellText = (row, b) => row.cells.filter((c) => c.x0 < bands[b].x1 - 0.2 && c.x1 > bands[b].x0 + 0.2).map((c) => c.run.text.trim()).join(" ").trim();
+    if (gutters.length && !hasLattice) {
+      const b = best.res.bands;
+      const straddles = gutters.some((g) => b.some((band) => band.x1 <= g.x1 + 1 && band.x1 - band.x0 > 30) && b.some((band) => band.x0 >= g.x0 - 1 && band.x1 - band.x0 > 30));
+      if (straddles) {
+        dbg("reject: straddles a column gutter");
+        i++;
+        continue;
+      }
+    }
+    const { bands, assign } = best.res;
+    const ruleBetween = (a, b) => {
+      const y02 = a.y + a.h * 0.5, y1 = b.y + b.h * 0.5;
+      return ruleYs.some((y) => y > y02 && y < y1);
+    };
+    const denseRules = ruleYs.length >= Math.max(2, multiRows * 0.6);
+    for (const row of blockRows) {
+      for (const c of row.cells.slice()) {
+        const b = assign.get(c);
+        if (b == null || b + 1 >= bands.length) continue;
+        if (row.cells.some((o) => o !== c && assign.get(o) === b + 1)) continue;
+        const nextX0 = bands[b + 1].x0;
+        let cut;
+        if (!c.parts) {
+          const w = c.x1 - c.x0;
+          if (c.x1 <= nextX0 + w * 0.3 || !/\s/.test(c.run.text.trim())) continue;
+          const text = c.run.text.trim();
+          const at = Math.round((nextX0 - c.x0) / w * text.length);
+          let best2 = -1;
+          for (let q = 0; q < text.length; q++) if (text[q] === " " && (best2 < 0 || Math.abs(q - at) < Math.abs(best2 - at))) best2 = q;
+          if (best2 <= 0 || best2 >= text.length - 1 || Math.abs(best2 - at) > text.length * 0.25) continue;
+          const perChar = w / text.length;
+          c.parts = [
+            { text: text.slice(0, best2), x0: c.x0, x1: c.x0 + best2 * perChar, idx: [c.idx, ...c.extra ?? []] },
+            { text: text.slice(best2 + 1), x0: c.x0 + (best2 + 1) * perChar, x1: c.x1, idx: [c.idx] }
+          ];
+          cut = 1;
+        } else {
+          cut = c.parts.findIndex((p) => p.x0 >= nextX0 - 0.5);
+        }
+        if (cut <= 0) continue;
+        const head = c.parts.slice(0, cut), tail = c.parts.slice(cut);
+        const tailCell = { run: { ...c.run, text: tail.map((p) => p.text.trim()).join(" ") }, idx: tail[0].idx[0], x0: tail[0].x0, x1: tail[tail.length - 1].x1, parts: tail };
+        tailCell.extra = tail.flatMap((p) => p.idx).filter((k) => k !== tailCell.idx);
+        c.run = { ...c.run, text: head.map((p) => p.text.trim()).join(" ") };
+        c.x1 = head[head.length - 1].x1;
+        c.idx = head[0].idx[0];
+        c.extra = head.flatMap((p) => p.idx).filter((k) => k !== c.idx);
+        c.parts = head.length > 1 ? head : void 0;
+        row.cells.push(tailCell);
+        assign.set(tailCell, b + 1);
+      }
+      row.cells.sort((a, b2) => a.x0 - b2.x0);
+    }
+    const clean = (t) => t.replace(/(?:\s*\.){3,}\s*$/, "").replace(/\s+/g, " ").trim();
+    const cellText = (row, b) => clean(row.cells.filter((c) => assign.get(c) === b).map((c) => c.run.text.trim()).join(" "));
+    const cellIdx = (c) => [c.idx, ...c.extra ?? []];
     const grid = [];
+    const gridRows = [];
     const lineIdx = [];
-    for (const row of blockRows) {
-      if (row.cells.length === 1 && grid.length) {
+    const pitches = [];
+    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 flushPending = () => {
+      if (!pendingLabel) return;
+      const cells = bands.map(() => "");
+      cells[0] = pendingLabel.text;
+      grid.push(cells);
+      gridRows.push(pendingLabel.row);
+      lineIdx.push(...pendingLabel.idx);
+      pendingLabel = null;
+    };
+    for (let r = 0; r < blockRows.length; r++) {
+      const row = blockRows[r];
+      if (row.cells.length === 1 && grid.length + (pendingLabel ? 1 : 0) > 0) {
         const c = row.cells[0];
-        const b = bands.findIndex((bb) => c.x0 < bb.x1 - 0.2 && c.x1 > bb.x0 + 0.2);
+        const b = assign.get(c) ?? bands.findIndex((bb) => overlaps(c, bb));
         if (b > 0) {
+          flushPending();
           grid[grid.length - 1][b] = (grid[grid.length - 1][b] + " " + c.run.text.trim()).trim();
-          lineIdx.push(c.idx, ...c.extra ?? []);
+          lineIdx.push(...cellIdx(c));
+          continue;
+        }
+        const text = clean(c.run.text);
+        const prev = gridRows[gridRows.length - 1];
+        const nextRow = blockRows[r + 1];
+        const nextLabel = nextRow && nextRow.cells.length >= 2 ? cellText(nextRow, 0) : "";
+        const lower = /^[(\[a-zà-ÿ]/.test(text);
+        const attachPrev = !pendingLabel && prev && grid.length && (denseRules ? !ruleBetween(prev, row) : lower);
+        if (attachPrev) {
+          grid[grid.length - 1][0] = (grid[grid.length - 1][0] + " " + text).trim();
+          lineIdx.push(...cellIdx(c));
           continue;
         }
+        const attachNext = nextLabel && (denseRules ? !ruleBetween(row, nextRow) : /^[a-zà-ÿ]/.test(nextLabel) || !/[.:]$/.test(text) && row.cells[0].x0 <= bands[0].x0 + emOf(c) * 0.5 && nextRow.y - row.y <= medPitch * 1.25);
+        if (pendingLabel) {
+          pendingLabel.text = `${pendingLabel.text} ${text}`;
+          pendingLabel.idx.push(...cellIdx(c));
+        } else pendingLabel = { text, idx: cellIdx(c), row };
+        if (!attachNext) flushPending();
+        continue;
+      }
+      const prevRow = gridRows[gridRows.length - 1];
+      if (prevRow && !pendingLabel && row.y - prevRow.y > medPitch * 1.7 && grid.length) {
+        grid.push(bands.map(() => ""));
+        gridRows.push(row);
       }
-      grid.push(bands.map((_, b) => cellText(row, b)));
-      for (const c of row.cells) {
-        lineIdx.push(c.idx);
-        for (const k of c.extra ?? []) lineIdx.push(k);
+      const cells = bands.map((_, b) => cellText(row, b));
+      if (pendingLabel) {
+        cells[0] = `${pendingLabel.text} ${cells[0]}`.trim();
+        lineIdx.push(...pendingLabel.idx);
+        pendingLabel = null;
       }
+      grid.push(cells);
+      gridRows.push(row);
+      for (const c of row.cells) lineIdx.push(...cellIdx(c));
+    }
+    flushPending();
+    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;
+      const last = bands.length - 1;
+      if (prev[last] !== "" || cur2[last] === "") continue;
+      if (prev.slice(1).some((v, k) => v && cur2[k + 1] && numeric(v) && numeric(cur2[k + 1]))) continue;
+      for (let k = 0; k < bands.length; k++) prev[k] = [prev[k], cur2[k]].filter(Boolean).join(" ");
+      grid.splice(r, 1);
+      gridRows.splice(r, 1);
+      r--;
+    }
+    while (grid.length && grid[grid.length - 1].every((c) => !c)) {
+      grid.pop();
+      gridRows.pop();
     }
     if (lineIdx.some((k) => used.has(k))) {
       i = best.j + 1;
       continue;
     }
+    const isNumCol = bands.map((_, k) => {
+      const vals = grid.map((r) => r[k]).filter(Boolean);
+      const n = vals.filter(numeric).length;
+      return n >= 2 && n / vals.length >= 0.6;
+    });
+    const numCols = isNumCol.filter(Boolean).length;
+    const hasLoneLabel = blockRows.some((r) => r.cells.length === 1 && (assign.get(r.cells[0]) ?? -1) === 0);
+    const structural = verticalRules >= 2 || filledRows >= 2 || ruleYs.length >= 3 && numCols > 0;
+    const counts = new Set(blockRows.filter((r) => r.cells.length >= 2).map((r) => r.cells.length));
+    if (!structural && numCols === 0 && (multiRows < 4 || hasLoneLabel || counts.size > 1 || bands.length === 2 && grid.length <= 3)) {
+      dbg("reject text block", grid[0]);
+      i++;
+      continue;
+    }
     const first = blockRows[0];
-    const tableW = bbox.x1 - bbox.x0;
-    const rowFill = (row) => {
-      const cy = row.y + row.h * 0.5;
-      const rects = gridShapes.filter(({ s }) => s.kind === "rect" && s.fill && s.fill.toLowerCase() !== "#ffffff" && s.height >= row.h * 0.6 && s.height < row.h * 4.5 && s.y <= cy && s.y + s.height >= cy);
-      const covered = rects.reduce((a, { s }) => a + s.width, 0);
-      if (!rects.length || covered < tableW * 0.5) return null;
-      const counts = /* @__PURE__ */ new Map();
-      for (const { s } of rects) counts.set(s.fill, (counts.get(s.fill) ?? 0) + s.width);
-      const fill = [...counts.entries()].sort((a, b) => b[1] - a[1])[0][0];
-      return { fill, rects };
-    };
     const headerBg = rowFill(first);
     const firstBold = first.cells.every((c) => c.run.bold);
     const bodyFills = blockRows.slice(1).map(rowFill);
     const headerDistinct = !!headerBg && !bodyFills.every((f) => f?.fill === headerBg.fill);
-    const isHeader = headerDistinct || firstBold && !blockRows.slice(1).every((r) => r.cells.every((c) => c.run.bold));
+    let headerRows = headerDistinct || firstBold && !blockRows.slice(1).every((r) => r.cells.every((c) => c.run.bold)) ? 1 : 0;
+    const rowBold = (r) => r.cells.every((c) => c.run.bold);
+    if (!blockRows.every(rowBold)) {
+      let b = 0;
+      while (b < Math.min(5, gridRows.length - 1) && gridRows[b] && rowBold(gridRows[b]) && grid[b].some(Boolean)) b++;
+      headerRows = Math.max(headerRows, b);
+    }
+    if (denseRules && ruleYs.length) {
+      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);
+      }
+    }
+    if (numCols > 0) {
+      let h = 0;
+      while (h < Math.min(5, grid.length - 2)) {
+        const row = grid[h];
+        const nonEmpty = row.filter(Boolean);
+        if (!nonEmpty.length) break;
+        const numericHere = row.some((v, k) => isNumCol[k] && v && numeric(v));
+        if (numericHere) break;
+        if (!row.some((v, k) => isNumCol[k] && v) && h >= headerRows) break;
+        h++;
+      }
+      headerRows = Math.max(headerRows, h);
+    }
+    if (headerRows > 0 && grid.length - headerRows < 1) headerRows = 0;
     const columns = bands.map((b, k) => {
-      const vals = grid.slice(isHeader ? 1 : 0).map((r) => r[k]).filter(Boolean);
-      const numericShare = vals.length ? vals.filter(numeric).length / vals.length : 0;
       const col = { width: Math.round((b.x1 - b.x0) * 10) / 10 };
-      if (numericShare >= 0.7) col.align = "right";
+      if (isNumCol[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);
-    for (let k = 0; k < bands.length; k++) {
-      const left = k === 0 ? x0 : (bands[k - 1].x1 + bands[k].x0) / 2;
-      const right = k === bands.length - 1 ? x1 : (bands[k].x1 + bands[k + 1].x0) / 2;
-      columns[k].width = Math.round((right - left) * 10) / 10;
-    }
-    const rowFills = (isHeader ? bodyFills : [headerBg, ...bodyFills]).map((f) => f?.fill ?? null);
+    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 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);
-    const altColor = odd.length && odd[0] && odd.every((f) => f === odd[0]) && even.every((f) => f !== odd[0]) ? odd[0] : void 0;
-    const borderShape = gridShapes.find(({ s }) => s.kind === "line" || s.kind === "rect" && (s.height < 0.6 || s.width < 0.6) && (s.fill || s.stroke));
+    const oddAlt = odd.length && odd[0] && odd.every((f) => f === odd[0]) && even.every((f) => f !== odd[0]) ? odd[0] : void 0;
+    const evenAlt = !oddAlt && even.length > 1 && even[0] && even.every((f) => f === even[0]) && odd.every((f) => f !== even[0]) ? even[0] : void 0;
+    const altColor = oddAlt || evenAlt;
+    const borderShape = gridShapes.find(({ s }) => isRule(s));
     const borderColor = borderShape ? borderShape.s.stroke || borderShape.s.fill : void 0;
-    const fontSize = Math.round(first.cells[0].run.fontSize * 10) / 10;
-    const y0 = headerBg ? Math.min(...headerBg.rects.map(({ s }) => s.y)) : first.y - first.h * 0.5;
+    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;
+      sizeChars.set(k, (sizeChars.get(k) ?? 0) + c.run.text.length);
+    }
+    const fontSize = [...sizeChars.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? Math.round(first.cells[0].run.fontSize * 10) / 10;
+    const lineMm = fontSize * PT_TO_MM * 1.2;
+    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 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: isHeader ? grid.slice(1) : grid,
-      style: { fontSize }
+      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` }
     };
-    if (isHeader) {
-      element.headers = grid[0];
+    if (headerRows > 0) {
+      element.headers = bands.map((_, k) => grid.slice(0, headerRows).map((r) => r[k]).filter(Boolean).join(" ").trim());
       const hs = { fontWeight: "bold" };
       if (headerBg) hs.backgroundColor = headerBg.fill;
-      const hc = first.cells[0].run.color;
-      if (hc && hc !== "#000000") hs.color = hc;
+      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];
+        if (hc && hc !== "#000000") hs.color = hc;
+      }
       element.headerStyle = hs;
     }
-    if (altColor) element.alternatingRowColor = altColor;
-    element.borders = borderColor ? { outer: true, inner: true, color: borderColor, width: 1 } : false;
+    if (oddAlt) element.alternatingRowColor = oddAlt;
+    if (evenAlt) {
+      element.rowStyle = { backgroundColor: evenAlt };
+      element.alternateRowStyle = { backgroundColor: "#ffffff" };
+    }
+    element.borders = hasGrid && borderColor ? { outer: true, inner: true, color: borderColor, width: 1 } : false;
+    const fillRects = /* @__PURE__ */ new Set();
+    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);
+    }
+    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);
+    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: gridShapes.map(({ k }) => k) });
+    out.push({ element, lineIdx, shapeIdx: consumedShapes });
     i = best.j + 1;
   }
   return out;
 }
 
-// ../../packages/jdf-pdf-import/src/core.ts
+// ../../packages/jdf-pdf-import/src/columns.ts
+function detectGutters(lines, bodyFontSize, pageWmm) {
+  const body = lines.filter((l) => l.text.trim().length > 0 && Math.abs(l.fontSize - bodyFontSize) <= 1.5 && l.width < pageWmm * 0.6 && l.width > 0);
+  if (body.length < 12) return [];
+  const minX = Math.min(...body.map((l) => l.x));
+  const maxX = Math.max(...body.map((l) => l.x + l.width));
+  const span = maxX - minX;
+  if (span < pageWmm * 0.4) return [];
+  const BIN = 0.5;
+  const n = Math.ceil(span / BIN) + 1;
+  const cov = new Array(n).fill(0);
+  for (const l of body) {
+    const a = Math.max(0, Math.floor((l.x - minX) / BIN)), b = Math.min(n, Math.ceil((l.x + l.width - minX) / BIN));
+    for (let i2 = a; i2 < b; i2++) cov[i2]++;
+  }
+  const noise = Math.max(2, Math.round(body.length * 0.05));
+  const gutters = [];
+  let i = 0;
+  while (i < n) {
+    if (cov[i] > noise) {
+      i++;
+      continue;
+    }
+    let j = i;
+    while (j < n && cov[j] <= noise) j++;
+    const g0 = minX + i * BIN, g1 = minX + j * BIN;
+    if (g1 - g0 >= 3 && g0 > minX + span * 0.15 && g1 < maxX - span * 0.15) gutters.push({ x0: g0, x1: g1 });
+    i = j;
+  }
+  const solid = gutters.every((g) => body.filter((l) => l.x + l.width <= g.x0 + 0.5).length >= 4 && body.filter((l) => l.x >= g.x1 - 0.5).length >= 4);
+  return solid ? gutters : [];
+}
+function orderByColumns(els, gutters, pageWmm) {
+  if (!gutters.length || els.length < 2) return els;
+  const bands = [];
+  let left = 0;
+  for (const g of gutters) {
+    bands.push({ x0: left, x1: g.x0 });
+    left = g.x1;
+  }
+  bands.push({ x0: left, x1: pageWmm });
+  const colOf = (e) => {
+    const x = e.position?.x ?? 0;
+    const k = bands.findIndex((b) => x >= b.x0 && x < b.x1);
+    if (k >= 0) return k;
+    let best = 0, d = Infinity;
+    bands.forEach((b, i) => {
+      const dd = Math.min(Math.abs(x - b.x0), Math.abs(x - b.x1));
+      if (dd < d) {
+        d = dd;
+        best = i;
+      }
+    });
+    return best;
+  };
+  const spans = (e) => {
+    const c = colOf(e);
+    if (c >= bands.length - 1) return false;
+    const right = (e.position?.x ?? 0) + (e.width ?? 0);
+    const next = bands[c + 1];
+    return right > (next.x0 + next.x1) / 2;
+  };
+  const sorted = els.slice().sort((a, b) => (a.position?.y ?? 0) - (b.position?.y ?? 0) || (a.position?.x ?? 0) - (b.position?.x ?? 0));
+  const out = [];
+  let band = [];
+  const flush = () => {
+    for (let c = 0; c < bands.length; c++) for (const e of band) if (colOf(e) === c) out.push(e);
+    band = [];
+  };
+  for (const e of sorted) {
+    if (spans(e)) {
+      flush();
+      out.push(e);
+    } else band.push(e);
+  }
+  flush();
+  return out;
+}
+
+// ../../packages/jdf-pdf-import/src/paragraphs.ts
 var PT_TO_MM2 = 0.352778;
+var LIST_START = /^\s*(?:[•◦▪●■\-–—*]\s|\(?\d{1,3}[.)]\s|\(?[a-zA-Z][.)]\s|[ivx]{1,4}[.)]\s)/;
+var TERMINAL = /[.!?:;]["'”’)\]]*$/;
+function textOf(e) {
+  if (e.type === "text") return String(e.content ?? "");
+  return (e.runs ?? []).map((r) => String(r.text ?? "")).join("");
+}
+function foldParagraphs(elements, meta, pageWmm) {
+  const foldable = (e) => !!meta.get(e) && !!e.position && (e.type === "text" && !e.heading || e.type === "richtext");
+  const out = [];
+  let i = 0;
+  while (i < elements.length) {
+    const first = elements[i];
+    if (!foldable(first)) {
+      out.push(first);
+      i++;
+      continue;
+    }
+    const para = [first];
+    let j = i + 1;
+    while (j < elements.length) {
+      const prev = para[para.length - 1], next = elements[j];
+      if (!foldable(next) || !continues(para, prev, next, meta)) break;
+      para.push(next);
+      j++;
+    }
+    out.push(para.length > 1 ? merge(para, meta, pageWmm) : first);
+    i = j;
+  }
+  return out;
+}
+function continues(para, prev, next, meta) {
+  const mp = meta.get(prev), mn = meta.get(next); meta.get(para[0]);
+  if (mp.face !== mn.face || Math.abs(mp.size - mn.size) >= 0.5) return false;
+  const lineH = mp.size * PT_TO_MM2;
+  const pitch = next.position.y - prev.position.y;
+  if (pitch < lineH * 0.9 || pitch > lineH * 1.75) return false;
+  const dx = next.position.x - (para.length === 1 ? prev.position.x : para[0].position.x);
+  if (para.length === 1 ? Math.abs(dx) > 6 : Math.abs(dx) > 1.2) return false;
+  if (para.length >= 2 && Math.abs(next.position.x - para[1].position.x) > 1.2) return false;
+  const nText = textOf(next), pText = textOf(prev).trimEnd();
+  if (LIST_START.test(nText) || !nText.trim()) return false;
+  const maxW = Math.max(mp.w, mn.w, ...para.map((e) => meta.get(e).w));
+  const full = mp.w >= maxW * 0.85;
+  const endsHyphen = /[-‐‑]$/.test(pText);
+  const softEnd = !TERMINAL.test(pText);
+  const startsLower = /^[a-z(\[]/.test(nText.trimStart());
+  return full || endsHyphen || softEnd && (startsLower || mp.w >= maxW * 0.6);
+}
+function merge(para, meta, pageWmm) {
+  const first = para[0], last = para[para.length - 1];
+  const m0 = meta.get(first);
+  const lineH = m0.size * PT_TO_MM2;
+  const x = Math.min(...para.map((e) => e.position.x));
+  const indent = first.position.x - x;
+  const right = Math.max(...para.map((e) => e.position.x + meta.get(e).w));
+  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 allText = para.every((e) => e.type === "text" && !e.link);
+  const base = { position: { x, y: first.position.y }, width: Math.round(width * 100) / 100, style };
+  if (allText) {
+    const content = para.map((e) => String(e.content ?? "").trim().replace(/[ \t]+/g, " ")).join(joiner());
+    const { height: _hh2, ...firstRest } = first;
+    return { ...firstRest, ...base, content };
+  }
+  const runs = [];
+  for (const e of para) {
+    const lineRuns = e.type === "text" ? [{ text: String(e.content ?? "").trim(), ...e.style?.fontWeight === "bold" ? { bold: true } : {}, ...e.style?.fontStyle === "italic" ? { italic: true } : {}, ...e.style?.color && e.style.color !== "#000000" ? { color: e.style.color } : {}, ...e.link ? { link: e.link } : {} }] : (e.runs ?? []).map((r) => ({ ...r }));
+    if (runs.length) runs[runs.length - 1].text = `${String(runs[runs.length - 1].text).trimEnd()}${joiner()}`;
+    runs.push(...lineRuns);
+  }
+  const { content: _c, heading: _h, link: _l, height: _hh, ...rest } = first;
+  return { ...rest, ...base, type: "richtext", runs, style: { fontSize: style.fontSize, fontFamily: style.fontFamily, lineHeight: style.lineHeight, ...style.textIndent ? { textIndent: style.textIndent } : {}, ...style.opacity != null ? { opacity: style.opacity } : {} } };
+}
+
+// ../../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);
@@ -875,6 +1362,47 @@ function rgbToHex(r, g, b) {
   const h = (n) => clampByte(n).toString(16).padStart(2, "0");
   return `#${h(r)}${h(g)}${h(b)}`;
 }
+function mergeCollinearShapes(shapes) {
+  const chain = (input, horizontal) => {
+    const groups = /* @__PURE__ */ new Map();
+    input.forEach((s, k) => {
+      if (s.kind !== "rect" || s.stroke || s.path || !s.fill) return;
+      if (horizontal ? s.height > 1 : s.width > 1) return;
+      const key = horizontal ? `${s.fill}|${s.opacity ?? 1}|${s.y.toFixed(1)}|${s.height.toFixed(1)}` : `${s.fill}|${s.opacity ?? 1}|${s.x.toFixed(1)}|${s.width.toFixed(1)}`;
+      const g = groups.get(key);
+      if (g) g.push({ s, k });
+      else groups.set(key, [{ s, k }]);
+    });
+    const replaceAt = /* @__PURE__ */ new Map();
+    const drop = /* @__PURE__ */ new Set();
+    for (const g of groups.values()) {
+      if (g.length < 2) continue;
+      g.sort((a, b) => horizontal ? a.s.x - b.s.x : a.s.y - b.s.y);
+      let run = [g[0]];
+      const flush = () => {
+        if (run.length >= 2) {
+          const first = run[0].s;
+          const end = Math.max(...run.map(({ s }) => horizontal ? s.x + s.width : s.y + s.height));
+          replaceAt.set(run[0].k, horizontal ? { ...first, width: end - first.x } : { ...first, height: end - first.y });
+          for (let q = 1; q < run.length; q++) drop.add(run[q].k);
+        }
+      };
+      for (let q = 1; q < g.length; q++) {
+        const prev = run[run.length - 1].s, cur = g[q].s;
+        const gap = horizontal ? cur.x - (prev.x + prev.width) : cur.y - (prev.y + prev.height);
+        if (gap <= 0.15) run.push(g[q]);
+        else {
+          flush();
+          run = [g[q]];
+        }
+      }
+      flush();
+    }
+    if (!replaceAt.size) return input;
+    return input.map((s, k) => replaceAt.get(k) ?? s).filter((_, k) => !drop.has(k));
+  };
+  return chain(chain(shapes, true), false);
+}
 function averageStops(stops) {
   if (!Array.isArray(stops) || stops.length === 0) return null;
   let r = 0, g = 0, b = 0, n = 0;
@@ -959,10 +1487,10 @@ async function walkOps(page, OPS, viewport) {
     const minY = Math.min(...ys), maxY = Math.max(...ys);
     imagePositions.push({
       name,
-      x: minX * PT_TO_MM2,
-      y: minY * PT_TO_MM2,
-      w: (maxX - minX) * PT_TO_MM2,
-      h: (maxY - minY) * PT_TO_MM2,
+      x: minX * PT_TO_MM3,
+      y: minY * PT_TO_MM3,
+      w: (maxX - minX) * PT_TO_MM3,
+      h: (maxY - minY) * PT_TO_MM3,
       inline,
       maskFill
     });
@@ -978,13 +1506,13 @@ async function walkOps(page, OPS, viewport) {
       const br = toViewport(r.x + r.w, r.y);
       shapes.push({
         kind: "rect",
-        x: Math.min(tl.x, br.x) * PT_TO_MM2,
-        y: Math.min(tl.y, br.y) * PT_TO_MM2,
-        width: Math.abs(br.x - tl.x) * PT_TO_MM2,
-        height: Math.abs(br.y - tl.y) * PT_TO_MM2,
+        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,
         stroke: isStroke ? gs.stroke : void 0,
-        strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM2 : void 0,
+        strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM3 : void 0,
         opacity: isFill ? gs.fillAlpha : gs.strokeAlpha
       });
     }
@@ -998,13 +1526,13 @@ async function walkOps(page, OPS, viewport) {
       const h = Math.abs(br.y - tl.y);
       shapes.push({
         kind: "rect",
-        x: x * PT_TO_MM2,
-        y: y * PT_TO_MM2,
-        width: w * PT_TO_MM2,
-        height: h * PT_TO_MM2,
+        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,
         stroke: isStroke ? gs.stroke : void 0,
-        strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM2 : void 0,
+        strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM3 : void 0,
         opacity: isFill ? gs.fillAlpha : gs.strokeAlpha
       });
     } else if (pathSegments.length === 2 && pathSegments[0].type === "M" && pathSegments[1].type === "L") {
@@ -1016,35 +1544,35 @@ async function walkOps(page, OPS, viewport) {
       const minY = Math.min(va.y, vb.y);
       const maxX = Math.max(va.x, vb.x);
       const maxY = Math.max(va.y, vb.y);
-      const x1Local = (va.x - minX) * PT_TO_MM2;
-      const y1Local = (va.y - minY) * PT_TO_MM2;
-      const x2Local = (vb.x - minX) * PT_TO_MM2;
-      const y2Local = (vb.y - minY) * PT_TO_MM2;
-      const wLocal = Math.max(0.05, (maxX - minX) * PT_TO_MM2);
-      const hLocal = Math.max(0.05, (maxY - minY) * PT_TO_MM2);
+      const x1Local = (va.x - minX) * PT_TO_MM3;
+      const y1Local = (va.y - minY) * PT_TO_MM3;
+      const x2Local = (vb.x - minX) * PT_TO_MM3;
+      const y2Local = (vb.y - minY) * PT_TO_MM3;
+      const wLocal = Math.max(0.05, (maxX - minX) * PT_TO_MM3);
+      const hLocal = Math.max(0.05, (maxY - minY) * PT_TO_MM3);
       const dx = Math.abs(va.x - vb.x);
       const dy = Math.abs(va.y - vb.y);
       const axisAligned = dx < 0.5 || dy < 0.5;
       if (axisAligned) {
         shapes.push({
           kind: "line",
-          x: minX * PT_TO_MM2,
-          y: minY * PT_TO_MM2,
+          x: minX * PT_TO_MM3,
+          y: minY * PT_TO_MM3,
           width: wLocal,
           height: hLocal,
           stroke: isStroke ? gs.stroke : void 0,
-          strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM2 : void 0,
+          strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM3 : void 0,
           opacity: gs.strokeAlpha
         });
       } else {
         shapes.push({
           kind: "path",
-          x: minX * PT_TO_MM2,
-          y: minY * PT_TO_MM2,
+          x: minX * PT_TO_MM3,
+          y: minY * PT_TO_MM3,
           width: wLocal,
           height: hLocal,
           stroke: isStroke ? gs.stroke : void 0,
-          strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM2 : void 0,
+          strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM3 : void 0,
           opacity: gs.strokeAlpha,
           path: `M ${x1Local.toFixed(2)} ${y1Local.toFixed(2)} L ${x2Local.toFixed(2)} ${y2Local.toFixed(2)}`
         });
@@ -1077,20 +1605,20 @@ async function walkOps(page, OPS, viewport) {
           if (seg.type === "Z") return "Z";
           const p = [];
           for (let i = 0; i < seg.pts.length; i += 2) {
-            p.push(((seg.pts[i] - minX) * PT_TO_MM2).toFixed(2));
-            p.push(((seg.pts[i + 1] - minY) * PT_TO_MM2).toFixed(2));
+            p.push(((seg.pts[i] - minX) * PT_TO_MM3).toFixed(2));
+            p.push(((seg.pts[i + 1] - minY) * PT_TO_MM3).toFixed(2));
           }
           return `${seg.type} ${p.join(" ")}`;
         }).join(" ");
         shapes.push({
           kind: "path",
-          x: minX * PT_TO_MM2,
-          y: minY * PT_TO_MM2,
-          width: bw * PT_TO_MM2,
-          height: bh * PT_TO_MM2,
+          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,
           stroke: isStroke ? gs.stroke : void 0,
-          strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM2 : void 0,
+          strokeWidth: isStroke ? gs.lineWidth * PT_TO_MM3 : void 0,
           opacity: isFill ? gs.fillAlpha : gs.strokeAlpha,
           path: d
         });
@@ -1431,10 +1959,10 @@ async function extractLinks(doc, page, viewport) {
     const xMax = Math.max(c1.x, c2.x);
     const yMax = Math.max(c1.y, c2.y);
     const rectMm = {
-      x: xMin * PT_TO_MM2,
-      y: yMin * PT_TO_MM2,
-      w: (xMax - xMin) * PT_TO_MM2,
-      h: (yMax - yMin) * PT_TO_MM2
+      x: xMin * PT_TO_MM3,
+      y: yMin * PT_TO_MM3,
+      w: (xMax - xMin) * PT_TO_MM3,
+      h: (yMax - yMin) * PT_TO_MM3
     };
     const url = a.url || a.unsafeUrl;
     const destPage = url ? void 0 : await resolveDestPage(doc, a.dest);
@@ -1472,10 +2000,10 @@ async function extractFormWidgets(page, viewport) {
     })).filter((o) => o.value !== "") : [];
     out.push({
       rectMm: {
-        x: xMin * PT_TO_MM2,
-        y: yMin * PT_TO_MM2,
-        w: (xMax - xMin) * PT_TO_MM2,
-        h: (yMax - yMin) * PT_TO_MM2
+        x: xMin * PT_TO_MM3,
+        y: yMin * PT_TO_MM3,
+        w: (xMax - xMin) * PT_TO_MM3,
+        h: (yMax - yMin) * PT_TO_MM3
       },
       fieldType: a.fieldType || "",
       fieldName: a.fieldName || `field-${out.length + 1}`,
@@ -1764,12 +2292,12 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       const w = safeNum(it.width, 0);
       runs.push({
         text: it.str,
-        x: safeNum(vx * PT_TO_MM2, 0),
-        y: safeNum(yTop * PT_TO_MM2, 0),
+        x: safeNum(vx * PT_TO_MM3, 0),
+        y: safeNum(yTop * PT_TO_MM3, 0),
         fontSize: safeNum(fontSize, 10),
         fontName: it.fontName,
-        width: safeNum(w * PT_TO_MM2, 0),
-        height: safeNum((it.height || fontSize) * PT_TO_MM2, fontSize * PT_TO_MM2),
+        width: safeNum(w * PT_TO_MM3, 0),
+        height: safeNum((it.height || fontSize) * PT_TO_MM3, fontSize * PT_TO_MM3),
         color: op?.fill || "#000000",
         opacity: invisible ? 0 : safeNum(op?.alpha, 1)
       });
@@ -1783,8 +2311,20 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       const c = fontMap.get(name) || classifyFont(name || "");
       return `${c.family}|${c.weight || ""}|${c.style || ""}`;
     };
+    const extent = (t) => {
+      if (!/\s$/.test(t.text)) return t.width;
+      const em = t.fontSize * PT_TO_MM3;
+      const est = Math.max(1, t.text.trim().length) * em * kGlyph + em * 0.25;
+      if (stretchedSpaces) return Math.min(t.width, est);
+      return t.width > est * 1.4 ? est : t.width;
+    };
+    const spaceItems = runs.filter((r) => !r.text.trim() && r.text.length && r.width >= r.fontSize * PT_TO_MM3 * 0.5);
+    const wideSpaces = spaceItems.filter((r) => r.width >= r.fontSize * PT_TO_MM3 * 2).length;
+    const tabular = spaceItems.length >= 8 && wideSpaces / spaceItems.length >= 0.25;
+    const gapEm = tabular ? 1 : 2;
     for (const r of runs) {
       if (!r.text.length) continue;
+      if (!r.text.trim() && r.width > r.fontSize * PT_TO_MM3 * gapEm) continue;
       const last = lines[lines.length - 1];
       if (!last) {
         lines.push({ ...r });
@@ -1792,16 +2332,10 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       }
       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 emMm = r.fontSize * PT_TO_MM2;
-      const extent = (t) => {
-        if (!/\s$/.test(t.text)) return t.width;
-        const em = t.fontSize * PT_TO_MM2;
-        const est = Math.max(1, t.text.trim().length) * em * kGlyph + em * 0.25;
-        if (stretchedSpaces) return Math.min(t.width, est);
-        return t.width > est * 1.4 ? est : t.width;
-      };
+      const emMm = r.fontSize * PT_TO_MM3;
       const gapMm = r.x - (last.x + extent(last));
-      const mergeOk = sameLine && sameStyle && gapMm >= -emMm * 0.5 && gapMm <= emMm * 0.45;
+      const symAfterNumber = /^[$€£¥]$/.test(r.text.trim()) && /[\d)]\s*$/.test(last.text);
+      const mergeOk = sameLine && sameStyle && !symAfterNumber && gapMm >= -emMm * 0.5 && gapMm <= emMm * 0.45;
       if (mergeOk) {
         const lastEndsSpace = /\s$/.test(last.text);
         const currStartsSpace = /^\s/.test(r.text);
@@ -1813,12 +2347,36 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         lines.push({ ...r });
       }
     }
+    {
+      const keep = [];
+      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;
+        if (dup) {
+          dup.bold = true;
+          continue;
+        }
+        keep.push(l);
+      }
+      lines.length = 0;
+      lines.push(...keep);
+    }
     const elements = [];
+    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: l.width, height: l.height, fontSize: l.fontSize, fontName: l.fontName, color: l.color, bold: cls.weight === "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 };
     });
-    const detected = options.detectTables === false ? [] : detectTables(tRuns, ops.shapes, pageW * PT_TO_MM2);
+    const sizeChars = /* @__PURE__ */ new Map();
+    for (const l of lines) {
+      const k = Math.round(l.fontSize * 2) / 2;
+      sizeChars.set(k, (sizeChars.get(k) ?? 0) + l.text.length);
+    }
+    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 consumedLines = /* @__PURE__ */ new Set();
     const consumedShapes = /* @__PURE__ */ new Set();
     const tableAtLine = /* @__PURE__ */ new Map();
@@ -1827,8 +2385,8 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       for (const k of t.shapeIdx) consumedShapes.add(k);
       tableAtLine.set(Math.min(...t.lineIdx), t.element);
     }
-    const pageWmm = pageW * PT_TO_MM2, pageHmm = pageH * PT_TO_MM2;
-    ops.shapes.forEach((sh, shapeIdx) => {
+    const pageWmm = pageW * PT_TO_MM3, pageHmm = pageH * PT_TO_MM3;
+    pageShapes.forEach((sh, shapeIdx) => {
       if (consumedShapes.has(shapeIdx)) return;
       if (sh.width < 0.3 && sh.height < 0.3) return;
       if (sh.x + sh.width <= 0 || sh.y + sh.height <= 0 || sh.x >= pageWmm || sh.y >= pageHmm) return;
@@ -1871,12 +2429,6 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         fit: "fill"
       });
     }
-    const sizeChars = /* @__PURE__ */ new Map();
-    for (const l of lines) {
-      const k = Math.round(l.fontSize * 2) / 2;
-      sizeChars.set(k, (sizeChars.get(k) ?? 0) + l.text.length);
-    }
-    const bodyFontSize = [...sizeChars.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? 0;
     const rowOf = /* @__PURE__ */ new Map();
     const rowStartOf = /* @__PURE__ */ new Map();
     const nextOnRow = /* @__PURE__ */ new Map();
@@ -1884,10 +2436,10 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       const order = lines.map((_, i) => i).filter((i) => !consumedLines.has(i));
       for (let a = 0; a < order.length; a++) {
         const i = order[a], li = lines[i];
-        const tolY = Math.max(0.6, li.fontSize * PT_TO_MM2 * 0.35);
         let bestNext = -1, bestX = Infinity;
         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 (lj.x < bestX) {
             bestX = lj.x;
@@ -1904,8 +2456,8 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         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_MM2;
-          const gap = lj.x - (lc.x + lc.width);
+          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;
           row.push(j);
           seen.add(j);
@@ -1917,7 +2469,7 @@ 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", italic: cls.style === "italic" };
+      return { cls, bold: cls.weight === "bold" || !!l.bold, italic: cls.style === "italic" };
     };
     lines.forEach((l, lineIdx) => {
       const tableEl = tableAtLine.get(lineIdx);
@@ -1928,10 +2480,10 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
       if (row.length > 1) {
         const first = lines[row[0]], last = lines[row[row.length - 1]];
         const base = runStyle(first);
-        const rowEnd = last.x + last.width;
-        const measuredW = Math.max((rowEnd - first.x) * 1.2 + first.fontSize * PT_TO_MM2 * 0.4, first.fontSize * PT_TO_MM2);
+        const rowEnd = last.x + extent(last);
+        const measuredW = Math.max((rowEnd - first.x) * 1.2 + first.fontSize * PT_TO_MM3 * 0.4, first.fontSize * PT_TO_MM3);
         const nextIdx2 = nextOnRow.get(row[row.length - 1]);
-        const cap2 = nextIdx2 != null ? lines[nextIdx2].x - first.x - first.fontSize * PT_TO_MM2 * 0.3 : pageWmm - first.x;
+        const cap2 = nextIdx2 != null ? lines[nextIdx2].x - first.x - first.fontSize * PT_TO_MM3 * 0.3 : pageWmm - first.x;
         const runs2 = [];
         row.forEach((idx, k) => {
           const r = lines[idx];
@@ -1939,8 +2491,8 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
           let text2 = r.text;
           if (k > 0) {
             const prev2 = lines[row[k - 1]];
-            const gap = r.x - (prev2.x + prev2.width);
-            if (gap > r.fontSize * PT_TO_MM2 * 0.08 && !/\s$/.test(prev2.text) && !/^\s/.test(text2)) text2 = " " + text2;
+            const gap = r.x - (prev2.x + extent(prev2));
+            if (gap > r.fontSize * PT_TO_MM3 * 0.08 && !/\s$/.test(prev2.text) && !/^\s/.test(text2)) text2 = " " + text2;
           }
           const run = { text: text2 };
           if (st.bold) run.bold = true;
@@ -1954,13 +2506,16 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         });
         const style2 = { fontSize: Math.round(first.fontSize * 10) / 10, fontFamily: base.cls.family };
         if (first.opacity < 0.999) style2.opacity = Math.round(first.opacity * 100) / 100;
-        elements.push({
+        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_MM2, Math.min(measuredW, cap2)) * 100) / 100),
+          width: Math.max(2, Math.round(Math.max(first.fontSize * PT_TO_MM3, Math.min(measuredW, cap2)) * 100) / 100),
           style: style2
-        });
+        };
+        const dominant = row.map((i) => lines[i]).sort((a, b) => b.text.trim().length - a.text.trim().length)[0];
+        lineMeta.set(rt, { w: Math.max(first.fontSize * PT_TO_MM3, rowEnd - first.x), size: dominant.fontSize, face: fontKey(dominant.fontName) });
+        elements.push(rt);
         return;
       }
       const cls = fontMap.get(l.fontName) || classifyFont(l.fontName || "");
@@ -1968,15 +2523,15 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         fontSize: Math.round(l.fontSize * 10) / 10,
         fontFamily: cls.family
       };
-      if (cls.weight === "bold") style.fontWeight = "bold";
+      if (cls.weight === "bold" || l.bold) style.fontWeight = "bold";
       if (cls.style === "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);
-      const measured = Math.max(l.width * 1.2 + l.fontSize * PT_TO_MM2 * 0.4, l.fontSize * PT_TO_MM2);
+      const measured = Math.max(extent(l) * 1.2 + l.fontSize * PT_TO_MM3 * 0.4, l.fontSize * PT_TO_MM3);
       const remaining = Math.max(measured, pageWmm - l.x);
       const nextIdx = nextOnRow.get(lineIdx);
-      const cap = nextIdx != null ? Math.max(l.fontSize * PT_TO_MM2, lines[nextIdx].x - l.x - l.fontSize * PT_TO_MM2 * 0.3) : Infinity;
+      const cap = nextIdx != null ? Math.max(l.fontSize * PT_TO_MM3, lines[nextIdx].x - l.x - l.fontSize * PT_TO_MM3 * 0.3) : Infinity;
       const elWidth = Math.min(measured, remaining, cap);
       const text = {
         type: "text",
@@ -1985,7 +2540,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         width: Math.max(2, Math.round(elWidth * 100) / 100),
         style
       };
-      if (cls.weight === "bold" && l.text.trim().length <= 120 && !consumedLines.has(lineIdx)) {
+      if ((cls.weight === "bold" || l.bold) && l.text.trim().length <= 120 && !consumedLines.has(lineIdx)) {
         const ratio = bodyFontSize > 0 ? l.fontSize / bodyFontSize : 1;
         if (l.fontSize >= 22 || ratio >= 1.8) text.heading = 1;
         else if (l.fontSize >= 17 || ratio >= 1.35) text.heading = 2;
@@ -1997,14 +2552,26 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         else if (link.destPage != null) text.link = { type: "internal", target: `#page-${link.destPage + 1}` };
       }
       const prev = elements[elements.length - 1];
-      if (text.heading && prev && prev.type === "text" && prev.heading === text.heading && !link && !prev.link && Math.abs(prev.style?.fontSize - style.fontSize) < 0.5 && Math.abs(prev.position.x - text.position.x) < 1 && text.position.y - prev.position.y < l.fontSize * PT_TO_MM2 * 2.2 && text.position.y > prev.position.y) {
+      if (text.heading && prev && prev.type === "text" && prev.heading === text.heading && !link && !prev.link && Math.abs(prev.style?.fontSize - style.fontSize) < 0.5 && Math.abs(prev.position.x - text.position.x) < 1 && text.position.y - prev.position.y < l.fontSize * PT_TO_MM3 * 2.2 && text.position.y > prev.position.y) {
         prev.content = `${prev.content} ${text.content}`.replace(/\s+/g, " ");
         prev.tocEntry = prev.content;
         prev.width = Math.max(prev.width ?? 0, text.width ?? 0);
         return;
       }
+      lineMeta.set(text, { w: Math.max(l.fontSize * PT_TO_MM3, extent(l)), size: l.fontSize, face: fontKey(l.fontName) });
       elements.push(text);
     });
+    if (options.readingOrder !== false) {
+      if (gutters.length) {
+        const isFlow = (e) => e.type === "text" || e.type === "richtext" || e.type === "table";
+        const flow = elements.filter(isFlow), rest = elements.filter((e) => !isFlow(e));
+        elements.splice(0, elements.length, ...rest, ...orderByColumns(flow, gutters, pageWmm));
+      }
+    }
+    if (options.foldParagraphs !== false) {
+      const folded = foldParagraphs(elements, lineMeta, pageWmm);
+      elements.splice(0, elements.length, ...folded);
+    }
     for (const w of formWidgets) {
       if (w.pushButton) continue;
       const baseEl = {
@@ -2039,7 +2606,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
     }
     pages.push({
       id: `page-${pi}`,
-      pageSize: { width: Math.round(pageW * PT_TO_MM2 * 100) / 100, height: Math.round(pageH * PT_TO_MM2 * 100) / 100 },
+      pageSize: { width: Math.round(pageW * PT_TO_MM3 * 100) / 100, height: Math.round(pageH * PT_TO_MM3 * 100) / 100 },
       margins: { top: 0, right: 0, bottom: 0, left: 0 },
       elements
     });
@@ -2599,10 +3166,11 @@ function serializeElement(el) {
         (row) => row.map((c, i) => {
           const h = headers[i];
           const v = cell(c).trim();
+          if (!v) return "";
           return h ? `${h}: ${v}` : v;
         }).filter((s) => s !== "").join(" | ")
       );
-      return lines.join("\n");
+      return lines.filter((l) => l !== "").join("\n");
     }
     case "collapsible": {
       const title = String(e.title ?? "").trim();

package/dist/jdf-schema.json

@@ -103,6 +103,7 @@
         "backgroundColor": { "type": "string" },
         "textAlign": { "type": "string", "enum": ["left","center","right","justify"] },
         "lineHeight": { "type": "number" },
+        "textIndent": { "type": "number", "description": "First-line indent in the document unit." },
         "letterSpacing": { "oneOf": [{ "type": "number" }, { "type": "string" }] },
         "padding": { "oneOf": [{ "type": "number" }, { "type": "string" }, { "$ref": "#/definitions/Margins" }] },
         "margin": { "oneOf": [{ "type": "number" }, { "type": "string" }, { "$ref": "#/definitions/Margins" }] },

package/package.json

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