@portone/docx-editor 0.4.0 → 0.5.1

package/dist/docx/serializeParagraph.d.ts

@@ -3,10 +3,15 @@
  *
  * Body paragraphs and paragraphs inside table cells take the same path.
  *
- * The inlines are grouped three times over: neighbours that share their formatting become one run,
- * the runs that share a hyperlink (`w:hyperlink`) go back inside it, and the links and runs that
- * share a content control (`w:sdt`) go back inside the wrapper that mark carries. The control is
- * the outer of the two wrappers, which is the nesting the mark order records (`schema`).
+ * A fragment the reader kept whole goes back where it stood: one kept inside a run is written as
+ * a piece of that run, and one kept beside the runs is written between them, which is what the
+ * two content models admit.
+ *
+ * The inlines are grouped from the outside in: neighbours sharing the outermost wrapper each stands
+ * inside go back into it, that grouping is made again one wrapper deeper, and at the bottom the
+ * neighbours that share their formatting become one run. `schema/wrappers` says which wrapper is
+ * which depth, and `docx/wrappers` says what each of them opens and closes as, so a wrapper of a
+ * new kind is written here without this file knowing anything about it.
  */
 import type { Node as PMNode } from "prosemirror-model";
 import { type ExportRefs } from "./exportRefs";

package/dist/docx/serializeParagraph.js

@@ -9,8 +9,9 @@ import {
 } from "../ooxml/image.js";
 import { wName } from "../ooxml/names.js";
 import { escapeXml } from "../ooxml/xml.js";
+import { wrapperMarks } from "../schema/wrappers.js";
 import { NO_EXPORT_REFS } from "./exportRefs.js";
