@portone/docx-editor 0.2.0 → 0.3.0

package/dist/ooxml/units.d.ts

@@ -1,30 +1,42 @@
 import { type ParagraphAlign } from "../model/format";
+import { type HexColor } from "./simpleTypes";
 /** The alignment `w:jc` writes down, both for a paragraph and for a table */
 export declare const ALIGN_BY_JC: Record<string, ParagraphAlign>;
 /** A color as the document writes it, six hex digits and no `#`. Null for anything else */
 export declare function normalizeHex(value: string): string | null;
 export declare function wAttr(el: Element, name: string): string | null;
+/**
+ * Whether a boolean property element states on (§17.17.4).
+ *
+ * An element carrying no `w:val` states on, and one that is not there at all states nothing, which
+ * a caller asking "is this on" reads as off. For malformed values, this project uses the same
+ * fallback as an absent attribute. That recovery policy is not a schema or Word guarantee.
+ */
+export declare function isOnElement(el: Element | null): boolean;
 /** `<w:b/>` means on, `<w:b w:val="0"/>` means off */
 export declare function isOn(parent: Element, name: string): boolean;
 export declare function childValue(parent: Element, name: string): string | null;
-export declare function toNumber(value: string | null): number | null;
 /** Cuts off the messy digits after the decimal point so the same input always yields the same value */
 export declare function round(value: number): number;
 /** twip (1/20 of a point) */
-export declare function twipsToPt(value: string | null): number | null;
+export declare function twipsToPt(twips: number | null): number | null;
 /** half-point (w:sz 20 = 10pt) */
-export declare function halfPointsToPt(value: string | null): number | null;
-/** 1/8 of a point */
-export declare function eighthsToPt(value: string | null): number | null;
+export declare function halfPointsToPt(half: number | null): number | null;
+/** The color as CSS spells it. `auto` is not a color to paint with, so it reads as none */
 export declare function toHexColor(value: string | null): string | null;
-/**
- * Moves one border side into a CSS value.
- *
- * A side the document has pinned down as "draw no line here" becomes `none`.
- * A kind we do not know, or a side that is not there at all, becomes null, so the caller can pick a default.
- * A side that draws a line but writes down no thickness gets the default one: reading it as "no
- * line" would take away a line the style laid down.
- */
+/** One border side as `CT_Border` records it (§17.3.4) */
+export interface BorderLine {
+    /** ST_Border (§17.18.2). `none` states that this side draws nothing */
+    val: string;
+    /** The thickness, in eighths of a point */
+    eighths: number;
+    color: HexColor;
+}
+/** The CSS declaration one line is drawn with, and null for a line there is none of */
+export declare function borderLineCss(line: BorderLine | null): string | null;
+/** The line a CSS declaration this module wrote stands for, so no caller reads one back its own way */
+export declare function borderLineOfCss(css: string | null): BorderLine | null;
+/** Moves one border side into a CSS value */
 export declare function borderCss(el: Element | null): string | null;
 /** One side inside `w:tblBorders` or `w:tcBorders` */
 export declare function borderSide(borders: Element | null, side: string): string | null;

package/dist/ooxml/units.js

@@ -1,5 +1,13 @@
 // src/ooxml/units.ts
 import { NO_FILL } from "../model/format.js";
