@portone/docx-editor 0.4.0 → 0.5.1

package/dist/editor/clipboard/readContext.d.ts

@@ -0,0 +1,34 @@
+import type { EditorState } from "prosemirror-state";
+import type { FormattingContext, ParagraphStyleOption } from "../../docx/formatting";
+import type { PageGeometry } from "../../docx/pageGeometry";
+import type { ImageToInsert } from "../insertImage";
+import type { HtmlSource } from "./source";
+/**
+ * Everything a piece of HTML is read against.
+ *
+ * The reader answers about the document it is read into - which styles it may name, which list
+ * numbers are taken, whether a list may be started at all - and nothing about the editor holding
+ * it. Gathering those in one place is what keeps the reader off the editing state, so the same
+ * reading can be asked for from a paste, from a drop, and from a test.
+ */
+export interface HtmlReadContext {
+    /** The document the markup is read into an element of */
+    document: Document;
+    formatting: FormattingContext;
+    /** The paper a block read into the document lands on, which is the width a pasted table takes */
+    geometry: PageGeometry;
+    paragraphStyles: readonly ParagraphStyleOption[];
+    numbering: {
+        used: ReadonlySet<number>;
+        canCreate: boolean;
+    };
+    /** The images already loaded for this read, by the token the markup carries */
+    images: ReadonlyMap<string, ImageToInsert>;
+    /**
+     * The application that wrote the markup being read (`./source`). It is a property of the markup
+     * and not of the document, so a context built before any markup is in hand names no application
+     * and `readHtml` fills it in from what it is handed.
+     */
+    source: HtmlSource;
+}
+export declare function readContextOf(state: EditorState, document: Document, images?: ReadonlyMap<string, ImageToInsert>): HtmlReadContext;

package/dist/editor/clipboard/readContext.js

@@ -0,0 +1,25 @@
+// src/editor/clipboard/readContext.ts
+import { numIdsIn } from "../commands/listCommands.js";
+import {
+  documentFormatting,
+  documentParagraphStyles,
+  sectionGeometryAt
+} from "../documentStyles.js";
+import { canStartNewList } from "../plugins/numberingDecorations.js";
+function readContextOf(state, document, images = /* @__PURE__ */ new Map()) {
+  return {
+    document,
+    formatting: documentFormatting(state),
+    geometry: sectionGeometryAt(state, state.selection.from),
+    paragraphStyles: documentParagraphStyles(state),
+    numbering: {
+      used: numIdsIn(state.doc),
+      canCreate: canStartNewList(state)
+    },
+    images,
+    source: "unknown"
+  };
+}
+export {
+  readContextOf
+};

package/dist/editor/clipboard/readers.d.ts

@@ -0,0 +1,33 @@
+import { type ResolvedPos, Slice } from "prosemirror-model";
+import { type PastedContent } from "./htmlReader";
+import type { HtmlReadContext } from "./readContext";
+/** What one reader is handed: the markup on the clipboard, and the document it is read into */
+export interface ClipboardInput {
+    dom: Node;
+    /** The name the markup carries for a slice this editor kept (`./internalChannel`). Null when it carries none */
+    token: string | null;
+    /** The open document the markup is being read into. Null for a state built without one */
+    sessionId: string | null;
+    context: HtmlReadContext;
+}
+/**
+ * One way of reading a clipboard. The chain is tried in order and the first reader to answer
+ * decides what goes in, so a reader that does not recognize what it was handed answers nothing.
+ */
+export type ClipboardReader = (input: ClipboardInput) => PastedContent | null;
+/**
+ * A copy made in this same open document, handed back as the slice it was.
+ *
+ * It leads the chain because it is the only reader that loses nothing: everything below reads
+ * markup, and markup is all a copy from anywhere else amounts to here.
+ */
+export declare const internalSliceReader: ClipboardReader;
+/** Everything the editor did not write itself, read for the formatting the markup states */
+export declare const foreignHtmlReader: ClipboardReader;
+export declare const DEFAULT_READERS: readonly ClipboardReader[];
+/**
+ * Plain text as content of this document: docx has no character for a line break or a tab stop,
+ * so those become the elements it does have, and the rest keeps the formatting in force where it
+ * is put.
+ */
+export declare function plainTextSlice(text: string, $context: ResolvedPos): Slice;

package/dist/editor/clipboard/readers.js

