kordoc 4.17.4 → 4.17.5

package/dist/{chunk-PVJFCDND.js → chunk-FL32PTUU.js}

@@ -5,11 +5,11 @@ import {
   HEADING_RATIO_H2,
   HEADING_RATIO_H3,
   tidyScriptTags
-} from "./chunk-ODVIUG6Q.js";
+} from "./chunk-L4QCMV7B.js";
 import {
   safeMax,
   safeMin
-} from "./chunk-DD6AY6EI.js";
+} from "./chunk-ZG7V4LAC.js";
 
 // src/pdf/line-extract.ts
 import { OPS } from "pdfjs-dist/legacy/build/pdf.mjs";
@@ -3163,6 +3163,297 @@ function panelBlocks(items, panel, pageNum) {
   });
 }
 
+// src/pdf/xy-cut.ts
+var MAX_XYCUT_DEPTH = 50;
+var XYCUT_MIN_GAP = 5;
+var CROSS_LAYOUT_BETA = 2;
+var CROSS_OVERLAP_RATIO = 0.1;
+var CROSS_MIN_OVERLAPS = 2;
+var CROSS_MAX_MASK_RATIO = 0.2;
+var NARROW_ELEMENT_WIDTH_RATIO = 0.1;
+var PROSE_GUTTER_MIN_GAP = 6;
+var XY_WRAP_BANDS = /* @__PURE__ */ new WeakMap();
+var XY_WRAP_ITEMS = /* @__PURE__ */ new WeakMap();
+var leaf = (items, wrapped) => {
+  wrapped = validWrapBands(items, wrapped);
+  const source = wrapped.length ? [...items] : [];
+  for (const item of items) {
+    if (wrapped.length) {
+      XY_WRAP_BANDS.set(item, wrapped);
+      XY_WRAP_ITEMS.set(item, source);
+    } else {
+      XY_WRAP_BANDS.delete(item);
+      XY_WRAP_ITEMS.delete(item);
+    }
+  }
+  return [items];
+};
+function xyCutOrder(items, gapThreshold, depth = 0, wrapped) {
+  if (items.length === 0) return [];
+  const newRegion = wrapped === void 0;
+  wrapped ??= inheritedWrapBands(items);
+  if (items.length <= 2 || depth >= MAX_XYCUT_DEPTH) return leaf(items, wrapped);
+  if (depth === 0 && items.length >= 3) {
+    const cross = identifyCrossLayoutItems(items);
+    if (cross.size > 0 && cross.size <= items.length * CROSS_MAX_MASK_RATIO) {
+      const rest = items.filter((i) => !cross.has(i));
+      if (rest.length > 0) {
+        const groups = xyCutOrder(rest, gapThreshold, 1);
+        return mergeCrossLayoutGroups(groups, [...cross]);
+      }
+    }
+  }
+  const minGap = Math.max(XYCUT_MIN_GAP, gapThreshold);
+  const sortedY = [...items].sort((a, b) => b.y - a.y);
+  let hCut = findHorizontalCut(sortedY, wrapped);
+  if (newRegion && hCut.gap >= minGap) {
+    wrapped = wrappedLineBands(items, wrapped);
+    hCut = findHorizontalCut(sortedY, wrapped);
+  }
+  const vCut = findVerticalCutWithOutlierFilter(items, minGap);
+  const hValid = hCut.gap >= minGap;
+  const vValid = (vCut.gap >= minGap || vCut.gap >= PROSE_GUTTER_MIN_GAP && isProseGutter(items, vCut.position)) && !splitsSpacedLabel(items, vCut.position);
+  let useHorizontal;
+  if (hValid && vValid) useHorizontal = vCut.gap <= hCut.gap * 1.5 || staggeredSides(items, vCut.position);
+  else if (hValid) useHorizontal = true;
+  else if (vValid) useHorizontal = false;
+  else return splitEdgeSpannedColumns(items, gapThreshold, depth) ?? leaf(items, wrapped);
+  if (useHorizontal) {
+    const upper = items.filter((i) => i.y > hCut.position);
+    const lower = items.filter((i) => i.y <= hCut.position);
+    if (upper.length > 0 && lower.length > 0 && upper.length < items.length) {
+      return [...xyCutOrder(upper, gapThreshold, depth + 1, wrapped), ...xyCutOrder(lower, gapThreshold, depth + 1, wrapped)];
+    }
+  } else {
+    const left = items.filter((i) => i.x + i.w / 2 < vCut.position);
+    const right = items.filter((i) => i.x + i.w / 2 >= vCut.position);
+    if (left.length > 0 && right.length > 0 && left.length < items.length) {
+      return [...xyCutOrder(left, gapThreshold, depth + 1), ...xyCutOrder(right, gapThreshold, depth + 1)];
+    }
+  }
+  return leaf(items, wrapped);
+}
+function splitsSpacedLabel(items, cutX) {
+  const lone = (i) => /^[가-힣]$/.test(i.text.trim());
+  const sameRow = (a, b) => Math.min(a.y, b.y) > Math.max(a.y - a.h, b.y - b.h);
+  const left = items.filter((i) => i.x + i.w / 2 < cutX);
+  const right = items.filter((i) => i.x + i.w / 2 >= cutX);
+  let spaced = 0;
+  for (const r of right) {
+    if (right.some((o) => o !== r && o.x < r.x && sameRow(o, r))) continue;
+    const row = left.filter((l2) => sameRow(l2, r));
+    if (row.length === 0) continue;
+    const l = row.reduce((a, b) => b.x + b.w > a.x + a.w ? b : a);
+    if (!lone(l) || !lone(r)) return false;
+    spaced++;
+  }
+  return spaced > 0;
+}
+function staggeredSides(items, cutX) {
+  const left = items.filter((i) => i.x + i.w / 2 < cutX);
+  const right = items.filter((i) => i.x + i.w / 2 >= cutX);
+  if (left.length * right.length > 2e5) return false;
+  const shareRow = (a, b) => Math.min(a.y, b.y) > Math.max(a.y - a.h, b.y - b.h);
+  if (left.some((a) => right.some((b) => shareRow(a, b)))) return false;
+  const sides = [...items].sort((a, b) => b.y - a.y).map((i) => i.x + i.w / 2 < cutX);
+  let switches = 0;
+  for (let k = 1; k < sides.length; k++) if (sides[k] !== sides[k - 1]) switches++;
+  return switches >= 3;
+}
+function identifyCrossLayoutItems(items) {
+  const cross = /* @__PURE__ */ new Set();
+  if (items.length < 3) return cross;
+  let maxWidth = 0;
+  for (const i of items) {
+    if (i.w > maxWidth) maxWidth = i.w;
+  }
+  const threshold = CROSS_LAYOUT_BETA * maxWidth;
+  for (const item of items) {
+    if (item.w < threshold) continue;
+    let overlaps = 0;
+    for (const other of items) {
+      if (other === item) continue;
+      const left = Math.max(item.x, other.x);
+      const right = Math.min(item.x + item.w, other.x + other.w);
+      const overlapW = right - left;
+      if (overlapW <= 0) continue;
+      const smaller = Math.min(item.w, other.w);
+      if (smaller > 0 && overlapW / smaller >= CROSS_OVERLAP_RATIO) {
+        overlaps++;
+        if (overlaps >= CROSS_MIN_OVERLAPS) break;
+      }
+    }
+    if (overlaps >= CROSS_MIN_OVERLAPS) cross.add(item);
+  }
+  return cross;
+}
+function mergeCrossLayoutGroups(groups, cross) {
+  if (cross.length === 0) return groups;
+  const sortedCross = [...cross].sort((a, b) => b.y + b.h - (a.y + a.h) || a.x - b.x);
+  const groupTop = (g) => {
+    let top = -Infinity;
+    for (const i of g) {
+      const t = i.y + i.h;
+      if (t > top) top = t;
+    }
+    return top;
+  };
+  const result = [];
+  let gi = 0, ci = 0;
+  while (gi < groups.length || ci < sortedCross.length) {
+    if (ci >= sortedCross.length) {
+      result.push(groups[gi++]);
+      continue;
+    }
+    if (gi >= groups.length) {
+      result.push([sortedCross[ci++]]);
+      continue;
+    }
+    const crossTop = sortedCross[ci].y + sortedCross[ci].h;
+    if (crossTop >= groupTop(groups[gi])) result.push([sortedCross[ci++]]);
+    else result.push(groups[gi++]);
+  }
+  return result;
+}
+function validWrapBands(items, bands) {
+  if (!bands.length) return [];
+  const present = new Set(items);
+  return bands.filter((b) => b.sources.every(({ item: a, state: s }) => present.has(a) && a.text === s.text && a.x === s.x && a.y === s.y && a.w === s.w && a.h === s.h && a.fontSize === s.fontSize && a.fontName === s.fontName && a.isHidden === s.isHidden && a.hasSpaceBefore === s.hasSpaceBefore && a.syntheticSpace === s.syntheticSpace && a.strike === s.strike && a.underline === s.underline && a.seq === s.seq && a.rotated === s.rotated));
+}
+function inheritedWrapBands(items) {
+  const source = XY_WRAP_ITEMS.get(items[0]);
+  const present = source?.length === items.length ? new Set(items) : null;
+  const sameLeaf = present && source.every((item) => present.has(item));
+  return sameLeaf ? validWrapBands(items, XY_WRAP_BANDS.get(items[0]) ?? []) : [];
+}
+function wrappedLineBands(items, inherited) {
+  const lines = groupByY(items).map((row) => {
+    const box = computeBBox(row, 0);
+    return {
+      text: mergeLineSimple(row).replace(/<\/?u>|~~/g, ""),
+      left: box.x,
+      right: box.x + box.width,
+      y: row.reduce((n, i) => n + i.y, 0) / row.length,
+      fontSize: dominantStyle(row)?.fontSize ?? 0,
+      sources: row.map((item) => ({ item, state: { ...item } }))
+    };
+  });
+  const joins = bodyLineJoins(lines);
+  const fresh = lines.slice(0, -1).flatMap((line, i) => joins[i] === "\n" || line.text.trim() === lines[i + 1].text.trim() ? [] : [{ top: line.y, bottom: lines[i + 1].y, sources: [...line.sources, ...lines[i + 1].sources] }]);
+  const freshKeys = new Set(fresh.map((b) => `${b.top}:${b.bottom}`));
+  return [...inherited.filter((b) => !freshKeys.has(`${b.top}:${b.bottom}`)), ...fresh].sort((a, b) => b.top - a.top);
+}
+function findHorizontalCut(sorted, wrapped) {
+  if (sorted.length < 2) return { position: 0, gap: 0 };
+  let largestGap = 0;
+  let position = 0;
+  let wrapIndex = 0;
+  for (let i = 1; i < sorted.length; i++) {
+    const prevBottom = sorted[i - 1].y - sorted[i - 1].h;
+    const currTop = sorted[i].y;
+    const gap = prevBottom - currTop;
+    if (gap <= 0) continue;
+    const at = (prevBottom + currTop) / 2;
+    while (wrapIndex < wrapped.length && at <= wrapped[wrapIndex].bottom) wrapIndex++;
+    const band = wrapped[wrapIndex];
+    if (gap > largestGap && !(band && at < band.top && at > band.bottom)) {
+      largestGap = gap;
+      position = at;
+    }
+  }
+  return { position, gap: largestGap };
+}
+function findVerticalCutWithOutlierFilter(items, minGap) {
+  const edgeCut = findVerticalCut(items);
+  if (edgeCut.gap >= minGap) return edgeCut;
+  if (items.length >= 3) {
+    let minX = Infinity, maxX = -Infinity;
+    for (const i of items) {
+      if (i.x < minX) minX = i.x;
+      const r = i.x + i.w;
+      if (r > maxX) maxX = r;
+    }
+    const narrowThreshold = (maxX - minX) * NARROW_ELEMENT_WIDTH_RATIO;
+    const filtered = items.filter((i) => i.w >= narrowThreshold);
+    if (filtered.length >= 2 && filtered.length < items.length && filtered.length >= items.length * 0.7) {
+      const filteredCut = findVerticalCut(filtered);
+      if (filteredCut.gap > edgeCut.gap && filteredCut.gap >= minGap) {
+        return filteredCut;
+      }
+    }
+  }
+  return edgeCut;
+}
+function findVerticalCut(items) {
+  if (items.length < 2) return { position: 0, gap: 0 };
+  const sorted = [...items].sort((a, b) => a.x - b.x || a.x + a.w - (b.x + b.w));
+  let largestGap = 0;
+  let position = 0;
+  let prevRight = null;
+  for (const it of sorted) {
+    const left = it.x;
+    const right = it.x + it.w;
+    if (prevRight !== null && left > prevRight) {
+      const gap = left - prevRight;
+      if (gap > largestGap) {
+        largestGap = gap;
+        position = (prevRight + left) / 2;
+      }
+    }
+    prevRight = prevRight === null ? right : Math.max(prevRight, right);
+  }
+  return { position, gap: largestGap };
+}
+function isProseGutter(items, x) {
+  const sideLines = (side) => {
+    const lines = [];
+    for (const item of [...side].sort((a, b) => b.y - a.y)) {
+      const line = lines.find((l) => Math.abs(l.y - item.y) <= 2);
+      if (line) {
+        line.chars += item.text.length;
+        line.left = Math.min(line.left, item.x);
+        line.right = Math.max(line.right, item.x + item.w);
+      } else lines.push({ y: item.y, chars: item.text.length, left: item.x, right: item.x + item.w });
+    }
+    return lines;
+  };
+  const left = sideLines(items.filter((i) => i.x + i.w / 2 < x));
+  const right = sideLines(items.filter((i) => i.x + i.w / 2 >= x));
+  if (left.length < 4 || right.length < 4) return false;
+  const prose = (lines) => {
+    const width = Math.max(...lines.map((l) => l.right)) - Math.min(...lines.map((l) => l.left));
+    const full = lines.filter((l) => l.chars >= 25 && l.right - l.left >= width * 0.6).length;
+    return full >= lines.length * 0.6;
+  };
+  if (!prose(left) || !prose(right)) return false;
+  const span = (lines) => [Math.min(...lines.map((l) => l.y)), Math.max(...lines.map((l) => l.y))];
+  const [l0, l1] = span(left), [r0, r1] = span(right);
+  return Math.min(l1, r1) - Math.max(l0, r0) >= Math.min(l1 - l0, r1 - r0) * 0.5;
+}
+function splitEdgeSpannedColumns(items, gapThreshold, depth) {
+  let minX = Infinity, maxX = -Infinity;
+  for (const i of items) {
+    minX = Math.min(minX, i.x);
+    maxX = Math.max(maxX, i.x + i.w);
+  }
+  const narrow = items.filter((i) => i.w < (maxX - minX) * 0.5);
+  if (narrow.length === items.length || narrow.length < 8) return null;
+  const cut = findVerticalCut(narrow);
+  if (cut.gap < PROSE_GUTTER_MIN_GAP || !isProseGutter(narrow, cut.position)) return null;
+  const crossing = items.filter((i) => i.x < cut.position && i.x + i.w > cut.position);
+  const rest = items.filter((i) => !crossing.includes(i));
+  const restTop = Math.max(...rest.map((i) => i.y)), restBottom = Math.min(...rest.map((i) => i.y));
+  const above = crossing.filter((i) => i.y > restTop), below = crossing.filter((i) => i.y < restBottom);
+  if (above.length + below.length !== crossing.length) return null;
+  const left = rest.filter((i) => i.x + i.w / 2 < cut.position), right = rest.filter((i) => i.x + i.w / 2 >= cut.position);
+  return [
+    ...above.length ? [above] : [],
+    ...xyCutOrder(left, gapThreshold, depth + 1),
+    ...xyCutOrder(right, gapThreshold, depth + 1),
+    ...below.length ? [below] : []
+  ];
+}
+
 // src/pdf/paragraph-lines.ts
 var FACE_CHARS = /* @__PURE__ */ new WeakMap();
 function hasNumberedStyledTitle(lines) {
@@ -3180,6 +3471,25 @@ function pushLineParagraphs(out, yLines, pageNum, lex) {
     return { text: l.text, left: b.x, right: b.x + b.width, y: l.items.reduce((s, i) => s + i.y, 0) / l.items.length, fontSize: dominantStyle(l.items)?.fontSize ?? 0 };
   });
   const joins = bodyLineJoins(geo, lex);
