@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/headers-footers/index.js

@@ -0,0 +1,1666 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+import { DetachedObjectError, DocxError } from '../../core/errors/docx-error';
+import { registerAlwaysOnBodyFeatureBootstrap } from '../document/body-always-on';
+import { bodyItemToBlock, isSupportedBodyItem, projectBlockToBodyItem, } from '../document/body-item-adapters';
+import { isParagraphBodyItem } from '../document/body-item';
+import { parseBodyBlocks, serializeBodyBlocks } from '../document/body-blocks';
+import { Paragraph } from '../document/paragraph';
+import { TextRange } from '../document/text-range';
+import { isWml, wmlElement } from '../document/wml';
+import { detachedBodyBlockParseContext } from '../../core/registry/block-handlers';
+import { allocateRelationshipId } from '../../core/opc/relationships';
+import { partByName, relationshipsForPart } from '../../core/opc/package';
+import { partName, partNameKey, resolveInternalTarget } from '../../core/opc/part-name';
+import { featureId, isFeatureRegistered, registerFeature, registerFeatureMultiPartHandler, replaceOrAddPackagePart, } from '../../core/registry/index';
+import { parseXml, serializeXml, WML_TRANSITIONAL_NAMESPACE } from '../../core/xml/index';
+import { defaultLetterPageSetup, finalSection, paragraphSectionBreak, setFinalSection, setParagraphSectionBreak, ownerDocumentOf, associatePageSetupDocument, ensureFinalSectionProperties, PageSetup, } from '../sections/index';
+import { HeaderFooter, registerHeadersFootersSlotFactory, resetHeadersFootersSlotFactoryForTests, registerHeadersFootersLinkToPreviousHandlers, resetHeadersFootersLinkToPreviousHandlersForTests, } from '../document/headers-footers';
+/** @public Compat value alias for instanceof / legacy callers. */
+export var Header = HeaderFooter;
+/** @public Compat value alias for instanceof / legacy callers. */
+export var Footer = HeaderFooter;
+export { HeaderFooter };
+var HEADERS_FOOTERS = featureId('headers-footers');
+/**
+ * Cross-bundle identity for HeadersFootersCatalog.
+ *
+ * Main entry and @syncfusion/ej2-docx/headers-footers can load separate module graphs of the
+ * same class. instanceof fails across those graphs; Symbol.for stays shared.
+ * @private
+ */
+var HEADERS_FOOTERS_CATALOG_BRAND = Symbol.for('@syncfusion/ej2-docx.HeadersFootersCatalog');
+/**
+ * @private
+ * Transitional header relationship (ECMA-376-4 §9.2.8). */
+export var HEADER_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/header';
+/**
+ * @private
+ * Transitional footer relationship (ECMA-376-4 §9.2.7). */
+export var FOOTER_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer';
+/**
+ * @private
+ * Strict header relationship (ECMA-376-1 §11.3.6). */
+export var STRICT_HEADER_RELATIONSHIP_TYPE = 'http://purl.oclc.org/ooxml/officeDocument/relationships/header';
+/**
+ * @private
+ * Strict footer relationship (ECMA-376-1 §11.3.9). */
+export var STRICT_FOOTER_RELATIONSHIP_TYPE = 'http://purl.oclc.org/ooxml/officeDocument/relationships/footer';
+/**
+ * @private
+ * ECMA-376-1 §11.3.6 Header part content type. */
+export var HEADER_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml';
+/**
+ * @private
+ * ECMA-376-1 §11.3.9 Footer part content type. */
+export var FOOTER_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml';
+var HEADER_RELATIONSHIP_TYPES = [HEADER_RELATIONSHIP_TYPE, STRICT_HEADER_RELATIONSHIP_TYPE];
+var FOOTER_RELATIONSHIP_TYPES = [FOOTER_RELATIONSHIP_TYPE, STRICT_FOOTER_RELATIONSHIP_TYPE];
+var ALL_RELATIONSHIP_TYPES = __spread(HEADER_RELATIONSHIP_TYPES, FOOTER_RELATIONSHIP_TYPES);
+var utf8Decoder = new TextDecoder('utf-8');
+var utf8 = new TextEncoder();
+function kindForRelationshipType(type) {
+    if (HEADER_RELATIONSHIP_TYPES.indexOf(type) !== -1) {
+        return 'header';
+    }
+    if (FOOTER_RELATIONSHIP_TYPES.indexOf(type) !== -1) {
+        return 'footer';
+    }
+    return undefined;
+}
+function contentTypeForKind(kind) {
+    return kind === 'header' ? HEADER_CONTENT_TYPE : FOOTER_CONTENT_TYPE;
+}
+function rootLocalName(kind) {
+    return kind === 'header' ? 'hdr' : 'ftr';
+}
+function relativeTarget(partNameValue) {
+    var logical = partNameValue.slice('/word/'.length);
+    return logical;
+}
+function firstParagraphText(blocks) {
+    var e_1, _a, e_2, _b;
+    try {
+        for (var blocks_1 = __values(blocks), blocks_1_1 = blocks_1.next(); !blocks_1_1.done; blocks_1_1 = blocks_1.next()) {
+            var block = blocks_1_1.value;
+            if (block.type !== 'paragraph') {
+                continue;
+            }
+            try {
+                for (var _c = __values(block.paragraph.items), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var inline = _d.value;
+                    if (inline instanceof TextRange) {
+                        return inline.text;
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return '';
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (blocks_1_1 && !blocks_1_1.done && (_a = blocks_1.return)) _a.call(blocks_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return undefined;
+}
+function blocksWithSimpleText(text, owner) {
+    if (owner === void 0) { owner = detachedParagraphOwner; }
+    var paragraph = Paragraph.fromXml(wmlElement('p', {
+        children: [
+            wmlElement('r', {
+                children: [
+                    wmlElement('t', {
+                        children: [{ kind: 'text', value: text }],
+                    }),
+                ],
+            }),
+        ],
+    }), owner);
+    return [{ type: 'paragraph', paragraph: paragraph }];
+}
+var detachedParagraphOwner = {
+    assertAttachedParagraph: function () {
+        return;
+    },
+    owningDocument: function () {
+        throw new DetachedObjectError('Header or footer content is not in a document');
+    },
+};
+/**
+ * Paragraph owner scoped to one header/footer catalog entry.
+ * Membership is checked against the live entry blocks.
+ */
+var HeaderFooterPartOwner = /** @class */ (function () {
+    function HeaderFooterPartOwner(document, relationshipId) {
+        this.document = document;
+        this.relationshipId = relationshipId;
+    }
+    HeaderFooterPartOwner.prototype.assertAttachedParagraph = function (target) {
+        var catalog = headersFootersFor(this.document);
+        var entry = catalog.entryForRelationship(this.relationshipId);
+        if (entry === undefined) {
+            throw new DetachedObjectError('Header or footer part is no longer loaded');
+        }
+        var found = entry.blocks.some(function (block) { return block.type === 'paragraph' && block.paragraph === target; });
+        if (!found) {
+            throw new DetachedObjectError('This paragraph is no longer in its header or footer');
+        }
+    };
+    /**
+     * @private
+     */
+    HeaderFooterPartOwner.prototype.owningDocument = function () {
+        return this.document;
+    };
+    return HeaderFooterPartOwner;
+}());
+function ownerForEntry(document, relationshipId) {
+    return new HeaderFooterPartOwner(document, relationshipId);
+}
+/**
+ * Bind a feature body block (table, content control, …) to the owning document when
+ * the value exposes `bindDocument`. Mirrors {@link Body} without exporting
+ * that helper from `document.ts`.
+ */
+function bindDocumentToFeatureBlock(value, document) {
+    if (typeof value !== 'object' || value === null || !('bindDocument' in value)) {
+        return;
+    }
+    var bindDocument = value.bindDocument;
+    bindDocument.call(value, document);
+}
+function releaseFeatureBlockContent(value) {
+    if (typeof value !== 'object' || value === null || !('releaseContent' in value)) {
+        return;
+    }
+    var releaseContent = value.releaseContent;
+    // TS 3.3: Function.call typing treats free functions as `this: void`.
+    if (typeof releaseContent === 'function') {
+        releaseContent.call(value);
+    }
+}
+function attachEntryParagraphs(document, entry) {
+    var e_3, _a;
+    var owner = ownerForEntry(document, entry.relationshipId);
+    try {
+        for (var _b = __values(entry.blocks), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var block = _c.value;
+            if (block.type === 'paragraph') {
+                block.paragraph.attach(owner);
+            }
+            else if (block.type === 'feature') {
+                bindDocumentToFeatureBlock(block.value, document);
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+}
+function detachEntryBlocks(blocks) {
+    var e_4, _a;
+    try {
+        for (var blocks_2 = __values(blocks), blocks_2_1 = blocks_2.next(); !blocks_2_1.done; blocks_2_1 = blocks_2.next()) {
+            var block = blocks_2_1.value;
+            if (block.type === 'paragraph') {
+                block.paragraph.detach();
+            }
+            else if (block.type === 'feature') {
+                releaseFeatureBlockContent(block.value);
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (blocks_2_1 && !blocks_2_1.done && (_a = blocks_2.return)) _a.call(blocks_2);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+}
+function parseHeaderFooterPart(part, relationship, kind) {
+    var root = parseXml(utf8Decoder.decode(part.data));
+    var localName = rootLocalName(kind);
+    if (!isWml(root, localName)) {
+        return undefined;
+    }
+    var blocks = parseBodyBlocks(root.children, detachedBodyBlockParseContext());
+    return {
+        partName: part.name,
+        relationshipId: relationship.id,
+        relationshipType: relationship.type,
+        kind: kind,
+        rootExtra: {
+            attributes: root.attributes,
+            namespaceDeclarations: root.namespaceDeclarations.length > 0
+                ? root.namespaceDeclarations
+                : [{ prefix: 'w', namespaceUri: WML_TRANSITIONAL_NAMESPACE }],
+        },
+        blocks: blocks,
+        dirty: false,
+        pendingRelationship: undefined,
+    };
+}
+/**
+ * In-memory header and footer parts linked from the Main Document.
+ * @private
+ */
+var HeadersFootersCatalog = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function HeadersFootersCatalog(entries) {
+        var e_5, _a;
+        this.entries = entries;
+        // TS 3.3 widens mapped pair literals to (T|U)[] rather than [T, U].
+        var byRelationshipIdEntries = [];
+        try {
+            for (var _b = __values(entries.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entry = _c.value;
+                byRelationshipIdEntries.push([entry.relationshipId, entry]);
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        this.byRelationshipId = new Map(byRelationshipIdEntries);
+        this.catalogDirty = false;
+        this.boundDocument = undefined;
+        // Shared across duplicate ESM graphs (main bundle vs feature subpath).
+        this[HEADERS_FOOTERS_CATALOG_BRAND] = true;
+    }
+    /**
+     * Bind this catalog to a live document so paragraph owners can resolve.
+     * Re-attaches existing paragraph blocks to entry-scoped owners.
+     * @private
+     */
+    HeadersFootersCatalog.prototype.bindDocument = function (document) {
+        var e_6, _a;
+        this.boundDocument = document;
+        try {
+            for (var _b = __values(this.entries.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entry = _c.value;
+                attachEntryParagraphs(document, entry);
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+    };
+    /**
+     * @private
+     */
+    HeadersFootersCatalog.prototype.entryForRelationship = function (relationshipId) {
+        return this.byRelationshipId.get(relationshipId);
+    };
+    HeadersFootersCatalog.prototype.requireBoundDocument = function () {
+        if (this.boundDocument === undefined) {
+            throw new DocxError('content/invalid-header-footer-reference', 'Headers/footers catalog is not bound to a document');
+        }
+        return this.boundDocument;
+    };
+    HeadersFootersCatalog.prototype.requireEntry = function (relationshipId) {
+        var entry = this.byRelationshipId.get(relationshipId);
+        if (entry === undefined) {
+            throw new DocxError('content/invalid-header-footer-reference', "Header/footer relationship " + relationshipId + " is not loaded in this document");
+        }
+        return entry;
+    };
+    /**
+     * @private
+     */
+    HeadersFootersCatalog.prototype.isDirty = function () {
+        var e_7, _a;
+        if (this.catalogDirty) {
+            return true;
+        }
+        try {
+            for (var _b = __values(this.entries.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entry = _c.value;
+                if (entry.dirty || entry.pendingRelationship !== undefined) {
+                    return true;
+                }
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        return false;
+    };
+    /**
+     * @private
+     */
+    HeadersFootersCatalog.prototype.applyToPackage = function (pkg, mainPartName) {
+        var e_8, _a;
+        var next = pkg;
+        var _loop_1 = function (entry) {
+            if (!entry.dirty && entry.pendingRelationship === undefined) {
+                return "continue";
+            }
+            var xml = serializeHeaderFooterPart(entry);
+            var rel = entry.pendingRelationship != null ? entry.pendingRelationship : relationshipsForPart(next, mainPartName).items.find(function (item) { return item.id === entry.relationshipId; });
+            next = replaceOrAddPackagePart(next, mainPartName, entry.partName, contentTypeForKind(entry.kind), xml, rel);
+            entry.dirty = false;
+            entry.pendingRelationship = undefined;
+        };
+        try {
+            for (var _b = __values(this.entries.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entry = _c.value;
+                _loop_1(entry);
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        this.catalogDirty = false;
+        return next;
+    };
+    /**
+     * @private
+     */
+    HeadersFootersCatalog.prototype.ensureDefaultPart = function (kind, section, usedRelIds, usedPartNames) {
+        return this.ensurePart(kind, section, 'default', usedRelIds, usedPartNames);
+    };
+    /**
+     * @private
+     */
+    HeadersFootersCatalog.prototype.ensurePart = function (kind, section, refType, usedRelIds, usedPartNames) {
+        var existingRel = section.headerFooterReferenceId(kind, refType);
+        if (existingRel !== undefined) {
+            var entry_1 = this.byRelationshipId.get(existingRel);
+            if (entry_1 !== undefined) {
+                return { entry: entry_1, relationshipId: existingRel };
+            }
+        }
+        // Include catalog-pending part names so a second allocate on the same kind
+        // does not collide with a part already added to the catalog but not yet in the package.
+        var catalogPartNameKeys = new Set(__spread(this.entries.keys()).map(function (n) { return partNameKey(n); }));
+        var allUsedPartNames = new Set(__spread(usedPartNames, catalogPartNameKeys));
+        var partNameValue = allocatePartName(kind, allUsedPartNames);
+        // Accumulate all tried IDs to avoid cycling back to an already-tried value.
+        // usedRelIds reflects only package relationships; catalog entries may not be
+        // persisted yet, so we must also exclude every ID already in this catalog.
+        var allUsedRelIds = new Set(__spread(usedRelIds, this.byRelationshipId.keys()));
+        var relId = allocateRelationshipId(allUsedRelIds);
+        var relationshipType = kind === 'header' ? HEADER_RELATIONSHIP_TYPE : FOOTER_RELATIONSHIP_TYPE;
+        var entry = {
+            partName: partNameValue,
+            relationshipId: relId,
+            relationshipType: relationshipType,
+            kind: kind,
+            rootExtra: {
+                attributes: [],
+                namespaceDeclarations: [{ prefix: 'w', namespaceUri: WML_TRANSITIONAL_NAMESPACE }],
+            },
+            // Always-present section slots stay empty until content is written.
+            // setSimpleText / authoring helpers still add paragraphs explicitly.
+            blocks: [],
+            dirty: true,
+            pendingRelationship: {
+                id: relId,
+                type: relationshipType,
+                target: relativeTarget(partNameValue),
+                extraAttributes: [],
+                children: [],
+            },
+        };
+        this.entries.set(partNameValue, entry);
+        this.byRelationshipId.set(relId, entry);
+        this.catalogDirty = true;
+        return { entry: entry, relationshipId: relId };
+    };
+    /**
+     * @private
+   * Whether a header or footer relationship id is loaded in this catalog. */
+    HeadersFootersCatalog.prototype.hasRelationship = function (relationshipId) {
+        return this.byRelationshipId.has(relationshipId);
+    };
+    /**
+     * Relationship ids for loaded parts of the given kind, in catalog order.
+     * @private
+     */
+    HeadersFootersCatalog.prototype.relationshipIds = function (kind) {
+        var e_9, _a;
+        var ids = [];
+        try {
+            for (var _b = __values(this.entries.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entry = _c.value;
+                if (entry.kind === kind) {
+                    ids.push(entry.relationshipId);
+                }
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+        return ids;
+    };
+    /**
+     * Body items for a header/footer part by relationship id (paragraphs, tables,
+     * block content controls, residuals), in document order.
+     *
+     * Empty when the relationship is missing. When the catalog is document-bound,
+     * paragraphs and feature blocks are attached for mutation.
+     * @private
+     */
+    HeadersFootersCatalog.prototype.itemsForRelationship = function (relationshipId) {
+        var e_10, _a;
+        var entry = this.byRelationshipId.get(relationshipId);
+        if (entry === undefined) {
+            return [];
+        }
+        if (this.boundDocument !== undefined) {
+            attachEntryParagraphs(this.boundDocument, entry);
+        }
+        var projected = [];
+        try {
+            for (var _b = __values(entry.blocks), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var block = _c.value;
+                var item = projectBlockToBodyItem(block);
+                if (item !== undefined) {
+                    projected.push(item);
+                }
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+        return projected;
+    };
+    /**
+     * Modeled paragraphs for a header/footer part by relationship id.
+     *
+     * Empty when the relationship is missing or has no paragraph blocks.
+     * When the catalog is document-bound, paragraphs are attached for mutation.
+     * @private
+     */
+    HeadersFootersCatalog.prototype.paragraphsForRelationship = function (relationshipId) {
+        var e_11, _a;
+        var entry = this.byRelationshipId.get(relationshipId);
+        if (entry === undefined) {
+            return [];
+        }
+        if (this.boundDocument !== undefined) {
+            attachEntryParagraphs(this.boundDocument, entry);
+        }
+        var paragraphs = [];
+        try {
+            for (var _b = __values(this.itemsForRelationship(relationshipId)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var item = _c.value;
+                if (isParagraphBodyItem(item)) {
+                    paragraphs.push(item);
+                }
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+        return paragraphs;
+    };
+    /**
+     * @private
+     */
+    HeadersFootersCatalog.prototype.setSimpleText = function (entry, text) {
+        var bound = boundHeaderFooterByRelId.get(entry.relationshipId);
+        detachEntryBlocks(entry.blocks);
+        if (bound !== undefined) {
+            entry.blocks = blocksWithSimpleText(text, bound);
+            // Keep Body store in sync without re-dirtying via lifecycle sync.
+            bound.replaceItemsSilent(entry.blocks.slice());
+        }
+        else if (this.boundDocument !== undefined) {
+            var owner = ownerForEntry(this.boundDocument, entry.relationshipId);
+            entry.blocks = blocksWithSimpleText(text, owner);
+        }
+        else {
+            entry.blocks = blocksWithSimpleText(text);
+        }
+        entry.dirty = true;
+    };
+    /**
+     * Replace the body of a loaded part with a single plain-text paragraph.
+     *
+     * Clears any prior rich body (multiple paragraphs, tables, opaque blocks).
+     *
+     * @throws DocxError `content/invalid-header-footer-reference` when the id is unknown.
+     * @private
+     */
+    HeadersFootersCatalog.prototype.setSimpleTextForRelationship = function (relationshipId, text) {
+        var entry = this.requireEntry(relationshipId);
+        this.setSimpleText(entry, text);
+    };
+    /**
+     * Insert a body item at `index` in a header/footer part (`0…length` inclusive).
+     *
+     * Attaches paragraphs and feature blocks when the catalog is document-bound.
+     * Returns the same `item` reference for chaining.
+     *
+     * @throws RangeError if `index` is out of range.
+     * @throws DocxError when the relationship id is unknown or the catalog is unbound.
+     * @private
+     */
+    HeadersFootersCatalog.prototype.insertBodyItemAtForRelationship = function (relationshipId, index, item) {
+        var _this = this;
+        var document = this.requireBoundDocument();
+        var entry = this.requireEntry(relationshipId);
+        if (!isSupportedBodyItem(item)) {
+            throw new TypeError('Unsupported body item type');
+        }
+        // Public index is over projected BodyItem instances (opaque blocks omitted).
+        var publicItems = this.itemsForRelationship(relationshipId);
+        if (index < 0 || index > publicItems.length) {
+            throw new RangeError("Body item index " + String(index) + " is out of range");
+        }
+        var block = bodyItemToBlock(item);
+        var bound = boundHeaderFooterByRelId.get(relationshipId);
+        if (block.type === 'paragraph') {
+            // Prefer HeaderFooter Body as paragraph owner when a live view is bound.
+            block.paragraph.attach(bound !== undefined ? bound : ownerForEntry(document, relationshipId));
+        }
+        else if (block.type === 'feature') {
+            bindDocumentToFeatureBlock(block.value, document);
+        }
+        var storeIndex;
+        if (index === publicItems.length) {
+            storeIndex = entry.blocks.length;
+        }
+        else {
+            var target_1 = publicItems[index];
+            storeIndex = entry.blocks.findIndex(function (candidate) {
+                var projected = projectBlockToBodyItem(candidate);
+                return projected !== undefined && _this.publicBodyItemsEqual(projected, target_1);
+            });
+            if (storeIndex < 0) {
+                throw new DetachedObjectError('Body item index is inconsistent');
+            }
+        }
+        var next = entry.blocks.slice();
+        next.splice(storeIndex, 0, block);
+        entry.blocks = next;
+        entry.dirty = true;
+        if (bound !== undefined) {
+            // Catalog wrote first; keep Body store identical without re-dirty via sync.
+            bound.replaceItemsSilent(entry.blocks.slice());
+        }
+        return item;
+    };
+    /**
+     * Remove the body item at `index` in a header/footer part (`0…length-1`).
+     * Paragraphs detach; feature blocks may release content.
+     *
+     * @throws RangeError if `index` is out of range.
+     * @throws DocxError when the relationship id is unknown.
+     * @private
+     */
+    HeadersFootersCatalog.prototype.removeBodyItemAtForRelationship = function (relationshipId, index) {
+        var _this = this;
+        var entry = this.requireEntry(relationshipId);
+        var publicItems = this.itemsForRelationship(relationshipId);
+        if (index < 0 || index >= publicItems.length) {
+            throw new RangeError("Body item index " + String(index) + " is out of range");
+        }
+        var target = publicItems[index];
+        if (target === undefined) {
+            throw new RangeError("Body item index " + String(index) + " is out of range");
+        }
+        var storeIndex = entry.blocks.findIndex(function (candidate) {
+            var projected = projectBlockToBodyItem(candidate);
+            return projected !== undefined && _this.publicBodyItemsEqual(projected, target);
+        });
+        if (storeIndex < 0) {
+            throw new DetachedObjectError('Body item index is inconsistent');
+        }
+        var block = entry.blocks[storeIndex];
+        if (block === undefined) {
+            throw new RangeError("Body item index " + String(index) + " is out of range");
+        }
+        var next = entry.blocks.slice();
+        next.splice(storeIndex, 1);
+        entry.blocks = next;
+        if (block.type === 'paragraph') {
+            block.paragraph.detach();
+        }
+        else if (block.type === 'feature') {
+            releaseFeatureBlockContent(block.value);
+        }
+        entry.dirty = true;
+        var bound = boundHeaderFooterByRelId.get(relationshipId);
+        if (bound !== undefined) {
+            bound.replaceItemsSilent(entry.blocks.slice());
+        }
+    };
+    /**
+     * Remove a body item from a header/footer part by collection or payload identity.
+     *
+     * @throws DetachedObjectError when the item is not in the part.
+     * @throws DocxError when the relationship id is unknown.
+     * @private
+     */
+    HeadersFootersCatalog.prototype.removeBodyItemForRelationship = function (relationshipId, item) {
+        var _this = this;
+        var entry = this.requireEntry(relationshipId);
+        var at = entry.blocks.findIndex(function (candidate) {
+            var projected = projectBlockToBodyItem(candidate);
+            return projected !== undefined && _this.publicBodyItemsEqual(projected, item);
+        });
+        if (at === -1) {
+            throw new DetachedObjectError('Body item is not in this header or footer');
+        }
+        var publicItems = this.itemsForRelationship(relationshipId);
+        var publicIndex = -1;
+        for (var i = 0; i < publicItems.length; i += 1) {
+            if (this.publicBodyItemsEqual(publicItems[i], item)) {
+                publicIndex = i;
+                break;
+            }
+        }
+        if (publicIndex === -1) {
+            throw new DetachedObjectError('Body item is not in this header or footer');
+        }
+        this.removeBodyItemAtForRelationship(relationshipId, publicIndex);
+    };
+    /**
+     * Append a paragraph to a header/footer part body.
+     *
+     * @param options - Optional style id and/or initial text (mirrors {@link Body.appendParagraph}).
+     * @throws DocxError when the relationship id is unknown or the catalog is unbound.
+     * @private
+     */
+    HeadersFootersCatalog.prototype.appendParagraphForRelationship = function (relationshipId, options) {
+        var document = this.requireBoundDocument();
+        var entry = this.requireEntry(relationshipId);
+        var bound = boundHeaderFooterByRelId.get(relationshipId);
+        var owner = bound !== undefined ? bound : ownerForEntry(document, relationshipId);
+        var paragraph = new Paragraph(owner);
+        this.insertBodyItemAtForRelationship(relationshipId, this.itemsForRelationship(relationshipId).length, paragraph);
+        if ((options == null ? undefined : options.style) !== undefined) {
+            // Route through the styles facade so built-in ids/names resolve.
+            paragraph.applyStyle(options.style);
+        }
+        if ((options == null ? undefined : options.text) !== undefined) {
+            paragraph.appendText(options.text);
+        }
+        return paragraph;
+    };
+    /**
+     * Insert an empty paragraph among existing paragraphs of a part.
+     * Opaque / non-paragraph siblings keep their relative places.
+     *
+     * @param index - Index in the paragraph list, `0…length` inclusive.
+     * @throws RangeError if `index` is out of range.
+     * @throws DocxError when the relationship id is unknown or the catalog is unbound.
+     * @private
+     */
+    HeadersFootersCatalog.prototype.insertParagraphForRelationship = function (relationshipId, index) {
+        var document = this.requireBoundDocument();
+        this.requireEntry(relationshipId);
+        var paragraphs = this.paragraphsForRelationship(relationshipId);
+        if (index < 0 || index > paragraphs.length) {
+            throw new RangeError("Paragraph index " + String(index) + " is out of range");
+        }
+        var bound = boundHeaderFooterByRelId.get(relationshipId);
+        var owner = bound !== undefined ? bound : ownerForEntry(document, relationshipId);
+        var paragraph = new Paragraph(owner);
+        if (index === paragraphs.length) {
+            this.insertBodyItemAtForRelationship(relationshipId, this.itemsForRelationship(relationshipId).length, paragraph);
+        }
+        else {
+            var target_2 = paragraphs[index];
+            if (target_2 === undefined) {
+                throw new RangeError("Paragraph index " + String(index) + " is out of range");
+            }
+            var publicItems = this.itemsForRelationship(relationshipId);
+            var at = publicItems.findIndex(function (item) { return isParagraphBodyItem(item) && item === target_2; });
+            if (at < 0) {
+                throw new DetachedObjectError('Paragraph index is inconsistent');
+            }
+            this.insertBodyItemAtForRelationship(relationshipId, at, paragraph);
+        }
+        return paragraph;
+    };
+    /**
+     * Remove a paragraph from a header/footer part. Further mutation throws {@link DetachedObjectError}.
+     *
+     * @throws DetachedObjectError when the paragraph is not in the part.
+     * @throws DocxError when the relationship id is unknown.
+     * @private
+     */
+    HeadersFootersCatalog.prototype.removeParagraphForRelationship = function (relationshipId, paragraph) {
+        this.removeBodyItemForRelationship(relationshipId, paragraph);
+    };
+    /**
+     * Remove all body blocks from a header/footer part (empty `w:hdr` / `w:ftr`).
+     *
+     * @throws DocxError when the relationship id is unknown.
+     * @private
+     */
+    HeadersFootersCatalog.prototype.clearForRelationship = function (relationshipId) {
+        var entry = this.requireEntry(relationshipId);
+        detachEntryBlocks(entry.blocks);
+        entry.blocks = [];
+        entry.dirty = true;
+        var bound = boundHeaderFooterByRelId.get(relationshipId);
+        if (bound !== undefined) {
+            bound.replaceItemsSilent([]);
+        }
+    };
+    /**
+     * @private
+     */
+    HeadersFootersCatalog.prototype.textForRelationship = function (relationshipId) {
+        if (relationshipId === undefined) {
+            return undefined;
+        }
+        var entry = this.byRelationshipId.get(relationshipId);
+        if (entry === undefined) {
+            return undefined;
+        }
+        return firstParagraphText(entry.blocks);
+    };
+    /**
+     * True when two body items refer to the same payload
+     * (paragraph instance, feature value, or opaque XML node).
+     */
+    HeadersFootersCatalog.prototype.publicBodyItemsEqual = function (a, b) {
+        return a === b;
+    };
+    HeadersFootersCatalog.prototype.storeBlocksEqual = function (a, b) {
+        if (a.type !== b.type) {
+            return false;
+        }
+        if (a.type === 'paragraph' && b.type === 'paragraph') {
+            return a.paragraph === b.paragraph;
+        }
+        if (a.type === 'feature' && b.type === 'feature') {
+            return a.featureId === b.featureId && a.value === b.value;
+        }
+        if (a.type === 'opaque' && b.type === 'opaque') {
+            return a.xml === b.xml;
+        }
+        return false;
+    };
+    return HeadersFootersCatalog;
+}());
+export { HeadersFootersCatalog };
+/**
+ * Bound HeaderFooter instances by relationship id (document-scoped views).
+ * Catalog text helpers and Body mutations stay in sync through this map.
+ * @private
+ */
+var boundHeaderFooterByRelId = new Map();
+/**
+ * @private
+ */
+function registerBoundHeaderFooter(relationshipId, hf) {
+    if (relationshipId === '') {
+        return;
+    }
+    boundHeaderFooterByRelId.set(relationshipId, hf);
+}
+/**
+ * Keep bound HeaderFooter Body store aligned after catalog-only mutations.
+ * @private
+ */
+function refreshBoundHeaderFooterFromEntry(relationshipId, entry) {
+    var e_12, _a;
+    var bound = boundHeaderFooterByRelId.get(relationshipId);
+    if (bound === undefined) {
+        return;
+    }
+    var document = bound.owningDocument();
+    try {
+        for (var _b = __values(entry.blocks), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var block = _c.value;
+            if (block.type === 'paragraph') {
+                block.paragraph.attach(bound);
+            }
+            else if (block.type === 'feature') {
+                bindDocumentToFeatureBlock(block.value, document);
+            }
+        }
+    }
+    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_12) throw e_12.error; }
+    }
+    bound.replaceItemsSilent(entry.blocks.slice());
+}
+/**
+ * Attach catalog blocks to a HeaderFooter Body store without marking dirty.
+ * @private
+ */
+function loadCatalogBlocksIntoHeaderFooter(document, entry, hf) {
+    var e_13, _a;
+    try {
+        // Prefer Body as paragraph owner when bound; keeps assertAttached on Body.
+        for (var _b = __values(entry.blocks), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var block = _c.value;
+            if (block.type === 'paragraph') {
+                block.paragraph.attach(hf);
+            }
+            else if (block.type === 'feature') {
+                bindDocumentToFeatureBlock(block.value, document);
+            }
+        }
+    }
+    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_13) throw e_13.error; }
+    }
+    hf.replaceItemsSilent(entry.blocks.slice());
+}
+/**
+ * Push HeaderFooter Body store into the catalog entry and mark dirty.
+ * @private
+ */
+function syncHeaderFooterToCatalog(document, relationshipId, hf) {
+    if (relationshipId === '') {
+        return;
+    }
+    var catalog = headersFootersFor(document);
+    var entry = catalog.entryForRelationship(relationshipId);
+    if (entry === undefined) {
+        return;
+    }
+    // Do not detach: paragraphs remain owned by the HeaderFooter Body.
+    entry.blocks = hf.rawBlocks().slice();
+    entry.dirty = true;
+}
+/**
+ * Live HeaderFooter for an already-materialized relationship id.
+ * @private
+ */
+function createHeaderFooterForRelationship(document, relationshipId, kind, refType, section) {
+    if (refType === void 0) { refType = 'default'; }
+    var existing = boundHeaderFooterByRelId.get(relationshipId);
+    if (existing !== undefined) {
+        return existing;
+    }
+    var catalog = headersFootersFor(document);
+    var entry = catalog.entryForRelationship(relationshipId);
+    var blocks = entry !== undefined ? entry.blocks.slice() : [];
+    var hf = new HeaderFooter(section, kind, refType, blocks, document, relationshipId);
+    if (entry !== undefined) {
+        loadCatalogBlocksIntoHeaderFooter(document, entry, hf);
+    }
+    hf.bindLifecycleHandlers(function () {
+        // Already materialized.
+    }, function () {
+        syncHeaderFooterToCatalog(document, hf.relationshipId, hf);
+    });
+    registerBoundHeaderFooter(relationshipId, hf);
+    return hf;
+}
+/**
+ * Lazy always-present header/footer slot bound to a DocSection + ref type.
+ * Package part + sectPr reference are created on first content mutation.
+ * @private
+ */
+function createSectionHeaderFooterSlot(section, kind, refType) {
+    var document = section.owningDocument();
+    var hf = new HeaderFooter(section, kind, refType, [], document, '');
+    var tryBindExisting = function () {
+        if (hf.relationshipId !== '') {
+            return;
+        }
+        var props = section.pageSetup;
+        if (!(props instanceof PageSetup)) {
+            return;
+        }
+        var relId = props.headerFooterReferenceId(kind, refType);
+        if (relId === undefined) {
+            return;
+        }
+        var catalog = headersFootersFor(document);
+        if (!catalog.hasRelationship(relId)) {
+            return;
+        }
+        hf.bindRelationshipId(relId);
+        registerBoundHeaderFooter(relId, hf);
+        var entry = catalog.entryForRelationship(relId);
+        if (entry !== undefined) {
+            loadCatalogBlocksIntoHeaderFooter(document, entry, hf);
+        }
+    };
+    var ensureBound = function () {
+        tryBindExisting();
+        if (hf.relationshipId !== '') {
+            return;
+        }
+        var props = ensurePageSetupForSlot(section);
+        var catalog = headersFootersFor(document);
+        var ensured = catalog.ensurePart(kind, props, refType, usedRelationshipIds(document), usedPartNameKeys(document));
+        props.setHeaderFooterReference(kind, refType, ensured.relationshipId);
+        hf.bindRelationshipId(ensured.relationshipId);
+        registerBoundHeaderFooter(ensured.relationshipId, hf);
+        loadCatalogBlocksIntoHeaderFooter(document, ensured.entry, hf);
+    };
+    hf.bindLifecycleHandlers(function () {
+        ensureBound();
+    }, function () {
+        if (hf.relationshipId === '') {
+            return;
+        }
+        syncHeaderFooterToCatalog(document, hf.relationshipId, hf);
+    });
+    tryBindExisting();
+    return hf;
+}
+/**
+ * Resolve live {@link PageSetup} on a section for header/footer writes.
+ * Final section uses dual-hold ensure; non-final sections seed pageSetup when missing.
+ *
+ * @private
+ */
+function ensurePageSetupForSlot(section) {
+    var document = section.owningDocument();
+    var sections = document.sections;
+    var index = sections.indexOf(section);
+    var isFinal = index >= 0 && index === sections.count - 1;
+    if (isFinal) {
+        var props = ensureFinalSectionProperties(document);
+        section.setPageSetup(props);
+        return props;
+    }
+    var existing = section.pageSetup;
+    if (existing instanceof PageSetup) {
+        associatePageSetupDocument(existing, document);
+        return existing;
+    }
+    var seeded = defaultLetterPageSetup();
+    associatePageSetupDocument(seeded, document);
+    section.setPageSetup(seeded);
+    // Dual-hold non-final closer when the body already has a last paragraph.
+    var blocks = section.body.listBlocks();
+    for (var i = blocks.length - 1; i >= 0; i -= 1) {
+        var block = blocks[i];
+        if (block !== undefined && block.type === 'paragraph') {
+            setParagraphSectionBreak(block.paragraph, seeded);
+            break;
+        }
+    }
+    return seeded;
+}
+/**
+ * True when `part` is a headers/footers catalog from this module graph or a
+ * duplicate published chunk of the same implementation.
+ * @private
+ */
+function isHeadersFootersCatalog(part) {
+    if (part instanceof HeadersFootersCatalog) {
+        return true;
+    }
+    if (part === null || typeof part !== 'object') {
+        return false;
+    }
+    var candidate = part;
+    if (candidate[HEADERS_FOOTERS_CATALOG_BRAND] === true) {
+        return true;
+    }
+    // Duck-type fallback for catalogs built before the brand existed.
+    return typeof candidate.bindDocument === 'function'
+        && typeof candidate.ensurePart === 'function'
+        && typeof candidate.setSimpleText === 'function'
+        && typeof candidate.textForRelationship === 'function'
+        && typeof candidate.applyToPackage === 'function';
+}
+/**
+ * Headers and footers catalog for a document.
+ *
+ * On a loaded package this is the catalog built from header/footer parts.
+ * On a newly authored document there may be no header/footer parts yet, so this
+ * function attaches an empty catalog on first use when the feature is registered.
+ *
+ * Accepts catalogs from either the main entry graph or `@syncfusion/ej2-docx/headers-footers`
+ * (duplicate class identity across published chunks).
+ *
+ * @throws DocxError `feature/not-registered` when the module was not registered.
+ * @private
+ */
+export function headersFootersFor(document) {
+    var part = document.featurePart(HEADERS_FOOTERS);
+    if (isHeadersFootersCatalog(part)) {
+        part.bindDocument(document);
+        return part;
+    }
+    if (part !== undefined) {
+        throw new DocxError('feature/not-registered', 'Headers/footers feature state was replaced with an unexpected part type');
+    }
+    if (!isFeatureRegistered(HEADERS_FOOTERS)) {
+        throw new DocxError('feature/not-registered', 'Headers/footers feature is not registered; call registerHeadersFootersFeature() before use');
+    }
+    var created = new HeadersFootersCatalog(new Map());
+    created.bindDocument(document);
+    document.setFeaturePart(HEADERS_FOOTERS, created);
+    return created;
+}
+/**
+ * Live {@link HeaderFooter} views for every loaded header part, in catalog order.
+ * @private
+ */
+export function headersInDocument(document) {
+    return headersFootersFor(document)
+        .relationshipIds('header')
+        .map(function (relationshipId) { return createHeaderFooterForRelationship(document, relationshipId, 'header'); });
+}
+/**
+ * Live {@link HeaderFooter} views for every loaded footer part, in catalog order.
+ * @private
+ */
+export function footersInDocument(document) {
+    return headersFootersFor(document)
+        .relationshipIds('footer')
+        .map(function (relationshipId) { return createHeaderFooterForRelationship(document, relationshipId, 'footer'); });
+}
+/**
+ * Live header linked from a section's `w:headerReference`, when present and loaded.
+ * @private
+ */
+export function headerForSection(document, section, refType) {
+    if (refType === void 0) { refType = 'default'; }
+    var relationshipId = section.headerFooterReferenceId('header', refType);
+    if (relationshipId === undefined) {
+        return undefined;
+    }
+    var catalog = headersFootersFor(document);
+    if (!catalog.hasRelationship(relationshipId)) {
+        return undefined;
+    }
+    return createHeaderFooterForRelationship(document, relationshipId, 'header', refType);
+}
+/**
+ * Live footer linked from a section's `w:footerReference`, when present and loaded.
+ * @private
+ */
+export function footerForSection(document, section, refType) {
+    if (refType === void 0) { refType = 'default'; }
+    var relationshipId = section.headerFooterReferenceId('footer', refType);
+    if (relationshipId === undefined) {
+        return undefined;
+    }
+    var catalog = headersFootersFor(document);
+    if (!catalog.hasRelationship(relationshipId)) {
+        return undefined;
+    }
+    return createHeaderFooterForRelationship(document, relationshipId, 'footer', refType);
+}
+/**
+ * Default header for the body-final section, when linked and loaded.
+ * @private
+ */
+export function defaultHeader(document) {
+    var section = finalSection(document);
+    if (section === undefined) {
+        return undefined;
+    }
+    return headerForSection(document, section, 'default');
+}
+/**
+ * Default footer for the body-final section, when linked and loaded.
+ * @private
+ */
+export function defaultFooter(document) {
+    var section = finalSection(document);
+    if (section === undefined) {
+        return undefined;
+    }
+    return footerForSection(document, section, 'default');
+}
+/**
+ * First-page header for the body-final section, when linked and loaded.
+ * @private
+ */
+export function firstHeader(document) {
+    var section = finalSection(document);
+    if (section === undefined) {
+        return undefined;
+    }
+    return headerForSection(document, section, 'first');
+}
+/**
+ * Even-page header for the body-final section, when linked and loaded.
+ * @private
+ */
+export function evenHeader(document) {
+    var section = finalSection(document);
+    if (section === undefined) {
+        return undefined;
+    }
+    return headerForSection(document, section, 'even');
+}
+/**
+ * First-page footer for the body-final section, when linked and loaded.
+ * @private
+ */
+export function firstFooter(document) {
+    var section = finalSection(document);
+    if (section === undefined) {
+        return undefined;
+    }
+    return footerForSection(document, section, 'first');
+}
+/**
+ * Even-page footer for the body-final section, when linked and loaded.
+ * @private
+ */
+export function evenFooter(document) {
+    var section = finalSection(document);
+    if (section === undefined) {
+        return undefined;
+    }
+    return footerForSection(document, section, 'even');
+}
+function serializeHeaderFooterPart(entry) {
+    var root = wmlElement(rootLocalName(entry.kind), {
+        attributes: entry.rootExtra.attributes,
+        namespaceDeclarations: entry.rootExtra.namespaceDeclarations,
+        children: serializeBodyBlocks(entry.blocks),
+    });
+    return utf8.encode(serializeXml(root));
+}
+function allocatePartName(kind, used) {
+    var stem = kind === 'header' ? 'header' : 'footer';
+    var index = 1;
+    while (used.has(partNameKey(partName("/word/" + stem + String(index) + ".xml")))) {
+        index += 1;
+    }
+    return partName("/word/" + stem + String(index) + ".xml");
+}
+function loadCatalog(pkg, mainPartName) {
+    var e_14, _a;
+    var rels = relationshipsForPart(pkg, mainPartName);
+    var entries = new Map();
+    try {
+        for (var _b = __values(rels.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var rel = _c.value;
+            var kind = kindForRelationshipType(rel.type);
+            if (kind === undefined) {
+                continue;
+            }
+            var target = resolveInternalTarget(rel.target, mainPartName);
+            var part = partByName(pkg, target);
+            if (part === undefined) {
+                continue;
+            }
+            var loaded = parseHeaderFooterPart(part, rel, kind);
+            if (loaded !== undefined) {
+                entries.set(loaded.partName, loaded);
+            }
+        }
+    }
+    catch (e_14_1) { e_14 = { error: e_14_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_14) throw e_14.error; }
+    }
+    return new HeadersFootersCatalog(entries);
+}
+function usedRelationshipIds(document) {
+    var e_15, _a;
+    var main = partName('/word/document.xml');
+    var used = new Set();
+    try {
+        for (var _b = __values(relationshipsForPart(document.opcPackage(), main).items), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var rel = _c.value;
+            used.add(rel.id);
+        }
+    }
+    catch (e_15_1) { e_15 = { error: e_15_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_15) throw e_15.error; }
+    }
+    return used;
+}
+function usedPartNameKeys(document) {
+    var e_16, _a;
+    var used = new Set();
+    try {
+        for (var _b = __values(document.opcPackage().parts), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var part = _c.value;
+            used.add(partNameKey(part.name));
+        }
+    }
+    catch (e_16_1) { e_16 = { error: e_16_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_16) throw e_16.error; }
+    }
+    return used;
+}
+function sectionForWrite(document) {
+    var existing = finalSection(document);
+    if (existing !== undefined) {
+        return existing;
+    }
+    var seeded = defaultLetterPageSetup();
+    // Pin the live model so subsequent header/footer writes keep object identity.
+    // Prefer setFinalSection over document.lastSection so feature checks do not
+    // depend on module-augmentation merge for the relative WordDocument import.
+    setFinalSection(document, seeded);
+    return seeded;
+}
+var registered = false;
+/**
+ * @private
+ * Test hook */
+export function resetHeadersFootersFeatureForTests() {
+    registered = false;
+    boundHeaderFooterByRelId.clear();
+    resetHeadersFootersSlotFactoryForTests();
+    resetHeadersFootersLinkToPreviousHandlersForTests();
+}
+/**
+ * @private
+ * Register the headers/footers multi-part handler. Idempotent. */
+export function registerHeadersFootersFeature() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    registerFeature({ id: HEADERS_FOOTERS });
+    registerFeatureMultiPartHandler({
+        featureId: HEADERS_FOOTERS,
+        relationshipTypes: ALL_RELATIONSHIP_TYPES,
+        loadParts: function (pkg, ctx) {
+            return loadCatalog(pkg, ctx.mainPartName);
+        },
+    });
+    registerHeadersFootersSlotFactory({
+        createHeader: function (section, refType) {
+            return createSectionHeaderFooterSlot(section, 'header', refType);
+        },
+        createFooter: function (section, refType) {
+            return createSectionHeaderFooterSlot(section, 'footer', refType);
+        },
+    });
+    registerHeadersFootersLinkToPreviousHandlers(function (section, link) {
+        var props = section.pageSetup;
+        if (!(props instanceof PageSetup)) {
+            return;
+        }
+        var document = section.owningDocument();
+        if (link) {
+            props.setHeaderFooterReference('header', 'default', undefined);
+            props.setHeaderFooterReference('header', 'first', undefined);
+            props.setHeaderFooterReference('header', 'even', undefined);
+            props.setHeaderFooterReference('footer', 'default', undefined);
+            props.setHeaderFooterReference('footer', 'first', undefined);
+            props.setHeaderFooterReference('footer', 'even', undefined);
+            return;
+        }
+        // Materialize empty local parts so the section no longer inherits.
+        getOrCreateSectionHeader(document, props, 'default');
+        getOrCreateSectionHeader(document, props, 'first');
+        getOrCreateSectionHeader(document, props, 'even');
+        getOrCreateSectionFooter(document, props, 'default');
+        getOrCreateSectionFooter(document, props, 'first');
+        getOrCreateSectionFooter(document, props, 'even');
+    }, function (section) {
+        var props = section.pageSetup;
+        if (!(props instanceof PageSetup)) {
+            return true;
+        }
+        var hasLocal = props.headerFooterReferenceId('header', 'default') !== undefined
+            || props.headerFooterReferenceId('header', 'first') !== undefined
+            || props.headerFooterReferenceId('header', 'even') !== undefined
+            || props.headerFooterReferenceId('footer', 'default') !== undefined
+            || props.headerFooterReferenceId('footer', 'first') !== undefined
+            || props.headerFooterReferenceId('footer', 'even') !== undefined;
+        return !hasLocal;
+    });
+}
+/**
+ * Text from the default header part, when linked from body-final `sectPr`.
+ * @private
+ */
+export function defaultHeaderText(document) {
+    var catalog = headersFootersFor(document);
+    var section = finalSection(document);
+    var relId = section == null ? undefined : section.headerFooterReferenceId('header', 'default');
+    return catalog.textForRelationship(relId);
+}
+/**
+ * Text from the default footer part, when linked from body-final `sectPr`.
+ * @private
+ */
+export function defaultFooterText(document) {
+    var catalog = headersFootersFor(document);
+    var section = finalSection(document);
+    var relId = section == null ? undefined : section.headerFooterReferenceId('footer', 'default');
+    return catalog.textForRelationship(relId);
+}
+/**
+ * Set default header text, creating the part and `sectPr` reference when needed.
+ * @private
+ */
+export function setDefaultHeader(document, text) {
+    var section = sectionForWrite(document);
+    setSectionHeader(document, section, text, 'default');
+    setFinalSection(document, section);
+}
+/**
+ * Set default footer text, creating the part and `sectPr` reference when needed.
+ * @private
+ */
+export function setDefaultFooter(document, text) {
+    var section = sectionForWrite(document);
+    setSectionFooter(document, section, text, 'default');
+    setFinalSection(document, section);
+}
+/**
+ * Header text linked from a section's `sectPr`.
+ * @private
+ */
+export function headerTextForSection(document, section, refType) {
+    if (refType === void 0) { refType = 'default'; }
+    var catalog = headersFootersFor(document);
+    var relId = section.headerFooterReferenceId('header', refType);
+    return catalog.textForRelationship(relId);
+}
+/**
+ * Footer text linked from a section's `sectPr`.
+ * @private
+ */
+export function footerTextForSection(document, section, refType) {
+    if (refType === void 0) { refType = 'default'; }
+    var catalog = headersFootersFor(document);
+    var relId = section.headerFooterReferenceId('footer', refType);
+    return catalog.textForRelationship(relId);
+}
+/**
+ * Set header text on a section, reusing an existing linked part when present.
+ * @private
+ */
+export function setSectionHeader(document, section, text, refType) {
+    if (refType === void 0) { refType = 'default'; }
+    var catalog = headersFootersFor(document);
+    var _a = catalog.ensurePart('header', section, refType, usedRelationshipIds(document), usedPartNameKeys(document)), entry = _a.entry, relationshipId = _a.relationshipId;
+    catalog.setSimpleText(entry, text);
+    section.setHeaderFooterReference('header', refType, relationshipId);
+}
+/**
+ * Set footer text on a section, reusing an existing linked part when present.
+ * @private
+ */
+export function setSectionFooter(document, section, text, refType) {
+    if (refType === void 0) { refType = 'default'; }
+    var catalog = headersFootersFor(document);
+    var _a = catalog.ensurePart('footer', section, refType, usedRelationshipIds(document), usedPartNameKeys(document)), entry = _a.entry, relationshipId = _a.relationshipId;
+    catalog.setSimpleText(entry, text);
+    section.setHeaderFooterReference('footer', refType, relationshipId);
+}
+/**
+ * Link an existing header part to a section without creating a duplicate part.
+ * @private
+ */
+export function linkSectionHeader(document, section, relationshipId, refType) {
+    if (refType === void 0) { refType = 'default'; }
+    var catalog = headersFootersFor(document);
+    if (!catalog.hasRelationship(relationshipId)) {
+        throw new DocxError('content/invalid-header-footer-reference', "Header/footer relationship " + relationshipId + " is not loaded in this document");
+    }
+    section.setHeaderFooterReference('header', refType, relationshipId);
+}
+/**
+ * Link an existing footer part to a section without creating a duplicate part.
+ * @private
+ */
+export function linkSectionFooter(document, section, relationshipId, refType) {
+    if (refType === void 0) { refType = 'default'; }
+    var catalog = headersFootersFor(document);
+    if (!catalog.hasRelationship(relationshipId)) {
+        throw new DocxError('content/invalid-header-footer-reference', "Header/footer relationship " + relationshipId + " is not loaded in this document");
+    }
+    section.setHeaderFooterReference('footer', refType, relationshipId);
+}
+/**
+ *  @private
+ * Require section properties associated with a document (section.pageSetup / document.sections).
+ */
+function requireAssociatedSectionDocument(section) {
+    var document = ownerDocumentOf(section);
+    if (document === undefined) {
+        throw new Error('sections: header/footer association requires section properties associated with a document (use section.pageSetup on a document section)');
+    }
+    return document;
+}
+/**
+ *  @private
+ * Resolve ref type; default slot when omitted.
+ */
+function resolveRefType(refType) {
+    return refType === undefined ? 'default' : refType;
+}
+/**
+ *  @private
+ * Ensure a header part + sectPr reference without wiping body text.
+ * Unlike {@link setSectionHeader}, does not call setSimpleText.
+ */
+function getOrCreateSectionHeader(document, section, refType) {
+    var catalog = headersFootersFor(document);
+    var ensured = catalog.ensurePart('header', section, refType, usedRelationshipIds(document), usedPartNameKeys(document));
+    section.setHeaderFooterReference('header', refType, ensured.relationshipId);
+    return createHeaderFooterForRelationship(document, ensured.relationshipId, 'header', refType);
+}
+/**
+ *  @private
+ * Ensure a footer part + sectPr reference without wiping body text.
+ * Unlike {@link setSectionFooter}, does not call setSimpleText.
+ */
+function getOrCreateSectionFooter(document, section, refType) {
+    var catalog = headersFootersFor(document);
+    var ensured = catalog.ensurePart('footer', section, refType, usedRelationshipIds(document), usedPartNameKeys(document));
+    section.setHeaderFooterReference('footer', refType, ensured.relationshipId);
+    return createHeaderFooterForRelationship(document, ensured.relationshipId, 'footer', refType);
+}
+function defineSectionHeaderFooterProperty(name, refType) {
+    var isHeader = name.endsWith('Header');
+    Object.defineProperty(PageSetup.prototype, name, {
+        configurable: true,
+        enumerable: false,
+        get: function () {
+            var document = requireAssociatedSectionDocument(this);
+            return isHeader
+                ? getOrCreateSectionHeader(document, this, refType)
+                : getOrCreateSectionFooter(document, this, refType);
+        },
+        set: function (value) {
+            var document = requireAssociatedSectionDocument(this);
+            if (value === undefined) {
+                this.setHeaderFooterReference(isHeader ? 'header' : 'footer', refType, undefined);
+                return;
+            }
+            if (!(value instanceof HeaderFooter)) {
+                throw new DocxError('argument/invalid', name + " setter expects HeaderFooter | undefined");
+            }
+            if (isHeader) {
+                if (value.kind !== 'header') {
+                    throw new DocxError('argument/invalid', name + " setter expects a header HeaderFooter");
+                }
+                linkSectionHeader(document, this, value.relationshipId, refType);
+                return;
+            }
+            if (value.kind !== 'footer') {
+                throw new DocxError('argument/invalid', name + " setter expects a footer HeaderFooter");
+            }
+            linkSectionFooter(document, this, value.relationshipId, refType);
+        },
+    });
+}
+defineSectionHeaderFooterProperty('oddHeader', 'default');
+defineSectionHeaderFooterProperty('oddFooter', 'default');
+defineSectionHeaderFooterProperty('firstPageHeader', 'first');
+defineSectionHeaderFooterProperty('firstPageFooter', 'first');
+defineSectionHeaderFooterProperty('evenHeader', 'even');
+defineSectionHeaderFooterProperty('evenFooter', 'even');
+/**
+
+ * or {@link PageSetup.evenHeader}. Returns the live header when already linked; does not create.
+ */
+PageSetup.prototype.header = function (refType) {
+    var document = requireAssociatedSectionDocument(this);
+    return headerForSection(document, this, resolveRefType(refType));
+};
+/**
+
+ * or {@link PageSetup.evenFooter}. Returns the live footer when already linked; does not create.
+ */
+PageSetup.prototype.footer = function (refType) {
+    var document = requireAssociatedSectionDocument(this);
+    return footerForSection(document, this, resolveRefType(refType));
+};
+/**
+/ `firstPageHeader` / `evenHeader`).
+ */
+PageSetup.prototype.getOrCreateHeader = function (refType) {
+    var document = requireAssociatedSectionDocument(this);
+    return getOrCreateSectionHeader(document, this, resolveRefType(refType));
+};
+/**
+/ `firstPageFooter` / `evenFooter`).
+ */
+PageSetup.prototype.getOrCreateFooter = function (refType) {
+    var document = requireAssociatedSectionDocument(this);
+    return getOrCreateSectionFooter(document, this, resolveRefType(refType));
+};
+/**
+/even).
+ */
+PageSetup.prototype.linkHeader = function (header, refType) {
+    var document = requireAssociatedSectionDocument(this);
+    linkSectionHeader(document, this, header.relationshipId, resolveRefType(refType));
+};
+/**
+/even).
+ */
+PageSetup.prototype.linkFooter = function (footer, refType) {
+    var document = requireAssociatedSectionDocument(this);
+    linkSectionFooter(document, this, footer.relationshipId, resolveRefType(refType));
+};
+/**
+/even).
+ */
+PageSetup.prototype.removeHeader = function (refType) {
+    requireAssociatedSectionDocument(this);
+    this.setHeaderFooterReference('header', resolveRefType(refType), undefined);
+};
+/**
+/even).
+ */
+PageSetup.prototype.removeFooter = function (refType) {
+    requireAssociatedSectionDocument(this);
+    this.setHeaderFooterReference('footer', resolveRefType(refType), undefined);
+};
+/**
+ * Set header text on a paragraph section break (`w:pPr/w:sectPr`).
+ * @private
+ */
+export function setParagraphSectionHeader(document, paragraph, text, refType) {
+    if (refType === void 0) { refType = 'default'; }
+    var section = paragraphSectionBreak(paragraph);
+    if (section === undefined) {
+        section = defaultLetterPageSetup();
+    }
+    setSectionHeader(document, section, text, refType);
+    setParagraphSectionBreak(paragraph, section);
+}
+/**
+ * Set footer text on a paragraph section break (`w:pPr/w:sectPr`).
+ * @private
+ */
+export function setParagraphSectionFooter(document, paragraph, text, refType) {
+    if (refType === void 0) { refType = 'default'; }
+    var section = paragraphSectionBreak(paragraph);
+    if (section === undefined) {
+        section = defaultLetterPageSetup();
+    }
+    setSectionFooter(document, section, text, refType);
+    setParagraphSectionBreak(paragraph, section);
+}
+registerAlwaysOnBodyFeatureBootstrap(function () {
+    registerHeadersFootersFeature();
+});
+registerHeadersFootersFeature();