@portone/docx-editor 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -22,6 +22,8 @@ export type { CellFormat, CellVerticalAlign, DocumentDefaults, HighlightName, Li
 export type { DocxExportErrorCode, DocxImportErrorCode, } from "./ooxml/errors";
 export { DocxExportError, DocxImportError } from "./ooxml/errors";
 export { docxSchema } from "./schema";
+/** Whose comments the panel offers to edit, which `DocxEditorMode` takes */
+export type { EditableComments } from "./schema/protection";
 /**
  * The lists the built-in pickers offer. They are exported so that a toolbar of your own can
  * offer the same ones without writing them out again; the pickers themselves read these very

package/dist/numbering/markers.js

@@ -70,6 +70,18 @@ function advance(counters, list, ilvl, start) {
     if (deeper > ilvl) counters.delete(deeper);
   }
 }
+var MARKER_SEGMENTER = new Intl.Segmenter();
+function capped(shape) {
+  if (shape.length <= MAX_MARKER_CHARS) return shape;
+  let text = "";
+  for (const { segment } of MARKER_SEGMENTER.segment(
+    shape.slice(0, MAX_MARKER_CHARS * 2)
+  )) {
+    if (text.length + segment.length > MAX_MARKER_CHARS) break;
+    text += segment;
+  }
+  return text;
+}
 function computeMarkers(paragraphs, numbering) {
   const countersByList = /* @__PURE__ */ new Map();
   return paragraphs.map((ref) => {
@@ -84,7 +96,7 @@ function computeMarkers(paragraphs, numbering) {
     }
     advance(counters, list, ref.ilvl, level.start);
     const shape = level.format === "bullet" ? level.text : fillLevels(level.text, list, counters);
-    const text = shape.slice(0, MAX_MARKER_CHARS);
+    const text = capped(shape);
     return text ? { text, indent: levelIndentPt(level.indent) } : null;
   });
 }

package/dist/schema/docxSchema.js

