kordoc 4.19.0 → 4.19.2

package/dist/mcp.js

@@ -3,7 +3,7 @@ import {
   assertWithinRoot,
   getAccessRoot,
   isOfflineMode
-} from "./chunk-AMDDV4CI.js";
+} from "./chunk-I2TBI7PN.js";
 import {
   APPROVAL_MAX,
   BODY_FONTS,
@@ -43,25 +43,25 @@ import {
   resolveBuiltinTemplate,
   unknownFontWarnings,
   usesGaejosikMunche
-} from "./chunk-C4JHZNRL.js";
-import "./chunk-QHN7N2QA.js";
-import "./chunk-AAE765MK.js";
+} from "./chunk-NV46IWKF.js";
+import "./chunk-VO22VAR3.js";
+import "./chunk-PWQ2BVAT.js";
 import "./chunk-3WSNLH4B.js";
-import "./chunk-GYQVQF2J.js";
+import "./chunk-TM4T4NYJ.js";
 import {
   detectFormat,
   detectOle2Format,
   detectZipFormat,
   extractHwp5MetadataOnly
-} from "./chunk-DGXGVC4Z.js";
+} from "./chunk-QZ63HXEG.js";
 import "./chunk-7FCNOKOR.js";
-import "./chunk-L5KNWOGR.js";
+import "./chunk-AOVMOCTK.js";
 import "./chunk-VQFA55IC.js";
-import "./chunk-FJE3TMZ7.js";
+import "./chunk-QYJPU4FZ.js";
 import {
   blocksToMarkdown
-} from "./chunk-XXUXQHUC.js";
-import "./chunk-OMJWAJBD.js";
+} from "./chunk-B4R443MV.js";
+import "./chunk-6ZBORHFB.js";
 import {
   KordocError,
   VERSION,
@@ -69,7 +69,7 @@ import {
   routeConsoleToStderr,
   sanitizeError,
   toArrayBuffer
-} from "./chunk-UTVNSCEI.js";
+} from "./chunk-OKHKEYTL.js";
 
 // src/mcp.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -355,7 +355,7 @@ ${markdown}`);
             break;
           case "pdf":
             try {
-              const { extractPdfMetadataOnly } = await import("./parser-FDE6GQST.js");
+              const { extractPdfMetadataOnly } = await import("./parser-3G4G6SST.js");
               metadata = await extractPdfMetadataOnly(buffer);
             } catch {
               metadata = void 0;
@@ -532,7 +532,7 @@ ${tableMarkdown}` }]
         if (!parsed.success) {
           return { content: [{ type: "text", text: `\uD30C\uC2F1 \uC2E4\uD328: ${parsed.error}` }], isError: true };
         }
-        const { blocksToChunks } = await import("./chunks-JPNLQOVD.js");
+        const { blocksToChunks } = await import("./chunks-2EC2R7PY.js");
         const chunks = blocksToChunks(parsed.blocks, { granularity, includeTableCells: include_table_cells });
         return { content: [{ type: "text", text: capResponseText(JSON.stringify(chunks, null, 2)) }] };
       } catch (err) {
@@ -777,7 +777,7 @@ ${previewMd}` }]
         }
         const image = new Uint8Array(await readFile2(imgResolved));
         const ext = extname2(imgResolved).slice(1).toLowerCase();
