@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/tables/tr-pr.js

@@ -0,0 +1,215 @@
+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 };
+        }
+    };
+};
+/**
+ * Typed parse/serialize helpers for `w:trPr`.
+ *
+ * Citations: Transitional `wml.xsd` `CT_TrPrBase`, `CT_Height`, `ST_HeightRule`,
+ * `ST_JcTable`.
+ */
+import { parseOnOff, serializeOnOff } from '../document/on-off';
+import { elementChildren, isWml, wmlAttr, wmlElement, } from '../document/wml';
+import { emptyPropsToUndefined, parseCnfStyle, parseShd, parseDecimalVal, parseTableAlignment, pointToTwips, serializeCnfStyle, serializeShd, serializeTableAlignment, normalizeCnfStyle, normalizedCnfStyleHasTrue, TableRowHeightRule, twipsToPoint, upsertPropChild, wmlAttrVal } from './tbl-pr';
+// TS 3.3: no `export type { ... }` — re-export interface via value import usage only.
+function findWmlChild(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 (isWml(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 ensureTrPr(trPr) {
+    return trPr != null ? trPr : wmlElement('trPr');
+}
+function writeTrChild(trPr, localName, replacement) {
+    var next = upsertPropChild(ensureTrPr(trPr), 'trPr', localName, replacement);
+    return emptyPropsToUndefined(next);
+}
+// TS 3.3 / ES5 parity: avoid Object.values on the const map.
+var HEIGHT_RULES = new Set([
+    TableRowHeightRule.Auto,
+    TableRowHeightRule.AtLeast,
+    TableRowHeightRule.Exact,
+]);
+/**
+ * @private
+ */
+export function readRowHeight(trPr) {
+    var __ts33_0;
+    if (trPr === undefined) {
+        return undefined;
+    }
+    var el = findWmlChild(trPr, 'trHeight');
+    if (el === undefined) {
+        return undefined;
+    }
+    var val = parseDecimalVal(wmlAttrVal(el, 'val'));
+    if (val === undefined) {
+        return undefined;
+    }
+    var ruleRaw = ((__ts33_0 = wmlAttrVal(el, 'hRule')), __ts33_0 != null ? __ts33_0 : 'auto');
+    if (!HEIGHT_RULES.has(ruleRaw)) {
+        return undefined;
+    }
+    return {
+        value: twipsToPoint(val),
+        rule: ruleRaw,
+    };
+}
+/**
+ * @private
+ */
+export function writeRowHeight(trPr, height) {
+    if (height === undefined) {
+        if (trPr === undefined) {
+            return undefined;
+        }
+        return writeTrChild(trPr, 'trHeight', undefined);
+    }
+    var attrs = [
+        wmlAttr('val', String(pointToTwips(height.value))),
+        wmlAttr('hRule', height.rule),
+    ];
+    return writeTrChild(trPr, 'trHeight', wmlElement('trHeight', { attributes: attrs }));
+}
+/**
+ * @private
+ */
+export function readRowCantSplit(trPr) {
+    if (trPr === undefined) {
+        return undefined;
+    }
+    var el = findWmlChild(trPr, 'cantSplit');
+    return el !== undefined ? parseOnOff(el) : undefined;
+}
+/**
+ * @private
+ */
+export function writeRowCantSplit(trPr, cantSplit) {
+    if (cantSplit === undefined && trPr === undefined) {
+        return undefined;
+    }
+    return writeTrChild(trPr, 'cantSplit', cantSplit !== undefined ? serializeOnOff('cantSplit', cantSplit) : undefined);
+}
+/**
+ * @private
+ */
+export function readRowIsHeader(trPr) {
+    if (trPr === undefined) {
+        return undefined;
+    }
+    var el = findWmlChild(trPr, 'tblHeader');
+    return el !== undefined ? parseOnOff(el) : undefined;
+}
+/**
+ * @private
+ */
+export function writeRowIsHeader(trPr, isHeader) {
+    if (isHeader === undefined && trPr === undefined) {
+        return undefined;
+    }
+    return writeTrChild(trPr, 'tblHeader', isHeader !== undefined ? serializeOnOff('tblHeader', isHeader) : undefined);
+}
+/**
+ * @private
+ */
+export function readRowAlignment(trPr) {
+    if (trPr === undefined) {
+        return undefined;
+    }
+    var el = findWmlChild(trPr, 'jc');
+    return el !== undefined ? parseTableAlignment(el) : undefined;
+}
+/**
+ * @private
+ */
+export function writeRowAlignment(trPr, alignment) {
+    if (alignment === undefined && trPr === undefined) {
+        return undefined;
+    }
+    return writeTrChild(trPr, 'jc', alignment !== undefined ? serializeTableAlignment(alignment) : undefined);
+}
+/**
+ * Row shading (`w:trPr/w:shd`).
+ *
+ * @private
+ */
+export function readRowShading(trPr) {
+    if (trPr === undefined) {
+        return undefined;
+    }
+    var el = findWmlChild(trPr, 'shd');
+    if (el === undefined) {
+        return undefined;
+    }
+    var shd = parseShd(el);
+    if (shd.fill === undefined && shd.color === undefined && shd.pattern === undefined) {
+        return undefined;
+    }
+    return shd;
+}
+/**
+ * @private
+ */
+export function writeRowShading(trPr, shading) {
+    if (shading === undefined && trPr === undefined) {
+        return undefined;
+    }
+    return writeTrChild(trPr, 'shd', shading !== undefined ? serializeShd(shading) : undefined);
+}
+/**
+ * Row conditional formatting membership (`w:trPr/w:cnfStyle` / `CT_Cnf`).
+ * Preserve-only: does not recompute from table layout.
+ *
+ * Citations: ECMA-376-1 §17.4.7; Part 4 §14.3.1.1 / §14.11.9; Transitional `CT_Cnf`.
+ *
+ * @private
+ */
+export function readRowCnfStyle(trPr) {
+    if (trPr === undefined) {
+        return undefined;
+    }
+    var el = findWmlChild(trPr, 'cnfStyle');
+    if (el === undefined) {
+        return undefined;
+    }
+    var state = parseCnfStyle(el);
+    var normalized = normalizeCnfStyle(state);
+    return normalizedCnfStyleHasTrue(normalized) ? state : undefined;
+}
+/**
+ * Write or clear row `w:cnfStyle`. Passing `undefined` removes the element.
+ * A supplied {@link NormalizedCnfStyle} is always written (including all-false).
+ *
+ * @private
+ */
+export function writeRowCnfStyle(trPr, state) {
+    if (state === undefined) {
+        if (trPr === undefined) {
+            return undefined;
+        }
+        return writeTrChild(trPr, 'cnfStyle', undefined);
+    }
+    var existing = trPr !== undefined ? findWmlChild(trPr, 'cnfStyle') : undefined;
+    var normalized = normalizeCnfStyle(state);
+    return writeTrChild(trPr, 'cnfStyle', serializeCnfStyle(normalized, existing));
+}

package/src/features/watermark/detect.d.ts

@@ -0,0 +1,76 @@
+import { OpenXmlElement } from '../../core/xml/index';
+/** VML main namespace (ECMA-376-4 VML). */
+export declare const VML_NS = "urn:schemas-microsoft-com:vml";
+/** Exact text watermark shapetype token (parse + dirty emit). */
+export declare const TEXT_WATERMARK_TYPE = "#_x0000_t136";
+/** Canonical picture watermark shapetype token (dirty emit). */
+export declare const PICTURE_WATERMARK_TYPE = "#_x0000_t75";
+/** Malformed but tolerated picture type (parse only; dirty normalizes to single `#`). */
+export declare const PICTURE_WATERMARK_TYPE_DOUBLE_HASH = "##_x0000_t75";
+/** Word DocIO / UI text watermark id prefix. */
+export declare const TEXT_WATERMARK_ID_PREFIX = "PowerPlusWaterMarkObject";
+/** Word DocIO / UI picture watermark id prefix. */
+export declare const PICTURE_WATERMARK_ID_PREFIX = "WordPictureWatermark";
+/**
+ * Parsed `v:shape/@style` declaration map (lower-cased keys, trimmed values).
+ *
+ * @private
+ */
+export declare function parseVmlStyle(style: string | undefined): Map<string, string>;
+/**
+ * Read an attribute from an element, accepting empty-namespace or a specific URI.
+ *
+ * VML attributes are commonly un-namespaced on the attribute node even when the
+ * element carries the VML namespace.
+ *
+ * @private
+ */
+export declare function vmlAttribute(el: OpenXmlElement, localName: string): string | undefined;
+/**
+ * True when `el` is a VML element with the given local name.
+ * @private
+ */
+export declare function isVml(el: OpenXmlElement, localName: string): boolean;
+/**
+ * Watermark positioning pattern shared by text (optional id) and picture
+ * (with negative z-index when z-index is present):
+ * absolute + horizontal/vertical center + both relatives margin.
+ *
+ * @private
+ */
+export declare function hasWatermarkPositionPattern(style: ReadonlyMap<string, string>, options?: {
+    readonly requireNegativeZIndexWhenPresent?: boolean;
+}): boolean;
+/**
+ * True when `type` is an accepted picture watermark shapetype token.
+ * Allows `#_x0000_t75` and `##_x0000_t75` only (not three or more leading `#`).
+ *
+ * @private
+ */
+export declare function isAcceptedPictureWatermarkType(type: string | undefined): boolean;
+/**
+ * Conservative text-watermark detector for a `v:shape` element.
+ *
+ * Requires `v:textpath`, type exactly `#_x0000_t136`, and either a
+ * `PowerPlusWaterMarkObject*` id or the watermark positioning pattern.
+ * Does **not** require `z-index:-1` (verified text fixtures omit a -1 token
+ * or use a large negative Word z-index).
+ *
+ * Host / `w:pict` checks are the caller's responsibility (header walk).
+ *
+ * @private
+ */
+export declare function isTextWatermarkShape(shape: OpenXmlElement): boolean;
+/**
+ * Conservative picture-watermark detector for a `v:shape` element.
+ *
+ * Requires `v:imagedata`, type `#_x0000_t75` or `##_x0000_t75`, and either a
+ * `WordPictureWatermark*` id or the positioning pattern (negative z-index
+ * enforced when z-index is present). Type alone is insufficient (WordArt /
+ * ordinary pictures must not match).
+ *
+ * Host / `w:pict` checks are the caller's responsibility (header walk).
+ *
+ * @private
+ */
+export declare function isPictureWatermarkShape(shape: OpenXmlElement): boolean;

package/src/features/watermark/detect.js

@@ -0,0 +1,219 @@
+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 };
+        }
+    };
+};
+/**
+ * Conservative watermark shape detectors (TASK-8061).
+ *
+ * Prefer false negatives over false positives. Same predicates feed parse,
+ * replace, and remove. Normative rules:
+ * `docs/requirements/watermark-basic.md` (Detection).
+ *
+ * @packageDocumentation
+ */
+import { elementChildren } from '../document/wml';
+/** VML main namespace (ECMA-376-4 VML). */
+export var VML_NS = 'urn:schemas-microsoft-com:vml';
+/** Exact text watermark shapetype token (parse + dirty emit). */
+export var TEXT_WATERMARK_TYPE = '#_x0000_t136';
+/** Canonical picture watermark shapetype token (dirty emit). */
+export var PICTURE_WATERMARK_TYPE = '#_x0000_t75';
+/** Malformed but tolerated picture type (parse only; dirty normalizes to single `#`). */
+export var PICTURE_WATERMARK_TYPE_DOUBLE_HASH = '##_x0000_t75';
+/** Word DocIO / UI text watermark id prefix. */
+export var TEXT_WATERMARK_ID_PREFIX = 'PowerPlusWaterMarkObject';
+/** Word DocIO / UI picture watermark id prefix. */
+export var PICTURE_WATERMARK_ID_PREFIX = 'WordPictureWatermark';
+/**
+ * Parsed `v:shape/@style` declaration map (lower-cased keys, trimmed values).
+ *
+ * @private
+ */
+export function parseVmlStyle(style) {
+    var e_1, _a;
+    var out = new Map();
+    if (style === undefined || style.length === 0) {
+        return out;
+    }
+    try {
+        for (var _b = __values(style.split(';')), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var part = _c.value;
+            var trimmed = part.trim();
+            if (trimmed.length === 0) {
+                continue;
+            }
+            var colon = trimmed.indexOf(':');
+            if (colon <= 0) {
+                continue;
+            }
+            var key = trimmed.slice(0, colon).trim().toLowerCase();
+            var value = trimmed.slice(colon + 1).trim();
+            if (key.length === 0) {
+                continue;
+            }
+            out.set(key, value);
+        }
+    }
+    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 out;
+}
+/**
+ * Read an attribute from an element, accepting empty-namespace or a specific URI.
+ *
+ * VML attributes are commonly un-namespaced on the attribute node even when the
+ * element carries the VML namespace.
+ *
+ * @private
+ */
+export function vmlAttribute(el, localName) {
+    var found = el.attributes.find(function (a) { return a.localName === localName &&
+        (a.namespaceUri === '' || a.namespaceUri === VML_NS); });
+    return found == null ? undefined : found.value;
+}
+/**
+ * True when `el` is a VML element with the given local name.
+ * @private
+ */
+export function isVml(el, localName) {
+    return el.namespaceUri === VML_NS && el.localName === localName;
+}
+function hasChildLocal(el, localName) {
+    var e_2, _a;
+    try {
+        for (var _b = __values(elementChildren(el)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isVml(child, localName)) {
+                return true;
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return false;
+}
+/**
+ * Watermark positioning pattern shared by text (optional id) and picture
+ * (with negative z-index when z-index is present):
+ * absolute + horizontal/vertical center + both relatives margin.
+ *
+ * @private
+ */
+export function hasWatermarkPositionPattern(style, options) {
+    var __ts33_0, __ts33_1, __ts33_2, __ts33_3, __ts33_4;
+    if ((((__ts33_0 = style.get('position')), __ts33_0 != null ? __ts33_0 : '')).toLowerCase() !== 'absolute') {
+        return false;
+    }
+    if ((((__ts33_1 = style.get('mso-position-horizontal')), __ts33_1 != null ? __ts33_1 : '')).toLowerCase() !== 'center') {
+        return false;
+    }
+    if ((((__ts33_2 = style.get('mso-position-vertical')), __ts33_2 != null ? __ts33_2 : '')).toLowerCase() !== 'center') {
+        return false;
+    }
+    if ((((__ts33_3 = style.get('mso-position-horizontal-relative')), __ts33_3 != null ? __ts33_3 : '')).toLowerCase() !== 'margin') {
+        return false;
+    }
+    if ((((__ts33_4 = style.get('mso-position-vertical-relative')), __ts33_4 != null ? __ts33_4 : '')).toLowerCase() !== 'margin') {
+        return false;
+    }
+    if ((options == null ? undefined : options.requireNegativeZIndexWhenPresent) === true) {
+        var zRaw = style.get('z-index');
+        if (zRaw !== undefined) {
+            var z = Number.parseFloat(zRaw);
+            if (!Number.isFinite(z) || z >= 0) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * True when `type` is an accepted picture watermark shapetype token.
+ * Allows `#_x0000_t75` and `##_x0000_t75` only (not three or more leading `#`).
+ *
+ * @private
+ */
+export function isAcceptedPictureWatermarkType(type) {
+    if (type === undefined) {
+        return false;
+    }
+    return type === PICTURE_WATERMARK_TYPE || type === PICTURE_WATERMARK_TYPE_DOUBLE_HASH;
+}
+/**
+ * Conservative text-watermark detector for a `v:shape` element.
+ *
+ * Requires `v:textpath`, type exactly `#_x0000_t136`, and either a
+ * `PowerPlusWaterMarkObject*` id or the watermark positioning pattern.
+ * Does **not** require `z-index:-1` (verified text fixtures omit a -1 token
+ * or use a large negative Word z-index).
+ *
+ * Host / `w:pict` checks are the caller's responsibility (header walk).
+ *
+ * @private
+ */
+export function isTextWatermarkShape(shape) {
+    var __ts33_5;
+    if (!isVml(shape, 'shape')) {
+        return false;
+    }
+    if (!hasChildLocal(shape, 'textpath')) {
+        return false;
+    }
+    var type = vmlAttribute(shape, 'type');
+    if (type !== TEXT_WATERMARK_TYPE) {
+        return false;
+    }
+    var id = ((__ts33_5 = vmlAttribute(shape, 'id')), __ts33_5 != null ? __ts33_5 : '');
+    if (id.startsWith(TEXT_WATERMARK_ID_PREFIX)) {
+        return true;
+    }
+    var style = parseVmlStyle(vmlAttribute(shape, 'style'));
+    return hasWatermarkPositionPattern(style);
+}
+/**
+ * Conservative picture-watermark detector for a `v:shape` element.
+ *
+ * Requires `v:imagedata`, type `#_x0000_t75` or `##_x0000_t75`, and either a
+ * `WordPictureWatermark*` id or the positioning pattern (negative z-index
+ * enforced when z-index is present). Type alone is insufficient (WordArt /
+ * ordinary pictures must not match).
+ *
+ * Host / `w:pict` checks are the caller's responsibility (header walk).
+ *
+ * @private
+ */
+export function isPictureWatermarkShape(shape) {
+    var __ts33_6;
+    if (!isVml(shape, 'shape')) {
+        return false;
+    }
+    if (!hasChildLocal(shape, 'imagedata')) {
+        return false;
+    }
+    var type = vmlAttribute(shape, 'type');
+    if (!isAcceptedPictureWatermarkType(type)) {
+        return false;
+    }
+    var id = ((__ts33_6 = vmlAttribute(shape, 'id')), __ts33_6 != null ? __ts33_6 : '');
+    if (id.startsWith(PICTURE_WATERMARK_ID_PREFIX)) {
+        return true;
+    }
+    var style = parseVmlStyle(vmlAttribute(shape, 'style'));
+    return hasWatermarkPositionPattern(style, { requireNegativeZIndexWhenPresent: true });
+}

package/src/features/watermark/index.d.ts

@@ -0,0 +1,28 @@
+export { PICTURE_WATERMARK_ID_PREFIX, PICTURE_WATERMARK_TYPE, PICTURE_WATERMARK_TYPE_DOUBLE_HASH, TEXT_WATERMARK_ID_PREFIX, TEXT_WATERMARK_TYPE, hasWatermarkPositionPattern, isAcceptedPictureWatermarkType, isVml, parseVmlStyle, vmlAttribute, } from './detect';
+export * from './logical-store';
+export * from './model';
+export * from './parse';
+export * from './serialize';
+import { isPictureWatermarkShape, isTextWatermarkShape } from './detect';
+import { clearLogicalWatermark, logicalWatermarkOf } from './logical-store';
+import { ImageType, PictureWatermark, TextWatermark, Watermark, WatermarkLayout, WatermarkType, PictureWatermarkOptions, SemitransparentState, TextWatermarkOptions, WatermarkShapeResidual } from './model';
+export { ImageType, PictureWatermark, TextWatermark, Watermark, WatermarkLayout, WatermarkType, isPictureWatermarkShape, isTextWatermarkShape, clearLogicalWatermark, logicalWatermarkOf, };
+export { PictureWatermarkOptions, SemitransparentState, TextWatermarkOptions, WatermarkShapeResidual, };
+/**
+ * @private
+ * Test hook */
+export declare function resetWatermarkFeatureForTests(): void;
+/**
+ * Register the watermark feature. Idempotent.
+ *
+ * Lazy header VML parse runs on first {@link WordDocument.watermark} get
+ * (TASK-8061). Dirty assignment marks the document so save materializes
+ * canonical watermark VML into scratch headers (TASK-8062). Remove/replace
+ * strips recognized watermark leaves, GCs unused header image relationships
+ * and unreferenced media, and never deletes header parts (TASK-8063). Picture
+ * media is applied via a package-level feature part after header multi-part
+ * writes.
+ *
+ * @private
+ */
+export declare function registerWatermarkFeature(): void;

package/src/features/watermark/index.js

@@ -0,0 +1,91 @@
+export { PICTURE_WATERMARK_ID_PREFIX, PICTURE_WATERMARK_TYPE, PICTURE_WATERMARK_TYPE_DOUBLE_HASH, TEXT_WATERMARK_ID_PREFIX, TEXT_WATERMARK_TYPE, hasWatermarkPositionPattern, isAcceptedPictureWatermarkType, isVml, parseVmlStyle, vmlAttribute, } from './detect';
+export * from './logical-store';
+export * from './model';
+export * from './parse';
+export * from './serialize';
+/**
+ * Optional watermark feature module (text and picture).
+ *
+ * Public construction (TASK-8060), lazy header VML parse (TASK-8061), and
+ * dirty header rewrite on save (TASK-8062). Logical state is held in a module
+ * WeakMap so clean parse never mutates package parts.
+ *
+ * OOXML ownership: docs/ooxml-mapping/watermark.md. Requirement:
+ * docs/requirements/watermark-basic.md. Spec: docs/specs/watermark-basic.md.
+ *
+ * @packageDocumentation
+ */
+import { WordDocument } from '../document/document';
+import { featureId, registerFeature, registerFeatureMaterializeHandler, registerFeaturePackagePartHandler, } from '../../core/registry/index';
+import { isPictureWatermarkShape, isTextWatermarkShape } from './detect';
+import { clearLogicalWatermark, logicalWatermarkOf, setLogicalWatermark, } from './logical-store';
+import { ImageType, PictureWatermark, TextWatermark, Watermark, WatermarkLayout, WatermarkType } from './model';
+import { ensureParsedAndLogical, markWatermarkParseCompleted, resetWatermarkParseStateForTests, } from './parse';
+import { loadWatermarkPackageParts, markWatermarkDirty, materializeWatermarks, resetWatermarkSerializeStateForTests, } from './serialize';
+export { ImageType, PictureWatermark, TextWatermark, Watermark, WatermarkLayout, WatermarkType, isPictureWatermarkShape, isTextWatermarkShape, clearLogicalWatermark, logicalWatermarkOf, };
+var WATERMARK = featureId('watermark');
+var registered = false;
+/**
+ * @private
+ * Test hook */
+export function resetWatermarkFeatureForTests() {
+    registered = false;
+    resetWatermarkParseStateForTests();
+    resetWatermarkSerializeStateForTests();
+}
+/**
+ * Register the watermark feature. Idempotent.
+ *
+ * Lazy header VML parse runs on first {@link WordDocument.watermark} get
+ * (TASK-8061). Dirty assignment marks the document so save materializes
+ * canonical watermark VML into scratch headers (TASK-8062). Remove/replace
+ * strips recognized watermark leaves, GCs unused header image relationships
+ * and unreferenced media, and never deletes header parts (TASK-8063). Picture
+ * media is applied via a package-level feature part after header multi-part
+ * writes.
+ *
+ * @private
+ */
+export function registerWatermarkFeature() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    registerFeature({ id: WATERMARK });
+    registerFeatureMaterializeHandler({
+        featureId: WATERMARK,
+        materialize: function (document) {
+            materializeWatermarks(document);
+        },
+    });
+    registerFeaturePackagePartHandler({
+        featureId: WATERMARK,
+        loadParts: function (pkg) {
+            return loadWatermarkPackageParts(pkg);
+        },
+    });
+}
+Object.defineProperty(WordDocument.prototype, 'watermark', {
+    configurable: true,
+    enumerable: false,
+    get: function () {
+        var _this = this;
+        ensureParsedAndLogical(this, function () { return logicalWatermarkOf(_this); }, function (value) {
+            setLogicalWatermark(_this, value);
+        });
+        return logicalWatermarkOf(this);
+    },
+    set: function (value) {
+        // Author assignment wins over a later lazy parse ensure.
+        // Assigning `undefined` clears the logical watermark (replaces removeWatermark()).
+        markWatermarkParseCompleted(this);
+        if (value === undefined) {
+            clearLogicalWatermark(this);
+        }
+        else {
+            setLogicalWatermark(this, value);
+        }
+        markWatermarkDirty(this);
+    },
+});
+registerWatermarkFeature();

package/src/features/watermark/logical-store.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Logical watermark attachment store (document → watermark).
+ *
+ * Kept separate from `index.ts` and `serialize.ts` so materialize can read
+ * logical state without a circular import through the public barrel.
+ *
+ * @packageDocumentation
+ */
+import { WordDocument } from '../document/document';
+import { Watermark } from './model';
+/**
+ * Read the logical watermark attached to a document.
+ * Does not trigger lazy parse.
+ *
+ * @private
+ */
+export declare function logicalWatermarkOf(document: WordDocument): Watermark | undefined;
+/**
+ * Attach or clear the logical watermark for a document (no package I/O).
+ *
+ * @private
+ */
+export declare function setLogicalWatermark(document: WordDocument, value: Watermark | undefined): void;
+/**
+ * Clear logical watermark state for a single document.
+ *
+ * @private
+ */
+export declare function clearLogicalWatermark(document: WordDocument): void;

package/src/features/watermark/logical-store.js

@@ -0,0 +1,31 @@
+/** Logical watermark attachment store (document → watermark). No package I/O. */
+var documentWatermarks = new WeakMap();
+/**
+ * Read the logical watermark attached to a document.
+ * Does not trigger lazy parse.
+ *
+ * @private
+ */
+export function logicalWatermarkOf(document) {
+    return documentWatermarks.get(document);
+}
+/**
+ * Attach or clear the logical watermark for a document (no package I/O).
+ *
+ * @private
+ */
+export function setLogicalWatermark(document, value) {
+    if (value === undefined) {
+        documentWatermarks.delete(document);
+        return;
+    }
+    documentWatermarks.set(document, value);
+}
+/**
+ * Clear logical watermark state for a single document.
+ *
+ * @private
+ */
+export function clearLogicalWatermark(document) {
+    documentWatermarks.delete(document);
+}