@portone/docx-editor 0.4.0 → 0.5.1

package/dist/schema/editGuard.d.ts

@@ -46,7 +46,7 @@ export type EditIntent =
  * against the places it puts that guard to the test, and a place naming a guard that no longer
  * stands has to be a mistake the compiler catches rather than an annotation answering for nothing.
  */
-export type EditGuardName = "protection" | "lock" | "bookmark" | "note" | "section";
+export type EditGuardName = "protection" | "lock" | "preserved" | "note" | "section";
 /** What every guard answers, whichever of the two judgements it is written as */
 interface GuardCommon {
     readonly name: EditGuardName;

package/dist/schema/guards.js

@@ -4,7 +4,7 @@ import {
   transactionReaches
 } from "./editGuard.js";
 import { lockGuard } from "./locks.js";
-import { bookmarkGuard, noteGuard, sectionGuard } from "./preservedGuards.js";
+import { noteGuard, preservedGuard, sectionGuard } from "./preservedGuards.js";
 import {
   isCommentNode,
   protectionAllows
@@ -36,7 +36,7 @@ var protectionGuard = {
 var EDIT_GUARDS = [
   protectionGuard,
   lockGuard,
-  bookmarkGuard,
+  preservedGuard,
   noteGuard,
   sectionGuard
 ];

package/dist/schema/index.d.ts

@@ -1,4 +1,5 @@
 export type { AttrClass } from "./attrRoles";
 export { attrsOfClass } from "./attrRoles";
+export type { PreservedDisplay } from "./docxSchema";
 export { docxSchema, isPageBreak } from "./docxSchema";
 export { imageNodeSpec, runMarkSpec } from "./rendering";

package/dist/schema/locks.d.ts

@@ -56,6 +56,9 @@ export interface ControlSpan extends StepRange {
  * A control that wrapped several runs comes in as several inlines wearing the very same mark, and
  * what a lock answers for is the control rather than the run: a stretch covering one run of a
  * control whole still covers only a part of the control.
+ *
+ * A control standing inside another gives a span of its own, the outer one first, and the two
+ * overlap: each locks on its own terms.
  */
 export declare function controlSpans(block: Textblock): ControlSpan[];
 /**

package/dist/schema/locks.js

@@ -10,11 +10,12 @@ import {
   ReplaceStep
 } from "prosemirror-transform";
 import { docxSchema } from "./index.js";
+import { wrappersOf } from "./wrappers.js";
 var unlockAllowed = new PluginKey("docxEditorUnlockAllowed");
 var historyReplay = new PluginKey("docxEditorHistoryReplay");
 var OPEN = { contents: false, deletion: false };
-function sdtMarkOf(node) {
-  return node?.marks.find((mark) => mark.type === docxSchema.marks.sdt) ?? null;
+function sdtMarksOf(node) {
+  return node ? wrappersOf(node, docxSchema.marks.sdt) : [];
 }
 function markLocks(mark) {
   return {
@@ -23,8 +24,7 @@ function markLocks(mark) {
   };
 }
 function lockedMarkOf(node) {
-  const mark = sdtMarkOf(node);
-  return mark !== null && markLocks(mark).contents ? mark : null;
+  return sdtMarksOf(node).find((mark) => markLocks(mark).contents) ?? null;
 }
 var CELL_CONTENTS_ATTR = "sdtContentsLocked";
 var CELL_DELETION_ATTR = "sdtDeletionLocked";
@@ -42,20 +42,37 @@ function isLockedCell(node) {
   return cellLocks(node).contents;
 }
 function carriesLock(node) {
-  const mark = node.isInline ? sdtMarkOf(node) : null;
-  const locks = mark === null ? cellLocks(node) : markLocks(mark);
-  return locks.contents || locks.deletion;
+  const marks = node.isInline ? sdtMarksOf(node) : [];
+  if (marks.length === 0) {
+    const locks = cellLocks(node);
+    return locks.contents || locks.deletion;
+  }
+  return marks.some((mark) => {
+    const locks = markLocks(mark);
+    return locks.contents || locks.deletion;
+  });
 }
 function controlSpans(block) {
   const spans = [];
+  let reaching = [];
   block.node.forEach((child, offset) => {
-    const mark = sdtMarkOf(child);
-    if (!mark) return;
     const from = block.start + offset;
     const to = from + child.nodeSize;
-    const last = spans.at(-1);
-    if (last && last.to === from && last.mark.eq(mark)) last.to = to;
-    else spans.push({ from, to, mark });
+    const standing = [];
+    for (const mark of sdtMarksOf(child)) {
+      const carried = reaching.find(
+        (span) => span.to === from && span.mark.eq(mark)
+      );
+      if (carried) {
+        carried.to = to;
+        standing.push(carried);
+        continue;
+      }
+      const started = { from, to, mark };
+      spans.push(started);
+      standing.push(started);
+    }
+    reaching = standing;
   });
   return spans;
 }

package/dist/schema/preservedFragments.d.ts

@@ -0,0 +1,12 @@
+import type { Node as PMNode } from "prosemirror-model";
+type MarkerAttr = "leadingXml" | "trailingXml";
+/**
+ * Whether this node is content the editor keeps as it came rather than one it models.
+ *
+ * The block placeholder declares it as a group; the two inline ones cannot, since their group says
+ * where they may stand, so they are named here and asked for by name everywhere else.
+ */
+export declare function isPreservedNode(node: PMNode): boolean;
+/** Visit preserved XML in the order the writer places it around editable content. */
+export declare function visitPreservedFragments(doc: PMNode, visit: (node: PMNode, pos: number, xml: string | null, attr?: MarkerAttr) => void): void;
+export {};

package/dist/schema/preservedFragments.js

@@ -0,0 +1,38 @@
+// src/schema/preservedFragments.ts
+function isPreservedNode(node) {
+  return node.type.name === "rawInline" || node.type.name === "rawRunContent" || node.type.isInGroup("preserved");
+}
+function visitPreservedFragments(doc, visit) {
+  const visitAttr = (node, pos, attr) => {
+    const xml = node.attrs[attr];
+    if (typeof xml === "string" && xml.length > 0) {
+      visit(node, pos, xml, attr);
+    }
+  };
+  const walk = (node, pos) => {
+    if (isPreservedNode(node)) {
+      visit(
+        node,
+        pos,
+        typeof node.attrs.xml === "string" ? node.attrs.xml : null
+      );
+    }
+    if (node.type.name === "table" || node.type.name === "tableRow") {
+      visitAttr(node, pos, "leadingXml");
+    }
+    node.forEach((child, offset) => {
+      walk(child, pos + 1 + offset);
+    });
+    if (node.type.name === "tableRow" || node.type.name === "tableCell") {
+      visitAttr(node, pos, "trailingXml");
+    }
+  };
+  doc.descendants((node, pos) => {
+    walk(node, pos);
+    return false;
+  });
+}
+export {
+  isPreservedNode,
+  visitPreservedFragments
+};

package/dist/schema/preservedGuards.d.ts

@@ -1,11 +1,13 @@
 /**
- * The guards over what a document is opened with and the editor only preserves: the two ends of a
- * bookmark range, the reference standing where a footnote or an endnote is called, and the
- * paragraph that ends a section.
+ * The guards over what a document is opened with and the editor only preserves: the fragments a
+ * file falls apart without, the reference standing where a footnote or an endnote is called, and
+ * the paragraph that ends a section.
  *
- * None of it is content the editor writes, so nothing in it can put such a thing back once it is
- * gone, and a document that lost one of a bookmark's two ends cannot be written back as a file at
- * all (`docx/exportDocx` refuses it). What the first two guards hold is therefore the whole list of
+ * The first of those is the two ends of a bookmark range, the two ends of a permission or move
+ * range, and the pieces of a field, which say what they say only in the order they stand in. None
+ * of it is content the editor writes, so nothing in it can put such a thing back once it is gone,
+ * and a document that lost one of a bookmark's two ends cannot be written back as a file at all
+ * (`docx/exportDocx` refuses it). What the first two guards hold is therefore the whole list of
  * the nodes they answer for, in the order the document carries them; a section break, which an
  * edit may legitimately move from one paragraph to another, is held by its number instead.
  */
@@ -27,7 +29,7 @@ type Signature = (node: PMNode) => string;
  * was.
  */
 export declare function preservedNodeGuard(name: EditGuardName, holds: (node: PMNode) => boolean, signature: Signature): ChangeGuard;
-export declare const bookmarkGuard: ChangeGuard;
+export declare const preservedGuard: ChangeGuard;
 export declare const noteGuard: ChangeGuard;
 /**
  * A guard that lets a change through only while it leaves at least as many section breaks standing

package/dist/schema/preservedGuards.js

@@ -1,9 +1,26 @@
 // src/schema/preservedGuards.ts
+import {
+  AddMarkStep,
+  AddNodeMarkStep,
+  AttrStep,
+  RemoveMarkStep,
+  RemoveNodeMarkStep,
+  ReplaceAroundStep,
+  ReplaceStep
+} from "prosemirror-transform";
+import { W_NS } from "../ooxml/names.js";
 import { parseProps, propsChild } from "../ooxml/props.js";
+import {
+  COMMENT_RANGE_MARKERS,
+  PERMISSION_MARKERS,
+  RANGE_MARKERS
+} from "../ooxml/rangeMarkers.js";
+import { parseAttrs } from "../ooxml/tagScan.js";
 import {
   rangeHolds,
   transactionReaches
 } from "./editGuard.js";
+import { visitPreservedFragments } from "./preservedFragments.js";
 function signatures(doc, holds, signature) {
   const found = [];
   doc.descendants((node) => {
@@ -23,19 +40,103 @@ function preservedNodeGuard(name, holds, signature) {
     shuts: (intent, state) => intent.kind === "replace" && rangeHolds(state.doc, intent.from, intent.to, holds)
   };
 }
-var BOOKMARK_XML = /<(?:[\w.-]+:)?bookmark(?:Start|End)\b/;
-function isBookmarkMarker(node) {
-  if (node.type.name === "bookmarkBlock") return true;
-  return node.type.name === "rawInline" && typeof node.attrs.xml === "string" && BOOKMARK_XML.test(node.attrs.xml);
+function isGuardedFragment(node) {
+  return node.attrs.guarded === true;
 }
-function bookmarkSignature(node) {
-  return node.type.name === "bookmarkBlock" ? `block:${node.attrs.srcId}:${node.attrs.name}` : `inline:${node.attrs.xml}`;
+function preservedSignature(node) {
+  return `${node.type.name}:${node.attrs.name}:${node.attrs.srcId}:${node.attrs.xml}`;
 }
-var bookmarkGuard = preservedNodeGuard(
-  "bookmark",
-  isBookmarkMarker,
-  bookmarkSignature
+var guardedNodes = preservedNodeGuard(
+  "preserved",
+  isGuardedFragment,
+  preservedSignature
 );
+var rangeMarkers = /* @__PURE__ */ new Set([
+  ...RANGE_MARKERS,
+  ...PERMISSION_MARKERS,
+  ...COMMENT_RANGE_MARKERS
+]);
+function markerFragments(xml) {
+  const children = parseProps(`<markers>${xml}</markers>`)?.children ?? [];
+  return children.flatMap((child) => {
+    if (!rangeMarkers.has(child.name)) return [];
+    const props = parseProps(child.xml);
+    if (!props) return [];
+    const prefixEnd = props.tag.indexOf(":");
+    const binding = prefixEnd < 0 ? "xmlns" : `xmlns:${props.tag.slice(0, prefixEnd)}`;
+    const namespace = parseAttrs(props.attrs ?? "")?.find(
+      ([name]) => name === binding
+    )?.[1];
+    if (namespace !== void 0 && namespace !== W_NS) return [];
+    return [child.xml];
+  });
+}
+function hasMarkerAttrs(node) {
+  return (node.type.name === "table" || node.type.name === "tableRow") && typeof node.attrs.leadingXml === "string" || (node.type.name === "tableCell" || node.type.name === "tableRow") && typeof node.attrs.trailingXml === "string";
+}
+function carrierBoundaryIn(doc, from, to) {
+  let found = false;
+  doc.nodesBetween(from, to, (node, pos) => {
+    if (hasMarkerAttrs(node) && (from <= pos || to >= pos + node.nodeSize)) {
+      found = true;
+    }
+    return !found;
+  });
+  return found;
+}
+function markerAttrsReached(tr) {
+  return tr.steps.some((step, index) => {
+    const before = tr.docs[index];
+    const after = tr.docs[index + 1] ?? tr.doc;
+    if (step instanceof AttrStep || step instanceof AddNodeMarkStep || step instanceof RemoveNodeMarkStep) {
+      const old = before.nodeAt(step.pos);
+      const next = after.nodeAt(step.pos);
+      return old !== null && hasMarkerAttrs(old) || next !== null && hasMarkerAttrs(next);
+    }
+    if (step instanceof AddMarkStep || step instanceof RemoveMarkStep)
+      return false;
+    if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep))
+      return true;
+    let reached = false;
+    step.getMap().forEach((oldStart, oldEnd, newStart, newEnd) => {
+      reached ||= carrierBoundaryIn(before, oldStart, oldEnd) || carrierBoundaryIn(after, newStart, newEnd);
+    });
+    return reached;
+  });
+}
+function preservedFragments(doc) {
+  const found = [];
+  visitPreservedFragments(doc, (node, _pos, xml, attr) => {
+    if (attr !== void 0 && xml !== null) {
+      found.push(
+        ...markerFragments(xml).map((fragment) => `marker:${fragment}`)
+      );
+    } else if (isGuardedFragment(node)) {
+      found.push(preservedSignature(node));
+    }
+  });
+  return found;
+}
+var preservedGuard = {
+  name: "preserved",
+  change: (tr) => !(transactionReaches(tr, isGuardedFragment) || markerAttrsReached(tr)) || same(preservedFragments(tr.before), preservedFragments(tr.doc)),
+  shuts: (intent, state) => {
+    if (guardedNodes.shuts(intent, state)) return true;
+    if (intent.kind !== "replace") return false;
+    let shut = false;
+    state.doc.nodesBetween(intent.from, intent.to, (node, pos) => {
+      if (intent.from > pos && intent.to < pos + node.nodeSize) return true;
+      if (!hasMarkerAttrs(node)) return true;
+      for (const attr of ["leadingXml", "trailingXml"]) {
+        const xml = node.attrs[attr];
+        if (typeof xml === "string" && markerFragments(xml).length > 0)
+          shut = true;
+      }
+      return !shut;
+    });
+    return shut;
+  }
+};
 function isNoteReference(node) {
   return node.type.name === "noteReference";
 }
@@ -73,8 +174,8 @@ var sectionGuard = {
   }
 };
 export {
-  bookmarkGuard,
   noteGuard,
+  preservedGuard,
   preservedNodeGuard,
   sectionGuard
 };

package/dist/schema/protection.d.ts

@@ -44,6 +44,11 @@ export declare function withoutComments(node: PMNode): PMNode;
  * The comparison is by source (`./sourceEquality`): a display value worked out again beside a
  * comment is no content change, so it neither turns a comment edit into a body edit nor takes the
  * ownership question off it.
+ *
+ * What a comment says is a story on the document node (`./stories`), so the comment stories come
+ * off before the markers do; without that, writing one of them would move the document node and
+ * every comment edit would read as a body edit. The footnote and header stories stay: rewriting
+ * one of those is a change to what the document says, and a comment protection turns it down.
  */
 export declare function changesOnlyComments(before: PMNode, after: PMNode): boolean;
 /**
@@ -82,9 +87,33 @@ export declare function commentEditsOwned(before: PMNode, after: PMNode, rules:
  */
 export declare function protectionAllows(before: PMNode, after: PMNode, rules: ProtectionState): boolean;
 /**
- * Whether every comment and reply that appeared between the two documents was written under this
- * identity, and every one that was already there kept the identity it was written under. The
- * editor takes an addition from anyone, since it writes the author itself; a server taking a file
- * back does not, since the file could claim any author.
+ * The display names these comment bodies write under while recording nobody for them.
+ *
+ * A name here is one no comment in the file can be attributed through, so a comment that appears
+ * under it names no more of a person than the ones already there do.
+ */
+export declare function unattributedCommentAuthors(bodies: Iterable<{
+    author: string | null;
+    authorId: string | null;
+}>): ReadonlySet<string>;
+/**
+ * Whether a comment or reply that appeared is one this author was in a position to write.
+ *
+ * One carrying this identity is, since a file can claim any author and only the requester's own
+ * identity vouches for itself. So is one carrying no identity at all under a name the original
+ * already holds unattributed: the writer records no person for such a name, precisely so that the
+ * comments already written under it are not handed to whoever comments next (`docx/comments/people`),
+ * and a submission the writer produced has to be one the verifier takes. Such a comment claims
+ * nobody and stays everyone's to edit, and the name it shows was already in the file.
+ */
+export declare function commentAdditionAllowed(added: {
+    author: string | null;
+    authorId: string | null;
+}, authorId: string, unattributed: ReadonlySet<string>): boolean;
+/**
+ * Whether every comment and reply that appeared between the two documents was one this identity
+ * could have written, and every one that was already there kept the identity it was written under.
+ * The editor takes an addition from anyone, since it writes the author itself; a server taking a
+ * file back does not, since the file could claim any author.
  */
-export declare function commentAdditionsBy(before: PMNode, after: PMNode, authorId: string): boolean;
+export declare function commentAdditionsBy(before: PMNode, after: PMNode, authorId: string, unattributed?: ReadonlySet<string>): boolean;

package/dist/schema/protection.js

@@ -1,6 +1,12 @@
 // src/schema/protection.ts
 import { Fragment } from "prosemirror-model";
 import { sameSource } from "./sourceEquality.js";
+import {
+  sameStory,
+  storyKey,
+  storyNodeOf,
+  withoutCommentStories
+} from "./stories.js";
 var COMMENT_NODES = /* @__PURE__ */ new Set([
   "commentStart",
   "commentEnd",
@@ -18,21 +24,25 @@ function withoutComments(node) {
   return node.copy(Fragment.fromArray(kept));
 }
 function changesOnlyComments(before, after) {
-  return sameSource(withoutComments(before), withoutComments(after));
+  return sameSource(
+    withoutComments(withoutCommentStories(before)),
+    withoutComments(withoutCommentStories(after))
+  );
 }
 function stringOrNull(value) {
   return typeof value === "string" ? value : null;
 }
-function bodyOf(attrs) {
+function bodyOf(attrs, doc) {
+  const id = stringOrNull(attrs.id);
   return {
     authorId: stringOrNull(attrs.authorId),
     author: stringOrNull(attrs.author),
     initials: stringOrNull(attrs.initials),
     date: stringOrNull(attrs.date),
-    text: stringOrNull(attrs.text) ?? ""
+    body: id === null ? null : storyNodeOf(doc, storyKey("comment", id))
   };
 }
-function replyBodies(value) {
+function replyBodies(value, doc) {
   const replies = /* @__PURE__ */ new Map();
   if (!Array.isArray(value)) return replies;
   for (const entry of value) {
@@ -40,7 +50,7 @@ function replyBodies(value) {
     const reply = entry;
     const id = stringOrNull(reply.id);
     if (id === null) continue;
-    replies.set(id, bodyOf(reply));
+    replies.set(id, bodyOf(reply, doc));
   }
   return replies;
 }
@@ -51,8 +61,8 @@ function threadsIn(doc) {
     const id = stringOrNull(node.attrs.id);
     if (id === null || threads.has(id)) return true;
     threads.set(id, {
-      ...bodyOf(node.attrs),
-      replies: replyBodies(node.attrs.replies)
+      ...bodyOf(node.attrs, doc),
+      replies: replyBodies(node.attrs.replies, doc)
     });
     return true;
   });
@@ -90,7 +100,7 @@ function sameIdentity(was, now) {
   return was.authorId === now.authorId && was.author === now.author;
 }
 function sameWords(was, now) {
-  return was.text === now.text && was.initials === now.initials && was.date === now.date;
+  return sameStory(was.body, now.body) && was.initials === now.initials && was.date === now.date;
 }
 function commentIdentitiesKept(before, after) {
   const now = threadsIn(after);
@@ -140,33 +150,51 @@ function protectionAllows(before, after, rules) {
     }
   }
 }
-function commentAdditionsBy(before, after, authorId) {
+function unattributedCommentAuthors(bodies) {
+  const names = /* @__PURE__ */ new Set();
+  for (const body of bodies) {
+    if (body.authorId === null && body.author !== null) names.add(body.author);
+  }
+  return names;
+}
+function commentAdditionAllowed(added, authorId, unattributed) {
+  if (added.authorId !== null) return added.authorId === authorId;
+  return added.author !== null && unattributed.has(added.author);
+}
+function commentAdditionsBy(before, after, authorId, unattributed) {
   if (!commentIdentitiesKept(before, after)) return false;
   const was = threadsIn(before);
+  const names = unattributed ?? unattributedCommentAuthors(
+    Array.from(was.values()).flatMap((thread) => [
+      thread,
+      ...thread.replies.values()
+    ])
+  );
+  const allowed = (added) => commentAdditionAllowed(added, authorId, names);
   for (const [id, thread] of threadsIn(after)) {
     const earlier = was.get(id);
     if (earlier === void 0) {
-      if (thread.authorId !== authorId) return false;
+      if (!allowed(thread)) return false;
       for (const reply of thread.replies.values()) {
-        if (reply.authorId !== authorId) return false;
+        if (!allowed(reply)) return false;
       }
       continue;
     }
     for (const [replyId, reply] of thread.replies) {
-      if (!earlier.replies.has(replyId) && reply.authorId !== authorId) {
-        return false;
-      }
+      if (!earlier.replies.has(replyId) && !allowed(reply)) return false;
     }
   }
   return true;
 }
 export {
   changesOnlyComments,
+  commentAdditionAllowed,
   commentAdditionsBy,
   commentEditsOwned,
   commentIdentitiesKept,
   commentOwned,
   isCommentNode,
   protectionAllows,
+  unattributedCommentAuthors,
   withoutComments
 };

package/dist/schema/rendering.d.ts

@@ -1,6 +1,20 @@
 import type { Attrs, DOMOutputSpec } from "prosemirror-model";
 import type { FontFallbacks } from "../styles/fontStack";
+/**
+ * What a run says to anyone reading it, the page and a copy of it alike.
+ *
+ * The rest of the drawing is this editor talking to itself - the original XML, the worked-out
+ * formatting it was drawn from - and `schema/clipboard` publishes only what is here.
+ */
+export declare function runAttrs(attrs: Attrs, fontFallbacks: FontFallbacks): Record<string, string | undefined>;
 /** The DOM representation shared by the schema and the editor's custom run mark view. */
 export declare function runMarkSpec(attrs: Attrs, fontFallbacks: FontFallbacks): DOMOutputSpec;
+/**
+ * What an image says to anyone reading it, the page and a copy of it alike.
+ *
+ * The size is given in the pixels it is drawn at rather than as the document's own measure in EMU,
+ * which is what makes it the half another application can read.
+ */
+export declare function imageAttrs(attrs: Attrs): Record<string, string | undefined>;
 /** The image element shared by the schema and the resizable image node view. */
 export declare function imageNodeSpec(attrs: Attrs): DOMOutputSpec;

package/dist/schema/rendering.js

@@ -9,38 +9,53 @@ function text(value) {
 function formatJson(format) {
   return format ? JSON.stringify(format) : void 0;
 }
+function runAttrs(attrs, fontFallbacks) {
+  const format = toRunFormat(attrs.format);
+  return {
+    class: editorClassNames.run,
+    style: runStyle(format, fontFallbacks),
+    // Which shape of a Han character the browser draws is decided by this and nothing else
+    lang: format?.lang
+  };
+}
 function runMarkSpec(attrs, fontFallbacks) {
   const format = toRunFormat(attrs.format);
   return [
     "span",
     {
-      class: editorClassNames.run,
-      style: runStyle(format, fontFallbacks),
-      // Which shape of a Han character the browser draws is decided by this and nothing else
-      lang: format?.lang,
+      ...runAttrs(attrs, fontFallbacks),
       "data-rattrs": text(attrs.rAttrs),
       "data-rpr": text(attrs.rPr),
-      "data-fmt": formatJson(format)
+      "data-fmt": formatJson(format),
+      // Read by `styles/editor.css` to stand a link's own line down
+      "data-underline": format?.underline && format.underline !== "none" ? "" : void 0
     },
     0
   ];
 }
-function imageNodeSpec(attrs) {
+function imageAttrs(attrs) {
   const extent = toImageExtent(attrs.extent);
+  return {
+    class: editorClassNames.image,
+    src: toImageSrc(attrs.src) ?? void 0,
+    alt: text(attrs.alt) ?? "",
+    width: extent ? `${Math.round(emuToPx(extent.cx))}` : void 0,
+    height: extent ? `${Math.round(emuToPx(extent.cy))}` : void 0
+  };
+}
+function imageNodeSpec(attrs) {
   return [
     "img",
     {
-      class: editorClassNames.image,
-      src: toImageSrc(attrs.src) ?? void 0,
-      alt: text(attrs.alt) ?? "",
-      width: extent ? `${Math.round(emuToPx(extent.cx))}` : void 0,
-      height: extent ? `${Math.round(emuToPx(extent.cy))}` : void 0,
-      "data-extent": formatJson(extent),
+      ...imageAttrs(attrs),
+      "data-extent": formatJson(toImageExtent(attrs.extent)),
       "data-xml": text(attrs.xml)
     }
   ];
 }
 export {
+  imageAttrs,
   imageNodeSpec,
+  runAttrs,
   runMarkSpec
 };

package/dist/schema/stories.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The side stories a document holds beside its body: a comment's text, a footnote's, a header's.
+ *
+ * Each is a document of this same schema, held on the document node under the key that names it,
+ * so an edit to one rides a transaction and lands in the history the way a body edit does. What
+ * turns one into XML and back is `docx/story`; here is only what the schema layer needs, which is
+ * the key, the value on the node, and the two comparisons the protection rules are written over.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+export type StoryKind = "comment" | "footnote" | "endnote" | "header" | "footer";
+/** `comment:4`, `footnote:2`, `header:word/header1.xml` */
+export type StoryKey = `${StoryKind}:${string}`;
+/** One story as the document node holds it, which is `Node.toJSON` of a document of this schema */
+export interface StoryJson {
+    readonly type: string;
+    readonly attrs?: Readonly<Record<string, unknown>>;
+    readonly content?: readonly unknown[];
+}
+/** The attr the stories stand on, named here so the schema and the readers cannot spell it apart */
+export declare const STORIES_ATTR = "stories";
+export declare function storyKey(kind: StoryKind, id: string): StoryKey;
+/**
+ * The key this text spells, or null for one that names no kind of story.
+ *
+ * An id carries colons of its own - a header is named by its part path - so the kind is read off
+ * the front and everything after the first colon is the id.
+ */
+export declare function asStoryKey(text: string): StoryKey | null;
+/** The stories this document holds, under the key naming each */
+export declare function storiesOf(doc: PMNode): Readonly<Record<string, StoryJson>>;
+/** The story this key names as a document node, and null where the document holds none */
+export declare function storyNodeOf(doc: PMNode, key: StoryKey): PMNode | null;
+/**
+ * Whether the two stories say the same thing.
+ *
+ * The block keys are left out of it, because they name the document each story was read from and
+ * two files opened side by side never share one. Everything else a block would be written back as
+ * is compared (`./sourceEquality`), so a body that gained a bold run reads as changed and one
+ * whose display values were worked out again does not.
+ */
+export declare function sameStory(a: PMNode | null, b: PMNode | null): boolean;
+/**
+ * The document with its comment stories taken out of it, replies included.
+ *
+ * A comment edit now moves the document node, and a comparison that could not see past that would
+ * call every comment edit a body edit. The footnote and header stories stay: changing one of them
+ * is a change to what the document says, and a comment protection is meant to turn it down.
+ */
+export declare function withoutCommentStories(doc: PMNode): PMNode;