@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/editable-ranges/index.js

@@ -0,0 +1,1348 @@
+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 { Paragraph } from '../document/paragraph';
+import { FeatureInlineParagraphItem, } from '../document/text-range';
+import { isWml, wmlAttr, wmlElement } from '../document/wml';
+import { objectValues } from '../../core/compat/object-compat';
+import { DetachedObjectError, DocxError } from '../../core/errors/docx-error';
+import { featureId, registerFeature, registerFeatureBlockHandler, registerFeatureInlineHandler, registerFeatureMaterializeHandler, visitParagraphsInDocumentOrder, } from '../../core/registry/index';
+var EDITABLE_RANGES = featureId('editable-ranges');
+/**
+ * Editor group for an editable range (`ST_EdGrp`, ECMA-376-1 §17.18.21).
+ *
+ * `w:edGrp` on the start marker names the set of users who may edit the range.
+ * ECMA note: `w:ed` (a single editor) takes precedence over the group when both
+ * are present; the library stores both without resolving precedence.
+ *
+ * @private
+ */
+export var EditableRangeEditorGroup = {
+    None: 'none',
+    Everyone: 'everyone',
+    Administrators: 'administrators',
+    Contributors: 'contributors',
+    Editors: 'editors',
+    Owners: 'owners',
+    Current: 'current',
+};
+var EDITOR_GROUPS = objectValues(EditableRangeEditorGroup);
+var DISPLACED_VALUES = ['next', 'prev'];
+/**
+ * Attributes the editable-range model consumes; everything else is residual.
+ *
+ * @private
+ */
+var MODELED_ATTRIBUTE_LOCAL_NAMES = [
+    'id',
+    'edGrp',
+    'ed',
+    'colFirst',
+    'colLast',
+    'displacedByCustomXml',
+];
+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 (unknown `edGrp`, non-decimal columns, bad
+ * displacement) stay in the residual bag so they round-trip unchanged.
+ *
+ * @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 parseDecimalId(raw) {
+    if (raw === undefined || !/^\d+$/.test(raw)) {
+        return undefined;
+    }
+    return Number.parseInt(raw, 10);
+}
+function parseDisplaced(raw) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    return DISPLACED_VALUES.find(function (value) { return value === raw; });
+}
+function parseEditorGroup(raw) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    return EDITOR_GROUPS.find(function (value) { return value === raw; });
+}
+function parseColumn(raw) {
+    return parseDecimalId(raw);
+}
+/**
+ * Editable-range start marker (`w:permStart`, ECMA-376-1 §17.13.7.2).
+ *
+ * Paired with an {@link EditableRangeEnd} by matching {@link EditableRangeStart.rangeId}
+ * (`w:id`). Markers are first-class DOM nodes occupying an exact slot among
+ * paragraph inlines (or body blocks for run-level markers between paragraphs),
+ * so relative order versus runs, bookmarks, fields, and other content is stable.
+ *
+ * @remarks
+ * - `rangeId` maps `w:id` (non-negative after save materialization; a negative
+ *   pending id is allocated on author and remapped before save).
+ * - `editorGroup` maps `w:edGrp` (`ST_EdGrp`); `editor` maps `w:ed`.
+ * - `columnFirst` / `columnLast` map `w:colFirst` / `w:colLast` (zero-based
+ *   table column span).
+ * - Attributes outside the modeled set are preserved verbatim and re-emitted on
+ *   serialization (lossless round-trip).
+ * - `undefined` means the attribute is absent on serialize; assigning a value
+ *   emits it; assigning `undefined` removes it.
+ *
+ * @private
+ */
+var EditableRangeStart = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function EditableRangeStart(rangeId, options) {
+        this.rangeIdValue = rangeId;
+        this.editorGroupValue = options == null ? undefined : options.editorGroup;
+        this.editorValue = options == null ? undefined : options.editor;
+        this.columnFirstValue = options == null ? undefined : options.columnFirst;
+        this.columnLastValue = options == null ? undefined : options.columnLast;
+        this.displacedByCustomXmlValue = options == null ? undefined : options.displacedByCustomXml;
+        this.residual = (options == null ? undefined : options.residualAttributes) !== undefined ? __spread(options.residualAttributes) : [];
+    }
+    Object.defineProperty(EditableRangeStart.prototype, "rangeId", {
+        /**
+         * Editable-range identifier shared with the paired end marker (`w:id`).
+         */
+        get: function () {
+            return this.rangeIdValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    EditableRangeStart.prototype.setRangeId = function (rangeId) {
+        this.rangeIdValue = rangeId;
+    };
+    /**
+     * @private
+     */
+    EditableRangeStart.prototype.isPendingRangeId = function () {
+        return this.rangeIdValue < 0;
+    };
+    Object.defineProperty(EditableRangeStart.prototype, "editorGroup", {
+        /**
+         * Editor group allowed to edit the range (`w:edGrp`, `ST_EdGrp`).
+         */
+        get: function () {
+            return this.editorGroupValue;
+        },
+        set: function (value) {
+            this.editorGroupValue = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EditableRangeStart.prototype, "editor", {
+        /**
+         * Single editor allowed to edit the range (`w:ed`) — `DOMAIN\user`,
+         * `user@domain`, or a machine-local `user` form.
+         */
+        get: function () {
+            return this.editorValue;
+        },
+        set: function (value) {
+            this.editorValue = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EditableRangeStart.prototype, "columnFirst", {
+        /**
+         * Zero-based first table column of the range (`w:colFirst`).
+         */
+        get: function () {
+            return this.columnFirstValue;
+        },
+        set: function (value) {
+            this.columnFirstValue = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EditableRangeStart.prototype, "columnLast", {
+        /**
+         * Zero-based last table column of the range (`w:colLast`).
+         */
+        get: function () {
+            return this.columnLastValue;
+        },
+        set: function (value) {
+            this.columnLastValue = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EditableRangeStart.prototype, "displacedByCustomXml", {
+        /**
+         * Displacement relative to a custom XML markup element
+         * (`w:displacedByCustomXml`).
+         */
+        get: function () {
+            return this.displacedByCustomXmlValue;
+        },
+        set: function (value) {
+            this.displacedByCustomXmlValue = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+   * Residual attributes preserved for lossless serialization. */
+    EditableRangeStart.prototype.residualAttributes = function () {
+        return this.residual;
+    };
+    /**
+     * @private
+     */
+    EditableRangeStart.prototype.releaseContent = function () {
+        return;
+    };
+    EditableRangeStart.prototype.toOpenXml = function () {
+        var attributes = [wmlAttr('id', String(this.rangeIdValue))];
+        if (this.editorGroupValue !== undefined) {
+            attributes.push(wmlAttr('edGrp', this.editorGroupValue));
+        }
+        if (this.editorValue !== undefined) {
+            attributes.push(wmlAttr('ed', this.editorValue));
+        }
+        if (this.columnFirstValue !== undefined) {
+            attributes.push(wmlAttr('colFirst', String(this.columnFirstValue)));
+        }
+        if (this.columnLastValue !== undefined) {
+            attributes.push(wmlAttr('colLast', String(this.columnLastValue)));
+        }
+        if (this.displacedByCustomXmlValue !== undefined) {
+            attributes.push(wmlAttr('displacedByCustomXml', this.displacedByCustomXmlValue));
+        }
+        attributes.push.apply(attributes, __spread(this.residual));
+        return wmlElement('permStart', { attributes: attributes });
+    };
+    return EditableRangeStart;
+}());
+export { EditableRangeStart };
+/**
+ * Editable-range end marker (`w:permEnd`, ECMA-376-1 §17.13.7.1).
+ *
+ * Paired with an {@link EditableRangeStart} by matching `w:id`. The end marker
+ * carries only the identifier, optional displacement, and residual attributes.
+ *
+ * @private
+ */
+var EditableRangeEnd = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function EditableRangeEnd(rangeId, options) {
+        this.rangeIdValue = rangeId;
+        this.displacedByCustomXmlValue = options == null ? undefined : options.displacedByCustomXml;
+        this.residual = (options == null ? undefined : options.residualAttributes) !== undefined ? __spread(options.residualAttributes) : [];
+    }
+    Object.defineProperty(EditableRangeEnd.prototype, "rangeId", {
+        /**
+         * Editable-range identifier shared with the paired start marker (`w:id`).
+         */
+        get: function () {
+            return this.rangeIdValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    EditableRangeEnd.prototype.setRangeId = function (rangeId) {
+        this.rangeIdValue = rangeId;
+    };
+    /**
+     * @private
+     */
+    EditableRangeEnd.prototype.isPendingRangeId = function () {
+        return this.rangeIdValue < 0;
+    };
+    Object.defineProperty(EditableRangeEnd.prototype, "displacedByCustomXml", {
+        /**
+         * Displacement relative to a custom XML markup element
+         * (`w:displacedByCustomXml`).
+         */
+        get: function () {
+            return this.displacedByCustomXmlValue;
+        },
+        set: function (value) {
+            this.displacedByCustomXmlValue = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+   * Residual attributes preserved for lossless serialization. */
+    EditableRangeEnd.prototype.residualAttributes = function () {
+        return this.residual;
+    };
+    /**
+     * @private
+     */
+    EditableRangeEnd.prototype.releaseContent = function () {
+        return;
+    };
+    EditableRangeEnd.prototype.toOpenXml = function () {
+        var attributes = [wmlAttr('id', String(this.rangeIdValue))];
+        if (this.displacedByCustomXmlValue !== undefined) {
+            attributes.push(wmlAttr('displacedByCustomXml', this.displacedByCustomXmlValue));
+        }
+        attributes.push.apply(attributes, __spread(this.residual));
+        return wmlElement('permEnd', { attributes: attributes });
+    };
+    return EditableRangeEnd;
+}());
+export { EditableRangeEnd };
+/**
+ * Live query view over a paired start/end marker pair, resolved by `w:id`.
+ *
+ * The view does not own markup: {@link EditableRangeStart} and
+ * {@link EditableRangeEnd} remain in their host containers (which may be
+ * different paragraphs), and property reads write through to the live start
+ * marker.
+ *
+ * @private
+ */
+var EditableRange = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function EditableRange(start, end) {
+        this.startMarkerValue = start;
+        this.endMarkerValue = end;
+    }
+    Object.defineProperty(EditableRange.prototype, "rangeId", {
+        /**
+         * Identifier shared by the paired markers (`w:id`).
+         */
+        get: function () {
+            return this.startMarkerValue.rangeId;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EditableRange.prototype, "startMarker", {
+        /**
+         * Start marker (`w:permStart`).
+         */
+        get: function () {
+            return this.startMarkerValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EditableRange.prototype, "endMarker", {
+        /**
+         * End marker (`w:permEnd`).
+         */
+        get: function () {
+            return this.endMarkerValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EditableRange.prototype, "editorGroup", {
+        /**
+         * Editor group allowed to edit the range (`w:edGrp` on the start marker).
+         * Assignment writes through to {@link EditableRangeStart.editorGroup}.
+         */
+        get: function () {
+            return this.startMarkerValue.editorGroup;
+        },
+        set: function (value) {
+            this.startMarkerValue.editorGroup = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EditableRange.prototype, "editor", {
+        /**
+         * Single editor allowed to edit the range (`w:ed` on the start marker).
+         * Assignment writes through to {@link EditableRangeStart.editor}.
+         */
+        get: function () {
+            return this.startMarkerValue.editor;
+        },
+        set: function (value) {
+            this.startMarkerValue.editor = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EditableRange.prototype, "columnFirst", {
+        /**
+         * Zero-based first table column of the range (`w:colFirst`).
+         */
+        get: function () {
+            return this.startMarkerValue.columnFirst;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EditableRange.prototype, "columnLast", {
+        /**
+         * Zero-based last table column of the range (`w:colLast`).
+         */
+        get: function () {
+            return this.startMarkerValue.columnLast;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Whether both markers are paragraph inlines of the same paragraph.
+     *
+     * Requires a document walk; pass the owning document via
+     * {@link editableRangeMarkersShareParagraph}.
+     *
+
+     * @private
+     */
+    EditableRange.prototype.markersShareParagraph = function (document) {
+        return editableRangeMarkersShareParagraph(document, this);
+    };
+    return EditableRange;
+}());
+export { EditableRange };
+/**
+ * Whether both markers of a paired range are inlines of the same paragraph.
+ *
+ * @private
+ */
+export function editableRangeMarkersShareParagraph(document, range) {
+    var startLoc = locateMarker(document, range.startMarker);
+    var endLoc = locateMarker(document, range.endMarker);
+    // TS 3.3 does not narrow unions through `(x == null ? undefined : x.kind)`.
+    return (startLoc !== undefined &&
+        endLoc !== undefined &&
+        startLoc.kind === 'inline' &&
+        endLoc.kind === 'inline' &&
+        startLoc.paragraph === endLoc.paragraph);
+}
+/**
+ * Locate a marker among document body blocks and paragraph inlines.
+ *
+ * @private
+ */
+function locateMarker(document, marker) {
+    var blocks = document.listBlocks();
+    for (var i = 0; i < blocks.length; i += 1) {
+        var block = blocks[i];
+        if (block === undefined) {
+            continue;
+        }
+        if (block.type === 'feature' && block.value === marker) {
+            return { kind: 'block', document: document, index: i };
+        }
+    }
+    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];
+            // TS 3.3 does not narrow InlineContent through `(x == null ? undefined : x.type)`.
+            if (inline !== undefined &&
+                inline instanceof FeatureInlineParagraphItem &&
+                inline.value === marker) {
+                found = { kind: 'inline', paragraph: paragraph, index: i };
+                return;
+            }
+        }
+    });
+    return found;
+}
+function removeMarkerAt(location, marker) {
+    if (location.kind === 'inline') {
+        location.paragraph.removeFeatureInline(marker);
+        return;
+    }
+    var block = location.document.listBlocks()[location.index];
+    if (block === undefined || block.type !== 'feature' || block.value !== marker) {
+        throw new DetachedObjectError('Editable-range marker is no longer in this document');
+    }
+    location.document.removeBlockAt(location.index);
+}
+/**
+ * Deep-clone a start marker, optionally overriding `rangeId`.
+ *
+ * Residual attributes are copied. Used by paragraph/content clone helpers that
+ * re-insert ranges without sharing live marker instances.
+ *
+ * @private
+ */
+export function cloneEditableRangeStart(source, options) {
+    var __ts33_1;
+    return new EditableRangeStart(((__ts33_1 = options == null ? undefined : options.rangeId), __ts33_1 != null ? __ts33_1 : source.rangeId), {
+        editorGroup: source.editorGroup,
+        editor: source.editor,
+        columnFirst: source.columnFirst,
+        columnLast: source.columnLast,
+        displacedByCustomXml: source.displacedByCustomXml,
+        residualAttributes: source.residualAttributes(),
+    });
+}
+/**
+ * Deep-clone an end marker, optionally overriding `rangeId`.
+ *
+ * @private
+ */
+export function cloneEditableRangeEnd(source, options) {
+    var __ts33_2;
+    return new EditableRangeEnd(((__ts33_2 = options == null ? undefined : options.rangeId), __ts33_2 != null ? __ts33_2 : source.rangeId), {
+        displacedByCustomXml: source.displacedByCustomXml,
+        residualAttributes: source.residualAttributes(),
+    });
+}
+/**
+ * Clone a paired range’s markers onto a target document with a fresh pending id.
+ *
+ * Returns detached start/end clones (not inserted). Callers insert them into
+ * the desired hosts. Both clones share the same pending id so they pair after
+ * insertion. Does not mutate the source markers.
+ *
+ * @private
+ */
+export function cloneEditableRangeForInsert(document, range) {
+    var pendingId = allocatePendingEditableRangeId(document);
+    return {
+        start: cloneEditableRangeStart(range.startMarker, { rangeId: pendingId }),
+        end: cloneEditableRangeEnd(range.endMarker, { rangeId: pendingId }),
+    };
+}
+/**
+ * Remove both markers of a paired editable range; enclosed content is kept.
+ *
+ * Markers may be paragraph inlines and/or body-level feature blocks. After
+ * removal the pair is gone from query APIs; orphan policy does not apply
+ * because both ends are deleted together.
+ *
+ * @param document - Owning document (used for body-level marker removal)
+ * @param range - Pair view from a query or authoring API
+ * @returns Nothing
+ * @throws {@link DocxError} `content/unknown-editable-range` when either marker
+ *   is not found in the document.
+ * @example
+ * ```ts
+ * const [range] = editableRangesInDocument(doc);
+ * if (range) removeEditableRange(doc, range);
+ * ```
+ * @private
+ */
+export function removeEditableRange(document, range) {
+    var startLoc = locateMarker(document, range.startMarker);
+    var endLoc = locateMarker(document, range.endMarker);
+    if (startLoc === undefined || endLoc === undefined) {
+        throw new DocxError('content/unknown-editable-range', 'Editable range markers are not in this document');
+    }
+    // Remove higher document-order index first so lower indices stay valid.
+    var startOrder = markerDocumentOrderKey(startLoc);
+    var endOrder = markerDocumentOrderKey(endLoc);
+    if (startOrder > endOrder) {
+        removeMarkerAt(startLoc, range.startMarker);
+        // Re-locate end after start removal if both were body blocks with shifting indices.
+        var endReloc = locateMarker(document, range.endMarker);
+        if (endReloc === undefined) {
+            throw new DocxError('content/unknown-editable-range', 'Editable range end marker is not in this document');
+        }
+        removeMarkerAt(endReloc, range.endMarker);
+    }
+    else {
+        removeMarkerAt(endLoc, range.endMarker);
+        var startReloc = locateMarker(document, range.startMarker);
+        if (startReloc === undefined) {
+            throw new DocxError('content/unknown-editable-range', 'Editable range start marker is not in this document');
+        }
+        removeMarkerAt(startReloc, range.startMarker);
+    }
+    rangeByStart.delete(range.startMarker);
+}
+function markerDocumentOrderKey(location) {
+    if (location.kind === 'block') {
+        // Body blocks ordered by block index; scale so they interleave roughly with
+        // paragraph walks (block index * large stride).
+        return location.index * 1000000;
+    }
+    // Prefer end-before-start removal within the same paragraph via content index.
+    var blocks = location.paragraph.owningDocument().listBlocks();
+    var blockIndex = 0;
+    for (var i = 0; i < blocks.length; i += 1) {
+        var b = blocks[i];
+        // TS 3.3 does not narrow BodyItem through `(x == null ? undefined : x.type)`.
+        if (b !== undefined && b.type === 'paragraph' && b.paragraph === location.paragraph) {
+            blockIndex = i;
+            break;
+        }
+    }
+    return blockIndex * 1000000 + location.index;
+}
+/**
+ * Move a single modeled marker from one paragraph content slot to another.
+ *
+ * Used for same-document reorder tests; does not change `rangeId`. When the
+ * marker is a body-level feature block, it is removed from the body and
+ * inserted as an inline in the target paragraph.
+ *
+ * @private
+ */
+export function moveEditableRangeMarkerToParagraph(document, marker, targetParagraph, inlineIndex) {
+    var location = locateMarker(document, marker);
+    if (location === undefined) {
+        throw new DocxError('content/unknown-editable-range', 'Editable-range marker is not in this document');
+    }
+    if (targetParagraph.owningDocument() !== document) {
+        throw new DocxError('content/invalid-editable-range', 'Target paragraph is not in this document');
+    }
+    removeMarkerAt(location, marker);
+    var insertAt = inlineIndex;
+    if (location.kind === 'inline' && location.paragraph === targetParagraph) {
+        // After removal, indices after the old slot shift left by one.
+        if (inlineIndex > location.index) {
+            insertAt = inlineIndex - 1;
+        }
+    }
+    if (insertAt < 0 || insertAt > targetParagraph.items.length) {
+        throw new RangeError("Feature inline index " + String(insertAt) + " is out of range");
+    }
+    targetParagraph.insertFeatureInlineAt(insertAt, EDITABLE_RANGES, marker);
+}
+/**
+ * Remap every editable-range marker in a paragraph to fresh pending ids, pairing
+ * starts with ends that share the previous id within the paragraph only.
+ *
+ * Intended for “clone paragraph then insert” flows so positive ids are not
+ * duplicated in the document. Cross-paragraph half-clones keep unpaired markers
+ * with new pending ids (one id per marker).
+ *
+ * @private
+ */
+export function remapEditableRangeIdsInParagraphToPending(paragraph) {
+    var e_1, _a, e_2, _b;
+    var document = paragraph.owningDocument();
+    var content = paragraph.items.toArray();
+    var oldToPending = new Map();
+    var usedIds = new Set();
+    collectEditableRangeIds(document, function (id) {
+        usedIds.add(id);
+    });
+    var allocPending = function () {
+        var candidate = -1;
+        while (usedIds.has(candidate)) {
+            candidate -= 1;
+        }
+        usedIds.add(candidate);
+        return candidate;
+    };
+    try {
+        for (var content_1 = __values(content), content_1_1 = content_1.next(); !content_1_1.done; content_1_1 = content_1.next()) {
+            var inline = content_1_1.value;
+            if (!(inline instanceof FeatureInlineParagraphItem)) {
+                continue;
+            }
+            if (inline.value instanceof EditableRangeStart || inline.value instanceof EditableRangeEnd) {
+                var oldId = inline.value.rangeId;
+                if (!oldToPending.has(oldId)) {
+                    oldToPending.set(oldId, allocPending());
+                }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (content_1_1 && !content_1_1.done && (_a = content_1.return)) _a.call(content_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    try {
+        for (var content_2 = __values(content), content_2_1 = content_2.next(); !content_2_1.done; content_2_1 = content_2.next()) {
+            var inline = content_2_1.value;
+            if (!(inline instanceof FeatureInlineParagraphItem)) {
+                continue;
+            }
+            if (inline.value instanceof EditableRangeStart || inline.value instanceof EditableRangeEnd) {
+                var pending_1 = oldToPending.get(inline.value.rangeId);
+                if (pending_1 !== undefined) {
+                    inline.value.setRangeId(pending_1);
+                }
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (content_2_1 && !content_2_1.done && (_b = content_2.return)) _b.call(content_2);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+}
+/**
+ * Clone all editable-range markers found as paragraph inlines, preserving local
+ * pairing by assigning one fresh pending id per former id shared by start/end
+ * in this paragraph.
+ *
+ * Returns new marker instances (not inserted). Non-range inlines are ignored —
+ * callers building a full paragraph clone still need core paragraph clone support.
+ *
+ * @private
+ */
+export function cloneEditableRangeMarkersFromParagraph(document, sourceParagraph) {
+    var e_3, _a;
+    var oldToPending = new Map();
+    var usedPending = new Set();
+    collectEditableRangeIds(document, function (id) {
+        usedPending.add(id);
+    });
+    var allocPending = function () {
+        var candidate = -1;
+        while (usedPending.has(candidate)) {
+            candidate -= 1;
+        }
+        usedPending.add(candidate);
+        return candidate;
+    };
+    var content = sourceParagraph.items.toArray();
+    try {
+        for (var content_3 = __values(content), content_3_1 = content_3.next(); !content_3_1.done; content_3_1 = content_3.next()) {
+            var inline = content_3_1.value;
+            if (!(inline instanceof FeatureInlineParagraphItem)) {
+                continue;
+            }
+            if (inline.value instanceof EditableRangeStart || inline.value instanceof EditableRangeEnd) {
+                if (!oldToPending.has(inline.value.rangeId)) {
+                    oldToPending.set(inline.value.rangeId, allocPending());
+                }
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (content_3_1 && !content_3_1.done && (_a = content_3.return)) _a.call(content_3);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    var markers = [];
+    for (var i = 0; i < content.length; i += 1) {
+        // TS 3.3 does not narrow InlineContent through `(x == null ? undefined : x.type)`.
+        var inline = content[i];
+        if (inline === undefined || !(inline instanceof FeatureInlineParagraphItem)) {
+            continue;
+        }
+        var pending_2 = oldToPending.get(inline.value instanceof EditableRangeStart || inline.value instanceof EditableRangeEnd
+            ? inline.value.rangeId
+            : Number.NaN);
+        if (pending_2 === undefined) {
+            continue;
+        }
+        if (inline.value instanceof EditableRangeStart) {
+            markers.push({
+                index: i,
+                marker: cloneEditableRangeStart(inline.value, { rangeId: pending_2 }),
+            });
+        }
+        else if (inline.value instanceof EditableRangeEnd) {
+            markers.push({
+                index: i,
+                marker: cloneEditableRangeEnd(inline.value, { rangeId: pending_2 }),
+            });
+        }
+    }
+    return { markers: markers };
+}
+function parseEditableRangeStart(element) {
+    if (!isWml(element, 'permStart')) {
+        return undefined;
+    }
+    var rangeId = parseDecimalId(wmlAttribute(element, 'id'));
+    if (rangeId === undefined) {
+        // Non-decimal or missing w:id — stay opaque so bytes are preserved verbatim.
+        return undefined;
+    }
+    var consumed = new Set(['id']);
+    var editorGroupRaw = wmlAttribute(element, 'edGrp');
+    var editorGroup = parseEditorGroup(editorGroupRaw);
+    if (editorGroupRaw !== undefined && editorGroup !== undefined) {
+        consumed.add('edGrp');
+    }
+    var editor = wmlAttribute(element, 'ed');
+    if (editor !== undefined) {
+        consumed.add('ed');
+    }
+    var columnFirstRaw = wmlAttribute(element, 'colFirst');
+    var columnFirst = parseColumn(columnFirstRaw);
+    if (columnFirstRaw !== undefined && columnFirst !== undefined) {
+        consumed.add('colFirst');
+    }
+    var columnLastRaw = wmlAttribute(element, 'colLast');
+    var columnLast = parseColumn(columnLastRaw);
+    if (columnLastRaw !== undefined && columnLast !== undefined) {
+        consumed.add('colLast');
+    }
+    var displacedRaw = wmlAttribute(element, 'displacedByCustomXml');
+    var displacedByCustomXml = parseDisplaced(displacedRaw);
+    if (displacedRaw !== undefined && displacedByCustomXml !== undefined) {
+        consumed.add('displacedByCustomXml');
+    }
+    return new EditableRangeStart(rangeId, {
+        editorGroup: editorGroup,
+        editor: editor,
+        columnFirst: columnFirst,
+        columnLast: columnLast,
+        displacedByCustomXml: displacedByCustomXml,
+        residualAttributes: residualAttributesOf(element, consumed),
+    });
+}
+function parseEditableRangeEnd(element) {
+    if (!isWml(element, 'permEnd')) {
+        return undefined;
+    }
+    var rangeId = parseDecimalId(wmlAttribute(element, 'id'));
+    if (rangeId === undefined) {
+        return undefined;
+    }
+    var consumed = new Set(['id']);
+    var displacedRaw = wmlAttribute(element, 'displacedByCustomXml');
+    var displacedByCustomXml = parseDisplaced(displacedRaw);
+    if (displacedRaw !== undefined && displacedByCustomXml !== undefined) {
+        consumed.add('displacedByCustomXml');
+    }
+    return new EditableRangeEnd(rangeId, {
+        displacedByCustomXml: displacedByCustomXml,
+        residualAttributes: residualAttributesOf(element, consumed),
+    });
+}
+/**
+ * WordDocument-order walk of modeled editable-range markers.
+ *
+ * Visits:
+ * - body-level feature blocks that are start/end markers
+ * - inline markers inside every paragraph reachable via
+ *   {@link visitParagraphsInDocumentOrder} (main body and nested feature
+ *   paragraphs such as table cells)
+ *
+ * Body-level markers that sit between paragraphs are emitted when their
+ * owning block is visited, before subsequent paragraphs. Nested table-cell
+ * body-level markers that are not paragraph inlines are only visible when
+ * hosted as paragraph inlines (common Word placement).
+ *
+ * @private
+ */
+function collectEditableRangeMarkersInDocumentOrder(document) {
+    var e_4, _a;
+    var markers = [];
+    var seen = new Set();
+    var push = function (marker) {
+        if (seen.has(marker)) {
+            return;
+        }
+        seen.add(marker);
+        markers.push(marker);
+    };
+    var visitParagraphInlines = function (paragraph) {
+        var e_5, _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 EditableRangeStart || inline.value instanceof EditableRangeEnd) {
+                    push(inline.value);
+                }
+            }
+        }
+        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; }
+        }
+    };
+    // Interleave body-level markers with paragraphs in listBlocks order.
+    // For nested feature paragraphs (tables), fall back to the registry walker
+    // after finishing the top-level block stream so cell inlines are included
+    // once, without double-counting top-level paragraphs already visited.
+    var topLevelParagraphs = new Set();
+    try {
+        for (var _b = __values(document.listBlocks()), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var block = _c.value;
+            if (block.type === 'paragraph') {
+                topLevelParagraphs.add(block.paragraph);
+                visitParagraphInlines(block.paragraph);
+                continue;
+            }
+            if (block.type === 'feature') {
+                if (block.value instanceof EditableRangeStart || block.value instanceof EditableRangeEnd) {
+                    push(block.value);
+                }
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    visitParagraphsInDocumentOrder(document, function (paragraph) {
+        if (topLevelParagraphs.has(paragraph)) {
+            return;
+        }
+        visitParagraphInlines(paragraph);
+    });
+    return markers;
+}
+function forEachEditableRangeMarker(document, visit) {
+    var e_6, _a;
+    try {
+        for (var _b = __values(collectEditableRangeMarkersInDocumentOrder(document)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var marker = _c.value;
+            visit(marker);
+        }
+    }
+    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; }
+    }
+}
+function collectEditableRangeIds(document, visit) {
+    forEachEditableRangeMarker(document, function (marker) {
+        visit(marker.rangeId);
+    });
+}
+/**
+ * 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
+ */
+/** Stable EditableRange identity for a start marker while its paired end is unchanged. */
+var rangeByStart = new WeakMap();
+function pairViewForMarkers(start, end) {
+    var range = rangeByStart.get(start);
+    if (range === undefined || range.endMarker !== end) {
+        range = new EditableRange(start, end);
+        rangeByStart.set(start, range);
+    }
+    return range;
+}
+function pairEditableRanges(markers) {
+    var pairedEnd = new Set();
+    var ranges = [];
+    for (var i = 0; i < markers.length; i += 1) {
+        var marker = markers[i];
+        if (!(marker instanceof EditableRangeStart)) {
+            continue;
+        }
+        var start = marker;
+        for (var j = i + 1; j < markers.length; j += 1) {
+            var candidate = markers[j];
+            if (!(candidate instanceof EditableRangeEnd)) {
+                continue;
+            }
+            if (candidate.rangeId !== start.rangeId) {
+                continue;
+            }
+            if (pairedEnd.has(candidate)) {
+                continue;
+            }
+            pairedEnd.add(candidate);
+            var range = rangeByStart.get(start);
+            if (range === undefined || range.endMarker !== candidate) {
+                range = new EditableRange(start, candidate);
+                rangeByStart.set(start, range);
+            }
+            ranges.push(range);
+            break;
+        }
+    }
+    return ranges;
+}
+/**
+ * All paired editable ranges in document order of their start markers.
+ *
+ * Walks body-level markers and paragraph inlines (including nested feature
+ * paragraphs such as table cells). Unpaired start/end markers are omitted from
+ * the list but remain in the DOM and continue to serialize.
+ *
+ * @param document - WordDocument whose body is walked
+ * @returns Stable pair views (same start marker → same `EditableRange` object)
+ * @example
+ * ```ts
+ * for (const range of editableRangesInDocument(doc)) {
+ *   console.log(range.rangeId, range.editorGroup);
+ * }
+ * ```
+ * @private
+ */
+export function editableRangesInDocument(document) {
+    return pairEditableRanges(collectEditableRangeMarkersInDocumentOrder(document));
+}
+/**
+ * Paired editable ranges whose start marker lies in this paragraph.
+ *
+ * The matching end may be in the same paragraph, a later paragraph, or a
+ * body-level feature block. Unpaired starts in the paragraph are omitted.
+ *
+ * @param paragraph - Paragraph that may host start markers
+ * @returns Subset of {@link editableRangesInDocument} for this paragraph
+ * @example
+ * ```ts
+ * const starts = editableRangesStartingInParagraph(doc.body.paragraphs[0]!);
+ * ```
+ * @private
+ */
+export function editableRangesStartingInParagraph(paragraph) {
+    // Pair against the full document stream so cross-paragraph ends resolve.
+    var owner = paragraph.owningDocument();
+    var all = editableRangesInDocument(owner);
+    return all.filter(function (range) {
+        var e_7, _a;
+        try {
+            for (var _b = __values(paragraph.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var inline = _c.value;
+                if (inline instanceof FeatureInlineParagraphItem && inline.value === range.startMarker) {
+                    return true;
+                }
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        return false;
+    });
+}
+/**
+ * First paired editable range with this range identifier, if any.
+ *
+ * When duplicate starts share an id, the first start in document order that
+ * successfully pairs wins (see pairing algorithm).
+ *
+ * @param document - WordDocument to search
+ * @param rangeId - `w:id` value (`EditableRange.rangeId`)
+ * @returns First matching pair, or `undefined`
+ * @example
+ * ```ts
+ * const range = editableRangeById(doc, 0);
+ * ```
+ * @private
+ */
+export function editableRangeById(document, rangeId) {
+    var e_8, _a;
+    try {
+        for (var _b = __values(editableRangesInDocument(document)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var range = _c.value;
+            if (range.rangeId === rangeId) {
+                return range;
+            }
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    return undefined;
+}
+/**
+ * Modeled editable-range markers in document order (paired and unpaired).
+ *
+ * Useful for diagnostics and tests; public authoring stays on pair views.
+ *
+ * @param document - WordDocument whose markers are listed
+ * @returns Start and end markers in document order
+ * @private
+ */
+export function editableRangeMarkersInDocument(document) {
+    return collectEditableRangeMarkersInDocumentOrder(document);
+}
+function materializeEditableRangeIds(document) {
+    var remap = new Map();
+    var nextId = 0;
+    collectEditableRangeIds(document, function (rangeId) {
+        if (rangeId >= 0 && rangeId >= nextId) {
+            nextId = rangeId + 1;
+        }
+    });
+    forEachEditableRangeMarker(document, function (marker) {
+        if (!marker.isPendingRangeId()) {
+            return;
+        }
+        var pendingId = marker.rangeId;
+        var resolved = remap.get(pendingId);
+        if (resolved === undefined) {
+            resolved = nextId;
+            nextId += 1;
+            remap.set(pendingId, resolved);
+        }
+        marker.setRangeId(resolved);
+    });
+}
+/**
+ * @private
+ * Allocate a pending (negative) id unique among editable-range markers. */
+export function allocatePendingEditableRangeId(document) {
+    var used = new Set();
+    collectEditableRangeIds(document, function (rangeId) {
+        used.add(rangeId);
+    });
+    var candidate = -1;
+    while (used.has(candidate)) {
+        candidate -= 1;
+    }
+    return candidate;
+}
+/**
+ * Next free non-negative editable-range id for the document (max existing + 1).
+ *
+ * Does not allocate or mutate markers; save-time materialization still remaps
+ * pending negative ids independently.
+ *
+ * @param document - WordDocument to scan
+ * @returns Smallest non-negative id not used by any marker
+ * @private
+ */
+export function nextEditableRangeId(document) {
+    var nextId = 0;
+    collectEditableRangeIds(document, function (rangeId) {
+        if (rangeId >= 0 && rangeId >= nextId) {
+            nextId = rangeId + 1;
+        }
+    });
+    return nextId;
+}
+var registered = false;
+/**
+ * @private
+ * Test hook */
+export function resetEditableRangesFeatureForTests() {
+    registered = false;
+}
+/**
+ * Register the editable-ranges feature handlers. Idempotent.
+ *
+ * Registers inline handlers (`w:permStart` / `w:permEnd` inside paragraphs),
+ * the matching body block handlers (run-level markers between paragraphs), and
+ * the save-time materialization pass that remaps pending negative identifiers
+ * to the next free non-negative `w:id`. When this module is not imported,
+ * editable-range markup stays opaque and is preserved byte-for-byte.
+ *
+ * @returns Nothing
+ * @example
+ * ```ts
+ * import { registerEditableRangesFeature } from '@syncfusion/ej2-docx/editable-ranges';
+ * registerEditableRangesFeature();
+ * ```
+ * @private
+ */
+export function registerEditableRangesFeature() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    registerFeature({ id: EDITABLE_RANGES });
+    registerFeatureInlineHandler({
+        featureId: EDITABLE_RANGES,
+        wmlLocalName: 'permStart',
+        tryParse: function (element) {
+            return parseEditableRangeStart(element);
+        },
+    });
+    registerFeatureInlineHandler({
+        featureId: EDITABLE_RANGES,
+        wmlLocalName: 'permEnd',
+        tryParse: function (element) {
+            return parseEditableRangeEnd(element);
+        },
+    });
+    registerFeatureBlockHandler({
+        featureId: EDITABLE_RANGES,
+        wmlLocalName: 'permStart',
+        tryParse: function (element) {
+            return parseEditableRangeStart(element);
+        },
+    });
+    registerFeatureBlockHandler({
+        featureId: EDITABLE_RANGES,
+        wmlLocalName: 'permEnd',
+        tryParse: function (element) {
+            return parseEditableRangeEnd(element);
+        },
+    });
+    registerFeatureMaterializeHandler({
+        featureId: EDITABLE_RANGES,
+        materialize: function (document) {
+            materializeEditableRangeIds(document);
+        },
+    });
+}
+/**
+ * Whether paragraph inline content is a modeled editable-range start marker
+ * (`w:permStart`) from this module.
+ *
+ * @private
+ */
+export function isEditableRangeStartInline(inline) {
+    return (inline instanceof FeatureInlineParagraphItem &&
+        inline.featureId === EDITABLE_RANGES &&
+        inline.value instanceof EditableRangeStart);
+}
+/**
+ * Whether paragraph inline content is a modeled editable-range end marker
+ * (`w:permEnd`) from this module.
+ *
+ * @private
+ */
+export function isEditableRangeEndInline(inline) {
+    return (inline instanceof FeatureInlineParagraphItem &&
+        inline.featureId === EDITABLE_RANGES &&
+        inline.value instanceof EditableRangeEnd);
+}
+function assertEditableRangeIndices(paragraph, startInlineIndex, endInlineIndex) {
+    var length = paragraph.items.length;
+    if (!Number.isInteger(startInlineIndex) ||
+        !Number.isInteger(endInlineIndex) ||
+        startInlineIndex < 0 ||
+        endInlineIndex < startInlineIndex ||
+        endInlineIndex > length) {
+        throw new DocxError('content/invalid-editable-range', "Editable range indices out of range: start=" + String(startInlineIndex) + " end=" + String(endInlineIndex) + " length=" + String(length));
+    }
+}
+/**
+ * Wrap an existing same-paragraph content slice in a new editable range.
+ *
+ * Indices refer to the current `paragraph.content` array **before** insertion:
+ * the start marker is inserted at `startInlineIndex`, and the end marker is
+ * inserted so that it follows the original slice
+ * (`endInlineIndex + 1` after the start push). Enclosed content is not copied
+ * or moved. Cross-paragraph authoring is not supported — use load/preserve for
+ * multi-paragraph ranges.
+ *
+ * @param paragraph - Paragraph that owns the inlines to wrap
+ * @param options - Inclusive/exclusive indices and optional editor metadata
+ * @returns Live pair view for the new markers (pending id until save)
+ * @example
+ * ```ts
+ * insertEditableRangeAt(paragraph, {
+ *   startInlineIndex: 1,
+ *   endInlineIndex: 2,
+ *   editorGroup: 'editors',
+ * });
+ * ```
+ * @private
+ */
+export function insertEditableRangeAt(paragraph, options) {
+    assertEditableRangeIndices(paragraph, options.startInlineIndex, options.endInlineIndex);
+    var document = paragraph.owningDocument();
+    var rangeId = allocatePendingEditableRangeId(document);
+    var start = new EditableRangeStart(rangeId, {
+        editorGroup: options.editorGroup,
+        editor: options.editor,
+        columnFirst: options.columnFirst,
+        columnLast: options.columnLast,
+    });
+    var end = new EditableRangeEnd(rangeId);
+    paragraph.insertFeatureInlineAt(options.startInlineIndex, EDITABLE_RANGES, start);
+    // After inserting start, original exclusive end shifts by +1.
+    paragraph.insertFeatureInlineAt(options.endInlineIndex + 1, EDITABLE_RANGES, end);
+    return pairViewForMarkers(start, end);
+}
+Paragraph.prototype.appendEditableRange = function (text, options) {
+    if (options === void 0) { options = {}; }
+    var document = this.owningDocument();
+    var rangeId = allocatePendingEditableRangeId(document);
+    var start = new EditableRangeStart(rangeId, {
+        editorGroup: options.editorGroup,
+        editor: options.editor,
+        columnFirst: options.columnFirst,
+        columnLast: options.columnLast,
+    });
+    this.appendFeatureInline(EDITABLE_RANGES, start);
+    this.appendText(text);
+    var end = new EditableRangeEnd(rangeId);
+    this.appendFeatureInline(EDITABLE_RANGES, end);
+    return pairViewForMarkers(start, end);
+};
+Paragraph.prototype.insertEditableRangeAt = function (options) {
+    return insertEditableRangeAt(this, options);
+};
+/**
+ * Feature id string for editable-range markers (`editable-ranges`).
+ * @private
+ */
+export var EDITABLE_RANGES_FEATURE_ID = EDITABLE_RANGES;
+registerEditableRangesFeature();