@portone/docx-editor 0.6.0 → 0.6.2

package/dist/ooxml/errors.d.ts

@@ -3,7 +3,9 @@
  *
  * Messages are English one-liners meant for developers. The `code` is the stable,
  * machine-readable part: consumers switch on it to show their own localized text,
- * so a code never changes meaning even when a message is reworded.
+ * so a code never changes meaning even when a message is reworded. An export refusal carries an
+ * `ExportProblemReason` besides, which tells the several situations one code covers apart and
+ * names what each is about, so a host can say which content to put back.
  */
 /**
  * Why a document could not be opened.
@@ -33,8 +35,139 @@ export declare class DocxImportError extends Error {
  * - `invalid-table`: the table grid is inconsistent, e.g. a vertical merge outliving its rows
  */
 export type DocxExportErrorCode = "missing-content-types" | "unsupported-content" | "lost-original" | "malformed-xml" | "invalid-table";
+/**
+ * The kinds of side story a refusal can be about, which are the kinds a document holds beside its
+ * body (`schema/stories`). Spelled here because the reasons stand below the schema layer.
+ */
+export type ExportStoryKind = "comment" | "footnote" | "endnote" | "header" | "footer";
+/**
+ * One side story, as the document holds it.
+ *
+ * A reason names it wherever the content the refusal is about may stand outside the body, and the
+ * refusal is then about that story rather than the document: `story` is null for the body itself.
+ */
+export interface ExportProblemStory {
+    readonly kind: ExportStoryKind;
+    /** A note's number, a comment's id, or the path of the part a header or footer stands in */
+    readonly id: string;
+}
+/** A part the export writes beside the body, named after what it holds */
+export type ExportPartName = "media" | "numbering" | "comments" | "commentsExtended" | "people" | "footnotes" | "endnotes";
+/**
+ * What a refusal is actually about.
+ *
+ * A `code` groups several situations - `unsupported-content` alone covers a list nothing defines,
+ * a block standing twice, and a change to a story no writer carries - and the `message` telling
+ * them apart is an English one-liner for a developer. This says which situation was met and names
+ * what it is about, so a host can write the sentence its own user reads. Switch on `kind`.
+ */
+export type ExportProblemReason = 
+/** A preserved fragment holding bookmark markup could not be parsed (`malformed-xml`) */
+{
+    readonly kind: "unreadable-preserved-xml";
+    readonly story: ExportProblemStory | null;
+}
+/** A bookmark marker carries no id to pair it by (`malformed-xml`) */
+ | {
+    readonly kind: "unnamed-bookmark";
+    readonly marker: "start" | "end";
+    readonly story: ExportProblemStory | null;
+}
+/**
+ * A bookmark marker whose partner is gone (`malformed-xml`): a `start` with no end after it, or
+ * an `end` with no start before it.
+ */
+ | {
+    readonly kind: "unmatched-bookmark";
+    readonly id: string;
+    readonly marker: "start" | "end";
+    readonly story: ExportProblemStory | null;
+}
+/** One bookmark id is started twice (`malformed-xml`) */
+ | {
+    readonly kind: "repeated-bookmark-start";
+    readonly id: string;
+    readonly story: ExportProblemStory | null;
+}
+/** A part cannot be rewritten around its root element (`malformed-xml`) */
+ | {
+    readonly kind: "unwritable-part-root";
+    readonly part: ExportPartName;
+}
+/** A cell's vertical merge covers rows its table does not have (`invalid-table`) */
+ | {
+    readonly kind: "vertical-merge-past-table";
+    readonly story: ExportProblemStory | null;
+}
+/** A node that is written from its original XML alone no longer holds it (`lost-original`) */
+ | {
+    readonly kind: "lost-preserved-xml";
+    readonly node: string;
+    readonly story: ExportProblemStory | null;
+}
+/** A placeholder pasted in from another opened document, whose XML this session never read (`lost-original`) */
+ | {
+    readonly kind: "preserved-from-another-document";
+    readonly node: string;
+    /** The session the placeholder was opened in */
+    readonly sessionId: string;
+    readonly story: ExportProblemStory | null;
+}
+/** One preserved block stands in two places, and it has one original XML to be written (`unsupported-content`) */
+ | {
+    readonly kind: "duplicate-preserved-block";
+    readonly node: string;
+    readonly story: ExportProblemStory | null;
+}
+/** A paragraph is in a list neither the file nor the editor's register defines (`unsupported-content`) */
+ | {
+    readonly kind: "undefined-list";
+    readonly numId: number;
+    readonly story: ExportProblemStory | null;
+}
+/** A story was changed and no part writer carries that change into the file (`unsupported-content`) */
+ | {
+    readonly kind: "unwritten-story-change";
+    readonly story: ExportProblemStory;
+    readonly change: "added" | "edited" | "removed";
+}
+/** A story was added under an id its part identifies entries by no whole number of (`unsupported-content`) */
+ | {
+    readonly kind: "story-id-not-a-number";
+    readonly story: ExportProblemStory;
+}
+/** A part the writer has to add cannot be declared, the package having no content types part (`missing-content-types`) */
+ | {
+    readonly kind: "missing-content-types";
+    readonly part: ExportPartName;
+};
+/** One reason the document cannot be written back, with the code `exportDocx` would throw it under */
+export interface ExportProblem {
+    readonly code: DocxExportErrorCode;
+    /** An English one-liner for a developer; reworded freely. Read `code` and `reason` instead */
+    readonly message: string;
+    /** Which of the situations the code covers was met, and what it is about */
+    readonly reason: ExportProblemReason;
+    /**
+     * Where the problem stands in the document: the block or marker it is about, or, for a footnote
+     * or an endnote, the first reference to that note in the body, the note's own text standing
+     * nowhere there. Absent for a problem of the package, of the session, of a header, footer or
+     * comment story, and of a note the body refers to nowhere.
+     */
+    readonly pos?: number;
+}
+/** What a `DocxExportError` may be given beyond its code and message */
+export interface DocxExportErrorOptions extends ErrorOptions {
+    /** The entry `exportProblems` reports for this refusal, where an invariant predicted it */
+    readonly problem?: ExportProblem;
+}
 /** Thrown when an edited document cannot be written back out without losing or corrupting content */
 export declare class DocxExportError extends Error {
     readonly code: DocxExportErrorCode;
-    constructor(code: DocxExportErrorCode, message: string, options?: ErrorOptions);
+    /**
+     * What `exportProblems` reports for this refusal, carrying its `reason` and `pos`. Absent for a
+     * refusal met while writing that no invariant predicted.
+     */
+    readonly problem?: ExportProblem;
+    constructor(code: DocxExportErrorCode, message: string, options?: DocxExportErrorOptions);
 }

