@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/hyperlinks/index.js

@@ -0,0 +1,685 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 { FeatureInlineParagraphItem, serializeRun, TextRange, } from '../document/text-range';
+import { elementChildren, isWml, wmlAttr, wmlElement, WML } from '../document/wml';
+import { allocateRelationshipId, relationshipsWith, TargetMode } from '../../core/opc/relationships';
+import { relationshipsForPart, withPartRelationships } from '../../core/opc/package';
+import { partName } from '../../core/opc/part-name';
+import { featureId, isFeatureRegistered, registerFeature, registerFeatureInlineHandler, registerFeatureMaterializeHandler, registerFeatureMultiPartHandler, visitParagraphsInDocumentOrder, } from '../../core/registry/index';
+var HYPERLINKS = featureId('hyperlinks');
+/**
+ * @private
+ * Transitional hyperlink relationship (ECMA-376-4 §9.2.1). */
+export var HYPERLINK_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink';
+/**
+ * @private
+ * Strict hyperlink relationship. */
+export var STRICT_HYPERLINK_RELATIONSHIP_TYPE = 'http://purl.oclc.org/ooxml/officeDocument/relationships/hyperlink';
+var HYPERLINK_RELATIONSHIP_TYPES = [
+    HYPERLINK_RELATIONSHIP_TYPE,
+    STRICT_HYPERLINK_RELATIONSHIP_TYPE,
+];
+var R_NS = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+var HyperlinkRunOwner = /** @class */ (function () {
+    function HyperlinkRunOwner() {
+        this.runs = [];
+    }
+    HyperlinkRunOwner.prototype.assertAttachedItem = function (target) {
+        if (!(target instanceof TextRange) || this.runs.indexOf(target) < 0) {
+            throw new DetachedObjectError('This run is no longer in its hyperlink');
+        }
+    };
+    HyperlinkRunOwner.prototype.appendRun = function () {
+        var run = new TextRange(this);
+        this.runs = __spread(this.runs, [run]);
+        return run;
+    };
+    HyperlinkRunOwner.prototype.listRuns = function () {
+        return this.runs;
+    };
+    HyperlinkRunOwner.prototype.detachRuns = function () {
+        var e_1, _a;
+        try {
+            for (var _b = __values(this.runs), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var run = _c.value;
+                run.detach();
+            }
+        }
+        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; }
+        }
+        this.runs = [];
+    };
+    HyperlinkRunOwner.prototype.hydrateRuns = function (runs) {
+        var e_2, _a;
+        this.runs = runs;
+        try {
+            for (var runs_1 = __values(runs), runs_1_1 = runs_1.next(); !runs_1_1.done; runs_1_1 = runs_1.next()) {
+                var run = runs_1_1.value;
+                run.attach(this);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (runs_1_1 && !runs_1_1.done && (_a = runs_1.return)) _a.call(runs_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    };
+    return HyperlinkRunOwner;
+}());
+function relIdAttribute(el) {
+    var __ts33_0;
+    return ((__ts33_0 = el.attributes.find(function (a) { return a.namespaceUri === R_NS && a.localName === 'id'; })), __ts33_0 == null ? undefined : __ts33_0.value);
+}
+function wmlAttribute(el, localName) {
+    var __ts33_1;
+    return ((__ts33_1 = el.attributes.find(function (a) { return a.localName === localName && (a.namespaceUri === WML || a.namespaceUri === ''); })), __ts33_1 == null ? undefined : __ts33_1.value);
+}
+function mergePendingRelationships(existing, add) {
+    var e_3, _a;
+    if (add.length === 0) {
+        return existing;
+    }
+    var used = new Set(existing.items.map(function (item) { return item.id; }));
+    var next = __spread(existing.items);
+    try {
+        for (var add_1 = __values(add), add_1_1 = add_1.next(); !add_1_1.done; add_1_1 = add_1.next()) {
+            var rel = add_1_1.value;
+            var id = rel.id;
+            while (used.has(id)) {
+                id = allocateRelationshipId(used);
+            }
+            used.add(id);
+            next.push(__assign({}, rel, { id: id }));
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (add_1_1 && !add_1_1.done && (_a = add_1.return)) _a.call(add_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return relationshipsWith(next, existing.opaque);
+}
+function parseOnOffAttribute(raw) {
+    if (raw === undefined || raw === '0' || raw === 'false') {
+        return raw === undefined ? undefined : false;
+    }
+    return true;
+}
+/**
+ * External or anchor hyperlink (`w:hyperlink`, ECMA-376-1 §17.16.22 `CT_Hyperlink`).
+ *
+ * Nested display content is exposed as {@link Hyperlink.runs}. Non-run children are
+ * preserved opaquely in document order and re-emitted on save.
+ *
+ * The resolved external URL is **not** a parameterless instance property: package
+ * relationships live on the document catalog. Use {@link hyperlinkTarget} with the
+ * owning {@link WordDocument} (MVP “url” / resolved external target).
+ *
+ * @remarks
+ * - `relationshipId` maps `r:id` when present; new external links receive an id at
+ *   materialize/save time.
+ * - `anchor`, `tooltip`, `docLocation`, `tgtFrame`, and `history` map the corresponding
+ *   `w:hyperlink` attributes when present in the package.
+ * - Field-based `HYPERLINK` instructions are out of scope (separate fields module).
+ *
+ * @public
+ */
+var Hyperlink = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function Hyperlink(runOwner, items, relationshipId, anchor, tooltip, docLocation, tgtFrame, history) {
+        this.runOwner = runOwner;
+        this.items = items;
+        this.relationshipIdValue = relationshipId;
+        this.anchor = anchor;
+        this.tooltip = tooltip;
+        this.docLocation = docLocation;
+        this.tgtFrame = tgtFrame;
+        this.history = history;
+    }
+    Object.defineProperty(Hyperlink.prototype, "relationshipId", {
+        /**
+         * @private
+       * External relationship id (`r:id`) when present. */
+        get: function () {
+            return this.relationshipIdValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    Hyperlink.prototype.resolveRelationshipId = function (relationshipId) {
+        this.relationshipIdValue = relationshipId;
+    };
+    Object.defineProperty(Hyperlink.prototype, "runs", {
+        /**
+         * Visible text runs inside the hyperlink, in document order.
+         *
+         * @public
+         */
+        get: function () {
+            return this.runOwner.listRuns();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    Hyperlink.prototype.releaseContent = function () {
+        this.runOwner.detachRuns();
+    };
+    /**
+     * @private
+     */
+    Hyperlink.prototype.toOpenXml = function () {
+        var e_4, _a;
+        var attributes = [];
+        if (this.tgtFrame !== undefined) {
+            attributes.push(wmlAttr('tgtFrame', this.tgtFrame));
+        }
+        if (this.tooltip !== undefined) {
+            attributes.push(wmlAttr('tooltip', this.tooltip));
+        }
+        if (this.docLocation !== undefined) {
+            attributes.push(wmlAttr('docLocation', this.docLocation));
+        }
+        if (this.history !== undefined) {
+            attributes.push(wmlAttr('history', this.history ? '1' : '0'));
+        }
+        if (this.anchor !== undefined) {
+            attributes.push(wmlAttr('anchor', this.anchor));
+        }
+        if (this.relationshipIdValue !== undefined) {
+            attributes.push({
+                namespaceUri: R_NS,
+                localName: 'id',
+                prefix: 'r',
+                value: this.relationshipIdValue,
+            });
+        }
+        // Emit children from `items` only (document order). Opaque non-run children are
+        // stored once in items — do not also prepend a separate extras list (would duplicate).
+        var children = [];
+        try {
+            for (var _b = __values(this.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var item = _c.value;
+                if (item.type === 'textRange') {
+                    children.push(serializeRun(item.run));
+                }
+                else {
+                    children.push(item.xml);
+                }
+            }
+        }
+        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; }
+        }
+        var namespaceDeclarations = this.relationshipIdValue !== undefined ? [{ prefix: 'r', namespaceUri: R_NS }] : [];
+        return wmlElement('hyperlink', { attributes: attributes, namespaceDeclarations: namespaceDeclarations, children: children });
+    };
+    return Hyperlink;
+}());
+export { Hyperlink };
+/**
+ * Hyperlink relationships on the Main Document part.
+ *
+ * @private
+ * Catalog of hyperlink relationships; not part of the stable public surface.
+ * @private
+ */
+var HyperlinksCatalog = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function HyperlinksCatalog(byRelationshipId, dirty) {
+        this.byRelationshipId = byRelationshipId;
+        this.pendingRemovals = [];
+        this.pendingExternal = new Map();
+        this.dirty = dirty;
+    }
+    /**
+     * @private
+     */
+    HyperlinksCatalog.prototype.removeEntry = function (relationshipId) {
+        if (!this.byRelationshipId.has(relationshipId)) {
+            return;
+        }
+        this.byRelationshipId.delete(relationshipId);
+        this.pendingRemovals.push(relationshipId);
+        this.dirty = true;
+    };
+    /**
+     * @private
+     */
+    HyperlinksCatalog.prototype.isDirty = function () {
+        return (this.dirty ||
+            this.pendingRemovals.length > 0 ||
+            this.pendingExternal.size > 0 ||
+            __spread(this.byRelationshipId.values()).some(function (e) { return e.pendingRelationship !== undefined; }));
+    };
+    /**
+     * @private
+     */
+    HyperlinksCatalog.prototype.applyToPackage = function (pkg, mainPartName) {
+        var e_5, _a, e_6, _b;
+        var next = pkg;
+        var pending = __spread(this.byRelationshipId.values()).map(function (entry) { return entry.pendingRelationship; })
+            .filter(function (rel) { return rel !== undefined; });
+        if (pending.length > 0) {
+            var existing = relationshipsForPart(next, mainPartName);
+            var merged = mergePendingRelationships(existing, pending);
+            try {
+                for (var _c = __values(this.byRelationshipId.values()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var entry = _d.value;
+                    entry.pendingRelationship = undefined;
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+            next = withPartRelationships(next, mainPartName, merged);
+        }
+        var _loop_1 = function (relationshipId) {
+            next = withFilteredPartRelationshipsLocal(next, mainPartName, function (rel) { return rel.id !== relationshipId; });
+        };
+        try {
+            for (var _e = __values(this.pendingRemovals), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var relationshipId = _f.value;
+                _loop_1(relationshipId);
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        this.pendingRemovals.length = 0;
+        this.dirty = false;
+        return next;
+    };
+    /**
+     * @private
+     */
+    HyperlinksCatalog.prototype.relationshipIds = function () {
+        return __spread(this.byRelationshipId.keys());
+    };
+    /**
+     * @private
+     */
+    HyperlinksCatalog.prototype.targetForRelationship = function (relationshipId) {
+        var __ts33_2;
+        return ((__ts33_2 = this.byRelationshipId.get(relationshipId)), __ts33_2 == null ? undefined : __ts33_2.target);
+    };
+    /**
+     * @private
+   * Register an external hyperlink before relationship allocation. */
+    HyperlinksCatalog.prototype.registerPendingExternal = function (hyperlink, target, relationshipType) {
+        if (relationshipType === void 0) { relationshipType = HYPERLINK_RELATIONSHIP_TYPE; }
+        this.pendingExternal.set(hyperlink, { target: target, relationshipType: relationshipType });
+        this.dirty = true;
+    };
+    /**
+     * @private
+     */
+    HyperlinksCatalog.prototype.pendingTargetFor = function (hyperlink) {
+        var __ts33_3;
+        return ((__ts33_3 = this.pendingExternal.get(hyperlink)), __ts33_3 == null ? undefined : __ts33_3.target);
+    };
+    /**
+     * @private
+     */
+    HyperlinksCatalog.prototype.materializePending = function (document) {
+        var _this = this;
+        if (this.pendingExternal.size === 0) {
+            return;
+        }
+        visitParagraphsInDocumentOrder(document, function (paragraph) {
+            var e_7, _a;
+            try {
+                for (var _b = __values(hyperlinksInParagraph(paragraph)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var hyperlink = _c.value;
+                    if (hyperlink.relationshipId !== undefined) {
+                        continue;
+                    }
+                    var pending_1 = _this.pendingExternal.get(hyperlink);
+                    if (pending_1 === undefined) {
+                        continue;
+                    }
+                    var relationshipId = _this.allocateExternalTarget(pending_1.target, usedRelationshipIds(document, _this), pending_1.relationshipType);
+                    hyperlink.resolveRelationshipId(relationshipId);
+                    _this.pendingExternal.delete(hyperlink);
+                }
+            }
+            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; }
+            }
+        });
+    };
+    /**
+     * @private
+     */
+    HyperlinksCatalog.prototype.allocateExternalTarget = function (target, usedRelIds, relationshipType) {
+        if (relationshipType === void 0) { relationshipType = HYPERLINK_RELATIONSHIP_TYPE; }
+        var relId = allocateRelationshipId(usedRelIds);
+        while (this.byRelationshipId.has(relId)) {
+            relId = allocateRelationshipId(new Set(__spread(usedRelIds, [relId])));
+        }
+        var pending = {
+            id: relId,
+            type: relationshipType,
+            target: target,
+            targetMode: TargetMode.External,
+            extraAttributes: [],
+            children: [],
+        };
+        this.byRelationshipId.set(relId, {
+            relationshipId: relId,
+            target: target,
+            relationshipType: relationshipType,
+            pendingRelationship: pending,
+        });
+        this.dirty = true;
+        return relId;
+    };
+    return HyperlinksCatalog;
+}());
+export { HyperlinksCatalog };
+function parseHyperlink(element) {
+    var e_8, _a;
+    if (!isWml(element, 'hyperlink')) {
+        return undefined;
+    }
+    var runOwner = new HyperlinkRunOwner();
+    var items = [];
+    var parsedRuns = [];
+    try {
+        for (var _b = __values(elementChildren(element)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'r')) {
+                var run = TextRange.fromXml(child, runOwner);
+                parsedRuns.push(run);
+                items.push({ type: 'textRange', run: run });
+                continue;
+            }
+            // Non-run children stay opaque and keep order among runs via `items`.
+            items.push({ type: 'opaque', xml: child });
+        }
+    }
+    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; }
+    }
+    runOwner.hydrateRuns(parsedRuns);
+    if (items.every(function (item) { return item.type === 'opaque'; })) {
+        return undefined;
+    }
+    return new Hyperlink(runOwner, items, relIdAttribute(element), wmlAttribute(element, 'anchor'), wmlAttribute(element, 'tooltip'), wmlAttribute(element, 'docLocation'), wmlAttribute(element, 'tgtFrame'), parseOnOffAttribute(wmlAttribute(element, 'history')));
+}
+function loadCatalog(pkg, mainPartName) {
+    var e_9, _a;
+    var rels = relationshipsForPart(pkg, mainPartName);
+    var byRelationshipId = new Map();
+    try {
+        for (var _b = __values(rels.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var rel = _c.value;
+            if (HYPERLINK_RELATIONSHIP_TYPES.indexOf(rel.type) === -1) {
+                continue;
+            }
+            byRelationshipId.set(rel.id, {
+                relationshipId: rel.id,
+                target: rel.target,
+                relationshipType: rel.type,
+                pendingRelationship: undefined,
+            });
+        }
+    }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_9) throw e_9.error; }
+    }
+    return new HyperlinksCatalog(byRelationshipId, false);
+}
+function usedRelationshipIds(document, catalog) {
+    var e_10, _a, e_11, _b;
+    var main = partName('/word/document.xml');
+    var used = new Set();
+    try {
+        for (var _c = __values(relationshipsForPart(document.opcPackage(), main).items), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var rel = _d.value;
+            used.add(rel.id);
+        }
+    }
+    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_10) throw e_10.error; }
+    }
+    try {
+        for (var _e = __values(catalog.relationshipIds()), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var id = _f.value;
+            used.add(id);
+        }
+    }
+    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+        }
+        finally { if (e_11) throw e_11.error; }
+    }
+    return used;
+}
+function withFilteredPartRelationshipsLocal(pkg, source, keep) {
+    var existing = relationshipsForPart(pkg, source);
+    var kept = existing.items.filter(keep);
+    if (kept.length === existing.items.length) {
+        return pkg;
+    }
+    return withPartRelationships(pkg, source, relationshipsWith(kept, existing.opaque));
+}
+var registered = false;
+/**
+ * @private
+ * Test hook */
+export function resetHyperlinksFeatureForTests() {
+    registered = false;
+}
+/**
+ * @private
+ * Register hyperlink inline and relationship handlers. Idempotent. */
+export function registerHyperlinksFeature() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    registerFeature({ id: HYPERLINKS });
+    registerFeatureMultiPartHandler({
+        featureId: HYPERLINKS,
+        relationshipTypes: HYPERLINK_RELATIONSHIP_TYPES,
+        loadParts: function (pkg, ctx) {
+            return loadCatalog(pkg, ctx.mainPartName);
+        },
+    });
+    registerFeatureMaterializeHandler({
+        featureId: HYPERLINKS,
+        materialize: function (document) {
+            var part = document.featurePart(HYPERLINKS);
+            if (part instanceof HyperlinksCatalog) {
+                part.materializePending(document);
+            }
+        },
+    });
+    registerFeatureInlineHandler({
+        featureId: HYPERLINKS,
+        wmlLocalName: 'hyperlink',
+        tryParse: function (element) {
+            return parseHyperlink(element);
+        },
+    });
+}
+/**
+ * Hyperlink catalog for a document.
+ *
+ * On a loaded package this is the catalog built from Main Document relationships.
+ * On a newly authored document there are no relationships yet, so this function
+ * attaches an empty catalog on first use and {@link WordDocument.saveSync | saveSync}
+ * materializes pending relationships into the package.
+ *
+ * @throws DocxError `feature/not-registered` when the module was not registered.
+ * @private
+ */
+export function hyperlinksFor(document) {
+    var part = document.featurePart(HYPERLINKS);
+    if (part instanceof HyperlinksCatalog) {
+        return part;
+    }
+    if (part !== undefined) {
+        throw new DocxError('feature/not-registered', 'Hyperlinks feature state was replaced with an unexpected part type');
+    }
+    if (!isFeatureRegistered(HYPERLINKS)) {
+        throw new DocxError('feature/not-registered', 'Hyperlinks feature is not registered; call registerHyperlinksFeature() before use');
+    }
+    var created = new HyperlinksCatalog(new Map(), false);
+    document.setFeaturePart(HYPERLINKS, created);
+    return created;
+}
+/**
+ * Hyperlinks in a paragraph, in document order.
+ *
+ * @private
+ */
+export function hyperlinksInParagraph(paragraph) {
+    var e_12, _a;
+    var found = [];
+    try {
+        for (var _b = __values(paragraph.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var inline = _c.value;
+            if (isHyperlinkInline(inline)) {
+                found.push(inline.value);
+            }
+        }
+    }
+    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 found;
+}
+/**
+ * Resolved external URL (MVP “url”) for a hyperlink, when present.
+ *
+ * Looks up the Main Document hyperlink relationship `Target` for
+ * {@link Hyperlink.relationshipId}, or the pending external target registered for a
+ * newly authored link that has not yet been materialized. Returns `undefined` for
+ * anchor-only internal links with no external relationship.
+ *
+ * Targets are data only — never fetched or executed (see security policy).
+ *
+ * @private
+ */
+export function hyperlinkTarget(document, hyperlink) {
+    if (hyperlink.relationshipId !== undefined) {
+        return hyperlinksFor(document).targetForRelationship(hyperlink.relationshipId);
+    }
+    return hyperlinksFor(document).pendingTargetFor(hyperlink);
+}
+/**
+ * Remove a hyperlink inline from its paragraph and drop its external relationship on save.
+ *
+ * @private
+ */
+export function removeHyperlink(document, paragraph, hyperlink) {
+    paragraph.removeFeatureInline(hyperlink);
+    if (hyperlink.relationshipId !== undefined) {
+        hyperlinksFor(document).removeEntry(hyperlink.relationshipId);
+    }
+}
+/**
+ * Whether paragraph inline content is a modeled hyperlink from this module.
+ *
+ * @private
+ */
+export function isHyperlinkInline(inline) {
+    return (inline instanceof FeatureInlineParagraphItem &&
+        inline.featureId === HYPERLINKS &&
+        inline.value instanceof Hyperlink);
+}
+registerHyperlinksFeature();