-import { relIdIn, withRelId } from "./hyperlink.js";
+import { wrapperKindOf } from "./wrappers.js";
 function sameMark(a, b) {
   if (a === null || b === null) return a === b;
   return a.eq(b);
@@ -65,6 +66,7 @@ function renderInline(node, images) {
   }
   if (node.type.name === "hardBreak")
     return emptyTagXml(wName("br"), rawAttrsOf(node.attrs.brAttrs));
+  if (node.type.name === "rawRunContent") return preservedXml(node);
   if (node.type.name === "image") return renderImage(node, images);
   if (node.type.name === "commentReference") {
     const original = node.attrs.referenceXml;
@@ -140,76 +142,39 @@ function addInline(parts, child, images) {
     parts.push({ kind: "run", mark, pieces: [piece] });
   }
 }
-function splitParagraphGroups(paragraph, refs) {
-  const groups = [];
-  paragraph.forEach((child) => {
-    const sdt = markOf(child, "sdt");
-    const link = markOf(child, "link");
-    let group = groups.at(-1);
-    if (!group || !sameMark(group.sdt, sdt)) {
-      group = { sdt, links: [] };
-      groups.push(group);
-    }
-    let inLink = group.links.at(-1);
-    if (!inLink || !sameMark(inLink.link, link)) {
-      inLink = { link, parts: [] };
-      group.links.push(inLink);
-    }
-    addInline(inLink.parts, child, refs.images);
-  });
-  return groups;
-}
 function renderParagraphPart(part) {
   if (part.kind === "raw") return part.xml;
   const open = openTagXml(wName("r"), rawAttrsOf(part.mark?.attrs.rAttrs));
   const rPr = part.mark?.attrs.rPr;
   return open + (typeof rPr === "string" ? rPr : "") + part.pieces.join("") + "</w:r>";
 }
-function openLinkTag(mark, links) {
-  const prefix = mark.attrs.linkPrefix;
-  const original = typeof prefix === "string" ? prefix : null;
-  const href = mark.attrs.href;
-  if (typeof href !== "string") {
-    if (original !== null) return original;
-    throw new DocxExportError(
-      "lost-original",
-      "a hyperlink carries neither an address nor the opening XML it goes back out as"
-    );
-  }
-  const relId = links.relIdOf(
-    href,
-    original === null ? null : relIdIn(original)
-  );
-  if (relId === void 0) {
-    if (original !== null) return original;
-    throw new DocxExportError(
-      "unsupported-content",
-      "an inserted hyperlink has no relationship to point at; export it through exportDocx"
-    );
+function groupsAtDepth(children, depth) {
+  const groups = [];
+  for (const child of children) {
+    const mark = wrapperMarks(child)[depth] ?? null;
+    const last = groups.at(-1);
+    if (last && sameMark(last.mark, mark)) last.children.push(child);
+    else groups.push({ mark, children: [child] });
   }
-  return withRelId(original ?? "<w:hyperlink>", relId);
+  return groups;
 }
-function renderLinkGroup(group, links) {
-  const body = group.parts.map(renderParagraphPart).join("");
-  if (!group.link) return body;
-  return `${openLinkTag(group.link, links)}${body}</w:hyperlink>`;
+function renderParts(children, images) {
+  const parts = [];
+  for (const child of children) addInline(parts, child, images);
+  return parts.map(renderParagraphPart).join("");
 }
-function renderParagraphGroup(group, refs) {
-  const body = group.links.map((inLink) => renderLinkGroup(inLink, refs.links)).join("");
-  if (!group.sdt) return body;
-  const prefix = group.sdt.attrs.sdtPrefix;
-  if (typeof prefix !== "string") {
-    throw new DocxExportError(
-      "lost-original",
-      "a content control has lost the opening XML it goes back out as"
-    );
-  }
-  return `${prefix}<w:sdtContent>${body}</w:sdtContent></w:sdt>`;
+function renderWrapped(children, depth, refs) {
+  return groupsAtDepth(children, depth).map((group) => {
+    if (group.mark === null) return renderParts(group.children, refs.images);
+    const kind = wrapperKindOf(group.mark);
+    const body = renderWrapped(group.children, depth + 1, refs);
+    return kind.open(group.mark, refs) + body + kind.close(group.mark);
+  }).join("");
 }
 function serializeParagraph(node, refs = NO_EXPORT_REFS) {
   const open = openTagXml(wName("p"), rawAttrsOf(node.attrs.pAttrs));
   const pPr = node.attrs.pPr;
-  const body = splitParagraphGroups(node, refs).map((group) => renderParagraphGroup(group, refs)).join("");
+  const body = renderWrapped(node.children, 0, refs);
   return open + (typeof pPr === "string" ? pPr : "") + body + "</w:p>";
 }
 export {

package/dist/docx/serializePreserved.d.ts

@@ -0,0 +1,14 @@
+/**
+ * How a block the editor never modelled goes back out, wherever in the document it stands.
+ *
+ * A block opened under the body names the fragment it stands for and the session holds the bytes;
+ * one opened inside a table cell was never a fragment of its own and carries its XML along. An
+ * edit may move either into the other's place, so the body writer and the cell writer read both
+ * the same way, from here.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import type { ExportRefs } from "./exportRefs";
+import { type SessionStore } from "./session";
+/** Why there is no original to write, which a block that came in from another document answers differently */
+export declare function lostOriginal(node: PMNode, session: SessionStore | null): string;
+export declare function serializePreservedBlock(node: PMNode, refs: ExportRefs): string;

package/dist/docx/serializePreserved.js

@@ -0,0 +1,24 @@
+// src/docx/serializePreserved.ts
+import { DocxExportError } from "../ooxml/errors.js";
+import { originalBlock, splitBlockKey } from "./session.js";
+function lostOriginal(node, session) {
+  const srcId = node.attrs.srcId;
+  const key = typeof srcId === "string" ? splitBlockKey(srcId) : null;
+  return key === null || key.sessionId === session?.sessionId ? "a preserved block has lost its original XML" : `a preserved block comes from another document (${key.sessionId})`;
+}
+function serializePreservedBlock(node, refs) {
+  const xml = node.attrs.xml;
+  if (typeof xml === "string") return xml;
+  const imported = refs.session ? originalBlock(node, refs.session) : void 0;
+  if (!imported) {
+    throw new DocxExportError(
+      "lost-original",
+      lostOriginal(node, refs.session)
+    );
+  }
+  return imported.xml;
+}
+export {
+  lostOriginal,
+  serializePreservedBlock
+};

package/dist/docx/serializeStory.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Writes a side story back into the element it stands in.
+ *
+ * The rule is the body's rule (`./serializeBlock`): a story nobody edited goes back out as the
+ * bytes it arrived as, and one that was edited is written block by block, each untouched block
+ * still verbatim. That is what keeps a comment's second paragraph and its run formatting through
+ * an edit of the first, and what keeps an untouched Comments part byte-identical.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import type { ExportRefs } from "./exportRefs";
+import type { ImportedStory } from "./story";
+/** The two ends of the element a story stands in, for a story the package did not arrive holding */
+export interface StoryContainer {
+    open: string;
+    close: string;
+}
+export declare function serializeStory(current: PMNode, imported: ImportedStory | null, container: StoryContainer, refs: ExportRefs): string;

package/dist/docx/serializeStory.js

@@ -0,0 +1,17 @@
+// src/docx/serializeStory.ts
+import { sameSource } from "../schema/sourceEquality.js";
+import { blockXml } from "./serializeBlock.js";
+function serializeStory(current, imported, container, refs) {
+  const ends = imported ?? container;
+  if (imported && sameSource(current, imported.doc)) {
+    return ends.open + imported.blocks.map((block) => block.xml).join("") + ends.close;
+  }
+  const pieces = [];
+  current.forEach((block) => {
+    pieces.push(blockXml(block, refs, current.childCount === 1));
+  });
+  return ends.open + pieces.join("") + ends.close;
+}
+export {
+  serializeStory
+};

package/dist/docx/serializeTable.js

@@ -17,11 +17,8 @@ import {
 } from "../ooxml/props.js";
 import { ST_MeasurementOrPercent, ST_TwipsMeasure } from "../ooxml/simpleTypes.js";
 import { NO_EXPORT_REFS } from "./exportRefs.js";
-import {
-  preservedXml,
-  rawAttrsOf,
-  serializeParagraph
-} from "./serializeParagraph.js";
+import { rawAttrsOf, serializeParagraph } from "./serializeParagraph.js";
+import { serializePreservedBlock } from "./serializePreserved.js";
 function propsOf(xml, tag) {
   if (typeof xml !== "string") return { tag, attrs: null, children: [] };
   const parsed = parseProps(xml);
@@ -99,12 +96,12 @@ function cellPropsXml(cell, role) {
 }
 function cellBlockXml(block, refs) {
   if (block.type.name === "paragraph") return serializeParagraph(block, refs);
-  if (block.type.name === "rawBlock") return preservedXml(block);
   if (block.type.name === "table") return serializeTable(block, refs);
-  throw new DocxExportError(
-    "unsupported-content",
-    `block that cannot go inside a table cell: ${block.type.name}`
-  );
+  return serializePreservedBlock(block, refs);
+}
+function markerXml(node, attr) {
+  const xml = node.attrs[attr];
+  return typeof xml === "string" ? xml : "";
 }
 function wrapInSdt(xml, cell, role) {
   const prefix = cell.attrs.sdtPrefix;
@@ -114,7 +111,7 @@ function wrapInSdt(xml, cell, role) {
 function cellXml(cell, role, refs) {
   const body = role === "continue" ? elementXml(wName("p"), []) : cell.children.map((block) => cellBlockXml(block, refs)).join("");
   const xml = openTagXml(wName("tc"), rawAttrsOf(cell.attrs.tcAttrs)) + cellPropsXml(cell, role) + body + "</w:tc>";
-  return wrapInSdt(xml, cell, role);
+  return wrapInSdt(xml, cell, role) + (role === "start" ? markerXml(cell, "trailingXml") : "");
 }
 function placeRow(row, covering) {
   const placed = [];
@@ -147,7 +144,7 @@ function rowXml(row, covering, refs) {
   const cells = placeRow(row, covering).map((placed) => cellXml(placed.cell, placed.role, refs)).join("");
   const tblPrEx = row.attrs.tblPrEx;
   const trPr = row.attrs.trPr;
-  return openTagXml(wName("tr"), rawAttrsOf(row.attrs.trAttrs)) + (typeof tblPrEx === "string" ? tblPrEx : "") + (typeof trPr === "string" ? trPr : "") + cells + "</w:tr>";
+  return openTagXml(wName("tr"), rawAttrsOf(row.attrs.trAttrs)) + (typeof tblPrEx === "string" ? tblPrEx : "") + (typeof trPr === "string" ? trPr : "") + markerXml(row, "leadingXml") + cells + "</w:tr>" + markerXml(row, "trailingXml");
 }
 function serializeTable(table, refs = NO_EXPORT_REFS) {
   const covering = [];
@@ -158,7 +155,7 @@ function serializeTable(table, refs = NO_EXPORT_REFS) {
       "a vertical merge in the table reaches past the last row"
     );
   }
-  return openTagXml(wName("tbl"), rawAttrsOf(table.attrs.tblAttrs)) + tablePropsXml(table) + tableGridXml(table) + rows + "</w:tbl>";
+  return openTagXml(wName("tbl"), rawAttrsOf(table.attrs.tblAttrs)) + tablePropsXml(table) + tableGridXml(table) + markerXml(table, "leadingXml") + rows + "</w:tbl>";
 }
 export {
   serializeTable

package/dist/docx/session.d.ts

@@ -10,10 +10,12 @@
 import type { Node as PMNode } from "prosemirror-model";
 import type { DocumentDefaults } from "../model/format";
 import { type Numbering, type NumberingOptions } from "../numbering/parseNumbering";
-import type { ImportedComments } from "./comments";
+import { type StoryKey } from "../schema/stories";
+import type { ImportedComments } from "./comments/reading";
 import { type FormattingContext, type ParagraphStyleOption } from "./formatting";
-import type { HeadersFooters } from "./headersFooters";
+import type { HeaderFooterStories } from "./headersFooters";
 import type { PageGeometry } from "./pageGeometry";
+import type { ImportedStory } from "./story";
 export interface ImportedBlock {
     xml: string;
     /** The node as it was the moment the document was opened. Compared against the current node to tell whether it was edited */
@@ -55,7 +57,7 @@ export declare class SessionStore implements DocxSession, SessionIdentity {
     readonly defaults: DocumentDefaults;
     /** The effective automatic tab interval read from settings.xml. Used for display only. */
     readonly defaultTabStopPt: number;
-    /** The paper this document is written on, read from the first section. Used for display only: the `w:sectPr` itself goes back out in the preserved tail */
+    /** The paper this document is written on, read from the first section. Used for display only: the `w:sectPr` itself goes back out as the text it arrived as */
     readonly geometry: PageGeometry;
     /** Everything the display values of a paragraph or a run are resolved against: the style chain, the defaults, the list definitions */
     readonly formatting: FormattingContext;
@@ -69,9 +71,24 @@ export declare class SessionStore implements DocxSession, SessionIdentity {
     readonly comments: ImportedComments;
     /** Comment ids referenced by the original main story. A missing id after editing means deletion. */
     readonly commentReferenceIds: ReadonlySet<string>;
-    /** First-section header and footer stories projected for the page preview. */
-    readonly headersFooters: HeadersFooters;
-    constructor(opened: Omit<SessionStore, "kind">);
+    /**
+     * What picking one section's headers and footers takes beyond the section itself: which story
+     * each header or footer relationship names, and the document-wide switch between odd and even.
+     * The stories themselves stand with every other one, so an edited header is read the same way.
+     */
+    readonly headerFooterStories: HeaderFooterStories;
+    /**
+     * The side stories the package arrived holding - a comment's body, a footnote's - each as the
+     * blocks it was written in. What the document currently says stands on the document node
+     * instead (`docx/story`), so the two compare the way a body block and its original do.
+     */
+    readonly stories: ReadonlyMap<StoryKey, ImportedStory>;
+    constructor(opened: Omit<SessionStore, "kind" | "blocksOf">);
+    /**
+     * The blocks of one story as it arrived, which is what a block key of that story indexes into.
+     * Empty for a story this document does not hold.
+     */
+    blocksOf(key: string): readonly ImportedBlock[];
 }
 /**
  * The store behind a session token.

package/dist/docx/session.js

@@ -2,6 +2,7 @@
 import {
   parseNumbering
 } from "../numbering/parseNumbering.js";
+import { asStoryKey } from "../schema/stories.js";
 import {
   numberingOptionsFor
 } from "./formatting.js";
@@ -24,7 +25,7 @@ var SessionStore = class {
   defaults;
   /** The effective automatic tab interval read from settings.xml. Used for display only. */
   defaultTabStopPt;
-  /** The paper this document is written on, read from the first section. Used for display only: the `w:sectPr` itself goes back out in the preserved tail */
+  /** The paper this document is written on, read from the first section. Used for display only: the `w:sectPr` itself goes back out as the text it arrived as */
   geometry;
   /** Everything the display values of a paragraph or a run are resolved against: the style chain, the defaults, the list definitions */
   formatting;
@@ -38,8 +39,18 @@ var SessionStore = class {
   comments;
   /** Comment ids referenced by the original main story. A missing id after editing means deletion. */
   commentReferenceIds;
-  /** First-section header and footer stories projected for the page preview. */
-  headersFooters;
+  /**
+   * What picking one section's headers and footers takes beyond the section itself: which story
+   * each header or footer relationship names, and the document-wide switch between odd and even.
+   * The stories themselves stand with every other one, so an edited header is read the same way.
+   */
+  headerFooterStories;
+  /**
+   * The side stories the package arrived holding - a comment's body, a footnote's - each as the
+   * blocks it was written in. What the document currently says stands on the document node
+   * instead (`docx/story`), so the two compare the way a body block and its original do.
+   */
+  stories;
   constructor(opened) {
     this.sessionId = opened.sessionId;
     this.parts = opened.parts;
@@ -57,7 +68,17 @@ var SessionStore = class {
     this.numberingPartPath = opened.numberingPartPath;
     this.comments = opened.comments;
     this.commentReferenceIds = opened.commentReferenceIds;
-    this.headersFooters = opened.headersFooters;
+    this.headerFooterStories = opened.headerFooterStories;
+    this.stories = opened.stories;
+  }
+  /**
+   * The blocks of one story as it arrived, which is what a block key of that story indexes into.
+   * Empty for a story this document does not hold.
+   */
+  blocksOf(key) {
+    if (key === BODY_STORY_KEY) return this.blocks;
+    const story = asStoryKey(key);
+    return story === null ? [] : this.stories.get(story)?.blocks ?? [];
   }
 };
 function sessionOf(session) {
@@ -100,7 +121,7 @@ function originalBlock(node, session) {
   if (typeof srcId !== "string") return void 0;
   const key = splitBlockKey(srcId);
   if (key === null || key.sessionId !== session.sessionId) return void 0;
-  return key.storyKey === BODY_STORY_KEY ? session.blocks[key.index] : void 0;
+  return session.blocksOf(key.storyKey)[key.index];
 }
 export {
   BODY_STORY_KEY,

package/dist/docx/story.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Reads a side story - a comment's body, a footnote's - the way the body of the document is read.
+ *
+ * A story is a document of the same schema, built by the same block readers, sliced verbatim by
+ * the same scanner. That is what lets a comment keep its bold run, its paragraph style and its
+ * second paragraph through an edit: the editor no longer holds a body as the plain text it reads
+ * as, but as the blocks it was written in, and writes back the ones nobody touched exactly as they
+ * arrived (`./serializeStory`).
+ *
+ * The stories the package arrived holding live on the session; what the document currently says
+ * lives on the document node, under `doc.attrs.stories`, so an edit to one rides a transaction and
+ * lands in the history beside every other edit.
+ */
+import { type Node as PMNode } from "prosemirror-model";
+import { type StoryKey, type StoryKind, storyNodeOf } from "../schema/stories";
+import { type FormattingContext } from "./formatting";
+import { type ImportSources } from "./importParagraph";
+import { type ImportedBlock, type SessionIdentity } from "./session";
+export type { StoryJson, StoryKey, StoryKind } from "../schema/stories";
+export { asStoryKey, sameStory, storiesOf, storyKey, withoutCommentStories, } from "../schema/stories";
+/** The story this key names as a document node, and null where the document holds none */
+export declare const storyOf: typeof storyNodeOf;
+/** One story as the package arrived holding it: where it stands, and the blocks it was written in */
+export interface ImportedStory {
+    key: StoryKey;
+    kind: StoryKind;
+    id: string;
+    partPath: string;
+    /** The whole element as written, which is what a story nobody edited goes back out as */
+    xml: string;
+    /**
+     * The container's opening tag as written, e.g. `<w:comment w:id="4" w:author="A">`. A container
+     * that arrived self-closing is written out as a pair, since an edited story needs one
+     */
+    open: string;
+    /** Everything after the last block, the closing tag included */
+    close: string;
+    /** The blocks between them, sliced verbatim; a block's `srcId` indexes into this list */
+    blocks: readonly ImportedBlock[];
+    doc: PMNode;
+}
+/** Where a run of stories of one kind is written down, and what tells one of them from the next */
+export interface StoryPart {
+    kind: StoryKind;
+    partPath: string;
+    xml: string;
+    /** The local name of the element each story stands in, e.g. `comment` or `footnote` */
+    entryName: string;
+    /** The attribute naming which story an element is */
+    idAttr: string;
+}
+/** What reading a story takes beyond the text of it */
+export interface StoryDeps {
+    session: SessionIdentity;
+    /**
+     * The images and links of the part the story stands in. A story holds neither a comment nor a
+     * note of its own - WordprocessingML puts neither there - so those two are read empty.
+     */
+    sources: ImportSources;
+    formatting: FormattingContext;
+}
+/**
+ * Moves a single block into a node.
+ *
+ * A paragraph always opens editable (`./importParagraph`). What is left over is a table whose rows
+ * this reader could not take apart, a range marker standing between blocks, and a block this
+ * reader has no reader for at all; each stands as one placeholder naming the original fragment.
+ */
+export declare function buildBlock(el: Element, srcId: string, sources: ImportSources, context: FormattingContext): PMNode;
+/**
+ * Folds the style chain into the display values.
+ *
+ * These values are used for display only, so the original XML fragments are left untouched.
+ * A table is left alone: which part of it a cell belongs to is what its table style dresses the
+ * paragraphs inside by, and `buildTable` is where that is known.
+ */
+export declare function withStyleFormats(node: PMNode, context: FormattingContext): PMNode;
+/**
+ * One story as it stands in the part, with its blocks read and sliced.
+ *
+ * A container holding no block at all still opens editable, the way a body holding nothing but a
+ * section does: the placeholder paragraph names an empty original fragment, so a story nobody
+ * edited goes back out as the bytes it arrived as.
+ */
+export declare function readStory(place: {
+    kind: StoryKind;
+    id: string;
+    partPath: string;
+}, container: {
+    el: Element;
+    xml: string;
+}, deps: StoryDeps): ImportedStory;
+/** Every story one part holds, in the order the part writes them */
+export declare function readStories(part: StoryPart, deps: StoryDeps): readonly ImportedStory[];
+/** The stories of a document keyed the way the session holds them */
+export declare function storiesByKey(stories: Iterable<ImportedStory>): ReadonlyMap<StoryKey, ImportedStory>;
+/**
+ * What writing a story takes of a transaction: the document it stands on, and the one step that
+ * changes a document attr.
+ *
+ * A `Transaction` is what a caller passes, and it is named by shape rather than imported because
+ * `src/core.ts` must reach neither the editor nor `prosemirror-state` (`src/core.test.ts`), and
+ * this module is on the way there.
+ */
+interface StoryWriter {
+    readonly doc: PMNode;
+    setDocAttribute(attr: string, value: unknown): this;
+}
+/** The document with this story written into it, which is the one way a story changes */
+export declare function setStory<T extends StoryWriter>(tr: T, key: StoryKey, story: PMNode): T;
+/** The document with these stories taken out of it, which is what deleting what they say leaves */
+export declare function withoutStories<T extends StoryWriter>(tr: T, keys: Iterable<StoryKey>): T;
+/**
+ * A story holding this text, one paragraph broken by a line break wherever the text is.
+ *
+ * That is the shape a plain-text body has been written in since before there were stories, so a
+ * body written through `updateComment` goes out as the bytes it always did.
+ */
+export declare function storyFromText(text: string): PMNode;
+/**
+ * What one leaf of a story puts on screen.
+ *
+ * A break ends a line, and a fragment the editor keeps rather than models says what it stands for
+ * - the character a `w:noBreakHyphen` draws, the words inside a field - which is the same answer
+ * `docx/importPolicy` gave when a body was flattened on the way in. Everything reading a story as
+ * plain text - a comment body, a footnote body, a header preview - asks here rather than keeping a
+ * vocabulary of its own, so the three of them cannot disagree.
+ */
+export declare function storyLeafText(leaf: PMNode): string;
+/** What a story reads as on screen: its paragraphs joined by newlines, its breaks and tabs kept */
+export declare function storyText(story: PMNode | null): string;
+/**
+ * The story with the thread key on the last paragraph of it, which is where Word keeps it.
+ *
+ * The key is written into the paragraph's own attribute text rather than into a model attr,
+ * because that text is what the writer puts back and a `w14:paraId` is not a name this schema
+ * holds. A paragraph already carrying one keeps it: a key already written is what the thread
+ * state elsewhere is keyed by, so re-pointing it would orphan that state.
+ */
+export declare function withThreadKeyOn(story: PMNode, paraId: string): PMNode;