kordoc 4.16.2 → 4.17.0

package/dist/{model-bundle-IMBW7D2Z.js → model-bundle-OUHGCEZY.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import {
   ALL_OCR_MODELS
-} from "./chunk-DES2LGFZ.js";
+} from "./chunk-A55JGNKD.js";
 import {
   ALL_FORMULA_MODELS,
   getModelStatusIn,
   getModelsDir
-} from "./chunk-KIOQ4N37.js";
-import "./chunk-JELRWAZC.js";
-import "./chunk-P6ZDXTV6.js";
+} from "./chunk-BLPR4HRF.js";
+import "./chunk-BZG7K44Z.js";
+import "./chunk-ZF6KHPB7.js";
 
 // src/shared/model-bundle.ts
 import { copyFile, mkdir } from "fs/promises";
@@ -101,4 +101,4 @@ export {
   importModels,
   modelCacheStatus
 };
-//# sourceMappingURL=model-bundle-IMBW7D2Z.js.map
+//# sourceMappingURL=model-bundle-OUHGCEZY.js.map

package/dist/{models-SY75IBOE.js → models-6D6LMOTH.js}

@@ -10,10 +10,10 @@ import {
   ocrModelPath,
   ocrModelsCached,
   parseCharacterDict
-} from "./chunk-DES2LGFZ.js";
-import "./chunk-KIOQ4N37.js";
-import "./chunk-JELRWAZC.js";
-import "./chunk-P6ZDXTV6.js";
+} from "./chunk-A55JGNKD.js";
+import "./chunk-BLPR4HRF.js";
+import "./chunk-BZG7K44Z.js";
+import "./chunk-ZF6KHPB7.js";
 export {
   ALL_OCR_MODELS,
   OCR_DET_MODEL,
@@ -26,4 +26,4 @@ export {
   ocrModelsCached,
   parseCharacterDict
 };
-//# sourceMappingURL=models-SY75IBOE.js.map
+//# sourceMappingURL=models-6D6LMOTH.js.map

package/dist/page-range-QHHFTL7X.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/mong-e/workspace/kordoc/dist/page-range-QHHFTL7X.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACF,wDAA6B;AAC7B,gCAA6B;AAC7B;AACE;AACA;AACF,qIAAC","file":"/Users/mong-e/workspace/kordoc/dist/page-range-QHHFTL7X.cjs"}
+{"version":3,"sources":["/Users/chris_gomdori/workspace/kordoc/dist/page-range-QHHFTL7X.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACF,wDAA6B;AAC7B,gCAA6B;AAC7B;AACE;AACA;AACF,qIAAC","file":"/Users/chris_gomdori/workspace/kordoc/dist/page-range-QHHFTL7X.cjs"}

package/dist/{parser-ZQM3664Z.js → parser-CTRB7PKD.js}

@@ -4,7 +4,7 @@ import {
   blocksToPages,
   encodePng,
   escapeLiteralDollar
-} from "./chunk-7KNGSQU7.js";
+} from "./chunk-YZ5HHS6A.js";
 import {
   hasRequestedPagesAfter,
   parsePageRange
@@ -16,7 +16,12 @@ import {
   EMPTY_PARTS,
   FILLER_CELLS,
   IMAGE_CELLS,
+  NO_EDGES,
+  PART_COLXS,
+  ROW_RULES,
   TABLE_COLXS,
+  TABLE_ROWYS,
+  TABLE_TAIL,
   TOC_BLOCKS,
   WrapLexicon,
   collapseEvenSpacing,
@@ -34,6 +39,7 @@ import {
   extractLines,
   extractPageBlocksWithLines,
   filterHiddenText,
+  joinCellEdges,
   joinPageBreakWraps,
   latinSoftWrap,
   mergeStackedHeadingLines,
@@ -44,15 +50,18 @@ import {
   startsNewItem,
   trimTrailingEmptyTableCols,
   wrapJoiner
-} from "./chunk-TXUKTOG2.js";
+} from "./chunk-4XVNQAK5.js";
 import {
-  stripScriptTags
-} from "./chunk-3IB7LBHC.js";
-import "./chunk-F4NRLLY4.js";
+  CELL_EDGES,
+  CONTENT_CELLS,
+  stripScriptTags,
+  unframeLayoutTables
+} from "./chunk-MJBCXW5R.js";
+import "./chunk-EFO6JZY6.js";
 import {
   KordocError,
   sanitizeHref
-} from "./chunk-MLIS253L.js";
+} from "./chunk-ML4NHUR7.js";
 
 // src/pdf/ocr-region-merge.ts
 function mergeOcrImageRegions(blocks, page, regions, ocrBlocks) {
@@ -673,6 +682,7 @@ function splitContactTables(blocks) {
 
 // src/pdf/table-parts.ts
 var PART_COL_TOL = 1;
+var PART_COL_SNAP = 0.3;
 function anchorsOf(table) {
   const out = [];
   const covered = /* @__PURE__ */ new Set();
@@ -690,9 +700,22 @@ function anchorsOf(table) {
   return out;
 }
 function unionCoords(a, b) {
+  const drift = a.length === b.length && a.every((x, i) => Math.abs(x - b[i]) <= PART_COL_TOL);
+  const tol = drift ? PART_COL_TOL : PART_COL_SNAP;
+  const pairs = [];
+  for (const v of b) for (const x of a) if (Math.abs(x - v) <= tol) pairs.push([Math.abs(x - v), v, x]);
+  pairs.sort((p, q) => p[0] - q[0]);
+  const map = /* @__PURE__ */ new Map(), taken = /* @__PURE__ */ new Set();
+  for (const [, v, x] of pairs) if (!map.has(v) && !taken.has(x)) {
+    map.set(v, x);
+    taken.add(x);
+  }
   const out = [...a];
-  for (const v of b) if (!a.some((x) => Math.abs(x - v) <= PART_COL_TOL)) out.push(v);
-  return out.sort((x, y) => x - y);
+  for (const v of b) if (!map.has(v)) {
+    map.set(v, v);
+    out.push(v);
+  }
+  return { U: out.sort((x, y) => x - y), map };
 }
 var indexOf = (coords, x) => {
   let best = -1, bestD = Infinity;
@@ -709,18 +732,31 @@ var rowText = (anchors, r) => anchors.filter((a) => a.r === r).map((a) => a.cell
 var hasText = (t) => t.replace(/\|/g, "") !== "";
 function joinSplitParts(prev, pcx, curr, ccx, dx = 0, prevBottom, lex) {
   if (pcx.length !== prev.cols + 1 || ccx.length !== curr.cols + 1) return null;
-  const U = unionCoords(pcx, ccx);
+  const { U, map } = unionCoords(pcx, ccx);
+  const cxU = ccx.map((v) => map.get(v) ?? v);
   const cols = U.length - 1;
   if (cols < 1) return null;
   const pa = anchorsOf(prev), ca = anchorsOf(curr);
-  let skip = 0;
+  let skip = 0, head = 0;
   while (skip < Math.min(3, curr.rows - 1, prev.rows) && rowText(ca, skip) !== "" && rowText(ca, skip) === rowText(pa, skip)) skip++;
   for (let h = 1; h <= 2 && !skip; h++) {
+    head = h;
     while (skip < Math.min(3, curr.rows - 1, prev.rows - h) && hasText(rowText(ca, skip)) && rowText(ca, skip) === rowText(pa, h + skip)) skip++;
   }
+  const sameSpans = (u, d) => {
+    if (u.length !== d.length || !u.length) return false;
+    const shift = pcx[u[u.length - 1].c + u[u.length - 1].cs] - ccx[d[d.length - 1].c + d[d.length - 1].cs];
+    return u.every((a, n) => Math.abs(pcx[a.c] - ccx[d[n].c] - shift) <= CONTINUATION_COL_TOL && Math.abs(pcx[a.c + a.cs] - ccx[d[n].c + d[n].cs] - shift) <= CONTINUATION_COL_TOL);
+  };
+  for (let k = 0; k < skip; k++) {
+    if (sameSpans(pa.filter((a) => a.r === head + k), ca.filter((a) => a.r === k))) continue;
+    if (hasText(rowText(ca, k))) return null;
+    skip = k;
+  }
   const rows = prev.rows + curr.rows - skip;
   const grid = Array.from({ length: rows }, () => Array.from({ length: cols }, () => ({ text: "", colSpan: 1, rowSpan: 1 })));
   const owner = Array.from({ length: rows }, () => new Array(cols).fill(null));
+  let edged = false;
   const place = (a, x, rowOff, shift = 0) => {
     const c1 = indexOf(U, x[a.c]), c2 = indexOf(U, x[a.c + a.cs]);
     if (c1 < 0 || c2 <= c1) return false;
@@ -733,12 +769,17 @@ function joinSplitParts(prev, pcx, curr, ccx, dx = 0, prevBottom, lex) {
     const lines = CELL_LINES.get(a.cell);
     if (lines) CELL_LINES.set(grid[r][c1], shift ? lines.map((l) => ({ ...l, l: l.l + shift, r: l.r + shift })) : lines);
     if (IMAGE_CELLS.has(a.cell)) IMAGE_CELLS.add(grid[r][c1]);
+    const edges = CELL_EDGES.get(a.cell);
+    if (edges) {
+      CELL_EDGES.set(grid[r][c1], edges);
+      edged = true;
+    }
     return true;
   };
   for (const a of pa) if (!FILLER_CELLS.has(a.cell) && !place(a, pcx, 0)) return null;
   for (const a of ca) {
     if (a.r < skip || FILLER_CELLS.has(a.cell)) continue;
-    if (!place(a, ccx, prev.rows - skip, dx)) return null;
+    if (!place(a, cxU, prev.rows - skip, dx)) return null;
   }
   const first = prev.rows;
   for (let c = 0; c < cols; c++) {
@@ -762,12 +803,32 @@ function joinSplitParts(prev, pcx, curr, ccx, dx = 0, prevBottom, lex) {
     for (let rr = above.r; rr < above.r + newRs; rr++) for (let dc = above.c; dc < above.c + above.cs; dc++) owner[rr][dc] = grown;
   }
   for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) if (owner[r][c] === null) FILLER_CELLS.add(grid[r][c]);
+  if (edged) {
+    for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) if (owner[r][c] === null) CELL_EDGES.set(grid[r][c], NO_EDGES);
+  }
+  for (let c = 0; c < cols && U[c + 1] <= pcx[0] + PART_COL_TOL; c++) {
+    let r = prev.rows;
+    while (r < rows && owner[r][c] === null) r++;
+    const through = { r: 0, c, rs: r, cs: 1, cell: grid[0][c] };
+    for (let rr = 0; rr < r; rr++) owner[rr][c] = through;
+  }
   const table = { rows, cols, cells: grid, hasHeader: prev.hasHeader, ...prev.caption ? { caption: prev.caption } : {} };
-  let split = rows > prev.rows && mergeSplitRow(table, owner, prev.rows, U);
-  if (rows > prev.rows && !split && prevBottom !== void 0 && mergeStraddlingCells(table, owner, prev.rows, prevBottom, lex)) split = mergeSplitRow(table, owner, prev.rows, U, true);
+  const pr = ROW_RULES.get(prev), cr = ROW_RULES.get(curr);
+  const shifted = dx !== 0;
+  const cut = {
+    open: !!pr && !!cr && !pr.bottom && !cr.top && pr.innerOpen + cr.innerOpen === 0 && pr.innerRuled + cr.innerRuled > 0,
+    ruled: !!pr && !!cr && pr.bottom && cr.top,
+    list: !shifted ? "any" : skip > 0 && ca.filter((a) => a.r < skip && a.cell.text.trim()).length < 2 ? "none" : "multi"
+  };
+  let split = rows > prev.rows && mergeSplitRow(table, owner, prev.rows, U, false, cut);
+  if (rows > prev.rows && !split && prevBottom !== void 0 && mergeStraddlingCells(table, owner, prev.rows, prevBottom, lex, U)) split = mergeSplitRow(table, owner, prev.rows, U, true, { ...cut, open: false });
+  if (pr && cr) {
+    const cutRuled = pr.bottom || cr.top;
+    ROW_RULES.set(table, { top: pr.top, bottom: cr.bottom, innerRuled: pr.innerRuled + cr.innerRuled + (!split && cutRuled ? 1 : 0), innerOpen: pr.innerOpen + cr.innerOpen + (!split && !cutRuled ? 1 : 0) });
+  }
   return { table, colXs: U, split, header: ca.filter((a) => a.r < skip && a.cell.text.trim()).length >= 2 };
 }
-function mergeStraddlingCells(table, owner, first, prevBottom, lex) {
+function mergeStraddlingCells(table, owner, first, prevBottom, lex, colXs) {
   const last = first - 1;
   const straddles = owner[first].some((o, c) => o !== null && o === owner[last][c]);
   let firstNew = table.cols;
@@ -791,6 +852,19 @@ function mergeStraddlingCells(table, owner, first, prevBottom, lex) {
     const tail = table.cells[u.r][u.c].text.trim().split(/\s+/).pop() ?? "", head = table.cells[first][d.c].text.trim().split(/\s+/)[0] ?? "";
     if (/^[가-힣]{2,}$/.test(tail) && /^[가-힣]{2,}/.test(head) && lex.evidence2(tail, head) === "") midWord = true;
   }
+  const crossed = /* @__PURE__ */ new Set();
+  const shape = (u, d) => `${u.r}:${u.rs}:${d.rs}`;
+  if (straddles && colXs) for (let c = 0; c < table.cols; ) {
+    const u = owner[last][c], d = owner[first][c];
+    if (!u) {
+      c++;
+      continue;
+    }
+    c = u.c + u.cs;
+    if (!d || d === u || u.r + u.rs - 1 !== last || d.r !== first || d.c !== u.c || d.cs !== u.cs || u.rs < 2) continue;
+    const a = table.cells[u.r][u.c], b = table.cells[first][d.c];
+    if (hasContent(a) && hasContent(b) && continuesAcross(a, b, colXs[u.c], colXs[u.c + u.cs])) crossed.add(shape(u, d));
+  }
   let merged = false;
   for (let c = 0; c < table.cols; ) {
     const u = owner[last][c], d = owner[first][c];
@@ -801,13 +875,16 @@ function mergeStraddlingCells(table, owner, first, prevBottom, lex) {
     c = u.c + u.cs;
     if (!d || d === u || u.r + u.rs - 1 !== last || d.r !== first || d.c !== u.c || d.cs !== u.cs) continue;
     const a = table.cells[u.r][u.c], b = table.cells[first][d.c];
-    if (!(u.rs >= 2 && u.c + u.cs <= firstNew && hasContent(a) && !hasContent(b))) {
+    if (!crossed.has(shape(u, d)) && !(u.rs >= 2 && u.c + u.cs <= firstNew && hasContent(a) && !hasContent(b))) {
       if (!straddles && !midWord) continue;
       if (u.r >= last && d.rs < 2) continue;
       const U = CELL_LINES.get(a);
-      if (!U?.length || U.length > STRADDLE_MAX_LINES || !hasContent(b)) continue;
-      const lu = U[U.length - 1];
-      if (!midWord && lu.y - prevBottom > (u.r >= last ? STRADDLE_BOTTOM_ONE_ROW : STRADDLE_BOTTOM) * (lu.h || 10)) continue;
+      if (!U?.length || !hasContent(b)) continue;
+      if (!(straddles && filledToBottom(U, prevBottom) && clauseContinues(a, b))) {
+        if (U.length > STRADDLE_MAX_LINES) continue;
+        const lu = U[U.length - 1];
+        if (!midWord && lu.y - prevBottom > (u.r >= last ? STRADDLE_BOTTOM_ONE_ROW : STRADDLE_BOTTOM) * (lu.h || 10)) continue;
+      }
     }
     appendCell(a, b);
     a.rowSpan = first + d.rs - u.r;
@@ -818,6 +895,11 @@ function mergeStraddlingCells(table, owner, first, prevBottom, lex) {
   }
   return merged;
 }
+function filledToBottom(U, bottom) {
+  if (U.length < 2) return false;
+  const lu = U[U.length - 1];
+  return lu.y - bottom < (U[0].y - lu.y) / (U.length - 1) + FILL_SLACK * (lu.h || 10);
+}
 var FULL_LINE_TOL = 1;
 var FULL_LINE_MIN_FRAC = 0.5;
 var FULL_LINE_EDGE_MIN = 12;
@@ -826,6 +908,7 @@ var SHORT_LINE_GAP = 1.5;
 var STRADDLE_MAX_LINES = 3;
 var STRADDLE_BOTTOM = 1.2;
 var STRADDLE_BOTTOM_ONE_ROW = 0.55;
+var FILL_SLACK = 0.5;
 var CARRIED_MIN_COL_W = 4;
 var LABEL_ROOM = 1.5;
 var HANGING_MIN = 0.5;
@@ -847,10 +930,16 @@ function continuesAcross(u, d, x1, x2) {
   maxR = Math.max(maxR, x2 - (minL - x1));
   if (maxR - last.r > FULL_LINE_TOL * fs) return false;
   if (U.length === 1 && x2 - last.r > Math.max(FULL_LINE_EDGE_MIN, SINGLE_LINE_WORD_GAP * fs)) return false;
-  if (last.r - last.l < FULL_LINE_MIN_FRAC * (x2 - x1)) return false;
-  const leftAligned = (l) => l.l - minL <= fs && maxR - l.r > SHORT_LINE_GAP * fs;
-  const hanging = U.length >= 2 && U.every((l) => maxR - l.r <= FULL_LINE_TOL * fs) && last.l - minL >= HANGING_MIN * fs && Math.abs(D[0].l - last.l) <= HANGING_TOL;
-  return U.some(leftAligned) || D.some(leftAligned) || hanging;
+  const indented = last.l - minL >= HANGING_MIN * fs;
+  if (last.r - last.l < FULL_LINE_MIN_FRAC * (indented ? x2 - last.l : x2 - x1)) return false;
+  const newItem = startsNewItem(u.text, d.text);
+  const all = D.length ? U.concat(D) : U;
+  const leftAligned = (l) => maxR - l.r > SHORT_LINE_GAP * fs && (l.l - minL <= fs || !newItem && all.some((o) => o !== l && Math.abs(o.l - l.l) <= HANGING_TOL && Math.abs(o.r - l.r) >= HANGING_MIN * fs));
+  const hanging = U.length >= 2 && U.every((l) => maxR - l.r <= FULL_LINE_TOL * fs) && indented && Math.abs(D[0].l - last.l) <= HANGING_TOL;
+  const hangingHead = !indented && D.length >= 2 && D[0].l - last.l >= HANGING_MIN * fs && maxR - D[0].r <= FULL_LINE_TOL * fs && D.every((l) => Math.abs(l.l - D[0].l) <= HANGING_TOL);
+  const d0 = D[0];
+  const hangStart = U.length === 1 && !newItem && d0.l - last.l >= HANGING_MIN * fs && D.every((l) => l.l >= d0.l - HANGING_TOL) && (Math.abs(d0.r - last.r) <= HANGING_TOL && d0.r - d0.l >= FULL_LINE_MIN_FRAC * (x2 - x1) || last.r - d0.r > SHORT_LINE_GAP * fs && Math.abs(d0.l + d0.r - last.l - last.r) / 2 >= HANGING_MIN * fs);
+  return U.some(leftAligned) || D.some(leftAligned) || hanging || hangingHead || hangStart;
 }
 var OUTLINE_HEAD = /^[□■]\s*\S/;
 var OUTLINE_ITEM = /^[ㅇ○◦\-‐–·․‧※*]\s*\S/;
@@ -859,14 +948,19 @@ function outlineContinues(u, d) {
   const D = d.text.split("\n").map((l) => l.trim()).filter(Boolean);
   return U.length >= 2 && D.length >= 1 && U.some((l) => OUTLINE_HEAD.test(l)) && OUTLINE_ITEM.test(D[0]);
 }
-function lineEnded(c, x1, x2, next = "") {
+function lineEnded(c, x1, x2, next) {
   const L = CELL_LINES.get(c);
   if (!L || L.length !== 1) return false;
   const l = L[0], h = l.h || 10;
-  const word = next.trim().split(/\s+/)[0] ?? "";
+  const d0 = next ? CELL_LINES.get(next)?.[0] : void 0;
+  if (d0 && d0.l - l.l >= HANGING_MIN * h) return false;
+  return x2 - l.r - (l.l - x1) >= Math.max(LABEL_ROOM, firstWordUnits(next?.text ?? "")) * h;
+}
+function firstWordUnits(text) {
+  const word = text.trim().replace(/^([(\[「『<〈])\s+/, "$1").split(/\s+/)[0] ?? "";
   let units = 0;
   for (const ch of word) units += /[가-힣\u3400-\u9fff]/.test(ch) ? 1 : 0.55;
-  return x2 - l.r - (l.l - x1) >= Math.max(LABEL_ROOM, units) * h;
+  return units;
 }
 function appendCell(a, b) {
   if (a.blocks?.length || b.blocks?.length) {
@@ -874,6 +968,7 @@ function appendCell(a, b) {
     a.blocks = [...asBlocks(a), ...asBlocks(b)];
   }
   if (b.text.trim()) a.text = a.text.trim() ? a.text + "\n" + b.text : b.text;
+  joinCellEdges(a, b);
 }
 var hasContent = (cell) => !!cell.text.trim() || !!cell.blocks?.length || IMAGE_CELLS.has(cell);
 var CLAUSE_OPEN_ENDING = /(?:하는|되는|하고|하며|하여|되어|되고|되며|이며|으며|어야|아야|여야)$/;
@@ -887,11 +982,42 @@ function clauseContinues(u, d) {
   const last = tail[tail.length - 1], before = tail[tail.length - 2];
   return last === "\uC744" && batchim(before) || last === "\uB97C" && !batchim(before) || CLAUSE_OPEN_ENDING.test(tail);
 }
+function wordOverflows(u, d, x1, x2) {
+  const U = CELL_LINES.get(u);
+  if (!U?.length || startsNewItem(u.text, d.text)) return false;
+  const last = U[U.length - 1], units = firstWordUnits(d.text);
+  return units > 0 && last.r - last.l + units * (last.h || 10) > x2 - x1;
+}
+var KO_ORDER = "\uAC00\uB098\uB2E4\uB77C\uB9C8\uBC14\uC0AC\uC544\uC790\uCC28\uCE74\uD0C0\uD30C\uD558";
+function itemMark(line) {
+  let m = /^(\d{1,2})([.)])(?!\d)/.exec(line);
+  if (m) return { style: "1" + m[2], n: +m[1] };
+  if (m = /^\((\d{1,2})\)/.exec(line)) return { style: "(1)", n: +m[1] };
+  if ((m = /^([가-하])([.)])/.exec(line)) && KO_ORDER.includes(m[1])) return { style: "\uAC00" + m[2], n: KO_ORDER.indexOf(m[1]) };
+  if ((m = /^\(([가-하])\)/.exec(line)) && KO_ORDER.includes(m[1])) return { style: "(\uAC00)", n: KO_ORDER.indexOf(m[1]) };
+  if (m = /^[①-⑳]/.exec(line)) return { style: "\u2460", n: m[0].charCodeAt(0) };
+  if (m = /^([A-Z])\.\s/.exec(line)) return { style: "A.", n: m[1].charCodeAt(0) };
+  return null;
+}
+function listContinues(u, d, multi = false) {
+  const head = itemMark(d.text.trim());
+  if (!head) return false;
+  const marks = u.text.split("\n").map((l) => itemMark(l.trim()));
+  let last = -1, count = 0;
+  marks.forEach((m, i) => {
+    if (m?.style === head.style) {
+      last = i;
+      count++;
+    }
+  });
+  return last >= 0 && marks[last].n + 1 === head.n && (count >= 2 || !multi && last > 0);
+}
 function outlineOnly(pairs, cell) {
   const filled = pairs.filter(([, d]) => hasContent(d.cell));
   return filled.length === 1 && outlineContinues(cell(filled[0][0]), cell(filled[0][1]));
 }
-function mergeSplitRow(table, owner, first, colXs, textOnly = false) {
+var NO_CUT = { open: false, ruled: false, list: "any" };
+function mergeSplitRow(table, owner, first, colXs, textOnly = false, cut = NO_CUT) {
   const last = first - 1;
   const pairs = [];
   let carried = false;
@@ -904,19 +1030,30 @@ function mergeSplitRow(table, owner, first, colXs, textOnly = false) {
     }
     if (!a || !b) return false;
     if (a !== b) {
-      if (a.c !== b.c || a.cs !== b.cs || a.r + a.rs - 1 !== last || b.r !== first || b.rs !== 1) return false;
+      if (a.c !== b.c || a.cs !== b.cs || a.r + a.rs - 1 !== last || b.r !== first) return false;
+      if (b.rs > 1 && (a.rs > 1 || !hasContent(a.cell))) return false;
       pairs.push([a, b]);
     } else if (a.r === last && a.rs === 2) carried = true;
     c = a.c + a.cs;
   }
-  const carriedSplit = !textOnly && carried && pairs.filter(([u, d]) => hasContent(u.cell) && hasContent(d.cell)).length <= 1 && !pairs.some(([u, d]) => !hasContent(u.cell) && hasContent(d.cell));
+  const newCell = pairs.some(([u, d]) => !hasContent(u.cell) && hasContent(d.cell));
   const cell = (a) => table.cells[a.r][a.c];
+  const contentPairs = pairs.filter(([u, d]) => hasContent(u.cell) && hasContent(d.cell));
+  const carriedSplit = !textOnly && carried && !newCell && (contentPairs.length <= 1 || contentPairs.every(([, d]) => d.rs > 1) || !cut.ruled && contentPairs.some(([u, d]) => wordOverflows(cell(u), cell(d), colXs[u.c], colXs[u.c + u.cs])));
   if (!carriedSplit) {
     const norm = (c) => c.text.replace(/\s+/g, "");
-    if (pairs.some(([u, d]) => hasContent(d.cell) && norm(cell(d)) !== norm(cell(u)) && lineEnded(cell(u), colXs[u.c], colXs[u.c + u.cs], cell(d).text))) return false;
-    if (!outlineOnly(pairs, cell) && !pairs.some(([u, d]) => continuesAcross(cell(u), cell(d), colXs[u.c], colXs[u.c + u.cs])) && !pairs.some(([u, d]) => clauseContinues(cell(u), cell(d)))) return false;
+    if (pairs.some(([u, d]) => hasContent(d.cell) && norm(cell(d)) !== norm(cell(u)) && lineEnded(cell(u), colXs[u.c], colXs[u.c + u.cs], cell(d)))) return false;
+    const flows = ([u, d]) => continuesAcross(cell(u), cell(d), colXs[u.c], colXs[u.c + u.cs]) || clauseContinues(cell(u), cell(d));
+    if (!(cut.open && !newCell)) {
+      if (pairs.some((p) => p[1].rs > 1 && !flows(p))) return false;
+      const one = pairs.filter(([, d]) => d.rs === 1);
+      if (!outlineOnly(pairs, cell) && !one.some(flows) && (cut.list === "none" || !one.some(([u, d]) => listContinues(cell(u), cell(d), cut.list === "multi")))) return false;
+    }
+  }
+  for (const [u, d] of pairs) {
+    appendCell(table.cells[u.r][u.c], table.cells[d.r][d.c]);
+    if (d.rs > 1) table.cells[u.r][u.c].rowSpan = u.rs + d.rs;
   }
-  for (const [u, d] of pairs) appendCell(table.cells[u.r][u.c], table.cells[d.r][d.c]);
   for (let r = 0; r < first; r++) for (let c = 0; c < table.cols; c++) {
     const o = owner[r][c];
     if (o && o.r === r && o.c === c && r + table.cells[r][c].rowSpan > first) table.cells[r][c].rowSpan--;
@@ -964,11 +1101,14 @@ function sameHeadShape(a, b) {
 function mergeCrossPageTables(blocks, pageHeights, lex) {
   mergeColumnFlow(blocks, pageHeights, lex);
   for (let i = blocks.length - 2; i >= 0; i--) {
-    const prev = blocks[i];
-    if (prev.type !== "table" || !prev.table || !prev.bbox || !prev.pageNumber) continue;
+    const tail = tailOf(blocks[i]);
+    if (tail.type !== "table" || !tail.table || !tail.bbox || !tail.pageNumber) continue;
     let j = i + 1;
-    while (j < blocks.length && (blocks[j].type !== "table" || insideTable(blocks[j], prev) || leftColumnOf(blocks[j], prev)) && (blocks[j].pageNumber ?? 0) <= prev.pageNumber + 1) j++;
+    const skip = (b) => b.type !== "table" || [blocks[i], tail].some((t) => insideTable(b, t) || leftColumnOf(b, t));
+    while (j < blocks.length && skip(blocks[j]) && (blocks[j].pageNumber ?? 0) <= tail.pageNumber + 1) j++;
     const curr = blocks[j];
+    const prev = tail !== blocks[i] && curr?.pageNumber === tail.pageNumber ? blocks[i] : tail;
+    if (!prev.table || !prev.bbox || !prev.pageNumber) continue;
     if (!curr || curr.type !== "table" || !curr.table || !curr.bbox || curr.pageNumber !== prev.pageNumber + 1) continue;
     if (startsWithUnitRow(prev.table) && startsWithUnitRow(curr.table)) continue;
     const joined = j === i + 1 || blocks.slice(i + 1, j).every((b) => besideOwn(b, prev, curr) || insideTable(b, prev)) ? looksContinued(prev, curr, pageHeights) && !restartsTable(blocks, i, curr.table, pageHeights) ? joinClipParts(prev, curr, pageHeights, lex) ?? false : null : null;
@@ -1051,24 +1191,36 @@ function joinClipParts(prev, curr, pageHeights, lex) {
   if (!CLIP_TABLES.has(pt) || !CLIP_TABLES.has(ct)) return null;
   const px = TABLE_COLXS.get(pt), cx = TABLE_COLXS.get(ct);
   if (!px || !cx) return null;
-  let xs = cx, shifted = false, dx = 0, foreign = false;
+  let xs = cx, shifted = false, dx = 0, foreign = false, within = false;
   if (!shiftedSame(px, cx, false)) {
     if (!pageHeights?.get(prev.pageNumber) || !pageHeights?.get(curr.pageNumber)) return null;
     dx = px[px.length - 1] - cx[cx.length - 1];
-    if (Math.abs(dx) > CONTINUATION_COL_TOL) {
+    within = Math.abs(dx) > CONTINUATION_COL_TOL && cx.length >= 3 && cx.every((x) => px.some((p) => Math.abs(p - x) <= CONTINUATION_COL_TOL));
+    if (Math.abs(dx) > CONTINUATION_COL_TOL && !within) {
       xs = cx.map((x) => x + dx);
       shifted = true;
     } else dx = 0;
-    if (!px.some((x) => Math.abs(x - xs[0]) <= CONTINUATION_COL_TOL)) return null;
-    const inner = xs.slice(1, -1);
-    foreign = inner.length > 0 && !inner.some((x) => px.some((p) => Math.abs(p - x) <= CONTINUATION_COL_TOL)) && headingRow(ct.cells[0] ?? []);
+    if (!px.some((x) => Math.abs(x - xs[0]) <= CONTINUATION_COL_TOL) && !prevLacksLeftCols(prev, px, xs, pageHeights)) return null;
+    const unrelated = (b) => {
+      const inner = b.slice(1, -1).map((x) => x + dx);
+      return inner.length > 0 && !inner.some((x) => px.some((p) => Math.abs(p - x) <= CONTINUATION_COL_TOL));
+    };
+    foreign = unrelated(cx) && unrelated(PART_COLXS.get(ct) ?? cx) && (headingRow(ct.cells[0] ?? []) || px.length > FOREIGN_FIRST_ROW_CELLS && anchorsOf(ct).filter((a) => a.r === 0).length >= FOREIGN_FIRST_ROW_CELLS);
   }
   const res = joinSplitParts(pt, px, ct, xs, dx, prev.bbox?.y, lex);
-  if (!res || (shifted || foreign) && !res.split && !res.header) return null;
+  if (!res || (shifted || foreign || within) && !res.split && !res.header) return null;
   TABLE_COLXS.set(res.table, res.colXs);
+  const ys = TABLE_ROWYS.get(pt);
+  if (ys) TABLE_ROWYS.set(res.table, ys);
+  PART_COLXS.set(res.table, PART_COLXS.get(pt) ?? px);
   CLIP_TABLES.add(res.table);
   return res.table;
 }
+function prevLacksLeftCols(prev, px, xs, pageHeights) {
+  const ph = pageHeights?.get(prev.pageNumber);
+  if (!ph || prev.bbox.y + prev.bbox.height < ph * (1 - PAGE_EDGE_BAND)) return false;
+  return xs[0] < px[0] && xs.slice(1, -1).some((x) => Math.abs(x - px[0]) <= CONTINUATION_COL_TOL);
+}
 function headingRow(row) {
   const heads = row.map((c) => c.text.replace(/\s+/g, "")).filter(Boolean);
   if (heads.length === 1) return heads[0].length <= 8 || /^[①-⑳❶-❿]/.test(heads[0]);
@@ -1077,13 +1229,36 @@ function headingRow(row) {
 var ANNEX_HEAD_RE = /^\s*[<\[(【]?\s*(?:붙\s*임|참\s*고|별\s*첨|별\s*지|별\s*표|첨\s*부|부\s*록)(?:\s*\d|\s*$|\s*[>\])】])|^\s*■/;
 function looksContinued(prev, curr, pageHeights) {
   const ph = pageHeights?.get(prev.pageNumber), ch = pageHeights?.get(curr.pageNumber);
-  if (ph && ch && (prev.bbox.y > ph * PAGE_EDGE_BAND || curr.bbox.y + curr.bbox.height < ch * (1 - PAGE_EDGE_BAND))) return false;
+  if (ph && ch && (prev.bbox.y > ph * PAGE_EDGE_BAND && !pushedLead(prev, curr) || curr.bbox.y + curr.bbox.height < ch * (1 - PAGE_EDGE_BAND))) return false;
   const firstRow = curr.table.cells[0] ?? [];
   const firstText = firstRow.find((c) => c.text.trim())?.text ?? "";
   if (!ANNEX_HEAD_RE.test(firstText)) return true;
   const filled = firstRow.map((c) => c.text.replace(/\s+/g, "")).filter(Boolean);
   return filled.length >= 2 && filled.every((t) => t === filled[0]);
 }
+function pushedLead(prev, curr) {
+  if (!CLIP_TABLES.has(prev.table) || !CLIP_TABLES.has(curr.table)) return false;
+  const lead = leadRows(curr.table);
+  return lead.image && lead.height > prev.bbox.y;
+}
+function leadRows(t) {
+  const ys = TABLE_ROWYS.get(t);
+  if (!ys || ys.length < 2) return { height: 0, image: false };
+  const anchors = anchorsOf(t);
+  let end = 1, image = false;
+  for (let r = 0; r < end; r++) {
+    for (const a of anchors) {
+      if (a.r !== r) continue;
+      end = Math.max(end, r + a.rs);
+      if (IMAGE_CELLS.has(a.cell)) image = true;
+    }
+  }
+  return { height: ys[0] - ys[Math.min(end, ys.length - 1)], image };
+}
+function tailOf(b) {
+  const t = b.table && TABLE_TAIL.get(b.table);
+  return t && b.bbox ? { ...b, pageNumber: t.page, bbox: { ...b.bbox, page: t.page, y: t.y, height: t.height } } : b;
+}
 function firstRowSig(t) {
   const x = TABLE_COLXS.get(t);
   if (!x || x.length !== t.cols + 1) return null;
@@ -1134,14 +1309,14 @@ function chainHead(blocks, i, pageHeights) {
         break;
       }
     }
-    const pb = blocks[p];
+    const pb = tailOf(blocks[p]);
     if (pb.pageNumber !== (cur.pageNumber ?? 0) - 1) break;
     if (!blocks.slice(p + 1, k).every((b) => besideOwn(b, pb, cur) || insideTable(b, pb))) break;
     if (!looksContinued(pb, cur, pageHeights)) break;
     const px = TABLE_COLXS.get(pb.table), cx = TABLE_COLXS.get(cur.table);
     if (!px || !cx) break;
     const dx = px[px.length - 1] - cx[cx.length - 1];
-    if (!shiftedSame(px, cx) && !px.some((x) => Math.abs(x - (cx[0] + dx)) <= CONTINUATION_COL_TOL)) break;
+    if (!shiftedSame(px, cx) && !px.some((x) => Math.abs(x - (cx[0] + dx)) <= CONTINUATION_COL_TOL) && !prevLacksLeftCols(pb, px, cx, pageHeights)) break;
     k = p;
   }
   return k;
@@ -1155,6 +1330,7 @@ function rowTextsEqual(a, b) {
   return a.some((c) => c.text.trim() !== "");
 }
 var CONTINUATION_COL_TOL = 2;
+var FOREIGN_FIRST_ROW_CELLS = 3;
 function shiftedSame(px, cx, allowShift = true) {
   if (px.length !== cx.length) return false;
   const dx = allowShift ? px[px.length - 1] - cx[cx.length - 1] : 0;
@@ -1199,6 +1375,10 @@ function mergeContinuedCells(blocks, pageHeights) {
     const at = cell.blocks || add.blocks ? cellBlocks(cell, prev.pageNumber).length : -1;
     if (cell.blocks || add.blocks) cell.blocks = [...cellBlocks(cell, prev.pageNumber), ...cellBlocks(add, part.pageNumber)];
     cell.text = [cell.text, add.text].filter((s) => s.trim()).join("\n");
+    joinCellEdges(cell, add);
+    const lines = CELL_LINES.get(add);
+    if (lines?.length) CELL_LINES.set(cell, [...CELL_LINES.get(cell) ?? [], ...lines]);
+    if (part.pageNumber && part.bbox) TABLE_TAIL.set(prev.table, TABLE_TAIL.get(part.table) ?? { page: part.pageNumber, y: part.bbox.y, height: part.bbox.height });
     if (cell.text.trim() || cell.blocks?.length) EMPTY_PARTS.delete(prev.table);
     blocks.splice(j, 1);
     if (cell.blocks && at > 0) {
@@ -1231,6 +1411,7 @@ function fillNestedContinuation(blocks, at) {
   if (!cell || !add || cell.text.trim() || cell.blocks?.length) return;
   cell.text = add.text;
   if (add.blocks) cell.blocks = add.blocks;
+  joinCellEdges(cell, add);
   blocks.splice(at, 1);
 }
 
@@ -2507,7 +2688,7 @@ function mergeLinkRuns(markdown) {
 
 // src/pdf/formula-ocr.ts
 async function applyFormulaOcr(buffer, blocks, pageFilter, effectivePageCount, warnings, _onProgress) {
-  const formulaMod = await import("./formula-EPKLPDU7.js");
+  const formulaMod = await import("./formula-SHBXRXOJ.js");
   const { FormulaPipeline, ensureFormulaModels } = formulaMod;
   await ensureFormulaModels((p) => {
     if (p.phase === "download" && p.total) {
@@ -2890,7 +3071,7 @@ async function parsePdfDocument(buffer, options) {
       }
       if (targets.size > 0) {
         try {
-          const { runPdfOcr } = await import("./pdf-ocr-6DEE23IP.js");
+          const { runPdfOcr } = await import("./pdf-ocr-462ZFSHX.js");
           const mode = typeof options?.ocr === "function" ? options.ocr : "builtin";
           const regionPages = new Map([...ocrRegions].filter(([p]) => options?.ocr !== "force" && !isImageBased && !pageQuality.find((q) => q.page === p)?.needsOcr));
           const ocrPageBlocks = await runPdfOcr(ocrBuffer, targets, mode, warnings, options?.onProgress, options?.tables !== false, vectorPageOps, regionPages);
@@ -3015,6 +3196,28 @@ async function parsePdfDocument(buffer, options) {
       return b.bbox.y > h * 0.1 && b.bbox.y + b.bbox.height < h * 0.9;
     });
     joinLatinCellWraps(outBlocks);
+    if (options?.layoutTables !== "keep" && await isHancomPdf(doc)) {
+      const shown = /* @__PURE__ */ new Map();
+      const markContent = (bs) => {
+        for (const b of bs ?? []) if (b.table) for (const row of b.table.cells) for (const c of row) {
+          if (IMAGE_CELLS.has(c)) CONTENT_CELLS.add(c);
+          markContent(c.blocks);
+        }
+      };
+      const visual = (bs) => bs.flatMap((b) => {
+        if (b.type !== "table") return [b];
+        let v = shown.get(b);
+        if (!v) {
+          markContent([b]);
+          shown.set(b, v = unframeLayoutTables([b], !!options?.keepTrailingEmptyCols));
+        }
+        return v;
+      });
+      outBlocks = visual(outBlocks);
+      const kept = visual(blocks);
+      blocks.length = 0;
+      for (const b of kept) blocks.push(b);
+    }
     const finishMarkdown = (bs) => mergeLinkRuns(cleanPdfText(blocksToMarkdown(bs), { keepLoneNumbers: true }));
     let markdown = finishMarkdown(outBlocks);
     return {
@@ -3051,6 +3254,14 @@ async function extractPdfMetadata(doc, metadata) {
   } catch {
   }
 }
+async function isHancomPdf(doc) {
+  try {
+    const info = (await doc.getMetadata())?.info;
+    return [info?.Producer, info?.Creator].some((v) => typeof v === "string" && /^\s*(?:hancom\b|hwp\b)/i.test(v));
+  } catch {
+    return false;
+  }
+}
 function parsePdfDate(dateStr) {
   const m = dateStr.match(/D:(\d{4})(\d{2})?(\d{2})?(\d{2})?(\d{2})?(\d{2})?/);
   if (!m) return void 0;
@@ -3090,4 +3301,4 @@ export {
   parsePdfDocument,
   removeHeaderFooterBlocks
 };
-//# sourceMappingURL=parser-ZQM3664Z.js.map
+//# sourceMappingURL=parser-CTRB7PKD.js.map