@portone/docx-editor 0.2.1 → 0.4.0

package/dist/docx/hyperlink.d.ts

@@ -45,9 +45,8 @@ export declare function relIdIn(prefix: string): string | null;
  *
  * A tag that already names one has only that value rewritten, so a link nobody retargeted comes
  * out as the very string it went in as. A tag that named none is given the attribute, which the
- * specification has supersede any `w:anchor` beside it, along with the namespace it lives in: the
- * body we write into is not always one that declares it, and declaring it again where it is
- * already bound to the same namespace changes nothing.
+ * specification has supersede any `w:anchor` beside it. The namespace it lives in is the part
+ * root's to bind, which `hyperlinkRefs` reports and `docx/exportDocx` sees to.
  */
 export declare function withRelId(prefix: string, relId: string): string;
 /** Which relationship each address goes out on while the body is being written */
@@ -62,6 +61,17 @@ export interface LinkRefs {
 }
 /** What a serializer called on its own, outside an export, has to work with */
 export declare const NO_LINK_REFS: LinkRefs;
+/**
+ * The refs a body is written through, and what the part it went into has to declare afterwards.
+ *
+ * `withRelId` puts the attribute on exactly the tag that arrived without one, and that is the tag
+ * `relIdOf` is handed a null `was` for, so what is recorded here and what is written cannot come
+ * apart.
+ */
+export interface LinkWriting extends LinkRefs {
+    /** Whether a link went out under an `r:id` its own opening tag did not arrive carrying */
+    addedRelId(): boolean;
+}
 /**
  * Hands out the relationship for every address the body points at, adding one where the package
  * has none.
@@ -72,4 +82,4 @@ export declare const NO_LINK_REFS: LinkRefs;
  * relationship a link arrived on is kept wherever it still leads where the link now goes, so
  * retargeting one link in a document leaves every other link's XML alone.
  */
-export declare function hyperlinkRefs(relationships: RelationshipWriter): LinkRefs;
+export declare function hyperlinkRefs(relationships: RelationshipWriter): LinkWriting;

package/dist/docx/hyperlink.js

@@ -34,7 +34,7 @@ function withRelId(prefix, relId) {
     return prefix.replace(REL_ID_VALUE, ` ${REL_ID_ATTR}="${relId}"`);
   }
   const name = "<w:hyperlink";
