@syncfusion/ej2-office-common 35.1.37

package/src/features/mathml/openxml.js

@@ -0,0 +1,87 @@
+/**
+ * Local structural OpenXml element-tree contract for mathml parse/serialize.
+ *
+ * office-common has no shared `src/core/xml` yet (TASK-9002/9003). This
+ * mirrors ej2-docx `src/core/xml/model.ts` so TASK-9011 can pass the same
+ * tree shape across the boundary. Unify when core XML lands.
+ *
+ * These types are part of the public `@syncfusion/ej2-office-common/mathml` surface
+ * (parse/serialize boundary). Keep them public under stripInternal builds —
+ * never tag this module as internal.
+ */
+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 };
+        }
+    };
+};
+/** Create an immutable element node. */
+export function createElement(namespaceUri, localName, prefix, options) {
+    return { kind: 'element',
+        namespaceUri: namespaceUri,
+        localName: localName,
+        prefix: prefix,
+        attributes: function () {
+            var _nc = options == null ? void 0 : options.attributes;
+            return _nc != null ? _nc : [];
+        }(),
+        namespaceDeclarations: function () {
+            var _nc = options == null ? void 0 : options.namespaceDeclarations;
+            return _nc != null ? _nc : [];
+        }(),
+        children: function () {
+            var _nc = options == null ? void 0 : options.children;
+            return _nc != null ? _nc : [];
+        }()
+    };
+}
+/** Create a text node. */
+export function createText(value) {
+    return {
+        kind: 'text',
+        value: value
+    };
+}
+/** Filter element children only. */
+export function childElements(element) {
+    return element.children.filter(function (c) { return c.kind === 'element'; });
+}
+/** Read the first matching attribute value by local name (any namespace). */
+export function attrValue(element, localName) {
+    return function () {
+        var _om = element.attributes.find(function (a) { return a.localName === localName; });
+        return _om == null ? void 0 : _om.value;
+    }();
+}
+/** Read attribute value restricted to a namespace URI. */
+export function attrValueNs(element, namespaceUri, localName) {
+    return function () {
+        var _om = element.attributes.find(function (a) { return a.namespaceUri === namespaceUri && a.localName === localName; });
+        return _om == null ? void 0 : _om.value;
+    }();
+}
+/** Concatenate direct text-node children. */
+export function textContent(element) {
+    var e_1, _a;
+    var out = '';
+    try {
+        for (var _b = __values(element.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (child.kind === 'text') {
+                out += child.value;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return out;
+}

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

@@ -0,0 +1,43 @@
+/**
+ * Tolerant OMML element-tree → typed Math* DOM parser.
+ *
+ * Source: mathml-spec §8; ECMA-376-4 Annex A.8.1.
+ * Never throws on load. Unknown m:* → UnknownMathElement.
+ * Malformed required structure → markPreserveOnly + optional diagnostic.
+ */
+import { OpenXmlElement } from '../openxml';
+import { MathElement } from '../model/math-element';
+/**
+ * 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;
+}
+/**
+ * Parse a single OMML root element (`m:oMathPara`, `m:oMath`, or any EG_OMathElements member)
+ * into a typed {@link MathElement}.
+ *
+ * Tolerant: never throws. Unknown / malformed nodes degrade rather than abort.
+ *
+ * @public
+ */
+export declare function parseMathElement(root: OpenXmlElement, options?: ParseMathOptions): MathElement;
+/**
+ * Parse zero or more sibling math roots (e.g. multiple `m:oMath` under a paragraph host).
+ *
+ * @public
+ */
+export declare function parseMathElements(roots: ReadonlyArray<OpenXmlElement>, options?: ParseMathOptions): MathElement[];