@@ -556,6 +556,9 @@ var docxSchema = new Schema({
         id: { default: null },
         referenceXml: { default: null },
         author: { default: null },
+        // The identity behind the display name, read from and written to the people part. Null for
+        // a comment nobody's identity is recorded for, which every comment made in Word is here
+        authorId: { default: null },
         initials: { default: null },
         date: { default: null },
         text: { default: "" },
@@ -576,6 +579,7 @@ var docxSchema = new Schema({
             "data-comment-id": text(node.attrs.id),
             "data-reference-xml": text(node.attrs.referenceXml),
             "data-comment-author": text(node.attrs.author),
+            "data-comment-author-id": text(node.attrs.authorId),
             "data-comment-initials": text(node.attrs.initials),
             "data-comment-date": text(node.attrs.date),
             "data-comment-text": text(node.attrs.text),
@@ -596,6 +600,7 @@ var docxSchema = new Schema({
             id: dom.getAttribute("data-comment-id"),
             referenceXml: dom.getAttribute("data-reference-xml"),
             author: dom.getAttribute("data-comment-author"),
+            authorId: dom.getAttribute("data-comment-author-id"),
             initials: dom.getAttribute("data-comment-initials"),
             date: dom.getAttribute("data-comment-date"),
             text: dom.getAttribute("data-comment-text") ?? "",

package/dist/schema/locks.d.ts

@@ -1,9 +1,13 @@
 /**
  * Evaluates OOXML content and deletion locks for inline controls and whole table cells. Commands
  * query these predicates before editing; `editor/plugins/lockedContent` enforces them at runtime.
+ *
+ * `transactionAllowed` is the one guard, and it answers for the protection the editor runs under
+ * (`./protection`) as well as for the locks, so that a command asking it asks both.
  */
 import type { Mark, Node as PMNode } from "prosemirror-model";
-import { PluginKey, type Selection, type Transaction } from "prosemirror-state";
+import { type EditorState, PluginKey, type Selection, type Transaction } from "prosemirror-state";
+import { type ProtectionState } from "./protection";
 /**
  * The pass that lets a transaction through the guard, which is how a lock can be lifted at all.
  * A plugin key is used as the name so that it cannot collide with a consumer's own metadata.
@@ -99,6 +103,27 @@ export declare function selectionShut(selection: Selection, doc: PMNode): boolea
  * it would have gone through.
  */
 export declare function replacementShut(selection: Selection, doc: PMNode): boolean;
+/**
+ * Whether any step of the transaction reaches a comment node: puts one in, takes one out, or
+ * rewrites the one where it stands, which is how a body, a reply and a resolution change.
+ *
+ * Every comment lives in its three nodes, so a change that reaches none of them cannot have
+ * changed a comment. That is what lets the guard settle the common transaction - typing, and
+ * nothing more - over the stretch it rewrote rather than over the whole document.
+ *
+ * A step of a kind this does not know - one a consumer brought - is answered as reaching one,
+ * since what it rewrote is not known either. The whole-document judgement then has the say, and
+ * an unknown step costs a comparison rather than a hole in the guard.
+ */
+export declare function transactionTouchesComments(tr: Transaction): boolean;
+/**
+ * Whether the protection lets this transaction through (`./protection`).
+ *
+ * The whole-document judgement is reached for only when a comment is touched at all
+ * (`transactionTouchesComments`). A change that touches none is a body edit: through under `none`,
+ * refused under `comments`, and nothing about ownership to ask.
+ */
+export declare function protectionAllowsTransaction(tr: Transaction, rules: ProtectionState): boolean;
 /**
  * Whether the guard would let this transaction through, decided and nothing else.
  *
@@ -106,7 +131,10 @@ export declare function replacementShut(selection: Selection, doc: PMNode): bool
  * (`editor/plugins/lockedContent`) - which a query about a button's state may not set off, so the
  * decision stands apart from it and every caller building an edit asks this rather than handing
  * the transaction to a state.
- * `doc` only stands in for a step the transaction kept no document for.
+ *
+ * The protection is judged before the passes and without them: a replayed edit is still an edit,
+ * and a pass that lifts a lock lifts no protection. Its judgement is over the whole change rather
+ * than step by step, which is what lets it tell a comment from everything else.
  */
-export declare function transactionAllowed(tr: Transaction, doc: PMNode): boolean;
+export declare function transactionAllowed(tr: Transaction, state: EditorState): boolean;
 export {};

package/dist/schema/locks.js

@@ -1,5 +1,7 @@
 // src/schema/locks.ts
-import { PluginKey } from "prosemirror-state";
+import {
+  PluginKey
+} from "prosemirror-state";
 import {
   AddMarkStep,
   AddNodeMarkStep,
@@ -10,6 +12,11 @@ import {
   ReplaceStep
 } from "prosemirror-transform";
 import { docxSchema } from "./index.js";
+import {
+  isCommentNode,
+  protectionAllows
+} from "./protection.js";
+import { protectionOf } from "./protectionState.js";
 var unlockAllowed = new PluginKey("docxEditorUnlockAllowed");
 var historyReplay = new PluginKey("docxEditorHistoryReplay");
 var OPEN = { contents: false, deletion: false };
@@ -188,11 +195,53 @@ function stepAllowed(step, doc) {
 function carriesPass(tr) {
   return tr.getMeta(unlockAllowed) === true || tr.getMeta(historyReplay) === true;
 }
-function transactionAllowed(tr, doc) {
+function rangeHoldsComment(doc, from, to) {
+  let found = false;
+  doc.nodesBetween(from, to, (node) => {
+    if (found) return false;
+    if (isCommentNode(node)) found = true;
+    return !found;
+  });
+  return found;
+}
+function transactionTouchesComments(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 node = before.nodeAt(step.pos);
+      return node !== null && isCommentNode(node);
+    }
+    if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep || step instanceof AddMarkStep || step instanceof RemoveMarkStep)) {
+      return true;
+    }
+    let touched = false;
+    step.getMap().forEach((oldStart, oldEnd, newStart, newEnd) => {
+      touched ||= rangeHoldsComment(before, oldStart, oldEnd) || rangeHoldsComment(after, newStart, newEnd);
+    });
+    return touched;
+  });
+}
+function protectionAllowsTransaction(tr, rules) {
+  switch (rules.protection) {
+    case "readOnly":
+      return false;
+    case "none":
+      return !transactionTouchesComments(tr) || protectionAllows(tr.before, tr.doc, rules);
+    case "comments":
+      return transactionTouchesComments(tr) && protectionAllows(tr.before, tr.doc, rules);
+    default: {
+      const unmodelled = rules.protection;
+      return unmodelled;
+    }
+  }
+}
+function transactionAllowed(tr, state) {
   if (!tr.docChanged) return true;
+  if (!protectionAllowsTransaction(tr, protectionOf(state))) return false;
   if (carriesPass(tr)) return true;
   return tr.steps.every(
-    (step, index) => stepAllowed(step, tr.docs[index] ?? doc)
+    (step, index) => stepAllowed(step, tr.docs[index] ?? state.doc)
   );
 }
 export {
@@ -203,9 +252,11 @@ export {
   insideLockedCell,
   isLockedCell,
   lockedMarkOf,
+  protectionAllowsTransaction,
   rangeTouchesLocked,
   replacementShut,
   selectionShut,
   transactionAllowed,
+  transactionTouchesComments,
   unlockAllowed
 };

package/dist/schema/protection.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The protection an editor runs under: what the document as a whole may receive, over and above
+ * the locks its own controls carry (`./locks`).
+ *
+ * The levels are named after OOXML `ST_DocProtect`, the enumeration `w:documentProtection/@w:edit`
+ * takes (ECMA-376 Part 1 §17.15.1.29): `readOnly` takes no edit at all, `comments` takes comments
+ * and nothing else, `none` takes every body edit. No level lifts the ownership rule over comments:
+ * whose comment may be edited is `editableComments`' question at every level, `none` included.
+ * `trackedChanges` and `forms`, the two values of the enumeration not modelled yet, would be added
+ * here.
+ *
+ * The protection is editor state rather than document state: it is the reader's standing, not the
+ * file's, so nothing here is written to or read from OOXML. `editor/plugins/documentProtection`
+ * holds it in the state and `./protectionState` reads it back; the guard (`transactionAllowed` in
+ * `./locks`) asks the judgements here. They take documents alone, so that the `./core` entry can
+ * make the same judgement over a file without an editor.
+ */
+import { type Node as PMNode } from "prosemirror-model";
+export type EditingProtection = "none" | "readOnly" | "comments";
+/**
+ * Whose comments may be edited or deleted. `own` is a comment carrying no recognised identity, or
+ * the very identity comments are being written under; `all` is every comment there is, which is
+ * the standing of a moderator.
+ */
+export type EditableComments = "own" | "all";
+export interface ProtectionState {
+    protection: EditingProtection;
+    /** The identity comments are written under. Null where nobody is writing any, a reader above all */
+    authorId: string | null;
+    editableComments: EditableComments;
+}
+/** Whether this node is one of the three a comment stands in the story as */
+export declare function isCommentNode(node: PMNode): boolean;
+/** Whether the two documents differ in nothing but their comments */
+export declare function changesOnlyComments(before: PMNode, after: PMNode): boolean;
+/**
+ * Whether a comment written under this identity may be edited or deleted.
+ *
+ * A comment carrying no recognised identity belongs to nobody in particular and stays open to
+ * everyone, which is what every comment was before identities were recorded and what a comment
+ * made in Word is; one carrying an identity is its author's alone.
+ */
+export declare function commentOwned(rules: ProtectionState, authorId: string | null): boolean;
+/**
+ * Whether every comment and reply that was already there kept the identity it was written under.
+ *
+ * An identity is not an edit anyone may make, its own author included: a comment rewritten into
+ * another author's name would be that author's to edit from then on, and one rewritten into
+ * nobody's would be everyone's. Only a comment that appears carries an identity chosen for it.
+ */
+export declare function commentIdentitiesKept(before: PMNode, after: PMNode): boolean;
+/**
+ * Whether every comment edited, moved or taken away between the two documents belonged to whoever
+ * did it. Adding a comment, replying, and settling a thread as resolved or open belong to
+ * everyone.
+ *
+ * Moving a comment onto other text is an edit of that comment rather than of the body, since the
+ * body reads the same afterwards, and it is the owner's to make.
+ * A root taken away takes its replies with it whoever wrote them: a thread hangs off its root,
+ * and the root's owner may take the thread down.
+ */
+export declare function commentEditsOwned(before: PMNode, after: PMNode, rules: ProtectionState): boolean;
+/**
+ * Whether the protection lets a document go from `before` to `after`.
+ *
+ * Ownership is judged only over a change that is nothing but comments. A body edit that sweeps a
+ * comment away with the text it was anchored to is a body edit, and the standing to make one is
+ * the protection's question; under `comments` no such edit goes through in the first place.
+ */
+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.
+ */
+export declare function commentAdditionsBy(before: PMNode, after: PMNode, authorId: string): boolean;

package/dist/schema/protection.js

@@ -0,0 +1,170 @@
+// src/schema/protection.ts
+import { Fragment } from "prosemirror-model";
+var COMMENT_NODES = /* @__PURE__ */ new Set([
+  "commentStart",
+  "commentEnd",
+  "commentReference"
+]);
+function isCommentNode(node) {
+  return COMMENT_NODES.has(node.type.name);
+}
+function withoutComments(node) {
+  if (node.isLeaf) return node;
+  const kept = [];
+  node.forEach((child) => {
+    if (!isCommentNode(child)) kept.push(withoutComments(child));
+  });
+  return node.copy(Fragment.fromArray(kept));
+}
+function changesOnlyComments(before, after) {
+  return withoutComments(before).eq(withoutComments(after));
+}
+function stringOrNull(value) {
+  return typeof value === "string" ? value : null;
+}
+function bodyOf(attrs) {
+  return {
+    authorId: stringOrNull(attrs.authorId),
+    author: stringOrNull(attrs.author),
+    initials: stringOrNull(attrs.initials),
+    date: stringOrNull(attrs.date),
+    text: stringOrNull(attrs.text) ?? ""
+  };
+}
+function replyBodies(value) {
+  const replies = /* @__PURE__ */ new Map();
+  if (!Array.isArray(value)) return replies;
+  for (const entry of value) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const reply = entry;
+    const id = stringOrNull(reply.id);
+    if (id === null) continue;
+    replies.set(id, bodyOf(reply));
+  }
+  return replies;
+}
+function threadsIn(doc) {
+  const threads = /* @__PURE__ */ new Map();
+  doc.descendants((node) => {
+    if (node.type.name !== "commentReference") return true;
+    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)
+    });
+    return true;
+  });
+  return threads;
+}
+function commentOwned(rules, authorId) {
+  if (rules.editableComments === "all") return true;
+  return authorId === null || authorId === rules.authorId;
+}
+function commentAnchors(doc) {
+  const markers = /* @__PURE__ */ new Map();
+  const visit = (node, start) => {
+    if (isCommentNode(node)) {
+      const id = stringOrNull(node.attrs.id);
+      if (id !== null) {
+        const at = markers.get(id) ?? [];
+        at.push(`${node.type.name}@${start}`);
+        markers.set(id, at);
+      }
+      return 0;
+    }
+    if (node.isLeaf) return node.nodeSize;
+    let content = 0;
+    node.forEach((child) => {
+      content += visit(child, start + 1 + content);
+    });
+    return content + 2;
+  };
+  visit(doc, -1);
+  return new Map(
+    Array.from(markers, ([id, at]) => [id, at.join(" ")])
+  );
+}
+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;
+}
+function commentIdentitiesKept(before, after) {
+  const now = threadsIn(after);
+  for (const [id, thread] of threadsIn(before)) {
+    const current = now.get(id);
+    if (current === void 0) continue;
+    if (!sameIdentity(thread, current)) return false;
+    for (const [replyId, reply] of thread.replies) {
+      const currentReply = current.replies.get(replyId);
+      if (currentReply !== void 0 && !sameIdentity(reply, currentReply)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function commentEditsOwned(before, after, rules) {
+  if (!commentIdentitiesKept(before, after)) return false;
+  if (rules.editableComments === "all") return true;
+  const now = threadsIn(after);
+  const anchoredBefore = commentAnchors(before);
+  const anchoredAfter = commentAnchors(after);
+  for (const [id, thread] of threadsIn(before)) {
+    const current = now.get(id);
+    const changed = current === void 0 || !sameWords(thread, current) || anchoredBefore.get(id) !== anchoredAfter.get(id);
+    if (changed && !commentOwned(rules, thread.authorId)) return false;
+    if (current === void 0) continue;
+    for (const [replyId, reply] of thread.replies) {
+      const currentReply = current.replies.get(replyId);
+      const replyChanged = currentReply === void 0 || !sameWords(reply, currentReply);
+      if (replyChanged && !commentOwned(rules, reply.authorId)) return false;
+    }
+  }
+  return true;
+}
+function protectionAllows(before, after, rules) {
+  switch (rules.protection) {
+    case "readOnly":
+      return false;
+    case "comments":
+      return changesOnlyComments(before, after) && commentEditsOwned(before, after, rules);
+    case "none":
+      return !changesOnlyComments(before, after) || commentEditsOwned(before, after, rules);
+    default: {
+      const unmodelled = rules.protection;
+      return unmodelled;
+    }
+  }
+}
+function commentAdditionsBy(before, after, authorId) {
+  if (!commentIdentitiesKept(before, after)) return false;
+  const was = threadsIn(before);
+  for (const [id, thread] of threadsIn(after)) {
+    const earlier = was.get(id);
+    if (earlier === void 0) {
+      if (thread.authorId !== authorId) return false;
+      for (const reply of thread.replies.values()) {
+        if (reply.authorId !== authorId) return false;
+      }
+      continue;
+    }
+    for (const [replyId, reply] of thread.replies) {
+      if (!earlier.replies.has(replyId) && reply.authorId !== authorId) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+export {
+  changesOnlyComments,
+  commentAdditionsBy,
+  commentEditsOwned,
+  commentIdentitiesKept,
+  commentOwned,
+  isCommentNode,
+  protectionAllows
+};

package/dist/schema/protectionState.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Where the protection (`./protection`) stands in an editor state, and the questions commands ask
+ * of it. Kept apart from the judgements so that those stay free of editor state for the `./core`
+ * entry.
+ */
+import { type EditorState, PluginKey } from "prosemirror-state";
+import type { EditingProtection, ProtectionState } from "./protection";
+/** What a state built without the protection plugin runs under, which is what every consumer had before it existed */
+export declare const UNPROTECTED: ProtectionState;
+export declare const protectionKey: PluginKey<ProtectionState>;
+export declare function protectionOf(state: EditorState): ProtectionState;
+export declare function editingProtection(state: EditorState): EditingProtection;
+/**
+ * Whether the protection shuts every edit to the body, comments aside.
+ *
+ * This is the question a command that changes text, formatting or structure asks before it reports
+ * that it applies, the way it asks the lock predicates (`./locks`): a command reporting true and
+ * then being refused by the guard draws a live control that swallows the click.
+ */
+export declare function editsShut(state: EditorState): boolean;

package/dist/schema/protectionState.js

@@ -0,0 +1,37 @@
+// src/schema/protectionState.ts
+import { PluginKey } from "prosemirror-state";
+var UNPROTECTED = {
+  protection: "none",
+  authorId: null,
+  editableComments: "own"
+};
+var protectionKey = new PluginKey(
+  "docxEditorProtection"
+);
+function protectionOf(state) {
+  return protectionKey.getState(state) ?? UNPROTECTED;
+}
+function editingProtection(state) {
+  return protectionOf(state).protection;
+}
+function editsShut(state) {
+  const protection = editingProtection(state);
+  switch (protection) {
+    case "none":
+      return false;
+    case "readOnly":
+    case "comments":
+      return true;
+    default: {
+      const unmodelled = protection;
+      return unmodelled;
+    }
+  }
+}
+export {
+  UNPROTECTED,
+  editingProtection,
+  editsShut,
+  protectionKey,
+  protectionOf
+};

package/dist/styles/fontStack.d.ts

@@ -36,6 +36,15 @@ export interface FontFallbacks {
  * own set (`fontFallbacks` on `DocxEditor`).
  */
 export declare const DEFAULT_FONT_FALLBACKS: FontFallbacks;
+/**
+ * The form a name is compared in. Quotes, letter case, and Unicode normalization all vary
+ * from document to document, so two spellings of one name have to compare equal.
+ *
+ * NFC only. An NFK* form is lossy and would fold the fullwidth Latin of a name such as
+ * `ＤＦＫａｉＳｈｕ` into ASCII. The result is a comparison key and is never
+ * written into a document or shown: the original spelling is what gets stored and exported.
+ */
+export declare function comparableFontName(name: string): string;
 /**
  * Whether this font name belongs to a script written in Han characters, kana or
  * Hangul.

package/dist/styles/fontStack.js

@@ -189,15 +189,15 @@ var DEFAULT_FONT_FALLBACKS = {
   defaultStack: "Arial, Helvetica, sans-serif",
   defaultFontName: "Arial"
 };
-function comparableName(name) {
-  return name.trim().replace(/^["']|["']$/g, "").toLowerCase();
+function comparableFontName(name) {
+  return name.trim().replace(/^["']|["']$/g, "").toLowerCase().normalize("NFC");
 }
 var EAST_ASIAN_CHARACTER = /[\u1100-\u11ff\u3000-\u30ff\u3130-\u318f\u31f0-\u31ff\u3400-\u4dbf\u4e00-\u9fff\ua960-\ua97f\uac00-\ud7ff\uf900-\ufaff\uff00-\uffef\u{20000}-\u{2fa1f}]/u;
 var eastAsianNames = new Set(
-  EAST_ASIAN_GROUPS.flatMap((group) => group.names.map(comparableName))
+  EAST_ASIAN_GROUPS.flatMap((group) => group.names.map(comparableFontName))
 );
 function isEastAsianFontName(name) {
-  return EAST_ASIAN_CHARACTER.test(name) || eastAsianNames.has(comparableName(name));
+  return EAST_ASIAN_CHARACTER.test(name) || eastAsianNames.has(comparableFontName(name));
 }
 var stacksByFallbacks = /* @__PURE__ */ new WeakMap();
 function stackByName(fallbacks) {
@@ -206,7 +206,7 @@ function stackByName(fallbacks) {
   const stacks = /* @__PURE__ */ new Map();
   for (const group of fallbacks.groups) {
     for (const name of group.names)
-      stacks.set(comparableName(name), group.stack);
+      stacks.set(comparableFontName(name), group.stack);
   }
   stacksByFallbacks.set(fallbacks, stacks);
   return stacks;
@@ -215,7 +215,7 @@ function matchedStacks(cssNames, fallbacks) {
   const stacks = stackByName(fallbacks);
   const matched = [];
   for (const name of cssNames.split(",")) {
-    const stack = stacks.get(comparableName(name));
+    const stack = stacks.get(comparableFontName(name));
     if (stack !== void 0 && !matched.includes(stack)) matched.push(stack);
   }
   return matched;
@@ -235,12 +235,12 @@ var GENERIC_FAMILIES = /* @__PURE__ */ new Set([
   "emoji"
 ]);
 function isGenericFamily(name) {
-  return GENERIC_FAMILIES.has(comparableName(name));
+  return GENERIC_FAMILIES.has(comparableFontName(name));
 }
 function distinctNames(names) {
   const seen = /* @__PURE__ */ new Set();
   return names.filter((name) => {
-    const comparable = comparableName(name);
+    const comparable = comparableFontName(name);
     if (seen.has(comparable)) return false;
     seen.add(comparable);
     return true;
@@ -257,6 +257,7 @@ function withFontFallback(cssNames, fallbacks = DEFAULT_FONT_FALLBACKS) {
 }
 export {
   DEFAULT_FONT_FALLBACKS,
+  comparableFontName,
   isEastAsianFontName,
   withFontFallback
 };

package/dist/table/cellFormatting.js

@@ -9,6 +9,7 @@ import {
   toCellFormat
 } from "../model/format.js";
 import { isLockedCell, transactionAllowed } from "../schema/locks.js";
+import { editsShut } from "../schema/protectionState.js";
 import { cellDefaultsAt, tableCellSources } from "./gridBorders.js";
 function text(value) {
   return typeof value === "string" ? value : null;
@@ -59,7 +60,7 @@ function cellFormatCommand(edit) {
     const changes = planChanges(rect, edit);
     if (changes.length === 0) return false;
     const transaction = applyChanges(state.tr, rect.tableStart, changes);
-    if (!transactionAllowed(transaction, state.doc)) return false;
+    if (!transactionAllowed(transaction, state)) return false;
     dispatch?.(transaction);
     return true;
   };
@@ -118,6 +119,7 @@ function cellFormats(state) {
   return selectedCells(state).map((cell) => toCellFormat(cell.attrs.format));
 }
 function canSetCellFormatting(state) {
+  if (editsShut(state)) return false;
   const cells = selectedCells(state);
   return cells.length > 0 && cells.every((cell) => !isLockedCell(cell));
 }

package/dist/table/commands.js

@@ -21,7 +21,7 @@ function isInTable(state) {
 function toCommand(build) {
   return (state, dispatch) => {
     const tr = build(state);
-    if (!tr || !transactionAllowed(tr, state.doc)) return false;
+    if (!tr || !transactionAllowed(tr, state)) return false;
     dispatch?.(tr);
     return true;
   };

package/dist/table/merge.js

@@ -26,11 +26,11 @@ function cellAt(rect, row, col) {
 }
 function canMergeCells(state) {
   const tr = buildMergeCellsTransaction(state);
-  return tr !== null && transactionAllowed(tr, state.doc);
+  return tr !== null && transactionAllowed(tr, state);
 }
 function canSplitCell(state) {
   const tr = buildSplitCellTransaction(state);
-  return tr !== null && transactionAllowed(tr, state.doc);
+  return tr !== null && transactionAllowed(tr, state);
 }
 function coveredWidthSum(rect, type) {
   let sum = 0;

package/dist/ui/CommentsPanel.d.ts

@@ -5,11 +5,11 @@ import { type CommentAuthor } from "../editor/commands/commentCommands";
 export interface CommentsPanelProps {
     view: EditorView;
     state: EditorState;
-    readOnly: boolean;
     composerOpen: boolean;
-    author: CommentAuthor;
+    /** Whose comments the composers write. Null for a reader, who is offered none */
+    author: CommentAuthor | null;
     closeComposer: () => void;
     scrollContainer: HTMLElement | null;
     allCommentsOpen: boolean;
 }
-export declare function CommentsPanel({ view, state, readOnly, composerOpen, author, closeComposer, scrollContainer, allCommentsOpen, }: CommentsPanelProps): ReactElement;
+export declare function CommentsPanel({ view, state, composerOpen, author, closeComposer, scrollContainer, allCommentsOpen, }: CommentsPanelProps): ReactElement;