@portone/docx-editor 0.2.0 → 0.3.0

package/dist/page/kinds/tableKind.js

@@ -0,0 +1,178 @@
+// src/page/kinds/tableKind.ts
+import { Decoration } from "prosemirror-view";
+import { toRowFormat } from "../../model/format.js";
+import { editorAttributes } from "../../styles/classNames.js";
+var PAGE_BREAK_BR = `br[${editorAttributes.breakType}="page"]`;
+function span(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : 1;
+}
+function paginationRows(table) {
+  return Array.from(
+    table.querySelectorAll(
+      `[${editorAttributes.tablePageSpace}],[${editorAttributes.tableRepeatedHeader}]`
+    )
+  );
+}
+function before(candidate, row) {
+  return Boolean(
+    candidate.compareDocumentPosition(row) & Node.DOCUMENT_POSITION_FOLLOWING
+  );
+}
+function rowEntries(view, tableNode, tablePos, tableDom, appliedRows, scale) {
+  const entries = [];
+  const tableTop = tableDom.getBoundingClientRect().top;
+  tableNode.forEach((row, offset) => {
+    const pos = tablePos + 1 + offset;
+    const dom = view.nodeDOM(pos);
+    if (!(dom instanceof HTMLElement)) return;
+    const rect = dom.getBoundingClientRect();
+    const appliedBefore = appliedRows.reduce(
+      (total, candidate) => total + (before(candidate, dom) ? candidate.getBoundingClientRect().height / scale : 0),
+      0
+    );
+    entries.push({
+      node: row,
+      pos,
+      top: (rect.top - tableTop) / scale - appliedBefore,
+      height: rect.height / scale
+    });
+  });
+  return entries;
+}
+function unsafeBoundaries(rows) {
+  const unsafe = /* @__PURE__ */ new Set();
+  rows.forEach((row, rowIndex) => {
+    row.node.forEach((cell) => {
+      const bottom = Math.min(rows.length, rowIndex + span(cell.attrs.rowspan));
+      for (let boundary = rowIndex + 1; boundary < bottom; boundary += 1) {
+        unsafe.add(boundary);
+      }
+    });
+  });
+  return unsafe;
+}
+function repeatsHeader(row) {
+  return toRowFormat(row?.attrs.format)?.repeatHeader === true;
+}
+function headerCount(rows) {
+  let count = 0;
+  while (count < rows.length && repeatsHeader(rows[count]?.node)) {
+    count += 1;
+  }
+  return count;
+}
+function headerRowsOf(tableNode, tablePos) {
+  const found = [];
+  let offset = 0;
+  for (let index = 0; index < tableNode.childCount; index += 1) {
+    const row = tableNode.child(index);
+    if (!repeatsHeader(row)) break;
+    found.push(tablePos + 1 + offset);
+    offset += row.nodeSize;
+  }
+  return found;
+}
+function columnCount(tableNode) {
+  const grid = tableNode.attrs.gridCols;
+  if (Array.isArray(grid) && grid.length > 0) return grid.length;
+  const first = tableNode.firstChild;
+  if (!first) return 1;
+  let columns = 0;
+  first.forEach((cell) => {
+    columns += span(cell.attrs.colspan);
+  });
+  return Math.max(1, columns);
+}
+function tableSpace(height, columns) {
+  const row = document.createElement("tr");
+  row.setAttribute(editorAttributes.tablePageSpace, `${height}`);
+  row.setAttribute("aria-hidden", "true");
+  row.setAttribute("contenteditable", "false");
+  row.style.height = `${height}px`;
+  const cell = document.createElement("td");
+  cell.colSpan = columns;
+  cell.style.height = `${height}px`;
+  row.append(cell);
+  return row;
+}
+function repeatedHeader(view, rowPos) {
+  const source = view.nodeDOM(rowPos);
+  const row = source instanceof HTMLElement && source.tagName === "TR" ? source.cloneNode(true) : document.createElement("tr");
+  row.setAttribute(editorAttributes.tableRepeatedHeader, "");
+  row.setAttribute("aria-hidden", "true");
+  row.setAttribute("contenteditable", "false");
+  row.removeAttribute("id");
+  row.querySelectorAll("[id]").forEach((element) => {
+    element.removeAttribute("id");
+  });
+  return row;
+}
+var tableKind = {
+  name: "table",
+  matches: (node) => node.type.spec.tableRole === "table",
+  measure({ view, node, pos, dom, scale }) {
+    const appliedRows = paginationRows(dom);
+    const rows = rowEntries(view, node, pos, dom, appliedRows, scale);
+    const headers = headerCount(rows);
+    const unsafe = unsafeBoundaries(rows);
+    const headerRows = rows.slice(0, headers);
+    const repeatHeaderHeight = headerRows.reduce(
+      (total, row) => total + row.height,
+      0
+    );
+    const candidates = [];
+    for (let rowIndex = Math.max(1, headers); rowIndex < rows.length; rowIndex += 1) {
+      const row = rows[rowIndex];
+      if (row && !unsafe.has(rowIndex)) {
+        candidates.push({
+          at: row.pos,
+          offset: row.top,
+          forced: false,
+          repeatHeight: repeatHeaderHeight
+        });
+      }
+    }
+    const firstBodyBoundary = candidates.find(
+      (candidate) => candidate.offset > repeatHeaderHeight + 0.5
+    );
+    const appliedHeight = appliedRows.reduce(
+      (total, row) => total + row.getBoundingClientRect().height / scale,
+      0
+    );
+    return {
+      candidates,
+      // 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
+      // whole table
+      breakAfter: dom.querySelectorAll(PAGE_BREAK_BR).length > 0,
+      appliedHeight
+    };
+  },
+  holdsCut: (doc, at) => doc.nodeAt(at)?.type.spec.tableRole === "row",
+  decorate(pos, node, cuts, into) {
+    if (cuts.length === 0) return;
+    const headerRows = headerRowsOf(node, pos);
+    const columns = columnCount(node);
+    for (const cut of cuts) {
+      into.push(
+        Decoration.widget(cut.at, () => tableSpace(cut.height, columns), {
+          key: `table-page-space-${cut.at}-${cut.height}-${columns}`,
+          side: -100
+        })
+      );
+      headerRows.forEach((rowPos, headerIndex) => {
+        into.push(
+          // No `key`: a keyed widget is held to be the same one and left alone, and this one is a
+          // copy of a row that the very edit rebuilding these decorations may have just changed
+          Decoration.widget(cut.at, (view) => repeatedHeader(view, rowPos), {
+            side: -90 + headerIndex
+          })
+        );
+      });
+    }
+  }
+};
+export {
+  tableKind
+};