@@ -0,0 +1,37 @@
+// src/editor/clipboard/readers.ts
+import { Fragment, Slice } from "prosemirror-model";
+import { NO_NEW_LISTS } from "../../numbering/listRegistry.js";
+import { docxSchema } from "../../schema/index.js";
+import { toPieces } from "../plainText.js";
+import { readHtml } from "./htmlReader.js";
+import { recallCopied } from "./internalChannel.js";
+var internalSliceReader = ({ token, sessionId }) => {
+  const recalled = recallCopied(token, sessionId);
+  return recalled === null ? null : { ...recalled, newLists: NO_NEW_LISTS };
+};
+var foreignHtmlReader = ({ dom, context }) => dom instanceof Element || dom instanceof DocumentFragment ? readHtml(dom, context) : null;
+var DEFAULT_READERS = [
+  internalSliceReader,
+  foreignHtmlReader
+];
+function plainTextSlice(text, $context) {
+  const marks = $context.marks();
+  const nodes = toPieces(text).map((piece) => {
+    if ("text" in piece) return docxSchema.text(piece.text, marks);
+    if (piece.node === "hardBreak") {
+      return docxSchema.nodes.hardBreak.create(null, null, marks);
+    }
+    const beside = marks.filter((mark) => mark.type !== docxSchema.marks.tab);
+    return docxSchema.text(
+      "	",
+      docxSchema.marks.tab.create().addToSet(beside)
+    );
+  });
+  return nodes.length === 0 ? Slice.empty : new Slice(Fragment.fromArray(nodes), 0, 0);
+}
+export {
+  DEFAULT_READERS,
+  foreignHtmlReader,
+  internalSliceReader,
+  plainTextSlice
+};

package/dist/editor/clipboard/source.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Which application wrote the markup on the clipboard.
+ *
+ * Every writer of HTML says so somewhere - in a generator meta element, in a class prefix, in the
+ * id it wraps a copy in - and what it says decides which readings apply: Word's list paragraphs
+ * are lists rather than paragraphs beginning with a bullet character, and its `<o:p>` markers are
+ * nothing at all. A reading recognizing no writer stays with what the markup itself states.
+ */
+/** The writers whose markup is read differently from plain HTML */
+export type HtmlSource = "editor" | "word" | "google-docs" | "libreoffice" | "unknown";
+/** The application the markup under this element was written by */
+export declare function detectHtmlSource(root: ParentNode): HtmlSource;

package/dist/editor/clipboard/source.js

@@ -0,0 +1,21 @@
+// src/editor/clipboard/source.ts
+import { editorClassNames } from "../../styles/classNames.js";
+import { INTERNAL_TOKEN_ATTRIBUTE } from "./internalChannel.js";
+var SIGNATURES = [
+  ["editor", `[${INTERNAL_TOKEN_ATTRIBUTE}], .${editorClassNames.paragraph}`],
+  ["word", 'meta[name="Generator" i][content^="Microsoft Word" i], .MsoNormal'],
+  ["google-docs", '[id^="docs-internal-guid-"]'],
+  [
+    "libreoffice",
+    'meta[name="generator" i][content*="LibreOffice" i], meta[name="generator" i][content*="OpenOffice" i]'
+  ]
+];
+function detectHtmlSource(root) {
+  for (const [source, selector] of SIGNATURES) {
+    if (root.querySelector(selector) !== null) return source;
+  }
+  return "unknown";
+}
+export {
+  detectHtmlSource
+};

package/dist/editor/commands/comments/editing.d.ts

@@ -1,16 +1,30 @@
 /** Edits Word comments through their range markers and reference nodes. */
+import type { Node as PMNode } from "prosemirror-model";
 import { type Command, type EditorState } from "prosemirror-state";
-import type { NewComment } from "./model";
-/** Adds a plain-text comment to the current text selection. */
-export declare function addComment(comment: NewComment): Command;
+import { type CommentRange, type NewComment } from "./model";
 /**
- * Whether a non-empty selection in one paragraph can receive a comment.
+ * Adds a plain-text comment to a stretch of text: the one given, or the current text selection.
+ *
+ * A composer that was opened over one stretch and submitted later names it, so that what the
+ * comment marks is the text it was written about rather than wherever the caret has since gone.
+ */
+export declare function addComment(comment: NewComment, at?: CommentRange): Command;
+/**
+ * Whether that stretch of text, or the current selection, can receive a comment.
  * This is the command itself asked without a dispatch, over a comment standing in for the one the
  * user would write, so the button and the click cannot answer differently.
  */
