@portone/docx-editor 0.1.0

package/dist/DocxEditor.js

@@ -0,0 +1,348 @@
+// src/DocxEditor.tsx
+import {
+  forwardRef,
+  useEffect,
+  useImperativeHandle,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import { exportDocx } from "./docx/exportDocx.js";
+import { importDocx } from "./docx/importDocx.js";
+import {
+  documentComments
+} from "./editor/commands/commentCommands.js";
+import { activeLinkSpan } from "./editor/commands/linkCommands.js";
+import { createEditorState, createEditorView } from "./editor/createEditor.js";
+import { isLinkPanelOpen } from "./editor/plugins/linkPanel.js";
+import { tableMenuAnchor } from "./editor/plugins/tableContextMenu.js";
+import { textMenuAnchor } from "./editor/plugins/textContextMenu.js";
+import { parseNumbering } from "./numbering/parseNumbering.js";
+import { DocxImportError } from "./ooxml/errors.js";
+import { PageGuides } from "./page/PageGuides.js";
+import { A4_PAGE_PIXELS, pagePixels } from "./page/pageLayout.js";
+import { usePageLayout } from "./page/usePageLayout.js";
+import { editorClassNames } from "./styles/classNames.js";
+import { CommentsPanel } from "./ui/CommentsPanel.js";
+import { LinkCard } from "./ui/LinkCard.js";
+import { LinkPanel } from "./ui/LinkPanel.js";
+import { NotesPanel } from "./ui/NotesPanel.js";
+import { TableMenu } from "./ui/TableMenu.js";
+import { TextMenu } from "./ui/TextMenu.js";
+import { Toolbar } from "./ui/Toolbar.js";
+import { useFitWidthZoom } from "./ui/useFitWidthZoom.js";
+import { normalizeZoom } from "./ui/zoom.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+function openDocument(bytes) {
+  try {
+    const { doc, session } = importDocx(bytes);
+    return {
+      status: "opened",
+      doc,
+      session,
+      numbering: parseNumbering(session.numberingXml)
+    };
+  } catch (error) {
+    if (error instanceof DocxImportError) return { status: "rejected", error };
+    throw error;
+  }
+}
+function useLatest(value) {
+  const box = useRef(value);
+  useEffect(() => {
+    box.current = value;
+  });
+  return box;
+}
+function isBlob(source) {
+  return typeof Blob !== "undefined" && source instanceof Blob;
+}
+function useDocumentBytes(source) {
+  const [read, setRead] = useState(null);
+  useEffect(() => {
+    if (!isBlob(source)) return;
+    let current = true;
+    source.arrayBuffer().then((bytes) => {
+      if (current) setRead({ of: source, status: "read", bytes });
+    }).catch((error) => {
+      if (current) setRead({ of: source, status: "failed", error });
+    });
+    return () => {
+      current = false;
+    };
+  }, [source]);
+  if (!isBlob(source)) return source;
+  if (read?.of !== source) return null;
+  if (read.status === "failed") throw read.error;
+  return read.bytes;
+}
+var IMPORT_REJECTION_REASON = {
+  "not-a-docx": "This file is not a docx document, or it is damaged.",
+  "too-large": "This document is too large to open.",
+  "missing-part": "This document is missing the part that holds its body.",
+  "missing-body": "This document has no body.",
+  "malformed-xml": "The XML inside this document cannot be read.",
+  "unsupported-content": "This document holds content that could not be kept as it is."
+};
+function ImportRejection({ error }) {
+  return /* @__PURE__ */ jsxs("div", { className: editorClassNames.rejection, role: "alert", children: [
+    /* @__PURE__ */ jsx("p", { className: editorClassNames.rejectionTitle, children: "This document was not opened" }),
+    /* @__PURE__ */ jsx("p", { children: IMPORT_REJECTION_REASON[error.code] })
+  ] });
+}
+function zoomVariable(factor) {
+  return { "--docx-editor-zoom": factor };
+}
+function DocxEditorSurface({
+  document: source,
+  renderImportError,
+  mode = { kind: "edit" },
+  showPageGuides = true,
+  zoom,
+  defaultZoom = "fit-width",
+  onZoomChange,
+  fontFallbacks,
+  presets,
+  commentAuthor = { name: "Anonymous" },
+  plugins,
+  className,
+  style,
+  onReady,
+  onChange
+}, ref) {
+  const readOnly = mode.kind === "readOnly";
+  const showToolbar = mode.kind === "edit" && (mode.toolbar ?? true);
+  const allowLocking = mode.kind === "edit" && (mode.locking ?? false);
+  const bytes = useDocumentBytes(source);
+  const opened = useMemo(
+    () => bytes === null ? null : openDocument(bytes),
+    [bytes]
+  );
+  const mountedPlugins = useRef(plugins).current;
+  const mountedContextMenus = useRef(
+    mode.kind !== "edit" || (mode.contextMenus ?? true)
+  ).current;
+  const mountedFontFallbacks = useRef(fontFallbacks).current;
+  const layerRef = useRef(null);
+  const rootRef = useRef(null);
+  const mountRef = useRef(null);
+  const keptState = useRef(
+    null
+  );
+  const viewRef = useRef(null);
+  const [live, setLive] = useState(null);
+  const [commentComposerOpen, setCommentComposerOpen] = useState(false);
+  const [commentsOpen, setCommentsOpen] = useState(false);
+  const [uncontrolledZoom, setUncontrolledZoom] = useState(
+    () => normalizeZoom(defaultZoom)
+  );
+  const latestOnReady = useLatest(onReady);
+  const latestOnChange = useLatest(onChange);
+  const selectedZoom = normalizeZoom(zoom ?? uncontrolledZoom);
+  const page = opened?.status === "opened" ? pagePixels(opened.session.geometry) : A4_PAGE_PIXELS;
+  const fitWidth = useFitWidthZoom(rootRef, page.pageWidth);
+  const effectiveZoom = selectedZoom === "fit-width" ? fitWidth : selectedZoom;
+  const changeZoom = (next) => {
+    const normalized = normalizeZoom(next);
+    if (zoom === void 0) setUncontrolledZoom(normalized);
+    onZoomChange?.(normalized);
+  };
+  useLayoutEffect(() => {
+    const mount = mountRef.current;
+    if (!mount || opened?.status !== "opened") return;
+    const kept = keptState.current;
+    const view = createEditorView({
+      mount,
+      state: kept?.of === opened ? kept.state : createEditorState(opened.doc, {
+        numbering: opened.numbering,
+        styles: opened.session.styles,
+        defaults: opened.session.defaults,
+        paragraphDefaults: opened.session.paragraphDefaults,
+        canStartNewList: opened.session.numberingPartPath !== null,
+        consumerPlugins: mountedPlugins,
+        paragraphStyles: opened.session.paragraphStyles,
+        contextMenus: mountedContextMenus,
+        geometry: opened.session.geometry,
+        defaultTabStopPt: opened.session.defaultTabStopPt,
+        reservedCommentIds: opened.session.comments.byId.keys(),
+        reservedCommentParaIds: [
+          ...opened.session.comments.ordered.flatMap(
+            (comment) => comment.paraId === null ? [] : [comment.paraId]
+          ),
+          ...opened.session.comments.extendedOrdered.map(
+            (extension) => extension.paraId
+          )
+        ]
+      }),
+      defaults: opened.session.defaults,
+      geometry: opened.session.geometry,
+      readOnly,
+      fontFallbacks: mountedFontFallbacks,
+      onStateChange: (state) => {
+        keptState.current = { of: opened, state };
+        setLive({ view, state });
+        latestOnChange.current?.();
+      }
+    });
+    viewRef.current = view;
+    keptState.current = { of: opened, state: view.state };
+    setLive({ view, state: view.state });
+    latestOnReady.current?.(view);
+    return () => {
+      view.destroy();
+      viewRef.current = null;
+      setLive(null);
+    };
+  }, [
+    opened,
+    readOnly,
+    mountedContextMenus,
+    mountedFontFallbacks,
+    mountedPlugins,
+    latestOnReady,
+    latestOnChange
+  ]);
+  useImperativeHandle(ref, () => {
+    const view = viewRef.current;
+    if (!view || opened?.status !== "opened") return null;
+    const session = opened.session;
+    return { view, exportBytes: () => exportDocx(view.state.doc, session) };
+  }, [opened, readOnly]);
+  const overlay = usePageLayout({
+    view: live?.view ?? null,
+    layer: layerRef,
+    enabled: showPageGuides,
+    revision: live?.state.doc,
+    geometry: opened?.status === "opened" ? opened.session.geometry : void 0
+  });
+  if (opened?.status === "rejected") {
+    return renderImportError ? renderImportError(opened.error) : /* @__PURE__ */ jsx(ImportRejection, { error: opened.error });
+  }
+  const textAnchor = live && !readOnly ? textMenuAnchor(live.state) : null;
+  const tableAnchor = live && !readOnly && !textAnchor ? tableMenuAnchor(live.state) : null;
+  const linkAtCursor = live && !live.view.composing && !isLinkPanelOpen(live.state) ? activeLinkSpan(live.state) : null;
+  const comments = live?.state === void 0 ? [] : documentComments(live.state);
+  const hasUnresolvedComments = comments.some((comment) => !comment.resolved);
+  const effectiveComposerOpen = commentComposerOpen && !readOnly;
+  const showComments = live !== null && (commentsOpen || effectiveComposerOpen || hasUnresolvedComments);
+  const commentsPanel = live && showComments && /* @__PURE__ */ jsx(
+    CommentsPanel,
+    {
+      view: live.view,
+      state: live.state,
+      readOnly,
+      composerOpen: effectiveComposerOpen,
+      author: commentAuthor,
+      closeComposer: () => setCommentComposerOpen(false),
+      scrollContainer: rootRef.current,
+      allCommentsOpen: commentsOpen
+    }
+  );
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: [editorClassNames.frame, className].filter(Boolean).join(" "),
+      style,
+      children: [
+        live && showToolbar && /* @__PURE__ */ jsx(
+          Toolbar,
+          {
+            view: live.view,
+            state: live.state,
+            fontFallbacks: mountedFontFallbacks,
+            presets,
+            commentsOpen,
+            onToggleComments: () => {
+              setCommentsOpen((open) => {
+                if (open) setCommentComposerOpen(false);
+                return !open;
+              });
+            },
+            zoom: selectedZoom,
+            onZoomChange: changeZoom
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: editorClassNames.workspace,
+            "data-comments": showComments ? "visible" : void 0,
+            style: zoomVariable(effectiveZoom),
+            children: [
+              live && readOnly && comments.length > 0 && /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  className: editorClassNames.commentsToggle,
+                  "aria-expanded": commentsOpen,
+                  onClick: () => setCommentsOpen((open) => !open),
+                  children: commentsOpen ? "Hide comments" : "Show comments"
+                }
+              ),
+              /* @__PURE__ */ jsxs("div", { ref: rootRef, className: editorClassNames.root, children: [
+                /* @__PURE__ */ jsxs(
+                  "div",
+                  {
+                    ref: layerRef,
+                    className: editorClassNames.pageLayer,
+                    style: { zoom: effectiveZoom },
+                    children: [
+                      /* @__PURE__ */ jsx("div", { ref: mountRef }),
+                      overlay && /* @__PURE__ */ jsx(
+                        PageGuides,
+                        {
+                          overlay,
+                          headersFooters: opened?.status === "opened" ? opened.session.headersFooters : void 0
+                        }
+                      ),
+                      live && opened?.status === "opened" && /* @__PURE__ */ jsx(NotesPanel, { state: live.state, pageWidth: page.pageWidth })
+                    ]
+                  }
+                ),
+                !commentsOpen && commentsPanel
+              ] }),
+              commentsOpen && commentsPanel
+            ]
+          }
+        ),
+        live && !readOnly && isLinkPanelOpen(live.state) && /* @__PURE__ */ jsx(LinkPanel, { view: live.view, state: live.state }),
+        live && linkAtCursor && /* @__PURE__ */ jsx(
+          LinkCard,
+          {
+            view: live.view,
+            state: live.state,
+            link: linkAtCursor,
+            readOnly
+          },
+          linkAtCursor.from
+        ),
+        live && textAnchor && /* @__PURE__ */ jsx(
+          TextMenu,
+          {
+            view: live.view,
+            state: live.state,
+            anchor: textAnchor,
+            allowLocking,
+            onAddComment: () => {
+              setCommentComposerOpen(true);
+            }
+          }
+        ),
+        live && tableAnchor && /* @__PURE__ */ jsx(
+          TableMenu,
+          {
+            view: live.view,
+            state: live.state,
+            anchor: tableAnchor,
+            allowLocking
+          }
+        )
+      ]
+    }
+  );
+}
+var DocxEditor = forwardRef(DocxEditorSurface);
+export {
+  DocxEditor
+};

