@portone/docx-editor 0.3.0 → 0.5.0

package/dist/docx/comments/writing.js

@@ -1,5 +1,5 @@
 // src/docx/comments/writing.ts
-import { elementXml, xmlnsAttr } from "../../ooxml/element.js";
+import { attrsText } from "../../ooxml/element.js";
 import { NAMESPACES, wName, xmlnsDecl } from "../../ooxml/names.js";
 import {
   ensureRootDeclarations,
@@ -7,10 +7,18 @@ import {
   splicePart
 } from "../../ooxml/partSplice.js";
 import { encodeUtf8 } from "../../ooxml/xml.js";
+import { sameSource } from "../../schema/sourceEquality.js";
+import { NO_EXPORT_REFS } from "../exportRefs.js";
 import { directoryOf } from "../relationships.js";
+import { serializeStory } from "../serializeStory.js";
+import {
+  storyFromText,
+  storyKey,
+  storyOf,
+  withThreadKeyOn
+} from "../story.js";
 import {
   arrivedEntries,
-  renderCommentBody,
   renderCommentExtension,
   withThreadKey
 } from "./grammar.js";
@@ -20,7 +28,26 @@ import {
 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;
+  return session.comments.byId.has(id) && carriesThreadMetadata(comment) && (session.comments.byId.get(id)?.paraId ?? null) === null;
+}
+function bodyStory(doc, id) {
+  return storyOf(doc, storyKey("comment", id));
+}
+function importedBody(session, id) {
+  return session.stories.get(storyKey("comment", id)) ?? null;
+}
+function importedEntry(comment, session) {
+  const arrived = session.comments.byId.get(comment.id);
+  if (arrived === void 0 || arrived.author !== comment.author || arrived.date !== comment.date || arrived.initials !== comment.initials) {
+    return null;
+  }
+  return importedBody(session, comment.id);
+}
+function bodyKept(doc, comment, session) {
+  const imported = importedEntry(comment, session);
+  if (imported === null) return null;
+  const current = bodyStory(doc, comment.id);
+  return current === null || sameSource(current, imported.doc) ? imported : null;
 }
 function commentsChanged(doc, session) {
   const current = commentReferencesIn(doc);
@@ -34,12 +61,8 @@ function commentsChanged(doc, session) {
   for (const id of originalBodies) {
     if (!currentBodies.has(id)) return true;
   }
-  for (const id of session.commentReferenceIds) {
-    const comment = current.get(id);
-    if (!comment?.imported) return true;
-  }
-  for (const comment of current.values()) {
-    if (comment.replies.some((reply) => !reply.imported)) return true;
+  for (const comment of currentBodies.values()) {
+    if (bodyKept(doc, comment, session) === null) return true;
   }
   for (const [id, comment] of current) {
     if (needsThreadKey(id, comment, session)) return true;
@@ -74,10 +97,13 @@ 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>`;
   }
-  return splicePart(comments.extendedXml, {
-    root: EXTENSIONS_ROOT,
-    replaceChildren: pieces.join("")
-  });
+  return ensureRootDeclarations(
+    splicePart(comments.extendedXml, {
+      root: EXTENSIONS_ROOT,
+      replaceChildren: pieces.join("")
+    }),
+    { namespaces: { w15: NAMESPACES.w15 } }
+  );
 }
 var COMMENTS_ROOT = "comments";
 var EXTENSIONS_ROOT = "commentsEx";
@@ -108,31 +134,38 @@ function carriesThreadMetadata(comment) {
 function keyedEntry(comment, arrivedKeyed) {
   return carriesThreadMetadata(comment) || arrivedKeyed.has(comment.id);
 }
-function renderedComment(comment, arrivedKeyed, arrived) {
-  if (comment.imported && comment.commentXml !== null) {
-    return carriesThreadMetadata(comment) ? withThreadKey(
-      comment.commentXml,
-      comment.paraId,
-      arrived.get(comment.id) ?? null
-    ) : comment.commentXml;
-  }
+function writtenContainer(comment) {
   const attrs = [
-    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]
+  const text = attrsText(
+    attrs.filter((attr) => attr !== null)
   );
+  return {
+    open: text === "" ? `<${wName("comment")}>` : `<${wName("comment")} ${text}>`,
+    close: `</${wName("comment")}>`
+  };
+}
+function renderedComment(comment, arrivedKeyed, arrived, doc, session) {
+  const kept = bodyKept(doc, comment, session);
+  if (kept !== null) {
+    return carriesThreadMetadata(comment) ? withThreadKey(kept.xml, comment.paraId, arrived.get(comment.id) ?? null) : kept.xml;
+  }
+  const paraId = keyedEntry(comment, arrivedKeyed) ? comment.paraId : null;
+  const entry = importedEntry(comment, session);
+  const said = bodyStory(doc, comment.id) ?? storyFromText("");
+  const body = paraId === null ? said : withThreadKeyOn(said, paraId);
+  return serializeStory(body, null, entry ?? writtenContainer(comment), {
+    ...NO_EXPORT_REFS,
+    session
+  });
 }
+var COMMENT_MARKUP = { namespaces: { w: NAMESPACES.w } };
 var THREAD_MARKUP = {
-  namespaces: { w14: NAMESPACES.w14, mc: NAMESPACES.mc },
+  namespaces: { w: NAMESPACES.w, w14: NAMESPACES.w14, mc: NAMESPACES.mc },
   ignorable: ["w14"]
 };
 function currentCommentBodies(references) {
@@ -157,7 +190,8 @@ function originalThreadIds(comments, rootIds) {
   }
   return ids;
 }
-function commentsXml(references, comments, originallyReferenced) {
+function commentsXml(doc, session, references, originallyReferenced) {
+  const comments = session.comments;
   const currentBodies = currentCommentBodies(references);
   const arrivedKeyed = new Set(
     Array.from(comments.byId.values()).flatMap(
@@ -172,20 +206,26 @@ function commentsXml(references, comments, originallyReferenced) {
   const pieces = [];
   const written = /* @__PURE__ */ new Set();
   for (const original of comments.ordered) {
+    if (written.has(original.id)) continue;
     const current = currentBodies.get(original.id);
     if (current) {
-      pieces.push(renderedComment(current, arrivedKeyed, arrived));
+      pieces.push(
+        renderedComment(current, arrivedKeyed, arrived, doc, session)
+      );
       written.add(original.id);
       continue;
     }
     if (!originalThreads.has(original.id)) {
-      pieces.push(original.xml);
+      const story = importedBody(session, original.id);
+      if (story !== null) pieces.push(story.xml);
       written.add(original.id);
     }
   }
   for (const [id, comment] of currentBodies) {
     if (!written.has(id)) {
-      pieces.push(renderedComment(comment, arrivedKeyed, arrived));
+      pieces.push(
+        renderedComment(comment, arrivedKeyed, arrived, doc, session)
+      );
     }
   }
   if (comments.xml === null) {
@@ -196,7 +236,10 @@ function commentsXml(references, comments, originallyReferenced) {
     root: COMMENTS_ROOT,
     replaceChildren: pieces.join("")
   });
-  return hasThreadMetadata ? ensureRootDeclarations(rewritten, THREAD_MARKUP) : rewritten;
+  return ensureRootDeclarations(
+    rewritten,
+    hasThreadMetadata ? THREAD_MARKUP : COMMENT_MARKUP
+  );
 }
 function planCommentParts(doc, session, context) {
   const bodyChanged = commentsChanged(doc, session);
@@ -215,7 +258,7 @@ function planCommentParts(doc, session, context) {
     parts.set(
       partPath,
       encodeUtf8(
-        commentsXml(references, session.comments, session.commentReferenceIds),
+        commentsXml(doc, session, references, session.commentReferenceIds),
         session.comments.hadBom
       )
     );

package/dist/docx/exportDocx.js

@@ -1,17 +1,21 @@
 // src/docx/exportDocx.ts
 import { DocxExportError } from "../ooxml/errors.js";
+import {
+  ensureRootDeclarations
+} from "../ooxml/partSplice.js";
 import {
   encodeUtf8,
   parseXml,
+  R_NS,
   W_NS,
   withXmlParser
 } from "../ooxml/xml.js";
-import { sameSource } from "../schema/sourceEquality.js";
 import { commentsPlanner } from "./comments.js";
 import { repackParts } from "./container.js";
 import {
   fidelityNotesOf
 } from "./fidelity.js";
+import { headerFooterPlanner } from "./headersFooters.js";
 import { hyperlinkRefs } from "./hyperlink.js";
 import { withUniqueIdentities } from "./identities.js";
 import { problemsOf } from "./invariants.js";
@@ -27,28 +31,22 @@ import {
   relationshipWriter,
   relsPathOf
 } from "./relationships.js";
-import { serializeBlock } from "./serializeBlock.js";
-import {
-  originalBlock,
-  sessionOf
-} from "./session.js";
-function blockXml(node, session, refs) {
-  const imported = originalBlock(node, session);
-  if (imported && sameSource(node, imported.node)) return imported.xml;
-  return serializeBlock(node, session, refs);
-}
+import { blockXml } from "./serializeBlock.js";
+import { sessionOf } from "./session.js";
 function buildDocumentXml(doc, session, refs) {
   const pieces = [session.documentPrefix];
   withUniqueIdentities(doc).forEach((child) => {
-    pieces.push(blockXml(child, session, refs));
+    pieces.push(blockXml(child, refs, doc.childCount === 1));
   });
+  const sectPr = doc.attrs.sectPr;
+  if (typeof sectPr === "string") pieces.push(sectPr);
   pieces.push(session.documentSuffix);
   return pieces.join("");
 }
 function localAttribute(el, name) {
   return Array.from(el.attributes).find((attribute) => attribute.localName === name)?.value ?? null;
 }
-function assertBookmarkPairs(documentXml) {
+function assertMainPart(documentXml, wroteLinks) {
   let root;
   try {
     root = parseXml(documentXml).documentElement;
@@ -63,6 +61,15 @@ function assertBookmarkPairs(documentXml) {
   const used = /* @__PURE__ */ new Set();
   for (const element of root.getElementsByTagName("*")) {
     if (element.namespaceURI !== W_NS) continue;
+    if (wroteLinks && element.localName === "hyperlink") {
+      const id2 = element.getAttributeNode("r:id");
+      if (id2 && id2.namespaceURI !== R_NS) {
+        throw new DocxExportError(
+          "unsupported-content",
+          "a hyperlink's r:id is shadowed by a different relationship namespace"
+        );
+      }
+    }
     if (element.localName !== "bookmarkStart" && element.localName !== "bookmarkEnd") {
       continue;
     }
@@ -97,9 +104,11 @@ function assertBookmarkPairs(documentXml) {
     );
   }
 }
+var LINK_MARKUP = { namespaces: { r: R_NS } };
 var PART_PLANNERS = [
   numberingPlanner,
-  commentsPlanner
+  commentsPlanner,
+  headerFooterPlanner
 ];
 function exportDocx(doc, session, options) {
   return exportDocxReport(doc, session, options).bytes;
@@ -135,12 +144,15 @@ function writeDocx(doc, store, notes, planners) {
     contentTypes: contentTypeWriter(store.parts)
   };
   const media = planImageMedia(doc, store, context);
-  const documentXml = buildDocumentXml(doc, store, {
+  const links = hyperlinkRefs(context.relationships);
+  const body = buildDocumentXml(doc, store, {
     images: media?.refs ?? NO_IMAGE_REFS,
-    links: hyperlinkRefs(context.relationships),
-    notes
+    links,
+    notes,
+    session: store
   });
-  assertBookmarkPairs(documentXml);
+  const documentXml = links.addedRelId() ? ensureRootDeclarations(body, LINK_MARKUP) : body;
+  assertMainPart(documentXml, links.addedRelId());
   const parts = runPartPlanners(planners, doc, store, context, media?.parts);
   const rels = context.relationships.part(store.parts.get(relsPath));
   if (rels) parts.set(relsPath, rels);

package/dist/docx/exportRefs.d.ts

@@ -1,19 +1,24 @@
 /**
  * What the serializers need from the rest of the package while a body is being written: which
  * relationship an inserted image ended up on (`docx/media`), which one each link's address lives
- * on (`docx/hyperlink`), and where to record an approximation a writer had to make
- * (`docx/fidelity`).
+ * on (`docx/hyperlink`), where to record an approximation a writer had to make (`docx/fidelity`),
+ * and the fragments the document was opened from (`docx/session`).
  *
  * They travel as one value so that a serializer taking a body apart passes on everything the
- * pieces of it may need, whatever a later kind of content turns out to require.
+ * pieces of it may need, whatever a later kind of content turns out to require. The session is
+ * among them because a preserved block names the fragment it stands for wherever it ends up: an
+ * edit may move one into a table cell, and the cell writer has no other way to reach the original.
  */
 import { type FidelityCollector } from "./fidelity";
 import { type LinkRefs } from "./hyperlink";
 import { type ImageRefs } from "./media";
+import type { SessionStore } from "./session";
 export interface ExportRefs {
     images: ImageRefs;
     links: LinkRefs;
     notes: FidelityCollector;
+    /** null for a serializer called on a document nobody opened */
+    session: SessionStore | null;
 }
 /** What a serializer called on its own, outside an export, has to work with */
 export declare const NO_EXPORT_REFS: ExportRefs;

package/dist/docx/exportRefs.js

@@ -5,7 +5,8 @@ import { NO_IMAGE_REFS } from "./media.js";
 var NO_EXPORT_REFS = {
   images: NO_IMAGE_REFS,
   links: NO_LINK_REFS,
-  notes: NO_FIDELITY_COLLECTOR
+  notes: NO_FIDELITY_COLLECTOR,
+  session: null
 };
 export {
   NO_EXPORT_REFS

package/dist/docx/fidelity.js

@@ -13,31 +13,45 @@ function elementOf(node) {
   return stringAttr(node.attrs.name) ?? elementNameOf(stringAttr(node.attrs.xml) ?? "");
 }
 function demotedBlock(element) {
-  const name = element === null ? null : localPart(element);
+  const name = localNameOf(element);
   if (name === "tbl") return { severity: "placeholder", code: "table-demoted" };
   if (name === "p") {
     return { severity: "placeholder", code: "paragraph-demoted" };
   }
   return { severity: "placeholder", code: "preserved-block" };
 }
+function severityOf(display) {
+  return display === "chip" ? "placeholder" : "hidden";
+}
 function preservedBy(node, element) {
   switch (node.type.name) {
-    case "docxRaw":
-      return demotedBlock(element);
     case "rawBlock":
-      return { severity: "placeholder", code: "preserved-block" };
-    case "bookmarkBlock":
-      return { severity: "hidden", code: "range-marker" };
+      return preservedBlockNote(node, element);
+    case "rawRunContent":
+      return {
+        severity: severityOf(node.attrs.display),
+        code: "preserved-run-content"
+      };
     case "rawInline":
-      return preservedInline(element);
+      return preservedInline(node, element);
     default:
       return null;
   }
 }
-function preservedInline(element) {
-  const name = element === null ? null : localPart(element);
+function preservedBlockNote(node, element) {
+  if (severityOf(node.attrs.display) === "placeholder") {
+    return demotedBlock(element);
+  }
+  return node.attrs.guarded === true ? { severity: "hidden", code: "range-marker" } : { severity: "hidden", code: "preserved-block" };
+}
+function preservedInline(node, element) {
+  const name = stringAttr(node.attrs.element) ?? localNameOf(element);
   if (name === "r") return null;
-  return name === "bookmarkStart" || name === "bookmarkEnd" ? { severity: "hidden", code: "range-marker" } : { severity: "hidden", code: "preserved-inline" };
+  const severity = severityOf(node.attrs.display);
+  return severity === "hidden" && node.attrs.guarded === true ? { severity, code: "range-marker" } : { severity, code: "preserved-inline" };
+}
+function localNameOf(element) {
+  return element === null ? null : localPart(element);
 }
 function blockNumberOf(node) {
   const srcId = stringAttr(node.attrs.srcId);

package/dist/docx/fields.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Where the fields of a paragraph stand, read back off the fragments the editor keeps as they came.
+ *
+ * A complex field is not one element. It is a begin character, the instruction text, an optional
+ * separate character, the result its producer cached, and an end character, all standing loose
+ * among the runs of the paragraph in that order (§17.16.18). Nothing in the model pairs them up, so
+ * anything that wants to know what a field was told to print has to read the characters back. A
+ * simple field says the same in one element and carries its instruction as an attribute (§17.16.19).
+ *
+ * What a field means, and how to work it out again, belongs to the fields feature. This answers the
+ * one question a projection has: where each field stands and what its instruction says.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+export interface FieldSpan {
+    /** The instruction text between begin and separate (or end), whitespace-trimmed */
+    instr: string;
+    /** Where the begin character stands, and the simple field itself for one written as a single element */
+    begin: number;
+    /** Where the separate character stands, and null for a field that cached no result */
+    separate: number | null;
+    /** Where the end character stands, which is `begin` again for a simple field */
+    end: number;
+    /** The half-open range of positions the cached result covers, and null for a field carrying none */
+    result: [number, number] | null;
+}
+/**
+ * Whether the node is one of the pieces a complex field is written out of rather than something
+ * the field prints. A projection drops these whether or not they pair up into a field.
+ */
+export declare function isFieldCharacter(node: PMNode): boolean;
+/**
+ * The fields this paragraph holds, in the order they begin, each position offset by `offset`.
+ *
+ * Positions are counted inside the paragraph's content, so `offset` is where that content starts:
+ * a caller reading a paragraph standing on its own passes 0, and one reading a paragraph of a
+ * document passes the position just inside it.
+ *
+ * A begin character with no end is no field: the file says a field starts there and never says
+ * what it prints, so there is nothing to pair it with and it is passed over. `documentFidelity`
+ * still reports the characters themselves as content kept rather than modelled.
+ */
+export declare function fieldSpans(paragraph: PMNode, offset: number): FieldSpan[];

package/dist/docx/fields.js

@@ -0,0 +1,76 @@
+// src/docx/fields.ts
+import { parsePropsXml } from "../ooxml/props.js";
+import { attributeByLocalName } from "../ooxml/xml.js";
+var FIELD_CHARACTER = "fldChar";
+var INSTRUCTION = "instrText";
+var SIMPLE_FIELD = "fldSimple";
+function attributeOf(node, name) {
+  const xml = node.attrs.xml;
+  if (typeof xml !== "string") return null;
+  const el = parsePropsXml(xml);
+  return el === null ? null : attributeByLocalName(el, name);
+}
+function chipText(node) {
+  const text = node.attrs.text;
+  return typeof text === "string" ? text : "";
+}
+var DELETED_INSTRUCTION = "delInstrText";
+var FIELD_PLUMBING = /* @__PURE__ */ new Set([
+  FIELD_CHARACTER,
+  INSTRUCTION,
+  DELETED_INSTRUCTION
+]);
+function isFieldCharacter(node) {
+  const element = node.attrs.element;
+  return node.type.name === "rawRunContent" && typeof element === "string" && FIELD_PLUMBING.has(element);
+}
+function fieldSpans(paragraph, offset) {
+  const spans = [];
+  const open = [];
+  paragraph.forEach((child, at) => {
+    const pos = offset + at;
+    const element = child.attrs.element;
+    if (child.type.name === "rawInline" && element === SIMPLE_FIELD) {
+      spans.push({
+        instr: (attributeOf(child, "instr") ?? "").trim(),
+        begin: pos,
+        separate: null,
+        end: pos,
+        result: null
+      });
+      return;
+    }
+    if (child.type.name !== "rawRunContent") return;
+    if (element === INSTRUCTION) {
+      const active2 = open.at(-1);
+      if (active2 && active2.separate === null) active2.instr += chipText(child);
+      return;
+    }
+    if (element !== FIELD_CHARACTER) return;
+    const kind = attributeOf(child, "fldCharType");
+    if (kind === "begin") {
+      open.push({ instr: "", begin: pos, separate: null });
+      return;
+    }
+    const active = open.at(-1);
+    if (active === void 0) return;
+    if (kind === "separate") {
+      if (active.separate === null) active.separate = pos;
+      return;
+    }
+    if (kind !== "end") return;
+    open.pop();
+    spans.push({
+      instr: active.instr.trim(),
+      begin: active.begin,
+      separate: active.separate,
+      end: pos,
+      result: active.separate === null ? null : [active.separate + 1, pos]
+    });
+  });
+  return spans.sort((a, b) => a.begin - b.begin);
+}
+export {
+  fieldSpans,
+  isFieldCharacter
+};

package/dist/docx/formatting/attrs.d.ts

@@ -4,8 +4,8 @@
  * and the clipboard reader all take them from here, so a paragraph is drawn the same whichever of
  * them last touched it.
  */
-import type { Mark } from "prosemirror-model";
-import type { ParagraphFormat, RunFormat } from "../../model/format";
+import { type Mark, type Node as PMNode } from "prosemirror-model";
+import { type ParagraphFormat, type RunFormat } from "../../model/format";
 import type { FormattingContext } from "./context";
 import { type ParagraphPlacement, type ResolvedParagraph } from "./resolve";
 /** The two derived paragraph attrs (`format` and `styleRun` in `schema`) */
@@ -25,3 +25,21 @@ export declare function paragraphAttrsFor(pPr: string | null, context: Formattin
  * An inline that is not text and carries no mark is left as it is.
  */
 export declare function runMarkUnder(mark: Mark | null, isText: boolean, paragraph: ResolvedParagraph, context: FormattingContext): Mark | null;
+/**
+ * The paragraph with the values the hierarchy gives it, and the text inside it wearing the run
+ * mark that goes with them.
+ *
+ * The style's run values are also laid on the paragraph itself, so that text carrying no run of
+ * its own - typed in the editor - is drawn in them (`styleRun` in `schema`).
+ * Where the paragraph stands in a table cell, `placement` is the part of the table it belongs to,
+ * which the table style dresses on top of everything else it lays down.
+ */
+export declare function styledParagraph(node: PMNode, context: FormattingContext, placement?: ParagraphPlacement | null): PMNode;
+/** Table display inputs, refreshed from the same style context as the paragraphs inside it. */
+export declare function tableStyleAttrs(tblPr: Element | null, context: FormattingContext): {
+    format: import("../..").TableFormat | null;
+    styleInside: import("../tableFormatting").InsideBorders | null;
+    styleCellMargins: import("../tableFormatting").CellMargins | null;
+    styleConditions: Readonly<Partial<Record<"band1Horz" | "band1Vert" | "band2Horz" | "band2Vert" | "firstCol" | "firstRow" | "lastCol" | "lastRow" | "neCell" | "nwCell" | "seCell" | "swCell" | "wholeTable", import("../tableFormatting").CellStyleFormat>>> | null;
+    styleBands: import("../tableFormatting").BandSizes | null;
+};

package/dist/docx/formatting/attrs.js

@@ -1,9 +1,26 @@
 // src/docx/formatting/attrs.ts
+import { Fragment } from "prosemirror-model";
+import {
+  toBandSizes,
+  toCellMargins,
+  toInsideBorders,
+  toTableStyleConditions
+} from "../../model/format.js";
 import { docxSchema } from "../../schema/index.js";
+import {
+  cellConditionsOf,
+  layerBandSizes,
+  NO_BAND_SIZES,
+  readBandSizes,
+  readTableFormat,
+  tblStyleIdOf
+} from "../tableFormatting.js";
 import {
   resolveParagraph,
-  resolveRun
+  resolveRun,
+  tableStyleFor
 } from "./resolve.js";
+import { layerTableFormat } from "./styles.js";
 function paragraphAttrsOf(paragraph) {
   return { format: paragraph.format, styleRun: paragraph.styleRun };
 }
@@ -24,8 +41,46 @@ function runMarkUnder(mark, isText, paragraph, context) {
   const format = resolveRun(null, paragraph, context);
   return format === null ? null : docxSchema.marks.run.create({ rPr: null, rAttrs: null, format });
 }
+function styledParagraph(node, context, placement = null) {
+  const pPr = node.attrs.pPr;
+  const paragraph = resolveParagraph(
+    typeof pPr === "string" ? pPr : null,
+    context,
+    placement
+  );
+  const inline = node.children.map((child) => {
+    const mark = runMarkUnder(
+      child.marks.find((entry) => entry.type === docxSchema.marks.run) ?? null,
+      child.isText,
+      paragraph,
+      context
+    );
+    return mark ? child.mark(mark.addToSet(child.marks)) : child;
+  });
+  return node.type.create(
+    { ...node.attrs, ...paragraphAttrsOf(paragraph) },
+    Fragment.fromArray(inline),
+    node.marks
+  );
+}
+function tableStyleAttrs(tblPr, context) {
+  const style = tableStyleFor(tblStyleIdOf(tblPr), context);
+  return {
+    format: layerTableFormat(style?.table ?? {}, readTableFormat(tblPr)),
+    styleInside: toInsideBorders(style?.tableInside),
+    styleCellMargins: toCellMargins(style?.tableCellMargins),
+    styleConditions: toTableStyleConditions(
+      cellConditionsOf(style?.tableConditions ?? {})
+    ),
+    styleBands: toBandSizes(
+      layerBandSizes(style?.tableBands ?? NO_BAND_SIZES, readBandSizes(tblPr))
+    )
+  };
+}
 export {
   paragraphAttrsFor,
   paragraphAttrsOf,
-  runMarkUnder
+  runMarkUnder,
+  styledParagraph,
+  tableStyleAttrs
 };

package/dist/docx/formatting/context.d.ts

@@ -1,5 +1,5 @@
 import type { RunFormat } from "../../model/format";
-import { type Numbering } from "../../numbering/parseNumbering";
+import { type Numbering, type NumberingOptions } from "../../numbering/parseNumbering";
 import { type CompatSettings } from "../documentSettings";
 import { type ThemeFonts } from "../theme";
 import { type StyleTable } from "./styles";
@@ -27,5 +27,13 @@ export interface FormattingContext {
     compat: CompatSettings;
 }
 export declare const NO_FORMATTING: FormattingContext;
+/**
+ * How a document's numbering part is read against the rest of what the document lays down.
+ *
+ * The numbering folder cannot reach styles.xml, so the links a definition follows are handed to it
+ * from here, and the two callers that read a numbering part - opening a document and asking an
+ * open one for its lists - resolve the same links.
+ */
+export declare function numberingOptionsFor(styles: StyleTable, themeFonts: ThemeFonts): NumberingOptions;
 /** The context an opened document resolves against. A document without a styles part lays down nothing */
-export declare function formattingContextOf(styles: Document | null, numbering: Numbering, themeFonts: ThemeFonts, compat?: CompatSettings): FormattingContext;
+export declare function formattingContextOf(styles: Document | null, numberingXml: string | null, themeFonts: ThemeFonts, compat?: CompatSettings): FormattingContext;