@portone/docx-editor 0.4.0 → 0.5.1

package/dist/page/pageLayout.d.ts

@@ -7,9 +7,17 @@
  * the places where Word actually breaks may differ.
  *
  * The size of a page is the document's own (`docx/pageGeometry`), not a fixed A4: a Letter
- * document breaks at Letter's height and fits its tables to Letter's width.
+ * document breaks at Letter's height and fits its tables to Letter's width. A document written in
+ * several sections breaks each block at the height of the section that block sits in
+ * (`docx/sections`), and a section opens a page of its own unless it declares `continuous`, which
+ * carries it on down the page the section before it ends on.
+ *
+ * The width is the exception: one sheet is drawn at one width (`styles/editor.css`), which is the
+ * first section's, so a section on wider paper is paginated on its own height but drawn on the
+ * paper the sheet holds.
  */
 import { type PageGeometry } from "../docx/pageGeometry";
+import type { DocumentSection, SectionProperties } from "../docx/sections";
 import type { MeasuredBlock, PageCut } from "./blockKinds";
 export type { MeasuredBlock };
 /** The paper measured in the pixels the sheet is drawn with */
@@ -39,6 +47,35 @@ export declare const PAGE_SPLIT_PX = 24;
 export declare function pagePixels(geometry: PageGeometry): PagePixels;
 /** The paper a document that names none is drawn on */
 export declare const A4_PAGE_PIXELS: PagePixels;
+/** The paper one section of a document is laid out on */
+export interface SectionPixels {
+    /**
+     * The last position this section covers. A section is closed by the paragraph carrying its
+     * `w:sectPr` (§17.6.17), so the block after that one opens the section that follows, and the
+     * section the body itself closes reaches past every block.
+     */
+    untilPos: number;
+    pixels: PagePixels;
+    /**
+     * How this section starts (§17.6.22). `continuous` carries it on down the page the section
+     * before it ends on; every other kind opens a page.
+     */
+    type: SectionProperties["type"];
+}
+/** The one section a document naming none is laid out on */
+export declare const A4_SECTION_PIXELS: readonly SectionPixels[];
+/**
+ * The paper of every section of a document, in the pixels the sheet is drawn with.
+ *
+ * Reading the sections walks every block (`docx/sections`), so this runs once per document change
+ * rather than once per measurement.
+ */
+export declare function sectionPixels(sections: readonly DocumentSection[]): SectionPixels[];
+/**
+ * The paper the block at this position is laid out on, which is the paper of every page that
+ * block stands on. A4 where the list names no section at all.
+ */
+export declare function sectionPaperAt(sections: readonly SectionPixels[], pos: number): PagePixels;
 /**
  * The paper the document names, as the CSS variables the sheet is drawn from.
  *
@@ -74,6 +111,17 @@ export interface PageStart {
     page: number;
     /** Where this page's body starts, measured from the top of the body */
     bodyStart: number;
+    /**
+     * The position of the block this page opens with, which is the block the text crossing into it
+     * belongs to. 0 for a document holding no block at all
+     */
+    pos: number;
+    /**
+     * The place this page takes within its own section, counted from 1 again at every section it
+     * opens. A document read with no section table at all is one section, so this counts the whole
+     * of it
+     */
+    pageInSection: number;
     /**
      * Whether text crosses over from the previous page, so this page continues with no top
      * margin
@@ -90,12 +138,21 @@ export interface PageLayout {
     pages: PageStart[];
     /** The body height with the last page filled out in full */
     bodyHeight: number;
