@syncfusion/ej2-office-common 35.1.37 → 35.1.43

package/src/office-common/features/mathml/parse/office-math-properties.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Property readers that populate the Office Math model from `m:*Pr` elements.
+ *
+ * Source: ECMA-376-1 §22.1.2 (shared-math.xsd). Invalid values are ignored so the model default applies.
+ */
+import { OpenXmlElement } from '../openxml';
+import { OfficeMathBreak } from '../office-math/break';
+import { OfficeMath } from '../office-math/office-math';
+import { OfficeMathFormat } from '../office-math/format';
+import { OfficeMathAccent, OfficeMathBar, OfficeMathBorderBox, OfficeMathBox, OfficeMathGroupCharacter, OfficeMathPhantom, OfficeMathRadical } from '../office-math/functions-basic';
+import { OfficeMathDelimiter, OfficeMathEquationArray, OfficeMathFraction, OfficeMathNArray, OfficeMathRightScript } from '../office-math/functions-multi';
+import { OfficeMathMatrix } from '../office-math/matrix';
+/**
+ * Finds the first `m:` child with the given local name. @private
+ *
+ * @param {OpenXmlElement | undefined} parent The parent element.
+ * @param {string} localName The local name to find.
+ * @returns {OpenXmlElement | undefined} The result.
+ */
+export declare function findMathChild(parent: OpenXmlElement | undefined, localName: string): OpenXmlElement | undefined;
+/**
+ * Finds every `m:` child with the given local name. @private
+ *
+ * @param {OpenXmlElement} parent The parent element.
+ * @param {string} localName The local name to find.
+ * @returns {OpenXmlElement[]} The result.
+ */
+export declare function findMathChildren(parent: OpenXmlElement, localName: string): OpenXmlElement[];
+/**
+ * Reads `m:brk` of a property container. @private
+ *
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @param {OfficeMath} owner Optional owning equation whose break collection creates the break.
+ * @returns {OfficeMathBreak | undefined} The result.
+ */
+export declare function readBreak(pr: OpenXmlElement | undefined, owner?: OfficeMath): OfficeMathBreak | undefined;
+/**
+ * Applies `m:rPr` to a run format. @private
+ *
+ * @param {OfficeMathFormat} format The Math run format to populate.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export declare function applyRunFormat(format: OfficeMathFormat, pr: OpenXmlElement | undefined): void;
+/**
+ * Applies `m:accPr`. @private
+ *
+ * @param {OfficeMathAccent} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export declare function applyAccent(fn: OfficeMathAccent, pr: OpenXmlElement | undefined): void;
+/**
+ * Applies `m:barPr`. @private
+ *
+ * @param {OfficeMathBar} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export declare function applyBar(fn: OfficeMathBar, pr: OpenXmlElement | undefined): void;
+/**
+ * Applies `m:borderBoxPr`. @private
+ *
+ * @param {OfficeMathBorderBox} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export declare function applyBorderBox(fn: OfficeMathBorderBox, pr: OpenXmlElement | undefined): void;
+/**
+ * Applies `m:boxPr`. @private
+ *
+ * @param {OfficeMathBox} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export declare function applyBox(fn: OfficeMathBox, pr: OpenXmlElement | undefined): void;
+/**
+ * Applies `m:dPr`. @private
+ *
+ * @param {OfficeMathDelimiter} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export declare function applyDelimiter(fn: OfficeMathDelimiter, pr: OpenXmlElement | undefined): void;
+/**
+ * Applies `m:eqArrPr`. @private
+ *
+ * @param {OfficeMathEquationArray} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export declare function applyEquationArray(fn: OfficeMathEquationArray, pr: OpenXmlElement | undefined): void;
+/**
+ * Applies `m:fPr`. @private
+ *
+ * @param {OfficeMathFraction} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export declare function applyFraction(fn: OfficeMathFraction, pr: OpenXmlElement | undefined): void;
+/**
+ * Applies `m:groupChrPr`. @private
+ *
+ * @param {OfficeMathGroupCharacter} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export declare function applyGroupCharacter(fn: OfficeMathGroupCharacter, pr: OpenXmlElement | undefined): void;
+/**
+ * Applies `m:naryPr`. @private
+ *
+ * @param {OfficeMathNArray} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export declare function applyNArray(fn: OfficeMathNArray, pr: OpenXmlElement | undefined): void;
+/**
+ * Applies `m:phantPr`. @private
+ *
+ * @param {OfficeMathPhantom} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export declare function applyPhantom(fn: OfficeMathPhantom, pr: OpenXmlElement | undefined): void;
+/**
+ * Applies `m:radPr`. @private
+ *
+ * @param {OfficeMathRadical} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export declare function applyRadical(fn: OfficeMathRadical, pr: OpenXmlElement | undefined): void;
+/**
+ * Applies `m:sSubSupPr`. @private
+ *
+ * @param {OfficeMathRightScript} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export declare function applyRightScript(fn: OfficeMathRightScript, pr: OpenXmlElement | undefined): void;
+/**
+ * Applies the scalar settings of `m:mPr` (columns are handled by {@link applyMatrixColumns}). @private
+ *
+ * @param {OfficeMathMatrix} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export declare function applyMatrix(fn: OfficeMathMatrix, pr: OpenXmlElement | undefined): void;
+/**
+ * Creates matrix columns from `m:mcs`, then pads to `cellCount` so every row cell has a column.
+ *
+ * @param {OfficeMathMatrix} fn The matrix.
+ * @param {OpenXmlElement} pr The `m:mPr` element.
+ * @param {number} cellCount The widest row, in cells.
+ * @returns {void}
+ * @private
+ */
+export declare function applyMatrixColumns(fn: OfficeMathMatrix, pr: OpenXmlElement | undefined, cellCount: number): void;
+/**
+ * Reads `m:argPr/m:argSz` (ST_Integer2, -2..2). Invalid values are ignored. @private
+ *
+ * @param {OpenXmlElement | undefined} argPr The `m:argPr` element, if present.
+ * @returns {string | undefined} The valid size as text, or undefined.
+ */
+export declare function readArgumentSize(argPr: OpenXmlElement | undefined): string | undefined;

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

