@portone/docx-editor 0.3.0 → 0.5.0

package/dist/ooxml/names.js

@@ -1,5 +1,7 @@
 // src/ooxml/names.ts
-import { R_NS, W_NS } from "./xml.js";
+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,
@@ -11,6 +13,9 @@ var NAMESPACES = {
   a: "http://schemas.openxmlformats.org/drawingml/2006/main",
   pic: "http://schemas.openxmlformats.org/drawingml/2006/picture"
 };
+function isKnownPrefix(prefix) {
+  return Object.hasOwn(NAMESPACES, prefix);
+}
 function qualify(prefix, local) {
   return `${prefix}:${local}`;
 }
@@ -21,8 +26,12 @@ function xmlnsDecl(prefix) {
   return `xmlns:${prefix}="${NAMESPACES[prefix]}"`;
 }
 export {
+  M_NS,
   NAMESPACES,
+  R_NS,
+  W_NS,
   W_PREFIX,
+  isKnownPrefix,
   qualify,
   wName,
   xmlnsDecl

package/dist/ooxml/partSplice.d.ts

@@ -62,6 +62,6 @@ export interface RootDeclarations {
 }
 /**
  * The part with its root binding every prefix named and its `mc:Ignorable` naming every token
- * asked for, each declared once: one the root declares already is left as it was written.
+ * asked for, each declared once: a matching declaration is preserved, and a conflicting binding is refused.
  */
 export declare function ensureRootDeclarations(xml: string, declarations: RootDeclarations): string;

package/dist/ooxml/partSplice.js

@@ -121,12 +121,19 @@ function withDeclarations(openTag, { namespaces, ignorable }) {
       "the root element's attributes could not be read"
     );
   }
