@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/bookmarks/index.js

@@ -0,0 +1,1009 @@
+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 { DocxError } from '../../core/errors/docx-error';
+import { registerAlwaysOnBodyFeatureBootstrap } from '../document/body-always-on';
+import { WordDocument } from '../document/document';
+import { Paragraph } from '../document/paragraph';
+import { FeatureInlineParagraphItem, } from '../document/text-range';
+import { isWml, wmlAttr, wmlElement } from '../document/wml';
+import { featureId, registerFeature, registerFeatureInlineHandler, registerFeatureMaterializeHandler, visitParagraphsInDocumentOrder, } from '../../core/registry/index';
+var BOOKMARKS = featureId('bookmarks');
+/**
+ * Attributes the bookmark model consumes; everything else is residual.
+ *
+ * @private
+ */
+var MODELED_ATTRIBUTE_LOCAL_NAMES = [
+    'id',
+    'name',
+    'colFirst',
+    'colLast',
+];
+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 isWmlAttribute(a) {
+    return a.prefix === 'w' || a.namespaceUri === '' || a.namespaceUri.indexOf('wordprocessingml') >= 0;
+}
+/**
+ * Residual attributes for lossless serialize.
+ *
+ * Modeled local names are omitted only when their values were successfully
+ * consumed. Invalid modeled values stay residual so they round-trip.
+ *
+ * @private
+ */
+function residualAttributesOf(el, consumedLocalNames) {
+    return el.attributes.filter(function (a) {
+        if (a.localName === 'space' && a.prefix === 'xml') {
+            return false;
+        }
+        if (isWmlAttribute(a) && MODELED_ATTRIBUTE_LOCAL_NAMES.indexOf(a.localName) !== -1) {
+            return !consumedLocalNames.has(a.localName);
+        }
+        return true;
+    });
+}
+function parseBookmarkId(raw) {
+    if (raw === undefined || !/^\d+$/.test(raw)) {
+        return undefined;
+    }
+    return Number.parseInt(raw, 10);
+}
+function parseColumnIndex(raw) {
+    return parseBookmarkId(raw);
+}
+/**
+ * Whether `name` is usable as `w:name` (non-empty after rejecting whitespace-only).
+ *
+ * @private
+ */
+function isValidBookmarkName(name) {
+    if (name.length === 0) {
+        return false;
+    }
+    // Reject whitespace-only names (DocIO / Word authoring parity).
+    for (var i = 0; i < name.length; i += 1) {
+        var c = name.charCodeAt(i);
+        if (c !== 0x20 && c !== 0x09 && c !== 0x0a && c !== 0x0d) {
+            return true;
+        }
+    }
+    return false;
+}
+function assertValidBookmarkName(name) {
+    if (!isValidBookmarkName(name)) {
+        throw new DocxError('content/invalid-bookmark', 'Bookmark name must not be empty');
+    }
+}
+function assertNonNegativeInteger(value, label) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || Math.floor(value) !== value) {
+        throw new DocxError('content/invalid-bookmark', label + ' must be a non-negative integer');
+    }
+}
+/**
+ * Bookmark range start marker (`w:bookmarkStart`, ECMA-376-1 §17.13.6.2).
+ *
+ * Paired with a {@link BookmarkEnd} that shares the same internal package id.
+ * Public surface is {@link BookmarkStart.name} and optional table column span
+ * (`firstColumn` / `lastColumn`). Pairing id stays internal.
+ *
+ * @remarks
+ * - `name` maps `w:name`; empty or whitespace-only names are rejected.
+ * - `firstColumn` / `lastColumn` map `w:colFirst` / `w:colLast` (zero-based).
+ * - `undefined` means the column attribute is absent on serialize.
+ * - Residual attributes outside the modeled set round-trip verbatim.
+ *
+ * @public
+ */
+var BookmarkStart = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function BookmarkStart(bookmarkId, name, options) {
+        assertValidBookmarkName(name);
+        this.bookmarkIdValue = bookmarkId;
+        this.nameValue = name;
+        this.firstColumnValue = options == null ? undefined : options.firstColumn;
+        this.lastColumnValue = options == null ? undefined : options.lastColumn;
+        this.residual = (options == null ? undefined : options.residualAttributes) !== undefined
+            ? __spread(options.residualAttributes) : [];
+    }
+    Object.defineProperty(BookmarkStart.prototype, "bookmarkId", {
+        /**
+         * Bookmark identifier shared with the paired end marker (`w:id`).
+         *
+         * @private
+         */
+        get: function () {
+            return this.bookmarkIdValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(BookmarkStart.prototype, "name", {
+        /**
+         * Bookmark name (`w:name`). Must be non-empty and not whitespace-only.
+         *
+         * Setting an invalid name throws {@link DocxError} with code
+         * `content/invalid-bookmark`.
+         */
+        get: function () {
+            return this.nameValue;
+        },
+        set: function (value) {
+            assertValidBookmarkName(value);
+            this.nameValue = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(BookmarkStart.prototype, "firstColumn", {
+        /**
+         * Zero-based first table column of the bookmark (`w:colFirst`).
+         *
+         * `undefined` means the attribute is absent. Assigning `undefined` clears it.
+         */
+        get: function () {
+            return this.firstColumnValue;
+        },
+        set: function (value) {
+            if (value !== undefined) {
+                assertNonNegativeInteger(value, 'firstColumn');
+            }
+            this.firstColumnValue = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(BookmarkStart.prototype, "lastColumn", {
+        /**
+         * Zero-based last table column of the bookmark (`w:colLast`).
+         *
+         * `undefined` means the attribute is absent. Assigning `undefined` clears it.
+         */
+        get: function () {
+            return this.lastColumnValue;
+        },
+        set: function (value) {
+            if (value !== undefined) {
+                assertNonNegativeInteger(value, 'lastColumn');
+            }
+            this.lastColumnValue = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Assigns the package `w:id` used to pair start and end markers.
+     *
+     * @private
+     */
+    BookmarkStart.prototype.setBookmarkId = function (bookmarkId) {
+        this.bookmarkIdValue = bookmarkId;
+    };
+    /**
+     * Whether this marker still holds a temporary negative id before save materialization.
+     *
+     * @private
+     */
+    BookmarkStart.prototype.isPendingBookmarkId = function () {
+        return this.bookmarkIdValue < 0;
+    };
+    /**
+     * @private
+     * Residual attributes preserved for lossless serialization.
+     */
+    BookmarkStart.prototype.residualAttributes = function () {
+        return this.residual;
+    };
+    /**
+     * No-op detach hook for {@link FeatureInline} parity.
+     *
+     * @private
+     */
+    BookmarkStart.prototype.releaseContent = function () {
+        return;
+    };
+    /**
+     * Serializes this marker to `w:bookmarkStart`.
+     *
+     * @private
+     */
+    BookmarkStart.prototype.toOpenXml = function () {
+        var attributes = [
+            wmlAttr('id', String(this.bookmarkIdValue)),
+            wmlAttr('name', this.nameValue),
+        ];
+        if (this.firstColumnValue !== undefined) {
+            attributes.push(wmlAttr('colFirst', String(this.firstColumnValue)));
+        }
+        if (this.lastColumnValue !== undefined) {
+            attributes.push(wmlAttr('colLast', String(this.lastColumnValue)));
+        }
+        attributes.push.apply(attributes, __spread(this.residual));
+        return wmlElement('bookmarkStart', { attributes: attributes });
+    };
+    return BookmarkStart;
+}());
+export { BookmarkStart };
+/**
+ * Bookmark range end marker (`w:bookmarkEnd`, ECMA-376-1 §17.13.6.1).
+ *
+ * Closes the range opened by a matching {@link BookmarkStart}. Pairing uses the
+ * internal package id; {@link BookmarkEnd.name} is a public convenience mirror
+ * of the start name when paired (settable independently for authoring symmetry
+ * with DocIO). OOXML `bookmarkEnd` serializes `w:id` only.
+ *
+ * @public
+ */
+var BookmarkEnd = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function BookmarkEnd(bookmarkId, name) {
+        this.bookmarkIdValue = bookmarkId;
+        this.nameValue = name !== undefined ? name : '';
+    }
+    Object.defineProperty(BookmarkEnd.prototype, "bookmarkId", {
+        /**
+         * Bookmark identifier shared with the paired start marker (`w:id`).
+         *
+         * @private
+         */
+        get: function () {
+            return this.bookmarkIdValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(BookmarkEnd.prototype, "name", {
+        /**
+         * Bookmark name convenience on the end marker (DocIO parity).
+         *
+         * Empty string is allowed on the end marker itself (schema has no `w:name`
+         * on `bookmarkEnd`). When set to a non-empty value, whitespace-only is
+         * rejected. Pairing always uses internal id, never this name.
+         */
+        get: function () {
+            return this.nameValue;
+        },
+        set: function (value) {
+            if (value.length > 0) {
+                assertValidBookmarkName(value);
+            }
+            this.nameValue = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Assigns the package `w:id` used to pair start and end markers.
+     *
+     * @private
+     */
+    BookmarkEnd.prototype.setBookmarkId = function (bookmarkId) {
+        this.bookmarkIdValue = bookmarkId;
+    };
+    /**
+     * Whether this marker still holds a temporary negative id before save materialization.
+     *
+     * @private
+     */
+    BookmarkEnd.prototype.isPendingBookmarkId = function () {
+        return this.bookmarkIdValue < 0;
+    };
+    /**
+     * No-op detach hook for {@link FeatureInline} parity.
+     *
+     * @private
+     */
+    BookmarkEnd.prototype.releaseContent = function () {
+        return;
+    };
+    /**
+     * Serializes this marker to `w:bookmarkEnd`.
+     *
+     * @private
+     */
+    BookmarkEnd.prototype.toOpenXml = function () {
+        return wmlElement('bookmarkEnd', {
+            attributes: [wmlAttr('id', String(this.bookmarkIdValue))],
+        });
+    };
+    return BookmarkEnd;
+}());
+export { BookmarkEnd };
+/**
+ * Live view over a paired {@link BookmarkStart} / {@link BookmarkEnd}.
+ *
+ * Does not own markup or cache enclosed content: markers remain paragraph
+ * inlines (possibly in different paragraphs). Property reads/writes for name
+ * and column span go through the start marker. Empty ranges and arbitrary
+ * content between markers are valid.
+ *
+ * Discover via {@link WordDocument.bookmarks} / {@link BookmarkCollection}.
+ *
+ * @public
+ */
+var Bookmark = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function Bookmark(start, end) {
+        this.startMarkerValue = start;
+        this.endMarkerValue = end;
+        // Keep end-name convenience in sync when constructed from a start pair.
+        if (this.endMarkerValue.name.length === 0 && start.name.length > 0) {
+            this.endMarkerValue.name = start.name;
+        }
+    }
+    Object.defineProperty(Bookmark.prototype, "name", {
+        /**
+         * Bookmark name (`w:name` on the start marker). Read-only on the pair view;
+         * rename via {@link BookmarkStart.name} / {@link bookmarkStart}.
+         */
+        get: function () {
+            return this.startMarkerValue.name;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Bookmark.prototype, "bookmarkStart", {
+        /**
+         * Start marker for this bookmark.
+         */
+        get: function () {
+            return this.startMarkerValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Bookmark.prototype, "bookmarkEnd", {
+        /**
+         * End marker for this bookmark.
+         */
+        get: function () {
+            return this.endMarkerValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Bookmark.prototype, "firstColumn", {
+        /**
+         * Zero-based first table column (`w:colFirst` on the start marker).
+         */
+        get: function () {
+            return this.startMarkerValue.firstColumn;
+        },
+        set: function (value) {
+            this.startMarkerValue.firstColumn = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Bookmark.prototype, "lastColumn", {
+        /**
+         * Zero-based last table column (`w:colLast` on the start marker).
+         */
+        get: function () {
+            return this.startMarkerValue.lastColumn;
+        },
+        set: function (value) {
+            this.startMarkerValue.lastColumn = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Bookmark.prototype, "bookmarkId", {
+        /**
+         * Identifier shared by the start and end markers (`w:id`).
+         *
+         * @private
+         */
+        get: function () {
+            return this.startMarkerValue.bookmarkId;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Bookmark.prototype, "startMarker", {
+        /**
+         * Start marker (internal alias of {@link bookmarkStart}).
+         *
+         * @private
+         */
+        get: function () {
+            return this.startMarkerValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Bookmark.prototype, "endMarker", {
+        /**
+         * End marker (internal alias of {@link bookmarkEnd}).
+         *
+         * @private
+         */
+        get: function () {
+            return this.endMarkerValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return Bookmark;
+}());
+export { Bookmark };
+function parseBookmarkStart(element) {
+    if (!isWml(element, 'bookmarkStart')) {
+        return undefined;
+    }
+    var bookmarkId = parseBookmarkId(wmlAttribute(element, 'id'));
+    var name = wmlAttribute(element, 'name');
+    if (bookmarkId === undefined || name === undefined || !isValidBookmarkName(name)) {
+        return undefined;
+    }
+    var consumed = new Set();
+    consumed.add('id');
+    consumed.add('name');
+    var firstColumnRaw = wmlAttribute(element, 'colFirst');
+    var firstColumn = parseColumnIndex(firstColumnRaw);
+    if (firstColumnRaw !== undefined && firstColumn !== undefined) {
+        consumed.add('colFirst');
+    }
+    var lastColumnRaw = wmlAttribute(element, 'colLast');
+    var lastColumn = parseColumnIndex(lastColumnRaw);
+    if (lastColumnRaw !== undefined && lastColumn !== undefined) {
+        consumed.add('colLast');
+    }
+    return new BookmarkStart(bookmarkId, name, {
+        firstColumn: firstColumn,
+        lastColumn: lastColumn,
+        residualAttributes: residualAttributesOf(element, consumed),
+    });
+}
+function parseBookmarkEnd(element) {
+    if (!isWml(element, 'bookmarkEnd')) {
+        return undefined;
+    }
+    var bookmarkId = parseBookmarkId(wmlAttribute(element, 'id'));
+    if (bookmarkId === undefined) {
+        return undefined;
+    }
+    return new BookmarkEnd(bookmarkId);
+}
+/**
+ * Collect bookmark markers from all paragraphs in document order
+ * (main story + nested feature paragraphs such as table cells).
+ *
+ * @private
+ */
+function collectBookmarkMarkersInDocumentOrder(document) {
+    var markers = [];
+    visitParagraphsInDocumentOrder(document, function (paragraph) {
+        var content = paragraph.items.toArray();
+        for (var i = 0; i < content.length; i += 1) {
+            var inline = content[i];
+            if (inline === undefined || !(inline instanceof FeatureInlineParagraphItem)) {
+                continue;
+            }
+            if (inline.value instanceof BookmarkStart || inline.value instanceof BookmarkEnd) {
+                markers.push(inline.value);
+            }
+        }
+    });
+    return markers;
+}
+function collectBookmarkIds(document, visit) {
+    var markers = collectBookmarkMarkersInDocumentOrder(document);
+    for (var i = 0; i < markers.length; i += 1) {
+        visit(markers[i].bookmarkId);
+    }
+}
+function usedBookmarkIds(document) {
+    var used = new Set();
+    collectBookmarkIds(document, function (bookmarkId) {
+        used.add(bookmarkId);
+    });
+    return used;
+}
+function allocatePendingBookmarkId(document) {
+    var used = usedBookmarkIds(document);
+    var candidate = -1;
+    while (used.has(candidate)) {
+        candidate -= 1;
+    }
+    return candidate;
+}
+function materializeBookmarkIds(document) {
+    var remap = new Map();
+    var nextId = 0;
+    collectBookmarkIds(document, function (bookmarkId) {
+        if (bookmarkId >= 0 && bookmarkId >= nextId) {
+            nextId = bookmarkId + 1;
+        }
+    });
+    visitParagraphsInDocumentOrder(document, function (paragraph) {
+        var e_1, _a;
+        try {
+            for (var _b = __values(paragraph.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var inline = _c.value;
+                if (!(inline instanceof FeatureInlineParagraphItem)) {
+                    continue;
+                }
+                if (inline.value instanceof BookmarkStart && inline.value.isPendingBookmarkId()) {
+                    var pendingId = inline.value.bookmarkId;
+                    var resolved = remap.get(pendingId);
+                    if (resolved === undefined) {
+                        resolved = nextId;
+                        nextId += 1;
+                        remap.set(pendingId, resolved);
+                    }
+                    inline.value.setBookmarkId(resolved);
+                }
+                if (inline.value instanceof BookmarkEnd && inline.value.isPendingBookmarkId()) {
+                    var pendingId = inline.value.bookmarkId;
+                    var resolved = remap.get(pendingId);
+                    if (resolved === undefined) {
+                        resolved = nextId;
+                        nextId += 1;
+                        remap.set(pendingId, resolved);
+                    }
+                    inline.value.setBookmarkId(resolved);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    });
+}
+function allocateBookmarkId(document) {
+    return allocatePendingBookmarkId(document);
+}
+/** Stable Bookmark identity for a start marker while its paired end is unchanged. */
+var bookmarkByStart = new WeakMap();
+/**
+ * Pair starts to ends in document order (ECMA one-start/one-end by id).
+ *
+ * For each start, the matching end is the first subsequent unpaired end with
+ * the same id. Duplicate starts before an end: first start pairs; later starts
+ * remain unpaired. Orphan ends remain unpaired. All markers stay in the DOM.
+ *
+ * @private
+ */
+function pairBookmarks(markers) {
+    var pairedEnd = new Set();
+    var ranges = [];
+    for (var i = 0; i < markers.length; i += 1) {
+        var marker = markers[i];
+        if (!(marker instanceof BookmarkStart)) {
+            continue;
+        }
+        var start = marker;
+        for (var j = i + 1; j < markers.length; j += 1) {
+            var candidate = markers[j];
+            if (!(candidate instanceof BookmarkEnd)) {
+                continue;
+            }
+            if (candidate.bookmarkId !== start.bookmarkId) {
+                continue;
+            }
+            if (pairedEnd.has(candidate)) {
+                continue;
+            }
+            pairedEnd.add(candidate);
+            var bookmark = bookmarkByStart.get(start);
+            if (bookmark === undefined || bookmark.bookmarkEnd !== candidate) {
+                bookmark = new Bookmark(start, candidate);
+                bookmarkByStart.set(start, bookmark);
+            }
+            ranges.push(bookmark);
+            break;
+        }
+    }
+    return ranges;
+}
+/**
+ * All paired bookmarks in document order of their start markers.
+ *
+ * Orphan start/end markers are omitted from the list but remain in the DOM
+ * and continue to serialize.
+ *
+ * @private
+ */
+export function bookmarksInDocument(document) {
+    return pairBookmarks(collectBookmarkMarkersInDocumentOrder(document));
+}
+/**
+ * Named bookmarks whose start marker lives in `paragraph`, in document order.
+ *
+ * Cross-paragraph bookmarks are included when their **start** is in this
+ * paragraph. Orphans are omitted.
+ *
+ * @private
+ */
+export function bookmarksInParagraph(paragraph) {
+    var document = paragraph.owningDocument();
+    var all = bookmarksInDocument(document);
+    var found = [];
+    for (var i = 0; i < all.length; i += 1) {
+        var bookmark = all[i];
+        var startLoc = locateBookmarkMarker(document, bookmark.bookmarkStart);
+        if (startLoc !== undefined && startLoc.paragraph === paragraph) {
+            found.push(bookmark);
+        }
+    }
+    return found;
+}
+/**
+ * First paired bookmark whose name matches exactly (case-sensitive), document order.
+ *
+ * @private
+ */
+export function bookmarkByName(document, name) {
+    var all = bookmarksInDocument(document);
+    for (var i = 0; i < all.length; i += 1) {
+        if (all[i].name === name) {
+            return all[i];
+        }
+    }
+    return undefined;
+}
+/**
+ * Locate a bookmark marker among paragraph inlines (document-wide walk).
+ *
+ * @private
+ */
+function locateBookmarkMarker(document, marker) {
+    var found;
+    visitParagraphsInDocumentOrder(document, function (paragraph) {
+        if (found !== undefined) {
+            return;
+        }
+        var content = paragraph.items.toArray();
+        for (var i = 0; i < content.length; i += 1) {
+            var inline = content[i];
+            if (inline !== undefined &&
+                inline instanceof FeatureInlineParagraphItem &&
+                inline.value === marker) {
+                found = { paragraph: paragraph, index: i };
+                return;
+            }
+        }
+    });
+    return found;
+}
+/**
+ * Remove start and end markers of a paired bookmark; enclosed content is kept.
+ *
+ * Markers may live in different paragraphs. Throws
+ * {@link DocxError} `content/unknown-bookmark` when either marker is missing.
+ *
+ * @private
+ */
+export function removeBookmark(document, bookmark) {
+    var startLoc = locateBookmarkMarker(document, bookmark.bookmarkStart);
+    var endLoc = locateBookmarkMarker(document, bookmark.bookmarkEnd);
+    if (startLoc === undefined || endLoc === undefined) {
+        throw new DocxError('content/unknown-bookmark', 'Bookmark markers are not in this document');
+    }
+    // Remove higher document-order index first when same paragraph so indices stay valid.
+    if (startLoc.paragraph === endLoc.paragraph) {
+        if (endLoc.index > startLoc.index) {
+            endLoc.paragraph.removeFeatureInline(bookmark.bookmarkEnd);
+            startLoc.paragraph.removeFeatureInline(bookmark.bookmarkStart);
+        }
+        else {
+            startLoc.paragraph.removeFeatureInline(bookmark.bookmarkStart);
+            var endReloc = locateBookmarkMarker(document, bookmark.bookmarkEnd);
+            if (endReloc === undefined) {
+                throw new DocxError('content/unknown-bookmark', 'Bookmark end marker is not in this document');
+            }
+            endReloc.paragraph.removeFeatureInline(bookmark.bookmarkEnd);
+        }
+    }
+    else {
+        // Different paragraphs — order does not affect indices across hosts.
+        endLoc.paragraph.removeFeatureInline(bookmark.bookmarkEnd);
+        startLoc.paragraph.removeFeatureInline(bookmark.bookmarkStart);
+    }
+    bookmarkByStart.delete(bookmark.bookmarkStart);
+}
+/**
+ * Live query collection of paired bookmarks on a {@link WordDocument}.
+ *
+ * Members are stable {@link Bookmark} views for the current start/end pairing.
+ * Index properties refresh on {@link count} / mutation helpers.
+ *
+ * @public
+ */
+var BookmarkCollection = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function BookmarkCollection(document) {
+        this.cachedLength = 0;
+        this.document = document;
+    }
+    Object.defineProperty(BookmarkCollection.prototype, "count", {
+        /**
+         * Number of paired bookmarks in document order.
+         *
+         * @public
+         */
+        get: function () {
+            this.rebuildIndexProperties();
+            return this.cachedLength;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Bookmark at zero-based `index`, or `undefined` when out of range.
+     *
+     * @public
+     */
+    BookmarkCollection.prototype.itemAt = function (index) {
+        var items = bookmarksInDocument(this.document);
+        return items[index];
+    };
+    /**
+     * First bookmark whose name matches exactly (case-sensitive).
+     *
+     * @public
+     */
+    BookmarkCollection.prototype.findByName = function (name) {
+        return bookmarkByName(this.document, name);
+    };
+    /**
+     * Remove markers for `bookmark`; content between markers is preserved.
+     *
+     * @throws DocxError `content/unknown-bookmark` when markers are detached.
+     * @public
+     */
+    BookmarkCollection.prototype.remove = function (bookmark) {
+        removeBookmark(this.document, bookmark);
+        this.rebuildIndexProperties();
+    };
+    /**
+     * Remove the bookmark at zero-based `index`.
+     *
+     * @throws RangeError when `index` is out of range.
+     * @public
+     */
+    BookmarkCollection.prototype.removeAt = function (index) {
+        var items = bookmarksInDocument(this.document);
+        if (index < 0 || index >= items.length) {
+            throw new RangeError('Bookmark index ' + String(index) + ' is out of range');
+        }
+        removeBookmark(this.document, items[index]);
+        this.rebuildIndexProperties();
+    };
+    /**
+     * Remove every paired bookmark’s markers; content is preserved.
+     *
+     * @public
+     */
+    BookmarkCollection.prototype.clear = function () {
+        var items = bookmarksInDocument(this.document).slice();
+        for (var i = 0; i < items.length; i += 1) {
+            removeBookmark(this.document, items[i]);
+        }
+        this.rebuildIndexProperties();
+    };
+    BookmarkCollection.prototype[Symbol.iterator] = function () {
+        var items = bookmarksInDocument(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 };
+            },
+        };
+    };
+    /**
+     * Refresh numeric index properties from the current pairing.
+     *
+     * @private
+     */
+    BookmarkCollection.prototype.rebuildIndexProperties = function () {
+        var items = bookmarksInDocument(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 BookmarkCollection;
+}());
+export { BookmarkCollection };
+var bookmarkCollections = new WeakMap();
+/**
+ * Stable public {@link BookmarkCollection} for `document`.
+ *
+ * @private
+ */
+export function bookmarkCollectionFor(document) {
+    registerBookmarksFeature();
+    var cached = bookmarkCollections.get(document);
+    if (cached !== undefined) {
+        cached.rebuildIndexProperties();
+        return cached;
+    }
+    var created = new BookmarkCollection(document);
+    created.rebuildIndexProperties();
+    bookmarkCollections.set(document, created);
+    return created;
+}
+Object.defineProperty(WordDocument.prototype, 'bookmarks', {
+    configurable: true,
+    enumerable: false,
+    get: function () {
+        return bookmarkCollectionFor(this);
+    },
+});
+var registered = false;
+/**
+ * @private
+ * Test hook */
+export function resetBookmarksFeatureForTests() {
+    registered = false;
+}
+/**
+ * @private
+ * Register bookmark inline handlers. Idempotent. */
+export function registerBookmarksFeature() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    registerFeature({ id: BOOKMARKS });
+    registerFeatureInlineHandler({
+        featureId: BOOKMARKS,
+        wmlLocalName: 'bookmarkStart',
+        tryParse: function (element) {
+            return parseBookmarkStart(element);
+        },
+    });
+    registerFeatureInlineHandler({
+        featureId: BOOKMARKS,
+        wmlLocalName: 'bookmarkEnd',
+        tryParse: function (element) {
+            return parseBookmarkEnd(element);
+        },
+    });
+    registerFeatureMaterializeHandler({
+        featureId: BOOKMARKS,
+        materialize: function (document) {
+            materializeBookmarkIds(document);
+        },
+    });
+}
+/**
+ * Whether paragraph inline content is a modeled bookmark start from this module.
+ *
+ * @private
+ */
+export function isBookmarkStartInline(inline) {
+    return (inline instanceof FeatureInlineParagraphItem &&
+        inline.featureId === BOOKMARKS &&
+        inline.value instanceof BookmarkStart);
+}
+/**
+ * Whether paragraph inline content is a modeled bookmark end from this module.
+ *
+ * @private
+ */
+export function isBookmarkEndInline(inline) {
+    return (inline instanceof FeatureInlineParagraphItem &&
+        inline.featureId === BOOKMARKS &&
+        inline.value instanceof BookmarkEnd);
+}
+/**
+ * Append a bookmark start marker (`w:bookmarkStart`) at the end of the paragraph.
+ *
+ * @param name - Bookmark name (`w:name`); must be non-empty / not whitespace-only.
+ * @returns The authored start marker (pending negative id until save).
+ * @throws DocxError `content/invalid-bookmark` for an invalid name.
+ * @public
+ */
+Paragraph.prototype.appendBookmarkStart = function (name) {
+    assertValidBookmarkName(name);
+    var bookmarkId = allocateBookmarkId(this.owningDocument());
+    var start = new BookmarkStart(bookmarkId, name);
+    this.appendFeatureInline(BOOKMARKS, start);
+    return start;
+};
+/**
+ * Append a bookmark end marker (`w:bookmarkEnd`) pairing with `start`.
+ *
+ * Uses the start marker’s internal id. Place after the desired enclosed content
+ * (same or a later paragraph) so the pair spans the intended range.
+ *
+ * @param start - Start marker previously appended (possibly in another paragraph).
+ * @returns The authored end marker.
+ * @public
+ */
+Paragraph.prototype.appendBookmarkEnd = function (start) {
+    var end = new BookmarkEnd(start.bookmarkId, start.name);
+    this.appendFeatureInline(BOOKMARKS, end);
+    return end;
+};
+/**
+ * Append a same-paragraph bookmark: start, optional text run, then end.
+ *
+ * When `options.text` is omitted or empty, an empty bookmark (adjacent markers)
+ * is created. Content already present in the paragraph is not enclosed; use
+ * {@link Paragraph.appendBookmarkStart} / {@link Paragraph.appendBookmarkEnd}
+ * around existing content for that case.
+ *
+ * @public
+ */
+Paragraph.prototype.appendBookmark = function (name, options) {
+    assertValidBookmarkName(name);
+    var bookmarkId = allocateBookmarkId(this.owningDocument());
+    var start = new BookmarkStart(bookmarkId, name);
+    this.appendFeatureInline(BOOKMARKS, start);
+    var text = options == null ? undefined : options.text;
+    if (text !== undefined && text.length > 0) {
+        this.appendText(text);
+    }
+    var end = new BookmarkEnd(bookmarkId, name);
+    this.appendFeatureInline(BOOKMARKS, end);
+    return new Bookmark(start, end);
+};
+registerAlwaysOnBodyFeatureBootstrap(function () {
+    registerBookmarksFeature();
+});
+registerBookmarksFeature();