kordoc 3.8.2 → 3.8.3

package/dist/{parser-NR2TYGO3.js → parser-TM3AS25T.js}

@@ -6,7 +6,7 @@ import {
   blocksToMarkdown,
   safeMax,
   safeMin
-} from "./chunk-553VTUVP.js";
+} from "./chunk-7J73IGMK.js";
 import {
   parsePageRange
 } from "./chunk-GE43BE46.js";
@@ -1262,7 +1262,106 @@ function detectClusterTables(items, pageNum) {
       }
     }
   }
-  return results;
+  return results.filter((r) => !isTwoColumnProse(r));
+}
+function isTwoColumnProse(r) {
+  const t = r.table;
+  if (t.rows < 8) return false;
+  const dense = [];
+  for (let c = 0; c < t.cols; c++) {
+    const filled = t.cells.filter((row) => row[c]?.text.trim()).length;
+    if (filled / t.rows >= 0.3) dense.push(c);
+  }
+  if (dense.length !== 2) return false;
+  for (const c of dense) {
+    const lens = t.cells.map((row) => row[c]?.text.replace(/\s+/g, "").length ?? 0).filter((n) => n > 0);
+    const avg = lens.reduce((s, v) => s + v, 0) / (lens.length || 1);
+    if (avg < 12) return false;
+  }
+  return findTwoColumnProseCutX([...r.usedItems]) !== null;
+}
+function findTwoColumnProseCutX(items) {
+  const lines = groupByBaseline(items);
+  if (lines.length < 8) return null;
+  let minX = Infinity;
+  let maxX = -Infinity;
+  for (const i of items) {
+    if (i.x < minX) minX = i.x;
+    if (i.x + i.w > maxX) maxX = i.x + i.w;
+  }
+  if (!Number.isFinite(maxX - minX)) return null;
+  if (maxX - minX < 100) return null;
+  const lo = minX + (maxX - minX) * 0.3;
+  const hi = minX + (maxX - minX) * 0.7;
+  const step = Math.max(2, (hi - lo) / 400);
+  let cutX = 0;
+  let bestCover = Infinity;
+  for (let x = lo; x <= hi; x += step) {
+    let cover = 0;
+    for (const line of lines) {
+      if (line.items.some((i) => i.x < x && i.x + i.w > x)) cover++;
+    }
+    if (cover < bestCover) {
+      bestCover = cover;
+      cutX = x;
+    }
+  }
+  if (bestCover / lines.length > 0.15) return null;
+  const left = [];
+  const right = [];
+  let twoSide = 0;
+  for (const line of lines) {
+    let hasL = false;
+    let hasR = false;
+    for (const i of line.items) {
+      if (i.x + i.w <= cutX) {
+        left.push(i);
+        hasL = true;
+      } else if (i.x >= cutX) {
+        right.push(i);
+        hasR = true;
+      }
+    }
+    if (hasL && hasR) twoSide++;
+  }
+  if (twoSide / lines.length < 0.55) return null;
+  if (left.length < 5 || right.length < 5) return null;
+  const allText = items.map((i) => i.text).join("").replace(/\s+/g, "");
+  const digits = (allText.match(/[\d,.%△—-]/g) || []).length;
+  if (allText.length === 0 || digits / allText.length > 0.15) return null;
+  const stats = [left, right].map((side) => {
+    let sMinX = Infinity;
+    let sMaxR = -Infinity;
+    let fsSum = 0;
+    const rowEnds = /* @__PURE__ */ new Map();
+    const rowLens = /* @__PURE__ */ new Map();
+    const rowFirst = /* @__PURE__ */ new Map();
+    for (const i of side) {
+      if (i.x < sMinX) sMinX = i.x;
+      const rgt = i.x + i.w;
+      if (rgt > sMaxR) sMaxR = rgt;
+      fsSum += i.fontSize;
+      const key = Math.round(i.y / 4);
+      rowEnds.set(key, Math.max(rowEnds.get(key) ?? -Infinity, rgt));
+      rowLens.set(key, (rowLens.get(key) ?? 0) + i.text.replace(/\s+/g, "").length);
+      const f = rowFirst.get(key);
+      if (!f || i.x < f.x) rowFirst.set(key, i);
+    }
+    const ends = [...rowEnds.values()].sort((a, b) => a - b);
+    const p85 = ends[Math.floor(ends.length * 0.85)] ?? sMaxR;
+    const fs = fsSum / side.length;
+    const justified = ends.filter((e) => Math.abs(e - p85) <= fs).length / ends.length;
+    const lens = [...rowLens.values()];
+    const avgLen = lens.reduce((s, v) => s + v, 0) / (lens.length || 1);
+    const markers = [...rowFirst.values()].filter((i) => /^[•▪◦‣∙·\-–—□■◇◆▶※*]/.test(i.text)).length;
+    return { width: sMaxR - sMinX, justified, avgLen, markerRatio: markers / (rowFirst.size || 1) };
+  });
+  if (stats.some((s) => s.avgLen < 12)) return null;
+  if (stats.some((s) => s.markerRatio > 0.1)) return null;
+  const widthSym = Math.min(stats[0].width, stats[1].width) / Math.max(stats[0].width, stats[1].width);
+  if (widthSym < 0.6) return null;
+  if (Math.min(stats[0].justified, stats[1].justified) < 0.55) return null;
+  return cutX;
 }
 function mergeEvenSpacedClusters(items) {
   const originMap = /* @__PURE__ */ new Map();
@@ -2459,7 +2558,7 @@ function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeigh
   if (grids.length > 0) {
     return extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals);
   }
