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

package/lib/common/commands/fields/open-hyperlink-command.js

@@ -4,7 +4,7 @@ import { ReadOnlyMode } from '../../interfaces/i-rich-edit-core';
 import { RichEditClientCommand } from '../client-command';
 import { CommandSimpleOptions } from '../command-base';
 import { HyperlinkCommandBase } from './hyperlink-command-base';
-import { UrlUtils } from '../../../common/utils/utils';
+import { createUrlValidationOptions, UrlUtils } from '../../../common/utils/utils';
 export class OpenHyperlinkCommand extends HyperlinkCommandBase {
     executeCore(state, options) {
         let field;
@@ -26,8 +26,9 @@ export class OpenHyperlinkCommand extends HyperlinkCommandBase {
             this.aspxForceSendingRequest();
         }
         if (hyperlinkInfo.isUri()) {
+            const options = createUrlValidationOptions(this.control.modelManager);
             let uri = hyperlinkInfo.getUriWithAnchor();
-            if (!UrlUtils.isValid(uri))
+            if (!UrlUtils.isValid(uri, options))
                 uri = UrlUtils.EmptyPage;
             Url.navigate(uri, "_blank");
         }

package/lib/common/commands/floating-objects/floating-object-drag-drop-change-position-command.js

@@ -200,7 +200,7 @@ export class FloatingObjectDragDropChangePositionCommand extends CommandBase {
         const newRun = this.activeSubDocument.getRunAndIndexesByPosition(position).run;
         if (newRun.getType() == RunType.AnchoredTextBoxRun) {
             const oldTextBoxRun = oldRun;
-            const originalSubDocument = this.control.modelManager.model.subDocuments[oldTextBoxRun.subDocId];
+            const originalSubDocument = this.control.modelManager.model.subDocumentsCollection.collection[oldTextBoxRun.subDocId];
             this.history.addAndRedo(new SwitchTextBoxSubDocumentsStateHistoryItem(this.modelManipulator, originalSubDocument, this.activeSubDocument, position));
         }
     }

package/lib/common/commands/floating-objects/insert-anchored-text-box-command.js

@@ -44,7 +44,7 @@ export class InsertAnchoredTextBoxCommand extends CommandBase {
         anchorInfo.zOrder = this.modelManipulator.floatingObject.zOrder.getNewZOrder(options.subDocument);
         anchorInfo.layoutTableCell = true;
         history.addTransaction(() => {
-            this.modelManipulator.textBox.insertAnchoredTextBoxViaHistoty(new SubDocumentPosition(this.selection.activeSubDocument, this.selection.lastSelectedInterval.start), this.inputPosition.charPropsBundle, new BaseTextBoxInfo(null, size, new Shape(ColorUtils.fromString(ColorUtils.colorNames.white), ColorHelper.BLACK_COLOR, UnitConverter.pointsToTwips(3.0 / 4)), anchorInfo, textBoxProperties, new NonVisualDrawingObjectInfo()));
+            this.modelManipulator.textBox.insertAnchoredTextBoxViaHistory(new SubDocumentPosition(this.selection.activeSubDocument, this.selection.lastSelectedInterval.start), this.inputPosition.charPropsBundle, new BaseTextBoxInfo(null, size, new Shape(ColorUtils.fromString(ColorUtils.colorNames.white), ColorHelper.BLACK_COLOR, UnitConverter.pointsToTwips(3.0 / 4)), anchorInfo, textBoxProperties, new NonVisualDrawingObjectInfo()));
             this.history.addAndRedo(new SelectionHistoryItem(this.modelManipulator, this.selection, this.selection.getState(), this.selection.getState().setInterval(new FixedInterval(this.selection.lastSelectedInterval.start, 1))));
             this.control.commandManager.getCommand(RichEditClientCommand.ChangeActiveSubDocumentToTextBox)
                 .execute(this.control.commandManager.isPublicApiCall, options);

package/lib/common/commands/ruler/toggle-show-horizontal-ruler-command.js

@@ -8,8 +8,10 @@ export class ToggleShowHorizontalRulerCommand extends CommandBase {
         const visible = this.control.horizontalRulerControl.getVisible();
         if (options.param == visible)
             return false;
-        this.control.horizontalRulerControl.setVisible(!visible);
+        const toggledVisible = !visible;
+        this.control.horizontalRulerControl.setVisible(toggledVisible);
         this.control.owner.adjustControl();
+        this.control.owner.raiseHorizontalRulerVisibleChanged(toggledVisible);
         return true;
     }
     isEnabled(_options) {

package/lib/common/commands/text/change-text-case-commands.d.ts

@@ -6,7 +6,7 @@ import { ISelectionBase } from '../../selection/selection-base';
 import { FixedInterval } from '@devexpress/utils/lib/intervals/fixed';
 import { CommandBase, CommandOptions } from '../command-base';
 import { IntervalCommandStateEx } from '../command-states';
-declare type HistItemConstructor = new (modelManipulator: ModelManipulator, subDocInterval: SubDocumentInterval, selection: ISelectionBase, layoutFormatterManager: FormatterManager) => ChangeCaseHistoryItemBase;
+type HistItemConstructor = new (modelManipulator: ModelManipulator, subDocInterval: SubDocumentInterval, selection: ISelectionBase, layoutFormatterManager: FormatterManager) => ChangeCaseHistoryItemBase;
 export declare class ChangeTextCaseCommandBaseBase extends CommandBase<IntervalCommandStateEx> {
     getActualIntervals(): FixedInterval[];
     getState(): IntervalCommandStateEx;

package/lib/common/event-manager.js

@@ -31,6 +31,10 @@ export var MouseButton;
     MouseButton[MouseButton["Middle"] = 4] = "Middle";
 })(MouseButton || (MouseButton = {}));
 export class EventManager {
+    set mouseWheelEvent(val) {
+        this.mouseHandler.mouseWheelEvent = val;
+        this.touchHandler.mouseWheelEvent = val;
+    }
     constructor(control, boxVisualizerManager) {
         this.moveLocked = false;
         this.shouldPreventContextMenuEvent = true;
@@ -42,10 +46,6 @@ export class EventManager {
         this.touchHandler = new TouchHandler(control, boxVisualizerManager);
         this.inputTypeHandlers = this.createInputTypeHandlers();
     }
-    set mouseWheelEvent(val) {
-        this.mouseHandler.mouseWheelEvent = val;
-        this.touchHandler.mouseWheelEvent = val;
-    }
     dispose() {
         clearTimeout(this.accumulatedTextInsertId);
         clearTimeout(this.lockMouseMoveTimerId);

package/lib/common/formats/html/export/html-document-exporter.js

@@ -3,11 +3,11 @@ import { HtmlMimeType } from "@devexpress/utils/lib/utils/mime-type";
 import { RichUtils } from "../../../model/rich-utils";
 import { HtmlExporter } from "./html-export";
 export class HtmlDocumentExporter {
+    get modelManipulator() { return this.exportModelOptions.modelManager.modelManipulator; }
     constructor(exportModelOptions, options) {
         this.exportModelOptions = exportModelOptions;
         this.options = options;
     }
-    get modelManipulator() { return this.exportModelOptions.modelManager.modelManipulator; }
     exportToBlob(callback) {
         this.modelManipulator.picture.loader.ensureAllPicturesLoaded(this.options.ensurePictureLoadedTimeout, (_loaded) => {
             callback(new Blob([this.exportAsString()], { type: HtmlMimeType }));

package/lib/common/formats/html/export/html-export.d.ts

@@ -6,21 +6,27 @@ import { SubDocument } from '../../../model/sub-document';
 import { HtmlBuilder } from './html-builder';
 import { IExportModelOptions } from '../../i-document-exporter';
 interface List {
+    parentList?: List;
     numberingListIndex: number;
     listLevelIndex: number;
     start: number;
     end: number;
 }
+interface IHtmlExporterOptions {
+    sanitaizeHyperlinkURIs?: boolean;
+    convertRelativeURIsToAbsolute?: boolean;
+}
 export declare class HtmlExporter {
     rangeCopy: RangeCopy;
     private exportModelOptions;
+    private htmlExporterOptions;
     private get modelManager();
     private get colorProvider();
     private get unitConverter();
     private get documentRenderer();
     private get lastMaxNumPages();
     private get pageIndex();
-    constructor(exportModelOptions: IExportModelOptions);
+    constructor(exportModelOptions: IExportModelOptions, htmlExporterOptions?: IHtmlExporterOptions);
     getHtmlElementsByInterval(model: DocumentModel, subDocument: SubDocument, interval: FixedInterval, guidLabel: string): HtmlBuilder;
     getParagraphsByInterval(subDocument: SubDocument, interval: FixedInterval): Paragraph[];
     getListsByParagraphs(paragraphs: Paragraph[]): List[];

package/lib/common/formats/html/export/html-export.js

@@ -24,11 +24,9 @@ import { TableWidthUnitType } from '../../../model/tables/secondary-structures/t
 import { HtmlConverter } from '../../../rich-utils/html-converter';
 import { HtmlBuilder } from './html-builder';
 import { isDefined } from '@devexpress/utils/lib/utils/common';
+import { createUrlValidationOptions, UrlUtils } from '../../../../common/utils/utils';
+import { ListUtils } from '@devexpress/utils/lib/utils/list';
 export class HtmlExporter {
-    constructor(exportModelOptions) {
-        this.rangeCopy = null;
-        this.exportModelOptions = exportModelOptions;
-    }
     get modelManager() { return this.exportModelOptions.modelManager; }
     get colorProvider() { return this.modelManager.model.colorProvider; }
     get unitConverter() { return this.exportModelOptions.uiUnitConverter; }
@@ -37,7 +35,13 @@ export class HtmlExporter {
     ;
     get pageIndex() { return this.exportModelOptions.pageIndex; }
     ;
+    constructor(exportModelOptions, htmlExporterOptions = null) {
+        this.rangeCopy = null;
+        this.exportModelOptions = exportModelOptions;
+        this.htmlExporterOptions = htmlExporterOptions;
+    }
     getHtmlElementsByInterval(model, subDocument, interval, guidLabel) {
+        var _a, _b, _c, _d;
         if (interval.length === 0)
             return;
         const unitTypeToString = this.unitConverter.getUnits() == RichEditUnit.Centimeter ? "cm" : "in";
@@ -337,7 +341,18 @@ export class HtmlExporter {
                     break;
             }
             if (hyperlinkInfo && !isInsideHyperlink) {
-                const url = hyperlinkInfo.uri + (hyperlinkInfo.anchor != "" ? "#" + hyperlinkInfo.anchor : "");
+                const sanitaizeHyperlinkURIs = (_b = (_a = this.htmlExporterOptions) === null || _a === void 0 ? void 0 : _a.sanitaizeHyperlinkURIs) !== null && _b !== void 0 ? _b : false;
+                const convertRelativeURIsToAbsolute = (_d = (_c = this.htmlExporterOptions) === null || _c === void 0 ? void 0 : _c.convertRelativeURIsToAbsolute) !== null && _d !== void 0 ? _d : false;
+                let url = hyperlinkInfo.uri;
+                const options = createUrlValidationOptions(this.exportModelOptions.modelManager);
+                if (!sanitaizeHyperlinkURIs || UrlUtils.isValid(url, options)) {
+                    if (convertRelativeURIsToAbsolute && UrlUtils.isRelative(url))
+                        url = UrlUtils.convertToAbsolute(url).href;
+                    if (hyperlinkInfo.anchor != "")
+                        url = url + "#" + hyperlinkInfo.anchor;
+                }
+                else
+                    url = UrlUtils.EmptyPage;
                 const tooltip = hyperlinkInfo.tip;
                 html
                     .clear()
@@ -455,42 +470,27 @@ export class HtmlExporter {
     }
     getListsByParagraphs(paragraphs) {
         const listsInInterval = [];
+        let previousList = null;
         for (let i = 0, paragraph; paragraph = paragraphs[i]; i++) {
             if (paragraph.isInList()) {
-                const paragraphNumberingListIndex = paragraph.getNumberingListIndex();
-                const paragraphListLevelIndex = paragraph.getListLevelIndex();
-                const paragraphStart = paragraph.startLogPosition.value;
-                const paragraphEnd = paragraph.getEndPosition();
-                let existingItem = null;
-                for (let j = 0; j < listsInInterval.length; j++) {
-                    if (listsInInterval[j].numberingListIndex === paragraphNumberingListIndex
-                        && listsInInterval[j].listLevelIndex === paragraphListLevelIndex) {
-                        existingItem = listsInInterval[j];
-                    }
-                }
-                if (existingItem && (paragraphListLevelIndex === 0 || existingItem.end == paragraphStart
-                    || listsInInterval[listsInInterval.length - 1].listLevelIndex > paragraphListLevelIndex)) {
-                    existingItem.end = paragraphEnd;
-                }
-                else {
-                    listsInInterval.push({
-                        numberingListIndex: paragraphNumberingListIndex,
-                        listLevelIndex: paragraphListLevelIndex,
-                        start: paragraphStart,
-                        end: paragraphEnd,
-                    });
-                }
-                let listLevelIndex = paragraphListLevelIndex;
-                while (listLevelIndex > 0) {
-                    let parentItem = null;
-                    for (let j = 0; j < listsInInterval.length; j++) {
-                        if (listsInInterval[j].listLevelIndex == listLevelIndex - 1)
-                            parentItem = listsInInterval[j];
-                    }
-                    if (parentItem)
-                        parentItem.end = paragraphEnd;
-                    listLevelIndex--;
+                const numberingListIndex = paragraph.getNumberingListIndex();
+                const listLevelIndex = paragraph.getListLevelIndex();
+                const start = paragraph.startLogPosition.value;
+                const end = paragraph.getEndPosition();
+                let list = ListUtils.reverseElementBy(listsInInterval, (list) => {
+                    return list.listLevelIndex <= (previousList === null || previousList === void 0 ? void 0 : previousList.listLevelIndex)
+                        && list.numberingListIndex === numberingListIndex
+                        && list.listLevelIndex === listLevelIndex;
+                });
+                if (!list) {
+                    const parentList = (previousList === null || previousList === void 0 ? void 0 : previousList.numberingListIndex) === numberingListIndex ? previousList : null;
+                    list = { parentList, numberingListIndex, listLevelIndex, start, end };
+                    listsInInterval.push(list);
                 }
+                previousList = list;
+                do {
+                    list.end = end;
+                } while (list = list.parentList);
             }
         }
         return listsInInterval;

package/lib/common/formats/html/import/html-importer.d.ts

@@ -12,7 +12,7 @@ import { LoadFontInfo } from './load-font-info';
 import { HtmlImporterMaskedCharacterProperties } from './utils/character-properties-utils';
 import { ParagraphListPropertiesUtils } from './utils/paragraph-list-properties-utils';
 import { FormatImagesImporter } from '../../utils/images-import';
-export declare type TypeOfTagImporterConstructor = new (importer: HtmlImporter) => HtmlTagImporterBase;
+export type TypeOfTagImporterConstructor = new (importer: HtmlImporter) => HtmlTagImporterBase;
 export declare class LevelInfo {
     element: HTMLElement;
     childElements: HTMLElement[];

package/lib/common/formats/html/import/html-importer.js

@@ -68,6 +68,18 @@ export class HtmlImportData {
     }
 }
 export class HtmlImporter {
+    get currElement() { return ListUtils.last(this.levelInfo).element; }
+    ;
+    get currElementChildren() { return ListUtils.last(this.levelInfo).childElements; }
+    ;
+    get prevLevelInfo() { return this.levelInfo[this.levelInfo.length - 2]; }
+    get currLevelInfo() { return ListUtils.last(this.levelInfo); }
+    get currListItemLevelInfo() { return ListUtils.reverseElementBy(this.levelInfo, (levelInfo) => { var _a; return ((_a = levelInfo.tagImporter) === null || _a === void 0 ? void 0 : _a.elementTag()) === 'LI'; }); }
+    get currListInfo() {
+        const currListItemLevelInfo = this.currListItemLevelInfo;
+        return currListItemLevelInfo && !currListItemLevelInfo.tagImporter.paragraphWasAddedBefore ? ListUtils.last(this.listInfos) : null;
+    }
+    get subDocument() { return this.subDocPosition.subDocument; }
     constructor(modelManager, measurer, subDocPosition, initElements, charPropsBundle, formatImagesImporter) {
         this.fieldsId = 0;
         this.listIndex = 0;
@@ -119,18 +131,6 @@ export class HtmlImporter {
         for (let importerConst of HtmlImporter.importers)
             this.tagImporters[new importerConst(this).elementTag()] = importerConst;
     }
-    get currElement() { return ListUtils.last(this.levelInfo).element; }
-    ;
-    get currElementChildren() { return ListUtils.last(this.levelInfo).childElements; }
-    ;
-    get prevLevelInfo() { return this.levelInfo[this.levelInfo.length - 2]; }
-    get currLevelInfo() { return ListUtils.last(this.levelInfo); }
-    get currListItemLevelInfo() { return ListUtils.reverseElementBy(this.levelInfo, (levelInfo) => { var _a; return ((_a = levelInfo.tagImporter) === null || _a === void 0 ? void 0 : _a.elementTag()) === 'LI'; }); }
-    get currListInfo() {
-        const currListItemLevelInfo = this.currListItemLevelInfo;
-        return currListItemLevelInfo && !currListItemLevelInfo.tagImporter.paragraphWasAddedBefore ? ListUtils.last(this.listInfos) : null;
-    }
-    get subDocument() { return this.subDocPosition.subDocument; }
     import() {
         this.importStarted = false;
         this.importedRunsInfo = [];

package/lib/common/formats/html/import/html-model-inserter.js

@@ -11,6 +11,10 @@ import { FixedInterval } from '@devexpress/utils/lib/intervals/fixed';
 import { ListUtils } from '@devexpress/utils/lib/utils/list';
 import { PasteHtmlDataHistoryItem } from '../model/history/paste-html-data-history-item';
 export class HtmlModelInserter {
+    get options() { return this.modelManager.richOptions.control; }
+    ;
+    get subDocument() { return this.subDocPos.subDocument; }
+    ;
     constructor(modelManager, subDocPos, htmlData, charPropsBundle) {
         this.pastedListsIndices = {};
         this.fieldsMap = {};
@@ -38,10 +42,6 @@ export class HtmlModelInserter {
             HtmlModelInserter.runConverterMap[RunType.FieldResultEndRun] = this.convertFieldResultEndRun;
         }
     }
-    get options() { return this.modelManager.richOptions.control; }
-    ;
-    get subDocument() { return this.subDocPos.subDocument; }
-    ;
     insert() {
         for (let runInfo of this.htmlData.runsInfo)
             this.position += HtmlModelInserter.runConverterMap[runInfo.runType].call(this, runInfo);

package/lib/common/formats/html/import/importers/base.js

@@ -1,11 +1,11 @@
 import { ListUtils } from '@devexpress/utils/lib/utils/list';
 export class HtmlTagImporterBase {
+    get colorProvider() { return this.importer.modelManager.model.colorProvider; }
     constructor(importer) {
         this.enablePreserveLineBreaks = false;
         this.paragraphWasAddedBefore = false;
         this.importer = importer;
     }
-    get colorProvider() { return this.importer.modelManager.model.colorProvider; }
     getClosestImporterByTagName(tagName) {
         return ListUtils.reverseElementBy(this.importer.levelInfo, (levelInfo) => levelInfo.tagImporter.elementTag() == tagName).tagImporter;
     }

package/lib/common/formats/html/import/importers/list-base.js

@@ -13,9 +13,7 @@ export class HtmlListTagImporterBase extends HtmlTagImporterBase {
         this.importer.addCurrLevelParagraphRunIfNeeded();
         const listIndex = this.importer.listIndex;
         const parentList = ListUtils.last(this.importer.listInfos);
-        const listLevel = parentList
-            ? parentList.listLevel + 1
-            : 0;
+        const listLevel = parentList ? parentList.listLevel + 1 : 0;
         if (listLevel === 9) {
             this._ignored = true;
             return;
@@ -31,6 +29,8 @@ export class HtmlListTagImporterBase extends HtmlTagImporterBase {
         if (this._ignored)
             return;
         this.importer.listInfos.pop();
-        this.importer.listIndex++;
+        const parentList = ListUtils.last(this.importer.listInfos);
+        if (!parentList)
+            this.importer.listIndex++;
     }
 }

package/lib/common/formats/html/import/utils/character-properties-utils.js

@@ -9,16 +9,16 @@ import { DomUtils } from '@devexpress/utils/lib/utils/dom';
 import { LoadFontInfo } from '../load-font-info';
 import { HtmlImporterFontUtils } from './font-utils';
 export class HtmlImporterMaskedCharacterProperties {
+    get model() { return this.importer.modelManager.model; }
+    ;
+    get controlOptions() { return this.importer.modelManager.richOptions.control; }
+    ;
     constructor(importer, loadFontInfos, tempFontInfoCache, allowCreateNewFonts) {
         this.importer = importer;
         this.loadFontInfos = loadFontInfos;
         this.tempFontInfoCache = tempFontInfoCache;
         this.allowCreateNewFonts = allowCreateNewFonts;
     }
-    get model() { return this.importer.modelManager.model; }
-    ;
-    get controlOptions() { return this.importer.modelManager.richOptions.control; }
-    ;
     getBundleFrom(element, interval) {
         return new MaskedCharacterPropertiesBundle(this.import(element, interval, this.importer.charPropsBundle.props), this.importer.charPropsBundle.style);
     }

package/lib/common/formats/i-document-importer.d.ts

@@ -1,8 +1,8 @@
 import { DocumentModel, IModelOptions } from '../model/document-model';
 import { DocumentImporterErrors } from './document-importer-errors';
 import { FormatImagesImporter } from './utils/images-import';
-export declare type FormatImportCallback = (model: DocumentModel, formatImagesImporter: FormatImagesImporter) => void;
-export declare type FormatImportReject = (reason: DocumentImporterErrors) => void;
+export type FormatImportCallback = (model: DocumentModel, formatImagesImporter: FormatImagesImporter) => void;
+export type FormatImportReject = (reason: DocumentImporterErrors) => void;
 export interface IDocumentImporter {
     importFromFile(blob: Blob, modelOptions: IModelOptions, callback: FormatImportCallback, reject: FormatImportReject): void;
 }

package/lib/common/formats/pdf/exporter.js

@@ -7,9 +7,6 @@ import { afterFontsLoaded, fontWebApiAvailable } from '@devexpress/utils/lib/uti
 import { ListUtils } from '@devexpress/utils/lib/utils/list';
 import { PdfLayoutPageExporter } from './page-exporter';
 export class PdfExporter {
-    constructor(docProcessor) {
-        this.docProcessor = docProcessor;
-    }
     get layoutFormatterManager() {
         return this.docProcessor.layoutFormatterManager;
     }
@@ -25,6 +22,9 @@ export class PdfExporter {
     get fontsSettings() {
         return this.docProcessor.modelManager.richOptions.fonts;
     }
+    constructor(docProcessor) {
+        this.docProcessor = docProcessor;
+    }
     export(callback, options) {
         const modifyPdfDocument = typeof options == 'function' ? options :
             (!options || !options.modifyPdfDocument ? () => { } : options.modifyPdfDocument);

package/lib/common/formats/pdf/interfaces.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-export declare type IPdfKitColorValue = string | [number, number, number] | [number, number, number, number];
+export type IPdfKitColorValue = string | [number, number, number] | [number, number, number, number];
 export interface IPdfKitDocument {
     pipe(stream: any): void;
     registerFont(font: string, source: ArrayBuffer, fontFamily: string): IPdfKitDocument;
@@ -31,7 +31,7 @@ export interface IPdfKitDocument {
     fillOpacity(opacity: number): IPdfKitDocument;
     fill(rule: IPdfKitRuleValue): IPdfKitDocument;
 }
-export declare type IPdfKitRuleValue = 'even-odd' | 'evenodd' | 'non-zero' | 'nonzero';
+export type IPdfKitRuleValue = 'even-odd' | 'evenodd' | 'non-zero' | 'nonzero';
 export interface IPdfKitPageOptions {
     size?: [number, number] | string;
     margin?: number;

package/lib/common/formats/rtf/export/exporter.js

@@ -10,6 +10,7 @@ import { RtfExportSR } from '../translation-table/rtf-export-sr';
 import { RtfContentExporter } from './exporters/rtf-content-exporter';
 import { RtfExportHelper } from './helpers/rtf-export-helper';
 export class RtfExporter {
+    get documentModel() { return this.modelManipulator.model; }
     constructor(modelManipulator, options) {
         this.modelManipulator = modelManipulator;
         this.options = options;
@@ -17,7 +18,6 @@ export class RtfExporter {
         this.contentExporter = new RtfContentExporter(this.documentModel, options, this.rtfExportHelper);
         this.rtfBuilder = this.contentExporter.createRtfBuilder();
     }
-    get documentModel() { return this.modelManipulator.model; }
     exportToBlob(callback) {
         this.modelManipulator.picture.loader.ensureAllPicturesLoaded(this.options.ensurePictureLoadedTimeout, (_loaded) => {
             callback(new Blob([this.exportAsString()], { type: 'application/rtf' }));

package/lib/common/formats/rtf/export/exporters/rtf-anchored-picture-run-exporter.js

@@ -1,17 +1,17 @@
 import { RtfFloatingObjectPictureExportStrategy } from './picture/rtf-floating-object-picture-export-strategy';
 import { RtfAnchoredRunExporter } from './rtf-anchored-run-exporter';
 export class RtfAnchoredPictureRunExporter extends RtfAnchoredRunExporter {
-    constructor(rtfBuilder, pictureRun, imageCache) {
-        super(rtfBuilder, pictureRun.anchorInfo, pictureRun.shape, pictureRun.size, pictureRun.info.containerProperties);
-        this.pictureRun = pictureRun;
-        this.imageCache = imageCache;
-    }
     getWidth() {
         return this.size.actualSize.width;
     }
     getHeight() {
         return this.size.actualSize.height;
     }
+    constructor(rtfBuilder, pictureRun, imageCache) {
+        super(rtfBuilder, pictureRun.anchorInfo, pictureRun.shape, pictureRun.size, pictureRun.info.containerProperties);
+        this.pictureRun = pictureRun;
+        this.imageCache = imageCache;
+    }
     exportContent() {
         const exportStrategy = new RtfFloatingObjectPictureExportStrategy();
         exportStrategy.export(this.rtfBuilder, this.pictureRun.info, this.imageCache, this.pictureRun.info.containerProperties);

package/lib/common/formats/rtf/export/exporters/rtf-content-exporter.d.ts

@@ -15,7 +15,7 @@ import { DocumentPropertyNames, RtfDocumentExporterOptions } from '../rtf-docume
 import { RtfCharacterPropertiesExporter } from './rtf-character-properties-exporter';
 import { RtfParagraphPropertiesExporter } from './rtf-paragraph-properties-exporter';
 import { RtfSectionPropertiesExporter } from './rtf-section-properties-exporter';
-export declare type RunHandler = (run: RunBase, runText: string, absolutePosition: number) => void;
+export type RunHandler = (run: RunBase, runText: string, absolutePosition: number) => void;
 export declare class RtfContentExporter {
     documentModel: DocumentModel;
     subDocument: SubDocument;

package/lib/common/formats/rtf/export/exporters/rtf-content-exporter.js

@@ -35,6 +35,8 @@ import { RtfSectionPropertiesExporter } from './rtf-section-properties-exporter'
 import { RtfStyleExporter } from './rtf-style-exporter';
 import { RtfTableExporter } from './table/rtf-table-exporter';
 export class RtfContentExporter {
+    get shouldExportHiddenText() { return true; }
+    ;
     constructor(documentModel, options, rtfExportHelper) {
         this.shouldFourceUpdateIterators = false;
         this.documentModel = documentModel;
@@ -57,8 +59,6 @@ export class RtfContentExporter {
             .add(RunType.AnchoredTextBoxRun, this.anchoredTextBoxRunHandler)
             .get();
     }
-    get shouldExportHiddenText() { return true; }
-    ;
     createRtfBuilder() {
         return new RtfBuilder();
     }

package/lib/common/formats/rtf/export/rtf-builder.d.ts

@@ -1,7 +1,7 @@
 import { ChunkedText } from '@devexpress/utils/lib/class/chunked-text';
 import { NonVisualDrawingObjectInfo } from '../../../model/manipulators/picture-manipulator/non-visual-drawing-object-info';
-declare type SpecialMarksTable = Record<string, string>;
-declare type Action = () => void;
+type SpecialMarksTable = Record<string, string>;
+type Action = () => void;
 export declare class RtfBuilder {
     static readonly specialMarks: SpecialMarksTable;
     static readonly byteToHexString: string[];

package/lib/common/formats/rtf/import/destination/base/destination.d.ts

@@ -2,10 +2,10 @@ import { SubDocument } from '../../../../../model/sub-document';
 import { RtfFormattingInfo } from '../../model/character/rtf-formatting-info';
 import { RtfImportData } from '../../rtf-import-data';
 import { DestinationType } from '../utils/destination-type';
-export declare type TranslateControlCharHandler = (importer: RtfImportData, ch: string) => void;
-export declare type ControlCharTranslatorTable = Record<string, TranslateControlCharHandler>;
-export declare type TranslateKeywordHandler = (importer: RtfImportData, parameterValue: number, hasParameter: boolean) => void;
-export declare type KeywordTranslatorTable = Record<string, TranslateKeywordHandler>;
+export type TranslateControlCharHandler = (importer: RtfImportData, ch: string) => void;
+export type ControlCharTranslatorTable = Record<string, TranslateControlCharHandler>;
+export type TranslateKeywordHandler = (importer: RtfImportData, parameterValue: number, hasParameter: boolean) => void;
+export type KeywordTranslatorTable = Record<string, TranslateKeywordHandler>;
 export declare abstract class DestinationBase {
     static readonly macCodePage: number;
     static readonly pcCodePage: number;

package/lib/common/formats/rtf/import/destination/base/destination.js

@@ -4,6 +4,7 @@ import { RtfFormattingInfo } from '../../model/character/rtf-formatting-info';
 import { RtfParsingState } from '../../model/enums';
 import { DestinationType } from '../utils/destination-type';
 export class DestinationBase {
+    static get empty() { return EmptyDestination._empty; }
     constructor(importer) {
         if (importer) {
             this.importer = importer;
@@ -13,7 +14,6 @@ export class DestinationBase {
             importer.importers.character.characterFormatting.rtfFormattingInfo = rtfFormattingInfo;
         }
     }
-    static get empty() { return EmptyDestination._empty; }
     createRtfFormattingInfo() {
         return new RtfFormattingInfo();
     }

package/lib/common/formats/rtf/import/destination/base/skip-destination.js

@@ -2,15 +2,15 @@ import { SkipCharacterDecoder } from '../../encoding/skip-character-decoder';
 import { DestinationType } from '../utils/destination-type';
 import { DestinationBase } from './destination';
 export class SkipDestination extends DestinationBase {
+    get destinationType() { return DestinationType.SkipDestination; }
+    get controlCharHT() { return null; }
+    ;
     constructor(importer) {
         super(importer);
         const formInfo = this.importer.importers.character.characterFormatting.rtfFormattingInfo;
         this.oldDecoder = formInfo.activeDecoder;
         formInfo.activeDecoder = new SkipCharacterDecoder();
     }
-    get destinationType() { return DestinationType.SkipDestination; }
-    get controlCharHT() { return null; }
-    ;
     beforePopRtfState() {
         this.importer.importers.character.characterFormatting.rtfFormattingInfo.activeDecoder = this.oldDecoder;
         super.beforePopRtfState();

package/lib/common/formats/rtf/import/destination/base/string-property-base-destination.js

@@ -3,13 +3,13 @@ import { StringUtils } from '@devexpress/utils/lib/utils/string';
 import { DestinationType } from '../utils/destination-type';
 import { DestinationBase } from './destination';
 export class StringPropertyBaseDestination extends DestinationBase {
+    get destinationType() { return DestinationType.StringPropertyBaseDestination; }
+    get controlCharHT() { return StringPropertyBaseDestination.controlCharHT; }
     constructor(importer, modifier) {
         super(importer);
         this.value = [];
         this.modifier = modifier;
     }
-    get destinationType() { return DestinationType.StringPropertyBaseDestination; }
-    get controlCharHT() { return StringPropertyBaseDestination.controlCharHT; }
     processCharCore(ch) {
         this.value.push(ch);
     }

package/lib/common/formats/rtf/import/destination/base/string-property-destination.js

@@ -3,12 +3,12 @@ import { StringUtils } from '@devexpress/utils/lib/utils/string';
 import { DestinationType } from '../utils/destination-type';
 import { UnicodeStringValueDestination } from './unicode-string-value-destination';
 export class StringPropertyDestination extends UnicodeStringValueDestination {
+    get destinationType() { return DestinationType.StringPropertyDestination; }
+    get controlCharHT() { return StringPropertyDestination.controlCharHT; }
     constructor(importer, setProperty) {
         super(importer);
         this.setProperty = setProperty;
     }
-    get destinationType() { return DestinationType.StringPropertyDestination; }
-    get controlCharHT() { return StringPropertyDestination.controlCharHT; }
     createEmptyClone() {
         return new StringPropertyDestination(this.importer, this.setProperty);
     }

package/lib/common/formats/rtf/import/destination/base/unicode-destination.js

@@ -1,12 +1,12 @@
 import { DestinationType } from '../utils/destination-type';
 import { DestinationBase } from './destination';
 export class UnicodeDestination extends DestinationBase {
+    get destinationType() { return DestinationType.UnicodeDestination; }
+    get controlCharHT() { return null; }
     constructor(importer, lastDestination) {
         super(importer);
         this.lastDestination = lastDestination;
     }
-    get destinationType() { return DestinationType.UnicodeDestination; }
-    get controlCharHT() { return null; }
     createClone() {
         return new UnicodeDestination(this.importer, this.lastDestination);
     }

package/lib/common/formats/rtf/import/destination/fields/field-sub-destination.js

@@ -1,11 +1,11 @@
 import { DefaultDestination } from '../sub-document/default-destination';
 import { DestinationType } from '../utils/destination-type';
 export class FieldSubDestination extends DefaultDestination {
+    get destinationType() { return DestinationType.FieldSubDestination; }
     constructor(importer) {
         super(importer, importer.subDocument);
         this.nestedGroupLevel = 1;
     }
-    get destinationType() { return DestinationType.FieldSubDestination; }
     createClone() {
         const clone = this.createInstance();
         clone.nestedGroupLevel = this.nestedGroupLevel;

package/lib/common/formats/rtf/import/destination/fields/table-content-field-destination.js

@@ -2,13 +2,13 @@ import { DestinationType } from '../utils/destination-type';
 import { TCFieldState } from './enums';
 import { FieldSubDestination } from './field-sub-destination';
 export class TableContentFieldDestination extends FieldSubDestination {
+    get destinationType() { return DestinationType.TableContentFieldDestination; }
     constructor(importer, createField) {
         super(importer);
         if (!createField)
             return;
         this.insertTextCore(TableContentFieldDestination.tcFieldName);
     }
-    get destinationType() { return DestinationType.TableContentFieldDestination; }
     tableOfContentsEntryLevelNumberKeyword(parameterValue, hasParameter) {
         this.closeQuotes();
         super.tableOfContentsEntryLevelNumberKeyword(parameterValue, hasParameter);