devexpress-richedit 24.1.8-build-24316-0102 → 24.2.2-beta

package/lib/common/model/fields/parsers/field-code-parser-if.js

@@ -0,0 +1,138 @@
+import { FieldName } from '../names';
+import { FieldCodeParserClientUpdatingBase } from './field-code-parser-client-updating-base';
+export class FieldCodeParserIf extends FieldCodeParserClientUpdatingBase {
+    get name() { return FieldName.If; }
+    fillResult() {
+        this.setInputPositionState();
+        let result = null;
+        try {
+            const expression = this.parseParameters(this.parameterInfoList);
+            result = expression.evaluate();
+        }
+        catch (err) {
+            if (err instanceof IfExpressionError) {
+                result = err.message;
+            }
+        }
+        finally {
+            if (result) {
+                this.replaceTextByInterval(this.getTopField().getResultInterval(), result);
+            }
+            return true;
+        }
+    }
+    parseParameters(parameters) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        if (parameters.length > 5)
+            throw new IfExpressionTooManyParametersError();
+        if (parameters.length === 0)
+            throw new IfExpressionMissingParametersError();
+        let leftExpression;
+        let operator;
+        let rightExpression;
+        let trueText;
+        let falseText;
+        if (parameters.length <= 3 && !IfExpression.isOperator((_a = parameters[1]) === null || _a === void 0 ? void 0 : _a.text)) {
+            leftExpression = new IfExpressionParameter((_b = parameters[0]) === null || _b === void 0 ? void 0 : _b.text, (_c = parameters[0]) === null || _c === void 0 ? void 0 : _c.quoted);
+            trueText = (_d = parameters[1]) === null || _d === void 0 ? void 0 : _d.text;
+            falseText = (_e = parameters[2]) === null || _e === void 0 ? void 0 : _e.text;
+        }
+        else {
+            leftExpression = new IfExpressionParameter((_f = parameters[0]) === null || _f === void 0 ? void 0 : _f.text, (_g = parameters[0]) === null || _g === void 0 ? void 0 : _g.quoted);
+            operator = (_h = parameters[1]) === null || _h === void 0 ? void 0 : _h.text;
+            rightExpression = new IfExpressionParameter((_j = parameters[2]) === null || _j === void 0 ? void 0 : _j.text, (_k = parameters[2]) === null || _k === void 0 ? void 0 : _k.quoted);
+            trueText = (_l = parameters[3]) === null || _l === void 0 ? void 0 : _l.text;
+            falseText = (_m = parameters[4]) === null || _m === void 0 ? void 0 : _m.text;
+        }
+        return new IfExpression(operator, leftExpression, rightExpression, trueText, falseText);
+    }
+}
+export class IfExpression {
+    constructor(operator, leftExpression, rightExpression, trueText = undefined, falseText = undefined) {
+        this.operator = operator;
+        this.leftExpression = leftExpression;
+        this.rightExpression = rightExpression;
+        this.trueText = trueText;
+        this.falseText = falseText;
+    }
+    static isOperator(operator) {
+        return IfExpression.operators.includes(operator);
+    }
+    evaluate() {
+        if (!this.operator && !this.leftExpression.isNumber) {
+            return this.leftExpression.text ? this.trueText : this.falseText;
+        }
+        if (!IfExpression.isOperator(this.operator)) {
+            throw new IfExpressionInvalidOperatorError();
+        }
+        let difference;
+        if (this.leftExpression.isNumber && this.rightExpression.isNumber) {
+            difference = this.leftExpression.number - this.rightExpression.number;
+        }
+        else {
+            const isEqualityOperator = this.operator === "=" || this.operator === "<>";
+            const compareFunction = isEqualityOperator ? IfExpression.compareStringsWithWildcards : IfExpression.compareStrings;
+            difference = compareFunction(this.leftExpression.text, this.rightExpression.text);
+        }
+        return this.evaluateComparison(difference) ? this.trueText : this.falseText;
+    }
+    evaluateComparison(comparisonResult) {
+        switch (this.operator) {
+            case "<":
+                return comparisonResult < 0;
+            case ">":
+                return comparisonResult > 0;
+            case "=":
+                return comparisonResult === 0;
+            case "<=":
+                return comparisonResult <= 0;
+            case ">=":
+                return comparisonResult >= 0;
+            case "<>":
+                return comparisonResult != 0;
+            default:
+                return false;
+        }
+    }
+    static compareStrings(leftValue, rightValue) {
+        return leftValue.localeCompare(rightValue);
+    }
+    static compareStringsWithWildcards(leftValue, rightValue) {
+        const escapedPattern = rightValue.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+        const regexPattern = escapedPattern.replace(/\*/g, '.*').replace(/\?/g, '.');
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(leftValue) ? 0 : 1;
+    }
+}
+IfExpression.operators = ["<", ">", "=", "<=", ">=", "<>"];
+export class IfExpressionParameter {
+    constructor(text, isQuoted = false) {
+        this.text = text;
+        this.number = parseFloat(text);
+        this.isNumber = !isQuoted && !Number.isNaN(this.number);
+    }
+}
+export class IfExpressionError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, IfExpressionError.prototype);
+    }
+}
+export class IfExpressionInvalidOperatorError extends IfExpressionError {
+    constructor(message) {
+        super(message !== null && message !== void 0 ? message : "IF field error: Invalid comparison operator");
+        Object.setPrototypeOf(this, IfExpressionInvalidOperatorError.prototype);
+    }
+}
+export class IfExpressionTooManyParametersError extends IfExpressionError {
+    constructor(message) {
+        super(message !== null && message !== void 0 ? message : "IF field error: Too many parameters");
+        Object.setPrototypeOf(this, IfExpressionTooManyParametersError.prototype);
+    }
+}
+export class IfExpressionMissingParametersError extends IfExpressionError {
+    constructor(message) {
+        super(message !== null && message !== void 0 ? message : "IF field error: Missing parameter(s)");
+        Object.setPrototypeOf(this, IfExpressionMissingParametersError.prototype);
+    }
+}

