devexpress-richedit 24.2.1-alpha-24260-0102 → 24.2.3

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

@@ -6,10 +6,11 @@ import { HyperlinkInfo } from '../field';
 import { FieldName } from '../names';
 import { FieldCodeParserState, FieldSwitchType } from './field-code-parser';
 import { FieldCodeParserClientUpdatingBase } from './field-code-parser-client-updating-base';
+import { UrlUtils } from '../../../utils/utils';
 export class FieldCodeParserHyperlink extends FieldCodeParserClientUpdatingBase {
     get name() { return FieldName.Hyperlink; }
     parseCodeCurrentFieldInternal(_responce) {
-        if (this.parseSwitchesAndArgs(true))
+        if (this.parseSwitchesAndArgs())
             this.fillResult();
         else
             this.removeInterval(this.getTopField().getResultInterval());
@@ -17,54 +18,47 @@ export class FieldCodeParserHyperlink extends FieldCodeParserClientUpdatingBase
         return true;
     }
     fillResult() {
-        var field = this.getTopField();
-        var text = this.parameterInfoList[0] ? this.parameterInfoList[0].text : "";
-        var newHyperlinkInfo = this.updateHyperlinkInfo(field, text);
+        var _a, _b;
+        const field = this.getTopField();
+        const text = (_b = (_a = this.parameterInfoList[0]) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : "";
+        const newHyperlinkInfo = this.updateHyperlinkInfo(text);
         if (!newHyperlinkInfo) {
-            if (!this.modelManager.richOptions.fields.keepHyperlinkResultForInvalidReference)
+            if (!this.modelManager.richOptions.fields.keepHyperlinkResultForInvalidReference) {
                 this.removeInterval(this.getTopField().getResultInterval());
+            }
             return true;
         }
-        var modelManipulator = this.modelManager.modelManipulator;
-        var resultInterval = field.getResultInterval();
-        if (resultInterval.length == 0) {
-            var resultText = text.length > 0 ? text : "#" + newHyperlinkInfo.anchor;
-            var newResultInterval = new FixedInterval(resultInterval.start, resultText.length);
+        const modelManipulator = this.modelManager.modelManipulator;
+        const resultInterval = field.getResultInterval();
+        if (resultInterval.length === 0) {
+            const resultText = text !== null && text !== void 0 ? text : "#" + newHyperlinkInfo.anchor;
+            const newResultInterval = new FixedInterval(resultInterval.start, resultText.length);
             this.setInputPositionState();
             this.replaceTextByInterval(resultInterval, resultText);
-            this.modelManager.history.addAndRedo(new ApplyFieldHyperlinkStyleHistoryItem(modelManipulator, new SubDocumentInterval(this.subDocument, newResultInterval)));
+            const subDocumentInterval = new SubDocumentInterval(this.subDocument, newResultInterval);
+            const historyItem = new ApplyFieldHyperlinkStyleHistoryItem(modelManipulator, subDocumentInterval);
+            this.modelManager.history.addAndRedo(historyItem);
         }
-        this.modelManager.history.addAndRedo(new ChangeFieldHyperlinkInfoHistoryItem(modelManipulator, this.subDocument, field.index, newHyperlinkInfo));
+        const historyItem = new ChangeFieldHyperlinkInfoHistoryItem(modelManipulator, this.subDocument, field.index, newHyperlinkInfo);
+        this.modelManager.history.addAndRedo(historyItem);
         return true;
     }
-    updateHyperlinkInfo(field, text) {
-        var newHyperlinkInfo = field.isHyperlinkField() ? field.getHyperlinkInfo().clone() : new HyperlinkInfo("", "", "", false);
+    updateHyperlinkInfo(text) {
+        const newHyperlinkInfo = new HyperlinkInfo("", "", "", false);
+        [newHyperlinkInfo.uri, newHyperlinkInfo.anchor] = UrlUtils.splitUrlByAnchor(text);
         newHyperlinkInfo.visited = false;
-        var tipSwitch;
-        var bookmarkSwitch;
-        for (var i = 0, switchInfo; switchInfo = this.switchInfoList[i]; i++)
-            if (switchInfo.type == FieldSwitchType.FieldSpecific) {
-                switch (switchInfo.name.toLocaleUpperCase()) {
-                    case "O":
-                        tipSwitch = switchInfo;
-                        break;
-                    case "L":
-                        bookmarkSwitch = switchInfo;
-                        break;
-                }
+        for (const switchInfo of this.switchInfoList) {
+            if (switchInfo.type != FieldSwitchType.FieldSpecific)
+                continue;
+            switch (switchInfo.name.toLocaleUpperCase()) {
+                case "O":
+                    newHyperlinkInfo.tip = switchInfo.arg;
+                    break;
+                case "L":
+                    newHyperlinkInfo.anchor = switchInfo.arg;
+                    break;
             }
-        newHyperlinkInfo.tip = tipSwitch ? tipSwitch.arg : "";
-        var splitted = text.split("#");
-        if (splitted.length == 1) {
-            newHyperlinkInfo.uri = splitted[0];
-            newHyperlinkInfo.anchor = bookmarkSwitch ? bookmarkSwitch.arg : "";
-            if (newHyperlinkInfo.uri == "" && newHyperlinkInfo.anchor == "")
-                return null;
-        }
-        else {
-            newHyperlinkInfo.uri = splitted[0];
-            newHyperlinkInfo.anchor = splitted[1];
         }
-        return newHyperlinkInfo;
+        return newHyperlinkInfo.isValid() ? newHyperlinkInfo : null;
     }
 }

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

@@ -0,0 +1,40 @@
+import { FieldName } from '../names';
+import { FieldCodeParserClientUpdatingBase } from './field-code-parser-client-updating-base';
+export declare class FieldCodeParserIf extends FieldCodeParserClientUpdatingBase {
+    get name(): FieldName;
+    protected fillResult(): boolean;
+    getResult(): string;
+    private parseParameters;
+}
+export declare class IfExpression {
+    operator: string;
+    leftExpression: IfExpressionParameter;
+    rightExpression: IfExpressionParameter;
+    trueText: string;
+    falseText: string;
+    static operators: string[];
+    constructor(operator: string, leftExpression: IfExpressionParameter, rightExpression: IfExpressionParameter, trueText?: string, falseText?: string);
+    static isOperator(operator: string): boolean;
+    evaluate(): string;
+    private evaluateComparison;
+    static compareStrings(leftValue: string, rightValue: string): number;
+    static compareStringsWithWildcards(leftValue: string, rightValue: string): 0 | 1;
+}
+export declare class IfExpressionParameter {
+    text: string;
+    number: number;
+    isNumber: boolean;
+    constructor(text: string, isQuoted?: boolean);
+}
+export declare class IfExpressionError extends Error {
+    constructor(message: string);
+}
+export declare class IfExpressionInvalidOperatorError extends IfExpressionError {
+    constructor(message?: string);
+}
+export declare class IfExpressionTooManyParametersError extends IfExpressionError {
+    constructor(message?: string);
+}
+export declare class IfExpressionMissingParametersError extends IfExpressionError {
+    constructor(message?: string);
+}

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

@@ -0,0 +1,141 @@
+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 {
+            result = this.getResult();
+        }
+        catch (err) {
+            if (err instanceof IfExpressionError) {
+                result = err.message;
+            }
+        }
+        finally {
+            if (result) {
+                this.replaceTextByInterval(this.getTopField().getResultInterval(), result);
+            }
+            return true;
+        }
+    }
+    getResult() {
+        const expression = this.parseParameters(this.parameterInfoList);
+        return expression.evaluate();
+    }
+    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 {
@@ -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;
@@ -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/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/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/manipulators/document/sub-document-inserter.d.ts

@@ -53,6 +53,7 @@ export declare class SubDocumentInserter {
     private getPatternTable;
     private collectFields;
     private collectBookmarks;
+    private collectRangePermission;
     private prependTableByParagraph;
     private getFontInfo;
     private getColorModelInfo;

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

@@ -96,6 +96,7 @@ export class SubDocumentInserter {
             this.collectTables();
             this.collectFields();
             this.collectBookmarks();
+            this.collectRangePermission();
             if (this.options.overlapTableCellContent) {
                 const lastInsertedParagraph = this.targetSubDocument.getParagraphByPosition(this.currInsertSubDocumentPosition.position - 1);
                 const nextParagraph = this.targetSubDocument.getParagraphByPosition(this.currInsertSubDocumentPosition.position);
@@ -204,6 +205,9 @@ export class SubDocumentInserter {
     collectBookmarks() {
         this.targetModelManipulator.bookmark.insertBookmarksFromSubDocument(this.sourceSubDocument, this.targetSubDocument, this.sourceInterval, this.modelsConstOffset);
     }
+    collectRangePermission() {
+        this.targetModelManipulator.rangePermission.insertRangePermissionsFromSubDocument(this.sourceSubDocument, this.targetSubDocument, this.sourceInterval, this.modelsConstOffset);
+    }
     prependTableByParagraph() {
         if (this.options.insertParagraphMarkBeforeIfStartsWithTable) {
             const tbl = Table.getTableByPosition(this.sourceSubDocument.tables, this.sourceInterval.start, false);

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

@@ -4,6 +4,7 @@ import { HistoryRun } from '../../character/history-runs';
 import { SubDocument } from '../../sub-document';
 import { TableCell } from '../../tables/main-structures/table-cell';
 import { ModelManipulator } from '../model-manipulator';
+import { ConstRangePermission } from '../../range-permissions';
 export declare class RemoveIntervalOperation {
     modelManipulator: ModelManipulator;
     currentSectionIndex: number;
@@ -42,6 +43,7 @@ export declare class RemoveIntervalOperationResult {
     private nestingLevels;
     private cellsIterator;
     bookmarkItems: ConstBookmark[];
+    rangePermssionsItems: ConstRangePermission[];
     constructor(cellsIterator: SelectedCellsIterator);
     registerItem(historyRun: HistoryRun): void;
     private registerItemCore;

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

@@ -23,6 +23,7 @@ export class RemoveIntervalOperation {
         this.cellsIterator = new SelectedCellsIterator(this.subDocument, interval);
         const result = new RemoveIntervalOperationResult(this.cellsIterator);
         result.bookmarkItems = this.modelManipulator.bookmark.deleteBookmarks(this.subDocument, interval);
+        result.rangePermssionsItems = this.modelManipulator.rangePermission.deleteRangePermissions(this.subDocument, interval);
         if (this.tryPackSelectionInOneRun(interval, result))
             return result;
         var iterator = this.subDocument.getRunIterator(interval);
@@ -53,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++;
@@ -348,6 +355,7 @@ export class RemoveIntervalOperationResult {
         this.historyRuns = [];
         this.nestingLevels = [];
         this.bookmarkItems = [];
+        this.rangePermssionsItems = [];
         this.cellsIterator = cellsIterator;
     }
     registerItem(historyRun) {

package/lib/common/model/manipulators/range-permission-manipulator.d.ts

@@ -1,7 +1,11 @@
 import { ConstRangePermission } from '../range-permissions';
 import { SubDocument } from '../sub-document';
 import { BaseManipulator } from './base-manipulator';
+import { ConstInterval } from '@devexpress/utils/lib/intervals/const';
+import { FixedInterval } from '@devexpress/utils/lib/intervals/fixed';
 export declare class RangePermissionManipulator extends BaseManipulator {
     createRangePermission(subDocument: SubDocument, permissionTemplate: ConstRangePermission): void;
     deleteRangePermission(subDocument: SubDocument, permissionTemplate: ConstRangePermission, permissionIndex?: number): void;
+    insertRangePermissionsFromSubDocument(fromSubDocument: SubDocument, toSubDocument: SubDocument, fromInterval: ConstInterval, modelsConstOffset: number): void;
+    deleteRangePermissions(subDocument: SubDocument, interval: FixedInterval): ConstRangePermission[];
 }

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

@@ -2,6 +2,7 @@ import { ListUtils } from '@devexpress/utils/lib/utils/list';
 import { RangePermissionsChangedSubDocumentChange } from '../changes/sub-document/range-permissions-changed';
 import { ConstRangePermission, RangePermission } from '../range-permissions';
 import { BaseManipulator } from './base-manipulator';
+import { SearchUtils } from '@devexpress/utils/lib/utils/search';
 export class RangePermissionManipulator extends BaseManipulator {
     createRangePermission(subDocument, permissionTemplate) {
         subDocument.rangePermissions.push(new RangePermission(subDocument.positionManager, permissionTemplate.interval, permissionTemplate.userName, permissionTemplate.group));
@@ -14,4 +15,38 @@ export class RangePermissionManipulator extends BaseManipulator {
         subDocument.filterRangePermissions(this.modelManipulator.modelManager.richOptions.documentProtection);
         this.modelManipulator.notifyModelChanged(new RangePermissionsChangedSubDocumentChange(subDocument.id, permissionTemplate));
     }
+    insertRangePermissionsFromSubDocument(fromSubDocument, toSubDocument, fromInterval, modelsConstOffset) {
+        const rangePermissions = fromSubDocument.rangePermissions;
+        let ind = SearchUtils.normedInterpolationIndexOf(rangePermissions, (b) => b.start, fromInterval.start);
+        while (rangePermissions[ind] && rangePermissions[ind].start >= fromInterval.start)
+            ind--;
+        ind = Math.max(0, ind);
+        for (let rpm; (rpm = rangePermissions[ind]) && rpm.start <= fromInterval.end; ind++) {
+            if (fromInterval.containsInterval(rpm.interval)) {
+                const template = rpm.constRangePermission;
+                template.interval.start += modelsConstOffset;
+                template.interval.end += modelsConstOffset + 1;
+                this.createRangePermission(toSubDocument, template);
+            }
+        }
+        toSubDocument.rangePermissions = toSubDocument.rangePermissions.sort(ConstRangePermission.comparer);
+    }
+    deleteRangePermissions(subDocument, interval) {
+        const rangePermissions = subDocument.rangePermissions;
+        const result = [];
+        let ind = SearchUtils.normedInterpolationIndexOf(rangePermissions, (b) => b.start, interval.start);
+        while (rangePermissions[ind] && rangePermissions[ind].start >= interval.start)
+            ind--;
+        ind = Math.max(0, ind);
+        for (let curr; (curr = rangePermissions[ind]) && curr.interval.start <= interval.end;) {
+            if (interval.containsInterval(curr.interval)) {
+                const tmpl = curr.constRangePermission;
+                this.deleteRangePermission(subDocument, tmpl, ind);
+                result.push(tmpl);
+            }
+            else
+                ind++;
+        }
+        return result;
+    }
 }

package/lib/common/model/manipulators/text-box-manipulator.d.ts

@@ -17,6 +17,6 @@ export declare class BaseTextBoxInfo {
     constructor(innerSubDocument: SubDocument, size: AnchorTextBoxSize, shape: Shape, anchorInfo: AnchorInfo, textBoxProperties: TextBoxProperties, containerProperties: NonVisualDrawingObjectInfo);
 }
 export declare class TextBoxManipulator extends RunsBaseManipulator {
-    insertAnchoredTextBoxViaHistoty(subDocPos: SubDocumentPosition, charPropsBundle: MaskedCharacterPropertiesBundle, textBoxInfo: BaseTextBoxInfo): void;
+    insertAnchoredTextBoxViaHistory(subDocPos: SubDocumentPosition, charPropsBundle: MaskedCharacterPropertiesBundle, textBoxInfo: BaseTextBoxInfo): void;
     insertAnchoredTextBox(subDocPos: SubDocumentPosition, charPropsBundle: MaskedCharacterPropertiesBundle, textBoxInfo: BaseTextBoxInfo): AnchoredTextBoxRun;
 }

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

@@ -16,7 +16,7 @@ export class BaseTextBoxInfo {
     }
 }
 export class TextBoxManipulator extends RunsBaseManipulator {
-    insertAnchoredTextBoxViaHistoty(subDocPos, charPropsBundle, textBoxInfo) {
+    insertAnchoredTextBoxViaHistory(subDocPos, charPropsBundle, textBoxInfo) {
         this.history.addAndRedo(new InsertAnchoredTextBoxHistoryItem(this.modelManipulator, subDocPos, charPropsBundle, textBoxInfo));
     }
     insertAnchoredTextBox(subDocPos, charPropsBundle, textBoxInfo) {
@@ -33,6 +33,7 @@ export class TextBoxManipulator extends RunsBaseManipulator {
         let textBoxSubDoc = textBoxInfo.innerSubDocument ?
             textBoxInfo.innerSubDocument :
             this.model.createSubDocument(SubDocumentInfoType.TextBox, subDocument.id);
+        textBoxInfo.innerSubDocument = textBoxSubDoc;
         textBoxRun.subDocId = textBoxSubDoc.id;
         subDocument.chunks[insertedRun.chunkIndex].textRuns[insertedRun.runIndex].paragraph.length++;
         this.modelManipulator.notifyModelChanged(new AnchoredTextBoxInsertedSubDocumentChange(subDocument.id, textBoxRun.anchoredObjectID, textBoxRun.subDocId, insertPositionAtStartDocument, textBoxInfo.anchorInfo, textBoxRun.containerProperties));

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

@@ -39,7 +39,7 @@ export class TextManipulator extends RunsBaseManipulator {
             return null;
         const historyItems = history.historyItems;
         const result = history.currentIndex == historyItems.length - 1 ? this.getLastHistoryItemNode(historyItems, null, checkType) : null;
-        return !result.empty ? result : null;
+        return (result === null || result === void 0 ? void 0 : result.empty) ? null : result;
     }
     getLastHistoryItemNode(historyItems, parent, checkType) {
         for (let ind = historyItems.length - 1, item; item = historyItems[ind]; ind--) {

package/lib/common/model/options/fields.d.ts

@@ -6,8 +6,7 @@ export declare class FieldsSettings {
     defaultTimeFormat: string;
     defaultDateFormat: string;
     openHyperlinkOnClick: boolean;
-    disableRelativeHyperlinkUri: boolean;
-    allowedHyperlinkUriProtocols: string[];
+    allowedHyperlinkUriSchemes: string[];
     keepHyperlinkResultForInvalidReference: boolean;
     createHyperlinkTooltip: (hyperlinkTooltip: string, hint: string) => string;
     constructor();

package/lib/common/model/options/fields.js

@@ -4,7 +4,6 @@ export class FieldsSettings {
     ;
     constructor() {
         this.openHyperlinkOnClick = false;
-        this.disableRelativeHyperlinkUri = false;
         this.updateFieldsBeforePrint = true;
         this.updateFieldsOnPaste = true;
         this.defaultTimeFormat = FieldsSettings.DEFAULT_TIME_FORMAT;
@@ -30,10 +29,8 @@ export class FieldsSettings {
             this.keepHyperlinkResultForInvalidReference = obj.keepHyperlinkResultForInvalidReference;
         if (isDefined(obj.createHyperlinkTooltip) && obj.createHyperlinkTooltip !== '')
             this.createHyperlinkTooltip = convertToFunction(obj.createHyperlinkTooltip);
-        if (isDefined(obj.disableRelativeHyperlinkUri))
-            this.disableRelativeHyperlinkUri = obj.disableRelativeHyperlinkUri;
-        if (isDefined(obj.allowedHyperlinkUriProtocols))
-            this.allowedHyperlinkUriProtocols = obj.allowedHyperlinkUriProtocols;
+        if (isDefined(obj.allowedHyperlinkUriSchemes))
+            this.allowedHyperlinkUriSchemes = obj.allowedHyperlinkUriSchemes;
     }
     clone() {
         const result = new FieldsSettings();

package/lib/common/model/range-permissions.js

@@ -7,8 +7,8 @@ import { BookmarkBase } from './bookmarks';
 export class RangePermission extends BookmarkBase {
     constructor(positionManager, interval, userName, group) {
         super(positionManager, interval);
-        this.userName = userName.toLowerCase();
-        this.group = group.toLowerCase();
+        this.userName = userName;
+        this.group = group;
     }
     isGranted(settings) {
         return RangePermission.allow(this.group, RangePermission.Everyone_GROUP_NAME) ||
@@ -17,7 +17,7 @@ export class RangePermission extends BookmarkBase {
             RangePermission.allow(this.group, settings.authenticationGroup);
     }
     static allow(permissionValue, settingsValue) {
-        return settingsValue != "" && permissionValue == settingsValue;
+        return settingsValue != "" && Comparers.stringIgnoreCase(permissionValue, settingsValue) == 0;
     }
     get end() { return this._interval.end - 1; }
     get length() { return this.end - this.start; }
@@ -42,7 +42,9 @@ export class RangePermission extends BookmarkBase {
         return new RangePermission(positionManager, this.interval, this.userName, this.group);
     }
     equals(obj) {
-        return super.equals(obj) && (StringUtils.isNullOrEmpty(this.userName) ? this.group == obj.group : this.userName == obj.userName);
+        return super.equals(obj) && (StringUtils.isNullOrEmpty(this.userName) ?
+            Comparers.stringIgnoreCase(obj.group, this.group) == 0 :
+            Comparers.stringIgnoreCase(obj.userName, this.userName) == 0);
     }
 }
 RangePermission.Everyone_GROUP_NAME = "Everyone".toLowerCase();

package/lib/common/model/styles-manager.js

@@ -123,6 +123,7 @@ export class StylesManager {
     }
     addTableCellStyleCore(oldStyle) {
         var newStyle = oldStyle.clone();
+        this.tableCellStyleNameToIndex[newStyle.styleName] = this.documentModel.tableCellStyles.push(newStyle) - 1;
         newStyle.characterProperties = this.documentModel.cache.mergedCharacterPropertiesCache.getItem(oldStyle.characterProperties);
         newStyle.tableCellProperties = this.documentModel.cache.tableCellPropertiesCache.getItem(oldStyle.tableCellProperties);
         return newStyle;