@portone/docx-editor 0.2.1 → 0.4.0

package/dist/editor/commands/lockCommands.js

@@ -3,29 +3,20 @@ import {
   TextSelection
 } from "prosemirror-state";
 import { namesNothing, newControlId } from "../../docx/sdt.js";
-import { withContentLock } from "../../docx/sdtProps.js";
-import { elementXml, openTagXml } from "../../ooxml/element.js";
-import { wName } from "../../ooxml/names.js";
+import { lockedControlPrefix, withContentLock } from "../../docx/sdtProps.js";
 import { docxSchema } from "../../schema/index.js";
+import { guardedCommand, openStretches } from "../../schema/guards.js";
 import {
   carriesLock,
   controlSpans,
   isLockedCell,
-  rangeTouchesLocked,
   selectionShut,
   unlockAllowed
 } from "../../schema/locks.js";
 import { editsShut } from "../../schema/protectionState.js";
 function lockedControlMark(id) {
   return docxSchema.marks.sdt.create({
-    sdtPrefix: openTagXml(wName("sdt"), null) + elementXml(
-      wName("sdtPr"),
-      [],
-      [
-        elementXml(wName("id"), [[wName("val"), `${id}`]]),
-        elementXml(wName("lock"), [[wName("val"), "sdtContentLocked"]])
-      ]
-    ),
+    sdtPrefix: lockedControlPrefix(id),
     contentsLocked: true,
     deletionLocked: true
   });
@@ -76,29 +67,33 @@ function takeover(met, stretch, open) {
   if (!only || isLocked(only.mark) || !prefix || !namesNothing(prefix)) {
     return null;
   }
-  const mark = open(stretch) ? withLock(only.mark, true) : null;
+  const mark = open ? withLock(only.mark, true) : null;
   return mark ? {
     from: Math.min(stretch.from, only.from),
     to: Math.max(stretch.to, only.to),
     mark
   } : null;
 }
-function blockLockEdits(doc, block, spans, reach) {
+function blockLockEdits(state, block, spans, reach) {
   const stretch = stretchIn(block, reach);
   if (!stretch) return [];
-  const open = (at) => !rangeTouchesLocked(doc, at.from, at.to);
+  const open = (of) => openStretches(state, of, "mark");
   const met = spans.filter((span) => overlaps(span, stretch));
-  const taken = takeover(met, stretch, open);
+  const taken = takeover(met, stretch, open([stretch]).length > 0);
   if (taken) return [taken];
-  const shut = met.filter((span) => !isLocked(span.mark) && open(span)).flatMap((span) => {
-    const mark = withLock(span.mark, true);
-    return mark ? [{ from: span.from, to: span.to, mark }] : [];
-  });
-  const fresh = gapsIn(stretch, spans).filter(open).map((gap) => ({ ...gap, mark: lockedControlMark(newControlId()) }));
+  const shut = open(met.filter((span) => !isLocked(span.mark))).flatMap(
+    (span) => {
+      const mark = withLock(span.mark, true);
+      return mark ? [{ from: span.from, to: span.to, mark }] : [];
+    }
+  );
+  const fresh = open(gapsIn(stretch, spans)).map((gap) => ({
+    ...gap,
+    mark: lockedControlMark(newControlId())
+  }));
   return [...shut, ...fresh];
 }
 function selectionLockDetail(state) {
-  if (editsShut(state)) return { kind: "none" };
   const selection = state.selection;
   const locking = !selection.empty && selection instanceof TextSelection;
   const edits = [];
@@ -115,7 +110,7 @@ function selectionLockDetail(state) {
         if (isLocked(span.mark) && reaches(span, reach)) spans.push(span);
       }
       if (locking) {
-        edits.push(...blockLockEdits(state.doc, block, controls, reach));
+        edits.push(...blockLockEdits(state, block, controls, reach));
       }
       return false;
     });
@@ -131,7 +126,7 @@ function selectionLockDetail(state) {
   return anyLocked ? { kind: "mixed", edits, ...locked } : { kind: "lockable", edits };
 }
 function selectionLock(state) {
-  return selectionLockDetail(state).kind;
+  return editsShut(state) ? "none" : selectionLockDetail(state).kind;
 }
 function lockEditsOf(lock) {
   switch (lock.kind) {
@@ -154,16 +149,13 @@ function lockedOf(lock) {
       return NOTHING_LOCKED;
   }
 }
-var lockSelection = (state, dispatch) => {
+var lockSelection = guardedCommand((state) => {
   const edits = lockEditsOf(selectionLockDetail(state));
-  if (edits.length === 0) return false;
-  if (dispatch) {
-    const tr = state.tr;
-    for (const edit of edits) tr.addMark(edit.from, edit.to, edit.mark);
-    dispatch(tr);
-  }
-  return true;
-};
+  if (edits.length === 0) return null;
+  const tr = state.tr;
+  for (const edit of edits) tr.addMark(edit.from, edit.to, edit.mark);
+  return tr;
+});
 function unlockCell(tr, cell) {
   const prefix = prefixOf(cell.node.attrs);
   tr.setNodeMarkup(cell.pos, null, {
@@ -173,21 +165,18 @@ function unlockCell(tr, cell) {
     sdtDeletionLocked: false
   });
 }
-var unlockSelection = (state, dispatch) => {
+var unlockSelection = guardedCommand((state) => {
   const { spans, cells } = lockedOf(selectionLockDetail(state));
-  if (spans.length === 0 && cells.length === 0) return false;
-  if (dispatch) {
-    const tr = state.tr.setMeta(unlockAllowed, true);
-    for (const span of spans) {
-      const opened = withLock(span.mark, false);
-      if (opened) tr.addMark(span.from, span.to, opened);
-      else tr.removeMark(span.from, span.to, span.mark);
-    }
-    for (const cell of cells) unlockCell(tr, cell);
-    dispatch(tr);
+  if (spans.length === 0 && cells.length === 0) return null;
+  const tr = state.tr.setMeta(unlockAllowed, true);
+  for (const span of spans) {
+    const opened = withLock(span.mark, false);
+    if (opened) tr.addMark(span.from, span.to, opened);
+    else tr.removeMark(span.from, span.to, span.mark);
   }
-  return true;
-};
+  for (const cell of cells) unlockCell(tr, cell);
+  return tr;
+});
 function selectionTouchesLocked(state) {
   return selectionShut(state.selection, state.doc);
 }

package/dist/editor/commands/paragraphCommands.js

@@ -1,22 +1,25 @@
 // src/editor/commands/paragraphCommands.ts
-import { layerRunFormat, styleIdOf } from "../../docx/formatting.js";
+import {
+  paragraphAttrsOf,
+  resolveParagraph,
+  runMarkUnder,
+  styleIdOf
+} from "../../docx/formatting.js";
 import {
   withParagraphAlign,
   withParagraphStyle
 } from "../../docx/paraProps.js";
-import { readRunProps } from "../../docx/runProps.js";
-import {
-  toParagraphFormat
-} from "../../model/format.js";
+import { toParagraphFormat } from "../../model/format.js";
 import { docxSchema } from "../../schema/index.js";
 import { lockedMarkOf } from "../../schema/locks.js";
-import { defaultParagraphStyleId, documentStyles } from "../documentStyles.js";
+import { documentFormatting } from "../documentStyles.js";
 import {
   editableParagraphs,
   editParagraphs,
   paragraphPPr,
   selectedParagraphs
 } from "../paragraphEdits.js";
+import { paragraphPlacementAt } from "../paragraphPlacement.js";
 function alignOf(node) {
   return toParagraphFormat(node.attrs.format)?.align ?? "left";
 }
@@ -24,9 +27,9 @@ function setParagraphAlign(align) {
   return (state, dispatch) => editParagraphs(
     state,
     dispatch,
-    (node, styles, defaultStyleId) => (
+    (node) => (
       // A paragraph already rendered with that alignment is left untouched, so its original XML survives
-      alignOf(node) === align ? null : withParagraphAlign(paragraphPPr(node), align, styles, defaultStyleId)
+      alignOf(node) === align ? null : withParagraphAlign(paragraphPPr(node), align)
     )
   );
 }
@@ -38,25 +41,16 @@ function activeParagraphAlign(state) {
   const first = aligns[0];
   return first !== void 0 && aligns.every((align) => align === first) ? { kind: "shared", align: first } : { kind: "mixed" };
 }
-function text(value) {
-  return typeof value === "string" ? value : null;
-}
-function restyledMark(child, style) {
-  const mark = child.marks.find((entry) => entry.type === docxSchema.marks.run);
-  if (mark) {
-    const format2 = layerRunFormat(style, readRunProps(text(mark.attrs.rPr)));
-    return mark.type.create({ ...mark.attrs, format: format2 });
-  }
-  if (!child.isText) return null;
-  const format = layerRunFormat(style, null);
-  if (format === null) return null;
-  return docxSchema.marks.run.create({ rPr: null, rAttrs: null, format });
-}
-function restyledMarks(spot, style) {
+function restyledMarks(spot, paragraph, context) {
   const changes = [];
   spot.node.forEach((child, offset) => {
     if (lockedMarkOf(child)) return;
-    const mark = restyledMark(child, style);
+    const mark = runMarkUnder(
+      child.marks.find((entry) => entry.type === docxSchema.marks.run) ?? null,
+      child.isText,
+      paragraph,
+      context
+    );
     if (!mark) return;
     const from = spot.pos + 1 + offset;
     changes.push({ from, to: from + child.nodeSize, mark });
@@ -65,12 +59,11 @@ function restyledMarks(spot, style) {
 }
 function writeStyleChanges(state, changed) {
   const tr = state.tr;
-  for (const { spot, props, marks } of changed) {
+  for (const { spot, props, attrs, marks } of changed) {
     tr.setNodeMarkup(tr.mapping.map(spot.pos), void 0, {
       ...spot.node.attrs,
       pPr: props.pPr,
-      format: props.format,
-      styleRun: props.styleRun
+      ...attrs
     });
     for (const change of marks) {
       tr.addMark(change.from, change.to, change.mark);
@@ -80,15 +73,24 @@ function writeStyleChanges(state, changed) {
 }
 function setParagraphStyle(styleId) {
   return (state, dispatch) => {
-    const styles = documentStyles(state);
-    const defaultStyleId = defaultParagraphStyleId(state);
+    const context = documentFormatting(state);
     const changed = editableParagraphs(state).flatMap((spot) => {
       const pPr = paragraphPPr(spot.node);
       if (styleIdOf(pPr) === styleId) return [];
-      const props = withParagraphStyle(pPr, styleId, styles, defaultStyleId);
+      const props = withParagraphStyle(pPr, styleId);
       if (!props) return [];
+      const paragraph = resolveParagraph(
+        props.pPr,
+        context,
+        paragraphPlacementAt(state.doc, spot.pos)
+      );
       return [
-        { spot, props, marks: restyledMarks(spot, props.styleRun ?? {}) }
+        {
+          spot,
+          props,
+          attrs: paragraphAttrsOf(paragraph),
+          marks: restyledMarks(spot, paragraph, context)
+        }
       ];
     });
     if (changed.length === 0) return false;

package/dist/editor/commands/spacingCommands.js

@@ -24,7 +24,7 @@ function setLineSpacing(spacing) {
     return editParagraphs(
       state,
       dispatch,
-      (node, styles, defaultStyleId) => sameLineSpacing(lineSpacingOf(node, defaults), spacing) ? null : withLineSpacing(paragraphPPr(node), spacing, styles, defaultStyleId)
+      (node) => sameLineSpacing(lineSpacingOf(node, defaults), spacing) ? null : withLineSpacing(paragraphPPr(node), spacing)
     );
   };
 }

package/dist/editor/createEditor.d.ts

@@ -4,42 +4,25 @@
 import type { Node as PMNode } from "prosemirror-model";
 import { EditorState, type Plugin } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
-import { type ParagraphFormatLayer, type ParagraphStyleOption, type StyleTable } from "../docx/formatting";
-import { type PageGeometry } from "../docx/pageGeometry";
-import type { DocumentDefaults } from "../model/format";
-import { type Numbering } from "../numbering/parseNumbering";
+import type { SessionStore } from "../docx/session";
 import type { EditableComments, EditingProtection } from "../schema/protection";
 import { type FontFallbacks } from "../styles/fontStack";
 import type { CommentAuthor } from "./commands/comments/model";
+import { type EditorDocument } from "./editorDocument";
 export interface EditorStateOptions {
-    numbering?: Numbering;
-    styles?: StyleTable;
-    defaults?: DocumentDefaults;
-    /** Paragraph properties from styles.xml docDefaults. */
-    paragraphDefaults?: ParagraphFormatLayer;
     /**
-     * Whether the document has a place (numbering.xml) to write the definition of a new list.
-     * Callers that build a state without opening a document assume that place exists and behave
-     * as they do today.
+     * What the opened document laid down: its styles, its list definitions, the paper it is
+     * written on. A state built without one reads `NO_DOCUMENT`, which answers as nothing having
+     * been written down. `editorStateForSession` is what fills it in for an opened document.
      */
-    canStartNewList?: boolean;
+    document?: EditorDocument;
     /** The plugins handed in from outside the package */
     consumerPlugins?: readonly Plugin[];
-    /** The styles the document defines for the style picker to offer */
-    paragraphStyles?: ParagraphStyleOption[];
     /**
      * Whether the right click is the editor's own. Turned off, the browser's own menu is never
      * taken away, which is what a consumer drawing menus of its own needs.
      */
     contextMenus?: boolean;
-    /** The paper the document names. A4 where a document names none */
-    geometry?: PageGeometry;
-    /** The interval between automatic tab stops, in points. */
-    defaultTabStopPt?: number;
-    /** Every id already present in the opened Comments part, including unreferenced entries. */
-    reservedCommentIds?: Iterable<string>;
-    /** Every paragraph id present in the opened comment parts, including orphan extension entries. */
-    reservedCommentParaIds?: Iterable<string>;
     /**
      * What the document as a whole may receive (`schema/protection`): everything, comments alone,
      * or nothing. Everything when none is given, which is what every state was before.
@@ -53,17 +36,22 @@ export interface EditorStateOptions {
 /**
  * Creates a single editing state.
  * The list definitions, the style table, and the document defaults are what the document
- * wrote down, and commands and the toolbar read them through plugins.
+ * wrote down, and commands and the toolbar read them off the snapshot the state holds.
  */
-export declare function createEditorState(doc: PMNode, { numbering, styles, defaults, paragraphDefaults, canStartNewList, consumerPlugins, paragraphStyles, contextMenus, geometry, defaultTabStopPt, reservedCommentIds, reservedCommentParaIds, protection, author, editableComments, }?: EditorStateOptions): EditorState;
+export declare function createEditorState(doc: PMNode, options?: EditorStateOptions): EditorState;
+/**
+ * The state for a document that was opened, which is the one way a session becomes an editing
+ * state: what the screen builds and what a test builds are then the same values.
+ */
+export declare function editorStateForSession(opened: {
+    doc: PMNode;
+    session: SessionStore;
+}, options?: Omit<EditorStateOptions, "document">): EditorState;
 export interface EditorOptions {
     mount: HTMLElement;
     state: EditorState;
-    defaults: DocumentDefaults;
-    /** The paper the document names. The sheet is drawn from it, A4 where a document names none */
-    geometry?: PageGeometry;
     /** The fonts stood in for the ones the document declares. The built-in set when none is given */
     fontFallbacks?: FontFallbacks;
     onStateChange: (state: EditorState) => void;
 }
-export declare function createEditorView({ mount, state, defaults, geometry, fontFallbacks, onStateChange, }: EditorOptions): EditorView;
+export declare function createEditorView({ mount, state, fontFallbacks, onStateChange, }: EditorOptions): EditorView;

package/dist/editor/createEditor.js

@@ -6,13 +6,6 @@ import { keymap } from "prosemirror-keymap";
 import { EditorState } from "prosemirror-state";
 import { tableEditing } from "prosemirror-tables";
 import { EditorView } from "prosemirror-view";
-import { DEFAULT_TAB_STOP_PT } from "../docx/documentSettings.js";
-import {
-  NO_DOCUMENT_DEFAULTS,
-  NO_STYLES
-} from "../docx/formatting.js";
-import { A4_PORTRAIT } from "../docx/pageGeometry.js";
-import { EMPTY_NUMBERING } from "../numbering/parseNumbering.js";
 import { pageDecorations } from "../page/pageDecorations.js";
 import { pageGeometryStyle, pagePixels } from "../page/pageLayout.js";
 import { editsShut } from "../schema/protectionState.js";
@@ -21,13 +14,20 @@ import {
   DEFAULT_FONT_FALLBACKS
 } from "../styles/fontStack.js";
 import { documentDefaultsStyle } from "../styles/inlineStyle.js";
-import { gridBorders, withDerivedGridBorders } from "../table/gridBorders.js";
-import { documentDefaultTabStopPt, documentStyleTable } from "./documentStyles.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 { commentDecorations } from "./plugins/commentDecorations.js";
-import { commentReservations } from "./plugins/commentReservations.js";
+import {
+  displayDerivation,
+  withDerivedDisplay
+} from "./plugins/displayDerivation.js";
 import { documentProtection } from "./plugins/documentProtection.js";
 import { imagePaste } from "./plugins/imagePaste.js";
 import { docxKeymap, historyKeys } from "./plugins/keymap.js";
@@ -36,7 +36,6 @@ import { listInputRules } from "./plugins/listInputRules.js";
 import { lockedContent } from "./plugins/lockedContent.js";
 import { numberingMarkers } from "./plugins/numberingDecorations.js";
 import { rowResize } from "./plugins/rowResize.js";
-import { styledParagraphs } from "./plugins/styledParagraphs.js";
 import { tabCaret } from "./plugins/tabCaret.js";
 import { tabDecorations } from "./plugins/tabDecorations.js";
 import { tabLayout } from "./plugins/tabLayout.js";
@@ -45,37 +44,32 @@ import { tabPointer } from "./plugins/tabPointer.js";
 import { textContextMenu } from "./plugins/textContextMenu.js";
 import { ImageNodeView } from "./views/imageResize.js";
 import { runMarkView } from "./views/runMarkView.js";
-function createEditorState(doc, {
-  numbering = EMPTY_NUMBERING,
-  styles = NO_STYLES,
-  defaults = NO_DOCUMENT_DEFAULTS,
-  paragraphDefaults = {},
-  canStartNewList = true,
-  consumerPlugins = [],
-  paragraphStyles = [],
-  contextMenus = true,
-  geometry = A4_PORTRAIT,
-  defaultTabStopPt = DEFAULT_TAB_STOP_PT,
-  reservedCommentIds = [],
-  reservedCommentParaIds = [],
-  protection = "none",
-  author = null,
-  editableComments = "own"
-} = {}) {
+function createEditorState(doc, options = {}) {
+  const {
+    document = NO_DOCUMENT,
+    consumerPlugins = [],
+    contextMenus = true,
+    protection = "none",
+    author = null,
+    editableComments = "own"
+  } = options;
   return EditorState.create({
-    doc: withDerivedGridBorders(doc),
+    // The values the document arrived with were worked out against whatever opened it; the
+    // state's are worked out against its own snapshot, tables' shared lines included
+    doc: withDerivedDisplay(doc, document),
     plugins: [
       // Consumer plugins lead the array. ProseMirror walks the plugins in order and takes the
       // first answer for a keypress, a paste, a drop or any other DOM event, so this is the
       // only place from which a consumer handler can win over the built-in one.
       ...consumerPlugins,
+      // Every document-level value the editor reads stands in one snapshot, and it leads the
+      // built-in plugins so that the ones drawing from it are initialized after it
+      editorDocument(document),
       // Refuses every edit no guard in `schema/guards` lets through, whoever asked for it. It is
       // not optional: a document that locked a part of itself stays locked in every consumer, and
       // the preserved bookmark markers and note references stay where the file put them.
       lockedContent(),
       documentProtection({ protection, author, editableComments }),
-      // An orphan Comments-part entry still owns its id and must not be replaced by a new comment.
-      commentReservations(reservedCommentIds, reservedCommentParaIds),
       history(),
       keymap(docxKeymap),
       historyKeys(),
@@ -102,52 +96,57 @@ function createEditorState(doc, {
       tabPointer(),
       tabLayout(),
       tabCaret(),
-      // Keeps table-cell lines aligned with OOXML precedence after an edit
-      gridBorders(),
-      // Reads the document's styles into the paragraphs an edit built from nothing
-      styledParagraphs(),
+      // Works the display values out again after every edit: the lines of a table's cells, and
+      // the style values of the paragraphs the edit built or rewrote
+      displayDerivation(),
       // Receiving a right-click means taking the browser's own menu away, so both of these stand
       // 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()] : [],
-      numberingMarkers(numbering, canStartNewList),
+      numberingMarkers(),
       // Values only go in when page display is turned on
-      pageDecorations(),
-      documentStyleTable(
-        styles,
-        defaults,
-        paragraphStyles,
-        geometry,
-        paragraphDefaults,
-        numbering,
-        defaultTabStopPt
-      )
+      pageDecorations()
     ]
   });
 }
+function editorStateForSession(opened, options = {}) {
+  return createEditorState(opened.doc, {
+    ...options,
+    document: editorDocumentOf(opened.session, opened.doc)
+  });
+}
+var sheetStyles = /* @__PURE__ */ new WeakMap();
+function sheetStyleOf(document, fallbacks) {
+  const remembered = sheetStyles.get(document);
+  if (remembered?.fallbacks === fallbacks) return remembered.style;
+  const style = `${pageGeometryStyle(pagePixels(document.geometry))};${documentDefaultsStyle(document.defaults, fallbacks)};`;
+  sheetStyles.set(document, { fallbacks, style });
+  return style;
+}
 function createEditorView({
   mount,
   state,
-  defaults,
-  geometry = A4_PORTRAIT,
   fontFallbacks = DEFAULT_FONT_FALLBACKS,
   onStateChange
 }) {
-  const sheetStyle = `${pageGeometryStyle(pagePixels(geometry))};${documentDefaultsStyle(defaults, fontFallbacks)};`;
   const view = new EditorView(mount, {
     state,
     // A protection that shuts the body shuts typing with it, and is read off the state so that a
     // mode switched on an open document takes effect without a new view. Selecting stays open
     // either way, which is what a reader marking a stretch for a comment needs
     editable: (current) => !editsShut(current),
-    attributes: (current) => ({
-      class: editorClassNames.sheet,
-      // The paper first, so a document that names one is drawn on it from the first frame
-      style: `${sheetStyle}tab-size:${documentDefaultTabStopPt(current)}pt`,
-      // A sheet that takes no typing is no longer focusable of itself, so a reader or a commenter
-      // is handed the focus another way: the keys reach it, and the selection stays its own
-      ...editsShut(current) ? { tabindex: "0" } : {}
-    }),
+    attributes: (current) => {
+      const document = documentOf(current);
+      return {
+        class: editorClassNames.sheet,
+        // The paper first, so a document that names one is drawn on it from the first frame
+        style: `${sheetStyleOf(document, fontFallbacks)}tab-size:${document.defaultTabStopPt}pt`,
+        // A sheet that takes no typing is no longer focusable of itself, so a reader or a
+        // commenter is handed the focus another way: the keys reach it, and the selection stays
+        // its own
+        ...editsShut(current) ? { tabindex: "0" } : {}
+      };
+    },
     // The schema can only draw a run with the default fallback fonts, so this editor draws its own
     markViews: { run: runMarkView(fontFallbacks) },
     // An image is drawn by a view of its own, which is what carries the resize handles
@@ -164,5 +163,6 @@ function createEditorView({
 }
 export {
   createEditorState,
-  createEditorView
+  createEditorView,
+  editorStateForSession
 };

package/dist/editor/documentStyles.d.ts

@@ -1,45 +1,23 @@
 /**
- * Brings what the document laid down into the editor: what styles.xml told us, and the paper it
- * is written on.
+ * What the document laid down, as the commands and the toolbar ask for it: what styles.xml told
+ * us, and the paper it is written on.
  *
- * Commands and the toolbar know nothing about the session, so this plugin holds all of it on
- * their behalf: deriving the display values again after a formatting edit needs the values the
- * style laid down, the toolbar needs the size a run is rendered at where nobody wrote a size
- * down, and a new table is fitted to the width of the body the paper leaves.
- * The values are fixed the moment the document is opened and do not change while editing.
+ * Commands and the toolbar know nothing about the session, so they read the snapshot
+ * `editor/editorDocument` holds on their behalf: deriving the display values again after a
+ * formatting edit needs the context the hierarchy is resolved against, the toolbar needs the size
+ * a run is rendered at where nobody wrote a size down, and a new table is fitted to the width of
+ * the body the paper leaves.
  */
-import { type EditorState, Plugin } from "prosemirror-state";
-import { type ParagraphFormatLayer, type ParagraphFormattingContext, type ParagraphStyleOption, type StyleTable } from "../docx/formatting";
+import type { EditorState } from "prosemirror-state";
+import type { FormattingContext, ParagraphStyleOption } from "../docx/formatting";
 import { type PageGeometry } from "../docx/pageGeometry";
 import type { DocumentDefaults } from "../model/format";
-import { type Numbering } from "../numbering/parseNumbering";
-/** Values that apply to the whole document */
-interface DocumentInfo {
-    styles: StyleTable;
-    defaults: DocumentDefaults;
-    paragraphDefaults: ParagraphFormatLayer;
-    numbering: Numbering;
-    paragraphStyles: ParagraphStyleOption[];
-    /** The paper the document is written on, which decides the width a new table is fitted to */
-    geometry: PageGeometry;
-    /** The distance between automatic tab stops when no custom stop applies. */
-    defaultTabStopPt: number;
-}
-/** This document's style table. Empty when the editor does not know the table */
-export declare function documentStyles(state: EditorState): StyleTable;
+/** Everything a paragraph's or a run's display values are resolved against. Empty when the editor does not know the document */
+export declare function documentFormatting(state: EditorState): FormattingContext;
 /** The default formatting this document wrote down. When the editor does not know it, it is the same as nothing being specified */
 export declare function documentDefaults(state: EditorState): DocumentDefaults;
-/** The values required to resolve the OOXML paragraph-property hierarchy. */
-export declare function documentParagraphFormatting(state: EditorState): ParagraphFormattingContext;
 /** The paragraph styles this document defines. Empty when the editor does not know them */
 export declare function documentParagraphStyles(state: EditorState): ParagraphStyleOption[];
-/**
- * The style a paragraph pointing at none of its own wears (`w:default="1"`). Null when the
- * document marks none.
- *
- * It is the style the list of them marks, of which `readParagraphStyles` leaves exactly one.
- */
-export declare function defaultParagraphStyleId(state: EditorState): string | null;
 /**
  * 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
@@ -56,5 +34,3 @@ export declare function documentDefaultTabStopPt(state: EditorState): number;
 export declare function documentBodyWidthPx(state: EditorState): number;
 /** The height one page of body content occupies, in pixels. */
 export declare function documentBodyHeightPx(state: EditorState): number;
-export declare function documentStyleTable(styles: StyleTable, defaults?: DocumentDefaults, paragraphStyles?: ParagraphStyleOption[], geometry?: PageGeometry, paragraphDefaults?: ParagraphFormatLayer, numbering?: Numbering, defaultTabStopPt?: number): Plugin<DocumentInfo>;
-export {};