@syncfusion/ej2-office-common 35.1.37 → 35.1.42

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

@@ -0,0 +1,54 @@
+import { OpenXmlElement } from './openxml';
+import { MathBreakBin, MathBreakBinSub, MathJc, MathLimLoc } from './model/enums';
+/**
+ * Typed `m:mathPr` settings. All members are optional; absent means "not specified".
+ *
+ * @public
+ */
+export interface MathSettings {
+    /** Math font name (`m:mathFont`). */
+    mathFont?: string;
+    /** Break on binary operators (`m:brkBin`). */
+    breakOnBinaryOperators?: MathBreakBin;
+    /** Break on binary subtraction (`m:brkBinSub`). */
+    breakOnBinarySubtraction?: MathBreakBinSub;
+    /** Use small fractions (`m:smallFrac`). */
+    smallFraction?: boolean;
+    /** Display math defaults (`m:dispDef`). */
+    displayMathDefaults?: boolean;
+    /** Left margin in twips (`m:lMargin`). */
+    leftMargin?: number;
+    /** Right margin in twips (`m:rMargin`). */
+    rightMargin?: number;
+    /** Default justification (`m:defJc`). */
+    defaultJustification?: MathJc;
+    /** Spacing before (`m:preSp`). */
+    preSpacing?: number;
+    /** Spacing after (`m:postSp`). */
+    postSpacing?: number;
+    /** Spacing between (`m:interSp`). */
+    interSpacing?: number;
+    /** Spacing within (`m:intraSp`). */
+    intraSpacing?: number;
+    /** Wrap indent in twips (`m:wrapIndent`); exclusive with {@link wrapRight}. */
+    wrapIndent?: number;
+    /** Wrap right (`m:wrapRight`); exclusive with {@link wrapIndent}. */
+    wrapRight?: boolean;
+    /** Integral limit location (`m:intLim`). */
+    integralLimitLocation?: MathLimLoc;
+    /** N-ary limit location (`m:naryLim`). */
+    naryLimitLocation?: MathLimLoc;
+}
+/**
+ * Parse an `m:mathPr` element. Unknown or invalid values are omitted (tolerant).
+ *
+ * @public
+ */
+export declare function parseMathSettings(mathPr: OpenXmlElement): MathSettings;
+/**
+ * Serialize {@link MathSettings} to `m:mathPr` in schema order.
+ *
+ * @throws MathmlValidationError when `wrapIndent` and `wrapRight` are both set, or a twips value is not a non-negative integer.
+ * @public
+ */
+export declare function mathSettingsToOpenXml(settings: MathSettings, prefix?: string): OpenXmlElement;

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