package/dist/core.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Framework-free DOCX import and export API. The opaque session preserves package parts between
+ * calls; server runtimes must provide global `DOMParser` and `Node` implementations.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type DocxBytes } from "./docx/importDocx";
+import type { DocxSession } from "./docx/session";
+export { exportDocx } from "./docx/exportDocx";
+export type { ParagraphStyleOption } from "./docx/formatting";
+export type { DocxBytes } from "./docx/importDocx";
+export type { DocxSession } from "./docx/session";
+export { documentNumbering, documentPartPath } from "./docx/session";
+export type { CellFormat, CellVerticalAlign, DocumentDefaults, HighlightName, LineSpacing, NumberingRef, ParagraphAlign, ParagraphFormat, RowFormat, RowHeight, RunFormat, TableFormat, TableWidth, TableWidthType, UnderlineKind, VerticalAlign, } from "./model/format";
+export { toCellFormat, toParagraphFormat, toRowFormat, toRunFormat, toTableFormat, toTableWidth, } from "./model/format";
+export type { LevelIndent, NumberFormat, Numbering, NumberingLevel, NumberingList, } from "./numbering/parseNumbering";
+export { parseNumbering } from "./numbering/parseNumbering";
+export type { DocxExportErrorCode, DocxImportErrorCode, } from "./ooxml/errors";
+export { DocxExportError, DocxImportError } from "./ooxml/errors";
+/**
+ * An image node's size is written in EMU, the unit the document itself uses. A builder
+ * that places an image is working in pixels, so the conversion ships with the type.
+ */
+export type { ImageExtent } from "./ooxml/image";
+export { emuToPx, pxToEmu, toImageExtent } from "./ooxml/image";
+export { docxSchema } from "./schema";
+/**
+ * Opens docx bytes into the document to work on and the session that remembers the file they came
+ * from.
+ *
+ * The engine hands out the store it fills in; this is where it narrows to the opaque session, so
+ * that the original XML behind it stays the exporter's business.
+ */
+export declare function importDocx(input: DocxBytes): {
+    doc: PMNode;
+    session: DocxSession;
+};

