@syncfusion/ej2-office-common 35.1.37 → 35.1.42

package/src/office-common/features/mathml/office-math/run-element.js

@@ -0,0 +1,97 @@
+/**
+ * Run element (`m:r`) holding a document-native run.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { MathFunctionType } from './enums';
+import { OfficeMathFunctionBase } from './function-base';
+import { OfficeMathFormat } from './format';
+import { BasicRun } from './basic';
+/**
+ * Math run: native document run plus Math format (`m:rPr`).
+ *
+ * @public
+ */
+var OfficeMathRunElement = /** @class */ (function (_super) {
+    __extends(OfficeMathRunElement, _super);
+    function OfficeMathRunElement(owner) {
+        var _this = _super.call(this, owner) || this;
+        _this.type = MathFunctionType.RunElement;
+        _this._mathFormat = new OfficeMathFormat(_this);
+        return _this;
+    }
+    Object.defineProperty(OfficeMathRunElement.prototype, "item", {
+        /** The native document run. */
+        get: function () { return this._item; },
+        set: function (value) {
+            this._item = value;
+            if (value !== undefined) {
+                value.ownerMathRunElement = this;
+            }
+            this.notifyMutated();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathRunElement.prototype, "text", {
+        /**
+         * Text of the run (`m:t`). Uses the host adapter when the run is attached to a paragraph
+         * that has one, otherwise a standalone run. Empty when no run exists yet.
+         *
+         * @returns {string} The run text.
+         */
+        get: function () {
+            var adapter = this.findAdapter();
+            if (this._item === undefined) {
+                return '';
+            }
+            return adapter !== undefined ? adapter.getRunText(this._item) : this._item.text;
+        },
+        set: function (value) {
+            var adapter = this.findAdapter();
+            if (this._item === undefined) {
+                this.item = adapter !== undefined ? adapter.createRun(this) : new BasicRun();
+            }
+            if (adapter !== undefined) {
+                adapter.setRunText(this._item, value);
+                this.notifyMutated();
+            }
+            else {
+                this._item.text = value;
+                this.notifyMutated();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    OfficeMathRunElement.prototype.findAdapter = function () {
+        var entity = this.ownerMathEntity;
+        while (entity !== undefined) {
+            var candidate = entity;
+            if (candidate.adapter !== undefined) {
+                return candidate.adapter;
+            }
+            entity = entity.ownerMathEntity;
+        }
+        return undefined;
+    };
+    Object.defineProperty(OfficeMathRunElement.prototype, "mathFormat", {
+        /** Math run format (`m:rPr`). */
+        get: function () { return this._mathFormat; },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathRunElement;
+}(OfficeMathFunctionBase));
+export { OfficeMathRunElement };

package/src/office-common/features/mathml/office-math/unknown-element.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Preservation of unrecognized Math elements.
+ */
+import { MathFunctionType } from './enums';
+import { OfficeMathFunctionBase } from './function-base';
+import { OfficeMathEntity } from './entity';
+import { OpenXmlElement } from '../openxml';
+/**
+ * An unrecognized `m:*` element kept verbatim so a load and save does not lose content.
+ *
+ * @public
+ */
+export declare class OfficeMathUnknownElement extends OfficeMathFunctionBase {
+    readonly type: MathFunctionType;
+    private readonly _localName;
+    private readonly _xml;
+    /**
+     * Creates the preserved element.
+     *
+     * @param {string} localName Local name of the element.
+     * @param {OpenXmlElement} xml The original element tree.
+     * @param {OfficeMathEntity} owner Optional owner.
+     */
+    constructor(localName: string, xml: OpenXmlElement, owner?: OfficeMathEntity);
+    /**
+     * Local name of the preserved element.
+     *
+     * @returns {string} The local name.
+     */
+    readonly localName: string;
+    /**
+     * The preserved element tree, re-serialized verbatim.
+     *
+     * @returns {OpenXmlElement} The original element tree.
+     */
+    readonly preservedXml: OpenXmlElement;
+}

package/src/office-common/features/mathml/office-math/unknown-element.js

@@ -0,0 +1,62 @@
+/**
+ * Preservation of unrecognized Math elements.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { MathFunctionType } from './enums';
+import { OfficeMathFunctionBase } from './function-base';
+/**
+ * An unrecognized `m:*` element kept verbatim so a load and save does not lose content.
+ *
+ * @public
+ */
+var OfficeMathUnknownElement = /** @class */ (function (_super) {
+    __extends(OfficeMathUnknownElement, _super);
+    /**
+     * Creates the preserved element.
+     *
+     * @param {string} localName Local name of the element.
+     * @param {OpenXmlElement} xml The original element tree.
+     * @param {OfficeMathEntity} owner Optional owner.
+     */
+    function OfficeMathUnknownElement(localName, xml, owner) {
+        var _this = _super.call(this, owner) || this;
+        _this.type = MathFunctionType.Unknown;
+        _this._localName = localName;
+        _this._xml = xml;
+        return _this;
+    }
+    Object.defineProperty(OfficeMathUnknownElement.prototype, "localName", {
+        /**
+         * Local name of the preserved element.
+         *
+         * @returns {string} The local name.
+         */
+        get: function () { return this._localName; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathUnknownElement.prototype, "preservedXml", {
+        /**
+         * The preserved element tree, re-serialized verbatim.
+         *
+         * @returns {OpenXmlElement} The original element tree.
+         */
+        get: function () { return this._xml; },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathUnknownElement;
+}(OfficeMathFunctionBase));
+export { OfficeMathUnknownElement };

package/src/office-common/features/mathml/office-math/xml-equal.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Structural equality of preserved XML trees.
+ */
+import { OpenXmlChild } from '../openxml';
+/**
+ * Compares two XML nodes structurally (names, attributes, children, text).
+ *
+ * @param {OpenXmlChild} a First node.
+ * @param {OpenXmlChild} b Second node.
+ * @returns {boolean} True when both nodes are structurally identical.
+ * @private
+ */
+export declare function xmlEqual(a: OpenXmlChild, b: OpenXmlChild): boolean;

package/src/office-common/features/mathml/office-math/xml-equal.js

@@ -0,0 +1,24 @@
+/**
+ * Structural equality of preserved XML trees.
+ */
+/**
+ * Compares two XML nodes structurally (names, attributes, children, text).
+ *
+ * @param {OpenXmlChild} a First node.
+ * @param {OpenXmlChild} b Second node.
+ * @returns {boolean} True when both nodes are structurally identical.
+ * @private
+ */
+export function xmlEqual(a, b) {
+    if (a.kind === 'text' || b.kind === 'text') {
+        return a.kind === b.kind && a.value === b.value;
+    }
+    var x = a;
+    var y = b;
+    return x.namespaceUri === y.namespaceUri && x.localName === y.localName
+        && x.attributes.length === y.attributes.length
+        && x.attributes.every(function (at, i) { return at.localName === y.attributes[i].localName
+            && at.namespaceUri === y.attributes[i].namespaceUri && at.value === y.attributes[i].value; })
+        && x.children.length === y.children.length
+        && x.children.every(function (c, i) { return xmlEqual(c, y.children[i]); });
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Tolerant OMML → Office Math model parser.
+ *
+ * Source: ECMA-376-1 §22.1 (shared-math.xsd). Never throws on load: unknown elements and
+ * structures missing required children are kept verbatim as {@link OfficeMathUnknownElement}.
+ */
+import { OpenXmlElement } from '../openxml';
+import { MathDocumentAdapter } from '../office-math/adapter';
+import { OfficeMathParagraph } from '../office-math/math-paragraph';
+import { ParseMathOptions } from './parse-options';
+/**
+ * Parses an `m:oMathPara` (or a bare `m:oMath`) into an {@link OfficeMathParagraph}.
+ *
+ * Tolerant: never throws. A bare `m:oMath` is wrapped in a paragraph that has no explicit justification.
+ * A malformed `m:oMathPara` (foreign children, text, or no `m:oMath`) is preserved verbatim as a single
+ * `OfficeMathUnknownElement` and reported through `onDiagnostic`.
+ *
+ * @param {OpenXmlElement} root The `m:oMathPara` or `m:oMath` element.
+ * @param {MathDocumentAdapter} adapter Optional host adapter supplying native runs and formats.
+ * @param {ParseMathOptions} options Optional parser options.
+ * @returns {OfficeMathParagraph} The populated model.
+ * @public
+ */
+export declare function parseOfficeMathParagraph(root: OpenXmlElement, adapter?: MathDocumentAdapter, options?: ParseMathOptions): OfficeMathParagraph;

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

@@ -0,0 +1,396 @@
+/**
+ * Tolerant OMML → Office Math model parser.
+ *
+ * Source: ECMA-376-1 §22.1 (shared-math.xsd). Never throws on load: unknown elements and
+ * structures missing required children are kept verbatim as {@link OfficeMathUnknownElement}.
+ */
+import { MATH_NAMESPACE, WML_TRANSITIONAL_NAMESPACE, XML_NAMESPACE } from '../constants';
+import { attrValue, attrValueNs, childElements, textContent } from '../openxml';
+import { MathFunctionType, MathJustification, MathLimitType, MathScriptType } from '../office-math/enums';
+import { BasicRun, BasicRunFormat } from '../office-math/basic';
+import { OfficeMathParagraph } from '../office-math/math-paragraph';
+import { OfficeMathUnknownElement } from '../office-math/unknown-element';
+import * as P from './office-math-properties';
+/**
+ * Implementation helper. @private
+ *
+ * @param {MathFunctionType} type The function type.
+ * @param {string} pr The property element (`m:*Pr`), if present.
+ * @param {string[]} args The argument element names, in order.
+ * @param {Fill} [apply] Optional property applier.
+ * @returns {Shape} The result.
+ */
+function shape(type, pr, args, apply) {
+    return { type: type, pr: pr, args: args, apply: apply };
+}
+var SHAPES = {
+    acc: shape(MathFunctionType.Accent, 'accPr', ['e'], P.applyAccent),
+    bar: shape(MathFunctionType.Bar, 'barPr', ['e'], P.applyBar),
+    borderBox: shape(MathFunctionType.BorderBox, 'borderBoxPr', ['e'], P.applyBorderBox),
+    box: shape(MathFunctionType.Box, 'boxPr', ['e'], P.applyBox),
+    f: shape(MathFunctionType.Fraction, 'fPr', ['num', 'den'], P.applyFraction),
+    func: shape(MathFunctionType.Function, 'funcPr', ['fName', 'e']),
+    groupChr: shape(MathFunctionType.GroupCharacter, 'groupChrPr', ['e'], P.applyGroupCharacter),
+    limLow: shape(MathFunctionType.Limit, 'limLowPr', ['e', 'lim']),
+    limUpp: shape(MathFunctionType.Limit, 'limUppPr', ['e', 'lim']),
+    nary: shape(MathFunctionType.NArray, 'naryPr', ['sub', 'sup', 'e'], P.applyNArray),
+    phant: shape(MathFunctionType.Phantom, 'phantPr', ['e'], P.applyPhantom),
+    rad: shape(MathFunctionType.Radical, 'radPr', ['deg', 'e'], P.applyRadical),
+    sPre: shape(MathFunctionType.LeftSubSuperscript, 'sPrePr', ['sub', 'sup', 'e']),
+    sSub: shape(MathFunctionType.SubSuperscript, 'sSubPr', ['e', 'sub']),
+    sSubSup: shape(MathFunctionType.RightSubSuperscript, 'sSubSupPr', ['e', 'sub', 'sup'], P.applyRightScript),
+    sSup: shape(MathFunctionType.SubSuperscript, 'sSupPr', ['e', 'sup'])
+};
+/**
+ * Implementation helper. @private
+ *
+ * @param {Context} ctx The parse context.
+ * @param {OpenXmlElement} xml The source element.
+ * @param {string} message The diagnostic message.
+ * @returns {void}
+ */
+function diagnose(ctx, xml, message) {
+    if (ctx.options !== undefined && ctx.options.onDiagnostic !== undefined) {
+        var diagnostic = { path: xml.localName, message: message, localName: xml.localName };
+        ctx.options.onDiagnostic(diagnostic);
+    }
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OpenXmlElement} xml The source element.
+ * @param {OfficeMath} target The target to populate.
+ * @returns {void}
+ */
+function preserve(xml, target) {
+    target.functions.insert(target.functions.count, new OfficeMathUnknownElement(xml.localName, xml));
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OpenXmlElement} ctrl The `m:ctrlPr` element.
+ * @param {OfficeMathFunctionBase} fn The function being populated.
+ * @param {Context} ctx The parse context.
+ * @returns {OfficeRunFormat} The result.
+ */
+function ctrlFormat(ctrl, fn, ctx) {
+    return ctx.adapter !== undefined ? ctx.adapter.parseControlProperties(ctrl, fn) : new BasicRunFormat(ctrl);
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OfficeMath} target The target to populate.
+ * @param {OpenXmlElement | undefined} el The source element.
+ * @param {Context} ctx The parse context.
+ * @returns {void}
+ */
+function fillArgument(target, el, ctx) {
+    if (el === undefined) {
+        return;
+    }
+    var ctrl = P.findMathChild(el, 'ctrlPr');
+    if (ctrl !== undefined) {
+        target.preservedControlProperties = ctrl;
+    }
+    var size = P.readArgumentSize(P.findMathChild(el, 'argPr'));
+    if (size !== undefined) {
+        target.argumentSize = Number(size);
+    }
+    fillElements(target, el, ctx);
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OfficeMath} target The target to populate.
+ * @param {OpenXmlElement} parent The parent element.
+ * @param {Context} ctx The parse context.
+ * @returns {void}
+ */
+function fillElements(target, parent, ctx) {
+    childElements(parent).forEach(function (child) {
+        var isMath = child.namespaceUri === MATH_NAMESPACE;
+        if (isMath && (child.localName === 'argPr' || child.localName === 'ctrlPr')) {
+            return;
+        }
+        parseFunction(child, target, ctx);
+    });
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OpenXmlElement} el The source element.
+ * @param {OfficeMath} target The target to populate.
+ * @param {Context} ctx The parse context.
+ * @returns {void}
+ */
+function parseFunction(el, target, ctx) {
+    if (el.namespaceUri !== MATH_NAMESPACE) {
+        preserve(el, target);
+        return;
+    }
+    if (el.localName === 'r') {
+        parseRun(el, target, ctx);
+        return;
+    }
+    if (el.localName === 'd' || el.localName === 'eqArr') {
+        parseList(el, target, ctx);
+        return;
+    }
+    if (el.localName === 'm') {
+        parseMatrix(el, target, ctx);
+        return;
+    }
+    var spec = SHAPES.hasOwnProperty(el.localName) ? SHAPES[el.localName] : undefined;
+    var args = spec === undefined ? [] : spec.args.map(function (n) { return P.findMathChild(el, n); });
+    if (spec === undefined || args.some(function (a) { return a === undefined; })) {
+        if (spec !== undefined) {
+            diagnose(ctx, el, 'm:' + el.localName + ' is missing a required child');
+        }
+        preserve(el, target);
+        return;
+    }
+    var fn = target.functions.add(spec.type);
+    var pr = P.findMathChild(el, spec.pr);
+    applyCommon(fn, pr, ctx);
+    if (spec.apply !== undefined) {
+        spec.apply(fn, pr);
+    }
+    bind(el.localName, fn, args, ctx);
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OfficeMathFunctionBase} fn The function being populated.
+ * @param {OpenXmlElement | undefined} pr The property element (`m:*Pr`), if present.
+ * @param {Context} ctx The parse context.
+ * @returns {void}
+ */
+function applyCommon(fn, pr, ctx) {
+    var ctrl = P.findMathChild(pr, 'ctrlPr');
+    if (ctrl !== undefined) {
+        fn.controlProperties = ctrlFormat(ctrl, fn, ctx);
+    }
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {string} name The local name of the child element.
+ * @param {OfficeMathFunctionBase} fn The function being populated.
+ * @param {OpenXmlElement[]} a First object.
+ * @param {Context} ctx The parse context.
+ * @returns {void}
+ */
+function bind(name, fn, a, ctx) {
+    var into = function (m, i) { return fillArgument(m, a[i], ctx); };
+    switch (fn.type) {
+        case MathFunctionType.Fraction:
+            into(fn.numerator, 0);
+            into(fn.denominator, 1);
+            break;
+        case MathFunctionType.Function:
+            into(fn.functionName, 0);
+            into(fn.equation, 1);
+            break;
+        case MathFunctionType.Limit:
+            fn.limitType = name === 'limUpp' ? MathLimitType.UpperLimit : MathLimitType.LowerLimit;
+            into(fn.equation, 0);
+            into(fn.limit, 1);
+            break;
+        case MathFunctionType.NArray:
+            into(fn.subscript, 0);
+            into(fn.superscript, 1);
+            into(fn.equation, 2);
+            break;
+        case MathFunctionType.Radical:
+            into(fn.degree, 0);
+            into(fn.equation, 1);
+            break;
+        case MathFunctionType.LeftSubSuperscript:
+            into(fn.subscript, 0);
+            into(fn.superscript, 1);
+            into(fn.equation, 2);
+            break;
+        case MathFunctionType.SubSuperscript:
+            fn.scriptType = name === 'sSub' ? MathScriptType.Subscript : MathScriptType.Superscript;
+            into(fn.equation, 0);
+            into(fn.script, 1);
+            break;
+        case MathFunctionType.RightSubSuperscript:
+            into(fn.equation, 0);
+            into(fn.subscript, 1);
+            into(fn.superscript, 2);
+            break;
+        default:
+            into(fn.equation, 0);
+    }
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OpenXmlElement} el The source element.
+ * @param {OfficeMath} target The target to populate.
+ * @param {Context} ctx The parse context.
+ * @returns {void}
+ */
+function parseList(el, target, ctx) {
+    var items = P.findMathChildren(el, 'e');
+    if (items.length < 1) {
+        diagnose(ctx, el, 'm:' + el.localName + ' is missing a required m:e');
+        preserve(el, target);
+        return;
+    }
+    var isDelimiter = el.localName === 'd';
+    var fn = target.functions.add(isDelimiter ? MathFunctionType.Delimiter : MathFunctionType.EquationArray);
+    var pr = P.findMathChild(el, isDelimiter ? 'dPr' : 'eqArrPr');
+    applyCommon(fn, pr, ctx);
+    if (isDelimiter) {
+        P.applyDelimiter(fn, pr);
+    }
+    else {
+        P.applyEquationArray(fn, pr);
+    }
+    var equations = fn.equations;
+    items.forEach(function (item) { return fillArgument(equations.add(), item, ctx); });
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OpenXmlElement} el The source element.
+ * @param {OfficeMath} target The target to populate.
+ * @param {Context} ctx The parse context.
+ * @returns {void}
+ */
+function parseMatrix(el, target, ctx) {
+    var rows = P.findMathChildren(el, 'mr');
+    if (rows.length < 1) {
+        diagnose(ctx, el, 'm:m is missing a required m:mr');
+        preserve(el, target);
+        return;
+    }
+    var matrix = target.functions.add(MathFunctionType.Matrix);
+    var pr = P.findMathChild(el, 'mPr');
+    applyCommon(matrix, pr, ctx);
+    P.applyMatrix(matrix, pr);
+    var widest = rows.reduce(function (max, r) { return Math.max(max, P.findMathChildren(r, 'e').length); }, 0);
+    P.applyMatrixColumns(matrix, pr, widest);
+    rows.forEach(function (row) {
+        var created = matrix.rows.add();
+        P.findMathChildren(row, 'e').forEach(function (cell, i) { return fillArgument(created.arguments.getItem(i), cell, ctx); });
+    });
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OpenXmlElement} el The source element.
+ * @param {OfficeMath} target The target to populate.
+ * @param {Context} ctx The parse context.
+ * @returns {void}
+ */
+function parseRun(el, target, ctx) {
+    var run = target.functions.add(MathFunctionType.RunElement);
+    P.applyRunFormat(run.mathFormat, P.findMathChild(el, 'rPr'));
+    if (ctx.adapter !== undefined) {
+        ctx.adapter.parseMathRun(el, run);
+        return;
+    }
+    var item = new BasicRun();
+    childElements(el).forEach(function (child) {
+        if (child.namespaceUri === MATH_NAMESPACE && child.localName === 'rPr') {
+            return;
+        }
+        if (child.namespaceUri === WML_TRANSITIONAL_NAMESPACE && child.localName === 'rPr') {
+            item.runProperties = child;
+            return;
+        }
+        if (child.namespaceUri === MATH_NAMESPACE && child.localName === 't') {
+            var space = attrValueNs(child, XML_NAMESPACE, 'space');
+            item.parts.push(space === undefined ? { kind: 'text', value: textContent(child) }
+                : { kind: 'text', value: textContent(child), space: space });
+            return;
+        }
+        item.parts.push({ kind: 'xml', element: child });
+    });
+    run.item = item;
+}
+/**
+ * Implementation helper. @private
+ *
+ * @param {OfficeMathParagraph} paragraph The paragraph being populated.
+ * @param {OpenXmlElement} oMath The `m:oMath` element.
+ * @param {Context} ctx The parse context.
+ * @returns {void}
+ */
+function fillRoot(paragraph, oMath, ctx) {
+    fillElements(paragraph.maths.add(), oMath, ctx);
+}
+/**
+ * Parses an `m:oMathPara` (or a bare `m:oMath`) into an {@link OfficeMathParagraph}.
+ *
+ * Tolerant: never throws. A bare `m:oMath` is wrapped in a paragraph that has no explicit justification.
+ * A malformed `m:oMathPara` (foreign children, text, or no `m:oMath`) is preserved verbatim as a single
+ * `OfficeMathUnknownElement` and reported through `onDiagnostic`.
+ *
+ * @param {OpenXmlElement} root The `m:oMathPara` or `m:oMath` element.
+ * @param {MathDocumentAdapter} adapter Optional host adapter supplying native runs and formats.
+ * @param {ParseMathOptions} options Optional parser options.
+ * @returns {OfficeMathParagraph} The populated model.
+ * @public
+ */
+export function parseOfficeMathParagraph(root, adapter, options) {
+    var paragraph = new OfficeMathParagraph(adapter);
+    var ctx = { adapter: adapter, options: options };
+    paragraph.suspendMutations(function () {
+        if (!isWellFormedRoot(root)) {
+            diagnose(ctx, root, 'm:' + root.localName + ' is not a well-formed m:oMath or m:oMathPara; preserved verbatim');
+            preserve(root, paragraph.maths.add());
+            return;
+        }
+        if (root.localName === 'oMath') {
+            fillRoot(paragraph, root, ctx);
+            return;
+        }
+        var jc = attrValueOf(P.findMathChild(P.findMathChild(root, 'oMathParaPr'), 'jc'));
+        if (jc !== undefined && Object.prototype.hasOwnProperty.call(JUSTIFICATION, jc)) {
+            paragraph.justification = JUSTIFICATION[jc];
+        }
+        P.findMathChildren(root, 'oMath').forEach(function (m) { return fillRoot(paragraph, m, ctx); });
+    });
+    return paragraph;
+}
+/**
+ * A root is well formed when it is `m:oMath`, or an `m:oMathPara` whose children are an optional
+ * `m:oMathParaPr` followed by at least one `m:oMath` and nothing else.
+ *
+ * @param {OpenXmlElement} root The candidate root element.
+ * @returns {boolean} True when the root can be modelled without losing content.
+ */
+function isWellFormedRoot(root) {
+    if (root.namespaceUri !== MATH_NAMESPACE) {
+        return false;
+    }
+    if (root.localName === 'oMath') {
+        return true;
+    }
+    if (root.localName !== 'oMathPara') {
+        return false;
+    }
+    var children = childElements(root).slice();
+    var nonMath = children.filter(function (c) { return c.namespaceUri !== MATH_NAMESPACE; });
+    var others = children.filter(function (c) { return c.namespaceUri === MATH_NAMESPACE
+        && c.localName !== 'oMath' && c.localName !== 'oMathParaPr'; });
+    var hasText = root.children.some(function (c) { return c.kind === 'text' && (c.value || '').trim() !== ''; });
+    return nonMath.length === 0 && others.length === 0 && !hasText && P.findMathChildren(root, 'oMath').length > 0;
+}
+var JUSTIFICATION = {
+    left: MathJustification.Left, right: MathJustification.Right,
+    center: MathJustification.Center, centerGroup: MathJustification.CenterGroup
+};
+/**
+ * Implementation helper. @private
+ *
+ * @param {OpenXmlElement | undefined} el The source element.
+ * @returns {string | undefined} The result.
+ */
+function attrValueOf(el) {
+    return el === undefined ? undefined : attrValue(el, 'val');
+}