kordoc 3.3.0 → 3.4.0

package/dist/index.js

@@ -17,7 +17,7 @@ import {
   sanitizeHref,
   stripDtd,
   toArrayBuffer
-} from "./chunk-ESBGMBRF.js";
+} from "./chunk-ZPLRG2SJ.js";
 import {
   parsePageRange
 } from "./chunk-GE43BE46.js";
@@ -22247,14 +22247,7 @@ async function patchHwp(original, editedMarkdown, options) {
   const editedUnits = splitMarkdownUnits(editedMarkdown);
   const pairs = alignUnits(origUnits.map((u) => u.raw), editedUnits.map((u) => u.raw));
   const paraMap = resolveParaMappings(origBlocks, scans);
-  const scanTables = scans.flatMap((s) => s.tables);
-  const obTableOrdinals = /* @__PURE__ */ new Map();
-  {
-    let ordinal = 0;
-    for (let i = 0; i < origBlocks.length; i++) {
-      if (origBlocks[i].type === "table" && origBlocks[i].table) obTableOrdinals.set(i, ordinal++);
-    }
-  }
+  const tableMap = resolveTableMappings(origBlocks, scans.flatMap((s) => s.tables));
   for (const [oi, ei] of pairs) {
     if (oi !== null && ei !== null) {
       const orig = origUnits[oi];
@@ -22264,8 +22257,7 @@ async function patchHwp(original, editedMarkdown, options) {
         origBlocks,
         paraMap,
         scans,
-        scanTables,
-        obTableOrdinals,
+        tableMap,
         skipped
       });
     } else if (oi !== null) {
@@ -22350,6 +22342,46 @@ function resolveParaMappings(blocks, scans) {
   }
   return result;
 }
+function resolveTableMappings(blocks, scanTables) {
+  const result = /* @__PURE__ */ new Map();
+  let si = 0;
+  for (let i = 0; i < blocks.length; i++) {
+    const table = blocks[i].table;
+    if (blocks[i].type !== "table" || !table) continue;
+    const cands = [];
+    for (let k = si; k < scanTables.length; k++) {
+      if (scanTables[k].rows === table.rows && scanTables[k].cols === table.cols) cands.push(k);
+    }
+    if (cands.length === 0) continue;
+    let pick = cands[0];
+    if (cands.length > 1) {
+      let best = tableContentScore(table, scanTables[cands[0]]);
+      for (let ci = 1; ci < cands.length; ci++) {
+        const sc = tableContentScore(table, scanTables[cands[ci]]);
+        if (sc > best) {
+          best = sc;
+          pick = cands[ci];
+        }
+      }
+    }
+    result.set(i, scanTables[pick]);
+    si = pick + 1;
+  }
+  return result;
+}
+function tableContentScore(irTable, scanTable) {
+  let matched = 0;
+  for (const [key, scanCell] of scanTable.cells) {
+    const comma = key.indexOf(",");
+    const r = Number(key.slice(0, comma)), c = Number(key.slice(comma + 1));
+    const irCell = irTable.cells[r]?.[c];
+    if (!irCell) continue;
+    const a = normForMatch(scanCell.paras.map((p) => p.rawText).join(" "));
+    const b = normForMatch(stripCellTokens(irCell.text));
+    if (a && a === b) matched++;
+  }
+  return matched;
+}
 function handleModified(orig, edited, ctx) {
   const block = ctx.origBlocks[orig.blockIdx];
   const skip = (reason) => {
@@ -22362,12 +22394,10 @@ function handleModified(orig, edited, ctx) {
   if (orig.fragment) return skip("\uBB38\uB2E8 \uBD84\uC808(\uAC15\uC81C \uC904\uBC14\uAFC8/\uBCD1\uD569 \uC720\uB2DB) \u2014 \uBD80\uBD84 \uC218\uC815\uC740 \uBBF8\uC9C0\uC6D0 (v1)");
   if (block.type === "table" && block.table) {
     if (orig.kind !== edited.kind) return skip("\uD45C \u2194 \uBE44\uD45C \uBCC0\uACBD\uC740 \uBBF8\uC9C0\uC6D0 (\uD45C \uAD6C\uC870 \uBCC0\uACBD)");
-    if (ctx.obTableOrdinals.size !== ctx.scanTables.length) return skip("\uD45C \uAC1C\uC218 \uBD88\uC77C\uCE58 \u2014 \uC18C\uC2A4\uB9F5 \uC2E0\uB8B0 \uBD88\uAC00");
-    const ordinal = ctx.obTableOrdinals.get(orig.blockIdx);
-    const scanTable = ordinal !== void 0 ? ctx.scanTables[ordinal] : void 0;
-    if (!scanTable) return skip("\uD45C \uC18C\uC2A4\uB9F5 \uB9E4\uD551 \uC2E4\uD328");
+    const scanTable = ctx.tableMap.get(orig.blockIdx);
+    if (!scanTable) return skip("\uD45C \uC18C\uC2A4\uB9F5 \uB9E4\uD551 \uC2E4\uD328 \u2014 \uD45C \uAC1C\uC218/\uAD6C\uC870 \uBD88\uC77C\uCE58\uB85C \uC2E0\uB8B0 \uBD88\uAC00");
     if (orig.kind === "gfm-table") return patchGfmCells(scanTable, orig, edited, ctx, skip);
-    if (orig.kind === "html-table") return skip("HTML \uD45C(\uBCD1\uD569/\uC904\uBC14\uAFC8 \uC140) \uC218\uC815\uC740 HWP5 \uBBF8\uC9C0\uC6D0 (v1)");
+    if (orig.kind === "html-table") return patchHtmlCells5(block.table, scanTable, orig, edited, ctx, skip);
     return patchTextChunk5(block.table, scanTable, orig, edited, ctx, skip);
   }
   if ((block.type === "paragraph" || block.type === "heading") && orig.kind === "text" && edited.kind === "text") {
@@ -22424,35 +22454,87 @@ function patchGfmCells(scanTable, orig, edited, ctx, skip) {
         ctx.skipped.push({ reason, before: summarize(origRows[r][c]), after: summarize(editedRows[r][c]) });
         return 0;
       };
-      const before = gfmCellToPlain(origRows[r][c]);
-      const after = gfmCellToPlain(editedRows[r][c]);
-      if (before === null || after === null) {
-        cellSkip("\uC11C\uC2DD/\uB9C1\uD06C/\uC774\uBBF8\uC9C0 \uD3EC\uD568 \uC140 \uC218\uC815\uC740 \uBBF8\uC9C0\uC6D0 (v1)");
-        continue;
-      }
-      if (after.includes("\n")) {
-        cellSkip("\uC140 \uB0B4 \uC904\uBC14\uAFC8 \uCD94\uAC00\uB294 \uBBF8\uC9C0\uC6D0 (v1)");
-        continue;
-      }
       const cell = scanTable.cells.get(`${r},${c}`);
       if (!cell) {
         cellSkip("\uBCD1\uD569 \uC601\uC5ED \uC140 \u2014 \uC575\uCEE4 \uC140\uC774 \uC544\uB2C8\uBBC0\uB85C \uBBF8\uC9C0\uC6D0");
         continue;
       }
-      if (cell.paras.length !== 1) {
-        cellSkip("\uBCF5\uC218 \uBB38\uB2E8 \uC140 \uC218\uC815\uC740 \uBBF8\uC9C0\uC6D0 (v1)");
+      const beforeParts = origRows[r][c].split(/<br\s*\/?>/i);
+      const afterParts = editedRows[r][c].split(/<br\s*\/?>/i);
+      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;
       }
-      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;
+      for (let k = 0; k < cell.paras.length; k++) {
+        const before = gfmCellToPlain(beforeParts[k]);
+        const after = gfmCellToPlain(afterParts[k]);
+        if (before === null || after === null) {
+          cellSkip("\uC11C\uC2DD/\uB9C1\uD06C/\uC774\uBBF8\uC9C0 \uD3EC\uD568 \uC140 \uC218\uC815\uC740 \uBBF8\uC9C0\uC6D0 (v1)");
+          break;
+        }
+        if (before === after) continue;
+        if (after.includes("\n")) {
+          cellSkip("\uC140 \uB0B4 \uC904\uBC14\uAFC8 \uCD94\uAC00\uB294 \uBBF8\uC9C0\uC6D0 (v1)");
+          break;
+        }
+        const para = cell.paras[k];
+        if (normForMatch(para.rawText) !== normForMatch(before)) {
+          cellSkip("\uC140 \uD14D\uC2A4\uD2B8 \uBD88\uC77C\uCE58 \u2014 \uC18C\uC2A4\uB9F5 \uC2E0\uB8B0 \uBD88\uAC00");
+          break;
+        }
+        if (sanitizeText(after) !== after) {
+          cellSkip("\uACF5\uBC31 \uC815\uADDC\uD654 \uBD88\uC548\uC815 \uD14D\uC2A4\uD2B8 \u2014 \uBBF8\uC9C0\uC6D0");
+          break;
+        }
+        applied += stageParaPatch(ctx.scans[para.sectionIndex], para, after, cellSkip);
       }
-      if (sanitizeText(after) !== after) {
-        cellSkip("\uACF5\uBC31 \uC815\uADDC\uD654 \uBD88\uC548\uC815 \uD14D\uC2A4\uD2B8 \u2014 \uBBF8\uC9C0\uC6D0");
+    }
+  }
+  return applied;
+}
+function extractImgTags5(inner) {
+  return (inner.match(/<img\s(?:"[^"]*"|'[^']*'|[^>"'])*?>/gi) || []).join(" ");
+}
+function patchHtmlCells5(table, scanTable, orig, edited, ctx, skip) {
+  if (replicateTableToHtml(table) !== orig.raw) return skip("\uD45C \uC88C\uD45C \uC7AC\uD604 \uBD88\uC77C\uCE58 \u2014 \uB9E4\uD551 \uC2E0\uB8B0 \uBD88\uAC00");
+  const replica = replicateHtmlTable(table);
+  const origRows = parseHtmlTable(orig.raw);
+  if (!origRows || origRows.length !== replica.length || origRows.some((r, i) => r.cells.length !== replica[i].cells.length || r.cells.some((c, j) => c.inner !== replica[i].cells[j].inner))) {
+    return skip("\uC140 \uACBD\uACC4 \uBAA8\uD638 (\uB9AC\uD130\uB7F4 \uD0DC\uADF8 \uC758\uC2EC) \u2014 \uB9E4\uD551 \uC2E0\uB8B0 \uBD88\uAC00");
+  }
+  const editedRows = parseHtmlTable(edited.raw);
+  if (!editedRows) return skip("\uD3B8\uC9D1\uB41C HTML \uD45C \uD30C\uC2F1 \uC2E4\uD328");
+  if (editedRows.length !== replica.length) return skip("\uD45C \uD589 \uCD94\uAC00/\uC0AD\uC81C\uB294 \uBBF8\uC9C0\uC6D0 (\uD45C \uAD6C\uC870 \uBCC0\uACBD)");
+  let applied = 0;
+  for (let r = 0; r < replica.length; r++) {
+    if (editedRows[r].cells.length !== replica[r].cells.length) {
+      skip(`\uD45C ${r + 1}\uD589 \uC140 \uC218 \uBCC0\uACBD\uC740 \uBBF8\uC9C0\uC6D0`);
+      continue;
+    }
+    for (let c = 0; c < replica[r].cells.length; c++) {
+      const oc = replica[r].cells[c];
+      const ec = editedRows[r].cells[c];
+      if (oc.colSpan !== ec.colSpan || oc.rowSpan !== ec.rowSpan) {
+        skip("\uC140 \uBCD1\uD569(colspan/rowspan) \uBCC0\uACBD\uC740 \uBBF8\uC9C0\uC6D0");
         continue;
       }
-      applied += stageParaPatch(ctx.scans[para.sectionIndex], para, after, cellSkip);
+      if (oc.inner === ec.inner) continue;
+      const origContent = htmlCellInnerToLines(oc.inner);
+      const editedContent = htmlCellInnerToLines(ec.inner);
+      if (origContent.hadNonText || editedContent.hadNonText) {
+        if (extractImgTags5(oc.inner) !== extractImgTags5(ec.inner)) {
+          skip("\uC140 \uB0B4 \uC774\uBBF8\uC9C0 \uBCC0\uACBD\uC740 \uBBF8\uC9C0\uC6D0");
+          continue;
+        }
+        if (extractTopLevelTables(oc.inner).join("\n") !== extractTopLevelTables(ec.inner).join("\n")) {
+          skip("\uC140 \uB0B4 \uC911\uCCA9\uD45C \uC218\uC815\uC740 HWP5 \uBBF8\uC9C0\uC6D0 (v1)");
+          continue;
+        }
+      }
+      if (origContent.lines.join("\n") !== editedContent.lines.join("\n")) {
+        const newLines = editedContent.lines.map((l) => unescapeGfm(l));
+        applied += applyCellEdit5(table, scanTable, oc.gridR, oc.gridC, newLines, ctx, oc.inner, ec.inner, origContent.lines.length);
+      }
     }
   }
   return applied;
@@ -22544,15 +22626,103 @@ function gfmCellToPlain(md2) {
   let t = md2.trim();
   const bold = t.match(/^\*\*([\s\S]+)\*\*$/);
   if (bold) t = bold[1];
-  if (/[*`]|!\[|\]\(|<(?!br\s*\/?>)/i.test(t)) return null;
+  if (/[*`]|!\[|\]\(/.test(t)) return null;
+  if (/<(?!br\s*\/?>)[a-zA-Z/]/i.test(t)) return null;
   return unescapeGfm(unescapeGfmCell(t));
 }
-var PARA_BREAK = Buffer.from([13, 0]);
+function splitParaText(data) {
+  const toks = [];
+  let i = 0;
+  while (i + 1 < data.length) {
+    const ch = data.readUInt16LE(i);
+    const start = i;
+    i += 2;
+    if (ch >= 32) {
+      let units = 1;
+      if (ch >= 55296 && ch <= 56319 && i + 1 < data.length) {
+        const lo = data.readUInt16LE(i);
+        if (lo >= 56320 && lo <= 57343) {
+          i += 2;
+          units = 2;
+        }
+      }
+      toks.push({ start, end: i, units, plain: true, visible: true });
+      continue;
+    }
+    switch (ch) {
+      case 0:
+      case 24:
+      case 25:
+      case 30:
+      case 31:
+        toks.push({ start, end: i, units: 1, plain: false, visible: true });
+        break;
+      case 9:
+        if (i + 14 <= data.length) i += 14;
+        toks.push({ start, end: i, units: 1, plain: false, visible: true });
+        break;
+      case 13:
+        toks.push({ start, end: i, units: 1, plain: false, visible: false });
+        break;
+      case 10:
+        if (i + 16 <= data.length && data.readUInt16LE(i) === 11) {
+          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 });
+        }
+        break;
+      default: {
+        const ext = isExtendedOnlyCtrlChar(ch);
+        const inl = ch >= 4 && ch <= 9 || ch >= 19 && ch <= 20;
+        if ((ext || inl) && i + 14 <= data.length) i += 14;
+        toks.push({ start, end: i, units: 1, plain: false, visible: false });
+        break;
+      }
+    }
+  }
+  if (i !== data.length) return null;
+  let firstP = -1, lastP = -1;
+  for (let k = 0; k < toks.length; k++) if (toks[k].plain) {
+    if (firstP < 0) firstP = k;
+    lastP = k;
+  }
+  if (firstP < 0) return null;
+  for (let k = firstP; k <= lastP; k++) if (!toks[k].plain) return null;
+  for (let k = 0; k < firstP; k++) if (toks[k].visible) return null;
+  for (let k = lastP + 1; k < toks.length; k++) if (toks[k].visible) return null;
+  const prefixEnd = toks[firstP].start;
+  const coreEnd = toks[lastP].end;
+  const prefixUnits = prefixEnd / 2;
+  const suffixUnits = (data.length - coreEnd) / 2;
+  return {
+    prefix: data.subarray(0, prefixEnd),
+    prefixUnits,
+    core: data.subarray(prefixEnd, coreEnd).toString("utf16le"),
+    suffix: data.subarray(coreEnd),
+    suffixUnits
+  };
+}
+function rebuildCharShape(csData, coreStartUnit) {
+  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 };
+  let coreId = pairs[0][1];
+  for (const [p, id] of pairs) if (p <= coreStartUnit) coreId = id;
+  const kept = pairs.filter(([p]) => p < coreStartUnit);
+  if (kept.length === 0 || kept[kept.length - 1][1] !== coreId) kept.push([coreStartUnit, coreId]);
+  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 };
+}
 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 === -1) return skip("\uBE48 \uBB38\uB2E8 \uD14D\uC2A4\uD2B8 \uCD94\uAC00\uB294 \uBBF8\uC9C0\uC6D0 (v1)");
   if (para.textIdx === -2) return skip("\uBCF5\uC218 PARA_TEXT \uB808\uCF54\uB4DC \uBB38\uB2E8 \u2014 \uBBF8\uC9C0\uC6D0 (v1)");
-  if (para.ctrlMask !== 0) return skip("\uCEE8\uD2B8\uB864 \uBB38\uC790 \uD3EC\uD568 \uBB38\uB2E8(\uD0ED/\uAC1C\uCCB4/\uD544\uB4DC/\uD2B9\uC218\uACF5\uBC31) \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");
@@ -22561,36 +22731,25 @@ function stageParaPatch(scan, para, newPlain, skip) {
   const headerRec = records[para.headerIdx];
   const textRec = records[para.textIdx];
   const charShapeRec = records[para.charShapeIdx];
-  const lineSegRec = records[para.lineSegIdx];
-  if (charShapeRec.data.length < 8 || lineSegRec.data.length < 36) {
-    return skip("CHAR_SHAPE/LINE_SEG \uB808\uCF54\uB4DC \uBE44\uC815\uD615 \u2014 \uBBF8\uC9C0\uC6D0");
+  if (charShapeRec.data.length < 8) {
+    return skip("CHAR_SHAPE \uB808\uCF54\uB4DC \uBE44\uC815\uD615 \u2014 \uBBF8\uC9C0\uC6D0");
+  }
+  const seg = splitParaText(textRec.data);
+  if (!seg) {
+    return skip(para.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");
   }
-  const hadBreak = textRec.data.length >= 2 && textRec.data.readUInt16LE(textRec.data.length - 2) === 13;
-  const expect = hadBreak ? Buffer.concat([Buffer.from(para.rawText, "utf16le"), PARA_BREAK]) : Buffer.from(para.rawText, "utf16le");
-  if (!expect.equals(textRec.data)) return skip("PARA_TEXT \uC7AC\uAD6C\uC131 \uBD88\uC77C\uCE58 \u2014 \uC6D0\uBB38 \uBCF4\uC874 \uBD88\uAC00\uB85C \uBBF8\uC9C0\uC6D0");
+  if (seg.core !== para.rawText) return skip("PARA_TEXT \uC7AC\uAD6C\uC131 \uBD88\uC77C\uCE58 \u2014 \uC6D0\uBB38 \uBCF4\uC874 \uBD88\uAC00\uB85C \uBBF8\uC9C0\uC6D0");
   const lead = para.rawText.match(/^\s*/)[0];
   const trail = para.rawText.match(/\s*$/)[0];
   const newRaw = para.rawText.trim() === para.rawText ? newPlain : lead + newPlain + trail;
-  const newText = hadBreak ? Buffer.concat([Buffer.from(newRaw, "utf16le"), PARA_BREAK]) : Buffer.from(newRaw, "utf16le");
+  const newText = Buffer.concat([seg.prefix, Buffer.from(newRaw, "utf16le"), seg.suffix]);
   scan.repl.set(para.textIdx, newText);
   const newHeader = Buffer.from(headerRec.data);
-  const nChars = newRaw.length + (hadBreak ? 1 : 0);
+  const nChars = seg.prefixUnits + newRaw.length + seg.suffixUnits;
   newHeader.writeUInt32LE((para.nCharsRaw & 2147483648 | nChars) >>> 0, 0);
-  if (charShapeRec.data.length > 8) {
-    newHeader.writeUInt16LE(1, 12);
-    scan.repl.set(para.charShapeIdx, Buffer.from(charShapeRec.data.subarray(0, 8)));
-  }
-  const csData = scan.repl.get(para.charShapeIdx) ?? Buffer.from(charShapeRec.data);
-  if (csData.readUInt32LE(0) !== 0) {
-    csData.writeUInt32LE(0, 0);
-    scan.repl.set(para.charShapeIdx, csData);
-  }
-  if (lineSegRec.data.length > 36 || lineSegRec.data.readUInt32LE(0) !== 0) {
-    const seg = Buffer.from(lineSegRec.data.subarray(0, 36));
-    seg.writeUInt32LE(0, 0);
-    newHeader.writeUInt16LE(1, 16);
-    scan.repl.set(para.lineSegIdx, seg);
-  }
+  const cs = rebuildCharShape(charShapeRec.data, seg.prefixUnits);
+  scan.repl.set(para.charShapeIdx, cs.buf);
+  newHeader.writeUInt16LE(cs.count, 12);
   scan.repl.set(para.headerIdx, newHeader);
   return 1;
 }
@@ -23179,7 +23338,7 @@ async function parseHwp(buffer, options) {
 async function parsePdf(buffer, options) {
   let parsePdfDocument;
   try {
-    const mod = await import("./parser-FLE2ZPAW.js");
+    const mod = await import("./parser-VZL3MK5X.js");
     parsePdfDocument = mod.parsePdfDocument;
   } catch {
     return {