@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

package/src/features/images/index.js

@@ -0,0 +1,1429 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+export * from './caption-authoring-api';
+export * from './caption-enums';
+export * from './caption-host';
+export * from './captions';
+export * from './host-codec';
+export * from './image-sniff';
+export * from './layout-types';
+import { sha256Hex } from '../../core/compat/sha256';
+import { DocxError } from '../../core/errors/docx-error';
+import { registerAlwaysOnBodyFeatureBootstrap } from '../document/body-always-on';
+import { WordDocument } from '../document/document';
+import { EntityType } from '../document/entity-type';
+import { pointToEmus, emuToPoint, scalePoint, pxToPoint } from '../document/length';
+import { Paragraph } from '../document/paragraph';
+import { FeatureInlineParagraphItem, FeatureRunParagraphItem } from '../document/text-range';
+import { allocateRelationshipId, relationshipsWith, TargetMode } from '../../core/opc/relationships';
+import { partByName, relationshipsForPart, withPartRelationships } from '../../core/opc/package';
+import { partName, partNameKey, resolveInternalTarget } from '../../core/opc/part-name';
+import { featureId, registerFeature, registerFeatureMaterializeHandler, registerFeatureMultiPartHandler, registerFeatureRunLeafHandler, replaceOrAddPackagePart, usedMainDocumentRelationshipIds, visitParagraphsInDocumentOrder, } from '../../core/registry/index';
+import { sniffImageContentType, sniffImagePixelDimensions } from './image-sniff';
+import { requirePictureCaptionAuthoring } from './caption-authoring-api';
+import { bindCaptionHostDocument, hostDocumentOf } from './caption-host';
+import { decodePictureHost, encodePictureHost } from './host-codec';
+import { assertEnumMember, HORIZONTAL_ALIGNMENT_SET, HORIZONTAL_ORIGIN_SET, HorizontalOrigin, PicturePlacement, PICTURE_PLACEMENT_SET, TEXT_WRAPPING_STYLE_SET, TextWrappingStyle, VERTICAL_ALIGNMENT_SET, VERTICAL_ORIGIN_SET, VerticalOrigin } from './layout-types';
+var IMAGES = featureId('images');
+/**
+ * @private Transitional image relationship (ECMA-376-4 §9.2.10). */
+export var IMAGE_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/image';
+/**
+ * @private Strict image relationship (ECMA-376-1 §11.3.10). */
+export var STRICT_IMAGE_RELATIONSHIP_TYPE = 'http://purl.oclc.org/ooxml/officeDocument/relationships/image';
+var IMAGE_RELATIONSHIP_TYPES = [IMAGE_RELATIONSHIP_TYPE, STRICT_IMAGE_RELATIONSHIP_TYPE];
+/**
+ * @private PNG media type (ECMA-376-1 §15.2.14). */
+var PNG_CONTENT_TYPE = 'image/png';
+/**
+ * @private JPEG media type (ECMA-376-1 §15.2.14). */
+var JPEG_CONTENT_TYPE = 'image/jpeg';
+/** Default display size (points) when intrinsic pixels cannot be sniffed. */
+var DEFAULT_IMAGE_WIDTH_PT = 100;
+var DEFAULT_IMAGE_HEIGHT_PT = 100;
+function resolveImageLayout(bytes, options) {
+    var opts = options != null ? options : {};
+    var pixels = sniffImagePixelDimensions(bytes);
+    var hasW = opts.width !== undefined;
+    var hasH = opts.height !== undefined;
+    var width;
+    var height;
+    if (hasW && hasH) {
+        width = opts.width;
+        height = opts.height;
+    }
+    else if (hasW && !hasH) {
+        width = opts.width;
+        if (pixels !== undefined && pixels.width > 0) {
+            height = scalePoint(width, pixels.height / pixels.width);
+        }
+        else {
+            height = DEFAULT_IMAGE_HEIGHT_PT;
+        }
+    }
+    else if (!hasW && hasH) {
+        height = opts.height;
+        if (pixels !== undefined && pixels.height > 0) {
+            width = scalePoint(height, pixels.width / pixels.height);
+        }
+        else {
+            width = DEFAULT_IMAGE_WIDTH_PT;
+        }
+    }
+    else if (pixels !== undefined && pixels.width > 0 && pixels.height > 0) {
+        width = pxToPoint(pixels.width);
+        height = pxToPoint(pixels.height);
+    }
+    else {
+        width = DEFAULT_IMAGE_WIDTH_PT;
+        height = DEFAULT_IMAGE_HEIGHT_PT;
+    }
+    var sniffed = sniffImageContentType(bytes);
+    var contentType = opts.imageType != null ? opts.imageType : sniffed;
+    if (contentType === undefined) {
+        throw new DocxError('content/invalid-image', 'Image contentType is required when bytes are not PNG or JPEG');
+    }
+    return { width: width, height: height, contentType: contentType };
+}
+/**
+ * Build {@link ImageInit} without writing `undefined` into optional
+ * fields (`exactOptionalPropertyTypes`).
+ */
+function imageInit(parts) {
+    return __assign({ relationshipId: parts.relationshipId, width: parts.width, height: parts.height }, (parts.name !== undefined ? { name: parts.name } : {}), (parts.title !== undefined ? { title: parts.title } : {}), (parts.description !== undefined ? { description: parts.description } : {}), (parts.lockAspectRatio !== undefined
+        ? { lockAspectRatio: parts.lockAspectRatio }
+        : {}), (parts.rotation !== undefined ? { rotation: parts.rotation } : {}), (parts.flipHorizontal !== undefined
+        ? { flipHorizontal: parts.flipHorizontal }
+        : {}), (parts.flipVertical !== undefined ? { flipVertical: parts.flipVertical } : {}), (parts.placement !== undefined ? { placement: parts.placement } : {}), (parts.wrapping !== undefined ? { wrapping: parts.wrapping } : {}), (parts.horizontalOrigin !== undefined
+        ? { horizontalOrigin: parts.horizontalOrigin }
+        : {}), (parts.verticalOrigin !== undefined
+        ? { verticalOrigin: parts.verticalOrigin }
+        : {}), (parts.horizontalPosition !== undefined
+        ? { horizontalPosition: parts.horizontalPosition }
+        : {}), (parts.verticalPosition !== undefined
+        ? { verticalPosition: parts.verticalPosition }
+        : {}), (parts.horizontalAlignment !== undefined
+        ? { horizontalAlignment: parts.horizontalAlignment }
+        : {}), (parts.verticalAlignment !== undefined
+        ? { verticalAlignment: parts.verticalAlignment }
+        : {}), (parts.docPrId !== undefined ? { docPrId: parts.docPrId } : {}), (parts.preservedHost !== undefined ? { preservedHost: parts.preservedHost } : {}), (parts.layoutDirty !== undefined ? { layoutDirty: parts.layoutDirty } : {}), (parts.hyperlinkRelationshipId !== undefined
+        ? { hyperlinkRelationshipId: parts.hyperlinkRelationshipId }
+        : {}), (parts.hyperlinkTarget !== undefined ? { hyperlinkTarget: parts.hyperlinkTarget } : {}));
+}
+function resolvePlacementAndWrapping(placement, wrapping) {
+    var wrap = wrapping != null ? wrapping : TextWrappingStyle.Inline;
+    if (wrap !== TextWrappingStyle.Inline) {
+        return { placement: PicturePlacement.Anchored, wrapping: wrap };
+    }
+    if (placement === PicturePlacement.Anchored) {
+        return { placement: PicturePlacement.Anchored, wrapping: TextWrappingStyle.None };
+    }
+    return { placement: PicturePlacement.Inline, wrapping: TextWrappingStyle.Inline };
+}
+/**
+ * DrawingML picture leaf in a paragraph (`w:r/w:drawing` with `wp:inline`
+ * or `wp:anchor` + `pic:pic`).
+ *
+ * Setting {@link Image.textWrappingStyle} to a non-inline value promotes the host
+ * to `wp:anchor`. Setting wrapping back to `'inline'` collapses to `wp:inline`
+ * and **drops** anchor position/wrap residual by design — see TSDoc on
+ * {@link Image.textWrappingStyle}.
+ *
+ * @public
+ */
+var Picture = /** @class */ (function () {
+    function Picture(documentOrRelationshipIdOrInit, width, height) {
+        /**
+         * Public discriminant for {@link Paragraph.items} ({@link EntityType.Picture}).
+         * @public
+         */
+        this.type = EntityType.Picture;
+        if (documentOrRelationshipIdOrInit instanceof WordDocument) {
+            this.relationshipIdValue = '';
+            this.widthValue = DEFAULT_IMAGE_WIDTH_PT;
+            this.heightValue = DEFAULT_IMAGE_HEIGHT_PT;
+            this.nameValue = 'Picture';
+            this.titleValue = undefined;
+            this.descriptionValue = undefined;
+            this.lockAspectRatioValue = true;
+            this.rotationValue = 0;
+            this.flipHorizontalValue = false;
+            this.flipVerticalValue = false;
+            this.placementValue = PicturePlacement.Inline;
+            this.wrappingValue = TextWrappingStyle.Inline;
+            this.horizontalOriginValue = undefined;
+            this.verticalOriginValue = undefined;
+            this.horizontalPositionValue = undefined;
+            this.verticalPositionValue = undefined;
+            this.horizontalAlignmentValue = undefined;
+            this.verticalAlignmentValue = undefined;
+            this.docPrIdValue = 1;
+            this.preservedHostValue = undefined;
+            this.layoutDirtyValue = true;
+            this.hyperlinkRelationshipIdValue = undefined;
+            this.hyperlinkTargetValue = undefined;
+            bindCaptionHostDocument(this, documentOrRelationshipIdOrInit);
+            return;
+        }
+        var init = typeof documentOrRelationshipIdOrInit === 'string'
+            ? {
+                relationshipId: documentOrRelationshipIdOrInit,
+                width: width,
+                height: height,
+            }
+            : documentOrRelationshipIdOrInit;
+        var resolved = resolvePlacementAndWrapping(init.placement, init.wrapping);
+        this.relationshipIdValue = init.relationshipId;
+        this.widthValue = init.width;
+        this.heightValue = init.height;
+        this.nameValue = init.name != null ? init.name : 'Picture';
+        this.titleValue = init.title;
+        this.descriptionValue = init.description;
+        this.lockAspectRatioValue = init.lockAspectRatio != null ? init.lockAspectRatio : true;
+        this.rotationValue = init.rotation != null ? init.rotation : 0;
+        this.flipHorizontalValue = init.flipHorizontal != null ? init.flipHorizontal : false;
+        this.flipVerticalValue = init.flipVertical != null ? init.flipVertical : false;
+        this.placementValue = resolved.placement;
+        this.wrappingValue = resolved.wrapping;
+        this.horizontalOriginValue = init.horizontalOrigin;
+        this.verticalOriginValue = init.verticalOrigin;
+        this.horizontalPositionValue = init.horizontalPosition;
+        this.verticalPositionValue = init.verticalPosition;
+        this.horizontalAlignmentValue = init.horizontalAlignment;
+        this.verticalAlignmentValue = init.verticalAlignment;
+        this.docPrIdValue = init.docPrId != null ? init.docPrId : 1;
+        this.preservedHostValue = init.preservedHost;
+        this.layoutDirtyValue = init.layoutDirty != null ? init.layoutDirty : init.preservedHost === undefined;
+        this.hyperlinkRelationshipIdValue = init.hyperlinkRelationshipId;
+        this.hyperlinkTargetValue = init.hyperlinkTarget;
+    }
+    /** @private Build from decoded host state. */
+    Picture.fromHostState = function (state) {
+        return new Picture(imageInit({
+            relationshipId: state.relationshipId,
+            width: emuToPoint(state.widthEmu),
+            height: emuToPoint(state.heightEmu),
+            name: state.name,
+            title: state.title,
+            description: state.description,
+            lockAspectRatio: state.lockAspectRatio,
+            rotation: state.rotation,
+            flipHorizontal: state.flipHorizontal,
+            flipVertical: state.flipVertical,
+            placement: state.placement,
+            wrapping: state.wrapping,
+            horizontalOrigin: state.horizontalOrigin,
+            verticalOrigin: state.verticalOrigin,
+            horizontalPosition: state.horizontalPosition,
+            verticalPosition: state.verticalPosition,
+            horizontalAlignment: state.horizontalAlignment,
+            verticalAlignment: state.verticalAlignment,
+            docPrId: state.docPrId,
+            preservedHost: state.preservedHost,
+            layoutDirty: false,
+            hyperlinkRelationshipId: state.hyperlinkRelationshipId,
+        }));
+    };
+    Object.defineProperty(Picture.prototype, "width", {
+        /** Display width in points (`wp:extent/@cx` EMU at host boundary). */
+        get: function () {
+            return this.widthValue;
+        },
+        set: function (value) {
+            this.widthValue = value;
+            this.layoutDirtyValue = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "height", {
+        /** Display height in points (`wp:extent/@cy` EMU at host boundary). */
+        get: function () {
+            return this.heightValue;
+        },
+        set: function (value) {
+            this.heightValue = value;
+            this.layoutDirtyValue = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "hyperlinkRelationshipId", {
+        /**
+         * @private
+         * DrawingML picture hyperlink relationship id (`a:hlinkClick/@r:id`).
+         */
+        get: function () {
+            return this.hyperlinkRelationshipIdValue;
+        },
+        set: function (value) {
+            this.hyperlinkRelationshipIdValue = value;
+            this.layoutDirtyValue = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "hyperlinkTarget", {
+        /**
+         * @private
+         * Runtime target URI for a picture-backed hyperlink. Not written to the
+         * picture DrawingML tree; the package relationship carries the target.
+         */
+        get: function () {
+            return this.hyperlinkTargetValue;
+        },
+        set: function (value) {
+            this.hyperlinkTargetValue = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "relationshipId", {
+        /**
+         * @private
+         * Relationship id for the image media part; empty until materialized at save. */
+        get: function () {
+            return this.relationshipIdValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "name", {
+        /**
+         * Non-visual picture name (`wp:docPr/@name`, `pic:cNvPr/@name`).
+         * @defaultValue `'Picture'` on authoring.
+         */
+        get: function () {
+            return this.nameValue;
+        },
+        set: function (value) {
+            this.nameValue = value;
+            this.layoutDirtyValue = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "title", {
+        /**
+         * Caption / accessibility title (`wp:docPr/@title`).
+         * Not the same as {@link description} (`@descr`).
+         */
+        get: function () {
+            return this.titleValue;
+        },
+        set: function (value) {
+            this.titleValue = value;
+            this.layoutDirtyValue = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "description", {
+        /** Alternative text (`wp:docPr/@descr`). */
+        get: function () {
+            return this.descriptionValue;
+        },
+        set: function (value) {
+            this.descriptionValue = value;
+            this.layoutDirtyValue = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "lockAspectRatio", {
+        /**
+         * Aspect-ratio lock (`a:graphicFrameLocks/@noChangeAspect`).
+         * Authoring default is `true`; missing locks on load read as `false`.
+         */
+        get: function () {
+            return this.lockAspectRatioValue;
+        },
+        set: function (value) {
+            this.lockAspectRatioValue = value;
+            this.layoutDirtyValue = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "rotation", {
+        /**
+         * Clockwise rotation in degrees (`a:xfrm/@rot`).
+         * Wire uses ST_Angle = degrees × 60000.
+         */
+        get: function () {
+            return this.rotationValue;
+        },
+        set: function (value) {
+            if (!Number.isFinite(value)) {
+                throw new RangeError("Invalid rotation value \"" + String(value) + "\"; expected a finite number");
+            }
+            this.rotationValue = value;
+            this.layoutDirtyValue = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "flipHorizontal", {
+        /** Horizontal flip (`a:xfrm/@flipH`). */
+        get: function () {
+            return this.flipHorizontalValue;
+        },
+        set: function (value) {
+            this.flipHorizontalValue = value;
+            this.layoutDirtyValue = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "flipVertical", {
+        /** Vertical flip (`a:xfrm/@flipV`). */
+        get: function () {
+            return this.flipVerticalValue;
+        },
+        set: function (value) {
+            this.flipVerticalValue = value;
+            this.layoutDirtyValue = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "placement", {
+        /**
+         * Host placement (`wp:inline` vs `wp:anchor`).
+         * Prefer mutating {@link textWrappingStyle}; non-inline wrapping forces anchored.
+         */
+        get: function () {
+            return this.placementValue;
+        },
+        set: function (value) {
+            assertEnumMember('placement', value, PICTURE_PLACEMENT_SET);
+            this.placementValue = value;
+            if (value === PicturePlacement.Inline) {
+                this.wrappingValue = TextWrappingStyle.Inline;
+            }
+            else if (this.wrappingValue === TextWrappingStyle.Inline) {
+                this.wrappingValue = TextWrappingStyle.None;
+            }
+            this.layoutDirtyValue = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "textWrappingStyle", {
+        /**
+         * Text wrapping style.
+         *
+         * - `'inline'` serializes as `wp:inline`. Collapsing an anchored picture to
+         *   inline **drops** position and wrap residual by design.
+         * - Other values promote to `wp:anchor` with the matching wrap element.
+         *   Tight/through without a residual wrapPolygon fall back to `wrapNone`
+         *   (library does not invent polygons).
+         *
+         * @throws RangeError when `value` is not a known {@link TextWrappingStyle}.
+         */
+        get: function () {
+            return this.wrappingValue;
+        },
+        set: function (value) {
+            assertEnumMember('textWrappingStyle', value, TEXT_WRAPPING_STYLE_SET);
+            this.wrappingValue = value;
+            if (value === TextWrappingStyle.Inline) {
+                this.placementValue = PicturePlacement.Inline;
+            }
+            else {
+                this.placementValue = PicturePlacement.Anchored;
+            }
+            this.layoutDirtyValue = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "wrapping", {
+        /**
+         * @deprecated Use {@link textWrappingStyle} instead.
+         */
+        get: function () {
+            return this.textWrappingStyle;
+        },
+        /**
+         * @deprecated Use {@link textWrappingStyle} instead.
+         */
+        set: function (value) {
+            this.textWrappingStyle = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "horizontalOrigin", {
+        /** Horizontal origin (`wp:positionH/@relativeFrom`). */
+        get: function () {
+            return this.horizontalOriginValue;
+        },
+        set: function (value) {
+            if (value !== undefined) {
+                assertEnumMember('horizontalOrigin', value, HORIZONTAL_ORIGIN_SET);
+            }
+            this.horizontalOriginValue = value;
+            this.layoutDirtyValue = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "verticalOrigin", {
+        /** Vertical origin (`wp:positionV/@relativeFrom`). */
+        get: function () {
+            return this.verticalOriginValue;
+        },
+        set: function (value) {
+            if (value !== undefined) {
+                assertEnumMember('verticalOrigin', value, VERTICAL_ORIGIN_SET);
+            }
+            this.verticalOriginValue = value;
+            this.layoutDirtyValue = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "horizontalPosition", {
+        /**
+         * Horizontal offset (`wp:positionH/wp:posOffset`).
+         * Setting this clears {@link horizontalAlignment} (align XOR posOffset).
+         */
+        get: function () {
+            return this.horizontalPositionValue;
+        },
+        set: function (value) {
+            this.horizontalPositionValue = value;
+            if (value !== undefined) {
+                this.horizontalAlignmentValue = undefined;
+            }
+            this.layoutDirtyValue = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "verticalPosition", {
+        /**
+         * Vertical offset (`wp:positionV/wp:posOffset`).
+         * Setting this clears {@link verticalAlignment} (align XOR posOffset).
+         */
+        get: function () {
+            return this.verticalPositionValue;
+        },
+        set: function (value) {
+            this.verticalPositionValue = value;
+            if (value !== undefined) {
+                this.verticalAlignmentValue = undefined;
+            }
+            this.layoutDirtyValue = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "horizontalAlignment", {
+        /**
+         * Horizontal alignment (`wp:positionH/wp:align`).
+         * Setting this clears {@link horizontalPosition} (align XOR posOffset).
+         *
+         * @throws RangeError when `value` is not a known {@link HorizontalAlignment}.
+         */
+        get: function () {
+            return this.horizontalAlignmentValue;
+        },
+        set: function (value) {
+            if (value !== undefined) {
+                assertEnumMember('horizontalAlignment', value, HORIZONTAL_ALIGNMENT_SET);
+                this.horizontalPositionValue = undefined;
+            }
+            this.horizontalAlignmentValue = value;
+            this.layoutDirtyValue = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Picture.prototype, "verticalAlignment", {
+        /**
+         * Vertical alignment (`wp:positionV/wp:align`).
+         * Setting this clears {@link verticalPosition} (align XOR posOffset).
+         *
+         * @throws RangeError when `value` is not a known {@link VerticalAlignment}.
+         */
+        get: function () {
+            return this.verticalAlignmentValue;
+        },
+        set: function (value) {
+            if (value !== undefined) {
+                assertEnumMember('verticalAlignment', value, VERTICAL_ALIGNMENT_SET);
+                this.verticalPositionValue = undefined;
+            }
+            this.verticalAlignmentValue = value;
+            this.layoutDirtyValue = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /** @private */
+    Picture.prototype.isPendingRelationship = function () {
+        return this.relationshipIdValue.length === 0;
+    };
+    /** @private */
+    Picture.prototype.resolveRelationshipId = function (relationshipId) {
+        this.relationshipIdValue = relationshipId;
+    };
+    /** @private Apply optional authoring fields from {@link ImageOptions}. */
+    Picture.prototype.applyAppendOptions = function (options) {
+        if (options.name !== undefined) {
+            this.name = options.name;
+        }
+        if (options.title !== undefined) {
+            this.title = options.title;
+        }
+        if (options.description !== undefined) {
+            this.description = options.description;
+        }
+        if (options.lockAspectRatio !== undefined) {
+            this.lockAspectRatio = options.lockAspectRatio;
+        }
+        if (options.rotation !== undefined) {
+            this.rotation = options.rotation;
+        }
+        if (options.flipHorizontal !== undefined) {
+            this.flipHorizontal = options.flipHorizontal;
+        }
+        if (options.flipVertical !== undefined) {
+            this.flipVertical = options.flipVertical;
+        }
+        var wrap = options.textWrappingStyle !== undefined
+            ? options.textWrappingStyle
+            : options.wrapping;
+        if (wrap !== undefined) {
+            this.textWrappingStyle = wrap;
+        }
+        else if (options.placement !== undefined) {
+            this.placement = options.placement;
+        }
+        if (options.horizontalOrigin !== undefined) {
+            this.horizontalOrigin = options.horizontalOrigin;
+        }
+        if (options.verticalOrigin !== undefined) {
+            this.verticalOrigin = options.verticalOrigin;
+        }
+        // Apply align before position so a simultaneous position wins XOR clear.
+        if (options.horizontalAlignment !== undefined) {
+            this.horizontalAlignment = options.horizontalAlignment;
+        }
+        if (options.verticalAlignment !== undefined) {
+            this.verticalAlignment = options.verticalAlignment;
+        }
+        if (options.horizontalPosition !== undefined) {
+            this.horizontalPosition = options.horizontalPosition;
+        }
+        if (options.verticalPosition !== undefined) {
+            this.verticalPosition = options.verticalPosition;
+        }
+    };
+    /**
+     * Add a Word-style caption paragraph next to this picture.
+     *
+     * Creates a separate caption paragraph (built-in `Caption` style, centered,
+     * spacing 30/240 twips) containing a `SEQ <captionName> \* <switch>` complex
+     * field (ECMA-376-1 §17.16.5.56), inserted immediately before
+     * ({@link CaptionPosition.Above}) or after ({@link CaptionPosition.Below})
+     * the paragraph containing this picture. The picture and its paragraph are not
+     * moved or modified. The initial field result is the next number in the
+     * caption-name sequence; Microsoft Word remains authoritative on refresh.
+     *
+     * @returns The new caption {@link Paragraph}; append additional caption text
+     * or adjust its formatting on the returned object.
+     * @throws DocxError `content/invalid-caption-name` when the name is empty or
+     * whitespace-only.
+     * @throws DocxError `content/invalid-caption-format` /
+     * `content/invalid-caption-position` for unknown enum values.
+     * @throws DetachedObjectError when this picture is not attached to a paragraph
+     * in a main document body.
+     */
+    Picture.prototype.addCaption = function (captionName, numberingFormat, position) {
+        // Caption authoring reuses fields + styles. Those modules must not enter the
+        // always-on core graph; load `./captions.js` (via `@syncfusion/ej2-docx/images` public
+        // entry or a direct import) so the provider is installed first.
+        return requirePictureCaptionAuthoring()(this, captionName, numberingFormat, position);
+    };
+    /**
+     * Load image bytes into this picture instance.
+     *
+     * Loads image content into the current `Picture` instance, supporting:
+     * - Newly created pictures
+     * - Pictures loaded from existing documents
+     *
+     * If the picture already contains image data, calling `loadImage()` replaces
+     * the existing image with the newly supplied image bytes. The replacement
+     * occurs within the same `Picture` instance — no remove-and-add operation
+     * is required.
+     *
+     * The Picture instance remains attached to its parent container after image
+     * replacement. Parent references, collection indexes, and existing object
+     * references remain unchanged. Only the underlying image data is replaced.
+     *
+     * @example
+     * ```typescript
+     * // Load image into a newly created picture
+     * const picture = new Picture(document);
+     * picture.loadImage(imageBytes);
+     *
+     * // Replace existing picture content (same instance / collection index)
+     * const picture = paragraph.items[0] as Picture;
+     * picture.loadImage(newImageBytes);
+     * ```
+     *
+     * @param imageBytes - Image data as `Uint8Array` (PNG or JPEG)
+     * @throws DocxError when the picture is not attached to a document
+     * @public
+     */
+    Picture.prototype.loadImage = function (imageBytes) {
+        var document = hostDocumentOf(this);
+        if (document === undefined) {
+            throw new DocxError('model/detached-object', 'Picture is not attached to a document; cannot load image bytes');
+        }
+        var catalog = imagesFor(document);
+        var sniffed = sniffImageContentType(imageBytes);
+        var contentType = sniffed != null ? sniffed : PNG_CONTENT_TYPE;
+        if (this.isPendingRelationship()) {
+            if (catalog.pendingBytesFor(this) !== undefined) {
+                catalog.updatePendingBytes(this, imageBytes);
+            }
+            else {
+                catalog.registerPendingImage(this, imageBytes, contentType);
+            }
+            return;
+        }
+        // Materialized relationship: replace media bytes in place (layout / rId unchanged).
+        catalog.replaceBytes(this.relationshipId, imageBytes);
+    };
+    /**
+     * @private
+    */
+    Picture.prototype.toOpenXml = function () {
+        if (this.relationshipIdValue.length === 0) {
+            throw new DocxError('model/detached-object', 'Inline image relationship id is not materialized; save the document first');
+        }
+        var input = {
+            placement: this.placementValue,
+            wrapping: this.wrappingValue,
+            widthEmu: pointToEmus(this.widthValue),
+            heightEmu: pointToEmus(this.heightValue),
+            relationshipId: this.relationshipIdValue,
+            name: this.nameValue,
+            title: this.titleValue,
+            description: this.descriptionValue,
+            lockAspectRatio: this.lockAspectRatioValue,
+            rotation: this.rotationValue,
+            flipHorizontal: this.flipHorizontalValue,
+            flipVertical: this.flipVerticalValue,
+            horizontalOrigin: this.horizontalOriginValue != null ? this.horizontalOriginValue : HorizontalOrigin.Column,
+            verticalOrigin: this.verticalOriginValue != null ? this.verticalOriginValue : VerticalOrigin.Paragraph,
+            horizontalPosition: this.horizontalPositionValue,
+            verticalPosition: this.verticalPositionValue,
+            horizontalAlignment: this.horizontalAlignmentValue,
+            verticalAlignment: this.verticalAlignmentValue,
+            docPrId: this.docPrIdValue,
+            preservedHost: this.preservedHostValue,
+            layoutDirty: this.layoutDirtyValue,
+            hyperlinkRelationshipId: this.hyperlinkRelationshipIdValue,
+        };
+        return encodePictureHost(input);
+    };
+    return Picture;
+}());
+export { Picture };
+/**
+ * Image media parts linked from the Main Document.
+ *
+ * @private
+ */
+var ImagesCatalog = /** @class */ (function () {
+    /** @private */
+    function ImagesCatalog(entries) {
+        this.entries = entries;
+        this.byRelationshipId = new Map(__spread(entries.values()).map(function (entry) { return [entry.relationshipId, entry]; }));
+        this.pendingRemovals = [];
+        this.pendingImages = new Map();
+    }
+    /** @private */
+    ImagesCatalog.prototype.removeEntry = function (relationshipId) {
+        var entry = this.byRelationshipId.get(relationshipId);
+        if (entry === undefined) {
+            return;
+        }
+        this.entries.delete(entry.partName);
+        this.byRelationshipId.delete(relationshipId);
+        this.pendingRemovals.push(entry);
+    };
+    /** @private */
+    ImagesCatalog.prototype.isDirty = function () {
+        var e_1, _a;
+        if (this.pendingRemovals.length > 0 || this.pendingImages.size > 0) {
+            return true;
+        }
+        try {
+            for (var _b = __values(this.entries.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entry = _c.value;
+                if (entry.dirty || entry.pendingRelationship !== undefined) {
+                    return true;
+                }
+            }
+        }
+        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 false;
+    };
+    /** @private */
+    ImagesCatalog.prototype.applyToPackage = function (pkg, mainPartName) {
+        var e_2, _a, e_3, _b;
+        var next = pkg;
+        var _loop_1 = function (entry) {
+            if (!entry.dirty && entry.pendingRelationship === undefined) {
+                return "continue";
+            }
+            var rel = entry.pendingRelationship != null ? entry.pendingRelationship : relationshipsForPart(next, mainPartName).items.find(function (item) { return item.id === entry.relationshipId; });
+            next = replaceOrAddPackagePart(next, mainPartName, entry.partName, entry.contentType, entry.data, rel);
+            entry.dirty = false;
+            entry.pendingRelationship = undefined;
+        };
+        try {
+            for (var _c = __values(this.entries.values()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var entry = _d.value;
+                _loop_1(entry);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        try {
+            for (var _e = __values(this.pendingRemovals), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var entry = _f.value;
+                next = removeImagePartFromPackage(next, mainPartName, entry);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        this.pendingRemovals.length = 0;
+        return next;
+    };
+    /** Image bytes for a loaded relationship id. */
+    ImagesCatalog.prototype.bytesForRelationship = function (relationshipId) {
+        var __ts33_0;
+        return ((__ts33_0 = this.byRelationshipId.get(relationshipId)), __ts33_0 == null ? undefined : __ts33_0.data);
+    };
+    /** @private Pending picture bytes before save-time materialization. */
+    ImagesCatalog.prototype.pendingBytesFor = function (picture) {
+        var __ts33_1;
+        return ((__ts33_1 = this.pendingImages.get(picture)), __ts33_1 == null ? undefined : __ts33_1.bytes);
+    };
+    /** @private Record picture intent without allocating package ids. */
+    ImagesCatalog.prototype.registerPendingImage = function (picture, bytes, contentType) {
+        this.pendingImages.set(picture, { bytes: bytes, contentType: contentType });
+    };
+    /** @private Drop a pending picture that was removed before save. */
+    ImagesCatalog.prototype.discardPendingImage = function (picture) {
+        this.pendingImages.delete(picture);
+    };
+    /** @private Replace bytes on a not-yet-materialized picture. */
+    ImagesCatalog.prototype.updatePendingBytes = function (picture, bytes) {
+        var pending = this.pendingImages.get(picture);
+        if (pending === undefined) {
+            throw new DocxError('content/unknown-image', 'Pending inline image was not found');
+        }
+        this.pendingImages.set(picture, __assign({}, pending, { bytes: bytes }));
+    };
+    /** @private */
+    ImagesCatalog.prototype.materializePending = function (document) {
+        var _this = this;
+        if (this.pendingImages.size === 0) {
+            return;
+        }
+        var hashToRelationshipId = new Map();
+        visitParagraphsInDocumentOrder(document, function (paragraph) {
+            var e_4, _a;
+            try {
+                for (var _b = __values(picturesInParagraph(paragraph)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var picture = _c.value;
+                    if (!picture.isPendingRelationship()) {
+                        continue;
+                    }
+                    var pending_1 = _this.pendingImages.get(picture);
+                    if (pending_1 === undefined) {
+                        continue;
+                    }
+                    var hash = sha256(pending_1.bytes);
+                    var relationshipId = hashToRelationshipId.get(hash);
+                    if (relationshipId === undefined) {
+                        var allocated = _this.allocatePart(pending_1.bytes, pending_1.contentType, usedRelationshipIds(document, _this), usedPartNameKeys(document, _this));
+                        relationshipId = allocated.relationshipId;
+                        hashToRelationshipId.set(hash, relationshipId);
+                    }
+                    picture.resolveRelationshipId(relationshipId);
+                    _this.pendingImages.delete(picture);
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        });
+    };
+    /** @private */
+    ImagesCatalog.prototype.pendingRelationshipIds = function () {
+        return __spread(this.byRelationshipId.keys());
+    };
+    /** @private */
+    ImagesCatalog.prototype.pendingPartNames = function () {
+        return __spread(this.entries.keys());
+    };
+    /** @private */
+    ImagesCatalog.prototype.allocatePart = function (data, contentType, usedRelIds, usedPartNames) {
+        var partNameValue = allocateImagePartName(contentType, usedPartNames);
+        var relId = allocateRelationshipId(usedRelIds);
+        while (this.byRelationshipId.has(relId)) {
+            relId = allocateRelationshipId(new Set(__spread(usedRelIds, [relId])));
+        }
+        var entry = {
+            partName: partNameValue,
+            relationshipId: relId,
+            relationshipType: IMAGE_RELATIONSHIP_TYPE,
+            contentType: contentType,
+            data: data,
+            dirty: true,
+            pendingRelationship: {
+                id: relId,
+                type: IMAGE_RELATIONSHIP_TYPE,
+                target: relativeTarget(partNameValue),
+                extraAttributes: [],
+                children: [],
+            },
+        };
+        this.entries.set(partNameValue, entry);
+        this.byRelationshipId.set(relId, entry);
+        return { entry: entry, relationshipId: relId };
+    };
+    /** @private */
+    ImagesCatalog.prototype.replaceBytes = function (relationshipId, data) {
+        var entry = this.byRelationshipId.get(relationshipId);
+        if (entry === undefined) {
+            throw new DocxError('content/unknown-image', "Image relationship " + relationshipId + " is not loaded");
+        }
+        entry.data = data;
+        var sniffed = sniffImageContentType(data);
+        if (sniffed !== undefined) {
+            entry.contentType = sniffed;
+        }
+        entry.dirty = true;
+    };
+    /**
+     * Bind every inline picture in the main story to this document after body parse
+     * so {@link Picture.loadImage} works when pictures are taken from
+     * {@link Paragraph.items} without a prior {@link picturesInParagraph} walk.
+     *
+     * Invoked from {@link WordDocument.fromPackage} via duck-typed
+     * `afterMainDocumentLoad` (same pattern as comments).
+     *
+     * @private
+     */
+    ImagesCatalog.prototype.afterMainDocumentLoad = function (document) {
+        visitParagraphsInDocumentOrder(document, function (paragraph) {
+            // Side effect: picturesInParagraph binds hostDocumentOf for each leaf.
+            picturesInParagraph(paragraph);
+        });
+    };
+    return ImagesCatalog;
+}());
+export { ImagesCatalog };
+function extensionForContentType(contentType) {
+    return contentType === JPEG_CONTENT_TYPE ? 'jpeg' : 'png';
+}
+function sha256(data) {
+    return sha256Hex(data);
+}
+function relativeTarget(partNameValue) {
+    return partNameValue.slice('/word/'.length);
+}
+function allocateImagePartName(contentType, used) {
+    var ext = extensionForContentType(contentType);
+    var index = 1;
+    while (used.has(partNameKey(partName("/word/media/image" + String(index) + "." + ext)))) {
+        index += 1;
+    }
+    return partName("/word/media/image" + String(index) + "." + ext);
+}
+/**
+ * Resolve media content type for an image relationship target.
+ * Keep non-PNG/JPEG types (e.g. GIF) so {@link ImagesCatalog.replaceBytes} can
+ * find the relationship when replacing an existing picture.
+ */
+function contentTypeForPart(part) {
+    if (part.contentType === PNG_CONTENT_TYPE || part.contentType === JPEG_CONTENT_TYPE) {
+        return part.contentType;
+    }
+    if (part.contentType.startsWith('image/')) {
+        return part.contentType;
+    }
+    var lower = part.name.toLowerCase();
+    if (lower.endsWith('.png')) {
+        return PNG_CONTENT_TYPE;
+    }
+    if (lower.endsWith('.jpeg') || lower.endsWith('.jpg')) {
+        return JPEG_CONTENT_TYPE;
+    }
+    if (lower.endsWith('.gif')) {
+        return 'image/gif';
+    }
+    if (part.contentType.length > 0) {
+        return part.contentType;
+    }
+    return 'application/octet-stream';
+}
+function loadCatalog(pkg, mainPartName) {
+    var e_5, _a;
+    var rels = relationshipsForPart(pkg, mainPartName);
+    var entries = new Map();
+    try {
+        for (var _b = __values(rels.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var rel = _c.value;
+            if (IMAGE_RELATIONSHIP_TYPES.indexOf(rel.type) === -1) {
+                continue;
+            }
+            // External image links are valid OPC; keep the relationship as-is and skip part load.
+            if (rel.targetMode === TargetMode.External || /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(rel.target.trim())) {
+                continue;
+            }
+            var target = resolveInternalTarget(rel.target, mainPartName);
+            var part = partByName(pkg, target);
+            if (part === undefined) {
+                continue;
+            }
+            var contentType = contentTypeForPart(part);
+            entries.set(part.name, {
+                partName: part.name,
+                relationshipId: rel.id,
+                relationshipType: rel.type,
+                contentType: contentType,
+                data: part.data,
+                dirty: false,
+                pendingRelationship: undefined,
+            });
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return new ImagesCatalog(entries);
+}
+function removeImagePartFromPackage(pkg, mainPartName, entry) {
+    var next = withRemovedPartLocal(pkg, entry.partName);
+    next = withRemovedContentTypeOverrideLocal(next, entry.partName);
+    next = withFilteredPartRelationshipsLocal(next, mainPartName, function (rel) { return rel.id !== entry.relationshipId; });
+    return next;
+}
+function withRemovedPartLocal(pkg, name) {
+    var key = partNameKey(name);
+    var parts = pkg.parts.filter(function (part) { return partNameKey(part.name) !== key; });
+    if (parts.length === pkg.parts.length) {
+        return pkg;
+    }
+    return __assign({}, pkg, { parts: parts });
+}
+function withRemovedContentTypeOverrideLocal(pkg, logicalPartName) {
+    return __assign({}, pkg, { contentTypes: {
+            records: pkg.contentTypes.records.filter(function (record) { return !(record.kind === 'override' && record.partName === logicalPartName); }),
+        } });
+}
+function withFilteredPartRelationshipsLocal(pkg, source, keep) {
+    var existing = relationshipsForPart(pkg, source);
+    var kept = existing.items.filter(keep);
+    if (kept.length === existing.items.length) {
+        return pkg;
+    }
+    return withPartRelationships(pkg, source, relationshipsWith(kept, existing.opaque));
+}
+function usedRelationshipIds(document, _catalog) {
+    // Shared across multi-part features so concurrent pending allocations cannot
+    // emit the same main-document rId (ink + images materialize independently).
+    return usedMainDocumentRelationshipIds(document);
+}
+function usedPartNameKeys(document, catalog) {
+    var e_6, _a, e_7, _b;
+    var used = new Set();
+    try {
+        for (var _c = __values(document.opcPackage().parts), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var part = _d.value;
+            used.add(partNameKey(part.name));
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    try {
+        for (var _e = __values(catalog.pendingPartNames()), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var name_1 = _f.value;
+            used.add(partNameKey(name_1));
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    return used;
+}
+var registered = false;
+/** @private Test hook */
+export function resetImagesFeatureForTests() {
+    registered = false;
+}
+/** @private Register the images multi-part and inline drawing handlers. Idempotent. */
+export function registerImagesFeature() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    registerFeature({ id: IMAGES });
+    registerFeatureMultiPartHandler({
+        featureId: IMAGES,
+        relationshipTypes: IMAGE_RELATIONSHIP_TYPES,
+        loadParts: function (pkg, ctx) {
+            return loadCatalog(pkg, ctx.mainPartName);
+        },
+    });
+    registerFeatureMaterializeHandler({
+        featureId: IMAGES,
+        materialize: function (document) {
+            var part = document.featurePart(IMAGES);
+            if (part instanceof ImagesCatalog) {
+                part.materializePending(document);
+            }
+        },
+    });
+    registerFeatureRunLeafHandler({
+        featureId: IMAGES,
+        wmlLocalName: 'drawing',
+        tryParse: function (element) {
+            var state = decodePictureHost(element);
+            if (state === undefined) {
+                return undefined;
+            }
+            return Picture.fromHostState(state);
+        },
+    });
+}
+/**
+ * Image media catalog for a document.
+ *
+ * @throws DocxError `UNKNOWN_FEATURE` when the module was not registered before load.
+ * @private
+ */
+export function imagesFor(document) {
+    var part = document.featurePart(IMAGES);
+    if (part === undefined || !(part instanceof ImagesCatalog)) {
+        throw new DocxError('feature/not-registered', 'Images catalog was not loaded; call registerImagesFeature() before WordDocument.open');
+    }
+    return part;
+}
+/**
+ * Inline pictures in a paragraph, in document order (including nested inline content controls).
+ *
+ * @private
+ */
+export function picturesInParagraph(paragraph) {
+    var found = [];
+    var host;
+    collectPicturesFromParagraphItems(paragraph.items.snapshot(), found, function () {
+        if (host === undefined) {
+            host = tryParagraphDocument(paragraph);
+        }
+        return host;
+    });
+    return found;
+}
+/**
+ * @deprecated Use {@link picturesInParagraph} instead.
+ * @private
+ */
+export function imagesInParagraph(paragraph) {
+    return picturesInParagraph(paragraph);
+}
+function collectPicturesFromParagraphItems(items, found, hostOf) {
+    var e_8, _a;
+    try {
+        for (var items_1 = __values(items), items_1_1 = items_1.next(); !items_1_1.done; items_1_1 = items_1.next()) {
+            var item = items_1_1.value;
+            if (item instanceof Picture) {
+                var resolvedHost = hostDocumentOf(item);
+                var host = resolvedHost !== undefined ? resolvedHost : hostOf();
+                if (host !== undefined) {
+                    bindCaptionHostDocument(item, host);
+                }
+                found.push(item);
+                continue;
+            }
+            if (item instanceof FeatureRunParagraphItem && isPictureLeaf(item)) {
+                var leaf = item.value;
+                var resolvedLeafHost = hostDocumentOf(leaf);
+                var host = resolvedLeafHost !== undefined ? resolvedLeafHost : hostOf();
+                if (host !== undefined) {
+                    bindCaptionHostDocument(leaf, host);
+                }
+                found.push(leaf);
+                continue;
+            }
+            var nested = nestedParagraphItemsOf(item);
+            if (nested !== undefined) {
+                collectPicturesFromParagraphItems(nested, found, hostOf);
+            }
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (items_1_1 && !items_1_1.done && (_a = items_1.return)) _a.call(items_1);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+}
+/** Nested run-level items under an inline content control (public or wrapper). */
+function nestedParagraphItemsOf(item) {
+    if (item instanceof FeatureInlineParagraphItem) {
+        return nestedParagraphItemsOfValue(item.value);
+    }
+    return nestedParagraphItemsOfValue(item);
+}
+function nestedParagraphItemsOfValue(value) {
+    if (value === null || typeof value !== 'object') {
+        return undefined;
+    }
+    var candidate = value;
+    if (candidate.entityType !== EntityType.InlineContentControl) {
+        return undefined;
+    }
+    var collection = candidate.paragraphItems;
+    if (collection === undefined) {
+        return undefined;
+    }
+    if (typeof collection.snapshot === 'function') {
+        return collection.snapshot();
+    }
+    return __spread(collection);
+}
+function tryParagraphDocument(paragraph) {
+    try {
+        return paragraph.owningDocument();
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+/**
+ * Inline picture bytes for a picture relationship.
+ * @private
+ */
+export function inlinePictureBytes(document, picture) {
+    var catalog = imagesFor(document);
+    var pending = catalog.pendingBytesFor(picture);
+    if (pending !== undefined) {
+        return pending;
+    }
+    if (picture.relationshipId.length === 0) {
+        return undefined;
+    }
+    return catalog.bytesForRelationship(picture.relationshipId);
+}
+/**
+ * @deprecated Use {@link inlinePictureBytes} instead.
+ * @private
+ */
+export function inlineImageBytes(document, image) {
+    return inlinePictureBytes(document, image);
+}
+/**
+ * Replace picture media bytes without changing layout markup.
+ * @private
+ */
+export function replaceInlinePictureBytes(document, picture, bytes) {
+    var catalog = imagesFor(document);
+    if (picture.isPendingRelationship()) {
+        catalog.updatePendingBytes(picture, bytes);
+        return;
+    }
+    catalog.replaceBytes(picture.relationshipId, bytes);
+}
+/**
+ * @deprecated Use {@link replaceInlinePictureBytes} instead.
+ * @private
+ */
+export function replaceInlineImageBytes(document, image, bytes) {
+    replaceInlinePictureBytes(document, image, bytes);
+}
+/**
+ * Remove an inline picture run from its paragraph and drop its media on the next save.
+ * @private
+ */
+export function removeInlinePicture(document, paragraph, picture) {
+    var e_9, _a;
+    try {
+        for (var _b = __values(paragraph.items.snapshot()), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var item = _c.value;
+            if (item instanceof Picture && item === picture) {
+                paragraph.removeFeatureRunItem(picture);
+                if (!picture.isPendingRelationship()) {
+                    imagesFor(document).removeEntry(picture.relationshipId);
+                }
+                else {
+                    imagesFor(document).discardPendingImage(picture);
+                }
+                return;
+            }
+            if (item instanceof FeatureRunParagraphItem && isPictureLeaf(item) && item.value === picture) {
+                paragraph.removeFeatureRunItem(picture);
+                if (!picture.isPendingRelationship()) {
+                    imagesFor(document).removeEntry(picture.relationshipId);
+                }
+                else {
+                    imagesFor(document).discardPendingImage(picture);
+                }
+                return;
+            }
+        }
+    }
+    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; }
+    }
+    throw new DocxError('content/unknown-image', 'Inline picture is not in this paragraph');
+}
+/**
+ * @deprecated Use {@link removeInlinePicture} instead.
+ * @private
+ */
+export function removeInlineImage(document, paragraph, image) {
+    removeInlinePicture(document, paragraph, image);
+}
+/**
+ * Whether a paragraph item is a modeled inline picture from this module.
+ *
+ * @private
+ */
+export function isPictureLeaf(item) {
+    if (item instanceof Picture) {
+        return true;
+    }
+    return item instanceof FeatureRunParagraphItem && item.featureId === IMAGES && item.value instanceof Picture;
+}
+/**
+ * @deprecated Use {@link isPictureLeaf} instead.
+ * @private
+ */
+export function isImageLeaf(item) {
+    return isPictureLeaf(item);
+}
+Paragraph.prototype.appendImage = function (bytes, options) {
+    var opts = options != null ? options : {};
+    var catalog = imagesFor(this.owningDocument());
+    var layout = resolveImageLayout(bytes, opts);
+    var wrap = opts.textWrappingStyle !== undefined ? opts.textWrappingStyle : opts.wrapping;
+    var picture = new Picture(imageInit({
+        relationshipId: '',
+        width: layout.width,
+        height: layout.height,
+        name: opts.name != null ? opts.name : 'Picture',
+        title: opts.title,
+        description: opts.description,
+        lockAspectRatio: opts.lockAspectRatio != null ? opts.lockAspectRatio : true,
+        rotation: opts.rotation != null ? opts.rotation : 0,
+        flipHorizontal: opts.flipHorizontal != null ? opts.flipHorizontal : false,
+        flipVertical: opts.flipVertical != null ? opts.flipVertical : false,
+        placement: opts.placement,
+        wrapping: wrap,
+        horizontalOrigin: opts.horizontalOrigin,
+        verticalOrigin: opts.verticalOrigin,
+        horizontalPosition: opts.horizontalPosition,
+        verticalPosition: opts.verticalPosition,
+        horizontalAlignment: opts.horizontalAlignment,
+        verticalAlignment: opts.verticalAlignment,
+        layoutDirty: true,
+    }));
+    catalog.registerPendingImage(picture, bytes, layout.contentType);
+    bindCaptionHostDocument(picture, this.owningDocument());
+    this.appendFeatureRunItem(IMAGES, picture);
+    return picture;
+};
+registerAlwaysOnBodyFeatureBootstrap(function () {
+    registerImagesFeature();
+});
+registerImagesFeature();