@syncfusion/ej2-office-common 35.1.37

package/src/features/ink/trace-codec.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Pure InkML trace codec (W3C InkML §3.2.1 via [MS-ODRAWXML] §1.2.1 / §2.1.4).
+ *
+ * Decodes differential-prefix packet text into absolute channel rows and plane
+ * points; encodes points as absolute `"x y, x y, …"` text. No XML dependency.
+ */
+/**
+ * Plane point used by ink traces and scaled path helpers.
+ *
+ * @private
+ */
+export interface InkPoint {
+    /** Horizontal coordinate in the active ink plane units. */
+    readonly x: number;
+    /** Vertical coordinate in the active ink plane units. */
+    readonly y: number;
+}
+/**
+ * Axis-aligned bounding box over decoded plane points.
+ *
+ * @private
+ */
+export interface InkBounds {
+    /** Minimum horizontal coordinate among the points. */
+    readonly minX: number;
+    /** Minimum vertical coordinate among the points. */
+    readonly minY: number;
+    /** Maximum horizontal coordinate among the points. */
+    readonly maxX: number;
+    /** Maximum vertical coordinate among the points. */
+    readonly maxY: number;
+}
+/**
+ * Width and height extent in the same coordinate space as plane points.
+ *
+ * @private
+ */
+export interface InkExtent {
+    /** Horizontal span of the drawing area. */
+    readonly width: number;
+    /** Vertical span of the drawing area. */
+    readonly height: number;
+}
+/**
+ * Security / guard counters for a decode pass.
+ *
+ * Consumers enforce hard limits; this module only surfaces counts so empty or
+ * whitespace-only input cannot loop unbounded without observability.
+ *
+ * @public
+ */
+export interface TraceDecodeStats {
+    readonly packetCount: number;
+    readonly channelValueCount: number;
+    readonly pointCount: number;
+}
+/**
+ * Result of decoding a trace string to channel rows and plane points.
+ *
+ * @public
+ */
+export interface TraceDecodeResult {
+    /** Absolute channel rows in document channel order (default X, Y, …). */
+    readonly channelRows: ReadonlyArray<ReadonlyArray<number>>;
+    /** Plane points from X/Y reduction (missing X or Y → point omitted). */
+    readonly points: ReadonlyArray<InkPoint>;
+    /** Guard counters for the decode pass. */
+    readonly stats: TraceDecodeStats;
+}
+/**
+ * Decode InkML trace text into absolute channel rows and X/Y plane points.
+ *
+ * Rules (W3C InkML §3.2.1):
+ * - Packets are comma-separated.
+ * - Channel values are whitespace-separated.
+ * - A `!` / `'` / `"` prefix before a value switches interpretation for the
+ *   **rest of that packet** (absolute, first-difference, second-difference).
+ * - First differences apply against the previous packet's same-channel value.
+ * - Second differences accumulate per channel across packets.
+ * - Default channel order when no context is supplied: X then Y.
+ * - Extra channels are tolerated; reduction uses the first two as X/Y when
+ *   present. A row missing X or Y does not produce a plane point.
+ *
+ * Empty / whitespace-only input yields zero packets and zero points (guarded).
+ *
+ * @public
+ */
+export declare function decodeTrace(traceText: string): TraceDecodeResult;
+/**
+ * Encode plane points as absolute InkML trace text (`"x y, x y, …"`).
+ *
+ * Always absolute (no differential prefixes). Generated from points only —
+ * never from stored markup (DOM mandate).
+ *
+ * @public
+ */
+export declare function encodeTrace(points: ReadonlyArray<InkPoint>): string;
+/**
+ * Compute axis-aligned bounds over plane points.
+ * Empty input returns a zero box (min=max=0) so callers can branch on count.
+ *
+ * @public
+ */
+export declare function computeInkBounds(points: ReadonlyArray<InkPoint>): InkBounds;
+/**
+ * Uniform scale of decoded strokes into an extent **without re-zeroing**.
+ *
+ * scale = min(extent.w / (maxX−minX), extent.h / (maxY−minY)) when the span
+ * is positive; origin of the coordinate system is preserved (decoded path).
+ * Degenerate (zero-span) axes map to the extent origin for that axis only.
+ *
+ * Source: cross-repo ink spec § Parser behavior — uniform scale for decoded
+ * strokes.
+ *
+ * @public
+ */
+export declare function scalePointsUniform(points: ReadonlyArray<InkPoint>, extent: InkExtent): ReadonlyArray<InkPoint>;
+/**
+ * Stretch-to-fit scale for **authored** strokes: re-zero to minX/minY, then
+ * stretch independently to the extent.
+ *
+ * Source: cross-repo ink spec § Parser behavior — authored strokes re-zero
+ * and stretch to the extent.
+ *
+ * @public
+ */
+export declare function scalePointsStretch(points: ReadonlyArray<InkPoint>, extent: InkExtent): ReadonlyArray<InkPoint>;