+    /**
+     * The margin under that last page, which is its own section's. The sheet is padded from the
+     * first section's paper alone (`editor/createEditor`), so a document ending on a deeper bottom
+     * margin needs the sheet drawn down to this.
+     */
+    marginBottom: number;
 }
 export interface PageLayoutInput {
     blocks: readonly MeasuredBlock[];
-    pageBodyHeight: number;
-    /** From the end of the previous page's body to the top of the next page's body */
-    pageStep: number;
+    /**
+     * The paper of each section in document order (`sectionPixels`). A block is laid out on the
+     * paper of the section it sits in, and the section a block opens starts a page of its own
+     * unless that section is `continuous`.
+     */
+    sections: readonly SectionPixels[];
 }
 /**
  * Distributes the blocks across pages.
@@ -110,5 +167,7 @@ export interface PageLayoutInput {
  * a row boundary in a table - is taken only where the piece after it would run off the page.
  * A block kept with the next one is pushed together with what it is kept with: the blocks kept
  * after it and the first piece of the block the keeps end at.
+ * Each block is measured against the paper of its own section, and the first block of a section
+ * opens a page of its own unless the section it opens declares `continuous`.
  */
-export declare function pageLayout({ blocks, pageBodyHeight, pageStep, }: PageLayoutInput): PageLayout;
+export declare function pageLayout({ blocks, sections }: PageLayoutInput): PageLayout;

package/dist/page/pageLayout.js

@@ -24,6 +24,23 @@ function pagePixels(geometry) {
   };
 }
 var A4_PAGE_PIXELS = pagePixels(A4_PORTRAIT);
+var A4_SECTION_PIXELS = [
+  { untilPos: Number.POSITIVE_INFINITY, pixels: A4_PAGE_PIXELS, type: null }
+];
+function sectionPixels(sections) {
+  return sections.map(({ anchor, props }) => ({
+    untilPos: anchor.kind === "paragraph" ? anchor.pos : Number.POSITIVE_INFINITY,
+    pixels: pagePixels(props.geometry),
+    type: props.type
+  }));
+}
+function sectionIndexAt(sections, pos) {
+  const reaching = sections.findIndex((section) => pos <= section.untilPos);
+  return reaching === -1 ? sections.length - 1 : reaching;
+}
+function sectionPaperAt(sections, pos) {
+  return sections[sectionIndexAt(sections, pos)]?.pixels ?? A4_PAGE_PIXELS;
+}
 function px(value) {
   return `${Math.round(value * 100) / 100}px`;
 }
@@ -41,15 +58,29 @@ var TOLERANCE_PX = 0.5;
 function round(value) {
   return Math.round(value * 100) / 100;
 }