package/dist/page/measureBlocks.d.ts

@@ -2,13 +2,15 @@
  * Measures the sheet as drawn on screen: the height of each body block, the gap above it, and
  * where the page breaks inside it stand, with nothing computed line by line.
  *
+ * Every place a block may be parted at is read as a break candidate (`page/blockKinds`) by the
+ * block's own kind (`page/kinds`), so this pass names no shape of block itself.
  * 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.
  * Where there is no layout (in tests) everything is 0, so the result is a single page.
  */
 import type { EditorView } from "prosemirror-view";
-import type { MeasuredBlock } from "./pageLayout";
+import { type MeasuredBlock } from "./blockKinds";
 /**
  * The measurements taken in order to draw the page overlay. Positions are relative to
  * the overlay box

package/dist/page/measureBlocks.js

@@ -1,8 +1,7 @@
 // src/page/measureBlocks.ts
 import { editorAttributes } from "../styles/classNames.js";
-import { measureTable } from "./tableMeasurements.js";
-var PAGE_BREAK_BR = `br[${editorAttributes.breakType}="page"]`;
-var BREAK_SPACE = `[${editorAttributes.pageBreakSpace}]`;
+import { blockKindFor } from "./blockKinds.js";
+import { blockKindsOf } from "./pageDecorations.js";
 function pixels(value) {
   const parsed = Number.parseFloat(value);
   return Number.isFinite(parsed) ? parsed : 0;
@@ -16,17 +15,14 @@ function appliedPush(element) {
 }
 function drawnBlocks(view) {
   const found = [];
-  view.state.doc.forEach((_node, offset) => {
+  view.state.doc.forEach((node, offset) => {
     const dom = view.nodeDOM(offset);
     if (dom instanceof HTMLElement && dom.getBoundingClientRect().height > 0) {
-      found.push({ pos: offset, dom });
+      found.push({ node, pos: offset, dom });
     }
   });
   return found;
 }
-function breakWithoutSpace(dom, spaces) {
-  return dom.querySelectorAll(PAGE_BREAK_BR).length > spaces;
-}
 function measureSheet(view, layer) {
   const sheet = view.dom;
   const sheetRect = sheet.getBoundingClientRect();
@@ -36,35 +32,38 @@ function measureSheet(view, layer) {
   const contentTop = pixels(style.paddingTop);
   const contentBottom = pixels(style.paddingBottom);
   const sheetY = (viewportY) => (viewportY - sheetRect.top) / scale;
+  const kinds = blockKindsOf(view.state);
   const blocks = [];
   let previousBottom = contentTop;
   let applied = 0;
-  let breakAfterPrevious = false;
-  for (const { pos, dom } of drawnBlocks(view)) {
-    const node = view.state.doc.nodeAt(pos);
+  for (const { node, pos, dom } of drawnBlocks(view)) {
     const rect = dom.getBoundingClientRect();
     applied += appliedPush(dom);
-    const top = sheetY(rect.top) - applied;
-    const measuredTable = node ? measureTable(view, node, pos, dom, scale) : null;
-    const breaks = [];
-    const spaces = Array.from(dom.querySelectorAll(BREAK_SPACE));
-    for (const space of spaces) {
-      const box = space.getBoundingClientRect();
-      breaks.push(sheetY(box.top) - applied - top);
-      applied += box.height / scale;
-    }
-    applied += measuredTable?.appliedHeight ?? 0;
+    const above = applied;
+    const blockY = (viewportY) => sheetY(viewportY) - above;
+    const top = blockY(rect.top);
+    const measured = blockKindFor(kinds, node).measure({
+      view,
+      node,
+      pos,
+      dom,
+      sheetY: blockY,
+      top,
+      scale
+    });
+    applied += measured.appliedHeight;
     const bottom = sheetY(rect.bottom) - applied;
     blocks.push({
       pos,
       gap: top - previousBottom,
       height: bottom - top,
-      breakBefore: breakAfterPrevious || dom.hasAttribute(editorAttributes.pageBreakBefore),
-      breaks,
-      ...measuredTable ? { table: measuredTable.table } : {}
+      breakBefore: dom.hasAttribute(editorAttributes.pageBreakBefore),
+      breakAfter: measured.breakAfter,
+      candidates: measured.candidates,
+      minFirstPiece: measured.minFirstPiece,
+      keepWithNext: measured.keepWithNext ?? false
     });
     previousBottom = bottom;
-    breakAfterPrevious = breakWithoutSpace(dom, spaces.length);
   }
   return {
     left: (sheetRect.left - layerRect.left) / scale,

package/dist/page/pageDecorations.d.ts

@@ -1,36 +1,35 @@
 /**
- * Decorations that move content to the next page: block pushes, page-break spaces, and table
- * continuation rows.
+ * Decorations that move content to the next page: the push above a block, and whatever the block's
+ * own kind draws the cuts inside it as (`page/kinds`).
  *
- * The document model is left untouched, so no trace of them is left in
- * the exported XML or in the edit history.
+ * 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.
+ * 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 { Plugin } from "prosemirror-state";
+import { type EditorState, Plugin } from "prosemirror-state";
 import { DecorationSet, type EditorView } from "prosemirror-view";
-import type { BlockPush, BreakSpace, TableContinuation } from "./pageLayout";
-/**
- * One break's space while the document changes under it.
- *
- * The layout counts breaks inside the block it measured (`page/pageLayout`), and an edit anywhere
- * before a break shifts that count, so what is kept here is the position of the `br` the space
- * belongs to: a position maps through an edit, an ordinal does not.
- */
-interface SpaceMark {
-    /** Where the `br` this space is put on stands */
-    at: number;
-    height: number;
-}
-interface PageMarks {
+import { type BlockKind, type PageCut } from "./blockKinds";
+import type { BlockPush } from "./pageLayout";
+/** Everything one measurement has to say about the page (`page/pageLayout`) */
+export interface PageMarksInput {
     pushes: readonly BlockPush[];
-    spaces: readonly SpaceMark[];
-    tableContinuations: readonly TableContinuation[];
+    /**
+     * Where the layout parted a block, keyed by the position the continued piece starts at.
+     *
+     * The layout counts within the block it measured, and an edit anywhere before a cut shifts that
+     * count, so what is kept here is a position: a position maps through an edit, an ordinal does
+     * not.
+     */
+    cuts: readonly PageCut[];
+}
+interface PageMarks extends PageMarksInput {
+    kinds: readonly BlockKind[];
     decorations: DecorationSet;
 }
-export declare function pageDecorations(): Plugin<PageMarks>;
-/** Does nothing when the same values are already applied */
-export declare function setPagePushes(view: EditorView, pushes: readonly BlockPush[]): void;
-/** Does nothing when the same values are already applied */
-export declare function setPageBreakSpaces(view: EditorView, spaces: readonly BreakSpace[]): void;
-/** Does nothing when the same table continuations are already applied */
-export declare function setTableContinuations(view: EditorView, continuations: readonly TableContinuation[]): void;
+export declare function pageDecorations(kinds?: readonly BlockKind[]): Plugin<PageMarks>;
+/** The kinds the editor was built with, which the measurement reads to match them */
+export declare function blockKindsOf(state: EditorState): readonly BlockKind[];
+/** 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

@@ -1,96 +1,31 @@
 // src/page/pageDecorations.ts
-import { Plugin, PluginKey } from "prosemirror-state";
+import {
+  Plugin,
+  PluginKey
+} from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
-import { docxSchema, isPageBreak } from "../schema/index.js";
 import { editorAttributes } from "../styles/classNames.js";
+import { blockKindFor } from "./blockKinds.js";
+import { DEFAULT_BLOCK_KINDS } from "./kinds/index.js";
 var marksKey = new PluginKey("docxPageDecorations");
 function pushStyle(marginTop) {
   return `margin-block-start:${marginTop}px`;
 }
-function spaceStyle(height) {
-  return `display:block;height:${height}px`;
-}
-function isPageBreakNode(node) {
-  return node?.type === docxSchema.nodes.hardBreak && isPageBreak(node.attrs.brAttrs);
-}
-function pageBreaksIn(block, blockPos) {
-  const found = [];
-  if (block.type !== docxSchema.nodes.paragraph) return found;
-  block.forEach((child, offset) => {
-    if (isPageBreakNode(child)) {
-      found.push({ at: blockPos + 1 + offset, size: child.nodeSize });
-    }
-  });
-  return found;
-}
-function breakSpaces(block, blockPos, heights, into) {
-  for (const { at, size } of pageBreaksIn(block, blockPos)) {
-    const height = heights.get(at) ?? 0;
-    into.push(
-      Decoration.inline(at, at + size, {
-        nodeName: "span",
-        style: spaceStyle(height),
-        [editorAttributes.pageBreakSpace]: `${height}`
-      })
-    );
+function cutsByBlock(doc, cuts) {
+  const byBlock = /* @__PURE__ */ new Map();
+  for (const cut of cuts) {
+    const $at = doc.resolve(cut.at);
+    if ($at.depth === 0) continue;
+    const blockPos = $at.before(1);
+    const found = byBlock.get(blockPos);
+    if (found) found.push(cut);
+    else byBlock.set(blockPos, [cut]);
   }
+  return byBlock;
 }
