@portone/docx-editor 0.2.0 → 0.3.0

package/dist/docx/comments/reading.js

@@ -1,21 +1,20 @@
 // src/docx/comments/reading.ts
 import {
+  attributeByLocalName,
   decodeUtf8,
   elementChildren,
   parseXml,
   serializeXml,
   W_NS
 } from "../../ooxml/xml.js";
-import { readRelationships, relsPathOf, resolveTarget } from "../relationships.js";
+import { relatedPartPath } from "../packageParts.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,14 +39,16 @@ 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(
-    (entry) => entry.type === COMMENTS_EXTENDED_REL_TYPE && !entry.external
+  const partPath = relatedPartPath(
+    parts,
+    mainPartPath,
+    COMMENTS_EXTENDED_REL_TYPE
   );
-  if (!relationship) {
+  if (partPath === null) {
     return {
       partPath: null,
       xml: null,
@@ -56,7 +57,6 @@ function readCommentExtensions(parts, mainPartPath) {
       ordered: []
     };
   }
-  const partPath = resolveTarget(mainPartPath, relationship.target);
   const bytes = parts.get(partPath);
   if (!bytes) {
     return {
@@ -73,13 +73,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 +90,33 @@ function readCommentExtensions(parts, mainPartPath) {
 }
 function readComments(parts, mainPartPath) {
   const people = readPeople(parts, mainPartPath);
-  const relationship = readRelationships(parts, relsPathOf(mainPartPath)).find(
-    (entry) => entry.type === COMMENTS_REL_TYPE && !entry.external
-  );
-  if (!relationship) return { ...NO_COMMENTS, people };
-  const partPath = resolveTarget(mainPartPath, relationship.target);
+  const extensions = readCommentExtensions(parts, mainPartPath);
+  const aside = {
+    people,
+    extendedPartPath: extensions.partPath,
+    extendedXml: extensions.xml,
+    extendedHadBom: extensions.hadBom,
+    extendedOrdered: extensions.ordered
+  };
+  const partPath = relatedPartPath(parts, mainPartPath, COMMENTS_REL_TYPE);
+  if (partPath === null) return { ...NO_COMMENTS, ...aside };
   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 +150,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/writing.d.ts

@@ -2,13 +2,25 @@
  * Plans changed comment package parts while preserving untouched XML.
  */
 import type { Node as PMNode } from "prosemirror-model";
-import { type RelationshipWriter } from "../relationships";
+import type { PartPlanner } from "../partPlan";
 import type { SessionStore } from "../session";
-export interface CommentPartChanges {
-    parts: ReadonlyMap<string, Uint8Array>;
-}
+import { type CommentReferenceData, type CommentReplyData } from "./model";
 /**
- * Plans the Comments part, relationship and content type only when comment state changed, and the
- * people part beside them for an author whose identity the document has yet to record.
+ * Whether the Comments part has to be rewritten: a comment or reply came, went, or changed, or an
+ * entry has to gain the key its thread state hangs off. The export invariants ask this as well, so
+ * a part the writer would leave alone is one they do not read.
  */
-export declare function planCommentParts(doc: PMNode, session: SessionStore, relationships: RelationshipWriter, currentContentTypes?: Uint8Array): CommentPartChanges | null;
+export declare function commentsChanged(doc: PMNode, session: SessionStore): boolean;
+/**
+ * Why the Comments part cannot be rewritten around its root, or null when it can.
+ *
+ * The same question stands in the export invariant list, so a refusal the writer raises is one a
+ * caller could have read there first, in the same words.
+ */
+export declare function commentsRootProblem(xml: string): string | null;
+/** Why the extended part cannot be rewritten around its root, or null when it can */
+export declare function extensionsRootProblem(xml: string): string | null;
+/** Whether the extended part has to be rewritten: thread state arrived, changed, or went with a deleted comment */
+export declare function extensionsChanged(doc: PMNode, session: SessionStore): boolean;
+export declare function currentCommentBodies(references: ReadonlyMap<string, CommentReferenceData>): ReadonlyMap<string, CommentReferenceData | CommentReplyData>;
+export declare const commentsPlanner: PartPlanner;

package/dist/docx/comments/writing.js

@@ -1,22 +1,27 @@
 // src/docx/comments/writing.ts
-import { DocxExportError } from "../../ooxml/errors.js";
-import { encodeUtf8, escapeXml, W_NS } from "../../ooxml/xml.js";
+import { elementXml, xmlnsAttr } from "../../ooxml/element.js";
+import { NAMESPACES, wName, xmlnsDecl } from "../../ooxml/names.js";
+import {
+  ensureRootDeclarations,
+  partRootProblem,
+  splicePart
+} from "../../ooxml/partSplice.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
-} from "./constants.js";
-import { withContentType } from "./contentTypes.js";
+  arrivedEntries,
+  renderCommentBody,
+  renderCommentExtension,
+  withThreadKey
+} from "./grammar.js";
 import {
   commentReferencesIn
 } from "./model.js";
+import { commentsExtendedPart, commentsPart, peoplePart } from "./parts.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 +41,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,35 +60,32 @@ 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>`;
-  }
-  const open = /<(?:[\w.-]+:)?commentsEx\b[^>]*>/.exec(comments.extendedXml);
-  if (!open) {
-    throw new DocxExportError(
-      "malformed-xml",
-      "the Comments Extended part has no commentsEx root element"
-    );
-  }
-  const name = /^<([^\s>]+)/.exec(open[0])?.[1];
-  const close = name ? comments.extendedXml.lastIndexOf(`</${name}>`) : -1;
-  if (close === -1) {
-    throw new DocxExportError(
-      "malformed-xml",
-      "the Comments Extended part has no closing commentsEx tag"
-    );
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w15:commentsEx ${xmlnsDecl("w15")}>${pieces.join("")}</w15:commentsEx>`;
   }
-  const bodyAt = open.index + open[0].length;
-  return comments.extendedXml.slice(0, bodyAt) + pieces.join("") + comments.extendedXml.slice(close);
+  return splicePart(comments.extendedXml, {
+    root: EXTENSIONS_ROOT,
+    replaceChildren: pieces.join("")
+  });
+}
+var COMMENTS_ROOT = "comments";
+var EXTENSIONS_ROOT = "commentsEx";
+function commentsRootProblem(xml) {
+  return partRootProblem(xml, COMMENTS_ROOT);
+}
+function extensionsRootProblem(xml) {
+  return partRootProblem(xml, EXTENSIONS_ROOT);
 }
 function extensionsChanged(doc, session) {
   const current = commentReferencesIn(doc);
@@ -103,51 +102,39 @@ 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>`;
-}
-function withThreadMarkupCompatibility(openTag) {
-  let updated = openTag;
-  if (!/\sxmlns:w14\s*=/.test(updated)) {
-    updated = updated.replace(/>$/, ` xmlns:w14="${W14_NS}">`);
-  }
-  if (!/\sxmlns:mc\s*=/.test(updated)) {
-    updated = updated.replace(/>$/, ` xmlns:mc="${MC_NS}">`);
-  }
-  const ignorable = /\smc:Ignorable\s*=\s*(["'])([^"']*)\1/.exec(updated);
-  if (!ignorable) {
-    return updated.replace(/>$/, ' mc:Ignorable="w14">');
-  }
-  const tokens = ignorable[2].split(/\s+/).filter(Boolean);
-  if (tokens.includes("w14")) return updated;
-  const replacement = ` mc:Ignorable=${ignorable[1]}${[...tokens, "w14"].join(" ")}${ignorable[1]}`;
-  return updated.slice(0, ignorable.index) + replacement + updated.slice(ignorable.index + ignorable[0].length);
+    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]
+  );
 }
+var THREAD_MARKUP = {
+  namespaces: { w14: NAMESPACES.w14, mc: NAMESPACES.mc },
+  ignorable: ["w14"]
+};
 function currentCommentBodies(references) {
   const comments = /* @__PURE__ */ new Map();
   for (const [id, comment] of references) {
@@ -172,16 +159,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,57 +184,32 @@ 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 open = /<(?:[\w.-]+:)?comments\b[^>]*>/.exec(comments.xml);
-  if (!open) {
-    throw new DocxExportError(
-      "malformed-xml",
-      "the Comments part has no comments root element"
-    );
-  }
-  const name = /^<([^\s>]+)/.exec(open[0])?.[1];
-  const close = name ? comments.xml.lastIndexOf(`</${name}>`) : -1;
-  if (close === -1) {
-    throw new DocxExportError(
-      "malformed-xml",
-      "the Comments part has no closing comments tag"
-    );
-  }
-  const openTag = hasThreadMetadata ? withThreadMarkupCompatibility(open[0]) : open[0];
-  return comments.xml.slice(0, open.index) + openTag + pieces.join("") + comments.xml.slice(close);
-}
-function availableCommentsPath(session) {
-  const directory = directoryOf(session.mainPartPath);
-  for (let suffix = 0; ; suffix += 1) {
-    const name = suffix === 0 ? "comments.xml" : `comments${suffix + 1}.xml`;
-    const path = directory + name;
-    if (!session.parts.has(path)) return path;
-  }
-}
-function availableCommentsExtendedPath(session) {
-  const directory = directoryOf(session.mainPartPath);
-  for (let suffix = 0; ; suffix += 1) {
-    const name = suffix === 0 ? "commentsExtended.xml" : `commentsExtended${suffix + 1}.xml`;
-    const path = directory + name;
-    if (!session.parts.has(path)) return path;
+    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 rewritten = splicePart(comments.xml, {
+    root: COMMENTS_ROOT,
+    replaceChildren: pieces.join("")
+  });
+  return hasThreadMetadata ? ensureRootDeclarations(rewritten, THREAD_MARKUP) : rewritten;
 }
-function planCommentParts(doc, session, relationships, currentContentTypes) {
+function planCommentParts(doc, session, context) {
   const bodyChanged = commentsChanged(doc, session);
   const threadChanged = extensionsChanged(doc, session);
   if (!bodyChanged && !threadChanged) return null;
+  const { relationships, contentTypes } = context;
   const references = commentReferencesIn(doc);
-  const addingPart = session.comments.partPath === null;
-  const partPath = session.comments.partPath ?? availableCommentsPath(session);
+  const addingPart = commentsPart.pathIn(session) === null;
+  const partPath = commentsPart.writePathIn(session);
   const parts = /* @__PURE__ */ new Map();
   if (addingPart) {
     const target = partPath.slice(directoryOf(session.mainPartPath).length);
-    relationships.add({ type: COMMENTS_REL_TYPE, target });
+    relationships.add({ type: commentsPart.relType, target });
   }
   if (bodyChanged) {
     parts.set(
@@ -253,22 +221,16 @@ function planCommentParts(doc, session, relationships, currentContentTypes) {
     );
   }
   if (addingPart || session.comments.xml === null) {
-    const contentTypes = withContentType(
-      session.parts,
-      partPath,
-      COMMENTS_CONTENT_TYPE,
-      currentContentTypes
-    );
-    if (contentTypes) parts.set(CONTENT_TYPES_PATH, contentTypes);
+    contentTypes.addOverride(partPath, commentsPart.contentType);
   }
   if (threadChanged && (references.size > 0 || session.comments.extendedPartPath !== null)) {
-    const addingExtendedPart = session.comments.extendedPartPath === null;
-    const extendedPartPath = session.comments.extendedPartPath ?? availableCommentsExtendedPath(session);
+    const addingExtendedPart = commentsExtendedPart.pathIn(session) === null;
+    const extendedPartPath = commentsExtendedPart.writePathIn(session);
     if (addingExtendedPart) {
       const target = extendedPartPath.slice(
         directoryOf(session.mainPartPath).length
       );
-      relationships.add({ type: COMMENTS_EXTENDED_REL_TYPE, target });
+      relationships.add({ type: commentsExtendedPart.relType, target });
     }
     parts.set(
       extendedPartPath,
@@ -282,26 +244,32 @@ function planCommentParts(doc, session, relationships, currentContentTypes) {
       )
     );
     if (addingExtendedPart || session.comments.extendedXml === null) {
-      const contentTypes = withContentType(
-        session.parts,
+      contentTypes.addOverride(
         extendedPartPath,
-        COMMENTS_EXTENDED_CONTENT_TYPE,
-        parts.get(CONTENT_TYPES_PATH) ?? currentContentTypes
+        commentsExtendedPart.contentType
       );
-      if (contentTypes) parts.set(CONTENT_TYPES_PATH, contentTypes);
     }
   }
   if (bodyChanged) {
     const people = planPeoplePart(
+      peoplePart,
       currentCommentBodies(references).values(),
       session,
-      relationships,
-      parts.get(CONTENT_TYPES_PATH) ?? currentContentTypes
+      context
     );
     for (const [path, bytes] of people ?? []) parts.set(path, bytes);
   }
-  return { parts };
+  return parts;
 }
+var commentsPlanner = {
+  name: "comments",
+  plan: planCommentParts
+};
 export {
-  planCommentParts
+  commentsChanged,
+  commentsPlanner,
+  commentsRootProblem,
+  currentCommentBodies,
+  extensionsChanged,
+  extensionsRootProblem
 };

package/dist/docx/documentSettings.d.ts

@@ -2,3 +2,10 @@
 export declare const DEFAULT_TAB_STOP_PT = 36;
 /** Reads the document-wide automatic tab interval from settings.xml. */
 export declare function readDefaultTabStop(settings: Document | null): number | null;
+/** The compatibility settings (`w:compat`) the display reads */
+export interface CompatSettings {
+    /** Part 4 §14.8.3.31: no custom tab stop is created at a hanging indent */
+    noTabHangInd: boolean;
+}
+export declare const NO_COMPAT: CompatSettings;
+export declare function readCompatSettings(settings: Document | null): CompatSettings;

package/dist/docx/documentSettings.js

@@ -1,14 +1,22 @@
 // src/docx/documentSettings.ts
-import { twipsToPt, wAttr } from "../ooxml/units.js";
+import { ST_TwipsMeasure } from "../ooxml/simpleTypes.js";
+import { isOn, twipsToPt, wAttr } from "../ooxml/units.js";
 import { childByLocalName } from "../ooxml/xml.js";
 var DEFAULT_TAB_STOP_PT = 36;
 function readDefaultTabStop(settings) {
   if (!settings) return null;
   const setting = childByLocalName(settings.documentElement, "defaultTabStop");
-  const value = setting ? twipsToPt(wAttr(setting, "val")) : null;
+  const value = setting ? twipsToPt(ST_TwipsMeasure.parse(wAttr(setting, "val"))) : null;
   return value !== null && value > 0 ? value : null;
 }
+var NO_COMPAT = { noTabHangInd: false };
+function readCompatSettings(settings) {
+  const compat = settings ? childByLocalName(settings.documentElement, "compat") : null;
+  return { noTabHangInd: compat !== null && isOn(compat, "noTabHangInd") };
+}
 export {
   DEFAULT_TAB_STOP_PT,
+  NO_COMPAT,
+  readCompatSettings,
   readDefaultTabStop
 };

package/dist/docx/exportDocx.d.ts

@@ -1,15 +1,50 @@
 /**
  * Turns the edited document back into docx bytes.
  *
- * The body (document.xml) is always rebuilt from preserved and edited blocks. numbering.xml is
- * rewritten only when a list was newly started, media parts only when an image was inserted, and
- * the Comments part only when comments changed. Content types and relationships change only when
- * one of those additions needs them.
+ * The body (document.xml) is always rebuilt from preserved and edited blocks. Every other part is
+ * written by a planner (`./partPlan`) that answers only when the document gives it something to
+ * write: numbering.xml when a list was newly started, the comment parts when comments changed,
+ * media parts when an image was inserted. Content types and relationships change only when one
+ * of those additions declares itself through the context every planner shares.
  *
  * The body is written before that relationships part, because a link asks for its relationship as
  * it is written (`docx/hyperlink`), and both writers hand out ids through the one writer so that
  * they cannot pick the same one.
  */
 import type { Node as PMNode } from "prosemirror-model";
+import { type XmlParser } from "../ooxml/xml";
+import { type FidelityNote } from "./fidelity";
+import { type PartPlanner } from "./partPlan";
 import { type DocxSession } from "./session";
-export declare function exportDocx(doc: PMNode, session: DocxSession): Uint8Array;
+/** What a caller may say about a write beyond handing over the document and its session */
+export interface ExportOptions {
+    /**
+     * The parser the original XML kept in the session is read back through. Left out, the
+     * `DOMParser` global is used, and a runtime carrying none refuses the write with
+     * `no-xml-parser`.
+     */
+    xmlParser?: XmlParser;
+}
+export declare function exportDocx(doc: PMNode, session: DocxSession, options?: ExportOptions): Uint8Array;
+/**
+ * The file to write, and what writing it could not carry across as it stood.
+ *
+ * The notes are the ones `documentFidelity` reads off the same document, followed by whatever the
+ * writer had to approximate on the way out. A host that hands a file to somebody else can say what
+ * that file no longer holds without opening it again.
+ *
+ * The first problem `exportProblems` reports is thrown before anything is written, so a refusal a
+ * caller could have asked about ahead of time arrives with the same code and message it would
+ * have read there.
+ */
+export declare function exportDocxReport(doc: PMNode, session: DocxSession, options?: ExportOptions): {
+    bytes: Uint8Array;
+    notes: FidelityNote[];
+};
+/**
+ * The same export, folding a planner list of the caller's choosing in place of `PART_PLANNERS`.
+ *
+ * On no entry point. No document can make a correct planner write a part that does not read back,
+ * so this is how a test hands the fold such a planner and watches the export refuse it.
+ */
+export declare function exportThroughPlanners(planners: readonly PartPlanner[], doc: PMNode, session: DocxSession, options?: ExportOptions): Uint8Array;