@portone/docx-editor 0.1.1 → 0.2.1

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,

package/dist/page/pageLayout.d.ts

@@ -10,6 +10,8 @@
  * document breaks at Letter's height and fits its tables to Letter's width.
  */
 import { type PageGeometry } from "../docx/pageGeometry";
+import type { MeasuredBlock, PageCut } from "./blockKinds";
+export type { MeasuredBlock };
 /** The paper measured in the pixels the sheet is drawn with */
 export interface PagePixels {
     /** The whole sheet, padding included */
@@ -45,44 +47,6 @@ export declare const A4_PAGE_PIXELS: PagePixels;
  * moment before a document is opened.
  */
 export declare function pageGeometryStyle(page: PagePixels): string;
-/** 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;
-    /** Set when the document records that a new page starts at this block */
-    breakBefore: boolean;
-    /**
-     * Every page break inside the block, in document order, each measured from the block's own top
-     * so that the block can be laid out wherever it lands.
-     * That top is the one the block would be drawn at with no space in it, so a space opened at one
-     * break shifts the ones after it.
-     */
-    breaks: readonly number[];
-    /** Row boundaries available when this block is an editable table */
-    table?: MeasuredTable;
-}
-/** A row that may start the continued part of a table */
-export interface TableBoundary {
-    /** The row's document position */
-    pos: number;
-    /** Its top measured from the table's natural top */
-    offset: number;
-}
-/** The measurements needed to continue a table without changing the document */
-export interface MeasuredTable {
-    boundaries: readonly TableBoundary[];
-    /** The smallest useful first piece: headers followed by one body row group */
-    firstPageMinimum: number;
-    repeatHeaderHeight: number;
-    /** Document positions of the contiguous header rows at the start of the table */
-    headerRows: readonly number[];
-    /** Changes when any projected header content or formatting changes */
-    headerSignature: string;
-    columns: number;
-}
 /** The space opened up at one page break, so that what follows it starts the next page */
 export interface BreakSpace {
     /** The position where the block holding the break starts */
@@ -148,8 +112,8 @@ export interface PageStart {
 export interface PageLayout {
     /** Only the blocks to be moved down to the next page */
     pushes: BlockPush[];
-    spaces: BreakSpace[];
-    tableContinuations: TableContinuation[];
+    /** Where the layout parted a block, and the space it opened before the continued piece */
+    cuts: PageCut[];
     splits: PageSplit[];
     /** One per page, the first page included */
     pages: PageStart[];
@@ -169,8 +133,9 @@ export interface PageLayoutInput {
  * blocks below it move down by the same amount.
  * A block taller than one page cannot be pushed, so it is left where it is and only the
  * places it crosses are reported.
- * A page break inside a block is filled out to the end of the page it falls on, which carries
- * the rest of that block - the rest of the sentence, the rest of the list item - to the top of
- * the next page while the block itself stays whole.
+ * A block is parted only where its measurer offered a candidate. A forced one - a page break
+ * written into the text - is filled out to the end of the page it falls on, which carries the rest
+ * of that block to the top of the next page while the block itself stays whole. An optional one -
+ * a row boundary in a table - is taken only where the piece after it would run off the page.
  */
 export declare function pageLayout({ blocks, pageBodyHeight, pageStep, }: PageLayoutInput): PageLayout;

package/dist/page/pageLayout.js

@@ -47,8 +47,7 @@ function pageLayout({
   pageStep
 }) {
   const pushes = [];
-  const spaces = [];
-  const tableContinuations = [];
+  const cuts = [];
   const splits = [];
   const firstPage = {
     page: 1,
@@ -58,14 +57,7 @@ function pageLayout({
   };
   const pages = [firstPage];
   if (!(pageBodyHeight > 0)) {
-    return {
-      pushes,
-      spaces,
-      tableContinuations,
-      splits,
-      pages,
-      bodyHeight: 0
-    };
+    return { pushes, cuts, splits, pages, bodyHeight: 0 };
   }
   let pageStart = 0;
   let cursor = 0;
@@ -82,11 +74,12 @@ function pageLayout({
       split(pageStart + pageBodyHeight, true, false);
     }
   };
+  let breakAfterPrevious = false;
   for (const block of blocks) {
     const pageEnd = pageStart + pageBodyHeight;
     const top = cursor + block.gap;
-    const startsPage = block.breakBefore && top > pageStart + TOLERANCE_PX;
-    const first = block.breaks[0] ?? block.table?.firstPageMinimum ?? block.height;
+    const startsPage = (block.breakBefore || breakAfterPrevious) && top > pageStart + TOLERANCE_PX;
+    const first = block.minFirstPiece;
     const overflows = top + first > pageEnd + TOLERANCE_PX;
     const fits = first <= pageBodyHeight + TOLERANCE_PX;
     const push = startsPage || overflows && fits ? Math.max(0, pageEnd + pageStep - top) : 0;
@@ -98,51 +91,35 @@ function pageLayout({
         push: round(push)
       });
     }
-    let contentTop = top + push;
-    for (const [index, offset] of block.breaks.entries()) {
-      const breakY = contentTop + offset;
-      crossTo(breakY);
-      split(pageStart + pageBodyHeight, false, true);
-      const height = Math.max(0, pageStart - breakY);
-      spaces.push({ pos: block.pos, index, height: round(height) });
-      contentTop += height;
-    }
-    let tableAdded = 0;
-    if (block.table) {
-      let segmentStart = 0;
-      for (let index = 0; index <= block.table.boundaries.length; index += 1) {
-        const segmentEnd = block.table.boundaries[index]?.offset ?? block.height;
-        const segmentTop = contentTop + segmentStart + tableAdded;
-        let segmentBottom = contentTop + segmentEnd + tableAdded;
-        const pageEnd2 = pageStart + pageBodyHeight;
-        const overflows2 = segmentBottom > pageEnd2 + TOLERANCE_PX;
-        const boundary = index === 0 ? null : block.table.boundaries[index - 1];
-        const segmentHeight = segmentEnd - segmentStart;
-        if (overflows2 && boundary && segmentTop > pageStart + TOLERANCE_PX && segmentHeight <= pageBodyHeight + TOLERANCE_PX) {
-          split(pageEnd2, false, false);
-          const height = Math.max(0, pageStart - segmentTop);
-          tableContinuations.push({
-            pos: boundary.pos,
-            height: round(height),
-            headerRows: block.table.headerRows,
-            headerSignature: block.table.headerSignature,
-            columns: block.table.columns
-          });
-          tableAdded += height + block.table.repeatHeaderHeight;
-          segmentBottom = contentTop + segmentEnd + tableAdded;
+    const contentTop = top + push;
+    let added = 0;
+    let pieceStart = 0;
+    for (let index = 0; index <= block.candidates.length; index += 1) {
+      const cut = index === 0 ? null : block.candidates[index - 1];
+      const pieceEnd = block.candidates[index]?.offset ?? block.height;
+      const pieceTop = contentTop + pieceStart + added;
+      let pieceBottom = contentTop + pieceEnd + added;
+      if (cut) {
+        if (cut.forced) crossTo(pieceTop);
+        const pageBottom = pageStart + pageBodyHeight;
+        const cutHere = cut.forced || pieceBottom > pageBottom + TOLERANCE_PX && pieceTop > pageStart + TOLERANCE_PX && pieceEnd - pieceStart <= pageBodyHeight + TOLERANCE_PX;
+        if (cutHere) {
+          split(pageBottom, false, cut.forced);
+          const height = Math.max(0, pageStart - pieceTop);
+          cuts.push({ at: cut.at, height: round(height) });
+          added += height + cut.repeatHeight;
+          pieceBottom += height + cut.repeatHeight;
         }
-        crossTo(segmentBottom);
-        segmentStart = segmentEnd;
       }
+      crossTo(pieceBottom);
+      pieceStart = pieceEnd;
     }
-    const bottom = contentTop + block.height + tableAdded;
-    crossTo(bottom);
-    cursor = bottom;
+    cursor = contentTop + block.height + added;
+    breakAfterPrevious = block.breakAfter;
   }
   return {
     pushes,
-    spaces,
-    tableContinuations,
+    cuts,
     splits,
     pages,
     bodyHeight: round(pageStart + pageBodyHeight)

package/dist/page/tableMeasurements.d.ts

@@ -1,10 +1,18 @@
 /** Measures safe row boundaries without treating pagination decorations as document content. */
 import type { Node as PMNode } from "prosemirror-model";
 import type { EditorView } from "prosemirror-view";
-import type { MeasuredTable } from "./pageLayout";
+import type { BreakCandidate } from "./blockKinds";
 export interface TableMeasure {
-    table: MeasuredTable;
+    /** Every row that may start the continued part of the table */
+    candidates: readonly BreakCandidate[];
+    /** The smallest useful first piece: headers followed by one body row group */
+    minFirstPiece: number;
     /** Height already added by the previous pagination pass */
     appliedHeight: number;
+    /** Document positions of the contiguous header rows at the start of the table */
+    headerRows: readonly number[];
+    /** Changes when any projected header content or formatting changes */
+    headerSignature: string;
+    columns: number;
 }
 export declare function measureTable(view: EditorView, tableNode: PMNode, tablePos: number, tableDom: HTMLElement, scale?: number): TableMeasure | null;

package/dist/page/tableMeasurements.js

@@ -81,33 +81,37 @@ function measureTable(view, tableNode, tablePos, tableDom, scale = 1) {
   if (rows.length === 0) return null;
   const headers = headerCount(rows);
   const unsafe = unsafeBoundaries(rows);
-  const boundaries = [];
+  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)) {
-      boundaries.push({ pos: row.pos, offset: row.top });
+      candidates.push({
+        at: row.pos,
+        offset: row.top,
+        forced: false,
+        repeatHeight: repeatHeaderHeight
+      });
     }
   }
-  const repeatHeaderHeight = rows.slice(0, headers).reduce((total, row) => total + row.height, 0);
-  const firstBodyBoundary = boundaries.find(
-    (boundary) => boundary.offset > repeatHeaderHeight + 0.5
+  const firstBodyBoundary = candidates.find(
+    (candidate) => candidate.offset > repeatHeaderHeight + 0.5
   );
   const appliedHeight = appliedRows.reduce(
     (total, row) => total + row.getBoundingClientRect().height / scale,
     0
   );
   return {
-    table: {
-      boundaries,
-      firstPageMinimum: firstBodyBoundary?.offset ?? tableDom.getBoundingClientRect().height / scale - appliedHeight,
-      repeatHeaderHeight,
-      headerRows: rows.slice(0, headers).map((row) => row.pos),
-      headerSignature: JSON.stringify(
-        rows.slice(0, headers).map((row) => row.node.toJSON())
-      ),
-      columns: columnCount(tableNode)
-    },
-    appliedHeight
+    candidates,
+    minFirstPiece: firstBodyBoundary?.offset ?? tableDom.getBoundingClientRect().height / scale - appliedHeight,
+    appliedHeight,
+    headerRows: headerRows.map((row) => row.pos),
+    headerSignature: JSON.stringify(headerRows.map((row) => row.node.toJSON())),
+    columns: columnCount(tableNode)
   };
 }
 export {

package/dist/page/usePageLayout.d.ts

@@ -8,9 +8,13 @@
  * in Japanese or Chinese stays open across a whole clause while the text grows line by line. So no
  * measurement is taken while a composition is open: the frame is taken again until it is over.
  */
+import type { Node as PMNode } from "prosemirror-model";
 import type { EditorView } from "prosemirror-view";
 import { type RefObject } from "react";
 import type { PageGeometry } from "../docx/pageGeometry";
+import type { PageCut } from "./blockKinds";
+import { type TableHeaderProjection } from "./measureBlocks";
+import { type BreakSpace, type TableContinuation } from "./pageLayout";
 /** One place where a page parts from the next. The position is measured on the sheet */
 export interface PageMark {
     page: number;
@@ -53,5 +57,16 @@ interface PageLayoutOptions {
     /** The paper the open document names. A4 where a document names none */
     geometry?: PageGeometry;
 }
+/**
+ * The layout's cuts as the two kinds of mark the decorations still take.
+ *
+ * A cut names the position the continued piece starts at, and which of the two it is follows from
+ * what stands there: a page `br` the block it sits in counted, or a table row. This stands in
+ * until the decorations take the cuts themselves.
+ */
+export declare function cutsToLegacyMarks(cuts: readonly PageCut[], tables: ReadonlyMap<number, TableHeaderProjection>, doc: PMNode): {
+    spaces: BreakSpace[];
+    tableContinuations: TableContinuation[];
+};
 export declare function usePageLayout({ view, layer, enabled, revision, geometry, }: PageLayoutOptions): PageOverlay | null;
 export {};