-  const declared = new Set(attrs.map(([name]) => name));
+  const declared = new Map(attrs);
   const additions = [];
   for (const [prefix, namespace] of Object.entries(namespaces)) {
-    if (namespace !== void 0 && !declared.has(`xmlns:${prefix}`)) {
-      additions.push([`xmlns:${prefix}`, namespace]);
+    if (namespace === void 0) continue;
+    const name = `xmlns:${prefix}`;
+    const existing = declared.get(name);
+    if (existing !== void 0 && existing !== namespace) {
+      throw new DocxExportError(
+        "unsupported-content",
+        `the part root binds ${prefix} to a namespace the writer cannot use`
+      );
     }
+    if (existing === void 0) additions.push([name, namespace]);
   }
   const ignoring = IGNORABLE.exec(openTag);
   let tokens = null;

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/ooxml/xml.d.ts

@@ -1,10 +1,5 @@
-/** The wordprocessing namespace that every element we read lives in */
-export declare const W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-/**
- * The relationship namespace. It is both where the `r:embed` attributes live and the base
- * every relationship type name is built on
- */
-export declare const R_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+import { R_NS, W_NS } from "./names";
+export { R_NS, W_NS };
 /**
  * The prefixes whose meaning the editor depends on, and the namespace each one has to carry.
  *
@@ -58,8 +53,12 @@ export declare function withXmlParser<T>(parser: XmlParser | undefined, work: ()
 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.
+ *
+ * A prefix `NAMESPACES` knows is bound to the namespace it stands for, so an attribute read off
+ * the fragment by namespace answers what it would in the part the fragment came out of. A prefix
+ * it does not know is bound to a placeholder, which carries no meaning but keeps the parser going:
+ * a fragment naming `o:`, `v:` or `wne:` would otherwise fail to parse and be refused whole
+ * (`ooxml/fragment`), taking the node that held it with it.
  *
  * 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.

package/dist/ooxml/xml.js

@@ -1,7 +1,6 @@
 // src/ooxml/xml.ts
 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";
+import { isKnownPrefix, NAMESPACES, R_NS, W_NS, W_PREFIX } from "./names.js";
 var RESERVED_PREFIXES = /* @__PURE__ */ new Map([
   ["w", W_NS],
   ["r", R_NS]
@@ -74,7 +73,7 @@ function parseXml(source) {
   return doc;
 }
 function namespaceDecls(xml) {
-  const prefixes = /* @__PURE__ */ new Set(["w"]);
+  const prefixes = /* @__PURE__ */ new Set([W_PREFIX]);
   for (const [, prefix] of xml.matchAll(/<\/?([A-Za-z_][\w.-]*):/g)) {
     prefixes.add(prefix);
   }
@@ -85,9 +84,10 @@ function namespaceDecls(xml) {
   }
   prefixes.delete("xml");
   prefixes.delete("xmlns");
-  return Array.from(prefixes).map(
-    (prefix) => `xmlns:${prefix}="${prefix === "w" ? W_NS : `urn:docx-editor:${prefix}`}"`
-  ).join(" ");
+  return Array.from(prefixes).map((prefix) => {
+    const namespace = isKnownPrefix(prefix) ? NAMESPACES[prefix] : `urn:docx-editor:${prefix}`;
+    return `xmlns:${prefix}="${namespace}"`;
+  }).join(" ");
 }
 function elementChildren(el) {
   return Array.from(el.children);

package/dist/page/PageGuides.d.ts

@@ -1,16 +1,20 @@
 /**
- * Draws the gaps between pages on the sheet, plus a number for each page.
+ * Draws the gaps between pages on the sheet.
  *
  * Straddling blocks have already been moved to the next page, so there is no text under
  * these bands.
  * 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,17 +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 badgeTitle(badge) {
-  return badge.exactPage ? `Page ${badge.page}` : `Page ${badge.page} (approximate)`;
-}
 function PageGuides({
   overlay,
-  headersFooters
+  headersFootersFor
 }) {
   const totalPages = overlay.pages.length;
   return /* @__PURE__ */ jsxs(
@@ -37,40 +34,19 @@ function PageGuides({
           },
           mark.page
         )),
-        overlay.badges.map((badge) => /* @__PURE__ */ jsx(
-          "span",
-          {
-            className: editorClassNames.pageBadge,
-            style: { top: `${badge.top}px` },
-            title: badgeTitle(badge),
-            children: badge.page
-          },
-          badge.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(
-            headersFooters.headers,
-            headersFooters,
-            page.page,
-            totalPages
-          );
-          const footer = headerFooterText(
-            headersFooters.footers,
-            headersFooters,
-            page.page,
-            totalPages
-          );
-          const headerAlign = headerFooterAlign(
+          const header = headerFooterOn(
             headersFooters.headers,
             headersFooters,
-            page.page
+            page.pageInSection
           );
-          const footerAlign = headerFooterAlign(
+          const footer = headerFooterOn(
             headersFooters.footers,
             headersFooters,
-            page.page
+            page.pageInSection
           );
           return [
             header === null ? null : /* @__PURE__ */ jsx(
@@ -81,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}`
             ),
@@ -96,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.
  *
@@ -63,11 +100,6 @@ export interface PageSplit {
     page: number;
     /** Whether the document records a break at this place */
     forced: boolean;
-    /**
-     * Whether every place before this one was recorded by the document, so the number can
-     * be trusted
-     */
-    exactPage: boolean;
     /**
      * Whether the block is taller than one page, so it cannot be pushed and the text
      * crosses this place
@@ -80,10 +112,16 @@ export interface PageStart {
     /** Where this page's body starts, measured from the top of the body */
     bodyStart: number;
     /**
-     * Whether every place before this one was recorded by the document, so the number can
-     * be trusted
+     * 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
      */
-    exactPage: boolean;
+    pageInSection: number;
     /**
      * Whether text crosses over from the previous page, so this page continues with no top
      * margin
@@ -100,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.
@@ -120,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,51 +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,
-    exactPage: true,
-    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;
-  let exactPage = true;
-  const split = (y, crossed, forced) => {
-    if (!forced) exactPage = false;
+  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, exactPage, crossed });
-    pageStart = crossed ? y : y + pageStep;
-    pages.push({ page, bodyStart: round(pageStart), exactPage, crossed });
+    splits.push({ y: round(y), page, forced, 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,
@@ -122,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) {
@@ -151,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
 };