@portone/docx-editor 0.2.0 → 0.2.1

package/dist/ooxml/element.js

@@ -0,0 +1,49 @@
+// src/ooxml/element.ts
+import { NAMESPACES, wName } from "./names.js";
+import { escapeXml, localPart } from "./xml.js";
+function attrsText(attrs) {
+  return attrs.map(([name, value]) => `${name}="${escapeXml(value)}"`).join(" ");
+}
+function elementXml(name, attrs, children = []) {
+  const text = attrsText(attrs);
+  const open = text === "" ? `<${name}` : `<${name} ${text}`;
+  if (children.length === 0) return `${open}/>`;
+  return `${open}>${children.join("")}</${name}>`;
+}
+function xmlnsAttr(prefix) {
+  return [`xmlns:${prefix}`, NAMESPACES[prefix]];
+}
+function withAttr(attrs, name, value) {
+  if (value === null) return withoutAttrs(attrs, [name]);
+  const at = attrs.findIndex(([attr]) => localPart(attr) === name);
+  if (at === -1) return [...attrs, [wName(name), value]];
+  return attrs.map(
+    (attr, index) => index === at ? [attr[0], value] : attr
+  );
+}
+function withoutAttrs(attrs, localNames) {
+  return attrs.filter(([name]) => !localNames.includes(localPart(name)));
+}
+function attrValue(attrs, localName) {
+  return attrs.find(([name]) => localPart(name) === localName)?.[1] ?? null;
+}
+function openTagXml(name, rawAttrs) {
+  return rawAttrs ? `<${name} ${rawAttrs}>` : `<${name}>`;
+}
+function emptyTagXml(name, rawAttrs) {
+  return rawAttrs ? `<${name} ${rawAttrs}/>` : `<${name}/>`;
+}
+function attrPairs(el) {
+  return el ? Array.from(el.attributes, (attr) => [attr.name, attr.value]) : [];
+}
+export {
+  attrPairs,
+  attrValue,
+  attrsText,
+  elementXml,
+  emptyTagXml,
+  openTagXml,
+  withAttr,
+  withoutAttrs,
+  xmlnsAttr
+};

package/dist/ooxml/fragment.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The gate a raw OOXML string passes through on its way from the DOM into a node or mark attr.
+ *
+ * A preserved fragment goes back out the way it came, spliced into a slot the writer opens and
+ * closes around it (`docx/serializeParagraph`), so a fragment that closes that slot itself, opens
+ * a sibling beside it, or lays text down beside what it holds writes something the editor never
+ * modelled into the exported file. What stands inside the element it carries is that element's own
+ * and travels with it. Reading one back is the only place such a string can arrive from outside,
+ * so every attr that carries one is read through here and a fragment that does not hold its shape
+ * is turned down rather than corrected.
+ *
+ * A refusal is not an error: `getAttrs` answers `false` with it, which drops the parse rule and
+ * leaves ProseMirror to settle the content one level plainer. Demotion, not contamination.
+ */
+/**
+ * What a raw XML string has to look like to be let into the attr that carries it.
+ *
+ * `element` is a whole element: a properties fragment, a drawing, an annotation reference.
+ * `attributes` is what stood inside an opening tag, as `attrString` writes it.
+ * `openTag` is an opening tag with everything it wrapped cut away, which the writer puts back by
+ * appending the closing text `closedBy` names. `head` is what may still stand between the two:
+ * the property elements the tag carries ahead of its content, by local name.
+ */
+export type RawXmlShape = {
+    kind: "element";
+    names: readonly string[] | "any";
+} | {
+    kind: "attributes";
+} | {
+    kind: "openTag";
+    name: string;
+    closedBy: string;
+    head: readonly string[];
+};
+/** A single element by local name, rejecting an explicitly foreign namespace */
+export declare function ELEMENT(...names: string[]): RawXmlShape;
+/**
+ * A single element of any name, in any namespace.
+ *
+ * What import could not model keeps its own XML (`rawInline`, `rawBlock`), and that is a
+ * `m:oMathPara`, a `mc:AlternateContent`, a `w:ins`, a bookmark: naming the ones allowed would
+ * turn a document the editor reads today into a demoted one.
+ */
+export declare const ANY_ELEMENT: RawXmlShape;
+/** The attributes of an opening tag, with neither the tag nor anything it held */
+export declare const ATTRIBUTES: RawXmlShape;
+/**
+ * The value if it holds the shape, null if there was none, `false` if it does not.
+ *
+ * The three answers are what `getAttrs` needs: a value to carry, an absent attr, and a rule to
+ * give up on.
+ */
+export declare function acceptRawXml(shape: RawXmlShape, value: string | null): string | null | false;