-function keepsWithNext(block, next) {
-  return block.keepWithNext && block.candidates.length === 0 && !block.breakAfter && !next.breakBefore;
+function withinSections(pages, sections) {
+  let section = null;
+  let within = 0;
+  return pages.map((page) => {
+    const index = sectionIndexAt(sections, page.pos);
+    within = index === section ? within + 1 : 1;
+    section = index;
+    return { ...page, pageInSection: within };
+  });
 }
-function keptExtents(blocks, fitsPage) {
+function keepsWithNext(block, next, opensPage) {
+  return block.keepWithNext && !opensPage && block.candidates.length === 0 && !block.breakAfter && !next.breakBefore;
+}
+function keptExtents(blocks, laid) {
+  const fitsPage = (extent, index) => {
+    const height = laid[index]?.paper.bodyHeight ?? 0;
+    return extent <= height + TOLERANCE_PX;
+  };
   const extents = /* @__PURE__ */ new Map();
   let run = [];
   const settle = () => {
     const head = run.at(-1);
-    if (head && fitsPage(head.extent)) {
+    if (head && fitsPage(head.extent, head.index)) {
       for (const { index, extent } of run) {
         extents.set(index, extent);
       }
@@ -59,7 +90,8 @@ function keptExtents(blocks, fitsPage) {
   for (let index = blocks.length - 2; index >= 0; index -= 1) {
     const block = blocks[index];
     const next = blocks[index + 1];
-    if (block && next && keepsWithNext(block, next)) {
+    const opensPage = laid[index + 1]?.opensPage === true;
+    if (block && next && keepsWithNext(block, next, opensPage)) {
       const below = run.at(-1)?.extent ?? next.minFirstPiece;
       run.push({ index, extent: block.height + next.gap + below });
     } else {
@@ -69,44 +101,67 @@ function keptExtents(blocks, fitsPage) {
   settle();
   return extents;
 }
-function pageLayout({
-  blocks,
-  pageBodyHeight,
-  pageStep
-}) {
+function pageLayout({ blocks, sections }) {
   const pushes = [];
   const cuts = [];
   const splits = [];
-  const firstPage = { page: 1, bodyStart: 0, crossed: false };
-  const pages = [firstPage];
-  if (!(pageBodyHeight > 0)) {
-    return { pushes, cuts, splits, pages, bodyHeight: 0 };
+  let blockPos = blocks[0]?.pos ?? 0;
+  const opened = [
+    { page: 1, bodyStart: 0, pos: blockPos, crossed: false }
+  ];
+  const roomy = sections.find(
+    (section) => section.pixels.bodyHeight > 0
+  )?.pixels;
+  if (roomy === void 0) {
+    return {
+      pushes,
+      cuts,
+      splits,
+      pages: withinSections(opened, sections),
+      bodyHeight: 0,
+      marginBottom: 0
+    };
   }
+  const blockSections = blocks.map(
+    (block) => sectionIndexAt(sections, block.pos)
+  );
+  const laid = blockSections.map((section, index) => {
+    const pixels = sections[section]?.pixels;
+    return {
+      paper: pixels && pixels.bodyHeight > 0 ? pixels : roomy,
+      opensPage: index > 0 && section !== blockSections[index - 1] && sections[section]?.type !== "continuous"
+    };
+  });
   let pageStart = 0;
   let cursor = 0;
-  const split = (y, crossed, forced) => {
+  let paper = laid[0]?.paper ?? roomy;
+  const stepTo = (opening) => paper.pageStep - paper.marginTop + opening.marginTop;
+  const split = (y, crossed, forced, opening = paper) => {
     const page = splits.length + 2;
     splits.push({ y: round(y), page, forced, crossed });
-    pageStart = crossed ? y : y + pageStep;
-    pages.push({ page, bodyStart: round(pageStart), crossed });
+    pageStart = crossed ? y : y + stepTo(opening);
+    opened.push({ page, bodyStart: round(pageStart), pos: blockPos, crossed });
   };
   const crossTo = (y) => {
-    while (y > pageStart + pageBodyHeight + TOLERANCE_PX) {
-      split(pageStart + pageBodyHeight, true, false);
+    while (y > pageStart + paper.bodyHeight + TOLERANCE_PX) {
+      split(pageStart + paper.bodyHeight, true, false);
     }
   };
-  const fitsPage = (extent) => extent <= pageBodyHeight + TOLERANCE_PX;
-  const kept = keptExtents(blocks, fitsPage);
+  const kept = keptExtents(blocks, laid);
   let breakAfterPrevious = false;
   for (const [index, block] of blocks.entries()) {
-    const pageEnd = pageStart + pageBodyHeight;
+    blockPos = block.pos;
+    const opening = laid[index]?.paper ?? paper;
+    const startsSection = laid[index]?.opensPage === true;
+    const pageEnd = pageStart + paper.bodyHeight;
     const top = cursor + block.gap;
-    const startsPage = (block.breakBefore || breakAfterPrevious) && top > pageStart + TOLERANCE_PX;
+    const startsPage = (block.breakBefore || breakAfterPrevious || startsSection) && top > pageStart + TOLERANCE_PX;
     const first = kept.get(index) ?? block.minFirstPiece;
     const overflows = top + first > pageEnd + TOLERANCE_PX;
-    const fits = fitsPage(first);
-    const push = startsPage || overflows && fits ? Math.max(0, pageEnd + pageStep - top) : 0;
-    if (push > 0 || startsPage) split(pageEnd, false, startsPage);
+    const fits = first <= opening.bodyHeight + TOLERANCE_PX;
+    const push = startsPage || overflows && fits ? Math.max(0, pageEnd + stepTo(opening) - top) : 0;
+    if (push > 0 || startsPage) split(pageEnd, false, startsPage, opening);
+    paper = opening;
     if (push > 0) {
       pushes.push({
         pos: block.pos,
@@ -115,6 +170,7 @@ function pageLayout({
       });
     }
     const contentTop = top + push;
+    const pageBodyHeight = paper.bodyHeight;
     let added = 0;
     let pieceStart = 0;
     for (let index2 = 0; index2 <= block.candidates.length; index2 += 1) {
@@ -144,14 +200,19 @@ function pageLayout({
     pushes,
     cuts,
     splits,
-    pages,
-    bodyHeight: round(pageStart + pageBodyHeight)
+    pages: withinSections(opened, sections),
+    // The last page is filled out in full on the paper of the section it opens with
+    bodyHeight: round(pageStart + paper.bodyHeight),
+    marginBottom: paper.marginBottom
   };
 }
 export {
   A4_PAGE_PIXELS,
+  A4_SECTION_PIXELS,
   PAGE_SPLIT_PX,
   pageGeometryStyle,
   pageLayout,
-  pagePixels
+  pagePixels,
+  sectionPaperAt,
+  sectionPixels
 };

package/dist/page/usePageLayout.d.ts

@@ -10,7 +10,7 @@
  */
 import type { EditorView } from "prosemirror-view";
 import { type RefObject } from "react";
-import type { PageGeometry } from "../docx/pageGeometry";
+import { type SectionPixels } from "./pageLayout";
 /** One place where a page parts from the next. The position is measured on the sheet */
 export interface PageMark {
     page: number;
@@ -22,6 +22,13 @@ export interface PageMark {
 /** The paper area of one visual page, used to place its header and footer stories. */
 export interface PageFace {
     page: number;
+    /** The position of the block this page opens with, which says which section it belongs to */
+    pos: number;
+    /**
+     * The place this page takes within that section, counted from 1 again at every section, which is
+     * what its header and footer variant is chosen by (`docx/headersFooters`)
+     */
+    pageInSection: number;
     headerTop: number;
     footerTop: number;
     left: number;
@@ -43,8 +50,11 @@ interface PageLayoutOptions {
     enabled: boolean;
     /** A value that differs every time the text changes */
     revision: unknown;
-    /** The paper the open document names. A4 where a document names none */
-    geometry?: PageGeometry;
+    /**
+     * The paper of each section of the open document (`page/pageLayout`), read once per document
+     * change by the caller. A4 where a document names none, and where none is open
+     */
+    sections?: readonly SectionPixels[];
 }
-export declare function usePageLayout({ view, layer, enabled, revision, geometry, }: PageLayoutOptions): PageOverlay | null;
+export declare function usePageLayout({ view, layer, enabled, revision, sections, }: PageLayoutOptions): PageOverlay | null;
 export {};

package/dist/page/usePageLayout.js

@@ -2,7 +2,6 @@
 import {
   useCallback,
   useEffect,
-  useMemo,
   useRef,
   useState
 } from "react";
@@ -10,10 +9,10 @@ import { editorCssVariables } from "../styles/classNames.js";
 import { measureSheet } from "./measureBlocks.js";
 import { setPageMarks } from "./pageDecorations.js";
 import {
-  A4_PAGE_PIXELS,
+  A4_SECTION_PIXELS,
   PAGE_SPLIT_PX,
   pageLayout,
-  pagePixels
+  sectionPaperAt
 } from "./pageLayout.js";
 function useFrameThrottle(run, hold) {
   const latest = useRef({ run, hold });
@@ -52,46 +51,46 @@ function usePageLayout({
   layer,
   enabled,
   revision,
-  geometry
+  sections
 }) {
   const [overlay, setOverlay] = useState(null);
-  const page = useMemo(
-    () => geometry ? pagePixels(geometry) : A4_PAGE_PIXELS,
-    [geometry]
-  );
+  const papers = sections === void 0 || sections.length === 0 ? A4_SECTION_PIXELS : sections;
   const remeasure = useFrameThrottle(
     () => {
       const box = layer.current;
       if (!view || !box || !enabled) return;
       const measured = measureSheet(view, box);
-      const layout = pageLayout({
-        blocks: measured.blocks,
-        pageBodyHeight: page.bodyHeight,
-        pageStep: page.pageStep
-      });
+      const layout = pageLayout({ blocks: measured.blocks, sections: papers });
+      const paperOf = (pos) => sectionPaperAt(papers, pos);
+      const sheet = paperOf(0);
       setPageMarks(view, { pushes: layout.pushes, cuts: layout.cuts });
-      const sheetHeight = measured.contentTop + layout.bodyHeight + measured.contentBottom;
+      const sheetHeight = measured.contentTop + layout.bodyHeight + Math.max(measured.contentBottom, layout.marginBottom);
       box.style.setProperty(editorCssVariables.sheetHeight, `${sheetHeight}px`);
       const next = {
         left: measured.left,
         top: measured.top,
         width: measured.width,
         sheetHeight,
+        // A gap opens below the page that ends at this place, so it is that page's own margin
+        // the band is drawn under
         marks: layout.splits.map((split) => ({
           page: split.page,
-          top: measured.contentTop + split.y + (split.crossed ? 0 : page.marginBottom),
+          top: measured.contentTop + split.y + (split.crossed ? 0 : paperOf(layout.pages[split.page - 2]?.pos ?? 0).marginBottom),
           height: split.crossed ? 0 : PAGE_SPLIT_PX,
           crossed: split.crossed
         })),
         // A page crossed into has no margin, so the place it was split at is its top corner
         pages: layout.pages.map((start) => {
-          const paperTop = measured.contentTop + start.bodyStart - (start.crossed ? 0 : page.marginTop);
+          const paper = paperOf(start.pos);
+          const paperTop = measured.contentTop + start.bodyStart - (start.crossed ? 0 : paper.marginTop);
           return {
             page: start.page,
-            headerTop: paperTop + page.marginTop / 2,
-            footerTop: paperTop + page.pageHeight - page.marginBottom / 2,
-            left: page.marginLeft,
-            width: page.bodyWidth,
+            pos: start.pos,
+            pageInSection: start.pageInSection,
+            headerTop: paperTop + paper.marginTop / 2,
+            footerTop: paperTop + paper.pageHeight - paper.marginBottom / 2,
+            left: sheet.marginLeft,
+            width: sheet.bodyWidth,
             crossed: start.crossed
           };
         })

package/dist/schema/attrRoles.js

@@ -4,7 +4,13 @@ var NODE_ATTR_ROLES = {
   doc: {
     // The definitions of the lists started while editing. The export writes numbering.xml from
     // them and nothing derives them again, so they are a source value the document node holds
-    newLists: { role: "source", class: "model" }
+    newLists: { role: "source", class: "model" },
+    // The section that closes the body, as the document wrote it. The export writes it back out
+    // between the blocks and the tail, so a change to it is a change to the document
+    sectPr: { role: "source", class: "preserved" },
+    // What each side story currently says. The comment writer puts a comment's back into the
+    // Comments part, so a change to one is a change to the document
+    stories: { role: "source", class: "model" }
   },
   paragraph: {
     srcId: { role: "session", class: "identity" },
@@ -25,13 +31,18 @@ var NODE_ATTR_ROLES = {
     styleInside: { role: "display", class: "derived" },
     styleCellMargins: { role: "display", class: "derived" },
     styleConditions: { role: "display", class: "derived" },
-    styleBands: { role: "display", class: "derived" }
+    styleBands: { role: "display", class: "derived" },
+    // The markers a table and a row carry are content the writer puts back exactly where it
+    // stood, so a change to one is a change to the table rather than a display refresh
+    leadingXml: { role: "source", class: "preserved" }
   },
   tableRow: {
     trAttrs: { role: "source", class: "preserved" },
     tblPrEx: { role: "source", class: "preserved" },
     trPr: { role: "source", class: "preserved" },
-    format: { role: "display", class: "derived" }
+    format: { role: "display", class: "derived" },
+    leadingXml: { role: "source", class: "preserved" },
+    trailingXml: { role: "source", class: "preserved" }
   },
   tableCell: {
     colspan: { role: "source", class: "model" },
@@ -47,19 +58,15 @@ var NODE_ATTR_ROLES = {
     // it out of the comparison would let a step that unlocks a cell pass as a re-derivation
     sdtPrefix: { role: "source", class: "preserved" },
     sdtContentsLocked: { role: "source", class: "derived" },
-    sdtDeletionLocked: { role: "source", class: "derived" }
+    sdtDeletionLocked: { role: "source", class: "derived" },
+    trailingXml: { role: "source", class: "preserved" }
   },
   rawBlock: {
     xml: { role: "source", class: "preserved" },
-    name: { role: "source", class: "identity" }
-  },
-  docxRaw: {
-    srcId: { role: "session", class: "identity" },
-    name: { role: "session", class: "identity" }
-  },
-  bookmarkBlock: {
     srcId: { role: "session", class: "identity" },
-    name: { role: "session", class: "identity" }
+    name: { role: "session", class: "identity" },
+    display: { role: "session", class: "derived" },
+    guarded: { role: "session", class: "derived" }
   },
   hardBreak: { brAttrs: { role: "source", class: "preserved" } },
   image: {
@@ -84,14 +91,11 @@ var NODE_ATTR_ROLES = {
     authorId: { role: "source", class: "model" },
     initials: { role: "source", class: "model" },
     date: { role: "source", class: "model" },
-    text: { role: "source", class: "model" },
-    commentXml: { role: "source", class: "preserved" },
     paraId: { role: "source", class: "identity" },
     resolved: { role: "source", class: "model" },
     extensionXml: { role: "source", class: "preserved" },
     replies: { role: "source", class: "model" },
-    // Read to decide whether the comment parts are rewritten at all; neither is written
-    imported: { role: "session", class: "derived" },
+    // Read to decide whether the extended comment part is rewritten at all; it is never written
     threadImported: { role: "session", class: "derived" }
   },
   noteReference: {
@@ -99,12 +103,32 @@ var NODE_ATTR_ROLES = {
     id: { role: "source", class: "identity" },
     customMarkFollows: { role: "source", class: "model" },
     referenceXml: { role: "source", class: "preserved" },
-    // Both come from the notes part as the document was opened, and the writer puts back the
+    // Worked out from the notes part as the document was opened, and the writer puts back the
     // reference alone: a note renumbered around an edit is the same reference it was
-    label: { role: "display", class: "derived" },
-    text: { role: "display", class: "derived" }
+    label: { role: "display", class: "derived" }
   },
-  rawInline: { xml: { role: "source", class: "preserved" } }
+  rawRunContent: {
+    xml: { role: "source", class: "preserved" },
+    // What the fragment is and how it is drawn are read off the preservation table when the
+    // document is opened and never worked out again, so they travel with the fragment itself
+    element: { role: "session", class: "identity" },
+    display: { role: "session", class: "derived" },
+    text: { role: "session", class: "derived" },
+    guarded: { role: "session", class: "derived" }
+  },
+  rawInline: {
+    xml: { role: "source", class: "preserved" },
+    element: { role: "session", class: "identity" },
+    display: { role: "session", class: "derived" },
+    text: { role: "session", class: "derived" },
+    guarded: { role: "session", class: "derived" }
+  }
+};
+var WRAPPER_ATTR_ROLES = {
+  // Which wrapper of its kind this is, counted through the document as it was opened
+  key: { role: "session", class: "identity" },
+  // How deep inside the other wrappers this one stood in the file
+  depth: { role: "session", class: "identity" }
 };
 var MARK_ATTR_ROLES = {
   run: {
@@ -114,15 +138,14 @@ var MARK_ATTR_ROLES = {
   },
   sdt: {
     sdtPrefix: { role: "source", class: "preserved" },
-    // Counted through the document as it was opened, to tell one control from the next
-    sdtKey: { role: "session", class: "identity" },
+    ...WRAPPER_ATTR_ROLES,
     contentsLocked: { role: "source", class: "derived" },
     deletionLocked: { role: "source", class: "derived" }
   },
   link: {
     linkPrefix: { role: "source", class: "preserved" },
     href: { role: "source", class: "model" },
-    linkKey: { role: "session", class: "identity" }
+    ...WRAPPER_ATTR_ROLES
   },
   tab: { tabAttrs: { role: "source", class: "preserved" } }
 };

package/dist/schema/clipboard.d.ts

@@ -0,0 +1,72 @@
+/**
+ * What each node and mark looks like once it has left the editor.
+ *
+ * A node draws itself twice. `toDOM` draws the page, where the editor reads its own attributes
+ * back (an IME composition, a browser edit), so everything the document is written from stands on
+ * the element. A copy lands in Word, in a spreadsheet, in a mail: none of them can read a `w:pPr`,
+ * and none of them should be handed a comment's author or the body of a footnote. So the shape a
+ * copy takes is declared here, beside the schema, rather than worked out afterwards by taking the
+ * page's drawing apart.
+ *
+ * The two cannot drift apart unnoticed: `Readonly<Record<DocxNodeName, ...>>` refuses to compile
+ * until a node added to the schema says what it leaves as, and `clipboard.test.ts` asks the schema
+ * itself the same question at runtime.
+ */
+import { type DOMOutputSpec, DOMSerializer, type Mark, type Node as PMNode, type Schema, type Slice } from "prosemirror-model";
+import { type docxSchema } from "./docxSchema";
+/**
+ * The paragraph style a copy carries, which is the one thing a paste needs that the drawing does
+ * not already say. It is the style's id alone, where the editor draws the whole `w:pPr`.
+ */
+export declare const COPIED_STYLE_ATTRIBUTE = "data-style";
+/**
+ * The address a link may carry, whichever way it travels.
+ *
+ * A copy writes one out and a paste reads one in, and an address this rule turns down is one
+ * neither end should act on, so both ask here.
+ */
+export declare function safeHref(value: string | null): string | null;
+export interface ClipboardNodeSpec {
+    /**
+     * The HTML a copy carries. `null` in place of a function says this kind of node never leaves the
+     * editor; a function answering null says this one leaves nothing. Either way neither the node
+     * nor anything inside it is written.
+     */
+    toClipboardDOM: ((node: PMNode) => DOMOutputSpec | null) | null;
+    /**
+     * The plain text a copy carries, given what its children said. A null answer leaves the node out
+     * of the text entirely, separator and all, so a block standing for something invisible does not
+     * open a blank line where it stood.
+     */
+    toClipboardText: ((node: PMNode, children: readonly string[]) => string | null) | null;
+}
+export interface ClipboardMarkSpec {
+    /** null writes no wrapper, and the content it covered goes out on its own */
+    toClipboardDOM: ((mark: Mark) => DOMOutputSpec) | null;
+}
+/**
+ * `Schema.nodes` is indexed by `string` as well as by the names it was built from, so `keyof` over
+ * it widens to `string`. The generic argument the schema literal was inferred with keeps them.
+ */
+export type DocxNodeName = typeof docxSchema extends Schema<infer N, string> ? N : never;
+export type DocxMarkName = typeof docxSchema extends Schema<string, infer M> ? M : never;
+export declare const clipboardSpecs: {
+    nodes: Readonly<Record<DocxNodeName, ClipboardNodeSpec>>;
+    marks: Readonly<Record<DocxMarkName, ClipboardMarkSpec>>;
+};
+/**
+ * The serializer a copy is written with.
+ *
+ * `stampCopy` is handed the whole copy once it stands, and only once: `DOMSerializer` draws a
+ * node's children by calling `serializeFragment` again with the element it drew as the target, so
+ * a call carrying one is inside the copy rather than around it.
+ */
+export declare function clipboardSerializer(stampCopy?: (copy: HTMLElement | DocumentFragment) => void): DOMSerializer;
+/**
+ * The plain text a copy leaves beside the HTML.
+ *
+ * ProseMirror's own answer is the text content with a line between blocks, which loses a tab, a
+ * page break, and the difference between the next cell and the next row. Somewhere those are the
+ * whole of what was copied, a table pasted into a spreadsheet above all.
+ */
+export declare function clipboardText(slice: Slice): string;