kordoc 4.21.19 → 4.21.21

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   blocksToPages,
   inlineImagesIntoMarkdown
-} from "./chunk-CLAIAXMX.js";
+} from "./chunk-T3DTTK23.js";
 import {
   parsePageRange
 } from "./chunk-V4BH5SRQ.js";
@@ -32,7 +32,7 @@ import {
   tidyScriptTags,
   unframeLayoutTables,
   wrapScript
-} from "./chunk-YDIVY65W.js";
+} from "./chunk-KTLHADU4.js";
 import {
   KordocError,
   OPTIONAL_DEP_INSTALL_HINT,
@@ -50,7 +50,7 @@ import {
   toArrayBuffer,
   unescapeHtml,
   unzipLimitBytes
-} from "./chunk-UDODNSDU.js";
+} from "./chunk-ZZIQWSGC.js";
 
 // src/plain-markdown.ts
 function toPlainMarkdown(md2) {
@@ -22501,7 +22501,7 @@ function isKeywordLabel(text) {
   }
   return false;
 }
-function fillInCellPatterns(cellText, values, matchedLabels, blockedLabels) {
+function fillInCellPatterns(cellText, values, matchedLabels, blockedLabels, annotationSkip) {
   let text = cellText;
   const matches = [];
   text = text.replace(
@@ -22538,7 +22538,7 @@ function fillInCellPatterns(cellText, values, matchedLabels, blockedLabels) {
     (match, keyword) => {
       const normalizedKw = normalizeLabel(keyword);
       const matchKey = values.available(normalizedKw) ? normalizedKw : void 0;
-      if (matchKey === void 0) return match;
+      if (matchKey === void 0 || annotationSkip?.has(matchKey)) return match;
       const newValue = values.consume(matchKey);
       matchedLabels.add(matchKey);
       matches.push({ key: matchKey, label: keyword, value: newValue });
@@ -22763,6 +22763,17 @@ function isLabelCell(text) {
   }
   return false;
 }
+function isBlankValue(text) {
+  return /^[\s_()（）\-\u2014\u2013~.·,]*$/.test(text);
+}
+function isColumnHeaderRow(heads, below) {
+  if (heads.length < 2 || below.some((b) => b === void 0)) return false;
+  const hs = heads.map((h) => h.trim());
+  if (hs.some((h) => !h || h.length > 40 || SENTENCE_ENDING_RE.test(h))) return false;
+  const blanks = below.filter((b) => isBlankValue(b)).length;
+  if (blanks === below.length) return true;
+  return hs.length >= 3 && blanks >= hs.length - 1 && hs.every((h) => h.length <= 20 && isLabelCell(h));
+}
 function extractFormFields(blocks) {
   const fields = [];
   let totalTables = 0;
@@ -22795,10 +22806,47 @@ function collectTables(blocks, out = [], depth = 0) {
   }
   return out;
 }
+function coveredGrid(table2) {
+  const covered = Array.from({ length: table2.rows }, () => new Array(table2.cols).fill(false));
+  for (let r = 0; r < table2.rows; r++) {
+    for (let c = 0; c < table2.cols; c++) {
+      const cell2 = table2.cells[r]?.[c];
+      if (!cell2 || covered[r][c]) continue;
+      for (let rr = r; rr < Math.min(r + cell2.rowSpan, table2.rows); rr++) {
+        for (let cc = c; cc < Math.min(c + cell2.colSpan, table2.cols); cc++) if (rr !== r || cc !== c) covered[rr][cc] = true;
+      }
+    }
+  }
+  return covered;
+}
+function columnHeaderRows(table2) {
+  const covered = coveredGrid(table2);
+  const rows = /* @__PURE__ */ new Set();
+  for (let r = 0; r + 1 < table2.rows; r++) {
+    const heads = [];
+    for (let c = 0; c < table2.cols; c++) {
+      const cell2 = table2.cells[r]?.[c];
+      if (cell2 && !covered[r][c] && cell2.rowSpan <= 1) heads.push(c);
+    }
+    const below = heads.map((c) => covered[r + 1][c] ? void 0 : table2.cells[r + 1]?.[c]?.text);
+    if (isColumnHeaderRow(heads.map((c) => table2.cells[r][c].text), below)) rows.add(r);
+  }
+  return rows;
+}
 function extractFromTable(table2) {
   const fields = [];
+  const headerRows = table2.cols >= 2 ? columnHeaderRows(table2) : /* @__PURE__ */ new Set();
+  const covered = headerRows.size > 0 ? coveredGrid(table2) : [];
   if (table2.cols >= 2) {
     for (let r = 0; r < table2.rows; r++) {
+      if (headerRows.has(r)) {
+        for (let c = 0; c < table2.cols; c++) {
+          const cell2 = table2.cells[r]?.[c];
+          if (!cell2 || covered[r][c] || cell2.rowSpan > 1 || !cell2.text.trim()) continue;
+          fields.push({ label: cell2.text.trim().replace(/[:：]\s*$/, ""), value: (table2.cells[r + 1]?.[c]?.text ?? "").trim(), row: r + 1, col: c });
+        }
+        continue;
+      }
       for (let c = 0; c < table2.cols - 1; c++) {
         const labelCell = table2.cells[r]?.[c];
         const valueCell = table2.cells[r]?.[c + 1];
@@ -23608,6 +23656,44 @@ function allLinesegRemovalSplices(xml) {
   }
   return splices;
 }
+function changedLinesegRemovalSplices(xml, edits) {
+  if (edits.length === 0) return [];
+  const points = edits.map((e) => e.start).sort((a, b) => a - b);
+  const tagRe = /<(\/?)((?:[A-Za-z0-9_]+:)?(?:p|linesegarray))(?=[\s/>])(?:"[^"]*"|'[^']*'|[^>"'])*?(\/?)>/g;
+  const stack = [];
+  const out = [];
+  let pi = 0;
+  let m;
+  while ((m = tagRe.exec(xml)) !== null) {
+    while (pi < points.length && points[pi] <= m.index) {
+      if (stack.length) stack[stack.length - 1].dirty = true;
+      pi++;
+    }
+    const [full, close, qname, selfClose] = m;
+    const isSeg = qname.endsWith("linesegarray");
+    if (isSeg) {
+      if (close) continue;
+      let end = m.index + full.length;
+      if (!selfClose) {
+        const ci = xml.indexOf(`</${qname}>`, end);
+        if (ci < 0) continue;
+        end = ci + qname.length + 3;
+        tagRe.lastIndex = end;
+      }
+      const top = stack[stack.length - 1];
+      if (top && !top.seg) top.seg = { start: m.index, end };
+      continue;
+    }
+    if (close) {
+      const p = stack.pop();
+      if (p?.dirty && p.seg) out.push({ start: p.seg.start, end: p.seg.end, replacement: "" });
+    } else if (!selfClose) {
+      stack.push({ dirty: false });
+    }
+  }
+  const claimed = edits.filter((e) => e.end > e.start);
+  return out.filter((ls) => !claimed.some((c) => ls.start >= c.start && ls.end <= c.end));
+}
 function applySplices(xml, splices) {
   const sorted = [...splices].sort((a, b) => a.start - b.start);
   const parts = [];
@@ -23729,10 +23815,17 @@ function fillClickHereInXml(xml, cursor, blockedLabels) {
     if (current === replacement) continue;
     splices.push({ start: region.start, end: region.end, replacement });
   }
+  const changedAt = [];
+  let delta = 0;
+  for (const s of [...splices].sort((a, b) => a.start - b.start)) {
+    changedAt.push(s.start + delta);
+    delta += s.replacement.length - (s.end - s.start);
+  }
   return {
     xml: splices.length > 0 ? applySplices(xml, splices) : null,
     filled,
-    matchedKeys
+    matchedKeys,
+    changedAt
   };
 }
 async function extractClickHereFields(hwpxBuffer) {
@@ -23981,6 +24074,7 @@ function patchZipEntries(original, replacements, additions) {
 }
 
 // src/form/filler-hwpx.ts
+var ANNOTATION_BLANK_RE = /[(（][^)）]*[:：]\s*[)）]/;
 async function fillHwpx(hwpxBuffer, values, blockedLabels) {
   const u8 = new Uint8Array(hwpxBuffer);
   precheckZipSize(hwpxBuffer);
@@ -23999,13 +24093,13 @@ async function fillHwpx(hwpxBuffer, values, blockedLabels) {
   const replacements = /* @__PURE__ */ new Map();
   const encoder = new TextEncoder();
   const sectionXmls = /* @__PURE__ */ new Map();
-  const fieldModified = /* @__PURE__ */ new Set();
+  const fieldModified = /* @__PURE__ */ new Map();
   const fieldMatchedKeys = /* @__PURE__ */ new Set();
   for (const p of sectionPaths) {
     const xml = await zip.file(p).async("text");
     const outcome = fillClickHereInXml(xml, cursor, blockedLabels);
     sectionXmls.set(p, outcome.xml ?? xml);
-    if (outcome.xml !== null) fieldModified.add(p);
+    if (outcome.xml !== null) fieldModified.set(p, outcome.changedAt);
     for (const f of outcome.filled) filled.push(f);
     for (const k of outcome.matchedKeys) fieldMatchedKeys.add(k);
   }
@@ -24013,9 +24107,31 @@ async function fillHwpx(hwpxBuffer, values, blockedLabels) {
     matchedLabels.add(k);
     normalizedValues.delete(k);
   }
+  const scans = sectionPaths.map((p, si) => scanSectionXml(sectionXmls.get(p), si));
+  const annotationSkip = /* @__PURE__ */ new Set();
+  for (let si = 0; si < scans.length; si++) {
+    const xml = sectionXmls.get(sectionPaths[si]);
+    for (const table2 of collectAllTables(scans[si])) {
+      for (const row of table2.rows) {
+        for (const cell2 of row) {
+          const t = cell2.paragraphs.filter((p) => !p.inTextbox).map((p) => paraTText(p, xml) ?? p.text).join("");
+          if (!isLabelCell(t) || ANNOTATION_BLANK_RE.test(t)) continue;
+          const key = findMatchingKey(normalizeLabel(t), cursor);
+          if (key !== void 0 && !cursor.isArray(key)) annotationSkip.add(key);
+        }
+      }
+    }
+    for (const para2 of scans[si].bodyParagraphs) {
+      for (const seg of scanInlineSegments(paraTText(para2, xml) ?? para2.text)) {
+        const key = matchInlineSegment(seg, cursor, blockedLabels)?.key;
+        if (key !== void 0 && !cursor.isArray(key)) annotationSkip.add(key);
+      }
+    }
+  }
+  const firstTarget = /* @__PURE__ */ new Map();
   for (let si = 0; si < sectionPaths.length; si++) {
     const xml = sectionXmls.get(sectionPaths[si]);
-    const scan = scanSectionXml(xml, si);
+    const scan = scans[si];
     const ledger = /* @__PURE__ */ new Map();
     const led = (p) => {
       let l = ledger.get(p);
@@ -24024,25 +24140,14 @@ async function fillHwpx(hwpxBuffer, values, blockedLabels) {
     };
     const matchText = (p) => paraTText(p, xml) ?? p.text;
     const cellLabelText = (cell2) => cell2.paragraphs.filter((p) => !p.inTextbox).map((p) => matchText(p)).join("");
-    const allTables = [];
-    const collectTables2 = (tables, depth) => {
-      if (depth > 16) return;
-      for (const t of tables) {
-        allTables.push(t);
-        for (const row of t.rows) {
-          for (const cell2 of row) collectTables2(cell2.tables, depth + 1);
-        }
-      }
-    };
-    collectTables2(scan.tables, 0);
-    collectTables2(scan.orphanTables, 0);
+    const allTables = collectAllTables(scan);
     const patternApplied = /* @__PURE__ */ new Set();
     for (const table2 of allTables) {
       for (const row of table2.rows) {
         for (const cell2 of row) {
           for (const para2 of cell2.paragraphs) {
             const text = matchText(para2);
-            const result = fillInCellPatterns(text, cursor, matchedLabels, blockedLabels);
+            const result = fillInCellPatterns(text, cursor, matchedLabels, blockedLabels, annotationSkip);
             if (!result) continue;
             const l = led(para2);
             if (l.fullText !== void 0) continue;
@@ -24066,29 +24171,69 @@ async function fillHwpx(hwpxBuffer, values, blockedLabels) {
         }
       }
     }
+    const isForeignLabel = (text) => {
+      if (isKeywordLabel(text)) return true;
+      const t = text.trim();
+      if (/^[①-⑳]/.test(t) && t.length <= 20) return true;
+      if (ANNOTATION_BLANK_RE.test(t)) return false;
+      const n = normalizeLabel(t);
+      return !!n && cursor.has(n);
+    };
+    const laterOk = (key, current) => cursor.isArray(key) || !firstTarget.has(key) || isBlankValue(current) || current.trim() === firstTarget.get(key);
+    const markFirst = (key, current) => {
+      if (!cursor.isArray(key) && !firstTarget.has(key)) firstTarget.set(key, current.trim());
+    };
+    const fillInLabelCell = (cell2, labelText, key, rowIdx, colIdx) => {
+      if (cell2.colSpan < 2) return;
+      if (!cursor.isArray(key) && matchedLabels.has(key)) return;
+      const paras = cell2.paragraphs.filter((p) => !p.inTextbox && matchText(p).trim());
+      if (paras.length !== 1 || cell2.tables.length > 0) return;
+      const l = led(paras[0]);
+      if (l.fullText !== void 0 || l.ranges.length > 0) return;
+      const value = cursor.consume(key);
+      if (value === void 0) return;
+      const text = matchText(paras[0]);
+      l.ranges.push({ start: text.trimEnd().length, end: text.length, replacement: " " + value });
+      l.filledIdx.push(filled.length);
+      l.matchKeys.push(key);
+      matchedLabels.add(key);
+      markFirst(key, labelText);
+      filled.push({ label: labelText.trim().replace(/[:：]\s*$/, ""), value, row: rowIdx, col: colIdx, key });
+    };
     for (const table2 of allTables) {
-      const skipHeaderRow = table2.rows.length >= 2 && (() => {
-        const first = table2.rows[0];
-        const allLabels = first.length > 0 && first.every((cell2) => {
-          const t = cellLabelText(cell2).trim();
-          return t.length > 0 && t.length <= 20 && isLabelCell(t);
-        });
-        if (!allLabels) return false;
+      const firstRowAllLabels = table2.rows.length >= 2 && table2.rows[0].length > 0 && table2.rows[0].every((cell2) => {
+        const t = cellLabelText(cell2).trim();
+        return t.length > 0 && t.length <= 20 && isLabelCell(t);
+      });
+      const headerRows = /* @__PURE__ */ new Set();
+      for (let r = 0; r + 1 < table2.rows.length; r++) {
+        const heads = table2.rows[r].filter((c) => c.rowSpan <= 1);
+        const below = heads.map((h) => table2.rows[r + 1].find((c) => c.colAddr === h.colAddr));
+        if (isColumnHeaderRow(heads.map(cellLabelText), below.map((b) => b ? cellLabelText(b) : void 0))) headerRows.add(r);
+      }
+      const skipRows = new Set(headerRows);
+      if (firstRowAllLabels) {
         const d0 = table2.rows[1][0];
-        return d0 === void 0 || !isLabelCell(cellLabelText(d0));
-      })();
-      for (let rowIdx = skipHeaderRow ? 1 : 0; rowIdx < table2.rows.length; rowIdx++) {
+        if (d0 === void 0 || !isLabelCell(cellLabelText(d0))) skipRows.add(0);
+      }
+      for (let rowIdx = 0; rowIdx < table2.rows.length; rowIdx++) {
+        if (skipRows.has(rowIdx)) continue;
         const cells = table2.rows[rowIdx];
-        for (let colIdx = 0; colIdx < cells.length - 1; colIdx++) {
+        for (let colIdx = 0; colIdx < cells.length; colIdx++) {
           const labelText = cellLabelText(cells[colIdx]);
           if (!isLabelCell(labelText)) continue;
-          const valueCell = cells[colIdx + 1];
-          if (isKeywordLabel(cellLabelText(valueCell))) continue;
           const normalizedCellLabel = normalizeLabel(labelText);
           if (!normalizedCellLabel) continue;
           if (blockedLabels?.has(normalizedCellLabel)) continue;
           const matchKey = findMatchingKey(normalizedCellLabel, cursor);
           if (matchKey === void 0) continue;
+          const valueCell = cells[colIdx + 1];
+          const valueText = valueCell ? cellLabelText(valueCell) : "";
+          if (!valueCell || isForeignLabel(valueText)) {
+            fillInLabelCell(cells[colIdx], labelText, matchKey, rowIdx, colIdx);
+            continue;
+          }
+          if (!laterOk(matchKey, valueText)) continue;
           if (patternApplied.has(valueCell)) {
             const target = valueCell.paragraphs.find((p) => p.tRanges.length > 0) ?? valueCell.paragraphs[0];
             if (!target) continue;
@@ -24100,6 +24245,7 @@ async function fillHwpx(hwpxBuffer, values, blockedLabels) {
             l.filledIdx.push(filled.length);
             l.matchKeys.push(matchKey);
             matchedLabels.add(matchKey);
+            markFirst(matchKey, valueText);
             filled.push({
               label: labelText.trim().replace(/[:：]\s*$/, ""),
               value: newValue,
@@ -24123,6 +24269,7 @@ async function fillHwpx(hwpxBuffer, values, blockedLabels) {
               lk.ranges = [];
             }
             matchedLabels.add(matchKey);
+            markFirst(matchKey, valueText);
             filled.push({
               label: labelText.trim().replace(/[:：]\s*$/, ""),
               value: newValue,
@@ -24133,65 +24280,67 @@ async function fillHwpx(hwpxBuffer, values, blockedLabels) {
           }
         }
       }
-      if (table2.rows.length >= 2) {
-        const headerCells = table2.rows[0];
-        const allLabels = headerCells.length > 0 && headerCells.every((cell2) => {
-          const t = cellLabelText(cell2).trim();
-          return t.length > 0 && t.length <= 20 && isLabelCell(t);
-        });
-        if (allLabels) {
-          for (let rowIdx = 1; rowIdx < table2.rows.length; rowIdx++) {
-            const dataCells = table2.rows[rowIdx];
-            for (let colIdx = 0; colIdx < Math.min(headerCells.length, dataCells.length); colIdx++) {
-              const headerLabel = normalizeLabel(cellLabelText(headerCells[colIdx]));
-              if (blockedLabels?.has(headerLabel)) continue;
-              const matchKey = findMatchingKey(headerLabel, cursor);
-              if (matchKey === void 0) continue;
-              if (!cursor.isArray(matchKey) && matchedLabels.has(matchKey)) continue;
-              const dataCell = dataCells[colIdx];
-              if (patternApplied.has(dataCell)) {
-                const target = dataCell.paragraphs.find((p) => p.tRanges.length > 0) ?? dataCell.paragraphs[0];
-                if (!target) continue;
-                const l = led(target);
-                if (l.fullText !== void 0) continue;
-                const newValue2 = cursor.consume(matchKey);
-                if (newValue2 === void 0) continue;
-                l.ranges.push({ start: 0, end: 0, replacement: newValue2 + " " });
-                l.filledIdx.push(filled.length);
-                l.matchKeys.push(matchKey);
-                matchedLabels.add(matchKey);
-                filled.push({
-                  label: cellLabelText(headerCells[colIdx]).trim(),
-                  value: newValue2,
-                  row: rowIdx,
-                  col: colIdx,
-                  key: matchKey
-                });
-                continue;
-              }
-              const newValue = cursor.consume(matchKey);
-              if (newValue === void 0) continue;
-              const paras = dataCell.paragraphs;
-              if (paras.length === 0) continue;
-              const l0 = led(paras[0]);
-              l0.fullText = newValue;
-              l0.ranges = [];
-              l0.filledIdx.push(filled.length);
-              l0.matchKeys.push(matchKey);
-              for (let k = 1; k < paras.length; k++) {
-                const lk = led(paras[k]);
-                lk.fullText = "";
-                lk.ranges = [];
-              }
+      const verticalRows = new Set(headerRows);
+      if (firstRowAllLabels) verticalRows.add(0);
+      for (const h of [...verticalRows].sort((a, b) => a - b)) {
+        const headerCells = table2.rows[h];
+        const scalarSeen = /* @__PURE__ */ new Set();
+        for (let rowIdx = h + 1; rowIdx < table2.rows.length && !verticalRows.has(rowIdx); rowIdx++) {
+          const dataCells = table2.rows[rowIdx];
+          for (let colIdx = 0; colIdx < headerCells.length; colIdx++) {
+            const dataCell = dataCells.find((c) => c.colAddr === headerCells[colIdx].colAddr);
+            if (!dataCell) continue;
+            const headerLabel = normalizeLabel(cellLabelText(headerCells[colIdx]));
+            if (!headerLabel || blockedLabels?.has(headerLabel)) continue;
+            const matchKey = findMatchingKey(headerLabel, cursor);
+            if (matchKey === void 0) continue;
+            if (!cursor.isArray(matchKey) && (matchedLabels.has(matchKey) || scalarSeen.has(colIdx))) continue;
+            if (!cursor.isArray(matchKey)) scalarSeen.add(colIdx);
+            if (isForeignLabel(cellLabelText(dataCell))) continue;
+            if (patternApplied.has(dataCell)) {
+              const target = dataCell.paragraphs.find((p) => p.tRanges.length > 0) ?? dataCell.paragraphs[0];
+              if (!target) continue;
+              const l = led(target);
+              if (l.fullText !== void 0) continue;
+              const newValue2 = cursor.consume(matchKey);
+              if (newValue2 === void 0) continue;
+              l.ranges.push({ start: 0, end: 0, replacement: newValue2 + " " });
+              l.filledIdx.push(filled.length);
+              l.matchKeys.push(matchKey);
               matchedLabels.add(matchKey);
+              markFirst(matchKey, cellLabelText(dataCell));
               filled.push({
                 label: cellLabelText(headerCells[colIdx]).trim(),
-                value: newValue,
+                value: newValue2,
                 row: rowIdx,
                 col: colIdx,
                 key: matchKey
               });
+              continue;
             }
+            const newValue = cursor.consume(matchKey);
+            if (newValue === void 0) continue;
+            const paras = dataCell.paragraphs;
+            if (paras.length === 0) continue;
+            const l0 = led(paras[0]);
+            l0.fullText = newValue;
+            l0.ranges = [];
+            l0.filledIdx.push(filled.length);
+            l0.matchKeys.push(matchKey);
+            for (let k = 1; k < paras.length; k++) {
+              const lk = led(paras[k]);
+              lk.fullText = "";
+              lk.ranges = [];
+            }
+            matchedLabels.add(matchKey);
+            markFirst(matchKey, cellLabelText(dataCell));
+            filled.push({
+              label: cellLabelText(headerCells[colIdx]).trim(),
+              value: newValue,
+              row: rowIdx,
+              col: colIdx,
+              key: matchKey
+            });
           }
         }
       }
@@ -24207,9 +24356,11 @@ async function fillHwpx(hwpxBuffer, values, blockedLabels) {
         const matched = matches[i];
         if (matched === void 0) continue;
         const matchKey = matched.key;
+        const ve = clampSegmentEnd(text, seg, segments[i + 1], matches[i + 1]?.viaExt ?? false);
+        if (!laterOk(matchKey, text.slice(seg.valueStart, ve))) continue;
         const newValue = cursor.consume(matchKey);
         if (newValue === void 0) continue;
-        const ve = clampSegmentEnd(text, seg, segments[i + 1], matches[i + 1]?.viaExt ?? false);
+        markFirst(matchKey, text.slice(seg.valueStart, ve));
         const replacement = seg.valueStart === ve ? padInsertion(text, seg.valueStart, newValue) : newValue;
         const l = led(para2);
         l.ranges.push({ start: seg.valueStart, end: ve, replacement });
@@ -24263,8 +24414,10 @@ async function fillHwpx(hwpxBuffer, values, blockedLabels) {
       for (const k of l.matchKeys) succeededKeys.add(k);
       splices.push(...paraSplices);
     }
-    if (splices.length > 0 || fieldModified.has(sectionPaths[si])) {
-      splices.push(...allLinesegRemovalSplices(xml));
+    const fieldAt = fieldModified.get(sectionPaths[si]);
+    if (splices.length > 0 || fieldAt) {
+      const marks = (fieldAt ?? []).map((at) => ({ start: at, end: at, replacement: "" }));
+      splices.push(...changedLinesegRemovalSplices(xml, [...splices, ...marks]));
       replacements.set(sectionPaths[si], encoder.encode(applySplices(xml, splices)));
     }
   }
@@ -24281,6 +24434,21 @@ async function fillHwpx(hwpxBuffer, values, blockedLabels) {
     ...warnings.length > 0 ? { warnings } : {}
   };
 }
+function collectAllTables(scan) {
+  const out = [];
+  const walk = (tables, depth) => {
+    if (depth > 16) return;
+    for (const t of tables) {
+      out.push(t);
+      for (const row of t.rows) {
+        for (const cell2 of row) walk(cell2.tables, depth + 1);
+      }
+    }
+  };
+  walk(scan.tables, 0);
+  walk(scan.orphanTables, 0);
+  return out;
+}
 
 // src/table/classifier.ts
 var DIAGRAM_KEYWORDS = /조직도|비상\s*연락망|연락망|체계도|업무\s*체계도|기구표|배치도|흐름도|추진\s*체계/u;
@@ -33368,7 +33536,7 @@ function parseCharPrs(headerDoc, hangulFonts) {
     if (color) def.textColor = color;
     if (cp.getAttribute("bold") === "1") def.bold = true;
     if (cp.getAttribute("italic") === "1") def.italic = true;
-    if (findChildByLocalName(cp, "underline")) def.underline = true;
+    if (findChildByLocalName(cp, "underline")?.getAttribute("type") === "BOTTOM") def.underline = true;
     const fontRef = findChildByLocalName(cp, "fontRef");
     const hangul = fontRef?.getAttribute("hangul");
     if (hangul) {
@@ -34698,6 +34866,163 @@ function buildEmbeddedLineSplices(para2, xml, newLines) {
   return splices;
 }
 
+// src/roundtrip/inline-edit.ts
+var ESCAPABLE = /* @__PURE__ */ new Set(["~", "*", "_", "`", "|", "#", "<", "$", "\\"]);
+var isWs = (c) => c !== void 0 && /\s/.test(c);
+function parseEmphasis(text) {
+  const toks = [];
+  const pushText = (s, code = false) => {
+    const last = toks[toks.length - 1];
+    if (last && last.kind === "text" && !!last.code === code) last.text += s;
+    else toks.push({ kind: "text", text: s, code });
+  };
+  for (let i = 0; i < text.length; ) {
+    const c = text[i];
+    if (c === "\\" && ESCAPABLE.has(text[i + 1])) {
+      pushText(text[i + 1]);
+      i += 2;
+      continue;
+    }
+    if (c === "`") {
+      const close = text.indexOf("`", i + 1);
+      if (close > i + 1) {
+        pushText(text.slice(i + 1, close), true);
+        i = close + 1;
+        continue;
+      }
+    }
+    if (text.startsWith("<u>", i)) {
+      toks.push({ kind: "u-open", text: "<u>" });
+      i += 3;
+      continue;
+    }
+    if (text.startsWith("</u>", i)) {
+      toks.push({ kind: "u-close", text: "</u>" });
+      i += 4;
+      continue;
+    }
+    if (text.startsWith("~~", i)) {
+      toks.push({ kind: "strike", text: "~~" });
+      i += 2;
+      continue;
+    }
+    if (c === "*") {
+      let j = i;
+      while (text[j] === "*") j++;
+      toks.push({ kind: "star", text: text.slice(i, j), n: j - i });
+      i = j;
+      continue;
+    }
+    pushText(c);
+    i++;
+  }
+  const charBefore = (k) => {
+    const t = toks[k - 1];
+    return t?.kind === "text" ? t.text[t.text.length - 1] : t ? "x" : void 0;
+  };
+  const charAfter = (k) => {
+    const t = toks[k + 1];
+    return t?.kind === "text" ? t.text[0] : t ? "x" : void 0;
+  };
+  const stack = [];
+  for (let k = 0; k < toks.length; k++) {
+    const t = toks[k];
+    if (t.kind === "text") continue;
+    const top = stack.length ? toks[stack[stack.length - 1]] : void 0;
+    const canClose = t.kind === "u-close" || (t.kind === "star" || t.kind === "strike") && charBefore(k) !== void 0 && !isWs(charBefore(k));
+    const matches = top && (t.kind === "u-close" && top.kind === "u-open" || t.kind === "strike" && top.kind === "strike" || t.kind === "star" && top.kind === "star" && top.n === t.n);
+    if (canClose && matches) {
+      top.paired = true;
+      t.paired = true;
+      stack.pop();
+      continue;
+    }
+    const canOpen = t.kind === "u-open" || (t.kind === "star" || t.kind === "strike") && charAfter(k) !== void 0 && !isWs(charAfter(k));
+    if (canOpen) stack.push(k);
+  }
+  const segs = [];
+  let cur = "";
+  const cut = () => {
+    if (cur) segs.push(cur);
+    cur = "";
+  };
+  for (const t of toks) {
+    if (t.kind !== "text" && t.paired) {
+      cut();
+      continue;
+    }
+    if (t.code) {
+      cut();
+      segs.push(t.text);
+      continue;
+    }
+    cur += t.text;
+  }
+  cut();
+  return { plain: segs.join(""), segs };
+}
+function alignToRaw(raw, norm2) {
+  const pos = new Array(norm2.length);
+  let j = 0;
+  for (let i = 0; i < norm2.length; i++) {
+    for (; ; ) {
+      if (j >= raw.length) return null;
+      const a = norm2[i], b = raw[j];
+      if (a === b || isWs(a) && isWs(b)) break;
+      if (isWs(b)) {
+        j++;
+        continue;
+      }
+      return null;
+    }
+    pos[i] = j++;
+  }
+  if (raw.slice(j).trim() !== "") return null;
+  return pos;
+}
+function commonEnds(a, b) {
+  let p = 0;
+  while (p < a.length && p < b.length && a[p] === b[p]) p++;
+  let s = 0;
+  while (s < a.length - p && s < b.length - p && a[a.length - 1 - s] === b[b.length - 1 - s]) s++;
+  return { p, s };
+}
+function alignedTextEdits(raw, origNorm, newNorm, origSegs, newSegs) {
+  if (!origNorm) return null;
+  const pos = alignToRaw(raw, origNorm);
+  if (!pos) return null;
+  const ranges = [];
+  const diffInto = (o, n, base) => {
+    if (o === n) return;
+    const { p, s } = commonEnds(o, n);
+    ranges.push({ a: base + p, b: base + o.length - s, text: n.slice(p, n.length - s) });
+  };
+  if (origSegs && newSegs && origSegs.length === newSegs.length && origSegs.length > 1 && origSegs.join("") === origNorm && newSegs.join("") === newNorm) {
+    let base = 0;
+    for (let k = 0; k < origSegs.length; k++) {
+      diffInto(origSegs[k], newSegs[k], base);
+      base += origSegs[k].length;
+    }
+  } else {
+    diffInto(origNorm, newNorm, 0);
+  }
+  const at = (a) => a < pos.length ? pos[a] : pos[pos.length - 1] + 1;
+  return ranges.map((r) => ({ start: at(r.a), end: r.b > r.a ? pos[r.b - 1] + 1 : at(r.a), text: r.text }));
+}
+function minimalTextSplices(para2, xml, origPlain, newPlain, origSegs, newSegs) {
+  const raw = paraTText(para2, xml);
+  if (raw === null) return null;
+  const edits = alignedTextEdits(raw, origPlain, newPlain, origSegs, newSegs);
+  if (!edits || edits.length === 0) return null;
+  const out = [];
+  for (const e of edits) {
+    const sp = buildRangeSplices(para2, xml, e.start, e.end, e.text);
+    if (!sp) return null;
+    out.push(...sp);
+  }
+  return out;
+}
+
 // src/roundtrip/table-patch.ts
 function patchGfmTable(table2, scanTable, orig, edited, ctx, skip) {
   const replica = replicateGfmTable(table2);
@@ -35014,7 +35339,8 @@ function applyCellEdit(table2, scanTable, gridR, gridC, newLines, ctx, before2,
     }
     for (let i = 0; i < nonEmpty.length; i++) {
       if (assigned[i] === nonEmpty[i].text || normForMatch(assigned[i]) === normForMatch(nonEmpty[i].text)) continue;
-      const sp = buildParagraphSplices(nonEmpty[i], assigned[i], ctx.scans[nonEmpty[i].sectionIndex]?.xml);
+      const xml = ctx.scans[nonEmpty[i].sectionIndex]?.xml;
+      const sp = (xml ? minimalTextSplices(nonEmpty[i], xml, normForMatch(nonEmpty[i].text), assigned[i]) : null) ?? buildParagraphSplices(nonEmpty[i], assigned[i], xml);
       if (sp === null) return skip("\uC140 \uBB38\uB2E8\uC5D0 \uD14D\uC2A4\uD2B8 \uB178\uB4DC\uB97C \uB9CC\uB4E4 \uC218 \uC5C6\uC74C");
       splices.push(...sp);
       sectionIndex = nonEmpty[i].sectionIndex;
@@ -35881,7 +36207,13 @@ function patchParagraph(block, orig, edited, ctx, skip) {
   if (sanitizeText(newPlain) !== newPlain) {
     return skip("\uACF5\uBC31 \uC815\uADDC\uD654 \uBD88\uC548\uC815 \uD14D\uC2A4\uD2B8 \u2014 \uD328\uCE58 \uC2DC \uC6D0\uBB38 \uBCF4\uC874 \uBD88\uAC00\uB85C \uBBF8\uC9C0\uC6D0");
   }
-  return stageParaPatch(ctx.scans[mapping.para.sectionIndex], mapping.para, newPlain, skip);
+  let origMd = restoreBr(textUnitToPlain(orig.raw, block));
+  if (block.footnoteText) origMd = origMd.replace(/\s*\(주: [\s\S]*\)$/, "");
+  if (mapping.prefixStripped) {
+    const origPrefix = block.text.split(" ", 1)[0];
+    if (origMd.startsWith(origPrefix + " ")) origMd = origMd.slice(origPrefix.length + 1);
+  }
+  return stageParaPatch(ctx.scans[mapping.para.sectionIndex], mapping.para, newPlain, skip, origMd);
 }
 function patchGfmCells(scanTable, orig, edited, ctx, skip) {
   const origRows = parseGfmTable(orig.lines);
@@ -36197,6 +36529,39 @@ function rebuildCharShape(csData, coreStartUnit) {
   });
   return { buf, count: kept.length };
 }
+function shiftCharShape(csData, start, end, newLen) {
+  const pairs = [];
+  for (let o = 0; o + 8 <= csData.length; o += 8) pairs.push([csData.readUInt32LE(o), csData.readUInt32LE(o + 4)]);
+  if (pairs.length === 0) return { buf: Buffer.from(csData.subarray(0, 8)), count: 1 };
+  const delta = newLen - (end - start);
+  const out = [];
+  let inRange;
+  for (const [p, id] of pairs) {
+    if (p <= start) out.push([p, id]);
+    else if (p <= end) inRange = id;
+    else {
+      if (inRange !== void 0) {
+        out.push([start + newLen, inRange]);
+        inRange = void 0;
+      }
+      out.push([p + delta, id]);
+    }
+  }
+  if (inRange !== void 0) out.push([start + newLen, inRange]);
+  const kept = [];
+  for (const [p, id] of out) {
+    const last = kept[kept.length - 1];
+    if (last && last[0] === p) last[1] = id;
+    else if (last && last[1] === id) continue;
+    else kept.push([p, id]);
+  }
+  const buf = Buffer.alloc(kept.length * 8);
+  kept.forEach(([p, id], k) => {
+    buf.writeUInt32LE(p >>> 0, k * 8);
+    buf.writeUInt32LE(id >>> 0, k * 8 + 4);
+  });
+  return { buf, count: kept.length };
+}
 var CRC_TABLE2 = (() => {
   const t = new Uint32Array(256);
   for (let n = 0; n < 256; n++) {
@@ -36235,7 +36600,7 @@ function synthesizeLineSegs(lineSegData, newRaw, startUnits) {
   }
   return { buf: Buffer.concat(segs), count: lines.length };
 }
-function stageParaPatch(scan, para2, newPlain, skip) {
+function stageParaPatch(scan, para2, newPlain, skip, origPlain) {
   if (!scan.safe) return skip("\uC139\uC158 \uB808\uCF54\uB4DC \uC7AC\uC9C1\uB82C\uD654 \uBD88\uC77C\uCE58 \u2014 \uC548\uC804\uC744 \uC704\uD574 \uC774 \uC139\uC158\uC740 \uBBF8\uC9C0\uC6D0");
   if (para2.textIdx === -2) return skip("\uBCF5\uC218 PARA_TEXT \uB808\uCF54\uB4DC \uBB38\uB2E8 \u2014 \uBBF8\uC9C0\uC6D0 (v1)");
   if (para2.rangeTagCount > 0) return skip("\uBC94\uC704 \uD0DC\uADF8(\uD615\uAD11\uD39C/\uAD50\uC815\uBD80\uD638) \uBB38\uB2E8 \u2014 \uBBF8\uC9C0\uC6D0 (v1)");
@@ -36277,15 +36642,16 @@ function stageParaPatch(scan, para2, newPlain, skip) {
     return skip(para2.ctrlMask !== 0 ? "\uCEE8\uD2B8\uB864 \uBB38\uC790(\uD0ED/\uD544\uB4DC/\uD2B9\uC218\uACF5\uBC31 \uB4F1 \uD14D\uC2A4\uD2B8 \uC911\uAC04) \uD3EC\uD568 \uBB38\uB2E8 \u2014 \uBBF8\uC9C0\uC6D0 (v1)" : "PARA_TEXT \uC7AC\uAD6C\uC131 \uBD88\uC77C\uCE58 \u2014 \uC6D0\uBB38 \uBCF4\uC874 \uBD88\uAC00\uB85C \uBBF8\uC9C0\uC6D0");
   }
   if (seg.core !== para2.rawText) return skip("PARA_TEXT \uC7AC\uAD6C\uC131 \uBD88\uC77C\uCE58 \u2014 \uC6D0\uBB38 \uBCF4\uC874 \uBD88\uAC00\uB85C \uBBF8\uC9C0\uC6D0");
+  const edit = origPlain !== void 0 && !origPlain.includes("\n") && !newPlain.includes("\n") ? alignedTextEdits(para2.rawText, origPlain, newPlain)?.[0] : void 0;
   const lead = para2.rawText.match(/^\s*/)[0];
   const trail = para2.rawText.match(/\s*$/)[0];
-  const newRaw = para2.rawText.trim() === para2.rawText ? newPlain : lead + newPlain + trail;
+  const newRaw = edit ? para2.rawText.slice(0, edit.start) + edit.text + para2.rawText.slice(edit.end) : para2.rawText.trim() === para2.rawText ? newPlain : lead + newPlain + trail;
   const newText = Buffer.concat([seg.prefix, Buffer.from(newRaw, "utf16le"), seg.suffix]);
   scan.repl.set(para2.textIdx, newText);
   const newHeader = Buffer.from(headerRec.data);
   const nChars = seg.prefixUnits + newRaw.length + seg.suffixUnits;
   newHeader.writeUInt32LE((para2.nCharsRaw & 2147483648 | nChars) >>> 0, 0);
-  const cs = rebuildCharShape(charShapeRec.data, seg.prefixUnits);
+  const cs = edit ? shiftCharShape(charShapeRec.data, seg.prefixUnits + edit.start, seg.prefixUnits + edit.end, edit.text.length) : rebuildCharShape(charShapeRec.data, seg.prefixUnits);
   scan.repl.set(para2.charShapeIdx, cs.buf);
   newHeader.writeUInt16LE(cs.count, 12);
   if (newRaw.includes("\n")) {
@@ -36387,8 +36753,7 @@ async function patchHwpx(original, editedMarkdown, options) {
     for (let i = 0; i < scans.length; i++) {
       if (sectionSplices[i].length === 0) continue;
       edited.push({ name: sectionPaths[i], xml: scans[i].xml, splices: [...sectionSplices[i]] });
-      const claimed = sectionSplices[i].filter((s) => s.end > s.start);
-      sectionSplices[i].push(...allLinesegRemovalSplices(scans[i].xml).filter((ls) => !claimed.some((c) => ls.start >= c.start && ls.end <= c.end)));
+      sectionSplices[i].push(...changedLinesegRemovalSplices(scans[i].xml, sectionSplices[i]));
       const newXml = applySplices(scans[i].xml, sectionSplices[i]);
       replacements.set(sectionPaths[i], encoder.encode(newXml));
     }
@@ -36681,9 +37046,13 @@ function patchParagraphUnit(block, orig, edited, ctx, skip) {
   if (block.text && block.text.includes("\n")) {
     return skip("\uBB38\uB2E8 \uB0B4 \uAC15\uC81C \uC904\uBC14\uAFC8 \uD3EC\uD568 \u2014 \uC218\uC815 \uC2DC \uC904\uBC14\uAFC8 \uBCF4\uC874 \uBD88\uAC00\uB85C \uBBF8\uC9C0\uC6D0 (v1)");
   }
-  const origPlain = textUnitToPlain(orig.raw, block);
-  let newPlain = textUnitToPlain(edited.raw, block);
+  const origInline = parseEmphasis(textUnitInline(orig.raw, block));
+  const newInline = parseEmphasis(textUnitInline(edited.raw, block));
+  let origPlain = origInline.plain;
+  let newPlain = newInline.plain;
+  const segsUsable = !block.footnoteText && !mapping.noteMarks?.length && !mapping.prefixStripped;
   if (block.footnoteText) {
+    origPlain = origPlain.replace(/\s*\(주: [\s\S]*\)$/, "");
     const noteMatch = newPlain.match(/\s*\(주: ([\s\S]*)\)$/);
     if (noteMatch) {
       newPlain = newPlain.slice(0, noteMatch.index).trimEnd();
@@ -36695,12 +37064,14 @@ function patchParagraphUnit(block, orig, edited, ctx, skip) {
     }
   }
   if (mapping.noteMarks?.length) {
+    origPlain = removeNoteMarks(origPlain, mapping.noteMarks).text;
     const r = removeNoteMarks(newPlain, mapping.noteMarks);
     newPlain = r.text;
     if (r.missing.length) ctx.skipped.push({ reason: "\uAC01\uC8FC \uCC38\uC870 \uBD80\uD638 \uC0AD\uC81C\uB294 \uBBF8\uC9C0\uC6D0 \u2014 \uAC01\uC8FC \uC720\uC9C0, \uBCF8\uBB38\uB9CC \uC801\uC6A9", before: r.missing.join(" ") });
   }
   if (mapping.prefixStripped) {
     const origPrefix = block.text.split(" ", 1)[0];
+    if (origPlain.startsWith(origPrefix + " ")) origPlain = origPlain.slice(origPrefix.length + 1);
     const sp = newPlain.indexOf(" ");
     const newFirst = sp > 0 ? newPlain.slice(0, sp) : newPlain;
     if (newFirst === origPrefix || AUTONUM_PREFIX_RE.test(newFirst)) {
@@ -36710,16 +37081,22 @@ function patchParagraphUnit(block, orig, edited, ctx, skip) {
     }
   }
   if (newPlain === origPlain) return skip("\uD14D\uC2A4\uD2B8 \uC678 \uBCC0\uACBD(\uD5E4\uB529 \uB808\uBCA8/\uC11C\uC2DD)\uB9CC \uAC10\uC9C0 \u2014 \uC2A4\uD0C0\uC77C \uBCC0\uACBD\uC740 \uBBF8\uC9C0\uC6D0");
-  if (sanitizeText(newPlain) !== newPlain) {
+  if (sanitizeText(newPlain) !== newPlain && sanitizeText(origPlain) === origPlain) {
     return skip("\uACF5\uBC31 \uC815\uADDC\uD654 \uBD88\uC548\uC815 \uD14D\uC2A4\uD2B8 \u2014 \uD328\uCE58 \uC2DC \uC6D0\uBB38 \uBCF4\uC874 \uBD88\uAC00\uB85C \uBBF8\uC9C0\uC6D0");
   }
   const xml = ctx.scans[mapping.para.sectionIndex]?.xml;
-  const splices = (xml ? markerRunSplices(mapping.para, xml, newPlain) : null) ?? buildParagraphSplices(mapping.para, newPlain, xml);
+  const splices = (xml ? minimalTextSplices(mapping.para, xml, origPlain, newPlain, segsUsable ? origInline.segs : void 0, segsUsable ? newInline.segs : void 0) : null) ?? (xml ? markerRunSplices(mapping.para, xml, newPlain) : null) ?? buildParagraphSplices(mapping.para, newPlain, xml);
   if (splices === null) return skip("\uBB38\uB2E8\uC5D0 \uD14D\uC2A4\uD2B8 \uB178\uB4DC\uB97C \uB9CC\uB4E4 \uC218 \uC5C6\uC74C");
   ctx.sectionSplices[mapping.para.sectionIndex].push(...splices);
+  if (segsUsable && origInline.segs.length !== newInline.segs.length) {
+    ctx.skipped.push({ reason: "\uAC15\uC870(\uAD75\uAC8C\xB7\uBC11\uC904 \uB4F1) \uCD94\uAC00\xB7\uC0AD\uC81C\uB294 \uBBF8\uC9C0\uC6D0: \uAE00\uB9CC \uC801\uC6A9, \uC6D0\uBB38 \uAE00\uC790 \uBAA8\uC591 \uC720\uC9C0", before: summarize(orig.raw), after: summarize(edited.raw), partial: true });
+  }
   return 1;
 }
 function textUnitToPlain(raw, block) {
+  return parseEmphasis(textUnitInline(raw, block)).plain;
+}
+function textUnitInline(raw, block) {
   let text = raw.split("\n").map((l) => l.trim()).filter(Boolean).join(" ");
   if (block.type === "heading" || block.text && /^\[별표\s*\d+/.test(sanitizeText(block.text))) {
     text = text.replace(/^#{1,6}\s+/, "");
@@ -36731,7 +37108,7 @@ function textUnitToPlain(raw, block) {
   if (/^\*[^*][\s\S]*\*$/.test(text) && block.text && /^\([^)]*조[^)]*관련\)$/.test(sanitizeText(block.text))) {
     text = text.slice(1, -1);
   }
-  return unescapeGfm(text);
+  return text;
 }
 function diffUnitLists(a, b) {
   const pairs = alignUnits(a.map((u) => u.raw), b.map((u) => u.raw));
@@ -39572,7 +39949,7 @@ var HwpxSession = class _HwpxSession {
     try {
       for (let s = 0; s < st.scans.length; s++) {
         if (sectionSplices[s].length === 0) continue;
-        sectionSplices[s].push(...allLinesegRemovalSplices(st.scans[s].xml));
+        sectionSplices[s].push(...changedLinesegRemovalSplices(st.scans[s].xml, sectionSplices[s]));
         replacements.set(st.sectionPaths[s], encoder.encode(applySplices(st.scans[s].xml, sectionSplices[s])));
       }
     } catch (err) {
@@ -42311,7 +42688,7 @@ function scriptsOff(r, off) {
 }
 async function parseImage(buffer, options) {
   try {
-    const { parseImageDocument } = await import("./image-ocr-23R7RVHP.js");
+    const { parseImageDocument } = await import("./image-ocr-3C6W3KZO.js");
     const { blocks, warnings } = await parseImageDocument(buffer, options);
     stripScriptTags({ blocks });
     return {
@@ -42371,7 +42748,7 @@ async function parseHwp(buffer, options) {
 async function parsePdf(buffer, options) {
   let parsePdfDocument;
   try {
-    const mod = await import("./parser-FXGAKPUI.js");
+    const mod = await import("./parser-56I364YM.js");
     parsePdfDocument = mod.parsePdfDocument;
   } catch {
     return {