@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/images/host-codec.js

@@ -0,0 +1,720 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+/**
+ * Picture DrawingML host decode/encode helpers (`wp:inline` / `wp:anchor` + `pic:pic`).
+ *
+ * Schema cites (Transitional `dml-wordprocessingDrawing.xsd`):
+ * - `CT_Inline`, `CT_Anchor`, `EG_WrapType`
+ * - `CT_PosH` / `CT_PosV` (align XOR posOffset; relativeFrom required)
+ * - `ST_RelFromH`, `ST_RelFromV`, `ST_AlignH`, `ST_AlignV`
+ * DrawingML main: `a:xfrm` rot/flipH/flipV; `a:CT_NonVisualDrawingProps` name/descr/title
+ * Locks: `a:graphicFrameLocks/@noChangeAspect`
+ *
+ * Anchor promotion defaults mirror ink host-codec minimal Word-like anchor
+ * (distL/R 114300, relativeHeight 251658240, layoutInCell 1, allowOverlap 1,
+ * positionH column posOffset 0, positionV paragraph posOffset 0, wrapNone).
+ *
+ * @packageDocumentation
+ */
+import { emuToPoint, pointToCoordinateEmus, emus } from '../document/length';
+import { isWml, wmlElement } from '../document/wml';
+import { HorizontalOrigin, PicturePlacement, TextWrappingStyle, VerticalOrigin, isHorizontalAlignment, isHorizontalOrigin, isVerticalAlignment, isVerticalOrigin } from './layout-types';
+var WP_NS = 'http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing';
+var A_NS = 'http://schemas.openxmlformats.org/drawingml/2006/main';
+var PIC_NS = 'http://schemas.openxmlformats.org/drawingml/2006/picture';
+var R_NS = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+/** ST_Angle: 60000ths of a degree (ECMA-376 DrawingML). */
+var ROTATION_UNITS_PER_DEGREE = 60000;
+var PICTURE_GRAPHIC_DATA_URI = 'http://schemas.openxmlformats.org/drawingml/2006/picture';
+function elementChildren(el) {
+    return el.children.filter(function (c) { return c.kind === 'element'; });
+}
+function isElement(el, namespaceUri, localName) {
+    return el.namespaceUri === namespaceUri && el.localName === localName;
+}
+function findFirstElement(root, namespaceUri, localName) {
+    var e_1, _a;
+    if (isElement(root, namespaceUri, localName)) {
+        return root;
+    }
+    try {
+        for (var _b = __values(elementChildren(root)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            var found = findFirstElement(child, namespaceUri, localName);
+            if (found !== undefined) {
+                return found;
+            }
+        }
+    }
+    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 attributeValue(el, namespaceUri, localName) {
+    var __ts33_0;
+    return ((__ts33_0 = el.attributes.find(function (a) { return a.namespaceUri === namespaceUri && a.localName === localName; })), __ts33_0 == null ? undefined : __ts33_0.value);
+}
+function textContent(el) {
+    var e_2, _a;
+    var out = '';
+    try {
+        for (var _b = __values(el.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (child.kind === 'text') {
+                out += child.value;
+            }
+        }
+    }
+    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 out;
+}
+function xmlElement(namespaceUri, prefix, localName, options) {
+    var __ts33_1, __ts33_2, __ts33_3;
+    return {
+        kind: 'element',
+        namespaceUri: namespaceUri,
+        localName: localName,
+        prefix: prefix,
+        attributes: ((__ts33_1 = options == null ? undefined : options.attributes), __ts33_1 != null ? __ts33_1 : []),
+        namespaceDeclarations: ((__ts33_2 = options == null ? undefined : options.namespaceDeclarations), __ts33_2 != null ? __ts33_2 : []),
+        children: ((__ts33_3 = options == null ? undefined : options.children), __ts33_3 != null ? __ts33_3 : []),
+    };
+}
+function attr(localName, value, namespaceUri, prefix) {
+    if (namespaceUri === void 0) { namespaceUri = ''; }
+    if (prefix === void 0) { prefix = ''; }
+    return { namespaceUri: namespaceUri, localName: localName, prefix: prefix, value: value };
+}
+function blipEmbedAttribute(id) {
+    return { namespaceUri: R_NS, localName: 'embed', prefix: 'r', value: id };
+}
+function extentAttributes(widthEmu, heightEmu) {
+    return [attr('cx', String(widthEmu)), attr('cy', String(heightEmu))];
+}
+function parseOnOff(raw) {
+    return raw === '1' || raw === 'true';
+}
+function parseXfrm(picRoot) {
+    var xfrm = findFirstElement(picRoot, A_NS, 'xfrm');
+    if (xfrm === undefined) {
+        return { rotation: 0, flipHorizontal: false, flipVertical: false };
+    }
+    var rotRaw = attributeValue(xfrm, '', 'rot');
+    var rotation = rotRaw !== undefined && /^-?\d+$/.test(rotRaw)
+        ? Number.parseInt(rotRaw, 10) / ROTATION_UNITS_PER_DEGREE
+        : 0;
+    return {
+        rotation: rotation,
+        flipHorizontal: parseOnOff(attributeValue(xfrm, '', 'flipH')),
+        flipVertical: parseOnOff(attributeValue(xfrm, '', 'flipV')),
+    };
+}
+function parseHlinkClickRelId(parent) {
+    var e_3, _a;
+    if (parent === undefined) {
+        return undefined;
+    }
+    try {
+        for (var _b = __values(elementChildren(parent)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isElement(child, A_NS, 'hlinkClick')) {
+                var relId = attributeValue(child, R_NS, 'id');
+                if (relId !== undefined && relId.length > 0) {
+                    return relId;
+                }
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return undefined;
+}
+function parseDocPr(host) {
+    var __ts33_4;
+    var docPr = findFirstElement(host, WP_NS, 'docPr');
+    if (docPr === undefined) {
+        return { name: 'Picture', title: undefined, description: undefined, id: 1, hyperlinkRelationshipId: undefined };
+    }
+    var idRaw = attributeValue(docPr, '', 'id');
+    var id = idRaw !== undefined && /^\d+$/.test(idRaw) ? Number.parseInt(idRaw, 10) : 1;
+    return {
+        name: ((__ts33_4 = attributeValue(docPr, '', 'name')), __ts33_4 != null ? __ts33_4 : 'Picture'),
+        title: attributeValue(docPr, '', 'title'),
+        description: attributeValue(docPr, '', 'descr'),
+        id: id,
+        hyperlinkRelationshipId: parseHlinkClickRelId(docPr),
+    };
+}
+function parseLockAspect(host) {
+    var locks = findFirstElement(host, A_NS, 'graphicFrameLocks');
+    if (locks === undefined) {
+        return false;
+    }
+    return parseOnOff(attributeValue(locks, '', 'noChangeAspect'));
+}
+function parsePosOffset(parent) {
+    if (parent === undefined) {
+        return undefined;
+    }
+    var offset = elementChildren(parent).find(function (c) { return isElement(c, WP_NS, 'posOffset'); });
+    if (offset === undefined) {
+        return undefined;
+    }
+    var raw = textContent(offset).trim();
+    if (!/^-?\d+$/.test(raw)) {
+        return undefined;
+    }
+    return emuToPoint(Number.parseInt(raw, 10));
+}
+function parseAlignChild(parent, axis) {
+    if (parent === undefined) {
+        return undefined;
+    }
+    var alignEl = elementChildren(parent).find(function (c) { return isElement(c, WP_NS, 'align'); });
+    if (alignEl === undefined) {
+        return undefined;
+    }
+    var raw = textContent(alignEl).trim();
+    if (axis === 'h') {
+        return isHorizontalAlignment(raw) ? raw : undefined;
+    }
+    return isVerticalAlignment(raw) ? raw : undefined;
+}
+function parseWrapping(host, placement) {
+    if (placement === PicturePlacement.Inline) {
+        return TextWrappingStyle.Inline;
+    }
+    if (findFirstElement(host, WP_NS, 'wrapNone') !== undefined) {
+        return TextWrappingStyle.None;
+    }
+    if (findFirstElement(host, WP_NS, 'wrapSquare') !== undefined) {
+        return TextWrappingStyle.Square;
+    }
+    if (findFirstElement(host, WP_NS, 'wrapTight') !== undefined) {
+        return TextWrappingStyle.Tight;
+    }
+    if (findFirstElement(host, WP_NS, 'wrapThrough') !== undefined) {
+        return TextWrappingStyle.Through;
+    }
+    if (findFirstElement(host, WP_NS, 'wrapTopAndBottom') !== undefined) {
+        return TextWrappingStyle.TopAndBottom;
+    }
+    return TextWrappingStyle.None;
+}
+/**
+ * Decode a picture `w:drawing` (inline or anchor with `a:blip` embed).
+ *
+ * @private
+ */
+export function decodePictureHost(drawing) {
+    var __ts33_5;
+    if (!isWml(drawing, 'drawing')) {
+        return undefined;
+    }
+    var blip = findFirstElement(drawing, A_NS, 'blip');
+    if (blip === undefined) {
+        return undefined;
+    }
+    var embed = attributeValue(blip, R_NS, 'embed');
+    if (embed === undefined || embed.length === 0) {
+        return undefined;
+    }
+    var inline = findFirstElement(drawing, WP_NS, 'inline');
+    var anchor = findFirstElement(drawing, WP_NS, 'anchor');
+    var host = inline != null ? inline : anchor;
+    if (host === undefined) {
+        return undefined;
+    }
+    var placement = inline !== undefined ? PicturePlacement.Inline : PicturePlacement.Anchored;
+    var extent = findFirstElement(host, WP_NS, 'extent');
+    if (extent === undefined) {
+        return undefined;
+    }
+    var cxRaw = attributeValue(extent, '', 'cx');
+    var cyRaw = attributeValue(extent, '', 'cy');
+    // cx/cy=0 is invalid for DrawingML extents; keep the drawing opaque for round-trip.
+    if (cxRaw === undefined ||
+        cyRaw === undefined ||
+        !/^\d+$/.test(cxRaw) ||
+        !/^\d+$/.test(cyRaw) ||
+        cxRaw === '0' ||
+        cyRaw === '0') {
+        return undefined;
+    }
+    var positionH = findFirstElement(host, WP_NS, 'positionH');
+    var positionV = findFirstElement(host, WP_NS, 'positionV');
+    var hOriginRaw = positionH !== undefined ? attributeValue(positionH, '', 'relativeFrom') : undefined;
+    var vOriginRaw = positionV !== undefined ? attributeValue(positionV, '', 'relativeFrom') : undefined;
+    var pic = ((__ts33_5 = findFirstElement(drawing, PIC_NS, 'pic')), __ts33_5 != null ? __ts33_5 : drawing);
+    var xfrm = parseXfrm(pic);
+    var docPr = parseDocPr(host);
+    var cNvPr = findFirstElement(pic, PIC_NS, 'cNvPr');
+    var hyperlinkRelationshipId = docPr.hyperlinkRelationshipId != null
+        ? docPr.hyperlinkRelationshipId
+        : parseHlinkClickRelId(cNvPr);
+    return {
+        placement: placement,
+        wrapping: parseWrapping(host, placement),
+        widthEmu: emus(Number.parseInt(cxRaw, 10)),
+        heightEmu: emus(Number.parseInt(cyRaw, 10)),
+        relationshipId: embed,
+        name: docPr.name,
+        title: docPr.title,
+        description: docPr.description,
+        lockAspectRatio: parseLockAspect(host),
+        rotation: xfrm.rotation,
+        flipHorizontal: xfrm.flipHorizontal,
+        flipVertical: xfrm.flipVertical,
+        horizontalOrigin: hOriginRaw !== undefined && isHorizontalOrigin(hOriginRaw) ? hOriginRaw : undefined,
+        verticalOrigin: vOriginRaw !== undefined && isVerticalOrigin(vOriginRaw) ? vOriginRaw : undefined,
+        horizontalPosition: parsePosOffset(positionH),
+        verticalPosition: parsePosOffset(positionV),
+        horizontalAlignment: parseAlignChild(positionH, 'h'),
+        verticalAlignment: parseAlignChild(positionV, 'v'),
+        docPrId: docPr.id,
+        hyperlinkRelationshipId: hyperlinkRelationshipId,
+        preservedHost: drawing,
+    };
+}
+function buildHlinkClick(relationshipId) {
+    return xmlElement(A_NS, 'a', 'hlinkClick', {
+        attributes: [attr('id', relationshipId, R_NS, 'r')],
+        children: [],
+        namespaceDeclarations: [],
+    });
+}
+function buildDocPr(input) {
+    var attributes = [
+        attr('id', String(input.docPrId)),
+        attr('name', input.name),
+    ];
+    if (input.description !== undefined && input.description.length > 0) {
+        attributes.push(attr('descr', input.description));
+    }
+    if (input.title !== undefined && input.title.length > 0) {
+        attributes.push(attr('title', input.title));
+    }
+    var children = [];
+    if (input.hyperlinkRelationshipId !== undefined && input.hyperlinkRelationshipId.length > 0) {
+        children.push(buildHlinkClick(input.hyperlinkRelationshipId));
+    }
+    return xmlElement(WP_NS, 'wp', 'docPr', { attributes: attributes, children: children });
+}
+function buildEffectExtent() {
+    return xmlElement(WP_NS, 'wp', 'effectExtent', {
+        attributes: [attr('l', '0'), attr('t', '0'), attr('r', '0'), attr('b', '0')],
+    });
+}
+function buildCNvGraphicFramePr(lockAspectRatio) {
+    var lockAttrs = lockAspectRatio
+        ? [attr('noChangeAspect', '1')]
+        : [];
+    return xmlElement(WP_NS, 'wp', 'cNvGraphicFramePr', {
+        children: [
+            xmlElement(A_NS, 'a', 'graphicFrameLocks', {
+                attributes: lockAttrs,
+            }),
+        ],
+    });
+}
+function buildPic(input) {
+    var xfrmAttrs = [];
+    if (input.rotation !== 0) {
+        xfrmAttrs.push(attr('rot', String(Math.round(input.rotation * ROTATION_UNITS_PER_DEGREE))));
+    }
+    if (input.flipHorizontal) {
+        xfrmAttrs.push(attr('flipH', '1'));
+    }
+    if (input.flipVertical) {
+        xfrmAttrs.push(attr('flipV', '1'));
+    }
+    var blipFill = xmlElement(PIC_NS, 'pic', 'blipFill', {
+        children: [
+            xmlElement(A_NS, 'a', 'blip', { attributes: [blipEmbedAttribute(input.relationshipId)] }),
+            xmlElement(A_NS, 'a', 'stretch', {
+                children: [xmlElement(A_NS, 'a', 'fillRect')],
+            }),
+        ],
+    });
+    var spPr = xmlElement(PIC_NS, 'pic', 'spPr', {
+        children: [
+            xmlElement(A_NS, 'a', 'xfrm', {
+                attributes: xfrmAttrs,
+                children: [
+                    xmlElement(A_NS, 'a', 'off', {
+                        attributes: [attr('x', '0'), attr('y', '0')],
+                    }),
+                    xmlElement(A_NS, 'a', 'ext', {
+                        attributes: extentAttributes(input.widthEmu, input.heightEmu),
+                    }),
+                ],
+            }),
+            xmlElement(A_NS, 'a', 'prstGeom', {
+                attributes: [attr('prst', 'rect')],
+                children: [xmlElement(A_NS, 'a', 'avLst')],
+            }),
+        ],
+    });
+    return xmlElement(PIC_NS, 'pic', 'pic', {
+        namespaceDeclarations: [
+            { prefix: 'pic', namespaceUri: PIC_NS },
+            { prefix: 'a', namespaceUri: A_NS },
+            { prefix: 'r', namespaceUri: R_NS },
+        ],
+        children: [
+            xmlElement(PIC_NS, 'pic', 'nvPicPr', {
+                children: [
+                    xmlElement(PIC_NS, 'pic', 'cNvPr', {
+                        attributes: [attr('id', '0'), attr('name', input.name)],
+                        children: (input.hyperlinkRelationshipId !== undefined && input.hyperlinkRelationshipId.length > 0)
+                            ? [buildHlinkClick(input.hyperlinkRelationshipId)]
+                            : [],
+                    }),
+                    xmlElement(PIC_NS, 'pic', 'cNvPicPr'),
+                ],
+            }),
+            blipFill,
+            spPr,
+        ],
+    });
+}
+function buildGraphic(input) {
+    return xmlElement(A_NS, 'a', 'graphic', {
+        children: [
+            xmlElement(A_NS, 'a', 'graphicData', {
+                attributes: [attr('uri', PICTURE_GRAPHIC_DATA_URI)],
+                children: [buildPic(input)],
+            }),
+        ],
+    });
+}
+function buildPositionH(input) {
+    var origin = input.horizontalOrigin;
+    var child;
+    if (input.horizontalAlignment !== undefined) {
+        child = xmlElement(WP_NS, 'wp', 'align', {
+            children: [{ kind: 'text', value: input.horizontalAlignment }],
+        });
+    }
+    else {
+        // posOffset is a coordinate (0 / negative allowed), not an extent.
+        var emu = input.horizontalPosition !== undefined
+            ? pointToCoordinateEmus(input.horizontalPosition)
+            : 0;
+        child = xmlElement(WP_NS, 'wp', 'posOffset', {
+            children: [{ kind: 'text', value: String(emu) }],
+        });
+    }
+    return xmlElement(WP_NS, 'wp', 'positionH', {
+        attributes: [attr('relativeFrom', origin)],
+        children: [child],
+    });
+}
+function buildPositionV(input) {
+    var origin = input.verticalOrigin;
+    var child;
+    if (input.verticalAlignment !== undefined) {
+        child = xmlElement(WP_NS, 'wp', 'align', {
+            children: [{ kind: 'text', value: input.verticalAlignment }],
+        });
+    }
+    else {
+        // posOffset is a coordinate (0 / negative allowed), not an extent.
+        var emu = input.verticalPosition !== undefined
+            ? pointToCoordinateEmus(input.verticalPosition)
+            : 0;
+        child = xmlElement(WP_NS, 'wp', 'posOffset', {
+            children: [{ kind: 'text', value: String(emu) }],
+        });
+    }
+    return xmlElement(WP_NS, 'wp', 'positionV', {
+        attributes: [attr('relativeFrom', origin)],
+        children: [child],
+    });
+}
+/**
+ * Build wrap element from modeled style.
+ * tight/through require wrapPolygon; without residual, fall back is not invented —
+ * callers should only dirty-author rectangular wraps unless residual provides polygon.
+ */
+function buildWrapElement(wrapping, residualWrap) {
+    if (residualWrap !== undefined &&
+        ((wrapping === TextWrappingStyle.Tight && residualWrap.localName === 'wrapTight') ||
+            (wrapping === TextWrappingStyle.Through && residualWrap.localName === 'wrapThrough') ||
+            (wrapping === TextWrappingStyle.Square && residualWrap.localName === 'wrapSquare') ||
+            (wrapping === TextWrappingStyle.None && residualWrap.localName === 'wrapNone') ||
+            (wrapping === TextWrappingStyle.TopAndBottom &&
+                residualWrap.localName === 'wrapTopAndBottom'))) {
+        return residualWrap;
+    }
+    switch (wrapping) {
+        case TextWrappingStyle.None:
+            return xmlElement(WP_NS, 'wp', 'wrapNone');
+        case TextWrappingStyle.Square:
+            return xmlElement(WP_NS, 'wp', 'wrapSquare', {
+                attributes: [attr('wrapText', 'bothSides')],
+            });
+        case TextWrappingStyle.TopAndBottom:
+            return xmlElement(WP_NS, 'wp', 'wrapTopAndBottom');
+        case TextWrappingStyle.Tight:
+            // Prefer residual polygon; without citeable default polygon, emit residual or square-safe fallback
+            if (residualWrap !== undefined && residualWrap.localName === 'wrapTight') {
+                return residualWrap;
+            }
+            // Authoring tight without polygon is not schema-complete; keep residual if any wrapTight
+            return residualWrap != null ? residualWrap : xmlElement(WP_NS, 'wp', 'wrapNone');
+        case TextWrappingStyle.Through:
+            if (residualWrap !== undefined && residualWrap.localName === 'wrapThrough') {
+                return residualWrap;
+            }
+            return residualWrap != null ? residualWrap : xmlElement(WP_NS, 'wp', 'wrapNone');
+        default:
+            return xmlElement(WP_NS, 'wp', 'wrapNone');
+    }
+}
+function findResidualWrap(anchor) {
+    var e_4, _a;
+    if (anchor === undefined) {
+        return undefined;
+    }
+    var _loop_1 = function (name_1) {
+        var found = elementChildren(anchor).find(function (c) { return isElement(c, WP_NS, name_1); });
+        if (found !== undefined) {
+            return { value: found };
+        }
+    };
+    try {
+        for (var _b = __values([
+            'wrapNone',
+            'wrapSquare',
+            'wrapTight',
+            'wrapThrough',
+            'wrapTopAndBottom',
+        ]), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var name_1 = _c.value;
+            var state_1 = _loop_1(name_1);
+            if (typeof state_1 === "object")
+                return state_1.value;
+        }
+    }
+    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; }
+    }
+    return undefined;
+}
+function findResidualEffectExtent(host) {
+    if (host === undefined) {
+        return undefined;
+    }
+    return elementChildren(host).find(function (c) { return isElement(c, WP_NS, 'effectExtent'); });
+}
+function copyElementAttrs(source, localNames) {
+    var e_5, _a;
+    if (source === undefined) {
+        return [];
+    }
+    var out = [];
+    try {
+        for (var localNames_1 = __values(localNames), localNames_1_1 = localNames_1.next(); !localNames_1_1.done; localNames_1_1 = localNames_1.next()) {
+            var name_2 = localNames_1_1.value;
+            var value = attributeValue(source, '', name_2);
+            if (value !== undefined) {
+                out.push(attr(name_2, value));
+            }
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (localNames_1_1 && !localNames_1_1.done && (_a = localNames_1.return)) _a.call(localNames_1);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return out;
+}
+function buildInlineHost(input) {
+    var __ts33_6;
+    var preservedInline = input.preservedHost !== undefined
+        ? findFirstElement(input.preservedHost, WP_NS, 'inline')
+        : undefined;
+    var effect = ((__ts33_6 = findResidualEffectExtent(preservedInline)), __ts33_6 != null ? __ts33_6 : buildEffectExtent());
+    return xmlElement(WP_NS, 'wp', 'inline', {
+        namespaceDeclarations: [
+            { prefix: 'wp', namespaceUri: WP_NS },
+            { prefix: 'a', namespaceUri: A_NS },
+            { prefix: 'pic', namespaceUri: PIC_NS },
+            { prefix: 'r', namespaceUri: R_NS },
+        ],
+        attributes: [
+            attr('distT', '0'),
+            attr('distB', '0'),
+            attr('distL', '0'),
+            attr('distR', '0'),
+        ],
+        children: [
+            xmlElement(WP_NS, 'wp', 'extent', {
+                attributes: extentAttributes(input.widthEmu, input.heightEmu),
+            }),
+            effect,
+            buildDocPr(input),
+            buildCNvGraphicFramePr(input.lockAspectRatio),
+            buildGraphic(input),
+        ],
+    });
+}
+function buildAnchoredHost(input) {
+    var __ts33_7;
+    var preservedAnchor = input.preservedHost !== undefined
+        ? findFirstElement(input.preservedHost, WP_NS, 'anchor')
+        : undefined;
+    var defaultAttrs = [
+        attr('distT', '0'),
+        attr('distB', '0'),
+        attr('distL', '114300'),
+        attr('distR', '114300'),
+        attr('simplePos', '0'),
+        attr('relativeHeight', '251658240'),
+        attr('behindDoc', '0'),
+        attr('locked', '0'),
+        attr('layoutInCell', '1'),
+        attr('allowOverlap', '1'),
+    ];
+    var preservedAttrs = copyElementAttrs(preservedAnchor, [
+        'distT',
+        'distB',
+        'distL',
+        'distR',
+        'simplePos',
+        'relativeHeight',
+        'behindDoc',
+        'locked',
+        'layoutInCell',
+        'allowOverlap',
+        'hidden',
+    ]);
+    var attrs = preservedAttrs.length > 0 ? preservedAttrs : defaultAttrs;
+    var residualWrap = findResidualWrap(preservedAnchor);
+    var residualEffect = ((__ts33_7 = findResidualEffectExtent(preservedAnchor)), __ts33_7 != null ? __ts33_7 : buildEffectExtent());
+    var residualSimplePos = preservedAnchor
+        ? elementChildren(preservedAnchor).find(function (c) { return isElement(c, WP_NS, 'simplePos'); })
+        : undefined;
+    var useModeledLayout = input.layoutDirty || preservedAnchor === undefined;
+    var simplePos;
+    var positionH;
+    var positionV;
+    var wrap;
+    if (useModeledLayout) {
+        simplePos = residualSimplePos != null ? residualSimplePos : xmlElement(WP_NS, 'wp', 'simplePos', {
+            attributes: [attr('x', '0'), attr('y', '0')],
+        });
+        positionH = buildPositionH(input);
+        positionV = buildPositionV(input);
+        wrap = buildWrapElement(input.wrapping === TextWrappingStyle.Inline ? TextWrappingStyle.None : input.wrapping, residualWrap);
+    }
+    else {
+        var ph = elementChildren(preservedAnchor).find(function (c) { return isElement(c, WP_NS, 'positionH'); });
+        var pv = elementChildren(preservedAnchor).find(function (c) { return isElement(c, WP_NS, 'positionV'); });
+        simplePos = residualSimplePos != null ? residualSimplePos : xmlElement(WP_NS, 'wp', 'simplePos', {
+            attributes: [attr('x', '0'), attr('y', '0')],
+        });
+        positionH = ph != null ? ph : xmlElement(WP_NS, 'wp', 'positionH', {
+            attributes: [attr('relativeFrom', HorizontalOrigin.Column)],
+            children: [
+                xmlElement(WP_NS, 'wp', 'posOffset', { children: [{ kind: 'text', value: '0' }] }),
+            ],
+        });
+        positionV = pv != null ? pv : xmlElement(WP_NS, 'wp', 'positionV', {
+            attributes: [attr('relativeFrom', VerticalOrigin.Paragraph)],
+            children: [
+                xmlElement(WP_NS, 'wp', 'posOffset', { children: [{ kind: 'text', value: '0' }] }),
+            ],
+        });
+        wrap = residualWrap != null ? residualWrap : xmlElement(WP_NS, 'wp', 'wrapNone');
+    }
+    return xmlElement(WP_NS, 'wp', 'anchor', {
+        namespaceDeclarations: [
+            { prefix: 'wp', namespaceUri: WP_NS },
+            { prefix: 'a', namespaceUri: A_NS },
+            { prefix: 'pic', namespaceUri: PIC_NS },
+            { prefix: 'r', namespaceUri: R_NS },
+        ],
+        attributes: attrs,
+        children: [
+            simplePos,
+            positionH,
+            positionV,
+            xmlElement(WP_NS, 'wp', 'extent', {
+                attributes: extentAttributes(input.widthEmu, input.heightEmu),
+            }),
+            residualEffect,
+            wrap,
+            buildDocPr(input),
+            buildCNvGraphicFramePr(input.lockAspectRatio),
+            buildGraphic(input),
+        ],
+    });
+}
+/**
+ * Encode a modeled picture host into `w:drawing`.
+ *
+ * @private
+ */
+export function encodePictureHost(input) {
+    if (input.relationshipId.length === 0) {
+        throw new Error('encodePictureHost: relationship id is not materialized');
+    }
+    var host = input.placement === PicturePlacement.Anchored ||
+        input.wrapping !== TextWrappingStyle.Inline
+        ? buildAnchoredHost(__assign({}, input, { placement: PicturePlacement.Anchored, wrapping: input.wrapping === TextWrappingStyle.Inline
+                ? TextWrappingStyle.None
+                : input.wrapping }))
+        : buildInlineHost(input);
+    return wmlElement('drawing', { children: [host] });
+}
+/**
+ * Whether wrapping requires an anchor host.
+ *
+ * @private
+ */
+export function wrappingRequiresAnchor(wrapping) {
+    return wrapping !== TextWrappingStyle.Inline;
+}