@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

package/src/features/notes/index.js

@@ -0,0 +1,1725 @@
+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 { parseBodyBlocks, serializeBodyBlocks } from '../document/body-blocks';
+import { WordDocument } from '../document/document';
+import { bodyItemToBlock, projectBlockToBodyItem } from '../document/body-item-adapters';
+import { SubSuperScript } from '../document/character-format';
+import { Paragraph } from '../document/paragraph';
+import { FeatureRunParagraphItem, TextRange } from '../document/text-range';
+import { elementChildren, isWml, wmlAttr, wmlElement } from '../document/wml';
+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, registerFeatureRunLeafHandler, replaceOrAddPackagePart, visitParagraphsInDocumentOrder, } from '../../core/registry/index';
+import { parseXml, serializeXml, WML_TRANSITIONAL_NAMESPACE } from '../../core/xml/index';
+import { createTable } from '../tables/index';
+import { createBlockContentControl, } from '../content-controls/index';
+var NOTES = featureId('notes');
+var WML = WML_TRANSITIONAL_NAMESPACE;
+var utf8Decoder = new TextDecoder('utf-8');
+var utf8 = new TextEncoder();
+/**
+ * @private
+ * Transitional footnotes relationship (ECMA-376-4 §9.2.6). */
+export var FOOTNOTES_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes';
+/**
+ * @private
+ * Transitional endnotes relationship (ECMA-376-4 §9.2.5). */
+export var ENDNOTES_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/endnotes';
+/**
+ * @private
+ * Strict footnotes relationship. */
+export var STRICT_FOOTNOTES_RELATIONSHIP_TYPE = 'http://purl.oclc.org/ooxml/officeDocument/relationships/footnotes';
+/**
+ * @private
+ * Strict endnotes relationship. */
+export var STRICT_ENDNOTES_RELATIONSHIP_TYPE = 'http://purl.oclc.org/ooxml/officeDocument/relationships/endnotes';
+/**
+ * @private
+ */
+export var FOOTNOTES_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml';
+/**
+ * @private
+ */
+export var ENDNOTES_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml';
+var FOOTNOTES_RELATIONSHIP_TYPES = [
+    FOOTNOTES_RELATIONSHIP_TYPE,
+    STRICT_FOOTNOTES_RELATIONSHIP_TYPE,
+];
+var ENDNOTES_RELATIONSHIP_TYPES = [
+    ENDNOTES_RELATIONSHIP_TYPE,
+    STRICT_ENDNOTES_RELATIONSHIP_TYPE,
+];
+var ALL_RELATIONSHIP_TYPES = __spread(FOOTNOTES_RELATIONSHIP_TYPES, ENDNOTES_RELATIONSHIP_TYPES);
+function wmlAttribute(el, localName) {
+    var __ts33_0;
+    return ((__ts33_0 = el.attributes.find(function (a) { return a.localName === localName && (a.namespaceUri === '' || a.prefix === 'w'); })), __ts33_0 == null ? undefined : __ts33_0.value);
+}
+function parseNoteId(raw) {
+    if (raw === undefined || !/^-?\d+$/.test(raw)) {
+        return undefined;
+    }
+    return Number.parseInt(raw, 10);
+}
+function parseFtnEdnType(raw) {
+    if (raw === 'normal' ||
+        raw === 'separator' ||
+        raw === 'continuationSeparator' ||
+        raw === 'continuationNotice') {
+        return raw;
+    }
+    return undefined;
+}
+function isSpecialNoteEntry(noteId, noteType) {
+    return (noteId <= 0 ||
+        noteType === 'separator' ||
+        noteType === 'continuationSeparator' ||
+        noteType === 'continuationNotice');
+}
+function rootLocalName(kind) {
+    return kind === 'footnote' ? 'footnotes' : 'endnotes';
+}
+function entryLocalName(kind) {
+    return kind === 'footnote' ? 'footnote' : 'endnote';
+}
+function contentTypeForKind(kind) {
+    return kind === 'footnote' ? FOOTNOTES_CONTENT_TYPE : ENDNOTES_CONTENT_TYPE;
+}
+function relationshipTypeForKind(kind) {
+    return kind === 'footnote' ? FOOTNOTES_RELATIONSHIP_TYPE : ENDNOTES_RELATIONSHIP_TYPE;
+}
+function relativeTarget(partNameValue) {
+    return partNameValue.slice('/word/'.length);
+}
+function kindForRelationshipType(type) {
+    if (FOOTNOTES_RELATIONSHIP_TYPES.indexOf(type) !== -1) {
+        return 'footnote';
+    }
+    if (ENDNOTES_RELATIONSHIP_TYPES.indexOf(type) !== -1) {
+        return 'endnote';
+    }
+    return undefined;
+}
+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 item = _d.value;
+                    if (item instanceof TextRange) {
+                        return item.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; }
+            }
+        }
+    }
+    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;
+}
+var detachedParagraphOwner = {
+    assertAttachedParagraph: function () {
+        return;
+    },
+    owningDocument: function () {
+        throw new DetachedObjectError('Note content is not in a WordDocument');
+    },
+};
+/**
+ * Paragraph owner scoped to one footnote or endnote catalog entry.
+ * Membership is checked against the live entry blocks.
+ */
+var NotePartOwner = /** @class */ (function () {
+    function NotePartOwner(WordDocument, kind, noteId) {
+        this.WordDocument = WordDocument;
+        this.kind = kind;
+        this.noteId = noteId;
+    }
+    NotePartOwner.prototype.assertAttachedParagraph = function (target) {
+        var catalog = notesFor(this.WordDocument);
+        var entry = catalog.normalEntry(this.kind, this.noteId);
+        if (entry === undefined) {
+            throw new DetachedObjectError('Note 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 note');
+        }
+    };
+    /**
+     * @private
+     */
+    NotePartOwner.prototype.owningDocument = function () {
+        return this.WordDocument;
+    };
+    return NotePartOwner;
+}());
+function ownerForNote(WordDocument, kind, noteId) {
+    return new NotePartOwner(WordDocument, kind, noteId);
+}
+/**
+ * Bind a feature body block (table, content control, …) to the owning WordDocument when
+ * the value exposes `bindDocument`. Mirrors Body without exporting that helper
+ * from WordDocument.ts.
+ */
+function bindDocumentToFeatureBlock(value, WordDocument) {
+    if (typeof value !== 'object' || value === null || !('bindDocument' in value)) {
+        return;
+    }
+    var bindDocument = value.bindDocument;
+    bindDocument.call(value, WordDocument);
+}
+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 attachNoteParagraphs(WordDocument, kind, entry) {
+    var e_3, _a;
+    var owner = ownerForNote(WordDocument, kind, entry.noteId);
+    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, WordDocument);
+            }
+        }
+    }
+    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 detachNoteBlocks(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 blocksWithSimpleText(text, owner) {
+    if (owner === void 0) { owner = detachedParagraphOwner; }
+    return parseBodyBlocks([
+        wmlElement('p', {
+            children: [
+                wmlElement('r', {
+                    children: [wmlElement('t', { children: [{ kind: 'text', value: text }] })],
+                }),
+            ],
+        }),
+    ], owner);
+}
+function defaultSeparatorEntries(kind) {
+    var childName = entryLocalName(kind);
+    var separatorLeaf = kind === 'footnote' ? 'separator' : 'separator';
+    var continuationLeaf = kind === 'footnote' ? 'continuationSeparator' : 'continuationSeparator';
+    return [
+        {
+            noteId: -1,
+            noteType: 'separator',
+            blocks: [],
+            preservedXml: wmlElement(childName, {
+                attributes: [wmlAttr('type', 'separator'), wmlAttr('id', '-1')],
+                children: [
+                    wmlElement('p', {
+                        children: [wmlElement('r', { children: [wmlElement(separatorLeaf)] })],
+                    }),
+                ],
+            }),
+        },
+        {
+            noteId: 0,
+            noteType: 'continuationSeparator',
+            blocks: [],
+            preservedXml: wmlElement(childName, {
+                attributes: [wmlAttr('type', 'continuationSeparator'), wmlAttr('id', '0')],
+                children: [
+                    wmlElement('p', {
+                        children: [wmlElement('r', { children: [wmlElement(continuationLeaf)] })],
+                    }),
+                ],
+            }),
+        },
+    ];
+}
+/**
+ * Footnote reference run leaf (`w:footnoteReference`).
+ *
+ * @private
+ */
+var FootnoteReference = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function FootnoteReference(noteId) {
+        this.noteId = noteId;
+    }
+    /**
+     * @private
+     */
+    FootnoteReference.prototype.toOpenXml = function () {
+        return wmlElement('footnoteReference', { attributes: [wmlAttr('id', String(this.noteId))] });
+    };
+    return FootnoteReference;
+}());
+export { FootnoteReference };
+/**
+ * Endnote reference run leaf (`w:endnoteReference`).
+ *
+ * @private
+ */
+var EndnoteReference = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function EndnoteReference(noteId) {
+        this.noteId = noteId;
+    }
+    /**
+     * @private
+     */
+    EndnoteReference.prototype.toOpenXml = function () {
+        return wmlElement('endnoteReference', { attributes: [wmlAttr('id', String(this.noteId))] });
+    };
+    return EndnoteReference;
+}());
+export { EndnoteReference };
+function serializeNotePart(state) {
+    var e_5, _a;
+    var childName = entryLocalName(state.kind);
+    var children = [];
+    try {
+        for (var _b = __values(state.entries), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var entry = _c.value;
+            if (entry.preservedXml !== undefined) {
+                children.push(entry.preservedXml);
+                continue;
+            }
+            var attributes = [wmlAttr('id', String(entry.noteId))];
+            if (entry.noteType !== undefined && entry.noteType !== 'normal') {
+                attributes.push(wmlAttr('type', entry.noteType));
+            }
+            children.push(wmlElement(childName, {
+                attributes: attributes,
+                children: serializeBodyBlocks(entry.blocks),
+            }));
+        }
+    }
+    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; }
+    }
+    var root = wmlElement(rootLocalName(state.kind), {
+        attributes: state.rootExtra.attributes,
+        namespaceDeclarations: state.rootExtra.namespaceDeclarations.length > 0
+            ? state.rootExtra.namespaceDeclarations
+            : [{ prefix: 'w', namespaceUri: WML }],
+        children: children,
+    });
+    return utf8.encode(serializeXml(root));
+}
+function parseNotePart(part, relationship, kind) {
+    var e_6, _a;
+    var root = parseXml(utf8Decoder.decode(part.data));
+    if (!isWml(root, rootLocalName(kind))) {
+        return undefined;
+    }
+    var entries = [];
+    var childName = entryLocalName(kind);
+    try {
+        for (var _b = __values(elementChildren(root)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (!isWml(child, childName)) {
+                continue;
+            }
+            var noteId = parseNoteId(wmlAttribute(child, 'id'));
+            if (noteId === undefined) {
+                continue;
+            }
+            var noteType = parseFtnEdnType(wmlAttribute(child, 'type'));
+            if (isSpecialNoteEntry(noteId, noteType)) {
+                entries.push({ noteId: noteId, noteType: noteType, blocks: [], preservedXml: child });
+                continue;
+            }
+            entries.push({
+                noteId: noteId,
+                noteType: noteType != null ? noteType : 'normal',
+                blocks: parseBodyBlocks(child.children, detachedParagraphOwner),
+                preservedXml: undefined,
+            });
+        }
+    }
+    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; }
+    }
+    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 }],
+        },
+        entries: entries,
+        dirty: false,
+        pendingRelationship: undefined,
+    };
+}
+function allocatePartName(kind, used) {
+    var base = kind === 'footnote' ? 'footnotes.xml' : 'endnotes.xml';
+    var primary = partName("/word/" + base);
+    if (!used.has(partNameKey(primary))) {
+        return primary;
+    }
+    var index = 2;
+    while (used.has(partNameKey(partName("/word/" + kind + String(index) + ".xml")))) {
+        index += 1;
+    }
+    return partName("/word/" + kind + String(index) + ".xml");
+}
+function allocateNoteId(entries) {
+    var e_7, _a;
+    var max = 0;
+    try {
+        for (var entries_1 = __values(entries), entries_1_1 = entries_1.next(); !entries_1_1.done; entries_1_1 = entries_1.next()) {
+            var entry = entries_1_1.value;
+            if (entry.noteId > max && !isSpecialNoteEntry(entry.noteId, entry.noteType)) {
+                max = entry.noteId;
+            }
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) _a.call(entries_1);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    return max + 1;
+}
+/**
+ * Footnotes and endnotes parts linked from the Main WordDocument.
+ *
+ * @private
+ */
+var NotesCatalog = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function NotesCatalog(parts) {
+        this.parts = parts;
+        this.boundDocument = undefined;
+    }
+    /**
+     * Bind this catalog to a live WordDocument so paragraph owners can resolve.
+     * Re-attaches existing modeled note body blocks to entry-scoped owners.
+     *
+     * @private
+     */
+    NotesCatalog.prototype.bindDocument = function (WordDocument) {
+        var e_8, _a, e_9, _b;
+        this.boundDocument = WordDocument;
+        try {
+            for (var _c = __values(this.parts.values()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var part = _d.value;
+                try {
+                    for (var _e = __values(part.entries), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var entry = _f.value;
+                        if (entry.preservedXml !== undefined) {
+                            continue;
+                        }
+                        if (isSpecialNoteEntry(entry.noteId, entry.noteType)) {
+                            continue;
+                        }
+                        attachNoteParagraphs(WordDocument, part.kind, entry);
+                    }
+                }
+                catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_9) throw e_9.error; }
+                }
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+    };
+    NotesCatalog.prototype.requireBoundDocument = function () {
+        if (this.boundDocument === undefined) {
+            throw new DocxError('content/unknown-note', 'Notes catalog is not bound to a WordDocument');
+        }
+        return this.boundDocument;
+    };
+    NotesCatalog.prototype.markPartDirty = function (kind) {
+        var part = this.parts.get(kind);
+        if (part === undefined) {
+            throw new DocxError('content/unknown-note', 'Notes part is not loaded');
+        }
+        part.dirty = true;
+    };
+    /**
+     * @private
+     */
+    NotesCatalog.prototype.isDirty = function () {
+        var e_10, _a;
+        try {
+            for (var _b = __values(this.parts.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var part = _c.value;
+                if (part.dirty || part.pendingRelationship !== undefined) {
+                    return true;
+                }
+            }
+        }
+        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 false;
+    };
+    /**
+     * @private
+     */
+    NotesCatalog.prototype.applyToPackage = function (pkg, mainPartName) {
+        var e_11, _a;
+        var next = pkg;
+        var _loop_1 = function (part) {
+            if (!part.dirty && part.pendingRelationship === undefined) {
+                return "continue";
+            }
+            var data = serializeNotePart(part);
+            var rel = part.pendingRelationship != null ? part.pendingRelationship : relationshipsForPart(next, mainPartName).items.find(function (item) { return item.id === part.relationshipId; });
+            next = replaceOrAddPackagePart(next, mainPartName, part.partName, contentTypeForKind(part.kind), data, rel);
+            part.dirty = false;
+            part.pendingRelationship = undefined;
+        };
+        try {
+            for (var _b = __values(this.parts.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var part = _c.value;
+                _loop_1(part);
+            }
+        }
+        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 next;
+    };
+    /**
+     * @private
+     */
+    NotesCatalog.prototype.ensurePart = function (kind, usedRelIds, usedPartNames) {
+        var existing = this.parts.get(kind);
+        if (existing !== undefined) {
+            return existing;
+        }
+        var partNameValue = allocatePartName(kind, usedPartNames);
+        var relId = allocateRelationshipId(usedRelIds);
+        while (__spread(this.parts.values()).some(function (part) { return part.relationshipId === relId; })) {
+            relId = allocateRelationshipId(new Set(__spread(usedRelIds, [relId])));
+        }
+        var created = {
+            partName: partNameValue,
+            relationshipId: relId,
+            relationshipType: relationshipTypeForKind(kind),
+            kind: kind,
+            rootExtra: {
+                attributes: [],
+                namespaceDeclarations: [{ prefix: 'w', namespaceUri: WML }],
+            },
+            entries: defaultSeparatorEntries(kind),
+            dirty: true,
+            pendingRelationship: {
+                id: relId,
+                type: relationshipTypeForKind(kind),
+                target: relativeTarget(partNameValue),
+                extraAttributes: [],
+                children: [],
+            },
+        };
+        this.parts.set(kind, created);
+        return created;
+    };
+    /**
+     * @private
+     */
+    NotesCatalog.prototype.addNormalEntry = function (kind, text) {
+        var part = this.parts.get(kind);
+        if (part === undefined) {
+            throw new DocxError('content/unknown-note', 'Notes part is not loaded');
+        }
+        var noteId = allocateNoteId(part.entries);
+        var blocks = this.boundDocument !== undefined
+            ? blocksWithSimpleText(text, ownerForNote(this.boundDocument, kind, noteId))
+            : blocksWithSimpleText(text);
+        part.entries = __spread(part.entries, [
+            { noteId: noteId, noteType: 'normal', blocks: blocks, preservedXml: undefined },
+        ]);
+        part.dirty = true;
+        return noteId;
+    };
+    /**
+     * @private
+     */
+    NotesCatalog.prototype.normalEntry = function (kind, noteId) {
+        var part = this.parts.get(kind);
+        if (part === undefined) {
+            return undefined;
+        }
+        var entry = part.entries.find(function (candidate) { return candidate.noteId === noteId; });
+        if (entry === undefined || entry.preservedXml !== undefined) {
+            return undefined;
+        }
+        if (isSpecialNoteEntry(entry.noteId, entry.noteType)) {
+            return undefined;
+        }
+        return entry;
+    };
+    NotesCatalog.prototype.requireNormalEntry = function (kind, noteId) {
+        var entry = this.normalEntry(kind, noteId);
+        if (entry === undefined) {
+            throw new DocxError('content/unknown-note', "Note id " + String(noteId) + " is not a modeled normal note");
+        }
+        return entry;
+    };
+    /**
+     * @private
+     */
+    NotesCatalog.prototype.textForNote = function (kind, noteId) {
+        var entry = this.normalEntry(kind, noteId);
+        if (entry === undefined) {
+            return undefined;
+        }
+        return firstParagraphText(entry.blocks);
+    };
+    /**
+     * Ordered body children ({@link BodyItem}) for a normal note — paragraphs, tables,
+     * block content controls, and residuals, in WordDocument order (same model as Body.items).
+     *
+     * @private
+     */
+    NotesCatalog.prototype.itemsForNote = function (kind, noteId) {
+        return this.blocksForNote(kind, noteId);
+    };
+    /**
+     * Body blocks of a normal note, when modeled (paragraphs, tables, content controls, residuals).
+     *
+     * @private
+     * Prefer {@link NotesCatalog.itemsForNote}.
+     */
+    NotesCatalog.prototype.blocksForNote = function (kind, noteId) {
+        var entry = this.normalEntry(kind, noteId);
+        if (entry === undefined) {
+            return [];
+        }
+        if (this.boundDocument !== undefined) {
+            attachNoteParagraphs(this.boundDocument, kind, entry);
+        }
+        var items = [];
+        for (var i = 0; i < entry.blocks.length; i += 1) {
+            var projected = projectBlockToBodyItem(entry.blocks[i]);
+            if (projected !== undefined) {
+                items.push(projected);
+            }
+        }
+        return items;
+    };
+    /**
+     * Body paragraphs of a normal note, when modeled.
+     *
+     * @private
+     * Prefer {@link NotesCatalog.itemsForNote} for mixed body content.
+     */
+    NotesCatalog.prototype.paragraphsForNote = function (kind, noteId) {
+        var e_12, _a;
+        var entry = this.normalEntry(kind, noteId);
+        if (entry === undefined) {
+            return [];
+        }
+        if (this.boundDocument !== undefined) {
+            attachNoteParagraphs(this.boundDocument, kind, entry);
+        }
+        var paragraphs = [];
+        try {
+            for (var _b = __values(entry.blocks), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var block = _c.value;
+                if (block.type === 'paragraph') {
+                    paragraphs.push(block.paragraph);
+                }
+            }
+        }
+        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; }
+        }
+        return paragraphs;
+    };
+    /**
+     * Replace the body of a normal note with a single paragraph of plain text.
+     *
+     * @private
+     */
+    NotesCatalog.prototype.setTextForNote = function (kind, noteId, text) {
+        var part = this.parts.get(kind);
+        if (part === undefined) {
+            throw new DocxError('content/unknown-note', 'Notes part is not loaded');
+        }
+        var entry = part.entries.find(function (candidate) { return candidate.noteId === noteId; });
+        if (entry === undefined || entry.preservedXml !== undefined) {
+            throw new DocxError('content/unknown-note', "Note id " + String(noteId) + " is not a modeled normal note");
+        }
+        if (isSpecialNoteEntry(entry.noteId, entry.noteType)) {
+            throw new DocxError('content/unknown-note', "Note id " + String(noteId) + " is a separator or special note and cannot be edited");
+        }
+        detachNoteBlocks(entry.blocks);
+        if (this.boundDocument !== undefined) {
+            entry.blocks = blocksWithSimpleText(text, ownerForNote(this.boundDocument, kind, noteId));
+        }
+        else {
+            entry.blocks = blocksWithSimpleText(text);
+        }
+        part.dirty = true;
+    };
+    /**
+     * Insert a body item at `index` in a normal note (`0…length` inclusive).
+     *
+     * Attaches paragraphs and feature blocks when the catalog is WordDocument-bound.
+     * Returns the same `item` reference for chaining.
+     *
+     * @throws RangeError if `index` is out of range.
+     * @throws DocxError when the note is unknown or the catalog is unbound.
+     *
+     * @private
+     */
+    NotesCatalog.prototype.insertBodyItemAtForNote = function (kind, noteId, index, item) {
+        var document = this.requireBoundDocument();
+        var entry = this.requireNormalEntry(kind, noteId);
+        if (index < 0 || index > entry.blocks.length) {
+            throw new RangeError("Body item index " + String(index) + " is out of range");
+        }
+        var block = bodyItemToBlock(item);
+        if (block.type === 'paragraph') {
+            block.paragraph.attach(ownerForNote(document, kind, noteId));
+        }
+        else if (block.type === 'feature') {
+            bindDocumentToFeatureBlock(block.value, document);
+        }
+        var next = entry.blocks.slice();
+        next.splice(index, 0, block);
+        entry.blocks = next;
+        this.markPartDirty(kind);
+        return item;
+    };
+    /**
+     * Remove the body item at `index` in a normal note (`0…length-1`).
+     * Paragraphs detach; feature blocks may release content.
+     *
+     * @throws RangeError if `index` is out of range.
+     * @throws DocxError when the note is unknown.
+     *
+     * @private
+     */
+    NotesCatalog.prototype.removeBodyItemAtForNote = function (kind, noteId, index) {
+        var entry = this.requireNormalEntry(kind, noteId);
+        if (index < 0 || index >= entry.blocks.length) {
+            throw new RangeError("Body item index " + String(index) + " is out of range");
+        }
+        var block = entry.blocks[index];
+        if (block === undefined) {
+            throw new RangeError("Body item index " + String(index) + " is out of range");
+        }
+        var next = __spread(entry.blocks);
+        next.splice(index, 1);
+        entry.blocks = next;
+        if (block.type === 'paragraph') {
+            block.paragraph.detach();
+        }
+        else if (block.type === 'feature') {
+            releaseFeatureBlockContent(block.value);
+        }
+        this.markPartDirty(kind);
+    };
+    /**
+     * Remove a body item from a normal note by collection or payload identity.
+     *
+     * @throws DetachedObjectError when the item is not in the note.
+     * @throws DocxError when the note is unknown.
+     *
+     * @private
+     */
+    NotesCatalog.prototype.removeBodyItemForNote = function (kind, noteId, item) {
+        var entry = this.requireNormalEntry(kind, noteId);
+        var at = -1;
+        for (var i = 0; i < entry.blocks.length; i += 1) {
+            if (projectBlockToBodyItem(entry.blocks[i]) === item) {
+                at = i;
+                break;
+            }
+        }
+        if (at === -1) {
+            throw new DetachedObjectError('Body item is not in this note');
+        }
+        this.removeBodyItemAtForNote(kind, noteId, at);
+    };
+    /**
+     * Append a paragraph to a normal note body.
+     *
+     * @throws DocxError when the note is unknown or the catalog is unbound.
+     *
+     * @private
+     */
+    NotesCatalog.prototype.appendParagraphToNote = function (kind, noteId, options) {
+        var WordDocument = this.requireBoundDocument();
+        var entry = this.requireNormalEntry(kind, noteId);
+        var owner = ownerForNote(WordDocument, kind, noteId);
+        var paragraph = new Paragraph(owner);
+        this.insertBodyItemAtForNote(kind, noteId, entry.blocks.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;
+    };
+    /**
+     * Append a table to a normal note body.
+     *
+     * @throws DocxError when the note is unknown or the catalog is unbound.
+     * @throws RangeError when dimensions are less than 1.
+     *
+     * @private
+     */
+    NotesCatalog.prototype.appendTableToNote = function (kind, noteId, rowCount, columnCount) {
+        this.requireBoundDocument();
+        var entry = this.requireNormalEntry(kind, noteId);
+        var table = createTable(rowCount, columnCount);
+        this.insertBodyItemAtForNote(kind, noteId, entry.blocks.length, table);
+        return table;
+    };
+    /**
+     * Append a block-level content control to a normal note body.
+     *
+     * @throws DocxError when the note is unknown or the catalog is unbound.
+     *
+     * @private
+     */
+    NotesCatalog.prototype.appendBlockContentControlToNote = function (kind, noteId, type) {
+        this.requireBoundDocument();
+        var entry = this.requireNormalEntry(kind, noteId);
+        var sdt = createBlockContentControl(type);
+        // ContentControl is the runtime block SDT; BodyItem is a structural union in core.
+        this.insertBodyItemAtForNote(kind, noteId, entry.blocks.length, sdt);
+        return sdt;
+    };
+    /**
+ * @private
+ */
+    NotesCatalog.prototype.removeNormalEntry = function (kind, noteId) {
+        var part = this.parts.get(kind);
+        if (part === undefined) {
+            throw new DocxError('content/unknown-note', 'Notes part is not loaded');
+        }
+        var next = part.entries.filter(function (entry) { return entry.noteId !== noteId; });
+        if (next.length === part.entries.length) {
+            throw new DocxError('content/unknown-note', "Note id " + String(noteId) + " is not in this WordDocument");
+        }
+        part.entries = next;
+        part.dirty = true;
+    };
+    return NotesCatalog;
+}());
+export { NotesCatalog };
+/**
+ * Live view of a footnote body in the footnotes part.
+ *
+ * Bound to a WordDocument and note id; reads and writes go through
+ * {@link NotesCatalog}. Body content is the same R5.6
+ * {@link BodyItem} list as {@link Body} (`items` +
+ * insert/remove). Does not expose raw OOXML.
+ *
+ * @public
+ */
+var Footnote = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function Footnote(WordDocument, noteId) {
+        this.WordDocument = WordDocument;
+        this.id = noteId;
+    }
+    Object.defineProperty(Footnote.prototype, "noteId", {
+        /**
+         * @private
+       * Stable id matching the footnote reference and footnotes part entry. */
+        get: function () {
+            return this.id;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Footnote.prototype, "items", {
+        /**
+         * Ordered body children ({@link BodyItem}) for this footnote —
+         * paragraphs, tables, block content controls, and residuals, in
+         * WordDocument order (same model as {@link Body.items}).
+         *
+         * @public
+         */
+        get: function () {
+            return notesFor(this.WordDocument).itemsForNote('footnote', this.id);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Insert a body item at `index` in {@link Footnote.items}
+     * (`0…length` inclusive — insert-before / append).
+     *
+     * Attaches paragraphs and feature blocks to the owning WordDocument. Returns the
+     * same `item` reference for chaining (API-RULES R1.1).
+     *
+     * @param index - Index in {@link Footnote.items}.
+     * @param item - Paragraph, feature, or opaque body child.
+     * @returns The inserted {@link BodyItem}.
+     * @throws RangeError if `index` is out of range.
+     *
+     * @public
+     */
+    Footnote.prototype.insertBodyItemAt = function (index, item) {
+        return notesFor(this.WordDocument).insertBodyItemAtForNote('footnote', this.id, index, item);
+    };
+    /**
+     * Remove the body item at `index` in {@link Footnote.items}
+     * (`0…length-1`). Paragraphs detach; feature blocks may release content.
+     *
+     * @param index - Index in {@link Footnote.items}.
+     * @throws RangeError if `index` is out of range.
+     *
+     * @public
+     */
+    Footnote.prototype.removeBodyItemAt = function (index) {
+        notesFor(this.WordDocument).removeBodyItemAtForNote('footnote', this.id, index);
+    };
+    /**
+     * Remove a body item from {@link Footnote.items} by collection or payload identity.
+     *
+     * @param item - Entry from `items`, or an equivalent payload wrapper.
+     * @throws DetachedObjectError if `item` is not in this footnote.
+     *
+     * @public
+     */
+    Footnote.prototype.removeBodyItem = function (item) {
+        notesFor(this.WordDocument).removeBodyItemForNote('footnote', this.id, item);
+    };
+    return Footnote;
+}());
+export { Footnote };
+/**
+ * Live view of an endnote body in the endnotes part.
+ *
+ * Bound to a WordDocument and note id; reads and writes go through
+ * {@link NotesCatalog}. Body content is the same R5.6
+ * {@link BodyItem} list as {@link Body} (`items` +
+ * insert/remove). Does not expose raw OOXML.
+ *
+ * @public
+ */
+var Endnote = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function Endnote(WordDocument, noteId) {
+        this.WordDocument = WordDocument;
+        this.id = noteId;
+    }
+    Object.defineProperty(Endnote.prototype, "noteId", {
+        /**
+         * @private
+       * Stable id matching the endnote reference and endnotes part entry. */
+        get: function () {
+            return this.id;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Endnote.prototype, "items", {
+        /**
+         * Ordered body children ({@link BodyItem}) for this endnote —
+         * paragraphs, tables, block content controls, and residuals, in
+         * WordDocument order (same model as {@link Body.items}).
+         *
+         * @public
+         */
+        get: function () {
+            return notesFor(this.WordDocument).itemsForNote('endnote', this.id);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Insert a body item at `index` in {@link Endnote.items}
+     * (`0…length` inclusive — insert-before / append).
+     *
+     * Attaches paragraphs and feature blocks to the owning WordDocument. Returns the
+     * same `item` reference for chaining (API-RULES R1.1).
+     *
+     * @param index - Index in {@link Endnote.items}.
+     * @param item - Paragraph, feature, or opaque body child.
+     * @returns The inserted {@link BodyItem}.
+     * @throws RangeError if `index` is out of range.
+     *
+     * @public
+     */
+    Endnote.prototype.insertBodyItemAt = function (index, item) {
+        return notesFor(this.WordDocument).insertBodyItemAtForNote('endnote', this.id, index, item);
+    };
+    /**
+     * Remove the body item at `index` in {@link Endnote.items}
+     * (`0…length-1`). Paragraphs detach; feature blocks may release content.
+     *
+     * @param index - Index in {@link Endnote.items}.
+     * @throws RangeError if `index` is out of range.
+     *
+     * @public
+     */
+    Endnote.prototype.removeBodyItemAt = function (index) {
+        notesFor(this.WordDocument).removeBodyItemAtForNote('endnote', this.id, index);
+    };
+    /**
+     * Remove a body item from {@link Endnote.items} by collection or payload identity.
+     *
+     * @param item - Entry from `items`, or an equivalent payload wrapper.
+     * @throws DetachedObjectError if `item` is not in this endnote.
+     *
+     * @public
+     */
+    Endnote.prototype.removeBodyItem = function (item) {
+        notesFor(this.WordDocument).removeBodyItemForNote('endnote', this.id, item);
+    };
+    return Endnote;
+}());
+export { Endnote };
+function loadCatalog(pkg, mainPartName) {
+    var e_13, _a;
+    var parts = new Map();
+    try {
+        for (var _b = __values(relationshipsForPart(pkg, mainPartName).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 parsed = parseNotePart(part, rel, kind);
+            if (parsed !== undefined) {
+                parts.set(kind, parsed);
+            }
+        }
+    }
+    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; }
+    }
+    return new NotesCatalog(parts);
+}
+function usedRelationshipIds(WordDocument) {
+    var e_14, _a;
+    var main = partName('/word/WordDocument.xml');
+    var used = new Set();
+    try {
+        for (var _b = __values(relationshipsForPart(WordDocument.opcPackage(), main).items), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var rel = _c.value;
+            used.add(rel.id);
+        }
+    }
+    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 used;
+}
+function usedPartNameKeys(WordDocument) {
+    var e_15, _a;
+    var used = new Set();
+    try {
+        for (var _b = __values(WordDocument.opcPackage().parts), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var part = _c.value;
+            used.add(partNameKey(part.name));
+        }
+    }
+    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;
+}
+var registered = false;
+/**
+ * @private
+ * Test hook */
+export function resetNotesFeatureForTests() {
+    registered = false;
+}
+/**
+ * @private
+ * Register note reference and notes-part handlers. Idempotent. */
+export function registerNotesFeature() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    registerFeature({ id: NOTES });
+    registerFeatureMultiPartHandler({
+        featureId: NOTES,
+        relationshipTypes: ALL_RELATIONSHIP_TYPES,
+        loadParts: function (pkg, ctx) {
+            return loadCatalog(pkg, ctx.mainPartName);
+        },
+    });
+    registerFeatureRunLeafHandler({
+        featureId: NOTES,
+        wmlLocalName: 'footnoteReference',
+        tryParse: function (element) {
+            if (!isWml(element, 'footnoteReference')) {
+                return undefined;
+            }
+            var noteId = parseNoteId(wmlAttribute(element, 'id'));
+            if (noteId === undefined) {
+                return undefined;
+            }
+            return new FootnoteReference(noteId);
+        },
+    });
+    registerFeatureRunLeafHandler({
+        featureId: NOTES,
+        wmlLocalName: 'endnoteReference',
+        tryParse: function (element) {
+            if (!isWml(element, 'endnoteReference')) {
+                return undefined;
+            }
+            var noteId = parseNoteId(wmlAttribute(element, 'id'));
+            if (noteId === undefined) {
+                return undefined;
+            }
+            return new EndnoteReference(noteId);
+        },
+    });
+}
+/**
+ * Notes catalog for a WordDocument.
+ *
+ * On a loaded package this is the catalog built from footnotes/endnotes parts.
+ * On a newly authored WordDocument there may be no notes parts yet, so this function
+ * attaches an empty catalog on first use when the feature is registered.
+ *
+ * @throws DocxError `feature/not-registered` when the module was not registered.
+ *
+ * @private
+ */
+export function notesFor(WordDocument) {
+    var part = WordDocument.featurePart(NOTES);
+    if (part instanceof NotesCatalog) {
+        part.bindDocument(WordDocument);
+        return part;
+    }
+    if (part !== undefined) {
+        throw new DocxError('feature/not-registered', 'Notes feature state was replaced with an unexpected part type');
+    }
+    if (!isFeatureRegistered(NOTES)) {
+        throw new DocxError('feature/not-registered', 'Notes feature is not registered; call registerNotesFeature() before use');
+    }
+    var created = new NotesCatalog(new Map());
+    created.bindDocument(WordDocument);
+    WordDocument.setFeaturePart(NOTES, created);
+    return created;
+}
+/** Interned footnote body views per document (stable `===` by note id). */
+var footnoteViews = new WeakMap();
+/** Interned endnote body views per document (stable `===` by note id). */
+var endnoteViews = new WeakMap();
+function footnoteViewMap(document) {
+    var map = footnoteViews.get(document);
+    if (map === undefined) {
+        map = new Map();
+        footnoteViews.set(document, map);
+    }
+    return map;
+}
+function endnoteViewMap(document) {
+    var map = endnoteViews.get(document);
+    if (map === undefined) {
+        map = new Map();
+        endnoteViews.set(document, map);
+    }
+    return map;
+}
+/**
+ * Interned live {@link Footnote} for `(document, noteId)`.
+ *
+ * @private
+ */
+export function footnoteInstanceFor(document, noteId) {
+    var map = footnoteViewMap(document);
+    var existing = map.get(noteId);
+    if (existing !== undefined) {
+        return existing;
+    }
+    var created = new Footnote(document, noteId);
+    map.set(noteId, created);
+    return created;
+}
+/**
+ * Interned live {@link Endnote} for `(document, noteId)`.
+ *
+ * @private
+ */
+export function endnoteInstanceFor(document, noteId) {
+    var map = endnoteViewMap(document);
+    var existing = map.get(noteId);
+    if (existing !== undefined) {
+        return existing;
+    }
+    var created = new Endnote(document, noteId);
+    map.set(noteId, created);
+    return created;
+}
+/**
+ * Live {@link Footnote} view for a reference in this WordDocument.
+ *
+ * @private
+ */
+export function footnoteFor(WordDocument, reference) {
+    return footnoteInstanceFor(WordDocument, reference.noteId);
+}
+/**
+ * Live {@link Endnote} view for a reference in this WordDocument.
+ *
+ * @private
+ */
+export function endnoteFor(WordDocument, reference) {
+    return endnoteInstanceFor(WordDocument, reference.noteId);
+}
+/**
+ * Footnote bodies referenced from the WordDocument body, in WordDocument order (first occurrence).
+ *
+ * @private
+ */
+export function footnotesInDocument(WordDocument) {
+    var found = [];
+    var seen = new Set();
+    visitParagraphsInDocumentOrder(WordDocument, function (paragraph) {
+        var e_16, _a;
+        try {
+            for (var _b = __values(footnotesInParagraph(paragraph)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var reference = _c.value;
+                if (seen.has(reference.noteId)) {
+                    continue;
+                }
+                seen.add(reference.noteId);
+                found.push(footnoteInstanceFor(WordDocument, reference.noteId));
+            }
+        }
+        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 found;
+}
+/**
+ * Endnote bodies referenced from the WordDocument body, in WordDocument order (first occurrence).
+ *
+ * @private
+ */
+export function endnotesInDocument(WordDocument) {
+    var found = [];
+    var seen = new Set();
+    visitParagraphsInDocumentOrder(WordDocument, function (paragraph) {
+        var e_17, _a;
+        try {
+            for (var _b = __values(endnotesInParagraph(paragraph)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var reference = _c.value;
+                if (seen.has(reference.noteId)) {
+                    continue;
+                }
+                seen.add(reference.noteId);
+                found.push(endnoteInstanceFor(WordDocument, reference.noteId));
+            }
+        }
+        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_17) throw e_17.error; }
+        }
+    });
+    return found;
+}
+/**
+ * Document-level footnotes manager (`WordDocument.footnotes`).
+ *
+ * Stable per-document identity. Enumerates interned {@link Footnote} bodies
+ * referenced from the main story in document order. Named {@link Footnotes}
+ * (plural) so it does not collide with the per-note {@link Footnote} body class.
+ *
+ * @public
+ */
+var Footnotes = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function Footnotes(document) {
+        this.cachedLength = 0;
+        this.document = document;
+    }
+    Object.defineProperty(Footnotes.prototype, "count", {
+        /**
+         * Number of distinct footnote bodies referenced from the main story.
+         *
+         * @public
+         */
+        get: function () {
+            this.rebuildIndexProperties();
+            return this.cachedLength;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Footnote at zero-based `index`, or `undefined` when out of range.
+     *
+     * @public
+     */
+    Footnotes.prototype.itemAt = function (index) {
+        return footnotesInDocument(this.document)[index];
+    };
+    Footnotes.prototype[Symbol.iterator] = function () {
+        var items = footnotesInDocument(this.document).slice();
+        var i = 0;
+        return {
+            next: function () {
+                if (i >= items.length) {
+                    return { done: true, value: undefined };
+                }
+                var value = items[i];
+                i += 1;
+                return { done: false, value: value };
+            },
+        };
+    };
+    /**
+     * @private
+     */
+    Footnotes.prototype.rebuildIndexProperties = function () {
+        var items = footnotesInDocument(this.document);
+        var nextLen = items.length;
+        var prevLen = this.cachedLength;
+        var limit = prevLen > nextLen ? prevLen : nextLen;
+        for (var i = 0; i < limit; i += 1) {
+            var key = String(i);
+            if (i < nextLen) {
+                Object.defineProperty(this, key, {
+                    value: items[i],
+                    writable: false,
+                    enumerable: true,
+                    configurable: true,
+                });
+            }
+            else {
+                delete this[key];
+            }
+        }
+        this.cachedLength = nextLen;
+    };
+    return Footnotes;
+}());
+export { Footnotes };
+/**
+ * Document-level endnotes manager (`WordDocument.endnotes`).
+ *
+ * Stable per-document identity. Enumerates interned {@link Endnote} bodies
+ * referenced from the main story in document order. Named {@link Endnotes}
+ * (plural) so it does not collide with the per-note {@link Endnote} body class.
+ *
+ * @public
+ */
+var Endnotes = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function Endnotes(document) {
+        this.cachedLength = 0;
+        this.document = document;
+    }
+    Object.defineProperty(Endnotes.prototype, "count", {
+        /**
+         * Number of distinct endnote bodies referenced from the main story.
+         *
+         * @public
+         */
+        get: function () {
+            this.rebuildIndexProperties();
+            return this.cachedLength;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Endnote at zero-based `index`, or `undefined` when out of range.
+     *
+     * @public
+     */
+    Endnotes.prototype.itemAt = function (index) {
+        return endnotesInDocument(this.document)[index];
+    };
+    Endnotes.prototype[Symbol.iterator] = function () {
+        var items = endnotesInDocument(this.document).slice();
+        var i = 0;
+        return {
+            next: function () {
+                if (i >= items.length) {
+                    return { done: true, value: undefined };
+                }
+                var value = items[i];
+                i += 1;
+                return { done: false, value: value };
+            },
+        };
+    };
+    /**
+     * @private
+     */
+    Endnotes.prototype.rebuildIndexProperties = function () {
+        var items = endnotesInDocument(this.document);
+        var nextLen = items.length;
+        var prevLen = this.cachedLength;
+        var limit = prevLen > nextLen ? prevLen : nextLen;
+        for (var i = 0; i < limit; i += 1) {
+            var key = String(i);
+            if (i < nextLen) {
+                Object.defineProperty(this, key, {
+                    value: items[i],
+                    writable: false,
+                    enumerable: true,
+                    configurable: true,
+                });
+            }
+            else {
+                delete this[key];
+            }
+        }
+        this.cachedLength = nextLen;
+    };
+    return Endnotes;
+}());
+export { Endnotes };
+var footnotesManagers = new WeakMap();
+var endnotesManagers = new WeakMap();
+/**
+ * Stable {@link Footnotes} manager for `document`.
+ *
+ * @private
+ */
+export function footnotesFor(document) {
+    registerNotesFeature();
+    var cached = footnotesManagers.get(document);
+    if (cached !== undefined) {
+        cached.rebuildIndexProperties();
+        return cached;
+    }
+    var created = new Footnotes(document);
+    created.rebuildIndexProperties();
+    footnotesManagers.set(document, created);
+    return created;
+}
+/**
+ * Stable {@link Endnotes} manager for `document`.
+ *
+ * @private
+ */
+export function endnotesFor(document) {
+    registerNotesFeature();
+    var cached = endnotesManagers.get(document);
+    if (cached !== undefined) {
+        cached.rebuildIndexProperties();
+        return cached;
+    }
+    var created = new Endnotes(document);
+    created.rebuildIndexProperties();
+    endnotesManagers.set(document, created);
+    return created;
+}
+function referencesInParagraph(paragraph, predicate) {
+    var e_18, _a;
+    var found = [];
+    try {
+        for (var _b = __values(paragraph.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var item = _c.value;
+            if (predicate(item)) {
+                found.push(item.value);
+            }
+        }
+    }
+    catch (e_18_1) { e_18 = { error: e_18_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_18) throw e_18.error; }
+    }
+    return found;
+}
+/**
+ * Footnote references in a paragraph, in WordDocument order.
+ *
+ * @private
+ */
+export function footnotesInParagraph(paragraph) {
+    return referencesInParagraph(paragraph, isFootnoteReferenceLeaf);
+}
+/**
+ * Endnote references in a paragraph, in WordDocument order.
+ *
+ * @private
+ */
+export function endnotesInParagraph(paragraph) {
+    return referencesInParagraph(paragraph, isEndnoteReferenceLeaf);
+}
+/**
+ * Visible text of a footnote body, when loaded.
+ *
+ * @private
+ */
+export function footnoteText(WordDocument, reference) {
+    return notesFor(WordDocument).textForNote('footnote', reference.noteId);
+}
+/**
+ * Visible text of an endnote body, when loaded.
+ *
+ * @private
+ */
+export function endnoteText(WordDocument, reference) {
+    return notesFor(WordDocument).textForNote('endnote', reference.noteId);
+}
+/**
+ * Insert a footnote reference and body at the end of a paragraph.
+ *
+ * @private
+ */
+export function insertFootnote(WordDocument, paragraph, text) {
+    var catalog = notesFor(WordDocument);
+    catalog.ensurePart('footnote', usedRelationshipIds(WordDocument), usedPartNameKeys(WordDocument));
+    var noteId = catalog.addNormalEntry('footnote', text);
+    var reference = new FootnoteReference(noteId);
+    var item = paragraph.appendFeatureRunItem(NOTES, reference);
+    // Note markers are superscript in Word (w:rPr/w:vertAlign w:val="superscript").
+    item.wireGroup.characterFormat.subSuperScript = SubSuperScript.SuperScript;
+    return reference;
+}
+/**
+ * Insert an endnote reference and body at the end of a paragraph.
+ *
+ * @private
+ */
+export function insertEndnote(WordDocument, paragraph, text) {
+    var catalog = notesFor(WordDocument);
+    catalog.ensurePart('endnote', usedRelationshipIds(WordDocument), usedPartNameKeys(WordDocument));
+    var noteId = catalog.addNormalEntry('endnote', text);
+    var reference = new EndnoteReference(noteId);
+    var item = paragraph.appendFeatureRunItem(NOTES, reference);
+    // Note markers are superscript in Word (w:rPr/w:vertAlign w:val="superscript").
+    item.wireGroup.characterFormat.subSuperScript = SubSuperScript.SuperScript;
+    return reference;
+}
+function removeReferenceRun(paragraph, reference) {
+    var e_19, _a;
+    try {
+        for (var _b = __values(paragraph.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var item = _c.value;
+            if (item instanceof FeatureRunParagraphItem && item.featureId === NOTES && item.value === reference) {
+                paragraph.removeFeatureRunItem(reference);
+                return;
+            }
+        }
+    }
+    catch (e_19_1) { e_19 = { error: e_19_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_19) throw e_19.error; }
+    }
+    throw new DocxError('content/unknown-note', 'Note reference is not in this paragraph');
+}
+/**
+ * Remove a footnote reference and body from a WordDocument.
+ *
+ * @private
+ */
+export function removeFootnote(WordDocument, paragraph, reference) {
+    removeReferenceRun(paragraph, reference);
+    notesFor(WordDocument).removeNormalEntry('footnote', reference.noteId);
+}
+/**
+ * Remove an endnote reference and body from a WordDocument.
+ *
+ * @private
+ */
+export function removeEndnote(WordDocument, paragraph, reference) {
+    removeReferenceRun(paragraph, reference);
+    notesFor(WordDocument).removeNormalEntry('endnote', reference.noteId);
+}
+/**
+ * Whether a paragraph item is a modeled footnote reference from this module.
+ *
+ * @private
+ */
+export function isFootnoteReferenceLeaf(item) {
+    return item instanceof FeatureRunParagraphItem && item.featureId === NOTES && item.value instanceof FootnoteReference;
+}
+/**
+ * Whether a paragraph item is a modeled endnote reference from this module.
+ *
+ * @private
+ */
+export function isEndnoteReferenceLeaf(item) {
+    return item instanceof FeatureRunParagraphItem && item.featureId === NOTES && item.value instanceof EndnoteReference;
+}
+Object.defineProperty(WordDocument.prototype, 'footnotes', {
+    configurable: true,
+    enumerable: false,
+    get: function () {
+        return footnotesFor(this);
+    },
+});
+Object.defineProperty(WordDocument.prototype, 'endnotes', {
+    configurable: true,
+    enumerable: false,
+    get: function () {
+        return endnotesFor(this);
+    },
+});
+Paragraph.prototype.appendFootnote = function (text) {
+    var reference = insertFootnote(this.owningDocument(), this, text);
+    return footnoteInstanceFor(this.owningDocument(), reference.noteId);
+};
+Paragraph.prototype.appendEndnote = function (text) {
+    var reference = insertEndnote(this.owningDocument(), this, text);
+    return endnoteInstanceFor(this.owningDocument(), reference.noteId);
+};
+registerNotesFeature();