formatferry 1.0.10 → 1.0.12

package/dist/index.js

@@ -21342,6 +21342,551 @@ var DocxAdapter = class {
 };
 var docxAdapter = new DocxAdapter();
 
+// ../../src/shared/feature-flags.ts
+var _flags = {
+  enableDocx: true,
+  enableXlsx: true,
+  enablePdf: true,
+  enableHtml: true,
+  enablePdfTableDetection: true
+};
+function getFeatureFlags() {
+  return { ..._flags };
+}
+
+// ../../src/shared/adapters/pdf-table-detector.ts
+var CJK_REGEX = /[\u3400-\u9FFF\uF900-\uFAFF\u3040-\u30FF\uAC00-\uD7AF]/;
+var NUMBER_LIKE_REGEX = /^[\s\-+$€£¥]*\(?[\d.,/:%\- ]+\)?[\s%$€£¥]*$/;
+var DATE_LIKE_REGEX = /^\d{1,4}[-/.]\d{1,2}([-/.]\d{1,4})?$/;
+var SUPERSCRIPT_MERGE_GAP_FACTOR = 0.3;
+var VERTICAL_OVERLAP_THRESHOLD = 0.5;
+var COLUMN_SUPPORT_THRESHOLD = 0.6;
+var COLUMN_GAP_MERGE_FACTOR = 0.35;
+var COLUMN_BOUNDARY_VOTE_TOLERANCE_FACTOR = 0.5;
+var MIN_CELL_OVERLAP_SCORE = 0.35;
+var WIDE_WHITESPACE_MIN_RUN = 2;
+var SHORT_CELL_THRESHOLD_LATIN = 40;
+var SHORT_CELL_THRESHOLD_CJK = 20;
+var MIN_CONFIDENCE_EMIT = 0.55;
+var MIN_CONFIDENCE_HIGH = 0.7;
+var PROSE_FLOW_MAX_FRACTION = 0.3;
+function splitWideWhitespaceItems(items) {
+  const out = [];
+  for (const it of items) {
+    const tokens = splitAtWideRuns(it.str, WIDE_WHITESPACE_MIN_RUN);
+    if (tokens.length < 2 || it.str.length < 4 || it.width <= 0) {
+      out.push(it);
+      continue;
+    }
+    const perChar = it.width / it.str.length;
+    for (const t of tokens) {
+      const subX = it.x + t.start * perChar;
+      const subRight = it.x + t.end * perChar;
+      const subWidth = Math.max(subRight - subX, perChar);
+      out.push({
+        ...it,
+        str: t.str,
+        x: subX,
+        width: subWidth,
+        right: subX + subWidth
+      });
+    }
+  }
+  return out;
+}
+function preFilterAndMerge(items) {
+  const filtered = items.filter(
+    (it) => it.str.trim().length > 0 && it.width > 0 && it.height > 0
+  );
+  if (filtered.length === 0) return [];
+  const alive = splitWideWhitespaceItems(filtered);
+  if (alive.length === 0) return [];
+  const widths = alive.map((it) => estimateCharWidth(it)).filter((w) => w > 0);
+  const medianCharWidth = median(widths) || 1;
+  const mergeGap = medianCharWidth * SUPERSCRIPT_MERGE_GAP_FACTOR;
+  const sorted = [...alive].sort((a, b) => b.y + b.height - (a.y + a.height) || a.x - b.x);
+  const bands = [];
+  for (const it of sorted) {
+    const band = bands[bands.length - 1];
+    if (band && band.some((bi) => verticalOverlap(bi, it) > 0 && bi.rotation === it.rotation)) {
+      band.push(it);
+    } else {
+      bands.push([it]);
+    }
+  }
+  const out = [];
+  for (const band of bands) {
+    band.sort((a, b) => a.x - b.x);
+    for (const item of band) {
+      const last = out[out.length - 1];
+      if (last && last.rotation === item.rotation && verticalOverlap(last, item) > 0 && item.x >= last.right && item.x - last.right < mergeGap) {
+        last.str = `${last.str}${item.str}`;
+        last.width = item.right - last.x;
+        last.right = item.right;
+        last.height = Math.max(last.height, item.height);
+        last.y = Math.min(last.y, item.y);
+        continue;
+      }
+      out.push({ ...item });
+    }
+  }
+  return out;
+}
+function clusterIntoRows(items) {
+  if (items.length === 0) return [];
+  const upright = items.filter((it) => it.rotation === 0);
+  upright.sort((a, b) => b.y - a.y || a.x - b.x);
+  const rows = [];
+  for (const item of upright) {
+    const row = rows[rows.length - 1];
+    if (row && overlapFraction(item.y, item.y + item.height, row.yMin, row.yMax) >= VERTICAL_OVERLAP_THRESHOLD) {
+      row.items.push(item);
+      row.yMin = Math.min(row.yMin, item.y);
+      row.yMax = Math.max(row.yMax, item.y + item.height);
+    } else {
+      rows.push({ yMin: item.y, yMax: item.y + item.height, items: [item] });
+    }
+  }
+  for (const r of rows) r.items.sort((a, b) => a.x - b.x);
+  rows.sort((a, b) => b.yMax - a.yMax);
+  return rows;
+}
+function detectColumns(rows) {
+  if (rows.length === 0) return [];
+  const allItems = rows.flatMap((r) => r.items);
+  if (allItems.length === 0) return [];
+  const medianCharWidth = median(allItems.map((it) => estimateCharWidth(it)).filter((w) => w > 0)) || 1;
+  const gapTol = medianCharWidth * COLUMN_GAP_MERGE_FACTOR;
+  const hardBoundaries = voteColumnBoundaries(rows, medianCharWidth);
+  const intervals = allItems.map((it) => ({ x0: it.x, x1: it.right })).sort((a, b) => a.x0 - b.x0);
+  const merged = [];
+  for (const iv of intervals) {
+    const last = merged[merged.length - 1];
+    const crossesHardBoundary = last !== void 0 && hardBoundaries.some((b) => b >= last.x1 && b <= iv.x0);
+    if (last && iv.x0 - last.x1 <= gapTol && !crossesHardBoundary) {
+      last.x1 = Math.max(last.x1, iv.x1);
+    } else {
+      merged.push({ ...iv });
+    }
+  }
+  const anchors = [];
+  for (const iv of merged) {
+    const rowsWithHit = rows.filter(
+      (r) => r.items.some((it) => rangeOverlap(it.x, it.right, iv.x0, iv.x1))
+    );
+    const support = rowsWithHit.length / rows.length;
+    if (support < COLUMN_SUPPORT_THRESHOLD) continue;
+    const alignment = chooseAlignment(rows, iv);
+    anchors.push({ x0: iv.x0, x1: iv.x1, alignment, support });
+  }
+  return anchors;
+}
+function coalesceMultiLineCells(rows, columns) {
+  if (rows.length < 2 || columns.length < 2) return rows;
+  const gaps = rowGaps(rows);
+  const baseline = gaps.length ? median(gaps) : 0;
+  const tightFactor = 0.7;
+  const out = [];
+  for (let i = 0; i < rows.length; i++) {
+    const cur = rows[i];
+    const prev = out[out.length - 1];
+    if (!prev) {
+      out.push({ ...cur, items: [...cur.items] });
+      continue;
+    }
+    const gap = prev.yMin - cur.yMax;
+    const prevCols = columnsCovered(prev, columns);
+    const curCols = columnsCovered(cur, columns);
+    const curIsSubset = [...curCols].every((c) => prevCols.has(c));
+    const covers = curCols.size >= 1 && curCols.size < columns.length;
+    const isTight = baseline > 0 && gap < baseline * tightFactor;
+    const lastColOnly = curCols.size === 1;
+    const isIntraCell = isTight && curIsSubset && covers || lastColOnly && gap < baseline * 1.5 && curIsSubset;
+    if (isIntraCell) {
+      for (const it of cur.items) {
+        prev.items.push(it);
+      }
+      prev.yMin = Math.min(prev.yMin, cur.yMin);
+      prev.items.sort((a, b) => a.x - b.x);
+      continue;
+    }
+    out.push({ ...cur, items: [...cur.items] });
+  }
+  return out;
+}
+function scoreCandidate(rows, columns) {
+  if (rows.length < 2 || columns.length < 2) return 0;
+  const totalCells = rows.length * columns.length;
+  let filledCells = 0;
+  let shortCells = 0;
+  const intraGaps = [];
+  const interGaps = [];
+  for (const row of rows) {
+    const cells = assignRowToColumns(row, columns);
+    for (let c = 0; c < columns.length; c++) {
+      const cellText = cells[c]?.str ?? "";
+      if (cellText.length > 0) {
+        filledCells++;
+        if (isShortCell(cellText)) shortCells++;
+      }
+    }
+    const sortedItems = [...row.items].sort((a, b) => a.x - b.x);
+    for (let i = 1; i < sortedItems.length; i++) {
+      const gap = sortedItems[i].x - sortedItems[i - 1].right;
+      if (gap < 0) continue;
+      const sameCol = sameColumn(sortedItems[i - 1], sortedItems[i], columns);
+      (sameCol ? intraGaps : interGaps).push(gap);
+    }
+  }
+  const columnAlignmentRatio = filledCells / totalCells;
+  const shortCellRatio = filledCells > 0 ? shortCells / filledCells : 0;
+  const gaps = rowGaps(rows);
+  const rowGapConsistency = gaps.length > 0 && mean(gaps) > 0 ? clamp01(1 - stdev(gaps) / Math.max(mean(gaps), 1e-6)) : 0;
+  const bimodality = intraGaps.length > 0 && interGaps.length > 0 ? clamp01(mean(interGaps) / Math.max(mean(intraGaps), 1e-6) / 5) : interGaps.length > 0 ? 0.5 : 0;
+  const rowCountBonus = rows.length >= 3 ? 1 : 0.5;
+  const score = 0.25 * columnAlignmentRatio + 0.25 * shortCellRatio + 0.2 * bimodality + 0.15 * rowGapConsistency + 0.15 * rowCountBonus;
+  return clamp01(score);
+}
+function findTableRegions(items, options = {}) {
+  const cleaned = preFilterAndMerge(items);
+  const rows = clusterIntoRows(cleaned);
+  if (rows.length < 2) return [];
+  const candidates = [];
+  let i = 0;
+  while (i < rows.length - 1) {
+    let best = null;
+    for (let j = i + 1; j < rows.length; j++) {
+      const run = rows.slice(i, j + 1);
+      const columns = detectColumns(run);
+      if (columns.length < 2) {
+        if (best) break;
+        continue;
+      }
+      const coalesced = coalesceMultiLineCells(run, columns);
+      if (coalesced.length < 2) {
+        continue;
+      }
+      if (!passesProseGuard(coalesced)) {
+        if (best) break;
+        else continue;
+      }
+      if (!passesLabelFormGuard(coalesced, columns)) {
+        if (best) break;
+        else continue;
+      }
+      const confidence = scoreCandidate(coalesced, columns);
+      if (confidence < MIN_CONFIDENCE_EMIT) {
+        if (best) break;
+        continue;
+      }
+      const bbox = computeBbox(run);
+      const medianH = median(run.flatMap((r) => r.items.map((it) => it.height))) || 0;
+      const mayContinue = options.pageBottomY !== void 0 && medianH > 0 && bbox.y0 - options.pageBottomY < medianH * 2;
+      best = {
+        rows: coalesced,
+        columns,
+        confidence,
+        bbox,
+        rowRange: { start: i, end: j },
+        mayContinue
+      };
+    }
+    if (best) {
+      candidates.push(best);
+      i = best.rowRange.end + 1;
+    } else {
+      i++;
+    }
+  }
+  return candidates;
+}
+var defaultHtmlEscape = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+function renderTableHtml(candidate, escape = defaultHtmlEscape) {
+  const { rows, columns } = candidate;
+  if (rows.length === 0 || columns.length === 0) return "";
+  const cellGrid = rows.map(
+    (row) => assignRowToColumns(row, columns).map((c) => c ? c.str : "")
+  );
+  const headerRow = rows[0];
+  const isHeader = looksLikeHeader(headerRow);
+  const parts = [];
+  parts.push("<table>");
+  let bodyStart = 0;
+  if (isHeader) {
+    parts.push("<thead>");
+    parts.push("<tr>");
+    for (const text of cellGrid[0]) {
+      parts.push(`<th>${escape(text)}</th>`);
+    }
+    parts.push("</tr>");
+    parts.push("</thead>");
+    bodyStart = 1;
+  }
+  parts.push("<tbody>");
+  for (let r = bodyStart; r < cellGrid.length; r++) {
+    parts.push("<tr>");
+    for (const text of cellGrid[r]) {
+      parts.push(`<td>${escape(text)}</td>`);
+    }
+    parts.push("</tr>");
+  }
+  parts.push("</tbody>");
+  parts.push("</table>");
+  return parts.join("");
+}
+var ConfidenceTier = {
+  HIGH: MIN_CONFIDENCE_HIGH,
+  EMIT: MIN_CONFIDENCE_EMIT
+};
+function estimateCharWidth(item) {
+  const chars = item.str.length;
+  return chars > 0 ? item.width / chars : 0;
+}
+function splitAtWideRuns(str, minRun) {
+  const tokens = [];
+  const isWs = (ch) => ch === " " || ch === "	" || ch === "\xA0";
+  let i = 0;
+  while (i < str.length) {
+    while (i < str.length && isWs(str[i])) i++;
+    if (i >= str.length) break;
+    const start = i;
+    let end = i;
+    while (i < str.length) {
+      if (isWs(str[i])) {
+        let j = i;
+        while (j < str.length && isWs(str[j])) j++;
+        if (j - i >= minRun) break;
+        i = j;
+      } else {
+        i++;
+        end = i;
+      }
+    }
+    if (end > start) tokens.push({ str: str.slice(start, end), start, end });
+  }
+  return tokens;
+}
+function voteColumnBoundaries(rows, medianCharWidth) {
+  if (rows.length < 2 || medianCharWidth <= 0) return [];
+  const candidates = [];
+  rows.forEach((row, rIdx) => {
+    const sorted = [...row.items].sort((a, b) => a.x - b.x);
+    for (let i = 1; i < sorted.length; i++) {
+      const gap = sorted[i].x - sorted[i - 1].right;
+      if (gap > 0) {
+        candidates.push({
+          mid: (sorted[i - 1].right + sorted[i].x) / 2,
+          rowIdx: rIdx
+        });
+      }
+    }
+  });
+  if (candidates.length === 0) return [];
+  candidates.sort((a, b) => a.mid - b.mid);
+  const tolerance = medianCharWidth * COLUMN_BOUNDARY_VOTE_TOLERANCE_FACTOR;
+  const clusters = [];
+  for (const c of candidates) {
+    const last = clusters[clusters.length - 1];
+    if (last && c.mid - last.mids[last.mids.length - 1] <= tolerance) {
+      last.mids.push(c.mid);
+      last.rowSet.add(c.rowIdx);
+    } else {
+      clusters.push({ mids: [c.mid], rowSet: /* @__PURE__ */ new Set([c.rowIdx]) });
+    }
+  }
+  const hard = [];
+  for (const cl of clusters) {
+    if (cl.rowSet.size / rows.length >= COLUMN_SUPPORT_THRESHOLD) {
+      hard.push(median(cl.mids));
+    }
+  }
+  hard.sort((a, b) => a - b);
+  return hard;
+}
+function median(xs) {
+  if (xs.length === 0) return 0;
+  const sorted = [...xs].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 mean(xs) {
+  if (xs.length === 0) return 0;
+  return xs.reduce((a, b) => a + b, 0) / xs.length;
+}
+function stdev(xs) {
+  if (xs.length < 2) return 0;
+  const m = mean(xs);
+  const variance = xs.reduce((acc, x) => acc + (x - m) ** 2, 0) / xs.length;
+  return Math.sqrt(variance);
+}
+function clamp01(x) {
+  if (x < 0) return 0;
+  if (x > 1) return 1;
+  return x;
+}
+function overlapFraction(a0, a1, b0, b1) {
+  const overlap = Math.max(0, Math.min(a1, b1) - Math.max(a0, b0));
+  const span = Math.max(a1 - a0, 1e-6);
+  return overlap / span;
+}
+function rangeOverlap(a0, a1, b0, b1) {
+  return Math.min(a1, b1) - Math.max(a0, b0) > 0;
+}
+function verticalOverlap(a, b) {
+  return overlapFraction(a.y, a.y + a.height, b.y, b.y + b.height);
+}
+function chooseAlignment(rows, iv) {
+  const lefts = [];
+  const rights = [];
+  const centers = [];
+  for (const row of rows) {
+    const candidates = row.items.filter(
+      (it) => rangeOverlap(it.x, it.right, iv.x0, iv.x1)
+    );
+    if (candidates.length === 0) continue;
+    const leftmost = candidates.reduce((a, b) => a.x < b.x ? a : b);
+    const rightmost = candidates.reduce((a, b) => a.right > b.right ? a : b);
+    lefts.push(leftmost.x);
+    rights.push(rightmost.right);
+    centers.push((leftmost.x + rightmost.right) / 2);
+  }
+  const sL = stdev(lefts);
+  const sR = stdev(rights);
+  const sC = stdev(centers);
+  if (sL <= sR && sL <= sC) return "left";
+  if (sR < sL && sR <= sC) return "right";
+  return "center";
+}
+function rowGaps(rows) {
+  const gaps = [];
+  for (let i = 1; i < rows.length; i++) {
+    const gap = rows[i - 1].yMin - rows[i].yMax;
+    if (gap >= 0) gaps.push(gap);
+  }
+  return gaps;
+}
+function columnsCovered(row, columns) {
+  const out = /* @__PURE__ */ new Set();
+  for (let c = 0; c < columns.length; c++) {
+    const col = columns[c];
+    if (row.items.some((it) => rangeOverlap(it.x, it.right, col.x0, col.x1))) {
+      out.add(c);
+    }
+  }
+  return out;
+}
+function assignRowToColumns(row, columns) {
+  const cells = columns.map(() => null);
+  const buckets = columns.map(() => []);
+  for (const item of row.items) {
+    let best = -1;
+    let bestScore = 0;
+    for (let c = 0; c < columns.length; c++) {
+      const col = columns[c];
+      const ovStart = Math.max(item.x, col.x0);
+      const ovEnd = Math.min(item.right, col.x1);
+      const overlap = Math.max(0, ovEnd - ovStart);
+      const colWidth = Math.max(col.x1 - col.x0, 1e-6);
+      const itemWidth = Math.max(item.width, 1e-6);
+      const score = overlap / Math.min(colWidth, itemWidth);
+      if (score > bestScore) {
+        bestScore = score;
+        best = c;
+      }
+    }
+    if (best >= 0 && bestScore > MIN_CELL_OVERLAP_SCORE) buckets[best].push(item);
+  }
+  for (let c = 0; c < columns.length; c++) {
+    const bucket = buckets[c].sort((a, b) => a.x - b.x);
+    if (bucket.length > 0) {
+      cells[c] = { str: bucket.map((it) => it.str).join(" ").trim() };
+    }
+  }
+  return cells;
+}
+function sameColumn(a, b, columns) {
+  const ca = findColumnIndex(a, columns);
+  const cb = findColumnIndex(b, columns);
+  return ca !== -1 && ca === cb;
+}
+function findColumnIndex(item, columns) {
+  for (let c = 0; c < columns.length; c++) {
+    if (rangeOverlap(item.x, item.right, columns[c].x0, columns[c].x1)) return c;
+  }
+  return -1;
+}
+function isShortCell(text) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return true;
+  if (NUMBER_LIKE_REGEX.test(trimmed) || DATE_LIKE_REGEX.test(trimmed)) return true;
+  const hasCjk = CJK_REGEX.test(trimmed);
+  const threshold = hasCjk ? SHORT_CELL_THRESHOLD_CJK : SHORT_CELL_THRESHOLD_LATIN;
+  return trimmed.length <= threshold;
+}
+function passesProseGuard(rows) {
+  if (rows.length < 2) return true;
+  let proseTransitions = 0;
+  for (let i = 0; i < rows.length - 1; i++) {
+    const cur = rows[i].items.map((it) => it.str).join(" ").trim();
+    const next = rows[i + 1].items.map((it) => it.str).join(" ").trim();
+    const curEndsWithPunct = /[.!?]["')\]]?$/.test(cur);
+    const nextStartsLower = /^[\p{Ll}]/u.test(next);
+    const bothLong = cur.length > 60 && next.length > 60;
+    if (curEndsWithPunct && nextStartsLower || bothLong) proseTransitions++;
+  }
+  const ratio = proseTransitions / Math.max(rows.length - 1, 1);
+  return ratio < PROSE_FLOW_MAX_FRACTION;
+}
+function passesLabelFormGuard(rows, columns) {
+  if (columns.length < 2) return true;
+  let labelish = 0;
+  let total = 0;
+  for (const row of rows) {
+    const assigned = assignRowToColumns(row, columns);
+    const cell = assigned[0];
+    if (!cell) continue;
+    total++;
+    const trimmed = cell.str.trimEnd();
+    if (/:$/.test(trimmed)) labelish++;
+  }
+  if (total < 2) return true;
+  const ratio = labelish / total;
+  if (columns.length === 2 && ratio >= 0.6) return false;
+  if (ratio >= 0.8) return false;
+  return true;
+}
+function computeBbox(rows) {
+  let x0 = Infinity;
+  let x1 = -Infinity;
+  let y0 = Infinity;
+  let y1 = -Infinity;
+  for (const r of rows) {
+    if (r.yMin < y0) y0 = r.yMin;
+    if (r.yMax > y1) y1 = r.yMax;
+    for (const it of r.items) {
+      if (it.x < x0) x0 = it.x;
+      if (it.right > x1) x1 = it.right;
+    }
+  }
+  return { x0, y0, x1, y1 };
+}
+function looksLikeHeader(row) {
+  if (row.items.length === 0) return false;
+  let boldish = 0;
+  let allCaps = 0;
+  let trailingColon = 0;
+  for (const it of row.items) {
+    if (it.fontName && /Bold|Black|Heavy|Semibold|Demibold/i.test(it.fontName)) boldish++;
+    const trimmed = it.str.trim();
+    if (trimmed.length >= 2 && trimmed === trimmed.toUpperCase() && /[A-Z]/.test(trimmed)) {
+      allCaps++;
+    }
+    if (trimmed.endsWith(":")) trailingColon++;
+  }
+  const n = row.items.length;
+  return boldish / n >= 0.5 || allCaps / n >= 0.5 || trailingColon / n >= 0.5;
+}
+
 // ../../src/shared/adapters/pdf-adapter.ts
 var PdfParseError = class extends Error {
   constructor(message, code, originalError) {
@@ -21353,9 +21898,269 @@ var PdfParseError = class extends Error {
 };
 var MIN_TEXT_CHARS_THRESHOLD = 10;
 var MULTI_COLUMN_X_VARIANCE_THRESHOLD = 100;
+var DESCENDER_BUDGET_FACTOR = 0.2;
+var FORM_LABEL_GAP_FACTOR = 3;
 function escapeHtml(str) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
 }
+function detectRotation(transform) {
+  const EPS = 1e-3;
+  const [sx, shy, shx, sy] = transform;
+  const skew = Math.max(Math.abs(shy), Math.abs(shx));
+  if (skew < EPS) {
+    return sx < 0 && sy < 0 ? 180 : 0;
+  }
+  if (shy > EPS && shx < -EPS) return 90;
+  if (shy < -EPS && shx > EPS) return 270;
+  return 0;
+}
+function textItemToPositioned(item) {
+  if (!item.str) return null;
+  if (!item.transform || item.transform.length < 6) return null;
+  const rotation = detectRotation(item.transform);
+  const tx = item.transform[4];
+  const ty = item.transform[5];
+  const rawHeight = item.height ?? Math.abs(item.transform[3]) ?? 10;
+  const height = rawHeight > 0 ? rawHeight : 10;
+  const width = item.width ?? item.str.length * (height * 0.5);
+  const descent = height * DESCENDER_BUDGET_FACTOR;
+  const y = ty - descent;
+  const paddedHeight = height + descent;
+  return {
+    str: item.str,
+    x: tx,
+    y,
+    width,
+    height: paddedHeight,
+    right: tx + width,
+    rotation,
+    fontName: item.fontName,
+    source: "text"
+  };
+}
+function widgetToPositionedItems(ann) {
+  if (ann.subtype !== "Widget" || !ann.rect || ann.rect.length !== 4) return [];
+  const [llx, lly, urx, ury] = ann.rect;
+  const width = urx - llx;
+  const height = ury - lly;
+  if (width <= 0 || height <= 0) return [];
+  const mk = (str) => ({
+    str,
+    x: llx,
+    y: lly,
+    width,
+    height,
+    right: urx,
+    rotation: 0,
+    source: "acroform"
+  });
+  if (ann.fieldType === "Tx") {
+    const raw = ann.fieldValue;
+    const value = Array.isArray(raw) ? raw.join(" ") : raw;
+    const str = (value ?? "").toString().trim();
+    if (str.length === 0) return [];
+    return [mk(str)];
+  }
+  if (ann.fieldType === "Btn" && (ann.checkBox === true || ann.radioButton === true)) {
+    const value = ann.fieldValue;
+    const expected = ann.exportValue ?? ann.buttonValue ?? "Yes";
+    const checked = value != null && value !== "Off" && (Array.isArray(value) ? value.includes(expected) : String(value) === expected);
+    return [mk(checked ? "[X]" : "[ ]")];
+  }
+  return [];
+}
+function normalizeForDedup(s) {
+  return s.normalize("NFKC").replace(/\u200B|\u200C|\u200D|\uFEFF/g, "").replace(/\s+/g, " ").trim();
+}
+function dedupAgainstWidgets(textItems, widgets) {
+  if (widgets.length === 0) return textItems;
+  const kept = [];
+  for (const txt of textItems) {
+    let drop = false;
+    const txtArea = Math.max(txt.width * txt.height, 1e-6);
+    const txtStr = normalizeForDedup(txt.str);
+    for (const w of widgets) {
+      const ox = Math.max(0, Math.min(txt.right, w.right) - Math.max(txt.x, w.x));
+      const oy = Math.max(0, Math.min(txt.y + txt.height, w.y + w.height) - Math.max(txt.y, w.y));
+      const overlap = ox * oy;
+      if (overlap / txtArea <= 0.3) continue;
+      const wStr = normalizeForDedup(w.str);
+      if (wStr.length > 0 && wStr === txtStr) {
+        drop = true;
+        break;
+      }
+    }
+    if (!drop) kept.push(txt);
+  }
+  return kept;
+}
+function itemsToLinearText(items) {
+  if (items.length === 0) return "";
+  const sorted = [...items].sort((a, b) => b.y + b.height - (a.y + a.height) || a.x - b.x);
+  const rows = [];
+  for (const it of sorted) {
+    const last = rows[rows.length - 1];
+    if (last && last.some(
+      (li) => Math.max(0, Math.min(li.y + li.height, it.y + it.height) - Math.max(li.y, it.y)) / Math.max(Math.min(li.height, it.height), 1e-6) >= 0.5
+    )) {
+      last.push(it);
+    } else {
+      rows.push([it]);
+    }
+  }
+  const widths = items.map((i) => i.str.length > 0 ? i.width / i.str.length : 0).filter((w) => w > 0);
+  const medianCharWidth = widths.length ? [...widths].sort((a, b) => a - b)[Math.floor(widths.length / 2)] || 1 : 1;
+  const labelGap = medianCharWidth * FORM_LABEL_GAP_FACTOR;
+  const NBSP2 = "\xA0\xA0";
+  const lines = [];
+  for (const row of rows) {
+    row.sort((a, b) => a.x - b.x);
+    let out = "";
+    for (let i = 0; i < row.length; i++) {
+      const item = row[i];
+      if (i > 0) {
+        const prev = row[i - 1];
+        const gap = item.x - prev.right;
+        const prevStr = prev.str.trimEnd();
+        const isLabel = /:$/.test(prevStr);
+        if (isLabel && gap > labelGap) {
+          out += NBSP2;
+        } else {
+          out += " ";
+        }
+      }
+      out += item.str;
+    }
+    lines.push(out);
+  }
+  return lines.join("\n").replace(/[ \t]+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+function renderPage(items, pageNum, nextPageNum, enableTableDetection, translate, pageBottomY) {
+  const warnings = [];
+  const candidates = enableTableDetection ? findTableRegions(items, { pageBottomY }) : [];
+  const htmlBlocks = [];
+  const candsByY = [...candidates].sort((a, b) => b.bbox.y1 - a.bbox.y1);
+  const itemOverlapsCandidate = (it, c) => {
+    const top = it.y + it.height;
+    const overlap = Math.min(c.bbox.y1, top) - Math.max(c.bbox.y0, it.y);
+    return overlap > 0;
+  };
+  const uprightItems = items.filter((it) => it.rotation === 0);
+  const aboveBuckets = candsByY.map(() => []);
+  const trailing = [];
+  for (const it of uprightItems) {
+    const top = it.y + it.height;
+    let placed = false;
+    let claimed = false;
+    for (let k = 0; k < candsByY.length; k++) {
+      const c = candsByY[k];
+      if (itemOverlapsCandidate(it, c)) {
+        claimed = true;
+        break;
+      }
+      if (top > c.bbox.y1) {
+        aboveBuckets[k].push(it);
+        placed = true;
+        break;
+      }
+    }
+    if (claimed) continue;
+    if (!placed) trailing.push(it);
+  }
+  const sortTopDown = (arr) => [...arr].sort((a, b) => b.y + b.height - (a.y + a.height));
+  const ordered = [];
+  for (let k = 0; k < candsByY.length; k++) {
+    const bucket = aboveBuckets[k];
+    if (bucket.length > 0) ordered.push({ kind: "text", items: sortTopDown(bucket) });
+    ordered.push({ kind: "table", cand: candsByY[k] });
+  }
+  if (trailing.length > 0) ordered.push({ kind: "text", items: sortTopDown(trailing) });
+  const rotatedItems = items.filter((it) => it.rotation !== 0);
+  if (rotatedItems.length > 0) {
+    ordered.push({ kind: "text", items: rotatedItems });
+  }
+  const linearTextParts = [];
+  for (const block of ordered) {
+    if (block.kind === "table") {
+      htmlBlocks.push(renderTableHtml(block.cand, escapeHtml));
+      if (block.cand.confidence < ConfidenceTier.HIGH && block.cand.confidence >= ConfidenceTier.EMIT) {
+        warnings.push(
+          localize(translate, "pdf.warnings.tableMediumConfidence", {
+            page: pageNum,
+            confidence: Math.round(block.cand.confidence * 100)
+          })
+        );
+      }
+      if (block.cand.mayContinue && nextPageNum !== void 0) {
+        warnings.push(
+          localize(translate, "pdf.warnings.tableMayContinue", {
+            page: pageNum,
+            nextPage: nextPageNum
+          })
+        );
+      }
+      linearTextParts.push(tableToText(block.cand));
+    } else {
+      const text = itemsToLinearText(block.items);
+      if (!text) continue;
+      linearTextParts.push(text);
+      const medH = (() => {
+        const hs = block.items.map((i) => i.height).filter((h) => h > 0);
+        if (hs.length === 0) return 10;
+        return hs.sort((a, b) => a - b)[Math.floor(hs.length / 2)] || 10;
+      })();
+      const topY = block.items.reduce(
+        (m, it) => Math.max(m, it.y + it.height),
+        -Infinity
+      );
+      const topRowItems = block.items.filter(
+        (it) => topY - (it.y + it.height) <= medH * 0.5
+      );
+      const topRowLooksTabular = topRowItems.length >= 4 && topRowItems.some((a) => topRowItems.some((b) => b.x - a.right > medH * 2));
+      const paragraphs = text.split(/\n{2,}/);
+      let paraIdx = 0;
+      for (const para of paragraphs) {
+        const trimmed = para.trim();
+        paraIdx++;
+        if (!trimmed) continue;
+        const hasWideGap = /( {3,}|\u00A0\u00A0|\t)/.test(trimmed);
+        const isFirstPara = paraIdx === 1;
+        const looksTabular = hasWideGap || isFirstPara && topRowLooksTabular;
+        const short = trimmed.length < 100 && !/[.,:;!?]$/.test(trimmed) && !/\n/.test(trimmed) && !looksTabular;
+        if (short) {
+          htmlBlocks.push(`<p><strong>${escapeHtml(trimmed)}</strong></p>`);
+        } else {
+          htmlBlocks.push(`<p>${escapeHtml(trimmed)}</p>`);
+        }
+      }
+    }
+  }
+  return {
+    htmlBlocks,
+    textContent: linearTextParts.join("\n\n").trim(),
+    tablesDetected: candidates.length,
+    warnings,
+    anyTableDetected: candidates.length > 0
+  };
+}
+function tableToText(cand) {
+  return cand.rows.map(
+    (row) => [...row.items].sort((a, b) => a.x - b.x).map((it) => it.str).join(" | ")
+  ).join("\n");
+}
+function localize(translate, key, vars) {
+  if (translate) return translate(key, vars);
+  if (key === "pdf.warnings.tableMediumConfidence") {
+    return `Table on page ${vars.page} reconstructed with medium confidence (${vars.confidence}%) \u2014 please verify.`;
+  }
+  if (key === "pdf.warnings.tableMayContinue") {
+    return `Table on page ${vars.page} may continue onto page ${vars.nextPage} and was not joined across pages.`;
+  }
+  if (key === "pdf.warnings.multiColumnLayout") {
+    return "Multi-column PDFs may not preserve layout accurately";
+  }
+  return key;
+}
 var PdfAdapter = class {
   pdfjs = null;
   /**
@@ -21375,7 +22180,11 @@ var PdfAdapter = class {
    * @returns Promise resolving to the parse result with HTML and metadata
    * @throws PdfParseError if the file cannot be parsed
    */
-  async parseToText(arrayBuffer, onProgress) {
+  async parseToText(arrayBuffer, optionsOrProgress) {
+    const opts = typeof optionsOrProgress === "function" ? { onProgress: optionsOrProgress } : optionsOrProgress ?? {};
+    const onProgress = opts.onProgress;
+    const translate = opts.translate;
+    const tableDetectionEnabled = opts.enableTableDetection ?? getFeatureFlags().enablePdfTableDetection ?? true;
     const pdfjs = await this.ensurePdfjsLoaded();
     const warnings = [];
     const pages = [];
@@ -21421,18 +22230,35 @@ var PdfAdapter = class {
         onProgress?.(pageNum / numPages);
         const page = await pdf.getPage(pageNum);
         const viewport = page.getViewport({ scale: 1 });
-        const textContent = await page.getTextContent();
-        const textItems = [];
+        const [textContent, annotations] = await Promise.all([
+          page.getTextContent(),
+          page.getAnnotations().catch((err) => {
+            console.warn(`[PdfAdapter] getAnnotations failed for page ${pageNum}:`, err);
+            return [];
+          })
+        ]);
+        const positionedText = [];
         const xPositions = [];
         for (const item of textContent.items) {
-          if ("str" in item && typeof item.str === "string") {
-            textItems.push(item);
-            if (item.transform && item.transform.length >= 5) {
-              xPositions.push(item.transform[4]);
-            }
-          }
-        }
-        if (!hasMultiColumnWarning && xPositions.length > 10) {
+          if (!("str" in item) || typeof item.str !== "string") continue;
+          const positioned = textItemToPositioned(item);
+          if (!positioned) continue;
+          positionedText.push(positioned);
+          xPositions.push(positioned.x);
+        }
+        const widgetItems = annotations.flatMap(widgetToPositionedItems);
+        const items = widgetItems.length > 0 ? [...dedupAgainstWidgets(positionedText, widgetItems), ...widgetItems] : positionedText;
+        const pageBottomY = Array.isArray(page.view) && page.view.length >= 2 ? page.view[1] : 0;
+        const rendered = renderPage(
+          items,
+          pageNum,
+          pageNum < numPages ? pageNum + 1 : void 0,
+          tableDetectionEnabled,
+          translate,
+          pageBottomY
+        );
+        for (const w of rendered.warnings) warnings.push(w);
+        if (!hasMultiColumnWarning && !rendered.anyTableDetected && xPositions.length > 10) {
           const uniqueXPositions = [...new Set(xPositions.map((x) => Math.round(x / 10) * 10))];
           if (uniqueXPositions.length >= 3) {
             const xRange = Math.max(...xPositions) - Math.min(...xPositions);
@@ -21446,32 +22272,13 @@ var PdfAdapter = class {
                 }
               }
               if (hasGap) {
-                warnings.push("Multi-column PDFs may not preserve layout accurately");
+                warnings.push(localize(translate, "pdf.warnings.multiColumnLayout", {}));
                 hasMultiColumnWarning = true;
               }
             }
           }
         }
-        let pageText = "";
-        let lastY = null;
-        for (const item of textItems) {
-          const text = item.str;
-          if (!text) continue;
-          if (item.transform && item.transform.length >= 6) {
-            const currentY = item.transform[5];
-            if (lastY !== null && Math.abs(currentY - lastY) > 5) {
-              pageText += "\n";
-            } else if (pageText && !pageText.endsWith(" ") && !pageText.endsWith("\n")) {
-              pageText += " ";
-            }
-            lastY = currentY;
-          } else if (pageText && !pageText.endsWith(" ") && !pageText.endsWith("\n")) {
-            pageText += " ";
-          }
-          pageText += text;
-        }
-        pageText = pageText.replace(/\n{3,}/g, "\n\n").replace(/[ \t]+/g, " ").trim();
-        totalTextLength += pageText.length;
+        totalTextLength += rendered.textContent.length;
         let hasImages = false;
         try {
           const operatorList = await page.getOperatorList();
@@ -21480,9 +22287,11 @@ var PdfAdapter = class {
         }
         pages.push({
           pageNumber: pageNum,
-          textContent: pageText,
+          textContent: rendered.textContent,
           hasImages,
-          viewportWidth: viewport.width
+          viewportWidth: viewport.width,
+          htmlBlocks: rendered.htmlBlocks,
+          tablesDetected: rendered.tablesDetected
         });
       }
       const hasAnyImages = pages.some((p) => p.hasImages);
@@ -21553,6 +22362,9 @@ var PdfAdapter = class {
     return pages.map((page, index) => {
       const pageMarker = index > 0 ? `<div data-page-marker="${page.pageNumber}" class="pdf-page-break">--- Page ${page.pageNumber} ---</div>
 ` : "";
+      if (page.htmlBlocks && page.htmlBlocks.length > 0) {
+        return pageMarker + page.htmlBlocks.join("\n");
+      }
       const paragraphs = page.textContent.split("\n\n").filter((p) => p.trim()).map((p) => {
         const trimmed = p.trim();
         if (trimmed.length < 100 && !trimmed.match(/[.,:;!?]$/)) {
@@ -21574,7 +22386,9 @@ var PdfAdapter = class {
     const loadingTask = pdfjs.getDocument({
       data: arrayBuffer,
       disableAutoFetch: true,
-      disableStream: true
+      disableStream: true,
+      // Disable JavaScript execution in PDF (Req 3.13) — match parseToText.
+      isEvalSupported: false
     });
     try {
       const pdf = await loadingTask.promise;
@@ -22147,7 +22961,7 @@ function extractArticle(html, domProvider) {
 }
 
 // ../../src/shared/token-estimator.ts
-var CJK_REGEX = /[\u4e00-\u9fff\u3400-\u4dbf\u3000-\u303f\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/g;
+var CJK_REGEX2 = /[\u4e00-\u9fff\u3400-\u4dbf\u3000-\u303f\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/g;
 var MAX_INPUT_LENGTH = 1e6;
 function estimateTokens(text) {
   if (!text || text.length === 0) {
@@ -22156,7 +22970,7 @@ function estimateTokens(text) {
   if (text.length > MAX_INPUT_LENGTH) {
     return Math.round(text.length / 4);
   }
-  const cjkMatches = text.match(CJK_REGEX);
+  const cjkMatches = text.match(CJK_REGEX2);
   const cjkCount = cjkMatches ? cjkMatches.length : 0;
   const otherCount = text.length - cjkCount;
   const cjkTokens = cjkCount / 1.5;
@@ -23140,8 +23954,8 @@ import { readFileSync as readFileSync4 } from "fs";
 import { resolve, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
 var getVersion = () => {
-  if ("1.0.10") {
-    return "1.0.10";
+  if ("1.0.12") {
+    return "1.0.12";
   }
   try {
     const __dirname = dirname3(fileURLToPath(import.meta.url));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "formatferry",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "FormatFerry CLI — Convert HTML, DOCX, PDF, XLSX, CSV to Markdown",
   "keywords": [
     "markdown",