@syncfusion/ej2-office-common 35.1.37

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

@@ -0,0 +1,749 @@
+/**
+ * Strict typed Math* DOM → OMML OpenXml element-tree serializer.
+ *
+ * Source: mathml-spec §9; ECMA-376-4 Annex A.8.1.
+ * Throws {@link MathmlValidationError} on schema violations (typed path).
+ * Preserve-only / unknown nodes re-emit `preservedXml` verbatim.
+ */
+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;
+};
+import { MATH_NAMESPACE, MATH_PREFIX_FALLBACKS, XML_NAMESPACE } from '../constants';
+import { MathmlValidationError } from '../errors';
+import { createElement, createText } from '../openxml';
+import { MATH_FTYPE_VALUES, MATH_JC_VALUES, MATH_LIMLOC_VALUES, MATH_SCRIPT_VALUES, MATH_SHP_VALUES, MATH_STYLE_VALUES, MATH_TOPBOT_VALUES, isInteger2, isInteger255 } from '../model/enums';
+import { UnknownMathElement } from '../model/math-element';
+function resolvePrefix(options) {
+    var e_1, _a;
+    if ((options == null ? void 0 : options.prefix) !== undefined && options.prefix.length > 0) {
+        return options.prefix;
+    }
+    var reserved = new Set(function () {
+        var _nc = options == null ? void 0 : options.reservedPrefixes;
+        return _nc != null ? _nc : [];
+    }());
+    try {
+        for (var MATH_PREFIX_FALLBACKS_1 = __values(MATH_PREFIX_FALLBACKS), MATH_PREFIX_FALLBACKS_1_1 = MATH_PREFIX_FALLBACKS_1.next(); !MATH_PREFIX_FALLBACKS_1_1.done; MATH_PREFIX_FALLBACKS_1_1 = MATH_PREFIX_FALLBACKS_1.next()) {
+            var candidate = MATH_PREFIX_FALLBACKS_1_1.value;
+            if (!reserved.has(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (MATH_PREFIX_FALLBACKS_1_1 && !MATH_PREFIX_FALLBACKS_1_1.done && (_a = MATH_PREFIX_FALLBACKS_1.return)) _a.call(MATH_PREFIX_FALLBACKS_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return 'm999';
+}
+function needsXmlSpacePreserve(value) {
+    if (value.length === 0) {
+        return true;
+    }
+    var first = value[0];
+    var last = value[value.length - 1];
+    return first === ' ' || first === '\t' || first === '\n' || first === '\r' || last === ' ' || last === '\t' || last === '\n' || last === '\r';
+}
+function emitOnOff(value) {
+    // ECMA-376 OnOffType — prefer canonical '1' / '0'.
+    return value ? '1' : '0';
+}
+function mEl(ctx, localName, children, attributes) {
+    if (children === void 0) { children = []; }
+    if (attributes === void 0) { attributes = []; }
+    return createElement(MATH_NAMESPACE, localName, ctx.prefix, {
+        attributes: attributes,
+        children: children
+    });
+}
+function valAttr(value) {
+    return {
+        namespaceUri: '',
+        localName: 'val',
+        prefix: '',
+        value: value
+    };
+}
+function valEl(ctx, localName, value) {
+    return mEl(ctx, localName, [], [valAttr(value)]);
+}
+function onOffEl(ctx, localName, value) {
+    return mEl(ctx, localName, [], [valAttr(emitOnOff(value))]);
+}
+function pushCtrlPr(children, ctrlPr) {
+    if (ctrlPr !== undefined) {
+        children.push(ctrlPr);
+    }
+}
+function assertInUnion(value, allowed, path, label) {
+    if (!(allowed.indexOf(value) !== -1)) {
+        throw new MathmlValidationError("Illegal " + label + " token '" + value + "' (not in schema enum)", path, 'enum-value');
+    }
+}
+/**
+ * Serialize a MathArgument as a named CT_OMathArg element
+ * (`e` | `num` | `den` | `sub` | `sup` | `lim` | `deg` | `fName`).
+ */
+function emitArg(ctx, localName, arg) {
+    var childPath = ctx.path + "." + localName;
+    var kids = [];
+    var argSz = arg.properties.argSz;
+    if (argSz !== undefined) {
+        if (!isInteger2(argSz)) {
+            throw new MathmlValidationError("argSz must be an integer in \u22122..2 (ST_Integer2), got " + String(argSz), childPath + ".argPr.argSz", 'value-range');
+        }
+        kids.push(mEl(ctx, 'argPr', [valEl(ctx, 'argSz', String(argSz))]));
+    }
+    for (var i = 0; i < arg.item.length; i++) {
+        var child = arg.item[i];
+        if (child === undefined) {
+            continue;
+        }
+        kids.push(serializeNode(child, {
+            prefix: ctx.prefix,
+            path: childPath + "[" + String(i) + "]"
+        }));
+    }
+    pushCtrlPr(kids, arg.ctrlPr);
+    return mEl(ctx, localName, kids);
+}
+function emitText(ctx, node) {
+    var attrs = [];
+    var space = node.xmlSpace;
+    if (space === undefined && needsXmlSpacePreserve(node.value)) {
+        space = 'preserve';
+    }
+    if (space !== undefined) {
+        attrs.push({
+            namespaceUri: XML_NAMESPACE,
+            localName: 'space',
+            prefix: 'xml',
+            value: space
+        });
+    }
+    return mEl(ctx, 't', [createText(node.value)], attrs);
+}
+function emitRunPr(ctx, run) {
+    var p = run.properties;
+    var kids = [];
+    if (p.isLiteral !== undefined) {
+        kids.push(onOffEl(ctx, 'lit', p.isLiteral));
+    }
+    if (p.isNormal !== undefined) {
+        kids.push(onOffEl(ctx, 'nor', p.isNormal));
+    }
+    if (p.scr !== undefined) {
+        assertInUnion(p.scr, MATH_SCRIPT_VALUES, ctx.path + ".rPr.scr", 'ST_Script');
+        kids.push(valEl(ctx, 'scr', p.scr));
+    }
+    if (p.sty !== undefined) {
+        assertInUnion(p.sty, MATH_STYLE_VALUES, ctx.path + ".rPr.sty", 'ST_Style');
+        kids.push(valEl(ctx, 'sty', p.sty));
+    }
+    if (p.brk !== undefined) {
+        if (!isInteger255(p.brk) && !(Number.isInteger(p.brk) && p.brk === 0)) {
+            // ST_Integer255 is 1..255; allow 0 as present break index edge (Word).
+            if (!Number.isInteger(p.brk) || p.brk < 0 || p.brk > 255) {
+                throw new MathmlValidationError("brk must be an integer in 0..255, got " + String(p.brk), ctx.path + ".rPr.brk", 'value-range');
+            }
+        }
+        kids.push(valEl(ctx, 'brk', String(p.brk)));
+    }
+    if (p.isAligned !== undefined) {
+        kids.push(onOffEl(ctx, 'aln', p.isAligned));
+    }
+    if (kids.length === 0) {
+        return undefined;
+    }
+    return mEl(ctx, 'rPr', kids);
+}
+function emitRun(ctx, run) {
+    var e_2, _a;
+    var kids = [];
+    var rPr = emitRunPr(ctx, run);
+    if (rPr !== undefined) {
+        kids.push(rPr);
+    }
+    if (run.wRPr !== undefined) {
+        kids.push(run.wRPr);
+    }
+    for (var i = 0; i < run.children.length; i++) {
+        var child = run.children[i];
+        if (child === undefined) {
+            continue;
+        }
+        kids.push(serializeNode(child, {
+            prefix: ctx.prefix,
+            path: ctx.path + ".r[" + String(i) + "]"
+        }));
+    }
+    try {
+        for (var _b = __values(run.opaqueChildren), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var opaque = _c.value;
+            kids.push(opaque);
+        }
+    }
+    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 mEl(ctx, 'r', kids);
+}
+function emitAccent(ctx, node) {
+    var kids = [];
+    var prKids = [];
+    if (node.properties.chr !== undefined) {
+        prKids.push(valEl(ctx, 'chr', node.properties.chr));
+    }
+    pushCtrlPr(prKids, node.properties.ctrlPr);
+    if (prKids.length > 0) {
+        kids.push(mEl(ctx, 'accPr', prKids));
+    }
+    kids.push(emitArg(ctx, 'e', node.base));
+    return mEl(ctx, 'acc', kids);
+}
+function emitBar(ctx, node) {
+    var kids = [];
+    var prKids = [];
+    if (node.properties.pos !== undefined) {
+        assertInUnion(node.properties.pos, MATH_TOPBOT_VALUES, ctx.path + ".barPr.pos", 'ST_TopBot');
+        prKids.push(valEl(ctx, 'pos', node.properties.pos));
+    }
+    pushCtrlPr(prKids, node.properties.ctrlPr);
+    if (prKids.length > 0) {
+        kids.push(mEl(ctx, 'barPr', prKids));
+    }
+    kids.push(emitArg(ctx, 'e', node.base));
+    return mEl(ctx, 'bar', kids);
+}
+function emitBox(ctx, node) {
+    var kids = [];
+    var prKids = [];
+    var p = node.properties;
+    if (p.isOperatorEmulated !== undefined) {
+        prKids.push(onOffEl(ctx, 'opEmu', p.isOperatorEmulated));
+    }
+    if (p.isNoBreak !== undefined) {
+        prKids.push(onOffEl(ctx, 'noBreak', p.isNoBreak));
+    }
+    if (p.isDifferential !== undefined) {
+        prKids.push(onOffEl(ctx, 'diff', p.isDifferential));
+    }
+    if (p.isAligned !== undefined) {
+        prKids.push(onOffEl(ctx, 'aln', p.isAligned));
+    }
+    pushCtrlPr(prKids, p.ctrlPr);
+    if (prKids.length > 0) {
+        kids.push(mEl(ctx, 'boxPr', prKids));
+    }
+    kids.push(emitArg(ctx, 'e', node.base));
+    return mEl(ctx, 'box', kids);
+}
+/** Public API boolean → OMML OnOff local name for `m:borderBoxPr`. */
+var BORDER_BOX_ONOFF_EMIT = [['isTopHidden', 'hideTop'], ['isBottomHidden', 'hideBot'], ['isLeftHidden', 'hideLeft'], ['isRightHidden', 'hideRight'], ['hasHorizontalStrike', 'strikeH'], ['hasVerticalStrike', 'strikeV'], ['hasBottomLeftToTopRightStrike', 'strikeBLTR'], ['hasTopLeftToBottomRightStrike', 'strikeTLBR']];
+function emitBorderBox(ctx, node) {
+    var e_3, _a;
+    var kids = [];
+    var prKids = [];
+    var p = node.properties;
+    try {
+        for (var BORDER_BOX_ONOFF_EMIT_1 = __values(BORDER_BOX_ONOFF_EMIT), BORDER_BOX_ONOFF_EMIT_1_1 = BORDER_BOX_ONOFF_EMIT_1.next(); !BORDER_BOX_ONOFF_EMIT_1_1.done; BORDER_BOX_ONOFF_EMIT_1_1 = BORDER_BOX_ONOFF_EMIT_1.next()) {
+            var _b = __read(BORDER_BOX_ONOFF_EMIT_1_1.value, 2), apiName = _b[0], xmlName = _b[1];
+            var v = p[apiName];
+            if (typeof v === 'boolean') {
+                prKids.push(onOffEl(ctx, xmlName, v));
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (BORDER_BOX_ONOFF_EMIT_1_1 && !BORDER_BOX_ONOFF_EMIT_1_1.done && (_a = BORDER_BOX_ONOFF_EMIT_1.return)) _a.call(BORDER_BOX_ONOFF_EMIT_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    pushCtrlPr(prKids, p.ctrlPr);
+    if (prKids.length > 0) {
+        kids.push(mEl(ctx, 'borderBoxPr', prKids));
+    }
+    kids.push(emitArg(ctx, 'e', node.base));
+    return mEl(ctx, 'borderBox', kids);
+}
+function emitDelimiter(ctx, node) {
+    var e_4, _a;
+    node.assertSerializable(ctx.path);
+    var kids = [];
+    var prKids = [];
+    var p = node.properties;
+    if (p.begChr !== undefined) {
+        prKids.push(valEl(ctx, 'begChr', p.begChr));
+    }
+    if (p.sepChr !== undefined) {
+        prKids.push(valEl(ctx, 'sepChr', p.sepChr));
+    }
+    if (p.endChr !== undefined) {
+        prKids.push(valEl(ctx, 'endChr', p.endChr));
+    }
+    if (p.canGrow !== undefined) {
+        prKids.push(onOffEl(ctx, 'grow', p.canGrow));
+    }
+    if (p.shp !== undefined) {
+        assertInUnion(p.shp, MATH_SHP_VALUES, ctx.path + ".dPr.shp", 'ST_Shp');
+        prKids.push(valEl(ctx, 'shp', p.shp));
+    }
+    pushCtrlPr(prKids, p.ctrlPr);
+    if (prKids.length > 0) {
+        kids.push(mEl(ctx, 'dPr', prKids));
+    }
+    try {
+        for (var _b = __values(node.elements), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var el = _c.value;
+            kids.push(emitArg(ctx, 'e', el));
+        }
+    }
+    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 mEl(ctx, 'd', kids);
+}
+function emitEqArr(ctx, node) {
+    var e_5, _a;
+    node.assertSerializable(ctx.path);
+    var kids = [];
+    var prKids = [];
+    var p = node.properties;
+    if (p.baseJc !== undefined) {
+        prKids.push(valEl(ctx, 'baseJc', p.baseJc));
+    }
+    if (p.hasMaxDistance !== undefined) {
+        prKids.push(onOffEl(ctx, 'maxDist', p.hasMaxDistance));
+    }
+    if (p.hasObjectDistance !== undefined) {
+        prKids.push(onOffEl(ctx, 'objDist', p.hasObjectDistance));
+    }
+    pushCtrlPr(prKids, p.ctrlPr);
+    if (prKids.length > 0) {
+        kids.push(mEl(ctx, 'eqArrPr', prKids));
+    }
+    try {
+        for (var _b = __values(node.elements), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var el = _c.value;
+            kids.push(emitArg(ctx, 'e', el));
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return mEl(ctx, 'eqArr', kids);
+}
+function emitFraction(ctx, node) {
+    var kids = [];
+    var prKids = [];
+    if (node.properties.type !== undefined) {
+        assertInUnion(node.properties.type, MATH_FTYPE_VALUES, ctx.path + ".fPr.type", 'ST_FType');
+        prKids.push(valEl(ctx, 'type', node.properties.type));
+    }
+    pushCtrlPr(prKids, node.properties.ctrlPr);
+    if (prKids.length > 0) {
+        kids.push(mEl(ctx, 'fPr', prKids));
+    }
+    // CT_F order: fPr?, num, den (OMML local names unchanged)
+    kids.push(emitArg(ctx, 'num', node.numerator));
+    kids.push(emitArg(ctx, 'den', node.denominator));
+    return mEl(ctx, 'f', kids);
+}
+function emitFunction(ctx, node) {
+    var kids = [];
+    var prKids = [];
+    pushCtrlPr(prKids, node.properties.ctrlPr);
+    if (prKids.length > 0) {
+        kids.push(mEl(ctx, 'funcPr', prKids));
+    }
+    // CT_Func: funcPr?, fName, e (OMML local name fName unchanged)
+    kids.push(emitArg(ctx, 'fName', node.name));
+    kids.push(emitArg(ctx, 'e', node.base));
+    return mEl(ctx, 'func', kids);
+}
+function emitGroupChr(ctx, node) {
+    var kids = [];
+    var prKids = [];
+    var p = node.properties;
+    if (p.chr !== undefined) {
+        prKids.push(valEl(ctx, 'chr', p.chr));
+    }
+    if (p.pos !== undefined) {
+        assertInUnion(p.pos, MATH_TOPBOT_VALUES, ctx.path + ".groupChrPr.pos", 'ST_TopBot');
+        prKids.push(valEl(ctx, 'pos', p.pos));
+    }
+    if (p.vertJc !== undefined) {
+        assertInUnion(p.vertJc, MATH_TOPBOT_VALUES, ctx.path + ".groupChrPr.vertJc", 'ST_TopBot');
+        prKids.push(valEl(ctx, 'vertJc', p.vertJc));
+    }
+    pushCtrlPr(prKids, p.ctrlPr);
+    if (prKids.length > 0) {
+        kids.push(mEl(ctx, 'groupChrPr', prKids));
+    }
+    kids.push(emitArg(ctx, 'e', node.base));
+    return mEl(ctx, 'groupChr', kids);
+}
+function emitLimLow(ctx, node) {
+    var kids = [];
+    var prKids = [];
+    pushCtrlPr(prKids, node.properties.ctrlPr);
+    if (prKids.length > 0) {
+        kids.push(mEl(ctx, 'limLowPr', prKids));
+    }
+    // CT_LimLow: limLowPr?, e, lim
+    kids.push(emitArg(ctx, 'e', node.base));
+    kids.push(emitArg(ctx, 'lim', node.lim));
+    return mEl(ctx, 'limLow', kids);
+}
+function emitLimUpp(ctx, node) {
+    var kids = [];
+    var prKids = [];
+    pushCtrlPr(prKids, node.properties.ctrlPr);
+    if (prKids.length > 0) {
+        kids.push(mEl(ctx, 'limUppPr', prKids));
+    }
+    // CT_LimUpp: limUppPr?, e, lim
+    kids.push(emitArg(ctx, 'e', node.base));
+    kids.push(emitArg(ctx, 'lim', node.lim));
+    return mEl(ctx, 'limUpp', kids);
+}
+function emitMatrixRow(ctx, node) {
+    var e_6, _a;
+    node.assertSerializable(ctx.path);
+    var kids = [];
+    try {
+        for (var _b = __values(node.elements), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var el = _c.value;
+            kids.push(emitArg(ctx, 'e', el));
+        }
+    }
+    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 mEl(ctx, 'mr', kids);
+}
+function emitMatrix(ctx, node) {
+    node.assertSerializable(ctx.path);
+    var kids = [];
+    var prKids = [];
+    var p = node.properties;
+    if (p.baseJc !== undefined) {
+        prKids.push(valEl(ctx, 'baseJc', p.baseJc));
+    }
+    if (p.isPlaceholderHidden !== undefined) {
+        prKids.push(onOffEl(ctx, 'plcHide', p.isPlaceholderHidden));
+    }
+    pushCtrlPr(prKids, p.ctrlPr);
+    if (prKids.length > 0) {
+        kids.push(mEl(ctx, 'mPr', prKids));
+    }
+    for (var i = 0; i < node.rows.length; i++) {
+        var row = node.rows[i];
+        if (row === undefined) {
+            continue;
+        }
+        kids.push(emitMatrixRow({
+            prefix: ctx.prefix,
+            path: ctx.path + ".mr[" + String(i) + "]"
+        }, row));
+    }
+    return mEl(ctx, 'm', kids);
+}
+function emitNary(ctx, node) {
+    var kids = [];
+    var prKids = [];
+    var p = node.properties;
+    if (p.chr !== undefined) {
+        prKids.push(valEl(ctx, 'chr', p.chr));
+    }
+    if (p.limLoc !== undefined) {
+        assertInUnion(p.limLoc, MATH_LIMLOC_VALUES, ctx.path + ".naryPr.limLoc", 'ST_LimLoc');
+        prKids.push(valEl(ctx, 'limLoc', p.limLoc));
+    }
+    if (p.canGrow !== undefined) {
+        prKids.push(onOffEl(ctx, 'grow', p.canGrow));
+    }
+    if (p.isSubscriptHidden !== undefined) {
+        prKids.push(onOffEl(ctx, 'subHide', p.isSubscriptHidden));
+    }
+    if (p.isSuperscriptHidden !== undefined) {
+        prKids.push(onOffEl(ctx, 'supHide', p.isSuperscriptHidden));
+    }
+    pushCtrlPr(prKids, p.ctrlPr);
+    if (prKids.length > 0) {
+        kids.push(mEl(ctx, 'naryPr', prKids));
+    }
+    // CT_Nary order: naryPr?, sub, sup, e
+    kids.push(emitArg(ctx, 'sub', node.subscript));
+    kids.push(emitArg(ctx, 'sup', node.superscript));
+    kids.push(emitArg(ctx, 'e', node.base));
+    return mEl(ctx, 'nary', kids);
+}
+function emitPhant(ctx, node) {
+    var kids = [];
+    var prKids = [];
+    var p = node.properties;
+    if (p.isShown !== undefined) {
+        prKids.push(onOffEl(ctx, 'show', p.isShown));
+    }
+    if (p.isZeroWidth !== undefined) {
+        prKids.push(onOffEl(ctx, 'zeroWid', p.isZeroWidth));
+    }
+    if (p.isZeroAscender !== undefined) {
+        prKids.push(onOffEl(ctx, 'zeroAsc', p.isZeroAscender));
+    }
+    if (p.isZeroDescender !== undefined) {
+        prKids.push(onOffEl(ctx, 'zeroDesc', p.isZeroDescender));
+    }
+    if (p.isTransparent !== undefined) {
+        prKids.push(onOffEl(ctx, 'transp', p.isTransparent));
+    }
+    pushCtrlPr(prKids, p.ctrlPr);
+    if (prKids.length > 0) {
+        kids.push(mEl(ctx, 'phantPr', prKids));
+    }
+    kids.push(emitArg(ctx, 'e', node.base));
+    return mEl(ctx, 'phant', kids);
+}
+function emitRad(ctx, node) {
+    var kids = [];
+    var prKids = [];
+    if (node.properties.isDegreeHidden !== undefined) {
+        prKids.push(onOffEl(ctx, 'degHide', node.properties.isDegreeHidden));
+    }
+    pushCtrlPr(prKids, node.properties.ctrlPr);
+    if (prKids.length > 0) {
+        kids.push(mEl(ctx, 'radPr', prKids));
+    }
+    // CT_Rad: radPr?, deg, e
+    kids.push(emitArg(ctx, 'deg', node.deg));
+    kids.push(emitArg(ctx, 'e', node.base));
+    return mEl(ctx, 'rad', kids);
+}
+function emitScriptPr(ctx, prName, isScriptAligned, ctrlPr) {
+    var prKids = [];
+    if (isScriptAligned !== undefined) {
+        prKids.push(onOffEl(ctx, 'alnScr', isScriptAligned));
+    }
+    pushCtrlPr(prKids, ctrlPr);
+    if (prKids.length === 0) {
+        return undefined;
+    }
+    return mEl(ctx, prName, prKids);
+}
+function emitSPre(ctx, node) {
+    var kids = [];
+    var pr = emitScriptPr(ctx, 'sPrePr', node.properties.isScriptAligned, node.properties.ctrlPr);
+    if (pr !== undefined) {
+        kids.push(pr);
+    }
+    // CT_SPre: sPrePr?, sub, sup, e
+    kids.push(emitArg(ctx, 'sub', node.sub));
+    kids.push(emitArg(ctx, 'sup', node.sup));
+    kids.push(emitArg(ctx, 'e', node.base));
+    return mEl(ctx, 'sPre', kids);
+}
+function emitSSub(ctx, node) {
+    var kids = [];
+    var pr = emitScriptPr(ctx, 'sSubPr', node.properties.isScriptAligned, node.properties.ctrlPr);
+    if (pr !== undefined) {
+        kids.push(pr);
+    }
+    // CT_SSub: sSubPr?, e, sub
+    kids.push(emitArg(ctx, 'e', node.base));
+    kids.push(emitArg(ctx, 'sub', node.subscript));
+    return mEl(ctx, 'sSub', kids);
+}
+function emitSSubSup(ctx, node) {
+    var kids = [];
+    var pr = emitScriptPr(ctx, 'sSubSupPr', node.properties.isScriptAligned, node.properties.ctrlPr);
+    if (pr !== undefined) {
+        kids.push(pr);
+    }
+    // CT_SSubSup: sSubSupPr?, e, sub, sup
+    kids.push(emitArg(ctx, 'e', node.base));
+    kids.push(emitArg(ctx, 'sub', node.subscript));
+    kids.push(emitArg(ctx, 'sup', node.superscript));
+    return mEl(ctx, 'sSubSup', kids);
+}
+function emitSSup(ctx, node) {
+    var kids = [];
+    var pr = emitScriptPr(ctx, 'sSupPr', node.properties.isScriptAligned, node.properties.ctrlPr);
+    if (pr !== undefined) {
+        kids.push(pr);
+    }
+    // CT_SSup: sSupPr?, e, sup
+    kids.push(emitArg(ctx, 'e', node.base));
+    kids.push(emitArg(ctx, 'sup', node.superscript));
+    return mEl(ctx, 'sSup', kids);
+}
+function emitOMath(ctx, node) {
+    var kids = [];
+    for (var i = 0; i < node.children.length; i++) {
+        var child = node.children[i];
+        if (child === undefined) {
+            continue;
+        }
+        kids.push(serializeNode(child, {
+            prefix: ctx.prefix,
+            path: ctx.path + "[" + String(i) + "]"
+        }));
+    }
+    return mEl(ctx, 'oMath', kids);
+}
+function emitOMathPara(ctx, node) {
+    node.assertSerializable(ctx.path);
+    var kids = [];
+    if (node.properties.jc !== undefined) {
+        assertInUnion(node.properties.jc, MATH_JC_VALUES, ctx.path + ".oMathParaPr.jc", 'ST_Jc');
+        kids.push(mEl(ctx, 'oMathParaPr', [valEl(ctx, 'jc', node.properties.jc)]));
+    }
+    for (var i = 0; i < node.equations.length; i++) {
+        var eq = node.equations[i];
+        if (eq === undefined) {
+            continue;
+        }
+        kids.push(emitOMath({
+            prefix: ctx.prefix,
+            path: ctx.path + ".oMath[" + String(i) + "]"
+        }, eq));
+    }
+    return mEl(ctx, 'oMathPara', kids);
+}
+function serializeNode(node, ctx) {
+    // Preserve-only degradation / unknown: re-emit captured XML verbatim.
+    if (node.preserveOnly) {
+        if (node.preservedXml === undefined) {
+            throw new MathmlValidationError('preserve-only node missing preservedXml', ctx.path, 'required-child');
+        }
+        return node.preservedXml;
+    }
+    if (node instanceof UnknownMathElement) {
+        if (node.preservedXml === undefined) {
+            throw new MathmlValidationError('unknown math node missing preservedXml', ctx.path, 'required-child');
+        }
+        return node.preservedXml;
+    }
+    switch (node.type) {
+        case 'oMathPara':
+            return emitOMathPara(ctx, node);
+        case 'oMath':
+            return emitOMath(ctx, node);
+        case 't':
+            return emitText(ctx, node);
+        case 'r':
+            return emitRun(ctx, node);
+        case 'acc':
+            return emitAccent(ctx, node);
+        case 'bar':
+            return emitBar(ctx, node);
+        case 'box':
+            return emitBox(ctx, node);
+        case 'borderBox':
+            return emitBorderBox(ctx, node);
+        case 'd':
+            return emitDelimiter(ctx, node);
+        case 'eqArr':
+            return emitEqArr(ctx, node);
+        case 'f':
+            return emitFraction(ctx, node);
+        case 'func':
+            return emitFunction(ctx, node);
+        case 'groupChr':
+            return emitGroupChr(ctx, node);
+        case 'limLow':
+            return emitLimLow(ctx, node);
+        case 'limUpp':
+            return emitLimUpp(ctx, node);
+        case 'm':
+            return emitMatrix(ctx, node);
+        case 'mr':
+            return emitMatrixRow(ctx, node);
+        case 'nary':
+            return emitNary(ctx, node);
+        case 'phant':
+            return emitPhant(ctx, node);
+        case 'rad':
+            return emitRad(ctx, node);
+        case 'sPre':
+            return emitSPre(ctx, node);
+        case 'sSub':
+            return emitSSub(ctx, node);
+        case 'sSubSup':
+            return emitSSubSup(ctx, node);
+        case 'sSup':
+            return emitSSup(ctx, node);
+        case 'arg':
+            // Arguments are only emitted via emitArg with a schema local name.
+            throw new MathmlValidationError('MathArgument cannot be serialized as a root; use a named CT_OMathArg slot', ctx.path, 'child-order');
+        case 'unknown':
+            // Handled above via instanceof; keep exhaustive.
+            if (node.preservedXml !== undefined) {
+                return node.preservedXml;
+            }
+            throw new MathmlValidationError('unknown math node missing preservedXml', ctx.path, 'required-child');
+        default:
+            {
+                var _exhaustive = node.type;
+                throw new MathmlValidationError("Unhandled math kind: " + String(_exhaustive), ctx.path, 'required-child');
+            }
+    }
+}
+/**
+ * Serialize a typed math node to an OpenXml element tree.
+ *
+ * Source: mathml-spec §9 — strict schema order; preserve-only re-emits XML.
+ *
+ * @public
+ */
+export function mathElementToOpenXml(node, options) {
+    var prefix = resolvePrefix(options);
+    return serializeNode(node, {
+        prefix: prefix,
+        path: node.type
+    });
+}