@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

package/src/features/watermark/parse.js

@@ -0,0 +1,815 @@
+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;
+};
+import { OpaqueParagraphItem, OpaqueRunItem } from '../document/text-range';
+import { elementChildren, isWml } from '../document/wml';
+import { partByName, relationshipsForPart } from '../../core/opc/package';
+import { partNameKey, resolveInternalTarget } from '../../core/opc/part-name';
+import { serializeXml } from '../../core/xml/serialize';
+import { objectEntries } from '../../core/compat/object-compat';
+import { defaultHeader, headersFootersFor, } from '../headers-footers/index';
+import { IMAGE_RELATIONSHIP_TYPE, JPEG_CONTENT_TYPE, PNG_CONTENT_TYPE, STRICT_IMAGE_RELATIONSHIP_TYPE, } from '../images/index';
+import { isPictureWatermarkShape, isTextWatermarkShape, isVml, parseVmlStyle, vmlAttribute, VML_NS, } from './detect';
+import { ImageType, PictureWatermark, TextWatermark, WatermarkLayout } from './model';
+/** Office namespace used by `o:title` / `o:spid` on VML. */
+var OFFICE_NS = 'urn:schemas-microsoft-com:office:office';
+/** Office document relationships namespace (`r:id` on `v:imagedata`). */
+var R_NS = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+var IMAGE_REL_TYPES = new Set([
+    IMAGE_RELATIONSHIP_TYPE,
+    STRICT_IMAGE_RELATIONSHIP_TYPE,
+]);
+/** Shape attributes consumed by the modeled text/picture surface (not residual). */
+var MODELED_SHAPE_ATTRS = new Set([
+    'id',
+    'type',
+    'style',
+    'fillcolor',
+    'stroked',
+    'filled',
+]);
+/** Style keys consumed for text/picture models. */
+var MODELED_STYLE_KEYS = new Set([
+    'position',
+    'margin-left',
+    'margin-top',
+    'width',
+    'height',
+    'rotation',
+    'z-index',
+    'mso-position-horizontal',
+    'mso-position-horizontal-relative',
+    'mso-position-vertical',
+    'mso-position-vertical-relative',
+]);
+/** textpath style keys consumed as fontName / size. */
+var MODELED_TEXTPATH_STYLE_KEYS = new Set(['font-family', 'font-size']);
+var parseIndexByDocument = new WeakMap();
+var parseCompleted = new WeakSet();
+/**
+ * Once set, {@link applyLogicalWatermarkFromDefaultHeader} must not re-seed
+ * logical state from the physical index. Covers first successful apply and
+ * author setter / {@link WordDocument.removeWatermark} so clear is sticky.
+ */
+var logicalSettled = new WeakSet();
+/**
+ * @private
+ * Test / serialize hook: physical watermark copies by header part key.
+ */
+export function physicalWatermarksOf(document) {
+    var __ts33_0, __ts33_1;
+    return ((__ts33_1 = ((__ts33_0 = parseIndexByDocument.get(document)), __ts33_0 == null ? undefined : __ts33_0.physicalByPartKey)), __ts33_1 != null ? __ts33_1 : new Map());
+}
+/**
+ * Mark parse complete so a later ensure does not overwrite author assignment.
+ * Used by the document host setter after logical attach / remove.
+ *
+ * @private
+ */
+export function markWatermarkParseCompleted(document) {
+    parseCompleted.add(document);
+    // Author path owns logical state; never re-apply from physical headers.
+    logicalSettled.add(document);
+    if (!parseIndexByDocument.has(document)) {
+        parseIndexByDocument.set(document, {
+            physicalByPartKey: new Map(),
+            completed: true,
+        });
+    }
+}
+/**
+ * @private
+ * Reset parse bookkeeping for unit tests.
+ */
+export function resetWatermarkParseStateForTests(document) {
+    if (document !== undefined) {
+        parseIndexByDocument.delete(document);
+        parseCompleted.delete(document);
+        logicalSettled.delete(document);
+    }
+}
+function attributeValue(el, namespaceUri, localName) {
+    var __ts33_2;
+    return ((__ts33_2 = el.attributes.find(function (a) { return a.namespaceUri === namespaceUri && a.localName === localName; })), __ts33_2 == null ? undefined : __ts33_2.value);
+}
+function findVmlChild(parent, localName) {
+    var e_1, _a;
+    try {
+        for (var _b = __values(elementChildren(parent)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isVml(child, localName)) {
+                return child;
+            }
+        }
+    }
+    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 undefined;
+}
+function styleExtraRecord(style, modeled) {
+    var e_2, _a;
+    var out = {};
+    var any = false;
+    try {
+        for (var style_1 = __values(style), style_1_1 = style_1.next(); !style_1_1.done; style_1_1 = style_1.next()) {
+            var _b = __read(style_1_1.value, 2), key = _b[0], value = _b[1];
+            if (!modeled.has(key)) {
+                out[key] = value;
+                any = true;
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (style_1_1 && !style_1_1.done && (_a = style_1.return)) _a.call(style_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return any ? out : undefined;
+}
+function attrKey(attr) {
+    if (attr.prefix !== '') {
+        return attr.prefix + ":" + attr.localName;
+    }
+    if (attr.namespaceUri !== '' && attr.namespaceUri !== VML_NS) {
+        return "{" + attr.namespaceUri + "}" + attr.localName;
+    }
+    return attr.localName;
+}
+function parsePt(raw) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    var match = /^([+-]?(?:\d+(?:\.\d*)?|\.\d+))\s*pt$/i.exec(raw.trim());
+    if (match === null) {
+        var asNum = Number.parseFloat(raw);
+        return Number.isFinite(asNum) ? asNum : undefined;
+    }
+    var value = Number.parseFloat(match[1] != null ? match[1] : '');
+    return Number.isFinite(value) ? value : undefined;
+}
+function stripFontFamilyQuotes(raw) {
+    var s = raw.trim();
+    if ((s.startsWith('"') && s.endsWith('"')) ||
+        (s.startsWith("'") && s.endsWith("'"))) {
+        s = s.slice(1, -1);
+    }
+    return s;
+}
+function parseRotationDegrees(style) {
+    var raw = style.get('rotation');
+    if (raw === undefined || raw.trim() === '') {
+        return undefined;
+    }
+    var value = Number.parseFloat(raw);
+    return Number.isFinite(value) ? value : undefined;
+}
+function layoutFromRotation(rotation) {
+    if (rotation === undefined || rotation === 0) {
+        return { layout: WatermarkLayout.Horizontal, customRotation: undefined };
+    }
+    if (rotation === 315) {
+        return { layout: WatermarkLayout.Diagonal, customRotation: undefined };
+    }
+    return { layout: WatermarkLayout.Diagonal, customRotation: rotation };
+}
+/**
+ * Opacity tri-state from `v:fill/@opacity` (and only that verified signal).
+ * Gray fill alone is not proof. `.5` / values below full → transparent; full → opaque; absent → unknown.
+ */
+function parseSemitransparentState(shape) {
+    var fill = findVmlChild(shape, 'fill');
+    if (fill === undefined) {
+        return { state: 'unknown', fillOpacity: undefined };
+    }
+    var opacity = vmlAttribute(fill, 'opacity');
+    if (opacity === undefined || opacity.trim() === '') {
+        return { state: 'unknown', fillOpacity: undefined };
+    }
+    var normalized = opacity.trim().toLowerCase();
+    if (normalized === '1' ||
+        normalized === '1.0' ||
+        normalized === '100%' ||
+        normalized === '65536f') {
+        return { state: 'opaque', fillOpacity: opacity };
+    }
+    var asNum = Number.parseFloat(normalized);
+    if (Number.isFinite(asNum)) {
+        if (asNum < 1) {
+            return { state: 'transparent', fillOpacity: opacity };
+        }
+        if (asNum === 1) {
+            return { state: 'opaque', fillOpacity: opacity };
+        }
+    }
+    return { state: 'unknown', fillOpacity: opacity };
+}
+function buildResidual(shape, style, textpath, textpathStyle, fillOpacity, imagedata, unresolvedImageNote) {
+    var e_3, _a, e_4, _b, e_5, _c, e_6, _d, e_7, _e, e_8, _f;
+    var residualChildrenXml = [];
+    var seenTextpath = false;
+    var seenFill = false;
+    var seenImagedata = false;
+    try {
+        for (var _g = __values(elementChildren(shape)), _h = _g.next(); !_h.done; _h = _g.next()) {
+            var child = _h.value;
+            if (isVml(child, 'textpath') && !seenTextpath) {
+                seenTextpath = true;
+                continue;
+            }
+            if (isVml(child, 'fill') && !seenFill) {
+                seenFill = true;
+                continue;
+            }
+            if (isVml(child, 'imagedata') && !seenImagedata) {
+                seenImagedata = true;
+                continue;
+            }
+            residualChildrenXml.push(serializeXml(child));
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_h && !_h.done && (_a = _g.return)) _a.call(_g);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    var extraShapeAttributes = {};
+    try {
+        for (var _j = __values(shape.attributes), _k = _j.next(); !_k.done; _k = _j.next()) {
+            var attr = _k.value;
+            var isVmlOrEmpty = attr.namespaceUri === '' || attr.namespaceUri === VML_NS;
+            if (isVmlOrEmpty && MODELED_SHAPE_ATTRS.has(attr.localName)) {
+                continue;
+            }
+            extraShapeAttributes[attrKey(attr)] = attr.value;
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_k && !_k.done && (_b = _j.return)) _b.call(_j);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    var extensions = {};
+    var styleExtra = styleExtraRecord(style, MODELED_STYLE_KEYS);
+    if (styleExtra !== undefined) {
+        try {
+            for (var _l = __values(objectEntries(styleExtra)), _m = _l.next(); !_m.done; _m = _l.next()) {
+                var _o = __read(_m.value, 2), k = _o[0], v = _o[1];
+                extensions["style." + k] = v;
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_m && !_m.done && (_c = _l.return)) _c.call(_l);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+    }
+    if (textpath !== undefined) {
+        var textpathModeledAttrs = new Set(['string', 'on', 'style']);
+        try {
+            for (var _p = __values(textpath.attributes), _q = _p.next(); !_q.done; _q = _p.next()) {
+                var attr = _q.value;
+                var isVmlOrEmpty = attr.namespaceUri === '' || attr.namespaceUri === VML_NS;
+                if (isVmlOrEmpty && textpathModeledAttrs.has(attr.localName)) {
+                    continue;
+                }
+                extensions["textpath." + attrKey(attr)] = attr.value;
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_q && !_q.done && (_d = _p.return)) _d.call(_p);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        var tpStyleExtra = styleExtraRecord(textpathStyle, MODELED_TEXTPATH_STYLE_KEYS);
+        if (tpStyleExtra !== undefined) {
+            try {
+                for (var _r = __values(objectEntries(tpStyleExtra)), _s = _r.next(); !_s.done; _s = _r.next()) {
+                    var _t = __read(_s.value, 2), k = _t[0], v = _t[1];
+                    extensions["textpathStyle." + k] = v;
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (_s && !_s.done && (_e = _r.return)) _e.call(_r);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+        }
+    }
+    if (imagedata !== undefined) {
+        var imagedataModeled = new Set(['id', 'gain', 'blacklevel']);
+        try {
+            for (var _u = __values(imagedata.attributes), _v = _u.next(); !_v.done; _v = _u.next()) {
+                var attr = _v.value;
+                if (attr.namespaceUri === R_NS && attr.localName === 'id') {
+                    continue;
+                }
+                var isLocal = attr.namespaceUri === '' ||
+                    attr.namespaceUri === VML_NS ||
+                    attr.namespaceUri === OFFICE_NS;
+                if (isLocal && imagedataModeled.has(attr.localName)) {
+                    // gain/blacklevel modeled as washout; retain raw tokens for clean fidelity.
+                    if (attr.localName === 'gain' || attr.localName === 'blacklevel') {
+                        extensions["imagedata." + attr.localName] = attr.value;
+                    }
+                    continue;
+                }
+                extensions["imagedata." + attrKey(attr)] = attr.value;
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_v && !_v.done && (_f = _u.return)) _f.call(_u);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+    }
+    var residual = {};
+    var shapeId = vmlAttribute(shape, 'id');
+    if (shapeId !== undefined) {
+        residual.shapeId = shapeId;
+    }
+    var shapeType = vmlAttribute(shape, 'type');
+    if (shapeType !== undefined) {
+        residual.shapeType = shapeType;
+    }
+    var styleAttribute = vmlAttribute(shape, 'style');
+    if (styleAttribute !== undefined) {
+        residual.styleAttribute = styleAttribute;
+    }
+    var fillcolor = vmlAttribute(shape, 'fillcolor');
+    if (fillcolor !== undefined) {
+        residual.fillcolor = fillcolor;
+    }
+    if (Object.keys(extraShapeAttributes).length > 0) {
+        residual.extraShapeAttributes = extraShapeAttributes;
+    }
+    if (residualChildrenXml.length > 0) {
+        residual.extraChildXml = residualChildrenXml;
+    }
+    if (fillOpacity !== undefined) {
+        residual.fillOpacity = fillOpacity;
+    }
+    if (imagedata !== undefined) {
+        var rid = attributeValue(imagedata, R_NS, 'id');
+        if (rid !== undefined) {
+            residual.imageRelationshipId = rid;
+        }
+    }
+    if (unresolvedImageNote !== undefined) {
+        residual.unresolvedImageNote = unresolvedImageNote;
+    }
+    if (Object.keys(extensions).length > 0) {
+        residual.extensions = extensions;
+    }
+    return residual;
+}
+/**
+ * @private
+ * Apply residual + custom rotation onto a constructed model.
+ */
+export function attachTextParseExtras(model, residual, customRotation) {
+    model.setParseResidual(residual);
+    if (customRotation !== undefined) {
+        model.setCustomRotationDegrees(customRotation);
+    }
+}
+/**
+ * @private
+ */
+export function attachPictureParseExtras(model, residual) {
+    model.setParseResidual(residual);
+}
+function parseTextWatermark(shape) {
+    var __ts33_3;
+    var style = parseVmlStyle(vmlAttribute(shape, 'style'));
+    var textpath = findVmlChild(shape, 'textpath');
+    var textpathStyle = parseVmlStyle(textpath === undefined ? undefined : vmlAttribute(textpath, 'style'));
+    var text = textpath === undefined ? '' : (((__ts33_3 = vmlAttribute(textpath, 'string')), __ts33_3 != null ? __ts33_3 : ''));
+    var fontRaw = textpathStyle.get('font-family');
+    var fontName = fontRaw === undefined ? undefined : stripFontFamilyQuotes(fontRaw);
+    var size = parsePt(textpathStyle.get('font-size'));
+    var color = vmlAttribute(shape, 'fillcolor');
+    var width = parsePt(style.get('width'));
+    var height = parsePt(style.get('height'));
+    var rotation = parseRotationDegrees(style);
+    var _a = layoutFromRotation(rotation), layout = _a.layout, customRotation = _a.customRotation;
+    var _b = parseSemitransparentState(shape), state = _b.state, fillOpacity = _b.fillOpacity;
+    var options = { layout: layout };
+    if (fontName !== undefined && fontName.length > 0) {
+        options.fontName = fontName;
+    }
+    if (size !== undefined && size > 0) {
+        options.size = size;
+    }
+    if (color !== undefined) {
+        options.color = color;
+    }
+    if (width !== undefined && width > 0) {
+        options.width = width;
+    }
+    if (height !== undefined && height > 0) {
+        options.height = height;
+    }
+    var model = new TextWatermark(text, options);
+    model.setSemitransparentState(state);
+    var residual = buildResidual(shape, style, textpath, textpathStyle, fillOpacity, undefined, undefined);
+    attachTextParseExtras(model, residual, customRotation);
+    return model;
+}
+function washoutFromImagedata(imagedata) {
+    var __ts33_4, __ts33_5, __ts33_6, __ts33_7;
+    // Verified Word washout on PictureWatermark.docx: gain + blacklevel on v:imagedata.
+    var gain = ((__ts33_5 = ((__ts33_4 = vmlAttribute(imagedata, 'gain')), __ts33_4 != null ? __ts33_4 : attributeValue(imagedata, OFFICE_NS, 'gain'))), __ts33_5 != null ? __ts33_5 : attributeValue(imagedata, '', 'gain'));
+    var blacklevel = ((__ts33_7 = ((__ts33_6 = vmlAttribute(imagedata, 'blacklevel')), __ts33_6 != null ? __ts33_6 : attributeValue(imagedata, OFFICE_NS, 'blacklevel'))), __ts33_7 != null ? __ts33_7 : attributeValue(imagedata, '', 'blacklevel'));
+    return gain !== undefined && blacklevel !== undefined;
+}
+function imageTypeFromContentType(contentType) {
+    if (contentType === undefined) {
+        return undefined;
+    }
+    var ct = contentType.toLowerCase();
+    if (ct === JPEG_CONTENT_TYPE || ct === 'image/jpg') {
+        return ImageType.Jpeg;
+    }
+    if (ct === PNG_CONTENT_TYPE) {
+        return ImageType.Png;
+    }
+    return undefined;
+}
+function resolvePictureBytes(pkg, headerPartName, imagedata) {
+    var rid = attributeValue(imagedata, R_NS, 'id');
+    if (rid === undefined || rid.length === 0) {
+        return {
+            bytes: undefined,
+            imageType: undefined,
+            unresolvedNote: 'missing-r-id',
+            relationshipId: undefined,
+        };
+    }
+    if (pkg === undefined) {
+        return {
+            bytes: undefined,
+            imageType: undefined,
+            unresolvedNote: 'no-package',
+            relationshipId: rid,
+        };
+    }
+    var rels;
+    try {
+        rels = relationshipsForPart(pkg, headerPartName);
+    }
+    catch (_a) {
+        return {
+            bytes: undefined,
+            imageType: undefined,
+            unresolvedNote: 'no-header-rels',
+            relationshipId: rid,
+        };
+    }
+    var rel = rels.items.find(function (item) { return item.id === rid; });
+    if (rel === undefined) {
+        return {
+            bytes: undefined,
+            imageType: undefined,
+            unresolvedNote: "missing-rel:" + rid,
+            relationshipId: rid,
+        };
+    }
+    if (!IMAGE_REL_TYPES.has(rel.type)) {
+        // Still attempt resolve; classification already matched other indicators.
+    }
+    if (/^https?:/i.test(rel.target) || /^mailto:/i.test(rel.target)) {
+        return {
+            bytes: undefined,
+            imageType: undefined,
+            unresolvedNote: 'external-target',
+            relationshipId: rid,
+        };
+    }
+    var targetName;
+    try {
+        targetName = resolveInternalTarget(rel.target, headerPartName);
+    }
+    catch (_b) {
+        return {
+            bytes: undefined,
+            imageType: undefined,
+            unresolvedNote: 'bad-target',
+            relationshipId: rid,
+        };
+    }
+    var part = partByName(pkg, targetName);
+    if (part === undefined) {
+        return {
+            bytes: undefined,
+            imageType: undefined,
+            unresolvedNote: "missing-part:" + targetName,
+            relationshipId: rid,
+        };
+    }
+    return {
+        bytes: part.data,
+        imageType: imageTypeFromContentType(part.contentType),
+        unresolvedNote: undefined,
+        relationshipId: rid,
+    };
+}
+function parsePictureWatermark(shape, pkg, headerPartName) {
+    var style = parseVmlStyle(vmlAttribute(shape, 'style'));
+    var imagedata = findVmlChild(shape, 'imagedata');
+    var width = parsePt(style.get('width'));
+    var height = parsePt(style.get('height'));
+    var washout = imagedata === undefined ? false : washoutFromImagedata(imagedata);
+    var resolved = imagedata === undefined
+        ? {
+            bytes: undefined,
+            imageType: undefined,
+            unresolvedNote: 'missing-imagedata',
+            relationshipId: undefined,
+        }
+        : resolvePictureBytes(pkg, headerPartName, imagedata);
+    var options = { washout: washout };
+    if (resolved.imageType !== undefined) {
+        options.imageType = resolved.imageType;
+    }
+    if (width !== undefined && width > 0) {
+        options.width = width;
+    }
+    if (height !== undefined && height > 0) {
+        options.height = height;
+    }
+    var model = new PictureWatermark(resolved.bytes, options);
+    if (resolved.bytes === undefined) {
+        model.imageData = undefined;
+    }
+    var residual = buildResidual(shape, style, undefined, new Map(), undefined, imagedata, resolved.unresolvedNote);
+    attachPictureParseExtras(model, residual);
+    return model;
+}
+function shapesUnderPict(pict) {
+    var e_9, _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_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_9) throw e_9.error; }
+    }
+    return shapes;
+}
+function visitOpenXmlForPict(node, visit) {
+    var e_10, _a;
+    if (isWml(node, 'pict')) {
+        visit(node);
+        return;
+    }
+    try {
+        for (var _b = __values(elementChildren(node)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            visitOpenXmlForPict(child, visit);
+        }
+    }
+    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_10) throw e_10.error; }
+    }
+}
+function collectPictFromBlocks(blocks, visit) {
+    var e_11, _a, e_12, _b;
+    try {
+        for (var blocks_1 = __values(blocks), blocks_1_1 = blocks_1.next(); !blocks_1_1.done; blocks_1_1 = blocks_1.next()) {
+            var block = blocks_1_1.value;
+            if (block.type === 'opaque') {
+                visitOpenXmlForPict(block.xml, visit);
+                continue;
+            }
+            if (block.type === 'paragraph') {
+                try {
+                    for (var _c = __values(block.paragraph.items), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var inline = _d.value;
+                        if (inline instanceof OpaqueParagraphItem || inline instanceof OpaqueRunItem) {
+                            visitOpenXmlForPict(inline.xml, visit);
+                        }
+                    }
+                }
+                catch (e_12_1) { e_12 = { error: e_12_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                    }
+                    finally { if (e_12) throw e_12.error; }
+                }
+            }
+        }
+    }
+    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    finally {
+        try {
+            if (blocks_1_1 && !blocks_1_1.done && (_a = blocks_1.return)) _a.call(blocks_1);
+        }
+        finally { if (e_11) throw e_11.error; }
+    }
+}
+/**
+ * Parse the first recognized watermark shape under header body blocks.
+ *
+ * @private
+ */
+export function parseWatermarkFromHeaderBlocks(blocks, pkg, headerPartName) {
+    var found;
+    collectPictFromBlocks(blocks, function (pict) {
+        var e_13, _a;
+        if (found !== undefined) {
+            return;
+        }
+        try {
+            for (var _b = __values(shapesUnderPict(pict)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var shape = _c.value;
+                if (isTextWatermarkShape(shape)) {
+                    found = parseTextWatermark(shape);
+                    return;
+                }
+                if (isPictureWatermarkShape(shape)) {
+                    found = parsePictureWatermark(shape, pkg, headerPartName);
+                    return;
+                }
+            }
+        }
+        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; }
+        }
+    });
+    return found;
+}
+/**
+ * Ensure header watermarks have been scanned once for this document.
+ *
+ * Builds the physical-by-part index only. Does **not** read or write
+ * `document.watermark` (avoids prototype getter re-entry). Logical apply is
+ * {@link applyLogicalWatermarkFromDefaultHeader} / {@link ensureParsedAndLogical}.
+ *
+ * Parse does not dirty header parts or mutate Open XML trees.
+ *
+ * @private
+ */
+export function ensureWatermarksParsed(document) {
+    var e_14, _a;
+    if (parseCompleted.has(document)) {
+        return;
+    }
+    parseCompleted.add(document);
+    var physicalByPartKey = new Map();
+    var catalog;
+    try {
+        catalog = headersFootersFor(document);
+    }
+    catch (_b) {
+        parseIndexByDocument.set(document, { physicalByPartKey: physicalByPartKey, completed: true });
+        return;
+    }
+    var pkg;
+    try {
+        pkg = document.opcPackage();
+    }
+    catch (_c) {
+        pkg = undefined;
+    }
+    var visited = new Set();
+    try {
+        for (var _d = __values(catalog.relationshipIds('header')), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var relId = _e.value;
+            var entry = catalog.entryForRelationship(relId);
+            if (entry === undefined) {
+                continue;
+            }
+            var key = partNameKey(entry.partName);
+            if (visited.has(key)) {
+                continue;
+            }
+            visited.add(key);
+            var watermark = parseWatermarkFromHeaderBlocks(entry.blocks, pkg, entry.partName);
+            if (watermark !== undefined) {
+                physicalByPartKey.set(key, watermark);
+            }
+        }
+    }
+    catch (e_14_1) { e_14 = { error: e_14_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        }
+        finally { if (e_14) throw e_14.error; }
+    }
+    parseIndexByDocument.set(document, { physicalByPartKey: physicalByPartKey, completed: true });
+}
+/**
+ * Apply logical watermark from default header after physical index is built.
+ * Separated so the document getter can call ensure then read logical without
+ * re-entrancy through the prototype getter mid-parse.
+ *
+ * @private
+ */
+export function applyLogicalWatermarkFromDefaultHeader(document, getLogical, setLogical) {
+    // Sticky after first apply or author setter/remove — never re-seed logical.
+    if (logicalSettled.has(document)) {
+        return;
+    }
+    if (getLogical() !== undefined) {
+        logicalSettled.add(document);
+        return;
+    }
+    var index = parseIndexByDocument.get(document);
+    if (index === undefined) {
+        return;
+    }
+    var header = defaultHeader(document);
+    if (header === undefined) {
+        // Physical scan finished with no default header; settle so getters stay empty.
+        logicalSettled.add(document);
+        return;
+    }
+    var catalog;
+    try {
+        catalog = headersFootersFor(document);
+    }
+    catch (_a) {
+        logicalSettled.add(document);
+        return;
+    }
+    var entry = catalog.entryForRelationship(header.relationshipId);
+    if (entry === undefined) {
+        logicalSettled.add(document);
+        return;
+    }
+    var wm = index.physicalByPartKey.get(partNameKey(entry.partName));
+    if (wm !== undefined) {
+        setLogical(wm);
+    }
+    logicalSettled.add(document);
+}
+/**
+ * Full ensure + logical apply used by the document host getter.
+ *
+ * @private
+ */
+export function ensureParsedAndLogical(document, getLogical, setLogical) {
+    ensureWatermarksParsed(document);
+    applyLogicalWatermarkFromDefaultHeader(document, getLogical, setLogical);
+}