kordoc 2.1.0 → 2.2.1

package/dist/{chunk-GJ2S6IMC.js → chunk-FINXMRCH.js}

@@ -1,53 +1,105 @@
 #!/usr/bin/env node
 import {
-  KordocError,
-  classifyError,
-  isPathTraversal,
-  precheckZipSize,
-  sanitizeHref,
-  toArrayBuffer
-} from "./chunk-PKIJLEV6.js";
+  detectFormat,
+  detectZipFormat
+} from "./chunk-MUAWCQDY.js";
 import {
   parsePageRange
-} from "./chunk-MOL7MDBG.js";
+} from "./chunk-3TBUDJDE.js";
 
-// src/detect.ts
-import JSZip from "jszip";
-function magicBytes(buffer) {
-  return new Uint8Array(buffer, 0, Math.min(4, buffer.byteLength));
-}
-function isZipFile(buffer) {
-  const b = magicBytes(buffer);
-  return b[0] === 80 && b[1] === 75 && b[2] === 3 && b[3] === 4;
-}
-function isOldHwpFile(buffer) {
-  const b = magicBytes(buffer);
-  return b[0] === 208 && b[1] === 207 && b[2] === 17 && b[3] === 224;
+// src/utils.ts
+var VERSION = true ? "2.2.1" : "0.0.0-dev";
+function toArrayBuffer(buf) {
+  if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
+    return buf.buffer;
+  }
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
 }
-function isPdfFile(buffer) {
-  const b = magicBytes(buffer);
-  return b[0] === 37 && b[1] === 80 && b[2] === 68 && b[3] === 70;
+var KordocError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "KordocError";
+  }
+};
+function sanitizeError(err) {
+  if (err instanceof KordocError) return err.message;
+  return "\uBB38\uC11C \uCC98\uB9AC \uC911 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4";
 }
-function detectFormat(buffer) {
-  if (buffer.byteLength < 4) return "unknown";
-  if (isZipFile(buffer)) return "hwpx";
-  if (isOldHwpFile(buffer)) return "hwp";
-  if (isPdfFile(buffer)) return "pdf";
-  return "unknown";
+function isPathTraversal(name) {
+  if (name.includes("\0")) return true;
+  const normalized = name.replace(/\\/g, "/");
+  const segments = normalized.split("/");
+  return segments.some((s) => s === "..") || normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized);
 }
