@ansonlai/docx-redline-js 0.10.0 → 0.11.0

package/dist/docx-redline.bundle.cjs

@@ -1,4 +1,4 @@
-// @ansonlai/docx-redline-js standalone CommonJS bundle v0.10.0 — https://github.com/AnsonLai/docx-redline-js
+// @ansonlai/docx-redline-js standalone CommonJS bundle v0.11.0 — https://github.com/AnsonLai/docx-redline-js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -8065,6 +8065,7 @@ __export(index_exports, {
   isLikelyStructuredTableSourceParagraph: () => isLikelyStructuredTableSourceParagraph,
   isMarkdownTableText: () => isMarkdownTableText,
   isNodeVisibleInRevisionView: () => isNodeVisibleInRevisionView,
+  mergeCommentParts: () => mergeCommentParts,
   mergeNumberingParts: () => mergeNumberingParts,
   mergeNumberingXmlBySchemaOrder: () => mergeNumberingXmlBySchemaOrder,
   normalizeBodySectionOrderStandalone: () => normalizeBodySectionOrderStandalone,
@@ -10595,6 +10596,7 @@ function paragraphMarkPPrXml(kind, ctx = {}) {
 }
 
 // services/table-reconciliation.js
+var cellMarkdown = (text2, options) => options?.plainTextContent === true ? { cleanText: String(text2 ?? ""), formatHints: [] } : preprocessMarkdown(text2);
 function generateTableOoxml(tableData, options = {}) {
   const {
     generateRedlines = false,
@@ -10628,7 +10630,7 @@ function generateTableOoxml(tableData, options = {}) {
     let cellsXml = "";
     for (let c = 0; c < numCols; c++) {
       const cellText = row[c] || "";
-      const { cleanText, formatHints } = preprocessMarkdown(cellText);
+      const { cleanText, formatHints } = cellMarkdown(cellText, options);
       const runModel = [{
         kind: generateRedlines ? RunKind.INSERTION : RunKind.TEXT,
         text: cleanText,
@@ -10743,7 +10745,7 @@ function serializeVirtualGridToOoxml(grid, operations, options) {
     let cellsXml = "";
     const rowInsertMeta = generateRedlines ? createRevisionMetadata(author, revisionIdAllocator) : null;
     for (const cellText of op.cells) {
-      const { cleanText, formatHints } = preprocessMarkdown(cellText);
+      const { cleanText, formatHints } = cellMarkdown(cellText, options);
       const runModel = [{
         kind: generateRedlines ? RunKind.INSERTION : RunKind.TEXT,
         text: cleanText,
@@ -10817,7 +10819,7 @@ function reconcileMultiBlockCellContent(cell, newText, options) {
       }
       return;
     }
-    const { cleanText, formatHints } = preprocessMarkdown(line);
+    const { cleanText, formatHints } = cellMarkdown(line, options);
     const diffOps = computeWordLevelDiffOps(block.acceptedText, cleanText);
     const model = applyPatches(splitRunsAtDiffBoundaries(block.runModel, diffOps), diffOps, {
       generateRedlines,
@@ -10827,7 +10829,7 @@ function reconcileMultiBlockCellContent(cell, newText, options) {
     out += serializeToOoxml(model, block.pPr, formatHints, { author, generateRedlines, revisionIdAllocator });
   });
   for (let i2 = cell.blocks.length; i2 < lines.length; i2++) {
-    const { cleanText, formatHints } = preprocessMarkdown(lines[i2]);
+    const { cleanText, formatHints } = cellMarkdown(lines[i2], options);
     const runModel = [{
       kind: generateRedlines ? RunKind.INSERTION : RunKind.TEXT,
       text: cleanText,
@@ -10846,7 +10848,7 @@ function reconcileCellContent(cell, newText, options) {
     return reconcileMultiBlockCellContent(cell, newText, options);
   }
   const { generateRedlines, author, revisionIdAllocator = null } = options;
-  const { cleanText, formatHints } = preprocessMarkdown(newText);
+  const { cleanText, formatHints } = cellMarkdown(newText, options);
   const oldText = cell.getText();
   const diffOps = computeWordLevelDiffOps(oldText, cleanText);
   const baseBlock = cell.blocks[0] || { runModel: [], pPr: null };
@@ -10892,7 +10894,7 @@ function parseTable(text2) {
   }
   const isSeparatorLine = (line) => {
     const normalized = line.replace(/\s+/g, "");
-    return /^\|:?-{3,}:?(\|:?-{3,}:?)+\|?$/.test(normalized);
+    return /^\|:?-{3,}:?(?:(\|:?-{3,}:?)+\|?|\|)$/.test(normalized);
   };
   const hasHeader = lines.some(isSeparatorLine);
   const dataLines = lines.filter((line) => !isSeparatorLine(line));
@@ -11476,7 +11478,7 @@ var ReconciliationPipeline = class {
 };
 
 // pipeline/structured-content.js
-var TABLE_SEPARATOR = /^\s*\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)+\|?\s*$/;
+var TABLE_SEPARATOR = /^\s*(?:\|\s*:?-{3,}:?\s*\||\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)+\|?)\s*$/;
 function isBlank(line) {
   return !line || line.trim().length === 0;
 }
@@ -15133,7 +15135,7 @@ function keepUnchangedTextOutsideWrappers(diffs, mapping) {
 function noChanges(serializer, xmlDoc) {
   return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: false });
 }
-function applyTableReconciliation(xmlDoc, modifiedText, serializer, parser, author, generateRedlines = true) {
+function applyTableReconciliation(xmlDoc, modifiedText, serializer, parser, author, generateRedlines = true, extra = {}) {
   const tableNodes = getElementsByTagNSOrTag(xmlDoc, NS_W, "tbl");
   const newTableData = parseTable(modifiedText);
   const hasNewContent = newTableData.rows.length > 0 || newTableData.headers.length > 0;
@@ -15149,7 +15151,8 @@ function applyTableReconciliation(xmlDoc, modifiedText, serializer, parser, auth
   const options = {
     generateRedlines,
     author,
-    revisionIdAllocator: getRevisionIdAllocatorForDocument(xmlDoc)
+    revisionIdAllocator: getRevisionIdAllocatorForDocument(xmlDoc),
+    plainTextContent: extra.plainTextContent === true
   };
   const reconciledOxml = serializeVirtualGridToOoxml(oldGrid, operations, options);
   const wrappedOxml = `<root xmlns:w="${NS_W}">${reconciledOxml}</root>`;
@@ -15169,14 +15172,14 @@ function applyTableReconciliation(xmlDoc, modifiedText, serializer, parser, auth
   targetTable.parentNode.replaceChild(importedTable, targetTable);
   return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: true });
 }
-function applyTextToTableTransformation(xmlDoc, modifiedText, serializer, parser, author, generateRedlines) {
+function applyTextToTableTransformation(xmlDoc, modifiedText, serializer, parser, author, generateRedlines, extra = {}) {
   const revisionIdAllocator = getRevisionIdAllocatorForDocument(xmlDoc);
   const tableData = parseTable(modifiedText);
   if (!tableData || tableData.rows.length === 0 && tableData.headers.length === 0) {
     log("[OxmlEngine] Failed to parse table data from Markdown");
     return noChanges(serializer, xmlDoc);
   }
-  const tableOoxml = generateTableOoxml(tableData, { generateRedlines, author, revisionIdAllocator, trackAsBlock: true });
+  const tableOoxml = generateTableOoxml(tableData, { generateRedlines, author, revisionIdAllocator, trackAsBlock: true, plainTextContent: extra.plainTextContent === true });
   const tableDoc = parseOoxmlSafe(`<root xmlns:w="${NS_W}">${tableOoxml}</root>`, "application/xml").doc;
   if (!tableDoc) return noChanges(serializer, xmlDoc);
   const tableParseError = getXmlParseError(tableDoc);
@@ -16375,11 +16378,11 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
     if (isMarkdownTable && !hasTables) {
       recordRouteSelection(options, "table", { transformation: "text-to-table" });
       log("[OxmlEngine] Text-to-table transformation: generating new table from Markdown");
-      return finalize(applyTextToTableTransformation(xmlDoc, cleanModifiedText, serializer, null, author, generateRedlines));
+      return finalize(applyTextToTableTransformation(xmlDoc, cleanModifiedText, serializer, null, author, generateRedlines, { plainTextContent: options.plainTextContent === true }));
     }
     if (hasTables && isMarkdownTable) {
       recordRouteSelection(options, "table", { transformation: "table-reconciliation" });
-      return finalize(applyTableReconciliation(xmlDoc, cleanModifiedText, serializer, null, author, generateRedlines));
+      return finalize(applyTableReconciliation(xmlDoc, cleanModifiedText, serializer, null, author, generateRedlines, { plainTextContent: options.plainTextContent === true }));
     }
     if (usesSurgicalTextMode) {
       recordRouteSelection(options, "surgical", { tableScoped: hasTables });
@@ -20675,232 +20678,6 @@ function applyCommentReplyToParts({ commentsXml, commentsExtendedXml = null, doc
   };
 }
 
-// engine/formatting-removal.js
-function removeNode2(node) {
-  if (node?.parentNode) {
-    node.parentNode.removeChild(node);
-  }
-}
-function removeFormattingFromRPr(rPr, formatTypes = ["all"]) {
-  if (!rPr) return null;
-  const rPrClone = rPr.cloneNode(true);
-  if (formatTypes.includes("all")) {
-    const toRemove = [
-      "w:b",
-      "w:i",
-      "w:u",
-      "w:strike",
-      "w:dstrike",
-      "w:color",
-      "w:sz",
-      "w:szCs",
-      "w:rFonts",
-      "w:highlight",
-      "w:vertAlign",
-      "w:spacing",
-      "w:w",
-      "w:kern",
-      "w:position"
-    ];
-    toRemove.forEach((tag) => {
-      const elements = rPrClone.querySelectorAll(`${tag}, ${tag.replace("w:", "")}`);
-      elements.forEach(removeNode2);
-    });
-  } else {
-    const tagMap = {
-      "bold": "w:b",
-      "italic": "w:i",
-      "underline": "w:u",
-      "strikethrough": "w:strike",
-      "doubleStrike": "w:dstrike",
-      "color": "w:color",
-      "highlight": "w:highlight",
-      "fontSize": "w:sz",
-      "fontSizeCs": "w:szCs",
-      // Complex script font size
-      "fontFamily": "w:rFonts",
-      "superscript": "w:vertAlign",
-      "subscript": "w:vertAlign"
-    };
-    formatTypes.forEach((type) => {
-      const tag = tagMap[type];
-      if (tag) {
-        const elements = rPrClone.querySelectorAll(`${tag}, ${tag.replace("w:", "")}`);
-        elements.forEach(removeNode2);
-      }
-    });
-  }
-  return rPrClone.children.length > 0 ? rPrClone : null;
-}
-function applyFormattingRemovalToOoxml(ooxmlString, targetText, formatTypes) {
-  if (!targetText || !ooxmlString) return ooxmlString;
-  const doc = parseOoxml(ooxmlString);
-  if (!doc) return ooxmlString;
-  const NS_W11 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-  const runs = doc.getElementsByTagNameNS(NS_W11, "r");
-  const insertions = doc.getElementsByTagNameNS(NS_W11, "ins");
-  const allRuns = [...Array.from(runs)];
-  for (const ins of insertions) {
-    const insideRuns = ins.getElementsByTagNameNS(NS_W11, "r");
-    allRuns.push(...Array.from(insideRuns));
-  }
-  for (const run of allRuns) {
-    const textNodes = run.getElementsByTagNameNS(NS_W11, "t");
-    const runText = Array.from(textNodes).map((t) => t.textContent).join("");
-    if (runText.includes(targetText) || runText === targetText) {
-      const rPrElements = run.getElementsByTagNameNS(NS_W11, "rPr");
-      if (rPrElements.length > 0) {
-        const rPr = rPrElements[0];
-        const newRPr = removeFormattingFromRPr(rPr, formatTypes);
-        if (newRPr) {
-          if (rPr.parentNode) {
-            rPr.parentNode.replaceChild(newRPr, rPr);
-          }
-        } else {
-          removeNode2(rPr);
-        }
-      }
-    }
-  }
-  return serializeOoxml(doc);
-}
-var HIGHLIGHT_COLOR_MAP = {
-  "yellow": "yellow",
-  "green": "green",
-  "cyan": "cyan",
-  "magenta": "magenta",
-  "blue": "blue",
-  "red": "red",
-  "darkblue": "darkBlue",
-  "darkcyan": "darkCyan",
-  "darkgreen": "darkGreen",
-  "darkmagenta": "darkMagenta",
-  "darkred": "darkRed",
-  "darkyellow": "darkYellow",
-  "gray25": "lightGray",
-  "gray50": "darkGray",
-  "black": "black",
-  "white": "white"
-};
-function injectHighlightIntoRPr(doc, rPr, color = "yellow", options = {}) {
-  const NS_W11 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-  const ooxmlColor = HIGHLIGHT_COLOR_MAP[color.toLowerCase()] || "yellow";
-  const generateRedlines = options?.generateRedlines ?? false;
-  const author = options?.author || getDefaultAuthor();
-  let rPrElement = rPr;
-  if (!rPrElement) {
-    rPrElement = createWordElement(doc, "w:rPr");
-  } else {
-    rPrElement = rPr.cloneNode(true);
-  }
-  let previousRPrState = null;
-  if (generateRedlines) {
-    previousRPrState = createWordElement(doc, "w:rPr");
-    Array.from(rPrElement.childNodes).forEach((child) => {
-      if (child.nodeName !== "w:rPrChange") {
-        previousRPrState.appendChild(child.cloneNode(true));
-      }
-    });
-  }
-  const existingHighlight = rPrElement.getElementsByTagNameNS(NS_W11, "highlight");
-  Array.from(existingHighlight).forEach(removeNode2);
-  const highlightEl = createWordElement(doc, "w:highlight");
-  highlightEl.setAttributeNS(NS_W11, "w:val", ooxmlColor);
-  rPrElement.appendChild(highlightEl);
-  if (generateRedlines && previousRPrState) {
-    const rPrChange = createWordElement(doc, "w:rPrChange");
-    const metadata = createRevisionMetadata(author, doc);
-    rPrChange.setAttribute("w:id", String(metadata.id));
-    rPrChange.setAttribute("w:author", metadata.author);
-    rPrChange.setAttribute("w:date", metadata.date);
-    rPrChange.appendChild(previousRPrState);
-    const existingChange = rPrElement.getElementsByTagNameNS(NS_W11, "rPrChange");
-    Array.from(existingChange).forEach(removeNode2);
-    rPrElement.appendChild(rPrChange);
-  }
-  return rPrElement;
-}
-function applyHighlightToOoxml(ooxmlString, targetText, color = "yellow", options = {}) {
-  if (!targetText || !ooxmlString) return ooxmlString;
-  const doc = parseOoxml(ooxmlString);
-  if (!doc) return ooxmlString;
-  let revisionIdAllocator;
-  if (options?._revisionIdAllocator instanceof RevisionIdAllocator) {
-    revisionIdAllocator = options._revisionIdAllocator;
-    seedRevisionIdsFromDocument(doc, revisionIdAllocator);
-  } else {
-    revisionIdAllocator = createRevisionIdAllocator(doc);
-  }
-  const NS_W11 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-  const getRunText = (run) => {
-    const textNodes = run.getElementsByTagNameNS(NS_W11, "t");
-    return Array.from(textNodes).map((t) => t.textContent).join("");
-  };
-  const allRuns = Array.from(doc.getElementsByTagNameNS(NS_W11, "r"));
-  const sourceRunsWithClaimedRevisionIds = /* @__PURE__ */ new WeakSet();
-  const cloneRunWithText2 = (sourceRun, text2, shouldHighlight) => {
-    const clonedRun = sourceRun.cloneNode(true);
-    if (sourceRunsWithClaimedRevisionIds.has(sourceRun)) {
-      refreshRunPropertyChangeIds(clonedRun, revisionIdAllocator);
-    } else {
-      sourceRunsWithClaimedRevisionIds.add(sourceRun);
-    }
-    const textNodes = clonedRun.getElementsByTagNameNS(NS_W11, "t");
-    Array.from(textNodes).forEach(removeNode2);
-    const newText = createWordElement(doc, "w:t");
-    newText.setAttribute("xml:space", "preserve");
-    newText.textContent = text2;
-    clonedRun.appendChild(newText);
-    if (shouldHighlight) {
-      const rPrElements = clonedRun.getElementsByTagNameNS(NS_W11, "rPr");
-      const existingRPr = rPrElements.length > 0 ? rPrElements[0] : null;
-      const newRPr = injectHighlightIntoRPr(doc, existingRPr, color, options);
-      if (existingRPr) {
-        clonedRun.replaceChild(newRPr, existingRPr);
-      } else {
-        clonedRun.insertBefore(newRPr, clonedRun.firstChild);
-      }
-    }
-    return clonedRun;
-  };
-  for (const run of allRuns) {
-    const runText = getRunText(run);
-    if (!runText) continue;
-    const matchIndexes = [];
-    let searchOffset = 0;
-    while (searchOffset <= runText.length - targetText.length) {
-      const matchIndex = runText.indexOf(targetText, searchOffset);
-      if (matchIndex === -1) break;
-      matchIndexes.push(matchIndex);
-      searchOffset = matchIndex + targetText.length;
-    }
-    if (matchIndexes.length === 0) continue;
-    const parent = run.parentNode;
-    if (!parent) {
-      console.warn("[Highlight] Run parent is null; skipping. Likely already processed.");
-      continue;
-    }
-    const fragment = doc.createDocumentFragment();
-    let cursor = 0;
-    for (const matchIndex of matchIndexes) {
-      if (matchIndex > cursor) {
-        fragment.appendChild(cloneRunWithText2(run, runText.slice(cursor, matchIndex), false));
-      }
-      fragment.appendChild(cloneRunWithText2(
-        run,
-        runText.slice(matchIndex, matchIndex + targetText.length),
-        true
-      ));
-      cursor = matchIndex + targetText.length;
-    }
-    if (cursor < runText.length) {
-      fragment.appendChild(cloneRunWithText2(run, runText.slice(cursor), false));
-    }
-    parent.replaceChild(fragment, run);
-  }
-  return serializeOoxml(doc);
-}
-
 // services/package-parts.js
 var WORD_ML = "application/vnd.openxmlformats-officedocument.wordprocessingml";
 var REL_OFFICE_DOC = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
@@ -21188,31 +20965,34 @@ async function ensureNumberingArtifactsInZip(zip, numberingXmlList, options = {}
     }
   }
 }
+function mergeCommentsPartXml(existingXml, commentsXml, options = {}) {
+  if (!existingXml || options.replaceExisting === true) return commentsXml;
+  const existingDoc = parseXmlStrictStandalone(existingXml, "word/comments.xml (existing)");
+  const incomingDoc = parseXmlStrictStandalone(commentsXml, "word/comments.xml (incoming)");
+  const incomingComments = Array.from(incomingDoc.documentElement.getElementsByTagNameNS(NS_W7, "comment"));
+  if (incomingComments.length === 0) return existingXml;
+  const existingRoot = existingDoc.documentElement;
+  const usedIds = new Set(
+    Array.from(existingRoot.getElementsByTagNameNS(NS_W7, "comment")).map((comment) => comment.getAttribute("w:id") || comment.getAttribute("id")).filter(Boolean)
+  );
+  for (const incomingComment of incomingComments) {
+    const id = incomingComment.getAttribute("w:id") || incomingComment.getAttribute("id");
+    if (id && usedIds.has(id)) {
+      throw Object.assign(new Error(`Duplicate comment id: ${id}`), { code: "DUPLICATE_COMMENT_ID", commentId: id });
+    }
+    if (id) usedIds.add(id);
+    existingRoot.appendChild(existingDoc.importNode(incomingComment, true));
+  }
+  return createSerializer().serializeToString(existingDoc);
+}
 async function ensureCommentsArtifactsInZip(zip, commentsXml, options = {}) {
   const onInfo = typeof options?.onInfo === "function" ? options.onInfo : () => {
   };
   if (!commentsXml) return;
   const serializer = createSerializer();
   const existingText = await readZipText(zip, COMMENTS_PATH);
-  if (!existingText || options.replaceExisting === true) {
-    onInfo("[Demo] Adding comments.xml");
-    zip.file(COMMENTS_PATH, commentsXml);
-  } else {
-    const existingDoc = parseXmlStrictStandalone(existingText, "word/comments.xml (existing)");
-    const incomingDoc = parseXmlStrictStandalone(commentsXml, "word/comments.xml (incoming)");
-    const existingRoot = existingDoc.documentElement;
-    const existingIds = new Set(
-      Array.from(existingRoot.getElementsByTagNameNS(NS_W7, "comment")).map((comment) => comment.getAttribute("w:id") || comment.getAttribute("id")).filter(Boolean)
-    );
-    for (const incomingComment of Array.from(incomingDoc.documentElement.getElementsByTagNameNS(NS_W7, "comment"))) {
-      const id = incomingComment.getAttribute("w:id") || incomingComment.getAttribute("id");
-      if (id && existingIds.has(id)) {
-        throw new Error(`Duplicate comment id: ${id}`);
-      }
-      existingRoot.appendChild(existingDoc.importNode(incomingComment, true));
-    }
-    zip.file(COMMENTS_PATH, serializer.serializeToString(existingDoc));
-  }
+  if (!existingText || options.replaceExisting === true) onInfo("[Demo] Adding comments.xml");
+  zip.file(COMMENTS_PATH, mergeCommentsPartXml(existingText, commentsXml, options));
   const ctText = await readZipText(zip, CONTENT_TYPES_PATH);
   if (ctText) {
     const ctDoc = parseXmlStrictStandalone(ctText, CONTENT_TYPES_PATH);
@@ -21448,6 +21228,318 @@ async function validateDocxPackage(zip) {
   }
 }
 
+// services/comment-parts-merge.js
+var PART_KEYS = Object.freeze({
+  comments: "commentsXml",
+  commentsExtended: "commentsExtendedXml",
+  commentsIds: "commentsIdsXml",
+  commentsExtensible: "commentsExtensibleXml"
+});
+var partsOf = (parts) => Object.fromEntries(Object.values(PART_KEYS).map((key) => [key, parts?.[key] || null]));
+function mergeCommentParts(parts = {}, output = {}) {
+  const before = partsOf(parts);
+  const after = { ...before };
+  const fail = (error2) => ({ status: "error", hasChanges: false, parts: before, changedParts: [], addedParts: [], error: error2 });
+  const commentsMode = output?.commentsXmlMode === "replace" ? "replace" : "merge";
+  const extendedMode = output?.commentsExtendedXmlMode === "replace" ? "replace" : "merge";
+  for (const [label, value] of [
+    ...Object.values(PART_KEYS).map((key) => [`parts.${key}`, before[key]]),
+    ["output.commentsXml", output?.commentsXml],
+    ["output.commentsExtendedXml", output?.commentsExtendedXml]
+  ]) {
+    if (value != null && typeof value !== "string") {
+      return fail({ code: "INVALID_COMMENT_PARTS", message: `${label} must be an XML string, null or omitted (got ${typeof value}).` });
+    }
+  }
+  const requirePart = (xml, part, rootName, label) => {
+    let doc;
+    try {
+      doc = parseXmlStrictStandalone(xml, label);
+    } catch (error2) {
+      throw Object.assign(error2, { part });
+    }
+    if (doc.documentElement?.localName !== rootName) {
+      throw Object.assign(new Error(`${label}: expected a <${rootName}> root element, found <${doc.documentElement?.localName || "none"}>.`), { code: "INVALID_COMMENT_PARTS", part });
+    }
+    return doc;
+  };
+  try {
+    if (output?.commentsXml) {
+      const incomingDoc = requirePart(output.commentsXml, "comments", "comments", "word/comments.xml (incoming)");
+      const seen = /* @__PURE__ */ new Set();
+      for (const node of Array.from(incomingDoc.getElementsByTagNameNS("*", "comment"))) {
+        const id = node.getAttribute("w:id") || node.getAttribute("id");
+        if (!id) continue;
+        if (seen.has(id)) {
+          throw Object.assign(new Error(`Duplicate comment id: ${id}`), { code: "DUPLICATE_COMMENT_ID", commentId: id, part: "comments" });
+        }
+        seen.add(id);
+      }
+      if (before.commentsXml) requirePart(before.commentsXml, "comments", "comments", "word/comments.xml (existing)");
+      if (before.commentsIdsXml) requirePart(before.commentsIdsXml, "commentsIds", "commentsIds", "word/commentsIds.xml (existing)");
+      if (before.commentsExtensibleXml) requirePart(before.commentsExtensibleXml, "commentsExtensible", "commentsExtensible", "word/commentsExtensible.xml (existing)");
+      after.commentsXml = mergeCommentsPartXml(before.commentsXml, output.commentsXml, { replaceExisting: commentsMode === "replace" });
+      Object.assign(after, reconcileCommentSiblingParts({
+        commentsXml: after.commentsXml,
+        commentsIdsXml: after.commentsIdsXml,
+        commentsExtensibleXml: after.commentsExtensibleXml
+      }));
+    }
+    if (output?.commentsExtendedXml) {
+      if (extendedMode !== "replace" && before.commentsExtendedXml) {
+        return fail({
+          code: "UNSUPPORTED_EXISTING_COMMENT_THREAD_METADATA",
+          part: "commentsExtended",
+          message: 'The output carries a commentsExtended delta (mode "merge") for parts that already have thread metadata; a delta cannot be merged into an existing commentsExtended.xml. Nothing was merged.'
+        });
+      }
+      requirePart(output.commentsExtendedXml, "commentsExtended", "commentsEx", "word/commentsExtended.xml (incoming)");
+      after.commentsExtendedXml = output.commentsExtendedXml;
+    }
+  } catch (error2) {
+    return fail({
+      code: error2?.code || "COMMENT_PARTS_MERGE_FAILED",
+      message: error2?.message || String(error2),
+      ...error2?.part || error2?.code === "DUPLICATE_COMMENT_ID" ? { part: error2.part || "comments" } : {},
+      ...error2?.commentId ? { commentId: error2.commentId } : {}
+    });
+  }
+  const changedParts = [];
+  const addedParts = [];
+  for (const [name, key] of Object.entries(PART_KEYS)) {
+    if (after[key] === before[key]) continue;
+    changedParts.push(name);
+    if (!before[key]) addedParts.push(name);
+  }
+  return { status: "ok", hasChanges: changedParts.length > 0, parts: after, changedParts, addedParts };
+}
+
+// engine/formatting-removal.js
+function removeNode2(node) {
+  if (node?.parentNode) {
+    node.parentNode.removeChild(node);
+  }
+}
+function removeFormattingFromRPr(rPr, formatTypes = ["all"]) {
+  if (!rPr) return null;
+  const rPrClone = rPr.cloneNode(true);
+  if (formatTypes.includes("all")) {
+    const toRemove = [
+      "w:b",
+      "w:i",
+      "w:u",
+      "w:strike",
+      "w:dstrike",
+      "w:color",
+      "w:sz",
+      "w:szCs",
+      "w:rFonts",
+      "w:highlight",
+      "w:vertAlign",
+      "w:spacing",
+      "w:w",
+      "w:kern",
+      "w:position"
+    ];
+    toRemove.forEach((tag) => {
+      const elements = rPrClone.querySelectorAll(`${tag}, ${tag.replace("w:", "")}`);
+      elements.forEach(removeNode2);
+    });
+  } else {
+    const tagMap = {
+      "bold": "w:b",
+      "italic": "w:i",
+      "underline": "w:u",
+      "strikethrough": "w:strike",
+      "doubleStrike": "w:dstrike",
+      "color": "w:color",
+      "highlight": "w:highlight",
+      "fontSize": "w:sz",
+      "fontSizeCs": "w:szCs",
+      // Complex script font size
+      "fontFamily": "w:rFonts",
+      "superscript": "w:vertAlign",
+      "subscript": "w:vertAlign"
+    };
+    formatTypes.forEach((type) => {
+      const tag = tagMap[type];
+      if (tag) {
+        const elements = rPrClone.querySelectorAll(`${tag}, ${tag.replace("w:", "")}`);
+        elements.forEach(removeNode2);
+      }
+    });
+  }
+  return rPrClone.children.length > 0 ? rPrClone : null;
+}
+function applyFormattingRemovalToOoxml(ooxmlString, targetText, formatTypes) {
+  if (!targetText || !ooxmlString) return ooxmlString;
+  const doc = parseOoxml(ooxmlString);
+  if (!doc) return ooxmlString;
+  const NS_W11 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+  const runs = doc.getElementsByTagNameNS(NS_W11, "r");
+  const insertions = doc.getElementsByTagNameNS(NS_W11, "ins");
+  const allRuns = [...Array.from(runs)];
+  for (const ins of insertions) {
+    const insideRuns = ins.getElementsByTagNameNS(NS_W11, "r");
+    allRuns.push(...Array.from(insideRuns));
+  }
+  for (const run of allRuns) {
+    const textNodes = run.getElementsByTagNameNS(NS_W11, "t");
+    const runText = Array.from(textNodes).map((t) => t.textContent).join("");
+    if (runText.includes(targetText) || runText === targetText) {
+      const rPrElements = run.getElementsByTagNameNS(NS_W11, "rPr");
+      if (rPrElements.length > 0) {
+        const rPr = rPrElements[0];
+        const newRPr = removeFormattingFromRPr(rPr, formatTypes);
+        if (newRPr) {
+          if (rPr.parentNode) {
+            rPr.parentNode.replaceChild(newRPr, rPr);
+          }
+        } else {
+          removeNode2(rPr);
+        }
+      }
+    }
+  }
+  return serializeOoxml(doc);
+}
+var HIGHLIGHT_COLOR_MAP = {
+  "yellow": "yellow",
+  "green": "green",
+  "cyan": "cyan",
+  "magenta": "magenta",
+  "blue": "blue",
+  "red": "red",
+  "darkblue": "darkBlue",
+  "darkcyan": "darkCyan",
+  "darkgreen": "darkGreen",
+  "darkmagenta": "darkMagenta",
+  "darkred": "darkRed",
+  "darkyellow": "darkYellow",
+  "gray25": "lightGray",
+  "gray50": "darkGray",
+  "black": "black",
+  "white": "white"
+};
+function injectHighlightIntoRPr(doc, rPr, color = "yellow", options = {}) {
+  const NS_W11 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+  const ooxmlColor = HIGHLIGHT_COLOR_MAP[color.toLowerCase()] || "yellow";
+  const generateRedlines = options?.generateRedlines ?? false;
+  const author = options?.author || getDefaultAuthor();
+  let rPrElement = rPr;
+  if (!rPrElement) {
+    rPrElement = createWordElement(doc, "w:rPr");
+  } else {
+    rPrElement = rPr.cloneNode(true);
+  }
+  let previousRPrState = null;
+  if (generateRedlines) {
+    previousRPrState = createWordElement(doc, "w:rPr");
+    Array.from(rPrElement.childNodes).forEach((child) => {
+      if (child.nodeName !== "w:rPrChange") {
+        previousRPrState.appendChild(child.cloneNode(true));
+      }
+    });
+  }
+  const existingHighlight = rPrElement.getElementsByTagNameNS(NS_W11, "highlight");
+  Array.from(existingHighlight).forEach(removeNode2);
+  const highlightEl = createWordElement(doc, "w:highlight");
+  highlightEl.setAttributeNS(NS_W11, "w:val", ooxmlColor);
+  rPrElement.appendChild(highlightEl);
+  if (generateRedlines && previousRPrState) {
+    const rPrChange = createWordElement(doc, "w:rPrChange");
+    const metadata = createRevisionMetadata(author, doc);
+    rPrChange.setAttribute("w:id", String(metadata.id));
+    rPrChange.setAttribute("w:author", metadata.author);
+    rPrChange.setAttribute("w:date", metadata.date);
+    rPrChange.appendChild(previousRPrState);
+    const existingChange = rPrElement.getElementsByTagNameNS(NS_W11, "rPrChange");
+    Array.from(existingChange).forEach(removeNode2);
+    rPrElement.appendChild(rPrChange);
+  }
+  return rPrElement;
+}
+function applyHighlightToOoxml(ooxmlString, targetText, color = "yellow", options = {}) {
+  if (!targetText || !ooxmlString) return ooxmlString;
+  const doc = parseOoxml(ooxmlString);
+  if (!doc) return ooxmlString;
+  let revisionIdAllocator;
+  if (options?._revisionIdAllocator instanceof RevisionIdAllocator) {
+    revisionIdAllocator = options._revisionIdAllocator;
+    seedRevisionIdsFromDocument(doc, revisionIdAllocator);
+  } else {
+    revisionIdAllocator = createRevisionIdAllocator(doc);
+  }
+  const NS_W11 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+  const getRunText = (run) => {
+    const textNodes = run.getElementsByTagNameNS(NS_W11, "t");
+    return Array.from(textNodes).map((t) => t.textContent).join("");
+  };
+  const allRuns = Array.from(doc.getElementsByTagNameNS(NS_W11, "r"));
+  const sourceRunsWithClaimedRevisionIds = /* @__PURE__ */ new WeakSet();
+  const cloneRunWithText2 = (sourceRun, text2, shouldHighlight) => {
+    const clonedRun = sourceRun.cloneNode(true);
+    if (sourceRunsWithClaimedRevisionIds.has(sourceRun)) {
+      refreshRunPropertyChangeIds(clonedRun, revisionIdAllocator);
+    } else {
+      sourceRunsWithClaimedRevisionIds.add(sourceRun);
+    }
+    const textNodes = clonedRun.getElementsByTagNameNS(NS_W11, "t");
+    Array.from(textNodes).forEach(removeNode2);
+    const newText = createWordElement(doc, "w:t");
+    newText.setAttribute("xml:space", "preserve");
+    newText.textContent = text2;
+    clonedRun.appendChild(newText);
+    if (shouldHighlight) {
+      const rPrElements = clonedRun.getElementsByTagNameNS(NS_W11, "rPr");
+      const existingRPr = rPrElements.length > 0 ? rPrElements[0] : null;
+      const newRPr = injectHighlightIntoRPr(doc, existingRPr, color, options);
+      if (existingRPr) {
+        clonedRun.replaceChild(newRPr, existingRPr);
+      } else {
+        clonedRun.insertBefore(newRPr, clonedRun.firstChild);
+      }
+    }
+    return clonedRun;
+  };
+  for (const run of allRuns) {
+    const runText = getRunText(run);
+    if (!runText) continue;
+    const matchIndexes = [];
+    let searchOffset = 0;
+    while (searchOffset <= runText.length - targetText.length) {
+      const matchIndex = runText.indexOf(targetText, searchOffset);
+      if (matchIndex === -1) break;
+      matchIndexes.push(matchIndex);
+      searchOffset = matchIndex + targetText.length;
+    }
+    if (matchIndexes.length === 0) continue;
+    const parent = run.parentNode;
+    if (!parent) {
+      console.warn("[Highlight] Run parent is null; skipping. Likely already processed.");
+      continue;
+    }
+    const fragment = doc.createDocumentFragment();
+    let cursor = 0;
+    for (const matchIndex of matchIndexes) {
+      if (matchIndex > cursor) {
+        fragment.appendChild(cloneRunWithText2(run, runText.slice(cursor, matchIndex), false));
+      }
+      fragment.appendChild(cloneRunWithText2(
+        run,
+        runText.slice(matchIndex, matchIndex + targetText.length),
+        true
+      ));
+      cursor = matchIndex + targetText.length;
+    }
+    if (cursor < runText.length) {
+      fragment.appendChild(cloneRunWithText2(run, runText.slice(cursor), false));
+    }
+    parent.replaceChild(fragment, run);
+  }
+  return serializeOoxml(doc);
+}
+
 // orchestration/route-plan.js
 var RoutePlanKind = Object.freeze({
   STRUCTURED_LIST_DIRECT: "structured_list_direct",
@@ -25152,7 +25244,7 @@ function deriveParagraphThenTableAppend(modifiedText) {
   const tableLines = lines.slice(1);
   if (!tableLines.every((line) => line.trim().startsWith("|"))) return null;
   const separator = tableLines[1].replace(/\s+/g, "");
-  if (!/^\|:?-{3,}:?(\|:?-{3,}:?)+\|?$/.test(separator)) return null;
+  if (!/^\|:?-{3,}:?(?:(\|:?-{3,}:?)+\|?|\|)$/.test(separator)) return null;
   return { paragraphMarkdown: lines[0].trim(), tableText: tableLines.join("\n") };
 }
 
@@ -25782,7 +25874,10 @@ async function buildInsertedPlainParagraph(xmlDoc, anchorParagraph, text2, revis
     String(text2 || ""),
     {
       author,
-      generateRedlines: false
+      generateRedlines: false,
+      // A caller's structuredContent: false keeps inserted paragraphs plain too: no headings,
+      // and inline Markdown markers stay literal.
+      ...options.plainTextContent === true ? { structuredContent: false, plainTextContent: true } : {}
     }
   );
   let sourceParagraph = null;
@@ -27308,7 +27403,7 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
         author,
         // A wholly inserted paragraph must track its own paragraph mark; otherwise Word's
         // Reject All removes the text but leaves an empty paragraph behind.
-        { generateRedlines, trackParagraphMark: true }
+        { generateRedlines, trackParagraphMark: true, plainTextContent: options.plainTextContent === true }
       );
       const imported = xmlDoc.importNode(plainParagraph, true);
       ensureParagraphIdsOnImportedNode(imported, operationSession);
@@ -27447,6 +27542,7 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
     existingRevisions: options.existingRevisions || "merge-same-author",
     structuredContent: options.structuredContent !== false,
     explicitStructuredContent: options.explicitStructuredContent === true,
+    plainTextContent: options.plainTextContent === true,
     _revisionIdAllocator: revisionIdAllocator,
     _isolatedTableCell: useTableScope
   }) : await applyRedlineToOxml2(scopedXml, originalTextForApply, effectiveModifiedText, {