package/dist/ooxml/fragment.js

@@ -0,0 +1,76 @@
+// src/ooxml/fragment.ts
+import {
+  elementChildren,
+  namespaceDecls,
+  parseXml,
+  RESERVED_PREFIXES,
+  W_NS
+} from "./xml.js";
+function ELEMENT(...names) {
+  return { kind: "element", names };
+}
+var ANY_ELEMENT = { kind: "element", names: "any" };
+var ATTRIBUTES = { kind: "attributes" };
+function loneElement(xml) {
+  let root;
+  try {
+    root = parseXml(`<x ${namespaceDecls(xml)}>${xml}</x>`).documentElement;
+  } catch {
+    return null;
+  }
+  if (root.childNodes.length !== 1) return null;
+  const el = elementChildren(root)[0];
+  return el === void 0 || rebindsReservedPrefix(el) ? null : el;
+}
+function isNamed(el, names) {
+  if (!names.includes(el.localName)) return false;
+  const declaration = el.prefix === null ? "xmlns" : `xmlns:${el.prefix}`;
+  for (let scope = el; scope.parentElement !== null; scope = scope.parentElement) {
+    if (scope.hasAttribute(declaration)) return el.namespaceURI === W_NS;
+  }
+  return true;
+}
+function holdsHeadAlone(el, shape) {
+  const closing = loneElement(`<w:${shape.name}>${shape.closedBy}`);
+  if (closing === null) return false;
+  const children = elementChildren(el);
+  const own = children.slice(
+    0,
+    children.length - elementChildren(closing).length
+  );
+  return el.childNodes.length === children.length && own.every((child) => isNamed(child, shape.head));
+}
+function rebindsReservedPrefix(el) {
+  return Array.from(el.attributes).some((attr) => {
+    if (attr.prefix !== "xmlns") return false;
+    const reserved = RESERVED_PREFIXES.get(attr.localName);
+    return reserved !== void 0 && reserved !== attr.value;
+  }) || elementChildren(el).some(rebindsReservedPrefix);
+}
+function holdsShape(shape, value) {
+  switch (shape.kind) {
+    case "element": {
+      const el = loneElement(value);
+      if (el === null) return false;
+      return shape.names === "any" || isNamed(el, shape.names);
+    }
+    case "attributes": {
+      const el = loneElement(`<y ${value}></y>`);
+      return el !== null && el.childNodes.length === 0;
+    }
+    case "openTag": {
+      const el = loneElement(value + shape.closedBy);
+      return el !== null && holdsHeadAlone(el, shape);
+    }
+  }
+}
+function acceptRawXml(shape, value) {
+  if (value === null) return null;
+  return holdsShape(shape, value) ? value : false;
+}
+export {
+  ANY_ELEMENT,
+  ATTRIBUTES,
+  ELEMENT,
+  acceptRawXml
+};

package/dist/ooxml/image.js

@@ -1,4 +1,5 @@
 // src/ooxml/image.ts