package/dist/ooxml/errors.js

@@ -9,10 +9,16 @@ var DocxImportError = class extends Error {
 };
 var DocxExportError = class extends Error {
   code;
+  /**
+   * What `exportProblems` reports for this refusal, carrying its `reason` and `pos`. Absent for a
+   * refusal met while writing that no invariant predicted.
+   */
+  problem;
   constructor(code, message, options) {
     super(message, options);
     this.name = "DocxExportError";
     this.code = code;
+    this.problem = options?.problem;
   }
 };
 export {

package/dist/page/blockKinds.d.ts

@@ -10,6 +10,7 @@
  */
 import type { Node as PMNode } from "prosemirror-model";
 import type { Decoration, EditorView } from "prosemirror-view";
+import type { PageDemand } from "./demands";
 /** A place inside a block where the next page may, or must, start */
 export interface BreakCandidate {
     /**
@@ -41,13 +42,21 @@ export interface MeasuredBlock {
     minFirstPiece: number;
     /** The document asks for this block to stand on the same page as the start of the block after it */
     keepWithNext: boolean;
+    /**
+     * The places in the block that ask the page they land on for room at its foot, their offsets read
+     * like a candidate's with no space in the block. A block asking for none may leave it out
+     */
+    demands?: readonly PageDemand[];
 }
 /** A page cut the layout decided on: the space opened before the continued piece */
 export interface PageCut {
     at: number;
     height: number;
 }
-/** One block as it stands on the sheet, handed to the kind about to measure it */
+/**
+ * One block as it stands on the sheet, handed to the kind about to measure it and then to every
+ * demand source (`page/demands`)
+ */
 export interface MeasureTarget {
     view: EditorView;
     node: PMNode;
@@ -72,6 +81,15 @@ export interface KindMeasure {
     breakAfter: boolean;
     /** Height the engine's own marks add inside this block, taken off its measured bottom */
     appliedHeight: number;
+    /**
+     * What the engine's marks have opened at each place this block was cut, as the browser drew it,
+     * by the candidate's position. What is drawn there can come out taller than the cut asked for -
+     * a table's spacer row takes half of a collapsed border on each side - and everything else a
+     * kind reports is read off the sheet as drawn, so a place below a cut is taken back to its
+     * natural offset by this rather than by what the layout asked for (`page/measureBlocks`).
+     * A kind that opens nothing leaves it out
+     */
+    opened?: ReadonlyMap<number, number>;
     /**
      * Whether the document asks for this block to stand on the same page as the start of the block
      * after it. A kind whose blocks never do leaves it out
@@ -82,9 +100,10 @@ export interface KindMeasure {
  * Everything the engine does with one shape of breakable block: how one is measured, and how the
  * cuts the layout gave it are drawn.
  *
- * A shape the engine learns later - a footnote area, a paragraph with a floating object hanging
- * out of it - is one more kind rather than another branch in the measurer, in the decorations
- * and in the plugin state at once.
+ * A shape the engine learns later is one more kind rather than another branch in the measurer, in
+ * the decorations and in the plugin state at once. Room a place inside a block asks of the page it
+ * lands on is not a shape: a block has one kind while such a place can stand inside a block of any
+ * kind, so it is asked of every block by a demand source (`page/demands`) instead.
  */
 export interface BlockKind {
     readonly name: string;

package/dist/page/demands/footnoteDemands.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The room a footnote reference asks of the page it lands on: its footnote, drawn at the foot of
+ * that page (`ui/notes`).
+ *
+ * The sheet is measured on every layout pass and nearly every block holds no reference, so which
+ * references a block holds is read off the block node and remembered against it. A node an edit
+ * did not touch is the same node afterwards, so a pass reads nothing off the page for a block with
+ * no reference and walks only the blocks an edit rebuilt.
+ */
+import type { DemandSource } from "./index";
+/** The band footnotes are kept in, which the layout's caller hands the heights of */
+export declare const FOOTNOTE_BAND = "footnote";
+/**
+ * Where footnotes stand among the bands a page keeps (`DemandBand.order`). Word sets them at the
+ * very foot of the body, under anything else the page holds there, so this is the last place
+ */
+export declare const FOOTNOTE_BAND_ORDER = 0;
+export declare const footnoteDemands: DemandSource;

package/dist/page/demands/footnoteDemands.js

@@ -0,0 +1,51 @@
+// src/page/demands/footnoteDemands.ts
+import { docxSchema } from "../../schema/index.js";
+import { storyKey } from "../../schema/stories.js";
+var FOOTNOTE_BAND = "footnote";
+var FOOTNOTE_BAND_ORDER = 0;
+var BAND_NOTE_KINDS = ["footnote"];
+var NO_REFERENCES = [];
+var NO_DEMANDS = [];
+var held = /* @__PURE__ */ new WeakMap();
+function footnoteReferencesIn(block) {
+  const remembered = held.get(block);
+  if (remembered) return remembered;
+  const found = [];
+  block.descendants((node, offset) => {
+    if (node.type !== docxSchema.nodes.noteReference) return true;
+    const id = node.attrs.id;
+    const kind = BAND_NOTE_KINDS.find(
+      (candidate) => candidate === node.attrs.kind
+    );
+    if (kind !== void 0 && typeof id === "string") {
+      found.push({ offset, key: storyKey(kind, id) });
+    }
+    return false;
+  });
+  const references = found.length === 0 ? NO_REFERENCES : found;
+  held.set(block, references);
+  return references;
+}
+var footnoteDemands = {
+  name: "footnote",
+  demandsIn({ view, node, pos, sheetY, top }) {
+    const references = footnoteReferencesIn(node);
+    if (references.length === 0) return NO_DEMANDS;
+    return references.flatMap(({ offset, key }) => {
+      const drawn = view.nodeDOM(pos + 1 + offset);
+      if (!(drawn instanceof Element)) return [];
+      return [
+        {
+          offset: sheetY(drawn.getBoundingClientRect().top) - top,
+          id: key,
+          band: FOOTNOTE_BAND
+        }
+      ];
+    });
+  }
+};
+export {
+  FOOTNOTE_BAND,
+  FOOTNOTE_BAND_ORDER,
+  footnoteDemands
+};

package/dist/page/demands/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Room a place inside a block asks the page it lands on to keep at the foot of its body.
+ *
+ * A block has one kind (`page/blockKinds`), and a place asking for room can stand inside a block of
+ * any kind: a paragraph, or a paragraph in a table cell. So what asks is not a kind but a source,
+ * and every registered source is asked about every block whatever its kind. The layout
+ * (`page/pageLayout`) knows a demand by its band alone, never by what put it there.
+ */
+import type { MeasureTarget } from "../blockKinds";
+/** Room one place in a block asks the page it lands on to keep at the foot */
+export interface PageDemand {
+    /**
+     * The place's top from the block's natural top. A source reads it off the sheet as drawn, the
+     * way a kind reads a candidate (`target.sheetY(viewportY) - target.top`), and the measurement
+     * takes back off the spaces the engine opened inside the block above that place
+     * (`page/measureBlocks`), so no source has to know what any kind draws
+     */
+    readonly offset: number;
+    /** What is kept. One id is kept once on a page, however many places on it ask for it */
+    readonly id: string;
+    /** The band at the foot of the page that keeps it (`DemandBand`) */
+    readonly band: string;
+}
+export interface DemandSource {
+    readonly name: string;
+    demandsIn(target: MeasureTarget): readonly PageDemand[];
+}
+export interface DemandBand {
+    /**
+     * Where this band stands among the bands one page keeps, counted up from the foot of the body:
+     * 0 stands at the very foot and a higher number above it, between the text and the band below.
+     * Without it a page would stack its bands in the order its text happened to reach them, so the
+     * same two bands could come out one way round on one page and the other way round on the next.
+     * Two bands a page may hold together name two different places
+     */
+    readonly order: number;
+    /** Height a page adds once when it holds any demand of this band */
+    readonly overhead: number;
+    /** The height each id takes in the band. An id not measured yet takes none */
+    readonly heights: ReadonlyMap<string, number>;
+}
+/** The sources the editor asks about every block, in the order their demands are listed */
+export declare const DEFAULT_DEMAND_SOURCES: readonly DemandSource[];

package/dist/page/demands/index.js

@@ -0,0 +1,8 @@
+// src/page/demands/index.ts
+import { footnoteDemands } from "./footnoteDemands.js";
+var DEFAULT_DEMAND_SOURCES = [
+  footnoteDemands
+];
+export {
+  DEFAULT_DEMAND_SOURCES
+};

package/dist/page/kinds/paragraphKind.js

@@ -28,9 +28,11 @@ var paragraphKind = {
     const breaks = pageBreaksIn(node, pos);
     const candidates = [];
     let appliedHeight = 0;
+    const opened = /* @__PURE__ */ new Map();
     dom.querySelectorAll(BREAK_SPACE).forEach((space, index) => {
       const box = space.getBoundingClientRect();
       const found = breaks.at(index);
+      const drawn = box.height / scale;
       if (found) {
         candidates.push({
           at: found.at,
@@ -38,8 +40,9 @@ var paragraphKind = {
           forced: true,
           repeatHeight: 0
         });
+        if (drawn > 0) opened.set(found.at, drawn);
       }
-      appliedHeight += box.height / scale;
+      appliedHeight += drawn;
     });
     return {
       candidates,
@@ -48,6 +51,7 @@ var paragraphKind = {
       // still start a new page, but only after the whole block
       breakAfter: dom.querySelectorAll(PAGE_BREAK_BR).length > candidates.length,
       appliedHeight,
+      opened,
       keepWithNext: toParagraphFormat(node.attrs.format)?.keepNext === true
     };
   },
@@ -59,6 +63,8 @@ var paragraphKind = {
       into.push(
         Decoration.inline(at, at + size, {
           nodeName: "span",
+          // Chrome can enter the enlarged break and insert text outside the document model.
+          contenteditable: "false",
           style: spaceStyle(height),
           [editorAttributes.pageBreakSpace]: `${height}`
         })

package/dist/page/kinds/tableKind.js

@@ -34,7 +34,8 @@ function rowEntries(view, tableNode, tablePos, tableDom, appliedRows, scale) {
       node: row,
       pos,
       top: (rect.top - tableTop) / scale - appliedBefore,
-      height: rect.height / scale
+      height: rect.height / scale,
+      appliedAbove: appliedBefore
     });
   });
   return entries;
@@ -132,6 +133,12 @@ var tableKind = {
         });
       }
     }
+    const opened = /* @__PURE__ */ new Map();
+    rows.forEach((row, index) => {
+      const above = index === 0 ? 0 : rows[index - 1]?.appliedAbove ?? 0;
+      const here = row.appliedAbove - above;
+      if (here > 0) opened.set(row.pos, here);
+    });
     const firstBodyBoundary = candidates.find(
       (candidate) => candidate.offset > repeatHeaderHeight + 0.5
     );
@@ -141,6 +148,7 @@ var tableKind = {
     );
     return {
       candidates,
+      opened,
       // The smallest useful first piece: the headers followed by one body row group
       minFirstPiece: firstBodyBoundary?.offset ?? dom.getBoundingClientRect().height / scale - appliedHeight,
       // A space cannot be opened inside a cell, so a break standing in one is answered after the

package/dist/page/measureBlocks.d.ts

@@ -7,6 +7,8 @@
  * The engine's own marks are taken back off as they are read, so a block already pushed and a
  * break already given its space read as they would with neither applied. A measurement that read
  * them in would add to what is already there, and the layout would creep on every pass.
+ * Every demand source (`page/demands`) is asked about every block as well, after its kind, and the
+ * places it reads have the spaces the engine opened inside the block taken back off the same way.
  * Where there is no layout (in tests) everything is 0, so the result is a single page.
  */
 import type { EditorView } from "prosemirror-view";

package/dist/page/measureBlocks.js

@@ -1,15 +1,15 @@
 // src/page/measureBlocks.ts
 import { editorAttributes } from "../styles/classNames.js";
-import { blockKindFor } from "./blockKinds.js";
-import { blockKindsOf } from "./pageDecorations.js";
+import { visualScaleOf } from "../styles/visualScale.js";
+import {
+  blockKindFor
+} from "./blockKinds.js";
+import { blockKindsOf, demandSourcesOf } from "./pageDecorations.js";
+var NOTHING_OPENED = /* @__PURE__ */ new Map();
 function pixels(value) {
   const parsed = Number.parseFloat(value);
   return Number.isFinite(parsed) ? parsed : 0;
 }
-function visualScale(element) {
-  const scale = pixels(getComputedStyle(element).zoom);
-  return scale > 0 ? scale : 1;
-}
 function appliedPush(element) {
   return pixels(element.getAttribute(editorAttributes.pagePush) ?? "");
 }
@@ -23,16 +23,28 @@ function drawnBlocks(view) {
   });
   return found;
 }
+function naturalOffset(candidates, opened, drawn) {
+  let shift = 0;
+  for (const candidate of candidates) {
+    const space = opened.get(candidate.at);
+    if (space === void 0) continue;
+    const start = candidate.offset + shift;
+    if (drawn < start) break;
+    shift += Math.min(space, drawn - start);
+  }
+  return drawn - shift;
+}
 function measureSheet(view, layer) {
   const sheet = view.dom;
   const sheetRect = sheet.getBoundingClientRect();
   const layerRect = layer.getBoundingClientRect();
   const style = getComputedStyle(sheet);
-  const scale = visualScale(layer);
+  const scale = visualScaleOf(layer);
   const contentTop = pixels(style.paddingTop);
   const contentBottom = pixels(style.paddingBottom);
   const sheetY = (viewportY) => (viewportY - sheetRect.top) / scale;
   const kinds = blockKindsOf(view.state);
+  const sources = demandSourcesOf(view.state);
   const blocks = [];
   let previousBottom = contentTop;
   let applied = 0;
@@ -42,7 +54,7 @@ function measureSheet(view, layer) {
     const above = applied;
     const blockY = (viewportY) => sheetY(viewportY) - above;
     const top = blockY(rect.top);
-    const measured = blockKindFor(kinds, node).measure({
+    const target = {
       view,
       node,
       pos,
@@ -50,7 +62,8 @@ function measureSheet(view, layer) {
       sheetY: blockY,
       top,
       scale
-    });
+    };
+    const measured = blockKindFor(kinds, node).measure(target);
     applied += measured.appliedHeight;
     const bottom = sheetY(rect.bottom) - applied;
     blocks.push({
@@ -61,7 +74,15 @@ function measureSheet(view, layer) {
       breakAfter: measured.breakAfter,
       candidates: measured.candidates,
       minFirstPiece: measured.minFirstPiece,
-      keepWithNext: measured.keepWithNext ?? false
+      keepWithNext: measured.keepWithNext ?? false,
+      demands: sources.flatMap((source) => source.demandsIn(target)).map((demand) => ({
+        ...demand,
+        offset: naturalOffset(
+          measured.candidates,
+          measured.opened ?? NOTHING_OPENED,
+          demand.offset
+        )
+      }))
     });
     previousBottom = bottom;
   }

package/dist/page/pageDecorations.d.ts

@@ -3,13 +3,15 @@
  * own kind draws the cuts inside it as (`page/kinds`).
  *
  * The kinds the editor was built with are held here, so the measurement and the decorations read
- * one registry and a block is measured by the same kind that draws it.
+ * one registry and a block is measured by the same kind that draws it. The demand sources
+ * (`page/demands`) the measurement asks about every block are held beside them.
  * The document model is left untouched, so no trace of any of it is left in the exported XML or
  * in the edit history.
  */
 import { type EditorState, Plugin } from "prosemirror-state";
 import { DecorationSet, type EditorView } from "prosemirror-view";
 import { type BlockKind, type PageCut } from "./blockKinds";
+import { type DemandSource } from "./demands";
 import type { BlockPush } from "./pageLayout";
 /** Everything one measurement has to say about the page (`page/pageLayout`) */
 export interface PageMarksInput {
@@ -25,11 +27,16 @@ export interface PageMarksInput {
 }
 interface PageMarks extends PageMarksInput {
     kinds: readonly BlockKind[];
+    sources: readonly DemandSource[];
     decorations: DecorationSet;
 }
-export declare function pageDecorations(kinds?: readonly BlockKind[]): Plugin<PageMarks>;
+export declare function pageDecorations(kinds?: readonly BlockKind[], sources?: readonly DemandSource[]): Plugin<PageMarks>;
 /** The kinds the editor was built with, which the measurement reads to match them */
 export declare function blockKindsOf(state: EditorState): readonly BlockKind[];
+/** The demand sources the editor was built with, which the measurement asks about every block */
+export declare function demandSourcesOf(state: EditorState): readonly DemandSource[];
+/** The cuts the sheet is drawn with, whose spaces the measurement takes back off a demand's place */
+export declare function pageCutsOf(state: EditorState): readonly PageCut[];
 /** One transaction, or none when the same marks are already applied */
 export declare function setPageMarks(view: EditorView, next: PageMarksInput): void;
 export {};

package/dist/page/pageDecorations.js

@@ -6,6 +6,7 @@ import {
 import { Decoration, DecorationSet } from "prosemirror-view";
 import { editorAttributes } from "../styles/classNames.js";
 import { blockKindFor } from "./blockKinds.js";
+import { DEFAULT_DEMAND_SOURCES } from "./demands/index.js";
 import { DEFAULT_BLOCK_KINDS } from "./kinds/index.js";
 var marksKey = new PluginKey("docxPageDecorations");
 function pushStyle(marginTop) {
@@ -46,9 +47,10 @@ function decorationsFor(doc, kinds, pushes, cuts) {
   });
   return DecorationSet.create(doc, decorations);
 }
-function marksFor(doc, kinds, pushes, cuts) {
+function marksFor(doc, { kinds, sources }, pushes, cuts) {
   return {
     kinds,
+    sources,
     pushes,
     cuts,
     decorations: decorationsFor(doc, kinds, pushes, cuts)
@@ -75,18 +77,18 @@ function samePageMarks(a, b) {
     return other !== void 0 && other.at === cut.at && other.height === cut.height;
   });
 }
-function pageDecorations(kinds = DEFAULT_BLOCK_KINDS) {
+function pageDecorations(kinds = DEFAULT_BLOCK_KINDS, sources = DEFAULT_DEMAND_SOURCES) {
   return new Plugin({
     key: marksKey,
     state: {
-      init: (_config, state) => marksFor(state.doc, kinds, [], []),
+      init: (_config, state) => marksFor(state.doc, { kinds, sources }, [], []),
       apply(tr, value) {
         const next = tr.getMeta(marksKey);
         if (next) return next;
         if (!tr.docChanged) return value;
         return marksFor(
           tr.doc,
-          value.kinds,
+          value,
           value.pushes.map((push) => ({
             ...push,
             pos: tr.mapping.map(push.pos)
@@ -106,6 +108,12 @@ function pageDecorations(kinds = DEFAULT_BLOCK_KINDS) {
 function blockKindsOf(state) {
   return marksKey.getState(state)?.kinds ?? DEFAULT_BLOCK_KINDS;
 }
+function demandSourcesOf(state) {
+  return marksKey.getState(state)?.sources ?? DEFAULT_DEMAND_SOURCES;
+}
+function pageCutsOf(state) {
+  return marksKey.getState(state)?.cuts ?? [];
+}
 function current(view) {
   return marksKey.getState(view.state) ?? { pushes: [], cuts: [] };
 }
@@ -116,7 +124,10 @@ function setPageMarks(view, next) {
       marksKey,
       marksFor(
         view.state.doc,
-        blockKindsOf(view.state),
+        {
+          kinds: blockKindsOf(view.state),
+          sources: demandSourcesOf(view.state)
+        },
         next.pushes,
         next.cuts
       )
@@ -125,6 +136,8 @@ function setPageMarks(view, next) {
 }
 export {
   blockKindsOf,
+  demandSourcesOf,
+  pageCutsOf,
   pageDecorations,
   setPageMarks
 };