@portone/docx-editor 0.2.1 → 0.3.0

package/dist/ooxml/tagScan.js

@@ -0,0 +1,108 @@
+// src/ooxml/tagScan.ts
+function skipPast(source, from, marker) {
+  const at = source.indexOf(marker, from);
+  return at === -1 ? -1 : at + marker.length;
+}
+function otherTag(end) {
+  return end === -1 ? null : { kind: "other", name: "", nameEnd: end, end };
+}
+function readTag(source, lt) {
+  if (source.startsWith("<?", lt)) return otherTag(skipPast(source, lt, "?>"));
+  if (source.startsWith("<!--", lt))
+    return otherTag(skipPast(source, lt, "-->"));
+  if (source.startsWith("<![CDATA[", lt))
+    return otherTag(skipPast(source, lt, "]]>"));
+  if (source.startsWith("<!", lt)) return otherTag(skipPast(source, lt, ">"));
+  const closing = source.startsWith("</", lt);
+  let i = lt + (closing ? 2 : 1);
+  const nameStart = i;
+  while (i < source.length && !" 	\r\n/>".includes(source[i])) i += 1;
+  const name = source.slice(nameStart, i);
+  if (!name) return null;
+  const nameEnd = i;
+  let quote = null;
+  while (i < source.length) {
+    const ch = source[i];
+    if (quote !== null) {
+      if (ch === quote) quote = null;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    } else if (ch === ">") {
+      const selfClosing = source[i - 1] === "/";
+      const kind = closing ? "close" : selfClosing ? "empty" : "open";
+      return { kind, name, nameEnd, end: i + 1 };
+    }
+    i += 1;
+  }
+  return null;
+}
+function rootTagAt(xml) {
+  let at = 0;
+  for (; ; ) {
+    const lt = xml.indexOf("<", at);
+    if (lt === -1) return -1;
+    const tag = readTag(xml, lt);
+    if (!tag) return -1;
+    if (tag.kind !== "other") return lt;
+    at = tag.end;
+  }
+}
+var ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'"
+};
+var HIGHEST_CODE_POINT = 1114111;
+function referenceText(name) {
+  const named = ENTITIES[name];
+  if (named !== void 0) return named;
+  const numeric = /^#(?:[xX]([0-9a-fA-F]+)|(\d+))$/.exec(name);
+  if (!numeric) return null;
+  const [, hex, decimal] = numeric;
+  const code = Number.parseInt(hex ?? decimal, hex === void 0 ? 10 : 16);
+  if (code > HIGHEST_CODE_POINT || code >= 55296 && code <= 57343) {
+    return null;
+  }
+  return String.fromCodePoint(code);
+}
+function decodeReferences(value) {
+  if (!value.includes("&")) return value;
+  let decoded = "";
+  let at = 0;
+  for (; ; ) {
+    const amp = value.indexOf("&", at);
+    if (amp === -1) return decoded + value.slice(at);
+    const semicolon = value.indexOf(";", amp);
+    if (semicolon === -1) return null;
+    const text = referenceText(value.slice(amp + 1, semicolon));
+    if (text === null) return null;
+    decoded += value.slice(at, amp) + text;
+    at = semicolon + 1;
+  }
+}
+var ATTRIBUTE = /(\s*)([^\s=/><"']+)\s*=\s*(?:"([^"<]*)"|'([^'<]*)')/y;
+function parseAttrs(raw) {
+  const attrs = [];
+  const names = /* @__PURE__ */ new Set();
+  let at = 0;
+  for (; ; ) {
+    ATTRIBUTE.lastIndex = at;
+    const matched = ATTRIBUTE.exec(raw);
+    if (!matched) return raw.slice(at).trim() === "" ? attrs : null;
+    const [, separator, name, doubled, singled] = matched;
+    if (at > 0 && separator === "") return null;
+    if (names.has(name)) return null;
+    names.add(name);
+    const value = decodeReferences(doubled ?? singled);
+    if (value === null) return null;
+    attrs.push([name, value]);
+    at = ATTRIBUTE.lastIndex;
+  }
+}
+export {
+  parseAttrs,
+  readTag,
+  rootTagAt
+};

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

@@ -29,6 +29,32 @@ 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.
@@ -50,12 +76,7 @@ export declare function attributeByLocalName(el: Element, localName: string): st
 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.
- */
+/** 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

@@ -36,11 +36,38 @@ 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");
   }
@@ -75,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(
@@ -112,5 +143,6 @@ export {
   localPart,
   namespaceDecls,
   parseXml,
-  serializeXml
+  serializeXml,
+  withXmlParser
 };

package/dist/page/blockKinds.d.ts

@@ -4,7 +4,12 @@
  * 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 {
     /**
@@ -34,9 +39,65 @@ export interface MeasuredBlock {
     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;