devexpress-richedit 24.1.5-build-24204-0102 → 24.1.5-build-24211-0105

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

@@ -36,7 +36,7 @@ export class HtmlTableTagImporter extends HtmlTagImporterBase {
         if (!(tbl.width.type == TableWidthUnitType.ModelUnits && tbl.width.value > 0))
             if (!ListUtils.unsafeAnyOf(this.rows, (row) => ListUtils.unsafeAnyOf(row.cells, (cell) => cell.preferredWidth.type == TableWidthUnitType.ModelUnits && cell.preferredWidth.value > 0))) {
                 tbl.width.type = TableWidthUnitType.FiftiethsOfPercent;
-                tbl.width.value = 100 * TableWidthUnit.MUTLIPLIER_FOR_PERCENTS;
+                tbl.width.value = 100 * TableWidthUnit.MULTIPLIER_FOR_PERCENTS;
             }
         this.importer.importedTablesInfo.push(tbl);
     }

package/lib/common/formats/html/import/utils/paragraph-properties-utils.d.ts

@@ -4,7 +4,7 @@ export declare class HtmlImporterMaskedParagraphProperties {
     private result;
     private elementStyle;
     private element;
-    import(colorProvider: ColorProvider, element: HTMLElement, isTableCellTag: boolean): MaskedParagraphProperties;
+    import(colorProvider: ColorProvider, element: HTMLElement, isTableCellTag?: boolean): MaskedParagraphProperties;
     private importAlignment;
     private importFirstLineIndent;
     private importLeftIndent;
@@ -13,7 +13,6 @@ export declare class HtmlImporterMaskedParagraphProperties {
     private importSpacingAfter;
     private importBackColor;
     private importLineSpacing;
-    private setSpacingAsMultiple;
     private importTopBorder;
     private importRightBorder;
     private importBottomBorder;

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

@@ -1,17 +1,14 @@
-import { Errors } from '@devexpress/utils/lib/errors';
 import { AttrUtils } from '@devexpress/utils/lib/utils/attr';
 import { DomUtils } from '@devexpress/utils/lib/utils/dom';
-import { MathUtils } from '@devexpress/utils/lib/utils/math';
 import { ColorUtils } from '@devexpress/utils/lib/utils/color';
 import { MapCreator } from '../../../../utils/map-creator';
 import { BorderLineStyle } from '../../../../model/borders/enums';
-import { MaskedParagraphProperties, ParagraphAlignment, ParagraphFirstLineIndent, ParagraphLineSpacingType, ParagraphPropertiesMask } from '../../../../model/paragraph/paragraph-properties';
-import { TableWidthUnit, TableWidthUnitType } from '../../../../model/tables/secondary-structures/table-units';
+import { MaskedParagraphProperties, ParagraphAlignment, ParagraphFirstLineIndent, ParagraphPropertiesMask, } from '../../../../model/paragraph/paragraph-properties';
 import { ShadingInfo } from '../../../../model/shadings/shading-info';
 import { ColorModelInfo } from '../../../../model/color/color-model-info';
 import { HtmlImportUtils } from './utils';
 export class HtmlImporterMaskedParagraphProperties {
-    import(colorProvider, element, isTableCellTag) {
+    import(colorProvider, element, isTableCellTag = false) {
         this.result = new MaskedParagraphProperties();
         this.element = element;
         this.elementStyle = element.style;
@@ -92,36 +89,10 @@ export class HtmlImporterMaskedParagraphProperties {
         this.result.setUseValue(ParagraphPropertiesMask.UseBeforeAutoSpacing, true);
         this.result.setUseValue(ParagraphPropertiesMask.UseAfterAutoSpacing, true);
         const stringLineHeight = this.elementStyle.lineHeight;
-        const height = HtmlImportUtils.getTableWidthUnit(stringLineHeight);
-        if (height == null) {
-            this.setSpacingAsMultiple(parseFloat(stringLineHeight));
-            return;
-        }
-        switch (height.type) {
-            case TableWidthUnitType.FiftiethsOfPercent:
-                this.setSpacingAsMultiple(height.value / TableWidthUnit.MAX_PERCENT_WIDTH);
-                break;
-            case TableWidthUnitType.ModelUnits:
-                this.result.lineSpacing = height.value;
-                this.result.lineSpacingType = this.elementStyle["mso-line-height-rule"] == "exactly" ?
-                    ParagraphLineSpacingType.Exactly :
-                    ParagraphLineSpacingType.AtLeast;
-                break;
-            case TableWidthUnitType.Nil:
-            case TableWidthUnitType.Auto:
-                break;
-            default: throw new Error(Errors.InternalException);
-        }
-    }
-    setSpacingAsMultiple(multipleValue) {
-        if (!multipleValue || isNaN(multipleValue))
-            return;
-        this.result.lineSpacing = multipleValue;
-        this.result.lineSpacingType =
-            MathUtils.numberCloseTo(multipleValue, 1.5) ? ParagraphLineSpacingType.Sesquialteral :
-                (MathUtils.numberCloseTo(multipleValue, 2) ? ParagraphLineSpacingType.Double :
-                    (MathUtils.numberCloseTo(multipleValue, 1) ? ParagraphLineSpacingType.Single :
-                        ParagraphLineSpacingType.Multiple));
+        const lineHeightRule = this.elementStyle["mso-line-height-rule"];
+        const lineSpacing = HtmlImportUtils.getLineSpacing(stringLineHeight, lineHeightRule);
+        this.result.lineSpacing = lineSpacing.value;
+        this.result.lineSpacingType = lineSpacing.type;
     }
     importTopBorder(colorProvider, calculatedStyle) {
         const borderTopInfo = HtmlImportUtils.getBorderInfo(colorProvider, calculatedStyle.borderTopWidth, calculatedStyle.borderTopStyle, calculatedStyle.borderTopColor);

package/lib/common/formats/html/import/utils/utils.d.ts

@@ -3,6 +3,7 @@ import { TableBordersBase } from '../../../../model/borders/table-border-base';
 import { ColorProvider } from '../../../../model/color/color-provider';
 import { IMaskedProperties } from '../../../../model/interfaces';
 import { TableWidthUnit } from '../../../../model/tables/secondary-structures/table-units';
+import { LineSpacingUnit } from '../../../../../common/model/paragraph/paragraph-properties';
 export declare class HtmlImportUtils {
     static getTableWidthUnit(stringValue: string): TableWidthUnit;
     static getValueInTwips(stringValue: string): number;
@@ -13,4 +14,6 @@ export declare class HtmlImportUtils {
     static getPropertyByMap<T>(map: {
         [key: string]: T;
     }, elementBy: string, defaultValue: T): T;
+    static getLineSpacing(value: string, lineHeightRule?: string): LineSpacingUnit;
+    private static getLineSpacingAsMultiple;
 }

package/lib/common/formats/html/import/utils/utils.js

@@ -5,6 +5,9 @@ import { ColorHelper } from '../../../../model/color/color';
 import { TableWidthUnit, TableWidthUnitType } from '../../../../model/tables/secondary-structures/table-units';
 import { UnitConverter } from '@devexpress/utils/lib/class/unit-converter';
 import { ColorUtils } from '@devexpress/utils/lib/utils/color';
+import { LineSpacingUnit } from '../../../../../common/model/paragraph/paragraph-properties';
+import { MathUtils } from '@devexpress/utils/lib/utils/math';
+import { Errors } from '@devexpress/utils/lib/errors';
 export class HtmlImportUtils {
     static getTableWidthUnit(stringValue) {
         if (!stringValue)
@@ -16,7 +19,7 @@ export class HtmlImportUtils {
             return null;
         switch (unitType) {
             case "%":
-                return new TableWidthUnit().init(numberValue * TableWidthUnit.MUTLIPLIER_FOR_PERCENTS, TableWidthUnitType.FiftiethsOfPercent);
+                return new TableWidthUnit().init(numberValue * TableWidthUnit.MULTIPLIER_FOR_PERCENTS, TableWidthUnitType.FiftiethsOfPercent);
             case "px":
                 return new TableWidthUnit().init(UnitConverter.pixelsToTwips(numberValue), TableWidthUnitType.ModelUnits);
             case "in":
@@ -72,8 +75,54 @@ export class HtmlImportUtils {
         HtmlImportUtils.importBorder(colorProvider, props, borders, leftMask, (brds, brd) => brds.left = brd, style.borderLeftWidth, style.borderLeftStyle, style.borderLeftColor);
     }
     static getPropertyByMap(map, elementBy, defaultValue) {
-        const mapedElement = map[elementBy];
-        return mapedElement !== undefined ? mapedElement : defaultValue;
+        const mappedElement = map[elementBy];
+        return mappedElement !== undefined ? mappedElement : defaultValue;
+    }
+    static getLineSpacing(value, lineHeightRule = '') {
+        if (value.toLowerCase() === 'normal')
+            return LineSpacingUnit.createSingle();
+        if (/^\d+(\.\d+)?$/.test(value)) {
+            const numberValue = parseFloat(value);
+            switch (numberValue) {
+                case 1:
+                    return LineSpacingUnit.createSingle();
+                case 1.5:
+                    return LineSpacingUnit.createSesquialteral();
+                case 2:
+                    return LineSpacingUnit.createDouble();
+                default:
+                    return LineSpacingUnit.createMultiple(numberValue);
+            }
+        }
+        const height = HtmlImportUtils.getTableWidthUnit(value);
+        if (height == null)
+            return HtmlImportUtils.getLineSpacingAsMultiple(parseFloat(value));
+        switch (height.type) {
+            case TableWidthUnitType.FiftiethsOfPercent:
+                return this.getLineSpacingAsMultiple(height.value / TableWidthUnit.MAX_PERCENT_WIDTH);
+            case TableWidthUnitType.ModelUnits:
+                if (lineHeightRule === 'exactly')
+                    return LineSpacingUnit.createExactly(height.value);
+                else
+                    return LineSpacingUnit.createAtLeast(height.value);
+            case TableWidthUnitType.Nil:
+            case TableWidthUnitType.Auto:
+                return LineSpacingUnit.createSingle();
+            default:
+                throw new Error(Errors.InternalException);
+        }
+    }
+    static getLineSpacingAsMultiple(multipleValue) {
+        if (!multipleValue || isNaN(multipleValue))
+            return LineSpacingUnit.createSingle();
+        if (MathUtils.numberCloseTo(multipleValue, 1))
+            return LineSpacingUnit.createSingle();
+        else if (MathUtils.numberCloseTo(multipleValue, 1.5))
+            return LineSpacingUnit.createSesquialteral();
+        else if (MathUtils.numberCloseTo(multipleValue, 2))
+            return LineSpacingUnit.createDouble();
+        else
+            return LineSpacingUnit.createMultiple(multipleValue);
     }
 }
 HtmlImportUtils.MapBorderStyleToType = new MapCreator()

package/lib/common/formats/rtf/import/destination/numbering-list/destination-old-paragraph-numbering-base.js

@@ -8,6 +8,11 @@ import { TextBeforeDestination } from '../base/text-before-destination';
 import { DestinationSubDocument } from '../sub-document/destination-sub-document';
 import { DestinationType } from '../utils/destination-type';
 export class DestinationOldParagraphNumberingBase extends DestinationBase {
+    constructor() {
+        super(...arguments);
+        this.textBefore = '';
+        this.textAfter = '';
+    }
     get destinationType() { return DestinationType.DestinationOldParagraphNumberingBase; }
     get controlCharHT() { return null; }
     static setNumberingListFormat(importer, format) {

package/lib/common/formats/rtf/import/destination/numbering-list/destination-old-paragraph-numbering.js

@@ -110,6 +110,8 @@ export class DestinationOldParagraphNumbering extends DestinationOldParagraphNum
             const levelInfo = this.importer.importers.numbering.oldListLevelInfoCollection.getByIndex(i + 1);
             const level = abstractNumberingList.levels[i];
             const firstLineIndent = levelInfo.indent;
+            const listLevelProperties = level.getListLevelProperties().clone();
+            level.setListLevelProperties(listLevelProperties);
             this.setFirstLineIndent(abstractNumberingList.levels[i], firstLineIndent);
             level.getCharacterProperties().copyFrom(this.importer.importers.character.characterFormatting.coreProperties);
             let formatString = `${levelInfo.textBefore}{${i}}${levelInfo.textAfter}`;
@@ -128,6 +130,8 @@ export class DestinationOldParagraphNumbering extends DestinationOldParagraphNum
         documentModel.abstractNumberingLists.push(abstractNumberingList);
         for (let i = 0; i < abstractNumberingList.levels.length; i++) {
             const level = abstractNumberingList.levels[i];
+            const listLevelProperties = level.getListLevelProperties().clone();
+            level.setListLevelProperties(listLevelProperties);
             level.getCharacterProperties().copyFrom(this.importer.importers.character.characterFormatting.coreProperties);
             level.getListLevelProperties().format = NumberingFormat.Bullet;
             const firstLineIndent = levelOffset * i + this.importer.importers.paragraph.paragraphFormatting.coreProperties.firstLineIndent;
@@ -148,6 +152,8 @@ export class DestinationOldParagraphNumbering extends DestinationOldParagraphNum
             documentModel.abstractNumberingLists.push(abstractNumberingList);
             for (let i = 0; i < abstractNumberingList.levels.length; i++) {
                 const level = abstractNumberingList.levels[i];
+                const listLevelProperties = level.getListLevelProperties().clone();
+                level.setListLevelProperties(listLevelProperties);
                 level.getCharacterProperties().copyFrom(this.importer.importers.character.characterFormatting.coreProperties);
                 const firstLineIndent = this.importer.importers.paragraph.paragraphFormatting.coreProperties.firstLineIndent + 150 * i;
                 this.setFirstLineIndent(level, firstLineIndent);
@@ -258,7 +264,9 @@ export class DestinationOldParagraphNumbering extends DestinationOldParagraphNum
             return this.multiLevelListIndex >= NumberingListIndexConstants.minValue;
     }
     areSameInfo(existingListLevelInfo, rtfOldListLevelInfo) {
-        return existingListLevelInfo.textAfter == rtfOldListLevelInfo.textAfter && existingListLevelInfo.textBefore == rtfOldListLevelInfo.textBefore;
+        return existingListLevelInfo.textAfter === rtfOldListLevelInfo.textAfter
+            && existingListLevelInfo.textBefore === rtfOldListLevelInfo.textBefore
+            && existingListLevelInfo.listLevelProperties.format === rtfOldListLevelInfo.listLevelProperties.format;
     }
     isSimpleList() {
         return this.simpleList;

package/lib/common/formats/rtf/import/keyword-tables/keyword-table-holder.js

@@ -248,6 +248,7 @@ export class KeywordTableHolder {
             .append(characterPropertiesKeywords)
             .get())
             .add(DestinationType.DestinationOldSectionNumberingLevel, paragraphNumberingDescKeywords)
+            .add(DestinationType.DestinationOldParagraphNumbering, paragraphNumberingDescKeywords)
             .add(DestinationType.InfoDestination, new MapCreator()
             .add("password", InfoDestination.onLegacyPasswordHash)
             .add("passwordhash", InfoDestination.onPasswordHash)

package/lib/common/formats/rtf/import/keyword-tables/paragraph-numbering-desc-keywords.js

@@ -1,4 +1,5 @@
 import { MapCreator } from '../../../../utils/map-creator';
+import { DestinationOldParagraphNumbering } from '../destination/numbering-list/destination-old-paragraph-numbering';
 import { DestinationOldParagraphNumberingBase } from '../destination/numbering-list/destination-old-paragraph-numbering-base';
 import { DestinationSubDocument } from '../destination/sub-document/destination-sub-document';
 export const paragraphNumberingDescKeywords = new MapCreator()
@@ -41,4 +42,6 @@ export const paragraphNumberingDescKeywords = new MapCreator()
     .add("pnqr", DestinationOldParagraphNumberingBase.onRightAlignmentKeyword)
     .add("pntxtb", DestinationOldParagraphNumberingBase.onTextBeforeKeyword)
     .add("pntxta", DestinationOldParagraphNumberingBase.onTextAfterKeyword)
+    .add("pnlvlbody", DestinationOldParagraphNumbering.onSimpleNumberingKeyword)
+    .add("pnlvlblt", DestinationOldParagraphNumbering.onBulletedParagraphKeyword)
     .get();

package/lib/common/formats/rtf/import/model/numbering-lists/rtf-old-list-level-info.js

@@ -13,8 +13,17 @@ export class RtfOldListLevelInfo {
         this.indent = 0;
     }
     clone() {
-        return null;
+        const result = new RtfOldListLevelInfo();
+        result.copyFrom(this);
+        return result;
     }
     copyFrom(_obj) {
+        this.skipNumbering = _obj.skipNumbering;
+        this.includeInformationFromPreviousLevel = _obj.includeInformationFromPreviousLevel;
+        this.characterProperties = _obj.characterProperties.clone();
+        this.listLevelProperties = _obj.listLevelProperties.clone();
+        this.textBefore = _obj.textBefore;
+        this.textAfter = _obj.textAfter;
+        this.indent = _obj.indent;
     }
 }

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

@@ -172,9 +172,11 @@ export class SubDocumentInserter {
         for (const targetRow of targetTable.rows) {
             targetRow.properties = this.getTableRowProperties(targetRow.properties);
             targetRow.tablePropertiesException = this.getTableProperties(targetRow.tablePropertiesException);
+            targetRow.conditionalFormatting = targetRow.conditionalFormatting;
             for (const targetCell of targetRow.cells) {
                 targetCell.properties = this.getTableCellProperties(targetCell.properties);
                 targetCell.style = this.getTableCellStyle(targetCell.style);
+                targetCell.conditionalFormatting = targetCell.conditionalFormatting;
             }
         }
         return targetTable;

package/lib/common/model/numbering-lists/numbering-list.js

@@ -84,8 +84,8 @@ export class AbstractNumberingList extends NumberingListBase {
         return this.documentModel.abstractNumberingListsIdProvider.getNextId();
     }
     createLevel(_index) {
-        var characterProperties = MaskedCharacterProperties.createDefault(this.documentModel);
-        var paragraphProperties = MaskedParagraphProperties.createDefault(this.documentModel);
+        const characterProperties = MaskedCharacterProperties.createDefault(this.documentModel);
+        const paragraphProperties = MaskedParagraphProperties.createDefault(this.documentModel);
         return new ListLevel(this.documentModel, characterProperties, paragraphProperties, new ListLevelProperties());
     }
     copyLevelsFrom(levels) {

package/lib/common/model/paragraph/paragraph-properties.d.ts

@@ -138,3 +138,16 @@ export declare class MaskedParagraphProperties extends ParagraphProperties imple
     static createDefault(model: DocumentModel): MaskedParagraphProperties;
     setValue<T>(desc: IParagraphPropertyDescriptor<T>, value: T): void;
 }
+export declare class LineSpacingUnit implements ICloneable<LineSpacingUnit> {
+    value: number;
+    type: ParagraphLineSpacingType;
+    init(value: number, type: ParagraphLineSpacingType): LineSpacingUnit;
+    clone(): LineSpacingUnit;
+    static create(value: number, type: ParagraphLineSpacingType): LineSpacingUnit;
+    static createSingle(): LineSpacingUnit;
+    static createSesquialteral(): LineSpacingUnit;
+    static createDouble(): LineSpacingUnit;
+    static createMultiple(value: number): LineSpacingUnit;
+    static createExactly(value: number): LineSpacingUnit;
+    static createAtLeast(value: number): LineSpacingUnit;
+}

package/lib/common/model/paragraph/paragraph-properties.js

@@ -301,3 +301,34 @@ export class MaskedParagraphProperties extends ParagraphProperties {
         this.setUseValue(desc.maskValue(), true);
     }
 }
+export class LineSpacingUnit {
+    init(value, type) {
+        this.value = value;
+        this.type = type;
+        return this;
+    }
+    clone() {
+        return new LineSpacingUnit().init(this.value, this.type);
+    }
+    static create(value, type) {
+        return new LineSpacingUnit().init(value, type);
+    }
+    static createSingle() {
+        return new LineSpacingUnit().init(1, ParagraphLineSpacingType.Single);
+    }
+    static createSesquialteral() {
+        return new LineSpacingUnit().init(1.5, ParagraphLineSpacingType.Sesquialteral);
+    }
+    static createDouble() {
+        return new LineSpacingUnit().init(2, ParagraphLineSpacingType.Double);
+    }
+    static createMultiple(value) {
+        return new LineSpacingUnit().init(value, ParagraphLineSpacingType.Multiple);
+    }
+    static createExactly(value) {
+        return new LineSpacingUnit().init(value, ParagraphLineSpacingType.Exactly);
+    }
+    static createAtLeast(value) {
+        return new LineSpacingUnit().init(value, ParagraphLineSpacingType.AtLeast);
+    }
+}

package/lib/common/model/tables/main-structures/table-cell.js

@@ -79,12 +79,14 @@ export class TableCell {
         return new TableCellPropertiesMergerShadingInfo().getProperty(this.properties, this.parentRow.parentTable.style, this.conditionalFormatting, defaultTableProperties);
     }
     clone(subDocument, parentRow) {
-        const result = new TableCell(parentRow, subDocument.documentModel.cache.tableCellPropertiesCache.getItem(this.properties));
+        const properties = subDocument.documentModel.cache.tableCellPropertiesCache.getItem(this.properties);
+        const result = new TableCell(parentRow, properties);
         result.preferredWidth = this.preferredWidth.clone();
         result.columnSpan = this.columnSpan;
         result.verticalMerging = this.verticalMerging;
         result.startParagraphPosition = subDocument.positionManager.registerPosition(this.startParagraphPosition.value);
         result.endParagrapPosition = subDocument.positionManager.registerPosition(this.endParagrapPosition.value);
+        result.conditionalFormatting = this.conditionalFormatting;
         return result;
     }
 }

package/lib/common/model/tables/main-structures/table-row.js

@@ -49,7 +49,8 @@ export class TableRow {
         return cells;
     }
     clone(subDocument, parentTable) {
-        const result = new TableRow(parentTable, subDocument.documentModel.cache.tableRowPropertiesCache.getItem(this.properties));
+        const properties = subDocument.documentModel.cache.tableRowPropertiesCache.getItem(this.properties);
+        const result = new TableRow(parentTable, properties);
         result.parentTable = parentTable;
         result.cells = ListUtils.map(this.cells, r => r.clone(subDocument, result));
         result.widthBefore = this.widthBefore.clone();
@@ -58,6 +59,7 @@ export class TableRow {
         result.gridAfter = this.gridAfter;
         result.height = this.height.clone();
         result.tablePropertiesException = this.tablePropertiesException.clone();
+        result.conditionalFormatting = this.conditionalFormatting;
         return result;
     }
 }

package/lib/common/model/tables/secondary-structures/table-units.d.ts

@@ -8,13 +8,13 @@ export declare class TableCustomUnit<ValueTypeVariants> implements IEquatable<Ta
 }
 export declare class TableWidthUnit extends TableCustomUnit<TableWidthUnitType> implements ICloneable<TableWidthUnit> {
     static MAX_PERCENT_WIDTH: number;
-    static MUTLIPLIER_FOR_PERCENTS: number;
+    static MULTIPLIER_FOR_PERCENTS: number;
     static createDefault(): TableWidthUnit;
     static create(value: number, type: TableWidthUnitType): TableWidthUnit;
     init(value: number, type: TableWidthUnitType): TableWidthUnit;
     clone(): TableWidthUnit;
     asNumberNoPercentType(converter: SimpleConverter<number>): number;
-    asNumber(avaliableWidth: number, converter: SimpleConverter<number>): number;
+    asNumber(availableWidth: number, converter: SimpleConverter<number>): number;
     divide(n: number): void;
 }
 export declare class TableHeightUnit extends TableCustomUnit<TableHeightUnitType> implements ICloneable<TableHeightUnit> {

package/lib/common/model/tables/secondary-structures/table-units.js

@@ -40,7 +40,7 @@ export class TableWidthUnit extends TableCustomUnit {
                 return 0;
         }
     }
-    asNumber(avaliableWidth, converter) {
+    asNumber(availableWidth, converter) {
         switch (this.type) {
             case TableWidthUnitType.Nil:
             case TableWidthUnitType.Auto:
@@ -48,7 +48,7 @@ export class TableWidthUnit extends TableCustomUnit {
             case TableWidthUnitType.ModelUnits:
                 return converter(this.value);
             case TableWidthUnitType.FiftiethsOfPercent:
-                return avaliableWidth * this.value / TableWidthUnit.MAX_PERCENT_WIDTH;
+                return availableWidth * this.value / TableWidthUnit.MAX_PERCENT_WIDTH;
         }
     }
     divide(n) {
@@ -57,7 +57,7 @@ export class TableWidthUnit extends TableCustomUnit {
     }
 }
 TableWidthUnit.MAX_PERCENT_WIDTH = 5000;
-TableWidthUnit.MUTLIPLIER_FOR_PERCENTS = 50;
+TableWidthUnit.MULTIPLIER_FOR_PERCENTS = 50;
 export class TableHeightUnit extends TableCustomUnit {
     init(value, type) {
         this.value = Math.floor(value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devexpress-richedit",
-  "version": "24.1.5-build-24204-0102",
+  "version": "24.1.5-build-24211-0105",
   "homepage": "https://www.devexpress.com/",
   "bugs": "https://www.devexpress.com/support/",
   "author": "Developer Express Inc.",
@@ -14,8 +14,8 @@
     "build-nspell": "webpack --mode production --config=bin/nspell.webpack.config.js"
   },
   "peerDependencies": {
-    "devextreme": "24.1.5-build-24202-1936",
-    "devextreme-dist": "24.1.5-build-24202-1936"
+    "devextreme": "24.1.5-build-24209-1937",
+    "devextreme-dist": "24.1.5-build-24209-1937"
   },
   "dependencies": {
     "jszip": "~3.10.1",