-function spaceMarks(doc, spaces) {
-  return spaces.flatMap((space) => {
-    const block = doc.nodeAt(space.pos);
-    const found = block ? pageBreaksIn(block, space.pos)[space.index] : null;
-    return found ? [{ at: found.at, height: space.height }] : [];
-  });
-}
-function tableSpace(continuation) {
-  const row = document.createElement("tr");
-  row.setAttribute(editorAttributes.tablePageSpace, `${continuation.height}`);
-  row.setAttribute("aria-hidden", "true");
-  row.setAttribute("contenteditable", "false");
-  row.style.height = `${continuation.height}px`;
-  const cell = document.createElement("td");
-  cell.colSpan = continuation.columns;
-  cell.style.height = `${continuation.height}px`;
-  row.append(cell);
-  return row;
-}
-function repeatedHeader(view, rowPos) {
-  const source = view.nodeDOM(rowPos);
-  const row = source instanceof HTMLElement && source.tagName === "TR" ? source.cloneNode(true) : document.createElement("tr");
-  row.setAttribute(editorAttributes.tableRepeatedHeader, "");
-  row.setAttribute("aria-hidden", "true");
-  row.setAttribute("contenteditable", "false");
-  row.removeAttribute("id");
-  row.querySelectorAll("[id]").forEach((element) => {
-    element.removeAttribute("id");
-  });
-  return row;
-}
-function tableContinuationDecorations(continuations, into) {
-  continuations.forEach((continuation) => {
-    into.push(
-      Decoration.widget(continuation.pos, () => tableSpace(continuation), {
-        key: `table-page-space-${continuation.pos}-${continuation.height}-${continuation.columns}`,
-        side: -100
-      })
-    );
-    continuation.headerRows.forEach((rowPos, headerIndex) => {
-      into.push(
-        Decoration.widget(
-          continuation.pos,
-          (view) => repeatedHeader(view, rowPos),
-          {
-            key: `table-repeated-header-${continuation.pos}-${headerIndex}-` + continuation.headerSignature,
-            side: -90 + headerIndex
-          }
-        )
-      );
-    });
-  });
-}
-function decorationsFor(doc, pushes, spaces, tableContinuations) {
+function decorationsFor(doc, kinds, pushes, cuts) {
   const byPos = new Map(pushes.map((push) => [push.pos, push]));
-  const heights = new Map(spaces.map((space) => [space.at, space.height]));
+  const byBlock = cutsByBlock(doc, cuts);
   const decorations = [];
   doc.forEach((node, offset) => {
     const push = byPos.get(offset);
@@ -102,65 +37,63 @@ function decorationsFor(doc, pushes, spaces, tableContinuations) {
         })
       );
     }
-    breakSpaces(node, offset, heights, decorations);
+    blockKindFor(kinds, node).decorate(
+      offset,
+      node,
+      byBlock.get(offset) ?? [],
+      decorations
+    );
   });