package/src/features/ink/trace-codec.js

@@ -0,0 +1,266 @@
+/**
+ * Pure InkML trace codec (W3C InkML §3.2.1 via [MS-ODRAWXML] §1.2.1 / §2.1.4).
+ *
+ * Decodes differential-prefix packet text into absolute channel rows and plane
+ * points; encodes points as absolute `"x y, x y, …"` text. No XML dependency.
+ */
+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 PREFIX_ABSOLUTE = '!';
+var PREFIX_FIRST_DIFF = "'";
+var PREFIX_SECOND_DIFF = '"';
+/**
+ * Tokenize a single channel value, stripping an optional InkML prefix.
+ * Source: W3C InkML §3.2.1 — `!` absolute, `'` first difference, `"` second difference.
+ */
+function splitPrefix(token) {
+    if (token.length === 0) {
+        return { prefix: undefined, raw: token };
+    }
+    var head = token.charAt(0);
+    if (head === PREFIX_ABSOLUTE) {
+        return { prefix: 'absolute', raw: token.slice(1) };
+    }
+    if (head === PREFIX_FIRST_DIFF) {
+        return { prefix: 'first', raw: token.slice(1) };
+    }
+    if (head === PREFIX_SECOND_DIFF) {
+        return { prefix: 'second', raw: token.slice(1) };
+    }
+    return { prefix: undefined, raw: token };
+}
+function parseNumber(raw) {
+    if (raw.length === 0) {
+        return undefined;
+    }
+    var n = Number(raw);
+    return Number.isFinite(n) ? n : undefined;
+}
+/**
+ * Decode InkML trace text into absolute channel rows and X/Y plane points.
+ *
+ * Rules (W3C InkML §3.2.1):
+ * - Packets are comma-separated.
+ * - Channel values are whitespace-separated.
+ * - A `!` / `'` / `"` prefix before a value switches interpretation for the
+ *   **rest of that packet** (absolute, first-difference, second-difference).
+ * - First differences apply against the previous packet's same-channel value.
+ * - Second differences accumulate per channel across packets.
+ * - Default channel order when no context is supplied: X then Y.
+ * - Extra channels are tolerated; reduction uses the first two as X/Y when
+ *   present. A row missing X or Y does not produce a plane point.
+ *
+ * Empty / whitespace-only input yields zero packets and zero points (guarded).
+ *
+ * @public
+ */
+export function decodeTrace(traceText) {
+    var e_1, _a;
+    var trimmed = traceText.trim();
+    if (trimmed.length === 0) {
+        return {
+            channelRows: [],
+            points: [],
+            stats: { packetCount: 0, channelValueCount: 0, pointCount: 0 },
+        };
+    }
+    var packetStrings = trimmed.split(',');
+    var channelRows = [];
+    var points = [];
+    var channelValueCount = 0;
+    // Previous absolute channel values (for first-difference).
+    var previous = [];
+    // Running second-difference deltas per channel (mutated in place per index).
+    var secondDelta = [];
+    // Default mode between packets is absolute until a prefix appears.
+    var defaultMode = 'absolute';
+    try {
+        for (var packetStrings_1 = __values(packetStrings), packetStrings_1_1 = packetStrings_1.next(); !packetStrings_1_1.done; packetStrings_1_1 = packetStrings_1.next()) {
+            var packetString = packetStrings_1_1.value;
+            var tokens = packetString.trim().split(/\s+/).filter(function (t) { return t.length > 0; });
+            if (tokens.length === 0) {
+                // Empty packet (e.g. trailing comma) — skip without inventing channels.
+                continue;
+            }
+            var mode = defaultMode;
+            var row = [];
+            for (var i = 0; i < tokens.length; i++) {
+                var token = tokens[i];
+                if (token === undefined) {
+                    continue;
+                }
+                var _b = splitPrefix(token), prefix = _b.prefix, raw = _b.raw;
+                if (prefix !== undefined) {
+                    mode = prefix;
+                    // Prefix mode persists for subsequent packets until another prefix.
+                    defaultMode = prefix;
+                }
+                var value = parseNumber(raw);
+                channelValueCount += 1;
+                if (value === undefined) {
+                    // Malformed token: skip channel slot (best-effort; no invented number).
+                    continue;
+                }
+                var absolute = void 0;
+                if (mode === 'absolute') {
+                    absolute = value;
+                    // Reset second-diff accumulator for this channel when absolute is used.
+                    secondDelta[i] = 0;
+                }
+                else if (mode === 'first') {
+                    var base = (previous[i] != null ? previous[i] : 0);
+                    absolute = base + value;
+                    secondDelta[i] = value;
+                }
+                else {
+                    // second difference: accumulate delta, then add to previous absolute
+                    var prevDelta = (secondDelta[i] != null ? secondDelta[i] : 0);
+                    var newDelta = prevDelta + value;
+                    secondDelta[i] = newDelta;
+                    var base = (previous[i] != null ? previous[i] : 0);
+                    absolute = base + newDelta;
+                }
+                row[i] = absolute;
+            }
+            channelRows.push(row);
+            previous = row.slice();
+            var x = row[0];
+            var y = row[1];
+            if (x !== undefined && y !== undefined) {
+                points.push({ x: x, y: y });
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (packetStrings_1_1 && !packetStrings_1_1.done && (_a = packetStrings_1.return)) _a.call(packetStrings_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return {
+        channelRows: channelRows,
+        points: points,
+        stats: {
+            packetCount: channelRows.length,
+            channelValueCount: channelValueCount,
+            pointCount: points.length,
+        },
+    };
+}
+/**
+ * Encode plane points as absolute InkML trace text (`"x y, x y, …"`).
+ *
+ * Always absolute (no differential prefixes). Generated from points only —
+ * never from stored markup (DOM mandate).
+ *
+ * @public
+ */
+export function encodeTrace(points) {
+    if (points.length === 0) {
+        return '';
+    }
+    return points.map(function (p) { return formatCoord(p.x) + " " + formatCoord(p.y); }).join(', ');
+}
+function formatCoord(n) {
+    // Prefer compact integer form when exact; otherwise default number string.
+    if (Number.isInteger(n)) {
+        return String(n);
+    }
+    return String(n);
+}
+/**
+ * Compute axis-aligned bounds over plane points.
+ * Empty input returns a zero box (min=max=0) so callers can branch on count.
+ *
+ * @public
+ */
+export function computeInkBounds(points) {
+    var first = points[0];
+    if (first === undefined) {
+        return { minX: 0, minY: 0, maxX: 0, maxY: 0 };
+    }
+    var minX = first.x;
+    var minY = first.y;
+    var maxX = minX;
+    var maxY = minY;
+    for (var i = 1; i < points.length; i++) {
+        var p = points[i];
+        if (p === undefined) {
+            continue;
+        }
+        if (p.x < minX)
+            minX = p.x;
+        if (p.y < minY)
+            minY = p.y;
+        if (p.x > maxX)
+            maxX = p.x;
+        if (p.y > maxY)
+            maxY = p.y;
+    }
+    return { minX: minX, minY: minY, maxX: maxX, maxY: maxY };
+}
+/**
+ * Uniform scale of decoded strokes into an extent **without re-zeroing**.
+ *
+ * scale = min(extent.w / (maxX−minX), extent.h / (maxY−minY)) when the span
+ * is positive; origin of the coordinate system is preserved (decoded path).
+ * Degenerate (zero-span) axes map to the extent origin for that axis only.
+ *
+ * Source: cross-repo ink spec § Parser behavior — uniform scale for decoded
+ * strokes.
+ *
+ * @public
+ */
+export function scalePointsUniform(points, extent) {
+    if (points.length === 0) {
+        return [];
+    }
+    var bounds = computeInkBounds(points);
+    var spanX = bounds.maxX - bounds.minX;
+    var spanY = bounds.maxY - bounds.minY;
+    var scaleX = spanX > 0 ? extent.width / spanX : 0;
+    var scaleY = spanY > 0 ? extent.height / spanY : 0;
+    var scale = spanX > 0 && spanY > 0
+        ? Math.min(scaleX, scaleY)
+        : spanX > 0
+            ? scaleX
+            : spanY > 0
+                ? scaleY
+                : 0;
+    return points.map(function (p) { return ({
+        x: p.x * scale,
+        y: p.y * scale,
+    }); });
+}
+/**
+ * Stretch-to-fit scale for **authored** strokes: re-zero to minX/minY, then
+ * stretch independently to the extent.
+ *
+ * Source: cross-repo ink spec § Parser behavior — authored strokes re-zero
+ * and stretch to the extent.
+ *
+ * @public
+ */
+export function scalePointsStretch(points, extent) {
+    if (points.length === 0) {
+        return [];
+    }
+    var bounds = computeInkBounds(points);
+    var spanX = bounds.maxX - bounds.minX;
+    var spanY = bounds.maxY - bounds.minY;
+    var scaleX = spanX > 0 ? extent.width / spanX : 0;
+    var scaleY = spanY > 0 ? extent.height / spanY : 0;
+    return points.map(function (p) { return ({
+        x: spanX > 0 ? (p.x - bounds.minX) * scaleX : 0,
+        y: spanY > 0 ? (p.y - bounds.minY) * scaleY : 0,
+    }); });
+}

package/src/features/mathml/constants.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Cited Office Math Markup Language (OMML) constants.
+ *
+ * Sources:
+ * - ECMA-376 Part 1 §22.1 (Office Math)
+ * - ECMA-376 Part 4 Annex A.8.1 `shared-math.xsd`
+ * - ECMA-376 Part 1 WordprocessingML transitional namespace
+ * - W3C XML 1.0 `xml:` namespace (xml:space on m:t)
+ */
+/**
+ * Office Math namespace URI (`m:`).
+ *
+ * Source: ECMA-376-1 §22.1 /
+ * `http://schemas.openxmlformats.org/officeDocument/2006/math`.
+ *
+ * @public
+ */
+export declare const MATH_NAMESPACE = "http://schemas.openxmlformats.org/officeDocument/2006/math";
+/**
+ * Preferred math prefix candidates for save-scoped registry.
+ * First unused candidate wins: `m`, then `m1`, `m2`, …
+ *
+ * Source: mathml-spec §1.9 / §9.3.
+ *
+ * @public
+ */
+export declare const MATH_PREFIX_FALLBACKS: string[];
+/**
+ * WordprocessingML transitional namespace (`w:`).
+ *
+ * Used when bridging `w:rPr` / run content under `m:r` and `m:ctrlPr`
+ * (ECMA-376-4 Annex A.8.1 `CT_R` / `CT_CtrlPr`).
+ *
+ * Source: ECMA-376-1 —
+ * `http://schemas.openxmlformats.org/wordprocessingml/2006/main`.
+ *
+ * @public
+ */
+export declare const WML_TRANSITIONAL_NAMESPACE = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+/**
+ * XML namespace used by `xml:space` on `m:t` (same policy as `w:t`).
+ *
+ * Source: W3C XML 1.0 — `http://www.w3.org/XML/1998/namespace`.
+ *
+ * @public
+ */
+export declare const XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";

package/src/features/mathml/constants.js

@@ -0,0 +1,47 @@
+/**
+ * Cited Office Math Markup Language (OMML) constants.
+ *
+ * Sources:
+ * - ECMA-376 Part 1 §22.1 (Office Math)
+ * - ECMA-376 Part 4 Annex A.8.1 `shared-math.xsd`
+ * - ECMA-376 Part 1 WordprocessingML transitional namespace
+ * - W3C XML 1.0 `xml:` namespace (xml:space on m:t)
+ */
+/**
+ * Office Math namespace URI (`m:`).
+ *
+ * Source: ECMA-376-1 §22.1 /
+ * `http://schemas.openxmlformats.org/officeDocument/2006/math`.
+ *
+ * @public
+ */
+export var MATH_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/math';
+/**
+ * Preferred math prefix candidates for save-scoped registry.
+ * First unused candidate wins: `m`, then `m1`, `m2`, …
+ *
+ * Source: mathml-spec §1.9 / §9.3.
+ *
+ * @public
+ */
+export var MATH_PREFIX_FALLBACKS = ['m', 'm1', 'm2', 'm3', 'm4', 'm5'];
+/**
+ * WordprocessingML transitional namespace (`w:`).
+ *
+ * Used when bridging `w:rPr` / run content under `m:r` and `m:ctrlPr`
+ * (ECMA-376-4 Annex A.8.1 `CT_R` / `CT_CtrlPr`).
+ *
+ * Source: ECMA-376-1 —
+ * `http://schemas.openxmlformats.org/wordprocessingml/2006/main`.
+ *
+ * @public
+ */
+export var WML_TRANSITIONAL_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+/**
+ * XML namespace used by `xml:space` on `m:t` (same policy as `w:t`).
+ *
+ * Source: W3C XML 1.0 — `http://www.w3.org/XML/1998/namespace`.
+ *
+ * @public
+ */
+export var XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';

package/src/features/mathml/errors.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Typed mathml errors (mathml-spec Errors section).
+ *
+ * Common-owned; docx-js passes them through untouched.
+ */
+/**
+ * Constraint categories for {@link MathmlValidationError}.
+ *
+ * @private
+ * Internal error detail; not part of the public authoring API.
+ */
+export declare type MathmlConstraintKind = 'child-order' | 'enum-value' | 'required-child' | 'value-range';
+/**
+ * Schema violation detected on author/serialize of a typed math tree.
+ *
+ * Source: mathml-spec Errors section —
+ * `elementPath` dotted model path (e.g. `'oMath.f.den'`),
+ * `constraintKind` one of child-order | enum-value | required-child | value-range.
+ *
+ * @private
+ * Internal error contract between the mathml model, parser, and serializer;
+ * not part of the public authoring API.
+ */
+export declare class MathmlValidationError extends Error {
+    /**
+     * Dotted model path of the violating element (e.g. `'oMath.f.den'`).
+     */
+    readonly elementPath: string;
+    /**
+     * Constraint category that was violated.
+     */
+    readonly constraintKind: MathmlConstraintKind;
+    constructor(message: string, elementPath: string, constraintKind: MathmlConstraintKind);
+}
+/**
+ * Mutation attempted on a preserve-only (degraded) math equation.
+ *
+ * Source: mathml-spec §8b — malformed load degrades; later mutate throws.
+ *
+ * @private
+ * Internal error contract between the mathml model, parser, and serializer;
+ * not part of the public authoring API.
+ */
+export declare class MathmlReadOnlyError extends Error {
+    /**
+     * Always `true` — the equation is locked in preserve-only mode and mutations are blocked.
+     */
+    readonly isPreserveOnly: true;
+    constructor(message?: string);
+}

package/src/features/mathml/errors.js

@@ -0,0 +1,69 @@
+/**
+ * Typed mathml errors (mathml-spec Errors section).
+ *
+ * Common-owned; docx-js passes them through untouched.
+ */
+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 __());
+    };
+})();
+/**
+ * Schema violation detected on author/serialize of a typed math tree.
+ *
+ * Source: mathml-spec Errors section —
+ * `elementPath` dotted model path (e.g. `'oMath.f.den'`),
+ * `constraintKind` one of child-order | enum-value | required-child | value-range.
+ *
+ * @private
+ * Internal error contract between the mathml model, parser, and serializer;
+ * not part of the public authoring API.
+ */
+var MathmlValidationError = /** @class */ (function (_super) {
+    __extends(MathmlValidationError, _super);
+    function MathmlValidationError(message, elementPath, constraintKind) {
+        var _newTarget = this.constructor;
+        var _this = _super.call(this, message) || this;
+        _this.name = 'MathmlValidationError';
+        _this.elementPath = elementPath;
+        _this.constraintKind = constraintKind;
+        Object.setPrototypeOf(_this, _newTarget.prototype);
+        return _this;
+    }
+    return MathmlValidationError;
+}(Error));
+export { MathmlValidationError };
+/**
+ * Mutation attempted on a preserve-only (degraded) math equation.
+ *
+ * Source: mathml-spec §8b — malformed load degrades; later mutate throws.
+ *
+ * @private
+ * Internal error contract between the mathml model, parser, and serializer;
+ * not part of the public authoring API.
+ */
+var MathmlReadOnlyError = /** @class */ (function (_super) {
+    __extends(MathmlReadOnlyError, _super);
+    function MathmlReadOnlyError(message) {
+        var _newTarget = this.constructor;
+        if (message === void 0) { message = 'Math equation is preserve-only and cannot be mutated'; }
+        var _this = _super.call(this, message) || this;
+        /**
+         * Always `true` — the equation is locked in preserve-only mode and mutations are blocked.
+         */
+        _this.isPreserveOnly = true;
+        _this.name = 'MathmlReadOnlyError';
+        Object.setPrototypeOf(_this, _newTarget.prototype);
+        return _this;
+    }
+    return MathmlReadOnlyError;
+}(Error));
+export { MathmlReadOnlyError };