-async function detectZipFormat(buffer) {
+function precheckZipSize(buffer, maxUncompressedSize = 100 * 1024 * 1024, maxEntries = 500) {
   try {
-    const zip = await JSZip.loadAsync(buffer);
-    if (zip.file("xl/workbook.xml")) return "xlsx";
-    if (zip.file("word/document.xml")) return "docx";
-    if (zip.file("Contents/content.hpf") || zip.file("mimetype")) return "hwpx";
-    const hasSection = Object.keys(zip.files).some((f) => f.startsWith("Contents/"));
-    if (hasSection) return "hwpx";
-    return "unknown";
-  } catch {
-    return "unknown";
+    const data = new DataView(buffer);
+    const len = buffer.byteLength;
+    let eocdOffset = -1;
+    for (let i = len - 22; i >= Math.max(0, len - 65557); i--) {
+      if (data.getUint32(i, true) === 101010256) {
+        eocdOffset = i;
+        break;
+      }
+    }
+    if (eocdOffset < 0) return { totalUncompressed: 0, entryCount: 0 };
+    const entryCount = data.getUint16(eocdOffset + 10, true);
+    if (entryCount > maxEntries) {
+      throw new KordocError(`ZIP \uC5D4\uD2B8\uB9AC \uC218 \uCD08\uACFC: ${entryCount} (\uCD5C\uB300 ${maxEntries})`);
+    }
+    const cdSize = data.getUint32(eocdOffset + 12, true);
+    const cdOffset = data.getUint32(eocdOffset + 16, true);
+    if (cdOffset + cdSize > len) return { totalUncompressed: 0, entryCount };
+    let totalUncompressed = 0;
+    let pos = cdOffset;
+    for (let i = 0; i < entryCount && pos + 46 <= cdOffset + cdSize; i++) {
+      if (data.getUint32(pos, true) !== 33639248) break;
+      totalUncompressed += data.getUint32(pos + 24, true);
+      const nameLen = data.getUint16(pos + 28, true);
+      const extraLen = data.getUint16(pos + 30, true);
+      const commentLen = data.getUint16(pos + 32, true);
+      pos += 46 + nameLen + extraLen + commentLen;
+    }
+    if (totalUncompressed > maxUncompressedSize) {
+      throw new KordocError(`ZIP \uBE44\uC555\uCD95 \uD06C\uAE30 \uCD08\uACFC: ${(totalUncompressed / 1024 / 1024).toFixed(1)}MB (\uCD5C\uB300 ${maxUncompressedSize / 1024 / 1024}MB)`);
+    }
+    return { totalUncompressed, entryCount };
+  } catch (err) {
+    if (err instanceof KordocError) throw err;
+    return { totalUncompressed: 0, entryCount: 0 };
   }
 }
+function stripDtd(xml) {
+  return xml.replace(/<!DOCTYPE\s[^[>]*(\[[\s\S]*?\])?\s*>/gi, "");
+}
+var SAFE_HREF_RE = /^(?:https?:|mailto:|tel:|#)/i;
+function sanitizeHref(href) {
+  const trimmed = href.trim();
+  if (!trimmed || !SAFE_HREF_RE.test(trimmed)) return null;
+  return trimmed;
+}
+function safeMin(arr) {
+  let min = Infinity;
+  for (let i = 0; i < arr.length; i++) if (arr[i] < min) min = arr[i];
+  return min;
+}
+function safeMax(arr) {
+  let max = -Infinity;
+  for (let i = 0; i < arr.length; i++) if (arr[i] > max) max = arr[i];
+  return max;
+}
+function classifyError(err) {
+  if (!(err instanceof Error)) return "PARSE_ERROR";
+  const msg = err.message;
+  if (msg.includes("\uC554\uD638\uD654")) return "ENCRYPTED";
+  if (msg.includes("DRM")) return "DRM_PROTECTED";
+  if (msg.includes("ZIP bomb") || msg.includes("ZIP \uBE44\uC555\uCD95 \uD06C\uAE30 \uCD08\uACFC") || msg.includes("ZIP \uC5D4\uD2B8\uB9AC \uC218 \uCD08\uACFC")) return "ZIP_BOMB";
+  if (msg.includes("bomb") || msg.includes("\uD06C\uAE30 \uCD08\uACFC") || msg.includes("\uC555\uCD95 \uD574\uC81C")) return "DECOMPRESSION_BOMB";
+  if (msg.includes("\uC774\uBBF8\uC9C0 \uAE30\uBC18")) return "IMAGE_BASED_PDF";
+  if (msg.includes("\uC139\uC158") && (msg.includes("\uCC3E\uC744 \uC218 \uC5C6") || msg.includes("\uC5C6\uC74C"))) return "NO_SECTIONS";
+  if (msg.includes("\uC2DC\uADF8\uB2C8\uCC98") || msg.includes("\uBCF5\uAD6C\uD560 \uC218 \uC5C6")) return "CORRUPTED";
+  return "PARSE_ERROR";
+}
 
 // src/table/builder.ts
 var MAX_COLS = 200;
@@ -110,6 +162,7 @@ function buildTableDirect(rows, numRows) {
       if (end > maxCols) maxCols = end;
     }
   }
+  if (maxCols > MAX_COLS) maxCols = MAX_COLS;
   if (maxCols === 0) return { rows: 0, cols: 0, cells: [], hasHeader: false };
   const grid = Array.from(
     { length: numRows },
@@ -119,7 +172,7 @@ function buildTableDirect(rows, numRows) {
     for (const cell of row) {
       const r = cell.rowAddr ?? 0;
       const c = cell.colAddr ?? 0;
-      if (r >= numRows || c >= maxCols) continue;
+      if (r >= numRows || c >= maxCols || r < 0 || c < 0) continue;
       grid[r][c] = { text: cell.text.trim(), colSpan: cell.colSpan, rowSpan: cell.rowSpan };
       for (let dr = 0; dr < cell.rowSpan; dr++) {
         for (let dc = 0; dc < cell.colSpan; dc++) {
@@ -148,9 +201,12 @@ function trimAndReturn(grid, numRows, maxCols) {
 }
 function convertTableToText(rows) {
   return rows.map(
-    (row) => row.map((c) => c.text.trim().replace(/\n/g, " ")).filter(Boolean).join(" | ")
+    (row) => row.map((c) => c.text.trim().replace(/\n/g, " ").replace(/\|/g, "\\|")).filter(Boolean).join(" / ")
   ).filter(Boolean).join("\n");
 }
+function escapeGfm(text) {
+  return text.replace(/~/g, "\\~");
+}
 var HWP_SHAPE_ALT_TEXT_RE = /(?:모서리가 둥근 |둥근 )?(?:사각형|직사각형|정사각형|원|타원|삼각형|이등변 삼각형|직각 삼각형|선|직선|곡선|화살표|굵은 화살표|이중 화살표|오각형|육각형|팔각형|별|[4-8]점별|십자|십자형|구름|구름형|마름모|도넛|평행사변형|사다리꼴|부채꼴|호|반원|물결|번개|하트|빗금|블록 화살표|수식|표|그림|개체|그리기\s?개체|묶음\s?개체|글상자|수식\s?개체|OLE\s?개체)\s?입니다\.?/g;
 function sanitizeText(text) {
   let result = text.replace(/[\u{F0000}-\u{FFFFD}]/gu, "").replace(HWP_SHAPE_ALT_TEXT_RE, "").replace(/  +/g, " ").trim();
@@ -260,7 +316,7 @@ function blocksToMarkdown(blocks) {
       if (block.footnoteText) {
         text += ` (\uC8FC: ${block.footnoteText})`;
       }
-      lines.push(text);
+      lines.push(escapeGfm(text), "");
     } else if (block.type === "table" && block.table) {
       if (lines.length > 0 && lines[lines.length - 1] !== "") {
         lines.push("");
@@ -283,13 +339,13 @@ function tableToMarkdown(table) {
     return content.split(/\n/).map((line) => {
       const trimmed = line.trim();
       if (!trimmed) return "";
-      if (/^\d+\.\s/.test(trimmed)) return `**${trimmed}**`;
-      if (/^[가-힣]\.\s/.test(trimmed)) return `  ${trimmed}`;
-      return trimmed;
+      if (/^\d+\.\s/.test(trimmed)) return `**${escapeGfm(trimmed)}**`;
+      if (/^[가-힣]\.\s/.test(trimmed)) return `  ${escapeGfm(trimmed)}`;
+      return escapeGfm(trimmed);
     }).filter(Boolean).join("\n");
   }
   if (numCols === 1 && numRows >= 2) {
-    return cells.map((row) => sanitizeText(row[0].text).replace(/\n/g, " ")).filter(Boolean).join("\n");
+    return cells.map((row) => escapeGfm(sanitizeText(row[0].text)).replace(/\n/g, " ")).filter(Boolean).join("\n");
   }
   const display = Array.from({ length: numRows }, () => Array(numCols).fill(""));
   const skip = /* @__PURE__ */ new Set();
@@ -298,15 +354,12 @@ function tableToMarkdown(table) {
       if (skip.has(`${r},${c}`)) continue;
       const cell = cells[r]?.[c];
       if (!cell) continue;
-      display[r][c] = sanitizeText(cell.text).replace(/\n/g, "<br>");
+      display[r][c] = escapeGfm(sanitizeText(cell.text)).replace(/\|/g, "\\|").replace(/\n/g, "<br>");
       for (let dr = 0; dr < cell.rowSpan; dr++) {
         for (let dc = 0; dc < cell.colSpan; dc++) {
           if (dr === 0 && dc === 0) continue;
           if (r + dr < numRows && c + dc < numCols) {
             skip.add(`${r + dr},${c + dc}`);
-            if (dr === 0) {
-              display[r][c + dc] = cell.text.replace(/\n/g, "<br>");
-            }
           }
         }
       }
@@ -344,7 +397,7 @@ function tableToMarkdown(table) {
 }
 
 // src/hwpx/parser.ts
-import JSZip2 from "jszip";
+import JSZip from "jszip";
 import { inflateRawSync } from "zlib";
 import { DOMParser } from "@xmldom/xmldom";
 
@@ -446,14 +499,11 @@ function parseStyleElements(doc, map) {
     }
   }
 }
-function stripDtd(xml) {
-  return xml.replace(/<!DOCTYPE\s[^[>]*(\[[\s\S]*?\])?\s*>/gi, "");
-}
 async function parseHwpxDocument(buffer, options) {
   precheckZipSize(buffer, MAX_DECOMPRESS_SIZE, MAX_ZIP_ENTRIES);
   let zip;
   try {
-    zip = await JSZip2.loadAsync(buffer);
+    zip = await JSZip.loadAsync(buffer);
   } catch {
     return extractFromBrokenZip(buffer);
   }
@@ -616,7 +666,7 @@ function parseDublinCoreMetadata(xml, metadata) {
 async function extractHwpxMetadataOnly(buffer) {
   let zip;
   try {
-    zip = await JSZip2.loadAsync(buffer);
+    zip = await JSZip.loadAsync(buffer);
   } catch {
     throw new KordocError("HWPX ZIP\uC744 \uC5F4 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
   }
@@ -811,7 +861,8 @@ function walkSection(node, blocks, tableCtx, tableStack, styleMap, warnings, sec
         if (newTable.rows.length > 0) {
           if (tableStack.length > 0) {
             const parentTable = tableStack.pop();
-            const nestedCols = Math.max(...newTable.rows.map((r) => r.length));
+            let nestedCols = 0;
+            for (const r of newTable.rows) if (r.length > nestedCols) nestedCols = r.length;
             if (newTable.rows.length >= 3 && nestedCols >= 2) {
               blocks.push({ type: "table", table: buildTable(newTable.rows), pageNumber: sectionNum });
             } else {
@@ -920,7 +971,8 @@ function walkParagraphChildren(node, blocks, tableCtx, tableStack, styleMap, war
         if (newTable.rows.length > 0) {
           if (tableStack.length > 0) {
             const parentTable = tableStack.pop();
-            const nestedCols = Math.max(...newTable.rows.map((r) => r.length));
+            let nestedCols = 0;
+            for (const r of newTable.rows) if (r.length > nestedCols) nestedCols = r.length;
             if (newTable.rows.length >= 3 && nestedCols >= 2) {
               blocks.push({ type: "table", table: buildTable(newTable.rows), pageNumber: sectionNum });
             } else {
@@ -2018,6 +2070,7 @@ function parseLenientCfb(data) {
   if (miniSectorSizeShift > 16) throw new Error("\uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 \uBBF8\uB2C8 \uC139\uD130 \uD06C\uAE30 \uC2DC\uD504\uD2B8: " + miniSectorSizeShift);
   const miniSectorSize = 1 << miniSectorSizeShift;
   const fatSectorCount = data.readUInt32LE(44);
+  if (fatSectorCount > 1e4) throw new Error("FAT \uC139\uD130 \uC218\uAC00 \uB108\uBB34 \uB9CE\uC2B5\uB2C8\uB2E4: " + fatSectorCount);
   const firstDirSector = data.readUInt32LE(48);
   const miniStreamCutoff = data.readUInt32LE(56);
   const firstMiniFatSector = data.readUInt32LE(60);
@@ -2406,10 +2459,14 @@ function findSections(cfb) {
 }
 function findSectionsLenient(lcfb, compressed) {
   const sections = [];
+  let totalDecompressed = 0;
   for (let i = 0; i < MAX_SECTIONS; i++) {
     const raw = lcfb.findStream(`/BodyText/Section${i}`) ?? lcfb.findStream(`Section${i}`);
     if (!raw) break;
-    sections.push({ idx: i, content: compressed ? decompressStream(raw) : raw });
+    const content = compressed ? decompressStream(raw) : raw;
+    totalDecompressed += content.length;
+    if (totalDecompressed > MAX_TOTAL_DECOMPRESS) throw new KordocError("\uCD1D \uC555\uCD95 \uD574\uC81C \uD06C\uAE30 \uCD08\uACFC (decompression bomb \uC758\uC2EC)");
+    sections.push({ idx: i, content });
   }
   if (sections.length === 0) {
     for (const e of lcfb.entries()) {
@@ -2417,7 +2474,12 @@ function findSectionsLenient(lcfb, compressed) {
       if (e.name.startsWith("Section")) {
         const idx = parseInt(e.name.replace("Section", ""), 10) || 0;
         const raw = lcfb.findStream(e.name);
-        if (raw) sections.push({ idx, content: compressed ? decompressStream(raw) : raw });
+        if (raw) {
+          const content = compressed ? decompressStream(raw) : raw;
+          totalDecompressed += content.length;
+          if (totalDecompressed > MAX_TOTAL_DECOMPRESS) throw new KordocError("\uCD1D \uC555\uCD95 \uD574\uC81C \uD06C\uAE30 \uCD08\uACFC (decompression bomb \uC758\uC2EC)");
+          sections.push({ idx, content });
+        }
       }
     }
   }
@@ -2425,11 +2487,15 @@ function findSectionsLenient(lcfb, compressed) {
 }
 function findViewTextSectionsLenient(lcfb, compressed) {
   const sections = [];
+  let totalDecompressed = 0;
   for (let i = 0; i < MAX_SECTIONS; i++) {
     const raw = lcfb.findStream(`/ViewText/Section${i}`) ?? lcfb.findStream(`Section${i}`);
     if (!raw) break;
     try {
-      sections.push({ idx: i, content: decryptViewText(raw, compressed) });
+      const content = decryptViewText(raw, compressed);
+      totalDecompressed += content.length;
+      if (totalDecompressed > MAX_TOTAL_DECOMPRESS) throw new KordocError("\uCD1D \uC555\uCD95 \uD574\uC81C \uD06C\uAE30 \uCD08\uACFC (decompression bomb \uC758\uC2EC)");
+      sections.push({ idx: i, content });
     } catch {
       break;
     }
@@ -2828,37 +2894,18 @@ function arrangeCells(rows, cols, cells) {
 // src/pdf/line-detector.ts
 import { OPS } from "pdfjs-dist/legacy/build/pdf.mjs";
 var ORIENTATION_TOL = 2;
-var MIN_LINE_LENGTH = 10;
-var COORD_MERGE_TOL = 3;
+var MIN_LINE_LENGTH = 15;
+var MAX_LINE_WIDTH = 5;
 var CONNECT_TOL = 5;
 var CELL_PADDING = 2;
-var MAX_LINE_WIDTH = 5;
-var IDENTITY = [1, 0, 0, 1, 0, 0];
-function matMultiply(m1, m2) {
-  return [
-    m1[0] * m2[0] + m1[2] * m2[1],
-    m1[1] * m2[0] + m1[3] * m2[1],
-    m1[0] * m2[2] + m1[2] * m2[3],
-    m1[1] * m2[2] + m1[3] * m2[3],
-    m1[0] * m2[4] + m1[2] * m2[5] + m1[4],
-    m1[1] * m2[4] + m1[3] * m2[5] + m1[5]
-  ];
-}
-function matTransformPoint(m, x, y) {
-  return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
-}
-function matScale(m) {
-  return Math.max(
-    Math.sqrt(m[1] * m[1] + m[3] * m[3]),
-    Math.sqrt(m[0] * m[0] + m[2] * m[2])
-  );
-}
+var MIN_COL_WIDTH = 15;
+var MIN_ROW_HEIGHT = 6;
+var VERTEX_MERGE_FACTOR = 4;
+var MIN_COORD_MERGE_TOL = 8;
 function extractLines(fnArray, argsArray) {
   const horizontals = [];
   const verticals = [];
-  let ctm = [...IDENTITY];
   let lineWidth = 1;
-  const stateStack = [];
   let currentPath = [];
   let pathStartX = 0, pathStartY = 0;
   let curX = 0, curY = 0;
@@ -2876,53 +2923,13 @@ function extractLines(fnArray, argsArray) {
       );
     }
   }
-  function tryConvertLinesToRectangle(path) {
-    if (path.length < 3 || path.length > 5) return false;
-    const first = path[0], last = path[path.length - 1];
-    const closed = Math.abs(first.x1 - last.x2) < 1 && Math.abs(first.y1 - last.y2) < 1;
-    if (!closed) return false;
-    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-    for (const seg of path) {
-      minX = Math.min(minX, seg.x1, seg.x2);
-      minY = Math.min(minY, seg.y1, seg.y2);
-      maxX = Math.max(maxX, seg.x1, seg.x2);
-      maxY = Math.max(maxY, seg.y1, seg.y2);
-    }
-    const w = maxX - minX, h = maxY - minY;
-    if (w < MIN_LINE_LENGTH && h < MIN_LINE_LENGTH) return false;
-    path.length = 0;
-    if (h < ORIENTATION_TOL * 2 || w > MIN_LINE_LENGTH && h <= MAX_LINE_WIDTH) {
-      path.push({ x1: minX, y1: (minY + maxY) / 2, x2: maxX, y2: (minY + maxY) / 2 });
-    } else if (w < ORIENTATION_TOL * 2 || h > MIN_LINE_LENGTH && w <= MAX_LINE_WIDTH) {
-      path.push({ x1: (minX + maxX) / 2, y1: minY, x2: (minX + maxX) / 2, y2: maxY });
-    } else {
-      pushRectangle(path, minX, minY, w, h);
-    }
-    return true;
-  }
-  function flushPath(isStroke, isFill) {
-    if (!isStroke && !isFill) {
-      currentPath = [];
-      return;
-    }
-    if (isFill && !isStroke && currentPath.length >= 3) {
-      tryConvertLinesToRectangle(currentPath);
-    }
-    const scale = matScale(ctm);
-    const effectiveLW = lineWidth * scale;
-    if (effectiveLW > MAX_LINE_WIDTH && isStroke && !isFill) {
+  function flushPath(isStroke) {
+    if (!isStroke) {
       currentPath = [];
       return;
     }
     for (const seg of currentPath) {
-      const [px1, py1] = matTransformPoint(ctm, seg.x1, seg.y1);
-      const [px2, py2] = matTransformPoint(ctm, seg.x2, seg.y2);
-      classifyAndAdd(
-        { x1: px1, y1: py1, x2: px2, y2: py2 },
-        effectiveLW,
-        horizontals,
-        verticals
-      );
+      classifyAndAdd(seg, lineWidth, horizontals, verticals);
     }
     currentPath = [];
   }
@@ -2930,28 +2937,9 @@ function extractLines(fnArray, argsArray) {
     const op = fnArray[i];
     const args = argsArray[i];
     switch (op) {
-      // ── Graphics State ──
-      case OPS.save:
-        stateStack.push({ ctm: [...ctm], lineWidth });
-        break;
-      case OPS.restore:
-        if (stateStack.length > 0) {
-          const state = stateStack.pop();
-          ctm = state.ctm;
-          lineWidth = state.lineWidth;
-        }
-        break;
-      case OPS.transform: {
-        const m = args;
-        if (m.length >= 6) {
-          ctm = matMultiply(ctm, [m[0], m[1], m[2], m[3], m[4], m[5]]);
-        }
-        break;
-      }
       case OPS.setLineWidth:
         lineWidth = args[0] || 1;
         break;
-      // ── Path Construction ──
       case OPS.constructPath: {
         const arg0 = args[0];
         if (Array.isArray(arg0)) {
@@ -3019,60 +3007,34 @@ function extractLines(fnArray, argsArray) {
               }
             }
           }
-          const isStroke5 = afterOp === OPS.stroke || afterOp === OPS.closeStroke;
-          const isFill5 = afterOp === OPS.fill || afterOp === OPS.eoFill;
-          const isBoth5 = afterOp === OPS.fillStroke || afterOp === OPS.eoFillStroke || afterOp === OPS.closeFillStroke || afterOp === OPS.closeEOFillStroke;
-          if (isStroke5 || isFill5 || isBoth5) {
-            flushPath(isStroke5 || isBoth5, isFill5 || isBoth5);
+          if (afterOp === OPS.stroke || afterOp === OPS.closeStroke) {
+            flushPath(true);
+          } else if (afterOp === OPS.fill || afterOp === OPS.eoFill || afterOp === OPS.fillStroke || afterOp === OPS.eoFillStroke || afterOp === OPS.closeFillStroke || afterOp === OPS.closeEOFillStroke) {
+            flushPath(true);
           } else if (afterOp === OPS.endPath) {
-            flushPath(false, false);
+            flushPath(false);
           }
         }
         break;
       }
-      // ── Paint Operations ──
       case OPS.stroke:
       case OPS.closeStroke:
-        flushPath(true, false);
+        flushPath(true);
         break;
       case OPS.fill:
       case OPS.eoFill:
-        flushPath(false, true);
-        break;
       case OPS.fillStroke:
       case OPS.eoFillStroke:
       case OPS.closeFillStroke:
       case OPS.closeEOFillStroke:
-        flushPath(true, true);
+        flushPath(true);
         break;
       case OPS.endPath:
-        flushPath(false, false);
-        break;
-    }
-  }
-  return {
-    horizontals: deduplicateLines(horizontals),
-    verticals: deduplicateLines(verticals)
-  };
-}
-function deduplicateLines(lines) {
-  if (lines.length <= 1) return lines;
-  const result = [];
-  const tol = COORD_MERGE_TOL;
-  for (const line of lines) {
-    let isDuplicate = false;
-    for (const existing of result) {
-      if (Math.abs(line.y1 - existing.y1) <= tol && Math.abs(line.y2 - existing.y2) <= tol && Math.abs(line.x1 - existing.x1) <= tol && Math.abs(line.x2 - existing.x2) <= tol) {
-        if (line.lineWidth > existing.lineWidth) {
-          existing.lineWidth = line.lineWidth;
-        }
-        isDuplicate = true;
+        flushPath(false);
         break;
-      }
     }
-    if (!isDuplicate) result.push(line);
   }
-  return result;
+  return { horizontals, verticals };
 }
 function classifyAndAdd(seg, lineWidth, horizontals, verticals) {
   const dx = Math.abs(seg.x2 - seg.x1);
@@ -3091,6 +3053,55 @@ function classifyAndAdd(seg, lineWidth, horizontals, verticals) {
     verticals.push({ x1: x, y1, x2: x, y2, lineWidth });
   }
 }
+function preprocessLines(horizontals, verticals) {
+  let h = horizontals.filter((l) => l.lineWidth <= MAX_LINE_WIDTH);
+  let v = verticals.filter((l) => l.lineWidth <= MAX_LINE_WIDTH);
+  h = mergeParallelLines(h, "h");
+  v = mergeParallelLines(v, "v");
+  return { horizontals: h, verticals: v };
+}
+function mergeParallelLines(lines, dir) {
+  if (lines.length <= 1) return lines;
+  const sorted = [...lines].sort((a, b) => {
+    const posA = dir === "h" ? a.y1 : a.x1;
+    const posB = dir === "h" ? b.y1 : b.x1;
+    if (Math.abs(posA - posB) > 0.1) return posA - posB;
+    return dir === "h" ? a.x1 - b.x1 : a.y1 - b.y1;
+  });
+  const MERGE_TOL = 3;
+  const result = [sorted[0]];
+  for (let i = 1; i < sorted.length; i++) {
+    const prev = result[result.length - 1];
+    const curr = sorted[i];
+    const prevPos = dir === "h" ? prev.y1 : prev.x1;
+    const currPos = dir === "h" ? curr.y1 : curr.x1;
+    if (Math.abs(prevPos - currPos) <= MERGE_TOL) {
+      const prevStart = dir === "h" ? prev.x1 : prev.y1;
+      const prevEnd = dir === "h" ? prev.x2 : prev.y2;
+      const currStart = dir === "h" ? curr.x1 : curr.y1;
+      const currEnd = dir === "h" ? curr.x2 : curr.y2;
+      const overlap = Math.min(prevEnd, currEnd) - Math.max(prevStart, currStart);
+      const minLen = Math.min(prevEnd - prevStart, currEnd - currStart);
+      if (overlap > minLen * 0.3) {
+        if (dir === "h") {
+          prev.x1 = Math.min(prev.x1, curr.x1);
+          prev.x2 = Math.max(prev.x2, curr.x2);
+          prev.y1 = (prev.y1 + curr.y1) / 2;
+          prev.y2 = prev.y1;
+        } else {
+          prev.y1 = Math.min(prev.y1, curr.y1);
+          prev.y2 = Math.max(prev.y2, curr.y2);
+          prev.x1 = (prev.x1 + curr.x1) / 2;
+          prev.x2 = prev.x1;
+        }
+        prev.lineWidth = Math.max(prev.lineWidth, curr.lineWidth);
+        continue;
+      }
+    }
+    result.push(curr);
+  }
+  return result;
+}
 function filterPageBorderLines(horizontals, verticals, pageWidth, pageHeight) {
   const margin = 5;
   return {
@@ -3102,8 +3113,49 @@ function filterPageBorderLines(horizontals, verticals, pageWidth, pageHeight) {
     )
   };
 }
+function buildVertices(horizontals, verticals) {
+  const vertices = [];
+  const tol = CONNECT_TOL;
+  for (const h of horizontals) {
+    for (const v of verticals) {
+      if (v.x1 >= h.x1 - tol && v.x1 <= h.x2 + tol && h.y1 >= v.y1 - tol && h.y1 <= v.y2 + tol) {
+        const radius = Math.max(h.lineWidth, v.lineWidth, 1);
+        vertices.push({ x: v.x1, y: h.y1, radius });
+      }
+    }
+  }
+  return vertices;
+}
+function mergeVertices(vertices) {
+  if (vertices.length <= 1) return vertices;
+  const merged = [];
+  const used = new Array(vertices.length).fill(false);
+  for (let i = 0; i < vertices.length; i++) {
+    if (used[i]) continue;
+    let sumX = vertices[i].x, sumY = vertices[i].y;
+    let maxRadius = vertices[i].radius;
+    let count = 1;
+    for (let j = i + 1; j < vertices.length; j++) {
+      if (used[j]) continue;
+      const mergeTol = VERTEX_MERGE_FACTOR * Math.max(maxRadius, vertices[j].radius);
+      if (Math.abs(vertices[i].x - vertices[j].x) <= mergeTol && Math.abs(vertices[i].y - vertices[j].y) <= mergeTol) {
+        sumX += vertices[j].x;
+        sumY += vertices[j].y;
+        maxRadius = Math.max(maxRadius, vertices[j].radius);
+        count++;
+        used[j] = true;
+      }
+    }
+    merged.push({ x: sumX / count, y: sumY / count, radius: maxRadius });
+  }
+  return merged;
+}
 function buildTableGrids(horizontals, verticals) {
   if (horizontals.length < 2 || verticals.length < 2) return [];
+  const allVertices = buildVertices(horizontals, verticals);
+  const vertices = mergeVertices(allVertices);
+  if (vertices.length < 4) return [];
+  const globalRadius = vertices.reduce((max, v) => Math.max(max, v.radius), 1);
   const allLines = [
     ...horizontals.map((l, i) => ({ ...l, type: "h", id: i })),
     ...verticals.map((l, i) => ({ ...l, type: "v", id: i + horizontals.length }))
@@ -3114,21 +3166,74 @@ function buildTableGrids(horizontals, verticals) {
     const hLines = group.filter((l) => l.type === "h");
     const vLines = group.filter((l) => l.type === "v");
     if (hLines.length < 2 || vLines.length < 2) continue;
-    const rawYs = hLines.map((l) => l.y1);
-    const rowYs = clusterCoordinates(rawYs).sort((a, b) => b - a);
-    const rawXs = vLines.map((l) => l.x1);
-    const colXs = clusterCoordinates(rawXs).sort((a, b) => a - b);
+    let gx1 = Infinity, gy1 = Infinity, gx2 = -Infinity, gy2 = -Infinity;
+    for (const l of vLines) {
+      if (l.x1 < gx1) gx1 = l.x1;
+      if (l.x1 > gx2) gx2 = l.x1;
+    }
+    for (const l of hLines) {
+      if (l.y1 < gy1) gy1 = l.y1;
+      if (l.y1 > gy2) gy2 = l.y1;
+    }
+    const groupBbox = {
+      x1: gx1 - CONNECT_TOL,
+      y1: gy1 - CONNECT_TOL,
+      x2: gx2 + CONNECT_TOL,
+      y2: gy2 + CONNECT_TOL
+    };
+    const groupVertices = vertices.filter(
+      (v) => v.x >= groupBbox.x1 && v.x <= groupBbox.x2 && v.y >= groupBbox.y1 && v.y <= groupBbox.y2
+    );
+    const groupRadius = groupVertices.length > 0 ? groupVertices.reduce((max, v) => Math.max(max, v.radius), 1) : globalRadius;
+    const coordMergeTol = Math.max(VERTEX_MERGE_FACTOR * groupRadius, MIN_COORD_MERGE_TOL);
+    const rawYs = [
+      ...hLines.map((l) => l.y1),
+      ...groupVertices.map((v) => v.y)
+    ];
+    const rowYs = clusterCoordinates(rawYs, coordMergeTol).sort((a, b) => b - a);
+    const rawXs = [
+      ...vLines.map((l) => l.x1),
+      ...groupVertices.map((v) => v.x)
+    ];
+    const colXs = clusterCoordinates(rawXs, coordMergeTol).sort((a, b) => a - b);
     if (rowYs.length < 2 || colXs.length < 2) continue;
+    const validColXs = enforceMinWidth(colXs, MIN_COL_WIDTH);
+    const validRowYs = enforceMinHeight(rowYs, MIN_ROW_HEIGHT);
+    if (validRowYs.length < 2 || validColXs.length < 2) continue;
     const bbox = {
-      x1: colXs[0],
-      y1: rowYs[rowYs.length - 1],
-      x2: colXs[colXs.length - 1],
-      y2: rowYs[0]
+      x1: validColXs[0],
+      y1: validRowYs[validRowYs.length - 1],
+      x2: validColXs[validColXs.length - 1],
+      y2: validRowYs[0]
     };
-    grids.push({ rowYs, colXs, bbox });
+    grids.push({ rowYs: validRowYs, colXs: validColXs, bbox, vertexRadius: groupRadius });
   }
   return mergeAdjacentGrids(grids);
 }
+function enforceMinWidth(colXs, minWidth) {
+  if (colXs.length <= 2) return colXs;
+  const result = [colXs[0]];
+  for (let i = 1; i < colXs.length; i++) {
+    const prevX = result[result.length - 1];
+    if (colXs[i] - prevX < minWidth && i < colXs.length - 1) {
+      continue;
+    }
+    result.push(colXs[i]);
+  }
+  return result;
+}
+function enforceMinHeight(rowYs, minHeight) {
+  if (rowYs.length <= 2) return rowYs;
+  const result = [rowYs[0]];
+  for (let i = 1; i < rowYs.length; i++) {
+    const prevY = result[result.length - 1];
+    if (prevY - rowYs[i] < minHeight && i < rowYs.length - 1) {
+      continue;
+    }
+    result.push(rowYs[i]);
+  }
+  return result;
+}
 function mergeAdjacentGrids(grids) {
   if (grids.length <= 1) return grids;
   const sorted = [...grids].sort((a, b) => b.bbox.y2 - a.bbox.y2);
@@ -3137,9 +3242,10 @@ function mergeAdjacentGrids(grids) {
     const prev = merged[merged.length - 1];
     const curr = sorted[i];
     if (prev.colXs.length === curr.colXs.length) {
-      const colMatch = prev.colXs.every((x, ci) => Math.abs(x - curr.colXs[ci]) <= COORD_MERGE_TOL * 3);
+      const mergeTol = Math.max(VERTEX_MERGE_FACTOR * Math.max(prev.vertexRadius, curr.vertexRadius), 6) * 3;
+      const colMatch = prev.colXs.every((x, ci) => Math.abs(x - curr.colXs[ci]) <= mergeTol);
       const verticalGap = prev.bbox.y1 - curr.bbox.y2;
-      if (colMatch && verticalGap >= -COORD_MERGE_TOL && verticalGap <= 20) {
+      if (colMatch && verticalGap >= -CONNECT_TOL && verticalGap <= 20) {
         const allRowYs = [.../* @__PURE__ */ new Set([...prev.rowYs, ...curr.rowYs])].sort((a, b) => b - a);
         merged[merged.length - 1] = {
           rowYs: allRowYs,
@@ -3149,7 +3255,8 @@ function mergeAdjacentGrids(grids) {
             y1: Math.min(prev.bbox.y1, curr.bbox.y1),
             x2: Math.max(prev.bbox.x2, curr.bbox.x2),
             y2: Math.max(prev.bbox.y2, curr.bbox.y2)
-          }
+          },
+          vertexRadius: Math.max(prev.vertexRadius, curr.vertexRadius)
         };
         continue;
       }
@@ -3158,14 +3265,14 @@ function mergeAdjacentGrids(grids) {
   }
   return merged;
 }
-function clusterCoordinates(values) {
+function clusterCoordinates(values, tolerance) {
   if (values.length === 0) return [];
   const sorted = [...values].sort((a, b) => a - b);
   const clusters = [{ sum: sorted[0], count: 1 }];
   for (let i = 1; i < sorted.length; i++) {
     const last = clusters[clusters.length - 1];
     const avg = last.sum / last.count;
-    if (Math.abs(sorted[i] - avg) <= COORD_MERGE_TOL) {
+    if (Math.abs(sorted[i] - avg) <= tolerance) {
       last.sum += sorted[i];
       last.count++;
     } else {
@@ -3222,6 +3329,20 @@ function extractCells(grid, horizontals, verticals) {
   const numRows = rowYs.length - 1;
   const numCols = colXs.length - 1;
   if (numRows <= 0 || numCols <= 0) return [];
+  const vBorders = Array.from(
+    { length: numRows },
+    (_, r) => Array.from(
+      { length: numCols + 1 },
+      (_2, c) => hasVerticalLine(verticals, colXs[c], rowYs[r], rowYs[r + 1], grid.vertexRadius)
+    )
+  );
+  const hBorders = Array.from(
+    { length: numRows + 1 },
+    (_, r) => Array.from(
+      { length: numCols },
+      (_2, c) => hasHorizontalLine(horizontals, rowYs[r], colXs[c], colXs[c + 1], grid.vertexRadius)
+    )
+  );
   const occupied = Array.from({ length: numRows }, () => Array(numCols).fill(false));
   const cells = [];
   for (let r = 0; r < numRows; r++) {
@@ -3229,18 +3350,26 @@ function extractCells(grid, horizontals, verticals) {
       if (occupied[r][c]) continue;
       let colSpan = 1;
       let rowSpan = 1;
-      while (c + colSpan < numCols) {
-        const borderX = colXs[c + colSpan];
-        const topY = rowYs[r];
-        const botY = rowYs[r + 1];
-        if (hasVerticalLine(verticals, borderX, topY, botY)) break;
+      while (c + colSpan < numCols && !vBorders[r][c + colSpan]) {
+        let canExpand = true;
+        for (let dr = 0; dr < rowSpan; dr++) {
+          if (vBorders[r + dr][c + colSpan]) {
+            canExpand = false;
+            break;
+          }
+        }
+        if (!canExpand) break;
         colSpan++;
       }
       while (r + rowSpan < numRows) {
-        const borderY = rowYs[r + rowSpan];
-        const leftX = colXs[c];
-        const rightX = colXs[c + colSpan];
-        if (hasHorizontalLine(horizontals, borderY, leftX, rightX)) break;
+        let hasLine = false;
+        for (let dc = 0; dc < colSpan; dc++) {
+          if (hBorders[r + rowSpan][c + dc]) {
+            hasLine = true;
+            break;
+          }
+        }
+        if (hasLine) break;
         rowSpan++;
       }
       for (let dr = 0; dr < rowSpan; dr++) {
@@ -3264,28 +3393,30 @@ function extractCells(grid, horizontals, verticals) {
   }
   return cells;
 }
-function hasVerticalLine(verticals, x, topY, botY) {
-  const tol = COORD_MERGE_TOL + 1;
+function hasVerticalLine(verticals, x, topY, botY, vertexRadius) {
+  const tol = Math.max(VERTEX_MERGE_FACTOR * vertexRadius, 4);
   for (const v of verticals) {
     if (Math.abs(v.x1 - x) <= tol) {
       const cellH = Math.abs(topY - botY);
+      if (cellH < 0.1) continue;
       const overlapTop = Math.min(v.y2, topY);
       const overlapBot = Math.max(v.y1, botY);
       const overlap = overlapTop - overlapBot;
-      if (overlap >= cellH * 0.5) return true;
+      if (overlap >= cellH * 0.75) return true;
     }
   }
   return false;
 }
-function hasHorizontalLine(horizontals, y, leftX, rightX) {
-  const tol = COORD_MERGE_TOL + 1;
+function hasHorizontalLine(horizontals, y, leftX, rightX, vertexRadius) {
+  const tol = Math.max(VERTEX_MERGE_FACTOR * vertexRadius, 4);
   for (const h of horizontals) {
     if (Math.abs(h.y1 - y) <= tol) {
       const cellW = Math.abs(rightX - leftX);
+      if (cellW < 0.1) continue;
       const overlapLeft = Math.max(h.x1, leftX);
       const overlapRight = Math.min(h.x2, rightX);
       const overlap = overlapRight - overlapLeft;
-      if (overlap >= cellW * 0.5) return true;
+      if (overlap >= cellW * 0.75) return true;
     }
   }
   return false;
@@ -3296,23 +3427,24 @@ function mapTextToCells(items, cells) {
     result.set(cell, []);
   }
   for (const item of items) {
-    const cx = item.x + item.w / 2;
-    const cy = item.y;
     const pad = CELL_PADDING;
     let bestCell = null;
-    let bestDist = Infinity;
+    let bestScore = 0;
     for (const cell of cells) {
-      if (cx >= cell.bbox.x1 - pad && cx <= cell.bbox.x2 + pad && cy >= cell.bbox.y1 - pad && cy <= cell.bbox.y2 + pad) {
-        const cellCx = (cell.bbox.x1 + cell.bbox.x2) / 2;
-        const cellCy = (cell.bbox.y1 + cell.bbox.y2) / 2;
-        const dist = Math.abs(cx - cellCx) + Math.abs(cy - cellCy);
-        if (dist < bestDist) {
-          bestDist = dist;
-          bestCell = cell;
-        }
+      const ix1 = Math.max(item.x, cell.bbox.x1 - pad);
+      const ix2 = Math.min(item.x + item.w, cell.bbox.x2 + pad);
+      const iy1 = Math.max(item.y, cell.bbox.y1 - pad);
+      const iy2 = Math.min(item.y + (item.h || item.fontSize), cell.bbox.y2 + pad);
+      if (ix1 >= ix2 || iy1 >= iy2) continue;
+      const intersectArea = (ix2 - ix1) * (iy2 - iy1);
+      const itemArea = Math.max(item.w, 1) * Math.max(item.h || item.fontSize, 1);
+      const score = intersectArea / itemArea;
+      if (score > bestScore) {
+        bestScore = score;
+        bestCell = cell;
       }
     }
-    if (bestCell) {
+    if (bestCell && bestScore > 0.3) {
       result.get(bestCell).push(item);
     }
   }
@@ -3339,8 +3471,13 @@ function cellTextToString(items) {
   const textLines = lines.map((line) => {
     const s = line.sort((a, b) => a.x - b.x);
     if (s.length === 1) return s[0].text;
+    const evenSpaced = detectEvenSpacedItems(s);
     let result = s[0].text;
     for (let j = 1; j < s.length; j++) {
+      if (evenSpaced[j]) {
+        result += s[j].text;
+        continue;
+      }
       const gap = s[j].x - (s[j - 1].x + s[j - 1].w);
       const avgFs = (s[j].fontSize + s[j - 1].fontSize) / 2;
       const prevIsKorean = /[가-힣]$/.test(result);
@@ -3355,6 +3492,57 @@ function cellTextToString(items) {
     }
     return result;
   });
+  return mergeCellTextLines(textLines);
+}
+function detectEvenSpacedItems(items) {
+  const result = new Array(items.length).fill(false);
+  if (items.length < 3) return result;
+  let runStart = -1;
+  for (let i = 0; i < items.length; i++) {
+    const isShortKorean = /^[가-힣]{1}$/.test(items[i].text) || /^[\d]{1}$/.test(items[i].text);
+    if (isShortKorean && runStart >= 0 && i > 0) {
+      const gap = items[i].x - (items[i - 1].x + items[i - 1].w);
+      const maxRunGap = Math.max(items[i].fontSize * 3, 30);
+      if (gap > maxRunGap) {
+        if (i - runStart >= 3) markEvenRun(items, result, runStart, i);
+        runStart = i;
+        continue;
+      }
+    }
+    if (isShortKorean) {
+      if (runStart < 0) runStart = i;
+    } else {
+      if (runStart >= 0 && i - runStart >= 3) {
+        markEvenRun(items, result, runStart, i);
+      }
+      runStart = -1;
+    }
+  }
+  if (runStart >= 0 && items.length - runStart >= 3) {
+    markEvenRun(items, result, runStart, items.length);
+  }
+  return result;
+}
+function markEvenRun(items, result, start, end) {
+  const gaps = [];
+  for (let i = start + 1; i < end; i++) {
+    gaps.push(items[i].x - (items[i - 1].x + items[i - 1].w));
+  }
+  const posGaps = gaps.filter((g2) => g2 > 0);
+  if (posGaps.length < 2) return;
+  let minGap = Infinity, maxGap = -Infinity;
+  for (const g2 of posGaps) {
+    if (g2 < minGap) minGap = g2;
+    if (g2 > maxGap) maxGap = g2;
+  }
+  const avgFs = items[start].fontSize;
+  if (minGap >= avgFs * 0.1 && maxGap <= avgFs * 3 && maxGap / Math.max(minGap, 0.1) <= 3) {
+    for (let i = start + 1; i < end; i++) {
+      result[i] = true;
+    }
+  }
+}
+function mergeCellTextLines(textLines) {
   if (textLines.length <= 1) return textLines[0] || "";
   const merged = [textLines[0]];
   for (let i = 1; i < textLines.length; i++) {
@@ -3380,24 +3568,172 @@ var Y_TOL = 3;
 var COL_CLUSTER_TOL = 15;
 var MIN_ROWS = 3;
 var MIN_COLS = 2;
-var MIN_GAP_FACTOR = 1.5;
-var MIN_COL_FILL_RATIO = 0.3;
+var MIN_GAP_FACTOR = 2;
+var MIN_GAP_ABSOLUTE = 20;
+var MIN_COL_FILL_RATIO = 0.4;
 function detectClusterTables(items, pageNum) {
   if (items.length < MIN_ROWS * MIN_COLS) return [];
-  const rows = groupByBaseline(items);
+  const { merged, originMap } = mergeEvenSpacedClusters(items);
+  const rows = groupByBaseline(merged);
   if (rows.length < MIN_ROWS) return [];
-  const suspiciousRows = rows.filter((row) => hasSuspiciousGaps(row));
-  if (suspiciousRows.length < MIN_ROWS) return [];
-  const columns = extractColumnClusters(suspiciousRows);
-  if (columns.length < MIN_COLS) return [];
-  const tableRegions = findTableRegions(rows, columns);
   const results = [];
-  for (const region of tableRegions) {
-    const table = buildClusterTable(region.rows, columns, pageNum);
-    if (table) results.push(table);
+  const headerResult = detectHeaderRow(rows);
+  if (headerResult) {
+    const { columns, headerIdx } = headerResult;
+    const headerRow = rows[headerIdx];
+    const headerItems = [...headerRow.items].sort((a, b) => a.x - b.x);
+    const headerAndBelow = rows.slice(headerIdx);
+    const mergedRows = mergeMultiLineRows(headerAndBelow, columns);
+    const tableRegions = findTableRegionsByHeader(mergedRows, columns, headerItems);
+    for (const region of tableRegions) {
+      const table = buildClusterTable(region.rows, columns, pageNum);
+      if (table) {
+        expandUsedItems(table.usedItems, originMap);
+        results.push(table);
+      }
+    }
+  }
+  if (results.length === 0) {
+    const suspiciousRows = rows.filter((row) => hasSuspiciousGaps(row));
+    if (suspiciousRows.length >= MIN_ROWS) {
+      const columns = extractColumnClusters(suspiciousRows);
+      if (columns.length >= MIN_COLS) {
+        const tableRegions = findTableRegions(rows, columns);
+        for (const region of tableRegions) {
+          const mergedRows = mergeMultiLineRows(region.rows, columns);
+          const table = buildClusterTable(mergedRows, columns, pageNum);
+          if (table) {
+            expandUsedItems(table.usedItems, originMap);
+            results.push(table);
+          }
+        }
+      }
+    }
   }
   return results;
 }
+function mergeEvenSpacedClusters(items) {
+  const originMap = /* @__PURE__ */ new Map();
+  const rows = groupByBaseline(items);
+  const merged = [];
+  for (const row of rows) {
+    const sorted = [...row.items].sort((a, b) => a.x - b.x);
+    let i = 0;
+    while (i < sorted.length) {
+      if (/^[가-힣\d]$/.test(sorted[i].text)) {
+        let runEnd = i + 1;
+        while (runEnd < sorted.length && /^[가-힣\d]$/.test(sorted[runEnd].text)) {
+          const gap = sorted[runEnd].x - (sorted[runEnd - 1].x + sorted[runEnd - 1].w);
+          const fs = sorted[runEnd].fontSize;
+          if (gap < fs * 0.1 || gap > fs * 3) break;
+          runEnd++;
+        }
+        if (runEnd - i >= 3) {
+          const gaps = [];
+          for (let g2 = i + 1; g2 < runEnd; g2++) {
+            gaps.push(sorted[g2].x - (sorted[g2 - 1].x + sorted[g2 - 1].w));
+          }
+          let minG = Infinity, maxG = -Infinity;
+          for (const g2 of gaps) {
+            if (g2 < minG) minG = g2;
+            if (g2 > maxG) maxG = g2;
+          }
+          if (minG > 0 && maxG / minG <= 3) {
+            const run = sorted.slice(i, runEnd);
+            const text = run.map((r) => r.text).join("");
+            const first = run[0], last = run[runEnd - i - 1];
+            const item = {
+              text,
+              x: first.x,
+              y: first.y,
+              w: last.x + last.w - first.x,
+              h: first.h,
+              fontSize: first.fontSize,
+              fontName: first.fontName
+            };
+            originMap.set(item, run);
+            merged.push(item);
+            i = runEnd;
+            continue;
+          }
+        }
+      }
+      merged.push(sorted[i]);
+      i++;
+    }
+  }
+  return { merged, originMap };
+}
+function expandUsedItems(usedItems, originMap) {
+  const toAdd = [];
+  for (const item of usedItems) {
+    const origins = originMap.get(item);
+    if (origins) for (const o of origins) toAdd.push(o);
+  }
+  for (const a of toAdd) usedItems.add(a);
+}
+function detectHeaderRow(rows) {
+  const allItems = rows.flatMap((r) => r.items);
+  if (allItems.length === 0) return null;
+  let allMinX = Infinity, allMaxX = -Infinity;
+  for (const i of allItems) {
+    if (i.x < allMinX) allMinX = i.x;
+    const r = i.x + i.w;
+    if (r > allMaxX) allMaxX = r;
+  }
+  const pageSpan = allMaxX - allMinX;
+  if (pageSpan <= 0) return null;
+  for (let ri = 0; ri < rows.length; ri++) {
+    const row = rows[ri];
+    if (row.items.length < MIN_COLS || row.items.length > 6) continue;
+    if (row.items.some((i) => i.text.length > 8)) continue;
+    if (!row.items.some((i) => /[가-힣]/.test(i.text))) continue;
+    if (row.items.some((i) => /^[□■○●·※▶▷◆◇\-]/.test(i.text))) continue;
+    const sorted = [...row.items].sort((a, b) => a.x - b.x);
+    const xSpan = sorted[sorted.length - 1].x + sorted[sorted.length - 1].w - sorted[0].x;
+    if (xSpan / pageSpan < 0.4) continue;
+    const avgFs = sorted.reduce((s, i) => s + i.fontSize, 0) / sorted.length;
+    let hasLargeGap = false;
+    for (let i = 1; i < sorted.length; i++) {
+      const gap = sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w);
+      if (gap >= avgFs * 2.5) {
+        hasLargeGap = true;
+        break;
+      }
+    }
+    if (!hasLargeGap) continue;
+    const columns = sorted.map((item) => ({ x: item.x, count: 0 }));
+    let matchCount = 0;
+    for (let j = ri + 1; j < rows.length && matchCount < MIN_ROWS + 2; j++) {
+      const matched = countMatchedColumnsRange(rows[j], columns, sorted);
+      if (matched >= MIN_COLS) matchCount++;
+    }
+    if (matchCount < MIN_ROWS) continue;
+    return { columns, headerIdx: ri };
+  }
+  return null;
+}
+function mergeMultiLineRows(rows, columns) {
+  if (rows.length <= 1) return rows;
+  const result = [rows[0]];
+  const allFontSizes = rows.flatMap((r) => r.items).map((i) => i.fontSize);
+  const avgFontSize = allFontSizes.length > 0 ? allFontSizes.reduce((s, v) => s + v, 0) / allFontSizes.length : 12;
+  for (let i = 1; i < rows.length; i++) {
+    const prev = result[result.length - 1];
+    const curr = rows[i];
+    const yGap = Math.abs(prev.y - curr.y);
+    const matchedCols = countMatchedColumns(curr, columns);
+    if (yGap < avgFontSize * 1.8 && curr.items.length <= 2 && (matchedCols < MIN_COLS || curr.items.length === 1)) {
+      result[result.length - 1] = {
+        y: prev.y,
+        items: [...prev.items, ...curr.items]
+      };
+    } else {
+      result.push(curr);
+    }
+  }
+  return result;
+}
 function groupByBaseline(items) {
   if (items.length === 0) return [];
   const sorted = [...items].sort((a, b) => b.y - a.y || a.x - b.x);
@@ -3419,8 +3755,9 @@ function groupByBaseline(items) {
 function hasSuspiciousGaps(row) {
   if (row.items.length < 2) return false;
   const sorted = [...row.items].sort((a, b) => a.x - b.x);
+  if (sorted.length === 2 && sorted[1].text.length > 20) return false;
   const avgFontSize = sorted.reduce((s, i) => s + i.fontSize, 0) / sorted.length;
-  const minGap = avgFontSize * MIN_GAP_FACTOR;
+  const minGap = Math.max(avgFontSize * MIN_GAP_FACTOR, MIN_GAP_ABSOLUTE);
   for (let i = 1; i < sorted.length; i++) {
     const gap = sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w);
     if (gap >= minGap) return true;
@@ -3447,6 +3784,41 @@ function extractColumnClusters(rows) {
   const minCount = Math.max(2, Math.floor(rows.length * MIN_COL_FILL_RATIO));
   return clusters.filter((c) => c.count >= minCount).sort((a, b) => a.x - b.x);
 }
+function findTableRegionsByHeader(allRows, columns, headerItems) {
+  const regions = [];
+  let currentRegion = [];
+  let missStreak = 0;
+  for (const row of allRows) {
+    const matchedCols = countMatchedColumnsRange(row, columns, headerItems);
+    if (matchedCols >= MIN_COLS) {
+      currentRegion.push(row);
+      missStreak = 0;
+    } else if (currentRegion.length > 0 && (row.items.length <= 2 || missStreak === 0)) {
+      currentRegion.push(row);
+      missStreak++;
+    } else {
+      while (currentRegion.length > 0) {
+        const last = currentRegion[currentRegion.length - 1];
+        if (countMatchedColumnsRange(last, columns, headerItems) >= MIN_COLS) break;
+        currentRegion.pop();
+      }
+      if (currentRegion.length >= MIN_ROWS) {
+        regions.push({ rows: [...currentRegion] });
+      }
+      currentRegion = [];
+      missStreak = 0;
+    }
+  }
+  while (currentRegion.length > 0) {
+    const last = currentRegion[currentRegion.length - 1];
+    if (countMatchedColumnsRange(last, columns, headerItems) >= MIN_COLS) break;
+    currentRegion.pop();
+  }
+  if (currentRegion.length >= MIN_ROWS) {
+    regions.push({ rows: currentRegion });
+  }
+  return regions;
+}
 function findTableRegions(allRows, columns) {
   const regions = [];
   let currentRegion = [];
@@ -3482,18 +3854,81 @@ function countMatchedColumns(row, columns) {
   }
   return matched.size;
 }
-function assignToColumn(item, columns) {
-  const MAX_DIST = COL_CLUSTER_TOL * 3;
-  let bestCol = -1;
-  let bestDist = Infinity;
-  for (let ci = 0; ci < columns.length; ci++) {
-    const dist = Math.abs(item.x - columns[ci].x);
-    if (dist < bestDist) {
-      bestDist = dist;
-      bestCol = ci;
+function countMatchedColumnsRange(row, columns, headerItems) {
+  const boundaries = [];
+  for (let ci = 0; ci < headerItems.length; ci++) {
+    const left = ci === 0 ? 0 : (headerItems[ci - 1].x + headerItems[ci - 1].w + headerItems[ci].x) / 2;
+    const right = ci === headerItems.length - 1 ? Infinity : (headerItems[ci].x + headerItems[ci].w + headerItems[ci + 1].x) / 2;
+    boundaries.push({ left, right });
+  }
+  const matched = /* @__PURE__ */ new Set();
+  for (const item of row.items) {
+    for (let ci = 0; ci < boundaries.length; ci++) {
+      if (item.x >= boundaries[ci].left && item.x < boundaries[ci].right) {
+        matched.add(ci);
+        break;
+      }
     }
   }
-  return bestDist <= MAX_DIST ? bestCol : -1;
+  return matched.size;
+}
+function assignRowItems(items, columns, numCols) {
+  if (items.length === 0) return [];
+  const sorted = [...items].sort((a, b) => a.x - b.x);
+  const colCenters = columns.map((c) => c.x);
+  const gaps = [];
+  for (let i = 1; i < sorted.length; i++) {
+    gaps.push({ idx: i, size: sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w) });
+  }
+  const gapSizes = gaps.map((g2) => g2.size).sort((a, b) => a - b);
+  const medianGap = gapSizes.length > 0 ? gapSizes[Math.floor(gapSizes.length / 2)] : 0;
+  const gapThreshold = sorted.length <= numCols + 1 ? 12 : Math.max(medianGap * 2.5, 12);
+  const significantGaps = gaps.filter((g2) => g2.size >= gapThreshold).sort((a, b) => b.size - a.size).slice(0, numCols - 1).sort((a, b) => a.idx - b.idx);
+  const groups = [];
+  let start = 0;
+  for (const gap of significantGaps) {
+    groups.push(sorted.slice(start, gap.idx));
+    start = gap.idx;
+  }
+  groups.push(sorted.slice(start));
+  const result = [];
+  const usedCols = /* @__PURE__ */ new Set();
+  const groupCenters = groups.map((g2) => {
+    let minX = Infinity, maxX = -Infinity;
+    for (const i of g2) {
+      if (i.x < minX) minX = i.x;
+      const r = i.x + i.w;
+      if (r > maxX) maxX = r;
+    }
+    return (minX + maxX) / 2;
+  });
+  const assignments = [];
+  for (let gi = 0; gi < groups.length; gi++) {
+    for (let ci = 0; ci < numCols; ci++) {
+      assignments.push({ gi, ci, dist: Math.abs(groupCenters[gi] - colCenters[ci]) });
+    }
+  }
+  assignments.sort((a, b) => a.dist - b.dist);
+  const assignedGroups = /* @__PURE__ */ new Set();
+  for (const { gi, ci } of assignments) {
+    if (assignedGroups.has(gi) || usedCols.has(ci)) continue;
+    result.push({ col: ci, items: groups[gi] });
+    assignedGroups.add(gi);
+    usedCols.add(ci);
+  }
+  for (let gi = 0; gi < groups.length; gi++) {
+    if (assignedGroups.has(gi)) continue;
+    let bestCol = 0, bestDist = Infinity;
+    for (let ci = 0; ci < numCols; ci++) {
+      const d = Math.abs(groupCenters[gi] - colCenters[ci]);
+      if (d < bestDist) {
+        bestDist = d;
+        bestCol = ci;
+      }
+    }
+    result.push({ col: bestCol, items: groups[gi] });
+  }
+  return result;
 }
 function buildClusterTable(rows, columns, pageNum) {
   const numCols = columns.length;
@@ -3511,12 +3946,12 @@ function buildClusterTable(rows, columns, pageNum) {
       usedItems.add(row.items[0]);
       continue;
     }
-    for (const item of row.items) {
-      const col = assignToColumn(item, columns);
-      if (col < 0) continue;
+    const assignments = assignRowItems(row.items, columns, numCols);
+    for (const { col, items } of assignments) {
+      const text = items.map((i) => i.text).join(" ");
       const existing = cells[r][col].text;
-      cells[r][col].text = existing ? existing + " " + item.text : item.text;
-      usedItems.add(item);
+      cells[r][col].text = existing ? existing + " " + text : text;
+      for (const item of items) usedItems.add(item);
     }
   }
   let emptyRows = 0;
@@ -3528,11 +3963,48 @@ function buildClusterTable(rows, columns, pageNum) {
     const hasValue = cells.some((row) => row[c].text !== "");
     if (!hasValue) return null;
   }
+  for (let r = numRows - 1; r >= 1; r--) {
+    const nonEmptyCols = cells[r].filter((c) => c.text.trim()).length;
+    if (nonEmptyCols !== 1) continue;
+    if (cells[r][0].text.trim() !== "") continue;
+    const contentText = cells[r].find((c) => c.text.trim())?.text.trim() || "";
+    if (/^[○●▶\-·]/.test(contentText)) continue;
+    for (let pr = r - 1; pr >= 0; pr--) {
+      if (cells[pr].some((c) => c.text.trim())) {
+        for (let c = 0; c < numCols; c++) {
+          const prev = cells[pr][c].text.trim();
+          const curr = cells[r][c].text.trim();
+          if (curr) cells[pr][c].text = prev ? prev + " " + curr : curr;
+        }
+        for (let c = 0; c < numCols; c++) cells[r][c].text = "";
+        break;
+      }
+    }
+  }
+  for (let r = 0; r < cells.length - 1; r++) {
+    const row = cells[r];
+    const hasCol0 = row[0].text.trim() !== "";
+    const hasColLast = numCols > 1 && row[numCols - 1].text.trim() !== "";
+    const midEmpty = row.slice(1, numCols - 1).every((c) => c.text.trim() === "");
+    if (hasCol0 && hasColLast && midEmpty) {
+      const next = cells[r + 1];
+      if (next[0].text.trim() === "" && next.some((c) => c.text.trim())) {
+        for (let c = 1; c < numCols; c++) {
+          const curr = next[c].text.trim();
+          if (curr) row[c].text = row[c].text.trim() ? row[c].text.trim() + " " + curr : curr;
+        }
+        for (let c = 0; c < numCols; c++) next[c].text = "";
+      }
+    }
+  }
+  const filteredCells = cells.filter((row) => row.some((c) => c.text.trim()));
+  const finalRowCount = filteredCells.length;
+  if (finalRowCount < MIN_ROWS) return null;
   const irTable = {
-    rows: numRows,
+    rows: finalRowCount,
     cols: numCols,
-    cells,
-    hasHeader: numRows > 1
+    cells: filteredCells,
+    hasHeader: finalRowCount > 1
   };
   const allItems = rows.flatMap((r) => r.items);
   let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
@@ -3609,7 +4081,7 @@ async function parsePdfDocument(buffer, options) {
     const effectivePageCount = Math.min(pageCount, MAX_PAGES);
     const pageFilter = options?.pages ? parsePageRange(options.pages, effectivePageCount) : null;
     const totalTarget = pageFilter ? pageFilter.size : effectivePageCount;
-    const allFontSizes = [];
+    const fontSizeFreq = /* @__PURE__ */ new Map();
     const pageHeights = /* @__PURE__ */ new Map();
     let parsedPages = 0;
     for (let i = 1; i <= effectivePageCount; i++) {
@@ -3626,7 +4098,7 @@ async function parsePdfDocument(buffer, options) {
           warnings.push({ page: i, message: `${hiddenCount}\uAC1C \uC228\uACA8\uC9C4 \uD14D\uC2A4\uD2B8 \uC694\uC18C \uD544\uD130\uB9C1\uB428`, code: "HIDDEN_TEXT_FILTERED" });
         }
         for (const item of visible) {
-          if (item.fontSize > 0) allFontSizes.push(item.fontSize);
+          if (item.fontSize > 0) fontSizeFreq.set(item.fontSize, (fontSizeFreq.get(item.fontSize) || 0) + 1);
         }
         const opList = await page.getOperatorList();
         const pageBlocks = extractPageBlocksWithLines(visible, i, opList, viewport.width, viewport.height);
@@ -3665,10 +4137,9 @@ async function parsePdfDocument(buffer, options) {
         blocks.splice(removed[ri], 1);
       }
     }
-    const medianFontSize = computeMedianFontSize(allFontSizes);
+    const medianFontSize = computeMedianFontSizeFromFreq(fontSizeFreq);
     if (medianFontSize > 0) {
       detectHeadings(blocks, medianFontSize);
-      mergeAdjacentHeadings(blocks);
     }
     detectMarkerHeadings(blocks);
     const outline = blocks.filter((b) => b.type === "heading" && b.level && b.text).map((b) => ({ level: b.level, text: b.text, pageNumber: b.pageNumber }));
@@ -3730,11 +4201,18 @@ function filterHiddenText(items, pageWidth, pageHeight) {
   }
   return { visible, hiddenCount };
 }
-function computeMedianFontSize(sizes) {
-  if (sizes.length === 0) return 0;
-  const sorted = [...sizes].sort((a, b) => a - b);
-  const mid = Math.floor(sorted.length / 2);
-  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+function computeMedianFontSizeFromFreq(freq) {
+  if (freq.size === 0) return 0;
+  let total = 0;
+  for (const count of freq.values()) total += count;
+  const sorted = [...freq.entries()].sort((a, b) => a[0] - b[0]);
+  const mid = Math.floor(total / 2);
+  let cumulative = 0;
+  for (const [size, count] of sorted) {
+    cumulative += count;
+    if (cumulative > mid) return size;
+  }
+  return sorted[sorted.length - 1][0];
 }
 function detectHeadings(blocks, medianFontSize) {
   for (const block of blocks) {
@@ -3754,220 +4232,27 @@ function detectHeadings(blocks, medianFontSize) {
     }
   }
 }
-function mergeAdjacentHeadings(blocks) {
-  let i = 0;
-  while (i < blocks.length - 1) {
-    const curr = blocks[i];
-    const next = blocks[i + 1];
-    if (curr.type !== "heading" || next.type !== "heading") {
-      i++;
-      continue;
-    }
-    if (!curr.bbox || !next.bbox || !curr.text || !next.text) {
-      i++;
-      continue;
-    }
-    const currBaseline = curr.bbox.y + (curr.style?.fontSize || curr.bbox.height);
-    const nextBaseline = next.bbox.y + (next.style?.fontSize || next.bbox.height);
-    const yDiff = Math.abs(currBaseline - nextBaseline);
-    const maxFs = Math.max(curr.style?.fontSize || 12, next.style?.fontSize || 12);
-    const sameY = curr.bbox.page === next.bbox.page && yDiff < maxFs * 1.5;
-    const sameLevel = curr.level === next.level;
-    if (sameY && sameLevel) {
-      const currX = curr.bbox.x;
-      const nextX = next.bbox.x;
-      if (currX <= nextX) {
-        curr.text = curr.text + " " + next.text;
-      } else {
-        curr.text = next.text + " " + curr.text;
-      }
-      curr.bbox = {
-        page: curr.bbox.page,
-        x: Math.min(curr.bbox.x, next.bbox.x),
-        y: Math.min(curr.bbox.y, next.bbox.y),
-        width: Math.max(curr.bbox.x + curr.bbox.width, next.bbox.x + next.bbox.width) - Math.min(curr.bbox.x, next.bbox.x),
-        height: Math.max(curr.bbox.height, next.bbox.height)
-      };
-      blocks.splice(i + 1, 1);
-    } else {
-      i++;
-    }
-  }
-}
 function collapseEvenSpacing(text) {
   const tokens = text.split(" ");
   const singleCharCount = tokens.filter((t) => t.length === 1).length;
   if (tokens.length >= 3 && singleCharCount / tokens.length >= 0.7) {
     return tokens.join("");
   }
-  return text;
-}
-function buildXyCutBlocks(items, pageNum) {
-  const allY = items.map((i) => i.y);
-  const pageHeight = Math.max(...allY) - Math.min(...allY);
-  const gapThreshold = Math.max(15, pageHeight * 0.03);
-  const orderedGroups = xyCutOrder(items, gapThreshold);
-  const blocks = [];
-  for (const group of orderedGroups) {
-    if (group.length === 0) continue;
-    const yLines = groupByY(group);
-    for (const line of yLines) {
-      const text = mergeLineSimple(line);
-      if (!text.trim()) continue;
-      blocks.push({
-        type: "paragraph",
-        text,
-        pageNumber: pageNum,
-        bbox: computeBBox(line, pageNum),
-        style: dominantStyle(line)
-      });
-    }
-  }
-  return blocks.length > 0 ? blocks : null;
-}
-function normalizeUnderSegmentedTable(table, items, pageNum, bbox) {
-  const totalCells = table.cells.reduce((sum, row) => sum + row.filter((c) => c.text.trim()).length, 0);
-  const totalTextLines = table.cells.reduce((sum, row) => sum + row.reduce((s, c) => s + (c.text.trim() ? c.text.split("\n").length : 0), 0), 0);
-  const isUnderSegmented = table.rows === 1 && table.cols === 1 || totalCells <= 2 && totalTextLines >= 8 || totalCells <= 2 && items.length >= 6;
-  if (!isUnderSegmented) return null;
-  if (hasMultiColumnLayout(items)) return buildXyCutBlocks(items, pageNum);
-  const directTable = buildTableFromTextLayout(items, pageNum, bbox);
-  if (directTable) return directTable;
-  const clusterItems = items.map((i) => ({
-    text: i.text,
-    x: i.x,
-    y: i.y,
-    w: i.w,
-    h: i.h,
-    fontSize: i.fontSize,
-    fontName: i.fontName
-  }));
-  const clusterResults = detectClusterTables(clusterItems, pageNum);
-  if (clusterResults.length > 0) {
-    const blocks = [];
-    const ciToIdx = /* @__PURE__ */ new Map();
-    for (let ci = 0; ci < clusterItems.length; ci++) ciToIdx.set(clusterItems[ci], ci);
-    const usedIndices = /* @__PURE__ */ new Set();
-    for (const cr of clusterResults) {
-      for (const ci of cr.usedItems) {
-        const idx = ciToIdx.get(ci);
-        if (idx !== void 0) usedIndices.add(idx);
-      }
-      blocks.push({ type: "table", table: cr.table, pageNumber: pageNum, bbox: cr.bbox });
-    }
-    const remaining = items.filter((_, idx) => !usedIndices.has(idx));
-    for (const item of remaining) {
-      if (!item.text.trim()) continue;
-      blocks.push({
-        type: "paragraph",
-        text: item.text,
-        pageNumber: pageNum,
-        bbox: computeBBox([item], pageNum),
-        style: { fontSize: item.fontSize, fontName: item.fontName }
-      });
-    }
-    blocks.sort((a, b) => {
-      const ay = a.bbox ? a.bbox.y + a.bbox.height : 0;
-      const by = b.bbox ? b.bbox.y + b.bbox.height : 0;
-      return by - ay;
-    });
-    return blocks.length > 0 ? blocks : null;
-  }
-  return null;
-}
-function buildTableFromTextLayout(items, pageNum, bbox) {
-  if (items.length < 4) return null;
-  const sorted = [...items].sort((a, b) => b.y - a.y || a.x - b.x);
-  const yTol = 3;
-  const rows = [];
-  let curRow = [sorted[0]];
-  let curY = sorted[0].y;
-  for (let i = 1; i < sorted.length; i++) {
-    if (Math.abs(sorted[i].y - curY) <= yTol) {
-      curRow.push(sorted[i]);
-    } else {
-      rows.push(curRow);
-      curRow = [sorted[i]];
-      curY = sorted[i].y;
-    }
-  }
-  rows.push(curRow);
-  if (rows.length < 2) return null;
-  const gapPositions = [];
-  for (const row of rows) {
-    if (row.length < 2) continue;
-    const sortedX = [...row].sort((a, b) => a.x - b.x);
-    const avgFs = sortedX.reduce((s, i) => s + i.fontSize, 0) / sortedX.length;
-    for (let j = 1; j < sortedX.length; j++) {
-      const gap = sortedX[j].x - (sortedX[j - 1].x + sortedX[j - 1].w);
-      if (gap >= avgFs * 1.5) {
-        gapPositions.push(sortedX[j - 1].x + sortedX[j - 1].w + gap / 2);
-      }
-    }
-  }
-  if (gapPositions.length < 2) return null;
-  gapPositions.sort((a, b) => a - b);
-  const colBoundaries = [];
-  let clusterSum = gapPositions[0], clusterCount = 1;
-  for (let i = 1; i < gapPositions.length; i++) {
-    const avg = clusterSum / clusterCount;
-    if (Math.abs(gapPositions[i] - avg) <= 15) {
-      clusterSum += gapPositions[i];
-      clusterCount++;
-    } else {
-      if (clusterCount >= 2) colBoundaries.push(clusterSum / clusterCount);
-      clusterSum = gapPositions[i];
-      clusterCount = 1;
-    }
-  }
-  if (clusterCount >= 2) colBoundaries.push(clusterSum / clusterCount);
-  if (colBoundaries.length === 0) return null;
-  const numCols = colBoundaries.length + 1;
-  const tableRows = [];
-  for (const row of rows) {
-    const cells = Array(numCols).fill("");
-    const sortedX = [...row].sort((a, b) => a.x - b.x);
-    for (const item of sortedX) {
-      const cx = item.x + item.w / 2;
-      let col = 0;
-      for (let b = 0; b < colBoundaries.length; b++) {
-        if (cx > colBoundaries[b]) col = b + 1;
-      }
-      cells[col] = cells[col] ? cells[col] + " " + item.text : item.text;
-    }
-    if (cells[0].trim() === "" && tableRows.length > 0) {
-      const prevCells = tableRows[tableRows.length - 1].cells;
-      for (let c = 0; c < numCols; c++) {
-        if (cells[c].trim()) {
-          prevCells[c] = prevCells[c] ? prevCells[c] + " " + cells[c].trim() : cells[c].trim();
-        }
-      }
-    } else {
-      tableRows.push({ cells });
-    }
-  }
-  if (tableRows.length < 2) return null;
-  const nonEmptyCount = tableRows.reduce((sum, r) => sum + r.cells.filter((c) => c.trim()).length, 0);
-  const totalCount = tableRows.length * numCols;
-  if (nonEmptyCount < totalCount * 0.3) return null;
-  const irCells = tableRows.map(
-    (r) => r.cells.map((text, colIdx) => {
-      let cleaned = text.trim();
-      if (colIdx > 0) cleaned = cleaned.replace(/^[•○·\-]\s*/, "");
-      return { text: cleaned, colSpan: 1, rowSpan: 1 };
-    })
+  return text.replace(
+    /(?<![가-힣])[가-힣](?: [가-힣\d]){2,}(?![가-힣])/g,
+    (match) => match.replace(/ /g, "")
   );
-  const irTable = {
-    rows: tableRows.length,
-    cols: numCols,
-    cells: irCells,
-    hasHeader: tableRows.length > 1
-  };
-  return [{ type: "table", table: irTable, pageNumber: pageNum, bbox }];
 }
 function shouldDemoteTable(table) {
   const allCells = table.cells.flatMap((row) => row.map((c) => c.text.trim())).filter(Boolean);
   const allText = allCells.join(" ");
+  if (table.rows <= 3 && table.cols <= 3) {
+    const totalCells2 = table.rows * table.cols;
+    const emptyCells2 = totalCells2 - allCells.length;
+    if (emptyCells2 >= totalCells2 * 0.3) return true;
+    if (/[□■◆○●▶ㅇ]/.test(allText)) return true;
+    if (/<[^>]+>/.test(allText)) return true;
+  }
   if (allText.length > 200) return false;
   if (/[□■◆○●▶]/.test(allText) && table.rows <= 3) return true;
   const totalCells = table.rows * table.cols;
@@ -4011,32 +4296,6 @@ function detectMarkerHeadings(blocks) {
     }
   }
 }
-function hasMultiColumnLayout(items) {
-  if (items.length < 30) return false;
-  const sorted = [...items].sort((a, b) => a.x - b.x);
-  const minX = sorted[0].x;
-  let maxX = minX;
-  for (const i of sorted) if (i.x + i.w > maxX) maxX = i.x + i.w;
-  const pageWidth = maxX - minX;
-  if (pageWidth < 200) return false;
-  let bestGap = 0;
-  let bestSplit = 0;
-  for (let j = 1; j < sorted.length; j++) {
-    const gap = sorted[j].x - (sorted[j - 1].x + sorted[j - 1].w);
-    if (gap > bestGap) {
-      bestGap = gap;
-      bestSplit = (sorted[j - 1].x + sorted[j - 1].w + sorted[j].x) / 2;
-    }
-  }
-  if (bestGap < 20) return false;
-  const splitRatio = (bestSplit - minX) / pageWidth;
-  if (splitRatio < 0.35 || splitRatio > 0.65) return false;
-  const leftCount = items.filter((i) => i.x + i.w / 2 < bestSplit).length;
-  const rightCount = items.filter((i) => i.x + i.w / 2 >= bestSplit).length;
-  if (leftCount < 15 || rightCount < 15) return false;
-  if (Math.min(leftCount, rightCount) / Math.max(leftCount, rightCount) < 0.35) return false;
-  return true;
-}
 var MAX_XYCUT_DEPTH = 50;
 function xyCutOrder(items, gapThreshold, depth = 0) {
   if (items.length === 0) return [];
@@ -4104,6 +4363,7 @@ function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeigh
   if (items.length === 0) return [];
   let { horizontals, verticals } = extractLines(opList.fnArray, opList.argsArray);
   ({ horizontals, verticals } = filterPageBorderLines(horizontals, verticals, pageWidth, pageHeight));
+  ({ horizontals, verticals } = preprocessLines(horizontals, verticals));
   const grids = buildTableGrids(horizontals, verticals);
   if (grids.length > 0) {
     return extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals);
@@ -4115,14 +4375,19 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
   const usedItems = /* @__PURE__ */ new Set();
   const sortedGrids = [...grids].sort((a, b) => b.bbox.y2 - a.bbox.y2);
   for (const grid of sortedGrids) {
+    const numGridRows = grid.rowYs.length - 1;
+    const numGridCols = grid.colXs.length - 1;
+    if (numGridRows === 1 && numGridCols >= 2) continue;
     const tableItems = [];
     const pad = 3;
+    const gridW = grid.bbox.x2 - grid.bbox.x1;
     for (const item of items) {
       if (usedItems.has(item)) continue;
-      if (item.x >= grid.bbox.x1 - pad && item.x + item.w <= grid.bbox.x2 + pad && item.y >= grid.bbox.y1 - pad && item.y <= grid.bbox.y2 + pad) {
-        tableItems.push(item);
-        usedItems.add(item);
-      }
+      if (item.y < grid.bbox.y1 - pad || item.y > grid.bbox.y2 + pad) continue;
+      if (item.x < grid.bbox.x1 - pad || item.x + item.w > grid.bbox.x2 + pad) continue;
+      if (gridW < 120 && item.x + item.w > grid.bbox.x2 - 2) continue;
+      tableItems.push(item);
+      usedItems.add(item);
     }
     const cells = extractCells(grid, horizontals, verticals);
     if (cells.length === 0) continue;
@@ -4146,6 +4411,7 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
       const cellItems = cellTextMap.get(cell) || [];
       let text = cellTextToString(cellItems);
       text = text.replace(/^[\s]*[-–—]\s*\d+\s*[-–—][\s]*$/gm, "").trim();
+      text = text.split("\n").map((line) => collapseEvenSpacing(line)).join("\n");
       irGrid[cell.row][cell.col] = {
         text,
         colSpan: cell.colSpan,
@@ -4167,31 +4433,61 @@ function extractBlocksWithGrids(items, pageNum, grids, horizontals, verticals) {
       width: grid.bbox.x2 - grid.bbox.x1,
       height: grid.bbox.y2 - grid.bbox.y1
     };
-    const normalized = normalizeUnderSegmentedTable(irTable, tableItems, pageNum, tableBbox);
-    if (normalized) {
-      blocks.push(...normalized);
-      continue;
-    }
     if (shouldDemoteTable(irTable)) {
       const demoted = demoteTableToText(irTable);
       if (demoted) {
-        blocks.push({ type: "paragraph", text: demoted, pageNumber: pageNum, bbox: tableBbox, style: dominantStyle(tableItems) });
+        const text = numGridRows === 1 ? "\n" + demoted + "\n" : demoted;
+        blocks.push({ type: "paragraph", text, pageNumber: pageNum, bbox: tableBbox, style: dominantStyle(tableItems) });
       }
       continue;
     }
     blocks.push({ type: "table", table: irTable, pageNumber: pageNum, bbox: tableBbox });
   }
-  const remaining = items.filter((i) => !usedItems.has(i));
+  let remaining = items.filter((i) => !usedItems.has(i));
   if (remaining.length > 0) {
     remaining.sort((a, b) => b.y - a.y || a.x - b.x);
-    const textBlocks = detectListBlocks(extractPageBlocksFallback(remaining, pageNum));
-    const allBlocks = [...blocks, ...textBlocks];
-    allBlocks.sort((a, b) => {
+    const clusterItems = remaining.map((i) => ({
+      text: i.text,
+      x: i.x,
+      y: i.y,
+      w: i.w,
+      h: i.h,
+      fontSize: i.fontSize,
+      fontName: i.fontName
+    }));
+    const clusterResults = detectClusterTables(clusterItems, pageNum);
+    if (clusterResults.length > 0) {
+      const ciToIdx = /* @__PURE__ */ new Map();
+      for (let ci = 0; ci < clusterItems.length; ci++) ciToIdx.set(clusterItems[ci], ci);
+      const usedClusterIndices = /* @__PURE__ */ new Set();
+      for (const cr of clusterResults) {
+        for (const ci of cr.usedItems) {
+          const idx = ciToIdx.get(ci);
+          if (idx !== void 0) usedClusterIndices.add(idx);
+        }
+        blocks.push({ type: "table", table: cr.table, pageNumber: pageNum, bbox: cr.bbox });
+      }
+      remaining = remaining.filter((_, idx) => !usedClusterIndices.has(idx));
+    }
+    if (remaining.length > 0) {
+      const allY = remaining.map((i) => i.y);
+      const pageH = safeMax(allY) - safeMin(allY);
+      const groups = xyCutOrder(remaining, Math.max(15, pageH * 0.03));
+      const textBlocks = [];
+      for (const group of groups) {
+        if (group.length === 0) continue;
+        const groupBlocks = extractPageBlocksFallback(group, pageNum);
+        for (const b of groupBlocks) textBlocks.push(b);
+      }
+      const finalTextBlocks = detectListBlocks(textBlocks);
+      for (const b of finalTextBlocks) blocks.push(b);
+    }
+    blocks.sort((a, b) => {
       const ay = a.bbox ? a.bbox.y + a.bbox.height : 0;
       const by = b.bbox ? b.bbox.y + b.bbox.height : 0;
       return by - ay;
     });
-    return mergeAdjacentTableBlocks(allBlocks);
+    return mergeAdjacentTableBlocks(blocks);
   }
   return mergeAdjacentTableBlocks(blocks);
 }
@@ -4217,57 +4513,53 @@ function mergeAdjacentTableBlocks(blocks) {
 }
 function extractPageBlocksFallback(items, pageNum) {
   if (items.length === 0) return [];
-  if (hasMultiColumnLayout(items)) {
-    const xyBlocks = buildXyCutBlocks(items, pageNum) || [];
-    return detectSpecialKoreanTables(detectListBlocks(xyBlocks));
-  }
   const blocks = [];
-  const allYLines = groupByY(items);
-  const columns = detectColumns(allYLines);
-  if (columns && columns.length >= 3) {
-    const tableText = extractWithColumns(allYLines, columns);
-    const bbox = computeBBox(items, pageNum);
-    blocks.push({ type: "paragraph", text: tableText, pageNumber: pageNum, bbox, style: dominantStyle(items) });
-  } else {
-    const clusterItems = items.map((i) => ({
-      text: i.text,
-      x: i.x,
-      y: i.y,
-      w: i.w,
-      h: i.h,
-      fontSize: i.fontSize,
-      fontName: i.fontName
-    }));
-    const clusterResults = hasMultiColumnLayout(items) ? [] : detectClusterTables(clusterItems, pageNum);
-    if (clusterResults.length > 0) {
-      const ciToIdx = /* @__PURE__ */ new Map();
-      for (let ci = 0; ci < clusterItems.length; ci++) ciToIdx.set(clusterItems[ci], ci);
-      const usedIndices = /* @__PURE__ */ new Set();
-      for (const cr of clusterResults) {
-        for (const ci of cr.usedItems) {
-          const idx = ciToIdx.get(ci);
-          if (idx !== void 0) usedIndices.add(idx);
-        }
-        blocks.push({ type: "table", table: cr.table, pageNumber: pageNum, bbox: cr.bbox });
+  const clusterItems = items.map((i) => ({
+    text: i.text,
+    x: i.x,
+    y: i.y,
+    w: i.w,
+    h: i.h,
+    fontSize: i.fontSize,
+    fontName: i.fontName
+  }));
+  const clusterResults = detectClusterTables(clusterItems, pageNum);
+  if (clusterResults.length > 0) {
+    const ciToIdx = /* @__PURE__ */ new Map();
+    for (let ci = 0; ci < clusterItems.length; ci++) ciToIdx.set(clusterItems[ci], ci);
+    const usedIndices = /* @__PURE__ */ new Set();
+    for (const cr of clusterResults) {
+      for (const ci of cr.usedItems) {
+        const idx = ciToIdx.get(ci);
+        if (idx !== void 0) usedIndices.add(idx);
       }
-      const remaining = items.filter((_, idx) => !usedIndices.has(idx));
-      if (remaining.length > 0) {
-        const yLines = groupByY(remaining);
-        for (const line of yLines) {
-          const text = mergeLineSimple(line);
-          if (!text.trim()) continue;
-          const bbox = computeBBox(line, pageNum);
-          blocks.push({ type: "paragraph", text, pageNumber: pageNum, bbox, style: dominantStyle(line) });
-        }
+      blocks.push({ type: "table", table: cr.table, pageNumber: pageNum, bbox: cr.bbox });
+    }
+    const remaining = items.filter((_, idx) => !usedIndices.has(idx));
+    if (remaining.length > 0) {
+      const yLines = groupByY(remaining);
+      for (const line of yLines) {
+        const text = mergeLineSimple(line);
+        if (!text.trim()) continue;
+        const bbox = computeBBox(line, pageNum);
+        blocks.push({ type: "paragraph", text, pageNumber: pageNum, bbox, style: dominantStyle(line) });
       }
-      blocks.sort((a, b) => {
-        const ay = a.bbox ? a.bbox.y + a.bbox.height : 0;
-        const by = b.bbox ? b.bbox.y + b.bbox.height : 0;
-        return by - ay;
-      });
+    }
+    blocks.sort((a, b) => {
+      const ay = a.bbox ? a.bbox.y + a.bbox.height : 0;
+      const by = b.bbox ? b.bbox.y + b.bbox.height : 0;
+      return by - ay;
+    });
+  } else {
+    const allYLines = groupByY(items);
+    const columns = detectColumns(allYLines);
+    if (columns && columns.length >= 3) {
+      const tableText = extractWithColumns(allYLines, columns);
+      const bbox = computeBBox(items, pageNum);
+      blocks.push({ type: "paragraph", text: tableText, pageNumber: pageNum, bbox, style: dominantStyle(items) });
     } else {
       const allY = items.map((i) => i.y);
-      const pageHeight = Math.max(...allY) - Math.min(...allY);
+      const pageHeight = safeMax(allY) - safeMin(allY);
       const gapThreshold = Math.max(15, pageHeight * 0.03);
       const orderedGroups = xyCutOrder(items, gapThreshold);
       for (const group of orderedGroups) {
@@ -4320,22 +4612,76 @@ function dominantStyle(items) {
   return { fontSize: dominantSize, fontName };
 }
 function normalizeItems(rawItems) {
-  return rawItems.filter((i) => typeof i.str === "string" && i.str.trim() !== "").map((i) => {
+  const items = [];
+  const spacePositions = [];
+  for (const i of rawItems) {
+    if (typeof i.str !== "string") continue;
+    const x = Math.round(i.transform[4]);
+    const y = Math.round(i.transform[5]);
+    if (!i.str.trim()) {
+      spacePositions.push({ x, y });
+      continue;
+    }
     const scaleY = Math.abs(i.transform[3]);
     const scaleX = Math.abs(i.transform[0]);
     const fontSize = Math.round(Math.max(scaleY, scaleX));
-    return {
-      text: i.str.trim(),
-      x: Math.round(i.transform[4]),
-      y: Math.round(i.transform[5]),
-      w: Math.round(i.width),
-      h: Math.round(i.height),
-      fontSize,
-      fontName: i.fontName || "",
-      // 0pt 폰트이거나 너비 0 → hidden text (prompt injection 의심)
-      isHidden: fontSize === 0 || i.width === 0 && i.str.trim().length > 0
-    };
-  }).sort((a, b) => b.y - a.y || a.x - b.x);
+    const w = Math.round(i.width);
+    const h = Math.round(i.height);
+    const isHidden = fontSize === 0 || i.width === 0 && i.str.trim().length > 0;
+    let text = i.str.trim();
+    if (/^[\d\s\-().·,☎]+$/.test(text) && /\d/.test(text) && / /.test(text)) {
+      text = text.replace(/ /g, "");
+    }
+    const split = splitEvenSpacedItem(text, x, w, fontSize);
+    if (split) {
+      for (const s of split) {
+        items.push({ text: s.text, x: s.x, y, w: s.w, h, fontSize, fontName: i.fontName || "", isHidden });
+      }
+    } else {
+      items.push({ text, x, y, w, h, fontSize, fontName: i.fontName || "", isHidden });
+    }
+  }
+  const sorted = items.sort((a, b) => b.y - a.y || a.x - b.x);
+  const deduped = [];
+  for (let i = 0; i < sorted.length; i++) {
+    let isDup = false;
+    for (let j = deduped.length - 1; j >= 0; j--) {
+      const prev = deduped[j];
+      if (prev.y - sorted[i].y > 3) break;
+      if (Math.abs(prev.y - sorted[i].y) <= 3 && prev.text === sorted[i].text && Math.abs(prev.x - sorted[i].x) <= 3) {
+        isDup = true;
+        break;
+      }
+    }
+    if (!isDup) deduped.push(sorted[i]);
+  }
+  if (spacePositions.length > 0) {
+    for (const item of deduped) {
+      for (const sp of spacePositions) {
+        if (Math.abs(sp.y - item.y) <= 3) {
+          const dist = item.x - sp.x;
+          if (dist >= 0 && dist <= 20) {
+            item.hasSpaceBefore = true;
+            break;
+          }
+        }
+      }
+    }
+  }
+  return deduped;
+}
+function splitEvenSpacedItem(text, itemX, itemW, fontSize) {
+  if (!/^[가-힣\d](?: [가-힣\d]){2,}$/.test(text)) return null;
+  const chars = text.split(" ");
+  if (chars.length < 3) return null;
+  const charW = itemW / chars.length;
+  if (charW > fontSize * 2) return null;
+  return chars.map((ch, idx) => ({
+    text: ch,
+    x: Math.round(itemX + idx * charW),
+    w: Math.round(charW * 0.8)
+    // 실제 글자 폭은 간격보다 좁음
+  }));
 }
 function groupByY(items) {
   if (items.length === 0) return [];
@@ -4360,14 +4706,14 @@ function isProseSpread(items) {
   for (let i = 1; i < sorted.length; i++) {
     gaps.push(sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w));
   }
-  const maxGap = Math.max(...gaps);
+  const maxGap = safeMax(gaps);
   const avgLen = items.reduce((s, i) => s + i.text.length, 0) / items.length;
   return maxGap < 40 && avgLen < 5;
 }
 function detectColumns(yLines) {
   const allItems = yLines.flat();
   if (allItems.length === 0) return null;
-  const pageWidth = Math.max(...allItems.map((i) => i.x + i.w)) - Math.min(...allItems.map((i) => i.x));
+  const pageWidth = safeMax(allItems.map((i) => i.x + i.w)) - safeMin(allItems.map((i) => i.x));
   if (pageWidth < 100) return null;
   let bigoLineIdx = -1;
   for (let i = 0; i < yLines.length; i++) {
@@ -4399,7 +4745,7 @@ function detectColumns(yLines) {
   }
   const peaks = xClusters.filter((c) => c.count >= 3).sort((a, b) => a.minX - b.minX);
   if (peaks.length < 3) return null;
-  const MERGE_TOL = 30;
+  const MERGE_TOL = 40;
   const merged = [peaks[0]];
   for (let i = 1; i < peaks.length; i++) {
     const prev = merged[merged.length - 1];
@@ -4413,7 +4759,14 @@ function detectColumns(yLines) {
       merged.push({ ...peaks[i] });
     }
   }
-  const columns = merged.filter((c) => c.count >= 3).map((c) => c.minX);
+  const rawColumns = merged.filter((c) => c.count >= 3).map((c) => c.minX);
+  if (rawColumns.length < 3) return null;
+  const MIN_DETECT_COL_WIDTH = 30;
+  const columns = [rawColumns[0]];
+  for (let i = 1; i < rawColumns.length; i++) {
+    if (rawColumns[i] - columns[columns.length - 1] < MIN_DETECT_COL_WIDTH) continue;
+    columns.push(rawColumns[i]);
+  }
   return columns.length >= 3 ? columns : null;
 }
 function findColumn(x, columns) {
@@ -4541,6 +4894,16 @@ function buildGridTable(lines, columns) {
     }
     merged.splice(0, headerEnd, headerRow);
   }
+  for (const row of merged) {
+    for (let c = 0; c < row.length; c++) {
+      if (row[c]) row[c] = collapseEvenSpacing(row[c]);
+    }
+  }
+  const totalCells = merged.length * numCols;
+  const filledCells = merged.reduce((s, row) => s + row.filter((c) => c).length, 0);
+  if (filledCells < totalCells * 0.35 || merged.length < 2 || merged.length <= 3 && numCols >= 7) {
+    return merged.map((r) => r.filter((c) => c).join("	")).join("\n");
+  }
   const md = [];
   md.push("| " + merged[0].join(" | ") + " |");
   md.push("| " + merged[0].map(() => "---").join(" | ") + " |");
@@ -4552,12 +4915,32 @@ function buildGridTable(lines, columns) {
 function mergeLineSimple(items) {
   if (items.length <= 1) return items[0]?.text || "";
   const sorted = [...items].sort((a, b) => a.x - b.x);
+  const isEvenSpaced = detectEvenSpacedItems(sorted);
   let result = sorted[0].text;
   for (let i = 1; i < sorted.length; i++) {
     const gap = sorted[i].x - (sorted[i - 1].x + sorted[i - 1].w);
     const avgFs = (sorted[i].fontSize + sorted[i - 1].fontSize) / 2;
-    if (gap > 15) result += "	";
-    else if (gap < avgFs * 0.15) {
+    const tabThreshold = Math.max(avgFs * 2, 30);
+    if (gap > tabThreshold) {
+      result += "	";
+      result += sorted[i].text;
+      continue;
+    }
+    if (isEvenSpaced[i]) {
+      result += sorted[i].text;
+      continue;
+    }
+    if (sorted[i].hasSpaceBefore && gap >= avgFs * 0.05) {
+      result += " ";
+      result += sorted[i].text;
+      continue;
+    }
+    if (/[□■○●▶◆◇ㅇ]$/.test(sorted[i - 1].text) && /^[가-힣]/.test(sorted[i].text) && gap > 1) {
+      result += " ";
+      result += sorted[i].text;
+      continue;
+    }
+    if (gap < avgFs * 0.15) {
     } else if (gap < avgFs * 0.35 && (/[가-힣]$/.test(result) || /^[가-힣]/.test(sorted[i].text))) {
     } else if (gap > 3) result += " ";
     result += sorted[i].text;
@@ -4566,8 +4949,8 @@ function mergeLineSimple(items) {
 }
 function cleanPdfText(text) {
   return mergeKoreanLines(
-    text.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(/^(?!\|).{3,30}$/gm, (line) => collapseEvenSpacing(line)).replace(/\n{3,}/g, "\n\n").trim();
+    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) => collapseEvenSpacing(line)).replace(/([□■◆○●▶ㅇ])\s+([가-힣])\s+([가-힣])/g, "$1 $2$3").replace(/\n{3,}/g, "\n\n").trim();
 }
 function startsWithMarker(line) {
   const t = line.trimStart();
@@ -4759,7 +5142,7 @@ function mergeKoreanLines(text) {
       result[result.length - 1] = prev + " " + currTrimmed;
       continue;
     }
-    if (/[가-힣·,\-]$/.test(prev) && /^[가-힣(]/.test(curr) && !startsWithMarker(curr) && !isStandaloneHeader(prev)) {
+    if (/[가-힣·,\-]$/.test(prev) && /^[가-힣(]/.test(curr) && !startsWithMarker(curr) && !isStandaloneHeader(prev) && !startsWithMarker(prev)) {
       result[result.length - 1] = prev + " " + curr;
     } else {
       result.push(curr);
@@ -4772,7 +5155,7 @@ function mergeKoreanLines(text) {
 import { readFile } from "fs/promises";
 
 // src/xlsx/parser.ts
-import JSZip3 from "jszip";
+import JSZip2 from "jszip";
 import { DOMParser as DOMParser2 } from "@xmldom/xmldom";
 var MAX_SHEETS = 100;
 var MAX_DECOMPRESS_SIZE3 = 100 * 1024 * 1024;
@@ -4810,7 +5193,7 @@ function getTextContent(el) {
   return el.textContent?.trim() ?? "";
 }
 function parseXml(text) {
-  return new DOMParser2().parseFromString(text, "text/xml");
+  return new DOMParser2().parseFromString(stripDtd(text), "text/xml");
 }
 function parseSharedStrings(xml) {
   const doc = parseXml(xml);
@@ -4963,7 +5346,7 @@ function sheetToBlocks(sheetName, grid, merges, maxRow, maxCol, sheetIndex) {
 }
 async function parseXlsxDocument(buffer, options) {
   precheckZipSize(buffer, MAX_DECOMPRESS_SIZE3);
-  const zip = await JSZip3.loadAsync(buffer);
+  const zip = await JSZip2.loadAsync(buffer);
   const warnings = [];
   const workbookFile = zip.file("xl/workbook.xml");
   if (!workbookFile) {
@@ -4985,7 +5368,7 @@ async function parseXlsxDocument(buffer, options) {
   }
   let pageFilter = null;
   if (options?.pages) {
-    const { parsePageRange: parsePageRange2 } = await import("./page-range-737B4EZW.js");
+    const { parsePageRange: parsePageRange2 } = await import("./page-range-OF5I4PQY.js");
     pageFilter = parsePageRange2(options.pages, sheets.length);
   }
   const blocks = [];
@@ -5053,7 +5436,7 @@ async function parseXlsxDocument(buffer, options) {
 }
 
 // src/docx/parser.ts
-import JSZip4 from "jszip";
+import JSZip3 from "jszip";
 import { DOMParser as DOMParser3 } from "@xmldom/xmldom";
 var MAX_DECOMPRESS_SIZE4 = 100 * 1024 * 1024;
 function getChildElements(parent, localName) {
@@ -5097,7 +5480,7 @@ function getAttr(el, localName) {
   return null;
 }
 function parseXml2(text) {
-  return new DOMParser3().parseFromString(text, "text/xml");
+  return new DOMParser3().parseFromString(stripDtd(text), "text/xml");
 }
 function parseStyles(xml) {
   const doc = parseXml2(xml);
@@ -5391,7 +5774,7 @@ async function extractImages(zip, rels, doc) {
 }
 async function parseDocxDocument(buffer, options) {
   precheckZipSize(buffer, MAX_DECOMPRESS_SIZE4);
-  const zip = await JSZip4.loadAsync(buffer);
+  const zip = await JSZip3.loadAsync(buffer);
   const warnings = [];
   const docFile = zip.file("word/document.xml");
   if (!docFile) {
@@ -5608,7 +5991,7 @@ function extractInlineFields(text) {
 }
 
 // src/hwpx/generator.ts
-import JSZip5 from "jszip";
+import JSZip4 from "jszip";
 
 // src/index.ts
 async function parse(input, options) {
@@ -5703,7 +6086,13 @@ function normalize(s) {
 }
 var MAX_LEVENSHTEIN_LEN = 1e4;
 function levenshtein(a, b) {
-  if (a.length + b.length > MAX_LEVENSHTEIN_LEN) return Math.abs(a.length - b.length);
+  if (a.length + b.length > MAX_LEVENSHTEIN_LEN) {
+    const sampleLen = Math.min(500, a.length, b.length);
+    let diffs = 0;
+    for (let i = 0; i < sampleLen; i++) if (a[i] !== b[i]) diffs++;
+    const sampleRate = sampleLen > 0 ? diffs / sampleLen : 1;
+    return Math.abs(a.length - b.length) + Math.round(Math.min(a.length, b.length) * sampleRate);
+  }
   if (a.length > b.length) [a, b] = [b, a];
   const m = a.length;
   const n = b.length;
@@ -5859,7 +6248,10 @@ function diffTableCells(a, b) {
 }
 
 export {
-  detectFormat,
+  VERSION,
+  toArrayBuffer,
+  KordocError,
+  sanitizeError,
   blocksToMarkdown,
   extractHwpxMetadataOnly,
   extractHwp5MetadataOnly,
@@ -5868,4 +6260,4 @@ export {
   extractFormFields,
   parse
 };
-//# sourceMappingURL=chunk-GJ2S6IMC.js.map
+//# sourceMappingURL=chunk-FINXMRCH.js.map