kordoc 4.18.3 → 4.18.5

package/dist/{chunk-BJ6RYYXV.js → chunk-2CRD4Q76.js}

@@ -4,15 +4,15 @@ import {
   HEADING_RATIO_H2,
   HEADING_RATIO_H3,
   tidyScriptTags
-} from "./chunk-PSJLB3SZ.js";
+} from "./chunk-PQ2ER3VQ.js";
 import {
   ensureModelsIn,
   getModelsDir
-} from "./chunk-3FZGL3IL.js";
+} from "./chunk-235UD74F.js";
 import {
   safeMax,
   safeMin
-} from "./chunk-CAN5P6N6.js";
+} from "./chunk-ZH5Y3JT6.js";
 
 // src/ocr/models.ts
 import { join } from "path";
@@ -488,13 +488,13 @@ function classifyAndAdd(seg, lineWidth, horizontals, verticals, fromFill = false
     verticals.push({ x1: x, y1, x2: x, y2, lineWidth, fromFill });
   }
 }
-function preprocessLines(horizontals, verticals) {
+function preprocessLines(horizontals, verticals, nonRules) {
   let h = horizontals.filter((l) => l.lineWidth <= MAX_LINE_WIDTH);
   let v = verticals.filter((l) => l.lineWidth <= MAX_LINE_WIDTH);
   h = dropShadingStacks(h, "h");
   v = dropShadingStacks(v, "v");
-  h = mergeParallelLines(h, "h");
-  v = mergeParallelLines(v, "v");
+  h = mergeParallelLines(h, "h", nonRules);
+  v = mergeParallelLines(v, "v", nonRules);
   return { horizontals: h, verticals: v };
 }
 var STACK_GAP = 2;
@@ -654,15 +654,15 @@ function closeOpenTableEdges(horizontals, verticals) {
     const hasInterior = verticals.some((v) => v.x1 > x1 + EDGE_INSET && v.x1 < x2 - EDGE_INSET && crossCount(v) >= 2);
     if (!hasInterior) continue;
     for (const edgeX of [x1, x2]) {
-      const closed = verticals.some((v) => Math.abs(v.x1 - edgeX) <= EDGE_NEAR && v.y1 <= yMax + EDGE_CONNECT_TOL && v.y2 >= yMin - EDGE_CONNECT_TOL);
-      if (!closed) {
+      const closed2 = verticals.some((v) => Math.abs(v.x1 - edgeX) <= EDGE_NEAR && v.y1 <= yMax + EDGE_CONNECT_TOL && v.y2 >= yMin - EDGE_CONNECT_TOL);
+      if (!closed2) {
         synthesized.push({ x1: edgeX, y1: yMin, x2: edgeX, y2: yMax, lineWidth: 0.5 });
       }
     }
   }
   return synthesized.length ? [...verticals, ...synthesized] : verticals;
 }
-function mergeParallelLines(lines, dir) {
+function mergeParallelLines(lines, dir, nonRules) {
   if (lines.length <= 1) return lines;
   const sorted = [...lines].sort((a, b) => {
     const posA = dir === "h" ? a.y1 : a.x1;
@@ -685,6 +685,7 @@ function mergeParallelLines(lines, dir) {
       const overlap2 = Math.min(prevEnd, currEnd) - Math.max(prevStart, currStart);
       const minLen = Math.min(prevEnd - prevStart, currEnd - currStart);
       if (overlap2 > minLen * 0.3) {
+        if (nonRules?.has(prev) && !nonRules.has(curr)) nonRules.delete(prev);
         if (dir === "h") {
           prev.x1 = Math.min(prev.x1, curr.x1);
           prev.x2 = Math.max(prev.x2, curr.x2);
@@ -4197,7 +4198,12 @@ function detectSpecialKoreanTables(blocks) {
   flushKvTable();
   return result;
 }
-function removeHeaderFooterBlocks(blocks, pageHeights, warnings, notes, tables = false) {
+function removeHeaderFooterBlocks(blocks, pageHeights, warnings, notes, tables = false, context = []) {
+  if (context.length && !tables) {
+    const removed = removeHeaderFooterBlocks([...blocks, ...context], pageHeights, [], notes).filter((index) => index < blocks.length);
+    if (removed.length) warnings.push({ message: `${removed.length}\uAC1C \uBA38\uB9AC\uAE00/\uBC14\uB2E5\uAE00 \uC694\uC18C \uC81C\uAC70\uB428`, code: "HIDDEN_TEXT_FILTERED" });
+    return removed;
+  }
   const ZONE_RATIO = 0.12;
   const MIN_REPEAT2 = 3;
   const topEntries = [];
@@ -4277,6 +4283,7 @@ function removeHeaderFooterBlocks(blocks, pageHeights, warnings, notes, tables =
 
 // src/pdf/table-meta.ts
 var CLIP_TABLES = /* @__PURE__ */ new WeakSet();
+var FRAME_TITLE_BLOCKS = /* @__PURE__ */ new WeakMap();
 var TABLE_COLXS = /* @__PURE__ */ new WeakMap();
 var TABLE_ROWYS = /* @__PURE__ */ new WeakMap();
 var TABLE_TAIL = /* @__PURE__ */ new WeakMap();
@@ -4384,6 +4391,262 @@ function mergeSliverColumns(grid, colXs, maxWidth) {
   return merged;
 }
 
+// src/pdf/image-bullets.ts
+import { OPS as OPS3, ImageKind } from "pdfjs-dist/legacy/build/pdf.mjs";
+var multiply = (m, t) => [
+  m[0] * t[0] + m[2] * t[1],
+  m[1] * t[0] + m[3] * t[1],
+  m[0] * t[2] + m[2] * t[3],
+  m[1] * t[2] + m[3] * t[3],
+  m[0] * t[4] + m[2] * t[5] + m[4],
+  m[1] * t[4] + m[3] * t[5] + m[5]
+];
+function hollowCircle(image) {
+  if (!image?.data || image.width < 16 || image.width > 128 || image.height < 16 || image.height > 128 || Math.abs(image.width - image.height) > Math.min(image.width, image.height) * 0.1) return false;
+  const stride = image.kind === ImageKind.RGB_24BPP ? 3 : image.kind === ImageKind.RGBA_32BPP ? 4 : 0;
+  const { width, height, data } = image;
+  if (!stride || data.length < width * height * stride) return false;
+  const dark = [];
+  let white = 0;
+  for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+    const i = (y * width + x) * stride;
+    if (stride === 4 && data[i + 3] < 240) return false;
+    const min = Math.min(data[i], data[i + 1], data[i + 2]), max = Math.max(data[i], data[i + 1], data[i + 2]);
+    if (max - min > 15) return false;
+    if (min >= 235) white++;
+    if (max < 180) dark.push({ x, y });
+  }
+  if (white < width * height * 0.65 || dark.length < width * height * 0.025 || dark.length > width * height * 0.3) return false;
+  const x0 = Math.min(...dark.map((p) => p.x)), x1 = Math.max(...dark.map((p) => p.x));
+  const y0 = Math.min(...dark.map((p) => p.y)), y1 = Math.max(...dark.map((p) => p.y));
+  const w = x1 - x0 + 1, h = y1 - y0 + 1, radius = (w + h) / 4;
+  const cx = (x0 + x1) / 2, cy = (y0 + y1) / 2;
+  if (Math.abs(w - h) > Math.min(w, h) * 0.15 || w < width * 0.4 || w > width * 0.85 || h < height * 0.4 || h > height * 0.85 || x0 < width * 0.04 || y0 < height * 0.04 || x1 >= width * 0.96 || y1 >= height * 0.96 || Math.abs(cx - width / 2) > width * 0.15 || Math.abs(cy - height / 2) > height * 0.15) return false;
+  const sectors = /* @__PURE__ */ new Set();
+  for (const point of dark) {
+    const r = Math.hypot(point.x - cx, point.y - cy) / radius;
+    if (r < 0.65 || r > 1.15) return false;
+    sectors.add(Math.floor((Math.atan2(point.y - cy, point.x - cx) + Math.PI) / (Math.PI * 2) * 8) % 8);
+  }
+  return sectors.size === 8;
+}
+async function resolveImagePixels(page, id) {
+  const objects = id.startsWith("g_") ? page.commonObjs : page.objs;
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(null), 5e3);
+    try {
+      objects.get(id, (value) => {
+        clearTimeout(timer);
+        resolve(value ?? null);
+      });
+    } catch {
+      clearTimeout(timer);
+      resolve(null);
+    }
+  });
+}
+function smallVisibleImagePaints(fnArray, argsArray) {
+  const paints = [];
+  let ctm = [1, 0, 0, 1, 0, 0];
+  let alpha = 1, clip = null, unknownClip = false;
+  const stack = [];
+  let pathRect, pendingClip = false;
+  const intersectClip = (box) => {
+    clip = clip ? {
+      x1: Math.max(clip.x1, box.x1),
+      y1: Math.max(clip.y1, box.y1),
+      x2: Math.min(clip.x2, box.x2),
+      y2: Math.min(clip.y2, box.y2)
+    } : box;
+  };
+  const rectangle = (x, y, w, h) => extractImageRegions(
+    [OPS3.transform, OPS3.transform, OPS3.paintImageXObject],
+    [ctm, [w, 0, 0, h, x, y], ["bounds"]]
+  )[0];
+  for (let i = 0; i < fnArray.length; i++) {
+    const op = fnArray[i], args = argsArray[i];
+    if (op === OPS3.save || op === OPS3.paintFormXObjectBegin) {
+      stack.push({ ctm, alpha, clip, unknownClip });
+      const matrix = op === OPS3.paintFormXObjectBegin ? args?.[0] : void 0;
+      if (Array.isArray(matrix) && matrix.length >= 6) ctm = multiply(ctm, matrix);
+      const bounds = op === OPS3.paintFormXObjectBegin ? args?.[1] : void 0;
+      if (Array.isArray(bounds) && bounds.length === 4) {
+        const box = rectangle(bounds[0], bounds[1], bounds[2] - bounds[0], bounds[3] - bounds[1]);
+        if (box && ctm[1] === 0 && ctm[2] === 0) intersectClip(box);
+        else unknownClip = true;
+      }
+    } else if (op === OPS3.restore || op === OPS3.paintFormXObjectEnd) {
+      const state = stack.pop();
+      ctm = state?.ctm ?? [1, 0, 0, 1, 0, 0];
+      alpha = state?.alpha ?? 1;
+      clip = state?.clip ?? null;
+      unknownClip = state?.unknownClip ?? false;
+    } else if (op === OPS3.setGState) {
+      for (const [key, value] of args?.[0] ?? []) {
+        if (key === "ca") alpha = typeof value === "number" ? value : 0;
+      }
+    } else if (op === OPS3.constructPath) {
+      const [operations, coordinates] = args;
+      pathRect = pathRect === void 0 && operations?.length === 1 && operations[0] === OPS3.rectangle && coordinates?.length >= 4 && ctm[1] === 0 && ctm[2] === 0 ? rectangle(coordinates[0], coordinates[1], coordinates[2], coordinates[3]) : null;
+    } else if (op === OPS3.clip || op === OPS3.eoClip) pendingClip = true;
+    else if ([
+      OPS3.endPath,
+      OPS3.stroke,
+      OPS3.closeStroke,
+      OPS3.fill,
+      OPS3.eoFill,
+      OPS3.fillStroke,
+      OPS3.eoFillStroke,
+      OPS3.closeFillStroke,
+      OPS3.closeEOFillStroke
+    ].includes(op)) {
+      if (pendingClip) {
+        if (pathRect) intersectClip(pathRect);
+        else unknownClip = true;
+      }
+      pendingClip = false;
+      pathRect = void 0;
+    } else if (op === OPS3.transform && Array.isArray(args) && args.length >= 6) ctm = multiply(ctm, args);
+    else if (op === OPS3.paintImageXObject && typeof args?.[0] === "string") {
+      if (typeof args[1] !== "number" || typeof args[2] !== "number" || args[1] < 16 || args[1] > 128 || args[2] < 16 || args[2] > 128) continue;
+      const box = extractImageRegions([OPS3.transform, OPS3.paintImageXObject], [ctm, args])[0];
+      if (!box || ctm[1] !== 0 || ctm[2] !== 0 || alpha < 0.99 || unknownClip || clip && (box.x1 + (box.x2 - box.x1) * 0.03 < clip.x1 || box.y1 + (box.y2 - box.y1) * 0.03 < clip.y1 || box.x2 - (box.x2 - box.x1) * 0.03 > clip.x2 || box.y2 - (box.y2 - box.y1) * 0.03 > clip.y2)) continue;
+      const width = box.x2 - box.x1, height = box.y2 - box.y1;
+      if (width < 3 || width > 24 || height < 3 || height > 24 || width / height < 0.5 || width / height > 2) continue;
+      paints.push({ id: args[0], box, mirrored: ctm[0] < 0 });
+    }
+  }
+  return paints;
+}
+async function restoreImageBullets(items, page, fnArray, argsArray, shapes = /* @__PURE__ */ new Map()) {
+  const candidates = [];
+  for (const { id, box } of smallVisibleImagePaints(fnArray, argsArray)) {
+    const width = box.x2 - box.x1, height = box.y2 - box.y1;
+    if (Math.abs(width - height) > Math.min(width, height) * 0.1) continue;
+    const line = items.filter((item) => !item.isHidden && item.fontSize > 0 && item.x >= box.x2 && item.x - box.x2 <= item.fontSize * 0.7 && Math.abs(item.y + item.h / 2 - (box.y1 + box.y2) / 2) <= item.fontSize * 0.4 && height >= item.fontSize * 0.5 && height <= item.fontSize * 1.2).sort((a, b) => a.x - b.x)[0];
+    if (!line || /^[○●•◦□■∙]/.test(line.text.trim()) || !/\p{L}/u.test(line.text)) continue;
+    const row = items.filter((item) => Math.abs(item.y - line.y) <= 2 && item.x >= line.x);
+    if (row.reduce((n, item) => n + (item.text.match(/\p{L}/gu)?.length ?? 0), 0) < 12 || items.some((item) => item !== line && Math.abs(item.y - line.y) <= 2 && item.x < line.x)) continue;
+    candidates.push({ id, x: box.x1, width, line });
+  }
+  let restored = 0;
+  const used = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    const same = candidates.filter((other) => other.id === candidate.id && other.line !== candidate.line && Math.abs(other.line.x - candidate.line.x) <= 1 && Math.abs(other.x - candidate.x) <= 1 && Math.abs(other.width - candidate.width) <= 1 && other.line.fontSize === candidate.line.fontSize && Math.abs(other.line.y - candidate.line.y) >= candidate.line.fontSize * 2);
+    const numbered = items.filter((item) => !item.isHidden && /^[①-⑮]\s*/.test(item.text.trim()) && item.fontName === candidate.line.fontName && item.fontSize === candidate.line.fontSize && Math.abs(item.x - candidate.x) <= 1 && (item.text.match(/\p{L}/gu)?.length ?? 0) >= 12).sort((a, b) => b.y - a.y);
+    const numberedList = numbered.some((item, index) => index > 0 && item.text.trim().charCodeAt(0) === numbered[index - 1].text.trim().charCodeAt(0) + 1);
+    if (!same.length && !numberedList || used.has(candidate.line)) continue;
+    if (!shapes.has(candidate.id)) shapes.set(candidate.id, hollowCircle(await resolveImagePixels(page, candidate.id)));
+    if (!shapes.get(candidate.id)) continue;
+    used.add(candidate.line);
+    items.push({ ...candidate.line, text: "\u25CB", x: candidate.x, w: candidate.width, strike: false, underline: false, hasSpaceBefore: false, syntheticSpace: false });
+    restored++;
+  }
+  return restored;
+}
+
+// src/pdf/flow-boxes.ts
+import { ImageKind as ImageKind2 } from "pdfjs-dist/legacy/build/pdf.mjs";
+var contains2 = (outer, inner, tolerance = 1) => inner.x1 >= outer.x1 - tolerance && inner.x2 <= outer.x2 + tolerance && inner.y1 >= outer.y1 - tolerance && inner.y2 <= outer.y2 + tolerance;
+function closed(grid, hs, vs) {
+  const b = grid.bbox;
+  return [b.y1, b.y2].every((y) => hs.some((h) => Math.abs(h.y1 - y) <= 1 && h.x1 <= b.x1 + 1 && h.x2 >= b.x2 - 1)) && [b.x1, b.x2].every((x) => vs.some((v) => Math.abs(v.x1 - x) <= 1 && v.y1 <= b.y1 + 1 && v.y2 >= b.y2 - 1));
+}
+function groupFlowBoxUnits(blocks, grids, hs, vs, images) {
+  const candidates = grids.filter((g) => g.bbox.y2 - g.bbox.y1 >= 30 && closed(g, hs, vs) && !grids.some((other) => other !== g && contains2(other.bbox, g.bbox, 0) && (other.bbox.x2 - other.bbox.x1) * (other.bbox.y2 - other.bbox.y1) > (g.bbox.x2 - g.bbox.x1) * (g.bbox.y2 - g.bbox.y1) + 1));
+  const bands = [], visited = /* @__PURE__ */ new Set();
+  for (const first of candidates) {
+    if (visited.has(first)) continue;
+    const row = candidates.filter((g) => Math.abs(g.bbox.y1 - first.bbox.y1) <= 1 && Math.abs(g.bbox.y2 - first.bbox.y2) <= 1).sort((a, b) => a.bbox.x1 - b.bbox.x1);
+    row.forEach((g) => visited.add(g));
+    if (row.length < 4 || row.filter((g) => g.rowYs.length === 2 && g.colXs.length === 2).length < 3) continue;
+    const connectors = [];
+    for (let i = 1; i < row.length; i++) {
+      const left = row[i - 1].bbox, right = row[i].bbox, gap = right.x1 - left.x2;
+      if (gap < 4 || gap > Math.min(left.x2 - left.x1, right.x2 - right.x1) * 0.6) break;
+      const centerX = (left.x2 + right.x1) / 2, centerY = (left.y1 + left.y2) / 2;
+      const connector = images.find((p) => {
+        const w = p.x2 - p.x1, h = p.y2 - p.y1;
+        return p.x1 >= left.x2 && p.x2 <= right.x1 && w >= gap * 0.4 && w <= gap * 0.9 && h >= 3 && h <= (left.y2 - left.y1) * 0.2 && w / h >= 0.8 && w / h <= 1.6 && Math.abs((p.x1 + p.x2) / 2 - centerX) <= gap * 0.15 && Math.abs((p.y1 + p.y2) / 2 - centerY) <= (left.y2 - left.y1) * 0.1;
+      });
+      if (!connector) break;
+      connectors.push(connector);
+    }
+    if (connectors.length !== row.length - 1 || connectors.some((p) => Math.abs(p.x2 - p.x1 - (connectors[0].x2 - connectors[0].x1)) > (connectors[0].x2 - connectors[0].x1) * 0.2 || Math.abs(p.y2 - p.y1 - (connectors[0].y2 - connectors[0].y1)) > (connectors[0].y2 - connectors[0].y1) * 0.2)) continue;
+    bands.push(row);
+  }
+  const members = /* @__PURE__ */ new Map();
+  for (const band of bands) {
+    const columns = band.map((g) => blocks.filter((b) => b.bbox && contains2(g.bbox, {
+      x1: b.bbox.x,
+      y1: b.bbox.y,
+      x2: b.bbox.x + b.bbox.width,
+      y2: b.bbox.y + b.bbox.height
+    })).sort((a, b) => b.bbox.y + b.bbox.height - a.bbox.y - a.bbox.height || a.bbox.x - b.bbox.x));
+    if (columns.some((column) => !column.length)) continue;
+    const unit = columns.flat();
+    for (const block of unit) members.set(block, unit);
+  }
+  const units = [], emitted = /* @__PURE__ */ new Set();
+  for (const block of blocks) {
+    const unit = members.get(block);
+    if (!unit) units.push([block]);
+    else if (!emitted.has(unit)) {
+      units.push(unit);
+      emitted.add(unit);
+    }
+  }
+  return units;
+}
+function arrowDirection(image) {
+  if (!image?.data || image.width < 16 || image.width > 128 || image.height < 16 || image.height > 128) return 0;
+  const { width, height, data } = image;
+  const stride = image.kind === ImageKind2.RGB_24BPP ? 3 : image.kind === ImageKind2.RGBA_32BPP ? 4 : 0;
+  if (!stride || data.length < width * height * stride) return 0;
+  const ink = [];
+  let white = 0;
+  for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+    const offset = (y * width + x) * stride;
+    if (stride === 4 && data[offset + 3] < 240) return 0;
+    const min = Math.min(data[offset], data[offset + 1], data[offset + 2]);
+    if (min >= 235) white++;
+    if (min < 230) ink.push({ x, y });
+  }
+  if (white < width * height * 0.55 || !ink.length) return 0;
+  const x0 = Math.min(...ink.map((p) => p.x)), x1 = Math.max(...ink.map((p) => p.x));
+  const y0 = Math.min(...ink.map((p) => p.y)), y1 = Math.max(...ink.map((p) => p.y));
+  const w = x1 - x0 + 1, h = y1 - y0 + 1, centerY = (y0 + y1) / 2;
+  if (w < width * 0.5 || h < height * 0.5 || x0 < width * 0.04 || y0 < height * 0.04 || x1 >= width * 0.96 || y1 >= height * 0.96) return 0;
+  const pointsRight = (mirror) => {
+    const points = ink.map((p) => ({ x: mirror ? x0 + x1 - p.x : p.x, y: p.y }));
+    const tail = points.filter((p) => p.x <= x0 + w * 0.25), tip = points.filter((p) => p.x >= x1 - w * 0.1);
+    if (!tail.length || !tip.length) return false;
+    const span = (points2) => Math.max(...points2.map((p) => p.y)) - Math.min(...points2.map((p) => p.y)) + 1;
+    if (span(tail) > h * 0.4 || span(tip) > h * 0.45 || Math.abs((Math.max(...tail.map((p) => p.y)) + Math.min(...tail.map((p) => p.y))) / 2 - centerY) > h * 0.1 || Math.abs((Math.max(...tip.map((p) => p.y)) + Math.min(...tip.map((p) => p.y))) / 2 - centerY) > h * 0.1) return false;
+    let head = 0;
+    for (let x = Math.ceil(x0 + w * 0.45); x <= x0 + w * 0.75; x++) {
+      const column = points.filter((p) => p.x === x);
+      if (column.length) head = Math.max(head, span(column));
+    }
+    const middle = new Set(points.filter((p) => Math.abs(p.y - centerY) <= 1).map((p) => p.x));
+    return head >= h * 0.8 && middle.size >= w * 0.9;
+  };
+  return pointsRight(false) ? 1 : pointsRight(true) ? -1 : 0;
+}
+async function detectRightArrowRegions(page, fnArray, argsArray, directions = /* @__PURE__ */ new Map()) {
+  const regions = [];
+  const paints = smallVisibleImagePaints(fnArray, argsArray);
+  for (const paint of paints) {
+    const row = paints.filter((other) => other.id === paint.id && Math.abs(other.box.y1 - paint.box.y1) <= 1 && Math.abs(other.box.y2 - paint.box.y2) <= 1 && Math.abs(other.box.x2 - other.box.x1 - (paint.box.x2 - paint.box.x1)) <= 1);
+    const positions = new Set(row.map((other) => Math.round(other.box.x1)));
+    if (positions.size < 3) continue;
+    if (!directions.has(paint.id)) directions.set(paint.id, arrowDirection(await resolveImagePixels(page, paint.id)));
+    const direction = directions.get(paint.id) ?? 0;
+    if (direction && (paint.mirrored ? -direction : direction) === 1) regions.push(paint.box);
+  }
+  return regions;
+}
+
 // src/pdf/side-tabs.ts
 var BAND = 0.12;
 var MAX_CHARS = 10;
@@ -4398,7 +4661,8 @@ function isSideTabTable(box, table, others, pageWidth, pageHeight) {
   if (!side) return false;
   const texts = table.cells.flat().map((c) => c.text.replace(/\s+/g, ""));
   if (!texts.some(Boolean) || texts.some((t) => [...t].length > TAB_CELL_CHARS)) return false;
-  return others.every((it) => it.y < box.y1 || it.y > box.y2 || (side === "R" ? it.x + it.w <= box.x1 + 1 : it.x >= box.x2 - 1));
+  const overlap2 = others.filter((it) => it.y >= box.y1 && it.y <= box.y2);
+  return overlap2.length > 0 && overlap2.every((it) => side === "R" ? it.x + it.w <= box.x1 + 1 : it.x >= box.x2 - 1);
 }
 function removeSideTabs(blocks, pageWidths) {
   const edges = /* @__PURE__ */ new Map();
@@ -4427,7 +4691,7 @@ function removeSideTabs(blocks, pageWidths) {
     }
     if (!w || !area || !b.bbox || !text || [...text].length > MAX_CHARS) return null;
     const side = b.bbox.x + b.bbox.width <= Math.min(w * BAND, area.left - 1) ? "L" : b.bbox.x >= Math.max(w * (1 - BAND), area.right + 1) ? "R" : null;
-    return side && text.replace(/\s+/g, "");
+    return side && `${side}\0${text.replace(/\s+/g, "")}`;
   };
   const pages = /* @__PURE__ */ new Map();
   for (const b of blocks) {
@@ -4634,15 +4898,39 @@ function sideTabGlyphs(items) {
     if (c) c.push(it);
     else cols.push([it]);
   }
+  const cands = [];
   for (const col of cols) {
-    if (col.length < SIDE_TAB_MIN) continue;
+    if (col.length < 2) continue;
     if (col.filter((g) => /[\p{L}\p{N}]/u.test(g.text)).length < col.length * 0.8) continue;
     col.sort((a, b) => b.y - a.y);
     const fs = [...col.map((i) => i.fontSize)].sort((a, b) => a - b)[col.length >> 1];
     if (col.slice(1).some((it, k) => col[k].y - it.y > fs * 3)) continue;
+    cands.push({ col, fs });
+  }
+  const bands = [];
+  for (const c of cands.sort((a, b) => a.col[0].x - b.col[0].x)) {
+    const last = bands[bands.length - 1];
+    if (last) {
+      const lastRight = Math.max(...last.col.map((i) => i.x + i.w));
+      const gap = Math.min(...c.col.map((i) => i.x)) - lastRight;
+      const lTop = Math.max(...last.col.map((i) => i.y)), lBot = Math.min(...last.col.map((i) => i.y));
+      const cTop = c.col[0].y, cBot = c.col[c.col.length - 1].y;
+      if (gap <= Math.max(last.fs, c.fs) * 1.5 && Math.min(lTop, cTop) >= Math.max(lBot, cBot)) {
+        last.col.push(...c.col);
+        last.fs = Math.max(last.fs, c.fs);
+        last.anchored ||= c.col.length >= SIDE_TAB_MIN;
+        continue;
+      }
+    }
+    bands.push({ col: [...c.col], fs: c.fs, anchored: c.col.length >= SIDE_TAB_MIN });
+  }
+  for (const { col, fs, anchored } of bands) {
+    if (!anchored) continue;
+    col.sort((a, b) => b.y - a.y);
     const members = new Set(col);
     const top = col[0].y + fs, bottom = col[col.length - 1].y - fs;
-    const others = items.filter((i) => !members.has(i) && i.y <= top && i.y >= bottom);
+    const others = items.filter((i) => !members.has(i) && i.text.trim() && i.y <= top && i.y >= bottom);
+    if (!others.length) continue;
     const left = Math.min(...col.map((i) => i.x)), right = Math.max(...col.map((i) => i.x + i.w));
     const rest = items.filter((i) => !members.has(i) && i.text.trim());
     const outside = rest.every((i) => i.x >= right + fs) || rest.every((i) => i.x + i.w <= left - fs);
@@ -5903,13 +6191,44 @@ var UNDER_SPAN_OVERLAP_RATIO = 0.8;
 var UNDER_BOX_PAIR_MIN_EM = 0.5;
 var UNDER_BOX_PAIR_MAX_EM = 2.2;
 var UNDER_BOX_PAIR_OVERLAP = 0.8;
-function markUnderlineItems(items, horizontals, verticals) {
+function markUnderlineItems(items, horizontals, verticals, nonRules) {
   const underlines = [];
+  if (nonRules?.size) horizontals = horizontals.filter((line) => !nonRules.has(line));
   if (items.length === 0 || horizontals.length === 0) return underlines;
+  const tightOwners = /* @__PURE__ */ new Map();
+  const tightlyOwned = (line) => {
+    const cached = tightOwners.get(line);
+    if (cached !== void 0) return cached;
+    const owners = items.filter((item) => {
+      const below = item.y - line.y1;
+      return item.w > 0 && item.text.trim() && below >= 0.5 && below <= 3 && Math.min(line.x2, item.x + item.w) > Math.max(line.x1, item.x);
+    }).sort((a, b) => a.x - b.x);
+    let owned = owners.length > 0 && (Math.abs(owners[0].x - line.x1) <= UNDER_GRID_EPS || owners.length === 1 && line.x1 > owners[0].x && line.x1 - owners[0].x <= Math.max(owners[0].h, owners[0].fontSize, 1) * 3) && Math.abs(owners[owners.length - 1].x + owners[owners.length - 1].w - line.x2) <= UNDER_GRID_EPS;
+    for (let i = 1; owned && i < owners.length; i++) {
+      const em = Math.max(owners[i].h, owners[i].fontSize, 1);
+      if (owners[i].x - (owners[i - 1].x + owners[i - 1].w) > em * UNDER_COLUMN_GAP_EM) owned = false;
+    }
+    tightOwners.set(line, owned);
+    return owned;
+  };
+  const paragraphUnderline = (line) => {
+    if (!tightlyOwned(line)) return false;
+    const width = line.x2 - line.x1;
+    const ys = [];
+    for (const other of horizontals) {
+      const overlap2 = Math.min(line.x2, other.x2) - Math.max(line.x1, other.x1);
+      if (other.lineWidth > UNDER_MAX_THICKNESS || overlap2 / Math.max(width, other.x2 - other.x1) < UNDER_SPAN_OVERLAP_RATIO || !tightlyOwned(other)) continue;
+      if (!ys.some((y) => Math.abs(y - other.y1) < UNDER_GRID_EPS)) ys.push(other.y1);
+      if (ys.length >= UNDER_REPEATED_SPAN_LEVELS) return true;
+    }
+    return false;
+  };
   for (const line of horizontals) {
     if (line.lineWidth > UNDER_MAX_THICKNESS) continue;
     const enclosed = insideTallCell(line, verticals, 0);
-    if (!enclosed && (touchesVertical(line, verticals) || isRepeatedSpanRule(line, horizontals))) continue;
+    const repeated = isRepeatedSpanRule(line, horizontals);
+    const textSeries = repeated && paragraphUnderline(line);
+    if (!enclosed && (touchesVertical(line, verticals) || repeated && !textSeries)) continue;
     const matches = [];
     for (const item of items) {
       const h = item.h > 0 ? item.h : item.fontSize;
@@ -5929,11 +6248,11 @@ function markUnderlineItems(items, horizontals, verticals) {
       covered += m.w;
     }
     const inset = enclosed && insideTallCell(line, verticals, maxH);
-    if (enclosed && !inset && (touchesVertical(line, verticals) || isRepeatedSpanRule(line, horizontals))) continue;
+    if (enclosed && !inset && (touchesVertical(line, verticals) || repeated && !textSeries)) continue;
     const pad = Math.max(maxH * UNDER_OWNER_PAD_EM, UNDER_OWNER_PAD_MIN_PT);
     if (line.x1 < x1 - pad || line.x2 > x2 + pad) continue;
     if (covered < (line.x2 - line.x1) * UNDER_MIN_COVERAGE) continue;
-    if (hasBoxTopPair(line, maxH, horizontals, inset ? items : void 0)) continue;
+    if (hasBoxTopPair(line, maxH, horizontals, inset || textSeries || tightlyOwned(line) ? items : void 0)) continue;
     matches.sort((a, b) => a.x - b.x);
     let hole = false;
     for (let i = 1; i < matches.length; i++) {
@@ -5964,6 +6283,7 @@ function touchesVertical(line, verticals) {
   for (const v of verticals) {
     if (v.x1 < line.x1 - UNDER_GRID_EPS || v.x1 > line.x2 + UNDER_GRID_EPS) continue;
     const lo = Math.min(v.y1, v.y2), hi = Math.max(v.y1, v.y2);
+    if (hi - lo <= UNDER_GRID_EPS) continue;
     if (lo <= line.y1 + UNDER_GRID_EPS && hi >= line.y1 - UNDER_GRID_EPS) return true;
   }
   return false;
@@ -6173,6 +6493,57 @@ function isPageFrameGrid(grid, cells, pageWidth, pageHeight, items = []) {
   return inner.length === 0 || crossing >= 1 && crossing >= inBig.length * 0.01;
 }
 
+// src/pdf/shaded-open-table.ts
+function closeShadedTableEdges(clipGrids, horizontals, verticals, fillRects) {
+  const near = (a, b) => Math.abs(a - b) <= 1.5;
+  let hs = horizontals, vs = verticals;
+  const restored = [];
+  for (const grid of clipGrids) {
+    if (grid.clipParent || grid.rowYs.length !== 2 || grid.colXs.length < 3 || !grid.cells?.length || grid.cells.some((c) => c.filler || c.rowSpan !== 1 || c.colSpan !== 1)) continue;
+    const { x1, x2, y1: mid, y2: top } = grid.bbox;
+    if (!grid.cells.every((c) => fillRects.some((f) => near(f.x1, c.bbox.x1) && near(f.x2, c.bbox.x2) && near(f.y1, c.bbox.y1) && near(f.y2, c.bbox.y2)))) continue;
+    const topRule = hs.find((h) => near(h.y1, top) && near(h.x1, x1) && near(h.x2, x2));
+    if (!topRule) continue;
+    const dividers = grid.colXs.slice(1, -1).map((x) => vs.find((v) => near(v.x1, x) && near(v.y2, top) && v.y1 <= mid - 6));
+    if (dividers.some((v) => !v)) continue;
+    const bottom = dividers[0].y1;
+    if (!dividers.every((v) => near(v.y1, bottom))) continue;
+    const bottomRule = hs.find((h) => near(h.y1, bottom) && near(h.x1, x1) && near(h.x2, x2));
+    if (!bottomRule) continue;
+    const missing = [x1, x2].filter((x) => !vs.some((v) => near(v.x1, x) && v.y1 <= bottom + 1.5 && v.y2 >= top - 1.5));
+    if (!missing.length) continue;
+    restored.push({ x1, x2, y1: bottom, y2: top });
+    vs = vs.concat(missing.map((x) => ({ x1: x, x2: x, y1: bottom, y2: top, lineWidth: topRule.lineWidth })));
+    if (!hs.some((h) => near(h.y1, mid) && near(h.x1, x1) && near(h.x2, x2))) {
+      hs = hs.concat({ x1, x2, y1: mid, y2: mid, lineWidth: topRule.lineWidth });
+    }
+  }
+  return { horizontals: hs, verticals: vs, restored };
+}
+function nestRestoredShadedGrids(grids, restored, horizontals, verticals) {
+  const near = (a, b) => Math.abs(a - b) <= 1.5;
+  if (restored.length === 0) return;
+  const nested = /* @__PURE__ */ new Set();
+  for (const grid of grids) {
+    const b = grid.bbox;
+    if (!restored.some((r) => near(r.x1, b.x1) && near(r.x2, b.x2) && near(r.y1, b.y1) && near(r.y2, b.y2))) continue;
+    if (grids.some((g) => g !== grid && b.x1 - g.bbox.x1 >= 0.8 && g.bbox.x2 - b.x2 >= 0.8 && b.y1 - g.bbox.y1 >= 0.8 && g.bbox.y2 - b.y2 >= 0.8)) {
+      grid.lineNested = true;
+      nested.add(grid);
+    }
+  }
+  for (const frame of grids) {
+    const b = frame.bbox;
+    if (frame.lineNested || ![...nested].some((g) => g.bbox.x1 > b.x1 && g.bbox.x2 < b.x2 && g.bbox.y1 > b.y1 && g.bbox.y2 < b.y2)) continue;
+    const fullH = horizontals.filter((h) => near(h.x1, b.x1) && near(h.x2, b.x2) && h.y1 >= b.y1 - 1.5 && h.y1 <= b.y2 + 1.5);
+    if (!fullH.some((h) => near(h.y1, b.y1)) || !fullH.some((h) => near(h.y1, b.y2)) || fullH.some((h) => h.y1 > b.y1 + 1.5 && h.y1 < b.y2 - 1.5)) continue;
+    const fullV = verticals.filter((v) => v.y1 <= b.y1 + 1.5 && v.y2 >= b.y2 - 1.5 && v.x1 >= b.x1 - 1.5 && v.x1 <= b.x2 + 1.5);
+    if (!fullV.some((v) => near(v.x1, b.x1)) || !fullV.some((v) => near(v.x1, b.x2)) || fullV.some((v) => v.x1 > b.x1 + 1.5 && v.x1 < b.x2 - 1.5)) continue;
+    frame.colXs = [b.x1, b.x2];
+    frame.rowYs = [b.y2, b.y1];
+  }
+}
+
 // src/pdf/open-table-ends.ts
 var ALIGN_TOL = 3;
 var MIN_RULES = 3;
@@ -6508,6 +6879,189 @@ function detectTextBoxTables(boxes, items, pageNum) {
   }];
 }
 
+// src/pdf/frame-cell-blocks.ts
+var FRAME_READING_UNITS = /* @__PURE__ */ new WeakMap();
+var FRAME_SOURCE_BOUNDS = /* @__PURE__ */ new WeakMap();
+function recordFrameReadingUnit(blocks, bbox) {
+  for (const block of blocks) FRAME_SOURCE_BOUNDS.set(block, bbox);
+  if (blocks.length < 2) return;
+  const unit = { blocks, bbox };
+  for (const block of blocks) FRAME_READING_UNITS.set(block, unit);
+}
+function frameLayoutBoxes(blocks) {
+  const boxes = [], seen2 = /* @__PURE__ */ new Set();
+  for (const block of blocks) {
+    const frame = FRAME_SOURCE_BOUNDS.get(block);
+    if (frame) {
+      if (!seen2.has(frame)) {
+        boxes.push(frame);
+        seen2.add(frame);
+      }
+    } else if (block.bbox) boxes.push(block.bbox);
+  }
+  return boxes;
+}
+function takeFrameSpanningText(items, cutX, pageNum, lex) {
+  let minX = Infinity, maxR = -Infinity;
+  for (const item of items) {
+    minX = Math.min(minX, item.x);
+    maxR = Math.max(maxR, item.x + item.w);
+  }
+  const span = maxR - minX;
+  const rows = groupByY([...items].sort((a, b) => b.y - a.y || a.x - b.x)).map((line) => {
+    const runs = [];
+    for (const item of [...line].sort((a, b) => a.x - b.x)) {
+      const run = runs[runs.length - 1], prev = run?.[run.length - 1];
+      if (prev && item.x - (prev.x + prev.w) <= Math.max(prev.fontSize, item.fontSize) * 0.6) run.push(item);
+      else runs.push([item]);
+    }
+    return runs;
+  });
+  const taken = /* @__PURE__ */ new Set(), blocks = [];
+  for (let r = 0; r < rows.length; r++) for (const run of rows[r]) {
+    if (taken.has(run[0]) || run[0].x >= cutX || Math.max(...run.map((i) => i.x + i.w)) <= cutX) continue;
+    const lines = [run], fs = Math.max(...run.map((i) => i.fontSize));
+    const left = run[0].x, right = Math.max(...run.map((i) => i.x + i.w));
+    if (right - left < span * 0.75) continue;
+    let prevY = run[0].y;
+    for (let next = r + 1; next < rows.length && rows[next].length === 1; next++) {
+      const tail = rows[next][0], y = tail[0].y;
+      if (taken.has(tail[0]) || prevY - y > fs * 1.8 || tail[0].x < left - 1 || tail[0].x > left + fs * 2 || tail.some((i) => Math.abs(i.fontSize - fs) > fs * 0.15) || Math.max(...tail.map((i) => i.x + i.w)) > right + 1) break;
+      lines.push(tail);
+      prevY = y;
+    }
+    for (const line of lines) for (const item of line) taken.add(item);
+    pushLineParagraphs(blocks, mergeSuperscriptLines(lines), pageNum, lex);
+  }
+  let keep = 0;
+  for (const item of items) if (!taken.has(item)) items[keep++] = item;
+  items.length = keep;
+  return blocks;
+}
+function frameColumnTextBands(items, spanning, cutX) {
+  const tops = spanning.filter((b) => b.bbox).map((b) => b.bbox.y + b.bbox.height).sort((a, b) => b - a);
+  const bands = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    let band = 0;
+    while (band < tops.length && tops[band] > item.y + item.h) band++;
+    const sides = bands.get(band) ?? [[], [], []];
+    sides[item.x + item.w <= cutX ? 0 : item.x >= cutX ? 2 : 1].push(item);
+    bands.set(band, sides);
+  }
+  return [...bands].sort((a, b) => a[0] - b[0]).flatMap(([, sides]) => sides.filter((side) => side.length));
+}
+function groupFrameParagraphUnits(units, frames) {
+  const source = /* @__PURE__ */ new Map();
+  for (const unit of units) for (const block of unit) source.set(block, unit);
+  const members = /* @__PURE__ */ new Map(), emitted = /* @__PURE__ */ new Set();
+  for (const frame of frames) {
+    if (frame.length < 2 || frame.some((block) => block.type !== "paragraph" || source.get(block)?.length !== 1)) continue;
+    for (const block of frame) members.set(block, frame);
+  }
+  const out = [];
+  for (const unit of units) {
+    const frame = unit.length === 1 ? members.get(unit[0]) : void 0;
+    if (!frame) out.push(unit);
+    else if (!emitted.has(frame)) {
+      out.push(frame);
+      emitted.add(frame);
+    }
+  }
+  for (const unit of out) {
+    if (unit.length < 2 || FRAME_READING_UNITS.get(unit[0])?.blocks === unit) continue;
+    const bs = unit.map((b) => b.bbox).filter((b) => !!b);
+    if (bs.length !== unit.length) continue;
+    const x = Math.min(...bs.map((b) => b.x)), y = Math.min(...bs.map((b) => b.y));
+    recordFrameReadingUnit(unit, {
+      page: bs[0].page,
+      x,
+      y,
+      width: Math.max(...bs.map((b) => b.x + b.width)) - x,
+      height: Math.max(...bs.map((b) => b.y + b.height)) - y
+    });
+  }
+  return out;
+}
+function recordFrameTitle(table, source, pageNum) {
+  if (!CLIP_TABLES.has(table) || table.rows !== 1 || table.cols !== 3 || source.length < 2) return;
+  const cells = table.cells[0];
+  if (cells.length !== 3 || cells.some((c) => c.colSpan !== 1 || c.rowSpan !== 1 || c.blocks?.length || c.text.includes("\n"))) return;
+  const [label, spacer, title] = cells;
+  if (!/^(?:붙임|별첨|첨부|부록)\s*\d{1,3}$/.test(label.text.trim()) || spacer.text.trim() || !title.text.trim()) return;
+  if (cells.some((c) => {
+    const e = CELL_EDGES.get(c);
+    return !e || e.t || e.b || e.l || e.r;
+  })) return;
+  const xs = TABLE_COLXS.get(table), style = dominantStyle(source), fs = style?.fontSize ?? 0;
+  if (!xs || xs.length !== 4 || fs <= 0) return;
+  const width = xs[3] - xs[0], gap = xs[2] - xs[1];
+  if (width < fs * 12 || gap <= 0 || gap > fs * 1.5 || xs[1] - xs[0] > width * 0.25 || xs[3] - xs[2] < width * 0.6) return;
+  if (source.some((i) => i.fontName !== source[0].fontName || Math.abs(i.fontSize - fs) > fs * 0.15)) return;
+  if (groupByY([...source].sort((a, b) => b.y - a.y)).length !== 1) return;
+  FRAME_TITLE_BLOCKS.set(table, {
+    type: "paragraph",
+    text: `${label.text.trim()} ${title.text.trim()}`,
+    pageNumber: pageNum,
+    bbox: computeBBox(source, pageNum),
+    style
+  });
+}
+var FRAME_RECT_TOL = 1.5;
+function takePendingNested(pending, cellBox, clipCell) {
+  const out = [];
+  for (let i = pending.length - 1; i >= 0; i--) {
+    const p = pending[i].parent;
+    if (pending[i].contained ? p.x1 >= cellBox.x1 - FRAME_RECT_TOL && p.x2 <= cellBox.x2 + FRAME_RECT_TOL && p.y1 >= cellBox.y1 - FRAME_RECT_TOL && p.y2 <= cellBox.y2 + FRAME_RECT_TOL : clipCell && Math.abs(p.x1 - cellBox.x1) <= FRAME_RECT_TOL && Math.abs(p.x2 - cellBox.x2) <= FRAME_RECT_TOL && Math.abs(p.y1 - cellBox.y1) <= FRAME_RECT_TOL && Math.abs(p.y2 - cellBox.y2) <= FRAME_RECT_TOL) {
+      out.push(pending[i].block);
+      pending.splice(i, 1);
+    }
+  }
+  return out;
+}
+function buildFrameCellBlocks(cellItems, nested, pageNum, lex) {
+  const tables = [...nested].sort((a, b) => b.bbox.y + b.bbox.height - (a.bbox.y + a.bbox.height));
+  const blocks = [];
+  let rest = [...cellItems];
+  const pushParagraphs = (items) => {
+    if (items.length === 0) return;
+    const source = items.map((it) => ({ ...it, isHidden: false })).sort((a, b) => b.y - a.y || a.x - b.x);
+    const paragraphs = [];
+    pushLineParagraphs(paragraphs, mergeSuperscriptLines(groupByY(source)), pageNum, lex);
+    for (const block of paragraphs) {
+      block.text = cleanCellText(block.text ?? "");
+      if (block.text) blocks.push(block);
+    }
+  };
+  for (const tb of tables) {
+    const bottom = tb.bbox.y;
+    pushParagraphs(rest.filter((it) => it.y >= bottom));
+    rest = rest.filter((it) => it.y < bottom);
+    blocks.push(tb);
+  }
+  pushParagraphs(rest);
+  const text = blocks.map((b) => b.type === "table" && b.table ? b.table.cells.flat().map((c) => c.text).filter(Boolean).join("\n") : b.text ?? "").filter(Boolean).join("\n");
+  return { blocks, text };
+}
+
+// src/pdf/nested-shaded-headers.ts
+function extendNestedShadedHeaders(clipGrids, lineGrids, horizontals, verticals, fills) {
+  const near = (a, b) => Math.abs(a - b) <= 1.5;
+  const contains3 = (a, b) => b.x1 >= a.x1 - 1.5 && b.x2 <= a.x2 + 1.5 && b.y1 >= a.y1 - 1.5 && b.y2 <= a.y2 + 1.5;
+  const extended = [];
+  for (let i = 0; i < clipGrids.length; i++) {
+    const c = clipGrids[i], parent = c.clipParent;
+    if (!parent || c.rowYs.length !== 2 || c.colXs.length < 3 || !c.cells?.length || c.cells.some((cell) => cell.filler || cell.rowSpan !== 1 || cell.colSpan !== 1)) continue;
+    if (!clipGrids.some((g) => g.rowYs.length === 2 && g.colXs.length === 2 && near(g.bbox.x1, parent.x1) && near(g.bbox.x2, parent.x2) && near(g.bbox.y1, parent.y1) && near(g.bbox.y2, parent.y2))) continue;
+    if (!c.cells.every((cell) => fills.some((f) => near(f.x1, cell.bbox.x1) && near(f.x2, cell.bbox.x2) && near(f.y1, cell.bbox.y1) && near(f.y2, cell.bbox.y2)))) continue;
+    const host = lineGrids.find((l) => l.rowYs.length > 2 && l.colXs.length === c.colXs.length && c.colXs.every((x, k) => near(x, l.colXs[k])) && c.rowYs.every((y, k) => near(y, l.rowYs[k])) && contains3(parent, l.bbox) && l.rowYs.every((y) => horizontals.some((h) => near(h.y1, y) && near(h.x1, l.bbox.x1) && near(h.x2, l.bbox.x2))) && l.colXs.every((x) => verticals.some((v) => near(v.x1, x) && v.y1 <= l.bbox.y1 + 1.5 && v.y2 >= l.bbox.y2 - 1.5)) && !clipGrids.some((o) => o !== c && !contains3(o.bbox, l.bbox) && Math.min(o.bbox.x2, l.bbox.x2) > Math.max(o.bbox.x1, l.bbox.x1) && Math.min(o.bbox.y2, l.bbox.y2) > Math.max(o.bbox.y1, l.bbox.y1)));
+    if (!host) continue;
+    const grid = { ...host, clipParent: parent, cells: extractCells(host, horizontals, verticals) };
+    clipGrids[i] = grid;
+    extended.push(grid);
+  }
+  return extended;
+}
+
 // src/pdf/page-regions.ts
 function splitTwoColumnProse(items, cutX) {
   const left = [];
@@ -6835,7 +7389,7 @@ function figureColumnBands(items, figures) {
 }
 
 // src/pdf/page-blocks.ts
-function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeight, extraLines, detectTables = true, carry, lexicon) {
+function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeight, extraLines, detectTables = true, carry, lexicon, verifiedRightArrows = []) {
   if (items.length === 0) {
     if (carry) carry.clip = void 0;
     return [];
@@ -6843,7 +7397,7 @@ function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeigh
   const tab = sideTabGlyphs(items);
   if (tab.size) {
     const glyphs = [...tab].sort((a, b) => b.y - a.y).map((g) => ({ type: "paragraph", text: g.text.trim(), pageNumber: pageNum, bbox: computeBBox([g], pageNum), style: dominantStyle([g]) }));
-    return [...glyphs, ...extractPageBlocksWithLines(items.filter((i) => !tab.has(i)), pageNum, opList, pageWidth, pageHeight, extraLines, detectTables, carry, lexicon)];
+    return [...glyphs, ...extractPageBlocksWithLines(items.filter((i) => !tab.has(i)), pageNum, opList, pageWidth, pageHeight, extraLines, detectTables, carry, lexicon, verifiedRightArrows)];
   }
   const lex = lexicon ?? new WrapLexicon();
   for (const line of streamLines(items)) lex.addLine(mergeLineSimple(line));
@@ -6871,19 +7425,28 @@ function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeigh
   }
   ;
   ({ horizontals, verticals } = filterPageBorderLines(horizontals, verticals, pageWidth, pageHeight));
-  ({ horizontals, verticals } = preprocessLines(horizontals, verticals));
+  ({ horizontals, verticals } = preprocessLines(horizontals, verticals, extracted.nonRules));
+  markStrikethroughItems(items, horizontals);
+  wrapStrikethroughRuns(items);
+  const underlines = new Set(markUnderlineItems(items, horizontals, verticals, extracted.nonRules));
+  if (underlines.size) horizontals = horizontals.filter((l) => !underlines.has(l));
+  wrapUnderlineRuns(items);
   horizontals = closeOpenTableEnds(horizontals, verticals, items.every((it) => it.seq !== void 0));
   verticals = closeOpenTableEdges(horizontals, verticals);
   verticals = bridgeSplitColumnVerticals(horizontals, verticals);
   if (detectTables && clipGrids.length === 0) verticals = bridgeSkippedRowVerticals(horizontals, verticals, items);
   if (detectTables && clipGrids.length === 0) ({ horizontals, verticals } = extendHeaderBoxRows(horizontals, verticals, items));
-  markStrikethroughItems(items, horizontals);
-  wrapStrikethroughRuns(items);
-  const underlines = new Set(markUnderlineItems(items, horizontals, verticals));
-  if (underlines.size) horizontals = horizontals.filter((l) => !underlines.has(l));
-  wrapUnderlineRuns(items);
+  const shadedEdges = detectTables ? closeShadedTableEdges(clipGrids, horizontals, verticals, extracted.fillRects) : void 0;
+  if (shadedEdges) ({ horizontals, verticals } = shadedEdges);
   const lineGrids = detectTables ? buildTableGrids(horizontals, verticals) : [];
+  if (shadedEdges) nestRestoredShadedGrids(lineGrids, shadedEdges.restored, horizontals, verticals);
   const tableClipGrids = dropHeadBandClipGrids(dropInsetClipGrids(dropShadingClipGrids(clipGrids, lineGrids, extracted.fillRects, verticals), lineGrids), lineGrids);
+  recordClipCellEdges(
+    extendNestedShadedHeaders(tableClipGrids, lineGrids, horizontals, verticals, extracted.fillRects),
+    extracted.horizontals.concat(extracted.shortH),
+    extracted.verticals.concat(extracted.shortV),
+    extracted.nonRules
+  );
   const grids = [...tableClipGrids, ...dropGridsInside(lineGrids, tableClipGrids, clipResult.containers)];
   const figures = () => extractImageRegions(opList.fnArray, opList.argsArray, true).filter((r) => r.x2 - r.x1 >= 40 && r.y2 - r.y1 >= 40).map((r) => ({ x: r.x1, y: r.y1, w: r.x2 - r.x1, h: r.y2 - r.y1 }));
   if (grids.length === 1 && grids[0].rowYs.length === 2 && grids[0].colXs.length === 2 && grids[0].bbox.x2 - grids[0].bbox.x1 > pageWidth * 1.2 && grids[0].bbox.y2 - grids[0].bbox.y1 > pageHeight * 1.2) {
@@ -6893,7 +7456,7 @@ function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeigh
   if (detectTables && clipGrids.length === 0 && ruled.length === 0 && lineGrids.length === 0) ruled.push(...detectTextBoxTables(extracted.hiddenBoxes, items, pageNum));
   if (ruled.length > 0) {
     const imageRegions = extractImageRegions(opList.fnArray, opList.argsArray).filter((r) => r.x2 - r.x1 >= 8 && r.y2 - r.y1 >= 8);
-    return extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, horizontals, verticals, imageRegions, lex, ruled, rawRules);
+    return extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, horizontals, verticals, imageRegions, lex, ruled, rawRules, verifiedRightArrows);
   }
   if (detectTables && stackedTableBands(items)) {
     return extractPageBlocksFallback(items, pageNum, true, detectTables, lex, figures());
@@ -6904,7 +7467,7 @@ function extractPageBlocksWithLines(items, pageNum, opList, pageWidth, pageHeigh
   }
   if (grids.length > 0) {
     const imageRegions = extractImageRegions(opList.fnArray, opList.argsArray).filter((r) => r.x2 - r.x1 >= 8 && r.y2 - r.y1 >= 8);
-    return extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, horizontals, verticals, imageRegions, lex, [], rawRules);
+    return extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, horizontals, verticals, imageRegions, lex, [], rawRules, verifiedRightArrows);
   }
   return extractPageBlocksFallback(items, pageNum, true, detectTables, lex, figures());
 }
@@ -7009,42 +7572,10 @@ function isSparseProseGrid(table) {
   const prose = filled.filter((t) => t.length >= 60 && /[.!?。]/.test(t)).reduce((n, t) => n + t.length, 0);
   return prose >= chars * 0.6;
 }
-var FRAME_RECT_TOL = 1.5;
-function takePendingNested(pending, cellBox, clipCell) {
-  const out = [];
-  for (let i = pending.length - 1; i >= 0; i--) {
-    const p = pending[i].parent;
-    if (pending[i].contained ? p.x1 >= cellBox.x1 - FRAME_RECT_TOL && p.x2 <= cellBox.x2 + FRAME_RECT_TOL && p.y1 >= cellBox.y1 - FRAME_RECT_TOL && p.y2 <= cellBox.y2 + FRAME_RECT_TOL : clipCell && Math.abs(p.x1 - cellBox.x1) <= FRAME_RECT_TOL && Math.abs(p.x2 - cellBox.x2) <= FRAME_RECT_TOL && Math.abs(p.y1 - cellBox.y1) <= FRAME_RECT_TOL && Math.abs(p.y2 - cellBox.y2) <= FRAME_RECT_TOL) {
-      out.push(pending[i].block);
-      pending.splice(i, 1);
-    }
-  }
-  return out;
-}
-function buildFrameCellBlocks(cellItems, nested, pageNum, wrap) {
-  const tables = [...nested].sort((a, b) => b.bbox.y + b.bbox.height - (a.bbox.y + a.bbox.height));
-  const blocks = [];
-  let rest = [...cellItems];
-  const pushParagraphs = (items) => {
-    if (items.length === 0) return;
-    for (const line of cleanCellText(cellTextToString(items, wrap)).split("\n")) {
-      const t = line.trim();
-      if (t) blocks.push({ type: "paragraph", text: t, pageNumber: pageNum });
-    }
-  };
-  for (const tb of tables) {
-    const bottom = tb.bbox.y;
-    pushParagraphs(rest.filter((it) => it.y >= bottom));
-    rest = rest.filter((it) => it.y < bottom);
-    blocks.push(tb);
-  }
-  pushParagraphs(rest);
-  const text = blocks.map((b) => b.type === "table" && b.table ? b.table.cells.flat().map((c) => c.text).filter(Boolean).join("\n") : b.text ?? "").filter(Boolean).join("\n");
-  return { blocks, text };
-}
-function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, horizontals, verticals, imageRegions = [], lex, ruled = [], rawRules = horizontals) {
+function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, horizontals, verticals, imageRegions = [], lex, ruled = [], rawRules = horizontals, verifiedRightArrows = []) {
   const ocrPage = items.length > 0 && items.every((i) => i.fontName === "ocr");
   const blocks = [];
+  const frameParagraphUnits = [];
   const usedItems = /* @__PURE__ */ new Set();
   for (const r of ruled) {
     for (const it of r.items) usedItems.add(it);
@@ -7101,7 +7632,7 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
       const nested = pendingNested.length ? takePendingNested(pendingNested, cell.bbox, !!grid.cells) : [];
       if (nested.length > 0) {
         nestedAttached = true;
-        const built = buildFrameCellBlocks(cellItems, nested, pageNum, { box: cell.bbox, lex });
+        const built = buildFrameCellBlocks(cellItems, nested, pageNum, lex);
         irGrid[cell.row][cell.col] = { text: built.text, colSpan: cell.colSpan, rowSpan: cell.rowSpan, blocks: built.blocks };
         if (cellItems.length) recordCellLines(irGrid[cell.row][cell.col], cellItems);
         takeClipCellEdges(cell, irGrid[cell.row][cell.col]);
@@ -7112,6 +7643,9 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
         colSpan: cell.colSpan,
         rowSpan: cell.rowSpan
       };
+      if (numRows === 1 && numCols === 1 && cellItems.length) {
+        irGrid[cell.row][cell.col].blocks = buildFrameCellBlocks(cellItems, [], pageNum, lex).blocks;
+      }
       const b = cell.bbox;
       const isBackdrop = (r) => r.x1 <= b.x1 + 1 && r.x2 >= b.x2 - 1 && r.y1 <= b.y1 + 1 && r.y2 >= b.y2 - 1;
       if (imageRegions.some((r) => {
@@ -7147,7 +7681,7 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
     }
     if (!rebuiltUsed && attachUnitRow(items, grid, finalGrid, numCols, usedItems)) finalRows++;
     let semanticOneColumn = false;
-    if (!grid.cells && numCols === 1 && numGridRows >= 2) {
+    if (!grid.cells && !nestedAttached && numCols === 1 && numGridRows >= 2) {
       const populatedRows = finalGrid.filter((row) => row[0]?.text.trim());
       if (populatedRows.length >= 4) {
         const fontSizes = tableItems.map((item) => item.fontSize).filter((size) => size > 0).sort((a, b) => a - b);
@@ -7200,6 +7734,7 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
       recordRowRules(irTable, grid.cells, grid.bbox, rawRules);
     }
     TABLE_COLXS.set(irTable, grid.colXs);
+    if (grid.cells) recordFrameTitle(irTable, tableItems, pageNum);
     if (grid.cells && finalRows === numRows) TABLE_ROWYS.set(irTable, grid.rowYs);
     if (grid.continues) CONT_PARTS.set(irTable, grid.continues);
     const hasContent = finalGrid.some((row) => row.some((cell) => cell.text.trim() !== ""));
@@ -7251,7 +7786,14 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
         continue;
       }
     }
-    if (!grid.cells && shouldDemoteTable(irTable)) {
+    if (!grid.cells && !nestedAttached && shouldDemoteTable(irTable)) {
+      const paragraphs = numRows === 1 && numCols === 1 ? irTable.cells[0]?.[0]?.blocks : void 0;
+      if (paragraphs?.length) {
+        blocks.push(...paragraphs);
+        frameParagraphUnits.push(paragraphs);
+        recordFrameReadingUnit(paragraphs, tableBbox);
+        continue;
+      }
       const demoted = demoteTableToText(irTable);
       if (demoted) {
         const text = numGridRows === 1 ? "\n" + demoted + "\n" : demoted;
@@ -7305,9 +7847,7 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
   }
   {
     const rects = remaining.map((i) => ({ x: i.x, y: i.y, w: i.w, h: i.h > 0 ? i.h : i.fontSize }));
-    for (const b of blocks) {
-      if (b.bbox && !(b.table && EMPTY_PARTS.has(b.table))) rects.push({ x: b.bbox.x, y: b.bbox.y, w: b.bbox.width, h: b.bbox.height });
-    }
+    for (const b of frameLayoutBoxes(blocks.filter((b2) => !(b2.table && EMPTY_PARTS.has(b2.table))))) rects.push({ x: b.x, y: b.y, w: b.width, h: b.height });
     gutterX = detectColumnGutter(rects) ?? findRuledColumnDivider(
       blocks.filter((b) => b.type === "table" && b.bbox && b.table && !EMPTY_PARTS.has(b.table)).map((b) => ({ x: b.bbox.x, y: b.bbox.y, w: b.bbox.width, h: b.bbox.height })),
       horizontals,
@@ -7320,14 +7860,15 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
   if (remaining.length > 0) {
     if (gutterX !== null) {
       const gx = gutterX;
+      const spanning = detectListBlocks(takeFrameSpanningText(remaining, gx, pageNum, lex));
+      for (const block of spanning) {
+        finalTextBlocks.push(block);
+        groupSizes.push(1);
+      }
       const allY = remaining.map((i) => i.y);
       const pageH = safeMax(allY) - safeMin(allY);
       const gapThreshold = Math.max(15, pageH * 0.03);
-      const sides = [
-        remaining.filter((i) => i.x + i.w <= gx),
-        remaining.filter((i) => i.x < gx && i.x + i.w > gx),
-        remaining.filter((i) => i.x >= gx)
-      ];
+      const sides = frameColumnTextBands(remaining, spanning, gx);
       const textBlocks = [];
       for (const side of sides) {
         if (side.length === 0) continue;
@@ -7338,7 +7879,7 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
           groupSizes.push(groupBlocks.length);
         }
       }
-      finalTextBlocks = detectListBlocks(textBlocks);
+      finalTextBlocks.push(...detectListBlocks(textBlocks));
     } else {
       const allY = remaining.map((i) => i.y);
       const pageH = safeMax(allY) - safeMin(allY);
@@ -7354,7 +7895,7 @@ function extractBlocksWithGrids(items, pageNum, pageWidth, pageHeight, grids, ho
       finalTextBlocks = detectListBlocks(textBlocks);
     }
   }
-  const units = blocks.map((b) => [b]);
+  const units = groupFrameParagraphUnits(groupFlowBoxUnits(blocks, grids, horizontals, verticals, verifiedRightArrows), frameParagraphUnits);
   let off = 0;
   for (const size of groupSizes) {
     const unit = finalTextBlocks.slice(off, off + size);
@@ -7493,7 +8034,7 @@ function mergeAdjacentTableBlocks(blocks) {
         table: merged,
         bbox: { ...pb, y: cb.y, height: pb.y + pb.height - cb.y }
       };
-    } else if (prev.type === "table" && curr.type === "table" && prev.table && curr.table && prev.table.cols === curr.table.cols && prev.table.renderAsTable === curr.table.renderAsTable && !CLIP_TABLES.has(prev.table) && !CLIP_TABLES.has(curr.table)) {
+    } else if (prev.type === "table" && curr.type === "table" && prev.table && curr.table && prev.table.cols === curr.table.cols && prev.table.renderAsTable === curr.table.renderAsTable && !CLIP_TABLES.has(prev.table) && !CLIP_TABLES.has(curr.table) && !separateRepeatedHeadings(prev, curr)) {
       const merged = {
         rows: prev.table.rows + curr.table.rows,
         cols: prev.table.cols,
@@ -7508,6 +8049,12 @@ function mergeAdjacentTableBlocks(blocks) {
   }
   return result;
 }
+function separateRepeatedHeadings(upper, lower) {
+  const u = upper.table, d = lower.table, ub = upper.bbox, db = lower.bbox;
+  if (!ub || !db || ub.page !== db.page || u.rows < 2 || d.rows < 2 || !u.hasHeader || !d.hasHeader || ub.y - (db.y + db.height) <= 1 || Math.abs(ub.x - db.x) > 1 || Math.abs(ub.width - db.width) > 1) return false;
+  const a = u.cells[0], b = d.cells[0], norm = (text) => text.replace(/<\/?u>|~~|\s+/g, "");
+  return a.filter((cell) => norm(cell.text)).length >= 2 && a.length === b.length && a.every((cell, c) => cell.colSpan === b[c].colSpan && cell.rowSpan === b[c].rowSpan && norm(cell.text) === norm(b[c].text));
+}
 function streamLines(items) {
   if (items.some((i) => i.seq === void 0)) return groupByY([...items].sort((a, b) => b.y - a.y || a.x - b.x));
   const lines = [];
@@ -7692,7 +8239,11 @@ export {
   extractImageRegions,
   filterHiddenText,
   collapseEvenSpacing,
+  computeBBox,
+  dominantStyle,
   normalizeItems,
+  groupByY,
+  mergeLineSimple,
   WrapLexicon,
   startsNewItem,
   wrapJoiner,
@@ -7713,6 +8264,7 @@ export {
   detectKoreanListBlocks,
   removeHeaderFooterBlocks,
   CLIP_TABLES,
+  FRAME_TITLE_BLOCKS,
   TABLE_COLXS,
   TABLE_ROWYS,
   TABLE_TAIL,
@@ -7726,7 +8278,11 @@ export {
   trimTrailingEmptyTableCols,
   NO_EDGES,
   joinCellEdges,
+  FRAME_READING_UNITS,
+  recordFrameReadingUnit,
+  restoreImageBullets,
+  detectRightArrowRegions,
   removeSideTabs,
   extractPageBlocksWithLines
 };
-//# sourceMappingURL=chunk-BJ6RYYXV.js.map
+//# sourceMappingURL=chunk-2CRD4Q76.js.map