-  return `${name} xmlns:r="${R_NS}" ${REL_ID_ATTR}="${relId}"${prefix.slice(name.length)}`;
+  return `${name} ${REL_ID_ATTR}="${relId}"${prefix.slice(name.length)}`;
 }
 var NO_LINK_REFS = { relIdOf: () => void 0 };
 function hyperlinkRefs(relationships) {
@@ -42,8 +42,11 @@ function hyperlinkRefs(relationships) {
     (rel) => rel.type === HYPERLINK_REL_TYPE && rel.external
   );
   const added = /* @__PURE__ */ new Map();
+  let attributeAdded = false;
   return {
+    addedRelId: () => attributeAdded,
     relIdOf: (href, was) => {
+      if (was === null) attributeAdded = true;
       const kept = external.find((rel) => rel.id === was);
       if (kept?.target === href) return was ?? void 0;
       const found = external.find((rel) => rel.target === href);

package/dist/docx/identities.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Settling, just before export, every name that may be held by one node only.
+ *
+ * An edit can leave one name standing in two places: splitting a paragraph inside a content
+ * control leaves that control in both halves, and dropping a copy of a paragraph carries the
+ * original's identifiers along with it. Each name a document must keep unique is one rule here,
+ * and the pass walks the blocks once in document order, so the first node to claim a name keeps it
+ * and every later claimant gives it up.
+ *
+ * A document nobody broke apart comes back node for node as it was, which is what keeps an
+ * unedited block going out as its original XML.
+ *
+ * The one walk answers two callers: `withUniqueIdentities` hands the writer the settled document
+ * and throws over a block that cannot yield, and `identityProblems` runs the same walk for
+ * `docx/invariants` and lists those blocks instead, so what the query reports and what the write
+ * refuses cannot come apart.
+ */
+import { type Node as PMNode } from "prosemirror-model";
+import { type DocxExportErrorCode } from "../ooxml/errors";
+export interface IdentityRule {
+    readonly name: string;
+    /**
+     * The block to write in place of `block`, with every name it claims that `written` already holds
+     * given up, and the names it keeps added to `written`. Returns `block` itself when nothing
+     * changes. null means the block cannot yield and the export must refuse. A block's children are
+     * not visited here; the walker visits them after this call.
+     */
+    visit(block: PMNode, written: Set<string>): PMNode | null;
+}
+/**
+ * The block a node was opened from, which `docx/exportDocx` writes the original bytes back for.
+ * A second node claiming the same block is written from its own attrs instead, and a block that
+ * exists only as its original XML has nothing to be written from, so it cannot yield.
+ */
+export declare const sourceBlockRule: IdentityRule;
+/**
+ * A later paragraph carrying an identifier already written goes out without one, and without its
+ * `w14:textId` too, which may not stand without a `w14:paraId` beside it. The walker reaches the
+ * paragraphs inside a table, so the rule reads the one block it is handed.
+ */
+export declare const paragraphIdRule: IdentityRule;
+/**
+ * A content control cannot cross a paragraph, so splitting a paragraph in the middle of one leaves
+ * that same control standing in two, and dropping unmarked text into the middle of one breaks it
+ * in two within the paragraph. Each piece after the first opens as a copy with a `w:id` of its
+ * own (see `docx/sdt` for what a copy must not carry along).
+ */
+export declare const controlRule: IdentityRule;
+/**
+ * In the order they apply to one block: the source rule first, so that a second claimant of a
+ * block is already a rebuilt paragraph by the time the paragraph rule takes its identifier away.
+ */
+export declare const IDENTITY_RULES: readonly IdentityRule[];
+/** A block that cannot yield: what the export refuses it with, and where it stands in the document */
+export interface IdentityProblem {
+    readonly code: DocxExportErrorCode;
+    readonly message: string;
+    readonly pos: number;
+}
+/** The document with every later claimant of a name released, in document order */
+export declare function withUniqueIdentities(doc: PMNode, rules?: readonly IdentityRule[]): PMNode;
+/**
+ * Every block `withUniqueIdentities` would refuse over, in document order, each where it stands;
+ * empty when the pass would go through. The pass is run as the export runs it and its settled
+ * document is dropped, so a caller asking ahead of the write reads the same refusal it would throw.
+ */
+export declare function identityProblems(doc: PMNode, rules?: readonly IdentityRule[]): readonly IdentityProblem[];

package/dist/docx/identities.js

@@ -0,0 +1,174 @@
+// src/docx/identities.ts
+import { Fragment } from "prosemirror-model";
+import { DocxExportError } from "../ooxml/errors.js";
+import { qualify } from "../ooxml/names.js";
+import { parseAttrs } from "../ooxml/tagScan.js";
+import { docxSchema } from "../schema/index.js";
+import { withoutParagraphIds } from "./cloning.js";
+import { copiedControlPrefix, newControlId } from "./sdt.js";
+var sourceBlockRule = {
+  name: "sourceBlock",
+  visit(block, written) {
+    const srcId = block.attrs.srcId;
+    if (typeof srcId !== "string" && typeof srcId !== "number") return block;
+    const name = String(srcId);
+    if (!written.has(name)) {
+      written.add(name);
+      return block;
+    }
+    if (block.type.isInGroup("preserved")) return null;
+    return block.type.create(
+      { ...block.attrs, srcId: null },
+      block.content,
+      block.marks
+    );
+  }
+};
+var PARA_ID = qualify("w14", "paraId");
+var LONG_HEX = /^[0-9A-Fa-f]{8}$/;
+function paragraphIdOf(pAttrs) {
+  if (typeof pAttrs !== "string") return null;
+  const value = parseAttrs(pAttrs)?.find(([name]) => name === PARA_ID)?.[1];
+  if (value === void 0 || !LONG_HEX.test(value)) return null;
+  const id = Number.parseInt(value, 16);
+  return id > 0 && id < 2147483648 ? id : null;
+}
+var paragraphIdRule = {
+  name: "paragraphId",
+  visit(block, written) {
+    if (block.type !== docxSchema.nodes.paragraph) return block;
+    const id = paragraphIdOf(block.attrs.pAttrs);
+    if (id === null) return block;
+    const name = String(id);
+    if (!written.has(name)) {
+      written.add(name);
+      return block;
+    }
+    return block.type.create(
+      { ...block.attrs, pAttrs: withoutParagraphIds(block.attrs.pAttrs) },
+      block.content,
+      block.marks
+    );
+  }
+};
+function sdtMarkOf(node) {
+  return node.marks.find((mark) => mark.type === docxSchema.marks.sdt) ?? null;
+}
+function controlName(mark) {
+  const key = mark.attrs.sdtKey;
+  const prefix = mark.attrs.sdtPrefix;
+  return `${typeof key === "number" ? key : 0} ${typeof prefix === "string" ? prefix : ""}`;
+}
+function copiedMark(mark) {
+  const prefix = mark.attrs.sdtPrefix;
+  if (typeof prefix !== "string") return mark;
+  return mark.type.create({
+    ...mark.attrs,
+    sdtPrefix: copiedControlPrefix(prefix, newControlId())
+  });
+}
+function claim(mark, written) {
+  const name = controlName(mark);
+  const copy = written.has(name) ? copiedMark(mark) : null;
+  written.add(name);
+  return { mark, copy };
+}
+function rewriteParagraph(paragraph, written) {
+  const inline = [];
+  let running = null;
+  let renamed = false;
+  paragraph.forEach((child) => {
+    const mark = sdtMarkOf(child);
+    if (!mark) {
+      running = null;
+      inline.push(child);
+      return;
+    }
+    const control = running?.mark.eq(mark) ? running : claim(mark, written);
+    running = control;
+    if (!control.copy) {
+      inline.push(child);
+      return;
+    }
+    renamed = true;
+    inline.push(
+      child.mark(control.copy.addToSet(mark.removeFromSet(child.marks)))
+    );
+  });
+  return renamed ? paragraph.copy(Fragment.fromArray(inline)) : paragraph;
+}
+var controlRule = {
+  name: "control",
+  visit(block, written) {
+    return block.type === docxSchema.nodes.paragraph ? rewriteParagraph(block, written) : block;
+  }
+};
+var IDENTITY_RULES = [
+  sourceBlockRule,
+  paragraphIdRule,
+  controlRule
+];
+function refusalOf(block, pos) {
+  return {
+    code: "unsupported-content",
+    message: `a preserved block stands in two places (${block.type.name})`,
+    pos
+  };
+}
+function visitBlock(block, pos, walk) {
+  let current = block;
+  for (const [index, rule] of walk.rules.entries()) {
+    const next = rule.visit(current, walk.written[index]);
+    if (next === null) {
+      walk.refuse(refusalOf(block, pos));
+      return current;
+    }
+    current = next;
+  }
+  return current;
+}
+function rewriteBlock(block, pos, walk) {
+  const visited = visitBlock(block, pos, walk);
+  if (visited.inlineContent || visited.childCount === 0) return visited;
+  const children = [];
+  let changed = false;
+  visited.forEach((child, offset) => {
+    const next = rewriteBlock(child, pos + 1 + offset, walk);
+    changed ||= next !== child;
+    children.push(next);
+  });
+  return changed ? visited.copy(Fragment.fromArray(children)) : visited;
+}
+function walkBlocks(doc, rules, refuse) {
+  const walk = {
+    rules,
+    written: rules.map(() => /* @__PURE__ */ new Set()),
+    refuse
+  };
+  const blocks = [];
+  let changed = false;
+  doc.forEach((block, offset) => {
+    const next = rewriteBlock(block, offset, walk);
+    changed ||= next !== block;
+    blocks.push(next);
+  });
+  return changed ? doc.copy(Fragment.fromArray(blocks)) : doc;
+}
+function withUniqueIdentities(doc, rules = IDENTITY_RULES) {
+  return walkBlocks(doc, rules, (problem) => {
+    throw new DocxExportError(problem.code, problem.message);
+  });
+}
+function identityProblems(doc, rules = IDENTITY_RULES) {
+  const problems = [];
+  walkBlocks(doc, rules, (problem) => problems.push(problem));
+  return problems;
+}
+export {
+  IDENTITY_RULES,
+  controlRule,
+  identityProblems,
+  paragraphIdRule,
+  sourceBlockRule,
+  withUniqueIdentities
+};

package/dist/docx/importDocx.d.ts

@@ -4,6 +4,8 @@
  * This module knows nothing about the screen. All it knows is the file and the document model.
  */
 import { type Node as PMNode } from "prosemirror-model";
+import { type XmlParser } from "../ooxml/xml";
+import { type FidelityNote } from "./fidelity";
 import { SessionStore } from "./session";
 /** A docx file as bytes, however it arrived (file input, fetch, filesystem) */
 export type DocxBytes = ArrayBuffer | Uint8Array;
@@ -15,7 +17,16 @@ export type DocxBytes = ArrayBuffer | Uint8Array;
  * engine on `./core` stays synchronous and bytes-only.
  */
 export type DocxSource = DocxBytes | Blob;
-export declare function importDocx(input: DocxBytes): {
+/** What a caller may say about a read beyond handing over the bytes */
+export interface ImportOptions {
+    /**
+     * The parser every part of the package is read through. Left out, the `DOMParser` global is
+     * used, and a runtime carrying none refuses the read with `no-xml-parser`.
+     */
+    xmlParser?: XmlParser;
+}
+export declare function importDocx(input: DocxBytes, options?: ImportOptions): {
     doc: PMNode;
     session: SessionStore;
+    notes: FidelityNote[];
 };

package/dist/docx/importDocx.js

@@ -1,7 +1,10 @@
 // src/docx/importDocx.ts
 import { Fragment } from "prosemirror-model";
-import { toRunFormat } from "../model/format.js";
-import { parseNumbering } from "../numbering/parseNumbering.js";
+import {
+  bindsWritingPrefix,
+  conformanceOf,
+  STRICT_OFFICE_DOCUMENT_REL
+} from "../ooxml/conformance.js";
 import { DocxImportError } from "../ooxml/errors.js";
 import {
   childByLocalName,
@@ -9,54 +12,59 @@ import {
   elementChildren,
   localPart,
   parseXml,
-  R_NS
+  R_NS,
+  withXmlParser
 } from "../ooxml/xml.js";
 import { docxSchema } from "../schema/index.js";
 import { commentReferencesIn, readComments } from "./comments.js";
 import { openParts } from "./container.js";
-import { DEFAULT_TAB_STOP_PT, readDefaultTabStop } from "./documentSettings.js";
 import {
-  defaultParagraphStyleIdOf,
-  defaultTableStyleIdOf,
-  effectiveParagraphFormat,
-  effectiveParagraphStyle,
-  layerRunFormat,
+  DEFAULT_TAB_STOP_PT,
+  readCompatSettings,
+  readDefaultTabStop
+} from "./documentSettings.js";
+import { fidelityNotesOf } from "./fidelity.js";
+import {
+  formattingContextOf,
   NO_DOCUMENT_DEFAULTS,
-  NO_STYLES,
-  readDefaultParagraphFormat,
   readDocumentDefaults,
   readParagraphStyles,
-  readStyles
+  styledParagraph
 } from "./formatting.js";
 import { readHeadersFooters } from "./headersFooters.js";
 import { readLinkTargets } from "./hyperlink.js";
 import { buildParagraph } from "./importParagraph.js";
 import { buildTable } from "./importTable.js";
 import { readImageSources } from "./media.js";
+import { NUMBERING_REL_TYPE } from "./newLists.js";
 import { readNotes } from "./notes.js";
+import { readPart, relatedPartPath } from "./packageParts.js";
 import { readBodyGeometry } from "./pageGeometry.js";
-import { resolveTarget } from "./relationships.js";
+import { readRelationships } from "./relationships.js";
 import { scanBody } from "./scan.js";
-import { SessionStore } from "./session.js";
+import {
+  BODY_STORY_KEY,
+  blockKey,
+  newSessionId,
+  SessionStore
+} from "./session.js";
 import { NO_THEME_FONTS, readThemeFonts } from "./theme.js";
 var OFFICE_DOCUMENT_REL = `${R_NS}/officeDocument`;
 var STYLES_REL = `${R_NS}/styles`;
-var NUMBERING_REL = `${R_NS}/numbering`;
 var THEME_REL = `${R_NS}/theme`;
 var SETTINGS_REL = `${R_NS}/settings`;
-function relationshipTarget(parts, relsPath, type) {
-  const rels = parts.get(relsPath);
-  if (!rels) return null;
-  for (const rel of elementChildren(
-    parseXml(decodeUtf8(rels).text).documentElement
-  )) {
-    if (rel.getAttribute("Type") === type) return rel.getAttribute("Target");
-  }
-  return null;
-}
 function findMainPartPath(parts) {
-  const target = relationshipTarget(parts, "_rels/.rels", OFFICE_DOCUMENT_REL);
+  const relationships = readRelationships(parts, "_rels/.rels");
+  const target = relationships.find(
+    (rel) => rel.type === OFFICE_DOCUMENT_REL
+  )?.target;
   if (!target) {
+    if (relationships.some((rel) => rel.type === STRICT_OFFICE_DOCUMENT_REL)) {
+      throw new DocxImportError(
+        "unsupported-conformance",
+        "the package relates its main document part as an ECMA-376 Strict one"
+      );
+    }
     throw new DocxImportError(
       "missing-part",
       "no relationship pointing at the main document part"
@@ -64,22 +72,27 @@ function findMainPartPath(parts) {
   }
   return target.replace(/^\//, "");
 }
-function relatedPartPath(parts, mainPartPath, type) {
-  const directory = mainPartPath.replace(/[^/]+$/, "");
-  const fileName = mainPartPath.slice(directory.length);
-  const target = relationshipTarget(
-    parts,
-    `${directory}_rels/${fileName}.rels`,
-    type
-  );
-  if (!target) return null;
-  return resolveTarget(mainPartPath, target);
-}
-function readPart(parts, path) {
-  const bytes = path === null ? void 0 : parts.get(path);
-  return bytes ? decodeUtf8(bytes).text : null;
+function assertWritableMainPart(root) {
+  if (conformanceOf(root) === "strict") {
+    throw new DocxImportError(
+      "unsupported-conformance",
+      "the main document part is written in the ECMA-376 Strict vocabulary"
+    );
+  }
+  if (conformanceOf(root) !== "transitional" || root.localName !== "document") {
+    throw new DocxImportError(
+      "unsupported-content",
+      "the main part is not a Transitional WordprocessingML document"
+    );
+  }
+  if (!bindsWritingPrefix(root)) {
+    throw new DocxImportError(
+      "unsupported-content",
+      "the main document part binds WordprocessingML to a prefix other than w"
+    );
+  }
 }
-function buildBlock(el, srcId, sources, styles, defaultTableStyleId) {
+function buildBlock(el, srcId, sources, context) {
   if (el.localName === "bookmarkStart" || el.localName === "bookmarkEnd") {
     return docxSchema.nodes.bookmarkBlock.create({
       srcId,
@@ -91,36 +104,18 @@ function buildBlock(el, srcId, sources, styles, defaultTableStyleId) {
     if (paragraph) return paragraph;
   }
   if (el.localName === "tbl") {
-    const table = buildTable(el, srcId, sources, styles, defaultTableStyleId);
+    const table = buildTable(el, srcId, sources, context);
     if (table) return table;
   }
   return docxSchema.nodes.docxRaw.create({ srcId, name: el.nodeName });
 }
-function styledInline(node, style) {
-  const mark = node.marks.find((entry) => entry.type === docxSchema.marks.run);
-  if (!mark) return node;
-  const format = layerRunFormat(style, toRunFormat(mark.attrs.format));
-  const next = mark.type.create({ ...mark.attrs, format });
-  return node.mark(next.addToSet(node.marks));
-}
-function styledParagraph(node, context) {
-  const style = effectiveParagraphStyle(node.attrs.pPr, context);
-  const inline = style ? node.children.map((child) => styledInline(child, style.run)) : node.children;
-  return node.type.create(
-    {
-      ...node.attrs,
-      format: effectiveParagraphFormat(node.attrs.pPr, context),
-      styleRun: style ? layerRunFormat(style.run, null) : null
-    },
-    Fragment.fromArray(inline),
-    node.marks
-  );
-}
 function withStyleFormats(node, context) {
   if (node.type === docxSchema.nodes.paragraph) {
     return styledParagraph(node, context);
   }
-  if (node.childCount === 0) return node;
+  if (node.childCount === 0 || node.type === docxSchema.nodes.table) {
+    return node;
+  }
   const children = node.children.map(
     (child) => withStyleFormats(child, context)
   );
@@ -153,7 +148,10 @@ function foldTrailingSectPr(scan) {
     suffix: last.xml + scan.suffix
   };
 }
-function importDocx(input) {
+function importDocx(input, options) {
+  return withXmlParser(options?.xmlParser, () => readDocx(input));
+}
+function readDocx(input) {
   const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
   const parts = openParts(bytes);
   const mainPartPath = findMainPartPath(parts);
@@ -164,6 +162,7 @@ function importDocx(input) {
   const { text: source, hadBom } = decodeUtf8(mainPart);
   const scanned = scanBody(source);
   const dom = parseXml(source);
+  assertWritableMainPart(dom.documentElement);
   const body = childByLocalName(dom.documentElement, "body");
   if (!body) {
     throw new DocxImportError("missing-body", "document has no w:body");
@@ -182,25 +181,25 @@ function importDocx(input) {
     parts,
     relatedPartPath(parts, mainPartPath, SETTINGS_REL)
   );
-  const defaultTabStopPt = readDefaultTabStop(settingsXml === null ? null : parseXml(settingsXml)) ?? DEFAULT_TAB_STOP_PT;
-  const numberingPartPath = relatedPartPath(parts, mainPartPath, NUMBERING_REL);
+  const settingsDom = settingsXml === null ? null : parseXml(settingsXml);
+  const defaultTabStopPt = readDefaultTabStop(settingsDom) ?? DEFAULT_TAB_STOP_PT;
+  const numberingPartPath = relatedPartPath(
+    parts,
+    mainPartPath,
+    NUMBERING_REL_TYPE
+  );
   const themeXml = readPart(
     parts,
     relatedPartPath(parts, mainPartPath, THEME_REL)
   );
   const themeFonts = themeXml === null ? NO_THEME_FONTS : readThemeFonts(parseXml(themeXml));
-  const styles = stylesDom ? readStyles(stylesDom, themeFonts) : NO_STYLES;
-  const defaultTableStyleId = stylesDom ? defaultTableStyleIdOf(stylesDom) : null;
-  const defaultParagraphStyleId = stylesDom ? defaultParagraphStyleIdOf(stylesDom) : null;
-  const paragraphDefaults = stylesDom ? readDefaultParagraphFormat(stylesDom) : {};
   const numberingXml = readPart(parts, numberingPartPath);
-  const numbering = parseNumbering(numberingXml);
-  const paragraphFormatting = {
-    styles,
-    defaultStyleId: defaultParagraphStyleId,
-    defaults: paragraphDefaults,
-    numbering
-  };
+  const formatting = formattingContextOf(
+    stylesDom,
+    numberingXml,
+    themeFonts,
+    readCompatSettings(settingsDom)
+  );
   const comments = readComments(parts, mainPartPath);
   const notes = readNotes(parts, mainPartPath);
   const noteLabels = {
@@ -224,15 +223,24 @@ function importDocx(input) {
     notes,
     noteLabel
   };
+  const sessionId = newSessionId();
   const blockNodes = blockElements.map(
     (el, i) => withStyleFormats(
-      buildBlock(el, i, sources, styles, defaultTableStyleId),
-      paragraphFormatting
+      buildBlock(
+        el,
+        blockKey({ sessionId }, BODY_STORY_KEY, i),
+        sources,
+        formatting
+      ),
+      formatting
     )
   );
+  const doc = docxSchema.nodes.doc.create(null, blockNodes);
   return {
-    doc: docxSchema.nodes.doc.create(null, blockNodes),
+    doc,
+    notes: fidelityNotesOf(doc, mainPartPath),
     session: new SessionStore({
+      sessionId,
       parts,
       mainPartPath,
       documentPrefix: scan.prefix,
@@ -241,19 +249,13 @@ function importDocx(input) {
       blocks: blockNodes.map((node, i) => ({ xml: scan.blocks[i].xml, node })),
       defaults: stylesDom ? readDocumentDefaults(stylesDom, themeFonts) : NO_DOCUMENT_DEFAULTS,
       defaultTabStopPt,
-      paragraphDefaults,
       geometry,
-      styles,
+      formatting,
       paragraphStyles: stylesDom ? readParagraphStyles(stylesDom) : [],
-      defaultParagraphStyleId,
       numberingXml,
       numberingPartPath,
       comments,
-      commentReferenceIds: new Set(
-        commentReferencesIn(
-          docxSchema.nodes.doc.create(null, blockNodes)
-        ).keys()
-      ),
+      commentReferenceIds: new Set(commentReferencesIn(doc).keys()),
       headersFooters
     })
   };

package/dist/docx/importParagraph.d.ts

@@ -29,4 +29,4 @@ export interface ImportSources {
 }
 export declare const NO_IMPORT_SOURCES: ImportSources;
 /** Moves a paragraph into an editable node. null if it holds content we do not model */
-export declare function buildParagraph(el: Element, srcId: number | null, sources?: ImportSources): PMNode | null;
+export declare function buildParagraph(el: Element, srcId: string | null, sources?: ImportSources): PMNode | null;

package/dist/docx/importParagraph.js

@@ -1,6 +1,8 @@
 // src/docx/importParagraph.ts
 import { readDrawingPicture } from "../ooxml/image.js";
+import { ST_OnOff } from "../ooxml/simpleTypes.js";
 import {
+  attributeByLocalName,
   attrString,
   childByLocalName,
   elementChildren,
@@ -104,9 +106,8 @@ function buildRunChild(el, marks, images, comments, notes, noteLabel) {
       if (id === null) return null;
       const kind = el.localName === "footnoteReference" ? "footnote" : "endnote";
       const note = noteById(notes, kind, id);
-      const customMarkFollows = Array.from(el.attributes).some(
-        (entry) => entry.localName === "customMarkFollows" && !["0", "false", "off"].includes(entry.value)
-      );
+      const written = attributeByLocalName(el, "customMarkFollows");
+      const customMarkFollows = written !== null && (ST_OnOff.parse(written) ?? true);
       return [
         docxSchema.nodes.noteReference.create(
           {

package/dist/docx/importTable.d.ts

@@ -3,7 +3,7 @@
  * values for display. Unsupported grids return null so the caller can preserve their source XML.
  */
 import type { Node as PMNode } from "prosemirror-model";
-import { type StyleTable } from "./formatting";
+import { type FormattingContext } from "./formatting";
 import { type ImportSources } from "./importParagraph";
 /** Moves a `<w:tbl>` into a table node. null if it cannot be modelled */
-export declare function buildTable(el: Element, srcId: number | null, sources?: ImportSources, styles?: StyleTable, defaultTableStyleId?: string | null): PMNode | null;
+export declare function buildTable(el: Element, srcId: string | null, sources?: ImportSources, context?: FormattingContext): PMNode | null;