@portone/docx-editor 0.2.0 → 0.2.1

package/dist/docx/comments/reading.d.ts

@@ -41,11 +41,13 @@ export interface ImportedCommentExtension {
     resolved: boolean;
     xml: string;
 }
+/** The thread key of a comment, which the writer puts on the last paragraph of its body */
+export declare function lastParagraphId(comment: Element): string | null;
 /**
  * Reads the Comments part related from the main document story.
  *
- * The people part is read whether or not there are comments: a document may carry one with no
- * comment left, and a comment added to it then has to be recorded in that part rather than in a
- * second one.
+ * The people part and the extended part are read whether or not there are comments: a document may
+ * carry either with no comment left, and a comment added to it then has to be written into the
+ * part it already has rather than into a second one beside it.
  */
 export declare function readComments(parts: Map<string, Uint8Array>, mainPartPath: string): ImportedComments;

package/dist/docx/comments/reading.js

@@ -1,5 +1,6 @@
 // src/docx/comments/reading.ts
 import {
+  attributeByLocalName,
   decodeUtf8,
   elementChildren,
   parseXml,
@@ -8,14 +9,12 @@ import {
 } from "../../ooxml/xml.js";
 import { readRelationships, relsPathOf, resolveTarget } from "../relationships.js";
 import { COMMENTS_EXTENDED_REL_TYPE, COMMENTS_REL_TYPE } from "./constants.js";
+import { lastBodyParagraph } from "./grammar.js";
 import {
   commentAuthorId,
   NO_PEOPLE,
   readPeople
 } from "./people.js";
-function attribute(el, localName) {
-  return Array.from(el.attributes).find((entry) => entry.localName === localName)?.value ?? null;
-}
 function inlineCommentText(node) {
   if (node.localName === "t") return node.textContent ?? "";
   if (node.localName === "tab") return "	";
@@ -40,8 +39,8 @@ var NO_COMMENTS = {
   people: NO_PEOPLE
 };
 function lastParagraphId(comment) {
-  const paragraphs = Array.from(comment.getElementsByTagNameNS(W_NS, "p"));
-  return paragraphs.length === 0 ? null : attribute(paragraphs[paragraphs.length - 1], "paraId");
+  const last = lastBodyParagraph(comment);
+  return last === null ? null : attributeByLocalName(last, "paraId");
 }
 function readCommentExtensions(parts, mainPartPath) {
   const relationship = readRelationships(parts, relsPathOf(mainPartPath)).find(
@@ -73,13 +72,13 @@ function readCommentExtensions(parts, mainPartPath) {
   const ordered = [];
   for (const el of elementChildren(root)) {
     if (el.localName !== "commentEx") continue;
-    const paraId = attribute(el, "paraId");
+    const paraId = attributeByLocalName(el, "paraId");
     if (paraId === null) continue;
     const extension = {
       paraId,
-      parentParaId: attribute(el, "paraIdParent"),
+      parentParaId: attributeByLocalName(el, "paraIdParent"),
       resolved: ["1", "true", "on"].includes(
-        attribute(el, "done")?.toLowerCase() ?? ""
+        attributeByLocalName(el, "done")?.toLowerCase() ?? ""
       ),
       xml: serializeXml(el)
     };
@@ -90,29 +89,36 @@ function readCommentExtensions(parts, mainPartPath) {
 }
 function readComments(parts, mainPartPath) {
   const people = readPeople(parts, mainPartPath);
+  const extensions = readCommentExtensions(parts, mainPartPath);
+  const aside = {
+    people,
+    extendedPartPath: extensions.partPath,
+    extendedXml: extensions.xml,
+    extendedHadBom: extensions.hadBom,
+    extendedOrdered: extensions.ordered
+  };
   const relationship = readRelationships(parts, relsPathOf(mainPartPath)).find(
     (entry) => entry.type === COMMENTS_REL_TYPE && !entry.external
   );
-  if (!relationship) return { ...NO_COMMENTS, people };
+  if (!relationship) return { ...NO_COMMENTS, ...aside };
   const partPath = resolveTarget(mainPartPath, relationship.target);
   const bytes = parts.get(partPath);
-  if (!bytes) return { ...NO_COMMENTS, partPath, people };
+  if (!bytes) return { ...NO_COMMENTS, partPath, ...aside };
   const { text, hadBom } = decodeUtf8(bytes);
   const root = parseXml(text).documentElement;
-  const extensions = readCommentExtensions(parts, mainPartPath);
   const base = elementChildren(root).filter((el) => el.localName === "comment").flatMap((el) => {
-    const id = attribute(el, "id");
+    const id = attributeByLocalName(el, "id");
     if (id === null) return [];
     const paraId = lastParagraphId(el);
     const extension = paraId ? extensions.byParaId.get(paraId) : void 0;
-    const author = attribute(el, "author");
+    const author = attributeByLocalName(el, "author");
     return [
       {
         id,
         author,
         authorId: author === null ? null : commentAuthorId(people, author),
-        initials: attribute(el, "initials"),
-        date: attribute(el, "date"),
+        initials: attributeByLocalName(el, "initials"),
+        date: attributeByLocalName(el, "date"),
         text: commentText(el),
         xml: serializeXml(el),
         paraId,
@@ -146,14 +152,11 @@ function readComments(parts, mainPartPath) {
     ordered,
     byId,
     repliesByParentId,
-    extendedPartPath: extensions.partPath,
-    extendedXml: extensions.xml,
-    extendedHadBom: extensions.hadBom,
-    extendedOrdered: extensions.ordered,
-    people
+    ...aside
   };
 }
 export {
   NO_COMMENTS,
+  lastParagraphId,
   readComments
 };

package/dist/docx/comments/verifying.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Whether every entry of the three comment parts is one this editor wrote, for an author who was
+ * in a position to write it.
+ *
+ * The parts a comment is written across are the ones a submission may rewrite, so the package
+ * comparison (`../commentOnlyChange`) leaves their bytes alone. Something has to read them, or a
+ * file could carry anything at all inside a comment and still be answered as unchanged. What that
+ * reading holds an entry to is two separate questions. Grammar asks whether this editor's writer
+ * could have put the entry out, whoever it belongs to. Permission asks whether this author could
+ * have made the change. Asking them as one would refuse a moderator rewriting somebody else's
+ * comment under `editableComments: "all"`, which is a thing the editor lets them do.
+ */
+import type { EditableComments } from "../../schema/protection";
+import type { CommentOnlyVerdict } from "../commentOnlyChange";
+import type { Story } from "../storyProjection";
+import { type ImportedPeople } from "./people";
+/**
+ * Whether this editor's writer could have put the entry out, whoever it belongs to.
+ *
+ * Shape alone: which attributes it carries and what stands inside it. Who may have written it is
+ * `entryAllowed`'s question. Each kind is read where it is written (`./grammar`).
+ */
+export declare function wellFormedEntry(entry: Element): boolean;
+/**
+ * Whether `authorId` could have written or rewritten this entry.
+ *
+ * Permission alone: whether the shape is one this editor writes is `wellFormedEntry`'s question.
+ * An entry that appeared has to be this author's. One that arrived keeps the identity it arrived
+ * with; settling its thread or replying to it belong to everyone and leave what it says alone,
+ * while rewriting what it says is its author's, a moderator's, or anyone's where no identity was
+ * recorded for it. That last is the rule the editor holds to (`schema/protection`), and the two
+ * have to answer alike or a file the editor wrote would be turned down here.
+ */
+export declare function entryAllowed(entry: Element, original: Element | null, authorId: string, editableComments: EditableComments, people: ImportedPeople): boolean;
+/**
+ * Whether the three comment parts came back holding only entries this editor writes, each of them
+ * one this author was in a position to write.
+ *
+ * This runs after the story has been judged, so a comment rewritten, re-anchored or deleted by the
+ * wrong hand is already named for what it is (`../commentOnlyChange`). What is left to this is
+ * everything the story cannot show: markup forged into a body, an entry nothing refers to, an
+ * identity recorded for somebody else.
+ */
+export declare function commentPartsKept(before: Story, after: Story, authorId: string, editableComments: EditableComments): CommentOnlyVerdict;

package/dist/docx/comments/verifying.js

@@ -0,0 +1,206 @@
+// src/docx/comments/verifying.ts
+import {
+  attributeByLocalName,
+  elementChildren,
+  isElement,
+  parseXml,
+  serializeXml,
+  W_NS
+} from "../../ooxml/xml.js";
+import { W14_NS, W15_NS } from "./constants.js";
+import {
+  attributesWithin,
+  COMMENT_ATTRIBUTES,
+  lastBodyParagraph,
+  readStrictCommentBody,
+  recordedIdentity,
+  wellFormedCommentExtension,
+  wellFormedPerson
+} from "./grammar.js";
+import { commentReferencesIn } from "./model.js";
+import { commentAuthorId } from "./people.js";
+import { lastParagraphId } from "./reading.js";
+var COMMENT_IDENTITY = [
+  "id",
+  "author",
+  "date",
+  "initials"
+];
+function sameAttributes(entry, original, names) {
+  return names.every(
+    (name) => attributeByLocalName(entry, name) === attributeByLocalName(original, name)
+  );
+}
+function arrivedEntries(xml, localName, idAttr) {
+  const entries = /* @__PURE__ */ new Map();
+  if (xml === null) return entries;
+  for (const el of elementChildren(parseXml(xml).documentElement)) {
+    if (el.localName !== localName) continue;
+    const id = attributeByLocalName(el, idAttr);
+    if (id === null || entries.has(id)) continue;
+    entries.set(id, { el, xml: serializeXml(el) });
+  }
+  return entries;
+}
+function submittedEntries(xml, namespace, localName, idAttr) {
+  if (xml === null) return [];
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const el of elementChildren(parseXml(xml).documentElement)) {
+    if (el.namespaceURI !== namespace || el.localName !== localName)
+      return null;
+    const id = attributeByLocalName(el, idAttr);
+    if (id === null || seen.has(id)) return null;
+    seen.add(id);
+    entries.push({ id, el, xml: serializeXml(el) });
+  }
+  return entries;
+}
+function referencedCommentIds(doc) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const [id, comment] of commentReferencesIn(doc)) {
+    ids.add(id);
+    for (const reply of comment.replies) ids.add(reply.id);
+  }
+  return ids;
+}
+function wellFormedEntry(entry) {
+  if (entry.namespaceURI === W_NS && entry.localName === "comment") {
+    return attributesWithin(entry, COMMENT_ATTRIBUTES) && readStrictCommentBody(entry) !== null;
+  }
+  if (entry.namespaceURI === W15_NS && entry.localName === "commentEx") {
+    return wellFormedCommentExtension(entry);
+  }
+  if (entry.namespaceURI === W15_NS && entry.localName === "person") {
+    return wellFormedPerson(entry);
+  }
+  return false;
+}
+function withoutThreadKey(entry) {
+  const copy = entry.cloneNode(true);
+  if (!isElement(copy)) return serializeXml(entry);
+  const last = lastBodyParagraph(copy);
+  last?.removeAttributeNS(W14_NS, "paraId");
+  return serializeXml(copy);
+}
+function threadKeyAlone(entry, original) {
+  const before = lastParagraphId(original);
+  const after = lastParagraphId(entry);
+  const kept = before === null || after === before;
+  return kept && withoutThreadKey(entry) === withoutThreadKey(original);
+}
+function entryAllowed(entry, original, authorId, editableComments, people) {
+  if (entry.namespaceURI === W_NS && entry.localName === "comment") {
+    const author = attributeByLocalName(entry, "author");
+    const recorded = author === null ? null : commentAuthorId(people, author);
+    if (original === null) return recorded === authorId;
+    const paraId = lastParagraphId(original);
+    if (!sameAttributes(entry, original, COMMENT_IDENTITY) || paraId !== null && lastParagraphId(entry) !== paraId) {
+      return false;
+    }
+    return editableComments === "all" || recorded === null || recorded === authorId;
+  }
+  if (entry.namespaceURI === W15_NS && entry.localName === "commentEx") {
+    if (original === null) return true;
+    return sameAttributes(entry, original, ["paraId", "paraIdParent"]);
+  }
+  if (entry.namespaceURI === W15_NS && entry.localName === "person") {
+    return original === null && recordedIdentity(entry) === authorId;
+  }
+  return false;
+}
+function commentEntries(story) {
+  return Array.from(
+    arrivedEntries(story.session.comments.xml, "comment", "id").values(),
+    (entry) => entry.el
+  );
+}
+var COMMENT_PARTS = [
+  {
+    namespace: W_NS,
+    localName: "comment",
+    idAttr: "id",
+    xmlOf: (story) => story.session.comments.xml,
+    pathOf: (story) => story.session.comments.partPath,
+    referents: (story) => referencedCommentIds(story.doc)
+  },
+  {
+    namespace: W15_NS,
+    localName: "commentEx",
+    idAttr: "paraId",
+    xmlOf: (story) => story.session.comments.extendedXml,
+    pathOf: (story) => story.session.comments.extendedPartPath,
+    // Thread state stands for a comment, and it is keyed by the comment's own thread key
+    referents: (story) => new Set(
+      commentEntries(story).flatMap((el) => {
+        const key = lastParagraphId(el);
+        return key === null ? [] : [key];
+      })
+    )
+  },
+  {
+    namespace: W15_NS,
+    localName: "person",
+    idAttr: "author",
+    xmlOf: (story) => story.session.comments.people.xml,
+    pathOf: (story) => story.session.comments.people.partPath,
+    // An identity stands for a name somebody writes comments under
+    referents: (story) => new Set(
+      commentEntries(story).flatMap((el) => {
+        const author = attributeByLocalName(el, "author");
+        return author === null ? [] : [author];
+      })
+    )
+  }
+];
+function partKept(kind, before, after, authorId, editableComments) {
+  const arrived = arrivedEntries(
+    kind.xmlOf(before),
+    kind.localName,
+    kind.idAttr
+  );
+  const submitted = submittedEntries(
+    kind.xmlOf(after),
+    kind.namespace,
+    kind.localName,
+    kind.idAttr
+  );
+  if (submitted === null) return false;
+  const stoodBehindNow = kind.referents(after);
+  const people = after.session.comments.people;
+  for (const entry of submitted) {
+    const original = arrived.get(entry.id);
+    if (original && original.xml === entry.xml) continue;
+    if (!stoodBehindNow.has(entry.id)) return false;
+    if (original && threadKeyAlone(entry.el, original.el)) continue;
+    if (!wellFormedEntry(entry.el) || !entryAllowed(
+      entry.el,
+      original?.el ?? null,
+      authorId,
+      editableComments,
+      people
+    )) {
+      return false;
+    }
+  }
+  const held = new Set(submitted.map((entry) => entry.id));
+  const stoodBehindBefore = kind.referents(before);
+  return Array.from(arrived.keys()).every(
+    (id) => stoodBehindBefore.has(id) || held.has(id)
+  );
+}
+function commentPartsKept(before, after, authorId, editableComments) {
+  for (const kind of COMMENT_PARTS) {
+    const path = kind.pathOf(after) ?? kind.pathOf(before);
+    if (path === null) continue;
+    if (!partKept(kind, before, after, authorId, editableComments)) {
+      return { ok: false, reason: "part-changed", part: path };
+    }
+  }
+  return { ok: true };
+}
+export {
+  commentPartsKept,
+  entryAllowed,
+  wellFormedEntry
+};

package/dist/docx/comments/writing.js

@@ -1,22 +1,30 @@
 // src/docx/comments/writing.ts
+import { elementXml, xmlnsAttr } from "../../ooxml/element.js";
 import { DocxExportError } from "../../ooxml/errors.js";
-import { encodeUtf8, escapeXml, W_NS } from "../../ooxml/xml.js";
+import { wName, xmlnsDecl } from "../../ooxml/names.js";
+import { encodeUtf8 } from "../../ooxml/xml.js";
 import { directoryOf } from "../relationships.js";
 import {
   COMMENTS_CONTENT_TYPE,
   COMMENTS_EXTENDED_CONTENT_TYPE,
   COMMENTS_EXTENDED_REL_TYPE,
   COMMENTS_REL_TYPE,
-  CONTENT_TYPES_PATH,
-  MC_NS,
-  W14_NS,
-  W15_NS
+  CONTENT_TYPES_PATH
 } from "./constants.js";
 import { withContentType } from "./contentTypes.js";
+import {
+  arrivedEntries,
+  renderCommentBody,
+  renderCommentExtension,
+  withThreadKey
+} from "./grammar.js";
 import {
   commentReferencesIn
 } from "./model.js";
 import { planPeoplePart } from "./people.js";
+function needsThreadKey(id, comment, session) {
+  return comment.imported && carriesThreadMetadata(comment) && (session.comments.byId.get(id)?.paraId ?? null) === null;
+}
 function commentsChanged(doc, session) {
   const current = commentReferencesIn(doc);
   if (current.size !== session.commentReferenceIds.size) return true;
@@ -36,14 +44,11 @@ function commentsChanged(doc, session) {
   for (const comment of current.values()) {
     if (comment.replies.some((reply) => !reply.imported)) return true;
   }
+  for (const [id, comment] of current) {
+    if (needsThreadKey(id, comment, session)) return true;
+  }
   return false;
 }
-function renderedExtension(comment) {
-  if (comment.extensionXml !== null) return comment.extensionXml;
-  const parent = "parentParaId" in comment ? ` w15:paraIdParent="${escapeXml(comment.parentParaId)}"` : "";
-  const done = "resolved" in comment ? ` w15:done="${comment.resolved ? "1" : "0"}"` : "";
-  return `<w15:commentEx w15:paraId="${escapeXml(comment.paraId)}"${parent}${done}/>`;
-}
 function extensionsXml(references, comments, originallyReferenced) {
   const current = currentCommentBodies(references);
   const originalThreads = originalThreadIds(comments, originallyReferenced);
@@ -58,19 +63,23 @@ function extensionsXml(references, comments, originallyReferenced) {
     const id = idByParaId.get(original.paraId);
     const item = id === void 0 ? void 0 : current.get(id);
     if (id !== void 0 && item && !written.has(id)) {
-      pieces.push(renderedExtension(item));
+      pieces.push(renderCommentExtension(item));
       written.add(id);
     } else if (id === void 0 || !originalThreads.has(id)) {
       pieces.push(original.xml);
     }
   }
   for (const [id, comment] of current) {
-    if (!written.has(id)) pieces.push(renderedExtension(comment));
+    if (!written.has(id) && carriesThreadMetadata(comment)) {
+      pieces.push(renderCommentExtension(comment));
+    }
   }
   if (comments.extendedXml === null) {
-    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w15:commentsEx xmlns:w15="${W15_NS}">${pieces.join("")}</w15:commentsEx>`;
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w15:commentsEx ${xmlnsDecl("w15")}>${pieces.join("")}</w15:commentsEx>`;
   }
-  const open = /<(?:[\w.-]+:)?commentsEx\b[^>]*>/.exec(comments.extendedXml);
+  const open = /<(?:[^\s<>/:="']+:)?commentsEx\b[^>]*>/.exec(
+    comments.extendedXml
+  );
   if (!open) {
     throw new DocxExportError(
       "malformed-xml",
@@ -78,14 +87,23 @@ function extensionsXml(references, comments, originallyReferenced) {
     );
   }
   const name = /^<([^\s>]+)/.exec(open[0])?.[1];
-  const close = name ? comments.extendedXml.lastIndexOf(`</${name}>`) : -1;
+  if (name === void 0) {
+    throw new DocxExportError(
+      "malformed-xml",
+      "the Comments Extended part has no commentsEx root element"
+    );
+  }
+  const bodyAt = open.index + open[0].length;
+  if (open[0].endsWith("/>")) {
+    return comments.extendedXml.slice(0, open.index) + `${open[0].slice(0, -2)}>${pieces.join("")}</${name}>` + comments.extendedXml.slice(bodyAt);
+  }
+  const close = comments.extendedXml.lastIndexOf(`</${name}>`);
   if (close === -1) {
     throw new DocxExportError(
       "malformed-xml",
       "the Comments Extended part has no closing commentsEx tag"
     );
   }
-  const bodyAt = open.index + open[0].length;
   return comments.extendedXml.slice(0, bodyAt) + pieces.join("") + comments.extendedXml.slice(close);
 }
 function extensionsChanged(doc, session) {
@@ -103,41 +121,42 @@ function extensionsChanged(doc, session) {
   }
   return false;
 }
-function commentTextXml(text) {
-  const lines = text.split("\n");
-  const pieces = [];
-  lines.forEach((line, index) => {
-    if (index > 0) pieces.push("<w:br/>");
-    if (line.length > 0 || lines.length === 1) {
-      pieces.push(`<w:t xml:space="preserve">${escapeXml(line)}</w:t>`);
-    }
-  });
-  return `<w:r>${pieces.join("")}</w:r>`;
-}
 function carriesThreadMetadata(comment) {
   return comment.extensionXml !== null || "threadImported" in comment && !comment.threadImported || "parentParaId" in comment;
 }
-function renderedComment(comment) {
+function keyedEntry(comment, arrivedKeyed) {
+  return carriesThreadMetadata(comment) || arrivedKeyed.has(comment.id);
+}
+function renderedComment(comment, arrivedKeyed, arrived) {
   if (comment.imported && comment.commentXml !== null) {
-    return comment.commentXml;
+    return carriesThreadMetadata(comment) ? withThreadKey(
+      comment.commentXml,
+      comment.paraId,
+      arrived.get(comment.id) ?? null
+    ) : comment.commentXml;
   }
   const attrs = [
-    `w:id="${escapeXml(comment.id)}"`,
-    comment.author === null ? null : `w:author="${escapeXml(comment.author)}"`,
-    comment.date === null ? null : `w:date="${escapeXml(comment.date)}"`,
-    comment.initials === null ? null : `w:initials="${escapeXml(comment.initials)}"`
-  ].filter((entry) => entry !== null).join(" ");
-  const threaded = carriesThreadMetadata(comment);
-  const paragraphAttrs = threaded ? ` xmlns:w14="${W14_NS}" w14:paraId="${escapeXml(comment.paraId)}"` : "";
-  return `<w:comment xmlns:w="${W_NS}" ${attrs}><w:p${paragraphAttrs}>${commentTextXml(comment.text)}</w:p></w:comment>`;
+    xmlnsAttr("w"),
+    [wName("id"), comment.id],
+    comment.author === null ? null : [wName("author"), comment.author],
+    comment.date === null ? null : [wName("date"), comment.date],
+    comment.initials === null ? null : [wName("initials"), comment.initials]
+  ];
+  const paraId = keyedEntry(comment, arrivedKeyed) ? comment.paraId : null;
+  const body = renderCommentBody(comment.text, paraId);
+  return elementXml(
+    wName("comment"),
+    attrs.filter((attr) => attr !== null),
+    [body]
+  );
 }
 function withThreadMarkupCompatibility(openTag) {
   let updated = openTag;
   if (!/\sxmlns:w14\s*=/.test(updated)) {
-    updated = updated.replace(/>$/, ` xmlns:w14="${W14_NS}">`);
+    updated = updated.replace(/>$/, ` ${xmlnsDecl("w14")}>`);
   }
   if (!/\sxmlns:mc\s*=/.test(updated)) {
-    updated = updated.replace(/>$/, ` xmlns:mc="${MC_NS}">`);
+    updated = updated.replace(/>$/, ` ${xmlnsDecl("mc")}>`);
   }
   const ignorable = /\smc:Ignorable\s*=\s*(["'])([^"']*)\1/.exec(updated);
   if (!ignorable) {
@@ -172,16 +191,22 @@ function originalThreadIds(comments, rootIds) {
 }
 function commentsXml(references, comments, originallyReferenced) {
   const currentBodies = currentCommentBodies(references);
+  const arrivedKeyed = new Set(
+    Array.from(comments.byId.values()).flatMap(
+      (entry) => entry.paraId === null ? [] : [entry.id]
+    )
+  );
   const hasThreadMetadata = Array.from(currentBodies.values()).some(
-    carriesThreadMetadata
+    (comment) => keyedEntry(comment, arrivedKeyed)
   );
+  const arrived = arrivedEntries(comments.xml);
   const originalThreads = originalThreadIds(comments, originallyReferenced);
   const pieces = [];
   const written = /* @__PURE__ */ new Set();
   for (const original of comments.ordered) {
     const current = currentBodies.get(original.id);
     if (current) {
-      pieces.push(renderedComment(current));
+      pieces.push(renderedComment(current, arrivedKeyed, arrived));
       written.add(original.id);
       continue;
     }
@@ -191,13 +216,15 @@ function commentsXml(references, comments, originallyReferenced) {
     }
   }
   for (const [id, comment] of currentBodies) {
-    if (!written.has(id)) pieces.push(renderedComment(comment));
+    if (!written.has(id)) {
+      pieces.push(renderedComment(comment, arrivedKeyed, arrived));
+    }
   }
   if (comments.xml === null) {
-    const compatibility = hasThreadMetadata ? ` xmlns:w14="${W14_NS}" xmlns:mc="${MC_NS}" mc:Ignorable="w14"` : "";
-    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:comments xmlns:w="${W_NS}"${compatibility}>${pieces.join("")}</w:comments>`;
+    const compatibility = hasThreadMetadata ? ` ${xmlnsDecl("w14")} ${xmlnsDecl("mc")} mc:Ignorable="w14"` : "";
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:comments ${xmlnsDecl("w")}${compatibility}>${pieces.join("")}</w:comments>`;
   }
-  const open = /<(?:[\w.-]+:)?comments\b[^>]*>/.exec(comments.xml);
+  const open = /<(?:[^\s<>/:="']+:)?comments\b[^>]*>/.exec(comments.xml);
   if (!open) {
     throw new DocxExportError(
       "malformed-xml",

package/dist/docx/exportDocx.js

@@ -4,6 +4,7 @@ import { parseNumbering } from "../numbering/parseNumbering.js";
 import { addListDefinitions } from "../numbering/writeNumbering.js";
 import { DocxExportError } from "../ooxml/errors.js";
 import { decodeUtf8, encodeUtf8, parseXml, W_NS } from "../ooxml/xml.js";
+import { sameSource } from "../schema/sourceEquality.js";
 import { planCommentParts } from "./comments.js";
 import { repackParts } from "./container.js";
 import { hyperlinkRefs } from "./hyperlink.js";
@@ -21,7 +22,7 @@ import {
 import { withUniqueControls } from "./uniqueControls.js";
 function blockXml(node, session, refs) {
   const imported = originalBlock(node, session);
-  if (imported && node.eq(imported.node)) return imported.xml;
+  if (imported && sameSource(node, imported.node)) return imported.xml;
   return serializeBlock(node, session, refs);
 }
 function buildDocumentXml(doc, session, refs) {

package/dist/docx/formatting/direct.js

@@ -3,6 +3,7 @@ import {
   isHighlightName,
   isUnderlineKind
 } from "../../model/format.js";
+import { overridingAttrs } from "../../ooxml/precedence.js";
 import { readTabStopDirectives } from "../../ooxml/tabStops.js";
 import {
   ALIGN_BY_JC,
@@ -18,11 +19,7 @@ import {
   wAttr
 } from "../../ooxml/units.js";
 import { childByLocalName } from "../../ooxml/xml.js";
-import {
-  NO_THEME_FONTS,
-  THEME_ATTRS,
-  themeFontName
-} from "../theme.js";
+import { NO_THEME_FONTS, themeFontName } from "../theme.js";
 var VERTICAL_ALIGN_BY_VAL = {
   superscript: "superscript",
   subscript: "subscript"
@@ -35,7 +32,7 @@ var FONT_SLOTS = ["ascii", "eastAsia", "hAnsi", "cs"];
 function slotFontName(rFonts, slot, themeFonts) {
   const written = wAttr(rFonts, slot);
   if (written !== null) return written;
-  for (const attr of THEME_ATTRS[slot] ?? []) {
+  for (const attr of overridingAttrs("rFonts", slot)) {
     const resolved = themeFontName(themeFonts, wAttr(rFonts, attr));
     if (resolved !== null) return resolved;
   }