@usejunior/docx-core 0.19.1 → 0.21.2

package/dist/primitives/sections.js

@@ -0,0 +1,644 @@
+import { findParagraphByBookmarkId, getParagraphBookmarkId, insertSingleParagraphBookmark, } from './bookmarks.js';
+import { childElements, createWmlElement, getDirectChildrenByName, isW } from './dom-helpers.js';
+import { OOXML, W } from './namespaces.js';
+import { allocateRevisionId, buildSectPrChangeElement, } from './track-changes-emitter.js';
+export class SectionMutationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'SectionMutationError';
+    }
+}
+function getWAttr(el, localName) {
+    return el.getAttributeNS(OOXML.W_NS, localName)
+        || el.getAttribute(`w:${localName}`)
+        || null;
+}
+function getRAttr(el, localName) {
+    return el.getAttributeNS(OOXML.R_NS, localName)
+        || el.getAttribute(`r:${localName}`)
+        || null;
+}
+function decimalAttr(el, localName) {
+    if (!el)
+        return null;
+    const raw = getWAttr(el, localName);
+    if (raw === null || !/^-?\d+$/.test(raw))
+        return null;
+    const value = Number(raw);
+    return Number.isSafeInteger(value) ? value : null;
+}
+/**
+ * Collect the two canonical live section-property placements without
+ * descending into `w:sectPrChange` snapshots.
+ *
+ * @conformance ECMA-376 edition 5, Part 1 § 17.6.18
+ * @see #654
+ */
+function collectLiveSections(doc) {
+    const body = doc.getElementsByTagNameNS(OOXML.W_NS, W.body).item(0);
+    if (!body)
+        return [];
+    const sections = [];
+    const paragraphs = body.getElementsByTagNameNS(OOXML.W_NS, W.p);
+    for (let i = 0; i < paragraphs.length; i++) {
+        const paragraph = paragraphs.item(i);
+        const pPr = getDirectChildrenByName(paragraph, W.pPr)[0];
+        const sectPr = pPr
+            ? getDirectChildrenByName(pPr, W.sectPr)[0]
+            : undefined;
+        if (sectPr) {
+            sections.push({ sectPr, location: 'paragraph', paragraph });
+        }
+    }
+    const finalSectPr = childElements(body)
+        .find((child) => isW(child, W.sectPr));
+    if (finalSectPr) {
+        sections.push({ sectPr: finalSectPr, location: 'body', paragraph: null });
+    }
+    return sections;
+}
+function projectReferences(sectPr, localName) {
+    return getDirectChildrenByName(sectPr, localName).map((reference) => ({
+        type: getWAttr(reference, W.type),
+        relationshipId: getRAttr(reference, 'id'),
+    }));
+}
+function projectSection(section, sectionIndex) {
+    const type = getDirectChildrenByName(section.sectPr, W.type)[0] ?? null;
+    const pgNumType = getDirectChildrenByName(section.sectPr, W.pgNumType)[0] ?? null;
+    const pgSz = getDirectChildrenByName(section.sectPr, W.pgSz)[0] ?? null;
+    const pgMar = getDirectChildrenByName(section.sectPr, W.pgMar)[0] ?? null;
+    return {
+        sectionIndex,
+        location: section.location,
+        anchorParagraphId: section.paragraph
+            ? getParagraphBookmarkId(section.paragraph)
+            : null,
+        breakType: type ? getWAttr(type, W.val) : null,
+        pageNumberStart: decimalAttr(pgNumType, W.start),
+        pageNumberFormat: pgNumType ? getWAttr(pgNumType, 'fmt') : null,
+        pageSize: pgSz
+            ? {
+                widthTwips: decimalAttr(pgSz, W.w),
+                heightTwips: decimalAttr(pgSz, 'h'),
+                orientation: getWAttr(pgSz, 'orient'),
+            }
+            : null,
+        margins: pgMar
+            ? {
+                topTwips: decimalAttr(pgMar, W.top),
+                rightTwips: decimalAttr(pgMar, W.right),
+                bottomTwips: decimalAttr(pgMar, W.bottom),
+                leftTwips: decimalAttr(pgMar, W.left),
+                headerTwips: decimalAttr(pgMar, 'header'),
+                footerTwips: decimalAttr(pgMar, 'footer'),
+                gutterTwips: decimalAttr(pgMar, 'gutter'),
+            }
+            : null,
+        headers: projectReferences(section.sectPr, W.headerReference),
+        footers: projectReferences(section.sectPr, W.footerReference),
+    };
+}
+/**
+ * Return canonical main-document section properties in document order.
+ *
+ * @conformance ECMA-376 edition 5, Part 1 § 17.6.18
+ * @conformance ECMA-376 edition 5, Part 1 § 17.6.12
+ * @see #654
+ */
+export function getDocumentSections(doc) {
+    return collectLiveSections(doc).map(projectSection);
+}
+const PAGE_SIZE_KEYS = [
+    'widthTwips',
+    'heightTwips',
+    'orientation',
+];
+const MARGIN_KEYS = [
+    'topTwips',
+    'rightTwips',
+    'bottomTwips',
+    'leftTwips',
+    'headerTwips',
+    'footerTwips',
+    'gutterTwips',
+];
+function hasDefinedValue(value, keys) {
+    return value !== undefined && keys.some((key) => value[key] !== undefined);
+}
+function validatePositiveTwips(value, label) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new SectionMutationError('INVALID_PAGE_SIZE', `${label} must be a positive safe integer.`);
+    }
+}
+function validateSignedTwips(value, label) {
+    if (!Number.isSafeInteger(value)) {
+        throw new SectionMutationError('INVALID_PAGE_MARGINS', `${label} must be a safe integer.`);
+    }
+}
+function validateUnsignedTwips(value, label) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new SectionMutationError('INVALID_PAGE_MARGINS', `${label} must be a non-negative safe integer.`);
+    }
+}
+function validateMutation(mutation) {
+    if (!Number.isSafeInteger(mutation.sectionIndex) || mutation.sectionIndex < 0) {
+        throw new SectionMutationError('INVALID_SECTION_INDEX', 'sectionIndex must be a non-negative safe integer.');
+    }
+    const hasPageSize = hasDefinedValue(mutation.pageSize, PAGE_SIZE_KEYS);
+    const hasMargins = hasDefinedValue(mutation.margins, MARGIN_KEYS);
+    if (mutation.pageNumberStart === undefined
+        && !hasPageSize
+        && !hasMargins) {
+        throw new SectionMutationError('EMPTY_SECTION_MUTATION', 'At least one section page-setup value must be provided.');
+    }
+    if (mutation.pageNumberStart !== undefined) {
+        if (!Number.isSafeInteger(mutation.pageNumberStart)
+            || mutation.pageNumberStart < 0) {
+            throw new SectionMutationError('INVALID_PAGE_NUMBER_START', 'pageNumberStart must be a non-negative safe integer.');
+        }
+    }
+    if (mutation.pageSize?.widthTwips !== undefined) {
+        validatePositiveTwips(mutation.pageSize.widthTwips, 'pageSize.widthTwips');
+    }
+    if (mutation.pageSize?.heightTwips !== undefined) {
+        validatePositiveTwips(mutation.pageSize.heightTwips, 'pageSize.heightTwips');
+    }
+    if (mutation.pageSize?.orientation !== undefined
+        && mutation.pageSize.orientation !== 'portrait'
+        && mutation.pageSize.orientation !== 'landscape') {
+        throw new SectionMutationError('INVALID_PAGE_ORIENTATION', 'pageSize.orientation must be "portrait" or "landscape".');
+    }
+    if (mutation.margins?.topTwips !== undefined) {
+        validateSignedTwips(mutation.margins.topTwips, 'margins.topTwips');
+    }
+    if (mutation.margins?.bottomTwips !== undefined) {
+        validateSignedTwips(mutation.margins.bottomTwips, 'margins.bottomTwips');
+    }
+    for (const key of [
+        'rightTwips',
+        'leftTwips',
+        'headerTwips',
+        'footerTwips',
+        'gutterTwips',
+    ]) {
+        const value = mutation.margins?.[key];
+        if (value !== undefined)
+            validateUnsignedTwips(value, `margins.${key}`);
+    }
+}
+function insertPgSzInSchemaOrder(sectPr, pgSz) {
+    const successors = new Set([
+        W.pgMar,
+        'paperSrc',
+        'pgBorders',
+        'lnNumType',
+        W.pgNumType,
+        'cols',
+        'formProt',
+        'vAlign',
+        'noEndnote',
+        W.titlePg,
+        'textDirection',
+        'bidi',
+        'rtlGutter',
+        'docGrid',
+        'printerSettings',
+        'sectPrChange',
+    ]);
+    const successor = childElements(sectPr)
+        .find((child) => successors.has(child.localName));
+    if (successor)
+        sectPr.insertBefore(pgSz, successor);
+    else
+        sectPr.appendChild(pgSz);
+}
+function insertPgMarInSchemaOrder(sectPr, pgMar) {
+    const successors = new Set([
+        'paperSrc',
+        'pgBorders',
+        'lnNumType',
+        W.pgNumType,
+        'cols',
+        'formProt',
+        'vAlign',
+        'noEndnote',
+        W.titlePg,
+        'textDirection',
+        'bidi',
+        'rtlGutter',
+        'docGrid',
+        'printerSettings',
+        'sectPrChange',
+    ]);
+    const successor = childElements(sectPr)
+        .find((child) => successors.has(child.localName));
+    if (successor)
+        sectPr.insertBefore(pgMar, successor);
+    else
+        sectPr.appendChild(pgMar);
+}
+function insertPgNumTypeInSchemaOrder(sectPr, pgNumType) {
+    const successors = new Set([
+        'cols',
+        'formProt',
+        'vAlign',
+        'noEndnote',
+        W.titlePg,
+        'textDirection',
+        'bidi',
+        'rtlGutter',
+        'docGrid',
+        'printerSettings',
+        'sectPrChange',
+    ]);
+    const successor = childElements(sectPr)
+        .find((child) => successors.has(child.localName));
+    if (successor)
+        sectPr.insertBefore(pgNumType, successor);
+    else
+        sectPr.appendChild(pgNumType);
+}
+function setSectionBreakType(sectPr, breakType) {
+    const existingTypes = getDirectChildrenByName(sectPr, W.type);
+    let type = existingTypes[0];
+    for (const duplicate of existingTypes.slice(1)) {
+        sectPr.removeChild(duplicate);
+    }
+    if (!type) {
+        type = createWmlElement(sectPr.ownerDocument, W.type);
+        const successor = childElements(sectPr).find((child) => child.localName !== W.headerReference
+            && child.localName !== W.footerReference);
+        if (successor)
+            sectPr.insertBefore(type, successor);
+        else
+            sectPr.appendChild(type);
+    }
+    type.setAttributeNS(OOXML.W_NS, `w:${W.val}`, breakType);
+}
+function removeDirectSectionChange(sectPr) {
+    for (const change of getDirectChildrenByName(sectPr, 'sectPrChange')) {
+        sectPr.removeChild(change);
+    }
+}
+function resetNonRelationshipSectionProperties(sectPr) {
+    for (const child of childElements(sectPr)) {
+        if (!isW(child, W.headerReference)
+            && !isW(child, W.footerReference)) {
+            sectPr.removeChild(child);
+        }
+    }
+    for (let i = sectPr.attributes.length - 1; i >= 0; i--) {
+        const attribute = sectPr.attributes.item(i);
+        if (attribute?.namespaceURI === OOXML.W_NS) {
+            sectPr.removeAttributeNode(attribute);
+        }
+    }
+}
+function ensureProspectiveSectionMutationIsValid(doc, sectionIndex, mutation, inheritProperties, currentSectPr) {
+    const fullMutation = { sectionIndex, ...mutation };
+    validateMutation(fullMutation);
+    const prospectiveSectPr = inheritProperties
+        ? currentSectPr.cloneNode(true)
+        : createWmlElement(doc, W.sectPr);
+    if (!inheritProperties) {
+        for (const reference of childElements(currentSectPr)) {
+            if (isW(reference, W.headerReference)
+                || isW(reference, W.footerReference)) {
+                prospectiveSectPr.appendChild(reference.cloneNode(true));
+            }
+        }
+    }
+    assertMissingElementsCanBeCreated({ sectPr: prospectiveSectPr, location: 'body', paragraph: null }, fullMutation);
+}
+function paragraphInsertionReference(anchor) {
+    let cursor = anchor.nextSibling;
+    while (cursor) {
+        if (cursor.nodeType !== 1) {
+            cursor = cursor.nextSibling;
+            continue;
+        }
+        if (isW(cursor, W.bookmarkEnd)) {
+            cursor = cursor.nextSibling;
+            continue;
+        }
+        break;
+    }
+    return cursor;
+}
+function addParagraphInsertionMarker(doc, pPr, ctx) {
+    const rPr = createWmlElement(doc, W.rPr);
+    rPr.appendChild(createWmlElement(doc, 'ins', {
+        'w:id': String(allocateRevisionId(ctx.idState)),
+        'w:author': ctx.author,
+        'w:date': ctx.date,
+    }));
+    pPr.insertBefore(rPr, pPr.firstChild);
+}
+function requestedValueDiffers(element, localName, value) {
+    return value !== undefined
+        && (!element || getWAttr(element, localName) !== String(value));
+}
+function assertMissingElementsCanBeCreated(liveSection, mutation) {
+    if (hasDefinedValue(mutation.pageSize, PAGE_SIZE_KEYS)
+        && getDirectChildrenByName(liveSection.sectPr, W.pgSz).length === 0
+        && (mutation.pageSize?.widthTwips === undefined
+            || mutation.pageSize.heightTwips === undefined)) {
+        throw new SectionMutationError('INCOMPLETE_PAGE_SIZE', 'A section without w:pgSz requires both widthTwips and heightTwips.');
+    }
+    if (hasDefinedValue(mutation.margins, MARGIN_KEYS)
+        && getDirectChildrenByName(liveSection.sectPr, W.pgMar).length === 0
+        && MARGIN_KEYS.some((key) => mutation.margins?.[key] === undefined)) {
+        throw new SectionMutationError('INCOMPLETE_PAGE_MARGINS', 'A section without w:pgMar requires all seven margin values.');
+    }
+}
+/**
+ * Atomically update one section's page setup while preserving every
+ * unspecified section property and recording one prior-state snapshot.
+ *
+ * @conformance ECMA-376 edition 5, Part 1 § 17.6.13
+ * @conformance ECMA-376 edition 5, Part 1 § 17.6.11
+ * @conformance ECMA-376 edition 5, Part 1 § 17.6.12
+ * @conformance ECMA-376 edition 5, Part 1 § 17.13.5.32
+ * @see #654
+ */
+export function updateSectionProperties(doc, mutation, ctx) {
+    validateMutation(mutation);
+    const liveSection = collectLiveSections(doc)[mutation.sectionIndex];
+    if (!liveSection) {
+        throw new SectionMutationError('SECTION_NOT_FOUND', `Section index ${mutation.sectionIndex} was not found.`);
+    }
+    assertMissingElementsCanBeCreated(liveSection, mutation);
+    const existingPgNumTypes = getDirectChildrenByName(liveSection.sectPr, W.pgNumType);
+    const existingPageSizes = getDirectChildrenByName(liveSection.sectPr, W.pgSz);
+    const existingMargins = getDirectChildrenByName(liveSection.sectPr, W.pgMar);
+    const previousSection = projectSection(liveSection, mutation.sectionIndex);
+    const pageNumberChanged = mutation.pageNumberStart !== undefined && (existingPgNumTypes.length !== 1
+        || decimalAttr(existingPgNumTypes[0] ?? null, W.start) !== mutation.pageNumberStart);
+    const pageSizeChanged = hasDefinedValue(mutation.pageSize, PAGE_SIZE_KEYS) && (existingPageSizes.length !== 1
+        || requestedValueDiffers(existingPageSizes[0], W.w, mutation.pageSize?.widthTwips)
+        || requestedValueDiffers(existingPageSizes[0], 'h', mutation.pageSize?.heightTwips)
+        || requestedValueDiffers(existingPageSizes[0], 'orient', mutation.pageSize?.orientation));
+    const marginsChanged = hasDefinedValue(mutation.margins, MARGIN_KEYS) && (existingMargins.length !== 1
+        || requestedValueDiffers(existingMargins[0], W.top, mutation.margins?.topTwips)
+        || requestedValueDiffers(existingMargins[0], W.right, mutation.margins?.rightTwips)
+        || requestedValueDiffers(existingMargins[0], W.bottom, mutation.margins?.bottomTwips)
+        || requestedValueDiffers(existingMargins[0], W.left, mutation.margins?.leftTwips)
+        || requestedValueDiffers(existingMargins[0], 'header', mutation.margins?.headerTwips)
+        || requestedValueDiffers(existingMargins[0], 'footer', mutation.margins?.footerTwips)
+        || requestedValueDiffers(existingMargins[0], 'gutter', mutation.margins?.gutterTwips));
+    if (!pageNumberChanged && !pageSizeChanged && !marginsChanged) {
+        return {
+            sectionIndex: mutation.sectionIndex,
+            changed: false,
+            previousSection,
+            currentSection: previousSection,
+        };
+    }
+    const oldSectPr = liveSection.sectPr.cloneNode(true);
+    if (pageSizeChanged) {
+        let pgSz = existingPageSizes[0];
+        for (const duplicate of existingPageSizes.slice(1)) {
+            liveSection.sectPr.removeChild(duplicate);
+        }
+        if (!pgSz) {
+            pgSz = createWmlElement(doc, W.pgSz);
+            insertPgSzInSchemaOrder(liveSection.sectPr, pgSz);
+        }
+        const pageSizeAttrs = [
+            [W.w, mutation.pageSize?.widthTwips],
+            ['h', mutation.pageSize?.heightTwips],
+            ['orient', mutation.pageSize?.orientation],
+        ];
+        for (const [name, value] of pageSizeAttrs) {
+            if (value !== undefined) {
+                pgSz.setAttributeNS(OOXML.W_NS, `w:${name}`, String(value));
+            }
+        }
+    }
+    if (marginsChanged) {
+        let pgMar = existingMargins[0];
+        for (const duplicate of existingMargins.slice(1)) {
+            liveSection.sectPr.removeChild(duplicate);
+        }
+        if (!pgMar) {
+            pgMar = createWmlElement(doc, W.pgMar);
+            insertPgMarInSchemaOrder(liveSection.sectPr, pgMar);
+        }
+        const marginAttrs = [
+            [W.top, mutation.margins?.topTwips],
+            [W.right, mutation.margins?.rightTwips],
+            [W.bottom, mutation.margins?.bottomTwips],
+            [W.left, mutation.margins?.leftTwips],
+            ['header', mutation.margins?.headerTwips],
+            ['footer', mutation.margins?.footerTwips],
+            ['gutter', mutation.margins?.gutterTwips],
+        ];
+        for (const [name, value] of marginAttrs) {
+            if (value !== undefined) {
+                pgMar.setAttributeNS(OOXML.W_NS, `w:${name}`, String(value));
+            }
+        }
+    }
+    if (pageNumberChanged) {
+        let pgNumType = existingPgNumTypes[0];
+        for (const duplicate of existingPgNumTypes.slice(1)) {
+            liveSection.sectPr.removeChild(duplicate);
+        }
+        if (!pgNumType) {
+            pgNumType = createWmlElement(doc, W.pgNumType);
+            insertPgNumTypeInSchemaOrder(liveSection.sectPr, pgNumType);
+        }
+        pgNumType.setAttributeNS(OOXML.W_NS, `w:${W.start}`, String(mutation.pageNumberStart));
+    }
+    if (ctx) {
+        for (const stale of getDirectChildrenByName(liveSection.sectPr, 'sectPrChange')) {
+            liveSection.sectPr.removeChild(stale);
+        }
+        liveSection.sectPr.appendChild(buildSectPrChangeElement(oldSectPr, ctx));
+    }
+    return {
+        sectionIndex: mutation.sectionIndex,
+        changed: true,
+        previousSection,
+        currentSection: projectSection(liveSection, mutation.sectionIndex),
+    };
+}
+const SECTION_BREAK_TYPES = new Set([
+    'nextPage',
+    'nextColumn',
+    'continuous',
+    'evenPage',
+    'oddPage',
+]);
+function removeInsertedBoundaryWithBookmarks(paragraph) {
+    const parent = paragraph.parentNode;
+    if (!parent)
+        return;
+    const previous = paragraph.previousSibling;
+    const next = paragraph.nextSibling;
+    if (previous?.nodeType === 1 && isW(previous, W.bookmarkStart)) {
+        parent.removeChild(previous);
+    }
+    if (next?.nodeType === 1 && isW(next, W.bookmarkEnd)) {
+        parent.removeChild(next);
+    }
+    parent.removeChild(paragraph);
+}
+/**
+ * Insert one main-document section boundary after a stable direct-body
+ * paragraph and optionally initialize the following section's page setup.
+ *
+ * The dedicated boundary paragraph carries an inserted paragraph-mark revision
+ * so accepting retains the split and rejecting removes it. Following-section
+ * property overrides use one prior-state snapshot.
+ *
+ * @conformance ECMA-376 edition 5, Part 1 § 17.6.18
+ * @conformance ECMA-376 edition 5, Part 1 § 17.6.22
+ * @conformance ECMA-376 edition 5, Part 1 § 17.13.5.20
+ * @conformance ECMA-376 edition 5, Part 1 § 17.13.5.32
+ * @see #654
+ */
+export function insertSectionBreak(doc, mutation, ctx, bookmarkReservation) {
+    if (typeof mutation.anchorParagraphId !== 'string'
+        || mutation.anchorParagraphId.trim().length === 0) {
+        throw new SectionMutationError('INVALID_SECTION_ANCHOR', 'anchorParagraphId must be a non-empty paragraph id.');
+    }
+    if (!SECTION_BREAK_TYPES.has(mutation.breakType)) {
+        throw new SectionMutationError('INVALID_SECTION_BREAK_TYPE', 'breakType must be nextPage, nextColumn, continuous, evenPage, or oddPage.');
+    }
+    if (mutation.inheritProperties !== undefined
+        && typeof mutation.inheritProperties !== 'boolean') {
+        throw new SectionMutationError('INVALID_INHERIT_PROPERTIES', 'inheritProperties must be a boolean.');
+    }
+    const anchor = findParagraphByBookmarkId(doc, mutation.anchorParagraphId);
+    if (!anchor) {
+        throw new SectionMutationError('SECTION_ANCHOR_NOT_FOUND', `Paragraph "${mutation.anchorParagraphId}" was not found or was ambiguous.`);
+    }
+    const body = doc.getElementsByTagNameNS(OOXML.W_NS, W.body).item(0);
+    if (!body || anchor.parentNode !== body) {
+        throw new SectionMutationError('SECTION_ANCHOR_NOT_BODY', 'The section-break anchor must be a direct child of the main document body.');
+    }
+    const anchorPPr = getDirectChildrenByName(anchor, W.pPr)[0];
+    if (anchorPPr
+        && getDirectChildrenByName(anchorPPr, W.sectPr).length > 0) {
+        throw new SectionMutationError('SECTION_BOUNDARY_EXISTS', 'The anchor paragraph already ends a section.');
+    }
+    const liveSections = collectLiveSections(doc);
+    let containingSection;
+    let cursor = anchor.nextSibling;
+    while (cursor) {
+        if (cursor.nodeType === 1) {
+            const element = cursor;
+            if (isW(element, W.p)) {
+                const pPr = getDirectChildrenByName(element, W.pPr)[0];
+                const sectPr = pPr
+                    ? getDirectChildrenByName(pPr, W.sectPr)[0]
+                    : undefined;
+                if (sectPr) {
+                    containingSection = liveSections.find((section) => section.sectPr === sectPr);
+                    break;
+                }
+            }
+            else if (isW(element, W.sectPr)) {
+                containingSection = liveSections.find((section) => section.sectPr === element);
+                break;
+            }
+        }
+        cursor = cursor.nextSibling;
+    }
+    if (!containingSection) {
+        throw new SectionMutationError('SECTION_NOT_FOUND', 'No live section boundary follows the anchor paragraph.');
+    }
+    const sectionIndex = liveSections.indexOf(containingSection);
+    if (sectionIndex < 0) {
+        throw new SectionMutationError('SECTION_NOT_FOUND', 'The containing section could not be resolved.');
+    }
+    const inheritProperties = mutation.inheritProperties ?? true;
+    if (mutation.newSection) {
+        ensureProspectiveSectionMutationIsValid(doc, sectionIndex, mutation.newSection, inheritProperties, containingSection.sectPr);
+    }
+    const sectionCountBefore = liveSections.length;
+    const originalFollowingSectPr = containingSection.sectPr.cloneNode(true);
+    const boundarySectPr = originalFollowingSectPr.cloneNode(true);
+    removeDirectSectionChange(boundarySectPr);
+    setSectionBreakType(boundarySectPr, mutation.breakType);
+    const boundaryParagraph = createWmlElement(doc, W.p);
+    const boundaryPPr = createWmlElement(doc, W.pPr);
+    if (ctx)
+        addParagraphInsertionMarker(doc, boundaryPPr, ctx);
+    boundaryPPr.appendChild(boundarySectPr);
+    boundaryParagraph.appendChild(boundaryPPr);
+    let followingChanged = false;
+    let boundaryInserted = false;
+    try {
+        if (!inheritProperties) {
+            resetNonRelationshipSectionProperties(containingSection.sectPr);
+            followingChanged = true;
+            if (mutation.newSection) {
+                updateSectionProperties(doc, { sectionIndex, ...mutation.newSection });
+            }
+            if (ctx) {
+                containingSection.sectPr.appendChild(buildSectPrChangeElement(originalFollowingSectPr, ctx));
+            }
+        }
+        else if (mutation.newSection) {
+            followingChanged = updateSectionProperties(doc, { sectionIndex, ...mutation.newSection }, ctx).changed;
+        }
+        body.insertBefore(boundaryParagraph, paragraphInsertionReference(anchor));
+        boundaryInserted = true;
+        const insertedBoundaryParagraphId = insertSingleParagraphBookmark(doc, boundaryParagraph, bookmarkReservation);
+        const sectionsAfter = getDocumentSections(doc);
+        if (sectionsAfter.length !== sectionCountBefore + 1) {
+            throw new SectionMutationError('SECTION_INSERTION_INVARIANT', 'Section insertion did not add exactly one live section.');
+        }
+        const precedingSection = sectionsAfter[sectionIndex];
+        const followingSection = sectionsAfter[sectionIndex + 1];
+        if (!precedingSection
+            || !followingSection
+            || precedingSection.anchorParagraphId !== insertedBoundaryParagraphId) {
+            throw new SectionMutationError('SECTION_INSERTION_INVARIANT', 'Inserted section boundaries were not projected at the expected indexes.');
+        }
+        return {
+            changed: true,
+            insertedBoundaryParagraphId,
+            precedingSectionIndex: sectionIndex,
+            followingSectionIndex: sectionIndex + 1,
+            sectionCountBefore,
+            sectionCountAfter: sectionsAfter.length,
+            precedingSection,
+            followingSection,
+        };
+    }
+    catch (error) {
+        if (boundaryInserted && boundaryParagraph.parentNode) {
+            removeInsertedBoundaryWithBookmarks(boundaryParagraph);
+        }
+        const liveParent = containingSection.sectPr.parentNode;
+        if (followingChanged && liveParent) {
+            liveParent.replaceChild(originalFollowingSectPr, containingSection.sectPr);
+        }
+        throw error;
+    }
+}
+/**
+ * Set one section's page-number restart while preserving all unrelated section
+ * properties and recording the prior state when a revision context is supplied.
+ *
+ * @conformance ECMA-376 edition 5, Part 1 § 17.6.12
+ * @conformance ECMA-376 edition 5, Part 1 § 17.13.5.32
+ * @see #654
+ */
+export function setSectionPageNumberStart(doc, mutation, ctx) {
+    const result = updateSectionProperties(doc, mutation, ctx);
+    return {
+        sectionIndex: result.sectionIndex,
+        changed: result.changed,
+        previousPageNumberStart: result.previousSection.pageNumberStart,
+        currentPageNumberStart: result.currentSection.pageNumberStart
+            ?? mutation.pageNumberStart,
+    };
+}
+//# sourceMappingURL=sections.js.map