kordoc 4.14.3 → 4.14.4

package/dist/{parser-RANGXGBD.cjs → parser-HVEKF73B.cjs}

@@ -2,7 +2,8 @@
 
 
 
-var _chunkEBZUZC6Fcjs = require('./chunk-EBZUZC6F.cjs');
+
+var _chunk5LAZQCUJcjs = require('./chunk-5LAZQCUJ.cjs');
 
 
 var _chunkDCZVOIEOcjs = require('./chunk-DCZVOIEO.cjs');
@@ -25,12 +26,15 @@ var _chunkDCZVOIEOcjs = require('./chunk-DCZVOIEO.cjs');
 
 
 
-var _chunkNOAQRCV6cjs = require('./chunk-NOAQRCV6.cjs');
-require('./chunk-HX4UUF7Y.cjs');
 
 
 
-var _chunkEMGF6EEVcjs = require('./chunk-EMGF6EEV.cjs');
+var _chunkUSHQCF5Tcjs = require('./chunk-USHQCF5T.cjs');
+require('./chunk-VWUYVEFN.cjs');
+
+
+
+var _chunkWJHAU73Bcjs = require('./chunk-WJHAU73B.cjs');
 
 
 var _chunkGS7T56RPcjs = require('./chunk-GS7T56RP.cjs');
