@portone/docx-editor 0.3.0 → 0.5.0

package/dist/editor/insertTable.js

@@ -5,7 +5,7 @@ import {
 } from "prosemirror-state";
 import { createTableNode, isTableSide } from "../docx/tableTemplate.js";
 import { editShut } from "../schema/guards.js";
-import { documentGeometry } from "./documentStyles.js";
+import { sectionGeometryAt } from "./documentStyles.js";
 function isInTable($pos) {
   for (let depth = $pos.depth; depth > 0; depth -= 1) {
     if ($pos.node(depth).type.spec.tableRole === "table") return true;
@@ -30,7 +30,7 @@ function insertTable({ rows, columns }) {
       const tr = state.tr.insert(
         at,
         Fragment.fromArray([
-          createTableNode(rows, columns, documentGeometry(state)),
+          createTableNode(rows, columns, sectionGeometryAt(state, at)),
           state.schema.nodes.paragraph.create()
         ])
       );

package/dist/editor/paragraphEdits.d.ts

@@ -8,6 +8,7 @@
  */
 import type { Node as PMNode } from "prosemirror-model";
 import type { EditorState, Transaction } from "prosemirror-state";
+import { type FormattingContext } from "../docx/formatting";
 import type { ParagraphProps } from "../docx/paraProps";
 export interface ParagraphSpot {
     pos: number;
@@ -33,5 +34,19 @@ export declare function editableParagraphs(state: EditorState): ParagraphSpot[];
 export declare function paragraphPPr(node: PMNode): string | null;
 /** How to edit a single paragraph. Null skips that paragraph */
 export type ParagraphSurgery = (node: PMNode) => ParagraphProps | null;
+/** What an edit does beyond swapping the fragments of the paragraphs it names */
+export interface ParagraphEditExtras {
+    /**
+     * The context the new display values are resolved against, which is the state's own unless the
+     * edit is itself changing it. An edit that starts a list hands in the context that already
+     * holds it, so the paragraph is drawn against the list it is joining in that same transaction.
+     */
+    formatting?: FormattingContext;
+    /**
+     * What else the edit records in the same transaction, such as the definition of the list the
+     * paragraphs are joining, so that undo takes the two back together.
+     */
+    alongside?: (tr: Transaction) => void;
+}
 /** Edits the selected paragraphs in a single transaction. Does nothing when there is nothing to edit */
-export declare function editParagraphs(state: EditorState, dispatch: ((tr: Transaction) => void) | undefined, surgery: ParagraphSurgery): boolean;
+export declare function editParagraphs(state: EditorState, dispatch: ((tr: Transaction) => void) | undefined, surgery: ParagraphSurgery, extras?: ParagraphEditExtras): boolean;

package/dist/editor/paragraphEdits.js

@@ -3,6 +3,7 @@ import { paragraphAttrsFor } from "../docx/formatting.js";
 import { docxSchema } from "../schema/index.js";
 import { editShut } from "../schema/guards.js";
 import { documentFormatting } from "./documentStyles.js";
+import { paragraphPlacementAt } from "./paragraphPlacement.js";
 function selectedParagraphs(state) {
   const spots = /* @__PURE__ */ new Map();
   for (const range of state.selection.ranges) {
@@ -23,25 +24,32 @@ function paragraphPPr(node) {
   const pPr = node.attrs.pPr;
   return typeof pPr === "string" ? pPr : null;
 }
-function writeChanges(state, changed) {
+function writeChanges(state, changed, extras) {
   const tr = state.tr;
-  const formatting = documentFormatting(state);
+  const formatting = extras.formatting ?? documentFormatting(state);
   for (const { spot, props } of changed) {
     tr.setNodeMarkup(tr.mapping.map(spot.pos), void 0, {
       ...spot.node.attrs,
       pPr: props.pPr,
-      ...paragraphAttrsFor(props.pPr, formatting)
+      ...paragraphAttrsFor(
+        props.pPr,
+        formatting,
+        paragraphPlacementAt(state.doc, spot.pos)
+      )
     });
   }
+  extras.alongside?.(tr);
   return tr;
 }
-function editParagraphs(state, dispatch, surgery) {
+function editParagraphs(state, dispatch, surgery, extras = {}) {
   const changed = editableParagraphs(state).flatMap((spot) => {
     const props = surgery(spot.node);
     return props ? [{ spot, props }] : [];
   });
   if (changed.length === 0) return false;
-  if (dispatch) dispatch(writeChanges(state, changed).scrollIntoView());
+  if (dispatch) {
+    dispatch(writeChanges(state, changed, extras).scrollIntoView());
+  }
   return true;
 }
 export {

package/dist/editor/paragraphPlacement.d.ts

@@ -0,0 +1,11 @@
+/** Finds the table-style conditions at an editor position for both reads and writes. */
+import type { Node as PMNode } from "prosemirror-model";
+import type { ParagraphPlacement } from "../docx/formatting";
+/**
+ * The part of a table the paragraph stands in, which its table style dresses it by. null for a
+ * paragraph of the body, and for one in a cell of a table this editor did not build.
+ *
+ * The cell is found by walking out of the paragraph rather than passed down, because the walk that
+ * runs the derivers goes over the blocks and hands each of them nothing but its own position.
+ */
+export declare function paragraphPlacementAt(doc: PMNode, pos: number): ParagraphPlacement | null;

package/dist/editor/paragraphPlacement.js

@@ -0,0 +1,18 @@
+// src/editor/paragraphPlacement.ts
+import { TableMap } from "prosemirror-tables";
+import { docxSchema } from "../schema/index.js";
+import { cellDefaultsAt, tableCellSources } from "../table/gridBorders.js";
+function paragraphPlacementAt(doc, pos) {
+  const $pos = doc.resolve(pos);
+  for (let depth = $pos.depth; depth >= 2; depth -= 1) {
+    if ($pos.node(depth).type !== docxSchema.nodes.tableCell) continue;
+    const table = $pos.node(depth - 2);
+    if (table.type !== docxSchema.nodes.table) return null;
+    const cell = $pos.before(depth) - $pos.start(depth - 2);
+    return cellDefaultsAt(TableMap.get(table), cell, tableCellSources(table)).placement;
+  }
+  return null;
+}
+export {
+  paragraphPlacementAt
+};

package/dist/editor/plainText.d.ts

@@ -1,3 +1,15 @@
 import type { EditorView } from "prosemirror-view";
+/** A single character that becomes an element, or text that goes in as it is */
+export type Piece = {
+    text: string;
+} | {
+    node: "hardBreak" | "tab";
+};
+/**
+ * Splits the incoming text into the pieces to be put into the document.
+ * Control characters that carry meaning become elements, and the rest are stripped because they
+ * would make the file impossible to open.
+ */
+export declare function toPieces(source: string): Piece[];
 export declare function insertPlainText(view: EditorView, source: string): void;
 export declare function insertPlainTextAt(view: EditorView, source: string, from: number, to: number): void;

package/dist/editor/plainText.js

@@ -46,5 +46,6 @@ function insertPlainTextAt(view, source, from, to) {
 }
 export {
   insertPlainText,
-  insertPlainTextAt
+  insertPlainTextAt,
+  toPieces
 };

package/dist/editor/plugins/columnResize.js

@@ -14,7 +14,7 @@ import {
   shiftedTableWidth,
   tableGridCols
 } from "../../table/widths.js";
-import { documentGeometry } from "../documentStyles.js";
+import { sectionGeometryAt } from "../documentStyles.js";
 import { TableNodeView } from "../views/tableView.js";
 var EDGE_TOLERANCE_PX = 4;
 var FALLBACK_DXA_PER_PX = 15;
@@ -127,7 +127,7 @@ function columnResize() {
         col: current.target.col,
         width: current.width
       },
-      documentGeometry(current.view.state)
+      sectionGeometryAt(current.view.state, current.target.tablePos)
     );
     if (tr) current.view.dispatch(tr);
   }
@@ -144,7 +144,10 @@ function columnResize() {
     drag = {
       view,
       target,
-      maxTotal: maxGridTotal(target.table, documentGeometry(view.state)),
+      maxTotal: maxGridTotal(
+        target.table,
+        sectionGeometryAt(view.state, target.tablePos)
+      ),
       startX: event.clientX,
       dxaPerPx: dxaPerPx(target.gridCols, target.tableDom),
       cols,

package/dist/editor/plugins/commentComposer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Where the built-in comment composer stands: the stretch of text it was opened over, or nothing
+ * when it is shut.
+ *
+ * The stretch is the point of holding it here rather than in the component that draws the form.
+ * A comment is written about text the reader picked out, and writing it takes as long as it takes:
+ * the caret moves on, the page is scrolled, a word elsewhere is fixed. The stretch is moved along
+ * by every edit that happens meanwhile, so the comment lands on the text it was written for, and
+ * the form goes away by itself once that text is gone or the document stops taking comments.
+ *
+ * The commands here are the editor's own. A consumer opening its own composer from its own toolbar
+ * is a public surface this package has not settled yet, so nothing below is exported from
+ * `./commands`.
+ */
+import type { Command, EditorState, Plugin } from "prosemirror-state";
+import type { CommentRange } from "../commands/comments/model";
+/**
+ * Opens the composer over the selected text. False where a comment could not go there anyway, so
+ * the menu entry that runs it is drawn dead rather than opening a form nothing would come of. It
+ * is the same question that entry is drawn from, asked of the same selection.
+ */
+export declare const openCommentComposer: Command;
+/** Closes it. Called on Cancel, on the comment being written, and on the panel being put away */
+export declare const closeCommentComposer: Command;
+export declare function isCommentComposerOpen(state: EditorState): boolean;
+/** The stretch the open composer is writing about. Null when no composer stands */
+export declare function commentComposerRange(state: EditorState): CommentRange | null;
+export declare function commentComposer(): Plugin<CommentRange | null>;

package/dist/editor/plugins/commentComposer.js

@@ -0,0 +1,46 @@
+// src/editor/plugins/commentComposer.ts
+import { canAddComment } from "../commands/comments/editing.js";
+import { panelPlugin } from "./panelState.js";
+function isCommentRange(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const { from, to } = value;
+  return typeof from === "number" && typeof to === "number";
+}
+var composer = panelPlugin({
+  name: "docxEditorCommentComposer",
+  isAnchor: isCommentRange,
+  // The stretch moves with the text around it. Its two ends are biased inwards, so text typed
+  // against either edge stays outside the comment and an edit that swallows the stretch leaves
+  // the two ends together, which is the form closing
+  onDocChange: (anchor, tr) => {
+    const from = tr.mapping.map(anchor.from, 1);
+    const to = tr.mapping.map(anchor.to, -1);
+    return to > from ? { from, to } : null;
+  },
+  // Asked after every transaction, which is what catches the mode being switched to read-only:
+  // that changes no text, so the mapping above never sees it. It is also what keeps the form from
+  // ever standing over a stretch that takes no comment, whoever opened it
+  closeWhen: (state, anchor) => !canAddComment(state, anchor)
+});
+var openCommentComposer = (state, dispatch) => {
+  if (!canAddComment(state)) return false;
+  const { from, to } = state.selection;
+  return composer.open({ from, to })(state, dispatch);
+};
+var closeCommentComposer = composer.close;
+function isCommentComposerOpen(state) {
+  return composer.anchor(state) !== null;
+}
+function commentComposerRange(state) {
+  return composer.anchor(state);
+}
+function commentComposer() {
+  return composer.plugin;
+}
+export {
+  closeCommentComposer,
+  commentComposer,
+  commentComposerRange,
+  isCommentComposerOpen,
+  openCommentComposer
+};

package/dist/editor/plugins/commentDecorations.d.ts

@@ -1,3 +1,30 @@
-/** Draws the text ranges identified by Word comment markers. */
-import { Plugin } from "prosemirror-state";
+/**
+ * What the comments in a document come to, worked out once per edit: the threads in document
+ * order, the lookup a command asking after one of them uses, and the ranges drawn over the text
+ * each was written for.
+ *
+ * All three are read off the same walk. Which comments a document holds is decided by the document
+ * and nothing else, so it is a projection (`./documentProjection`) rather than something worked
+ * out again for every command asked, every decoration drawn and every render of the list beside
+ * the page.
+ */
+import type { Plugin } from "prosemirror-state";
+import { DecorationSet } from "prosemirror-view";
+import { type DocumentComment } from "../commands/comments/model";
+export interface DocumentComments {
+    comments: readonly DocumentComment[];
+    /**
+     * The comments by id. A document can hold the same id twice - a reference copied and pasted
+     * carries the one it was written with - and the first of them wins, which is the one a search
+     * through the list in document order arrived at.
+     */
+    byId: ReadonlyMap<string, DocumentComment>;
+    /** The stretch each comment was written for, drawn as it stood when the edit landed */
+    decorations: DecorationSet;
+}
+export declare const commentProjection: import("./documentProjection").DocumentProjection<DocumentComments>;
+/**
+ * What a state built by `createEditor` registers: the comments it goes on to answer, and the
+ * ranges drawn over the text identified by the Word comment markers holding them.
+ */
 export declare function commentDecorations(): Plugin;

package/dist/editor/plugins/commentDecorations.js

@@ -1,23 +1,97 @@
 // src/editor/plugins/commentDecorations.ts
-import { Plugin } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
+import { storyKey, storyOf, storyText } from "../../docx/story.js";
 import { editorClassNames } from "../../styles/classNames.js";
-import { documentComments } from "../commands/commentCommands.js";
-function commentDecorations() {
-  return new Plugin({
-    props: {
-      decorations(state) {
-        const decorations = documentComments(state).filter((comment) => comment.from < comment.to).map(
-          (comment) => Decoration.inline(comment.from, comment.to, {
-            class: editorClassNames.commentRange,
-            "data-comment-id": comment.id
-          })
-        );
-        return DecorationSet.create(state.doc, decorations);
-      }
+import {
+  repliesAttr,
+  stringAttr
+} from "../commands/comments/model.js";
+import { documentProjection } from "./documentProjection.js";
+function markerPositions(doc) {
+  const starts = /* @__PURE__ */ new Map();
+  const ends = /* @__PURE__ */ new Map();
+  const references = [];
+  doc.descendants((node, pos) => {
+    const id = stringAttr(node.attrs.id);
+    if (id === null) return true;
+    if (node.type.name === "commentStart" && !starts.has(id)) {
+      starts.set(id, pos);
+    } else if (node.type.name === "commentEnd" && !ends.has(id)) {
+      ends.set(id, pos);
+    } else if (node.type.name === "commentReference") {
+      references.push({ node, pos });
     }
+    return true;
+  });
+  return { starts, ends, references };
+}
+function bodyText(doc, id) {
+  return storyText(storyOf(doc, storyKey("comment", id)));
+}
+function commentsIn(doc) {
+  const markers = markerPositions(doc);
+  return markers.references.map(({ node, pos }) => {
+    const id = stringAttr(node.attrs.id) ?? "";
+    const start = markers.starts.get(id);
+    const end = markers.ends.get(id);
+    const hasRange = start !== void 0 && end !== void 0 && start < end;
+    const point = start ?? end ?? pos;
+    return {
+      id,
+      author: stringAttr(node.attrs.author),
+      authorId: stringAttr(node.attrs.authorId),
+      initials: stringAttr(node.attrs.initials),
+      date: stringAttr(node.attrs.date),
+      text: bodyText(doc, id),
+      from: hasRange ? start + 1 : point,
+      to: hasRange ? end : point,
+      referencePos: pos,
+      resolved: node.attrs.resolved === true,
+      replies: repliesAttr(node.attrs.replies).map((reply) => ({
+        id: reply.id,
+        author: reply.author,
+        authorId: reply.authorId,
+        initials: reply.initials,
+        date: reply.date,
+        text: bodyText(doc, reply.id)
+      }))
+    };
   });
 }
+function deriveComments(doc) {
+  const comments = commentsIn(doc);
+  const byId = /* @__PURE__ */ new Map();
+  for (const comment of comments) {
+    if (!byId.has(comment.id)) byId.set(comment.id, comment);
+  }
+  return {
+    comments,
+    byId,
+    decorations: DecorationSet.create(
+      doc,
+      comments.filter((comment) => comment.from < comment.to).map(
+        (comment) => Decoration.inline(comment.from, comment.to, {
+          class: editorClassNames.commentRange,
+          "data-comment-id": comment.id
+        })
+      )
+    )
+  };
+}
+var commentProjection = documentProjection(
+  "docxEditorComments",
+  deriveComments,
+  {
+    // The set the last edit derived. Written as a method so that `this` is the plugin holding it
+    decorations(state) {
+      return this.getState(state)?.decorations;
+    }
+  }
+);
+function commentDecorations() {
+  return commentProjection.plugin;
+}
 export {
-  commentDecorations
+  commentDecorations,
+  commentProjection
 };

package/dist/editor/plugins/documentProjection.d.ts

@@ -0,0 +1,31 @@
+/**
+ * One convention for a value the whole document decides: the comments beside it, the notes under
+ * it, the list markers drawn over it.
+ *
+ * Such a value is worked out by walking the document, and what it is worked out from changes only
+ * when the document does. Held here, it is derived once per edit rather than once per read, and a
+ * caret moving, a menu opening or a component rendering again all read back the value the last
+ * edit left. What a caller writes is unchanged: `read` answers with a value either way.
+ *
+ * A projection derives from the document alone. Anything that also depends on the selection, the
+ * protection or another plugin belongs in that plugin, which is asked again after every
+ * transaction rather than after an edit alone.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type EditorState, Plugin, type PluginSpec } from "prosemirror-state";
+export interface DocumentProjection<T> {
+    plugin: Plugin<T>;
+    /**
+     * The derived value. A state built without the plugin - one a consumer assembled itself, or one
+     * a test made out of a bare document - is answered by deriving on the spot, so a public reader
+     * standing on a projection keeps answering whoever asks it.
+     */
+    read(state: EditorState): T;
+}
+export declare function documentProjection<T>(name: string, derive: (doc: PMNode) => T, 
+/**
+ * The view props drawn from the derived value, which is how a projection that paints what it
+ * derived - comment ranges over the text they were written for - stays one plugin. `this` in
+ * such a prop is the plugin, so it reads the value back with `this.getState(state)`.
+ */
+props?: PluginSpec<T>["props"]): DocumentProjection<T>;

package/dist/editor/plugins/documentProjection.js

@@ -0,0 +1,22 @@
+// src/editor/plugins/documentProjection.ts
+import {
+  Plugin,
+  PluginKey
+} from "prosemirror-state";
+function documentProjection(name, derive, props) {
+  const key = new PluginKey(name);
+  return {
+    plugin: new Plugin({
+      key,
+      state: {
+        init: (_config, state) => derive(state.doc),
+        apply: (tr, held) => tr.docChanged ? derive(tr.doc) : held
+      },
+      props
+    }),
+    read: (state) => key.getState(state) ?? derive(state.doc)
+  };
+}
+export {
+  documentProjection
+};

package/dist/editor/plugins/imagePaste.js

@@ -3,12 +3,14 @@ import { isHistoryTransaction } from "prosemirror-history";
 import { Plugin, PluginKey } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
 import { editShut, selectionIntents } from "../../schema/guards.js";
+import { readHtmlSlice, withPastedContent } from "../clipboard/htmlReader.js";
 import {
   hasResolvableClipboardImages,
   resolveClipboardImages
 } from "../clipboard/images.js";
-import { documentBodyHeightPx, documentBodyWidthPx } from "../documentStyles.js";
-import { richHtmlSlice } from "../externalClipboard.js";
+import { plainTextPaste } from "../clipboard/parser.js";
+import { readContextOf } from "../clipboard/readContext.js";
+import { documentBodyWidthPx, sectionBodyHeightPx } from "../documentStyles.js";
 import { insertPlainTextAt } from "../plainText.js";
 var LOAD_TIMEOUT_MS = 15e3;
 var imagePasteKey = new PluginKey("docxImagePaste");
@@ -87,15 +89,20 @@ function imagePaste() {
     if (!range) return;
     removeMarker(task);
     if (task.view.isDestroyed) return;
-    const slice = resolved === null || resolved.images.size === 0 ? null : richHtmlSlice(
-      task.view.state,
-      task.view.dom.ownerDocument,
-      resolved.source,
-      resolved.images
+    const content = resolved === null || resolved.images.size === 0 ? null : readHtmlSlice(
+      readContextOf(
+        task.view.state,
+        task.view.dom.ownerDocument,
+        resolved.images
+      ),
+      resolved.source
     );
-    if (slice !== null) {
+    if (content !== null) {
       task.view.dispatch(
-        task.view.state.tr.replaceRange(range.from, range.to, slice).scrollIntoView()
+        withPastedContent(
+          task.view.state.tr.replaceRange(range.from, range.to, content.slice),
+          content
+        ).scrollIntoView()
       );
     } else {
       insertPlainTextAt(task.view, task.text, range.from, range.to);
@@ -222,6 +229,7 @@ function imagePaste() {
     props: {
       decorations: (state) => imagePasteKey.getState(state)?.decorations,
       handlePaste(view, event) {
+        if (plainTextPaste(view, event)) return false;
         if (selectionIntents(view.state.selection, "replace").some(
           (intent) => editShut(view.state, intent)
         )) {
@@ -253,8 +261,10 @@ function imagePaste() {
           view,
           html,
           text,
+          // One sheet is drawn at one width, the first section's, and a pasted image is fitted
+          // to it; how tall a page is, though, is the paper of the section it lands in
           maxWidthPx: documentBodyWidthPx(view.state),
-          maxHeightPx: documentBodyHeightPx(view.state),
+          maxHeightPx: sectionBodyHeightPx(view.state, from),
           canceled: false,
           controller: null
         });

package/dist/editor/plugins/linkPanel.d.ts

@@ -9,15 +9,19 @@
  * It closes on the document changing, which is what applying a link or taking one off does: the
  * panel is about the selection it opened over, and after an edit that selection has been answered.
  */
-import { type Command, type EditorState, Plugin } from "prosemirror-state";
+import type { Command, EditorState, Plugin } from "prosemirror-state";
+/** The panel is about the selection it opened over, so standing open is all there is to hold */
+declare const OPEN = true;
 /** Whether the link panel is open */
 export declare function isLinkPanelOpen(state: EditorState): boolean;
 /**
  * Opens the panel. It reports false where a link could not go on anyway - a caret standing in no
  * link, a selection a lock leaves nothing of - so that Cmd+K there is a key this editor did not
- * take, and a control drawn from it is drawn dead.
+ * take, and a control drawn from it is drawn dead. A panel already open is one more such place:
+ * the button that opened it has nothing left to do while it stands.
  */
 export declare const openLinkPanel: Command;
 /** Closes it. Called on applying, on Escape, and on a click outside */
 export declare const closeLinkPanel: Command;
-export declare function linkPanel(): Plugin<boolean>;
+export declare function linkPanel(): Plugin<typeof OPEN | null>;
+export {};

package/dist/editor/plugins/linkPanel.js

@@ -1,35 +1,21 @@
 // src/editor/plugins/linkPanel.ts
-import {
-  Plugin,
-  PluginKey
-} from "prosemirror-state";
 import { canSetLink } from "../commands/linkCommands.js";
-var panelKey = new PluginKey("docxEditorLinkPanel");
+import { panelPlugin } from "./panelState.js";
+var OPEN = true;
+var panel = panelPlugin({
+  name: "docxEditorLinkPanel",
+  isAnchor: (value) => value === OPEN,
+  // An edit answers the panel: the link went on, came off, or the text it was about moved
+  onDocChange: "close",
+  canOpen: (state) => canSetLink(state)
+});
 function isLinkPanelOpen(state) {
-  return panelKey.getState(state) === true;
+  return panel.anchor(state) === OPEN;
 }
-var openLinkPanel = (state, dispatch) => {
-  if (isLinkPanelOpen(state) || !canSetLink(state)) return false;
-  if (dispatch) dispatch(state.tr.setMeta(panelKey, true));
-  return true;
-};
-var closeLinkPanel = (state, dispatch) => {
-  if (!isLinkPanelOpen(state)) return false;
-  if (dispatch) dispatch(state.tr.setMeta(panelKey, false));
-  return true;
-};
+var openLinkPanel = (state, dispatch) => !isLinkPanelOpen(state) && panel.open(OPEN)(state, dispatch);
+var closeLinkPanel = panel.close;
 function linkPanel() {
-  return new Plugin({
-    key: panelKey,
-    state: {
-      init: () => false,
-      apply: (tr, open) => {
-        const meta = tr.getMeta(panelKey);
-        if (typeof meta === "boolean") return meta;
-        return tr.docChanged ? false : open;
-      }
-    }
-  });
+  return panel.plugin;
 }
 export {
   closeLinkPanel,

package/dist/editor/plugins/numberingDecorations.d.ts

@@ -6,7 +6,8 @@
 import type { Node as PMNode } from "prosemirror-model";
 import { type EditorState, Plugin } from "prosemirror-state";
 import { DecorationSet } from "prosemirror-view";
-import type { Numbering } from "../../numbering/parseNumbering";
+import { type RunFormat } from "../../model/format";
+import type { LevelAlign, LevelSuffix, Numbering } from "../../numbering/parseNumbering";
 /** A number to draw on screen and the paragraph position it attaches to */
 export interface PlacedMarker {
     from: number;
@@ -19,6 +20,12 @@ export interface PlacedMarker {
     indentEndPt: number | null;
     /** The first-line indentation, under the same rule */
     textIndentPt: number | null;
+    /** What the level puts between the number and the text (`w:suff`) */
+    suffix: LevelSuffix;
+    /** Where the number sits inside the width kept for it (`w:lvlJc`) */
+    align: LevelAlign;
+    /** The formatting the level puts on the number alone (`lvl/rPr`) */
+    run: RunFormat | null;
 }
 /** Walks a document to find the paragraphs that get numbers and what those numbers are */
 export declare function paragraphMarkers(doc: PMNode, numbering: Numbering): PlacedMarker[];
@@ -27,9 +34,8 @@ export declare function markerDecorations(doc: PMNode, numbering: Numbering): De
 export declare function documentNumbering(state: EditorState): Numbering;
 /**
  * Whether a new list can be started in this document.
- * A document without numbering.xml has nowhere to write a new definition, so it would be
- * blocked at export time. In such a document the commands that start a list do not apply
- * in the first place.
+ * A document with nowhere to write a new definition would be blocked at export time, so in such
+ * a document the commands that start a list do not apply in the first place.
  */
 export declare function canStartNewList(state: EditorState): boolean;
 /** Draws the numbers this document's lists put in front of their paragraphs */