@portone/docx-editor 0.2.1 → 0.3.0

package/dist/docx/comments/people.js

@@ -1,7 +1,7 @@
 // src/docx/comments/people.ts
 import { xmlnsAttr } from "../../ooxml/element.js";
-import { DocxExportError } from "../../ooxml/errors.js";
 import { xmlnsDecl } from "../../ooxml/names.js";
+import { splicePart } from "../../ooxml/partSplice.js";
 import {
   attributeByLocalName,
   childByLocalName,
@@ -10,20 +10,9 @@ import {
   encodeUtf8,
   parseXml
 } from "../../ooxml/xml.js";
-import {
-  directoryOf,
-  readRelationships,
-  relsPathOf,
-  resolveTarget
-} from "../relationships.js";
-import {
-  COMMENT_AUTHOR_PROVIDER,
-  CONTENT_TYPES_PATH,
-  PEOPLE_CONTENT_TYPE,
-  PEOPLE_REL_TYPE,
-  W15_NS
-} from "./constants.js";
-import { withContentType } from "./contentTypes.js";
+import { relatedPartPath } from "../packageParts.js";
+import { directoryOf } from "../relationships.js";
+import { COMMENT_AUTHOR_PROVIDER, PEOPLE_REL_TYPE, W15_NS } from "./constants.js";
 import { renderPerson } from "./grammar.js";
 var NO_PEOPLE = {
   partPath: null,
@@ -32,11 +21,8 @@ var NO_PEOPLE = {
   byAuthor: /* @__PURE__ */ new Map()
 };
 function readPeople(parts, mainPartPath) {
-  const relationship = readRelationships(parts, relsPathOf(mainPartPath)).find(
-    (entry) => entry.type === PEOPLE_REL_TYPE && !entry.external
-  );
-  if (!relationship) return NO_PEOPLE;
-  const partPath = resolveTarget(mainPartPath, relationship.target);
+  const partPath = relatedPartPath(parts, mainPartPath, PEOPLE_REL_TYPE);
+  if (partPath === null) return NO_PEOPLE;
   const bytes = parts.get(partPath);
   if (!bytes) return { ...NO_PEOPLE, partPath };
   const { text, hadBom } = decodeUtf8(bytes);
@@ -85,43 +71,6 @@ function w15Prefix(root) {
   const prefix = declaration.name.slice("xmlns:".length);
   return prefix === "" ? "" : `${prefix}:`;
 }
-function rootTagStart(xml) {
-  let at = 0;
-  for (; ; ) {
-    const opens = xml.indexOf("<", at);
-    if (opens === -1) return -1;
-    if (xml.startsWith("<!--", opens)) {
-      at = xml.indexOf("-->", opens + 4) + 3;
-      continue;
-    }
-    if (xml.startsWith("<?", opens)) {
-      at = xml.indexOf("?>", opens + 2) + 2;
-      continue;
-    }
-    return opens;
-  }
-}
-function openTagEnd(xml, at) {
-  let quote = null;
-  for (let i = at; i < xml.length; i += 1) {
-    const character = xml[i];
-    if (quote !== null) {
-      if (character === quote) quote = null;
-      continue;
-    }
-    if (character === '"' || character === "'") {
-      quote = character;
-      continue;
-    }
-    if (character === ">") {
-      return { end: i + 1, selfClosing: xml[i - 1] === "/" };
-    }
-  }
-  return null;
-}
-function malformed(detail) {
-  return new DocxExportError("malformed-xml", `the people part ${detail}`);
-}
 function peopleXml(people, added) {
   const xml = people.xml;
   if (xml === null) {
@@ -131,11 +80,7 @@ function peopleXml(people, added) {
     );
     return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w15:people ${xmlnsDecl("w15")}>${persons2.join("")}</w15:people>`;
   }
-  const root = parseXml(xml).documentElement;
-  if (root.localName !== "people") {
-    throw malformed("has no people root element");
-  }
-  const prefix = w15Prefix(root);
+  const prefix = w15Prefix(parseXml(xml).documentElement);
   const persons = Array.from(
     added,
     ([author, userId]) => renderPerson(
@@ -145,46 +90,24 @@ function peopleXml(people, added) {
       prefix === null ? xmlnsAttr("w15") : null
     )
   ).join("");
-  const start = rootTagStart(xml);
-  const open = start === -1 ? null : openTagEnd(xml, start);
-  if (open === null) throw malformed("has no people root element");
-  if (open.selfClosing) {
-    return `${xml.slice(0, open.end - 2)}>${persons}</${root.nodeName}>` + xml.slice(open.end);
-  }
-  const close = xml.lastIndexOf(`</${root.nodeName}`);
-  if (close === -1) throw malformed("has no closing people tag");
-  return xml.slice(0, close) + persons + xml.slice(close);
-}
-function availablePeoplePath(session) {
-  const directory = directoryOf(session.mainPartPath);
-  for (let suffix = 0; ; suffix += 1) {
-    const name = suffix === 0 ? "people.xml" : `people${suffix + 1}.xml`;
-    const path = directory + name;
-    if (!session.parts.has(path)) return path;
-  }
+  return splicePart(xml, { root: "people", append: persons });
 }
-function planPeoplePart(bodies, session, relationships, currentContentTypes) {
+function planPeoplePart(part, bodies, session, context) {
   const people = session.comments.people;
   const added = unrecordedAuthors(bodies, people);
   if (added.size === 0) return null;
   const parts = /* @__PURE__ */ new Map();
-  const addingPart = people.partPath === null;
-  const partPath = people.partPath ?? availablePeoplePath(session);
+  const addingPart = part.pathIn(session) === null;
+  const partPath = part.writePathIn(session);
   if (addingPart) {
-    relationships.add({
-      type: PEOPLE_REL_TYPE,
+    context.relationships.add({
+      type: part.relType,
       target: partPath.slice(directoryOf(session.mainPartPath).length)
     });
   }
   parts.set(partPath, encodeUtf8(peopleXml(people, added), people.hadBom));
   if (addingPart || people.xml === null) {
-    const contentTypes = withContentType(
-      session.parts,
-      partPath,
-      PEOPLE_CONTENT_TYPE,
-      currentContentTypes
-    );
-    if (contentTypes) parts.set(CONTENT_TYPES_PATH, contentTypes);
+    context.contentTypes.addOverride(partPath, part.contentType);
   }
   return parts;
 }
@@ -192,5 +115,6 @@ export {
   NO_PEOPLE,
   commentAuthorId,
   planPeoplePart,
-  readPeople
+  readPeople,
+  unrecordedAuthors
 };

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

@@ -0,0 +1,7 @@
+/**
+ * The protection that takes comments and nothing else, as the policy both the part planners and
+ * the server verifier read (`../protectionPolicy`).
+ */
+type StoryReason = "body-changed" | "comment-not-owned" | "comment-author-forged";
+export declare const commentsPolicy: import("../protectionPolicy").ProtectionPolicy<StoryReason, "comment-markup-rejected">;
+export {};

package/dist/docx/comments/policy.js

@@ -0,0 +1,43 @@
+// src/docx/comments/policy.ts
+import {
+  commentAdditionsBy,
+  commentEditsOwned,
+  commentIdentitiesKept,
+  withoutComments
+} from "../../schema/protection.js";
+import {
+  registerProtectionPolicy
+} from "../protectionPolicy.js";
+import { comparableStory } from "../storyProjection.js";
+import { COMMENT_STORY_PARTS } from "./parts.js";
+var refused = (reason) => ({ ok: false, reason });
+function sameBody(before, after) {
+  const was = comparableStory(before, withoutComments);
+  const now = comparableStory(after, withoutComments);
+  return was !== null && now !== null && was.length === now.length && was.every((block, at) => block === now[at]);
+}
+function commentsStoryKept(before, after, authorId, { editableComments }) {
+  if (!sameBody(before, after)) return refused("body-changed");
+  if (!commentIdentitiesKept(before.doc, after.doc) || !commentAdditionsBy(before.doc, after.doc, authorId)) {
+    return refused("comment-author-forged");
+  }
+  if (!commentEditsOwned(before.doc, after.doc, {
+    protection: "comments",
+    authorId,
+    editableComments
+  })) {
+    return refused("comment-not-owned");
+  }
+  return { ok: true };
+}
+var commentsPolicy = registerProtectionPolicy(
+  {
+    level: "comments",
+    parts: COMMENT_STORY_PARTS,
+    rejectedMarkup: "comment-markup-rejected",
+    storyKept: commentsStoryKept
+  }
+);
+export {
+  commentsPolicy
+};

package/dist/docx/comments/reading.js

@@ -7,7 +7,7 @@ import {
   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 {
@@ -43,10 +43,12 @@ function lastParagraphId(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,
@@ -55,7 +57,6 @@ function readCommentExtensions(parts, mainPartPath) {
       ordered: []
     };
   }
-  const partPath = resolveTarget(mainPartPath, relationship.target);
   const bytes = parts.get(partPath);
   if (!bytes) {
     return {
@@ -97,11 +98,8 @@ function readComments(parts, mainPartPath) {
     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, ...aside };
-  const partPath = resolveTarget(mainPartPath, relationship.target);
+  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, ...aside };
   const { text, hadBom } = decodeUtf8(bytes);

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,17 +1,13 @@
 // src/docx/comments/writing.ts
 import { elementXml, xmlnsAttr } from "../../ooxml/element.js";
-import { DocxExportError } from "../../ooxml/errors.js";
-import { wName, xmlnsDecl } from "../../ooxml/names.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
-} from "./constants.js";
-import { withContentType } from "./contentTypes.js";
 import {
   arrivedEntries,
   renderCommentBody,
@@ -21,6 +17,7 @@ import {
 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;
@@ -77,34 +74,18 @@ function extensionsXml(references, comments, originallyReferenced) {
   if (comments.extendedXml === null) {
     return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w15:commentsEx ${xmlnsDecl("w15")}>${pieces.join("")}</w15:commentsEx>`;
   }
-  const open = /<(?:[^\s<>/:="']+:)?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];
-  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"
-    );
-  }
-  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);
@@ -150,23 +131,10 @@ function renderedComment(comment, arrivedKeyed, arrived) {
     [body]
   );
 }
-function withThreadMarkupCompatibility(openTag) {
-  let updated = openTag;
-  if (!/\sxmlns:w14\s*=/.test(updated)) {
-    updated = updated.replace(/>$/, ` ${xmlnsDecl("w14")}>`);
-  }
-  if (!/\sxmlns:mc\s*=/.test(updated)) {
-    updated = updated.replace(/>$/, ` ${xmlnsDecl("mc")}>`);
-  }
-  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);
-}
+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) {
@@ -224,51 +192,24 @@ function commentsXml(references, comments, originallyReferenced) {
     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 = /<(?:[^\s<>/:="']+:)?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);
+  const rewritten = splicePart(comments.xml, {
+    root: COMMENTS_ROOT,
+    replaceChildren: pieces.join("")
+  });
+  return hasThreadMetadata ? ensureRootDeclarations(rewritten, THREAD_MARKUP) : rewritten;
 }
-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;
-  }
-}
-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(
@@ -280,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,
@@ -309,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;