@@ -160,7 +164,7 @@ async function extractPageImages(page, fnArray, argsArray, pageNumber, state, wa
     const filename = `image_${String(state.imageIndex).padStart(3, "0")}.png`;
     state.seen.set(hash, filename);
     if (withBytes) {
-      const png = _chunkEBZUZC6Fcjs.encodePng.call(void 0, w, h, rgba);
+      const png = _chunk5LAZQCUJcjs.encodePng.call(void 0, w, h, rgba);
       state.totalBytes += png.length;
       images.push({ filename, data: png, mimeType: "image/png" });
     }
@@ -208,7 +212,9 @@ var RARE_JONG = /* @__PURE__ */ new Set([3, 5, 6, 9, 10, 11, 12, 13, 14, 15, 18,
 var MOJIBAKE_MIN_HANGUL = 30;
 var MOJIBAKE_MAX_NOBATCHIM = 0.15;
 var MOJIBAKE_MIN_RAREBATCHIM = 0.25;
-function computePageQuality(page, text) {
+var VECTOR_TEXT_MIN_GLYPHS = 40;
+var VECTOR_TEXT_MIN_SHARE = 0.25;
+function computePageQuality(page, text, vectorGlyphs = 0) {
   let total = 0;
   let hangul = 0;
   let hangulNoBatchim = 0;
@@ -249,7 +255,10 @@ function computePageQuality(page, text) {
   const garbledHangul = hangul >= MOJIBAKE_MIN_HANGUL && hangulNoBatchimRatio < MOJIBAKE_MAX_NOBATCHIM && hangulRareBatchimRatio >= MOJIBAKE_MIN_RAREBATCHIM;
   let needsOcr = false;
   let ocrReason;
-  if (total < LOW_TEXT_THRESHOLD) {
+  if (vectorGlyphs >= VECTOR_TEXT_MIN_GLYPHS && vectorGlyphs >= (vectorGlyphs + total) * VECTOR_TEXT_MIN_SHARE) {
+    needsOcr = true;
+    ocrReason = "vector_text";
+  } else if (total < LOW_TEXT_THRESHOLD) {
     needsOcr = true;
     ocrReason = "low_text";
   } else if (puaRatio >= HIGH_PUA_THRESHOLD) {
@@ -334,6 +343,221 @@ function summarizeDocumentQuality(pages) {
   };
 }
 
+// src/pdf/vector-glyphs.ts
+
+var GLYPH_MIN_H = 3;
+var GLYPH_MAX_H = 40;
+var GLYPH_MAX_ASPECT = 2;
+var GLYPH_MIN_SEGS = 8;
+var GLYPH_MIN_SUBS = 2;
+var RUN_GAP_EM = 1.5;
+var RUN_MIN = 3;
+var RUN_ALIGN_EM = 0.05;
+var RUN_MAX_OVERLAP = 0.2;
+var RUN_MIN_COLOR = 0.9;
+var RUN_MIN_SHAPES = 0.5;
+var mul = (m, t) => [
+  m[0] * t[0] + m[2] * t[1],
+  m[1] * t[0] + m[3] * t[1],
+  m[0] * t[2] + m[2] * t[3],
+  m[1] * t[2] + m[3] * t[3],
+  m[0] * t[4] + m[2] * t[5] + m[4],
+  m[1] * t[4] + m[3] * t[5] + m[5]
+];
+function collectGlyphPaths(fnArray, argsArray) {
+  const out = [];
+  let ctm = [1, 0, 0, 1, 0, 0];
+  let color = 0;
+  const stack = [];
+  let x1 = Infinity, y1 = Infinity, x2 = -Infinity, y2 = -Infinity;
+  let segs = 0, subs = 0, rects = 0;
+  let ops = [];
+  const add = (x, y) => {
+    const tx = ctm[0] * x + ctm[2] * y + ctm[4], ty = ctm[1] * x + ctm[3] * y + ctm[5];
+    if (tx < x1) x1 = tx;
+    if (tx > x2) x2 = tx;
+    if (ty < y1) y1 = ty;
+    if (ty > y2) y2 = ty;
+  };
+  const reset = () => {
+    x1 = Infinity;
+    y1 = Infinity;
+    x2 = -Infinity;
+    y2 = -Infinity;
+    segs = 0;
+    subs = 0;
+    rects = 0;
+    ops = [];
+  };
+  for (let i = 0; i < fnArray.length; i++) {
+    const op = fnArray[i];
+    const args = argsArray[i];
+    switch (op) {
+      case _pdfmjs.OPS.save:
+        stack.push([ctm, color]);
+        break;
+      case _pdfmjs.OPS.restore:
+        [ctm, color] = _nullishCoalesce(stack.pop(), () => ( [[1, 0, 0, 1, 0, 0], 0]));
+        break;
+      case _pdfmjs.OPS.transform:
+        ctm = mul(ctm, args);
+        break;
+      case _pdfmjs.OPS.paintFormXObjectBegin: {
+        stack.push([ctm, color]);
+        const m = args[0];
+        if (Array.isArray(m) && m.length >= 6) ctm = mul(ctm, m);
+        break;
+      }
+      case _pdfmjs.OPS.paintFormXObjectEnd:
+        [ctm, color] = _nullishCoalesce(stack.pop(), () => ( [[1, 0, 0, 1, 0, 0], 0]));
+        break;
+      case _pdfmjs.OPS.setFillRGBColor: {
+        const c = args;
+        color = c[0] << 16 | c[1] << 8 | c[2];
+        break;
+      }
+      case _pdfmjs.OPS.constructPath: {
+        const [subOps, coords] = args;
+        if (!Array.isArray(subOps) || !Array.isArray(coords)) break;
+        ops.push(i);
+        let ci = 0;
+        for (const s of subOps) {
+          if (s === _pdfmjs.OPS.moveTo) {
+            add(coords[ci], coords[ci + 1]);
+            ci += 2;
+            subs++;
+          } else if (s === _pdfmjs.OPS.lineTo) {
+            add(coords[ci], coords[ci + 1]);
+            ci += 2;
+            segs++;
+          } else if (s === _pdfmjs.OPS.curveTo) {
+            add(coords[ci], coords[ci + 1]);
+            add(coords[ci + 2], coords[ci + 3]);
+            add(coords[ci + 4], coords[ci + 5]);
+            ci += 6;
+            segs++;
+          } else if (s === _pdfmjs.OPS.curveTo2 || s === _pdfmjs.OPS.curveTo3) {
+            add(coords[ci], coords[ci + 1]);
+            add(coords[ci + 2], coords[ci + 3]);
+            ci += 4;
+            segs++;
+          } else if (s === _pdfmjs.OPS.rectangle) {
+            const rx = coords[ci], ry = coords[ci + 1], rw = coords[ci + 2], rh = coords[ci + 3];
+            add(rx, ry);
+            add(rx + rw, ry + rh);
+            add(rx, ry + rh);
+            add(rx + rw, ry);
+            ci += 4;
+            rects++;
+            subs++;
+            segs += 4;
+          }
+        }
+        break;
+      }
+      case _pdfmjs.OPS.fill:
+      case _pdfmjs.OPS.eoFill:
+      case _pdfmjs.OPS.fillStroke:
+      case _pdfmjs.OPS.eoFillStroke:
+      case _pdfmjs.OPS.closeFillStroke:
+      case _pdfmjs.OPS.closeEOFillStroke: {
+        const w = x2 - x1, h = y2 - y1;
+        if (segs > rects * 4 && h >= GLYPH_MIN_H && h <= GLYPH_MAX_H && w <= h * GLYPH_MAX_ASPECT && segs >= GLYPH_MIN_SEGS && subs >= GLYPH_MIN_SUBS) {
+          out.push({ x1, y1, x2, y2, segs, subs, color, ops: [...ops, i] });
+        }
+        reset();
+        break;
+      }
+      case _pdfmjs.OPS.stroke:
+      case _pdfmjs.OPS.closeStroke:
+      case _pdfmjs.OPS.endPath:
+        reset();
+        break;
+    }
+  }
+  return out;
+}
+function coveredByText(b, texts) {
+  const cx = (b.x1 + b.x2) / 2, cy = (b.y1 + b.y2) / 2;
+  for (const t of texts) {
+    if (cx >= t.x - 1 && cx <= t.x + t.w + 1 && cy >= t.y - t.h * 0.3 - 1 && cy <= t.y + t.h + 1 && t.text.trim()) return true;
+  }
+  return false;
+}
+var median = (a) => {
+  const s = a.slice().sort((x, y) => x - y);
+  return s[s.length >> 1];
+};
+var spread = (a) => {
+  const c = median(a);
+  return median(a.map((v) => Math.abs(v - c)));
+};
+function isTextRun(m, em) {
+  if (m.length < RUN_MIN) return false;
+  if (Math.min(spread(m.map((b) => b.y2)), spread(m.map((b) => b.y1))) > em * RUN_ALIGN_EM) return false;
+  let overlaps = 0;
+  for (let i = 1; i < m.length; i++) if (m[i].x1 < m[i - 1].x2 - em * 0.1) overlaps++;
+  if (overlaps > (m.length - 1) * RUN_MAX_OVERLAP) return false;
+  const colors = /* @__PURE__ */ new Map();
+  for (const b of m) colors.set(b.color, (_nullishCoalesce(colors.get(b.color), () => ( 0))) + 1);
+  if (Math.max(...colors.values()) < m.length * RUN_MIN_COLOR) return false;
+  const shapes = new Set(m.map((b) => `${Math.round((b.x2 - b.x1) * 2)}:${Math.round((b.y2 - b.y1) * 2)}:${b.segs}`));
+  return shapes.size >= m.length * RUN_MIN_SHAPES;
+}
+function scanVectorGlyphs(fnArray, argsArray, texts) {
+  const paths = collectGlyphPaths(fnArray, argsArray);
+  if (paths.length < RUN_MIN) return { glyphs: 0, paths };
+  const free = paths.filter((b) => !coveredByText(b, texts));
+  const sorted = free.slice().sort((a, b) => a.y1 + a.y2 - (b.y1 + b.y2));
+  let glyphs = 0;
+  let row = [];
+  let rowCy = 0, rowH = 0;
+  const flushRow = () => {
+    if (row.length < RUN_MIN) return;
+    row.sort((a, b) => a.x1 - b.x1);
+    const em = median(row.map((b) => b.y2 - b.y1));
+    let start = 0, maxX = row[0].x2;
+    for (let i = 1; i <= row.length; i++) {
+      if (i < row.length && row[i].x1 - maxX <= em * RUN_GAP_EM) {
+        if (row[i].x2 > maxX) maxX = row[i].x2;
+        continue;
+      }
+      const run = row.slice(start, i);
+      if (isTextRun(run, em)) glyphs += run.length;
+      if (i < row.length) {
+        start = i;
+        maxX = row[i].x2;
+      }
+    }
+  };
+  for (const b of sorted) {
+    const cy = (b.y1 + b.y2) / 2, h = b.y2 - b.y1;
+    if (row.length && Math.abs(cy - rowCy) <= Math.max(h, rowH) * 0.5) {
+      row.push(b);
+      continue;
+    }
+    flushRow();
+    row = [b];
+    rowCy = cy;
+    rowH = h;
+  }
+  flushRow();
+  return { glyphs, paths };
+}
+function ocrVectorOps(opList, paths) {
+  const drop = /* @__PURE__ */ new Set();
+  for (const p of paths) for (const i of p.ops) drop.add(i);
+  const fnArray = [];
+  const argsArray = [];
+  for (let i = 0; i < opList.fnArray.length; i++) {
+    const op = opList.fnArray[i];
+    if (drop.has(i) || op === _pdfmjs.OPS.clip || op === _pdfmjs.OPS.eoClip) continue;
+    fnArray.push(op);
+    argsArray.push(opList.argsArray[i]);
+  }
+  return { fnArray, argsArray };
+}
+
 // src/pdf/table-parts.ts
 var PART_COL_TOL = 1;
 function anchorsOf(table) {
@@ -369,7 +593,8 @@ var indexOf = (coords, x) => {
   return bestD <= PART_COL_TOL ? best : -1;
 };
 var rowText = (anchors, r) => anchors.filter((a) => a.r === r).map((a) => a.cell.text.replace(/\s+/g, "")).join("|");
-function joinSplitParts(prev, pcx, curr, ccx) {
+var hasText = (t) => t.replace(/\|/g, "") !== "";
+function joinSplitParts(prev, pcx, curr, ccx, dx = 0, prevBottom) {
   if (pcx.length !== prev.cols + 1 || ccx.length !== curr.cols + 1) return null;
   const U = unionCoords(pcx, ccx);
   const cols = U.length - 1;
@@ -377,10 +602,13 @@ function joinSplitParts(prev, pcx, curr, ccx) {
   const pa = anchorsOf(prev), ca = anchorsOf(curr);
   let skip = 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++) {
+    while (skip < Math.min(3, curr.rows - 1, prev.rows - h) && hasText(rowText(ca, skip)) && rowText(ca, skip) === rowText(pa, h + skip)) skip++;
+  }
   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));
-  const place = (a, x, rowOff) => {
+  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;
     const r = a.r + rowOff;
@@ -389,15 +617,15 @@ function joinSplitParts(prev, pcx, curr, ccx) {
       if (r + dr < rows) owner[r + dr][dc] = placed;
     }
     grid[r][c1] = { ...a.cell, colSpan: c2 - c1, rowSpan: a.rs };
-    const lines = _chunkNOAQRCV6cjs.CELL_LINES.get(a.cell);
-    if (lines) _chunkNOAQRCV6cjs.CELL_LINES.set(grid[r][c1], lines);
-    if (_chunkNOAQRCV6cjs.IMAGE_CELLS.has(a.cell)) _chunkNOAQRCV6cjs.IMAGE_CELLS.add(grid[r][c1]);
+    const lines = _chunkUSHQCF5Tcjs.CELL_LINES.get(a.cell);
+    if (lines) _chunkUSHQCF5Tcjs.CELL_LINES.set(grid[r][c1], shift ? lines.map((l) => ({ ...l, l: l.l + shift, r: l.r + shift })) : lines);
+    if (_chunkUSHQCF5Tcjs.IMAGE_CELLS.has(a.cell)) _chunkUSHQCF5Tcjs.IMAGE_CELLS.add(grid[r][c1]);
     return true;
   };
-  for (const a of pa) if (!_chunkNOAQRCV6cjs.FILLER_CELLS.has(a.cell) && !place(a, pcx, 0)) return null;
+  for (const a of pa) if (!_chunkUSHQCF5Tcjs.FILLER_CELLS.has(a.cell) && !place(a, pcx, 0)) return null;
   for (const a of ca) {
-    if (a.r < skip || _chunkNOAQRCV6cjs.FILLER_CELLS.has(a.cell)) continue;
-    if (!place(a, ccx, prev.rows - skip)) return null;
+    if (a.r < skip || _chunkUSHQCF5Tcjs.FILLER_CELLS.has(a.cell)) continue;
+    if (!place(a, ccx, prev.rows - skip, dx)) return null;
   }
   const first = prev.rows;
   for (let c = 0; c < cols; c++) {
@@ -420,19 +648,49 @@ function joinSplitParts(prev, pcx, curr, ccx) {
     const grown = { ...above, rs: newRs };
     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) _chunkNOAQRCV6cjs.FILLER_CELLS.add(grid[r][c]);
+  for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) if (owner[r][c] === null) _chunkUSHQCF5Tcjs.FILLER_CELLS.add(grid[r][c]);
   const table = { rows, cols, cells: grid, hasHeader: prev.hasHeader, ...prev.caption ? { caption: prev.caption } : {} };
-  if (rows > prev.rows) mergeSplitRow(table, owner, prev.rows, U);
-  return { table, colXs: U };
+  const split = rows > prev.rows && mergeSplitRow(table, owner, prev.rows, U);
+  if (rows > prev.rows && !split && prevBottom !== void 0) mergeStraddlingCells(table, owner, prev.rows, prevBottom);
+  return { table, colXs: U, split, header: ca.filter((a) => a.r < skip && a.cell.text.trim()).length >= 2 };
+}
+function mergeStraddlingCells(table, owner, first, prevBottom) {
+  const last = first - 1;
+  if (!owner[first].some((o, c) => o !== null && o === owner[last][c])) return;
+  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 >= last || 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];
+    const U = _chunkUSHQCF5Tcjs.CELL_LINES.get(a);
+    if (!_optionalChain([U, 'optionalAccess', _12 => _12.length]) || U.length > STRADDLE_MAX_LINES || !hasContent(b)) continue;
+    const lu = U[U.length - 1];
+    if (lu.y - prevBottom > STRADDLE_BOTTOM * (lu.h || 10)) continue;
+    appendCell(a, b);
+    a.rowSpan = first + d.rs - u.r;
+    table.cells[first][d.c] = { text: "", colSpan: 1, rowSpan: 1 };
+    const grown = { ...u, rs: a.rowSpan };
+    for (let rr = u.r; rr < u.r + grown.rs; rr++) for (let dc = u.c; dc < u.c + u.cs; dc++) owner[rr][dc] = grown;
+  }
 }
 var FULL_LINE_TOL = 1;
 var FULL_LINE_MIN_FRAC = 0.5;
 var FULL_LINE_EDGE_MIN = 12;
 var SINGLE_LINE_WORD_GAP = 3.5;
 var SHORT_LINE_GAP = 1.5;
+var STRADDLE_MAX_LINES = 3;
+var STRADDLE_BOTTOM = 1.2;
+var CARRIED_MIN_COL_W = 4;
+var LABEL_ROOM = 1.5;
+var HANGING_MIN = 0.5;
+var HANGING_TOL = 1;
 function continuesAcross(u, d, x1, x2) {
-  const U = _chunkNOAQRCV6cjs.CELL_LINES.get(u), D = _chunkNOAQRCV6cjs.CELL_LINES.get(d);
-  if (!_optionalChain([U, 'optionalAccess', _12 => _12.length]) || !_optionalChain([D, 'optionalAccess', _13 => _13.length])) return false;
+  const U = _chunkUSHQCF5Tcjs.CELL_LINES.get(u), D = _chunkUSHQCF5Tcjs.CELL_LINES.get(d);
+  if (!_optionalChain([U, 'optionalAccess', _13 => _13.length]) || !_optionalChain([D, 'optionalAccess', _14 => _14.length])) return false;
   const last = U[U.length - 1];
   const fs = last.h || 10;
   let minL = Infinity, maxR = -Infinity;
@@ -444,70 +702,113 @@ function continuesAcross(u, d, x1, x2) {
     minL = Math.min(minL, l.l);
     maxR = Math.max(maxR, l.r);
   }
+  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;
-  return U.some(leftAligned) || D.some(leftAligned);
+  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;
+}
+function lineEnded(c, x1, x2) {
+  const L = _chunkUSHQCF5Tcjs.CELL_LINES.get(c);
+  if (!L || L.length !== 1) return false;
+  const l = L[0];
+  return x2 - l.r - (l.l - x1) >= LABEL_ROOM * (l.h || 10);
 }
+function appendCell(a, b) {
+  if (_optionalChain([a, 'access', _15 => _15.blocks, 'optionalAccess', _16 => _16.length]) || _optionalChain([b, 'access', _17 => _17.blocks, 'optionalAccess', _18 => _18.length])) {
+    const asBlocks = (c) => _optionalChain([c, 'access', _19 => _19.blocks, 'optionalAccess', _20 => _20.length]) ? c.blocks : c.text.split("\n").map((l) => l.trim()).filter(Boolean).map((text) => ({ type: "paragraph", text }));
+    a.blocks = [...asBlocks(a), ...asBlocks(b)];
+  }
+  if (b.text.trim()) a.text = a.text.trim() ? a.text + "\n" + b.text : b.text;
+}
+var hasContent = (cell) => !!cell.text.trim() || !!_optionalChain([cell, 'access', _21 => _21.blocks, 'optionalAccess', _22 => _22.length]) || _chunkUSHQCF5Tcjs.IMAGE_CELLS.has(cell);
 function mergeSplitRow(table, owner, first, colXs) {
   const last = first - 1;
   const pairs = [];
+  let carried = false;
   for (let c = 0; c < table.cols; ) {
     const a = owner[last][c], b = owner[first][c];
-    if (!a || !b) return;
+    if (!a && !b) {
+      if (colXs[c + 1] - colXs[c] >= CARRIED_MIN_COL_W) carried = true;
+      c++;
+      continue;
+    }
+    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;
+      if (a.c !== b.c || a.cs !== b.cs || a.r + a.rs - 1 !== last || b.r !== first || b.rs !== 1) return false;
       pairs.push([a, b]);
-    }
+    } else if (a.r === last && a.rs === 2) carried = true;
     c = a.c + a.cs;
   }
-  if (!pairs.some(([u, d]) => continuesAcross(u.cell, d.cell, colXs[u.c], colXs[u.c + u.cs]))) return;
-  for (const [u, d] of pairs) {
-    const a = table.cells[u.r][u.c], b = table.cells[d.r][d.c];
-    if (b.text.trim()) a.text = a.text.trim() ? a.text + "\n" + b.text : b.text;
-    if (_optionalChain([b, 'access', _14 => _14.blocks, 'optionalAccess', _15 => _15.length])) a.blocks = [..._nullishCoalesce(a.blocks, () => ( [])), ...b.blocks];
+  const carriedSplit = carried && pairs.filter(([u, d]) => hasContent(u.cell) && hasContent(d.cell)).length <= 1 && !pairs.some(([u, d]) => !hasContent(u.cell) && hasContent(d.cell));
+  const cell = (a) => table.cells[a.r][a.c];
+  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]))) return false;
+    if (!pairs.some(([u, d]) => continuesAcross(cell(u), cell(d), colXs[u.c], colXs[u.c + u.cs]))) return false;
   }