package/lib/common/model/fields/parsers/field-code-parser-merge-field.js

@@ -25,7 +25,7 @@ export class FieldCodeParserMailMerge extends FieldCodeParserDocVariable {
     }
     getMergeFieldName() {
         if (this.parameterInfoList.length == 0)
-            this.parseSwitchesAndArgs(true);
+            this.parseSwitchesAndArgs();
         return this.parameterInfoList[0] ? this.parameterInfoList[0].text : '';
     }
     applyResponse(response) {

package/lib/common/model/fields/parsers/field-code-parser.d.ts

@@ -38,7 +38,8 @@ export declare class FieldSwitch {
 export declare class FieldParameter {
     interval: FixedInterval;
     text: string;
-    constructor(interval: FixedInterval, textRepresentation: string);
+    quoted: boolean;
+    constructor(interval: FixedInterval, textRepresentation: string, quoted?: boolean);
     clone(): FieldParameter;
 }
 export declare class FieldCodeParserHelper {
@@ -46,7 +47,7 @@ export declare class FieldCodeParserHelper {
     static isBackslesh(char: string): boolean;
     static isQuote(char: string): boolean;
 }
-export declare type FieldParserConstructorArguments = {
+export type FieldParserConstructorArguments = {
     modelManager: IModelManager;
     layoutFormatterManager: FormatterManager;
     requestManager: FieldRequestManager;
@@ -55,7 +56,7 @@ export declare type FieldParserConstructorArguments = {
     modelIterator: ModelIterator;
     fieldNameFirstLetterPosition: number;
 };
-export declare type FieldParserConstructor = (args: FieldParserConstructorArguments) => FieldCodeParser;
+export type FieldParserConstructor = (args: FieldParserConstructorArguments) => FieldCodeParser;
 export declare abstract class FieldCodeParser {
     protected readonly switchInfoList: FieldSwitch[];
     protected readonly parameterInfoList: FieldParameter[];
@@ -97,7 +98,7 @@ export declare abstract class FieldCodeParser {
     updateInfo(): boolean;
     protected needUpdateInfo(): boolean;
     protected updateInfoCore(): void;
-    parseSwitchesAndArgs(needAtLestOneSpaceAfterFieldName: boolean): boolean;
+    parseSwitchesAndArgs(): boolean;
     private skipWhitespaces;
     private getFieldParameterInfo;
     private getSwitchInfo;

package/lib/common/model/fields/parsers/field-code-parser.js

@@ -43,12 +43,13 @@ export class FieldSwitch {
     }
 }
 export class FieldParameter {
-    constructor(interval, textRepresentation) {
+    constructor(interval, textRepresentation, quoted = false) {
         this.text = textRepresentation;
         this.interval = interval;
+        this.quoted = quoted;
     }
     clone() {
-        return new FieldParameter(this.interval.clone(), this.text);
+        return new FieldParameter(this.interval.clone(), this.text, this.quoted);
     }
 }
 export class FieldCodeParserHelper {
@@ -313,7 +314,7 @@ export class FieldCodeParser {
     updateInfo() {
         if (!this.needUpdateInfo())
             return false;
-        this.parseSwitchesAndArgs(true);
+        this.parseSwitchesAndArgs();
         this.updateInfoCore();
         return true;
     }
@@ -321,14 +322,7 @@ export class FieldCodeParser {
         return false;
     }
     updateInfoCore() { }
-    parseSwitchesAndArgs(needAtLestOneSpaceAfterFieldName) {
-        if (needAtLestOneSpaceAfterFieldName) {
-            var prevPos = this.modelIterator.getAbsolutePosition();
-            if (this.skipWhitespaces())
-                this.modelIterator.setPosition(prevPos);
-            else
-                return this.modelIterator.run.getType() == RunType.FieldCodeEndRun;
-        }
+    parseSwitchesAndArgs() {
         while (this.skipWhitespaces() && this.modelIterator.run.getType() != RunType.FieldCodeEndRun) {
             var currChar = this.modelIterator.getCurrentChar();
             if (FieldCodeParserHelper.isBackslesh(currChar)) {
@@ -364,7 +358,7 @@ export class FieldCodeParser {
         var argInterval = parseResult.quoted ?
             FixedInterval.fromPositions(startPosition + 1, this.modelIterator.getAbsolutePosition() - 1) :
             FixedInterval.fromPositions(startPosition, this.modelIterator.getAbsolutePosition());
-        return new FieldParameter(argInterval, parseResult.argListChars.join(""));
+        return new FieldParameter(argInterval, parseResult.argListChars.join(""), parseResult.quoted);
     }
     getSwitchInfo() {
         if (!this.moveIteratorToNextChar() || this.modelIterator.run.getType() != RunType.TextRun)

package/lib/common/model/fields/tree-creator.js

@@ -18,6 +18,7 @@ import { FieldCodeParserTc } from './parsers/field-code-parser-tc';
 import { FieldCodeParserTime } from './parsers/field-code-parser-time';
 import { FieldCodeParserToc } from './parsers/field-code-parser-toc';
 import { FieldCodeParserFillIn } from './parsers/fill-in';
+import { FieldCodeParserIf } from './parsers/field-code-parser-if';
 class FieldParsersAndIntervals {
     constructor(interval) {
         this.interval = interval;
@@ -40,6 +41,7 @@ export class UpdateFieldsOptions {
     }
 }
 export class FieldsWaitingForUpdate {
+    get fields() { return this.subDocument.fields; }
     constructor(modelManager, layoutFormatterManager, requestManager, subDocumentIntervals, options, callback) {
         this.infoForFutureUpdate = [];
         this.savedSelectionIntervals = [];
@@ -52,7 +54,6 @@ export class FieldsWaitingForUpdate {
         this.infoForFutureUpdate = ListUtils.map(subDocumentIntervals.intervals, (interval) => new FieldParsersAndIntervals(new LinkedInterval(this.subDocument.positionManager, interval)));
         this.savedSelectionIntervals = ListUtils.map(subDocumentIntervals.intervals, (interval) => new LinkedInterval(this.subDocument.positionManager, interval));
     }
-    get fields() { return this.subDocument.fields; }
     update(response, immediateSendRequest = true) {
         if (this.fields.length == 0) {
             this.endAction();
@@ -182,6 +183,7 @@ export class FieldsWaitingForUpdate {
 }
 FieldsWaitingForUpdate.TOC_NAME = "TOC";
 FieldsWaitingForUpdate.parsersMap = {
+    ["IF"]: (args) => new FieldCodeParserIf(args),
     ["DATE"]: (args) => new FieldCodeParserDate(args),
     ["TIME"]: (args) => new FieldCodeParserTime(args),
     ["DOCVARIABLE"]: (args) => new FieldCodeParserDocVariable(args),

package/lib/common/model/floating-objects/sizes.js

@@ -16,13 +16,13 @@ export class AnchorInlineBaseSize {
     }
 }
 export class PictureSize extends AnchorInlineBaseSize {
+    get originalSize() { return this.cacheInfo.size; }
+    ;
     constructor(lockAspectRatio, rotation, cacheInfo, scale) {
         super(lockAspectRatio, rotation);
         this.cacheInfo = cacheInfo;
         this.scale = scale;
     }
-    get originalSize() { return this.cacheInfo.size; }
-    ;
     get actualSize() {
         return Size.initByCommonAction(adp => adp(this.cacheInfo.size) * adp(this.scale) / 100);
     }

package/lib/common/model/fonts/control-font.js

@@ -12,15 +12,6 @@ export var FontLoadStatus;
     FontLoadStatus[FontLoadStatus["Error"] = 3] = "Error";
 })(FontLoadStatus || (FontLoadStatus = {}));
 export class ControlFont {
-    constructor(fontFamily, descriptors, key) {
-        this.isFontCollection = false;
-        this.status = FontLoadStatus.Unloaded;
-        this.sourceUrls = [];
-        this._unicodeRanges = null;
-        this.fontFamily = fontFamily;
-        this.descriptors = descriptors;
-        this.cacheKey = key ? key : [this.fontFamily, this.descriptors.cacheKey].join('/');
-    }
     get loaded() { return this.status == FontLoadStatus.Loaded; }
     get unicodeRanges() {
         if (!this._unicodeRanges)
@@ -33,6 +24,15 @@ export class ControlFont {
         controlFontType.set(ControlFontType.Italic, this.descriptors.msWordItalic());
         return controlFontType.getValue();
     }
+    constructor(fontFamily, descriptors, key) {
+        this.isFontCollection = false;
+        this.status = FontLoadStatus.Unloaded;
+        this.sourceUrls = [];
+        this._unicodeRanges = null;
+        this.fontFamily = fontFamily;
+        this.descriptors = descriptors;
+        this.cacheKey = key ? key : [this.fontFamily, this.descriptors.cacheKey].join('/');
+    }
     applySource(data, callback) {
         if (!this.data)
             this.data = data;

package/lib/common/model/fonts/loader.js

@@ -67,13 +67,13 @@ export class ControlFontsLoader {
     }
 }
 class FontToLoad {
+    get currentPath() { return this.sourceUrls[this.ind]; }
     constructor(font, fontsSettings) {
         this.sourceUrls = [];
         this.ind = 0;
         this.font = font;
         this.sourceUrls = font.allSourceUrls(fontsSettings.defaultFolder);
     }
-    get currentPath() { return this.sourceUrls[this.ind]; }
     next() {
         return ++this.ind < this.sourceUrls.length;
     }

package/lib/common/model/footnotes/footnote.d.ts

@@ -14,7 +14,7 @@ export declare enum NoteType {
     ContinuationNotice = 2,
     Normal = 3
 }
-export declare type NoteSeparatorTypes = NoteType.Separator | NoteType.ContinuationSeparator | NoteType.ContinuationNotice;
+export type NoteSeparatorTypes = NoteType.Separator | NoteType.ContinuationSeparator | NoteType.ContinuationNotice;
 export declare enum NoteNumberingRestartType {
     Continuous = 0,
     NewPage = 1,

package/lib/common/model/history/base/history-item.js

@@ -1,24 +1,24 @@
 import { Errors } from '@devexpress/utils/lib/errors';
 export class HistoryItem {
+    canBeMerged() {
+        return false;
+    }
     constructor(modelManipulator) {
         this.uniqueId = -1;
         this.modelManipulator = modelManipulator;
     }
-    canBeMerged() {
-        return false;
-    }
     changeModified() {
         return true;
     }
 }
 export class CompositionHistoryItem extends HistoryItem {
+    canBeMerged() {
+        return true;
+    }
     constructor() {
         super(null);
         this.historyItems = [];
     }
-    canBeMerged() {
-        return true;
-    }
     changeModified() {
         var item;
         for (var i = 0; item = this.historyItems[i]; i++) {

package/lib/common/model/history/base/interval-based-history-item.js

@@ -1,9 +1,9 @@
 import { HistoryItem } from './history-item';
 export class IntervalBasedHistoryItem extends HistoryItem {
+    get boundSubDocument() { return this.subDocInterval.subDocument; }
+    get interval() { return this.subDocInterval.interval; }
     constructor(modelManipulator, subDocInterval) {
         super(modelManipulator);
         this.subDocInterval = subDocInterval;
     }
-    get boundSubDocument() { return this.subDocInterval.subDocument; }
-    get interval() { return this.subDocInterval.interval; }
 }

package/lib/common/model/history/base/position-based-history-item.js

@@ -1,9 +1,9 @@
 import { HistoryItem } from './history-item';
 export class PositionBasedHistoryItem extends HistoryItem {
+    get boundSubDocument() { return this.subDocPos.subDocument; }
+    get position() { return this.subDocPos.position; }
     constructor(modelManipulator, subDocPos) {
         super(modelManipulator);
         this.subDocPos = subDocPos;
     }
-    get boundSubDocument() { return this.subDocPos.subDocument; }
-    get position() { return this.subDocPos.position; }
 }

package/lib/common/model/history/items/floating-objects/insert-anchored-picture-history-item.js

@@ -23,6 +23,7 @@ export class InsertAnchoredTextBoxHistoryItem extends PositionBasedHistoryItem {
     }
     redo() {
         this.modelManipulator.textBox.insertAnchoredTextBox(this.subDocPos, this.charPropsBundle, this.textBoxInfo);
+        this.modelManipulator.model.subDocumentsCollection.restore(this.textBoxInfo.innerSubDocument.id);
     }
     undo() {
         this.modelManipulator.range.removeIntervalWithoutHistory(this.boundSubDocument, new FixedInterval(this.position, 1), false);

package/lib/common/model/history/items/insert-text-history-item.js

@@ -1,13 +1,13 @@
 import { FixedInterval } from '@devexpress/utils/lib/intervals/fixed';
 import { HistoryItem } from '../base/history-item';
 export class InsertTextHistoryItem extends HistoryItem {
+    canBeMerged() {
+        return true;
+    }
     constructor(modelManipulator, params) {
         super(modelManipulator);
         this.params = params.clone();
     }
-    canBeMerged() {
-        return true;
-    }
     redo() {
         this.modelManipulator.text.insertTextInner(this.params);
     }

package/lib/common/model/history/items/switch-text-box-sub-documents-state-history-item.js

@@ -7,7 +7,6 @@ export class SwitchTextBoxSubDocumentsStateHistoryItem extends HistoryItem {
         this.position = position;
     }
     redo() {
-        this.oldSubDocument = this.oldSubDocument.getActualSubDocument();
         const newRun = this.textBoxParentSubDocument.getRunAndIndexesByPosition(this.position).run;
         this.newSubDocument = this.modelManipulator.model.subDocuments[newRun.subDocId];
         this.modelManipulator.model.subDocumentsCollection.replace(this.oldSubDocument.id, this.newSubDocument.id);

package/lib/common/model/history/selection/scroll-history-item.js

@@ -2,6 +2,9 @@ import { HistoryItem } from '../base/history-item';
 import { Flag } from '@devexpress/utils/lib/class/flag';
 import { HistoryItemDirection } from './history-item-direction';
 export class ScrollHistoryItem extends HistoryItem {
+    canBeMerged() {
+        return true;
+    }
     constructor(modelManipulator, selection, oldState, newState, directionValue = HistoryItemDirection.OnRedoAndUndo) {
         super(modelManipulator);
         this.selection = selection;
@@ -9,9 +12,6 @@ export class ScrollHistoryItem extends HistoryItem {
         this.oldState = oldState;
         this.directionFlag = new Flag(directionValue);
     }
-    canBeMerged() {
-        return true;
-    }
     redo() {
         if (this.directionFlag.get(HistoryItemDirection.OnRedo))
             this.selection.scrollManager.setScroll(this.newState);

package/lib/common/model/history/selection/selection-history-item.js

@@ -2,6 +2,9 @@ import { HistoryItem } from '../base/history-item';
 import { Flag } from '@devexpress/utils/lib/class/flag';
 import { HistoryItemDirection } from './history-item-direction';
 export class SelectionHistoryItem extends HistoryItem {
+    canBeMerged() {
+        return true;
+    }
     constructor(modelManipulator, selection, oldState, newState, directionValue = HistoryItemDirection.OnRedoAndUndo) {
         super(modelManipulator);
         this.selection = selection;
@@ -9,9 +12,6 @@ export class SelectionHistoryItem extends HistoryItem {
         this.newState = newState;
         this.directionFlag = new Flag(directionValue);
     }
-    canBeMerged() {
-        return true;
-    }
     redo() {
         if (this.directionFlag.get(HistoryItemDirection.OnRedo))
             this.selection.setState(this.newState);

package/lib/common/model/json/importers/sub-document/run-importers.d.ts

@@ -4,8 +4,8 @@ import { ImageCache } from '../../../caches/images';
 import { CharacterStyle } from '../../../character/character-style';
 import { Paragraph } from '../../../paragraph/paragraph';
 import { RunBase } from '../../../runs/run-base';
-export declare type SimpleRunConstructor = new (startOffset: number, paragraph: Paragraph, charPropsBundle: MaskedCharacterPropertiesBundle) => RunBase;
-export declare type NoteRunConstructor = new (startOffset: number, paragraph: Paragraph, charPropsBundle: MaskedCharacterPropertiesBundle, noteDocumentId: number) => RunBase;
+export type SimpleRunConstructor = new (startOffset: number, paragraph: Paragraph, charPropsBundle: MaskedCharacterPropertiesBundle) => RunBase;
+export type NoteRunConstructor = new (startOffset: number, paragraph: Paragraph, charPropsBundle: MaskedCharacterPropertiesBundle, noteDocumentId: number) => RunBase;
 export declare abstract class BaseRunImporter {
     private maskedCharacterPropertiesCache;
     private charStyles;

package/lib/common/model/manipulators/base-manipulator.js

@@ -1,7 +1,7 @@
 export class BaseManipulator {
+    get history() { return this.modelManipulator.modelManager.history; }
+    get model() { return this.modelManipulator.modelManager.model; }
     constructor(manipulator) {
         this.modelManipulator = manipulator;
     }
-    get history() { return this.modelManipulator.modelManager.history; }
-    get model() { return this.modelManipulator.modelManager.model; }
 }

package/lib/common/model/manipulators/document/sub-document-inserter.js

@@ -31,6 +31,12 @@ export class SubDocumentInserterOptions extends Initializer {
     }
 }
 export class SubDocumentInserter {
+    get history() { return this.targetModelManipulator.modelManager.history; }
+    get modelsConstOffset() { return this.targetStartPosition - this.sourceInterval.start; }
+    get sameModel() { return this.sourceDocumentModel === this.targetDocumentModel; }
+    get currInsertSubDocumentPosition() {
+        return new SubDocumentPosition(this.targetSubDocument, this.currentTargetPosition);
+    }
     constructor(targetModelManipulator, options, targetSubDocPos, sourceSubDocInterval) {
         this.numberingListCache = {};
         this.abstractNumberingListIndexesMap = {};
@@ -66,12 +72,6 @@ export class SubDocumentInserter {
             [RunType.NoteContinuationSeparatorRun]: this.notSupportedRunHandler.bind(this),
         };
     }
-    get history() { return this.targetModelManipulator.modelManager.history; }
-    get modelsConstOffset() { return this.targetStartPosition - this.sourceInterval.start; }
-    get sameModel() { return this.sourceDocumentModel === this.targetDocumentModel; }
-    get currInsertSubDocumentPosition() {
-        return new SubDocumentPosition(this.targetSubDocument, this.currentTargetPosition);
-    }
     insert() {
         this.sourceSubDocument = this.sourceSubDocInterval.subDocument;
         this.sourceInterval = this.sourceSubDocInterval.interval;

package/lib/common/model/manipulators/model-manipulator.js

@@ -25,6 +25,7 @@ import { TextBoxManipulator } from './text-box-manipulator';
 import { TextCaseManipulator } from './text-case-manipulator';
 import { TextManipulator } from './text-manipulator/text-manipulator';
 export class ModelManipulator {
+    get model() { return this.modelManager.model; }
     constructor(modelManager, batchUpdatableObject) {
         this.modelListeners = [];
         this.onFontsChanged = new EventDispatcher();
@@ -57,7 +58,6 @@ export class ModelManipulator {
         this.section = new SectionManipulator(this);
         this.documentMerger = new DocumentMerger(this);
     }
-    get model() { return this.modelManager.model; }
     notifyModelChanged(change) {
         this.modelListeners.forEach(listener => listener.modelChanged(change));
     }

package/lib/common/model/manipulators/picture-manipulator/insert-picture-manipulator-params.js

@@ -4,13 +4,13 @@ import { PictureSize } from '../../floating-objects/sizes';
 import { Shape } from '../../shapes/shape';
 import { NonVisualDrawingObjectInfo } from './non-visual-drawing-object-info';
 export class BasePictureInfo {
+    get cacheInfo() { return this.size.cacheInfo; }
     constructor(size, shape, containerProperties, drawingProperties) {
         this.size = size;
         this.shape = shape;
         this.containerProperties = containerProperties;
         this.nonVisualDrawingProperties = drawingProperties;
     }
-    get cacheInfo() { return this.size.cacheInfo; }
 }
 export class InlinePictureInfo extends BasePictureInfo {
     constructor(size, shape, publicAPIID, containerProperties, drawingProperties) {

package/lib/common/model/manipulators/picture-manipulator/loader/image-loading-options.d.ts

@@ -1,7 +1,7 @@
 import { Size } from '@devexpress/utils/lib/geometry/size';
 import { FixedInterval } from '@devexpress/utils/lib/intervals/fixed';
 import { CacheImageInfo } from '../../../caches/images';
-export declare type ImageLoadingOptionsCallback = (picInterval: FixedInterval, cacheInfo: CacheImageInfo) => void;
+export type ImageLoadingOptionsCallback = (picInterval: FixedInterval, cacheInfo: CacheImageInfo) => void;
 export declare class ImageLoadingOptions {
     imageLoadedEvent: ImageLoadingOptionsCallback[];
     actualSize?: Size;

package/lib/common/model/manipulators/picture-manipulator/loader/picture-loader.d.ts

@@ -16,7 +16,7 @@ export declare class PicSizeUpdaterData {
 interface IPictureLoadedListener {
     notifyPictureLoaded(): void;
 }
-export declare type AllPicturesLoaded = (isLoaded: boolean) => void;
+export type AllPicturesLoaded = (isLoaded: boolean) => void;
 export interface ISizeUpdater {
     getImageLoadingOptions(run: PictureRunType): ImageLoadingOptions;
 }

package/lib/common/model/manipulators/picture-manipulator/loader/picture-loader.js

@@ -128,12 +128,12 @@ class CallbacksInfo {
     }
 }
 export class PictureLoader {
+    get imageCache() { return this.modelManipulator.model.cache.imageCache; }
     constructor(modelManipulator) {
         this.callbacksInfo = [];
         this.modelManipulator = modelManipulator;
         this.sizeUpdater = new PicSizeUpdater(modelManipulator, this);
     }
-    get imageCache() { return this.modelManipulator.model.cache.imageCache; }
     notifyPictureLoaded() {
         if (this.sizeUpdater.allPicturesLoaded()) {
             const clbs = this.callbacksInfo;

package/lib/common/model/manipulators/range/create-range-copy-operation.js

@@ -25,6 +25,9 @@ import { TablesManipulator } from '../tables/tables-manipulator';
 import { isDefined } from '@devexpress/utils/lib/utils/common';
 import { SubDocumentInserterOptions } from '../document/sub-document-inserter';
 export class CreateRangeCopyOperation {
+    get documentModel() {
+        return this.subDocument.documentModel;
+    }
     constructor(subDocument, abstractNumberingListCache, numberingListCache) {
         this.newOffsetAtStartChunk = 0;
         this.additionalParagraphRunPositions = {};
@@ -32,9 +35,6 @@ export class CreateRangeCopyOperation {
         this.numberingListCache = numberingListCache;
         this.abstractNumberingListCache = abstractNumberingListCache;
     }
-    get documentModel() {
-        return this.subDocument.documentModel;
-    }
     copyStyles(newDocumentModel) {
         newDocumentModel.characterStyles = ListUtils.deepCopy(this.documentModel.characterStyles);
         newDocumentModel.paragraphStyles = ListUtils.deepCopy(this.documentModel.paragraphStyles);

package/lib/common/model/manipulators/range/remove-interval-operation.js

@@ -54,8 +54,14 @@ export class RemoveIntervalOperation {
         var accumulatedInterval = new FixedInterval(this.position, 0);
         let removedTextList = [];
         while (iterator.moveNext()) {
-            if (EnumUtils.isAnyOf(iterator.currentRun.getType(), RunType.AnchoredPictureRun, RunType.AnchoredTextBoxRun))
-                this.modelManipulator.notifyModelChanged(new AnchorObjectRemovedSubDocumentChange(this.subDocument.id, (iterator.currentRun).anchoredObjectID, iterator.currentInterval().start));
+            if (EnumUtils.isAnyOf(iterator.currentRun.getType(), RunType.AnchoredPictureRun, RunType.AnchoredTextBoxRun)) {
+                const currentRun = iterator.currentRun;
+                const position = iterator.currentInterval().start;
+                const change = new AnchorObjectRemovedSubDocumentChange(this.subDocument.id, currentRun.anchoredObjectID, position);
+                if (currentRun instanceof AnchoredTextBoxRun)
+                    this.modelManipulator.model.subDocumentsCollection.replace(currentRun.subDocId, subDocument.id);
+                this.modelManipulator.notifyModelChanged(change);
+            }
             if (iterator.currentChunk !== subDocument.chunks[this.currentChunkIndex]) {
                 this.removeAccumulatedInterval(accumulatedInterval, this.position, 0, removedTextList);
                 this.currentChunkIndex++;

package/lib/common/model/manipulators/tables/insert-table-cell-operation.js

@@ -7,11 +7,11 @@ import { TableCellMergingState } from '../../tables/secondary-structures/table-b
 import { TableCellUtils } from '../../tables/table-utils';
 import { InsertParagraphManipulatorParams } from '../paragraph-manipulator/insert-paragraph-manipulator-params';
 export class InsertTableCellOperationBase {
+    get modelManipulator() { return this.modelManager.modelManipulator; }
     constructor(modelManager, subDocument) {
         this.subDocument = subDocument;
         this.modelManager = modelManager;
     }
-    get modelManipulator() { return this.modelManager.modelManipulator; }
     execute(table, rowIndex, cellIndex, inpPos, options) {
         let row = table.rows[rowIndex];
         let cell = row.cells[cellIndex];