@portone/docx-editor 0.4.0 → 0.5.0

package/dist/ooxml/image.js

@@ -1,6 +1,7 @@
 // src/ooxml/image.ts
 import { NAMESPACES } from "./names.js";
-import { childByLocalName, escapeXml, R_NS } from "./xml.js";
+import { parseAttrs, readTag } from "./tagScan.js";
+import { childByLocalName, escapeXml, localPart, R_NS } from "./xml.js";
 var EMU_PER_PX = 9525;
 function emuToPx(emu) {
   return emu / EMU_PER_PX;
@@ -76,11 +77,55 @@ function readDrawingPicture(drawing) {
   const descr = childOf(inline, "docPr")?.getAttribute("descr") ?? null;
   return { relId, extent, alt: descr === "" ? null : descr };
 }
-var EXTENT_TAG = /<([\w.-]+:)?extent\b[^>]*\/>/g;
-var EXT_TAG = /<([\w.-]+:)?ext\b[^>]*\/>/g;
+function isPictureSize(path) {
+  const names = path.join("/");
+  return names === "drawing/inline/extent" || names === "drawing/inline/graphic/graphicData/pic/spPr/xfrm/ext";
+}
+function resizeTag(open, extent) {
+  const tag = readTag(open, 0);
+  if (!tag) return open;
+  const attrs = new Map(
+    parseAttrs(
+      open.slice(tag.nameEnd, tag.end - (tag.kind === "empty" ? 2 : 1))
+    ) ?? []
+  );
+  return open.replace(
+    /(\s+)([^\s=/>]+)(\s*=\s*)(["'])([\s\S]*?)\4/g,
+    (whole, gap, name, equals, quote) => {
+      if (name !== "cx" && name !== "cy") return whole;
+      const size = extent[name];
+      if (Number(attrs.get(name)) === size) return whole;
+      return `${gap}${name}${equals}${quote}${size}${quote}`;
+    }
+  );
+}
 function withExtent(xml, extent) {
-  const size = `cx="${extent.cx}" cy="${extent.cy}"`;
-  return xml.replace(EXTENT_TAG, (_match, prefix) => `<${prefix ?? ""}extent ${size}/>`).replace(EXT_TAG, (_match, prefix) => `<${prefix ?? ""}ext ${size}/>`);
+  const path = [];
+  const parts = [];
+  let at = 0;
+  let kept = 0;
+  for (; ; ) {
+    const lt = xml.indexOf("<", at);
+    if (lt === -1) break;
+    const tag = readTag(xml, lt);
+    if (!tag) return xml;
+    if (tag.kind === "close") {
+      path.pop();
+    } else if (tag.kind !== "other") {
+      path.push(localPart(tag.name));
+      if (isPictureSize(path)) {
+        parts.push(
+          xml.slice(kept, lt),
+          resizeTag(xml.slice(lt, tag.end), extent)
+        );
+        kept = tag.end;
+      }
+      if (tag.kind === "empty") path.pop();
+    }
+    at = tag.end;
+  }
+  parts.push(xml.slice(kept));
+  return parts.join("");
 }
 function imageDrawingXml(image) {
   const size = `cx="${image.extent.cx}" cy="${image.extent.cy}"`;

package/dist/ooxml/names.d.ts

@@ -13,6 +13,12 @@ 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 math namespace. Nothing here is written under a prefix of ours - a `m:oMath` travels as the
+ * XML it arrived as - so it names the namespace alone and stays out of `NAMESPACES`, which is the
+ * list of prefixes the writer spells out.
+ */
+export declare const M_NS = "http://schemas.openxmlformats.org/officeDocument/2006/math";
 /** The prefix every WordprocessingML element and attribute this package writes carries */
 export declare const W_PREFIX = "w";
 export declare const NAMESPACES: {

package/dist/ooxml/names.js

@@ -1,6 +1,7 @@
 // src/ooxml/names.ts
 var W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
 var R_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+var M_NS = "http://schemas.openxmlformats.org/officeDocument/2006/math";
 var W_PREFIX = "w";
 var NAMESPACES = {
   w: W_NS,
@@ -25,6 +26,7 @@ function xmlnsDecl(prefix) {
   return `xmlns:${prefix}="${NAMESPACES[prefix]}"`;
 }
 export {
+  M_NS,
   NAMESPACES,
   R_NS,
   W_NS,

package/dist/ooxml/props.d.ts

@@ -52,6 +52,14 @@ export declare function renderProps(props: Props): string;
  * carries children in a different order under a different parent (`pPr/rPr`).
  */
 export declare function setChild(props: Props, name: string, xml: string | null, parent?: string): Props;
+/**
+ * Replaces every child of one name with this list of them, in the order given.
+ *
+ * `CT_SectPr` lets a section name a header and a footer once per variant, so a name standing more
+ * than once is a list rather than a single child, and writing one of them is writing the list. An
+ * empty list takes them all away.
+ */
+export declare function setChildren(props: Props, name: string, xmls: readonly string[], parent?: string): Props;
 export declare function propsChild(children: readonly PropsChild[], name: string): PropsChild | undefined;
 /**
  * The opening tag's attributes as pairs, and null when their shape cannot be made out.

package/dist/ooxml/props.js

@@ -115,28 +115,37 @@ function tailWith(props, carried) {
   return tail === "" ? {} : { tail };
 }
 function setChild(props, name, xml, parent) {
+  return setChildren(props, name, xml === null ? [] : [xml], parent);
+}
+function setChildren(props, name, xmls, parent) {
   const order = childOrderOf(localPart(props.tag), parent);
   const at = props.children.findIndex((entry) => entry.name === name);
-  if (at !== -1 && xml !== null) {
+  if (at !== -1 && xmls.length > 0) {
     const rest = dropChildren(props.children.slice(at + 1), name);
     return {
       ...props,
       children: [
         ...props.children.slice(0, at),
-        { ...props.children[at], xml },
+        ...xmls.map(
+          (xml, index2) => index2 === 0 ? { ...props.children[at], xml } : { name, xml }
+        ),
         ...rest.kept
       ],
       ...tailWith(props, rest.carried)
     };
   }
   const { kept, carried } = dropChildren(props.children, name);
-  if (xml === null) {
+  if (xmls.length === 0) {
     return { ...props, children: kept, ...tailWith(props, carried) };
   }
   const index = insertIndex(kept, name, order, props.tag);
   return {
     ...props,
-    children: [...kept.slice(0, index), { name, xml }, ...kept.slice(index)],
+    children: [
+      ...kept.slice(0, index),
+      ...xmls.map((xml) => ({ name, xml })),
+      ...kept.slice(index)
+    ],
     ...tailWith(props, carried)
   };
 }
@@ -210,5 +219,6 @@ export {
   renderElement,
   renderProps,
   setChild,
+  setChildren,
   withAttrs
 };

package/dist/ooxml/rangeMarkers.d.ts

@@ -0,0 +1,5 @@
+/** `EG_RangeMarkupElements` less the comment markers modelled inside paragraphs and wrappers */
+export declare const RANGE_MARKERS: string[];
+/** The markers of `EG_RunLevelElts` that stand outside `EG_RangeMarkupElements` */
+export declare const PERMISSION_MARKERS: string[];
+export declare const COMMENT_RANGE_MARKERS: string[];

package/dist/ooxml/rangeMarkers.js

@@ -0,0 +1,24 @@
+// src/ooxml/rangeMarkers.ts
+var RANGE_MARKERS = [
+  "bookmarkStart",
+  "bookmarkEnd",
+  "moveFromRangeStart",
+  "moveFromRangeEnd",
+  "moveToRangeStart",
+  "moveToRangeEnd",
+  "customXmlInsRangeStart",
+  "customXmlInsRangeEnd",
+  "customXmlDelRangeStart",
+  "customXmlDelRangeEnd",
+  "customXmlMoveFromRangeStart",
+  "customXmlMoveFromRangeEnd",
+  "customXmlMoveToRangeStart",
+  "customXmlMoveToRangeEnd"
+];
+var PERMISSION_MARKERS = ["permStart", "permEnd"];
+var COMMENT_RANGE_MARKERS = ["commentRangeStart", "commentRangeEnd"];
+export {
+  COMMENT_RANGE_MARKERS,
+  PERMISSION_MARKERS,
+  RANGE_MARKERS
+};

package/dist/page/PageGuides.d.ts

@@ -6,11 +6,15 @@
  * Only the places crossed by a block taller than one page are marked over the text, with
  * a faint dotted line.
  * The box only paints, so the mouse still reaches the text beneath it.
+ *
+ * Each page draws the header and footer of the section it opens with, since a document names its
+ * headers section by section (`docx/headersFooters`).
  */
 import type { ReactElement } from "react";
 import { type HeadersFooters } from "../docx/headersFooters";
-import type { PageOverlay } from "./usePageLayout";
-export declare function PageGuides({ overlay, headersFooters, }: {
+import type { PageFace, PageOverlay } from "./usePageLayout";
+export declare function PageGuides({ overlay, headersFootersFor, }: {
     overlay: PageOverlay;
-    headersFooters?: HeadersFooters;
+    /** The stories the section this page belongs to shows. Left out while no document is open */
+    headersFootersFor?: (page: PageFace) => HeadersFooters | null;
 }): ReactElement;

package/dist/page/PageGuides.js

@@ -1,14 +1,14 @@
 // src/page/PageGuides.tsx
 import {
   displayPageNumber,
-  headerFooterAlign,
+  headerFooterOn,
   headerFooterText
 } from "../docx/headersFooters.js";
 import { editorClassNames } from "../styles/classNames.js";
 import { jsx, jsxs } from "react/jsx-runtime";
 function PageGuides({
   overlay,
-  headersFooters
+  headersFootersFor
 }) {
   const totalPages = overlay.pages.length;
   return /* @__PURE__ */ jsxs(
@@ -34,30 +34,19 @@ function PageGuides({
           },
           mark.page
         )),
-        headersFooters && overlay.pages.flatMap((page) => {
-          if (page.crossed) return [];
+        headersFootersFor && overlay.pages.flatMap((page) => {
+          const headersFooters = page.crossed ? null : headersFootersFor(page);
+          if (headersFooters === null) return [];
           const number = displayPageNumber(headersFooters, page.page);
-          const header = headerFooterText(
+          const header = headerFooterOn(
             headersFooters.headers,
             headersFooters,
-            page.page,
-            totalPages
+            page.pageInSection
           );
-          const footer = headerFooterText(
+          const footer = headerFooterOn(
             headersFooters.footers,
             headersFooters,
-            page.page,
-            totalPages
-          );
-          const headerAlign = headerFooterAlign(
-            headersFooters.headers,
-            headersFooters,
-            page.page
-          );
-          const footerAlign = headerFooterAlign(
-            headersFooters.footers,
-            headersFooters,
-            page.page
+            page.pageInSection
           );
           return [
             header === null ? null : /* @__PURE__ */ jsx(
@@ -68,10 +57,10 @@ function PageGuides({
                   top: `${page.headerTop}px`,
                   left: `${page.left}px`,
                   width: `${page.width}px`,
-                  textAlign: headerAlign ?? void 0
+                  textAlign: header.align ?? void 0
                 },
                 title: `Page ${number} header`,
-                children: header
+                children: headerFooterText(header.story, number, totalPages)
               },
               `header-${page.page}`
             ),
@@ -83,10 +72,10 @@ function PageGuides({
                   top: `${page.footerTop}px`,
                   left: `${page.left}px`,
                   width: `${page.width}px`,
-                  textAlign: footerAlign ?? void 0
+                  textAlign: footer.align ?? void 0
                 },
                 title: `Page ${number} footer`,
-                children: footer
+                children: headerFooterText(footer.story, number, totalPages)
               },
               `footer-${page.page}`
             )

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 {};