@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/drawing/body-pr.js

@@ -0,0 +1,663 @@
+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 };
+        }
+    };
+};
+/**
+ * `wps:bodyPr` text-body properties codec (TASK-8049).
+ *
+ * Schema cites (transitional `dml-main.xsd` + `dml-wordprocessingDrawing.xsd`):
+ * - `CT_TextBodyProperties` attributes: `rot`, `spcFirstLastPara`,
+ *   `vertOverflow` (`ST_TextVertOverflowType`), `horzOverflow`
+ *   (`ST_TextHorzOverflowType`), `vert` (`ST_TextVerticalType`), `wrap`
+ *   (`ST_TextWrappingType` = `none|square` only), `lIns`/`tIns`/`rIns`/`bIns`
+ *   (`ST_Coordinate32` EMU), `numCol`, `spcCol`, `rtlCol`, `fromWordArt`,
+ *   `anchor` (`ST_TextAnchoringType`), `anchorCtr`, `forceAA`, `upright`
+ *   (default false), `compatLnSpc`
+ * - Sequence: `prstTxWarp?`, `EG_TextAutofit?` (`a:noAutofit` |
+ *   `a:normAutofit` | `a:spAutoFit`), `scene3d?`, `EG_Text3D?`, `extLst?`
+ * - `CT_TextNormalAutofit`: `@fontScale` (`ST_TextFontScalePercent` 1000…100000,
+ *   default 100%), `@lnSpcReduction` (default 0%)
+ * - Wire element: **`wps:bodyPr`** (type `a:CT_TextBodyProperties`); autofit
+ *   children use the DrawingML `a:` namespace
+ * - `CT_WordprocessingShape` (dml-wordprocessingDrawing): after `style?` /
+ *   `extLst?` / `txbx|linkedTxbx?`, **`bodyPr` minOccurs=1**
+ *
+ * Unknown attrs and residual children (`prstTxWarp`, `scene3d`, Text3D,
+ * `extLst`) stay residual — never invent OOXML.
+ *
+ * @packageDocumentation
+ */
+import { emuToPoint, pointToCoordinateEmus } from '../document/length';
+import { DocxError } from '../../core/errors/docx-error';
+import { A_NS, WPS_NS } from './host-codec';
+/**
+ * DrawingML text anchoring (`ST_TextAnchoringType`).
+ *
+ * @private
+ */
+export var TEXT_ANCHORING_VALUES = ['t', 'ctr', 'b', 'just', 'dist'];
+/**
+ * DrawingML vertical text overflow (`ST_TextVertOverflowType`).
+ *
+ * @private
+ */
+export var TEXT_VERT_OVERFLOW_VALUES = ['overflow', 'ellipsis', 'clip'];
+/**
+ * DrawingML horizontal text overflow (`ST_TextHorzOverflowType`).
+ *
+ * @private
+ */
+export var TEXT_HORZ_OVERFLOW_VALUES = ['overflow', 'clip'];
+/**
+ * DrawingML text vertical type (`ST_TextVerticalType`).
+ *
+ * @private
+ */
+export var TEXT_VERTICAL_TYPE_VALUES = [
+    'horz',
+    'vert',
+    'vert270',
+    'wordArtVert',
+    'eaVert',
+    'mongolianVert',
+    'wordArtVertRtl',
+];
+/**
+ * DrawingML text wrapping inside the shape (`ST_TextWrappingType`).
+ * Schema allows **`none` | `square` only**.
+ *
+ * @private
+ */
+export var TEXT_BODY_WRAP_VALUES = ['none', 'square'];
+/** ST_TextFontScalePercent: 1000…100000 (percent × 1000; 100000 = 100%). */
+var FONT_SCALE_MIN = 1000;
+var FONT_SCALE_MAX = 100000;
+var TEXT_ANCHORING_SET = new Set(TEXT_ANCHORING_VALUES);
+var TEXT_VERT_OVERFLOW_SET = new Set(TEXT_VERT_OVERFLOW_VALUES);
+var TEXT_HORZ_OVERFLOW_SET = new Set(TEXT_HORZ_OVERFLOW_VALUES);
+var TEXT_VERTICAL_TYPE_SET = new Set(TEXT_VERTICAL_TYPE_VALUES);
+var TEXT_BODY_WRAP_SET = new Set(TEXT_BODY_WRAP_VALUES);
+/**
+ * Whether `value` is a schema `ST_TextAnchoringType` token.
+ *
+ * @private
+ */
+export function isTextAnchoring(value) {
+    return TEXT_ANCHORING_SET.has(value);
+}
+/**
+ * Whether `value` is a schema `ST_TextVertOverflowType` token.
+ *
+ * @private
+ */
+export function isTextVertOverflow(value) {
+    return TEXT_VERT_OVERFLOW_SET.has(value);
+}
+/**
+ * Whether `value` is a schema `ST_TextHorzOverflowType` token.
+ *
+ * @private
+ */
+export function isTextHorzOverflow(value) {
+    return TEXT_HORZ_OVERFLOW_SET.has(value);
+}
+/**
+ * Whether `value` is a schema `ST_TextVerticalType` token.
+ *
+ * @private
+ */
+export function isTextVerticalType(value) {
+    return TEXT_VERTICAL_TYPE_SET.has(value);
+}
+/**
+ * Whether `value` is a schema `ST_TextWrappingType` token (`none`|`square`).
+ *
+ * @private
+ */
+export function isTextBodyWrap(value) {
+    return TEXT_BODY_WRAP_SET.has(value);
+}
+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;
+}
+/**
+ * Shallow child lookup under `root` (direct element children only).
+ *
+ * @private
+ */
+export function findBodyPrChild(root, namespaceUri, localName) {
+    var e_1, _a;
+    try {
+        for (var _b = __values(elementChildren(root)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isElement(child, namespaceUri, localName)) {
+                return child;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return undefined;
+}
+/**
+ * Deep first-match walker under `root` (including `root` itself).
+ * Local so residual dual-AC hosts can be searched without circular imports.
+ */
+function findDeepElement(root, namespaceUri, localName) {
+    var e_2, _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 = findDeepElement(child, namespaceUri, localName);
+            if (found !== undefined) {
+                return found;
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return undefined;
+}
+function attrValue(el, localName) {
+    var __ts33_0;
+    return ((__ts33_0 = el.attributes.find(function (a) { return a.namespaceUri === '' && a.localName === localName; })), __ts33_0 == null ? undefined : __ts33_0.value);
+}
+/**
+ * Parse OOXML boolean attribute wire (`"1"`/`"true"`/`"0"`/`"false"`).
+ * Returns `undefined` when absent or unrecognized.
+ */
+function parseXmlBoolean(raw) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    if (raw === '1' || raw === 'true') {
+        return true;
+    }
+    if (raw === '0' || raw === 'false') {
+        return false;
+    }
+    return undefined;
+}
+/**
+ * Parse `ST_Coordinate32` EMU attribute to branded Point.
+ * Accepts non-negative integers only (insets are physical margins ≥ 0).
+ * Uses `emuToPoint()` so 0 is legal (unlike `lengthToEmus`, which requires > 0).
+ */
+function parseInsetEmu(raw) {
+    if (raw === undefined || !/^-?\d+$/.test(raw)) {
+        return undefined;
+    }
+    var n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n) || n < 0) {
+        return undefined;
+    }
+    return emuToPoint(n);
+}
+/**
+ * Parse percent-ish autofit attributes.
+ * Accepts either plain decimal (`100000`) or percent-string (`100%`).
+ * fontScale schema range is 1000…100000 when decimal.
+ */
+function parsePercentAttr(raw) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    if (/^\d+%$/.test(raw)) {
+        var pct = Number.parseInt(raw.slice(0, -1), 10);
+        if (!Number.isFinite(pct)) {
+            return undefined;
+        }
+        // Map "100%" → 100000, "50%" → 50000 (percent × 1000).
+        return pct * 1000;
+    }
+    if (/^\d+$/.test(raw)) {
+        return Number.parseInt(raw, 10);
+    }
+    return undefined;
+}
+function parseAutoFit(bodyPr) {
+    if (findBodyPrChild(bodyPr, A_NS, 'noAutofit') !== undefined) {
+        return { kind: 'none' };
+    }
+    if (findBodyPrChild(bodyPr, A_NS, 'spAutoFit') !== undefined) {
+        return { kind: 'shape' };
+    }
+    var norm = findBodyPrChild(bodyPr, A_NS, 'normAutofit');
+    if (norm !== undefined) {
+        var fontScale = parsePercentAttr(attrValue(norm, 'fontScale'));
+        var lineSpaceReduction = parsePercentAttr(attrValue(norm, 'lnSpcReduction'));
+        var result = { kind: 'normal' };
+        if (fontScale !== undefined) {
+            result.fontScale = fontScale;
+        }
+        if (lineSpaceReduction !== undefined) {
+            result.lineSpaceReduction = lineSpaceReduction;
+        }
+        return result;
+    }
+    return undefined;
+}
+/**
+ * Locate `wps:bodyPr` under a residual dual-AC drawing host.
+ *
+ * @private
+ */
+export function findBodyPrElement(residual) {
+    return findDeepElement(residual, WPS_NS, 'bodyPr');
+}
+/**
+ * Locate `wps:txbx` under a residual dual-AC drawing host.
+ *
+ * @private
+ */
+export function findTxbxElement(residual) {
+    return findDeepElement(residual, WPS_NS, 'txbx');
+}
+/**
+ * Locate `w:txbxContent` under a residual host (WML namespace, local `txbxContent`).
+ *
+ * @private
+ */
+export function findTxbxContentElement(residual) {
+    var e_3, _a;
+    // Walk from txbx first when present; fall back to deep search.
+    var txbx = findTxbxElement(residual);
+    if (txbx !== undefined) {
+        try {
+            for (var _b = __values(elementChildren(txbx)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                if (child.localName === 'txbxContent') {
+                    return child;
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+    }
+    // Deep fallback (any namespace with localName txbxContent).
+    var walk = function (root) {
+        var e_4, _a;
+        if (root.localName === 'txbxContent') {
+            return root;
+        }
+        try {
+            for (var _b = __values(elementChildren(root)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                var found = walk(child);
+                if (found !== undefined) {
+                    return found;
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        return undefined;
+    };
+    return walk(residual);
+}
+/**
+ * Read `wps:bodyPr` MVP state from residual DrawingML host.
+ *
+ * Residual hosts are dual MC AlternateContent trees, so `wps:bodyPr` is
+ * located with a deep walk. Children of the found bodyPr stay shallow.
+ *
+ * Cites: `CT_TextBodyProperties` + `EG_TextAutofit` (dml-main.xsd);
+ * `CT_WordprocessingShape/bodyPr` (dml-wordprocessingDrawing.xsd).
+ *
+ * @private
+ */
+export function readBodyPropertiesState(residual) {
+    var bodyPr = findBodyPrElement(residual);
+    if (bodyPr === undefined) {
+        return {
+            verticalAnchor: undefined,
+            anchorCenter: undefined,
+            textDirection: undefined,
+            textWrapInside: undefined,
+            verticalOverflow: undefined,
+            horizontalOverflow: undefined,
+            fromWordArt: undefined,
+            insets: undefined,
+            autoFit: undefined,
+            hasPresetTextWarp: false,
+            residual: false,
+        };
+    }
+    var anchorRaw = attrValue(bodyPr, 'anchor');
+    var vertRaw = attrValue(bodyPr, 'vert');
+    var wrapRaw = attrValue(bodyPr, 'wrap');
+    var vertOverflowRaw = attrValue(bodyPr, 'vertOverflow');
+    var horzOverflowRaw = attrValue(bodyPr, 'horzOverflow');
+    var left = parseInsetEmu(attrValue(bodyPr, 'lIns'));
+    var top = parseInsetEmu(attrValue(bodyPr, 'tIns'));
+    var right = parseInsetEmu(attrValue(bodyPr, 'rIns'));
+    var bottom = parseInsetEmu(attrValue(bodyPr, 'bIns'));
+    var hasAnyInset = left !== undefined || top !== undefined || right !== undefined || bottom !== undefined;
+    var insets;
+    if (hasAnyInset) {
+        var insetOut = {};
+        if (left !== undefined) {
+            insetOut.left = left;
+        }
+        if (top !== undefined) {
+            insetOut.top = top;
+        }
+        if (right !== undefined) {
+            insetOut.right = right;
+        }
+        if (bottom !== undefined) {
+            insetOut.bottom = bottom;
+        }
+        insets = insetOut;
+    }
+    var hasPresetTextWarp = findBodyPrChild(bodyPr, A_NS, 'prstTxWarp') !== undefined;
+    var hasScene3d = findBodyPrChild(bodyPr, A_NS, 'scene3d') !== undefined;
+    var hasSp3d = findBodyPrChild(bodyPr, A_NS, 'sp3d') !== undefined;
+    var hasFlatTx = findBodyPrChild(bodyPr, A_NS, 'flatTx') !== undefined;
+    var hasExtLst = findBodyPrChild(bodyPr, A_NS, 'extLst') !== undefined;
+    // Modeled attrs only; any other bodyPr attrs count as residual.
+    var modeledAttrNames = new Set([
+        'anchor',
+        'anchorCtr',
+        'vert',
+        'wrap',
+        'vertOverflow',
+        'horzOverflow',
+        'fromWordArt',
+        'lIns',
+        'tIns',
+        'rIns',
+        'bIns',
+    ]);
+    var hasUnknownAttrs = bodyPr.attributes.some(function (a) { return a.namespaceUri === '' && !modeledAttrNames.has(a.localName); });
+    return {
+        verticalAnchor: anchorRaw !== undefined && isTextAnchoring(anchorRaw) ? anchorRaw : undefined,
+        anchorCenter: parseXmlBoolean(attrValue(bodyPr, 'anchorCtr')),
+        textDirection: vertRaw !== undefined && isTextVerticalType(vertRaw) ? vertRaw : undefined,
+        textWrapInside: wrapRaw !== undefined && isTextBodyWrap(wrapRaw) ? wrapRaw : undefined,
+        verticalOverflow: vertOverflowRaw !== undefined && isTextVertOverflow(vertOverflowRaw)
+            ? vertOverflowRaw
+            : undefined,
+        horizontalOverflow: horzOverflowRaw !== undefined && isTextHorzOverflow(horzOverflowRaw)
+            ? horzOverflowRaw
+            : undefined,
+        fromWordArt: parseXmlBoolean(attrValue(bodyPr, 'fromWordArt')),
+        insets: insets,
+        autoFit: parseAutoFit(bodyPr),
+        hasPresetTextWarp: hasPresetTextWarp,
+        residual: hasPresetTextWarp || hasScene3d || hasSp3d || hasFlatTx || hasExtLst || hasUnknownAttrs,
+    };
+}
+function buildEmptyAElement(localName) {
+    return {
+        kind: 'element',
+        namespaceUri: A_NS,
+        localName: localName,
+        prefix: 'a',
+        attributes: [],
+        namespaceDeclarations: [],
+        children: [],
+    };
+}
+function buildNormAutofit(fontScale, lineSpaceReduction) {
+    var attributes = [];
+    if (fontScale !== undefined) {
+        if (!Number.isInteger(fontScale) ||
+            fontScale < FONT_SCALE_MIN ||
+            fontScale > FONT_SCALE_MAX) {
+            throw new DocxError('content/invalid-shape', "normAutofit fontScale " + String(fontScale) + " outside ST_TextFontScalePercent range " + String(FONT_SCALE_MIN) + "\u2026" + String(FONT_SCALE_MAX));
+        }
+        attributes.push({
+            namespaceUri: '',
+            localName: 'fontScale',
+            prefix: '',
+            value: String(fontScale),
+        });
+    }
+    if (lineSpaceReduction !== undefined) {
+        if (!Number.isInteger(lineSpaceReduction) || lineSpaceReduction < 0) {
+            throw new DocxError('content/invalid-shape', "normAutofit lnSpcReduction " + String(lineSpaceReduction) + " must be a non-negative integer");
+        }
+        attributes.push({
+            namespaceUri: '',
+            localName: 'lnSpcReduction',
+            prefix: '',
+            value: String(lineSpaceReduction),
+        });
+    }
+    return {
+        kind: 'element',
+        namespaceUri: A_NS,
+        localName: 'normAutofit',
+        prefix: 'a',
+        attributes: attributes,
+        namespaceDeclarations: [],
+        children: [],
+    };
+}
+function buildAutoFitChild(autoFit) {
+    if (autoFit.kind === 'none') {
+        return buildEmptyAElement('noAutofit');
+    }
+    if (autoFit.kind === 'shape') {
+        return buildEmptyAElement('spAutoFit');
+    }
+    return buildNormAutofit(autoFit.fontScale, autoFit.lineSpaceReduction);
+}
+/**
+ * Convert inset points to a non-negative wire EMU integer string.
+ * 0 is legal for insets; uses pointToCoordinateEmus (allows 0).
+ */
+function insetToEmuString(value) {
+    var emu = pointToCoordinateEmus(value);
+    if (!Number.isInteger(emu) || emu < 0) {
+        throw new DocxError('content/invalid-shape', "bodyPr inset must be a non-negative point value convertible to EMU, got " + String(value));
+    }
+    return String(emu);
+}
+/**
+ * Build `wps:bodyPr` from the modeled MVP subset.
+ *
+ * Always emits the element (schema requires bodyPr on `wps:wsp`). When no
+ * modeled fields are set, emits empty `<wps:bodyPr/>`.
+ *
+ * Autofit children use the DrawingML `a:` namespace. Residual warp/3d/extLst
+ * are not re-emitted on the full structure rebuild path.
+ *
+ * @private
+ */
+export function buildBodyPrElement(state) {
+    var attributes = [];
+    if (state.verticalAnchor !== undefined) {
+        if (!isTextAnchoring(state.verticalAnchor)) {
+            throw new DocxError('content/invalid-shape', "Invalid bodyPr anchor \"" + String(state.verticalAnchor) + "\"");
+        }
+        attributes.push({
+            namespaceUri: '',
+            localName: 'anchor',
+            prefix: '',
+            value: state.verticalAnchor,
+        });
+    }
+    if (state.anchorCenter !== undefined) {
+        attributes.push({
+            namespaceUri: '',
+            localName: 'anchorCtr',
+            prefix: '',
+            value: state.anchorCenter ? '1' : '0',
+        });
+    }
+    if (state.textDirection !== undefined) {
+        if (!isTextVerticalType(state.textDirection)) {
+            throw new DocxError('content/invalid-shape', "Invalid bodyPr vert \"" + String(state.textDirection) + "\"");
+        }
+        attributes.push({
+            namespaceUri: '',
+            localName: 'vert',
+            prefix: '',
+            value: state.textDirection,
+        });
+    }
+    if (state.textWrapInside !== undefined) {
+        if (!isTextBodyWrap(state.textWrapInside)) {
+            throw new DocxError('content/invalid-shape', "Invalid bodyPr wrap \"" + String(state.textWrapInside) + "\" (schema: none|square only)");
+        }
+        attributes.push({
+            namespaceUri: '',
+            localName: 'wrap',
+            prefix: '',
+            value: state.textWrapInside,
+        });
+    }
+    if (state.verticalOverflow !== undefined) {
+        if (!isTextVertOverflow(state.verticalOverflow)) {
+            throw new DocxError('content/invalid-shape', "Invalid bodyPr vertOverflow \"" + String(state.verticalOverflow) + "\"");
+        }
+        attributes.push({
+            namespaceUri: '',
+            localName: 'vertOverflow',
+            prefix: '',
+            value: state.verticalOverflow,
+        });
+    }
+    if (state.horizontalOverflow !== undefined) {
+        if (!isTextHorzOverflow(state.horizontalOverflow)) {
+            throw new DocxError('content/invalid-shape', "Invalid bodyPr horzOverflow \"" + String(state.horizontalOverflow) + "\"");
+        }
+        attributes.push({
+            namespaceUri: '',
+            localName: 'horzOverflow',
+            prefix: '',
+            value: state.horizontalOverflow,
+        });
+    }
+    if (state.fromWordArt !== undefined) {
+        attributes.push({
+            namespaceUri: '',
+            localName: 'fromWordArt',
+            prefix: '',
+            value: state.fromWordArt ? '1' : '0',
+        });
+    }
+    var insets = state.insets;
+    if (insets !== undefined) {
+        if (insets.left !== undefined) {
+            attributes.push({
+                namespaceUri: '',
+                localName: 'lIns',
+                prefix: '',
+                value: insetToEmuString(insets.left),
+            });
+        }
+        if (insets.top !== undefined) {
+            attributes.push({
+                namespaceUri: '',
+                localName: 'tIns',
+                prefix: '',
+                value: insetToEmuString(insets.top),
+            });
+        }
+        if (insets.right !== undefined) {
+            attributes.push({
+                namespaceUri: '',
+                localName: 'rIns',
+                prefix: '',
+                value: insetToEmuString(insets.right),
+            });
+        }
+        if (insets.bottom !== undefined) {
+            attributes.push({
+                namespaceUri: '',
+                localName: 'bIns',
+                prefix: '',
+                value: insetToEmuString(insets.bottom),
+            });
+        }
+    }
+    var children = [];
+    if (state.autoFit !== undefined) {
+        children.push(buildAutoFitChild(state.autoFit));
+    }
+    return {
+        kind: 'element',
+        namespaceUri: WPS_NS,
+        localName: 'bodyPr',
+        prefix: 'wps',
+        attributes: attributes,
+        namespaceDeclarations: [],
+        children: children,
+    };
+}
+/**
+ * Whether any modeled bodyPr field is present (used by encode path to decide
+ * empty vs populated bodyPr emission — empty is still required on wsp).
+ *
+ * @private
+ */
+export function hasModeledBodyPrFields(state) {
+    return (state.verticalAnchor !== undefined ||
+        state.anchorCenter !== undefined ||
+        state.textDirection !== undefined ||
+        state.textWrapInside !== undefined ||
+        state.verticalOverflow !== undefined ||
+        state.horizontalOverflow !== undefined ||
+        state.fromWordArt !== undefined ||
+        state.insets !== undefined ||
+        state.autoFit !== undefined);
+}
+/**
+ * Public text direction inside a shape text frame (`wps:bodyPr/@vert`).
+ * @public
+ */
+export var TextDirection = {
+    Horizontal: 'horz',
+    Vertical: 'vert',
+    Vertical270: 'vert270',
+    WordArtVertical: 'wordArtVert',
+    EastAsianVertical: 'eaVert',
+    MongolianVertical: 'mongolianVert',
+    WordArtVerticalRtl: 'wordArtVertRtl',
+};
+/**
+ * Public vertical alignment of text inside a shape text frame (`wps:bodyPr/@anchor`).
+ * @public
+ */
+export var TextVerticalAlignment = {
+    Top: 't',
+    Center: 'ctr',
+    Bottom: 'b',
+    Justified: 'just',
+    Distributed: 'dist',
+};