@@ -0,0 +1,174 @@
+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 __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+/**
+ * Document-level math settings (`m:mathPr`, `CT_MathPr`).
+ *
+ * Source: ECMA-376 shared-math.xsd `CT_MathPr`; parity with compression
+ * `OfficeMathProperties` / `SerializeMathProperties`.
+ *
+ * @packageDocumentation
+ */
+import { MATH_NAMESPACE } from './constants';
+import { MathmlValidationError } from './errors';
+import { createElement, attrValue, childElements } from './openxml';
+import { parseMathBreakBin, parseMathBreakBinSub, parseMathJc, parseMathLimLoc, parseOnOff } from './model/enums';
+var TWIPS_ELEMENTS = [
+    ['leftMargin', 'lMargin'],
+    ['rightMargin', 'rMargin'],
+    ['defaultJustification', 'defJc'],
+    ['preSpacing', 'preSp'],
+    ['postSpacing', 'postSp'],
+    ['interSpacing', 'interSp'],
+    ['intraSpacing', 'intraSp'],
+];
+function child(pr, name) {
+    return childElements(pr).find(function (c) { return c.namespaceUri === MATH_NAMESPACE && c.localName === name; });
+}
+function val(pr, name) {
+    var c = child(pr, name);
+    return c ? attrValue(c, 'val') : undefined;
+}
+function twips(pr, name) {
+    var v = val(pr, name);
+    return v !== undefined && /^\d+$/.test(v) ? Number(v) : undefined;
+}
+function onOff(pr, name) {
+    var c = child(pr, name);
+    if (!c) {
+        return undefined;
+    }
+    var v = attrValue(c, 'val');
+    return v === undefined ? true : parseOnOff(v);
+}
+/**
+ * Parse an `m:mathPr` element. Unknown or invalid values are omitted (tolerant).
+ *
+ * @public
+ */
+export function parseMathSettings(mathPr) {
+    var s = {};
+    var set = function (k, v) {
+        if (v !== undefined) {
+            s[k] = v;
+        }
+    };
+    set('mathFont', val(mathPr, 'mathFont'));
+    var bb = val(mathPr, 'brkBin');
+    set('breakOnBinaryOperators', bb !== undefined ? parseMathBreakBin(bb) : undefined);
+    var bs = val(mathPr, 'brkBinSub');
+    set('breakOnBinarySubtraction', bs !== undefined ? parseMathBreakBinSub(bs) : undefined);
+    set('smallFraction', onOff(mathPr, 'smallFrac'));
+    set('displayMathDefaults', onOff(mathPr, 'dispDef'));
+    set('leftMargin', twips(mathPr, 'lMargin'));
+    set('rightMargin', twips(mathPr, 'rMargin'));
+    var jc = val(mathPr, 'defJc');
+    set('defaultJustification', jc !== undefined ? parseMathJc(jc) : undefined);
+    set('preSpacing', twips(mathPr, 'preSp'));
+    set('postSpacing', twips(mathPr, 'postSp'));
+    set('interSpacing', twips(mathPr, 'interSp'));
+    set('intraSpacing', twips(mathPr, 'intraSp'));
+    set('wrapIndent', twips(mathPr, 'wrapIndent'));
+    set('wrapRight', onOff(mathPr, 'wrapRight'));
+    var il = val(mathPr, 'intLim');
+    set('integralLimitLocation', il !== undefined ? parseMathLimLoc(il) : undefined);
+    var nl = val(mathPr, 'naryLim');
+    set('naryLimitLocation', nl !== undefined ? parseMathLimLoc(nl) : undefined);
+    return s;
+}
+/**
+ * Serialize {@link MathSettings} to `m:mathPr` in schema order.
+ *
+ * @throws MathmlValidationError when `wrapIndent` and `wrapRight` are both set, or a twips value is not a non-negative integer.
+ * @public
+ */
+export function mathSettingsToOpenXml(settings, prefix) {
+    if (prefix === void 0) { prefix = 'm'; }
+    var e_1, _a;
+    var kids = [];
+    var el = function (name, value) {
+        kids.push(createElement(MATH_NAMESPACE, name, prefix, {
+            attributes: [{ namespaceUri: '', localName: 'val', prefix: '', value: value }],
+            children: [],
+        }));
+    };
+    var flag = function (name, v) {
+        if (v !== undefined) {
+            el(name, v ? '1' : '0');
+        }
+    };
+    var tw = function (name, v) {
+        if (v === undefined) {
+            return;
+        }
+        if (!Number.isInteger(v) || v < 0) {
+            throw new MathmlValidationError(name + " must be a non-negative integer, got " + String(v), "mathPr." + name, 'value-range');
+        }
+        el(name, String(v));
+    };
+    if (settings.wrapIndent !== undefined && settings.wrapRight !== undefined) {
+        throw new MathmlValidationError('wrapIndent and wrapRight are mutually exclusive', 'mathPr', 'child-order');
+    }
+    if (settings.mathFont !== undefined) {
+        el('mathFont', settings.mathFont);
+    }
+    if (settings.breakOnBinaryOperators !== undefined) {
+        el('brkBin', settings.breakOnBinaryOperators);
+    }
+    if (settings.breakOnBinarySubtraction !== undefined) {
+        el('brkBinSub', settings.breakOnBinarySubtraction);
+    }
+    flag('smallFrac', settings.smallFraction);
+    flag('dispDef', settings.displayMathDefaults);
+    try {
+        for (var TWIPS_ELEMENTS_1 = __values(TWIPS_ELEMENTS), TWIPS_ELEMENTS_1_1 = TWIPS_ELEMENTS_1.next(); !TWIPS_ELEMENTS_1_1.done; TWIPS_ELEMENTS_1_1 = TWIPS_ELEMENTS_1.next()) {
+            var _b = __read(TWIPS_ELEMENTS_1_1.value, 2), key = _b[0], name_1 = _b[1];
+            var v = settings[key];
+            if (typeof v === 'string') {
+                el(name_1, v);
+            }
+            else {
+                tw(name_1, v);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (TWIPS_ELEMENTS_1_1 && !TWIPS_ELEMENTS_1_1.done && (_a = TWIPS_ELEMENTS_1.return)) _a.call(TWIPS_ELEMENTS_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    tw('wrapIndent', settings.wrapIndent);
+    flag('wrapRight', settings.wrapRight);
+    if (settings.integralLimitLocation !== undefined) {
+        el('intLim', settings.integralLimitLocation);
+    }
+    if (settings.naryLimitLocation !== undefined) {
+        el('naryLim', settings.naryLimitLocation);
+    }
+    return createElement(MATH_NAMESPACE, 'mathPr', prefix, { attributes: [], children: kids });
+}

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

@@ -0,0 +1,59 @@
+/**
+ * Generic document-adapter contracts.
+ *
+ * `ej2-office-common` stays document-agnostic: a host (for example `ej2-docx`)
+ * supplies native runs and character formats through {@link MathDocumentAdapter}.
+ */
+import { OpenXmlElement } from '../openxml';
+import { OfficeMathFunctionBase } from './function-base';
+import { OfficeMathRunElement } from './run-element';
+/**
+ * A document-specific run held by an {@link OfficeMathRunElement}.
+ *
+ * @public
+ */
+export interface OfficeRun {
+    /** The run element that contains this run. */
+    ownerMathRunElement?: OfficeMathRunElement;
+}
+/**
+ * A document-specific character format.
+ *
+ * @public
+ */
+export interface OfficeRunFormat {
+    /** Creates an independent copy. */
+    clone(): OfficeRunFormat;
+    /** Value equality with another format; when omitted, formats are treated as equal. */
+    equals?(other: OfficeRunFormat): boolean;
+}
+/**
+ * Host integration points used by the Math model, parser, serializer and LaTeX converter.
+ *
+ * @public
+ */
+export interface MathDocumentAdapter {
+    /** Creates a native run for the run element. */
+    createRun(runElement: OfficeMathRunElement): OfficeRun;
+    /** Replaces the run text. */
+    setRunText(run: OfficeRun, text: string): void;
+    /** Appends text to the run. */
+    appendRunText(run: OfficeRun, text: string): void;
+    /** Reads the run text. */
+    getRunText(run: OfficeRun): string;
+    /** Creates the default Math character format for the Math owner. */
+    createDefaultMathCharacterFormat(mathOwner: unknown): OfficeRunFormat;
+    /** Creates an independent copy of the run. */
+    cloneRun(run: OfficeRun): OfficeRun;
+    /** Parses `m:ctrlPr` of a function into a native character format. */
+    parseControlProperties(element: OpenXmlElement, owner: OfficeMathFunctionBase): OfficeRunFormat;
+    /**
+     * Parses `m:r` content into the run element, in source order (`w:rPr`, text and other children).
+     * The parser has already applied `m:rPr`; the adapter ignores it and must assign `runElement.item`.
+     */
+    parseMathRun(element: OpenXmlElement, runElement: OfficeMathRunElement): void;
+    /** Serializes a control-properties format to the children of `m:ctrlPr`. */
+    serializeControlProperties(format: OfficeRunFormat): OpenXmlElement[];
+    /** Serializes the run (`w:rPr` and content) to the non-`m:rPr` children of `m:r`. */
+    serializeMathRun(runElement: OfficeMathRunElement): OpenXmlElement[];
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Generic document-adapter contracts.
+ *
+ * `ej2-office-common` stays document-agnostic: a host (for example `ej2-docx`)
+ * supplies native runs and character formats through {@link MathDocumentAdapter}.
+ */

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

@@ -0,0 +1,91 @@
+/**
+ * Minimal document-agnostic run and format used when no document adapter is supplied.
+ */
+import { OfficeRun, OfficeRunFormat } from './adapter';
+import { OfficeMathRunElement } from './run-element';
+import { OpenXmlElement } from '../openxml';
+/**
+ * Default character format of the standalone package. Keeps a parsed `m:ctrlPr` verbatim.
+ *
+ * @public
+ */
+export declare class BasicRunFormat implements OfficeRunFormat {
+    /** The original `m:ctrlPr` element, when the format was parsed from XML. */
+    readonly preservedXml: OpenXmlElement | undefined;
+    /**
+     * Creates the format.
+     *
+     * @param {OpenXmlElement} preservedXml Optional original `m:ctrlPr` element.
+     */
+    constructor(preservedXml?: OpenXmlElement);
+    /**
+     * Creates an independent copy.
+     *
+     * @returns {OfficeRunFormat} The copy.
+     */
+    clone(): OfficeRunFormat;
+    /**
+     * Value equality with another format.
+     *
+     * @param {OfficeRunFormat} other The format to compare with.
+     * @returns {boolean} True when both keep the same XML.
+     */
+    equals(other: OfficeRunFormat): boolean;
+}
+/**
+ * A text segment of a standalone run (`m:t`).
+ *
+ * @public
+ */
+export interface BasicRunText {
+    /** Discriminator. */
+    readonly kind: 'text';
+    /** Text value. */
+    readonly value: string;
+    /** `xml:space` value of the source element, when present. */
+    readonly space?: string;
+}
+/**
+ * A non-text child of a standalone run, kept verbatim.
+ *
+ * @public
+ */
+export interface BasicRunXml {
+    /** Discriminator. */
+    readonly kind: 'xml';
+    /** The preserved element. */
+    readonly element: OpenXmlElement;
+}
+/**
+ * Ordered content item of a standalone run.
+ *
+ * @public
+ */
+export declare type BasicRunPart = BasicRunText | BasicRunXml;
+/**
+ * Default run of the standalone package. Keeps text and non-text children in source order.
+ *
+ * @public
+ */
+export declare class BasicRun implements OfficeRun {
+    /** The run element that contains this run. */
+    ownerMathRunElement?: OfficeMathRunElement;
+    /** Run character format. */
+    characterFormat: OfficeRunFormat;
+    /** The original `w:rPr` element, when parsed from XML. */
+    runProperties: OpenXmlElement | undefined;
+    /** Ordered run content: text segments and preserved children. */
+    readonly parts: BasicRunPart[];
+    /**
+     * Concatenated text of all text segments.
+     *
+     * @returns {string} The run text.
+     */
+    text: string;
+    /**
+     * Creates an independent copy of the run.
+     *
+     * @returns {BasicRun} The copy.
+     */
+    clone(): BasicRun;
+}

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

@@ -0,0 +1,93 @@
+/**
+ * Minimal document-agnostic run and format used when no document adapter is supplied.
+ */
+import { xmlEqual } from './xml-equal';
+/**
+ * Default character format of the standalone package. Keeps a parsed `m:ctrlPr` verbatim.
+ *
+ * @public
+ */
+var BasicRunFormat = /** @class */ (function () {
+    /**
+     * Creates the format.
+     *
+     * @param {OpenXmlElement} preservedXml Optional original `m:ctrlPr` element.
+     */
+    function BasicRunFormat(preservedXml) {
+        this.preservedXml = preservedXml;
+    }
+    /**
+     * Creates an independent copy.
+     *
+     * @returns {OfficeRunFormat} The copy.
+     */
+    BasicRunFormat.prototype.clone = function () {
+        return new BasicRunFormat(this.preservedXml);
+    };
+    /**
+     * Value equality with another format.
+     *
+     * @param {OfficeRunFormat} other The format to compare with.
+     * @returns {boolean} True when both keep the same XML.
+     */
+    BasicRunFormat.prototype.equals = function (other) {
+        var peer = other instanceof BasicRunFormat ? other : undefined;
+        if (peer === undefined) {
+            return false;
+        }
+        if (this.preservedXml === undefined || peer.preservedXml === undefined) {
+            return this.preservedXml === peer.preservedXml;
+        }
+        return xmlEqual(this.preservedXml, peer.preservedXml);
+    };
+    return BasicRunFormat;
+}());
+export { BasicRunFormat };
+/**
+ * Default run of the standalone package. Keeps text and non-text children in source order.
+ *
+ * @public
+ */
+var BasicRun = /** @class */ (function () {
+    function BasicRun() {
+        /** Run character format. */
+        this.characterFormat = new BasicRunFormat();
+        /** Ordered run content: text segments and preserved children. */
+        this.parts = [];
+    }
+    Object.defineProperty(BasicRun.prototype, "text", {
+        /**
+         * Concatenated text of all text segments.
+         *
+         * @returns {string} The run text.
+         */
+        get: function () {
+            return this.parts.map(function (part) { return part.kind === 'text' ? part.value : ''; }).join('');
+        },
+        set: function (value) {
+            var _this = this;
+            var first = this.parts.map(function (part) { return part.kind; }).indexOf('text');
+            var kept = this.parts.filter(function (part) { return part.kind !== 'text'; });
+            var at = first < 0 ? kept.length : this.parts.slice(0, first).filter(function (p) { return p.kind !== 'text'; }).length;
+            kept.splice(at, 0, { kind: 'text', value: value });
+            this.parts.length = 0;
+            kept.forEach(function (part) { return _this.parts.push(part); });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Creates an independent copy of the run.
+     *
+     * @returns {BasicRun} The copy.
+     */
+    BasicRun.prototype.clone = function () {
+        var copy = new BasicRun();
+        copy.characterFormat = this.characterFormat.clone();
+        copy.runProperties = this.runProperties;
+        this.parts.forEach(function (part) { return copy.parts.push(part); });
+        return copy;
+    };
+    return BasicRun;
+}());
+export { BasicRun };

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

@@ -0,0 +1,30 @@
+/**
+ * Math break (`m:brk`) and its collection.
+ */
+import { OwnerHolder } from './owner-holder';
+import { OwnedCollection, CollectionOwner } from './collection';
+/**
+ * Manual line break inside a Math run, box or run format.
+ *
+ * @public
+ */
+export declare class OfficeMathBreak extends OwnerHolder {
+    /** Alignment point (`m:alnAt`) the next line aligns to. Default 0. */
+    alignAt: number;
+    /** Whether `alignAt` was set or parsed explicitly. */
+    readonly hasExplicitAlignAt: boolean;
+}
+/**
+ * Ordered collection of {@link OfficeMathBreak}.
+ *
+ * @public
+ */
+export declare class OfficeMathBreakCollection extends OwnedCollection<OfficeMathBreak> {
+    constructor(owner: CollectionOwner);
+    /**
+     * Creates a break and appends it, or inserts it at `index`.
+     *
+     * @param index
+     */
+    add(index?: number): OfficeMathBreak;
+}

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

@@ -0,0 +1,75 @@
+/**
+ * Math break (`m:brk`) and its collection.
+ */
+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 { K } from './keys';
+import { OwnerHolder } from './owner-holder';
+import { OwnedCollection } from './collection';
+/**
+ * Manual line break inside a Math run, box or run format.
+ *
+ * @public
+ */
+var OfficeMathBreak = /** @class */ (function (_super) {
+    __extends(OfficeMathBreak, _super);
+    function OfficeMathBreak() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(OfficeMathBreak.prototype, "alignAt", {
+        /** Alignment point (`m:alnAt`) the next line aligns to. Default 0. */
+        get: function () {
+            return this.getProperty(K.AlignAt, function () { return 0; });
+        },
+        set: function (value) {
+            this.setProperty(K.AlignAt, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(OfficeMathBreak.prototype, "hasExplicitAlignAt", {
+        /** Whether `alignAt` was set or parsed explicitly. */
+        get: function () {
+            return this.isExplicit(K.AlignAt);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return OfficeMathBreak;
+}(OwnerHolder));
+export { OfficeMathBreak };
+/**
+ * Ordered collection of {@link OfficeMathBreak}.
+ *
+ * @public
+ */
+var OfficeMathBreakCollection = /** @class */ (function (_super) {
+    __extends(OfficeMathBreakCollection, _super);
+    function OfficeMathBreakCollection(owner) {
+        return _super.call(this, owner) || this;
+    }
+    /**
+     * Creates a break and appends it, or inserts it at `index`.
+     *
+     * @param index
+     */
+    OfficeMathBreakCollection.prototype.add = function (index) {
+        var item = new OfficeMathBreak(this.owner);
+        item.setOwner(undefined);
+        this.insertItem(index === undefined ? this.count : index, item);
+        return item;
+    };
+    return OfficeMathBreakCollection;
+}(OwnedCollection));
+export { OfficeMathBreakCollection };

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

@@ -0,0 +1,104 @@
+/**
+ * Generic owner-aware mutable collection used by every Math collection.
+ */
+import { OfficeMathEntity } from './entity';
+import { OwnerHolder } from './owner-holder';
+/** Owner of a collection: any Math entity that can bubble mutations. */
+export declare type CollectionOwner = OfficeMathEntity & {
+    notifyMutated(): void;
+};
+/**
+ * Ordered collection that assigns/detaches owners and notifies the root on change.
+ * Items are also reachable by numeric index (`collection[0]`).
+ *
+ * @public
+ */
+export declare abstract class OwnedCollection<T extends OwnerHolder> {
+    protected readonly owner: CollectionOwner;
+    [index: number]: T;
+    private readonly _items;
+    private _synced;
+    protected constructor(owner: CollectionOwner);
+    /** Number of items. */
+    readonly count: number;
+    /**
+     * Returns the item at `index`.
+     *
+     * @param index
+     */
+    getItem(index: number): T;
+    /**
+     * Inserts an item at `index`; throws when it already belongs to a collection.
+     *
+     * @param index
+     * @param item
+     */
+    insert(index: number, item: T): void;
+    /**
+     * Removes the item; no-op when it is not in the collection.
+     *
+     * @param value
+     */
+    remove(value: T): void;
+    /**
+     * Removes the item at `index`.
+     *
+     * @param index
+     */
+    removeAt(index: number): void;
+    /** Removes all items. */
+    clear(): void;
+    /** Iterates the items in order. */
+    [Symbol.iterator](): Iterator<T>;
+    /**
+     * Snapshot of the items.
+     *
+     * @private
+     */
+    toArray(): T[];
+    /**
+     * Appends without owner assignment or notification (view/internal use).
+     *
+     * @param item
+     * @private
+     */
+    pushRaw(item: T): void;
+    /**
+     * Inserts with owner assignment but without the matrix guard or validation (synchronization use).
+     *
+     * @param index
+     * @param item
+     * @private
+     */
+    insertRaw(index: number, item: T): void;
+    /**
+     * Assigns ownership of an item entering the collection.
+     *
+     * @param item
+     */
+    protected attach(item: T): void;
+    /**
+     * Removes by index and detaches without notification (synchronization use).
+     *
+     * @param index
+     * @private
+     */
+    removeRawAt(index: number): T;
+    /**
+     * Inserts after validating index and ownership.
+     *
+     * @param index
+     * @param item
+     */
+    protected insertItem(index: number, item: T): void;
+    /** Hook for subclasses after any structural change. */
+    protected afterChange(): void;
+    /**
+     * Detaches a removed item.
+     *
+     * @param item
+     */
+    protected detach(item: T): void;
+    private checkIndex;
+    private syncIndexes;
+}