-  return extractPageBlocksFallback(items, pageNum);
+  return extractPageBlocksFallback(items, pageNum, true);
 }
 var STRIKE_MAX_THICKNESS = 2;
 var STRIKE_MAX_THICKNESS_RATIO = 0.25;
@@ -2704,7 +2803,53 @@ function mergeAdjacentTableBlocks(blocks) {
   }
   return result;
 }
-function extractPageBlocksFallback(items, pageNum) {
+function splitTwoColumnProse(items, cutX) {
+  const left = [];
+  const right = [];
+  const cross = [];
+  for (const i of items) {
+    if (i.x + i.w <= cutX) left.push(i);
+    else if (i.x >= cutX) right.push(i);
+    else cross.push(i);
+  }
+  if (cross.length === 0) {
+    return [left, right].filter((g2) => g2.length > 0);
+  }
+  cross.sort((a, b) => b.y - a.y);
+  const crossLines = [];
+  for (const c of cross) {
+    const last = crossLines[crossLines.length - 1];
+    if (last && Math.abs(last[0].y - c.y) <= 3) last.push(c);
+    else crossLines.push([c]);
+  }
+  const bandItem = (arr) => arr.filter((i) => {
+    for (const cl of crossLines) {
+      if (Math.abs(cl[0].y - i.y) <= 3) {
+        cl.push(i);
+        return false;
+      }
+    }
+    return true;
+  });
+  const leftRest = bandItem(left);
+  const rightRest = bandItem(right);
+  const boundYs = crossLines.map((cl) => cl[0].y);
+  const bandOf = (y) => {
+    let k = 0;
+    while (k < boundYs.length && y < boundYs[k]) k++;
+    return k;
+  };
+  const groups = [];
+  for (let k = 0; k <= crossLines.length; k++) {
+    const L = leftRest.filter((i) => bandOf(i.y) === k);
+    const R = rightRest.filter((i) => bandOf(i.y) === k);
+    if (L.length > 0) groups.push(L);
+    if (R.length > 0) groups.push(R);
+    if (k < crossLines.length) groups.push(crossLines[k]);
+  }
+  return groups;
+}
+function extractPageBlocksFallback(items, pageNum, fullPage = false) {
   if (items.length === 0) return [];
   const blocks = [];
   const clusterItems = items.map((i) => ({
@@ -2745,8 +2890,9 @@ function extractPageBlocksFallback(items, pageNum) {
       return by - ay;
     });
   } else {
+    const proseCutX = fullPage ? findTwoColumnProseCutX(items) : null;
     const allYLines = mergeSuperscriptLines(groupByY(items));
-    const columns = detectColumns(allYLines);
+    const columns = proseCutX !== null ? null : detectColumns(allYLines);
     if (columns && columns.length >= 3) {
       const tableText = extractWithColumns(allYLines, columns);
       const bbox = computeBBox(items, pageNum);
@@ -2755,7 +2901,7 @@ function extractPageBlocksFallback(items, pageNum) {
       const allY = items.map((i) => i.y);
       const pageHeight = safeMax(allY) - safeMin(allY);
       const gapThreshold = Math.max(15, pageHeight * 0.03);
-      const orderedGroups = xyCutOrder(items, gapThreshold);
+      const orderedGroups = proseCutX !== null ? splitTwoColumnProse(items, proseCutX) : xyCutOrder(items, gapThreshold);
       for (const group of orderedGroups) {
         if (group.length === 0) continue;
         const yLines = mergeSuperscriptLines(groupByY(group));
@@ -3210,4 +3356,4 @@ export {
   parsePdfDocument,
   removeHeaderFooterBlocks
 };
-//# sourceMappingURL=parser-NR2TYGO3.js.map
+//# sourceMappingURL=parser-TM3AS25T.js.map