@syncfusion/ej2-office-common 35.1.37 → 35.1.42

package/src/office-common/features/mathml/office-math/collection.js

@@ -0,0 +1,170 @@
+/**
+ * Generic owner-aware mutable collection used by every Math collection.
+ */
+/**
+ * Ordered collection that assigns/detaches owners and notifies the root on change.
+ * Items are also reachable by numeric index (`collection[0]`).
+ *
+ * @public
+ */
+var OwnedCollection = /** @class */ (function () {
+    function OwnedCollection(owner) {
+        this.owner = owner;
+        this._items = [];
+        this._synced = 0;
+    }
+    Object.defineProperty(OwnedCollection.prototype, "count", {
+        /** Number of items. */
+        get: function () {
+            return this._items.length;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Returns the item at `index`.
+     *
+     * @param index
+     */
+    OwnedCollection.prototype.getItem = function (index) {
+        this.checkIndex(index, this._items.length - 1);
+        return this._items[index];
+    };
+    /**
+     * Inserts an item at `index`; throws when it already belongs to a collection.
+     *
+     * @param index
+     * @param item
+     */
+    OwnedCollection.prototype.insert = function (index, item) {
+        this.insertItem(index, item);
+    };
+    /**
+     * Removes the item; no-op when it is not in the collection.
+     *
+     * @param value
+     */
+    OwnedCollection.prototype.remove = function (value) {
+        var index = this._items.indexOf(value);
+        if (index >= 0) {
+            this.removeAt(index);
+        }
+    };
+    /**
+     * Removes the item at `index`.
+     *
+     * @param index
+     */
+    OwnedCollection.prototype.removeAt = function (index) {
+        this.checkIndex(index, this._items.length - 1);
+        var removed = this._items.splice(index, 1)[0];
+        this.detach(removed);
+        this.afterChange();
+    };
+    /** Removes all items. */
+    OwnedCollection.prototype.clear = function () {
+        var _this = this;
+        var removed = this._items.splice(0, this._items.length);
+        removed.forEach(function (item) { return _this.detach(item); });
+        this.afterChange();
+    };
+    /** Iterates the items in order. */
+    OwnedCollection.prototype[Symbol.iterator] = function () {
+        return this._items[Symbol.iterator]();
+    };
+    /**
+     * Snapshot of the items.
+     *
+     * @private
+     */
+    OwnedCollection.prototype.toArray = function () {
+        return this._items.slice();
+    };
+    /**
+     * Appends without owner assignment or notification (view/internal use).
+     *
+     * @param item
+     * @private
+     */
+    OwnedCollection.prototype.pushRaw = function (item) {
+        this._items.push(item);
+        this.syncIndexes();
+    };
+    /**
+     * Inserts with owner assignment but without the matrix guard or validation (synchronization use).
+     *
+     * @param index
+     * @param item
+     * @private
+     */
+    OwnedCollection.prototype.insertRaw = function (index, item) {
+        this.attach(item);
+        this._items.splice(index, 0, item);
+        this.syncIndexes();
+    };
+    /**
+     * Assigns ownership of an item entering the collection.
+     *
+     * @param item
+     */
+    OwnedCollection.prototype.attach = function (item) {
+        item.setOwner(this.owner);
+    };
+    /**
+     * Removes by index and detaches without notification (synchronization use).
+     *
+     * @param index
+     * @private
+     */
+    OwnedCollection.prototype.removeRawAt = function (index) {
+        var removed = this._items.splice(index, 1)[0];
+        this.detach(removed);
+        this.syncIndexes();
+        return removed;
+    };
+    /**
+     * Inserts after validating index and ownership.
+     *
+     * @param index
+     * @param item
+     */
+    OwnedCollection.prototype.insertItem = function (index, item) {
+        this.checkIndex(index, this._items.length);
+        if (this._items.indexOf(item) >= 0 || (item.ownerMathEntity !== undefined && item.ownerMathEntity !== this.owner)) {
+            throw new Error('The item already belongs to a Math collection.');
+        }
+        item.setOwner(this.owner);
+        this._items.splice(index, 0, item);
+        this.afterChange();
+    };
+    /** Hook for subclasses after any structural change. */
+    OwnedCollection.prototype.afterChange = function () {
+        this.syncIndexes();
+        this.owner.notifyMutated();
+    };
+    /**
+     * Detaches a removed item.
+     *
+     * @param item
+     */
+    OwnedCollection.prototype.detach = function (item) {
+        item.setOwner(undefined);
+    };
+    OwnedCollection.prototype.checkIndex = function (index, max) {
+        if (!(index >= 0 && index <= max) || Math.floor(index) !== index) {
+            throw new RangeError('Index ' + index + ' is out of range.');
+        }
+    };
+    OwnedCollection.prototype.syncIndexes = function () {
+        var self = this;
+        for (var i = this._items.length; i < this._synced; i++) {
+            delete self[i];
+        }
+        for (var i = 0; i < this._items.length; i++) {
+            self[i] = this._items[i];
+        }
+        this._synced = this._items.length;
+    };
+    return OwnedCollection;
+}());
+export { OwnedCollection };

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

@@ -0,0 +1,12 @@
+/**
+ * Root contract of every Office Math object.
+ */
+/**
+ * Participates in the Math owner hierarchy.
+ *
+ * @public
+ */
+export interface OfficeMathEntity {
+    /** The entity that contains this object, or `undefined` for a root/detached object. */
+    readonly ownerMathEntity: OfficeMathEntity | undefined;
+}

package/src/office-common/features/mathml/office-math/entity.js

@@ -0,0 +1,3 @@
+/**
+ * Root contract of every Office Math object.
+ */

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

@@ -0,0 +1,97 @@
+/**
+ * Office Math authoring enumerations.
+ *
+ * Values mirror the Compression `Syncfusion.Office` Math enums so scratch-level
+ * authoring behaves identically to DocIO. OMML token mapping lives in the
+ * parser/serializer.
+ */
+/** Math paragraph justification. @public */
+export declare enum MathJustification {
+    CenterGroup = 0,
+    Center = 1,
+    Left = 2,
+    Right = 3
+}
+/** Math script (font family class) of a run. @public */
+export declare enum MathFontType {
+    DoubleStruck = 0,
+    Fraktur = 1,
+    Monospace = 2,
+    Roman = 3,
+    SansSerif = 4,
+    Script = 5
+}
+/** Math run style. @public */
+export declare enum MathStyleType {
+    Italic = 0,
+    BoldItalic = 1,
+    Bold = 2,
+    Regular = 3
+}
+/** Identifies the concrete Math function created by the function factory. @public */
+export declare enum MathFunctionType {
+    /** Unrecognized `m:*` element preserved verbatim; never created by the factory. */
+    Unknown = 0,
+    Accent = 1,
+    Bar = 2,
+    BorderBox = 3,
+    Box = 4,
+    Delimiter = 5,
+    EquationArray = 6,
+    Fraction = 7,
+    Function = 8,
+    GroupCharacter = 9,
+    Limit = 10,
+    Matrix = 11,
+    NArray = 12,
+    Phantom = 13,
+    Radical = 14,
+    LeftSubSuperscript = 15,
+    SubSuperscript = 16,
+    RightSubSuperscript = 17,
+    RunElement = 18
+}
+/** Delimiter shape. @public */
+export declare enum MathDelimiterShapeType {
+    Centered = 0,
+    Match = 1
+}
+/** Fraction type. @public */
+export declare enum MathFractionType {
+    NormalFractionBar = 0,
+    NoFractionBar = 1,
+    SkewedFractionBar = 2,
+    FractionInline = 3
+}
+/** Horizontal alignment of a matrix column. @public */
+export declare enum MathHorizontalAlignment {
+    Center = 0,
+    Left = 1,
+    Right = 2
+}
+/** Vertical alignment of a matrix or equation array. @public */
+export declare enum MathVerticalAlignment {
+    Center = 0,
+    Top = 1,
+    Bottom = 2
+}
+/** Spacing rule for matrix and equation array spacing. @public */
+export declare enum SpacingRule {
+    Single = 0,
+    OneAndHalf = 1,
+    Double = 2,
+    Exactly = 3,
+    Multiple = 4
+}
+/** Script type of a single sub/superscript function. @public */
+export declare enum MathScriptType {
+    Superscript = 0,
+    Subscript = 1
+}
+/** Limit type of a limit function. @public */
+export declare enum MathLimitType {
+    LowerLimit = 0,
+    UpperLimit = 1
+}
+/** Em constant used by matrix spacing (half-em snapping). */
+export declare const MATH_EM = 12;

package/src/office-common/features/mathml/office-math/enums.js

@@ -0,0 +1,108 @@
+/**
+ * Office Math authoring enumerations.
+ *
+ * Values mirror the Compression `Syncfusion.Office` Math enums so scratch-level
+ * authoring behaves identically to DocIO. OMML token mapping lives in the
+ * parser/serializer.
+ */
+/** Math paragraph justification. @public */
+export var MathJustification;
+(function (MathJustification) {
+    MathJustification[MathJustification["CenterGroup"] = 0] = "CenterGroup";
+    MathJustification[MathJustification["Center"] = 1] = "Center";
+    MathJustification[MathJustification["Left"] = 2] = "Left";
+    MathJustification[MathJustification["Right"] = 3] = "Right";
+})(MathJustification || (MathJustification = {}));
+/** Math script (font family class) of a run. @public */
+export var MathFontType;
+(function (MathFontType) {
+    MathFontType[MathFontType["DoubleStruck"] = 0] = "DoubleStruck";
+    MathFontType[MathFontType["Fraktur"] = 1] = "Fraktur";
+    MathFontType[MathFontType["Monospace"] = 2] = "Monospace";
+    MathFontType[MathFontType["Roman"] = 3] = "Roman";
+    MathFontType[MathFontType["SansSerif"] = 4] = "SansSerif";
+    MathFontType[MathFontType["Script"] = 5] = "Script";
+})(MathFontType || (MathFontType = {}));
+/** Math run style. @public */
+export var MathStyleType;
+(function (MathStyleType) {
+    MathStyleType[MathStyleType["Italic"] = 0] = "Italic";
+    MathStyleType[MathStyleType["BoldItalic"] = 1] = "BoldItalic";
+    MathStyleType[MathStyleType["Bold"] = 2] = "Bold";
+    MathStyleType[MathStyleType["Regular"] = 3] = "Regular";
+})(MathStyleType || (MathStyleType = {}));
+/** Identifies the concrete Math function created by the function factory. @public */
+export var MathFunctionType;
+(function (MathFunctionType) {
+    /** Unrecognized `m:*` element preserved verbatim; never created by the factory. */
+    MathFunctionType[MathFunctionType["Unknown"] = 0] = "Unknown";
+    MathFunctionType[MathFunctionType["Accent"] = 1] = "Accent";
+    MathFunctionType[MathFunctionType["Bar"] = 2] = "Bar";
+    MathFunctionType[MathFunctionType["BorderBox"] = 3] = "BorderBox";
+    MathFunctionType[MathFunctionType["Box"] = 4] = "Box";
+    MathFunctionType[MathFunctionType["Delimiter"] = 5] = "Delimiter";
+    MathFunctionType[MathFunctionType["EquationArray"] = 6] = "EquationArray";
+    MathFunctionType[MathFunctionType["Fraction"] = 7] = "Fraction";
+    MathFunctionType[MathFunctionType["Function"] = 8] = "Function";
+    MathFunctionType[MathFunctionType["GroupCharacter"] = 9] = "GroupCharacter";
+    MathFunctionType[MathFunctionType["Limit"] = 10] = "Limit";
+    MathFunctionType[MathFunctionType["Matrix"] = 11] = "Matrix";
+    MathFunctionType[MathFunctionType["NArray"] = 12] = "NArray";
+    MathFunctionType[MathFunctionType["Phantom"] = 13] = "Phantom";
+    MathFunctionType[MathFunctionType["Radical"] = 14] = "Radical";
+    MathFunctionType[MathFunctionType["LeftSubSuperscript"] = 15] = "LeftSubSuperscript";
+    MathFunctionType[MathFunctionType["SubSuperscript"] = 16] = "SubSuperscript";
+    MathFunctionType[MathFunctionType["RightSubSuperscript"] = 17] = "RightSubSuperscript";
+    MathFunctionType[MathFunctionType["RunElement"] = 18] = "RunElement";
+})(MathFunctionType || (MathFunctionType = {}));
+/** Delimiter shape. @public */
+export var MathDelimiterShapeType;
+(function (MathDelimiterShapeType) {
+    MathDelimiterShapeType[MathDelimiterShapeType["Centered"] = 0] = "Centered";
+    MathDelimiterShapeType[MathDelimiterShapeType["Match"] = 1] = "Match";
+})(MathDelimiterShapeType || (MathDelimiterShapeType = {}));
+/** Fraction type. @public */
+export var MathFractionType;
+(function (MathFractionType) {
+    MathFractionType[MathFractionType["NormalFractionBar"] = 0] = "NormalFractionBar";
+    MathFractionType[MathFractionType["NoFractionBar"] = 1] = "NoFractionBar";
+    MathFractionType[MathFractionType["SkewedFractionBar"] = 2] = "SkewedFractionBar";
+    MathFractionType[MathFractionType["FractionInline"] = 3] = "FractionInline";
+})(MathFractionType || (MathFractionType = {}));
+/** Horizontal alignment of a matrix column. @public */
+export var MathHorizontalAlignment;
+(function (MathHorizontalAlignment) {
+    MathHorizontalAlignment[MathHorizontalAlignment["Center"] = 0] = "Center";
+    MathHorizontalAlignment[MathHorizontalAlignment["Left"] = 1] = "Left";
+    MathHorizontalAlignment[MathHorizontalAlignment["Right"] = 2] = "Right";
+})(MathHorizontalAlignment || (MathHorizontalAlignment = {}));
+/** Vertical alignment of a matrix or equation array. @public */
+export var MathVerticalAlignment;
+(function (MathVerticalAlignment) {
+    MathVerticalAlignment[MathVerticalAlignment["Center"] = 0] = "Center";
+    MathVerticalAlignment[MathVerticalAlignment["Top"] = 1] = "Top";
+    MathVerticalAlignment[MathVerticalAlignment["Bottom"] = 2] = "Bottom";
+})(MathVerticalAlignment || (MathVerticalAlignment = {}));
+/** Spacing rule for matrix and equation array spacing. @public */
+export var SpacingRule;
+(function (SpacingRule) {
+    SpacingRule[SpacingRule["Single"] = 0] = "Single";
+    SpacingRule[SpacingRule["OneAndHalf"] = 1] = "OneAndHalf";
+    SpacingRule[SpacingRule["Double"] = 2] = "Double";
+    SpacingRule[SpacingRule["Exactly"] = 3] = "Exactly";
+    SpacingRule[SpacingRule["Multiple"] = 4] = "Multiple";
+})(SpacingRule || (SpacingRule = {}));
+/** Script type of a single sub/superscript function. @public */
+export var MathScriptType;
+(function (MathScriptType) {
+    MathScriptType[MathScriptType["Superscript"] = 0] = "Superscript";
+    MathScriptType[MathScriptType["Subscript"] = 1] = "Subscript";
+})(MathScriptType || (MathScriptType = {}));
+/** Limit type of a limit function. @public */
+export var MathLimitType;
+(function (MathLimitType) {
+    MathLimitType[MathLimitType["LowerLimit"] = 0] = "LowerLimit";
+    MathLimitType[MathLimitType["UpperLimit"] = 1] = "UpperLimit";
+})(MathLimitType || (MathLimitType = {}));
+/** Em constant used by matrix spacing (half-em snapping). */
+export var MATH_EM = 12;

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

@@ -0,0 +1,28 @@
+/**
+ * Math run format (`m:rPr`).
+ */
+import { MathFontType, MathStyleType } from './enums';
+import { OwnerHolder } from './owner-holder';
+import { OfficeMathBreak } from './break';
+/**
+ * Math-specific run properties, separate from Word character formatting (`w:rPr`).
+ *
+ * @public
+ */
+export declare class OfficeMathFormat extends OwnerHolder {
+    private _break;
+    /** Aligns the run (`m:aln`). Default false. */
+    hasAlignment: boolean;
+    /** Literal text (`m:lit`). Default false. */
+    hasLiteral: boolean;
+    /** Normal text (`m:nor`). Default false. */
+    hasNormalText: boolean;
+    /** Math font (`m:scr`). Default roman. */
+    font: MathFontType;
+    /** Math style (`m:sty`). Default italic. */
+    style: MathStyleType;
+    /** Optional manual break (`m:brk`). Not created automatically. */
+    break: OfficeMathBreak | undefined;
+    /** Whether any `m:rPr` content must be written. */
+    readonly hasContent: boolean;
+}

package/src/office-common/features/mathml/office-math/format.js

@@ -0,0 +1,90 @@
+/**
+ * Math run format (`m:rPr`).
+ */
+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 { MathFontType, MathStyleType } from './enums';
+import { K } from './keys';
+import { OwnerHolder } from './owner-holder';
+/**
+ * Math-specific run properties, separate from Word character formatting (`w:rPr`).
+ *
+ * @public
+ */
+var OfficeMathFormat = /** @class */ (function (_super) {
+    __extends(OfficeMathFormat, _super);
+    function OfficeMathFormat() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(OfficeMathFormat.prototype, "hasAlignment", {
+        /** Aligns the run (`m:aln`). Default false. */
+        get: function () { return this.getProperty(K.HasAlignment, function () { return false; }); },
+        set: function (value) { this.setProperty(K.HasAlignment, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathFormat.prototype, "hasLiteral", {
+        /** Literal text (`m:lit`). Default false. */
+        get: function () { return this.getProperty(K.HasLiteral, function () { return false; }); },
+        set: function (value) { this.setProperty(K.HasLiteral, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathFormat.prototype, "hasNormalText", {
+        /** Normal text (`m:nor`). Default false. */
+        get: function () { return this.getProperty(K.HasNormalText, function () { return false; }); },
+        set: function (value) { this.setProperty(K.HasNormalText, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathFormat.prototype, "font", {
+        /** Math font (`m:scr`). Default roman. */
+        get: function () { return this.getProperty(K.Script, function () { return MathFontType.Roman; }); },
+        set: function (value) { this.setProperty(K.Script, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathFormat.prototype, "style", {
+        /** Math style (`m:sty`). Default italic. */
+        get: function () { return this.getProperty(K.Style, function () { return MathStyleType.Italic; }); },
+        set: function (value) { this.setProperty(K.Style, value); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathFormat.prototype, "break", {
+        /** Optional manual break (`m:brk`). Not created automatically. */
+        get: function () { return this._break; },
+        set: function (value) {
+            this._break = value;
+            if (value !== undefined) {
+                value.setOwner(this);
+            }
+            this.notifyMutated();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathFormat.prototype, "hasContent", {
+        /** Whether any `m:rPr` content must be written. */
+        get: function () {
+            var _this = this;
+            return this._break !== undefined || [K.HasAlignment, K.HasLiteral, K.HasNormalText, K.Script, K.Style]
+                .some(function (key) { return _this.isExplicit(key); });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathFormat;
+}(OwnerHolder));
+export { OfficeMathFormat };

package/src/office-common/features/mathml/office-math/function-base.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Base class of every Math function.
+ */
+import { OfficeRunFormat } from './adapter';
+import { MathFunctionType } from './enums';
+import { OwnerHolder } from './owner-holder';
+/**
+ * Base of all concrete Math functions.
+ *
+ * @public
+ */
+export declare abstract class OfficeMathFunctionBase extends OwnerHolder {
+    private _controlProperties;
+    /** The concrete function type. */
+    abstract readonly type: MathFunctionType;
+    /**
+     * Character format of the function (`m:ctrlPr`). Created from the paragraph default on first access.
+     */
+    controlProperties: OfficeRunFormat;
+    /**
+     * Whether control properties exist (assigned, parsed or accessed).
+     *
+     * @private
+     */
+    readonly hasControlProperties: boolean;
+    private getDefaultControlProperties;
+}

package/src/office-common/features/mathml/office-math/function-base.js

@@ -0,0 +1,69 @@
+/**
+ * Base class of every Math function.
+ */
+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 { OwnerHolder } from './owner-holder';
+/**
+ * Base of all concrete Math functions.
+ *
+ * @public
+ */
+var OfficeMathFunctionBase = /** @class */ (function (_super) {
+    __extends(OfficeMathFunctionBase, _super);
+    function OfficeMathFunctionBase() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(OfficeMathFunctionBase.prototype, "controlProperties", {
+        /**
+         * Character format of the function (`m:ctrlPr`). Created from the paragraph default on first access.
+         */
+        get: function () {
+            if (this._controlProperties === undefined) {
+                this._controlProperties = this.getDefaultControlProperties();
+            }
+            return this._controlProperties;
+        },
+        set: function (value) {
+            this._controlProperties = value;
+            this.notifyMutated();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathFunctionBase.prototype, "hasControlProperties", {
+        /**
+         * Whether control properties exist (assigned, parsed or accessed).
+         *
+         * @private
+         */
+        get: function () {
+            return this._controlProperties !== undefined;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    OfficeMathFunctionBase.prototype.getDefaultControlProperties = function () {
+        var entity = this.ownerMathEntity;
+        while (entity !== undefined && !('defaultMathCharacterFormat' in entity)) {
+            entity = entity.ownerMathEntity;
+        }
+        if (entity === undefined) {
+            throw new Error('Math function is not attached to a Math paragraph.');
+        }
+        return entity.defaultMathCharacterFormat.clone();
+    };
+    return OfficeMathFunctionBase;
+}(OwnerHolder));
+export { OfficeMathFunctionBase };

package/src/office-common/features/mathml/office-math/function-collection.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Collection and factory of Math functions.
+ */
+import { OwnedCollection, CollectionOwner } from './collection';
+import { MathFunctionType, MathLimitType, MathScriptType } from './enums';
+import { OfficeMathFunctionBase } from './function-base';
+/**
+ * Creates an unattached function of the given type.
+ *
+ * @param type
+ * @private
+ */
+export declare function createMathFunction(type: MathFunctionType): OfficeMathFunctionBase;
+/**
+ * Ordered collection of Math functions with a type-based factory.
+ *
+ * @public
+ */
+export declare class OfficeMathFunctionCollection extends OwnedCollection<OfficeMathFunctionBase> {
+    constructor(owner: CollectionOwner);
+    /**
+     * Creates a function of the given type and appends it, or inserts it at `index`.
+     *
+     * @param type
+     * @param index
+     */
+    add(type: MathFunctionType, index?: number): OfficeMathFunctionBase;
+}
+export { MathLimitType, MathScriptType };