+  const first = lines[0]?.items[0];
+  const bands = first ? XY_WRAP_BANDS.get(first) ?? [] : [];
+  const hasBand = (top, bottom) => {
+    let lo = 0, hi = bands.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (bands[mid].top > top + 3) lo = mid + 1;
+      else hi = mid;
+    }
+    for (; lo < bands.length && bands[lo].top >= top - 3; lo++) {
+      if (Math.abs(bands[lo].bottom - bottom) <= 3) return true;
+    }
+    return false;
+  };
+  for (let i = 0; i + 1 < geo.length; i++) {
+    if (joins[i] === "\n" && Math.abs(geo[i + 1].fontSize - geo[i].fontSize) <= 0.15 * geo[i].fontSize && !startsNewItem(geo[i].text, geo[i + 1].text) && hasBand(geo[i].y, geo[i + 1].y)) {
+      joins[i] = wrapJoiner(geo[i].text, geo[i + 1].text, lex);
+    }
+  }
   for (let i = 0; i + 1 < geo.length; i++) {
     if (/^\d{1,2}$/.test(geo[i].text.trim()) && geo[i].fontSize >= geo[i + 1].fontSize * 1.2) joins[i] = "\n";
   }
@@ -4863,242 +5173,6 @@ function findRuledColumnDivider(regions, horizontals, verticals, pageWidth, page
   return candidates.length === 1 ? candidates[0] : null;
 }
 