package/src/features/mathml/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Optional Office Math Markup Language (OMML) feature module
+ * (`@syncfusion/ej2-office-common/mathml`).
+ *
+ * Provides the shared typed Math* DOM, tolerant OMML parser, strict
+ * serializer, clone/equality helpers, and cited constants. "MathML" here
+ * means OMML (`m:*` per ECMA-376-1 §22.1 / Part 4 Annex A.8.1) — not W3C MathML.
+ *
+ * Docx integration (`MathInline`, paragraph accessors, save hook) is TASK-9011.
+ *
+ * @packageDocumentation
+ */
+export { MATH_NAMESPACE, MATH_PREFIX_FALLBACKS, WML_TRANSITIONAL_NAMESPACE, XML_NAMESPACE, } from './constants';
+export { MathBreakBin, MathBreakBinSub, MathFractionType, MathJc, MathLimLoc, MathScript, MathShape, MathSpacingRule, MathStyle, MathTopBot, } from './model/enums';
+export { MATH_BREAKBIN_VALUES, MATH_BREAKBINSUB_VALUES, MATH_FTYPE_VALUES, MATH_JC_VALUES, MATH_LIMLOC_VALUES, MATH_SCRIPT_VALUES, MATH_SHP_VALUES, MATH_SPACING_RULE_VALUES, MATH_STYLE_VALUES, MATH_TOPBOT_VALUES, emitOnOff, isInteger2, isInteger255, isSpacingRule, isUnSignedInteger, parseMathBreakBin, parseMathBreakBinSub, parseMathFractionType, parseMathJc, parseMathLimLoc, parseMathScript, parseMathShape, parseMathStyle, parseMathTopBot, parseOnOff, } from './model/enums';
+export { MathArgProperties, MathElementKind, MathElementType, } from './model/math-element';
+export { MathArgument, MathElement, MathText, UnknownMathElement, mathArg, } from './model/math-element';
+export { MathParaProperties } from './model/roots';
+export { MathOMath, MathParagraph } from './model/roots';
+export { MathAccentProperties, MathBarProperties, MathBorderBoxProperties, MathBoxProperties, MathCtrlPr, MathDelimiterProperties, MathEquationArrayProperties, MathFractionProperties, MathFunctionProperties, MathGroupCharacterProperties, MathLimitProperties, MathMatrixProperties, MathNaryProperties, MathPhantomProperties, MathRadicalProperties, MathRunProperties, MathScriptControlProperties, } from './model/controls';
+export { MathAccent, MathBar, MathBorderBox, MathBox, MathDelimiter, MathEquationArray, MathFraction, MathFunction, MathGroupCharacter, MathLimitLower, MathLimitUpper, MathMatrix, MathMatrixRow, MathNaryOperator, MathPhantom, MathPreSubSuperscript, MathRadical, MathRun, MathSubscript, MathSubSuperscript, MathSuperscript, } from './model/controls';
+export { MathParseDiagnostic, ParseMathOptions } from './parse/math-parser';
+export { parseMathElement, parseMathElements } from './parse/math-parser';
+export { SerializeMathOptions } from './serialize/math-serializer';
+export { mathElementToOpenXml } from './serialize/math-serializer';
+export { cloneMathElement, mathEqual } from './math-factory';
+export { MathmlConstraintKind } from './errors';
+export { MathmlReadOnlyError, MathmlValidationError } from './errors';
+export { NamespaceDeclaration, OpenXmlAttribute, OpenXmlChild, OpenXmlElement, OpenXmlText, } from './openxml';
+export { attrValue, attrValueNs, childElements, createElement, createText, textContent, } from './openxml';