+import {
+  EIGHTHS_PER_PT,
+  HALF_POINTS_PER_PT,
+  ST_EighthPointMeasure,
+  ST_HexColor,
+  ST_OnOff,
+  TWIPS_PER_PT
+} from "./simpleTypes.js";
 import { childByLocalName, W_NS } from "./xml.js";
 var ALIGN_BY_JC = {
   left: "left",
@@ -17,39 +25,29 @@ function normalizeHex(value) {
 function wAttr(el, name) {
   return el.getAttributeNS(W_NS, name) ?? el.getAttribute(name);
 }
-function isOn(parent, name) {
-  const el = childByLocalName(parent, name);
+function isOnElement(el) {
   if (!el) return false;
-  const value = wAttr(el, "val");
-  return value === null || value === "1" || value === "true" || value === "on";
+  return ST_OnOff.parse(wAttr(el, "val")) ?? true;
+}
+function isOn(parent, name) {
+  return isOnElement(childByLocalName(parent, name));
 }
 function childValue(parent, name) {
   const el = childByLocalName(parent, name);
   return el ? wAttr(el, "val") : null;
 }
-function toNumber(value) {
-  if (value === null) return null;
-  const parsed = Number.parseFloat(value);
-  return Number.isFinite(parsed) ? parsed : null;
-}
 function round(value) {
   return Math.round(value * 100) / 100;
 }
-function twipsToPt(value) {
-  const twips = toNumber(value);
-  return twips === null ? null : round(twips / 20);
-}
-function halfPointsToPt(value) {
-  const half = toNumber(value);
-  return half === null ? null : round(half / 2);
+function twipsToPt(twips) {
+  return twips === null ? null : round(twips / TWIPS_PER_PT);
 }
-function eighthsToPt(value) {
-  const eighths = toNumber(value);
-  return eighths === null ? null : round(eighths / 8);
+function halfPointsToPt(half) {
+  return half === null ? null : round(half / HALF_POINTS_PER_PT);
 }
 function toHexColor(value) {
-  if (value === null || value === "auto") return null;
-  return /^[0-9a-fA-F]{6}$/.test(value) ? `#${value}` : null;
+  const color = ST_HexColor.parse(value);
+  return color?.kind === "rgb" ? `#${color.hex}` : null;
 }
 var BORDER_STYLE_BY_VAL = {
   single: "solid",
@@ -78,17 +76,52 @@ var BORDER_STYLE_BY_VAL = {
   dotDotDash: "dashed",
   dashDotStroked: "dashed"
 };
-var FALLBACK_BORDER_PT = 0.5;
-function borderCss(el) {
+var BORDER_VAL_BY_STYLE = {
+  solid: "single",
+  double: "double",
+  dashed: "dashed",
+  dotted: "dotted"
+};
+var FALLBACK_BORDER_EIGHTHS = 4;
+var DEFAULT_BORDER_CSS_COLOR = "#000000";
+var NO_LINE = {
+  val: "none",
+  eighths: 0,
+  color: { kind: "auto" }
+};
+function borderLineOf(el) {
   if (!el) return null;
   const val = wAttr(el, "val") ?? "";
-  if (val === "nil" || val === "none") return "none";
-  const style = BORDER_STYLE_BY_VAL[val];
+  if (val === "nil" || val === "none") return NO_LINE;
+  if (!BORDER_STYLE_BY_VAL[val]) return null;
+  const written = ST_EighthPointMeasure.parse(wAttr(el, "sz"));
+  return {
+    val,
+    eighths: written === null || written === 0 ? FALLBACK_BORDER_EIGHTHS : written,
+    color: ST_HexColor.parse(wAttr(el, "color")) ?? { kind: "auto" }
+  };
+}
+function borderLineCss(line) {
+  if (!line) return null;
+  if (line.val === "none") return "none";
+  const style = BORDER_STYLE_BY_VAL[line.val];
   if (!style) return null;
-  const written = eighthsToPt(wAttr(el, "sz"));
-  const widthPt = written === null || written === 0 ? FALLBACK_BORDER_PT : written;
-  const color = toHexColor(wAttr(el, "color")) ?? "#000000";
-  return `${widthPt}pt ${style} ${color}`;
+  const color = line.color.kind === "rgb" ? `#${line.color.hex}` : DEFAULT_BORDER_CSS_COLOR;
+  return `${round(line.eighths / EIGHTHS_PER_PT)}pt ${style} ${color}`;
+}
+var BORDER_CSS = /^(\d+(?:\.\d+)?)pt (solid|double|dashed|dotted) (#[0-9a-f]{6})$/i;
+function borderLineOfCss(css) {
+  if (css === null) return null;
+  if (css === "none") return NO_LINE;
+  const matched = BORDER_CSS.exec(css);
+  if (!matched) return null;
+  const eighths = Math.round(Number(matched[1]) * EIGHTHS_PER_PT);
+  const color = ST_HexColor.parse(matched[3].slice(1).toUpperCase());
+  if (eighths <= 0 || color === null) return null;
+  return { val: BORDER_VAL_BY_STYLE[matched[2].toLowerCase()], eighths, color };
+}
+function borderCss(el) {
+  return borderLineCss(borderLineOf(el));
 }
 function borderSide(borders, side) {
   return borders ? borderCss(childByLocalName(borders, side)) : null;
@@ -101,16 +134,17 @@ function shadingOf(parent) {
 export {
   ALIGN_BY_JC,
   borderCss,
+  borderLineCss,
+  borderLineOfCss,
   borderSide,
   childValue,
-  eighthsToPt,
   halfPointsToPt,
   isOn,
+  isOnElement,
   normalizeHex,
   round,
   shadingOf,
   toHexColor,
-  toNumber,
   twipsToPt,
   wAttr
 };

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;
 /**
@@ -21,11 +29,55 @@ export declare function decodeUtf8(bytes: Uint8Array): {
     hadBom: boolean;
 };
 export declare function encodeUtf8(text: string, withBom: boolean): Uint8Array;
+/**
+ * What reading a package part asks of a runtime: an XML string in, a document out.
+ *
+ * A browser's `DOMParser` is one, and so is a `DOMParser` from jsdom. The package ships none of
+ * them.
+ *
+ * Markup it cannot read may be answered either way a parser answers one: by handing back a
+ * document holding a `parsererror` element, or by throwing. Both are read as `malformed-xml`.
+ */
+export interface XmlParser {
+    parseFromString(source: string, type: "application/xml"): Document;
+}
+/**
+ * Runs `work` with every `parseXml` inside it reading through the one parser settled on here.
+ *
+ * Settling it at the boundary rather than at each read is what lets an entry point turn a runtime
+ * holding no parser down before it has read anything, instead of wherever the first part happens
+ * to be parsed; it also means one parser serves the whole call rather than a fresh `DOMParser`
+ * being built for every part.
+ *
+ * The public entry points are synchronous, so the scope covers exactly the work one of them does
+ * and nothing that runs after it. `undefined` keeps the enclosing scope's parser rather than
+ * clearing it, which is what lets an entry point opening a file through another one - the verifier
+ * running two imports - hand its own parser down without every inner call having to carry it.
+ */
+export declare function withXmlParser<T>(parser: XmlParser | undefined, work: () => T): T;
 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 */
+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);
@@ -32,19 +36,65 @@ function declaresDtd(source) {
     at = closes;
   }
 }
+var scopedParser;
+function resolveParser(parser) {
+  const named = parser ?? scopedParser;
+  if (named) return named;
+  if (typeof DOMParser === "function") return new DOMParser();
+  throw new DocxImportError(
+    "no-xml-parser",
+    "no XML parser: pass `xmlParser` or install a DOMParser global"
+  );
+}
+function withXmlParser(parser, work) {
+  const enclosing = scopedParser;
+  scopedParser = resolveParser(parser);
+  try {
+    return work();
+  } finally {
+    scopedParser = enclosing;
+  }
+}
 function parseXml(source) {
   if (declaresDtd(source)) {
     throw new DocxImportError("malformed-xml", "the XML declares a DTD");
   }
-  const doc = new DOMParser().parseFromString(source, "application/xml");
+  let doc;
+  try {
+    doc = resolveParser(void 0).parseFromString(source, "application/xml");
+  } catch (cause) {
+    if (cause instanceof DocxImportError) throw cause;
+    throw new DocxImportError("malformed-xml", "could not parse the XML", {
+      cause
+    });
+  }
   if (doc.getElementsByTagName("parsererror").length > 0) {
     throw new DocxImportError("malformed-xml", "could not parse the XML");
   }
   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;
 }
@@ -52,15 +102,19 @@ function attrString(el) {
   if (el.attributes.length === 0) return null;
   return Array.from(el.attributes).map((attr) => `${attr.name}="${escapeXml(attr.value)}"`).join(" ");
 }
+var ELEMENT_NODE = 1;
+var TEXT_NODE = 3;
+var CDATA_SECTION_NODE = 4;
+var COMMENT_NODE = 8;
 function isElement(node) {
-  return node.nodeType === Node.ELEMENT_NODE;
+  return node.nodeType === ELEMENT_NODE;
 }
 function serializeChildNode(node) {
   if (isElement(node)) return serializeXml(node);
-  if (node.nodeType === Node.TEXT_NODE || node.nodeType === Node.CDATA_SECTION_NODE) {
+  if (node.nodeType === TEXT_NODE || node.nodeType === CDATA_SECTION_NODE) {
     return escapeXml(node.nodeValue ?? "");
   }
-  if (node.nodeType === Node.COMMENT_NODE) {
+  if (node.nodeType === COMMENT_NODE) {
     return `<!--${node.nodeValue ?? ""}-->`;
   }
   throw new DocxImportError(
@@ -75,15 +129,20 @@ 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
+  serializeXml,
+  withXmlParser
 };

package/dist/page/blockKinds.d.ts

@@ -0,0 +1,103 @@
+/**
+ * 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.
+ *
+ * Which measurer a block gets, and what draws the cuts it was given, is the block's kind
+ * (`page/kinds`).
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import type { Decoration, EditorView } from "prosemirror-view";
+/** 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;
+    /** The document asks for this block to stand on the same page as the start of the block after it */
+    keepWithNext: boolean;
+}
+/** 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 */
+export interface MeasureTarget {
+    view: EditorView;
+    node: PMNode;
+    pos: number;
+    dom: HTMLElement;
+    /**
+     * Sheet coordinates from viewport coordinates: the visual scale taken out, and everything the
+     * engine has opened up above this block taken back off
+     */
+    sheetY(viewportY: number): number;
+    /** The block's natural top: pushes and spaces opened above it already taken back off */
+    top: number;
+    /** The visual scale the sheet is drawn at, which a length read off the screen is divided by */
+    scale: number;
+}
+/** What a kind has to say about the block it measured */
+export interface KindMeasure {
+    candidates: readonly BreakCandidate[];
+    /** The smallest piece that has to fit on the page the block starts on */
+    minFirstPiece: number;
+    /** The block holds a break it could not open a space at, so the next block starts a page */
+    breakAfter: boolean;
+    /** Height the engine's own marks add inside this block, taken off its measured bottom */
+    appliedHeight: 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
+     */
+    keepWithNext?: boolean;
+}
+/**
+ * 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.
+ */
+export interface BlockKind {
+    readonly name: string;
+    matches(node: PMNode): boolean;
+    measure(target: MeasureTarget): KindMeasure;
+    /** Whether `at` still names a place this kind can cut at in `doc`; a false drops the cut */
+    holdsCut(doc: PMNode, at: number): boolean;
+    /**
+     * The decorations one block of this kind carries: the cuts the layout gave it, plus whatever it
+     * needs before any measurement (a paragraph puts an empty space on every page `br`, so the
+     * measurement has an element to read it off).
+     */
+    decorate(pos: number, node: PMNode, cuts: readonly PageCut[], into: Decoration[]): void;
+}
+/** The first kind whose `matches` answers. The kind registered last has to match every block */
+export declare function blockKindFor(kinds: readonly BlockKind[], node: PMNode): BlockKind;

package/dist/page/blockKinds.js

@@ -0,0 +1,11 @@
+// src/page/blockKinds.ts
+function blockKindFor(kinds, node) {
+  const found = kinds.find((kind) => kind.matches(node));
+  if (!found) {
+    throw new Error(`no block kind matches a ${node.type.name} block`);
+  }
+  return found;
+}
+export {
+  blockKindFor
+};

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

@@ -0,0 +1,6 @@
+import type { BlockKind } from "../blockKinds";
+/**
+ * The block shapes the editor pages, in the order they are asked. A new kind goes ahead of the
+ * kinds it is narrower than, and the last one claims every block none of the others did.
+ */
+export declare const DEFAULT_BLOCK_KINDS: readonly BlockKind[];

package/dist/page/kinds/index.js

@@ -0,0 +1,10 @@
+// src/page/kinds/index.ts
+import { paragraphKind } from "./paragraphKind.js";
+import { tableKind } from "./tableKind.js";
+var DEFAULT_BLOCK_KINDS = [
+  tableKind,
+  paragraphKind
+];
+export {
+  DEFAULT_BLOCK_KINDS
+};

package/dist/page/kinds/paragraphKind.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The kind every block falls back to: a paragraph, and any other shape no kind ahead of it claims.
+ *
+ * A page `br` is the one place a paragraph is parted at, and the space opened at it is what the
+ * measurement reads the break's place off, so every `br` carries a space of its own before
+ * anything is measured. A break standing where no space can be opened - inside a table cell,
+ * where it would grow the cell rather than the page - is answered by the whole block instead.
+ */
+import type { BlockKind } from "../blockKinds";
+export declare const paragraphKind: BlockKind;

package/dist/page/kinds/paragraphKind.js

@@ -0,0 +1,71 @@
+// src/page/kinds/paragraphKind.ts
+import { Decoration } from "prosemirror-view";
+import { toParagraphFormat } from "../../model/format.js";
+import { docxSchema, isPageBreak } from "../../schema/index.js";
+import { editorAttributes } from "../../styles/classNames.js";
+var PAGE_BREAK_BR = `br[${editorAttributes.breakType}="page"]`;
+var BREAK_SPACE = `[${editorAttributes.pageBreakSpace}]`;
+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;
+}
+var paragraphKind = {
+  name: "paragraph",
+  matches: () => true,
+  measure({ node, pos, dom, sheetY, top, scale }) {
+    const breaks = pageBreaksIn(node, pos);
+    const candidates = [];
+    let appliedHeight = 0;
+    dom.querySelectorAll(BREAK_SPACE).forEach((space, index) => {
+      const box = space.getBoundingClientRect();
+      const found = breaks.at(index);
+      if (found) {
+        candidates.push({
+          at: found.at,
+          offset: sheetY(box.top) - appliedHeight - top,
+          forced: true,
+          repeatHeight: 0
+        });
+      }
+      appliedHeight += box.height / scale;
+    });
+    return {
+      candidates,
+      minFirstPiece: candidates[0]?.offset ?? dom.getBoundingClientRect().height / scale - appliedHeight,
+      // A break with no space of its own sits somewhere the space could not be opened. Those
+      // still start a new page, but only after the whole block
+      breakAfter: dom.querySelectorAll(PAGE_BREAK_BR).length > candidates.length,
+      appliedHeight,
+      keepWithNext: toParagraphFormat(node.attrs.format)?.keepNext === true
+    };
+  },
+  holdsCut: (doc, at) => isPageBreakNode(doc.nodeAt(at)),
+  decorate(pos, node, cuts, into) {
+    const heights = new Map(cuts.map((cut) => [cut.at, cut.height]));
+    for (const { at, size } of pageBreaksIn(node, pos)) {
+      const height = heights.get(at) ?? 0;
+      into.push(
+        Decoration.inline(at, at + size, {
+          nodeName: "span",
+          style: spaceStyle(height),
+          [editorAttributes.pageBreakSpace]: `${height}`
+        })
+      );
+    }
+  }
+};
+export {
+  paragraphKind
+};

package/dist/page/kinds/tableKind.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The kind of a table: it is parted between rows, and a continued page opens a spacer row and
+ * repeats the headers the table opens with.
+ *
+ * Both sides read the table as it stands on screen without treating the rows this very engine
+ * drew as content: the measurement takes their heights back off, and the projection is derived
+ * again from the document, so an edit to a header row redraws it with nothing measured anew.
+ */
+import type { BlockKind } from "../blockKinds";
+export declare const tableKind: BlockKind;