-  tableContinuationDecorations(tableContinuations, decorations);
   return DecorationSet.create(doc, decorations);
 }
-function marksFor(doc, pushes, spaces, tableContinuations) {
+function marksFor(doc, kinds, pushes, cuts) {
   return {
+    kinds,
     pushes,
-    spaces,
-    tableContinuations,
-    decorations: decorationsFor(doc, pushes, spaces, tableContinuations)
+    cuts,
+    decorations: decorationsFor(doc, kinds, pushes, cuts)
   };
 }
-function samePushes(a, b) {
-  return a.length === b.length && a.every((push, index) => {
-    const other = b[index];
-    return other !== void 0 && other.pos === push.pos && other.marginTop === push.marginTop;
-  });
-}
-function sameSpaces(a, b) {
-  return a.length === b.length && a.every((space, index) => {
-    const other = b[index];
-    return other !== void 0 && other.at === space.at && other.height === space.height;
-  });
-}
-function sameTableContinuations(a, b) {
-  return a.length === b.length && a.every((continuation, index) => {
-    const other = b[index];
-    return other !== void 0 && other.pos === continuation.pos && other.height === continuation.height && other.columns === continuation.columns && other.headerSignature === continuation.headerSignature && other.headerRows.length === continuation.headerRows.length && other.headerRows.every(
-      (rowPos, rowIndex) => rowPos === continuation.headerRows[rowIndex]
-    );
+function stillCuts(kinds, doc, at) {
+  const $at = doc.resolve(at);
+  if ($at.depth === 0) return false;
+  const block = doc.nodeAt($at.before(1));
+  return block !== null && blockKindFor(kinds, block).holdsCut(doc, at);
+}
+function retainsContent(tr, at, mapped) {
+  const node = tr.before.nodeAt(at);
+  if (!node || node.isLeaf) return false;
+  const content = tr.mapping.mapResult(at + 1, -1);
+  return !content.deletedAcross && content.pos === mapped + 1;
+}
+function samePageMarks(a, b) {
+  return a.pushes.length === b.pushes.length && a.cuts.length === b.cuts.length && a.pushes.every((push, index) => {
+    const other = b.pushes[index];
+    return other !== void 0 && other.pos === push.pos && other.marginTop === push.marginTop && other.push === push.push;
+  }) && a.cuts.every((cut, index) => {
+    const other = b.cuts[index];
+    return other !== void 0 && other.at === cut.at && other.height === cut.height;
   });
 }
-function pageDecorations() {
+function pageDecorations(kinds = DEFAULT_BLOCK_KINDS) {
   return new Plugin({
     key: marksKey,
     state: {
-      init: (_config, state) => marksFor(state.doc, [], [], []),
+      init: (_config, state) => marksFor(state.doc, kinds, [], []),
       apply(tr, value) {
         const next = tr.getMeta(marksKey);
         if (next) return next;
         if (!tr.docChanged) return value;
         return marksFor(
           tr.doc,
+          value.kinds,
           value.pushes.map((push) => ({
             ...push,
             pos: tr.mapping.map(push.pos)
           })),
-          value.spaces.flatMap((space) => {
-            const at = tr.mapping.map(space.at);
-            return isPageBreakNode(tr.doc.nodeAt(at)) ? [{ ...space, at }] : [];
-          }),
-          value.tableContinuations.flatMap((continuation) => {
-            const pos = tr.mapping.map(continuation.pos);
-            if (tr.doc.nodeAt(pos)?.type.spec.tableRole !== "row") return [];
-            const headerRows = continuation.headerRows.map((rowPos) => tr.mapping.map(rowPos)).filter(
-              (rowPos) => tr.doc.nodeAt(rowPos)?.type.spec.tableRole === "row"
-            );
-            return [{ ...continuation, pos, headerRows }];
+          value.cuts.flatMap((cut) => {
+            const mapped = tr.mapping.mapResult(cut.at, 1);
+            return !stillCuts(value.kinds, tr.doc, mapped.pos) || mapped.deleted && !retainsContent(tr, cut.at, mapped.pos) ? [] : [{ ...cut, at: mapped.pos }];
           })
         );
       }
@@ -170,42 +103,28 @@ function pageDecorations() {
     }
   });
 }
+function blockKindsOf(state) {
+  return marksKey.getState(state)?.kinds ?? DEFAULT_BLOCK_KINDS;
+}
 function current(view) {
-  return marksKey.getState(view.state) ?? marksFor(view.state.doc, [], [], []);
+  return marksKey.getState(view.state) ?? { pushes: [], cuts: [] };
 }
-function dispatch(view, next) {
+function setPageMarks(view, next) {
+  if (samePageMarks(current(view), next)) return;
   view.dispatch(
-    view.state.tr.setMeta(marksKey, next).setMeta("addToHistory", false)
-  );
-}
-function setPagePushes(view, pushes) {
-  const marks = current(view);
-  if (samePushes(marks.pushes, pushes)) return;
-  dispatch(
-    view,
-    marksFor(view.state.doc, pushes, marks.spaces, marks.tableContinuations)
-  );
-}
-function setPageBreakSpaces(view, spaces) {
-  const marks = current(view);
-  const next = spaceMarks(view.state.doc, spaces);
-  if (sameSpaces(marks.spaces, next)) return;
-  dispatch(
-    view,
-    marksFor(view.state.doc, marks.pushes, next, marks.tableContinuations)
-  );
-}
-function setTableContinuations(view, continuations) {
-  const marks = current(view);
-  if (sameTableContinuations(marks.tableContinuations, continuations)) return;
-  dispatch(
-    view,
-    marksFor(view.state.doc, marks.pushes, marks.spaces, continuations)
+    view.state.tr.setMeta(
+      marksKey,
+      marksFor(
+        view.state.doc,
+        blockKindsOf(view.state),
+        next.pushes,
+        next.cuts
+      )
+    ).setMeta("addToHistory", false)
   );
 }
 export {
+  blockKindsOf,
   pageDecorations,
-  setPageBreakSpaces,
-  setPagePushes,
-  setTableContinuations
+  setPageMarks
 };