-export declare function canAddComment(state: EditorState): boolean;
+export declare function canAddComment(state: EditorState, at?: CommentRange): boolean;
 /** Replaces the plain-text body of one comment, retaining its author and anchor. */
 export declare function updateComment(id: string, text: string): Command;
+/**
+ * Replaces the body of one comment with a formatted one, retaining its author and anchor.
+ *
+ * The body is a document of `docxSchema`, the same schema the page is edited in, so a paragraph
+ * style, a bold run and a second paragraph all survive being written, exported and read back.
+ * `updateComment` is the same command for a body that is only text.
+ */
+export declare function setCommentBody(id: string, body: PMNode): Command;
 /** Marks a comment thread resolved or open without deleting it. */
 export declare function setCommentResolved(id: string, resolved: boolean): Command;
 /** Adds a plain-text reply and reopens the thread when it was resolved. */
@@ -19,7 +33,13 @@ export declare function addCommentReply(id: string, reply: NewComment): Command;
 export declare function updateCommentReply(commentId: string, replyId: string, text: string): Command;
 /** Removes one reply while retaining its root comment and anchor. */
 export declare function removeCommentReply(commentId: string, replyId: string): Command;
-/** Removes a comment's range markers, reference and Comments-part entry. */
+/**
+ * Removes a comment's range markers, reference and Comments-part entry.
+ *
+ * What the comment and its replies said goes with them: a body is a story on the document node,
+ * and one left behind for a comment nothing refers to would ride every later comparison of the
+ * document without standing for anything.
+ */
 export declare function removeComment(id: string): Command;
 /** Selects the text anchored by a comment, or places the caret at a point comment. */
 export declare function selectComment(id: string): Command;

package/dist/editor/commands/comments/editing.js

@@ -3,16 +3,40 @@ import {
   TextSelection
 } from "prosemirror-state";
 import { commentParaId } from "../../../docx/comments.js";
+import {
+  sameStory,
+  setStory,
+  storyFromText,
+  storyKey,
+  storyOf,
+  storyText,
+  withoutStories
+} from "../../../docx/story.js";
 import { docxSchema } from "../../../schema/index.js";
 import { guardedCommand } from "../../../schema/guards.js";
+import { isWrapperType } from "../../../schema/wrappers.js";
 import {
   reservedCommentIds,
   reservedCommentParaIds
 } from "../../editorDocument.js";