-// src/pdf/xy-cut.ts
-var MAX_XYCUT_DEPTH = 50;
-var XYCUT_MIN_GAP = 5;
-var CROSS_LAYOUT_BETA = 2;
-var CROSS_OVERLAP_RATIO = 0.1;
-var CROSS_MIN_OVERLAPS = 2;
-var CROSS_MAX_MASK_RATIO = 0.2;
-var NARROW_ELEMENT_WIDTH_RATIO = 0.1;
-var PROSE_GUTTER_MIN_GAP = 6;
-function xyCutOrder(items, gapThreshold, depth = 0) {
-  if (items.length === 0) return [];
-  if (items.length <= 2 || depth >= MAX_XYCUT_DEPTH) return [items];
-  if (depth === 0 && items.length >= 3) {
-    const cross = identifyCrossLayoutItems(items);
-    if (cross.size > 0 && cross.size <= items.length * CROSS_MAX_MASK_RATIO) {
-      const rest = items.filter((i) => !cross.has(i));
-      if (rest.length > 0) {
-        const groups = xyCutOrder(rest, gapThreshold, 1);
-        return mergeCrossLayoutGroups(groups, [...cross]);
-      }
-    }
-  }
-  const minGap = Math.max(XYCUT_MIN_GAP, gapThreshold);
-  const hCut = findHorizontalCut(items);
-  const vCut = findVerticalCutWithOutlierFilter(items, minGap);
-  const hValid = hCut.gap >= minGap;
-  const vValid = (vCut.gap >= minGap || vCut.gap >= PROSE_GUTTER_MIN_GAP && isProseGutter(items, vCut.position)) && !splitsSpacedLabel(items, vCut.position);
-  let useHorizontal;
-  if (hValid && vValid) useHorizontal = vCut.gap <= hCut.gap * 1.5 || staggeredSides(items, vCut.position);
-  else if (hValid) useHorizontal = true;
-  else if (vValid) useHorizontal = false;
-  else return splitEdgeSpannedColumns(items, gapThreshold, depth) ?? [items];
-  if (useHorizontal) {
-    const upper = items.filter((i) => i.y > hCut.position);
-    const lower = items.filter((i) => i.y <= hCut.position);
-    if (upper.length > 0 && lower.length > 0 && upper.length < items.length) {
-      return [...xyCutOrder(upper, gapThreshold, depth + 1), ...xyCutOrder(lower, gapThreshold, depth + 1)];
-    }
-  } else {
-    const left = items.filter((i) => i.x + i.w / 2 < vCut.position);
-    const right = items.filter((i) => i.x + i.w / 2 >= vCut.position);
-    if (left.length > 0 && right.length > 0 && left.length < items.length) {
-      return [...xyCutOrder(left, gapThreshold, depth + 1), ...xyCutOrder(right, gapThreshold, depth + 1)];
-    }
-  }
-  return [items];
-}
-function splitsSpacedLabel(items, cutX) {
-  const lone = (i) => /^[가-힣]$/.test(i.text.trim());
-  const sameRow = (a, b) => Math.min(a.y, b.y) > Math.max(a.y - a.h, b.y - b.h);
-  const left = items.filter((i) => i.x + i.w / 2 < cutX);
-  const right = items.filter((i) => i.x + i.w / 2 >= cutX);
-  let spaced = 0;
-  for (const r of right) {
-    if (right.some((o) => o !== r && o.x < r.x && sameRow(o, r))) continue;
-    const row = left.filter((l2) => sameRow(l2, r));
-    if (row.length === 0) continue;
-    const l = row.reduce((a, b) => b.x + b.w > a.x + a.w ? b : a);
-    if (!lone(l) || !lone(r)) return false;
-    spaced++;
-  }
-  return spaced > 0;
-}
-function staggeredSides(items, cutX) {
-  const left = items.filter((i) => i.x + i.w / 2 < cutX);
-  const right = items.filter((i) => i.x + i.w / 2 >= cutX);
-  if (left.length * right.length > 2e5) return false;
-  const shareRow = (a, b) => Math.min(a.y, b.y) > Math.max(a.y - a.h, b.y - b.h);
-  if (left.some((a) => right.some((b) => shareRow(a, b)))) return false;
-  const sides = [...items].sort((a, b) => b.y - a.y).map((i) => i.x + i.w / 2 < cutX);
-  let switches = 0;
-  for (let k = 1; k < sides.length; k++) if (sides[k] !== sides[k - 1]) switches++;
-  return switches >= 3;
-}
-function identifyCrossLayoutItems(items) {
-  const cross = /* @__PURE__ */ new Set();
-  if (items.length < 3) return cross;
-  let maxWidth = 0;
-  for (const i of items) {
-    if (i.w > maxWidth) maxWidth = i.w;
-  }
-  const threshold = CROSS_LAYOUT_BETA * maxWidth;
-  for (const item of items) {
-    if (item.w < threshold) continue;
-    let overlaps = 0;
-    for (const other of items) {
-      if (other === item) continue;
-      const left = Math.max(item.x, other.x);
-      const right = Math.min(item.x + item.w, other.x + other.w);
-      const overlapW = right - left;
-      if (overlapW <= 0) continue;
-      const smaller = Math.min(item.w, other.w);
-      if (smaller > 0 && overlapW / smaller >= CROSS_OVERLAP_RATIO) {
-        overlaps++;
-        if (overlaps >= CROSS_MIN_OVERLAPS) break;
-      }
-    }
-    if (overlaps >= CROSS_MIN_OVERLAPS) cross.add(item);
-  }
-  return cross;
-}
-function mergeCrossLayoutGroups(groups, cross) {
-  if (cross.length === 0) return groups;
-  const sortedCross = [...cross].sort((a, b) => b.y + b.h - (a.y + a.h) || a.x - b.x);
-  const groupTop = (g) => {
-    let top = -Infinity;
-    for (const i of g) {
-      const t = i.y + i.h;
-      if (t > top) top = t;
-    }
-    return top;
-  };
-  const result = [];
-  let gi = 0, ci = 0;
-  while (gi < groups.length || ci < sortedCross.length) {
-    if (ci >= sortedCross.length) {
-      result.push(groups[gi++]);
-      continue;
-    }
-    if (gi >= groups.length) {
-      result.push([sortedCross[ci++]]);
-      continue;
-    }
-    const crossTop = sortedCross[ci].y + sortedCross[ci].h;
-    if (crossTop >= groupTop(groups[gi])) result.push([sortedCross[ci++]]);
-    else result.push(groups[gi++]);
-  }
-  return result;
-}
-function findHorizontalCut(items) {
-  if (items.length < 2) return { position: 0, gap: 0 };
-  const sorted = [...items].sort((a, b) => b.y - a.y);
-  let largestGap = 0;
-  let position = 0;
-  for (let i = 1; i < sorted.length; i++) {
-    const prevBottom = sorted[i - 1].y - sorted[i - 1].h;
-    const currTop = sorted[i].y;
-    const gap = prevBottom - currTop;
-    if (gap > largestGap) {
-      largestGap = gap;
-      position = (prevBottom + currTop) / 2;
-    }
-  }
-  return { position, gap: largestGap };
-}
-function findVerticalCutWithOutlierFilter(items, minGap) {
-  const edgeCut = findVerticalCut(items);
-  if (edgeCut.gap >= minGap) return edgeCut;
-  if (items.length >= 3) {
-    let minX = Infinity, maxX = -Infinity;
-    for (const i of items) {
-      if (i.x < minX) minX = i.x;
-      const r = i.x + i.w;
-      if (r > maxX) maxX = r;
-    }
-    const narrowThreshold = (maxX - minX) * NARROW_ELEMENT_WIDTH_RATIO;
-    const filtered = items.filter((i) => i.w >= narrowThreshold);
-    if (filtered.length >= 2 && filtered.length < items.length && filtered.length >= items.length * 0.7) {
-      const filteredCut = findVerticalCut(filtered);
-      if (filteredCut.gap > edgeCut.gap && filteredCut.gap >= minGap) {
-        return filteredCut;
-      }
-    }
-  }
-  return edgeCut;
-}
-function findVerticalCut(items) {
-  if (items.length < 2) return { position: 0, gap: 0 };
-  const sorted = [...items].sort((a, b) => a.x - b.x || a.x + a.w - (b.x + b.w));
-  let largestGap = 0;
-  let position = 0;
-  let prevRight = null;
-  for (const it of sorted) {
-    const left = it.x;
-    const right = it.x + it.w;
-    if (prevRight !== null && left > prevRight) {
-      const gap = left - prevRight;
-      if (gap > largestGap) {
-        largestGap = gap;
-        position = (prevRight + left) / 2;
-      }
-    }
-    prevRight = prevRight === null ? right : Math.max(prevRight, right);
-  }
-  return { position, gap: largestGap };
-}
-function isProseGutter(items, x) {
-  const sideLines = (side) => {
-    const lines = [];
-    for (const item of [...side].sort((a, b) => b.y - a.y)) {
-      const line = lines.find((l) => Math.abs(l.y - item.y) <= 2);
-      if (line) {
-        line.chars += item.text.length;
-        line.left = Math.min(line.left, item.x);
-        line.right = Math.max(line.right, item.x + item.w);
-      } else lines.push({ y: item.y, chars: item.text.length, left: item.x, right: item.x + item.w });
-    }
-    return lines;
-  };
-  const left = sideLines(items.filter((i) => i.x + i.w / 2 < x));
-  const right = sideLines(items.filter((i) => i.x + i.w / 2 >= x));
-  if (left.length < 4 || right.length < 4) return false;
-  const prose = (lines) => {
-    const width = Math.max(...lines.map((l) => l.right)) - Math.min(...lines.map((l) => l.left));
-    const full = lines.filter((l) => l.chars >= 25 && l.right - l.left >= width * 0.6).length;
-    return full >= lines.length * 0.6;
-  };
-  if (!prose(left) || !prose(right)) return false;
-  const span = (lines) => [Math.min(...lines.map((l) => l.y)), Math.max(...lines.map((l) => l.y))];
-  const [l0, l1] = span(left), [r0, r1] = span(right);
-  return Math.min(l1, r1) - Math.max(l0, r0) >= Math.min(l1 - l0, r1 - r0) * 0.5;
-}
-function splitEdgeSpannedColumns(items, gapThreshold, depth) {
-  let minX = Infinity, maxX = -Infinity;
-  for (const i of items) {
-    minX = Math.min(minX, i.x);
-    maxX = Math.max(maxX, i.x + i.w);
-  }
-  const narrow = items.filter((i) => i.w < (maxX - minX) * 0.5);
-  if (narrow.length === items.length || narrow.length < 8) return null;
-  const cut = findVerticalCut(narrow);
-  if (cut.gap < PROSE_GUTTER_MIN_GAP || !isProseGutter(narrow, cut.position)) return null;
-  const crossing = items.filter((i) => i.x < cut.position && i.x + i.w > cut.position);
-  const rest = items.filter((i) => !crossing.includes(i));
-  const restTop = Math.max(...rest.map((i) => i.y)), restBottom = Math.min(...rest.map((i) => i.y));
-  const above = crossing.filter((i) => i.y > restTop), below = crossing.filter((i) => i.y < restBottom);
-  if (above.length + below.length !== crossing.length) return null;
-  const left = rest.filter((i) => i.x + i.w / 2 < cut.position), right = rest.filter((i) => i.x + i.w / 2 >= cut.position);
-  return [
-    ...above.length ? [above] : [],
-    ...xyCutOrder(left, gapThreshold, depth + 1),
-    ...xyCutOrder(right, gapThreshold, depth + 1),
-    ...below.length ? [below] : []
-  ];
-}
-
 // src/pdf/two-column.ts
 var GUTTER_SCAN_LO = 0.3;
 var GUTTER_SCAN_HI = 0.7;
@@ -7429,4 +7503,4 @@ export {
   joinCellEdges,
   extractPageBlocksWithLines
 };
-//# sourceMappingURL=chunk-PVJFCDND.js.map
+//# sourceMappingURL=chunk-FL32PTUU.js.map