kordoc 3.13.0 → 3.15.0

package/dist/{chunk-TWACKS3K.js → chunk-Q3IHI3E6.js}

@@ -18,7 +18,7 @@ import {
   extractTextFromNode,
   findChildByLocalName,
   fitRatioForFewerLines
-} from "./chunk-33CIKNL4.js";
+} from "./chunk-734GJLXH.js";
 import {
   HEADING_RATIO_H1,
   HEADING_RATIO_H2,
@@ -30,7 +30,7 @@ import {
   convertTableToText,
   flattenLayoutTables,
   mapPuaText
-} from "./chunk-YXOT7P5B.js";
+} from "./chunk-Q5ZPWQID.js";
 import {
   parsePageRange
 } from "./chunk-MOL7MDBG.js";
@@ -44,7 +44,7 @@ import {
   sanitizeHref,
   stripDtd,
   toArrayBuffer
-} from "./chunk-Q6UXVJXI.js";
+} from "./chunk-SCFFABCT.js";
 
 // src/index.ts
 import { readFile } from "fs/promises";
@@ -640,10 +640,22 @@ function findEnclosingBrackets(eqString, startIdx) {
   }
   return null;
 }
+function maskLiteralSpans(eqString) {
+  return eqString.replace(/"[^"]*"/g, (m) => "\uFFFF".repeat(m.length)).replace(/\\text\{[^}]*\}/g, (m) => "\uFFFF".repeat(m.length));
+}
+function findKeywordToken(eqString, word, from = 0) {
+  const masked = maskLiteralSpans(eqString);
+  for (let i = masked.indexOf(word, from); i !== -1; i = masked.indexOf(word, i + 1)) {
+    const okL = i === 0 || masked[i - 1] === " ";
+    const okR = i + word.length === masked.length || masked[i + word.length] === " ";
+    if (okL && okR) return i;
+  }
+  return -1;
+}
 function replaceFrac(eqString) {
   const hmlFrac = "over";
   while (true) {
-    const cursor = eqString.indexOf(hmlFrac);
+    const cursor = findKeywordToken(eqString, hmlFrac);
     if (cursor === -1) break;
     try {
       const [numStart, numEnd] = findBrackets(eqString, cursor, 0);
@@ -659,12 +671,12 @@ function replaceFrac(eqString) {
 }
 function replaceRootOf(eqString) {
   while (true) {
-    const rootCursor = eqString.indexOf("root");
+    const rootCursor = findKeywordToken(eqString, "root");
     if (rootCursor === -1) break;
     try {
-      const ofCursor = eqString.indexOf("of");
-      if (ofCursor === -1) return eqString;
       const elem1 = findBrackets(eqString, rootCursor, 1);
+      const ofCursor = findKeywordToken(eqString, "of", elem1[1]);
+      if (ofCursor === -1) return eqString;
       const elem2 = findBrackets(eqString, ofCursor, 1);
       const e1 = eqString.slice(elem1[0] + 1, elem1[1] - 1);
       const e2 = eqString.slice(elem2[0] + 1, elem2[1] - 1);
@@ -2082,7 +2094,6 @@ function appendParaText(state, data, resolveControl) {
           break;
         }
         result += "\n";
-        if (i + 14 <= data.length) i += 14;
         break;
       }
       case CHAR_PARA:
@@ -17955,6 +17966,7 @@ function collectOmmlRoots(p) {
       const tag = el.localName || el.tagName?.replace(/^[^:]+:/, "") || "";
       if (tag === "oMath" || tag === "oMathPara") {
         out.push(el);
+      } else if (tag === "txbxContent" || tag === "Fallback") {
       } else {
         walk(el);
       }
@@ -18079,6 +18091,13 @@ function parseTable(tbl, styles, numbering, footnotes, rels) {
   for (const tr of trElements) {
     const row = [];
     let col = 0;
+    const trPrEls = getChildElements(tr, "trPr");
+    if (trPrEls.length > 0) {
+      const gridBeforeEls = getChildElements(trPrEls[0], "gridBefore");
+      if (gridBeforeEls.length > 0) {
+        col = parseInt(getAttr(gridBeforeEls[0], "val") ?? "0", 10) || 0;
+      }
+    }
     for (const tc of getChildElements(tr, "tc")) {
       let colSpan = 1;
       let vMerge = null;
@@ -18093,12 +18112,28 @@ function parseTable(tbl, styles, numbering, footnotes, rels) {
           vMerge = getAttr(vMergeEls[0], "val") === "restart" ? "restart" : "continue";
         }
       }
-      const text = vMerge === "continue" ? "" : collectCellText(tc, styles, numbering, footnotes, rels, 0).join("\n");
+      const text = collectCellText(tc, styles, numbering, footnotes, rels, 0).join("\n");
       row.push({ col, colSpan, vMerge, text });
       col += colSpan;
     }
     rawRows.push(row);
   }
+  for (let r = 0; r < rawRows.length; r++) {
+    for (const cell of rawRows[r]) {
+      if (cell.vMerge !== "continue" || !cell.text) continue;
+      let start;
+      for (let pr = r - 1; pr >= 0 && !start; pr--) {
+        start = rawRows[pr].find((pc) => pc.col === cell.col && pc.vMerge !== "continue");
+      }
+      if (start) {
+        start.text = start.text ? `${start.text}
+${cell.text}` : cell.text;
+        cell.text = "";
+      } else {
+        cell.vMerge = null;
+      }
+    }
+  }
   const cellRows = rawRows.map(
     (row, r) => row.filter((cell) => cell.vMerge !== "continue").map((cell) => {
       let rowSpan = 1;
@@ -18588,6 +18623,81 @@ function countSections(body) {
 }
 
 // src/form/match.ts
+function parseYMD(v) {
+  const d = v.replace(/\D/g, "");
+  let y, m, day;
+  if (d.length >= 8) {
+    y = d.slice(0, 4);
+    m = d.slice(4, 6);
+    day = d.slice(6, 8);
+  } else if (d.length === 6) {
+    const yy = +d.slice(0, 2);
+    y = String(yy <= 29 ? 2e3 + yy : 1900 + yy);
+    m = d.slice(2, 4);
+    day = d.slice(4, 6);
+  } else return null;
+  return { y, yy: y.slice(2), m, d: day };
+}
+function fmtDate(v, style) {
+  const p = parseYMD(v);
+  if (!p) return v;
+  return (style || "yyyy-mm-dd").replace(/yyyy/g, p.y).replace(/yy/g, p.yy).replace(/mm/g, p.m).replace(/dd/g, p.d).replace(/m/g, String(+p.m)).replace(/d/g, String(+p.d));
+}
+function maskDigits(v, pattern) {
+  const ds = v.replace(/\D/g, "");
+  let i = 0;
+  return pattern.replace(/#/g, () => ds[i++] ?? "");
+}
+function fmtPhone(v, style) {
+  const d = v.replace(/\D/g, "");
+  if (d.length < 9) return v;
+  const a = d.slice(0, 3), b = d.slice(3, -4), c = d.slice(-4);
+  switch (style) {
+    case "digits":
+      return d;
+    case "dot":
+      return `${a}.${b}.${c}`;
+    case "space":
+      return `${a} ${b} ${c}`;
+    case "intl":
+      return `+82-${d.slice(1, 3)}-${b}-${c}`;
+    case "intl-paren":
+      return `82)${d.slice(1, 3)}-${b}-${c}`;
+    default:
+      return `${a}-${b}-${c}`;
+  }
+}
+function fmtRRN(v, style) {
+  const d = v.replace(/\D/g, "");
+  if (d.length !== 13) return v;
+  switch (style) {
+    case "digits":
+      return d;
+    case "front":
+      return d.slice(0, 6);
+    case "masked":
+      return `${d.slice(0, 6)}-${d[6]}******`;
+    default:
+      return `${d.slice(0, 6)}-${d.slice(6)}`;
+  }
+}
+function formatFillValue(value, format) {
+  if (!format) return value;
+  const ci = format.indexOf(":");
+  const kind = ci >= 0 ? format.slice(0, ci) : format;
+  const style = ci >= 0 ? format.slice(ci + 1) : "";
+  if (kind === "date") return fmtDate(value, style);
+  if (kind === "phone") return fmtPhone(value, style);
+  if (kind === "rrn") return fmtRRN(value, style);
+  if (kind === "mask") return maskDigits(value, style);
+  if (kind === "digits") return value.replace(/\D/g, "");
+  if (kind === "upper") return value.toUpperCase();
+  if (kind === "lower") return value.toLowerCase();
+  if (kind === "nospace") return value.replace(/\s+/g, "");
+  if (format.includes("#")) return maskDigits(value, format);
+  if (/(yyyy|yy|mm|dd)/.test(format)) return fmtDate(value, format);
+  return value;
+}
 var ValueCursor = class {
   constructor(values) {
     this.values = values;
@@ -18739,11 +18849,32 @@ function padInsertion(text, pos, value) {
 }
 function normalizeValues(values) {
   const map = /* @__PURE__ */ new Map();
-  for (const [label, value] of Object.entries(values)) {
-    map.set(normalizeLabel(label), value);
+  for (const [label, raw] of Object.entries(values)) {
+    const { value, format } = typeof raw === "object" && !Array.isArray(raw) ? raw : { value: raw, format: void 0 };
+    map.set(normalizeLabel(label), Array.isArray(value) ? value.map((v) => formatFillValue(v, format)) : formatFillValue(value, format));
   }
   return map;
 }
+async function fillWithUniqueGuard(values, run) {
+  const first = await run(values);
+  const counts = /* @__PURE__ */ new Map();
+  for (const f of first.filled) {
+    if (f.key) counts.set(f.key, (counts.get(f.key) ?? 0) + 1);
+  }
+  const isArrayValue = (normKey) => {
+    for (const [label, raw] of Object.entries(values)) {
+      if (normalizeLabel(label) !== normKey) continue;
+      return Array.isArray(typeof raw === "object" && !Array.isArray(raw) ? raw.value : raw);
+    }
+    return false;
+  };
+  const dup = new Set([...counts].filter(([k, n]) => n >= 2 && !isArrayValue(k)).map(([k]) => k));
+  if (dup.size === 0) return { ...first, rejected: [] };
+  const filtered = Object.fromEntries(Object.entries(values).filter(([label]) => !dup.has(normalizeLabel(label))));
+  const second = await run(filtered);
+  const rejected = Object.keys(values).filter((label) => dup.has(normalizeLabel(label)));
+  return { ...second, rejected };
+}
 function resolveUnmatched(normalizedValues, matchedLabels, originalValues) {
   return [...normalizedValues.keys()].filter((k) => !matchedLabels.has(k)).map((k) => {
     for (const orig of Object.keys(originalValues)) {
@@ -19013,7 +19144,7 @@ function fillFormFields(blocks, values) {
           cell.text = result.text;
           patternFilledCells.add(cell);
           for (const m of result.matches) {
-            filled.push({ label: m.label, value: m.value, row: r, col: c });
+            filled.push({ label: m.label, value: m.value, row: r, col: c, key: m.key });
           }
         }
       }
@@ -19093,7 +19224,8 @@ function fillTable(table, values, filled, matchedLabels, patternFilledCells) {
         label: labelCell.text.trim().replace(/[:：]\s*$/, ""),
         value: newValue,
         row: r,
-        col: c
+        col: c,
+        key: matchKey
       });
     }
   }
@@ -19122,7 +19254,8 @@ function fillTable(table, values, filled, matchedLabels, patternFilledCells) {
           label: headerCell.text.trim(),
           value: newValue,
           row: r,
-          col: c
+          col: c,
+          key: matchKey
         });
       }
     }
@@ -19139,7 +19272,7 @@ function fillInlineFields(text, values, filled, matchedLabels) {
     const newValue = values.consume(matchKey);
     if (newValue === void 0) continue;
     matchedLabels.add(matchKey);
-    filled.push({ label: seg.label.trim(), value: newValue, row: -1, col: -1 });
+    filled.push({ label: seg.label.trim(), value: newValue, row: -1, col: -1, key: matchKey });
     out += text.slice(pos, seg.valueStart);
     out += seg.valueStart === seg.valueEnd ? padInsertion(text, seg.valueStart, newValue) : newValue;
     pos = seg.valueEnd;
@@ -19976,7 +20109,8 @@ async function fillHwpx(hwpxBuffer, values) {
                 label: cellLabelText(headerCells[colIdx]).trim(),
                 value: newValue,
                 row: rowIdx,
-                col: colIdx
+                col: colIdx,
+                key: matchKey
               });
             }
           }
@@ -21487,6 +21621,9 @@ function readCommand(input, idx, depth) {
     const body = readGroupOrToken(input, name.next, depth);
     return { value: `${ACCENT_COMMANDS[command]}{${body.value}}`, next: body.next };
   }
+  if (command === ",") return { value: "`", next: name.next };
+  if (command === ";" || command === ":") return { value: "~", next: name.next };
+  if (command === "!") return { value: "", next: name.next };
   if (command === "mathrm" || command === "text") {
     const start = skipSpaces(input, name.next);
     if (input[start] === "{") {
@@ -23489,10 +23626,11 @@ function handleModified(orig, edited, ctx) {
 function patchParagraph(block, orig, edited, ctx, skip) {
   const mapping = ctx.paraMap.get(orig.blockIdx);
   if (!mapping?.para) return skip("\uBB38\uB2E8 \uC18C\uC2A4\uB9F5 \uB9E4\uD551 \uC2E4\uD328 (\uBA38\uB9AC\uB9D0/\uAE00\uC0C1\uC790/\uCEA1\uC158 \uC601\uC5ED\uC774\uAC70\uB098 \uD14D\uC2A4\uD2B8 \uBD88\uC77C\uCE58)");
-  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 restoreBr = (s) => s.replace(/\s*<br\s*\/?\s*>\s*/gi, "\n");
+  let newPlain = restoreBr(textUnitToPlain(edited.raw, block));
+  if (block.text && block.text.includes("\n") && !newPlain.includes("\n")) {
+    return skip("\uB2E4\uC911\uC904 \uBB38\uB2E8 \uC218\uC815\uC5D0 <br> \uC5C6\uC74C \u2014 \uC904\uBC14\uAFC8 \uC704\uCE58 \uBCF4\uC874 \uBD88\uAC00\uB85C \uBBF8\uC9C0\uC6D0 (\uC904\uBC14\uAFC8\uC740 <br>\uB85C \uD45C\uAE30)");
   }
-  let newPlain = textUnitToPlain(edited.raw, block);
   if (block.footnoteText) {
     const noteMatch = newPlain.match(/\s*\(주: ([\s\S]*)\)$/);
     if (noteMatch) {
@@ -23514,7 +23652,7 @@ function patchParagraph(block, orig, edited, ctx, skip) {
       ctx.skipped.push({ reason: "\uC790\uB3D9\uBC88\uD638 \uC811\uB450 \uC2DD\uBCC4 \uC2E4\uD328 \u2014 \uBC88\uD638 \uD3EC\uD568 \uD14D\uC2A4\uD2B8\uB85C \uC801\uC6A9 (\uBDF0\uC5B4\uC5D0\uC11C \uC911\uBCF5 \uD45C\uC2DC \uAC00\uB2A5)", after: summarize(newPlain) });
     }
   }
-  const origPlain = textUnitToPlain(orig.raw, block);
+  const origPlain = restoreBr(textUnitToPlain(orig.raw, block));
   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) {
     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");
@@ -23542,6 +23680,28 @@ function patchGfmCells(scanTable, orig, edited, ctx, skip) {
       }
       const beforeParts = origRows[r][c].split(/<br\s*\/?>/i);
       const afterParts = editedRows[r][c].split(/<br\s*\/?>/i);
+      if (cell.paras.length === 1) {
+        const beforeEach = beforeParts.map(gfmCellToPlain);
+        const afterEach = afterParts.map(gfmCellToPlain);
+        if (beforeEach.some((p) => p === null) || afterEach.some((p) => p === null)) {
+          cellSkip("\uC11C\uC2DD/\uB9C1\uD06C/\uC774\uBBF8\uC9C0 \uD3EC\uD568 \uC140 \uC218\uC815\uC740 \uBBF8\uC9C0\uC6D0 (v1)");
+          continue;
+        }
+        const before = beforeEach.join("\n");
+        const after = afterEach.join("\n");
+        if (before === after) continue;
+        const para = cell.paras[0];
+        if (normForMatch(para.rawText) !== normForMatch(before)) {
+          cellSkip("\uC140 \uD14D\uC2A4\uD2B8 \uBD88\uC77C\uCE58 \u2014 \uC18C\uC2A4\uB9F5 \uC2E0\uB8B0 \uBD88\uAC00");
+          continue;
+        }
+        if (afterEach.some((l) => sanitizeText(l) !== l)) {
+          cellSkip("\uACF5\uBC31 \uC815\uADDC\uD654 \uBD88\uC548\uC815 \uD14D\uC2A4\uD2B8 \u2014 \uBBF8\uC9C0\uC6D0");
+          continue;
+        }
+        applied += stageParaPatch(ctx.scans[para.sectionIndex], para, after, cellSkip);
+        continue;
+      }
       if (beforeParts.length !== cell.paras.length || afterParts.length !== cell.paras.length) {
         cellSkip("\uC140 \uBB38\uB2E8 \uC218 \uBCC0\uACBD \u2014 \uBBF8\uC9C0\uC6D0 (\uBB38\uB2E8 \uCD94\uAC00/\uC0AD\uC81C)");
         continue;
@@ -23686,13 +23846,13 @@ function applyCellEdit5(table, scanTable, gridR, gridC, newLines, ctx, before, a
   const assigned = [];
   for (let i = 0; i < targets.length; i++) {
     if (i < newLines.length) {
-      assigned.push(i === targets.length - 1 && newLines.length > targets.length ? newLines.slice(i).join(" ") : newLines[i]);
+      assigned.push(i === targets.length - 1 && newLines.length > targets.length ? newLines.slice(i).join("\n") : newLines[i]);
     } else {
       assigned.push("");
     }
   }
   if (newLines.length > targets.length) {
-    ctx.skipped.push({ reason: "\uC140 \uB0B4 \uC904 \uCD94\uAC00\uB294 \uBB38\uB2E8 \uC0DD\uC131 \uBBF8\uC9C0\uC6D0 \u2014 \uB9C8\uC9C0\uB9C9 \uBB38\uB2E8\uC5D0 \uBCD1\uD569 \uC801\uC6A9", after: summarize(after), partial: true });
+    ctx.skipped.push({ reason: "\uC140 \uB0B4 \uCD94\uAC00 \uC904\uC744 \uB9C8\uC9C0\uB9C9 \uBB38\uB2E8\uC5D0 \uAC15\uC81C \uC904\uBC14\uAFC8\uC73C\uB85C \uBCD1\uD569(\uBB38\uB2E8 \uC0DD\uC131 \uB300\uC2E0)", after: summarize(after), partial: true });
   } else if (newLines.length < nonEmpty.length && nonEmpty.length > 1) {
     ctx.skipped.push({ reason: "\uC140 \uB0B4 \uC904 \uC0AD\uC81C\uB294 \uBB38\uB2E8 \uC81C\uAC70 \uBBF8\uC9C0\uC6D0 \u2014 \uBE48 \uBB38\uB2E8 \uC794\uC874(\uBDF0\uC5B4\uC5D0 \uBE48 \uC904 \uD45C\uC2DC \uAC00\uB2A5)", before: summarize(before), after: summarize(after), partial: true });
   }
@@ -23750,8 +23910,7 @@ function splitParaText(data) {
           i += 16;
           toks.push({ start, end: i, units: 1, plain: false, visible: false });
         } else {
-          if (i + 14 <= data.length) i += 14;
-          toks.push({ start, end: i, units: 1, plain: false, visible: true });
+          toks.push({ start, end: i, units: 1, plain: true, visible: true });
         }
         break;
       default: {
@@ -23814,13 +23973,31 @@ function rebuildCharShape(csData, coreStartUnit) {
   });
   return { buf, count: kept.length };
 }
+function synthesizeLineSegs(lineSegData, newRaw, startUnits) {
+  if (lineSegData.length < 36) return null;
+  const seg0 = lineSegData.subarray(0, 36);
+  const vPos0 = seg0.readInt32LE(4);
+  const pitch = seg0.readInt32LE(8) + seg0.readInt32LE(20);
+  if (pitch <= 0) return null;
+  const lines = newRaw.split("\n");
+  const segs = [];
+  let pos = startUnits;
+  for (let k = 0; k < lines.length; k++) {
+    const s = Buffer.from(seg0);
+    s.writeUInt32LE((k === 0 ? 0 : pos) >>> 0, 0);
+    s.writeInt32LE(vPos0 + k * pitch, 4);
+    segs.push(s);
+    pos += lines[k].length + 1;
+  }
+  return { buf: Buffer.concat(segs), count: lines.length };
+}
 function stageParaPatch(scan, para, newPlain, skip) {
   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 (para.textIdx === -2) return skip("\uBCF5\uC218 PARA_TEXT \uB808\uCF54\uB4DC \uBB38\uB2E8 \u2014 \uBBF8\uC9C0\uC6D0 (v1)");
   if (para.rangeTagCount > 0) return skip("\uBC94\uC704 \uD0DC\uADF8(\uD615\uAD11\uD39C/\uAD50\uC815\uBD80\uD638) \uBB38\uB2E8 \u2014 \uBBF8\uC9C0\uC6D0 (v1)");
   if (para.charShapeIdx < 0 || para.lineSegIdx < 0) return skip("\uBB38\uB2E8 \uB808\uCF54\uB4DC \uAD6C\uC131 \uBE44\uC815\uD615 \u2014 \uBBF8\uC9C0\uC6D0");
   if (scan.repl.has(para.headerIdx)) return skip("\uB3D9\uC77C \uBB38\uB2E8 \uC911\uBCF5 \uC218\uC815 \u2014 \uCCAB \uC218\uC815\uB9CC \uC801\uC6A9");
-  if (/[\u0000-\u001f]/.test(newPlain)) return skip("\uC0C8 \uD14D\uC2A4\uD2B8\uC5D0 \uC81C\uC5B4\uBB38\uC790 \uD3EC\uD568 \u2014 \uBBF8\uC9C0\uC6D0");
+  if (/[\u0000-\u0009\u000b-\u001f]/.test(newPlain)) return skip("\uC0C8 \uD14D\uC2A4\uD2B8\uC5D0 \uC81C\uC5B4\uBB38\uC790 \uD3EC\uD568 \u2014 \uBBF8\uC9C0\uC6D0");
   const records = scan.records;
   const headerRec = records[para.headerIdx];
   const charShapeRec = records[para.charShapeIdx];
@@ -23840,6 +24017,13 @@ function stageParaPatch(scan, para, newPlain, skip) {
     const cs2 = rebuildCharShape(charShapeRec.data, 0);
     scan.repl.set(para.charShapeIdx, cs2.buf);
     newHeader2.writeUInt16LE(cs2.count, 12);
+    if (newPlain.includes("\n")) {
+      const synth = synthesizeLineSegs(records[para.lineSegIdx].data, newPlain, 0);
+      if (synth) {
+        scan.repl.set(para.lineSegIdx, synth.buf);
+        newHeader2.writeUInt16LE(synth.count, 16);
+      }
+    }
     scan.repl.set(para.headerIdx, newHeader2);
     return 1;
   }
@@ -23860,15 +24044,108 @@ function stageParaPatch(scan, para, newPlain, skip) {
   const cs = rebuildCharShape(charShapeRec.data, seg.prefixUnits);
   scan.repl.set(para.charShapeIdx, cs.buf);
   newHeader.writeUInt16LE(cs.count, 12);
+  if (newRaw.includes("\n")) {
+    const synth = synthesizeLineSegs(records[para.lineSegIdx].data, newRaw, seg.prefixUnits);
+    if (synth) {
+      scan.repl.set(para.lineSegIdx, synth.buf);
+      newHeader.writeUInt16LE(synth.count, 16);
+    }
+  }
   scan.repl.set(para.headerIdx, newHeader);
   return 1;
 }
 
-// src/roundtrip/session.ts
+// src/validate.ts
 import JSZip8 from "jszip";
+import { DOMParser as DOMParser4 } from "@xmldom/xmldom";
+var REQUIRED_FILES = [
+  "mimetype",
+  "META-INF/container.xml",
+  "Contents/content.hpf",
+  "Contents/header.xml",
+  "Contents/section0.xml"
+];
+var EXPECTED_MIMETYPE = "application/hwp+zip";
+var XML_SUFFIXES = [".xml", ".hpf", ".rdf"];
+var SECTION_FILE_RE = /^Contents\/section\d+\.xml$/;
+var SECCNT_RE = /<(?:\w+:)?head\b[^>]*?\bsecCnt="(\d+)"/;
+var OPF_HREF_RE = /<opf:item\b[^>]*?\bhref="([^"]*)"/g;
+async function validateHwpx(buffer) {
+  const issues = [];
+  let zip;
+  try {
+    zip = await JSZip8.loadAsync(buffer);
+  } catch (err) {
+    return {
+      ok: false,
+      issues: [{ message: `\uC720\uD6A8\uD55C ZIP\uC774 \uC544\uB2D8: ${err instanceof Error ? err.message : String(err)}` }],
+      entryCount: 0
+    };
+  }
+  const rawNames = Object.keys(zip.files);
+  const names = rawNames.filter((n) => !zip.files[n].dir);
+  if (names.length === 0) return { ok: false, issues: [{ message: "\uBE48 ZIP" }], entryCount: 0 };
+  if (rawNames[0] !== "mimetype") {
+    issues.push({ message: `\uCCAB zip \uC5D4\uD2B8\uB9AC\uAC00 '${rawNames[0]}' \u2014 'mimetype'\uC774\uC5B4\uC57C \uD568` });
+  }
+  const nameset = new Set(names);
+  if (nameset.has("mimetype")) {
+    const mt = (await zip.files["mimetype"].async("string")).trim();
+    if (mt !== EXPECTED_MIMETYPE) {
+      issues.push({ path: "mimetype", message: `\uB0B4\uC6A9\uC774 '${mt}' \u2014 '${EXPECTED_MIMETYPE}'\uC774\uC5B4\uC57C \uD568` });
+    }
+  }
+  for (const req of REQUIRED_FILES) {
+    if (!nameset.has(req)) issues.push({ message: `\uD544\uC218 \uD30C\uC77C \uB204\uB77D: ${req}` });
+  }
+  for (const name of names) {
+    if (!XML_SUFFIXES.some((s) => name.endsWith(s))) continue;
+    const text = await zip.files[name].async("string");
+    let firstError = null;
+    try {
+      new DOMParser4({
+        onError(level, msg2) {
+          if (level !== "warning" && firstError === null) firstError = String(msg2);
+        }
+      }).parseFromString(text, "text/xml");
+    } catch (err) {
+      firstError ??= err instanceof Error ? err.message : String(err);
+    }
+    if (firstError !== null) {
+      issues.push({ path: name, message: `XML \uC6F0\uD3FC\uB4DC \uC704\uBC18: ${firstError.split("\n")[0]}` });
+    }
+  }
+  if (nameset.has("Contents/header.xml")) {
+    const header = await zip.files["Contents/header.xml"].async("string");
+    const m = SECCNT_RE.exec(header);
+    if (m) {
+      const declared = Number(m[1]);
+      const actual = names.filter((n) => SECTION_FILE_RE.test(n)).length;
+      if (declared !== actual) {
+        issues.push({
+          path: "Contents/header.xml",
+          message: `secCnt=${declared}\uC778\uB370 \uC2E4\uC81C sectionN.xml\uC740 ${actual}\uAC1C \u2014 \uD55C\uCEF4\uB3C5\uC2A4\uAC00 \uC5F4\uAE30\uB97C \uAC70\uBD80\uD568`
+        });
+      }
+    }
+  }
+  if (nameset.has("Contents/content.hpf")) {
+    const hpf = await zip.files["Contents/content.hpf"].async("string");
+    for (const m of hpf.matchAll(OPF_HREF_RE)) {
+      const href = m[1];
+      if (!nameset.has(href) && !nameset.has(`Contents/${href}`)) {
+        issues.push({ path: "Contents/content.hpf", message: `manifest\uAC00 \uC5C6\uB294 \uD30C\uC77C\uC744 \uCC38\uC870: ${href}` });
+      }
+    }
+  }
+  return { ok: issues.length === 0, issues, entryCount: names.length };
+}
+
+// src/roundtrip/session.ts
+import JSZip9 from "jszip";
 async function buildState(bytes) {
   const parsed = await parseHwpxDocument(u8ToArrayBuffer2(bytes));
-  const zip = await JSZip8.loadAsync(bytes);
+  const zip = await JSZip9.loadAsync(bytes);
   const sectionPaths = await resolveSectionEntryNames(zip);
   if (sectionPaths.length === 0) {
     throw new Error("HWPX \uC139\uC158 \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
@@ -24449,7 +24726,7 @@ async function parseHwp(buffer, options) {
 async function parsePdf(buffer, options) {
   let parsePdfDocument;
   try {
-    const mod = await import("./parser-XUNGOH76.js");
+    const mod = await import("./parser-76JSTEP3.js");
     parsePdfDocument = mod.parsePdfDocument;
   } catch {
     return {
@@ -24542,7 +24819,9 @@ async function fillForm(input, values, outputFormat = "markdown") {
 export {
   extractHwpxMetadataOnly,
   extractHwp5MetadataOnly,
+  formatFillValue,
   ValueCursor,
+  fillWithUniqueGuard,
   isLabelCell,
   extractFormFields,
   inferFieldType,
@@ -24560,6 +24839,7 @@ export {
   diffBlocks,
   patchHwpx,
   patchHwp,
+  validateHwpx,
   HwpxSession,
   openHwpxDocument,
   patchHwpxBlocks,
@@ -24577,4 +24857,4 @@ export {
   parseHwpml,
   fillForm
 };
-//# sourceMappingURL=chunk-TWACKS3K.js.map
+//# sourceMappingURL=chunk-Q3IHI3E6.js.map