-        const { placeSealHwpx } = await import("./seal-E2E7CFZJ.js");
+        const { placeSealHwpx } = await import("./seal-EJWPS5VK.js");
         const result = await placeSealHwpx(buffer, [{
           anchor,
           occurrence,
@@ -894,7 +894,7 @@ ${previewMd}` }]
         if (outPath && await isSameFile(outPath, resolved)) {
           return { content: [{ type: "text", text: "output_path\uAC00 \uC785\uB825 \uD30C\uC77C\uACFC \uAC19\uC2B5\uB2C8\uB2E4 \u2014 \uC6D0\uBCF8\uC744 \uB36E\uC5B4\uC4F0\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. \uB2E4\uB978 \uACBD\uB85C\uB97C \uC9C0\uC815\uD558\uC138\uC694." }], isError: true };
         }
-        const { redactDocument } = await import("./redact-doc-6H7WPUQD.js");
+        const { redactDocument } = await import("./redact-doc-PNRDDBI3.js");
         const r = await redactDocument(buffer, { rules, maskChar: mask_char, filePath: file_path, dryRun: dry_run });
         const MAX_LINES = 50;
         const listed = r.fileHits.length > 0 ? r.fileHits.map((h) => `  - [${h.rule}] ${h.masked} (${h.where} @ ${h.part})`) : r.markdownHits.map((h) => `  - [${h.rule}] ${h.masked}`);
@@ -968,7 +968,7 @@ function registerRenderTools(server2) {
         const { buffer, resolved } = await readValidatedFile(file_path, MAX_FILE_SIZE, /* @__PURE__ */ new Set([".hwpx", ".hwp"]));
         const isHwp5 = resolved.toLowerCase().endsWith(".hwp");
         if (!isHwp5 && !pages && (format === "png" || format === "svg")) {
-          const { renderHwpxToSvg } = await import("./render-PBQJGZT3.js");
+          const { renderHwpxToSvg } = await import("./render-S3ALARVO.js");
           const result = await renderHwpxToSvg(buffer, { highlights, reflow: true, reflowMode: reflow_mode });
           const summary2 = [
             `\uB80C\uB354 \uC644\uB8CC: ${result.pageCount}\uD398\uC774\uC9C0, ${Math.round(result.width)}x${Math.round(result.height)}pt (\uD14D\uC2A4\uD2B8 ${result.stats.texts}\xB7\uC774\uBBF8\uC9C0 ${result.stats.images}\xB7\uD45C ${result.stats.tables})`,
@@ -980,7 +980,7 @@ function registerRenderTools(server2) {
             summary2.push(`\uC800\uC7A5: ${outPath}`);
             return { content: [{ type: "text", text: summary2.join("\n") }] };
           }
-          const { rasterizeSvg } = await import("./rasterize-X3I7SWXF.js");
+          const { rasterizeSvg } = await import("./rasterize-Y2RLMVCL.js");
           const raster = await rasterizeSvg(result.svg, result.width, result.height, max_width_px ? { maxWidthPx: max_width_px } : void 0);
           if (outPath) {
             await mkdir2(dirname3(outPath), { recursive: true });
@@ -995,7 +995,7 @@ function registerRenderTools(server2) {
             ]
           };
         }
-        const { renderDocument } = await import("./render-PBQJGZT3.js");
+        const { renderDocument } = await import("./render-S3ALARVO.js");
         const { scene, assets } = await renderDocument(buffer, { format, pages, highlights, reflow: true, reflowMode: reflow_mode, maxWidthPx: max_width_px });
         const summary = [
           `\uB80C\uB354 \uC644\uB8CC: \uBB38\uC11C ${scene.pages.length}\uD398\uC774\uC9C0 \uC911 ${assets.filter((a) => a.page !== void 0).length || 1}\uAC74 (\uD14D\uC2A4\uD2B8 ${scene.stats.texts}\xB7\uC774\uBBF8\uC9C0 ${scene.stats.images}\xB7\uD45C ${scene.stats.tables}\xB7\uB3C4\uD615 ${scene.stats.shapes})`,
@@ -1045,7 +1045,7 @@ function registerRenderTools(server2) {
       try {
         const { buffer } = await readValidatedFile(file_path, MAX_FILE_SIZE, /* @__PURE__ */ new Set([".hwpx", ".hwp"]));
         const dir = safeOutputPath(join2(output_dir, "regions.json"), /* @__PURE__ */ new Set([".json"])).replace(/[\\/]regions\.json$/, "");
-        const { extractRenderedRegions } = await import("./render-PBQJGZT3.js");
+        const { extractRenderedRegions } = await import("./render-S3ALARVO.js");
         const regions = await extractRenderedRegions(buffer, { types: target, format, pages, paddingPt: padding_pt, reflow: true });
         await mkdir2(dir, { recursive: true });
         const ext = format === "jpeg" ? "jpg" : "png";
@@ -1081,7 +1081,7 @@ function registerRenderTools(server2) {
         }
         const { buffer } = await readValidatedFile(file_path, MAX_FILE_SIZE, /* @__PURE__ */ new Set([".hwpx", ".hwp"]));
         const dir = output_dir ? safeOutputPath(join2(output_dir, "tables.json"), /* @__PURE__ */ new Set([".json"])).replace(/[\\/]tables\.json$/, "") : void 0;
-        const { extractTables } = await import("./visual-4GDT5BRH.js");
+        const { extractTables } = await import("./visual-GDXMKDVY.js");
         const tables = await extractTables(buffer, { policy: visual, format, paddingPt: padding_pt });
         if (dir) await mkdir2(dir, { recursive: true });
         const ext = format === "jpeg" ? "jpg" : "png";
@@ -1138,7 +1138,7 @@ function registerGenerateTools(server2) {
       try {
         const out = safeOutputPath(output_path, PROFILE_EXTENSIONS);
         const { buffer } = await readValidatedFile(hwpx_path);
-        const { hwpxToProfile } = await import("./-I3DEUQUC.js");
+        const { hwpxToProfile } = await import("./-3JIHF2AL.js");
         const profile = await hwpxToProfile(buffer);
         await mkdir3(dirname4(out), { recursive: true });
         await writeOutputFile(out, JSON.stringify(profile, null, 2));
@@ -1245,7 +1245,7 @@ function registerGenerateTools(server2) {
         }
         let profile;
         if (profile_path) {
-          const { parseFormatProfileJson } = await import("./profile-io-6WCU4KHY.js");
+          const { parseFormatProfileJson } = await import("./profile-io-ZVNMDLLS.js");
           profile = parseFormatProfileJson(await readFile3(safePath(profile_path, PROFILE_EXTENSIONS), "utf-8"));
         }
         const out = safeOutputPath(output_path, /* @__PURE__ */ new Set([".hwpx"]));

package/dist/{model-bundle-OBIKG4K5.js → model-bundle-NGTKULP7.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import {
   ALL_OCR_MODELS
-} from "./chunk-UCTD3BXH.js";
+} from "./chunk-56ZWAREM.js";
 import {
   ALL_FORMULA_MODELS,
   getModelStatusIn,
   getModelsDir
-} from "./chunk-VZSOPECZ.js";
-import "./chunk-AMDDV4CI.js";
-import "./chunk-UTVNSCEI.js";
+} from "./chunk-JK7N4R4K.js";
+import "./chunk-I2TBI7PN.js";
+import "./chunk-OKHKEYTL.js";
 
 // src/shared/model-bundle.ts
 import { copyFile, mkdir } from "fs/promises";
@@ -101,4 +101,4 @@ export {
   importModels,
   modelCacheStatus
 };
-//# sourceMappingURL=model-bundle-OBIKG4K5.js.map
+//# sourceMappingURL=model-bundle-NGTKULP7.js.map

package/dist/{models-2OZHOPPM.js → models-QOSU5SYL.js}

@@ -10,10 +10,10 @@ import {
   ocrModelPath,
   ocrModelsCached,
   parseCharacterDict
-} from "./chunk-UCTD3BXH.js";
-import "./chunk-VZSOPECZ.js";
-import "./chunk-AMDDV4CI.js";
-import "./chunk-UTVNSCEI.js";
+} from "./chunk-56ZWAREM.js";
+import "./chunk-JK7N4R4K.js";
+import "./chunk-I2TBI7PN.js";
+import "./chunk-OKHKEYTL.js";
 export {
   ALL_OCR_MODELS,
   OCR_DET_MODEL,
@@ -26,4 +26,4 @@ export {
   ocrModelsCached,
   parseCharacterDict
 };
-//# sourceMappingURL=models-2OZHOPPM.js.map
+//# sourceMappingURL=models-QOSU5SYL.js.map

package/dist/{parser-FDE6GQST.js → parser-3G4G6SST.js}

@@ -50,25 +50,26 @@ import {
   startsNewItem,
   trimTrailingEmptyTableCols,
   wrapJoiner
-} from "./chunk-RYKNAYKC.js";
+} from "./chunk-EUCBMW6C.js";
 import {
   ocrModelsCached
-} from "./chunk-UCTD3BXH.js";
-import "./chunk-VZSOPECZ.js";
-import "./chunk-AMDDV4CI.js";
+} from "./chunk-56ZWAREM.js";
+import "./chunk-JK7N4R4K.js";
+import "./chunk-I2TBI7PN.js";
 import {
   blocksToPages
-} from "./chunk-QHN7N2QA.js";
+} from "./chunk-VO22VAR3.js";
 import {
   encodePng
 } from "./chunk-7FCNOKOR.js";
 import {
   CELL_EDGES,
+  CELL_PAGES,
   CONTENT_CELLS,
   escapeLiteralTags,
   stripScriptTags,
   unframeLayoutTables
-} from "./chunk-L5KNWOGR.js";
+} from "./chunk-AOVMOCTK.js";
 import {
   hasRequestedPagesAfter,
   parsePageRange
@@ -78,11 +79,11 @@ import {
   assignTableIds,
   blocksToMarkdown,
   escapeLiteralDollar
-} from "./chunk-XXUXQHUC.js";
+} from "./chunk-B4R443MV.js";
 import {
   KordocError,
   sanitizeHref
-} from "./chunk-UTVNSCEI.js";
+} from "./chunk-OKHKEYTL.js";
 
 // src/pdf/ocr-region-merge.ts
 function mergeOcrImageRegions(blocks, page, regions, ocrBlocks) {
@@ -763,6 +764,167 @@ function splitContactTables(blocks) {
   }
 }
 
+// src/pdf/table-pages.ts
+var CELL_SPLITS = /* @__PURE__ */ new WeakMap();
+function relocate(src, dst, from = 0) {
+  const out = [];
+  for (const s of CELL_SPLITS.get(src) ?? []) {
+    const at = dst.text.indexOf(src.text.slice(s.at, s.at + 20).trimEnd(), Math.max(from, out.at(-1)?.at ?? 0));
+    if (at >= 0) out.push({ at, page: s.page });
+  }
+  return out;
+}
+var setSplits = (cell, splits) => {
+  if (splits.length) CELL_SPLITS.set(cell, splits.sort((a, b) => a.at - b.at));
+};
+function markContinuedText(cell, add, page) {
+  if (!add.text.trim()) return;
+  const base = cell.text.trim() ? cell.text.length + 1 : 0;
+  setSplits(cell, [
+    ...CELL_SPLITS.get(cell) ?? [],
+    { at: base, page },
+    ...(CELL_SPLITS.get(add) ?? []).map((s) => ({ at: base + s.at, page: s.page }))
+  ]);
+}
+function rowStarts(t) {
+  const covered = /* @__PURE__ */ new Set();
+  const rows = [];
+  for (let r = 0; r < t.rows; r++) {
+    const starts = [];
+    for (let c = 0; c < t.cols; c++) {
+      if (covered.has(r * 1e5 + c)) continue;
+      const cell = t.cells[r]?.[c];
+      if (!cell) continue;
+      for (let dr = 0; dr < cell.rowSpan; dr++) for (let dc = 0; dc < cell.colSpan; dc++) if (dr || dc) covered.add((r + dr) * 1e5 + c + dc);
+      starts.push({ cell, c });
+    }
+    rows.push(starts);
+  }
+  return rows;
+}
+var covering = (t, r) => rowStarts(t).slice(0, r + 1).flatMap((starts, rr) => starts.filter((s) => rr + s.cell.rowSpan > r).map((s) => s.cell));
+function cellPage(cell) {
+  const p = CELL_PAGES.get(cell);
+  if (p !== void 0 || !cell.blocks?.length || cell.blocks.some((b) => b.pageNumber === void 0)) return p;
+  return Math.min(...cell.blocks.map((b) => b.pageNumber));
+}
+function tableRowPages(t, pageNumber) {
+  const pages = [];
+  let prev = pageNumber;
+  for (const starts of rowStarts(t)) {
+    let mark, text = false;
+    for (const { cell } of starts) {
+      const p = cellPage(cell);
+      if (p !== void 0) mark = Math.max(mark ?? p, p);
+      else if (cell.text.trim() || cell.blocks?.length) text = true;
+    }
+    const page = mark ?? (text ? pageNumber : prev);
+    prev = page !== void 0 && prev !== void 0 ? Math.max(prev, page) : page ?? prev;
+    pages.push(prev);
+  }
+  return pages;
+}
+function markJoinedPages(table, prev, curr) {
+  const pt = prev.table, ct = curr.table;
+  if (!curr.pageNumber || table.rows < pt.rows) return;
+  const pp = tableRowPages(pt, prev.pageNumber), cp = tableRowPages(ct, curr.pageNumber);
+  const off = table.rows - ct.rows;
+  const rows = rowStarts(table), ptRows = rowStarts(pt), ctRows = rowStarts(ct);
+  rows.forEach((starts, r) => {
+    const page2 = r < pt.rows ? pp[r] : cp[r - off];
+    for (const { cell } of starts) {
+      if (page2 !== void 0 && page2 !== prev.pageNumber) CELL_PAGES.set(cell, page2);
+      const src = (r < pt.rows ? ptRows[r] : ctRows[r - off])?.find((s) => s.cell !== cell && s.cell.text === cell.text && CELL_SPLITS.has(s.cell));
+      if (src) setSplits(cell, relocate(src.cell, cell));
+    }
+  });
+  const cr = pt.rows - 1 - off, page = cp[cr];
+  if (cr < 0 || page === void 0 || page === prev.pageNumber) return;
+  const tails = ctRows[cr].filter((s) => s.cell.text.trim());
+  for (const { cell } of ctRows[cr]) for (const b of cell.blocks ?? []) b.pageNumber ??= page;
+  const heads = covering(pt, pt.rows - 1);
+  for (const cell of covering(table, pt.rows - 1)) {
+    if (cell.blocks?.length) continue;
+    const head = heads.filter((h) => h.text.trim() && cell.text.startsWith(h.text.trimEnd()) && cell.text.trim().length > h.text.trim().length).sort((a, b) => b.text.length - a.text.length)[0];
+    if (!head) continue;
+    const from = head.text.trimEnd().length;
+    const hit = tails.map((t) => ({ t: t.cell, at: cell.text.indexOf(t.cell.text.trim().slice(0, 20), from) })).filter((h) => h.at >= from).sort((a, b) => a.at - b.at)[0];
+    if (!hit) continue;
+    setSplits(cell, [...relocate(head, cell), { at: hit.at, page }, ...relocate(hit.t, cell, hit.at)]);
+  }
+}
+function splitCell(cell, page) {
+  if (page === void 0) return null;
+  if (cell.blocks?.length) {
+    const k2 = cell.blocks.findIndex((b) => (b.pageNumber ?? page) > page);
+    if (k2 <= 0) return null;
+    const head = cell.blocks.slice(0, k2), tail = cell.blocks.slice(k2);
+    const text = (bs) => bs.map((b) => b.text ?? "").filter(Boolean).join("\n");
+    return { head: { text: text(head), blocks: head }, tail: { text: text(tail), blocks: tail }, page: tail[0].pageNumber, rest: [] };
+  }
+  const splits = CELL_SPLITS.get(cell) ?? [];
+  const k = splits.findIndex((s2) => s2.page > page && s2.at < cell.text.length);
+  if (k < 0) return null;
+  const s = splits[k];
+  const rest = cell.text.slice(s.at), lead = rest.length - rest.trimStart().length;
+  return {
+    head: { text: cell.text.slice(0, s.at).trimEnd() },
+    tail: { text: rest.trim() },
+    page: s.page,
+    rest: splits.slice(k + 1).map((x) => ({ at: x.at - s.at - lead, page: x.page })).filter((x) => x.at > 0)
+  };
+}
+function splitCrossPageRows(t, pageNumber) {
+  const pages = tableRowPages(t, pageNumber);
+  const rows = rowStarts(t);
+  for (let r = 0; r < t.rows; r++) {
+    const splits = rows[r].map((s) => ({ ...s, split: splitCell(s.cell, pages[r]) })).filter((s) => s.split);
+    if (!splits.length) continue;
+    const clone = (cell, patch) => {
+      const out = { ...cell, ...patch };
+      const p = CELL_PAGES.get(cell);
+      if (p !== void 0) CELL_PAGES.set(out, p);
+      if (!("text" in patch) && CELL_SPLITS.has(cell)) CELL_SPLITS.set(out, CELL_SPLITS.get(cell));
+      return out;
+    };
+    const e = Math.max(...splits.map((s) => r + s.cell.rowSpan - 1));
+    const cells = t.cells.map((row2) => row2.slice());
+    const row = Array.from({ length: t.cols }, () => ({ text: "", colSpan: 1, rowSpan: 1 }));
+    for (const { cell, c, split } of splits) {
+      cells[r][c] = clone(cell, split.head);
+      const tail = { ...cell, ...split.tail, rowSpan: 1 };
+      CELL_PAGES.set(tail, split.page);
+      setSplits(tail, split.rest);
+      row[c] = tail;
+    }
+    rows.forEach((starts, rr) => {
+      for (const { cell, c } of starts) {
+        if (splits.some((s) => s.cell === cell) || rr > e || rr + cell.rowSpan - 1 <= e) continue;
+        cells[rr][c] = clone(cells[rr][c], { rowSpan: cell.rowSpan + 1 });
+      }
+    });
+    cells.splice(e + 1, 0, row);
+    return splitCrossPageRows({ ...t, rows: t.rows + 1, cells }, pageNumber);
+  }
+  return t;
+}
+function splitPageTables(blocks) {
+  return blocks.flatMap((b) => {
+    if (b.type !== "table" || !b.table) return [b];
+    const t = splitCrossPageRows(b.table, b.pageNumber);
+    const pages = tableRowPages(t, b.pageNumber);
+    const cuts = [0];
+    for (let r = 1; r < t.rows; r++) if (pages[r] !== pages[r - 1]) cuts.push(r);
+    if (cuts.length === 1) return t === b.table ? [b] : [{ ...b, table: t }];
+    return cuts.map((from, k) => {
+      const end = cuts[k + 1] ?? t.rows;
+      const cells = t.cells.slice(from, end).map((row, dr) => row.map((cell) => cell && from + dr + cell.rowSpan > end ? { ...cell, rowSpan: end - from - dr } : cell));
+      const table = { ...t, rows: end - from, cells, ...k ? { caption: void 0, captionBlocks: void 0 } : {} };
+      return { ...b, table, pageNumber: pages[from] };
+    });
+  });
+}
+
 // src/pdf/table-parts.ts
 var flowText = (text) => text.replace(/<\/?u>|~~/g, "");
 var PART_COL_TOL = 1;
@@ -1182,6 +1344,7 @@ function leftColumnOf(b, t) {
 }
 function placeJoined(blocks, i, j, table) {
   const prev = blocks[i];
+  markJoinedPages(table, prev, blocks[j]);
   blocks[i] = { ...prev, table };
   blocks.splice(j, 1);
   let k = j - 1;
@@ -1535,6 +1698,7 @@ function mergeContinuedCells(blocks, pageHeights) {
     if (!cell || !add) continue;
     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)];
+    else if (part.pageNumber) markContinuedText(cell, add, part.pageNumber);
     cell.text = [cell.text, add.text].filter((s) => s.trim()).join("\n");
     joinCellEdges(cell, add);
     const lines = CELL_LINES.get(add);
@@ -2883,7 +3047,7 @@ function mergeLinkRuns(markdown) {
 
 // src/pdf/formula-ocr.ts
 async function applyFormulaOcr(buffer, blocks, pageFilter, effectivePageCount, warnings, _onProgress) {
-  const formulaMod = await import("./formula-DUEAYGIG.js");
+  const formulaMod = await import("./formula-RSTTP626.js");
   const { FormulaPipeline, ensureFormulaModels } = formulaMod;
   await ensureFormulaModels((p) => {
     if (p.phase === "download" && p.total) {
@@ -3304,7 +3468,7 @@ async function parsePdfDocument(buffer, options) {
       }
       if (targets.size > 0) {
         try {
-          const { runPdfOcr } = await import("./pdf-ocr-YHC4X67W.js");
+          const { runPdfOcr } = await import("./pdf-ocr-R3VGX6F2.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);
@@ -3462,7 +3626,7 @@ async function parsePdfDocument(buffer, options) {
     let markdown = finishMarkdown(outBlocks);
     return {
       markdown,
-      pages: blocksToPages(splitPageBreakWraps(outBlocks), finishMarkdown),
+      pages: blocksToPages(splitPageTables(splitPageBreakWraps(outBlocks)), finishMarkdown),
       blocks,
       metadata,
       outline: outline.length > 0 ? outline : void 0,
@@ -3542,4 +3706,4 @@ export {
   parsePdfDocument,
   removeHeaderFooterBlocks
 };
-//# sourceMappingURL=parser-FDE6GQST.js.map
+//# sourceMappingURL=parser-3G4G6SST.js.map