-import { documentComments, repliesAttr, stringAttr } from "./reading.js";
-function validCommentSelection(state) {
+import {
+  repliesAttr,
+  stringAttr
+} from "./model.js";
+import { commentById } from "./reading.js";
+function anchorableRange(doc, { from, to }) {
+  if (!Number.isInteger(from) || !Number.isInteger(to) || from >= to || from < 0 || to > doc.content.size)
+    return null;
+  const $from = doc.resolve(from);
+  if (!$from.sameParent(doc.resolve(to))) return null;
+  if ($from.parent.type.name !== "paragraph") return null;
+  return { from, to };
+}
+function commentedRange(state, at) {
+  if (at) return anchorableRange(state.doc, at);
   const { selection } = state;
-  return selection instanceof TextSelection && !selection.empty && selection.$from.sameParent(selection.$to) && selection.$from.parent.type.name === "paragraph";
+  if (!(selection instanceof TextSelection)) return null;
+  return anchorableRange(state.doc, selection);
 }
 function nextCommentId(state) {
   const taken = /* @__PURE__ */ new Set();
@@ -70,17 +94,16 @@ function wrapperMarksAt(state, pos, side) {
   const resolved = state.doc.resolve(pos);
   const adjacent = side === "before" ? resolved.nodeBefore : resolved.nodeAfter;
   return (adjacent?.marks ?? resolved.marks()).filter(
-    (mark) => mark.type.name === "sdt" || mark.type.name === "link"
+    (mark) => isWrapperType(mark.type)
   );
 }
-function addCommentTransaction(state, comment) {
-  if (!validCommentSelection(state) || comment.text.trim().length === 0) {
-    return null;
-  }
+function addCommentTransaction(state, comment, at) {
+  const range = commentedRange(state, at);
+  if (range === null || comment.text.trim().length === 0) return null;
   const id = nextCommentId(state);
   const date = comment.date ?? (/* @__PURE__ */ new Date()).toISOString();
   const paraId = nextCommentParaId(state, `comment-${id}-${date}`);
-  const { from, to } = state.selection;
+  const { from, to } = range;
   const startMarks = wrapperMarksAt(state, from, "after");
   const endMarks = wrapperMarksAt(state, to, "before");
   const end = docxSchema.nodes.commentEnd.create(
@@ -96,9 +119,6 @@ function addCommentTransaction(state, comment) {
       authorId: comment.authorId ?? null,
       initials: comment.initials ?? null,
       date,
-      text: comment.text,
-      commentXml: null,
-      imported: false,
       paraId,
       resolved: false,
       extensionXml: null,
@@ -113,39 +133,63 @@ function addCommentTransaction(state, comment) {
     null,
     startMarks
   );
-  return state.tr.insert(to, end).insert(to + 1, reference).insert(from, start);
+  return setStory(
+    state.tr.insert(to, end).insert(to + 1, reference).insert(from, start),
+    storyKey("comment", id),
+    storyFromText(comment.text)
+  );
 }
-function addComment(comment) {
-  return guardedCommand((state) => addCommentTransaction(state, comment));
+function addComment(comment, at) {
+  return guardedCommand((state) => addCommentTransaction(state, comment, at));
 }
-function canAddComment(state) {
-  return addComment({
-    text: "comment",
-    author: "Author",
-    date: "1970-01-01T00:00:00.000Z"
-  })(state);
+function canAddComment(state, at) {
+  return addComment(
+    {
+      text: "comment",
+      author: "Author",
+      date: "1970-01-01T00:00:00.000Z"
+    },
+    at
+  )(state);
 }
-function updateComment(id, text) {
-  return guardedCommand((state) => {
-    if (text.trim().length === 0) return null;
-    let transaction = state.tr;
-    let changed = false;
-    state.doc.descendants((node, pos) => {
-      if (node.type.name === "commentReference" && stringAttr(node.attrs.id) === id && stringAttr(node.attrs.text) !== text) {
-        transaction = transaction.setNodeMarkup(pos, null, {
-          ...node.attrs,
-          text,
-          commentXml: null,
-          imported: false
-        });
-        changed = true;
-      }
-      return true;
-    });
-    return changed ? transaction : null;
+function referenceAt(state, id) {
+  let at = null;
+  state.doc.descendants((node, pos) => {
+    if (at !== null) return false;
+    if (node.type.name === "commentReference" && stringAttr(node.attrs.id) === id) {
+      at = pos;
+    }
+    return at === null;
   });
+  return at;
+}
+function bodyTransaction(state, referenceId, bodyId, body) {
+  if (body.type !== docxSchema.nodes.doc) return null;
+  if (storyText(body).trim().length === 0) return null;
+  const at = referenceAt(state, referenceId);
+  const reference = at === null ? null : state.doc.nodeAt(at);
+  if (at === null || reference === null) return null;
+  const key = storyKey("comment", bodyId);
+  if (sameStory(storyOf(state.doc, key), body)) return null;
+  return setStory(state.tr, key, body).setNodeMarkup(
+    at,
+    null,
+    reference.attrs,
+    reference.marks
+  );
 }
-function updateReference(id, change) {
+function textBodyTransaction(state, referenceId, bodyId, text) {
+  const held = storyOf(state.doc, storyKey("comment", bodyId));
+  if (held !== null && storyText(held) === text) return null;
+  return bodyTransaction(state, referenceId, bodyId, storyFromText(text));
+}
+function updateComment(id, text) {
+  return guardedCommand((state) => textBodyTransaction(state, id, id, text));
+}
+function setCommentBody(id, body) {
+  return guardedCommand((state) => bodyTransaction(state, id, id, body));
+}
+function updateReference(id, change, alongside = (tr) => tr) {
   return guardedCommand((state) => {
     let transaction = state.tr;
     let changed = false;
@@ -160,7 +204,7 @@ function updateReference(id, change) {
       }
       return false;
     });
-    return changed ? transaction : null;
+    return changed ? alongside(transaction) : null;
   });
 }
 function setCommentResolved(id, resolved) {
@@ -179,84 +223,110 @@ function addCommentReply(id, reply) {
     if (reply.text.trim().length === 0) return false;
     const replyId = nextCommentId(state);
     const date = reply.date ?? (/* @__PURE__ */ new Date()).toISOString();
-    return updateReference(id, (node) => {
-      const parentParaId = stringAttr(node.attrs.paraId) ?? nextCommentParaId(state, `comment-${id}`);
-      const paraId = nextCommentParaId(state, `comment-${replyId}-${date}`, [
-        parentParaId
-      ]);
-      return {
-        ...node.attrs,
-        paraId: parentParaId,
-        resolved: false,
-        extensionXml: null,
-        threadImported: false,
-        replies: [
-          ...repliesAttr(node.attrs.replies),
-          {
-            id: replyId,
-            author: reply.author,
-            authorId: reply.authorId ?? null,
-            initials: reply.initials ?? null,
-            date,
-            text: reply.text,
-            commentXml: null,
-            imported: false,
-            paraId,
-            parentParaId,
-            extensionXml: null
-          }
-        ]
-      };
-    })(state, dispatch);
+    return updateReference(
+      id,
+      (node) => {
+        const parentParaId = stringAttr(node.attrs.paraId) ?? nextCommentParaId(state, `comment-${id}`);
+        const paraId = nextCommentParaId(state, `comment-${replyId}-${date}`, [
+          parentParaId
+        ]);
+        return {
+          ...node.attrs,
+          paraId: parentParaId,
+          resolved: false,
+          extensionXml: null,
+          threadImported: false,
+          replies: [
+            ...repliesAttr(node.attrs.replies),
+            {
+              id: replyId,
+              author: reply.author,
+              authorId: reply.authorId ?? null,
+              initials: reply.initials ?? null,
+              date,
+              paraId,
+              parentParaId,
+              extensionXml: null
+            }
+          ]
+        };
+      },
+      (tr) => setStory(tr, storyKey("comment", replyId), storyFromText(reply.text))
+    )(state, dispatch);
   };
 }
 function updateCommentReply(commentId, replyId, text) {
-  return updateReference(commentId, (node) => {
-    if (text.trim().length === 0) return null;
-    const replies = repliesAttr(node.attrs.replies);
-    const index = replies.findIndex((reply) => reply.id === replyId);
-    if (index < 0 || replies[index].text === text) return null;
-    return {
-      ...node.attrs,
-      replies: replies.map(
-        (reply, at) => at === index ? { ...reply, text, commentXml: null, imported: false } : reply
-      )
-    };
+  return guardedCommand((state) => {
+    const holdsReply = repliesOf(state, commentId).some(
+      (reply) => reply.id === replyId
+    );
+    if (!holdsReply) return null;
+    return textBodyTransaction(state, commentId, replyId, text);
   });
 }
-function removeCommentReply(commentId, replyId) {
-  return updateReference(commentId, (node) => {
-    const replies = repliesAttr(node.attrs.replies);
-    if (!replies.some((reply) => reply.id === replyId)) return null;
-    const removedIds = /* @__PURE__ */ new Set([replyId]);
-    const removedParaIds = new Set(
-      replies.filter((reply) => removedIds.has(reply.id)).map((reply) => reply.paraId)
-    );
-    let changed = true;
-    while (changed) {
-      changed = false;
-      for (const reply of replies) {
-        if (!removedIds.has(reply.id) && removedParaIds.has(reply.parentParaId)) {
-          removedIds.add(reply.id);
-          removedParaIds.add(reply.paraId);
-          changed = true;
-        }
-      }
+function repliesOf(state, commentId) {
+  let replies = [];
+  state.doc.descendants((node) => {
+    if (node.type.name !== "commentReference" || stringAttr(node.attrs.id) !== commentId) {
+      return true;
     }
-    return {
-      ...node.attrs,
-      replies: replies.filter((reply) => !removedIds.has(reply.id)),
-      threadImported: false
-    };
+    replies = repliesAttr(node.attrs.replies);
+    return false;
   });
+  return replies;
+}
+function dropBodies(ids) {
+  return (tr) => withoutStories(
+    tr,
+    Array.from(ids, (id) => storyKey("comment", id))
+  );
+}
+function removeCommentReply(commentId, replyId) {
+  return (state, dispatch) => {
+    const removedReplyIds = /* @__PURE__ */ new Set();
+    return updateReference(
+      commentId,
+      (node) => {
+        const replies = repliesAttr(node.attrs.replies);
+        if (!replies.some((reply) => reply.id === replyId)) return null;
+        const removedIds = /* @__PURE__ */ new Set([replyId]);
+        const removedParaIds = new Set(
+          replies.filter((reply) => removedIds.has(reply.id)).map((reply) => reply.paraId)
+        );
+        let changed = true;
+        while (changed) {
+          changed = false;
+          for (const reply of replies) {
+            if (!removedIds.has(reply.id) && removedParaIds.has(reply.parentParaId)) {
+              removedIds.add(reply.id);
+              removedParaIds.add(reply.paraId);
+              changed = true;
+            }
+          }
+        }
+        for (const id of removedIds) removedReplyIds.add(id);
+        return {
+          ...node.attrs,
+          replies: replies.filter((reply) => !removedIds.has(reply.id)),
+          threadImported: false
+        };
+      },
+      dropBodies(removedReplyIds)
+    )(state, dispatch);
+  };
 }
 function removeComment(id) {
   return guardedCommand((state) => {
     const positions = [];
+    const bodies = /* @__PURE__ */ new Set([id]);
     state.doc.descendants((node, pos) => {
       if ((node.type.name === "commentStart" || node.type.name === "commentEnd" || node.type.name === "commentReference") && stringAttr(node.attrs.id) === id) {
         positions.push({ pos, size: node.nodeSize });
       }
+      if (node.type.name === "commentReference" && stringAttr(node.attrs.id) === id) {
+        for (const reply of repliesAttr(node.attrs.replies))
+          bodies.add(reply.id);
+      }
       return true;
     });
     if (positions.length === 0) return null;
@@ -264,12 +334,12 @@ function removeComment(id) {
     for (const marker of positions.sort((a, b) => b.pos - a.pos)) {
       transaction.delete(marker.pos, marker.pos + marker.size);
     }
-    return transaction;
+    return dropBodies(bodies)(transaction);
   });
 }
 function selectComment(id) {
   return (state, dispatch) => {
-    const comment = documentComments(state).find((entry) => entry.id === id);
+    const comment = commentById(state, id);
     if (!comment) return false;
     dispatch?.(
       state.tr.setSelection(
@@ -286,6 +356,7 @@ export {
   removeComment,
   removeCommentReply,
   selectComment,
+  setCommentBody,
   setCommentResolved,
   updateComment,
   updateCommentReply

package/dist/editor/commands/comments/model.d.ts

@@ -1,4 +1,6 @@
 /** Public comment values and shared attribute readers. */
+import type { CommentReplyData } from "../../../docx/comments";
+/** Who a comment is written by: the name it is shown under, and the identity behind it. */
 export interface CommentAuthor {
     /**
      * The identity behind the name, an opaque string the host application chooses. Recorded in the
@@ -8,6 +10,14 @@ export interface CommentAuthor {
     name: string;
     initials?: string;
 }
+/**
+ * A stretch of text a comment is written for: a pair of document positions, the way a comment
+ * already in the document reports its own (`DocumentComment.from`, `.to`).
+ */
+export interface CommentRange {
+    from: number;
+    to: number;
+}
 export interface NewComment {
     text: string;
     author: string;
@@ -17,24 +27,31 @@ export interface NewComment {
     /** ISO 8601 timestamp. The current time is used when omitted. */
     date?: string;
 }
+/**
+ * One comment as a reader of the document sees it. Every field is readonly: the record is the
+ * editor's own, worked out once per edit and handed to whoever asks (`editor/plugins/documentProjection`).
+ */
 export interface DocumentComment {
-    id: string;
-    author: string | null;
-    authorId: string | null;
-    initials: string | null;
-    date: string | null;
-    text: string;
-    from: number;
-    to: number;
-    referencePos: number;
-    resolved: boolean;
-    replies: readonly DocumentCommentReply[];
+    readonly id: string;
+    readonly author: string | null;
+    readonly authorId: string | null;
+    readonly initials: string | null;
+    readonly date: string | null;
+    /** What it says, as plain text. The formatting behind it is `setCommentBody`'s to write */
+    readonly text: string;
+    readonly from: number;
+    readonly to: number;
+    readonly referencePos: number;
+    readonly resolved: boolean;
+    readonly replies: readonly DocumentCommentReply[];
 }
 export interface DocumentCommentReply {
-    id: string;
-    author: string | null;
-    authorId: string | null;
-    initials: string | null;
-    date: string | null;
-    text: string;
+    readonly id: string;
+    readonly author: string | null;
+    readonly authorId: string | null;
+    readonly initials: string | null;
+    readonly date: string | null;
+    readonly text: string;
 }
+export declare function stringAttr(value: unknown): string | null;
+export declare function repliesAttr(value: unknown): readonly CommentReplyData[];