+import { NAMESPACES } from "./names.js";
 import { childByLocalName, escapeXml, R_NS } from "./xml.js";
 var EMU_PER_PX = 9525;
 function emuToPx(emu) {
@@ -42,7 +43,7 @@ function toImageExtent(value) {
   const cy = positiveInt(value.cy);
   return cx === null || cy === null ? null : { cx, cy };
 }
-var PICTURE_URI = "http://schemas.openxmlformats.org/drawingml/2006/picture";
+var PICTURE_URI = NAMESPACES.pic;
 function childOf(el, name) {
   return el ? childByLocalName(el, name) : null;
 }
@@ -82,8 +83,8 @@ function withExtent(xml, extent) {
   const size = `cx="${extent.cx}" cy="${extent.cy}"`;
   return xml.replace(EXTENT_TAG, (_match, prefix) => `<${prefix ?? ""}extent ${size}/>`).replace(EXT_TAG, (_match, prefix) => `<${prefix ?? ""}ext ${size}/>`);
 }
-var WP_NS = "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
-var A_NS = "http://schemas.openxmlformats.org/drawingml/2006/main";
+var WP_NS = NAMESPACES.wp;
+var A_NS = NAMESPACES.a;
 function imageDrawingXml(image) {
   const size = `cx="${image.extent.cx}" cy="${image.extent.cy}"`;
   const name = `Picture ${image.docPrId}`;

package/dist/ooxml/names.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The namespace prefixes the writer spells out, and the namespace each one stands for.
+ *
+ * Reading is another matter: a document may bind these prefixes to names of its own, so an element
+ * that arrived in the file is looked up by its local part. What this package writes is settled
+ * here, and the part a fragment is spliced into declares the same binding, so the prefix is
+ * decided once rather than at every call site.
+ */
+/** The prefix every WordprocessingML element and attribute this package writes carries */
+export declare const W_PREFIX = "w";
+export declare const NAMESPACES: {
+    readonly w: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+    readonly r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+    readonly w14: "http://schemas.microsoft.com/office/word/2010/wordml";
+    readonly w15: "http://schemas.microsoft.com/office/word/2012/wordml";
+    readonly mc: "http://schemas.openxmlformats.org/markup-compatibility/2006";
+    readonly wp: "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
+    readonly a: "http://schemas.openxmlformats.org/drawingml/2006/main";
+    readonly pic: "http://schemas.openxmlformats.org/drawingml/2006/picture";
+};
+export type KnownPrefix = keyof typeof NAMESPACES;
+/** The name `local` goes out under (`qualify("w15", "commentEx")` -> `w15:commentEx`) */
+export declare function qualify(prefix: KnownPrefix, local: string): string;
+/** `wName("val")` -> `w:val`. The one place the written WordprocessingML prefix is decided */
+export declare function wName(local: string): string;
+/** The declaration a part root carries for one prefix, ready to write inside an opening tag */
+export declare function xmlnsDecl(prefix: KnownPrefix): string;

package/dist/ooxml/names.js

@@ -0,0 +1,29 @@
+// src/ooxml/names.ts
+import { R_NS, W_NS } from "./xml.js";
+var W_PREFIX = "w";
+var NAMESPACES = {
+  w: W_NS,
+  r: R_NS,
+  w14: "http://schemas.microsoft.com/office/word/2010/wordml",
+  w15: "http://schemas.microsoft.com/office/word/2012/wordml",
+  mc: "http://schemas.openxmlformats.org/markup-compatibility/2006",
+  wp: "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
+  a: "http://schemas.openxmlformats.org/drawingml/2006/main",
+  pic: "http://schemas.openxmlformats.org/drawingml/2006/picture"
+};
+function qualify(prefix, local) {
+  return `${prefix}:${local}`;
+}
+function wName(local) {
+  return qualify(W_PREFIX, local);
+}
+function xmlnsDecl(prefix) {
+  return `xmlns:${prefix}="${NAMESPACES[prefix]}"`;
+}
+export {
+  NAMESPACES,
+  W_PREFIX,
+  qualify,
+  wName,
+  xmlnsDecl
+};

package/dist/ooxml/precedence.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Which attribute beats which when an element writes down both.
+ *
+ * OOXML records the same setting twice over in several places: a font slot beside the theme
+ * reference that overrules it, a color beside the theme color, an indent in twips beside the same
+ * indent counted in characters. Writing one of a pair while leaving the other standing means
+ * writing a value Word will not show, so the one that would win is dropped as the other is written.
+ *
+ * The table is keyed by the local names of the owning element and the attribute together, because
+ * neither is enough on its own: `color` is an attribute of `w:shd` but an element of its own whose
+ * value sits in `w:val`, and `left` is an attribute of `w:ind` but an element of `w:tcMar`.
+ */
+import { type XmlAttr } from "./element";
+/**
+ * The attributes that override the named one when both are there, so writing the named one drops
+ * them (§17.3.1.12 ind, §17.3.2.26 rFonts, §17.3.2.6 color, §17.3.5 shd, §17.3.1.33 spacing).
+ *
+ * The border sides are the children of `w:tcBorders`, each of them a CT_Border that records a
+ * color of its own.
+ */
+export declare const OVERRIDING_ATTRS: Readonly<Record<`${string}/${string}`, readonly string[]>>;
+/** What writing `element`'s `name` drops along with it. Empty for a pair nothing overrides */
+export declare function overridingAttrs(element: string, name: string): readonly string[];
+/**
+ * `withAttr` with the attributes the new value would be fighting with dropped as it is written.
+ *
+ * This is how an attribute is meant to be written, so that a writer added later cannot forget the
+ * drop. A caller that means to leave an overriding attribute standing says so by reaching for
+ * `withAttr` instead.
+ */
+export declare function setAttr(attrs: readonly XmlAttr[], element: string, name: string, value: string | null): XmlAttr[];

package/dist/ooxml/precedence.js

@@ -0,0 +1,51 @@
+// src/ooxml/precedence.ts
+import { withAttr, withoutAttrs } from "./element.js";
+var THEME_COLOR = [
+  "themeColor",
+  "themeTint",
+  "themeShade"
+];
+var NO_OVERRIDES = [];
+var OVERRIDING_ATTRS = {
+  "rFonts/ascii": ["asciiTheme"],
+  "rFonts/hAnsi": ["hAnsiTheme"],
+  "rFonts/eastAsia": ["eastAsiaTheme"],
+  // This is the slot whose capitalization varies from document to document
+  "rFonts/cs": ["cstheme", "csTheme"],
+  "color/val": THEME_COLOR,
+  "shd/color": THEME_COLOR,
+  "shd/fill": ["themeFill", "themeFillTint", "themeFillShade"],
+  "ind/left": ["leftChars"],
+  "ind/start": ["startChars"],
+  "ind/right": ["rightChars"],
+  "ind/end": ["endChars"],
+  "ind/hanging": ["hangingChars"],
+  "ind/firstLine": ["firstLineChars"],
+  "spacing/before": ["beforeLines"],
+  "spacing/after": ["afterLines"],
+  "top/color": THEME_COLOR,
+  "start/color": THEME_COLOR,
+  "left/color": THEME_COLOR,
+  "bottom/color": THEME_COLOR,
+  "end/color": THEME_COLOR,
+  "right/color": THEME_COLOR,
+  "insideH/color": THEME_COLOR,
+  "insideV/color": THEME_COLOR,
+  "tl2br/color": THEME_COLOR,
+  "tr2bl/color": THEME_COLOR
+};
+function overridingAttrs(element, name) {
+  return OVERRIDING_ATTRS[`${element}/${name}`] ?? NO_OVERRIDES;
+}
+function setAttr(attrs, element, name, value) {
+  return withAttr(
+    withoutAttrs(attrs, overridingAttrs(element, name)),
+    name,
+    value
+  );
+}
+export {
+  OVERRIDING_ATTRS,
+  overridingAttrs,
+  setAttr
+};

package/dist/ooxml/xml.d.ts

@@ -5,6 +5,14 @@ export declare const W_NS = "http://schemas.openxmlformats.org/wordprocessingml/
  * every relationship type name is built on
  */
 export declare const R_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+/**
+ * The prefixes whose meaning the editor depends on, and the namespace each one has to carry.
+ *
+ * Every element the writer spells out is a `w:` one, and the relationship a link or an image points
+ * at is named by `r:id` or `r:embed`, so a fragment that bound either prefix elsewhere would leave
+ * the writer's own markup meaning something else.
+ */
+export declare const RESERVED_PREFIXES: ReadonlyMap<string, string>;
 /** The name with its namespace prefix stripped off (`w:ascii` -> `ascii`) */
 export declare function localPart(name: string): string;
 /**
@@ -22,10 +30,33 @@ export declare function decodeUtf8(bytes: Uint8Array): {
 };
 export declare function encodeUtf8(text: string, withBom: boolean): Uint8Array;
 export declare function parseXml(source: string): Document;
+/**
+ * Gathers the namespace prefixes used in the fragment and declares them.
+ * Only `w` carries real meaning; the rest are placeholders that keep the parser from stopping.
+ * All we read are element names and `w:` attributes, so placeholders still let the values be read as they are.
+ *
+ * An attribute standing at the very start of the string counts too, since a fragment may be an
+ * attribute list of its own (`attrString`) rather than an element.
+ */
+export declare function namespaceDecls(xml: string): string;
 export declare function elementChildren(el: Element): Element[];
+/**
+ * The value of the attribute with this local name, whatever prefix it was written under.
+ *
+ * A document is free to bind the WordprocessingML namespace to a prefix of its own, so an
+ * attribute is looked up by the name it carries rather than by the spelling a producer chose.
+ */
+export declare function attributeByLocalName(el: Element, localName: string): string | null;
 export declare function childByLocalName(el: Element, name: string): Element | null;
 /** Turns an opening tag's attributes into an `a="b" c="d"` string */
 export declare function attrString(el: Element): string | null;
+/**
+ * Whether this node is an element.
+ *
+ * `Node` is a global a server is asked to install (`site/content/docs/core.mdx`); `Element` is
+ * not, so nothing here may reach for it at run time.
+ */
+export declare function isElement(node: Node): node is Element;
 /**
  * Turns a single element back into an XML string.
  *

package/dist/ooxml/xml.js

@@ -2,6 +2,10 @@
 import { DocxImportError } from "./errors.js";
 var W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
 var R_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+var RESERVED_PREFIXES = /* @__PURE__ */ new Map([
+  ["w", W_NS],
+  ["r", R_NS]
+]);
 function localPart(name) {
   const colon = name.indexOf(":");
   return colon === -1 ? name : name.slice(colon + 1);
@@ -42,9 +46,28 @@ function parseXml(source) {
   }
   return doc;
 }
+function namespaceDecls(xml) {
+  const prefixes = /* @__PURE__ */ new Set(["w"]);
+  for (const [, prefix] of xml.matchAll(/<\/?([A-Za-z_][\w.-]*):/g)) {
+    prefixes.add(prefix);
+  }
+  for (const [, prefix] of xml.matchAll(
+    /(?:^|[\s"'])([A-Za-z_][\w.-]*):[\w.-]+=/g
+  )) {
+    prefixes.add(prefix);
+  }
+  prefixes.delete("xml");
+  prefixes.delete("xmlns");
+  return Array.from(prefixes).map(
+    (prefix) => `xmlns:${prefix}="${prefix === "w" ? W_NS : `urn:docx-editor:${prefix}`}"`
+  ).join(" ");
+}
 function elementChildren(el) {
   return Array.from(el.children);
 }
+function attributeByLocalName(el, localName) {
+  return Array.from(el.attributes).find((entry) => entry.localName === localName)?.value ?? null;
+}
 function childByLocalName(el, name) {
   return elementChildren(el).find((child) => child.localName === name) ?? null;
 }
@@ -75,15 +98,19 @@ function serializeXml(el) {
   return inner ? `${open}>${inner}</${el.nodeName}>` : `${open}/>`;
 }
 export {
+  RESERVED_PREFIXES,
   R_NS,
   W_NS,
   attrString,
+  attributeByLocalName,
   childByLocalName,
   decodeUtf8,
   elementChildren,
   encodeUtf8,
   escapeXml,
+  isElement,
   localPart,
+  namespaceDecls,
   parseXml,
   serializeXml
 };

package/dist/page/blockKinds.d.ts

@@ -0,0 +1,42 @@
+/**
+ * What the page engine knows about a block, whatever shape of block it is.
+ *
+ * A measurer says where a block may be parted and how much of it has to fit on the page it
+ * starts on; the layout (`page/pageLayout`) answers with the places it decided to part it at.
+ * Neither side names a paragraph or a table.
+ */
+/** A place inside a block where the next page may, or must, start */
+export interface BreakCandidate {
+    /**
+     * The document position the continued piece starts at: a page `br` for a paragraph, a row for a
+     * table. A position maps through an edit, which is why the marks are kept by position and not
+     * by ordinal (see `page/pageDecorations`)
+     */
+    at: number;
+    /** The top of the continued piece, measured from the block's natural top with no space in it */
+    offset: number;
+    /** A forced candidate always cuts; an optional one cuts only when the piece after it would overflow */
+    forced: boolean;
+    /** Height the continued piece carries onto the next page ahead of its own content (a repeated header) */
+    repeatHeight: number;
+}
+/** One body block as drawn on screen */
+export interface MeasuredBlock {
+    /** The position where this block starts in the document */
+    pos: number;
+    /** The height that naturally opens up between the previous block and this one */
+    gap: number;
+    height: number;
+    /** The document records that a new page starts at this block */
+    breakBefore: boolean;
+    /** The block holds a break it cannot open a space at (inside a cell), so the next block starts a page */
+    breakAfter: boolean;
+    candidates: readonly BreakCandidate[];
+    /** The smallest piece that has to fit on the page the block starts on */
+    minFirstPiece: number;
+}
+/** A page cut the layout decided on: the space opened before the continued piece */
+export interface PageCut {
+    at: number;
+    height: number;
+}

package/dist/page/measureBlocks.d.ts

@@ -2,13 +2,21 @@
  * 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`), whatever
+ * shape of block it is: a page break for a paragraph, a safe row boundary for a table.
  * 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";
+/** What a table continuation still needs from the measurement to be drawn */
+export interface TableHeaderProjection {
+    headerRows: readonly number[];
+    headerSignature: string;
+    columns: number;
+}
 /**
  * The measurements taken in order to draw the page overlay. Positions are relative to
  * the overlay box
@@ -21,5 +29,10 @@ export interface SheetMeasure {
     contentTop: number;
     contentBottom: number;
     blocks: MeasuredBlock[];
+    /**
+     * The header facts of every table block, by the table's position, for the adapter that turns
+     * cuts back into table continuations (`page/usePageLayout`)
+     */
+    tables: ReadonlyMap<number, TableHeaderProjection>;
 }
 export declare function measureSheet(view: EditorView, layer: HTMLElement): SheetMeasure;

package/dist/page/measureBlocks.js

@@ -1,5 +1,6 @@
 // src/page/measureBlocks.ts
 import { editorAttributes } from "../styles/classNames.js";
+import { pageBreaksIn } from "./pageDecorations.js";
 import { measureTable } from "./tableMeasurements.js";
 var PAGE_BREAK_BR = `br[${editorAttributes.breakType}="page"]`;
 var BREAK_SPACE = `[${editorAttributes.pageBreakSpace}]`;
@@ -37,34 +38,52 @@ function measureSheet(view, layer) {
   const contentBottom = pixels(style.paddingBottom);
   const sheetY = (viewportY) => (viewportY - sheetRect.top) / scale;
   const blocks = [];
+  const tables = /* @__PURE__ */ new Map();
   let previousBottom = contentTop;
   let applied = 0;
-  let breakAfterPrevious = false;
   for (const { pos, dom } of drawnBlocks(view)) {
     const node = view.state.doc.nodeAt(pos);
     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 breaks = node ? pageBreaksIn(node, pos) : [];
     const spaces = Array.from(dom.querySelectorAll(BREAK_SPACE));
-    for (const space of spaces) {
+    const forced = [];
+    spaces.forEach((space, index) => {
       const box = space.getBoundingClientRect();
-      breaks.push(sheetY(box.top) - applied - top);
+      const found = breaks.at(index);
+      if (found) {
+        forced.push({
+          at: found.at,
+          offset: sheetY(box.top) - applied - top,
+          forced: true,
+          repeatHeight: 0
+        });
+      }
       applied += box.height / scale;
-    }
+    });
     applied += measuredTable?.appliedHeight ?? 0;
     const bottom = sheetY(rect.bottom) - applied;
+    const height = bottom - top;
+    if (measuredTable) {
+      tables.set(pos, {
+        headerRows: measuredTable.headerRows,
+        headerSignature: measuredTable.headerSignature,
+        columns: measuredTable.columns
+      });
+    }
     blocks.push({
       pos,
       gap: top - previousBottom,
-      height: bottom - top,
-      breakBefore: breakAfterPrevious || dom.hasAttribute(editorAttributes.pageBreakBefore),
-      breaks,
-      ...measuredTable ? { table: measuredTable.table } : {}
+      height,
+      breakBefore: dom.hasAttribute(editorAttributes.pageBreakBefore),
+      breakAfter: breakWithoutSpace(dom, spaces.length),
+      // A space is never opened inside a table, so at most one of the two lists holds anything
+      candidates: [...forced, ...measuredTable?.candidates ?? []],
+      minFirstPiece: measuredTable?.minFirstPiece ?? forced[0]?.offset ?? height
     });
     previousBottom = bottom;
-    breakAfterPrevious = breakWithoutSpace(dom, spaces.length);
   }
   return {
     left: (sheetRect.left - layerRect.left) / scale,
@@ -72,7 +91,8 @@ function measureSheet(view, layer) {
     width: sheetRect.width / scale,
     contentTop,
     contentBottom,
-    blocks
+    blocks,
+    tables
   };
 }
 export {

package/dist/page/pageDecorations.d.ts

@@ -5,6 +5,7 @@
  * The document model is left untouched, so no trace of them is left in
  * the exported XML or in the edit history.
  */
+import type { Node as PMNode } from "prosemirror-model";
 import { Plugin } from "prosemirror-state";
 import { DecorationSet, type EditorView } from "prosemirror-view";
 import type { BlockPush, BreakSpace, TableContinuation } from "./pageLayout";
@@ -26,6 +27,21 @@ interface PageMarks {
     tableContinuations: readonly TableContinuation[];
     decorations: DecorationSet;
 }
+/** One page break inside a block, where it stands and how much room the `br` itself takes */
+interface BreakAt {
+    at: number;
+    size: number;
+}
+/**
+ * Every page break inside this block, in document order.
+ * A space is put on the breaks of a top-level paragraph alone: inside a table cell it would grow
+ * the cell rather than the page, so a break there is left to the whole-block rule in
+ * `page/measureBlocks`, and none is found here.
+ *
+ * The measurement reads the same list to pair each space element it finds with the break it
+ * belongs to (`page/measureBlocks`).
+ */
+export declare function pageBreaksIn(block: PMNode, blockPos: number): BreakAt[];
 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;

package/dist/page/pageDecorations.js

@@ -204,6 +204,7 @@ function setTableContinuations(view, continuations) {
   );
 }
 export {
+  pageBreaksIn,
   pageDecorations,
   setPageBreakSpaces,
   setPagePushes,