package/dist/core.js

@@ -0,0 +1,38 @@
+// src/core.ts
+import { importDocx as openDocx } from "./docx/importDocx.js";
+import { exportDocx } from "./docx/exportDocx.js";
+import { documentNumbering, documentPartPath } from "./docx/session.js";
+import {
+  toCellFormat,
+  toParagraphFormat,
+  toRowFormat,
+  toRunFormat,
+  toTableFormat,
+  toTableWidth
+} from "./model/format.js";
+import { parseNumbering } from "./numbering/parseNumbering.js";
+import { DocxExportError, DocxImportError } from "./ooxml/errors.js";
+import { emuToPx, pxToEmu, toImageExtent } from "./ooxml/image.js";
+import { docxSchema } from "./schema/index.js";
+function importDocx(input) {
+  return openDocx(input);
+}
+export {
+  DocxExportError,
+  DocxImportError,
+  documentNumbering,
+  documentPartPath,
+  docxSchema,
+  emuToPx,
+  exportDocx,
+  importDocx,
+  parseNumbering,
+  pxToEmu,
+  toCellFormat,
+  toImageExtent,
+  toParagraphFormat,
+  toRowFormat,
+  toRunFormat,
+  toTableFormat,
+  toTableWidth
+};

package/dist/docx/comments/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const COMMENTS_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments";
+export declare const COMMENTS_EXTENDED_REL_TYPE = "http://schemas.microsoft.com/office/2011/relationships/commentsExtended";
+export declare const COMMENTS_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml";
+export declare const COMMENTS_EXTENDED_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml";
+export declare const CONTENT_TYPES_PATH = "[Content_Types].xml";
+export declare const W14_NS = "http://schemas.microsoft.com/office/word/2010/wordml";
+export declare const W15_NS = "http://schemas.microsoft.com/office/word/2012/wordml";
+export declare const MC_NS = "http://schemas.openxmlformats.org/markup-compatibility/2006";