package/src/features/mathml/index.js

@@ -0,0 +1,22 @@
+/**
+ * Optional Office Math Markup Language (OMML) feature module
+ * (`@syncfusion/ej2-office-common/mathml`).
+ *
+ * Provides the shared typed Math* DOM, tolerant OMML parser, strict
+ * serializer, clone/equality helpers, and cited constants. "MathML" here
+ * means OMML (`m:*` per ECMA-376-1 §22.1 / Part 4 Annex A.8.1) — not W3C MathML.
+ *
+ * Docx integration (`MathInline`, paragraph accessors, save hook) is TASK-9011.
+ *
+ * @packageDocumentation
+ */
+export { MATH_NAMESPACE, MATH_PREFIX_FALLBACKS, WML_TRANSITIONAL_NAMESPACE, XML_NAMESPACE, } from './constants';
+export { MATH_BREAKBIN_VALUES, MATH_BREAKBINSUB_VALUES, MATH_FTYPE_VALUES, MATH_JC_VALUES, MATH_LIMLOC_VALUES, MATH_SCRIPT_VALUES, MATH_SHP_VALUES, MATH_SPACING_RULE_VALUES, MATH_STYLE_VALUES, MATH_TOPBOT_VALUES, emitOnOff, isInteger2, isInteger255, isSpacingRule, isUnSignedInteger, parseMathBreakBin, parseMathBreakBinSub, parseMathFractionType, parseMathJc, parseMathLimLoc, parseMathScript, parseMathShape, parseMathStyle, parseMathTopBot, parseOnOff, } from './model/enums';
+export { MathArgument, MathElement, MathText, UnknownMathElement, mathArg, } from './model/math-element';
+export { MathOMath, MathParagraph } from './model/roots';
+export { MathAccent, MathBar, MathBorderBox, MathBox, MathDelimiter, MathEquationArray, MathFraction, MathFunction, MathGroupCharacter, MathLimitLower, MathLimitUpper, MathMatrix, MathMatrixRow, MathNaryOperator, MathPhantom, MathPreSubSuperscript, MathRadical, MathRun, MathSubscript, MathSubSuperscript, MathSuperscript, } from './model/controls';
+export { parseMathElement, parseMathElements } from './parse/math-parser';
+export { mathElementToOpenXml } from './serialize/math-serializer';
+export { cloneMathElement, mathEqual } from './math-factory';
+export { MathmlReadOnlyError, MathmlValidationError } from './errors';
+export { attrValue, attrValueNs, childElements, createElement, createText, textContent, } from './openxml';