@portone/docx-editor 0.3.0 → 0.5.0

package/dist/editor/commands/formatting/propertyCommands.js

@@ -12,6 +12,7 @@ import {
 import { docxSchema } from "../../../schema/index.js";
 import { editShut, openStretches } from "../../../schema/guards.js";
 import { documentFormatting } from "../../documentStyles.js";
+import { paragraphPlacementAt } from "../../paragraphPlacement.js";
 import {
   activePieces,
   caretPiece,
@@ -21,7 +22,11 @@ import {
 function editedMark(state, target, edit) {
   const context = documentFormatting(state);
   const rPr = text(target.mark?.attrs.rPr);
-  const paragraph = resolveParagraph(target.pPr, context);
+  const paragraph = resolveParagraph(
+    target.pPr,
+    context,
+    paragraphPlacementAt(state.doc, target.from)
+  );
   const next = editRunProps(
     { rPr, format: target.format },
     inheritedRunFormat(rPr, paragraph, context),

package/dist/editor/commands/index.d.ts

@@ -56,8 +56,8 @@ export { insertLineBreak, insertPageBreak } from "./breakCommands";
  * question takes are not exported anywhere.
  */
 export { canRunCommand } from "./canRunCommand";
-export type { CommentAuthor, DocumentComment, DocumentCommentReply, NewComment, } from "./commentCommands";
-export { addComment, addCommentReply, canAddComment, canEditComment, documentComments, removeComment, removeCommentReply, selectComment, setCommentResolved, updateComment, updateCommentReply, } from "./commentCommands";
+export type { CommentAuthor, CommentRange, DocumentComment, DocumentCommentReply, NewComment, } from "./commentCommands";
+export { addComment, addCommentReply, canAddComment, canEditComment, documentComments, removeComment, removeCommentReply, selectComment, setCommentBody, setCommentResolved, updateComment, updateCommentReply, } from "./commentCommands";
 /**
  * Whether the document as it stands can be written back, and every reason it could not, each
  * with the code `exportDocx` would throw it under. `canExport` is what an export control is

package/dist/editor/commands/index.js

@@ -25,6 +25,7 @@ import {
   removeComment,
   removeCommentReply,
   selectComment,
+  setCommentBody,
   setCommentResolved,
   updateComment,
   updateCommentReply
@@ -158,6 +159,7 @@ export {
   selectComment,
   selectionLock,
   selectionTouchesLocked,
+  setCommentBody,
   setCommentResolved,
   setFontFamily,
   setFontSize,

package/dist/editor/commands/listCommands.d.ts

@@ -4,7 +4,8 @@
  * All they do is change a paragraph's place in a list (its numbering id and level).
  * Editing the formatting fragments belongs to `docx/paraProps`, and the list's appearance
  * belongs to `numbering/`.
- * The definition of a new list is not put into the document; numbering.xml picks it up on export.
+ * Starting a list records its definition on the document node in the same transaction, and the
+ * export writes that definition into numbering.xml.
  */
 import type { Node as PMNode } from "prosemirror-model";
 import type { Command, EditorState } from "prosemirror-state";
@@ -24,6 +25,8 @@ export declare function listLevelChange(numbering: Numbering, node: PMNode, delt
 export declare const increaseListLevel: Command;
 /** Moves a list item one level back up, which is not the paragraph's own indent. What Shift+Tab does */
 export declare const decreaseListLevel: Command;
+/** Every numbering id a paragraph of this document wears */
+export declare function numIdsIn(doc: PMNode): Set<number>;
 /**
  * Takes the selected paragraphs out of the list.
  * Only the hanging indentation the marker sat in goes with it; an indentation the paragraph had
@@ -31,8 +34,14 @@ export declare const decreaseListLevel: Command;
  */
 export declare const removeFromList: Command;
 /**
- * The kind of list the selected paragraphs belong to. Null when they are not a list or the kinds
- * are mixed.
+ * The kind of this list position, which the number format of its level decides.
+ * Null where nothing defines the list, which is a position whose kind cannot be told and so is
+ * neither of the two buttons.
+ */
+export declare function listKindOf(numbering: Numbering, ref: NumberingRef): ListKind | null;
+/**
+ * The kind of list the selected paragraphs belong to. Null when they are not a list, when nothing
+ * defines the list they are in, or when the kinds are mixed.
  * It reads the paragraphs a lock leaves open, the same ones `editParagraphs` writes to: counting a
  * locked paragraph that stays out of the list would keep the answer mixed, so the button would make
  * a list a second time instead of taking it off.

package/dist/editor/commands/listCommands.js

@@ -5,12 +5,18 @@ import {
 } from "../../docx/paraProps.js";
 import { toParagraphFormat } from "../../model/format.js";
 import {
+  listsWorn,
+  NEW_LISTS_ATTR,
+  newListsValue
+} from "../../numbering/listRegistry.js";
+import {
+  allocateList,
   listFor,
-  listKindOf,
   MAX_ILVL,
-  nextNumId
+  templateList
 } from "../../numbering/listTemplate.js";
 import { docxSchema } from "../../schema/index.js";
+import { documentFormatting } from "../documentStyles.js";
 import {
   editableParagraphs,
   editParagraphs,
@@ -24,18 +30,25 @@ import {
 function listRefOf(node) {
   return toParagraphFormat(node.attrs.format)?.numbering ?? null;
 }
-function changeParagraphs(state, dispatch, plan) {
-  return editParagraphs(state, dispatch, (node) => {
-    const change = plan(node);
-    return change && withListNumbering(paragraphPPr(node), change);
-  });
+function changeParagraphs(state, dispatch, plan, extras = {
+  alongside: pruneLists(documentNumbering(state).added)
+}) {
+  return editParagraphs(
+    state,
+    dispatch,
+    (node) => {
+      const change = plan(node);
+      return change && withListNumbering(paragraphPPr(node), change);
+    },
+    extras
+  );
 }
 function indentForLevel(numbering, node, ref) {
   const format = toParagraphFormat(node.attrs.format);
   if (format?.indentStartPt === void 0 && format?.indentLeftPt === void 0) {
     return { kind: "keep" };
   }
-  const indent = listFor(numbering, ref.numId).levels.get(ref.ilvl)?.indent;
+  const indent = listFor(numbering, ref.numId)?.levels.get(ref.ilvl)?.indent;
   return indent ? { kind: "level", indent } : { kind: "keep" };
 }
 function listLevelChange(numbering, node, delta) {
@@ -58,24 +71,50 @@ function levelShift(delta) {
 }
 var increaseListLevel = levelShift(1);
 var decreaseListLevel = levelShift(-1);
-function usedNumIds(state, numbering) {
-  const used = new Set(numbering.lists.keys());
-  state.doc.descendants((node) => {
+function numIdsIn(doc) {
+  const worn = /* @__PURE__ */ new Set();
+  doc.descendants((node) => {
     if (node.type !== docxSchema.nodes.paragraph) return true;
     const ref = listRefOf(node);
-    if (ref) used.add(ref.numId);
+    if (ref) worn.add(ref.numId);
     return false;
   });
-  return used;
+  return worn;
+}
+function recordLists(tr, lists) {
+  tr.setDocAttribute(
+    NEW_LISTS_ATTR,
+    newListsValue(listsWorn(lists, numIdsIn(tr.doc)))
+  );
+}
+function pruneLists(lists) {
+  return (tr) => {
+    if (listsWorn(lists, numIdsIn(tr.doc)) !== lists) recordLists(tr, lists);
+  };
 }
 function startList(kind) {
   return (state, dispatch) => {
     if (!canStartNewList(state)) return false;
-    const numId = nextNumId(usedNumIds(state, documentNumbering(state)), kind);
-    return changeParagraphs(state, dispatch, (node) => ({
-      numbering: { numId, ilvl: listRefOf(node)?.ilvl ?? 0 },
-      indent: { kind: "keep" }
-    }));
+    const started = allocateList(
+      documentNumbering(state),
+      numIdsIn(state.doc),
+      templateList(kind)
+    );
+    return changeParagraphs(
+      state,
+      dispatch,
+      (node) => ({
+        numbering: { numId: started.numId, ilvl: listRefOf(node)?.ilvl ?? 0 },
+        indent: { kind: "keep" }
+      }),
+      {
+        formatting: {
+          ...documentFormatting(state),
+          numbering: started.numbering
+        },
+        alongside: (tr) => recordLists(tr, started.numbering.added)
+      }
+    );
   };
 }
 var removeFromList = (state, dispatch) => changeParagraphs(
@@ -83,16 +122,16 @@ var removeFromList = (state, dispatch) => changeParagraphs(
   dispatch,
   (node) => listRefOf(node) ? { numbering: null, indent: { kind: "clearHanging" } } : null
 );
-function kindOf(numbering, ref) {
-  const level = listFor(numbering, ref.numId).levels.get(ref.ilvl);
-  if (!level) return listKindOf(ref.numId);
+function listKindOf(numbering, ref) {
+  const level = listFor(numbering, ref.numId)?.levels.get(ref.ilvl);
+  if (!level) return null;
   return level.format === "bullet" ? "bullet" : "numbered";
 }
 function activeListKind(state) {
   const numbering = documentNumbering(state);
   const kinds = editableParagraphs(state).map(({ node }) => {
     const ref = listRefOf(node);
-    return ref === null ? null : kindOf(numbering, ref);
+    return ref === null ? null : listKindOf(numbering, ref);
   });
   const first = kinds[0] ?? null;
   return kinds.every((kind) => kind === first) ? first : null;
@@ -107,14 +146,19 @@ function isInList(state) {
     (spot) => listRefOf(spot.node) !== null
   );
 }
-var leaveListAtLineStart = (state, dispatch) => editParagraphs(state, dispatch, (node) => {
-  if (!listRefOf(node)) return null;
-  const unlisted = withListNumbering(paragraphPPr(node), {
-    numbering: null,
-    indent: { kind: "clearHanging" }
-  });
-  return unlisted && withLeftIndent(unlisted.pPr, 0);
-});
+var leaveListAtLineStart = (state, dispatch) => editParagraphs(
+  state,
+  dispatch,
+  (node) => {
+    if (!listRefOf(node)) return null;
+    const unlisted = withListNumbering(paragraphPPr(node), {
+      numbering: null,
+      indent: { kind: "clearHanging" }
+    });
+    return unlisted && withLeftIndent(unlisted.pPr, 0);
+  },
+  { alongside: pruneLists(documentNumbering(state).added) }
+);
 var leaveEmptyListItem = (state, dispatch) => {
   const { empty, $from } = state.selection;
   const paragraph = $from.parent;
@@ -130,8 +174,10 @@ export {
   increaseListLevel,
   isInList,
   leaveEmptyListItem,
+  listKindOf,
   listLevelChange,
   listRefOf,
+  numIdsIn,
   removeFromList,
   toggleBulletList,
   toggleNumberedList

package/dist/editor/commands/noteQueries.d.ts

@@ -1,12 +1,29 @@
 /** Document-level readers for imported footnotes and endnotes. */
 import type { EditorState } from "prosemirror-state";
+import { DecorationSet } from "prosemirror-view";
 import type { NoteKind } from "../../docx/notes";
 export interface DocumentNote {
-    kind: NoteKind;
-    id: string;
-    label: string;
-    text: string;
-    referencePos: number;
+    readonly kind: NoteKind;
+    readonly id: string;
+    readonly label: string;
+    readonly text: string;
+    readonly referencePos: number;
 }
+interface NoteProjection {
+    notes: readonly DocumentNote[];
+    /**
+     * The body of each note on the marker pointing at it, which is the tooltip a reader gets without
+     * looking away from the line. It is drawn rather than written on the node, because what a note
+     * says is a story on the document and not an attr of the reference.
+     */
+    tooltips: DecorationSet;
+}
+/**
+ * Which notes the document refers to is the document's to decide, so the list is worked out once
+ * per edit (`editor/plugins/documentProjection`) rather than once per render of the panel under
+ * the page.
+ */
+export declare const noteProjection: import("../plugins/documentProjection").DocumentProjection<NoteProjection>;
 /** The distinct notes referenced by the main document story, in first-reference order. */
 export declare function documentNotes(state: EditorState): readonly DocumentNote[];
+export {};

package/dist/editor/commands/noteQueries.js

@@ -1,15 +1,29 @@
 // src/editor/commands/noteQueries.ts
+import { Decoration, DecorationSet } from "prosemirror-view";
+import { storyKey, storyOf, storyText } from "../../docx/story.js";
+import { documentProjection } from "../plugins/documentProjection.js";
 function stringAttr(value) {
   return typeof value === "string" ? value : null;
 }
-function documentNotes(state) {
+function noteKindOf(node) {
+  return node.attrs.kind === "endnote" ? "endnote" : "footnote";
+}
+function noteText(doc, kind, id) {
+  return storyText(storyOf(doc, storyKey(kind, id)));
+}
+function deriveNotes(doc) {
   const notes = [];
+  const tooltips = [];
   const seen = /* @__PURE__ */ new Set();
-  state.doc.descendants((node, pos) => {
+  doc.descendants((node, pos) => {
     if (node.type.name !== "noteReference") return true;
     const id = stringAttr(node.attrs.id);
     if (id === null) return true;
-    const kind = node.attrs.kind === "endnote" ? "endnote" : "footnote";
+    const kind = noteKindOf(node);
+    const text = noteText(doc, kind, id);
+    if (text !== "") {
+      tooltips.push(Decoration.node(pos, pos + node.nodeSize, { title: text }));
+    }
     const key = `${kind}:${id}`;
     if (seen.has(key)) return true;
     seen.add(key);
@@ -17,13 +31,27 @@ function documentNotes(state) {
       kind,
       id,
       label: stringAttr(node.attrs.label) ?? "?",
-      text: stringAttr(node.attrs.text) ?? "",
+      text,
       referencePos: pos
     });
     return true;
   });
-  return notes;
+  return { notes, tooltips: DecorationSet.create(doc, tooltips) };
+}
+var noteProjection = documentProjection(
+  "docxEditorNotes",
+  deriveNotes,
+  {
+    // The set the last edit derived. Written as a method so that `this` is the plugin holding it
+    decorations(state) {
+      return this.getState(state)?.tooltips;
+    }
+  }
+);
+function documentNotes(state) {
+  return noteProjection.read(state).notes;
 }
 export {
-  documentNotes
+  documentNotes,
+  noteProjection
 };

package/dist/editor/commands/paragraphCommands.js

@@ -19,6 +19,7 @@ import {
   paragraphPPr,
   selectedParagraphs
 } from "../paragraphEdits.js";
+import { paragraphPlacementAt } from "../paragraphPlacement.js";
 function alignOf(node) {
   return toParagraphFormat(node.attrs.format)?.align ?? "left";
 }
@@ -78,7 +79,11 @@ function setParagraphStyle(styleId) {
       if (styleIdOf(pPr) === styleId) return [];
       const props = withParagraphStyle(pPr, styleId);
       if (!props) return [];
-      const paragraph = resolveParagraph(props.pPr, context);
+      const paragraph = resolveParagraph(
+        props.pPr,
+        context,
+        paragraphPlacementAt(state.doc, spot.pos)
+      );
       return [
         {
           spot,

package/dist/editor/createEditor.js

@@ -14,15 +14,17 @@ import {
   DEFAULT_FONT_FALLBACKS
 } from "../styles/fontStack.js";
 import { documentDefaultsStyle } from "../styles/inlineStyle.js";
+import { docxClipboard } from "./clipboard/plugin.js";
+import { noteProjection } from "./commands/noteQueries.js";
 import {
   documentOf,
   editorDocument,
   editorDocumentOf,
   NO_DOCUMENT
 } from "./editorDocument.js";
-import { externalClipboard } from "./externalClipboard.js";
 import { imageFiles } from "./imageFiles.js";
 import { columnResize } from "./plugins/columnResize.js";
+import { commentComposer } from "./plugins/commentComposer.js";
 import { commentDecorations } from "./plugins/commentDecorations.js";
 import {
   displayDerivation,
@@ -80,17 +82,22 @@ function createEditorState(doc, options = {}) {
       // above, is what takes such a conversion back
       listInputRules(),
       dropCursor(),
-      // Clipboard priority is files, resolvable HTML images, then regular HTML or plain text.
+      // Images get the first reading. The clipboard then handles only empty readings and text
+      // fallbacks; tableEditing owns insertion into a cell selection for every nonempty slice.
       imageFiles(),
       imagePaste(),
-      externalClipboard(),
+      docxClipboard(),
       // A press that grabs a table edge must be intercepted before a cell-selection drag starts.
       // For DOM events the plugin registered first wins, so both resizers precede `tableEditing`.
       columnResize(),
       rowResize(),
       tableEditing(),
       // Comment anchors live in the model; this paints their ranges without changing document XML.
+      // The list beside the page, the lookup the comment commands ask, and these ranges are the
+      // one walk this plugin holds (`plugins/commentDecorations`)
       commentDecorations(),
+      // What the notes under the page are, worked out from the document the same way
+      noteProjection.plugin,
       // Adjacent text tabs still need separate DOM ranges for layout and pointer selection.
       tabDecorations(),
       tabPointer(),
@@ -103,6 +110,9 @@ function createEditorState(doc, options = {}) {
       // or fall together with the menus the editor draws. The text menu stands ahead of the table
       // menu, and hands a click with nothing selected inside a cell back to it
       ...contextMenus ? [textContextMenu(), tableContextMenu()] : [],
+      // Holds the stretch of text the built-in comment composer was opened over. It reads the
+      // protection above it, so it stands after the plugin that holds one
+      commentComposer(),
       numberingMarkers(),
       // Values only go in when page display is turned on
       pageDecorations()
@@ -112,7 +122,7 @@ function createEditorState(doc, options = {}) {
 function editorStateForSession(opened, options = {}) {
   return createEditorState(opened.doc, {
     ...options,
-    document: editorDocumentOf(opened.session)
+    document: editorDocumentOf(opened.session, opened.doc)
   });
 }
 var sheetStyles = /* @__PURE__ */ new WeakMap();

package/dist/editor/documentStyles.d.ts

@@ -19,10 +19,25 @@ export declare function documentDefaults(state: EditorState): DocumentDefaults;
 /** The paragraph styles this document defines. Empty when the editor does not know them */
 export declare function documentParagraphStyles(state: EditorState): ParagraphStyleOption[];
 /**
- * The paper the document is written on. A document the editor knows no paper for is drawn on
- * the same A4 every document was drawn on before the geometry was read
+ * The paper the sheet is drawn on: the first section's, since one sheet is drawn at one paper
+ * (`page/pageLayout`). A document the editor knows no paper for is drawn on the same A4 every
+ * document was drawn on before the geometry was read.
+ *
+ * Anything deciding a value for one spot in the document - the width of a table put there, the
+ * height a pasted image is fitted to - asks `sectionGeometryAt` instead, since a later section may
+ * be written on another paper.
  */
 export declare function documentGeometry(state: EditorState): PageGeometry;
+/**
+ * The paper the block at this position is written on: the paper of the section that block belongs
+ * to (`docx/sections`), which is the width a table inserted or resized there is fitted to.
+ *
+ * The section table is read off the document rather than off the snapshot the state carries: a
+ * section is where the document says it is, and the snapshot holds the first section's paper
+ * alone. Reading it walks every block, so a caller drawing a whole document asks once and looks
+ * its positions up (`page/pageLayout`) rather than calling this per block.
+ */
+export declare function sectionGeometryAt(state: EditorState, pos: number): PageGeometry;
 /** The document-wide interval between automatic tab stops, in points. */
 export declare function documentDefaultTabStopPt(state: EditorState): number;
 /**
@@ -32,5 +47,12 @@ export declare function documentDefaultTabStopPt(state: EditorState): number;
  * itself asks for it rather than taking the A4 width `fittedExtent` falls back to.
  */
 export declare function documentBodyWidthPx(state: EditorState): number;
-/** The height one page of body content occupies, in pixels. */
-export declare function documentBodyHeightPx(state: EditorState): number;
+/**
+ * The height one page of body content occupies at this position, in pixels: the height the paper
+ * of the section that block sits in leaves.
+ *
+ * It is the height an image taller than the page is shrunk to when it is pasted there, so a tall
+ * image dropped into a section on shorter paper is fitted to that section rather than to the
+ * sheet's own.
+ */
+export declare function sectionBodyHeightPx(state: EditorState, pos: number): number;

package/dist/editor/documentStyles.js

@@ -4,6 +4,7 @@ import {
   bodyWidth,
   twipsToPx
 } from "../docx/pageGeometry.js";
+import { sectionAt } from "../docx/sections.js";
 import { documentOf } from "./editorDocument.js";
 function documentFormatting(state) {
   return documentOf(state).formatting;
@@ -17,21 +18,25 @@ function documentParagraphStyles(state) {
 function documentGeometry(state) {
   return documentOf(state).geometry;
 }
+function sectionGeometryAt(state, pos) {
+  return sectionAt(state.doc, pos).props.geometry;
+}
 function documentDefaultTabStopPt(state) {
   return documentOf(state).defaultTabStopPt;
 }
 function documentBodyWidthPx(state) {
   return bodyWidth(documentGeometry(state)).px;
 }
-function documentBodyHeightPx(state) {
-  return twipsToPx(bodyHeightTwips(documentGeometry(state)));
+function sectionBodyHeightPx(state, pos) {
+  return twipsToPx(bodyHeightTwips(sectionGeometryAt(state, pos)));
 }
 export {
-  documentBodyHeightPx,
   documentBodyWidthPx,
   documentDefaultTabStopPt,
   documentDefaults,
   documentFormatting,
   documentGeometry,
-  documentParagraphStyles
+  documentParagraphStyles,
+  sectionBodyHeightPx,
+  sectionGeometryAt
 };

package/dist/editor/editorDocument.d.ts

@@ -7,6 +7,7 @@
  * behalf, and `editorDocumentOf` is the one place a session is read into editor values: a screen
  * and a test that open the same document hold the same values.
  */
+import type { Node as PMNode } from "prosemirror-model";
 import { type EditorState, Plugin } from "prosemirror-state";
 import { type FormattingContext, type ParagraphStyleOption } from "../docx/formatting";
 import { type PageGeometry } from "../docx/pageGeometry";
@@ -22,8 +23,8 @@ export interface EditorDocument {
     /** The styles the document defines for the style picker to offer */
     readonly paragraphStyles: ParagraphStyleOption[];
     /**
-     * Whether the document has a place (numbering.xml) to write the definition of a new list.
-     * A state built without opening a document assumes that place exists and behaves as every
+     * Whether the definition of a new list has somewhere to go, which is what the commands that
+     * start one ask. A state built without opening a document assumes it has and behaves as every
      * state did before the question was asked.
      */
     readonly canStartNewList: boolean;
@@ -39,15 +40,15 @@ export interface EditorDocument {
 /** What a state built without an opened document answers: the same as nothing being written down */
 export declare const NO_DOCUMENT: EditorDocument;
 /** The one place an opened document is read into the values the editor holds */
-export declare function editorDocumentOf(session: SessionStore): EditorDocument;
+export declare function editorDocumentOf(session: SessionStore, doc: PMNode): EditorDocument;
 /** The document the state was built for. `NO_DOCUMENT` for a state built without one */
 export declare function documentOf(state: EditorState): EditorDocument;
 /**
  * Holds the snapshot for the lifetime of the state.
  *
- * It is derived again only where a document-level edit could have been recorded, so an ordinary
- * edit and a selection move both leave the same object behind, allowing the sheet's style to be
- * cached against that identity.
+ * It is derived again only where a document-level edit could have been recorded - the attrs of the
+ * document node, which is where such an edit is written - so an ordinary edit and a selection move
+ * both leave the same object behind, allowing the sheet's style to be cached against that identity.
  */
 export declare function editorDocument(document: EditorDocument): Plugin<EditorDocument>;
 /** The comment ids the opened document already spent, which a new comment may not take */

package/dist/editor/editorDocument.js

@@ -5,7 +5,9 @@ import {
   NO_DOCUMENT_DEFAULTS,
   NO_FORMATTING
 } from "../docx/formatting.js";
+import { canDefineNewList } from "../docx/newLists.js";
 import { A4_PORTRAIT } from "../docx/pageGeometry.js";
+import { NEW_LISTS_ATTR, newListsOf } from "../numbering/listRegistry.js";
 var NO_IDS = /* @__PURE__ */ new Set();
 var NO_PARAGRAPH_STYLES = [];
 var NO_DOCUMENT = {
@@ -29,13 +31,20 @@ function reservedParaIds(session) {
   }
   return paraIds;
 }
-function editorDocumentOf(session) {
+function formattingWithNewLists(formatting, doc) {
+  const added = newListsOf(doc.attrs[NEW_LISTS_ATTR]);
+  if (added.size === 0 && formatting.numbering.added.size === 0) {
+    return formatting;
+  }
+  return { ...formatting, numbering: { ...formatting.numbering, added } };
+}
+function editorDocumentOf(session, doc) {
   return {
     session,
-    formatting: session.formatting,
+    formatting: formattingWithNewLists(session.formatting, doc),
     defaults: session.defaults,
     paragraphStyles: session.paragraphStyles,
-    canStartNewList: session.numberingPartPath !== null,
+    canStartNewList: canDefineNewList(session),
     geometry: session.geometry,
     defaultTabStopPt: session.defaultTabStopPt,
     reservedCommentIds: new Set(session.comments.byId.keys()),
@@ -46,15 +55,18 @@ var editorDocumentKey = new PluginKey("docxEditorDocument");
 function documentOf(state) {
   return editorDocumentKey.getState(state) ?? NO_DOCUMENT;
 }
-function derive(session, _doc) {
-  return editorDocumentOf(session);
+function derived(current, doc) {
+  return current.session === null ? {
+    ...current,
+    formatting: formattingWithNewLists(current.formatting, doc)
+  } : editorDocumentOf(current.session, doc);
 }
 function editorDocument(document) {
   return new Plugin({
     key: editorDocumentKey,
     state: {
       init: () => document,
-      apply: (tr, current, old) => current.session === null || tr.doc.attrs === old.doc.attrs ? current : derive(current.session, tr.doc)
+      apply: (tr, current, old) => tr.doc.attrs === old.doc.attrs ? current : derived(current, tr.doc)
     }
   });
 }

package/dist/editor/imageFiles.d.ts

@@ -65,8 +65,8 @@ export declare function insertImageFiles(view: EditorView, files: readonly File[
 /**
  * The plugin that takes image files pasted or dropped onto the paper.
  *
- * It has to sit ahead of the plain-text plugin, which answers for every paste and drop
- * whether or not it has anything to insert (see the plugin order in `createEditor.ts`).
+ * It runs before clipboard fallback and table insertion (see the order in `createEditor.ts`).
+ * A paste that chose plain text leaves any accompanying image file alone.
  * An event carrying no image file is passed on untouched, so text keeps coming in exactly
  * as it did.
  */

package/dist/editor/imageFiles.js

@@ -10,6 +10,7 @@ import {
   pxToEmu,
   toImageSrc
 } from "../ooxml/image.js";
+import { plainTextPaste } from "./clipboard/parser.js";
 import { documentBodyWidthPx } from "./documentStyles.js";
 import { insertImage } from "./insertImage.js";
 import { moveCaretToDrop } from "./plugins/dropCaret.js";
@@ -140,6 +141,7 @@ function imageFiles() {
   return new Plugin({
     props: {
       handlePaste(view, event) {
+        if (plainTextPaste(view, event)) return false;
         const files = imageFilesIn(event.clipboardData);
         if (files.length === 0) return false;
         void insertImageFiles(view, files);

package/dist/editor/insertTable.d.ts

@@ -13,6 +13,6 @@ export interface TableSize {
 }
 /**
  * Inserts a table of empty cells and moves the caret into the first cell.
- * The table is as wide as one line of body text on the paper the open document names
+ * The table is as wide as one line of body text on the paper of the section it goes into
  */
 export declare function insertTable({ rows, columns }: TableSize): Command;