@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

package/src/features/watermark/serialize.js

@@ -0,0 +1,1517 @@
+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 __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 };
+        }
+    };
+};
+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;
+};
+/**
+ * Dirty watermark header rewrite (TASK-8062).
+ *
+ * Materializes logical watermark state into section headers on save.
+ * Picture media + header-local image relationships are staged as a
+ * {@link FeaturePackageLevelPart} applied after header multi-part writes.
+ *
+ * Canonical emit: `docs/specs/watermark-basic.md`. Washout tokens from
+ * PictureWatermark.docx fixture: `gain="19661f"` `blacklevel="22938f"`.
+ *
+ * @packageDocumentation
+ */
+import { sha256Hex } from '../../core/compat/sha256';
+import { OpaqueParagraphItem, OpaqueRunItem } from '../document/text-range';
+import { elementChildren, isWml, wmlElement } from '../document/wml';
+import { DocxError } from '../../core/errors/docx-error';
+import { objectEntries } from '../../core/compat/object-compat';
+import { allocateRelationshipId, partByName, relationshipsForPart, relationshipsWith, resolveInternalTarget, withAddedPart, withContentTypeOverride, withPartRelationships } from '../../core/opc/index';
+import { partName, partNameKey } from '../../core/opc/part-name';
+import { featureId } from '../../core/registry/feature-registry';
+import { parseXml } from '../../core/xml/index';
+import { headersFootersFor } from '../headers-footers/index';
+import { IMAGE_RELATIONSHIP_TYPE, JPEG_CONTENT_TYPE, PNG_CONTENT_TYPE, STRICT_IMAGE_RELATIONSHIP_TYPE } from '../images/index';
+import { sniffImageContentType, sniffImagePixelDimensions } from '../images/image-sniff';
+import { finalSection, paragraphSectionBreak } from '../sections/index';
+import { isPictureWatermarkShape, isTextWatermarkShape, isVml, PICTURE_WATERMARK_ID_PREFIX, PICTURE_WATERMARK_TYPE, TEXT_WATERMARK_ID_PREFIX, TEXT_WATERMARK_TYPE, VML_NS, } from './detect';
+import { ImageType, WatermarkLayout, WatermarkType } from './model';
+import { logicalWatermarkOf } from './logical-store';
+var WATERMARK = featureId('watermark');
+/** Office namespace used for `o:title` / washout attrs on `v:imagedata`. */
+var OFFICE_NS = 'urn:schemas-microsoft-com:office:office';
+/** Relationships namespace for `r:id` on `v:imagedata`. */
+var R_NS = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+/** Image relationship types (transitional + strict). */
+var IMAGE_RELATIONSHIP_TYPES = [
+    IMAGE_RELATIONSHIP_TYPE,
+    STRICT_IMAGE_RELATIONSHIP_TYPE,
+];
+/** Text fallback dimensions (pt) when width/height unset — locked by spec. */
+var TEXT_FALLBACK_WIDTH_PT = 250;
+var TEXT_FALLBACK_HEIGHT_PT = 100;
+/** Canonical dirty text z-index. */
+var TEXT_Z_INDEX = '-251658752';
+/** Canonical dirty picture z-index. */
+var PICTURE_Z_INDEX = '-1';
+/**
+ * Verified Word washout tokens from PictureWatermark.docx fixture
+ * (`v:imagedata` gain + blacklevel).
+ */
+var WASHOUT_GAIN = '19661f';
+var WASHOUT_BLACKLEVEL = '22938f';
+/** Header reference types stamped for scratch watermark policy. */
+var HEADER_REF_TYPES = ['default', 'even', 'first'];
+/** Documents whose logical watermark assignment requires header rewrite. */
+var dirtyDocuments = new WeakSet();
+/**
+ * Package-level pending state for watermark picture media + header image rels
+ * (adds) and post-strip GC (header image rel filters + media removals).
+ *
+ * Applied in `applyFeaturePackageParts` after HF multi-part writes header XML.
+ */
+var WatermarkPackageParts = /** @class */ (function () {
+    function WatermarkPackageParts() {
+        this.dirtyValue = false;
+        this.mediaParts = [];
+        this.headerRels = [];
+        this.headerImageRelFilters = [];
+        this.mediaRemovals = [];
+    }
+    /**
+     * @private
+     */
+    WatermarkPackageParts.prototype.isDirty = function () {
+        return this.dirtyValue;
+    };
+    /**
+     * @private
+   * Stage a media part (dedupe by bytes+content type externally). */
+    WatermarkPackageParts.prototype.stageMedia = function (part) {
+        this.mediaParts.push(part);
+        this.dirtyValue = true;
+    };
+    /**
+     * @private
+   * Stage a header-local image relationship. */
+    WatermarkPackageParts.prototype.stageHeaderRel = function (headerPartName, relationship) {
+        this.headerRels.push({ headerPartName: headerPartName, relationship: relationship });
+        this.dirtyValue = true;
+    };
+    /**
+     * @private
+     * Relationship ids staged for a header part (not yet in package).
+     * GC must treat these as still referenced so filters do not drop them.
+     */
+    WatermarkPackageParts.prototype.stagedHeaderRelIds = function (headerPartName) {
+        var e_1, _a;
+        var key = partNameKey(headerPartName);
+        var ids = new Set();
+        try {
+            for (var _b = __values(this.headerRels), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var item = _c.value;
+                if (partNameKey(item.headerPartName) === key) {
+                    ids.add(item.relationship.id);
+                }
+            }
+        }
+        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; }
+        }
+        return ids;
+    };
+    /**
+     * @private
+     * After rewrite, drop header-local image relationships whose ids
+     * are no longer referenced in that header's body (Removal rule 7).
+     */
+    WatermarkPackageParts.prototype.stageHeaderImageRelFilter = function (headerPartName, referencedIds) {
+        this.headerImageRelFilters.push({ headerPartName: headerPartName, referencedIds: referencedIds });
+        this.dirtyValue = true;
+    };
+    /**
+     * @private
+     * Stage media part removal when package-wide unused (Removal rule 8).
+     */
+    WatermarkPackageParts.prototype.stageMediaRemoval = function (name) {
+        var key = partNameKey(name);
+        if (this.mediaRemovals.some(function (existing) { return partNameKey(existing) === key; })) {
+            return;
+        }
+        this.mediaRemovals.push(name);
+        this.dirtyValue = true;
+    };
+    /**
+     * @private
+   * Clear after successful apply. */
+    WatermarkPackageParts.prototype.clear = function () {
+        this.mediaParts = [];
+        this.headerRels = [];
+        this.headerImageRelFilters = [];
+        this.mediaRemovals = [];
+        this.dirtyValue = false;
+    };
+    /**
+     * @private
+     */
+    WatermarkPackageParts.prototype.applyToPackage = function (pkg) {
+        var e_2, _a, e_3, _b, e_4, _c, e_5, _d, e_6, _e, e_7, _f;
+        if (!this.dirtyValue) {
+            return pkg;
+        }
+        var next = pkg;
+        try {
+            for (var _g = __values(this.mediaParts), _h = _g.next(); !_h.done; _h = _g.next()) {
+                var media = _h.value;
+                var packagePart = {
+                    name: media.partName,
+                    contentType: media.contentType,
+                    data: media.data,
+                };
+                next = withAddedPart(next, packagePart);
+                next = withContentTypeOverride(next, media.partName, media.contentType);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_h && !_h.done && (_a = _g.return)) _a.call(_g);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        // Group header rels by part and merge.
+        var byHeader = new Map();
+        try {
+            for (var _j = __values(this.headerRels), _k = _j.next(); !_k.done; _k = _j.next()) {
+                var item = _k.value;
+                var key = partNameKey(item.headerPartName);
+                var bucket = byHeader.get(key);
+                if (bucket === undefined) {
+                    bucket = { partName: item.headerPartName, rels: [] };
+                    byHeader.set(key, bucket);
+                }
+                bucket.rels.push(item.relationship);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_k && !_k.done && (_b = _j.return)) _b.call(_j);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        try {
+            for (var _l = __values(byHeader.values()), _m = _l.next(); !_m.done; _m = _l.next()) {
+                var bucket = _m.value;
+                var existing = relationshipsForPart(next, bucket.partName);
+                var used = new Set(existing.items.map(function (r) { return r.id; }));
+                var merged = __spread(existing.items);
+                var _loop_1 = function (rel) {
+                    if (merged.some(function (item) { return item.type === rel.type && item.target === rel.target; })) {
+                        return "continue";
+                    }
+                    var id = rel.id;
+                    while (used.has(id)) {
+                        id = allocateRelationshipId(used);
+                    }
+                    used.add(id);
+                    merged.push(__assign({}, rel, { id: id }));
+                };
+                try {
+                    for (var _o = __values(bucket.rels), _p = _o.next(); !_p.done; _p = _o.next()) {
+                        var rel = _p.value;
+                        _loop_1(rel);
+                    }
+                }
+                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                finally {
+                    try {
+                        if (_p && !_p.done && (_d = _o.return)) _d.call(_o);
+                    }
+                    finally { if (e_5) throw e_5.error; }
+                }
+                next = withPartRelationships(next, bucket.partName, relationshipsWith(merged, existing.opaque));
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_m && !_m.done && (_c = _l.return)) _c.call(_l);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        var _loop_2 = function (filter) {
+            next = withFilteredPartRelationshipsLocal(next, filter.headerPartName, function (rel) { return !isImageRelationshipType(rel.type) || filter.referencedIds.has(rel.id); });
+        };
+        try {
+            // Drop unused header-local image relationships (rule 7).
+            for (var _q = __values(this.headerImageRelFilters), _r = _q.next(); !_r.done; _r = _q.next()) {
+                var filter = _r.value;
+                _loop_2(filter);
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_r && !_r.done && (_e = _q.return)) _e.call(_q);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        try {
+            // Drop media only when package-wide unreferenced (rule 8).
+            for (var _s = __values(this.mediaRemovals), _t = _s.next(); !_t.done; _t = _s.next()) {
+                var mediaName = _t.value;
+                if (mediaPartIsReferenced(next, mediaName)) {
+                    continue;
+                }
+                next = withRemovedPartLocal(next, mediaName);
+                next = withRemovedContentTypeOverrideLocal(next, mediaName);
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_t && !_t.done && (_f = _s.return)) _f.call(_s);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        this.clear();
+        return next;
+    };
+    return WatermarkPackageParts;
+}());
+export { WatermarkPackageParts };
+function isImageRelationshipType(type) {
+    return IMAGE_RELATIONSHIP_TYPES.indexOf(type) !== -1;
+}
+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 mediaPartIsReferenced(pkg, mediaName) {
+    var e_8, _a, e_9, _b, e_10, _c;
+    var mediaKey = partNameKey(mediaName);
+    var check = function (rel, source) {
+        if (rel.targetMode === 'External') {
+            return false;
+        }
+        try {
+            // Package Relationships resolve with omitted source (not partName('/')).
+            return partNameKey(resolveInternalTarget(rel.target, source)) === mediaKey;
+        }
+        catch (_a) {
+            return false;
+        }
+    };
+    try {
+        for (var _d = __values(pkg.packageRelationships.items), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var rel = _e.value;
+            if (check(rel)) {
+                return true;
+            }
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    try {
+        for (var _f = __values(pkg.partRelationships), _g = _f.next(); !_g.done; _g = _f.next()) {
+            var set = _g.value;
+            try {
+                for (var _h = __values(set.relationships.items), _j = _h.next(); !_j.done; _j = _h.next()) {
+                    var rel = _j.value;
+                    if (check(rel, set.source)) {
+                        return true;
+                    }
+                }
+            }
+            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+            finally {
+                try {
+                    if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+                }
+                finally { if (e_10) throw e_10.error; }
+            }
+        }
+    }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+        }
+        finally { if (e_9) throw e_9.error; }
+    }
+    return false;
+}
+/**
+ * Mark document dirty for watermark materialize.
+ * @private
+ */
+export function markWatermarkDirty(document) {
+    dirtyDocuments.add(document);
+}
+/**
+ * True when watermark materialize must rewrite headers.
+ * @private
+ */
+export function isWatermarkDirty(document) {
+    return dirtyDocuments.has(document);
+}
+/**
+ * Clear dirty flag (after successful materialize or clean load).
+ * @private
+ */
+export function clearWatermarkDirty(document) {
+    dirtyDocuments.delete(document);
+}
+/**
+ * Reset module dirty state for tests.
+ * @private
+ */
+export function resetWatermarkSerializeStateForTests() {
+    // WeakSet cannot be cleared globally; documents are GC'd. No-op holder for API symmetry.
+}
+function packagePartsFor(document) {
+    var existing = document.featurePart(WATERMARK);
+    if (existing instanceof WatermarkPackageParts) {
+        return existing;
+    }
+    var created = new WatermarkPackageParts();
+    document.setFeaturePart(WATERMARK, created);
+    return created;
+}
+function usedRelationshipIds(document) {
+    var e_11, _a;
+    var main = partName('/word/document.xml');
+    var used = new Set();
+    try {
+        for (var _b = __values(relationshipsForPart(document.opcPackage(), main).items), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var rel = _c.value;
+            used.add(rel.id);
+        }
+    }
+    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_11) throw e_11.error; }
+    }
+    return used;
+}
+function usedPartNameKeys(document) {
+    var e_12, _a;
+    var used = new Set();
+    try {
+        for (var _b = __values(document.opcPackage().parts), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var part = _c.value;
+            used.add(partNameKey(part.name));
+        }
+    }
+    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 used;
+}
+/**
+ * Ordered dual-hold section properties: paragraph break bags, then body-final.
+ * Internal walk only — the public surface is `lastSection` / `sectionBreak`.
+ */
+function sectionPropertiesInDocumentOrder(document) {
+    var e_13, _a;
+    var out = [];
+    try {
+        for (var _b = __values(document.listBlocks()), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var block = _c.value;
+            if (block.type !== 'paragraph') {
+                continue;
+            }
+            var breakProps = paragraphSectionBreak(block.paragraph);
+            if (breakProps !== undefined) {
+                out.push(breakProps);
+            }
+        }
+    }
+    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_13) throw e_13.error; }
+    }
+    var bodyFinal = finalSection(document);
+    if (bodyFinal !== undefined) {
+        out.push(bodyFinal);
+    }
+    return out;
+}
+/**
+ * Dual-hold already keeps each `PageSetup` on its break paragraph or
+ * body-final slot. Mutating header refs in place is enough for save; no
+ * Section-view write-back is required.
+ */
+function ensureScratchHeaders(document, catalog) {
+    var e_14, _a, e_15, _b;
+    var usedRelIds = usedRelationshipIds(document);
+    var usedPartNames = usedPartNameKeys(document);
+    try {
+        for (var _c = __values(sectionPropertiesInDocumentOrder(document)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var props = _d.value;
+            try {
+                for (var HEADER_REF_TYPES_1 = __values(HEADER_REF_TYPES), HEADER_REF_TYPES_1_1 = HEADER_REF_TYPES_1.next(); !HEADER_REF_TYPES_1_1.done; HEADER_REF_TYPES_1_1 = HEADER_REF_TYPES_1.next()) {
+                    var refType = HEADER_REF_TYPES_1_1.value;
+                    var relationshipId = catalog.ensurePart('header', props, refType, usedRelIds, usedPartNames).relationshipId;
+                    props.setHeaderFooterReference('header', refType, relationshipId);
+                    usedRelIds.add(relationshipId);
+                }
+            }
+            catch (e_15_1) { e_15 = { error: e_15_1 }; }
+            finally {
+                try {
+                    if (HEADER_REF_TYPES_1_1 && !HEADER_REF_TYPES_1_1.done && (_b = HEADER_REF_TYPES_1.return)) _b.call(HEADER_REF_TYPES_1);
+                }
+                finally { if (e_15) throw e_15.error; }
+            }
+        }
+    }
+    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; }
+    }
+}
+function shapesUnderPict(pict) {
+    var e_16, _a;
+    var shapes = [];
+    try {
+        for (var _b = __values(elementChildren(pict)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isVml(child, 'shape')) {
+                shapes.push(child);
+            }
+        }
+    }
+    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 shapes;
+}
+function pictContainsRecognizedWatermark(pict) {
+    var e_17, _a;
+    try {
+        for (var _b = __values(shapesUnderPict(pict)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var shape = _c.value;
+            if (isTextWatermarkShape(shape) || isPictureWatermarkShape(shape)) {
+                return true;
+            }
+        }
+    }
+    catch (e_17_1) { e_17 = { error: e_17_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_17) throw e_17.error; }
+    }
+    return false;
+}
+function openXmlContainsRecognizedWatermark(node) {
+    var e_18, _a;
+    if (isWml(node, 'pict')) {
+        return pictContainsRecognizedWatermark(node);
+    }
+    try {
+        for (var _b = __values(elementChildren(node)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (openXmlContainsRecognizedWatermark(child)) {
+                return true;
+            }
+        }
+    }
+    catch (e_18_1) { e_18 = { error: e_18_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_18) throw e_18.error; }
+    }
+    return false;
+}
+function isWatermarkOpaqueInline(inline) {
+    return (inline instanceof OpaqueParagraphItem &&
+        openXmlContainsRecognizedWatermark(inline.xml));
+}
+/**
+ * True when every remaining item is a watermark opaque (or the paragraph is empty) —
+ * i.e. the paragraph is watermark-owned and safely empty after strip (Removal 4).
+ */
+function isWatermarkOnlyParagraph(paragraph) {
+    var content = paragraph.items;
+    if (content.length === 0) {
+        return true;
+    }
+    return content.every(function (inline) { return isWatermarkOpaqueInline(inline); });
+}
+/**
+ * Strip recognized watermark `w:pict` items from a header entry (Removal 1–5).
+ *
+ * - Opaque watermark paragraph items: filter via paragraph snapshot + hydrate.
+ * - Watermark-only empty paragraphs: omit from blocks (never delete header parts).
+ * - Tables / non-wm opaque / feature blocks: preserved.
+ */
+function stripEntryWatermarkLeaves(entry) {
+    var e_19, _a;
+    var nextBlocks = [];
+    var changed = false;
+    try {
+        for (var _b = __values(entry.blocks), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var block = _c.value;
+            if (block.type === 'opaque') {
+                if (openXmlContainsRecognizedWatermark(block.xml)) {
+                    changed = true;
+                    continue;
+                }
+                nextBlocks.push(block);
+                continue;
+            }
+            if (block.type !== 'paragraph') {
+                nextBlocks.push(block);
+                continue;
+            }
+            var paragraph = block.paragraph;
+            var strippedWm = false;
+            if (paragraph.items.some(isWatermarkOpaqueInline)) {
+                strippedWm = true;
+                if (isWatermarkOnlyParagraph(paragraph)) {
+                    // Removal 4: watermark-owned and safely empty → drop paragraph.
+                    changed = true;
+                    continue;
+                }
+                var snap = paragraph.snapshot();
+                var filteredItems = snap.items.filter(function (inline) { return !isWatermarkOpaqueInline(inline); });
+                if (filteredItems.length !== snap.items.length) {
+                    paragraph.hydrate(__assign({}, snap, { items: filteredItems }));
+                    changed = true;
+                }
+            }
+            // After strip, drop paragraphs that only held watermark content.
+            if (strippedWm && isWatermarkOnlyParagraph(paragraph)) {
+                changed = true;
+                continue;
+            }
+            nextBlocks.push(block);
+        }
+    }
+    catch (e_19_1) { e_19 = { error: e_19_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_19) throw e_19.error; }
+    }
+    if (changed) {
+        entry.blocks = nextBlocks;
+        entry.dirty = true;
+    }
+    return changed;
+}
+/**
+ * Collect relationship ids still referenced from header body markup
+ * (`r:id` attributes, including `v:imagedata`).
+ */
+function collectReferencedRelationshipIds(entry) {
+    var e_20, _a, e_21, _b;
+    var ids = new Set();
+    var scan = function (node) {
+        var e_22, _a, e_23, _b;
+        try {
+            for (var _c = __values(node.attributes), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var a = _d.value;
+                if (a.localName === 'id' && (a.namespaceUri === R_NS || a.prefix === 'r')) {
+                    ids.add(a.value);
+                }
+                if (a.namespaceUri === R_NS && (a.localName === 'embed' || a.localName === 'link')) {
+                    ids.add(a.value);
+                }
+            }
+        }
+        catch (e_22_1) { e_22 = { error: e_22_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_22) throw e_22.error; }
+        }
+        try {
+            for (var _e = __values(elementChildren(node)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var child = _f.value;
+                scan(child);
+            }
+        }
+        catch (e_23_1) { e_23 = { error: e_23_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            }
+            finally { if (e_23) throw e_23.error; }
+        }
+    };
+    try {
+        for (var _c = __values(entry.blocks), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var block = _d.value;
+            if (block.type === 'opaque') {
+                scan(block.xml);
+                continue;
+            }
+            if (block.type === 'paragraph') {
+                try {
+                    for (var _e = __values(block.paragraph.items), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var inline = _f.value;
+                        if (inline instanceof OpaqueParagraphItem || inline instanceof OpaqueRunItem) {
+                            scan(inline.xml);
+                        }
+                    }
+                }
+                catch (e_21_1) { e_21 = { error: e_21_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_21) throw e_21.error; }
+                }
+                try {
+                    scan(block.paragraph.toOpenXml());
+                }
+                catch (_g) {
+                    // Detached / incomplete — live scan above is enough.
+                }
+            }
+        }
+    }
+    catch (e_20_1) { e_20 = { error: e_20_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_20) throw e_20.error; }
+    }
+    return ids;
+}
+/**
+ * Stage header-local image rel GC (rule 7) and package-wide media GC (rule 8)
+ * for one unique header after strip/rewrite.
+ */
+function stageHeaderRelationshipGc(document, headerPartName, entry, protectedMediaKeys) {
+    var e_24, _a, e_25, _b;
+    var packageParts = packagePartsFor(document);
+    var referencedIds = collectReferencedRelationshipIds(entry);
+    try {
+        for (var _c = __values(packageParts.stagedHeaderRelIds(headerPartName)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var id = _d.value;
+            referencedIds.add(id);
+        }
+    }
+    catch (e_24_1) { e_24 = { error: e_24_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_24) throw e_24.error; }
+    }
+    packageParts.stageHeaderImageRelFilter(headerPartName, referencedIds);
+    var pkg = document.opcPackage();
+    var headerRels = relationshipsForPart(pkg, headerPartName);
+    try {
+        for (var _e = __values(headerRels.items), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var rel = _f.value;
+            if (!isImageRelationshipType(rel.type)) {
+                continue;
+            }
+            if (referencedIds.has(rel.id)) {
+                continue;
+            }
+            try {
+                var target = resolveInternalTarget(rel.target, headerPartName);
+                if (protectedMediaKeys.has(partNameKey(target))) {
+                    continue;
+                }
+                if (partByName(pkg, target) === undefined) {
+                    continue;
+                }
+                packageParts.stageMediaRemoval(target);
+            }
+            catch (_g) {
+                // Invalid target — skip.
+            }
+        }
+    }
+    catch (e_25_1) { e_25 = { error: e_25_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+        }
+        finally { if (e_25) throw e_25.error; }
+    }
+}
+function vAttr(localName, value) {
+    return { namespaceUri: '', localName: localName, prefix: '', value: value };
+}
+function vElement(localName, options) {
+    var __ts33_0, __ts33_1, __ts33_2;
+    return {
+        kind: 'element',
+        namespaceUri: VML_NS,
+        localName: localName,
+        prefix: 'v',
+        attributes: ((__ts33_0 = options == null ? undefined : options.attributes), __ts33_0 != null ? __ts33_0 : []),
+        namespaceDeclarations: ((__ts33_1 = options == null ? undefined : options.namespaceDeclarations), __ts33_1 != null ? __ts33_1 : []),
+        children: ((__ts33_2 = options == null ? undefined : options.children), __ts33_2 != null ? __ts33_2 : []),
+    };
+}
+function formatPt(value) {
+    if (Number.isInteger(value)) {
+        return String(value);
+    }
+    // Trim excessive float noise while keeping precision for scaled sizes.
+    return String(Math.round(value * 1000) / 1000);
+}
+function textRotationDegrees(model) {
+    var custom = model.getCustomRotationDegrees();
+    if (custom !== undefined) {
+        return custom;
+    }
+    return model.layout === WatermarkLayout.Horizontal ? 0 : 315;
+}
+function textWidthHeight(model) {
+    return {
+        width: model.width != null ? model.width : TEXT_FALLBACK_WIDTH_PT,
+        height: model.height != null ? model.height : TEXT_FALLBACK_HEIGHT_PT,
+    };
+}
+function buildTextStyle(model) {
+    var _a = textWidthHeight(model), width = _a.width, height = _a.height;
+    var rotation = textRotationDegrees(model);
+    return [
+        'position:absolute',
+        'margin-left:0',
+        'margin-top:0',
+        "width:" + formatPt(width) + "pt",
+        "height:" + formatPt(height) + "pt",
+        "rotation:" + formatPt(rotation),
+        "z-index:" + TEXT_Z_INDEX,
+        'mso-position-horizontal:center',
+        'mso-position-horizontal-relative:margin',
+        'mso-position-vertical:center',
+        'mso-position-vertical-relative:margin',
+    ].join(';');
+}
+function buildTextpathStyle(model) {
+    var font = model.fontName.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    return "font-family:\"" + font + "\";font-size:" + formatPt(model.size) + "pt";
+}
+function mergeResidualShapeAttrs(base, residual, skip) {
+    var e_26, _a;
+    if ((residual == null ? undefined : residual.extraShapeAttributes) === undefined) {
+        return base;
+    }
+    var out = __spread(base);
+    var present = new Set(base.map(function (a) { return a.localName; }));
+    try {
+        for (var _b = __values(objectEntries(residual.extraShapeAttributes)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var _d = __read(_c.value, 2), name_1 = _d[0], value = _d[1];
+            if (skip.has(name_1) || present.has(name_1)) {
+                continue;
+            }
+            out.push(vAttr(name_1, value));
+            present.add(name_1);
+        }
+    }
+    catch (e_26_1) { e_26 = { error: e_26_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_26) throw e_26.error; }
+    }
+    return out;
+}
+function residualExtraChildren(residual) {
+    var e_27, _a;
+    if ((residual == null ? undefined : residual.extraChildXml) === undefined || residual.extraChildXml.length === 0) {
+        return [];
+    }
+    var children = [];
+    try {
+        for (var _b = __values(residual.extraChildXml), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var xml = _c.value;
+            try {
+                children.push(parseXml(xml));
+            }
+            catch (_d) {
+                // Skip unparsable residual fragments rather than fail save.
+            }
+        }
+    }
+    catch (e_27_1) { e_27 = { error: e_27_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_27) throw e_27.error; }
+    }
+    return children;
+}
+function buildTextPict(model, shapeId) {
+    var e_28, _a;
+    var residual = model.getParseResidual();
+    var skip = new Set([
+        'id',
+        'type',
+        'style',
+        'fillcolor',
+        'stroked',
+        'filled',
+    ]);
+    var attrs = mergeResidualShapeAttrs([
+        vAttr('id', shapeId),
+        vAttr('type', TEXT_WATERMARK_TYPE),
+        vAttr('style', buildTextStyle(model)),
+        vAttr('fillcolor', model.color),
+        vAttr('stroked', 'f'),
+    ], residual, skip);
+    var children = [];
+    // Dirty opacity: true → exact .5; false → verified full opacity="1" (overrides residual
+    // transparency and round-trips through parse as Opaque, not Unknown/absent).
+    if (model.semitransparent) {
+        children.push(vElement('fill', { attributes: [vAttr('opacity', '.5')] }));
+    }
+    else {
+        children.push(vElement('fill', { attributes: [vAttr('opacity', '1')] }));
+    }
+    children.push(vElement('textpath', {
+        attributes: [
+            vAttr('on', 't'),
+            vAttr('string', model.text),
+            vAttr('style', buildTextpathStyle(model)),
+        ],
+    }));
+    try {
+        // Residual extra children that are not fill/textpath (already owned).
+        for (var _b = __values(residualExtraChildren(residual)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (child.kind === 'element' && isVml(child, 'fill')) {
+                // Owned by dirty semitransparent path — skip residual fill when dirty controls opacity.
+                continue;
+            }
+            if (child.kind === 'element' && isVml(child, 'textpath')) {
+                continue;
+            }
+            children.push(child);
+        }
+    }
+    catch (e_28_1) { e_28 = { error: e_28_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_28) throw e_28.error; }
+    }
+    var shape = vElement('shape', {
+        attributes: attrs,
+        children: children,
+        namespaceDeclarations: [
+            { prefix: 'v', namespaceUri: VML_NS },
+            { prefix: 'o', namespaceUri: OFFICE_NS },
+            { prefix: 'r', namespaceUri: R_NS },
+        ],
+    });
+    return wmlElement('pict', { children: [shape] });
+}
+function pictureBaseSizePt(model) {
+    var bytes = model.imageData;
+    if (bytes !== undefined) {
+        var pixels = sniffImagePixelDimensions(bytes);
+        if (pixels !== undefined) {
+            // 96 DPI: px * 72/96 = px * 0.75
+            return { width: pixels.width * 0.75, height: pixels.height * 0.75 };
+        }
+    }
+    // Fallback when dimensions unknown.
+    return { width: 100, height: 100 };
+}
+/**
+ * Scaling matrix (requirement):
+ * - neither explicit W/H → base * scaling/100
+ * - only width → width + height from aspect (no scale on width)
+ * - only height → symmetric
+ * - both explicit → neither scaled
+ */
+function pictureWidthHeight(model) {
+    var base = pictureBaseSizePt(model);
+    var explicitWidth = model.width;
+    var explicitHeight = model.height;
+    if (explicitWidth !== undefined && explicitHeight !== undefined) {
+        return { width: explicitWidth, height: explicitHeight };
+    }
+    if (explicitWidth !== undefined) {
+        var aspect = base.height / (base.width === 0 ? 1 : base.width);
+        return { width: explicitWidth, height: explicitWidth * aspect };
+    }
+    if (explicitHeight !== undefined) {
+        var aspect = base.width / (base.height === 0 ? 1 : base.height);
+        return { width: explicitHeight * aspect, height: explicitHeight };
+    }
+    var scale = model.scaling / 100;
+    return { width: base.width * scale, height: base.height * scale };
+}
+function buildPictureStyle(model) {
+    var _a = pictureWidthHeight(model), width = _a.width, height = _a.height;
+    return [
+        'position:absolute',
+        'margin-left:0',
+        'margin-top:0',
+        "width:" + formatPt(width) + "pt",
+        "height:" + formatPt(height) + "pt",
+        "z-index:" + PICTURE_Z_INDEX,
+        'mso-position-horizontal:center',
+        'mso-position-horizontal-relative:margin',
+        'mso-position-vertical:center',
+        'mso-position-vertical-relative:margin',
+    ].join(';');
+}
+function resolvePictureContentType(model) {
+    var bytes = model.imageData;
+    if (bytes === undefined || bytes.byteLength === 0) {
+        throw new DocxError('content/invalid-image', 'Picture watermark has no image bytes to serialize');
+    }
+    var sniffed = sniffImageContentType(bytes);
+    if (sniffed !== undefined) {
+        return sniffed;
+    }
+    if (model.imageType === ImageType.Jpeg) {
+        return JPEG_CONTENT_TYPE;
+    }
+    if (model.imageType === ImageType.Png) {
+        return PNG_CONTENT_TYPE;
+    }
+    throw new DocxError('content/invalid-image', 'Picture watermark image bytes are not a supported JPEG or PNG payload');
+}
+function sha256(data) {
+    return sha256Hex(data);
+}
+function allocateImagePartName(contentType, used) {
+    var ext = contentType === JPEG_CONTENT_TYPE ? 'jpeg' : 'png';
+    var index = 1;
+    while (used.has(partNameKey(partName("/word/media/image" + String(index) + "." + ext)))) {
+        index += 1;
+    }
+    return partName("/word/media/image" + String(index) + "." + ext);
+}
+function relativeMediaTarget(partNameValue) {
+    // Header is under /word/; media target is relative: media/imageN.ext
+    return partNameValue.slice('/word/'.length);
+}
+function buildPicturePict(model, shapeId, imageRelId) {
+    var e_29, _a;
+    var residual = model.getParseResidual();
+    var skip = new Set(['id', 'type', 'style', 'filled', 'stroked', 'fillcolor']);
+    var attrs = mergeResidualShapeAttrs([
+        vAttr('id', shapeId),
+        vAttr('type', PICTURE_WATERMARK_TYPE),
+        vAttr('style', buildPictureStyle(model)),
+        vAttr('filled', 'f'),
+        vAttr('stroked', 'f'),
+    ], residual, skip);
+    var imageAttrs = [
+        { namespaceUri: R_NS, localName: 'id', prefix: 'r', value: imageRelId },
+        { namespaceUri: OFFICE_NS, localName: 'title', prefix: 'o', value: '' },
+    ];
+    if (model.washout) {
+        imageAttrs.push(vAttr('gain', WASHOUT_GAIN));
+        imageAttrs.push(vAttr('blacklevel', WASHOUT_BLACKLEVEL));
+    }
+    var children = [
+        vElement('imagedata', { attributes: imageAttrs }),
+    ];
+    try {
+        for (var _b = __values(residualExtraChildren(residual)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (child.kind === 'element' && isVml(child, 'imagedata')) {
+                continue;
+            }
+            children.push(child);
+        }
+    }
+    catch (e_29_1) { e_29 = { error: e_29_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_29) throw e_29.error; }
+    }
+    var shape = vElement('shape', {
+        attributes: attrs,
+        children: children,
+        namespaceDeclarations: [
+            { prefix: 'v', namespaceUri: VML_NS },
+            { prefix: 'o', namespaceUri: OFFICE_NS },
+            { prefix: 'r', namespaceUri: R_NS },
+        ],
+    });
+    return wmlElement('pict', { children: [shape] });
+}
+function collectUsedShapeIds(catalog) {
+    var e_30, _a;
+    var used = new Set();
+    var _loop_3 = function (relId) {
+        var e_31, _a, e_32, _b;
+        var entry = catalog.entryForRelationship(relId);
+        if (entry === undefined) {
+            return "continue";
+        }
+        var scan = function (node) {
+            var e_33, _a;
+            if (isVml(node, 'shape')) {
+                var idAttr = node.attributes.find(function (a) { return a.localName === 'id'; });
+                if (idAttr !== undefined) {
+                    used.add(idAttr.value);
+                }
+            }
+            try {
+                for (var _b = __values(elementChildren(node)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var child = _c.value;
+                    scan(child);
+                }
+            }
+            catch (e_33_1) { e_33 = { error: e_33_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_33) throw e_33.error; }
+            }
+        };
+        try {
+            for (var _c = __values(entry.blocks), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var block = _d.value;
+                if (block.type === 'opaque') {
+                    scan(block.xml);
+                }
+                else if (block.type === 'paragraph') {
+                    try {
+                        for (var _e = __values(block.paragraph.items), _f = _e.next(); !_f.done; _f = _e.next()) {
+                            var inline = _f.value;
+                            if (inline instanceof OpaqueParagraphItem || inline instanceof OpaqueRunItem) {
+                                scan(inline.xml);
+                            }
+                        }
+                    }
+                    catch (e_32_1) { e_32 = { error: e_32_1 }; }
+                    finally {
+                        try {
+                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                        }
+                        finally { if (e_32) throw e_32.error; }
+                    }
+                }
+            }
+        }
+        catch (e_31_1) { e_31 = { error: e_31_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_31) throw e_31.error; }
+        }
+    };
+    try {
+        for (var _b = __values(catalog.relationshipIds('header')), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var relId = _c.value;
+            _loop_3(relId);
+        }
+    }
+    catch (e_30_1) { e_30 = { error: e_30_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_30) throw e_30.error; }
+    }
+    return used;
+}
+function allocateShapeId(prefix, used) {
+    var n = 1;
+    while (used.has("" + prefix + String(n))) {
+        n += 1;
+    }
+    var id = "" + prefix + String(n);
+    used.add(id);
+    return id;
+}
+function appendWatermarkPict(catalog, relationshipId, pict) {
+    var paragraph = catalog.appendParagraphForRelationship(relationshipId);
+    paragraph.appendParagraphItem(new OpaqueParagraphItem(pict));
+}
+function preparePictureMedia(document, model, headerPartNames) {
+    var e_34, _a, e_35, _b, e_36, _c;
+    var contentType = resolvePictureContentType(model);
+    var data = model.imageData;
+    if (data === undefined || data.byteLength === 0) {
+        throw new DocxError('content/invalid-image', 'Picture watermark has no image bytes to serialize');
+    }
+    var pkg = document.opcPackage();
+    var usedPartNames = usedPartNameKeys(document);
+    // Dedupe: reuse existing media part with same hash+content type when present.
+    var hash = sha256(data);
+    var mediaPartName;
+    try {
+        for (var _d = __values(pkg.parts), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var part = _e.value;
+            if (part.contentType !== contentType) {
+                continue;
+            }
+            if (!String(part.name).includes('/word/media/')) {
+                continue;
+            }
+            if (part.data.byteLength === data.byteLength && sha256(part.data) === hash) {
+                mediaPartName = part.name;
+                break;
+            }
+        }
+    }
+    catch (e_34_1) { e_34 = { error: e_34_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        }
+        finally { if (e_34) throw e_34.error; }
+    }
+    var packageParts = packagePartsFor(document);
+    if (mediaPartName === undefined) {
+        mediaPartName = allocateImagePartName(contentType, usedPartNames);
+        usedPartNames.add(partNameKey(mediaPartName));
+        packageParts.stageMedia({ partName: mediaPartName, contentType: contentType, data: data });
+    }
+    var relIdByHeaderPartKey = new Map();
+    var target = relativeMediaTarget(mediaPartName);
+    try {
+        for (var headerPartNames_1 = __values(headerPartNames), headerPartNames_1_1 = headerPartNames_1.next(); !headerPartNames_1_1.done; headerPartNames_1_1 = headerPartNames_1.next()) {
+            var headerPartName = headerPartNames_1_1.value;
+            var key = partNameKey(headerPartName);
+            if (relIdByHeaderPartKey.has(key)) {
+                continue;
+            }
+            var existingRels = relationshipsForPart(pkg, headerPartName);
+            var match = existingRels.items.find(function (r) { return r.type === IMAGE_RELATIONSHIP_TYPE && r.target === target; });
+            var relId = void 0;
+            if (match !== undefined) {
+                relId = match.id;
+            }
+            else {
+                var used = new Set(existingRels.items.map(function (r) { return r.id; }));
+                try {
+                    // Also reserve ids already staged for this header.
+                    for (var _f = __values(relIdByHeaderPartKey.values()), _g = _f.next(); !_g.done; _g = _f.next()) {
+                        var id = _g.value;
+                        used.add(id);
+                    }
+                }
+                catch (e_36_1) { e_36 = { error: e_36_1 }; }
+                finally {
+                    try {
+                        if (_g && !_g.done && (_c = _f.return)) _c.call(_f);
+                    }
+                    finally { if (e_36) throw e_36.error; }
+                }
+                relId = allocateRelationshipId(used);
+                var relationship = {
+                    id: relId,
+                    type: IMAGE_RELATIONSHIP_TYPE,
+                    target: target,
+                    extraAttributes: [],
+                    children: [],
+                };
+                packageParts.stageHeaderRel(headerPartName, relationship);
+            }
+            relIdByHeaderPartKey.set(key, relId);
+        }
+    }
+    catch (e_35_1) { e_35 = { error: e_35_1 }; }
+    finally {
+        try {
+            if (headerPartNames_1_1 && !headerPartNames_1_1.done && (_b = headerPartNames_1.return)) _b.call(headerPartNames_1);
+        }
+        finally { if (e_35) throw e_35.error; }
+    }
+    return { relIdByHeaderPartKey: relIdByHeaderPartKey, contentType: contentType, data: data, mediaPartName: mediaPartName };
+}
+function uniqueHeaderEntries(document, catalog) {
+    var e_37, _a, e_38, _b;
+    var seen = new Set();
+    var out = [];
+    try {
+        for (var _c = __values(sectionPropertiesInDocumentOrder(document)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var props = _d.value;
+            try {
+                for (var HEADER_REF_TYPES_2 = __values(HEADER_REF_TYPES), HEADER_REF_TYPES_2_1 = HEADER_REF_TYPES_2.next(); !HEADER_REF_TYPES_2_1.done; HEADER_REF_TYPES_2_1 = HEADER_REF_TYPES_2.next()) {
+                    var refType = HEADER_REF_TYPES_2_1.value;
+                    var relId = props.headerFooterReferenceId('header', refType);
+                    if (relId === undefined) {
+                        continue;
+                    }
+                    var entry = catalog.entryForRelationship(relId);
+                    if (entry === undefined) {
+                        continue;
+                    }
+                    var key = partNameKey(entry.partName);
+                    if (seen.has(key)) {
+                        continue;
+                    }
+                    seen.add(key);
+                    out.push({ relationshipId: relId, partName: entry.partName });
+                }
+            }
+            catch (e_38_1) { e_38 = { error: e_38_1 }; }
+            finally {
+                try {
+                    if (HEADER_REF_TYPES_2_1 && !HEADER_REF_TYPES_2_1.done && (_b = HEADER_REF_TYPES_2.return)) _b.call(HEADER_REF_TYPES_2);
+                }
+                finally { if (e_38) throw e_38.error; }
+            }
+        }
+    }
+    catch (e_37_1) { e_37 = { error: e_37_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_37) throw e_37.error; }
+    }
+    return out;
+}
+/**
+ * Materialize dirty logical watermark into header parts.
+ *
+ * Called from the feature materialize handler before multi-part apply.
+ *
+ * - Assign/replace (`logical` defined): ensure scratch headers, strip recognized
+ *   watermark leaves, append canonical text/picture markup, stage image-rel/media GC.
+ * - Remove (`logical` undefined): strip recognized watermark leaves from existing
+ *   unique headers only (no new scratch headers), stage GC (Removal 1–10).
+ *
+ * @private
+ */
+export function materializeWatermarks(document) {
+    var e_39, _a, e_40, _b, e_41, _c, e_42, _d, e_43, _e, e_44, _f;
+    var __ts33_3;
+    if (!isWatermarkDirty(document)) {
+        return;
+    }
+    var catalog;
+    try {
+        catalog = headersFootersFor(document);
+    }
+    catch (_g) {
+        // HF not registered — cannot materialize; leave dirty for honest failure on save paths that need it.
+        return;
+    }
+    var logical = logicalWatermarkOf(document);
+    // Assign/replace needs scratch headers; remove-only rewrites existing headers.
+    if (logical !== undefined) {
+        ensureScratchHeaders(document, catalog);
+    }
+    var headers = uniqueHeaderEntries(document, catalog);
+    var usedShapeIds = collectUsedShapeIds(catalog);
+    var protectedMediaKeys = new Set();
+    try {
+        // Strip recognized watermark leaves from each unique header once.
+        for (var headers_1 = __values(headers), headers_1_1 = headers_1.next(); !headers_1_1.done; headers_1_1 = headers_1.next()) {
+            var header = headers_1_1.value;
+            var entry = catalog.entryForRelationship(header.relationshipId);
+            if (entry === undefined) {
+                continue;
+            }
+            stripEntryWatermarkLeaves(entry);
+        }
+    }
+    catch (e_39_1) { e_39 = { error: e_39_1 }; }
+    finally {
+        try {
+            if (headers_1_1 && !headers_1_1.done && (_a = headers_1.return)) _a.call(headers_1);
+        }
+        finally { if (e_39) throw e_39.error; }
+    }
+    if (logical === undefined) {
+        try {
+            // Remove path: strip + GC only (rules 1–10); never delete header parts (rule 9).
+            for (var headers_2 = __values(headers), headers_2_1 = headers_2.next(); !headers_2_1.done; headers_2_1 = headers_2.next()) {
+                var header = headers_2_1.value;
+                var entry = catalog.entryForRelationship(header.relationshipId);
+                if (entry === undefined) {
+                    continue;
+                }
+                stageHeaderRelationshipGc(document, header.partName, entry, protectedMediaKeys);
+            }
+        }
+        catch (e_40_1) { e_40 = { error: e_40_1 }; }
+        finally {
+            try {
+                if (headers_2_1 && !headers_2_1.done && (_b = headers_2.return)) _b.call(headers_2);
+            }
+            finally { if (e_40) throw e_40.error; }
+        }
+        clearWatermarkDirty(document);
+        return;
+    }
+    if (logical.type === WatermarkType.TextWatermark) {
+        var text = logical;
+        try {
+            for (var headers_3 = __values(headers), headers_3_1 = headers_3.next(); !headers_3_1.done; headers_3_1 = headers_3.next()) {
+                var header = headers_3_1.value;
+                var shapeId = allocateShapeId(TEXT_WATERMARK_ID_PREFIX, usedShapeIds);
+                var pict = buildTextPict(text, shapeId);
+                appendWatermarkPict(catalog, header.relationshipId, pict);
+            }
+        }
+        catch (e_41_1) { e_41 = { error: e_41_1 }; }
+        finally {
+            try {
+                if (headers_3_1 && !headers_3_1.done && (_c = headers_3.return)) _c.call(headers_3);
+            }
+            finally { if (e_41) throw e_41.error; }
+        }
+        try {
+            for (var headers_4 = __values(headers), headers_4_1 = headers_4.next(); !headers_4_1.done; headers_4_1 = headers_4.next()) {
+                var header = headers_4_1.value;
+                var entry = catalog.entryForRelationship(header.relationshipId);
+                if (entry === undefined) {
+                    continue;
+                }
+                stageHeaderRelationshipGc(document, header.partName, entry, protectedMediaKeys);
+            }
+        }
+        catch (e_42_1) { e_42 = { error: e_42_1 }; }
+        finally {
+            try {
+                if (headers_4_1 && !headers_4_1.done && (_d = headers_4.return)) _d.call(headers_4);
+            }
+            finally { if (e_42) throw e_42.error; }
+        }
+        clearWatermarkDirty(document);
+        return;
+    }
+    // Only remaining public watermark kind is picture (WatermarkType.PictureWatermark).
+    var picture = logical;
+    var media = preparePictureMedia(document, picture, headers.map(function (h) { return h.partName; }));
+    protectedMediaKeys.add(partNameKey(media.mediaPartName));
+    try {
+        for (var headers_5 = __values(headers), headers_5_1 = headers_5.next(); !headers_5_1.done; headers_5_1 = headers_5.next()) {
+            var header = headers_5_1.value;
+            var shapeId = allocateShapeId(PICTURE_WATERMARK_ID_PREFIX, usedShapeIds);
+            var relId = ((__ts33_3 = media.relIdByHeaderPartKey.get(partNameKey(header.partName))), __ts33_3 != null ? __ts33_3 : media.relIdByHeaderPartKey.values().next().value);
+            if (relId === undefined) {
+                throw new DocxError('content/invalid-image', 'Picture watermark failed to allocate a header image relationship');
+            }
+            var pict = buildPicturePict(picture, shapeId, relId);
+            appendWatermarkPict(catalog, header.relationshipId, pict);
+        }
+    }
+    catch (e_43_1) { e_43 = { error: e_43_1 }; }
+    finally {
+        try {
+            if (headers_5_1 && !headers_5_1.done && (_e = headers_5.return)) _e.call(headers_5);
+        }
+        finally { if (e_43) throw e_43.error; }
+    }
+    try {
+        for (var headers_6 = __values(headers), headers_6_1 = headers_6.next(); !headers_6_1.done; headers_6_1 = headers_6.next()) {
+            var header = headers_6_1.value;
+            var entry = catalog.entryForRelationship(header.relationshipId);
+            if (entry === undefined) {
+                continue;
+            }
+            stageHeaderRelationshipGc(document, header.partName, entry, protectedMediaKeys);
+        }
+    }
+    catch (e_44_1) { e_44 = { error: e_44_1 }; }
+    finally {
+        try {
+            if (headers_6_1 && !headers_6_1.done && (_f = headers_6.return)) _f.call(headers_6);
+        }
+        finally { if (e_44) throw e_44.error; }
+    }
+    clearWatermarkDirty(document);
+}
+/**
+ * Load empty/clean package parts for registration.
+ * @private
+ */
+export function loadWatermarkPackageParts(_pkg) {
+    void _pkg;
+    return new WatermarkPackageParts();
+}