@uurtech/jdf-cli 0.2.3 → 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,180 +685,494 @@ 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);
     }
   }
-  return bands.map(({ x0, x1 }) => ({ x0, 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++;
+  }
+  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(/[%)]$/, ""));
+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;
     }
     if (gutters.length && !hasLattice) {
-      const b = best.bands;
-      const straddles = b.some((band, k) => k < b.length - 1 && gutters.some((g) => band.x1 <= g.x1 + 1 && b[k + 1].x0 >= g.x0 - 1) && band.x1 - band.x0 > 30 && b[k + 1].x1 - b[k + 1].x0 > 30);
+      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 = 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();
+    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;
@@ -1040,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;
@@ -1948,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 });
@@ -1958,15 +2333,9 @@ 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_MM3;
-      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 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);
@@ -1978,11 +2347,26 @@ 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 sizeChars = /* @__PURE__ */ new Map();
     for (const l of lines) {
@@ -1991,7 +2375,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 detected = options.detectTables === false ? [] : detectTables(tRuns, ops.shapes, pageW * PT_TO_MM3, gutters);
+    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();
@@ -2001,7 +2386,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;
-    ops.shapes.forEach((sh, shapeIdx) => {
+    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;
@@ -2072,7 +2457,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         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 + lc.width);
+          const gap = lj.x - (lc.x + extent(lc));
           if (gap < -em * 0.3 || gap > em * 0.6) break;
           row.push(j);
           seen.add(j);
@@ -2084,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);
@@ -2095,7 +2480,7 @@ 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 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_MM3 * 0.3 : pageWmm - first.x;
@@ -2106,7 +2491,7 @@ 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);
+            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 };
@@ -2138,12 +2523,12 @@ 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_MM3 * 0.4, l.fontSize * PT_TO_MM3);
+      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_MM3, lines[nextIdx].x - l.x - l.fontSize * PT_TO_MM3 * 0.3) : Infinity;
@@ -2155,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;
@@ -2173,7 +2558,7 @@ async function importPdfToJdf(source, title, runtime, options = {}) {
         prev.width = Math.max(prev.width ?? 0, text.width ?? 0);
         return;
       }
-      lineMeta.set(text, { w: Math.max(l.fontSize * PT_TO_MM3, l.width), size: l.fontSize, face: fontKey(l.fontName) });
+      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) {
@@ -2781,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/package.json

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