@syncfusion/ej2-office-common 35.1.37 → 35.1.42

package/src/office-common/features/mathml/serialize/office-math-properties-writer.js

@@ -0,0 +1,267 @@
+/**
+ * Writers that turn explicit Office Math properties into `m:*Pr` children.
+ *
+ * Source: ECMA-376-1 §22.1.2 (shared-math.xsd). Only explicitly set properties are written, in schema order.
+ */
+var _a;
+import { MathFunctionType } from '../office-math/enums';
+import { K } from '../office-math/keys';
+import { invalid, mathAttribute, mathElement, token, unsigned, valueElement, writeFlags, writeValue } from './omml-writer';
+var FRACTION = ['bar', 'noBar', 'skw', 'lin'];
+var VERTICAL = ['center', 'top', 'bottom'];
+var HORIZONTAL = ['center', 'left', 'right'];
+var SHAPE = ['centered', 'match'];
+var FONT = ['double-struck', 'fraktur', 'monospace', 'roman', 'sans-serif', 'script'];
+var STYLE = ['i', 'bi', 'b', 'p'];
+/** Element name of the property container of each function. @private */
+export var PROPERTY_ELEMENT = (_a = {},
+    _a[MathFunctionType.Accent] = 'accPr',
+    _a[MathFunctionType.Bar] = 'barPr',
+    _a[MathFunctionType.BorderBox] = 'borderBoxPr',
+    _a[MathFunctionType.Box] = 'boxPr',
+    _a[MathFunctionType.Delimiter] = 'dPr',
+    _a[MathFunctionType.EquationArray] = 'eqArrPr',
+    _a[MathFunctionType.Fraction] = 'fPr',
+    _a[MathFunctionType.Function] = 'funcPr',
+    _a[MathFunctionType.GroupCharacter] = 'groupChrPr',
+    _a[MathFunctionType.Matrix] = 'mPr',
+    _a[MathFunctionType.NArray] = 'naryPr',
+    _a[MathFunctionType.Phantom] = 'phantPr',
+    _a[MathFunctionType.Radical] = 'radPr',
+    _a[MathFunctionType.LeftSubSuperscript] = 'sPrePr',
+    _a[MathFunctionType.RightSubSuperscript] = 'sSubSupPr',
+    _a);
+/**
+ * Writes `m:brk` when the break has an explicit alignment point, otherwise an empty `m:brk`. @private
+ *
+ * @param {WriteContext} ctx The write context.
+ * @param {OfficeMathBreak} brk The break.
+ * @returns {OpenXmlChild} The element.
+ */
+export function writeBreak(ctx, brk) {
+    if (!brk.isExplicit(K.AlignAt)) {
+        return mathElement(ctx, 'brk');
+    }
+    if (!Number.isInteger(brk.alignAt) || brk.alignAt < 1 || brk.alignAt > 255) {
+        invalid('alnAt must be an integer in 1..255, got ' + String(brk.alignAt), 'brk.alnAt', 'value-range');
+    }
+    return mathElement(ctx, 'brk', [], [mathAttribute(ctx, 'alnAt', String(brk.alignAt))]);
+}
+/**
+ * Writes the children of `m:rPr`. `m:nor` excludes `m:scr`/`m:sty` per the schema choice. @private
+ *
+ * @param {WriteContext} ctx The write context.
+ * @param {OfficeMathFormat} format The Math run format.
+ * @returns {OpenXmlChild[]} The children.
+ */
+export function runFormatChildren(ctx, format) {
+    var out = [];
+    writeFlags(ctx, out, format, [[K.HasLiteral, 'lit', format.hasLiteral]]);
+    var normal = format.isExplicit(K.HasNormalText) && (format.hasNormalText || !isScriptStyle(format));
+    if (normal) {
+        writeFlags(ctx, out, format, [[K.HasNormalText, 'nor', format.hasNormalText]]);
+    }
+    else {
+        writeValue(ctx, out, format, K.Script, 'scr', function () { return token(FONT, format.font, 'rPr.scr', 'ST_Script'); });
+        writeValue(ctx, out, format, K.Style, 'sty', function () { return token(STYLE, format.style, 'rPr.sty', 'ST_Style'); });
+    }
+    if (format.break !== undefined) {
+        out.push(writeBreak(ctx, format.break));
+    }
+    writeFlags(ctx, out, format, [[K.HasAlignment, 'aln', format.hasAlignment]]);
+    return out;
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OfficeMathFormat} format The Math run format.
+ * @returns {boolean} True when a script or style is explicit.
+ */
+function isScriptStyle(format) {
+    return format.isExplicit(K.Script) || format.isExplicit(K.Style);
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {number} rule The spacing rule.
+ * @param {string} path The element path.
+ * @returns {string} The decimal text.
+ */
+function ruleText(rule, path) {
+    return rule >= 0 && rule <= 4 && Number.isInteger(rule) ? String(rule) : invalid('Illegal spacing rule ' + String(rule), path, 'enum-value');
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {WriteContext} ctx The write context.
+ * @param {OpenXmlChild[]} out The children being built.
+ * @param {OfficeMathEquationArray | OfficeMathMatrix} fn The function.
+ * @param {string} path The element path.
+ * @returns {void}
+ */
+function rowSpacing(ctx, out, fn, path) {
+    writeValue(ctx, out, fn, K.RowSpacingRule, 'rSpRule', function () { return ruleText(fn.rowSpacingRule, path + '.rSpRule'); });
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {WriteContext} ctx The write context.
+ * @param {OpenXmlChild[]} out The children being built.
+ * @param {OfficeMathEquationArray} fn The equation array.
+ * @returns {void}
+ */
+function equationArray(ctx, out, fn) {
+    writeValue(ctx, out, fn, K.EqArrAlign, 'baseJc', function () { return token(VERTICAL, fn.verticalAlignment, 'eqArrPr.baseJc', 'ST_YAlign'); });
+    writeFlags(ctx, out, fn, [[K.MaxDist, 'maxDist', fn.expandEquationContainer], [K.ObjDist, 'objDist', fn.expandEquationContent]]);
+    rowSpacing(ctx, out, fn, 'eqArrPr');
+    writeValue(ctx, out, fn, K.RowSpacing, 'rSp', function () { return unsigned(fn.rowSpacing, 'eqArrPr.rSp'); });
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {WriteContext} ctx The write context.
+ * @param {OpenXmlChild[]} out The children being built.
+ * @param {OfficeMathMatrix} fn The matrix.
+ * @returns {void}
+ */
+function matrix(ctx, out, fn) {
+    writeValue(ctx, out, fn, K.MatrixAlign, 'baseJc', function () { return token(VERTICAL, fn.verticalAlignment, 'mPr.baseJc', 'ST_YAlign'); });
+    writeFlags(ctx, out, fn, [[K.PlaceHoldHidden, 'plcHide', fn.hidePlaceholder]]);
+    rowSpacing(ctx, out, fn, 'mPr');
+    writeValue(ctx, out, fn, K.ColumnGapRule, 'cGpRule', function () { return ruleText(fn.columnGapRule, 'mPr.cGpRule'); });
+    writeValue(ctx, out, fn, K.RowSpacing, 'rSp', function () { return unsigned(fn.rowSpacing, 'mPr.rSp'); });
+    writeValue(ctx, out, fn, K.ColumnSpacing, 'cSp', function () { return unsigned(fn.columnSpacing, 'mPr.cSp'); });
+    writeValue(ctx, out, fn, K.ColumnGap, 'cGp', function () { return unsigned(fn.columnGap, 'mPr.cGp'); });
+    var columns = matrixColumns(ctx, fn);
+    if (columns !== undefined) {
+        out.push(columns);
+    }
+}
+/**
+ * Writes `m:mcs`, grouping consecutive columns with the same explicit alignment. Omitted when no column
+ * alignment is explicit, because the parser recreates default columns from the row cells. @private
+ *
+ * @param {WriteContext} ctx The write context.
+ * @param {OfficeMathMatrix} fn The matrix.
+ * @returns {OpenXmlChild | undefined} The element, if needed.
+ */
+function matrixColumns(ctx, fn) {
+    var columns = fn.columns.toArray();
+    if (!columns.some(function (c) { return c.isExplicit(K.MatrixAlign); })) {
+        return undefined;
+    }
+    var groups = [];
+    columns.forEach(function (column) {
+        var last = groups[groups.length - 1];
+        var same = last !== undefined && last.column.isExplicit(K.MatrixAlign) === column.isExplicit(K.MatrixAlign)
+            && (!column.isExplicit(K.MatrixAlign) || last.column.horizontalAlignment === column.horizontalAlignment);
+        if (same && last !== undefined && last.count < 255) {
+            last.count++;
+        }
+        else {
+            groups.push({ column: column, count: 1 });
+        }
+    });
+    return mathElement(ctx, 'mcs', groups.map(function (g) {
+        var kids = [valueElement(ctx, 'count', String(g.count))];
+        writeValue(ctx, kids, g.column, K.MatrixAlign, 'mcJc', function () { return token(HORIZONTAL, g.column.horizontalAlignment, 'mcPr.mcJc', 'ST_XAlign'); });
+        return mathElement(ctx, 'mc', [mathElement(ctx, 'mcPr', kids)]);
+    }));
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {WriteContext} ctx The write context.
+ * @param {OpenXmlChild[]} out The children being built.
+ * @param {OfficeMathFunctionBase} fn The function.
+ * @returns {void}
+ */
+function multiProperties(ctx, out, fn) {
+    if (fn.type === MathFunctionType.Delimiter) {
+        var d_1 = fn;
+        writeValue(ctx, out, d_1, K.BegChar, 'begChr', function () { return d_1.beginCharacter; });
+        writeValue(ctx, out, d_1, K.SeparatorChar, 'sepChr', function () { return d_1.separator; });
+        writeValue(ctx, out, d_1, K.EndChar, 'endChr', function () { return d_1.endCharacter; });
+        writeFlags(ctx, out, d_1, [[K.Grow, 'grow', d_1.isGrow]]);
+        writeValue(ctx, out, d_1, K.Shape, 'shp', function () { return token(SHAPE, d_1.delimiterShape, 'dPr.shp', 'ST_Shp'); });
+    }
+    else if (fn.type === MathFunctionType.EquationArray) {
+        equationArray(ctx, out, fn);
+    }
+    else if (fn.type === MathFunctionType.Fraction) {
+        var f_1 = fn;
+        writeValue(ctx, out, f_1, K.FractionType, 'type', function () { return token(FRACTION, f_1.fractionType, 'fPr.type', 'ST_FType'); });
+    }
+    else if (fn.type === MathFunctionType.Matrix) {
+        matrix(ctx, out, fn);
+    }
+    else if (fn.type === MathFunctionType.NArray) {
+        var n_1 = fn;
+        writeValue(ctx, out, n_1, K.NAryChar, 'chr', function () { return n_1.nArrayCharacter; });
+        writeValue(ctx, out, n_1, K.SubSupLimit, 'limLoc', function () { return n_1.subSuperscriptLimit ? 'subSup' : 'undOvr'; });
+        writeFlags(ctx, out, n_1, [[K.HasGrow, 'grow', n_1.hasGrow], [K.HideSubscript, 'subHide', n_1.hideLowerLimit],
+            [K.HideSuperscript, 'supHide', n_1.hideUpperLimit]]);
+    }
+    else if (fn.type === MathFunctionType.RightSubSuperscript) {
+        writeFlags(ctx, out, fn, [[K.SkipAlign, 'alnScr', fn.isSkipAlign]]);
+    }
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {WriteContext} ctx The write context.
+ * @param {OpenXmlChild[]} out The children being built.
+ * @param {OfficeMathFunctionBase} fn The function.
+ * @returns {void}
+ */
+function basicProperties(ctx, out, fn) {
+    if (fn.type === MathFunctionType.Accent) {
+        writeValue(ctx, out, fn, K.AccentChar, 'chr', function () { return fn.accentCharacter; });
+    }
+    else if (fn.type === MathFunctionType.Bar) {
+        writeValue(ctx, out, fn, K.BarTop, 'pos', function () { return fn.barTop ? 'top' : 'bot'; });
+    }
+    else if (fn.type === MathFunctionType.BorderBox) {
+        var b = fn;
+        writeFlags(ctx, out, b, [[K.HideTop, 'hideTop', b.hideTop], [K.HideBottom, 'hideBot', b.hideBottom],
+            [K.HideLeft, 'hideLeft', b.hideLeft], [K.HideRight, 'hideRight', b.hideRight],
+            [K.StrikeHorizontal, 'strikeH', b.strikeHorizontal], [K.StrikeVertical, 'strikeV', b.strikeVertical],
+            [K.StrikeBLTR, 'strikeBLTR', b.strikeDiagonalUp], [K.StrikeTLBR, 'strikeTLBR', b.strikeDiagonalDown]]);
+    }
+    else if (fn.type === MathFunctionType.Box) {
+        var b = fn;
+        writeFlags(ctx, out, b, [[K.OperatorEmulator, 'opEmu', b.operatorEmulator], [K.NoBreak, 'noBreak', b.noBreak],
+            [K.EnableDifferential, 'diff', b.enableDifferential]]);
+        if (b.break !== undefined) {
+            out.push(writeBreak(ctx, b.break));
+        }
+        writeFlags(ctx, out, b, [[K.BoxAlign, 'aln', b.alignment]]);
+    }
+    else if (fn.type === MathFunctionType.GroupCharacter) {
+        var g_1 = fn;
+        writeValue(ctx, out, g_1, K.GroupChar, 'chr', function () { return g_1.groupCharacter; });
+        writeValue(ctx, out, g_1, K.HasCharTop, 'pos', function () { return g_1.hasCharacterTop ? 'top' : 'bot'; });
+        writeValue(ctx, out, g_1, K.HasAlignTop, 'vertJc', function () { return g_1.hasAlignTop ? 'top' : 'bot'; });
+    }
+    else if (fn.type === MathFunctionType.Phantom) {
+        var p = fn;
+        writeFlags(ctx, out, p, [[K.Show, 'show', p.show], [K.ZeroWidth, 'zeroWid', p.zeroWidth],
+            [K.ZeroAscent, 'zeroAsc', p.zeroAscent], [K.ZeroDescent, 'zeroDesc', p.zeroDescent], [K.Transparent, 'transp', p.transparent]]);
+    }
+    else if (fn.type === MathFunctionType.Radical) {
+        writeFlags(ctx, out, fn, [[K.HideDegree, 'degHide', fn.hideDegree]]);
+    }
+}
+/**
+ * Writes the explicit properties of a function in schema order, excluding `m:ctrlPr`. @private
+ *
+ * @param {WriteContext} ctx The write context.
+ * @param {OfficeMathFunctionBase} fn The function.
+ * @returns {OpenXmlChild[]} The property children.
+ */
+export function functionProperties(ctx, fn) {
+    var out = [];
+    basicProperties(ctx, out, fn);
+    multiProperties(ctx, out, fn);
+    return out;
+}

package/src/office-common/features/mathml/serialize/office-math-serializer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Office Math model → OMML serializer.
+ *
+ * Source: ECMA-376-1 §22.1 (shared-math.xsd). Writes only explicitly set properties, in schema order, and
+ * re-emits {@link OfficeMathUnknownElement} content verbatim. Throws {@link MathmlValidationError} for
+ * structures the schema forbids (for example a delimiter without an `m:e`).
+ */
+import { OpenXmlElement } from '../openxml';
+import { OfficeMathParagraph } from '../office-math/math-paragraph';
+import { SerializeOfficeMathOptions } from './omml-writer';
+export { SerializeOfficeMathOptions } from './omml-writer';
+/**
+ * Serializes an {@link OfficeMathParagraph} to `m:oMathPara`, or to a bare `m:oMath` for an inline
+ * paragraph (one equation, no explicit justification). A paragraph that holds a verbatim-preserved malformed
+ * root re-emits that root unchanged.
+ *
+ * @param {OfficeMathParagraph} paragraph The model.
+ * @param {SerializeOfficeMathOptions} options Optional serializer options.
+ * @returns {OpenXmlElement} The `m:oMathPara` or `m:oMath` element.
+ * @throws {MathmlValidationError} When the model violates the schema.
+ * @public
+ */
+export declare function serializeOfficeMathParagraph(paragraph: OfficeMathParagraph, options?: SerializeOfficeMathOptions): OpenXmlElement;

package/src/office-common/features/mathml/serialize/office-math-serializer.js

@@ -0,0 +1,306 @@
+/**
+ * Office Math model → OMML serializer.
+ *
+ * Source: ECMA-376-1 §22.1 (shared-math.xsd). Writes only explicitly set properties, in schema order, and
+ * re-emits {@link OfficeMathUnknownElement} content verbatim. Throws {@link MathmlValidationError} for
+ * structures the schema forbids (for example a delimiter without an `m:e`).
+ */
+import { MATH_NAMESPACE, XML_NAMESPACE } from '../constants';
+import { createText } from '../openxml';
+import { MathFunctionType, MathLimitType, MathScriptType } from '../office-math/enums';
+import { BasicRun, BasicRunFormat } from '../office-math/basic';
+import { K } from '../office-math/keys';
+import { OfficeMathUnknownElement } from '../office-math/unknown-element';
+import { invalid, mathElement, resolveMathPrefix, token, valueElement } from './omml-writer';
+import { functionProperties, PROPERTY_ELEMENT, runFormatChildren } from './office-math-properties-writer';
+var JUSTIFICATION = ['centerGroup', 'center', 'left', 'right'];
+/**
+ * Implementation helper. @private
+ *
+ * @param {OfficeMathFunctionBase} fn The function.
+ * @returns {Layout | undefined} The layout, or undefined for list/matrix/run/unknown functions.
+ */
+function layoutOf(fn) {
+    switch (fn.type) {
+        case MathFunctionType.Accent: return { name: 'acc', pr: 'accPr', args: [['e', fn.equation]] };
+        case MathFunctionType.Bar: return { name: 'bar', pr: 'barPr', args: [['e', fn.equation]] };
+        case MathFunctionType.BorderBox: return { name: 'borderBox', pr: 'borderBoxPr', args: [['e', fn.equation]] };
+        case MathFunctionType.Box: return { name: 'box', pr: 'boxPr', args: [['e', fn.equation]] };
+        case MathFunctionType.GroupCharacter:
+            return { name: 'groupChr', pr: 'groupChrPr', args: [['e', fn.equation]] };
+        case MathFunctionType.Phantom: return { name: 'phant', pr: 'phantPr', args: [['e', fn.equation]] };
+        case MathFunctionType.Radical:
+            return { name: 'rad', pr: 'radPr', args: [['deg', fn.degree], ['e', fn.equation]] };
+        case MathFunctionType.Fraction:
+            return { name: 'f', pr: 'fPr', args: [['num', fn.numerator], ['den', fn.denominator]] };
+        case MathFunctionType.Function:
+            return { name: 'func', pr: 'funcPr', args: [['fName', fn.functionName], ['e', fn.equation]] };
+        default: return layoutOfScripts(fn);
+    }
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OfficeMathFunctionBase} fn The function.
+ * @returns {Layout | undefined} The layout, or undefined when `fn` is not a limit, n-ary or script function.
+ */
+function layoutOfScripts(fn) {
+    if (fn.type === MathFunctionType.Limit) {
+        var l = fn;
+        var upper = l.limitType === MathLimitType.UpperLimit;
+        return { name: upper ? 'limUpp' : 'limLow', pr: upper ? 'limUppPr' : 'limLowPr', args: [['e', l.equation], ['lim', l.limit]] };
+    }
+    if (fn.type === MathFunctionType.NArray) {
+        var n = fn;
+        return { name: 'nary', pr: 'naryPr', args: [['sub', n.subscript], ['sup', n.superscript], ['e', n.equation]] };
+    }
+    if (fn.type === MathFunctionType.SubSuperscript) {
+        var s = fn;
+        var sub = s.scriptType === MathScriptType.Subscript;
+        return { name: sub ? 'sSub' : 'sSup', pr: sub ? 'sSubPr' : 'sSupPr', args: [['e', s.equation], [sub ? 'sub' : 'sup', s.script]] };
+    }
+    if (fn.type === MathFunctionType.RightSubSuperscript) {
+        var r = fn;
+        return { name: 'sSubSup', pr: 'sSubSupPr', args: [['e', r.equation], ['sub', r.subscript], ['sup', r.superscript]] };
+    }
+    if (fn.type === MathFunctionType.LeftSubSuperscript) {
+        var p = fn;
+        return { name: 'sPre', pr: 'sPrePr', args: [['sub', p.subscript], ['sup', p.superscript], ['e', p.equation]] };
+    }
+    return undefined;
+}
+/**
+ * Builds the `m:ctrlPr` of a function from its control properties. @private
+ *
+ * @param {WriteContext} ctx The write context.
+ * @param {OfficeMathFunctionBase} fn The function.
+ * @returns {OpenXmlChild[]} Zero or one element.
+ */
+function controlProperties(ctx, fn) {
+    if (!fn.hasControlProperties) {
+        return [];
+    }
+    if (ctx.adapter !== undefined) {
+        var kids = ctx.adapter.serializeControlProperties(fn.controlProperties);
+        return kids.length > 0 ? [mathElement(ctx, 'ctrlPr', kids)] : [];
+    }
+    var format = fn.controlProperties instanceof BasicRunFormat ? fn.controlProperties : undefined;
+    return format !== undefined && format.preservedXml !== undefined ? [format.preservedXml] : [];
+}
+/**
+ * Writes the property container (`m:*Pr`) of a function, or nothing when it would be empty. @private
+ *
+ * @param {WriteContext} ctx The write context.
+ * @param {OfficeMathFunctionBase} fn The function.
+ * @param {string} prName The container element name.
+ * @returns {OpenXmlChild[]} Zero or one element.
+ */
+function propertyContainer(ctx, fn, prName) {
+    var kids = functionProperties(ctx, fn).concat(controlProperties(ctx, fn));
+    return kids.length > 0 ? [mathElement(ctx, prName, kids)] : [];
+}
+/**
+ * Writes an argument element (`m:e`, `m:num`, …). @private
+ *
+ * @param {WriteContext} ctx The write context.
+ * @param {string} name The element name.
+ * @param {OfficeMath} math The argument content.
+ * @param {string} path The element path for diagnostics.
+ * @returns {OpenXmlElement} The element.
+ */
+function writeArgument(ctx, name, math, path) {
+    var kids = [];
+    if (math.isExplicit(K.ArgumentSize)) {
+        kids.push(mathElement(ctx, 'argPr', [valueElement(ctx, 'argSz', String(math.argumentSize))]));
+    }
+    writeContent(ctx, math, path).forEach(function (e) { return kids.push(e); });
+    if (math.preservedControlProperties !== undefined) {
+        kids.push(math.preservedControlProperties);
+    }
+    return mathElement(ctx, name, kids);
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {WriteContext} ctx The write context.
+ * @param {OfficeMath} math The equation.
+ * @param {string} path The element path for diagnostics.
+ * @returns {OpenXmlElement[]} The serialized functions.
+ */
+function writeContent(ctx, math, path) {
+    return math.functions.toArray().map(function (fn, i) { return writeFunction(ctx, fn, path + '[' + String(i) + ']'); });
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {WriteContext} ctx The write context.
+ * @param {string} name The element name (`d` or `eqArr`).
+ * @param {OfficeMathDelimiter | OfficeMathEquationArray} fn The function.
+ * @param {string} prName The property container name.
+ * @param {string} path The element path for diagnostics.
+ * @returns {OpenXmlElement} The element.
+ */
+function writeList(ctx, name, fn, prName, path) {
+    if (fn.equations.count < 1) {
+        invalid('m:' + name + ' requires at least one m:e', path, 'required-child');
+    }
+    var kids = propertyContainer(ctx, fn, prName);
+    fn.equations.toArray().forEach(function (e, i) { return kids.push(writeArgument(ctx, 'e', e, path + '.e[' + String(i) + ']')); });
+    return mathElement(ctx, name, kids);
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {WriteContext} ctx The write context.
+ * @param {OfficeMathMatrix} fn The matrix.
+ * @param {string} path The element path for diagnostics.
+ * @returns {OpenXmlElement} The element.
+ */
+function writeMatrix(ctx, fn, path) {
+    if (fn.rows.count < 1) {
+        invalid('m:m requires at least one m:mr', path, 'required-child');
+    }
+    var kids = propertyContainer(ctx, fn, PROPERTY_ELEMENT[MathFunctionType.Matrix]);
+    fn.rowItems.forEach(function (row, r) {
+        var cells = row.arguments.toArray()
+            .map(function (cell, c) { return writeArgument(ctx, 'e', cell, path + '.mr[' + String(r) + '].e[' + String(c) + ']'); });
+        kids.push(mathElement(ctx, 'mr', cells));
+    });
+    return mathElement(ctx, 'm', kids);
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {string} value The text.
+ * @returns {boolean} True when leading or trailing whitespace needs `xml:space="preserve"`.
+ */
+function needsPreserve(value) {
+    return value.length === 0 || /^\s|\s$/.test(value);
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {WriteContext} ctx The write context.
+ * @param {BasicRunPart} part The run part.
+ * @returns {OpenXmlChild} The serialized part.
+ */
+function writeRunPart(ctx, part) {
+    if (part.kind === 'xml') {
+        return part.element;
+    }
+    var space = part.space !== undefined ? part.space : needsPreserve(part.value) ? 'preserve' : undefined;
+    var attrs = space === undefined ? [] : [{ namespaceUri: XML_NAMESPACE, localName: 'space', prefix: 'xml', value: space }];
+    return mathElement(ctx, 't', [createText(part.value)], attrs);
+}
+/**
+ * Writes `m:r`: `m:rPr`, then the host/WordprocessingML run content. @private
+ *
+ * @param {WriteContext} ctx The write context.
+ * @param {OfficeMathRunElement} run The run element.
+ * @returns {OpenXmlElement} The element.
+ */
+function writeRun(ctx, run) {
+    var kids = [];
+    var format = runFormatChildren(ctx, run.mathFormat);
+    if (format.length > 0) {
+        kids.push(mathElement(ctx, 'rPr', format));
+    }
+    if (ctx.adapter !== undefined) {
+        ctx.adapter.serializeMathRun(run).forEach(function (e) { return kids.push(e); });
+    }
+    else if (run.item instanceof BasicRun) {
+        if (run.item.runProperties !== undefined) {
+            kids.push(run.item.runProperties);
+        }
+        run.item.parts.forEach(function (part) { return kids.push(writeRunPart(ctx, part)); });
+    }
+    return mathElement(ctx, 'r', kids);
+}
+/**
+ * Serializes one function. @private
+ *
+ * @param {WriteContext} ctx The write context.
+ * @param {OfficeMathFunctionBase} fn The function.
+ * @param {string} path The element path for diagnostics.
+ * @returns {OpenXmlElement} The element.
+ */
+function writeFunction(ctx, fn, path) {
+    if (fn instanceof OfficeMathUnknownElement) {
+        return fn.preservedXml;
+    }
+    if (fn.type === MathFunctionType.RunElement) {
+        return writeRun(ctx, fn);
+    }
+    if (fn.type === MathFunctionType.Delimiter) {
+        return writeList(ctx, 'd', fn, 'dPr', path);
+    }
+    if (fn.type === MathFunctionType.EquationArray) {
+        return writeList(ctx, 'eqArr', fn, 'eqArrPr', path);
+    }
+    if (fn.type === MathFunctionType.Matrix) {
+        return writeMatrix(ctx, fn, path);
+    }
+    var layout = layoutOf(fn);
+    if (layout === undefined) {
+        return invalid('Unsupported Math function type ' + String(fn.type), path, 'enum-value');
+    }
+    var kids = propertyContainer(ctx, fn, layout.pr);
+    layout.args.forEach(function (a) { return kids.push(writeArgument(ctx, a[0], a[1], path + '.' + a[0])); });
+    return mathElement(ctx, layout.name, kids);
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OfficeMathParagraph} paragraph The paragraph.
+ * @returns {OpenXmlElement | undefined} A malformed root that the parser preserved verbatim, if that is all the paragraph holds.
+ */
+function preservedRoot(paragraph) {
+    if (paragraph.maths.count !== 1 || paragraph.maths.getItem(0).functions.count !== 1) {
+        return undefined;
+    }
+    var only = paragraph.maths.getItem(0).functions.getItem(0);
+    var isRoot = only instanceof OfficeMathUnknownElement && only.preservedXml.namespaceUri === MATH_NAMESPACE
+        && (only.localName === 'oMath' || only.localName === 'oMathPara');
+    return isRoot ? only.preservedXml : undefined;
+}
+/**
+ * Serializes an {@link OfficeMathParagraph} to `m:oMathPara`, or to a bare `m:oMath` for an inline
+ * paragraph (one equation, no explicit justification). A paragraph that holds a verbatim-preserved malformed
+ * root re-emits that root unchanged.
+ *
+ * @param {OfficeMathParagraph} paragraph The model.
+ * @param {SerializeOfficeMathOptions} options Optional serializer options.
+ * @returns {OpenXmlElement} The `m:oMathPara` or `m:oMath` element.
+ * @throws {MathmlValidationError} When the model violates the schema.
+ * @public
+ */
+export function serializeOfficeMathParagraph(paragraph, options) {
+    var adapter = paragraph.adapter;
+    var ctx = { prefix: resolveMathPrefix(options), adapter: adapter };
+    var preserved = preservedRoot(paragraph);
+    if (preserved !== undefined) {
+        return preserved;
+    }
+    var display = options !== undefined && options.display !== undefined
+        ? options.display : paragraph.hasExplicitJustification || paragraph.maths.count !== 1;
+    var maths = paragraph.maths.toArray();
+    if (maths.length < 1) {
+        invalid('An equation paragraph requires at least one m:oMath', 'oMathPara', 'required-child');
+    }
+    if (!display) {
+        if (maths.length > 1) {
+            invalid('A bare m:oMath holds exactly one equation', 'oMath', 'child-order');
+        }
+        return mathElement(ctx, 'oMath', writeContent(ctx, maths[0], 'oMath'));
+    }
+    var kids = [];
+    if (paragraph.hasExplicitJustification) {
+        var jc = token(JUSTIFICATION, paragraph.justification, 'oMathParaPr.jc', 'ST_Jc');
+        kids.push(mathElement(ctx, 'oMathParaPr', [valueElement(ctx, 'jc', jc)]));
+    }
+    maths.forEach(function (m, i) {
+        var path = 'oMathPara.oMath[' + String(i) + ']';
+        kids.push(mathElement(ctx, 'oMath', writeContent(ctx, m, path)));
+    });
+    return mathElement(ctx, 'oMathPara', kids);
+}