@@ -0,0 +1,432 @@
+/**
+ * Property readers that populate the Office Math model from `m:*Pr` elements.
+ *
+ * Source: ECMA-376-1 §22.1.2 (shared-math.xsd). Invalid values are ignored so the model default applies.
+ */
+import { MATH_NAMESPACE } from '../constants';
+import { attrValue, childElements } from '../openxml';
+import { MathDelimiterShapeType, MathFontType, MathFractionType, MathHorizontalAlignment, MathStyleType, MathVerticalAlignment } from '../office-math/enums';
+import { OfficeMathBreak } from '../office-math/break';
+import { OfficeMath } from '../office-math/office-math';
+/**
+ * Finds the first `m:` child with the given local name. @private
+ *
+ * @param {OpenXmlElement | undefined} parent The parent element.
+ * @param {string} localName The local name to find.
+ * @returns {OpenXmlElement | undefined} The result.
+ */
+export function findMathChild(parent, localName) {
+    return parent === undefined ? undefined : childElements(parent)
+        .filter(function (c) { return c.namespaceUri === MATH_NAMESPACE && c.localName === localName; })[0];
+}
+/**
+ * Finds every `m:` child with the given local name. @private
+ *
+ * @param {OpenXmlElement} parent The parent element.
+ * @param {string} localName The local name to find.
+ * @returns {OpenXmlElement[]} The result.
+ */
+export function findMathChildren(parent, localName) {
+    return childElements(parent).filter(function (c) { return c.namespaceUri === MATH_NAMESPACE && c.localName === localName; });
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @param {string} name The local name of the child element.
+ * @returns {string | undefined} The result.
+ */
+function str(pr, name) {
+    var child = findMathChild(pr, name);
+    return child === undefined ? undefined : attrValue(child, 'val');
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @param {string} name The local name of the child element.
+ * @returns {boolean | undefined} The result.
+ */
+function onOff(pr, name) {
+    var child = findMathChild(pr, name);
+    if (child === undefined) {
+        return undefined;
+    }
+    var raw = attrValue(child, 'val');
+    if (raw === undefined) {
+        return true;
+    }
+    var v = raw.toLowerCase();
+    return v === '1' || v === 'true' || v === 'on' ? true : v === '0' || v === 'false' || v === 'off' ? false : undefined;
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @param {string} name The local name of the child element.
+ * @returns {number | undefined} The result.
+ */
+function int(pr, name) {
+    var raw = str(pr, name);
+    return raw !== undefined && /^\d+$/.test(raw) ? Number(raw) : undefined;
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @param {Array<[string, Function]>} table The lookup table of valid values.
+ * @returns {void}
+ */
+function flags(pr, table) {
+    table.forEach(function (entry) {
+        var value = onOff(pr, entry[0]);
+        if (value !== undefined) {
+            entry[1](value);
+        }
+    });
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @param {string} name The local name of the child element.
+ * @param {Function} set Callback receiving the parsed value.
+ * @returns {void}
+ */
+function text(pr, name, set) {
+    var value = str(pr, name);
+    if (value !== undefined) {
+        set(value);
+    }
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {string | undefined} value The value to convert.
+ * @returns {MathVerticalAlignment | undefined} The result.
+ */
+function verticalAlignment(value) {
+    if (value === 'top') {
+        return MathVerticalAlignment.Top;
+    }
+    if (value === 'bottom') {
+        return MathVerticalAlignment.Bottom;
+    }
+    return value === 'center' ? MathVerticalAlignment.Center : undefined;
+}
+/**
+ * Reads `m:brk` of a property container. @private
+ *
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @param {OfficeMath} owner Optional owning equation whose break collection creates the break.
+ * @returns {OfficeMathBreak | undefined} The result.
+ */
+export function readBreak(pr, owner) {
+    var brk = findMathChild(pr, 'brk');
+    if (brk === undefined) {
+        return undefined;
+    }
+    var result = owner !== undefined ? owner.breaks.add() : new OfficeMathBreak();
+    var raw = attrValue(brk, 'alnAt');
+    if (raw !== undefined && /^\d+$/.test(raw) && Number(raw) >= 1 && Number(raw) <= 255) {
+        result.alignAt = Number(raw);
+    }
+    return result;
+}
+var FONTS = {
+    'roman': MathFontType.Roman, 'script': MathFontType.Script, 'fraktur': MathFontType.Fraktur,
+    'double-struck': MathFontType.DoubleStruck, 'sans-serif': MathFontType.SansSerif, 'monospace': MathFontType.Monospace
+};
+var STYLES = {
+    p: MathStyleType.Regular, b: MathStyleType.Bold, i: MathStyleType.Italic, bi: MathStyleType.BoldItalic
+};
+/**
+ * Applies `m:rPr` to a run format. @private
+ *
+ * @param {OfficeMathFormat} format The Math run format to populate.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export function applyRunFormat(format, pr) {
+    flags(pr, [['lit', function (v) { format.hasLiteral = v; }], ['nor', function (v) { format.hasNormalText = v; }],
+        ['aln', function (v) { format.hasAlignment = v; }]]);
+    var scr = str(pr, 'scr');
+    if (scr !== undefined && FONTS.hasOwnProperty(scr)) {
+        format.font = FONTS[scr];
+    }
+    var sty = str(pr, 'sty');
+    if (sty !== undefined && STYLES.hasOwnProperty(sty)) {
+        format.style = STYLES[sty];
+    }
+    var brk = readBreak(pr);
+    if (brk !== undefined) {
+        format.break = brk;
+    }
+}
+/**
+ * Applies `m:accPr`. @private
+ *
+ * @param {OfficeMathAccent} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export function applyAccent(fn, pr) {
+    text(pr, 'chr', function (v) { fn.accentCharacter = v; });
+}
+/**
+ * Applies `m:barPr`. @private
+ *
+ * @param {OfficeMathBar} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export function applyBar(fn, pr) {
+    var pos = str(pr, 'pos');
+    if (pos === 'top' || pos === 'bot') {
+        fn.barTop = pos === 'top';
+    }
+}
+/**
+ * Applies `m:borderBoxPr`. @private
+ *
+ * @param {OfficeMathBorderBox} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export function applyBorderBox(fn, pr) {
+    flags(pr, [['hideTop', function (v) { fn.hideTop = v; }], ['hideBot', function (v) { fn.hideBottom = v; }],
+        ['hideLeft', function (v) { fn.hideLeft = v; }], ['hideRight', function (v) { fn.hideRight = v; }],
+        ['strikeH', function (v) { fn.strikeHorizontal = v; }], ['strikeV', function (v) { fn.strikeVertical = v; }],
+        ['strikeBLTR', function (v) { fn.strikeDiagonalUp = v; }], ['strikeTLBR', function (v) { fn.strikeDiagonalDown = v; }]]);
+}
+/**
+ * Applies `m:boxPr`. @private
+ *
+ * @param {OfficeMathBox} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export function applyBox(fn, pr) {
+    flags(pr, [['opEmu', function (v) { fn.operatorEmulator = v; }], ['noBreak', function (v) { fn.noBreak = v; }],
+        ['diff', function (v) { fn.enableDifferential = v; }], ['aln', function (v) { fn.alignment = v; }]]);
+    var brk = readBreak(pr, fn.ownerMathEntity instanceof OfficeMath ? fn.ownerMathEntity : undefined);
+    if (brk !== undefined) {
+        fn.break = brk;
+    }
+}
+/**
+ * Applies `m:dPr`. @private
+ *
+ * @param {OfficeMathDelimiter} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export function applyDelimiter(fn, pr) {
+    text(pr, 'begChr', function (v) { fn.beginCharacter = v; });
+    text(pr, 'sepChr', function (v) { fn.separator = v; });
+    text(pr, 'endChr', function (v) { fn.endCharacter = v; });
+    flags(pr, [['grow', function (v) { fn.isGrow = v; }]]);
+    var shp = str(pr, 'shp');
+    if (shp === 'centered' || shp === 'match') {
+        fn.delimiterShape = shp === 'centered' ? MathDelimiterShapeType.Centered : MathDelimiterShapeType.Match;
+    }
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @param {Function} rule Callback receiving the spacing rule.
+ * @param {Function} value Callback receiving the spacing value.
+ * @param {string} ruleName The local name of the rule element.
+ * @param {string} valueName The local name of the value element.
+ * @returns {void}
+ */
+function spacing(pr, rule, value, ruleName, valueName) {
+    var r = int(pr, ruleName);
+    if (r !== undefined && r <= 4) {
+        rule(r);
+    }
+    var v = int(pr, valueName);
+    if (v !== undefined) {
+        try {
+            value(v);
+        }
+        catch (e) {
+            if (!(e instanceof RangeError)) {
+                throw e;
+            }
+        }
+    }
+}
+/**
+ * Applies `m:eqArrPr`. @private
+ *
+ * @param {OfficeMathEquationArray} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export function applyEquationArray(fn, pr) {
+    var align = verticalAlignment(str(pr, 'baseJc'));
+    if (align !== undefined) {
+        fn.verticalAlignment = align;
+    }
+    flags(pr, [['maxDist', function (v) { fn.expandEquationContainer = v; }],
+        ['objDist', function (v) { fn.expandEquationContent = v; }]]);
+    spacing(pr, function (v) { fn.rowSpacingRule = v; }, function (v) { fn.rowSpacing = v; }, 'rSpRule', 'rSp');
+}
+var FRACTIONS = {
+    bar: MathFractionType.NormalFractionBar, noBar: MathFractionType.NoFractionBar,
+    skw: MathFractionType.SkewedFractionBar, lin: MathFractionType.FractionInline
+};
+/**
+ * Applies `m:fPr`. @private
+ *
+ * @param {OfficeMathFraction} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export function applyFraction(fn, pr) {
+    var type = str(pr, 'type');
+    if (type !== undefined && FRACTIONS.hasOwnProperty(type)) {
+        fn.fractionType = FRACTIONS[type];
+    }
+}
+/**
+ * Applies `m:groupChrPr`. @private
+ *
+ * @param {OfficeMathGroupCharacter} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export function applyGroupCharacter(fn, pr) {
+    text(pr, 'chr', function (v) { fn.groupCharacter = v; });
+    var pos = str(pr, 'pos');
+    if (pos === 'top' || pos === 'bot') {
+        fn.hasCharacterTop = pos === 'top';
+    }
+    var vert = str(pr, 'vertJc');
+    if (vert === 'top' || vert === 'bot') {
+        fn.hasAlignTop = vert === 'top';
+    }
+}
+/**
+ * Applies `m:naryPr`. @private
+ *
+ * @param {OfficeMathNArray} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export function applyNArray(fn, pr) {
+    text(pr, 'chr', function (v) { fn.nArrayCharacter = v; });
+    var loc = str(pr, 'limLoc');
+    if (loc === 'undOvr' || loc === 'subSup') {
+        fn.subSuperscriptLimit = loc === 'subSup';
+    }
+    flags(pr, [['grow', function (v) { fn.hasGrow = v; }], ['subHide', function (v) { fn.hideLowerLimit = v; }],
+        ['supHide', function (v) { fn.hideUpperLimit = v; }]]);
+}
+/**
+ * Applies `m:phantPr`. @private
+ *
+ * @param {OfficeMathPhantom} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export function applyPhantom(fn, pr) {
+    flags(pr, [['show', function (v) { fn.show = v; }], ['zeroWid', function (v) { fn.zeroWidth = v; }],
+        ['zeroAsc', function (v) { fn.zeroAscent = v; }], ['zeroDesc', function (v) { fn.zeroDescent = v; }],
+        ['transp', function (v) { fn.transparent = v; }]]);
+}
+/**
+ * Applies `m:radPr`. @private
+ *
+ * @param {OfficeMathRadical} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export function applyRadical(fn, pr) {
+    flags(pr, [['degHide', function (v) { fn.hideDegree = v; }]]);
+}
+/**
+ * Applies `m:sSubSupPr`. @private
+ *
+ * @param {OfficeMathRightScript} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export function applyRightScript(fn, pr) {
+    flags(pr, [['alnScr', function (v) { fn.isSkipAlign = v; }]]);
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {string | undefined} value The value to convert.
+ * @returns {MathHorizontalAlignment | undefined} The result.
+ */
+function columnAlignment(value) {
+    if (value === 'left') {
+        return MathHorizontalAlignment.Left;
+    }
+    if (value === 'right') {
+        return MathHorizontalAlignment.Right;
+    }
+    return value === 'center' ? MathHorizontalAlignment.Center : undefined;
+}
+/**
+ * Applies the scalar settings of `m:mPr` (columns are handled by {@link applyMatrixColumns}). @private
+ *
+ * @param {OfficeMathMatrix} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @returns {void}
+ */
+export function applyMatrix(fn, pr) {
+    var align = verticalAlignment(str(pr, 'baseJc'));
+    if (align !== undefined) {
+        fn.verticalAlignment = align;
+    }
+    flags(pr, [['plcHide', function (v) { fn.hidePlaceholder = v; }]]);
+    spacing(pr, function (v) { fn.rowSpacingRule = v; }, function (v) { fn.rowSpacing = v; }, 'rSpRule', 'rSp');
+    spacing(pr, function (v) { fn.columnGapRule = v; }, function (v) { fn.columnGap = v; }, 'cGpRule', 'cGp');
+    var cSp = int(pr, 'cSp');
+    if (cSp !== undefined) {
+        fn.columnSpacing = cSp;
+    }
+}
+/**
+ * Creates matrix columns from `m:mcs`, then pads to `cellCount` so every row cell has a column.
+ *
+ * @param {OfficeMathMatrix} fn The matrix.
+ * @param {OpenXmlElement} pr The `m:mPr` element.
+ * @param {number} cellCount The widest row, in cells.
+ * @returns {void}
+ * @private
+ */
+export function applyMatrixColumns(fn, pr, cellCount) {
+    var mcs = findMathChild(pr, 'mcs');
+    var groups = mcs === undefined ? [] : findMathChildren(mcs, 'mc');
+    groups.forEach(function (mc) {
+        var mcPr = findMathChild(mc, 'mcPr');
+        var raw = int(mcPr, 'count');
+        var count = raw !== undefined && raw >= 1 && raw <= 255 ? raw : 1;
+        var align = columnAlignment(str(mcPr, 'mcJc'));
+        for (var i = 0; i < count; i++) {
+            var column = fn.columns.add();
+            if (align !== undefined) {
+                column.horizontalAlignment = align;
+            }
+        }
+    });
+    while (fn.columns.count < cellCount) {
+        fn.columns.add();
+    }
+}
+/**
+ * Reads `m:argPr/m:argSz` (ST_Integer2, -2..2). Invalid values are ignored. @private
+ *
+ * @param {OpenXmlElement | undefined} argPr The `m:argPr` element, if present.
+ * @returns {string | undefined} The valid size as text, or undefined.
+ */
+export function readArgumentSize(argPr) {
+    var raw = str(argPr, 'argSz');
+    return raw !== undefined && /^-?\d+$/.test(raw) && Math.abs(Number(raw)) <= 2 ? raw : undefined;
+}

package/src/office-common/features/mathml/parse/parse-options.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Parser options and diagnostics shared by the Office Math parser.
+ */
+/**
+ * Optional diagnostic callback for degradation events.
+ *
+ * @public
+ */
+export interface MathParseDiagnostic {
+    readonly path: string;
+    readonly message: string;
+    readonly localName: string;
+}
+/**
+ * Parser options.
+ *
+ * @public
+ */
+export interface ParseMathOptions {
+    /** Called when a structure is degraded to preserve-only. */
+    readonly onDiagnostic?: (d: MathParseDiagnostic) => void;
+}

package/src/office-common/features/mathml/parse/parse-options.js

@@ -0,0 +1,3 @@
+/**
+ * Parser options and diagnostics shared by the Office Math parser.
+ */

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

@@ -0,0 +1,38 @@
+/**
+ * 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.
+ */
+import { OpenXmlChild } from '../openxml';
+import { OfficeMathBreak } from '../office-math/break';
+import { OfficeMathFormat } from '../office-math/format';
+import { OfficeMathFunctionBase } from '../office-math/function-base';
+import { WriteContext } from './omml-writer';
+/** Element name of the property container of each function. @private */
+export declare const PROPERTY_ELEMENT: {
+    [type: number]: string;
+};
+/**
+ * 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 declare function writeBreak(ctx: WriteContext, brk: OfficeMathBreak): OpenXmlChild;
+/**
+ * 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 declare function runFormatChildren(ctx: WriteContext, format: OfficeMathFormat): OpenXmlChild[];
+/**
+ * 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 declare function functionProperties(ctx: WriteContext, fn: OfficeMathFunctionBase): OpenXmlChild[];