@portone/docx-editor 0.3.0 → 0.4.0

package/dist/docx/tableFormatting/reading.js

@@ -1,6 +1,10 @@
 // src/docx/tableFormatting/reading.ts
+import {
+  TABLE_STYLE_CONDITIONS
+} from "../../model/format.js";
 import { parsePropsXml } from "../../ooxml/props.js";
 import {
+  ST_DecimalNumber,
   ST_MeasurementOrPercent,
   ST_SignedTwipsMeasure,
   ST_TwipsMeasure
@@ -8,7 +12,6 @@ import {
 import {
   ALIGN_BY_JC,
   borderLineCss,
-  borderLineOfCss,
   borderSide,
   childValue,
   isOn,
@@ -109,30 +112,89 @@ var NO_BORDER_DEFAULTS = {
   left: null,
   right: null
 };
-function gridEdgesOf(rect, grid) {
+var NO_CELL_DEFAULTS = {
+  borders: NO_BORDER_DEFAULTS,
+  margins: NO_CELL_MARGINS,
+  background: null,
+  verticalAlign: null,
+  placement: { tableStyleId: null, conditions: [] }
+};
+var NO_BAND_SIZES = { row: null, col: null };
+function bandSize(tblPr, name) {
+  const count = ST_DecimalNumber.parse(childValue(tblPr, name));
+  return count !== null && count > 0 ? count : null;
+}
+function readBandSizes(tblPr) {
+  if (!tblPr) return NO_BAND_SIZES;
+  return {
+    row: bandSize(tblPr, "tblStyleRowBandSize"),
+    col: bandSize(tblPr, "tblStyleColBandSize")
+  };
+}
+function layerBandSizes(style, over) {
+  return { row: over.row ?? style.row, col: over.col ?? style.col };
+}
+var NO_CELL_STYLE_BORDERS = {
+  top: null,
+  bottom: null,
+  left: null,
+  right: null
+};
+var NO_CELL_STYLE_FORMAT = {
+  background: null,
+  borders: NO_CELL_STYLE_BORDERS,
+  inside: NO_INSIDE_BORDERS,
+  margins: NO_CELL_MARGINS,
+  verticalAlign: null
+};
+var NO_TABLE_STYLE_CONDITIONS = {};
+function conditionBorders(tcBorders, table) {
   return {
-    top: rect.top === 0,
-    bottom: rect.bottom === grid.rows,
-    left: rect.left === 0,
-    right: rect.right === grid.cols
+    top: borderSide(tcBorders, "top") ?? table.borderTop ?? null,
+    bottom: borderSide(tcBorders, "bottom") ?? table.borderBottom ?? null,
+    left: borderSide(tcBorders, "left") ?? borderSide(tcBorders, "start") ?? table.borderLeft ?? null,
+    right: borderSide(tcBorders, "right") ?? borderSide(tcBorders, "end") ?? table.borderRight ?? null
   };
 }
-function cellBorderDefaults(edges, outer, inside) {
+function readCellStyleFormat(tcPr, tblPr) {
+  const table = readTableFormat(tblPr) ?? {};
+  const tcBorders = tcPr ? childByLocalName(tcPr, "tcBorders") : null;
   return {
-    top: borderLineOfCss(
-      edges.top ? outer?.borderTop ?? null : inside.horizontal
-    ),
-    bottom: borderLineOfCss(
-      edges.bottom ? outer?.borderBottom ?? null : inside.horizontal
-    ),
-    left: borderLineOfCss(
-      edges.left ? outer?.borderLeft ?? null : inside.vertical
-    ),
-    right: borderLineOfCss(
-      edges.right ? outer?.borderRight ?? null : inside.vertical
-    )
+    background: (tcPr ? shadingOf(tcPr) : null) ?? table.background ?? null,
+    borders: conditionBorders(tcBorders, table),
+    inside: layerInsideBorders(readInsideBorders(tblPr), {
+      horizontal: borderSide(tcBorders, "insideH"),
+      vertical: borderSide(tcBorders, "insideV")
+    }),
+    margins: readCellMarginsOf(tcPr, "tcMar"),
+    verticalAlign: tcPr ? cellVerticalAlignOf(tcPr) : null
   };
 }
+function layerCellStyleBorders(base, over) {
+  return {
+    top: over.top ?? base.top,
+    bottom: over.bottom ?? base.bottom,
+    left: over.left ?? base.left,
+    right: over.right ?? base.right
+  };
+}
+function layerCellStyleFormat(base, over) {
+  return {
+    background: over.background ?? base.background,
+    borders: layerCellStyleBorders(base.borders, over.borders),
+    inside: layerInsideBorders(base.inside, over.inside),
+    margins: layerCellMargins(base.margins, over.margins),
+    verticalAlign: over.verticalAlign ?? base.verticalAlign
+  };
+}
+function cellConditionsOf(conditions) {
+  const cells = {};
+  for (const type of TABLE_STYLE_CONDITIONS) {
+    const format = conditions[type];
+    if (format) cells[type] = format.cell;
+  }
+  return cells;
+}
 function tblStyleIdOf(tblPr) {
   return tblPr ? childValue(tblPr, "tblStyle") : null;
 }
@@ -178,6 +240,9 @@ var CELL_VERTICAL_ALIGN_BY_VAL = {
   center: "center",
   bottom: "bottom"
 };
+function cellVerticalAlignOf(tcPr) {
+  return CELL_VERTICAL_ALIGN_BY_VAL[childValue(tcPr, "vAlign") ?? ""] ?? null;
+}
 function readCellPadding(tcPr, margins) {
   const padding = layerCellMargins(margins, readCellMarginsOf(tcPr, "tcMar"));
   const format = {};
@@ -187,24 +252,26 @@ function readCellPadding(tcPr, margins) {
   if (padding.leftPt !== null) format.paddingLeftPt = padding.leftPt;
   return format;
 }
-function readCellFormat(tcPr, defaults, margins = NO_CELL_MARGINS) {
+function readCellFormat(tcPr, defaults = NO_CELL_DEFAULTS) {
   const borders = tcPr ? childByLocalName(tcPr, "tcBorders") : null;
+  const lines = defaults.borders;
   const format = {};
-  const top = borderSide(borders, "top") ?? borderLineCss(defaults.top);
+  const top = borderSide(borders, "top") ?? borderLineCss(lines.top);
   if (top) format.borderTop = top;
-  const bottom = borderSide(borders, "bottom") ?? borderLineCss(defaults.bottom);
+  const bottom = borderSide(borders, "bottom") ?? borderLineCss(lines.bottom);
   if (bottom) format.borderBottom = bottom;
-  const left = borderSide(borders, "left") ?? borderSide(borders, "start") ?? borderLineCss(defaults.left);
+  const left = borderSide(borders, "left") ?? borderSide(borders, "start") ?? borderLineCss(lines.left);
   if (left) format.borderLeft = left;
-  const right = borderSide(borders, "right") ?? borderSide(borders, "end") ?? borderLineCss(defaults.right);
+  const right = borderSide(borders, "right") ?? borderSide(borders, "end") ?? borderLineCss(lines.right);
   if (right) format.borderRight = right;
-  if (tcPr) {
-    const background = shadingOf(tcPr);
-    if (background) format.background = background;
-    const verticalAlign = CELL_VERTICAL_ALIGN_BY_VAL[childValue(tcPr, "vAlign") ?? ""];
-    if (verticalAlign) format.verticalAlign = verticalAlign;
-  }
-  const padded = { ...format, ...readCellPadding(tcPr, margins) };
+  const background = (tcPr ? shadingOf(tcPr) : null) ?? defaults.background;
+  if (background) format.background = background;
+  const verticalAlign = (tcPr ? cellVerticalAlignOf(tcPr) : null) ?? defaults.verticalAlign;
+  if (verticalAlign) format.verticalAlign = verticalAlign;
+  const padded = {
+    ...format,
+    ...readCellPadding(tcPr, defaults.margins)
+  };
   return Object.keys(padded).length > 0 ? padded : null;
 }
 function insideBordersOf(tblPr) {
@@ -215,23 +282,30 @@ function cellMarginsOf(tblPr) {
   const el = tblPr === null ? null : parsePropsXml(tblPr);
   return readCellMarginsOf(el, "tblCellMar");
 }
-function readCellProps(tcPr, defaults, margins = NO_CELL_MARGINS) {
+function readCellProps(tcPr, defaults = NO_CELL_DEFAULTS) {
   const el = tcPr === null ? null : parsePropsXml(tcPr);
-  return readCellFormat(el, defaults, margins);
+  return readCellFormat(el, defaults);
 }
 export {
+  NO_BAND_SIZES,
   NO_BORDER_DEFAULTS,
+  NO_CELL_DEFAULTS,
   NO_CELL_MARGINS,
+  NO_CELL_STYLE_FORMAT,
   NO_INSIDE_BORDERS,
-  cellBorderDefaults,
+  NO_TABLE_STYLE_CONDITIONS,
+  cellConditionsOf,
   cellMarginsOf,
-  gridEdgesOf,
   insideBordersOf,
+  layerBandSizes,
   layerCellMargins,
+  layerCellStyleFormat,
   layerInsideBorders,
+  readBandSizes,
   readCellFormat,
   readCellMarginsOf,
   readCellProps,
+  readCellStyleFormat,
   readGridCols,
   readInsideBorders,
   readRowFormat,

package/dist/docx/tableFormatting.d.ts

@@ -1,2 +1,3 @@
+export * from "./tableFormatting/conditions";
 export * from "./tableFormatting/editing";
 export * from "./tableFormatting/reading";

package/dist/docx/tableFormatting.js

@@ -1,3 +1,4 @@
 // src/docx/tableFormatting.ts
+export * from "./tableFormatting/conditions.js";
 export * from "./tableFormatting/editing.js";
 export * from "./tableFormatting/reading.js";

package/dist/docx/tableTemplate.js

@@ -5,9 +5,8 @@ import { orderedElement, parsePropsXml } from "../ooxml/props.js";
 import { docxSchema } from "../schema/index.js";
 import { A4_PORTRAIT, bodyWidth } from "./pageGeometry.js";
 import {
-  cellBorderDefaults,
-  gridEdgesOf,
-  NO_CELL_MARGINS,
+  cellDefaultsFor,
+  NO_CELL_SOURCES,
   readCellFormat,
   readInsideBorders,
   readTableFormat,
@@ -81,7 +80,7 @@ function cellTemplate(width, defaults) {
     tcPr,
     tcW: readTableWidth(el, "tcW"),
     // A new table writes no `tblCellMar`, so its cells take their padding from the stylesheet
-    format: readCellFormat(el, defaults, NO_CELL_MARGINS)
+    format: readCellFormat(el, defaults)
   };
 }
 function cellNode(props) {
@@ -109,17 +108,18 @@ function createTableNode(rows, cols, geometry = A4_PORTRAIT) {
   const gridCols = evenGridCols(cols, total);
   const tblPr = tablePropsXml(total);
   const tblPrEl = parsePropsXml(tblPr);
-  const inside = readInsideBorders(tblPrEl);
   const outer = readTableFormat(tblPrEl);
+  const sources = {
+    ...NO_CELL_SOURCES,
+    outer,
+    inside: readInsideBorders(tblPrEl)
+  };
   const cellAt = (row, col) => cellTemplate(
     gridCols[col],
-    cellBorderDefaults(
-      gridEdgesOf(
-        { top: row, bottom: row + 1, left: col, right: col + 1 },
-        { rows, cols }
-      ),
-      outer,
-      inside
+    cellDefaultsFor(
+      { top: row, bottom: row + 1, left: col, right: col + 1 },
+      { rows, cols },
+      sources
     )
   );
   return docxSchema.nodes.table.create(

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/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,8 @@ 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 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(
@@ -84,8 +123,8 @@ var removeFromList = (state, dispatch) => changeParagraphs(
   (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);
+  const level = listFor(numbering, ref.numId)?.levels.get(ref.ilvl);
+  if (!level) return null;
   return level.format === "bullet" ? "bullet" : "numbered";
 }
 function activeListKind(state) {
@@ -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;
@@ -132,6 +176,7 @@ export {
   leaveEmptyListItem,
   listLevelChange,
   listRefOf,
+  numIdsIn,
   removeFromList,
   toggleBulletList,
   toggleNumberedList

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

@@ -112,7 +112,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/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/externalClipboard.d.ts

@@ -1,8 +1,19 @@
 import { Slice } from "prosemirror-model";
-import { type EditorState, Plugin } from "prosemirror-state";
+import { type EditorState, Plugin, type Transaction } from "prosemirror-state";
 import type { EditorView } from "prosemirror-view";
+import { type NewLists } from "../numbering/listRegistry";
 import type { ImageToInsert } from "./insertImage";
-export declare function richHtmlSlice(state: EditorState, document: Document, source: string, images?: ReadonlyMap<string, ImageToInsert>): Slice | null;
+/** What a paste puts in: the content, and the definitions of the lists it started */
+export interface PastedContent {
+    slice: Slice;
+    newLists: NewLists;
+}
+export declare function richHtmlSlice(state: EditorState, document: Document, source: string, images?: ReadonlyMap<string, ImageToInsert>): PastedContent | null;
+/**
+ * The transaction a paste is put in with: the content, and the definitions of the lists it started
+ * recorded on the document node so that the export writes them out and undo takes them back.
+ */
+export declare function withPastedContent(tr: Transaction, content: PastedContent): Transaction;
 export declare function insertRichHtml(view: EditorView, source: string): boolean;
 export declare function insertClipboardData(view: EditorView, data: {
     html?: string;