package/dist/docx/comments/constants.js

@@ -0,0 +1,20 @@
+// src/docx/comments/constants.ts
+import { R_NS } from "../../ooxml/xml.js";
+var COMMENTS_REL_TYPE = `${R_NS}/comments`;
+var COMMENTS_EXTENDED_REL_TYPE = "http://schemas.microsoft.com/office/2011/relationships/commentsExtended";
+var COMMENTS_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml";
+var COMMENTS_EXTENDED_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml";
+var CONTENT_TYPES_PATH = "[Content_Types].xml";
+var W14_NS = "http://schemas.microsoft.com/office/word/2010/wordml";
+var W15_NS = "http://schemas.microsoft.com/office/word/2012/wordml";
+var MC_NS = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+export {
+  COMMENTS_CONTENT_TYPE,
+  COMMENTS_EXTENDED_CONTENT_TYPE,
+  COMMENTS_EXTENDED_REL_TYPE,
+  COMMENTS_REL_TYPE,
+  CONTENT_TYPES_PATH,
+  MC_NS,
+  W14_NS,
+  W15_NS
+};

package/dist/docx/comments/model.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Maps imported comment threads to and from ProseMirror reference data.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import type { ImportedComments } from "./reading";
+export interface CommentReferenceData {
+    id: string;
+    author: string | null;
+    initials: string | null;
+    date: string | null;
+    text: string;
+    commentXml: string | null;
+    imported: boolean;
+    paraId: string;
+    resolved: boolean;
+    extensionXml: string | null;
+    threadImported: boolean;
+    replies: readonly CommentReplyData[];
+}
+export interface CommentReplyData {
+    id: string;
+    author: string | null;
+    initials: string | null;
+    date: string | null;
+    text: string;
+    commentXml: string | null;
+    imported: boolean;
+    paraId: string;
+    parentParaId: string;
+    extensionXml: string | null;
+}
+/** A stable Word paragraph id for a comment created or upgraded by the editor. */
+export declare function commentParaId(seed: string): string;
+/** Replies below one referenced comment, in the order of the Comments part. */
+export declare function importedCommentReplies(comments: ImportedComments, rootId: string): readonly CommentReplyData[];
+/** The first reference for each comment id, in document order. */
+export declare function commentReferencesIn(doc: PMNode): ReadonlyMap<string, CommentReferenceData>;

