@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/ole-object/catalog.js

@@ -0,0 +1,908 @@
+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 };
+        }
+    };
+};
+/**
+ * OLE object multi-package-part catalog (TASK-8054 embed + TASK-8055 link +
+ * TASK-8056 icon/preview media).
+ *
+ * Owns the embedded-package bytes for OLE objects (`word/embeddings/*`),
+ * external link targets, and optional icon/preview media
+ * (`word/media/imageN.{png|jpeg}`), mirroring the images module part
+ * pipeline (`registerPendingImage` → `materializePending` → `allocatePart` →
+ * `applyToPackage`):
+ *
+ * - **Pending registration at append** — authoring registers payload bytes
+ *   (and optional icon bytes) against the created {@link OleObject} without
+ *   allocating package ids; relationship ids and part names are allocated at
+ *   save (`materializePending`).
+ * - **Deterministic part naming** — embeddings `word/embeddings/oleObject{N}.bin`
+ *   (ECMA-376-1 §15.2.10); icons `word/media/image{N}.{png|jpeg}`
+ *   (ECMA-376-1 §15.2.14; images module parity).
+ * - **Content type** — embed: caller-provided, else the default
+ *   `application/vnd.openxmlformats-officedocument.oleObject`; icon: sniffed
+ *   PNG/JPEG only.
+ * - **No OLE byte dedupe** — OLE storages are not content-addressable (two
+ *   appends of identical bytes yield two distinct parts and relationships).
+ * - **Icon hash dedupe** — identical icon bytes share one media part and one
+ *   image relationship (sha256; images module parity).
+ * - **Orphan GC at save** — a part with no referencing `w:object` in the
+ *   document is removed together with its relationship and content-type
+ *   override (parity with the images module).
+ * - **Linked objects (TASK-8055)** — external relationships only
+ *   (`TargetMode="External"`); **no part** is created for the OLE link.
+ *   Icon media for a link is still an internal image part.
+ *
+ * Security (`.agent/policies/security.md`): payload bytes are opaque data.
+ * This catalog stores, replaces, and writes them; it never parses,
+ * decompresses, inspects beyond length, activates, or launches anything.
+ * Link targets are strings only. Icon bytes are PNG/JPEG media only.
+ *
+ * @packageDocumentation
+ */
+import { sha256Hex as sha256Digest } from '../../core/compat/sha256';
+import { allocateRelationshipId, relationshipsWith, TargetMode } from '../../core/opc/relationships';
+import { partByName, relationshipsForPart, withPartRelationships } from '../../core/opc/package';
+import { partName, partNameKey } from '../../core/opc/part-name';
+import { replaceOrAddPackagePart } from '../../core/registry/multi-part-handlers';
+import { usedMainDocumentRelationshipIds } from '../../core/registry/multi-part-handlers';
+import { IMAGE_RELATIONSHIP_TYPE, JPEG_CONTENT_TYPE, PNG_CONTENT_TYPE } from '../images/index';
+import { OLE_OBJECT_LINK_LONG_PATH_RELATIONSHIP_TYPE, OLE_OBJECT_RELATIONSHIP_TYPE, } from './relationship';
+/**
+ * Default content type for authored embedded-object parts (unknown binary
+ * storage). ECMA-376-1 §15.2.10 permits any content type; Word uses this
+ * token for OLE compound storages.
+ *
+ * @private
+ */
+export var OLE_OBJECT_DEFAULT_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.oleObject';
+/** Part-name prefix for authored embedding parts (spec §Package parts). */
+var EMBEDDINGS_PART_PREFIX = '/word/embeddings/oleObject';
+/** Part-name extension for authored embedding parts. */
+var EMBEDDINGS_PART_SUFFIX = '.bin';
+/** Part-name prefix for authored icon media (images module parity). */
+var MEDIA_PART_PREFIX = '/word/media/image';
+/**
+ * Package catalog for embedded OLE object parts, linked external targets,
+ * and icon/preview media parts (TASK-8056).
+ *
+ * Loaded from Main-WordDocument relationships of the transitional `oleObject`
+ * type (and the long-path link variant on load only) plus image
+ * relationships whose parts are PNG/JPEG (icon media). Authored
+ * embeds/links/icons register pending entries that are materialized at save.
+ *
+ * @private
+ */
+var OleObjectCatalog = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function OleObjectCatalog(entries, externalByRelationshipId, iconEntries) {
+        var e_1, _a;
+        if (externalByRelationshipId === void 0) { externalByRelationshipId = new Map(); }
+        if (iconEntries === void 0) { iconEntries = new Map(); }
+        this.entries = entries;
+        this.byRelationshipId = new Map(__spread(entries.values()).map(function (entry) { return [entry.relationshipId, entry]; }));
+        this.externalByRelationshipId = externalByRelationshipId;
+        this.iconEntries = iconEntries;
+        this.iconByRelationshipId = new Map(__spread(iconEntries.values()).map(function (entry) { return [entry.relationshipId, entry]; }));
+        this.iconHashToRelationshipId = new Map();
+        try {
+            for (var _b = __values(iconEntries.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entry = _c.value;
+                this.iconHashToRelationshipId.set(sha256Hex(entry.data), entry.relationshipId);
+            }
+        }
+        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.pendingRemovals = [];
+        this.pendingExternalRemovals = [];
+        this.pendingIconRemovals = [];
+        this.pendingEmbeds = new Map();
+        this.pendingLinks = new Map();
+        this.pendingIcons = new Map();
+    }
+    /**
+     * Loaded + pending embedded-object entries (embedded only; linked objects
+     * have no part).
+     *
+     * @private
+     */
+    OleObjectCatalog.prototype.objects = function () {
+        return __spread(this.entries.values());
+    };
+    /**
+     * Payload bytes for a main-document relationship id (embedded parts only).
+     *
+     * @private
+     */
+    OleObjectCatalog.prototype.bytesForRelationship = function (relationshipId) {
+        var __ts33_0;
+        return ((__ts33_0 = this.byRelationshipId.get(relationshipId)), __ts33_0 == null ? undefined : __ts33_0.data);
+    };
+    /**
+     * External target string for a main-document relationship id (linked
+     * objects only). Returns `undefined` for embeds. The string is stored
+     * verbatim and is never fetched, resolved, or opened.
+     *
+     * @private
+     */
+    OleObjectCatalog.prototype.targetForRelationship = function (relationshipId) {
+        var __ts33_1;
+        return ((__ts33_1 = this.externalByRelationshipId.get(relationshipId)), __ts33_1 == null ? undefined : __ts33_1.target);
+    };
+    /**
+     * Icon/preview image bytes for a main-document image relationship id
+     * (TASK-8056). Returns `undefined` when the id is not an icon media entry.
+     *
+     * @private
+     */
+    OleObjectCatalog.prototype.iconBytesForRelationship = function (relationshipId) {
+        var __ts33_2;
+        return ((__ts33_2 = this.iconByRelationshipId.get(relationshipId)), __ts33_2 == null ? undefined : __ts33_2.data);
+    };
+    /**
+     * @private
+   * Pending payload bytes for a not-yet-materialized embed. */
+    OleObjectCatalog.prototype.pendingBytesFor = function (object) {
+        var __ts33_3;
+        return ((__ts33_3 = this.pendingEmbeds.get(object)), __ts33_3 == null ? undefined : __ts33_3.bytes);
+    };
+    /**
+     * @private
+   * Pending external target for a not-yet-materialized link. */
+    OleObjectCatalog.prototype.pendingTargetFor = function (object) {
+        var __ts33_4;
+        return ((__ts33_4 = this.pendingLinks.get(object)), __ts33_4 == null ? undefined : __ts33_4.target);
+    };
+    /**
+     * @private
+   * Pending icon bytes for a not-yet-materialized icon. */
+    OleObjectCatalog.prototype.pendingIconBytesFor = function (object) {
+        var __ts33_5;
+        return ((__ts33_5 = this.pendingIcons.get(object)), __ts33_5 == null ? undefined : __ts33_5.bytes);
+    };
+    /**
+     * @private
+   * Part names already owned by the catalog (embed + icon). */
+    OleObjectCatalog.prototype.pendingPartNames = function () {
+        return __spread(this.entries.keys(), this.iconEntries.keys());
+    };
+    /**
+     * @private
+     * Relationship ids already owned by the catalog
+     * (embed + link + icon).
+     */
+    OleObjectCatalog.prototype.pendingRelationshipIds = function () {
+        return __spread(this.byRelationshipId.keys(), this.externalByRelationshipId.keys(), this.iconByRelationshipId.keys());
+    };
+    /**
+     * @private
+     * Record embed intent without allocating package ids
+     * (images `registerPendingImage` pattern). `contentType` may be
+     * caller-provided or the module default.
+     */
+    OleObjectCatalog.prototype.registerPendingEmbed = function (object, bytes, contentType) {
+        this.pendingEmbeds.set(object, { bytes: bytes, contentType: contentType });
+    };
+    /**
+     * @private
+     * Record link intent without allocating package ids
+     * (hyperlinks `registerPendingExternal` pattern). Target is a stored
+     * string only — never fetched.
+     */
+    OleObjectCatalog.prototype.registerPendingLink = function (object, target) {
+        this.pendingLinks.set(object, { target: target });
+    };
+    /**
+     * @private
+     * Record icon/preview media intent without allocating package
+     * ids (TASK-8056; images `registerPendingImage` pattern). Bytes must
+     * already be sniffed as PNG or JPEG by the caller.
+     */
+    OleObjectCatalog.prototype.registerPendingIcon = function (object, bytes, contentType) {
+        this.pendingIcons.set(object, { bytes: bytes, contentType: contentType });
+    };
+    /**
+     * @private
+   * Drop a pending embed removed before save. */
+    OleObjectCatalog.prototype.discardPendingEmbed = function (object) {
+        this.pendingEmbeds.delete(object);
+    };
+    /**
+     * @private
+   * Drop a pending link removed before save. */
+    OleObjectCatalog.prototype.discardPendingLink = function (object) {
+        this.pendingLinks.delete(object);
+    };
+    /**
+     * @private
+   * Drop a pending icon removed before save. */
+    OleObjectCatalog.prototype.discardPendingIcon = function (object) {
+        this.pendingIcons.delete(object);
+    };
+    /**
+     * @private
+   * Replace bytes on a not-yet-materialized embed. */
+    OleObjectCatalog.prototype.updatePendingBytes = function (object, bytes) {
+        var pending = this.pendingEmbeds.get(object);
+        if (pending === undefined) {
+            throw new Error('Pending OLE object was not found');
+        }
+        this.pendingEmbeds.set(object, __assign({}, pending, { bytes: bytes }));
+    };
+    /**
+     * @private
+     * Replace bytes on a loaded entry and mark it dirty
+     * (byte-replace only; the library never interprets OLE storages).
+     */
+    OleObjectCatalog.prototype.replaceBytes = function (relationshipId, bytes) {
+        var entry = this.byRelationshipId.get(relationshipId);
+        if (entry === undefined) {
+            throw new Error("OLE object relationship " + relationshipId + " is not loaded");
+        }
+        entry.data = bytes;
+        entry.dirty = true;
+    };
+    /**
+     * @private
+     * Queue orphan removal of a part + relationship + content-type
+     * override (GC parity with the images module). For external (link-only)
+     * relationships, removes the relationship entry only — there is no part.
+     */
+    OleObjectCatalog.prototype.removeEntry = function (relationshipId) {
+        var entry = this.byRelationshipId.get(relationshipId);
+        if (entry !== undefined) {
+            this.entries.delete(entry.partName);
+            this.byRelationshipId.delete(relationshipId);
+            this.pendingRemovals.push(entry);
+            return;
+        }
+        if (this.externalByRelationshipId.has(relationshipId)) {
+            this.externalByRelationshipId.delete(relationshipId);
+            this.pendingExternalRemovals.push(relationshipId);
+        }
+    };
+    /**
+     * @private
+     * Queue removal of an icon media part + image relationship
+     * (TASK-8056). Shared media (hash-deduped) is removed only when this is
+     * the last catalog reference; callers must not remove shared icons while
+     * other objects still reference the same relationship id.
+     */
+    OleObjectCatalog.prototype.removeIconEntry = function (relationshipId) {
+        var entry = this.iconByRelationshipId.get(relationshipId);
+        if (entry === undefined) {
+            return;
+        }
+        this.iconEntries.delete(entry.partName);
+        this.iconByRelationshipId.delete(relationshipId);
+        var hash = sha256Hex(entry.data);
+        if (this.iconHashToRelationshipId.get(hash) === relationshipId) {
+            this.iconHashToRelationshipId.delete(hash);
+        }
+        this.pendingIconRemovals.push(entry);
+    };
+    /**
+     * @private
+     */
+    OleObjectCatalog.prototype.isDirty = function () {
+        var e_2, _a, e_3, _b, e_4, _c;
+        if (this.pendingRemovals.length > 0 ||
+            this.pendingExternalRemovals.length > 0 ||
+            this.pendingIconRemovals.length > 0 ||
+            this.pendingEmbeds.size > 0 ||
+            this.pendingLinks.size > 0 ||
+            this.pendingIcons.size > 0) {
+            return true;
+        }
+        try {
+            for (var _d = __values(this.entries.values()), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var entry = _e.value;
+                if (entry.dirty || entry.pendingRelationship !== undefined) {
+                    return true;
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        try {
+            for (var _f = __values(this.externalByRelationshipId.values()), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var entry = _g.value;
+                if (entry.pendingRelationship !== undefined) {
+                    return true;
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        try {
+            for (var _h = __values(this.iconEntries.values()), _j = _h.next(); !_j.done; _j = _h.next()) {
+                var entry = _j.value;
+                if (entry.dirty || entry.pendingRelationship !== undefined) {
+                    return true;
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        return false;
+    };
+    /**
+     * @private
+     * Allocate a new embedding part + main-document relationship
+     * for one pending embed (images `allocatePart` pattern; no dedupe).
+     */
+    OleObjectCatalog.prototype.allocatePart = function (bytes, contentType, usedRelIds, usedPartNames) {
+        var partNameValue = allocateEmbeddingPartName(usedPartNames);
+        var relId = allocateRelationshipId(usedRelIds);
+        while (this.byRelationshipId.has(relId) ||
+            this.externalByRelationshipId.has(relId) ||
+            this.iconByRelationshipId.has(relId)) {
+            relId = allocateRelationshipId(new Set(__spread(usedRelIds, [relId])));
+        }
+        var entry = {
+            partName: partNameValue,
+            relationshipId: relId,
+            relationshipType: OLE_OBJECT_RELATIONSHIP_TYPE,
+            contentType: contentType,
+            data: bytes,
+            dirty: true,
+            pendingRelationship: {
+                id: relId,
+                type: OLE_OBJECT_RELATIONSHIP_TYPE,
+                target: relativeTarget(partNameValue),
+                extraAttributes: [],
+                children: [],
+            },
+        };
+        this.entries.set(partNameValue, entry);
+        this.byRelationshipId.set(relId, entry);
+        return { entry: entry, relationshipId: relId };
+    };
+    /**
+     * @private
+     * Allocate an external oleObject relationship for one pending
+     * link (hyperlinks `allocateExternalTarget` pattern). No part is created.
+     * Always emits the transitional oleObject type — never the long-path
+     * accept-only variant.
+     */
+    OleObjectCatalog.prototype.allocateExternalTarget = function (target, usedRelIds) {
+        var relId = allocateRelationshipId(usedRelIds);
+        while (this.byRelationshipId.has(relId) ||
+            this.externalByRelationshipId.has(relId) ||
+            this.iconByRelationshipId.has(relId)) {
+            relId = allocateRelationshipId(new Set(__spread(usedRelIds, [relId])));
+        }
+        var pending = {
+            id: relId,
+            type: OLE_OBJECT_RELATIONSHIP_TYPE,
+            target: target,
+            targetMode: TargetMode.External,
+            extraAttributes: [],
+            children: [],
+        };
+        this.externalByRelationshipId.set(relId, {
+            relationshipId: relId,
+            target: target,
+            relationshipType: OLE_OBJECT_RELATIONSHIP_TYPE,
+            pendingRelationship: pending,
+        });
+        return relId;
+    };
+    /**
+     * @private
+     * Allocate (or reuse via sha256) an icon media part + image
+     * relationship (TASK-8056; images `allocatePart` + hash-dedupe pattern).
+     */
+    OleObjectCatalog.prototype.allocateIconPart = function (bytes, contentType, usedRelIds, usedPartNames) {
+        var hash = sha256Hex(bytes);
+        var existingId = this.iconHashToRelationshipId.get(hash);
+        if (existingId !== undefined) {
+            var existing = this.iconByRelationshipId.get(existingId);
+            if (existing !== undefined) {
+                return { entry: existing, relationshipId: existingId };
+            }
+        }
+        var partNameValue = allocateIconPartName(contentType, usedPartNames);
+        var relId = allocateRelationshipId(usedRelIds);
+        while (this.byRelationshipId.has(relId) ||
+            this.externalByRelationshipId.has(relId) ||
+            this.iconByRelationshipId.has(relId)) {
+            relId = allocateRelationshipId(new Set(__spread(usedRelIds, [relId])));
+        }
+        var entry = {
+            partName: partNameValue,
+            relationshipId: relId,
+            relationshipType: IMAGE_RELATIONSHIP_TYPE,
+            contentType: contentType,
+            data: bytes,
+            dirty: true,
+            pendingRelationship: {
+                id: relId,
+                type: IMAGE_RELATIONSHIP_TYPE,
+                target: relativeTarget(partNameValue),
+                extraAttributes: [],
+                children: [],
+            },
+        };
+        this.iconEntries.set(partNameValue, entry);
+        this.iconByRelationshipId.set(relId, entry);
+        this.iconHashToRelationshipId.set(hash, relId);
+        return { entry: entry, relationshipId: relId };
+    };
+    /**
+     * @private
+     * Allocate relationship ids (+ part names for embeds/icons) for
+     * pending embeds, links, and icons and resolve each object's `r:id` values
+     * (save-time `materializePending`). The caller supplies the modeled OLE
+     * objects in document order (avoids a circular import of the index listing
+     * helper). Objects that carry a pending registration but were not visited
+     * keep their registration (the next save retries); objects removed before
+     * save are dropped via `discardPendingEmbed` / `discardPendingLink` /
+     * `discardPendingIcon`.
+     */
+    OleObjectCatalog.prototype.materializePending = function (document, objects) {
+        var e_5, _a, e_6, _b;
+        if (this.pendingEmbeds.size === 0 &&
+            this.pendingLinks.size === 0 &&
+            this.pendingIcons.size === 0) {
+            return;
+        }
+        var usedRelIds = usedMainDocumentRelationshipIds(document);
+        try {
+            for (var _c = __values(this.pendingRelationshipIds()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var id = _d.value;
+                usedRelIds.add(id);
+            }
+        }
+        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; }
+        }
+        var usedPartNames = usedPartNameKeys(document, this);
+        try {
+            for (var objects_1 = __values(objects), objects_1_1 = objects_1.next(); !objects_1_1.done; objects_1_1 = objects_1.next()) {
+                var object = objects_1_1.value;
+                if (object.isPendingRelationship()) {
+                    var pendingEmbed = this.pendingEmbeds.get(object);
+                    if (pendingEmbed !== undefined) {
+                        var allocated = this.allocatePart(pendingEmbed.bytes, pendingEmbed.contentType, usedRelIds, usedPartNames);
+                        usedRelIds.add(allocated.relationshipId);
+                        usedPartNames.add(partNameKey(allocated.entry.partName));
+                        object.resolveRelationshipId(allocated.relationshipId);
+                        this.pendingEmbeds.delete(object);
+                    }
+                    else {
+                        var pendingLink = this.pendingLinks.get(object);
+                        if (pendingLink !== undefined) {
+                            var relationshipId = this.allocateExternalTarget(pendingLink.target, usedRelIds);
+                            usedRelIds.add(relationshipId);
+                            object.resolveRelationshipId(relationshipId);
+                            this.pendingLinks.delete(object);
+                        }
+                    }
+                }
+                if (object.isPendingIcon()) {
+                    var pendingIcon = this.pendingIcons.get(object);
+                    if (pendingIcon !== undefined) {
+                        var allocated = this.allocateIconPart(pendingIcon.bytes, pendingIcon.contentType, usedRelIds, usedPartNames);
+                        usedRelIds.add(allocated.relationshipId);
+                        usedPartNames.add(partNameKey(allocated.entry.partName));
+                        object.resolveIconRelationshipId(allocated.relationshipId);
+                        this.pendingIcons.delete(object);
+                    }
+                }
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (objects_1_1 && !objects_1_1.done && (_b = objects_1.return)) _b.call(objects_1);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+    };
+    /**
+     * @private
+     */
+    OleObjectCatalog.prototype.applyToPackage = function (pkg, mainPartName) {
+        var e_7, _a, e_8, _b, e_9, _c, e_10, _d, e_11, _e, e_12, _f;
+        var next = pkg;
+        var _loop_1 = function (entry) {
+            if (!entry.dirty && entry.pendingRelationship === undefined) {
+                return "continue";
+            }
+            var rel = entry.pendingRelationship != null ? entry.pendingRelationship : relationshipsForPart(next, mainPartName).items.find(function (item) { return item.id === entry.relationshipId; });
+            next = replaceOrAddPackagePart(next, mainPartName, entry.partName, entry.contentType, entry.data, rel);
+            entry.dirty = false;
+            entry.pendingRelationship = undefined;
+        };
+        try {
+            for (var _g = __values(this.entries.values()), _h = _g.next(); !_h.done; _h = _g.next()) {
+                var entry = _h.value;
+                _loop_1(entry);
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_h && !_h.done && (_a = _g.return)) _a.call(_g);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        var _loop_2 = function (entry) {
+            if (!entry.dirty && entry.pendingRelationship === undefined) {
+                return "continue";
+            }
+            var rel = entry.pendingRelationship != null ? entry.pendingRelationship : relationshipsForPart(next, mainPartName).items.find(function (item) { return item.id === entry.relationshipId; });
+            next = replaceOrAddPackagePart(next, mainPartName, entry.partName, entry.contentType, entry.data, rel);
+            entry.dirty = false;
+            entry.pendingRelationship = undefined;
+        };
+        try {
+            for (var _j = __values(this.iconEntries.values()), _k = _j.next(); !_k.done; _k = _j.next()) {
+                var entry = _k.value;
+                _loop_2(entry);
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_k && !_k.done && (_b = _j.return)) _b.call(_j);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        // Merge pending external (link) relationships — no parts (hyperlinks pattern).
+        var pendingExternalRels = __spread(this.externalByRelationshipId.values()).map(function (entry) { return entry.pendingRelationship; })
+            .filter(function (rel) { return rel !== undefined; });
+        if (pendingExternalRels.length > 0) {
+            var existing = relationshipsForPart(next, mainPartName);
+            var merged = mergePendingRelationships(existing, pendingExternalRels);
+            try {
+                for (var _l = __values(this.externalByRelationshipId.values()), _m = _l.next(); !_m.done; _m = _l.next()) {
+                    var entry = _m.value;
+                    entry.pendingRelationship = undefined;
+                }
+            }
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+            finally {
+                try {
+                    if (_m && !_m.done && (_c = _l.return)) _c.call(_l);
+                }
+                finally { if (e_9) throw e_9.error; }
+            }
+            next = withPartRelationships(next, mainPartName, merged);
+        }
+        try {
+            for (var _o = __values(this.pendingRemovals), _p = _o.next(); !_p.done; _p = _o.next()) {
+                var entry = _p.value;
+                next = removeOleObjectPartFromPackage(next, mainPartName, entry);
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (_p && !_p.done && (_d = _o.return)) _d.call(_o);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+        this.pendingRemovals.length = 0;
+        try {
+            for (var _q = __values(this.pendingIconRemovals), _r = _q.next(); !_r.done; _r = _q.next()) {
+                var entry = _r.value;
+                next = removeOleIconPartFromPackage(next, mainPartName, entry);
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (_r && !_r.done && (_e = _q.return)) _e.call(_q);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+        this.pendingIconRemovals.length = 0;
+        var _loop_3 = function (relationshipId) {
+            next = withFilteredPartRelationshipsLocal(next, mainPartName, function (rel) { return rel.id !== relationshipId; });
+        };
+        try {
+            for (var _s = __values(this.pendingExternalRemovals), _t = _s.next(); !_t.done; _t = _s.next()) {
+                var relationshipId = _t.value;
+                _loop_3(relationshipId);
+            }
+        }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (_t && !_t.done && (_f = _s.return)) _f.call(_s);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
+        this.pendingExternalRemovals.length = 0;
+        return next;
+    };
+    return OleObjectCatalog;
+}());
+export { OleObjectCatalog };
+function mergePendingRelationships(existing, add) {
+    var e_13, _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_13_1) { e_13 = { error: e_13_1 }; }
+    finally {
+        try {
+            if (add_1_1 && !add_1_1.done && (_a = add_1.return)) _a.call(add_1);
+        }
+        finally { if (e_13) throw e_13.error; }
+    }
+    return relationshipsWith(next, existing.opaque);
+}
+function relativeTarget(partNameValue) {
+    return partNameValue.slice('/word/'.length);
+}
+/** First unused `oleObject{N}.bin` part name (deterministic, no dedupe). */
+function allocateEmbeddingPartName(used) {
+    var index = 1;
+    while (used.has(partNameKey("" + EMBEDDINGS_PART_PREFIX + String(index) + EMBEDDINGS_PART_SUFFIX))) {
+        index += 1;
+    }
+    return partName("" + EMBEDDINGS_PART_PREFIX + String(index) + EMBEDDINGS_PART_SUFFIX);
+}
+/** First unused `image{N}.{png|jpeg}` part name (images module parity). */
+function allocateIconPartName(contentType, used) {
+    var ext = extensionForIconContentType(contentType);
+    var index = 1;
+    while (used.has(partNameKey("" + MEDIA_PART_PREFIX + String(index) + "." + ext))) {
+        index += 1;
+    }
+    return partName("" + MEDIA_PART_PREFIX + String(index) + "." + ext);
+}
+function extensionForIconContentType(contentType) {
+    return contentType === JPEG_CONTENT_TYPE ? 'jpeg' : 'png';
+}
+function sha256Hex(data) {
+    return sha256Digest(data);
+}
+function usedPartNameKeys(document, catalog) {
+    var e_14, _a, e_15, _b;
+    var used = new Set();
+    try {
+        for (var _c = __values(document.opcPackage().parts), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var part = _d.value;
+            used.add(partNameKey(part.name));
+        }
+    }
+    catch (e_14_1) { e_14 = { error: e_14_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_14) throw e_14.error; }
+    }
+    try {
+        for (var _e = __values(catalog.pendingPartNames()), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var name_1 = _f.value;
+            used.add(partNameKey(name_1));
+        }
+    }
+    catch (e_15_1) { e_15 = { error: e_15_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+        }
+        finally { if (e_15) throw e_15.error; }
+    }
+    return used;
+}
+function removeOleObjectPartFromPackage(pkg, mainPartName, entry) {
+    var next = withRemovedPartLocal(pkg, entry.partName);
+    next = withRemovedContentTypeOverrideLocal(next, entry.partName);
+    next = withFilteredPartRelationshipsLocal(next, mainPartName, function (rel) { return rel.id !== entry.relationshipId; });
+    return next;
+}
+function removeOleIconPartFromPackage(pkg, mainPartName, entry) {
+    var next = withRemovedPartLocal(pkg, entry.partName);
+    next = withRemovedContentTypeOverrideLocal(next, entry.partName);
+    next = withFilteredPartRelationshipsLocal(next, mainPartName, function (rel) { return rel.id !== entry.relationshipId; });
+    return next;
+}
+function withRemovedPartLocal(pkg, name) {
+    var key = partNameKey(name);
+    var parts = pkg.parts.filter(function (part) { return partNameKey(part.name) !== key; });
+    if (parts.length === pkg.parts.length) {
+        return pkg;
+    }
+    return __assign({}, pkg, { parts: parts });
+}
+function withRemovedContentTypeOverrideLocal(pkg, logicalPartName) {
+    return __assign({}, pkg, { contentTypes: {
+            records: pkg.contentTypes.records.filter(function (record) { return !(record.kind === 'override' && record.partName === logicalPartName); }),
+        } });
+}
+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));
+}
+function isOleObjectRelationshipType(type) {
+    return (type === OLE_OBJECT_RELATIONSHIP_TYPE ||
+        type === OLE_OBJECT_LINK_LONG_PATH_RELATIONSHIP_TYPE);
+}
+function isImageRelationshipType(type) {
+    return type === IMAGE_RELATIONSHIP_TYPE;
+}
+function contentTypeForIconPart(part) {
+    if (part.contentType === PNG_CONTENT_TYPE || part.contentType === JPEG_CONTENT_TYPE) {
+        return part.contentType;
+    }
+    return undefined;
+}
+/**
+ * Load the OLE-object catalog from Main-WordDocument relationships of the
+ * `oleObject` type (and the long-path link variant) plus PNG/JPEG image
+ * relationships used as OLE icon/preview media (TASK-8056).
+ *
+ * Internal oleObject targets load embedded parts; external targets load
+ * link target strings only (no part). Image relationships with PNG/JPEG
+ * content types load into the icon catalog.
+ *
+ * @private
+ */
+export function loadOleObjectCatalog(pkg, mainPartName) {
+    var e_16, _a;
+    var rels = relationshipsForPart(pkg, mainPartName);
+    var entries = new Map();
+    var externalByRelationshipId = new Map();
+    var iconEntries = new Map();
+    try {
+        for (var _b = __values(rels.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var rel = _c.value;
+            if (isOleObjectRelationshipType(rel.type)) {
+                // External targets are linked objects (TASK-8055); store the target string only.
+                if (rel.targetMode === TargetMode.External) {
+                    externalByRelationshipId.set(rel.id, {
+                        relationshipId: rel.id,
+                        target: rel.target,
+                        relationshipType: rel.type,
+                        pendingRelationship: undefined,
+                    });
+                    continue;
+                }
+                // Long-path is a link-only product type; ignore internal targets for it.
+                if (rel.type === OLE_OBJECT_LINK_LONG_PATH_RELATIONSHIP_TYPE) {
+                    continue;
+                }
+                var target = resolveInternalTargetLocal(rel.target, mainPartName);
+                var part = partByName(pkg, target);
+                if (part === undefined) {
+                    continue; // dangling relationship: body parse keeps the object; GC handles the rest
+                }
+                entries.set(part.name, {
+                    partName: part.name,
+                    relationshipId: rel.id,
+                    relationshipType: rel.type,
+                    contentType: part.contentType,
+                    data: part.data,
+                    dirty: false,
+                    pendingRelationship: undefined,
+                });
+                continue;
+            }
+            // TASK-8056: PNG/JPEG image relationships are candidates for icon media.
+            if (!isImageRelationshipType(rel.type) || rel.targetMode === TargetMode.External) {
+                continue;
+            }
+            var imageTarget = resolveInternalTargetLocal(rel.target, mainPartName);
+            var imagePart = partByName(pkg, imageTarget);
+            if (imagePart === undefined) {
+                continue;
+            }
+            var iconContentType = contentTypeForIconPart(imagePart);
+            if (iconContentType === undefined) {
+                continue;
+            }
+            iconEntries.set(imagePart.name, {
+                partName: imagePart.name,
+                relationshipId: rel.id,
+                relationshipType: rel.type,
+                contentType: iconContentType,
+                data: imagePart.data,
+                dirty: false,
+                pendingRelationship: undefined,
+            });
+        }
+    }
+    catch (e_16_1) { e_16 = { error: e_16_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_16) throw e_16.error; }
+    }
+    return new OleObjectCatalog(entries, externalByRelationshipId, iconEntries);
+}
+function resolveInternalTargetLocal(target, mainPartName) {
+    if (target.startsWith('/')) {
+        return partName(target);
+    }
+    // Relative targets resolve against the source part directory (/word/…).
+    var base = mainPartName.slice(0, mainPartName.lastIndexOf('/') + 1);
+    return partName("" + base + target);
+}