@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

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

@@ -0,0 +1,2595 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+import { parseBodyBlocks, serializeBodyBlocks } from '../document/body-blocks';
+import { emuToPoint } from '../document/length';
+import { isWml, WML, wmlElement } from '../document/wml';
+import { MARKUP_COMPATIBILITY_NAMESPACE } from '../../core/mc/index';
+import { HorizontalAlignment, HorizontalOrigin, TextWrappingStyle, TextWrappingType, VerticalAlignment, VerticalOrigin, isHorizontalAlignmentWire, isVerticalAlignmentWire, isHorizontalOrigin, isVerticalOrigin, isTextWrappingTypeWire } from '../images/layout-types';
+import { buildFillElement, buildLineElement, findSpPrElement } from './sp-pr';
+/**
+ * @private
+ */
+export var WP_NS = 'http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing';
+/**
+ * @private
+ */
+export var A_NS = 'http://schemas.openxmlformats.org/drawingml/2006/main';
+/**
+ * @private
+ */
+export var R_NS = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+/**
+ * @private
+ */
+export var WPS_NS = 'http://schemas.microsoft.com/office/word/2010/wordprocessingShape';
+/**
+ * @private
+ */
+export var WPG_NS = 'http://schemas.microsoft.com/office/word/2010/wordprocessingGroup';
+/**
+ * @private
+ */
+export var WPC_NS = 'http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas';
+/**
+ * @private
+ */
+export var VML_NS = 'urn:schemas-microsoft-com:vml';
+/**
+ * Word VML extensions namespace (`vml-wordprocessingDrawing.xsd` targetNamespace).
+ * Used for `w10:wrap` / `w10:anchorlock` on authored Fallback shapes.
+ *
+ * @private
+ */
+export var W10_NS = 'urn:schemas-microsoft-com:office:word';
+/**
+ * @private
+ */
+export var MC_NS = MARKUP_COMPATIBILITY_NAMESPACE;
+/** 914400 EMU = 1 inch; 12700 EMU = 1 pt. */
+var EMU_PER_POINT = 12700;
+/**
+ * ST_Angle: 60000ths of a degree (ECMA-376 DrawingML `dml-main` CT_Transform2D).
+ * Same unit as images host-codec; local copy avoids drawing→images encode coupling.
+ *
+ * @private
+ */
+export var ROTATION_UNITS_PER_DEGREE = 60000;
+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;
+}
+/**
+ * @private
+ */
+export 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;
+}
+/**
+ * @private
+ */
+export 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 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 cloneElement(el) {
+    return {
+        kind: 'element',
+        namespaceUri: el.namespaceUri,
+        localName: el.localName,
+        prefix: el.prefix,
+        attributes: el.attributes.map(function (a) { return (__assign({}, a)); }),
+        namespaceDeclarations: el.namespaceDeclarations.map(function (n) { return (__assign({}, n)); }),
+        children: el.children.map(function (c) {
+            if (c.kind === 'element') {
+                return cloneElement(c);
+            }
+            // OpenXmlChild is element | text only (src/core/xml/model.ts).
+            return { kind: 'text', value: c.value };
+        }),
+    };
+}
+function buildDocPr(input) {
+    var attributes = [
+        attr('id', String(input.docPrId)),
+        attr('name', input.name),
+    ];
+    if (input.title !== undefined && input.title.length > 0) {
+        attributes.push(attr('title', input.title));
+    }
+    if (input.description !== undefined && input.description.length > 0) {
+        attributes.push(attr('descr', input.description));
+    }
+    return xmlElement(WP_NS, 'wp', 'docPr', { attributes: attributes });
+}
+function buildEffectExtent() {
+    return xmlElement(WP_NS, 'wp', 'effectExtent', {
+        attributes: [attr('l', '0'), attr('t', '0'), attr('r', '0'), attr('b', '0')],
+    });
+}
+function buildXfrmAttributes(input) {
+    var xfrmAttrs = [];
+    // Omit @rot when 0 — Word/images convention (ST_Angle default).
+    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'));
+    }
+    return xfrmAttrs;
+}
+function buildXfrm(input) {
+    var rotation = input.rotation != null ? input.rotation : 0;
+    var flipHorizontal = input.flipHorizontal != null ? input.flipHorizontal : false;
+    var flipVertical = input.flipVertical != null ? input.flipVertical : false;
+    var off = xmlElement(A_NS, 'a', 'off', {
+        attributes: [attr('x', '0'), attr('y', '0')],
+    });
+    var ext = xmlElement(A_NS, 'a', 'ext', {
+        attributes: [attr('cx', String(input.widthEmu)), attr('cy', String(input.heightEmu))],
+    });
+    return xmlElement(A_NS, 'a', 'xfrm', {
+        attributes: buildXfrmAttributes({ rotation: rotation, flipHorizontal: flipHorizontal, flipVertical: flipVertical }),
+        children: [off, ext],
+    });
+}
+function buildCNvGraphicFramePr(lockAspectRatio) {
+    var lockAttrs = lockAspectRatio ? [attr('noChangeAspect', '1')] : [];
+    return xmlElement(WP_NS, 'wp', 'cNvGraphicFramePr', {
+        children: [
+            xmlElement(A_NS, 'a', 'graphicFrameLocks', {
+                attributes: lockAttrs,
+            }),
+        ],
+    });
+}
+/**
+ * Build `wps:spPr` children in `CT_ShapeProperties` schema order:
+ * `a:xfrm`, `EG_Geometry` (prstGeom + avLst), `EG_FillProperties` (residual
+ * preserved when unmodeled), `a:ln` (residual preserved when unmodeled), then
+ * residual bag (effects/scene3d/… — GO Q9 residual).
+ */
+function buildSpPrChildren(input, preservedSpPr) {
+    var e_2, _a, e_3, _b;
+    var children = [];
+    children.push(buildXfrm(input));
+    children.push(xmlElement(A_NS, 'a', 'prstGeom', {
+        attributes: [attr('prst', input.presetGeometry)],
+        children: [xmlElement(A_NS, 'a', 'avLst')],
+    }));
+    // Fill: modeled MVP wins; otherwise preserve the residual fill element.
+    if (input.fill !== undefined) {
+        children.push(buildFillElement(input.fill));
+    }
+    else
+        try {
+            for (var _c = __values(['noFill', 'solidFill', 'gradFill', 'blipFill', 'pattFill', 'grpFill']), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var localName = _d.value;
+                var residualFill = preservedSpPr !== undefined ? findSpPrElement(preservedSpPr, A_NS, localName) : undefined;
+                if (residualFill !== undefined) {
+                    children.push(residualFill);
+                    break;
+                }
+            }
+        }
+        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; }
+        }
+    // Line: modeled MVP wins; otherwise preserve the residual a:ln element.
+    if (input.line !== undefined) {
+        children.push(buildLineElement(input.line));
+    }
+    else if (preservedSpPr !== undefined) {
+        var residualLn = findSpPrElement(preservedSpPr, A_NS, 'ln');
+        if (residualLn !== undefined) {
+            children.push(residualLn);
+        }
+    }
+    // Residual bag: everything after geometry known to CT_ShapeProperties that
+    // the MVP does not model (effects, scene3d, sp3d, extLst) — GO Q9 deferred.
+    var residualTail = [];
+    if (preservedSpPr !== undefined) {
+        var modeledFillNames = new Set([
+            'noFill',
+            'solidFill',
+            'gradFill',
+            'blipFill',
+            'pattFill',
+            'grpFill',
+        ]);
+        try {
+            for (var _e = __values(elementChildrenOf(preservedSpPr)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var child = _f.value;
+                if (isElement(child, A_NS, 'xfrm') ||
+                    isElement(child, A_NS, 'prstGeom') ||
+                    isElement(child, A_NS, 'custGeom') ||
+                    (isElement(child, A_NS, 'ln') ||
+                        (child.namespaceUri === A_NS && modeledFillNames.has(child.localName)))) {
+                    continue;
+                }
+                residualTail.push(child);
+            }
+        }
+        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; }
+        }
+    }
+    children.push.apply(children, __spread(residualTail));
+    return children;
+}
+function elementChildrenOf(el) {
+    return el.children.filter(function (c) { return c.kind === 'element'; });
+}
+function buildWpsShape(input) {
+    var __ts33_4;
+    var preservedSpPr = findResidualSpPr(input.preservedHost);
+    var spPr = xmlElement(WPS_NS, 'wps', 'spPr', {
+        children: buildSpPrChildren(input, preservedSpPr),
+    });
+    // Text box marker (`CT_NonVisualDrawingShapeProps/@txBox`, default false) —
+    // Word sets it on text box shapes; detection itself keys off the
+    // `wps:txbx` child per [MS-ODRAWXML] §2.13.3.2.
+    var hasTxbx = input.txbxContent !== undefined || residualHasTxbx(input.preservedHost);
+    var cNvSpPr = xmlElement(WPS_NS, 'wps', 'cNvSpPr', {
+        attributes: hasTxbx ? [attr('txBox', '1')] : [],
+    });
+    // CT_WordprocessingShape order (wordprocessingShape.xsd): cNvSpPr?, spPr,
+    // style?, extLst?, (txbx|linkedTxbx)?, bodyPr (minOccurs 1). Preserve
+    // residual `wps:style` on structure rebuild so solid fill dirty does not
+    // drop theme refs (GO).
+    var residualStyle = input.preservedHost !== undefined
+        ? findFirstElement(input.preservedHost, WPS_NS, 'style')
+        : undefined;
+    var children = [cNvSpPr, spPr];
+    if (residualStyle !== undefined) {
+        children.push(cloneElement(residualStyle));
+    }
+    // Text box (TASK-8049): modeled txbxContent when provided; residual txbx
+    // cloned verbatim when the rebuild did not model the body (structure dirt
+    // from layout/wrap mutators must not drop textbox content). linkedTxbx is
+    // OOS (GO) — residual clone preserves it; author path never emits it.
+    var residualTxbx = input.preservedHost !== undefined
+        ? findFirstElement(input.preservedHost, WPS_NS, 'txbx')
+        : undefined;
+    var residualLinkedTxbx = input.preservedHost !== undefined
+        ? findFirstElement(input.preservedHost, WPS_NS, 'linkedTxbx')
+        : undefined;
+    if (input.txbxContent !== undefined) {
+        children.push(buildTxbxElement(input.txbxContent));
+    }
+    else if (residualTxbx !== undefined) {
+        children.push(cloneElement(residualTxbx));
+    }
+    else if (residualLinkedTxbx !== undefined) {
+        children.push(cloneElement(residualLinkedTxbx));
+    }
+    // bodyPr is schema-required (minOccurs 1). Modeled state wins; residual
+    // bodyPr is cloned when present; otherwise an empty element is authored
+    // (Word convention for a defaulted text body).
+    var residualBodyPr = input.preservedHost !== undefined
+        ? findFirstElement(input.preservedHost, WPS_NS, 'bodyPr')
+        : undefined;
+    children.push(((__ts33_4 = input.bodyPr != null ? input.bodyPr : residualBodyPr), __ts33_4 != null ? __ts33_4 : buildEmptyBodyPr()));
+    return xmlElement(WPS_NS, 'wps', 'wsp', {
+        namespaceDeclarations: [{ prefix: 'wps', namespaceUri: WPS_NS }],
+        children: children,
+    });
+}
+/** Empty `wps:bodyPr` (schema-required element with all-optional content). */
+function buildEmptyBodyPr() {
+    return xmlElement(WPS_NS, 'wps', 'bodyPr');
+}
+/**
+ * Locate the residual `wps:spPr` for fill/line preservation on rebuild.
+ * Residual hosts nest `wps:spPr` under dual MC / `w:drawing` / `wp:*` /
+ * `a:graphic` / `wps:wsp`, so lookup is deep.
+ *
+ * @private
+ */
+export function findResidualSpPr(preservedHost) {
+    if (preservedHost === undefined) {
+        return undefined;
+    }
+    return findFirstElement(preservedHost, WPS_NS, 'spPr');
+}
+/**
+ * Build `wps:txbx` (`CT_TextboxInfo`) from serialized `w:txbxContent` children.
+ *
+ * Schema: `CT_TextboxInfo` = sequence `txbxContent` (minOccurs 1) + optional
+ * `extLst`; optional `@id` (default 0). `w:txbxContent` is
+ * `EG_BlockLevelElts` minOccurs 1 — the body must not be empty (Word authors
+ * at least one `w:p`; go6 author minimum matches).
+ *
+ * Cites:
+ * `specs/schemas/xsd/OfficeOpenXML-XMLSchema-Transitional/dml-wordprocessingDrawing.xsd`
+ * `CT_TxbxContent` / `CT_TextboxInfo`.
+ *
+ * @private
+ */
+export function buildTxbxElement(contentChildren) {
+    return xmlElement(WPS_NS, 'wps', 'txbx', {
+        children: [
+            xmlElement(WML, 'w', 'txbxContent', {
+                namespaceDeclarations: [{ prefix: 'w', namespaceUri: WML }],
+                children: contentChildren,
+            }),
+        ],
+    });
+}
+/**
+ * Serialize modeled `w:txbxContent` block state into `txbxContent` element
+ * children. Modeled paragraphs/tables/SDTs emit their DOM form; residual
+ * blocks (opaque XML not owned by a registered feature) pass through verbatim
+ * — the library never invents block OOXML it does not model.
+ *
+ * @private
+ */
+export function serializeTxbxContentBlocks(blocks) {
+    return serializeBodyBlocks(blocks);
+}
+/**
+ * Parse `w:txbxContent` children into core block state.
+ *
+ * Uses the same `parseBodyBlocks` path as headers/footers and table cells:
+ * `w:p` → modeled `Paragraph`; `w:tbl` → modeled `Table` **only when the
+ * tables feature is registered**; `w:sdt` → modeled SDT **only when the
+ * content-controls feature is registered**; everything else (and any block
+ * whose feature is unregistered) stays residual-opaque — never dropped, never
+ * invented (GO Q6; offline policy).
+ *
+ * @private
+ */
+export function parseTxbxContentBlocks(txbxContent, ctx) {
+    return parseBodyBlocks(txbxContent.children, ctx);
+}
+/**
+ * Whether any `wps:wsp` under the host carries a `wps:txbx` (or `linkedTxbx`)
+ * child — deep walk so dual MC Choice branches resolve.
+ *
+ * @private
+ */
+export function residualHasTxbx(host) {
+    var e_4, _a;
+    if (host === undefined) {
+        return false;
+    }
+    var wsp = findFirstElement(host, WPS_NS, 'wsp');
+    if (wsp === undefined) {
+        return false;
+    }
+    try {
+        for (var _b = __values(elementChildren(wsp)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isElement(child, WPS_NS, 'txbx') ||
+                isElement(child, WPS_NS, 'linkedTxbx')) {
+                return true;
+            }
+        }
+    }
+    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 false;
+}
+/**
+ * Build top-level `wpg:wgp` group shape for graphicData (TASK-8051).
+ *
+ * Top-level wgp has no `cNvPr` (identity lives on `wp:docPr`). Nested groups
+ * use `wpg:grpSp` with `cNvPr` — authored via residual clone or nested
+ * structure paths, not this builder.
+ *
+ * Cites: [MS-ODRAWXML] §2.16.3.2 CT_WordprocessingGroup —
+ * `cNvGrpSpPr?`, `grpSpPr`, then `(wsp|grpSp|graphicFrame|contentPart|spTree)*`.
+ *
+ * @private
+ */
+export function buildWpgGroup(input) {
+    var children = input.groupChildElements != null ? input.groupChildElements : [];
+    var cNvGrpSpPr = xmlElement(WPG_NS, 'wpg', 'cNvGrpSpPr');
+    var xfrmChildren = [
+        xmlElement(A_NS, 'a', 'off', {
+            attributes: [attr('x', '0'), attr('y', '0')],
+        }),
+        xmlElement(A_NS, 'a', 'ext', {
+            attributes: [attr('cx', String(input.widthEmu)), attr('cy', String(input.heightEmu))],
+        }),
+        xmlElement(A_NS, 'a', 'chOff', {
+            attributes: [attr('x', '0'), attr('y', '0')],
+        }),
+        xmlElement(A_NS, 'a', 'chExt', {
+            attributes: [attr('cx', String(input.widthEmu)), attr('cy', String(input.heightEmu))],
+        }),
+    ];
+    var xfrmAttrs = [];
+    if (input.rotation !== undefined && input.rotation !== 0) {
+        // ST_Angle is 60000ths of a degree.
+        xfrmAttrs.push(attr('rot', String(Math.round(input.rotation * 60000))));
+    }
+    if (input.flipHorizontal === true) {
+        xfrmAttrs.push(attr('flipH', '1'));
+    }
+    if (input.flipVertical === true) {
+        xfrmAttrs.push(attr('flipV', '1'));
+    }
+    var xfrm = xmlElement(A_NS, 'a', 'xfrm', {
+        attributes: xfrmAttrs,
+        children: xfrmChildren,
+    });
+    var grpSpPr = xmlElement(WPG_NS, 'wpg', 'grpSpPr', {
+        children: [xfrm],
+    });
+    return xmlElement(WPG_NS, 'wpg', 'wgp', {
+        namespaceDeclarations: [{ prefix: 'wpg', namespaceUri: WPG_NS }],
+        children: __spread([cNvGrpSpPr, grpSpPr], children),
+    });
+}
+/**
+ * Build a nested bare `wps:wsp` for group/canvas children (TASK-8051).
+ * Carries `wps:cNvPr` identity after `wps:cNvSpPr` (fixture / Word order used
+ * by TASK-8051 tests). No dual AC wrapper — nested children are bare wsp.
+ *
+ * @private
+ */
+export function buildNestedWpsShape(input) {
+    var __ts33_5;
+    var preservedSpPr = findResidualSpPr(input.preservedHost);
+    var spPr = xmlElement(WPS_NS, 'wps', 'spPr', {
+        children: buildSpPrChildren(input, preservedSpPr),
+    });
+    var hasTxbx = input.txbxContent !== undefined || residualHasTxbx(input.preservedHost);
+    var cNvSpPr = xmlElement(WPS_NS, 'wps', 'cNvSpPr', {
+        attributes: hasTxbx ? [attr('txBox', '1')] : [],
+    });
+    // Nested identity: wps:cNvPr (id/name/title/descr). Fixture order is
+    // cNvSpPr then cNvPr (tests assert ChildA / NestedRect via these attrs).
+    var cNvPrAttrs = [
+        attr('id', String(input.docPrId)),
+        attr('name', input.name),
+    ];
+    if (input.title !== undefined && input.title.length > 0) {
+        cNvPrAttrs.push(attr('title', input.title));
+    }
+    if (input.description !== undefined && input.description.length > 0) {
+        cNvPrAttrs.push(attr('descr', input.description));
+    }
+    var cNvPr = xmlElement(WPS_NS, 'wps', 'cNvPr', {
+        attributes: cNvPrAttrs,
+    });
+    var residualStyle = input.preservedHost !== undefined
+        ? findFirstElement(input.preservedHost, WPS_NS, 'style')
+        : undefined;
+    // Match fixture child order: cNvSpPr, cNvPr, spPr, style?, txbx?, bodyPr.
+    var children = [cNvSpPr, cNvPr, spPr];
+    if (residualStyle !== undefined) {
+        children.push(cloneElement(residualStyle));
+    }
+    var residualTxbx = input.preservedHost !== undefined
+        ? findFirstElement(input.preservedHost, WPS_NS, 'txbx')
+        : undefined;
+    var residualLinkedTxbx = input.preservedHost !== undefined
+        ? findFirstElement(input.preservedHost, WPS_NS, 'linkedTxbx')
+        : undefined;
+    if (input.txbxContent !== undefined) {
+        children.push(buildTxbxElement(input.txbxContent));
+    }
+    else if (residualTxbx !== undefined) {
+        children.push(cloneElement(residualTxbx));
+    }
+    else if (residualLinkedTxbx !== undefined) {
+        children.push(cloneElement(residualLinkedTxbx));
+    }
+    var residualBodyPr = input.preservedHost !== undefined
+        ? findFirstElement(input.preservedHost, WPS_NS, 'bodyPr')
+        : undefined;
+    children.push(((__ts33_5 = input.bodyPr != null ? input.bodyPr : residualBodyPr), __ts33_5 != null ? __ts33_5 : buildEmptyBodyPr()));
+    return xmlElement(WPS_NS, 'wps', 'wsp', {
+        namespaceDeclarations: [{ prefix: 'wps', namespaceUri: WPS_NS }],
+        children: children,
+    });
+}
+function buildGraphic(input) {
+    if (input.groupChildElements !== undefined) {
+        var graphicData_1 = xmlElement(A_NS, 'a', 'graphicData', {
+            attributes: [attr('uri', WPG_NS)],
+            children: [buildWpgGroup(input)],
+        });
+        return xmlElement(A_NS, 'a', 'graphic', {
+            namespaceDeclarations: [{ prefix: 'a', namespaceUri: A_NS }],
+            children: [graphicData_1],
+        });
+    }
+    var graphicData = xmlElement(A_NS, 'a', 'graphicData', {
+        attributes: [attr('uri', WPS_NS)],
+        children: [buildWpsShape(input)],
+    });
+    return xmlElement(A_NS, 'a', 'graphic', {
+        namespaceDeclarations: [{ prefix: 'a', namespaceUri: A_NS }],
+        children: [graphicData],
+    });
+}
+/**
+ * Parse wrapping from residual host placement.
+ *
+ * @private
+ */
+export function parseDrawingWrapping(host, placement) {
+    if (placement === '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;
+}
+/**
+ * Parse `wp:wrapSquare|wrapTight|wrapThrough/@wrapText`.
+ * Absent → Both (schema default); wire token → token; other → Unknown.
+ *
+ * @private
+ */
+export function parseWrapTextAttr(wrapEl) {
+    if (wrapEl === undefined) {
+        return TextWrappingType.Both;
+    }
+    var raw = attributeValue(wrapEl, '', 'wrapText');
+    if (raw === undefined || raw.trim() === '') {
+        return TextWrappingType.Both;
+    }
+    var token = raw.trim();
+    if (isTextWrappingTypeWire(token)) {
+        return token;
+    }
+    return TextWrappingType.Unknown;
+}
+/**
+ * Whether residual wrap element already carries the modeled wire wrapText (or
+ * wrapText is not applicable / unmodeled / Unknown — keep residual as-is).
+ */
+function residualWrapTextMatches(residualWrap, wrapType) {
+    if (wrapType === undefined || wrapType === TextWrappingType.Unknown) {
+        return true;
+    }
+    if (!isTextWrappingTypeWire(wrapType)) {
+        return true;
+    }
+    // Styles without @wrapText never carry side type on wire.
+    if (residualWrap.localName === 'wrapNone' || residualWrap.localName === 'wrapTopAndBottom') {
+        return true;
+    }
+    var residualType = parseWrapTextAttr(residualWrap);
+    return residualType === wrapType;
+}
+/**
+ * Rebuild a residual wrap element with a corrected `@wrapText`, preserving
+ * children (e.g. wrapPolygon) and non-wrapText attributes.
+ */
+function rebuildWrapWithWrapText(residualWrap, wrapType) {
+    var e_5, _a;
+    var attributes = [];
+    var sawWrapText = false;
+    try {
+        for (var _b = __values(residualWrap.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var a = _c.value;
+            if (a.namespaceUri === '' && a.localName === 'wrapText') {
+                attributes.push(attr('wrapText', wrapType));
+                sawWrapText = true;
+            }
+            else {
+                attributes.push(__assign({}, a));
+            }
+        }
+    }
+    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; }
+    }
+    if (!sawWrapText) {
+        attributes.push(attr('wrapText', wrapType));
+    }
+    return {
+        kind: 'element',
+        namespaceUri: residualWrap.namespaceUri,
+        localName: residualWrap.localName,
+        prefix: residualWrap.prefix,
+        attributes: attributes,
+        namespaceDeclarations: residualWrap.namespaceDeclarations.map(function (n) { return (__assign({}, n)); }),
+        children: residualWrap.children.slice(),
+    };
+}
+/**
+ * Build wrap element from modeled style.
+ * Tight/through require wrapPolygon; without residual polygon, fall back to wrapNone
+ * (library does not invent polygons — images parity).
+ * When residual matches style but modeled wire wrapType differs, rebuild with
+ * corrected wrapText and preserve residual children/attrs.
+ *
+ * @private
+ */
+export function buildWrapElement(wrapping, residualWrap, wrapType) {
+    var residualMatchesStyle = 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'));
+    if (residualMatchesStyle && residualWrap !== undefined) {
+        if (residualWrapTextMatches(residualWrap, wrapType)) {
+            return residualWrap;
+        }
+        // Modeled schema wrapType differs from residual @wrapText — rebuild.
+        if (wrapType !== undefined && isTextWrappingTypeWire(wrapType) &&
+            (wrapping === TextWrappingStyle.Square ||
+                wrapping === TextWrappingStyle.Tight ||
+                wrapping === TextWrappingStyle.Through)) {
+            return rebuildWrapWithWrapText(residualWrap, wrapType);
+        }
+        return residualWrap;
+    }
+    var wireWrapText = wrapType !== undefined && isTextWrappingTypeWire(wrapType)
+        ? wrapType
+        : TextWrappingType.Both;
+    switch (wrapping) {
+        case TextWrappingStyle.None:
+            return xmlElement(WP_NS, 'wp', 'wrapNone');
+        case TextWrappingStyle.Square:
+            return xmlElement(WP_NS, 'wp', 'wrapSquare', {
+                attributes: [attr('wrapText', wireWrapText)],
+            });
+        case TextWrappingStyle.TopAndBottom:
+            return xmlElement(WP_NS, 'wp', 'wrapTopAndBottom');
+        case TextWrappingStyle.Tight:
+        case TextWrappingStyle.Through:
+            // CT_WrapPath requires wrapPolygon; library does not invent vertices.
+            return xmlElement(WP_NS, 'wp', 'wrapNone');
+        case TextWrappingStyle.Inline:
+            // Encode path never places Inline wrap on anchor (coerced earlier).
+            return xmlElement(WP_NS, 'wp', 'wrapNone');
+        default:
+            return xmlElement(WP_NS, 'wp', 'wrapNone');
+    }
+}
+function findResidualWrap(anchor) {
+    var e_6, _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_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    return undefined;
+}
+/**
+ * Locate residual `wp:positionH` / `wp:positionV` children of an anchor.
+ *
+ * Children are preserved as-is (unknown `@relativeFrom` tokens or extra
+ * position children stay byte-identical on rebuild that does not model them).
+ *
+ * @private
+ */
+export function findResidualPositions(anchor) {
+    if (anchor === undefined) {
+        return { positionH: undefined, positionV: undefined };
+    }
+    return {
+        positionH: elementChildren(anchor).find(function (c) { return isElement(c, WP_NS, 'positionH'); }),
+        positionV: elementChildren(anchor).find(function (c) { return isElement(c, WP_NS, 'positionV'); }),
+    };
+}
+function findResidualEffectExtent(host) {
+    if (host === undefined) {
+        return undefined;
+    }
+    return elementChildren(host).find(function (c) { return isElement(c, WP_NS, 'effectExtent'); });
+}
+/**
+ * Whether the host carries a local-name attribute with numeric (possibly
+ * negative) integer content — used to detect residual host attrs without
+ * parsing semantics.
+ */
+/**
+ * Build `wp:positionH` for a new anchor when residual position is absent.
+ * Images parity default: `relativeFrom="column"` + `posOffset 0`.
+ */
+function buildDefaultPositionH() {
+    return xmlElement(WP_NS, 'wp', 'positionH', {
+        attributes: [attr('relativeFrom', HorizontalOrigin.Column)],
+        children: [
+            xmlElement(WP_NS, 'wp', 'posOffset', { children: [{ kind: 'text', value: '0' }] }),
+        ],
+    });
+}
+/**
+ * Build `wp:positionV` for a new anchor when residual position is absent.
+ * Images parity default: `relativeFrom="paragraph"` + `posOffset 0`.
+ */
+function buildDefaultPositionV() {
+    return xmlElement(WP_NS, 'wp', 'positionV', {
+        attributes: [attr('relativeFrom', VerticalOrigin.Paragraph)],
+        children: [
+            xmlElement(WP_NS, 'wp', 'posOffset', { children: [{ kind: 'text', value: '0' }] }),
+        ],
+    });
+}
+/**
+ * Build modeled `wp:positionH` (`CT_PosH`).
+ *
+ * Tokens: `ST_RelFromH` / `ST_AlignH` are imported, not invented (GO Q1 —
+ * `src/features/images/layout-types.ts`). Align XOR posOffset follows the
+ * `CT_PosH` schema choice. `ST_PositionOffset` is `xsd:int` (negative EMU
+ * legal). Default origin `'column'`; offset default `0` (images parity).
+ *
+ * @private
+ */
+export function buildDrawingPositionH(input) {
+    var origin = input.horizontalOrigin !== undefined ? input.horizontalOrigin : HorizontalOrigin.Column;
+    var child;
+    // Only schema ST_AlignH tokens serialize as wp:align. Model-only None/Unknown use posOffset.
+    if (input.horizontalAlignment !== undefined && isHorizontalAlignmentWire(input.horizontalAlignment)) {
+        child = xmlElement(WP_NS, 'wp', 'align', {
+            children: [{ kind: 'text', value: input.horizontalAlignment }],
+        });
+    }
+    else {
+        child = xmlElement(WP_NS, 'wp', 'posOffset', {
+            children: [{ kind: 'text', value: String(input.horizontalPositionEmu != null ? input.horizontalPositionEmu : 0) }],
+        });
+    }
+    return xmlElement(WP_NS, 'wp', 'positionH', {
+        attributes: [attr('relativeFrom', origin)],
+        children: [child],
+    });
+}
+/**
+ * Build modeled `wp:positionV` (`CT_PosV`). Default origin `'paragraph'`;
+ * offset default `0` (images parity).
+ *
+ * @private
+ */
+export function buildDrawingPositionV(input) {
+    var origin = input.verticalOrigin !== undefined ? input.verticalOrigin : VerticalOrigin.Paragraph;
+    var child;
+    // Only schema ST_AlignV tokens serialize as wp:align. Model-only None/Unknown use posOffset.
+    if (input.verticalAlignment !== undefined && isVerticalAlignmentWire(input.verticalAlignment)) {
+        child = xmlElement(WP_NS, 'wp', 'align', {
+            children: [{ kind: 'text', value: input.verticalAlignment }],
+        });
+    }
+    else {
+        child = xmlElement(WP_NS, 'wp', 'posOffset', {
+            children: [{ kind: 'text', value: String(input.verticalPositionEmu != null ? input.verticalPositionEmu : 0) }],
+        });
+    }
+    return xmlElement(WP_NS, 'wp', 'positionV', {
+        attributes: [attr('relativeFrom', origin)],
+        children: [child],
+    });
+}
+function copyElementAttrs(source, localNames) {
+    var e_7, _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_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (localNames_1_1 && !localNames_1_1.done && (_a = localNames_1.return)) _a.call(localNames_1);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    return out;
+}
+function parseEmuAttr(host, localName) {
+    var raw = attributeValue(host, '', localName);
+    if (raw === undefined || !/^\d+$/.test(raw)) {
+        return undefined;
+    }
+    return Number.parseInt(raw, 10);
+}
+function parseOnOffAttr(host, localName) {
+    var raw = attributeValue(host, '', localName);
+    return raw === '1' || raw === 'true';
+}
+function textContent(el) {
+    var e_8, _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_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    return out;
+}
+/**
+ * Parse `wp:posOffset`/`wp:align` under `wp:positionH|V`.
+ *
+ * Cites: `CT_PosH`/`CT_PosV` — exactly one of `align` or `posOffset`
+ * (`ST_PositionOffset` = `xsd:int`, so negative EMU is legal);
+ * `ST_AlignH`/`ST_AlignV` token sets —
+ * `specs/schemas/xsd/OfficeOpenXML-XMLSchema-Transitional/dml-wordprocessingDrawing.xsd`.
+ * Unknown align tokens are dropped from the typed model (never re-written).
+ */
+function parsePosOffsetRawEmu(position) {
+    if (position === undefined) {
+        return undefined;
+    }
+    var offset = elementChildren(position).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 Number.parseInt(raw, 10);
+}
+/** Point form of the parsed `wp:posOffset` EMU (undefined when absent or negative). */
+function parsePosOffsetEmu(position) {
+    var emu = parsePosOffsetRawEmu(position);
+    // Point is a non-negative brand (images parity). Negative offsets are legal
+    // on the wire (ST_PositionOffset = xsd:int) but unrepresentable;
+    // the raw element is preserved for round-trip (see findResidualPositions).
+    return emu !== undefined && emu >= 0 ? emuToPoint(emu) : undefined;
+}
+/**
+ * Parse `wp:align` on positionH/positionV.
+ * No position -> undefined (caller). No align child -> None (posOffset axis).
+ * Schema wire token -> token. Unrecognized residual token -> Unknown.
+ * Never returns undefined for a present position element.
+ */
+function parseAlignChild(position, axis) {
+    if (position === undefined) {
+        return undefined;
+    }
+    var alignEl = elementChildren(position).find(function (c) { return isElement(c, WP_NS, 'align'); });
+    if (alignEl === undefined) {
+        return axis === 'h' ? HorizontalAlignment.None : VerticalAlignment.None;
+    }
+    var raw = textContent(alignEl).trim();
+    if (axis === 'h') {
+        if (isHorizontalAlignmentWire(raw)) {
+            return raw;
+        }
+        return HorizontalAlignment.Unknown;
+    }
+    if (isVerticalAlignmentWire(raw)) {
+        return raw;
+    }
+    return VerticalAlignment.Unknown;
+}
+/**
+ * Read wrapping, distances, behindDoc, and preset geometry from residual DrawingML.
+ *
+ * @private
+ */
+export function readDrawingWrapState(residual) {
+    var __ts33_6;
+    var drawing = ((__ts33_6 = preferredDrawingElement(residual)), __ts33_6 != null ? __ts33_6 : residual);
+    var inline = findFirstElement(drawing, WP_NS, 'inline');
+    var anchor = findFirstElement(drawing, WP_NS, 'anchor');
+    var host = inline != null ? inline : anchor;
+    var placement = inline !== undefined ? 'inline' : anchor !== undefined ? 'anchor' : undefined;
+    var wrapping = host !== undefined && placement !== undefined
+        ? parseDrawingWrapping(host, placement)
+        : TextWrappingStyle.None;
+    var residualWrap = host !== undefined ? findResidualWrap(host) : undefined;
+    var wrapType = wrapping === TextWrappingStyle.Square ||
+        wrapping === TextWrappingStyle.Tight ||
+        wrapping === TextWrappingStyle.Through
+        ? parseWrapTextAttr(residualWrap)
+        : TextWrappingType.Both;
+    var prstGeom = findFirstElement(drawing, A_NS, 'prstGeom');
+    var presetGeometry = prstGeom !== undefined ? attributeValue(prstGeom, '', 'prst') : undefined;
+    var anchorBooleans = {
+        behindDocument: placement === 'anchor' && host !== undefined
+            ? parseOnOffAttr(host, 'behindDoc')
+            : false,
+        lockAnchor: placement === 'anchor' && host !== undefined
+            ? parseOnOffAttr(host, 'locked')
+            : false,
+        allowOverlap: placement === 'anchor' && host !== undefined
+            ? parseOnOffAttr(host, 'allowOverlap')
+            : false,
+        layoutInCell: placement === 'anchor' && host !== undefined
+            ? parseOnOffAttr(host, 'layoutInCell')
+            : false,
+    };
+    if (host === undefined) {
+        return __assign({ placement: placement,
+            wrapping: wrapping, wrapType: TextWrappingType.Both, distanceTopEmu: undefined, distanceBottomEmu: undefined, distanceLeftEmu: undefined, distanceRightEmu: undefined }, anchorBooleans, { presetGeometry: presetGeometry });
+    }
+    return __assign({ placement: placement,
+        wrapping: wrapping,
+        wrapType: wrapType, distanceTopEmu: parseEmuAttr(host, 'distT'), distanceBottomEmu: parseEmuAttr(host, 'distB'), distanceLeftEmu: parseEmuAttr(host, 'distL'), distanceRightEmu: parseEmuAttr(host, 'distR') }, anchorBooleans, { presetGeometry: presetGeometry });
+}
+/**
+ * Read `wp:positionH` / `wp:positionV` from residual DrawingML.
+ *
+ * Tokens are validated against images `layout-types` sets (GO Q1 import);
+ * unknown `@relativeFrom` or align text is dropped (not preserved into the
+ * typed model) so the encoder never writes an invented token.
+ *
+ * @private
+ */
+export function readDrawingPositionState(residual) {
+    var __ts33_7;
+    var drawing = ((__ts33_7 = preferredDrawingElement(residual)), __ts33_7 != null ? __ts33_7 : residual);
+    var inline = findFirstElement(drawing, WP_NS, 'inline');
+    var anchor = findFirstElement(drawing, WP_NS, 'anchor');
+    var host = inline != null ? inline : anchor;
+    var positionH = host !== undefined ? elementChildren(host).find(function (c) { return isElement(c, WP_NS, 'positionH'); }) : undefined;
+    var positionV = host !== undefined ? elementChildren(host).find(function (c) { return isElement(c, WP_NS, 'positionV'); }) : undefined;
+    var hOriginRaw = positionH !== undefined ? attributeValue(positionH, '', 'relativeFrom') : undefined;
+    var vOriginRaw = positionV !== undefined ? attributeValue(positionV, '', 'relativeFrom') : undefined;
+    return {
+        horizontalOrigin: hOriginRaw !== undefined && isHorizontalOrigin(hOriginRaw) ? hOriginRaw : undefined,
+        verticalOrigin: vOriginRaw !== undefined && isVerticalOrigin(vOriginRaw) ? vOriginRaw : undefined,
+        horizontalPosition: parsePosOffsetEmu(positionH),
+        verticalPosition: parsePosOffsetEmu(positionV),
+        horizontalPositionEmu: parsePosOffsetRawEmu(positionH),
+        verticalPositionEmu: parsePosOffsetRawEmu(positionV),
+        horizontalAlignment: parseAlignChild(positionH, 'h'),
+        verticalAlignment: parseAlignChild(positionV, 'v'),
+    };
+}
+/**
+ * Resolve effective placement from modeled wrap + requested placement.
+ * Inline wrap forces `wp:inline`; other wraps force `wp:anchor`.
+ *
+ * @private
+ */
+export function effectiveDrawingPlacement(placement, wrapping) {
+    if (wrapping === TextWrappingStyle.Inline) {
+        return 'inline';
+    }
+    if (wrapping !== undefined) {
+        return 'anchor';
+    }
+    return placement;
+}
+/**
+ * Resolve effective wrapping for encode. Anchor + Inline wrap coerces to None.
+ *
+ * @private
+ */
+export function effectiveDrawingWrapping(placement, wrapping) {
+    if (wrapping === undefined) {
+        return placement === 'inline' ? TextWrappingStyle.Inline : TextWrappingStyle.None;
+    }
+    if (placement === 'anchor' && wrapping === TextWrappingStyle.Inline) {
+        return TextWrappingStyle.None;
+    }
+    if (placement === 'inline') {
+        return TextWrappingStyle.Inline;
+    }
+    return wrapping;
+}
+function buildInlineHost(input) {
+    var __ts33_8;
+    var preservedInline = input.preservedHost !== undefined
+        ? findFirstElement(input.preservedHost, WP_NS, 'inline')
+        : undefined;
+    var effect = ((__ts33_8 = findResidualEffectExtent(preservedInline)), __ts33_8 != null ? __ts33_8 : buildEffectExtent());
+    var distT = input.distanceTopEmu != null ? input.distanceTopEmu : 0;
+    var distB = input.distanceBottomEmu != null ? input.distanceBottomEmu : 0;
+    var distL = input.distanceLeftEmu != null ? input.distanceLeftEmu : 0;
+    var distR = input.distanceRightEmu != null ? input.distanceRightEmu : 0;
+    var nsDecls = [
+        { prefix: 'wp', namespaceUri: WP_NS },
+        { prefix: 'a', namespaceUri: A_NS },
+        { prefix: 'wps', namespaceUri: WPS_NS },
+    ];
+    if (input.groupChildElements !== undefined) {
+        nsDecls.push({ prefix: 'wpg', namespaceUri: WPG_NS });
+    }
+    return xmlElement(WP_NS, 'wp', 'inline', {
+        namespaceDeclarations: nsDecls,
+        attributes: [
+            attr('distT', String(distT)),
+            attr('distB', String(distB)),
+            attr('distL', String(distL)),
+            attr('distR', String(distR)),
+        ],
+        children: [
+            xmlElement(WP_NS, 'wp', 'extent', {
+                attributes: [attr('cx', String(input.widthEmu)), attr('cy', String(input.heightEmu))],
+            }),
+            effect,
+            buildDocPr(input),
+            buildCNvGraphicFramePr(input.lockAspectRatio != null ? input.lockAspectRatio : true),
+            buildGraphic(input),
+        ],
+    });
+}
+function buildAnchorHost(input) {
+    var __ts33_9, __ts33_10, __ts33_11, __ts33_12, __ts33_13;
+    var preservedAnchor = input.preservedHost !== undefined
+        ? findFirstElement(input.preservedHost, WP_NS, 'anchor')
+        : undefined;
+    var defaultAttrs = [
+        attr('distT', String(input.distanceTopEmu != null ? input.distanceTopEmu : 0)),
+        attr('distB', String(input.distanceBottomEmu != null ? input.distanceBottomEmu : 0)),
+        attr('distL', String(input.distanceLeftEmu != null ? input.distanceLeftEmu : 114300)),
+        attr('distR', String(input.distanceRightEmu != null ? input.distanceRightEmu : 114300)),
+        attr('simplePos', '0'),
+        attr('relativeHeight', '251658240'),
+        attr('behindDoc', input.behindDocument === true ? '1' : '0'),
+        attr('locked', input.lockAnchor === true ? '1' : '0'),
+        attr('layoutInCell', input.layoutInCell === false ? '0' : '1'),
+        attr('allowOverlap', input.allowOverlap === false ? '0' : '1'),
+    ];
+    // When modeled host attrs are supplied, prefer them over residual attrs.
+    var hasModeledHostAttrs = input.distanceTopEmu !== undefined ||
+        input.distanceBottomEmu !== undefined ||
+        input.distanceLeftEmu !== undefined ||
+        input.distanceRightEmu !== undefined ||
+        input.behindDocument !== undefined ||
+        input.lockAnchor !== undefined ||
+        input.allowOverlap !== undefined ||
+        input.layoutInCell !== undefined ||
+        input.layoutDirty === true;
+    var attrs;
+    if (hasModeledHostAttrs || preservedAnchor === undefined) {
+        if (preservedAnchor !== undefined && !hasModeledHostAttrs) {
+            var preservedAttrs = copyElementAttrs(preservedAnchor, [
+                'distT',
+                'distB',
+                'distL',
+                'distR',
+                'simplePos',
+                'relativeHeight',
+                'behindDoc',
+                'locked',
+                'layoutInCell',
+                'allowOverlap',
+                'hidden',
+            ]);
+            attrs = preservedAttrs.length > 0 ? preservedAttrs : defaultAttrs;
+        }
+        else if (preservedAnchor !== undefined) {
+            // Merge: keep non-modeled structural attrs from residual; override the
+            // modeled distance / behindDoc / anchor-option attrs.
+            var base = copyElementAttrs(preservedAnchor, [
+                'simplePos',
+                'relativeHeight',
+                'hidden',
+            ]);
+            var merged = __spread([
+                attr('distT', String(((__ts33_9 = input.distanceTopEmu != null ? input.distanceTopEmu : parseEmuAttr(preservedAnchor, 'distT')), __ts33_9 != null ? __ts33_9 : 0))),
+                attr('distB', String(((__ts33_10 = input.distanceBottomEmu != null ? input.distanceBottomEmu : parseEmuAttr(preservedAnchor, 'distB')), __ts33_10 != null ? __ts33_10 : 0))),
+                attr('distL', String(((__ts33_11 = input.distanceLeftEmu != null ? input.distanceLeftEmu : parseEmuAttr(preservedAnchor, 'distL')), __ts33_11 != null ? __ts33_11 : 114300))),
+                attr('distR', String(((__ts33_12 = input.distanceRightEmu != null ? input.distanceRightEmu : parseEmuAttr(preservedAnchor, 'distR')), __ts33_12 != null ? __ts33_12 : 114300)))
+            ], (base.length > 0
+                ? base
+                : [
+                    attr('simplePos', '0'),
+                    attr('relativeHeight', '251658240'),
+                ]), [
+                attr('behindDoc', input.behindDocument !== undefined
+                    ? input.behindDocument
+                        ? '1'
+                        : '0'
+                    : parseOnOffAttr(preservedAnchor, 'behindDoc')
+                        ? '1'
+                        : '0'),
+                attr('locked', input.lockAnchor !== undefined
+                    ? input.lockAnchor
+                        ? '1'
+                        : '0'
+                    : parseOnOffAttr(preservedAnchor, 'locked')
+                        ? '1'
+                        : '0'),
+                attr('allowOverlap', input.allowOverlap !== undefined
+                    ? input.allowOverlap
+                        ? '1'
+                        : '0'
+                    : parseOnOffAttr(preservedAnchor, 'allowOverlap')
+                        ? '1'
+                        : '0'),
+                attr('layoutInCell', input.layoutInCell !== undefined
+                    ? input.layoutInCell
+                        ? '1'
+                        : '0'
+                    : parseOnOffAttr(preservedAnchor, 'layoutInCell')
+                        ? '1'
+                        : '0'),
+            ]);
+            attrs = merged;
+        }
+        else {
+            attrs = defaultAttrs;
+        }
+    }
+    else {
+        var preservedAttrs = copyElementAttrs(preservedAnchor, [
+            'distT',
+            'distB',
+            'distL',
+            'distR',
+            'simplePos',
+            'relativeHeight',
+            'behindDoc',
+            'locked',
+            'layoutInCell',
+            'allowOverlap',
+            'hidden',
+        ]);
+        attrs = preservedAttrs.length > 0 ? preservedAttrs : defaultAttrs;
+    }
+    var residualWrap = findResidualWrap(preservedAnchor);
+    var residualEffect = ((__ts33_13 = findResidualEffectExtent(preservedAnchor)), __ts33_13 != null ? __ts33_13 : buildEffectExtent());
+    var residualSimplePos = preservedAnchor
+        ? elementChildren(preservedAnchor).find(function (c) { return isElement(c, WP_NS, 'simplePos'); })
+        : undefined;
+    var residualPositions = findResidualPositions(preservedAnchor);
+    var useModeledLayout = input.layoutDirty === true || preservedAnchor === undefined;
+    var wrapping = effectiveDrawingWrapping('anchor', input.wrapping != null ? input.wrapping : TextWrappingStyle.None);
+    var simplePos;
+    var positionH;
+    var positionV;
+    var wrap;
+    var modeledModes = usedModeledPositionMode(input);
+    if (useModeledLayout) {
+        simplePos = residualSimplePos != null ? residualSimplePos : xmlElement(WP_NS, 'wp', 'simplePos', {
+            attributes: [attr('x', '0'), attr('y', '0')],
+        });
+        // Rebuild each axis independently so setting V never rewrites H.
+        positionH = modeledModes.horizontal
+            ? buildDrawingPositionH(input)
+            : (residualPositions.positionH != null ? residualPositions.positionH : buildDefaultPositionH());
+        positionV = modeledModes.vertical
+            ? buildDrawingPositionV(input)
+            : (residualPositions.positionV != null ? residualPositions.positionV : buildDefaultPositionV());
+        wrap = buildWrapElement(wrapping, residualWrap, input.wrapType);
+    }
+    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', 'column')],
+            children: [
+                xmlElement(WP_NS, 'wp', 'posOffset', {
+                    children: [{ kind: 'text', value: '0' }],
+                }),
+            ],
+        });
+        positionV = pv != null ? pv : xmlElement(WP_NS, 'wp', 'positionV', {
+            attributes: [attr('relativeFrom', 'paragraph')],
+            children: [
+                xmlElement(WP_NS, 'wp', 'posOffset', {
+                    children: [{ kind: 'text', value: '0' }],
+                }),
+            ],
+        });
+        wrap = residualWrap != null ? residualWrap : xmlElement(WP_NS, 'wp', 'wrapNone');
+    }
+    var nsDecls = [
+        { prefix: 'wp', namespaceUri: WP_NS },
+        { prefix: 'a', namespaceUri: A_NS },
+        { prefix: 'wps', namespaceUri: WPS_NS },
+    ];
+    if (input.groupChildElements !== undefined) {
+        nsDecls.push({ prefix: 'wpg', namespaceUri: WPG_NS });
+    }
+    return xmlElement(WP_NS, 'wp', 'anchor', {
+        namespaceDeclarations: nsDecls,
+        attributes: attrs,
+        children: [
+            simplePos,
+            positionH,
+            positionV,
+            xmlElement(WP_NS, 'wp', 'extent', {
+                attributes: [attr('cx', String(input.widthEmu)), attr('cy', String(input.heightEmu))],
+            }),
+            residualEffect,
+            wrap,
+            buildDocPr(input),
+            buildCNvGraphicFramePr(input.lockAspectRatio != null ? input.lockAspectRatio : true),
+            buildGraphic(input),
+        ],
+    });
+}
+/** True when any anchor-option field is explicitly modeled. */
+/**
+ * Whether the caller explicitly modeled a position mode (offset or align).
+ * Hydrated-from-residual values do NOT count: rebuilt wire must preserve the
+ * residual axis bytes untouched unless the user intervened on that axis.
+ *
+ * @private
+ */
+export function usedModeledPositionMode(input) {
+    return {
+        horizontal: input.horizontalModeled === true,
+        vertical: input.verticalModeled === true,
+    };
+}
+function parseOnOff(raw) {
+    return raw === '1' || raw === 'true';
+}
+function parseExtentEmus(element) {
+    if (element === undefined) {
+        return undefined;
+    }
+    var cxRaw = attributeValue(element, '', 'cx');
+    var cyRaw = attributeValue(element, '', 'cy');
+    if (cxRaw === undefined || cyRaw === undefined || !/^\d+$/.test(cxRaw) || !/^\d+$/.test(cyRaw)) {
+        return undefined;
+    }
+    return {
+        widthEmu: Number.parseInt(cxRaw, 10),
+        heightEmu: Number.parseInt(cyRaw, 10),
+    };
+}
+function parseXfrmTransform(root) {
+    var xfrm = findFirstElement(root, A_NS, 'xfrm');
+    if (xfrm === undefined) {
+        return { rotation: 0, flipHorizontal: false, flipVertical: false, ext: undefined };
+    }
+    var rotRaw = attributeValue(xfrm, '', 'rot');
+    var rotation = rotRaw !== undefined && /^-?\d+$/.test(rotRaw)
+        ? Number.parseInt(rotRaw, 10) / ROTATION_UNITS_PER_DEGREE
+        : 0;
+    var extEl = elementChildren(xfrm).find(function (c) { return isElement(c, A_NS, 'ext'); });
+    return {
+        rotation: rotation,
+        flipHorizontal: parseOnOff(attributeValue(xfrm, '', 'flipH')),
+        flipVertical: parseOnOff(attributeValue(xfrm, '', 'flipV')),
+        ext: parseExtentEmus(extEl),
+    };
+}
+function parseLockAspect(host) {
+    var locks = findFirstElement(host, A_NS, 'graphicFrameLocks');
+    if (locks === undefined) {
+        return false;
+    }
+    return parseOnOff(attributeValue(locks, '', 'noChangeAspect'));
+}
+function preferHost(drawing) {
+    var inline = findFirstElement(drawing, WP_NS, 'inline');
+    var anchor = findFirstElement(drawing, WP_NS, 'anchor');
+    return inline != null ? inline : anchor;
+}
+/**
+ * Read size/transform/lock from preferred DrawingML host.
+ * Public size prefers `wp:extent`; xfrm ext is residual until size dirty.
+ *
+ * @private
+ */
+export function readDrawingLayout(root) {
+    var __ts33_14, __ts33_15, __ts33_16;
+    var drawing = ((__ts33_14 = preferredDrawingElement(root)), __ts33_14 != null ? __ts33_14 : (isWml(root, 'drawing') ? root : undefined));
+    if (drawing === undefined) {
+        return {
+            widthEmu: undefined,
+            heightEmu: undefined,
+            rotation: 0,
+            flipHorizontal: false,
+            flipVertical: false,
+            lockAspectRatio: false,
+        };
+    }
+    var host = preferHost(drawing);
+    var extentEl = host !== undefined ? findFirstElement(host, WP_NS, 'extent') : undefined;
+    var fromExtent = parseExtentEmus(extentEl);
+    var xfrm = parseXfrmTransform(drawing);
+    return {
+        widthEmu: ((__ts33_15 = fromExtent == null ? undefined : fromExtent.widthEmu), __ts33_15 != null ? __ts33_15 : xfrm.ext == null ? undefined : xfrm.ext.widthEmu),
+        heightEmu: ((__ts33_16 = fromExtent == null ? undefined : fromExtent.heightEmu), __ts33_16 != null ? __ts33_16 : xfrm.ext == null ? undefined : xfrm.ext.heightEmu),
+        rotation: xfrm.rotation,
+        flipHorizontal: xfrm.flipHorizontal,
+        flipVertical: xfrm.flipVertical,
+        lockAspectRatio: host !== undefined ? parseLockAspect(host) : false,
+    };
+}
+function replaceLocalAttrs(el, mutator) {
+    var next = mutator(__spread(el.attributes));
+    el.attributes = next;
+}
+function setExtentAttrs(el, widthEmu, heightEmu) {
+    replaceLocalAttrs(el, function (attrs) {
+        var e_9, _a;
+        var next = [];
+        var sawCx = false;
+        var sawCy = false;
+        try {
+            for (var attrs_1 = __values(attrs), attrs_1_1 = attrs_1.next(); !attrs_1_1.done; attrs_1_1 = attrs_1.next()) {
+                var a = attrs_1_1.value;
+                if (a.namespaceUri === '' && a.localName === 'cx') {
+                    sawCx = true;
+                    next.push(attr('cx', String(widthEmu)));
+                    continue;
+                }
+                if (a.namespaceUri === '' && a.localName === 'cy') {
+                    sawCy = true;
+                    next.push(attr('cy', String(heightEmu)));
+                    continue;
+                }
+                next.push(a);
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (attrs_1_1 && !attrs_1_1.done && (_a = attrs_1.return)) _a.call(attrs_1);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+        if (!sawCx) {
+            next.push(attr('cx', String(widthEmu)));
+        }
+        if (!sawCy) {
+            next.push(attr('cy', String(heightEmu)));
+        }
+        return next;
+    });
+}
+function patchXfrmElement(xfrm, layout) {
+    replaceLocalAttrs(xfrm, function (attrs) {
+        var e_10, _a;
+        var kept = [];
+        try {
+            for (var attrs_2 = __values(attrs), attrs_2_1 = attrs_2.next(); !attrs_2_1.done; attrs_2_1 = attrs_2.next()) {
+                var a = attrs_2_1.value;
+                if (a.namespaceUri !== '') {
+                    kept.push(a);
+                    continue;
+                }
+                if (a.localName === 'rot' || a.localName === 'flipH' || a.localName === 'flipV') {
+                    continue;
+                }
+                kept.push(a);
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (attrs_2_1 && !attrs_2_1.done && (_a = attrs_2.return)) _a.call(attrs_2);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+        return __spread(kept, buildXfrmAttributes(layout));
+    });
+    var ext = elementChildren(xfrm).find(function (c) { return isElement(c, A_NS, 'ext'); });
+    if (ext === undefined) {
+        ext = xmlElement(A_NS, 'a', 'ext', {
+            attributes: [attr('cx', String(layout.widthEmu)), attr('cy', String(layout.heightEmu))],
+        });
+        var children = __spread(xfrm.children, [ext]);
+        xfrm.children = children;
+    }
+    else {
+        setExtentAttrs(ext, layout.widthEmu, layout.heightEmu);
+    }
+}
+function ensureXfrmOnSpPr(drawing, layout) {
+    var xfrm = findFirstElement(drawing, A_NS, 'xfrm');
+    if (xfrm !== undefined) {
+        patchXfrmElement(xfrm, layout);
+        return;
+    }
+    // Insert under first wps:spPr when present (do not invent full wsp tree).
+    var spPr = findFirstElement(drawing, WPS_NS, 'spPr');
+    if (spPr === undefined) {
+        return;
+    }
+    var off = xmlElement(A_NS, 'a', 'off', {
+        attributes: [attr('x', '0'), attr('y', '0')],
+    });
+    var ext = xmlElement(A_NS, 'a', 'ext', {
+        attributes: [attr('cx', String(layout.widthEmu)), attr('cy', String(layout.heightEmu))],
+    });
+    xfrm = xmlElement(A_NS, 'a', 'xfrm', {
+        attributes: buildXfrmAttributes(layout),
+        children: [off, ext],
+    });
+    spPr.children = __spread([xfrm], spPr.children);
+}
+function patchCNvGraphicFramePr(host, lockAspectRatio) {
+    var framePr = elementChildren(host).find(function (c) { return isElement(c, WP_NS, 'cNvGraphicFramePr'); });
+    if (framePr === undefined) {
+        framePr = buildCNvGraphicFramePr(lockAspectRatio);
+        // Insert after docPr when possible; else append.
+        var children = __spread(host.children);
+        var docPrIndex = children.findIndex(function (c) { return c.kind === 'element' && isElement(c, WP_NS, 'docPr'); });
+        if (docPrIndex >= 0) {
+            children.splice(docPrIndex + 1, 0, framePr);
+        }
+        else {
+            children.push(framePr);
+        }
+        host.children = children;
+        return;
+    }
+    var locks = elementChildren(framePr).find(function (c) { return isElement(c, A_NS, 'graphicFrameLocks'); });
+    if (locks === undefined) {
+        locks = xmlElement(A_NS, 'a', 'graphicFrameLocks', {
+            attributes: lockAspectRatio ? [attr('noChangeAspect', '1')] : [],
+        });
+        framePr.children = __spread([locks], framePr.children);
+        return;
+    }
+    replaceLocalAttrs(locks, function (attrs) {
+        var e_11, _a;
+        var kept = [];
+        try {
+            for (var attrs_3 = __values(attrs), attrs_3_1 = attrs_3.next(); !attrs_3_1.done; attrs_3_1 = attrs_3.next()) {
+                var a = attrs_3_1.value;
+                if (a.namespaceUri === '' && a.localName === 'noChangeAspect') {
+                    continue;
+                }
+                kept.push(a);
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (attrs_3_1 && !attrs_3_1.done && (_a = attrs_3.return)) _a.call(attrs_3);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+        if (lockAspectRatio) {
+            kept.push(attr('noChangeAspect', '1'));
+        }
+        return kept;
+    });
+}
+function emuToPointsString(emus) {
+    var pt = emus / EMU_PER_POINT;
+    // Avoid scientific notation; trim trailing zeros modestly.
+    var rounded = Math.round(pt * 1000) / 1000;
+    return String(rounded) + "pt";
+}
+/**
+ * Convert non-negative EMU to a bare points number string for VML CSS tokens
+ * that omit the `pt` unit in ShapeRequirements samples (e.g. mso-wrap-distance-top:0).
+ * Zero is emitted as `0` (no unit); positive values use `Npt`.
+ */
+function emuToCssLengthToken(emus) {
+    if (emus === 0) {
+        return '0';
+    }
+    return emuToPointsString(emus);
+}
+/**
+ * sRGB hex for VML color attributes. Strip optional leading `#`; lowercase 6-digit.
+ * Returns undefined when the value is not a 6-digit hex (omit rather than invent).
+ */
+function srgbToVmlColor(srgb) {
+    var raw = srgb.startsWith('#') ? srgb.slice(1) : srgb;
+    if (!/^[0-9A-Fa-f]{6}$/.test(raw)) {
+        return undefined;
+    }
+    return "#" + raw.toLowerCase();
+}
+/**
+ * DML `ST_LineCap` → VML `ST_StrokeEndCap` (`vml-main.xsd`: flat|square|round).
+ * Cites: AG_StrokeAttributes `@endcap`; DML rnd|sq|flat.
+ */
+function mapLineCapToVmlEndcap(cap) {
+    if (cap === undefined) {
+        return undefined;
+    }
+    switch (cap) {
+        case 'rnd':
+            return 'round';
+        case 'sq':
+            return 'square';
+        case 'flat':
+            return 'flat';
+        default:
+            // TS 3.3: LineCap widens to string without literal asserts — no never exhaustiveness.
+            return undefined;
+    }
+}
+/**
+ * DML `ST_LineEndType` → VML `ST_StrokeArrowType`.
+ *
+ * Locked corpus pair (ShapeRequirements connector Fallback):
+ * DML `a:tailEnd type="triangle"` → VML `endarrow="block"`.
+ * Identity pairs with matching ST_StrokeArrowType tokens: none, diamond, oval.
+ * Unmapped (stealth, arrow) are omitted — never invent classic/open without cite.
+ */
+function mapLineEndTypeToVmlArrow(type) {
+    if (type === undefined) {
+        return undefined;
+    }
+    switch (type) {
+        case 'none':
+            return 'none';
+        case 'triangle':
+            return 'block';
+        case 'diamond':
+            return 'diamond';
+        case 'oval':
+            return 'oval';
+        case 'stealth':
+        case 'arrow':
+            return undefined;
+        default:
+            return undefined;
+    }
+}
+/**
+ * DML arrow size (sm|med|lg) → VML ST_StrokeArrowWidth / Point
+ * (narrow|medium|wide and short|medium|long). Same three-level ladder; cited
+ * only when arrow type is also mapped.
+ */
+function mapLineEndSizeToVmlWidth(size) {
+    if (size === undefined) {
+        return undefined;
+    }
+    switch (size) {
+        case 'sm':
+            return 'narrow';
+        case 'med':
+            return 'medium';
+        case 'lg':
+            return 'wide';
+        default:
+            // TS 3.3: LineEndSize widens to string[] element without literal asserts.
+            return undefined;
+    }
+}
+function mapLineEndSizeToVmlLength(size) {
+    if (size === undefined) {
+        return undefined;
+    }
+    switch (size) {
+        case 'sm':
+            return 'short';
+        case 'med':
+            return 'medium';
+        case 'lg':
+            return 'long';
+        default:
+            return undefined;
+    }
+}
+/**
+ * DML `ST_LineDashingVal` → VML `@dashstyle` (xsd:string on AG_StrokeAttributes).
+ * Only clear literal pairs; omit unmapped (never invent dash patterns).
+ */
+function mapLineDashingToVml(dash) {
+    if (dash === undefined || dash === 'unknown') {
+        return undefined;
+    }
+    switch (dash) {
+        case 'solid':
+            return 'solid';
+        case 'dash':
+        case 'lgDash':
+        case 'sysDash':
+            return 'dash';
+        case 'dot':
+        case 'sysDot':
+            return 'dot';
+        case 'dashDot':
+        case 'lgDashDot':
+        case 'sysDashDot':
+            return 'dashDot';
+        case 'lgDashDotDot':
+        case 'sysDashDotDot':
+            return 'dashDotDot';
+        default:
+            // TS 3.3: LineDashing widens to string without literal asserts.
+            return undefined;
+    }
+}
+/**
+ * `wp:wrap*` style → `w10:wrap/@type` (`ST_WrapType`) and optional
+ * `mso-wrap-style` (ECMA Part 4 allows square|none only on that CSS token).
+ */
+function mapWrappingToVmlWrap(wrapping) {
+    switch (wrapping) {
+        case TextWrappingStyle.Square:
+            return { w10Type: 'square', msoWrapStyle: 'square' };
+        case TextWrappingStyle.None:
+            return { w10Type: 'none', msoWrapStyle: 'none' };
+        case TextWrappingStyle.Tight:
+            return { w10Type: 'tight', msoWrapStyle: undefined };
+        case TextWrappingStyle.Through:
+            return { w10Type: 'through', msoWrapStyle: undefined };
+        case TextWrappingStyle.TopAndBottom:
+            return { w10Type: 'topAndBottom', msoWrapStyle: undefined };
+        case TextWrappingStyle.Inline:
+        case undefined:
+            // Inline hosts: no w10:wrap; mso-wrap-style omitted (flow with text).
+            return { w10Type: undefined, msoWrapStyle: undefined };
+        default:
+            // TS 3.3: TextWrappingStyle widens to string without literal asserts.
+            return { w10Type: undefined, msoWrapStyle: undefined };
+    }
+}
+/**
+ * DML `ST_RelFromH` → w10 `ST_HorizontalAnchor` / mso-position-horizontal-relative.
+ * Only tokens that exist on both sides: margin|page|text(←column)|char(←character).
+ * Margin-side variants (leftMargin, …) are omitted rather than inventing.
+ */
+function mapHorizontalOriginToVml(origin) {
+    switch (origin) {
+        case HorizontalOrigin.Margin:
+            return 'margin';
+        case HorizontalOrigin.Page:
+            return 'page';
+        case HorizontalOrigin.Column:
+            // ShapeRequirements samples use mso-position-horizontal-relative:text for
+            // column-relative anchors (w10 ST_HorizontalAnchor includes `text`).
+            return 'text';
+        case HorizontalOrigin.Character:
+            return 'char';
+        case HorizontalOrigin.LeftMargin:
+        case HorizontalOrigin.RightMargin:
+        case HorizontalOrigin.InsideMargin:
+        case HorizontalOrigin.OutsideMargin:
+        case undefined:
+            return undefined;
+        default:
+            // TS 3.3: HorizontalOrigin widens to string without literal asserts.
+            return undefined;
+    }
+}
+/**
+ * DML `ST_RelFromV` → w10 `ST_VerticalAnchor` / mso-position-vertical-relative.
+ * margin|page|text(←paragraph)|line. Margin-side variants omitted.
+ */
+function mapVerticalOriginToVml(origin) {
+    switch (origin) {
+        case VerticalOrigin.Margin:
+            return 'margin';
+        case VerticalOrigin.Page:
+            return 'page';
+        case VerticalOrigin.Paragraph:
+            // ShapeRequirements: mso-position-vertical-relative:text
+            return 'text';
+        case VerticalOrigin.Line:
+            return 'line';
+        case VerticalOrigin.TopMargin:
+        case VerticalOrigin.BottomMargin:
+        case VerticalOrigin.InsideMargin:
+        case VerticalOrigin.OutsideMargin:
+        case undefined:
+            return undefined;
+        default:
+            // TS 3.3: VerticalOrigin widens to string without literal asserts.
+            return undefined;
+    }
+}
+/**
+ * Build VML `style` attribute from modeled layout (ShapeRequirements Fallback pattern).
+ *
+ * Always: width/height in pt.
+ * Anchor: position:absolute; margin-left/top from offsets when modeled; z-index;
+ * visibility:visible; optional mso-wrap-style (square|none only); mso-wrap-distance-*;
+ * mso-position-horizontal/vertical absolute + relative tokens when origins map.
+ * Rotation: CSS `rotation:N` degrees when non-zero (DML rot is 1/60000 deg).
+ * Flip: `flip:x` / `flip:y` / `flip:xy` when modeled (VML style AG_Style).
+ */
+function buildVmlShapeStyle(input) {
+    var __ts33_17, __ts33_18;
+    var placement = effectiveDrawingPlacement(input.placement, input.wrapping);
+    var wrapping = effectiveDrawingWrapping(placement, input.wrapping);
+    var parts = [];
+    if (placement === 'anchor') {
+        parts.push('position:absolute');
+        var marginLeft = input.horizontalPositionEmu != null ? input.horizontalPositionEmu : 0;
+        var marginTop = input.verticalPositionEmu != null ? input.verticalPositionEmu : 0;
+        parts.push("margin-left:" + emuToPointsString(marginLeft));
+        parts.push("margin-top:" + emuToPointsString(marginTop));
+    }
+    parts.push("width:" + emuToPointsString(input.widthEmu));
+    parts.push("height:" + emuToPointsString(input.heightEmu));
+    if (placement === 'anchor') {
+        // Default relativeHeight matches buildAnchorHost (251658240).
+        // behindDoc: Word uses negative z-index for behind-text; emit only when true.
+        var zIndex = input.behindDocument === true ? -251658240 : 251658240;
+        parts.push("z-index:" + String(zIndex));
+        parts.push('visibility:visible');
+        var wrapMap = mapWrappingToVmlWrap(wrapping);
+        if (wrapMap.msoWrapStyle !== undefined) {
+            parts.push("mso-wrap-style:" + wrapMap.msoWrapStyle);
+        }
+        // ShapeRequirements connector sample: mso-wrap-distance-left/right 9pt
+        // (= 114300 EMU anchor default); top/bottom 0.
+        var distL = input.distanceLeftEmu != null ? input.distanceLeftEmu : 114300;
+        var distT = input.distanceTopEmu != null ? input.distanceTopEmu : 0;
+        var distR = input.distanceRightEmu != null ? input.distanceRightEmu : 114300;
+        var distB = input.distanceBottomEmu != null ? input.distanceBottomEmu : 0;
+        parts.push("mso-wrap-distance-left:" + emuToCssLengthToken(distL));
+        parts.push("mso-wrap-distance-top:" + emuToCssLengthToken(distT));
+        parts.push("mso-wrap-distance-right:" + emuToCssLengthToken(distR));
+        parts.push("mso-wrap-distance-bottom:" + emuToCssLengthToken(distB));
+        parts.push('mso-position-horizontal:absolute');
+        var hRel = ((__ts33_17 = mapHorizontalOriginToVml(input.horizontalOrigin)), __ts33_17 != null ? __ts33_17 :
+            // Default column → text (ShapeRequirements + images parity default origin).
+            'text');
+        parts.push("mso-position-horizontal-relative:" + hRel);
+        parts.push('mso-position-vertical:absolute');
+        var vRel = ((__ts33_18 = mapVerticalOriginToVml(input.verticalOrigin)), __ts33_18 != null ? __ts33_18 :
+            // Default paragraph → text.
+            'text');
+        parts.push("mso-position-vertical-relative:" + vRel);
+    }
+    var rotation = input.rotation != null ? input.rotation : 0;
+    if (rotation !== 0) {
+        // VML style rotation is degrees (not DML 60000ths).
+        var rounded = Math.round(rotation * 1000) / 1000;
+        parts.push("rotation:" + String(rounded));
+    }
+    var flipH = input.flipHorizontal === true;
+    var flipV = input.flipVertical === true;
+    if (flipH && flipV) {
+        parts.push('flip:xy');
+    }
+    else if (flipH) {
+        parts.push('flip:x');
+    }
+    else if (flipV) {
+        parts.push('flip:y');
+    }
+    // bodyPr spAutoFit → mso-fit-shape-to-text (Word VML textbox autofit).
+    if (input.bodyPr !== undefined) {
+        var hasSpAutoFit = elementChildren(input.bodyPr).some(function (c) { return c.namespaceUri === A_NS && c.localName === 'spAutoFit'; });
+        if (hasSpAutoFit) {
+            parts.push('mso-fit-shape-to-text:t');
+        }
+    }
+    return parts.join(';');
+}
+/**
+ * Read bodyPr inset attributes (lIns/tIns/rIns/bIns EMU) into VML `@inset`
+ * string (`left,top,right,bottom` in pt). CT_Textbox `@inset` (vml-main.xsd).
+ * Missing sides default to 0pt so the four-tuple is well-formed when any side
+ * is modeled.
+ */
+function bodyPrInsetsToVmlInset(bodyPr) {
+    if (bodyPr === undefined) {
+        return undefined;
+    }
+    var lRaw = attributeValue(bodyPr, '', 'lIns');
+    var tRaw = attributeValue(bodyPr, '', 'tIns');
+    var rRaw = attributeValue(bodyPr, '', 'rIns');
+    var bRaw = attributeValue(bodyPr, '', 'bIns');
+    if (lRaw === undefined && tRaw === undefined && rRaw === undefined && bRaw === undefined) {
+        return undefined;
+    }
+    var parse = function (raw) {
+        if (raw === undefined || raw === '') {
+            return 0;
+        }
+        var n = Number(raw);
+        return (Number.isFinite(n) ? n : 0);
+    };
+    return emuToPointsString(parse(lRaw)) + "," + emuToPointsString(parse(tRaw)) + "," + emuToPointsString(parse(rRaw)) + "," + emuToPointsString(parse(bRaw));
+}
+/**
+ * Build `v:stroke` child when line endcap / dash / arrows / joinstyle need emission.
+ * ShapeRequirements always emits `joinstyle="miter"` on stroke for authored shapes;
+ * we emit the child whenever any stroke detail beyond shape-level color/weight is set,
+ * and always include joinstyle=miter when the child is present (corpus pattern).
+ */
+function buildVmlStrokeChild(input) {
+    var line = input.line;
+    if (line === undefined) {
+        return undefined;
+    }
+    var strokeAttrs = [];
+    if (line.kind === 'none') {
+        // AG_StrokeAttributes `@on` — turn stroke off (pairs with shape stroked="f").
+        strokeAttrs.push(attr('on', 'f'));
+    }
+    else {
+        var endcap = mapLineCapToVmlEndcap(line.cap);
+        if (endcap !== undefined) {
+            strokeAttrs.push(attr('endcap', endcap));
+        }
+        var dashstyle = mapLineDashingToVml(line.dash);
+        if (dashstyle !== undefined && dashstyle !== 'solid') {
+            // solid is the default; omit rather than noise.
+            strokeAttrs.push(attr('dashstyle', dashstyle));
+        }
+        if (line.widthEmu !== undefined) {
+            strokeAttrs.push(attr('weight', emuToPointsString(line.widthEmu)));
+        }
+        var color = srgbToVmlColor(line.srgb);
+        if (color !== undefined) {
+            strokeAttrs.push(attr('color', color));
+        }
+        var startArrow = mapLineEndTypeToVmlArrow(line.beginArrowType);
+        if (startArrow !== undefined && startArrow !== 'none') {
+            strokeAttrs.push(attr('startarrow', startArrow));
+            var sw = mapLineEndSizeToVmlWidth(line.beginArrowSize);
+            var sl = mapLineEndSizeToVmlLength(line.beginArrowSize);
+            if (sw !== undefined) {
+                strokeAttrs.push(attr('startarrowwidth', sw));
+            }
+            if (sl !== undefined) {
+                strokeAttrs.push(attr('startarrowlength', sl));
+            }
+        }
+        var endArrow = mapLineEndTypeToVmlArrow(line.endArrowType);
+        if (endArrow !== undefined && endArrow !== 'none') {
+            // ShapeRequirements connector: endarrow="block" (DML triangle).
+            strokeAttrs.push(attr('endarrow', endArrow));
+            var ew = mapLineEndSizeToVmlWidth(line.endArrowSize);
+            var el = mapLineEndSizeToVmlLength(line.endArrowSize);
+            if (ew !== undefined) {
+                strokeAttrs.push(attr('endarrowwidth', ew));
+            }
+            if (el !== undefined) {
+                strokeAttrs.push(attr('endarrowlength', el));
+            }
+        }
+    }
+    // Emit child when we have any stroke detail, or always for solid/none so
+    // joinstyle miter matches ShapeRequirements Fallback samples.
+    strokeAttrs.push(attr('joinstyle', 'miter'));
+    return xmlElement(VML_NS, 'v', 'stroke', { attributes: strokeAttrs });
+}
+/**
+ * Corpus-backed VML Fallback pict tree (Policy B dual AC — TASK-8050).
+ *
+ * Emits `w:pict` > `v:shape` with style, fill/stroke attrs, optional `v:stroke`,
+ * `w10:wrap` / `w10:anchorlock`, and `v:textbox` (cloned txbxContent) when modeled.
+ * Does not invent shapetype paths or execute VML.
+ *
+ * @private
+ */
+export function buildVmlFallbackStub(input) {
+    var placement = effectiveDrawingPlacement(input.placement, input.wrapping);
+    var wrapping = effectiveDrawingWrapping(placement, input.wrapping);
+    var shapeAttrs = [
+        attr('style', buildVmlShapeStyle(input)),
+        attr('id', "Shape" + String(input.docPrId)),
+    ];
+    // AG_Fill: filled / fillcolor (vml-main.xsd).
+    if (input.fill !== undefined) {
+        if (input.fill.kind === 'none') {
+            shapeAttrs.push(attr('filled', 'f'));
+        }
+        else {
+            var color = srgbToVmlColor(input.fill.srgb);
+            if (color !== undefined) {
+                shapeAttrs.push(attr('filled', 't'));
+                shapeAttrs.push(attr('fillcolor', color));
+            }
+        }
+    }
+    // AG_ShapeAttributes: stroked / strokecolor / strokeweight.
+    if (input.line !== undefined) {
+        if (input.line.kind === 'none') {
+            shapeAttrs.push(attr('stroked', 'f'));
+        }
+        else {
+            shapeAttrs.push(attr('stroked', 't'));
+            var color = srgbToVmlColor(input.line.srgb);
+            if (color !== undefined) {
+                shapeAttrs.push(attr('strokecolor', color));
+            }
+            if (input.line.widthEmu !== undefined) {
+                shapeAttrs.push(attr('strokeweight', emuToPointsString(input.line.widthEmu)));
+            }
+        }
+    }
+    var children = [];
+    // v:fill opacity when solid fill has non-opaque transparency (public t = 100 - opacity%).
+    if (input.fill !== undefined && input.fill.kind === 'solid') {
+        var solidFill = input.fill;
+        if (solidFill.alpha !== undefined) {
+            var publicTransparency = Math.round(100 - solidFill.alpha / 1000);
+            if (publicTransparency > 0 && publicTransparency <= 100) {
+                var fillColor = srgbToVmlColor(solidFill.srgb);
+                var fillAttrs = [];
+                if (fillColor !== undefined) {
+                    fillAttrs.push(attr('color', fillColor));
+                }
+                fillAttrs.push(attr('opacity', String(100 - publicTransparency) + '%'));
+                children.push(xmlElement(VML_NS, 'v', 'fill', { attributes: fillAttrs }));
+            }
+        }
+    }
+    var strokeChild = buildVmlStrokeChild(input);
+    if (strokeChild !== undefined) {
+        children.push(strokeChild);
+    }
+    // w10:wrap — ST_WrapType from vml-wordprocessingDrawing.xsd.
+    var wrapMap = mapWrappingToVmlWrap(wrapping);
+    var needsW10 = false;
+    if (placement === 'anchor' && wrapMap.w10Type !== undefined) {
+        var wrapAttrs = [attr('type', wrapMap.w10Type)];
+        var anchorx = mapHorizontalOriginToVml(input.horizontalOrigin);
+        var anchory = mapVerticalOriginToVml(input.verticalOrigin);
+        if (anchorx !== undefined) {
+            wrapAttrs.push(attr('anchorx', anchorx));
+        }
+        if (anchory !== undefined) {
+            wrapAttrs.push(attr('anchory', anchory));
+        }
+        children.push(xmlElement(W10_NS, 'w10', 'wrap', {
+            attributes: wrapAttrs,
+        }));
+        needsW10 = true;
+    }
+    // w10:anchorlock — empty CT when lockAnchor (vml-wordprocessingDrawing.xsd).
+    if (placement === 'anchor' && input.lockAnchor === true) {
+        children.push(xmlElement(W10_NS, 'w10', 'anchorlock', {}));
+        needsW10 = true;
+    }
+    // v:textbox — CT_Textbox with optional @inset + w:txbxContent children.
+    // Dual-write text box body into Fallback when txbxContent is modeled (Policy B).
+    if (input.txbxContent !== undefined) {
+        var textboxAttrs = [];
+        var inset = bodyPrInsetsToVmlInset(input.bodyPr);
+        if (inset !== undefined) {
+            textboxAttrs.push(attr('inset', inset));
+        }
+        var txbxChildren = input.txbxContent.map(function (c) { return cloneElement(c); });
+        // CT_Textbox allows w:txbxContent; wrap cloned block children in w:txbxContent
+        // when the payload is raw body blocks (encode path passes txbxContent element
+        // children — typically already the inner blocks, or a single txbxContent).
+        // Prefer a single w:txbxContent wrapper when children are not already one.
+        var textboxChildEls = void 0;
+        if (txbxChildren.length === 1 &&
+            txbxChildren[0] !== undefined &&
+            isWml(txbxChildren[0], 'txbxContent')) {
+            textboxChildEls = txbxChildren;
+        }
+        else {
+            textboxChildEls = [wmlElement('txbxContent', { children: txbxChildren })];
+        }
+        children.push(xmlElement(VML_NS, 'v', 'textbox', {
+            attributes: textboxAttrs,
+            children: textboxChildEls,
+        }));
+    }
+    var namespaceDeclarations = [{ prefix: 'v', namespaceUri: VML_NS }];
+    if (needsW10) {
+        namespaceDeclarations.push({ prefix: 'w10', namespaceUri: W10_NS });
+    }
+    var shape = xmlElement(VML_NS, 'v', 'shape', {
+        attributes: shapeAttrs,
+        children: children,
+    });
+    return wmlElement('pict', {
+        namespaceDeclarations: namespaceDeclarations,
+        children: [shape],
+    });
+}
+/**
+ * Build `w:drawing` with `wp:inline` or `wp:anchor` host (Choice body only).
+ * Wrapping drives host kind: Inline ⇒ inline; other styles ⇒ anchor.
+ *
+ * @private
+ */
+export function buildDrawingMlHost(input) {
+    var placement = effectiveDrawingPlacement(input.placement, input.wrapping);
+    var wrapping = effectiveDrawingWrapping(placement, input.wrapping);
+    var resolved = __assign({}, input, { placement: placement,
+        wrapping: wrapping });
+    var host = placement === 'inline' ? buildInlineHost(resolved) : buildAnchorHost(resolved);
+    return wmlElement('drawing', { children: [host] });
+}
+/**
+ * Author dual AC root: Choice(wps DrawingML) + Fallback(VML pict tree).
+ * Policy B (GO Q2/Q3/Q7) — TASK-8050 corpus-backed VML Fallback.
+ *
+ * @private
+ */
+export function encodeAuthoredDrawingShape(input) {
+    var drawing = buildDrawingMlHost(input);
+    var fallback = buildVmlFallbackStub(input);
+    // ECMA-376-3 §7.6: Choice @Requires prefixes must be bound in scope.
+    // Declare xmlns:wps (and supporting prefixes) on AlternateContent so
+    // Requires="wps" resolves before Choice descends into w:drawing.
+    // xmlns:w10 is always declared so anchor Fallback w10:wrap / w10:anchorlock
+    // resolve under Fallback without inventing undeclared prefixes (vml-wordprocessingDrawing.xsd).
+    return xmlElement(MC_NS, 'mc', 'AlternateContent', {
+        namespaceDeclarations: [
+            { prefix: 'mc', namespaceUri: MC_NS },
+            { prefix: 'wps', namespaceUri: WPS_NS },
+            { prefix: 'wp', namespaceUri: WP_NS },
+            { prefix: 'a', namespaceUri: A_NS },
+            { prefix: 'v', namespaceUri: VML_NS },
+            { prefix: 'w10', namespaceUri: W10_NS },
+        ],
+        children: [
+            xmlElement(MC_NS, 'mc', 'Choice', {
+                attributes: [attr('Requires', 'wps')],
+                children: [drawing],
+            }),
+            xmlElement(MC_NS, 'mc', 'Fallback', {
+                children: [fallback],
+            }),
+        ],
+    });
+}
+/**
+ * Author dual AC root for a wordprocessing group: Choice(wpg DrawingML) +
+ * Fallback(VML pict stub). Policy B — TASK-8051.
+ *
+ * Top-level graphicData uri = WPG; body is `wpg:wgp` without cNvPr.
+ * xmlns:wpg is declared on AlternateContent so Requires="wpg" resolves;
+ * xmlns:wps is kept so nested authored `wps:wsp` children resolve.
+ *
+ * @private
+ */
+export function encodeAuthoredGroup(input) {
+    // Reuse the leaf host builders via EncodeDrawingShapeInput + groupChildElements.
+    // presetGeometry is a VML-fallback stub placeholder only (not written to DML).
+    // TS 3.3: nested conditional object spreads explode the checker (OOM).
+    // Mutable assigns only when defined — same exactOptionalPropertyTypes semantics.
+    var shapeLikeMutable = {
+        placement: input.placement,
+        widthEmu: input.widthEmu,
+        heightEmu: input.heightEmu,
+        presetGeometry: 'rect',
+        docPrId: input.docPrId,
+        name: input.name,
+        title: input.title,
+        description: input.description,
+        groupChildElements: input.children,
+    };
+    if (input.rotation !== undefined) {
+        shapeLikeMutable.rotation = input.rotation;
+    }
+    if (input.flipHorizontal !== undefined) {
+        shapeLikeMutable.flipHorizontal = input.flipHorizontal;
+    }
+    if (input.flipVertical !== undefined) {
+        shapeLikeMutable.flipVertical = input.flipVertical;
+    }
+    if (input.lockAspectRatio !== undefined) {
+        shapeLikeMutable.lockAspectRatio = input.lockAspectRatio;
+    }
+    if (input.wrapping !== undefined) {
+        shapeLikeMutable.wrapping = input.wrapping;
+    }
+    if (input.distanceTopEmu !== undefined) {
+        shapeLikeMutable.distanceTopEmu = input.distanceTopEmu;
+    }
+    if (input.distanceBottomEmu !== undefined) {
+        shapeLikeMutable.distanceBottomEmu = input.distanceBottomEmu;
+    }
+    if (input.distanceLeftEmu !== undefined) {
+        shapeLikeMutable.distanceLeftEmu = input.distanceLeftEmu;
+    }
+    if (input.distanceRightEmu !== undefined) {
+        shapeLikeMutable.distanceRightEmu = input.distanceRightEmu;
+    }
+    if (input.behindDocument !== undefined) {
+        shapeLikeMutable.behindDocument = input.behindDocument;
+    }
+    if (input.horizontalOrigin !== undefined) {
+        shapeLikeMutable.horizontalOrigin = input.horizontalOrigin;
+    }
+    if (input.verticalOrigin !== undefined) {
+        shapeLikeMutable.verticalOrigin = input.verticalOrigin;
+    }
+    if (input.horizontalPositionEmu !== undefined) {
+        shapeLikeMutable.horizontalPositionEmu = input.horizontalPositionEmu;
+    }
+    if (input.verticalPositionEmu !== undefined) {
+        shapeLikeMutable.verticalPositionEmu = input.verticalPositionEmu;
+    }
+    if (input.horizontalAlignment !== undefined) {
+        shapeLikeMutable.horizontalAlignment = input.horizontalAlignment;
+    }
+    if (input.verticalAlignment !== undefined) {
+        shapeLikeMutable.verticalAlignment = input.verticalAlignment;
+    }
+    if (input.lockAnchor !== undefined) {
+        shapeLikeMutable.lockAnchor = input.lockAnchor;
+    }
+    if (input.allowOverlap !== undefined) {
+        shapeLikeMutable.allowOverlap = input.allowOverlap;
+    }
+    if (input.layoutInCell !== undefined) {
+        shapeLikeMutable.layoutInCell = input.layoutInCell;
+    }
+    if (input.horizontalModeled !== undefined) {
+        shapeLikeMutable.horizontalModeled = input.horizontalModeled;
+    }
+    if (input.verticalModeled !== undefined) {
+        shapeLikeMutable.verticalModeled = input.verticalModeled;
+    }
+    if (input.preservedHost !== undefined) {
+        shapeLikeMutable.preservedHost = input.preservedHost;
+    }
+    if (input.layoutDirty !== undefined) {
+        shapeLikeMutable.layoutDirty = input.layoutDirty;
+    }
+    var shapeLike = shapeLikeMutable;
+    var drawing = buildDrawingMlHost(shapeLike);
+    var fallback = buildVmlFallbackStub(shapeLike);
+    return xmlElement(MC_NS, 'mc', 'AlternateContent', {
+        namespaceDeclarations: [
+            { prefix: 'mc', namespaceUri: MC_NS },
+            { prefix: 'wpg', namespaceUri: WPG_NS },
+            { prefix: 'wps', namespaceUri: WPS_NS },
+            { prefix: 'wp', namespaceUri: WP_NS },
+            { prefix: 'a', namespaceUri: A_NS },
+            { prefix: 'v', namespaceUri: VML_NS },
+            { prefix: 'w10', namespaceUri: W10_NS },
+        ],
+        children: [
+            xmlElement(MC_NS, 'mc', 'Choice', {
+                attributes: [attr('Requires', 'wpg')],
+                children: [drawing],
+            }),
+            xmlElement(MC_NS, 'mc', 'Fallback', {
+                children: [fallback],
+            }),
+        ],
+    });
+}
+/**
+ * Locate preferred DrawingML `w:drawing` for typed reads.
+ * Prefer MC Choice branch when residual is AlternateContent.
+ *
+ * @private
+ */
+export function preferredDrawingElement(root) {
+    var e_12, _a, e_13, _b;
+    if (isWml(root, 'drawing')) {
+        return root;
+    }
+    if (root.namespaceUri === MC_NS && root.localName === 'AlternateContent') {
+        try {
+            for (var _c = __values(elementChildren(root)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var child = _d.value;
+                if (child.namespaceUri !== MC_NS || child.localName !== 'Choice') {
+                    continue;
+                }
+                try {
+                    for (var _e = __values(elementChildren(child)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var nested = _f.value;
+                        if (isWml(nested, 'drawing')) {
+                            return nested;
+                        }
+                    }
+                }
+                catch (e_13_1) { e_13 = { error: e_13_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_13) throw e_13.error; }
+                }
+            }
+        }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
+        // No Choice drawing — last resort scan.
+        return findFirstElement(root, root.namespaceUri, 'drawing') !== undefined
+            ? undefined
+            : (function () {
+                var e_14, _a;
+                try {
+                    for (var _b = __values(elementChildren(root)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var child = _c.value;
+                        var d = preferredDrawingElement(child);
+                        if (d !== undefined) {
+                            return d;
+                        }
+                        if (isWml(child, 'drawing')) {
+                            return child;
+                        }
+                    }
+                }
+                catch (e_14_1) { e_14 = { error: e_14_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_14) throw e_14.error; }
+                }
+                return undefined;
+            })();
+    }
+    return undefined;
+}
+/**
+ * Read `wp:docPr` identity from preferred drawing host.
+ *
+ * @private
+ */
+export function readDocPrIdentity(root) {
+    var __ts33_19;
+    var drawing = ((__ts33_19 = preferredDrawingElement(root)), __ts33_19 != null ? __ts33_19 : (isWml(root, 'drawing') ? root : undefined));
+    if (drawing === undefined) {
+        return { name: undefined, title: undefined, description: undefined, docPrId: 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 { name: undefined, title: undefined, description: undefined, docPrId: undefined };
+    }
+    var docPr = findFirstElement(host, WP_NS, 'docPr');
+    if (docPr === undefined) {
+        return { name: undefined, title: undefined, description: undefined, docPrId: undefined };
+    }
+    var idRaw = attributeValue(docPr, '', 'id');
+    var idParsed = idRaw !== undefined && /^\d+$/.test(idRaw) ? Number.parseInt(idRaw, 10) : undefined;
+    var name = attributeValue(docPr, '', 'name');
+    var title = attributeValue(docPr, '', 'title');
+    var descr = attributeValue(docPr, '', 'descr');
+    return {
+        name: name !== undefined && name.length > 0 ? name : undefined,
+        title: title !== undefined && title.length > 0 ? title : undefined,
+        description: descr !== undefined && descr.length > 0 ? descr : undefined,
+        docPrId: idParsed,
+    };
+}
+function patchDocPrOnElement(docPr, identity) {
+    var e_15, _a;
+    var next = [];
+    var sawId = false;
+    var sawName = false;
+    var sawTitle = false;
+    var sawDescr = false;
+    try {
+        for (var _b = __values(docPr.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var a = _c.value;
+            if (a.namespaceUri !== '') {
+                next.push(a);
+                continue;
+            }
+            if (a.localName === 'id') {
+                sawId = true;
+                if (identity.docPrId !== undefined) {
+                    next.push(attr('id', String(identity.docPrId)));
+                }
+                else {
+                    next.push(a);
+                }
+                continue;
+            }
+            if (a.localName === 'name') {
+                sawName = true;
+                if (identity.name !== undefined) {
+                    next.push(attr('name', identity.name));
+                }
+                else {
+                    // Clearing name is not typical; keep residual when undefined means "no override".
+                    // Callers always pass concrete name when dirty from mutators.
+                    next.push(a);
+                }
+                continue;
+            }
+            if (a.localName === 'title') {
+                sawTitle = true;
+                if (identity.title === undefined) {
+                    continue;
+                }
+                next.push(attr('title', identity.title));
+                continue;
+            }
+            if (a.localName === 'descr') {
+                sawDescr = true;
+                if (identity.description === undefined) {
+                    continue;
+                }
+                next.push(attr('descr', identity.description));
+                continue;
+            }
+            next.push(a);
+        }
+    }
+    catch (e_15_1) { e_15 = { error: e_15_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_15) throw e_15.error; }
+    }
+    if (!sawId && identity.docPrId !== undefined) {
+        next.unshift(attr('id', String(identity.docPrId)));
+    }
+    if (!sawName && identity.name !== undefined) {
+        next.push(attr('name', identity.name));
+    }
+    if (!sawTitle && identity.title !== undefined && identity.title.length > 0) {
+        next.push(attr('title', identity.title));
+    }
+    if (!sawDescr && identity.description !== undefined && identity.description.length > 0) {
+        next.push(attr('descr', identity.description));
+    }
+    // Mutate in place on the clone's docPr via replacement — OpenXmlElement.attributes is readonly
+    // in type but we rebuild parent instead. Use object replace:
+    docPr.attributes = next;
+}
+/**
+ * Deep-clone residual and patch `wp:docPr` identity attributes only (identity dirty).
+ *
+ * @private
+ */
+export function patchResidualDocPr(residual, identity) {
+    var __ts33_20;
+    var cloned = cloneElement(residual);
+    var drawing = ((__ts33_20 = preferredDrawingElement(cloned)), __ts33_20 != null ? __ts33_20 : (isWml(cloned, 'drawing') ? cloned : undefined));
+    if (drawing === undefined) {
+        return cloned;
+    }
+    var inline = findFirstElement(drawing, WP_NS, 'inline');
+    var anchor = findFirstElement(drawing, WP_NS, 'anchor');
+    var host = inline != null ? inline : anchor;
+    if (host === undefined) {
+        return cloned;
+    }
+    var docPr = findFirstElement(host, WP_NS, 'docPr');
+    if (docPr === undefined) {
+        return cloned;
+    }
+    patchDocPrOnElement(docPr, identity);
+    return cloned;
+}
+/**
+ * Deep-clone residual and patch layout: `wp:extent`, `a:xfrm` (rot/flip/ext),
+ * `a:graphicFrameLocks/@noChangeAspect`, and optional `wp:docPr` identity.
+ * Preserves `wp:effectExtent` and other unmodeled siblings (layout dirty path).
+ *
+ * @private
+ */
+export function patchResidualLayout(residual, layout) {
+    var __ts33_21;
+    var cloned = cloneElement(residual);
+    var drawing = ((__ts33_21 = preferredDrawingElement(cloned)), __ts33_21 != null ? __ts33_21 : (isWml(cloned, 'drawing') ? cloned : undefined));
+    if (drawing === undefined) {
+        return cloned;
+    }
+    var host = preferHost(drawing);
+    if (host === undefined) {
+        return cloned;
+    }
+    var extentEl = findFirstElement(host, WP_NS, 'extent');
+    if (extentEl !== undefined) {
+        setExtentAttrs(extentEl, layout.widthEmu, layout.heightEmu);
+    }
+    else {
+        var extent = xmlElement(WP_NS, 'wp', 'extent', {
+            attributes: [attr('cx', String(layout.widthEmu)), attr('cy', String(layout.heightEmu))],
+        });
+        var children = __spread(host.children);
+        // Prefer before effectExtent / wrap / docPr when possible.
+        var insertAt = children.findIndex(function (c) { return c.kind === 'element' &&
+            (isElement(c, WP_NS, 'effectExtent') ||
+                isElement(c, WP_NS, 'docPr') ||
+                c.localName.startsWith('wrap')); });
+        if (insertAt >= 0) {
+            children.splice(insertAt, 0, extent);
+        }
+        else {
+            children.unshift(extent);
+        }
+        host.children = children;
+    }
+    ensureXfrmOnSpPr(drawing, layout);
+    patchCNvGraphicFramePr(host, layout.lockAspectRatio);
+    var docPr = findFirstElement(host, WP_NS, 'docPr');
+    if (docPr !== undefined) {
+        patchDocPrOnElement(docPr, layout);
+    }
+    return cloned;
+}
+/**
+ * True when root is MC AlternateContent owned by drawing (Choice with drawing, not picture/ink).
+ *
+ * @private
+ */
+export function isDrawingAlternateContent(root) {
+    return root.namespaceUri === MC_NS && root.localName === 'AlternateContent';
+}
+/**
+ * True when residual is a nested bare drawing child (`wps:wsp` or `wpg:grpSp`)
+ * rather than a top-level `w:drawing` / MC host (TASK-8051). Nested identity
+ * lives on `wps:cNvPr` / `wpg:cNvPr`, not `wp:docPr`.
+ *
+ * @private
+ */
+export function isNestedDrawingResidual(root) {
+    if (root.namespaceUri === WPS_NS && root.localName === 'wsp') {
+        return true;
+    }
+    if (root.namespaceUri === WPG_NS && root.localName === 'grpSp') {
+        return true;
+    }
+    return false;
+}
+/**
+ * Read nested `cNvPr` identity from bare `wps:wsp` / `wpg:grpSp` residual.
+ *
+ * @private
+ */
+export function readCNvPrIdentity(root) {
+    var __ts33_22;
+    var cNvPr = ((__ts33_22 = findFirstElement(root, WPS_NS, 'cNvPr')), __ts33_22 != null ? __ts33_22 : findFirstElement(root, WPG_NS, 'cNvPr'));
+    if (cNvPr === undefined) {
+        return { name: undefined, title: undefined, description: undefined, docPrId: undefined };
+    }
+    var idRaw = attributeValue(cNvPr, '', 'id');
+    var idParsed = idRaw !== undefined && /^\d+$/.test(idRaw) ? Number.parseInt(idRaw, 10) : undefined;
+    var name = attributeValue(cNvPr, '', 'name');
+    var title = attributeValue(cNvPr, '', 'title');
+    var descr = attributeValue(cNvPr, '', 'descr');
+    return {
+        name: name !== undefined && name.length > 0 ? name : undefined,
+        title: title !== undefined && title.length > 0 ? title : undefined,
+        description: descr !== undefined && descr.length > 0 ? descr : undefined,
+        docPrId: idParsed,
+    };
+}
+/**
+ * Deep-clone nested residual and patch `cNvPr` identity attributes only
+ * (identity dirty on group/canvas children — TASK-8051).
+ *
+ * @private
+ */
+export function patchResidualCNvPr(residual, identity) {
+    var __ts33_23;
+    var cloned = cloneElement(residual);
+    var cNvPr = ((__ts33_23 = findFirstElement(cloned, WPS_NS, 'cNvPr')), __ts33_23 != null ? __ts33_23 : findFirstElement(cloned, WPG_NS, 'cNvPr'));
+    if (cNvPr === undefined) {
+        return cloned;
+    }
+    patchDocPrOnElement(cNvPr, identity);
+    return cloned;
+}