package/dist/docx/comments/model.js

@@ -0,0 +1,104 @@
+// src/docx/comments/model.ts
+function commentParaId(seed) {
+  let hash = 2166136261;
+  for (const char of seed) {
+    hash ^= char.charCodeAt(0);
+    hash = Math.imul(hash, 16777619);
+  }
+  const value = hash >>> 0 & 2147483647;
+  return (value === 0 ? 1 : value).toString(16).toUpperCase().padStart(8, "0");
+}
+function importedCommentReplies(comments, rootId) {
+  const replies = [];
+  const visited = /* @__PURE__ */ new Set([rootId]);
+  const pending = [...comments.repliesByParentId.get(rootId) ?? []].reverse().map((reply) => ({ parentId: rootId, reply }));
+  while (pending.length > 0) {
+    const item = pending.pop();
+    if (item === void 0 || visited.has(item.reply.id)) continue;
+    const { parentId, reply } = item;
+    visited.add(reply.id);
+    const parent = comments.byId.get(parentId);
+    const paraId = reply.paraId ?? commentParaId(`comment-${reply.id}`);
+    const parentParaId = reply.parentParaId ?? parent?.paraId ?? commentParaId(`comment-${parentId}`);
+    replies.push({
+      id: reply.id,
+      author: reply.author,
+      initials: reply.initials,
+      date: reply.date,
+      text: reply.text,
+      commentXml: reply.xml,
+      imported: true,
+      paraId,
+      parentParaId,
+      extensionXml: reply.extensionXml
+    });
+    const children = comments.repliesByParentId.get(reply.id) ?? [];
+    for (let index = children.length - 1; index >= 0; index -= 1) {
+      pending.push({ parentId: reply.id, reply: children[index] });
+    }
+  }
+  return replies;
+}
+function nullableString(value) {
+  return typeof value === "string" ? value : null;
+}
+function replyData(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((candidate) => {
+    if (typeof candidate !== "object" || candidate === null) return [];
+    const entry = candidate;
+    const id = nullableString(entry.id);
+    const paraId = nullableString(entry.paraId);
+    const parentParaId = nullableString(entry.parentParaId);
+    if (id === null || paraId === null || parentParaId === null) return [];
+    return [
+      {
+        id,
+        author: nullableString(entry.author),
+        initials: nullableString(entry.initials),
+        date: nullableString(entry.date),
+        text: nullableString(entry.text) ?? "",
+        commentXml: nullableString(entry.commentXml),
+        imported: entry.imported === true,
+        paraId,
+        parentParaId,
+        extensionXml: nullableString(entry.extensionXml)
+      }
+    ];
+  });
+}
+function referenceData(node) {
+  if (node.type.name !== "commentReference") return null;
+  const id = nullableString(node.attrs.id);
+  if (id === null) return null;
+  return {
+    id,
+    author: nullableString(node.attrs.author),
+    initials: nullableString(node.attrs.initials),
+    date: nullableString(node.attrs.date),
+    text: nullableString(node.attrs.text) ?? "",
+    commentXml: nullableString(node.attrs.commentXml),
+    imported: node.attrs.imported === true,
+    paraId: nullableString(node.attrs.paraId) ?? "00000001",
+    resolved: node.attrs.resolved === true,
+    extensionXml: nullableString(node.attrs.extensionXml),
+    threadImported: node.attrs.threadImported === true,
+    replies: replyData(node.attrs.replies)
+  };
+}
+function commentReferencesIn(doc) {
+  const references = /* @__PURE__ */ new Map();
+  doc.descendants((node) => {
+    const comment = referenceData(node);
+    if (comment && !references.has(comment.id)) {
+      references.set(comment.id, comment);
+    }
+    return true;
+  });
+  return references;
+}
+export {
+  commentParaId,
+  commentReferencesIn,
+  importedCommentReplies
+};

package/dist/docx/comments/reading.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Reads comment and comment-extension package parts.
+ */
+export interface ImportedComment {
+    id: string;
+    author: string | null;
+    initials: string | null;
+    date: string | null;
+    text: string;
+    xml: string;
+    paraId: string | null;
+    parentParaId: string | null;
+    resolved: boolean;
+    extensionXml: string | null;
+}
+export interface ImportedComments {
+    partPath: string | null;
+    xml: string | null;
+    hadBom: boolean;
+    ordered: readonly ImportedComment[];
+    byId: ReadonlyMap<string, ImportedComment>;
+    repliesByParentId: ReadonlyMap<string, readonly ImportedComment[]>;
+    extendedPartPath: string | null;
+    extendedXml: string | null;
+    extendedHadBom: boolean;
+    extendedOrdered: readonly ImportedCommentExtension[];
+}
+export declare const NO_COMMENTS: ImportedComments;
+export interface ImportedCommentExtension {
+    paraId: string;
+    parentParaId: string | null;
+    resolved: boolean;
+    xml: string;
+}
+/** Reads the Comments part related from the main document story. */
+export declare function readComments(parts: Map<string, Uint8Array>, mainPartPath: string): ImportedComments;