+  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--;
   }
   table.cells.splice(first, 1);
   table.rows--;
+  return true;
 }
 var NEIGHBOR_TABLE_EPSILON = 0.2;
-function besideBoth(b, p, c) {
-  if (b.type === "table" || !b.bbox) return false;
+function besideOwn(b, p, c) {
+  if (!b.bbox) return false;
+  if (b.type === "table") return leftColumnOf(b, p);
+  const t = (b.pageNumber === p.pageNumber ? p : c).bbox;
   const bx1 = b.bbox.x, bx2 = b.bbox.x + b.bbox.width;
-  return [p.bbox, c.bbox].every((t) => bx2 <= t.x + 1 || bx1 >= t.x + t.width - 1);
+  return bx2 <= t.x + 1 || bx1 >= t.x + t.width - 1;
+}
+function leftColumnOf(b, t) {
+  return !!b.bbox && b.pageNumber === t.pageNumber && b.bbox.x + b.bbox.width <= t.bbox.x + 1;
+}
+function placeJoined(blocks, i, j, table) {
+  const prev = blocks[i];
+  blocks[i] = { ...prev, table };
+  blocks.splice(j, 1);
+  let k = j - 1;
+  while (k > i && !leftColumnOf(blocks[k], prev)) k--;
+  if (k > i) blocks.splice(k, 0, blocks.splice(i, 1)[0]);
+}
+function insideTable(b, t) {
+  if (!b.bbox || b.pageNumber !== t.pageNumber) return false;
+  const o = t.bbox;
+  return b.bbox.x >= o.x - 1 && b.bbox.x + b.bbox.width <= o.x + o.width + 1 && b.bbox.y >= o.y - 1 && b.bbox.y + b.bbox.height <= o.y + o.height + 1;
 }
 function mergeCrossPageTables(blocks, pageHeights) {
+  mergeColumnFlow(blocks, pageHeights);
   for (let i = blocks.length - 2; i >= 0; i--) {
     const prev = blocks[i];
     if (prev.type !== "table" || !prev.table || !prev.bbox || !prev.pageNumber) continue;
     let j = i + 1;
-    while (j < blocks.length && blocks[j].type !== "table" && (_nullishCoalesce(blocks[j].pageNumber, () => ( 0))) <= prev.pageNumber + 1) j++;
+    while (j < blocks.length && (blocks[j].type !== "table" || insideTable(blocks[j], prev) || leftColumnOf(blocks[j], prev)) && (_nullishCoalesce(blocks[j].pageNumber, () => ( 0))) <= prev.pageNumber + 1) j++;
     const curr = blocks[j];
     if (!curr || curr.type !== "table" || !curr.table || !curr.bbox || curr.pageNumber !== prev.pageNumber + 1) continue;
-    const joined = j === i + 1 || blocks.slice(i + 1, j).every((b) => besideBoth(b, prev, curr)) ? looksContinued(prev, curr, pageHeights) ? _nullishCoalesce(joinClipParts(prev, curr, pageHeights), () => ( false)) : null : null;
+    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) ? _nullishCoalesce(joinClipParts(prev, curr, pageHeights), () => ( false)) : null : null;
     if (joined) {
-      blocks[i] = { ...prev, table: joined };
-      blocks.splice(j, 1);
+      placeJoined(blocks, i, j, joined);
       continue;
     }
-    if (_chunkNOAQRCV6cjs.EMPTY_PARTS.has(curr.table)) {
+    if (_chunkUSHQCF5Tcjs.EMPTY_PARTS.has(curr.table)) {
       blocks.splice(j, 1);
       i++;
       continue;
     }
     if (joined === null) continue;
-    if (prev.table.cols !== curr.table.cols || _chunkNOAQRCV6cjs.EMPTY_PARTS.has(prev.table)) continue;
+    if (prev.table.cols !== curr.table.cols || _chunkUSHQCF5Tcjs.EMPTY_PARTS.has(prev.table)) continue;
     const width = Math.max(prev.bbox.width, curr.bbox.width, 1);
     const leftDiff = Math.abs(prev.bbox.x - curr.bbox.x);
     const rightDiff = Math.abs(prev.bbox.x + prev.bbox.width - (curr.bbox.x + curr.bbox.width));
     if (leftDiff > width * NEIGHBOR_TABLE_EPSILON || rightDiff > width * NEIGHBOR_TABLE_EPSILON) continue;
-    const px = _chunkNOAQRCV6cjs.TABLE_COLXS.get(prev.table), cx = _chunkNOAQRCV6cjs.TABLE_COLXS.get(curr.table);
-    if (px && cx && (px.length !== cx.length || px.some((x, k) => Math.abs(x - cx[k]) > CONTINUATION_COL_TOL))) continue;
+    const px = _chunkUSHQCF5Tcjs.TABLE_COLXS.get(prev.table), cx = _chunkUSHQCF5Tcjs.TABLE_COLXS.get(curr.table);
+    if (px && cx && !shiftedSame(px, cx, !_chunkUSHQCF5Tcjs.CLIP_TABLES.has(prev.table) && !_chunkUSHQCF5Tcjs.CLIP_TABLES.has(curr.table))) continue;
     let currCells = curr.table.cells;
     if (currCells.length > 1 && prev.table.cells.length > 0 && rowTextsEqual(prev.table.cells[0], currCells[0])) {
       currCells = currCells.slice(1);
@@ -523,40 +824,119 @@ function mergeCrossPageTables(blocks, pageHeights) {
       hasHeader: prev.table.hasHeader,
       caption: prev.table.caption
     };
-    if (_nullishCoalesce(px, () => ( cx))) _chunkNOAQRCV6cjs.TABLE_COLXS.set(merged, _nullishCoalesce(px, () => ( cx)));
-    if (_chunkNOAQRCV6cjs.CLIP_TABLES.has(prev.table) || _chunkNOAQRCV6cjs.CLIP_TABLES.has(curr.table)) _chunkNOAQRCV6cjs.CLIP_TABLES.add(merged);
-    blocks[i] = { ...prev, table: merged };
-    blocks.splice(j, 1);
+    if (_nullishCoalesce(px, () => ( cx))) _chunkUSHQCF5Tcjs.TABLE_COLXS.set(merged, _nullishCoalesce(px, () => ( cx)));
+    if (_chunkUSHQCF5Tcjs.CLIP_TABLES.has(prev.table) || _chunkUSHQCF5Tcjs.CLIP_TABLES.has(curr.table)) _chunkUSHQCF5Tcjs.CLIP_TABLES.add(merged);
+    placeJoined(blocks, i, j, merged);
   }
   for (let i = blocks.length - 1; i >= 0; i--) {
     const t = blocks[i].table;
-    if (blocks[i].type === "table" && t && _chunkNOAQRCV6cjs.EMPTY_PARTS.has(t)) blocks.splice(i, 1);
+    if (blocks[i].type === "table" && t && _chunkUSHQCF5Tcjs.EMPTY_PARTS.has(t)) blocks.splice(i, 1);
+  }
+}
+function mergeColumnFlow(blocks, pageHeights) {
+  if (!pageHeights) return;
+  for (let i = 0; i < blocks.length; i++) {
+    const L = blocks[i];
+    if (L.type !== "table" || !L.table || !L.bbox || !L.pageNumber || !_chunkUSHQCF5Tcjs.CLIP_TABLES.has(L.table) || _chunkUSHQCF5Tcjs.EMPTY_PARTS.has(L.table)) continue;
+    const ph = pageHeights.get(L.pageNumber);
+    if (!ph || L.bbox.y > ph * PAGE_EDGE_BAND) continue;
+    let s0 = i, s1 = i;
+    while (s0 > 0 && blocks[s0 - 1].pageNumber === L.pageNumber) s0--;
+    while (s1 + 1 < blocks.length && blocks[s1 + 1].pageNumber === L.pageNumber) s1++;
+    let k = -1;
+    for (let q = s0; q <= s1; q++) {
+      const R2 = blocks[q];
+      if (q === i || R2.type !== "table" || !R2.table || !R2.bbox || !leftColumnOf(L, R2)) continue;
+      const top2 = R2.bbox.y + R2.bbox.height;
+      if (top2 < ph * (1 - PAGE_EDGE_BAND)) continue;
+      if (k < 0 || top2 > blocks[k].bbox.y + blocks[k].bbox.height) k = q;
+    }
+    if (k < 0) continue;
+    const R = blocks[k];
+    if (Math.abs(R.bbox.width - L.bbox.width) > Math.max(R.bbox.width, L.bbox.width) * NEIGHBOR_TABLE_EPSILON) continue;
+    if (!looksContinued(L, R) || restartsTable(blocks, i, R.table, pageHeights)) continue;
+    const joined = joinClipParts(L, R, pageHeights);
+    if (!joined) continue;
+    const top = L.bbox.y + L.bbox.height;
+    const at = Math.min(i, k);
+    blocks[at] = { ...L, table: joined, bbox: { ...L.bbox, y: R.bbox.y, height: Math.max(0, top - R.bbox.y) } };
+    blocks.splice(Math.max(i, k), 1);
+    i = at - 1;
   }
 }
 function joinClipParts(prev, curr, pageHeights) {
   const pt = prev.table, ct = curr.table;
-  if (!_chunkNOAQRCV6cjs.CLIP_TABLES.has(pt) || !_chunkNOAQRCV6cjs.CLIP_TABLES.has(ct)) return null;
-  const px = _chunkNOAQRCV6cjs.TABLE_COLXS.get(pt), cx = _chunkNOAQRCV6cjs.TABLE_COLXS.get(ct);
+  if (!_chunkUSHQCF5Tcjs.CLIP_TABLES.has(pt) || !_chunkUSHQCF5Tcjs.CLIP_TABLES.has(ct)) return null;
+  const px = _chunkUSHQCF5Tcjs.TABLE_COLXS.get(pt), cx = _chunkUSHQCF5Tcjs.TABLE_COLXS.get(ct);
   if (!px || !cx) return null;
-  const sameCols = px.length === cx.length && px.every((x, k) => Math.abs(x - cx[k]) <= CONTINUATION_COL_TOL);
-  if (!sameCols) {
-    if (!_optionalChain([pageHeights, 'optionalAccess', _16 => _16.get, 'call', _17 => _17(prev.pageNumber)]) || !_optionalChain([pageHeights, 'optionalAccess', _18 => _18.get, 'call', _19 => _19(curr.pageNumber)])) return null;
-    if (Math.abs(px[px.length - 1] - cx[cx.length - 1]) > CONTINUATION_COL_TOL) return null;
-    if (!px.some((x) => Math.abs(x - cx[0]) <= CONTINUATION_COL_TOL)) return null;
+  let xs = cx, shifted = false, dx = 0;
+  if (!shiftedSame(px, cx, false)) {
+    if (!_optionalChain([pageHeights, 'optionalAccess', _23 => _23.get, 'call', _24 => _24(prev.pageNumber)]) || !_optionalChain([pageHeights, 'optionalAccess', _25 => _25.get, 'call', _26 => _26(curr.pageNumber)])) return null;
+    dx = px[px.length - 1] - cx[cx.length - 1];
+    if (Math.abs(dx) > CONTINUATION_COL_TOL) {
+      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 res = joinSplitParts(pt, px, ct, cx);
-  if (!res) return null;
-  _chunkNOAQRCV6cjs.TABLE_COLXS.set(res.table, res.colXs);
-  _chunkNOAQRCV6cjs.CLIP_TABLES.add(res.table);
+  const res = joinSplitParts(pt, px, ct, xs, dx, _optionalChain([prev, 'access', _27 => _27.bbox, 'optionalAccess', _28 => _28.y]));
+  if (!res || shifted && !res.split && !res.header) return null;
+  _chunkUSHQCF5Tcjs.TABLE_COLXS.set(res.table, res.colXs);
+  _chunkUSHQCF5Tcjs.CLIP_TABLES.add(res.table);
   return res.table;
 }
 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 = _optionalChain([pageHeights, 'optionalAccess', _20 => _20.get, 'call', _21 => _21(prev.pageNumber)]), ch = _optionalChain([pageHeights, 'optionalAccess', _22 => _22.get, 'call', _23 => _23(curr.pageNumber)]);
+  const ph = _optionalChain([pageHeights, 'optionalAccess', _29 => _29.get, 'call', _30 => _30(prev.pageNumber)]), ch = _optionalChain([pageHeights, 'optionalAccess', _31 => _31.get, 'call', _32 => _32(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;
-  const firstText = _nullishCoalesce(_optionalChain([curr, 'access', _24 => _24.table, 'access', _25 => _25.cells, 'access', _26 => _26[0], 'optionalAccess', _27 => _27.find, 'call', _28 => _28((c) => c.text.trim()), 'optionalAccess', _29 => _29.text]), () => ( ""));
+  const firstText = _nullishCoalesce(_optionalChain([curr, 'access', _33 => _33.table, 'access', _34 => _34.cells, 'access', _35 => _35[0], 'optionalAccess', _36 => _36.find, 'call', _37 => _37((c) => c.text.trim()), 'optionalAccess', _38 => _38.text]), () => ( ""));
   return !ANNEX_HEAD_RE.test(firstText);
 }
+function firstRowSig(t) {
+  const x = _chunkUSHQCF5Tcjs.TABLE_COLXS.get(t);
+  if (!x || x.length !== t.cols + 1) return null;
+  return anchorsOf(t).filter((a) => a.r === 0).map((a) => ({ x1: x[a.c], x2: x[a.c + a.cs], t: a.cell.text.replace(/\s+/g, "") }));
+}
+function restartsTable(blocks, i, curr, pageHeights) {
+  const cs = firstRowSig(curr);
+  if (!cs || cs.length < RESTART_MIN_ANCHORS) return false;
+  const hs = firstRowSig(blocks[chainHead(blocks, i, pageHeights)].table);
+  if (!hs || hs.length !== cs.length) return false;
+  const dx = hs[hs.length - 1].x2 - cs[cs.length - 1].x2;
+  if (!hs.every((h, n) => Math.abs(h.x1 - cs[n].x1 - dx) <= CONTINUATION_COL_TOL && Math.abs(h.x2 - cs[n].x2 - dx) <= CONTINUATION_COL_TOL)) return false;
+  let same = 0, diff = 0;
+  for (let n = 0; n < hs.length; n++) {
+    if (!hs[n].t && !cs[n].t) continue;
+    if (hs[n].t === cs[n].t) same++;
+    else diff++;
+  }
+  return same >= 2 && diff >= 1;
+}
+function chainHead(blocks, i, pageHeights) {
+  let k = i;
+  for (let steps = 0; steps < RESTART_LOOKBACK_PAGES; steps++) {
+    const cur = blocks[k];
+    let p = k - 1;
+    while (p >= 0 && blocks[p].type !== "table" && (_nullishCoalesce(blocks[p].pageNumber, () => ( 0))) >= (_nullishCoalesce(cur.pageNumber, () => ( 0))) - 1) p--;
+    if (p < 0 || blocks[p].type !== "table" || !blocks[p].table || !blocks[p].bbox) break;
+    for (let q = p - 1; q >= 0 && blocks[q].pageNumber === blocks[p].pageNumber; q--) {
+      if (blocks[q].type === "table" && blocks[q].bbox && insideTable(blocks[p], blocks[q])) {
+        p = q;
+        break;
+      }
+    }
+    const pb = blocks[p];
+    if (pb.pageNumber !== (_nullishCoalesce(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 = _chunkUSHQCF5Tcjs.TABLE_COLXS.get(pb.table), cx = _chunkUSHQCF5Tcjs.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;
+    k = p;
+  }
+  return k;
+}
 function rowTextsEqual(a, b) {
   if (a.length !== b.length) return false;
   const norm = (t) => t.replace(/\s+/g, "");
@@ -566,7 +946,52 @@ function rowTextsEqual(a, b) {
   return a.some((c) => c.text.trim() !== "");
 }
 var CONTINUATION_COL_TOL = 2;
+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;
+  return px.every((x, k) => Math.abs(x - cx[k] - dx) <= CONTINUATION_COL_TOL);
+}
 var PAGE_EDGE_BAND = 0.16;
+var RESTART_MIN_ANCHORS = 3;
+var RESTART_LOOKBACK_PAGES = 5;
+
+// src/pdf/cell-continuation.ts
+var COL_MATCH_TOL = 0.5;
+function lastRowCell(t, x1, x2) {
+  const xs = _chunkUSHQCF5Tcjs.TABLE_COLXS.get(t);
+  const covered = /* @__PURE__ */ new Set();
+  for (let r = 0; r < t.rows; r++) {
+    for (let c = 0; c < t.cols; c++) {
+      if (covered.has(r * 1e5 + c)) continue;
+      const cell = _optionalChain([t, 'access', _39 => _39.cells, 'access', _40 => _40[r], 'optionalAccess', _41 => _41[c]]);
+      if (!cell) continue;
+      for (let dr = 0; dr < cell.rowSpan; dr++) for (let dc = 0; dc < cell.colSpan; dc++) covered.add((r + dr) * 1e5 + c + dc);
+      if (r + cell.rowSpan !== t.rows) continue;
+      if (xs ? Math.abs(xs[c] - x1) <= COL_MATCH_TOL && Math.abs(xs[c + cell.colSpan] - x2) <= COL_MATCH_TOL : t.cols === 1) return cell;
+    }
+  }
+  return void 0;
+}
+var cellBlocks = (cell, pageNumber) => _nullishCoalesce(cell.blocks, () => ( cell.text.split("\n").map((t) => t.trim()).filter(Boolean).map((text) => ({ type: "paragraph", text, pageNumber }))));
+function mergeContinuedCells(blocks, pageHeights) {
+  for (let j = blocks.length - 1; j > 0; j--) {
+    const part = blocks[j];
+    const from = part.table ? _chunkUSHQCF5Tcjs.CONT_PARTS.get(part.table) : void 0;
+    if (!from || !part.table) continue;
+    let i = j - 1;
+    while (i >= 0 && blocks[i].type !== "table") i--;
+    const prev = blocks[i];
+    if (i < 0 || !prev.table || prev.pageNumber !== (_nullishCoalesce(part.pageNumber, () => ( 0))) - 1) continue;
+    const cell = lastRowCell(prev.table, from.x1, from.x2);
+    const add = _optionalChain([part, 'access', _42 => _42.table, 'access', _43 => _43.cells, 'access', _44 => _44[0], 'optionalAccess', _45 => _45[0]]);
+    if (!cell || !add) continue;
+    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");
+    if (cell.text.trim() || _optionalChain([cell, 'access', _46 => _46.blocks, 'optionalAccess', _47 => _47.length])) _chunkUSHQCF5Tcjs.EMPTY_PARTS.delete(prev.table);
+    blocks.splice(j, 1);
+    if (cell.blocks) mergeCrossPageTables(cell.blocks, pageHeights);
+  }
+}
 
 // src/pdf/symbol-fonts.ts
 var WINANSI_REVERSE = {
@@ -600,7 +1025,7 @@ var WINANSI_REVERSE = {
 };
 function symbolFontTable(fontName) {
   if (!fontName) return void 0;
-  if (/wingdings(?![\s-]*[23])/i.test(fontName)) return _chunkEBZUZC6Fcjs.WINGDINGS;
+  if (/wingdings(?![\s-]*[23])/i.test(fontName)) return _chunk5LAZQCUJcjs.WINGDINGS;
   return void 0;
 }
 function remapSymbolText(text, table) {
@@ -661,8 +1086,8 @@ function splitSingleCellTables(blocks) {
   const out = [];
   for (const b of blocks) {
     const t = b.type === "table" ? b.table : void 0;
-    const cell = t && t.rows === 1 && t.cols === 1 ? _optionalChain([t, 'access', _30 => _30.cells, 'access', _31 => _31[0], 'optionalAccess', _32 => _32[0]]) : void 0;
-    if (!cell || _optionalChain([cell, 'access', _33 => _33.blocks, 'optionalAccess', _34 => _34.some, 'call', _35 => _35((x) => x.type === "table")])) {
+    const cell = t && t.rows === 1 && t.cols === 1 ? _optionalChain([t, 'access', _48 => _48.cells, 'access', _49 => _49[0], 'optionalAccess', _50 => _50[0]]) : void 0;
+    if (!cell || _optionalChain([cell, 'access', _51 => _51.blocks, 'optionalAccess', _52 => _52.some, 'call', _53 => _53((x) => x.type === "table")])) {
       out.push(b);
       continue;
     }
@@ -677,7 +1102,8 @@ function cleanPdfText(text) {
     normalizeAraea(stripControlChars(text)).replace(/^\d{1,4}\n/, "").replace(/^[\s]*[-–—]\s*[-–—]?\d+[-–—]?[\s]*[-–—]?[\s]*$/gm, "").replace(/^\s*\d+\s*\/\s*\d+\s*$/gm, "").replace(/\n\d{1,4}\n/g, "\n").replace(/\n\d{1,4}$/, "").replace(/^#{1,6}\s*\d{1,4}\s*$/gm, "")
   ).replace(/^(?!\| ---).*$/gm, (line) => {
     if (/^\s*\${1,2}.+\${1,2}\s*$/.test(line)) return line;
-    return _chunkNOAQRCV6cjs.collapseEvenSpacing.call(void 0, line);
+    const mark = _nullishCoalesce(_optionalChain([/^(?:#{1,6}|-) /, 'access', _54 => _54.exec, 'call', _55 => _55(line), 'optionalAccess', _56 => _56[0]]), () => ( ""));
+    return mark + _chunkUSHQCF5Tcjs.collapseEvenSpacing.call(void 0, line.slice(mark.length));
   }).replace(/([□■◆○●▶ㅇ])\s+([가-힣])\s+([가-힣])/g, "$1 $2$3").replace(/\\~\\~/g, "~~").replace(/~~~~/g, "").replace(/<u>\s*<\/u>/g, "").replace(/\n{3,}/g, "\n\n").trim();
 }
 function startsWithMarker(line) {
@@ -725,7 +1151,7 @@ function applyLinkAnnotations(items, annots) {
   const wrapped = /* @__PURE__ */ new Set();
   for (const a of annots) {
     if (a.subtype !== "Link" || !a.url || !a.rect || a.rect.length < 4) continue;
-    const url = _chunkEMGF6EEVcjs.sanitizeHref.call(void 0, a.url);
+    const url = _chunkWJHAU73Bcjs.sanitizeHref.call(void 0, a.url);
     if (!url) continue;
     const x1 = Math.min(a.rect[0], a.rect[2]), x2 = Math.max(a.rect[0], a.rect[2]);
     const y1 = Math.min(a.rect[1], a.rect[3]), y2 = Math.max(a.rect[1], a.rect[3]);
@@ -756,7 +1182,7 @@ function applyLinkAnnotations(items, annots) {
 
 // src/pdf/formula-ocr.ts
 async function applyFormulaOcr(buffer, blocks, pageFilter, effectivePageCount, warnings, _onProgress) {
-  const formulaMod = await Promise.resolve().then(() => _interopRequireWildcard(require("./formula-CPO2TZGB.cjs")));
+  const formulaMod = await Promise.resolve().then(() => _interopRequireWildcard(require("./formula-5LOVHAKE.cjs")));
   const { FormulaPipeline, ensureFormulaModels } = formulaMod;
   await ensureFormulaModels((p) => {
     if (p.phase === "download" && p.total) {
@@ -924,7 +1350,7 @@ async function loadPdfWithTimeout(buffer) {
       new Promise((_, reject) => {
         timer = setTimeout(() => {
           loadingTask.destroy();
-          reject(new (0, _chunkEMGF6EEVcjs.KordocError)("PDF \uB85C\uB529 \uD0C0\uC784\uC544\uC6C3 (30\uCD08 \uCD08\uACFC)"));
+          reject(new (0, _chunkWJHAU73Bcjs.KordocError)("PDF \uB85C\uB529 \uD0C0\uC784\uC544\uC6C3 (30\uCD08 \uCD08\uACFC)"));
         }, PDF_LOAD_TIMEOUT_MS);
       })
     ]);
@@ -933,12 +1359,12 @@ async function loadPdfWithTimeout(buffer) {
   }
 }
 async function parsePdfDocument(buffer, options) {
-  const formulaBuffer = _optionalChain([options, 'optionalAccess', _36 => _36.formulaOcr]) ? buffer.slice(0) : null;
-  const ocrBuffer = _optionalChain([options, 'optionalAccess', _37 => _37.ocr]) ? buffer.slice(0) : null;
+  const formulaBuffer = _optionalChain([options, 'optionalAccess', _57 => _57.formulaOcr]) ? buffer.slice(0) : null;
+  const ocrBuffer = _optionalChain([options, 'optionalAccess', _58 => _58.ocr]) ? buffer.slice(0) : null;
   const doc = await loadPdfWithTimeout(buffer);
   try {
     const pageCount = doc.numPages;
-    if (pageCount === 0) throw new (0, _chunkEMGF6EEVcjs.KordocError)("PDF\uC5D0 \uD398\uC774\uC9C0\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    if (pageCount === 0) throw new (0, _chunkWJHAU73Bcjs.KordocError)("PDF\uC5D0 \uD398\uC774\uC9C0\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.");
     const metadata = { pageCount, pageMode: "layout" };
     await extractPdfMetadata(doc, metadata);
     const blocks = [];
@@ -947,7 +1373,7 @@ async function parsePdfDocument(buffer, options) {
     let totalChars = 0;
     let totalTextBytes = 0;
     const effectivePageCount = Math.min(pageCount, MAX_PAGES);
-    const pageFilter = _optionalChain([options, 'optionalAccess', _38 => _38.pages]) ? _chunkDCZVOIEOcjs.parsePageRange.call(void 0, options.pages, effectivePageCount) : null;
+    const pageFilter = _optionalChain([options, 'optionalAccess', _59 => _59.pages]) ? _chunkDCZVOIEOcjs.parsePageRange.call(void 0, options.pages, effectivePageCount) : null;
     const totalTarget = pageFilter ? pageFilter.size : effectivePageCount;
     const fontSizeFreq = /* @__PURE__ */ new Map();
     const pageHeights = /* @__PURE__ */ new Map();
@@ -956,6 +1382,9 @@ async function parsePdfDocument(buffer, options) {
     const imageState = createPdfImageState();
     const extractedImages = [];
     const pageImageBlocks = /* @__PURE__ */ new Map();
+    const carry = {};
+    const vectorPageOps = /* @__PURE__ */ new Map();
+    const wrapLexicon = new (0, _chunkUSHQCF5Tcjs.WrapLexicon)();
     let parsedPages = 0;
     for (let i = 1; i <= effectivePageCount; i++) {
       if (pageFilter && !pageFilter.has(i)) continue;
@@ -965,8 +1394,8 @@ async function parsePdfDocument(buffer, options) {
         const viewport = page.getViewport({ scale: 1 });
         pageHeights.set(i, viewport.height);
         const rawItems = tc.items;
-        const items = _chunkNOAQRCV6cjs.normalizeItems.call(void 0, rawItems);
-        const { visible, hiddenCount } = _chunkNOAQRCV6cjs.filterHiddenText.call(void 0, items, viewport.width, viewport.height);
+        const items = _chunkUSHQCF5Tcjs.normalizeItems.call(void 0, rawItems);
+        const { visible, hiddenCount } = _chunkUSHQCF5Tcjs.filterHiddenText.call(void 0, items, viewport.width, viewport.height);
         if (hiddenCount > 0) {
           warnings.push({ page: i, message: `${hiddenCount}\uAC1C \uC228\uACA8\uC9C4 \uD14D\uC2A4\uD2B8 \uC694\uC18C \uD544\uD130\uB9C1\uB428`, code: "HIDDEN_TEXT_FILTERED" });
         }
@@ -981,32 +1410,33 @@ async function parsePdfDocument(buffer, options) {
         const opList = await page.getOperatorList();
         remapSymbolFontItems(visible, (loadedName) => {
           try {
-            return page.commonObjs.has(loadedName) ? _optionalChain([page, 'access', _39 => _39.commonObjs, 'access', _40 => _40.get, 'call', _41 => _41(loadedName), 'optionalAccess', _42 => _42.name]) : void 0;
+            return page.commonObjs.has(loadedName) ? _optionalChain([page, 'access', _60 => _60.commonObjs, 'access', _61 => _61.get, 'call', _62 => _62(loadedName), 'optionalAccess', _63 => _63.name]) : void 0;
           } catch (e5) {
             return void 0;
           }
         });
+        for (const it of visible) if (it.text.includes("$")) it.text = _chunk5LAZQCUJcjs.escapeLiteralDollar.call(void 0, it.text);
         const pageArea = viewport.width * viewport.height;
         if (pageArea > 0) {
-          const imageRegions = _chunkNOAQRCV6cjs.extractImageRegions.call(void 0, opList.fnArray, opList.argsArray);
+          const imageRegions = _chunkUSHQCF5Tcjs.extractImageRegions.call(void 0, opList.fnArray, opList.argsArray);
           let uncovered = 0;
           for (const r of imageRegions) {
             const area = (r.x2 - r.x1) * (r.y2 - r.y1);
             if (area < pageArea * 0.05) continue;
             pagesWithLargeImage.add(i);
-            const hasText = visible.some((it) => {
+            const hasText2 = visible.some((it) => {
               const cx = it.x + it.w / 2;
               const cy = it.y + (it.h || it.fontSize) / 2;
               return cx >= r.x1 && cx <= r.x2 && cy >= r.y1 && cy <= r.y2;
             });
-            if (!hasText) uncovered++;
+            if (!hasText2) uncovered++;
           }
           if (uncovered > 0) skippedImagePages.set(i, uncovered);
         }
-        const pageBlocks = _chunkNOAQRCV6cjs.extractPageBlocksWithLines.call(void 0, visible, i, opList, viewport.width, viewport.height, void 0, _optionalChain([options, 'optionalAccess', _43 => _43.tables]) !== false);
+        const pageBlocks = _chunkUSHQCF5Tcjs.extractPageBlocksWithLines.call(void 0, visible, i, opList, viewport.width, viewport.height, void 0, _optionalChain([options, 'optionalAccess', _64 => _64.tables]) !== false, carry, wrapLexicon);
         for (const b of pageBlocks) blocks.push(b);
         try {
-          const { blocks: imgBlocks, images: pageImages } = await extractPageImages(page, opList.fnArray, opList.argsArray, i, imageState, warnings, _optionalChain([options, 'optionalAccess', _44 => _44.images]) !== false);
+          const { blocks: imgBlocks, images: pageImages } = await extractPageImages(page, opList.fnArray, opList.argsArray, i, imageState, warnings, _optionalChain([options, 'optionalAccess', _65 => _65.images]) !== false);
           if (imgBlocks.length > 0) pageImageBlocks.set(i, imgBlocks);
           extractedImages.push(...pageImages);
         } catch (e6) {
@@ -1022,19 +1452,24 @@ async function parsePdfDocument(buffer, options) {
           totalTextBytes += t.length * 2;
           pageText += pageText ? "\n" + t : t;
         }
-        pageQuality.push(computePageQuality(i, pageText));
-        if (totalTextBytes > MAX_TOTAL_TEXT) throw new (0, _chunkEMGF6EEVcjs.KordocError)("\uD14D\uC2A4\uD2B8 \uCD94\uCD9C \uD06C\uAE30 \uCD08\uACFC");
+        const vector = scanVectorGlyphs(opList.fnArray, opList.argsArray, visible);
+        const quality = computePageQuality(i, pageText, vector.glyphs);
+        pageQuality.push(quality);
+        if (_optionalChain([options, 'optionalAccess', _66 => _66.ocr]) && quality.ocrReason === "vector_text" && page.rotate % 360 === 0 && page.view[0] === 0 && page.view[1] === 0) {
+          vectorPageOps.set(i, ocrVectorOps(opList, vector.paths));
+        }
+        if (totalTextBytes > MAX_TOTAL_TEXT) throw new (0, _chunkWJHAU73Bcjs.KordocError)("\uD14D\uC2A4\uD2B8 \uCD94\uCD9C \uD06C\uAE30 \uCD08\uACFC");
         parsedPages++;
-        _optionalChain([options, 'optionalAccess', _45 => _45.onProgress, 'optionalCall', _46 => _46(parsedPages, totalTarget)]);
+        _optionalChain([options, 'optionalAccess', _67 => _67.onProgress, 'optionalCall', _68 => _68(parsedPages, totalTarget)]);
       } catch (pageErr) {
-        if (pageErr instanceof _chunkEMGF6EEVcjs.KordocError) throw pageErr;
+        if (pageErr instanceof _chunkWJHAU73Bcjs.KordocError) throw pageErr;
         warnings.push({ page: i, message: `\uD398\uC774\uC9C0 ${i} \uD30C\uC2F1 \uC2E4\uD328: ${pageErr instanceof Error ? pageErr.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958"}`, code: "PARTIAL_PARSE" });
       }
     }
     const parsedPageCount = parsedPages || (pageFilter ? pageFilter.size : effectivePageCount);
     const isImageBased = totalChars / Math.max(parsedPageCount, 1) < 10;
     const ocrDone = /* @__PURE__ */ new Set();
-    if (_optionalChain([options, 'optionalAccess', _47 => _47.ocr]) && ocrBuffer) {
+    if (_optionalChain([options, 'optionalAccess', _69 => _69.ocr]) && ocrBuffer) {
       const inScope = (p) => !pageFilter || pageFilter.has(p);
       const targets = /* @__PURE__ */ new Set();
       if (options.ocr === "force" || isImageBased) {
@@ -1048,9 +1483,9 @@ async function parsePdfDocument(buffer, options) {
       }
       if (targets.size > 0) {
         try {
-          const { runPdfOcr } = await Promise.resolve().then(() => _interopRequireWildcard(require("./pdf-ocr-VHSFACH7.cjs")));
+          const { runPdfOcr } = await Promise.resolve().then(() => _interopRequireWildcard(require("./pdf-ocr-JRDBJ6TA.cjs")));
           const mode = typeof options.ocr === "function" ? options.ocr : "builtin";
-          const ocrPageBlocks = await runPdfOcr(ocrBuffer, targets, mode, warnings, options.onProgress, options.tables !== false);
+          const ocrPageBlocks = await runPdfOcr(ocrBuffer, targets, mode, warnings, options.onProgress, options.tables !== false, vectorPageOps);
           if (ocrPageBlocks.size > 0) {
             for (const p of ocrPageBlocks.keys()) ocrDone.add(p);
             const merged = blocks.filter((b) => !(b.pageNumber && ocrDone.has(b.pageNumber)));
@@ -1080,6 +1515,7 @@ async function parsePdfDocument(buffer, options) {
     }
     if (!isImageBased) {
       const OCR_REASON_MESSAGES = {
+        vector_text: "\uAE00\uC790\uB97C \uACE1\uC120(\uBCA1\uD130 \uACBD\uB85C)\uC73C\uB85C \uADF8\uB9B0 \uD398\uC774\uC9C0 (\uD14D\uC2A4\uD2B8\uCE35\uC5D0 \uAE00\uC790 \uC5C6\uC74C)",
         low_text: "\uD14D\uC2A4\uD2B8\uAC00 \uAC70\uC758 \uC5C6\uB294 \uD398\uC774\uC9C0 (\uC2A4\uCE94/\uC774\uBBF8\uC9C0 \uCD94\uC815)",
         high_pua: "\uAE00\uAF34 \uB9E4\uD551 \uC2E4\uD328 (PUA \uBE44\uC728 \uB192\uC74C) \u2014 \uCD94\uCD9C \uD14D\uC2A4\uD2B8 \uC2E0\uB8B0 \uBD88\uAC00",
         high_control: "\uC81C\uC5B4\uBB38\uC790 \uBE44\uC728 \uB192\uC74C \u2014 \uCD94\uCD9C \uD14D\uC2A4\uD2B8 \uC2E0\uB8B0 \uBD88\uAC00",
@@ -1097,16 +1533,18 @@ async function parsePdfDocument(buffer, options) {
         warnings.push({ page, message: `${count}\uAC1C \uC774\uBBF8\uC9C0 \uC601\uC5ED\uC5D0 \uCD94\uCD9C \uAC00\uB2A5\uD55C \uD14D\uC2A4\uD2B8 \uC5C6\uC74C (\uADF8\uB9BC/\uCC28\uD2B8/\uB3C4\uC7A5 \uB0B4\uC6A9 \uB204\uB77D \uAC00\uB2A5)`, code: "SKIPPED_IMAGE" });
       }
     }
-    if (_optionalChain([options, 'optionalAccess', _48 => _48.removeHeaderFooter]) !== false && parsedPageCount >= 3) {
-      const removed = _chunkNOAQRCV6cjs.removeHeaderFooterBlocks.call(void 0, blocks, pageHeights, warnings);
+    if (_optionalChain([options, 'optionalAccess', _70 => _70.removeHeaderFooter]) !== false && parsedPageCount >= 3) {
+      const removed = _chunkUSHQCF5Tcjs.removeHeaderFooterBlocks.call(void 0, blocks, pageHeights, warnings);
       for (let ri = removed.length - 1; ri >= 0; ri--) {
         blocks.splice(removed[ri], 1);
       }
     }
+    mergeContinuedCells(blocks, pageHeights);
     mergeCrossPageTables(blocks, pageHeights);
-    if (!_optionalChain([options, 'optionalAccess', _49 => _49.keepTrailingEmptyCols])) _chunkNOAQRCV6cjs.trimTrailingEmptyTableCols.call(void 0, blocks);
+    if (!_optionalChain([options, 'optionalAccess', _71 => _71.keepTrailingEmptyCols])) _chunkUSHQCF5Tcjs.trimTrailingEmptyTableCols.call(void 0, blocks);
+    _chunkUSHQCF5Tcjs.joinPageBreakWraps.call(void 0, blocks, wrapLexicon);
     injectPageImageBlocks(blocks, pageImageBlocks);
-    if (_optionalChain([options, 'optionalAccess', _50 => _50.formulaOcr]) && formulaBuffer) {
+    if (_optionalChain([options, 'optionalAccess', _72 => _72.formulaOcr]) && formulaBuffer) {
       try {
         await applyFormulaOcr(formulaBuffer, blocks, pageFilter, effectivePageCount, warnings, options.onProgress);
       } catch (e) {
@@ -1116,17 +1554,17 @@ async function parsePdfDocument(buffer, options) {
         });
       }
     }
-    const medianFontSize = _chunkNOAQRCV6cjs.computeMedianFontSizeFromFreq.call(void 0, fontSizeFreq);
+    const medianFontSize = _chunkUSHQCF5Tcjs.computeMedianFontSizeFromFreq.call(void 0, fontSizeFreq);
     if (medianFontSize > 0) {
-      _chunkNOAQRCV6cjs.detectHeadings.call(void 0, blocks, medianFontSize);
+      _chunkUSHQCF5Tcjs.detectHeadings.call(void 0, blocks, medianFontSize);
     }
-    _chunkNOAQRCV6cjs.detectMarkerHeadings.call(void 0, blocks);
-    _chunkNOAQRCV6cjs.detectTableCaptions.call(void 0, blocks);
-    _chunkNOAQRCV6cjs.detectKoreanListBlocks.call(void 0, blocks);
+    _chunkUSHQCF5Tcjs.detectMarkerHeadings.call(void 0, blocks);
+    _chunkUSHQCF5Tcjs.detectTableCaptions.call(void 0, blocks);
+    _chunkUSHQCF5Tcjs.detectKoreanListBlocks.call(void 0, blocks);
     const outline = blocks.filter((b) => b.type === "heading" && b.level && b.text).map((b) => ({ level: b.level, text: b.text, pageNumber: b.pageNumber }));
     sanitizeBlockControlChars(blocks);
     const outBlocks = splitSingleCellTables(blocks);
-    let markdown = cleanPdfText(_chunkEBZUZC6Fcjs.blocksToMarkdown.call(void 0, outBlocks));
+    let markdown = cleanPdfText(_chunk5LAZQCUJcjs.blocksToMarkdown.call(void 0, outBlocks));
     return {
       markdown,
       blocks,
@@ -1146,7 +1584,7 @@ async function parsePdfDocument(buffer, options) {
 async function extractPdfMetadata(doc, metadata) {
   try {
     const result = await doc.getMetadata();
-    if (!_optionalChain([result, 'optionalAccess', _51 => _51.info])) return;
+    if (!_optionalChain([result, 'optionalAccess', _73 => _73.info])) return;
     const info = result.info;
     if (typeof info.Title === "string" && info.Title.trim()) metadata.title = info.Title.trim();
     if (typeof info.Author === "string" && info.Author.trim()) metadata.author = info.Author.trim();
@@ -1185,5 +1623,5 @@ async function extractPdfMetadataOnly(buffer) {
 
 
 
-exports.cleanPdfText = cleanPdfText; exports.detectKoreanListBlocks = _chunkNOAQRCV6cjs.detectKoreanListBlocks; exports.detectTableCaptions = _chunkNOAQRCV6cjs.detectTableCaptions; exports.extractPdfMetadataOnly = extractPdfMetadataOnly; exports.mergeCrossPageTables = mergeCrossPageTables; exports.parsePdfDocument = parsePdfDocument; exports.removeHeaderFooterBlocks = _chunkNOAQRCV6cjs.removeHeaderFooterBlocks;
-//# sourceMappingURL=parser-RANGXGBD.cjs.map
+exports.cleanPdfText = cleanPdfText; exports.detectKoreanListBlocks = _chunkUSHQCF5Tcjs.detectKoreanListBlocks; exports.detectTableCaptions = _chunkUSHQCF5Tcjs.detectTableCaptions; exports.extractPdfMetadataOnly = extractPdfMetadataOnly; exports.mergeCrossPageTables = mergeCrossPageTables; exports.parsePdfDocument = parsePdfDocument; exports.removeHeaderFooterBlocks = _chunkUSHQCF5Tcjs.removeHeaderFooterBlocks;
+//# sourceMappingURL=parser-HVEKF73B.cjs.map