devexpress-richedit 24.1.5-build-24204-0102 → 24.1.5-build-24221-1027

package/dist/dx.richedit.js

@@ -13829,6 +13829,37 @@ class MaskedParagraphProperties extends ParagraphProperties {
         this.setUseValue(desc.maskValue(), true);
     }
 }
+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);
+    }
+}
 
 ;// CONCATENATED MODULE: ./src/common/model/history/items/character-properties-history-items.ts
 
@@ -14701,7 +14732,7 @@ class TableWidthUnit extends TableCustomUnit {
                 return 0;
         }
     }
-    asNumber(avaliableWidth, converter) {
+    asNumber(availableWidth, converter) {
         switch (this.type) {
             case TableWidthUnitType.Nil:
             case TableWidthUnitType.Auto:
@@ -14709,7 +14740,7 @@ 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) {
@@ -14718,7 +14749,7 @@ class TableWidthUnit extends TableCustomUnit {
     }
 }
 TableWidthUnit.MAX_PERCENT_WIDTH = 5000;
-TableWidthUnit.MUTLIPLIER_FOR_PERCENTS = 50;
+TableWidthUnit.MULTIPLIER_FOR_PERCENTS = 50;
 class TableHeightUnit extends TableCustomUnit {
     init(value, type) {
         this.value = Math.floor(value);
@@ -17159,8 +17190,8 @@ class AbstractNumberingList extends numbering_list_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) {
@@ -25486,12 +25517,14 @@ 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;
     }
 }
@@ -25548,7 +25581,8 @@ 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 = utils_list.ListUtils.map(this.cells, r => r.clone(subDocument, result));
         result.widthBefore = this.widthBefore.clone();
@@ -25557,6 +25591,7 @@ class TableRow {
         result.gridAfter = this.gridAfter;
         result.height = this.height.clone();
         result.tablePropertiesException = this.tablePropertiesException.clone();
+        result.conditionalFormatting = this.conditionalFormatting;
         return result;
     }
 }
@@ -30944,7 +30979,7 @@ function hexToBase64(hexStr) {
     return hexadecimal_converter_btoa(result.join(""));
 }
 function base64ToHex(base64Str) {
-    for (var i = 0, bin = hexadecimal_converter_atob(base64Str.replace(/[ \r\n]+$/, "")), hex = []; i < bin.length; ++i) {
+    for (var i = 0, bin = atob(base64Str.replace(/[ \r\n]+$/, "")), hex = []; i < bin.length; ++i) {
         var tmp = bin.charCodeAt(i).toString(16);
         if (tmp.length === 1)
             tmp = "0" + tmp;
@@ -30967,7 +31002,7 @@ function hexadecimal_converter_btoa(bin) {
     }
     return base64.join("");
 }
-function hexadecimal_converter_atob(base64) {
+function atob(base64) {
     if (/(=[^=]+|={3,})$/.test(base64))
         throw new Error("String contains an invalid character");
     base64 = base64.replace(/=/g, "");
@@ -41138,9 +41173,11 @@ 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;
@@ -62357,9 +62394,18 @@ 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;
     }
 }
 
@@ -64599,6 +64645,11 @@ const documentPropertiesKeywords = new MapCreator()
 
 
 class DestinationOldParagraphNumberingBase extends DestinationBase {
+    constructor() {
+        super(...arguments);
+        this.textBefore = '';
+        this.textAfter = '';
+    }
     get destinationType() { return DestinationType.DestinationOldParagraphNumberingBase; }
     get controlCharHT() { return null; }
     static setNumberingListFormat(importer, format) {
@@ -64756,10 +64807,296 @@ class DestinationOldParagraphNumberingBase extends DestinationBase {
     }
 }
 
+;// CONCATENATED MODULE: ./src/common/formats/rtf/import/destination/numbering-list/destination-old-paragraph-numbering.ts
+
+
+
+
+
+
+
+
+
+class DestinationOldParagraphNumbering extends DestinationOldParagraphNumberingBase {
+    constructor(importer) {
+        super(importer);
+        this.oldLevelNumber = -1;
+        if (importer.importers.numbering.oldListLevelInfo == null)
+            importer.importers.numbering.oldListLevelInfo = new RtfOldListLevelInfo();
+        importer.importers.character.characterFormatting.coreProperties.setAllUse();
+        this.multiLevelListIndex = NumberingListIndexConstants.listIndexNotSetted;
+        this.simpleListIndex = NumberingListIndexConstants.listIndexNotSetted;
+    }
+    get destinationType() { return DestinationType.DestinationOldParagraphNumbering; }
+    static onParagraphLevelKeyword(importer, parameterValue, hasParameter) {
+        if (hasParameter && parameterValue == 10) {
+            DestinationOldParagraphNumbering.onSimpleNumberingKeyword(importer, 0, false);
+            return;
+        }
+        importer.destination.oldLevelNumber = parameterValue;
+        importer.destination.simpleList = false;
+    }
+    static onBulletedParagraphKeyword(importer, _parameterValue, _hasParameter) {
+        importer.importers.numbering.oldListLevelInfo.listLevelProperties.format = NumberingFormat.Bullet;
+    }
+    static onSimpleNumberingKeyword(importer, _parameterValue, _hasParameter) {
+        importer.destination.simpleList = true;
+    }
+    static onSkipNumberingKeyword(importer, _parameterValue, _hasParameter) {
+        importer.importers.numbering.oldListLevelInfo.skipNumbering = true;
+    }
+    static onListOverrideKeyword(importer, parameterValue, _hasParameter) {
+        const index = importer.importers.numbering.listOverrideIndexToNumberingListIndexMap[parameterValue];
+        if (index !== undefined)
+            importer.importers.paragraph.paragraphFormatting.paragraphListInfo.numberingListIndex = index;
+        importer.destination.explicitNumberingListIndex = true;
+    }
+    static onListLevelKeyword(importer, parameterValue, _hasParameter) {
+        importer.importers.paragraph.paragraphFormatting.paragraphListInfo.listLevelIndex = parameterValue;
+        importer.destination.explicitListLevelIndex = true;
+    }
+    createClone() {
+        const result = new DestinationOldParagraphNumbering(this.importer);
+        return result;
+    }
+    beforePopRtfState() {
+        super.beforePopRtfState();
+        if (this.shouldCreateNewList()) {
+            this.createNewList();
+        }
+        else {
+            this.skipNumbering = this.isSkipNumbering();
+            this.simpleListIndex = this.importer.importers.numbering.currentOldSimpleListIndex;
+            this.multiLevelListIndex = this.importer.importers.numbering.currentOldMultiLevelListIndex;
+        }
+        if (this.explicitNumberingListIndex && this.explicitListLevelIndex) {
+            this.listLevelIndex = this.importer.importers.paragraph.paragraphFormatting.listLevelIndex;
+            this.numberingListIndex = this.importer.importers.paragraph.paragraphFormatting.numberingListIndex;
+        }
+        else
+            this.listLevelIndex = this.oldLevelNumber >= 0 ? this.oldLevelNumber - 1 : 0;
+    }
+    afterPopRtfState() {
+        super.afterPopRtfState();
+        this.importer.importers.paragraph.paragraphFormatting.paragraphListInfo.listLevelIndex = this.listLevelIndex;
+        const actualNumberingListIndex = this.isSimpleList() ? this.simpleListIndex : this.multiLevelListIndex;
+        this.importer.importers.numbering.currentOldListSkipNumbering = this.skipNumbering;
+        if (this.isOldNumberingListCreated) {
+            this.importer.importers.numbering.currentOldMultiLevelListIndex = this.multiLevelListIndex;
+            this.importer.importers.numbering.currentOldSimpleListIndex = this.simpleListIndex;
+            this.importer.importers.numbering.currentOldSimpleList = this.simpleList;
+        }
+        if (this.explicitListLevelIndex && this.explicitNumberingListIndex) {
+            this.importer.importers.paragraph.paragraphFormatting.paragraphListInfo.numberingListIndex = this.numberingListIndex;
+            this.importer.importers.paragraph.paragraphFormatting.paragraphListInfo.listLevelIndex = this.listLevelIndex;
+        }
+        else
+            this.importer.importers.paragraph.paragraphFormatting.paragraphListInfo.numberingListIndex = !this.skipNumbering ?
+                actualNumberingListIndex : NumberingListIndexConstants.noNumberingList;
+    }
+    createNewList() {
+        const oldListLevelInfo = this.importer.importers.numbering.oldListLevelInfo;
+        if (this.simpleList) {
+            this.createSimpleNumberingListLevels();
+            this.simpleListIndex = this.importer.documentModel.numberingLists.length - 1;
+            this.multiLevelListIndex = this.importer.importers.numbering.currentOldMultiLevelListIndex;
+        }
+        else if (oldListLevelInfo.listLevelProperties.format == NumberingFormat.Bullet) {
+            this.createBulletedListLevels();
+            this.multiLevelListIndex = this.importer.documentModel.numberingLists.length - 1;
+            this.simpleListIndex = this.importer.importers.numbering.currentOldSimpleListIndex;
+        }
+        else {
+            this.createMultilevelListLevels();
+            this.multiLevelListIndex = this.importer.documentModel.numberingLists.length - 1;
+            this.simpleListIndex = this.importer.importers.numbering.currentOldSimpleListIndex;
+        }
+    }
+    createMultilevelListLevels() {
+        const documentModel = this.importer.documentModel;
+        const abstractNumberingList = new AbstractNumberingList(documentModel);
+        documentModel.abstractNumberingLists.push(abstractNumberingList);
+        for (let i = 0; i < abstractNumberingList.levels.length; i++) {
+            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}`;
+            if (i > 0 && levelInfo.includeInformationFromPreviousLevel)
+                formatString = abstractNumberingList.levels[i - 1].getListLevelProperties().displayFormatString + formatString;
+            this.setDisplayFormatString(level, formatString);
+            this.setLegacyProperties(level, 0, 0);
+        }
+        this.isOldNumberingListCreated = true;
+        documentModel.numberingLists.push(new NumberingList(documentModel, documentModel.abstractNumberingLists.length - 1));
+    }
+    createBulletedListLevels() {
+        const documentModel = this.importer.documentModel;
+        const levelOffset = unit_converter/* UnitConverter */.u.documentsToTwips(150);
+        const abstractNumberingList = new AbstractNumberingList(documentModel);
+        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;
+            this.setFirstLineIndent(level, firstLineIndent);
+            this.setDisplayFormatString(level, this.importer.importers.numbering.oldListLevelInfo.textBefore + this.importer.importers.numbering.oldListLevelInfo.textAfter);
+            this.setTemplateCode(level, NumberingHelper.generateNewTemplateCode(documentModel));
+            this.setLegacyProperties(level, 0, 0);
+        }
+        this.isOldNumberingListCreated = true;
+        documentModel.numberingLists.push(new NumberingList(documentModel, documentModel.abstractNumberingLists.length - 1));
+    }
+    createSimpleNumberingListLevels() {
+        const documentModel = this.importer.documentModel;
+        const addResult = this.shouldCreateNewAbstractSimpleList();
+        const existingNumberingListIndex = addResult.existingNumberingListIndex;
+        if (addResult.isSecceed) {
+            const abstractNumberingList = new AbstractNumberingList(documentModel);
+            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);
+                this.setDisplayFormatString(level, `${this.importer.importers.numbering.oldListLevelInfo.textBefore}{${i}}${this.importer.importers.numbering.oldListLevelInfo.textAfter}`);
+                this.setTemplateCode(level, NumberingHelper.generateNewTemplateCode(documentModel));
+                this.setLegacyProperties(level, 0, 0);
+                const start = this.importer.importers.numbering.oldListLevelInfo.listLevelProperties.start;
+                if (start > 0)
+                    level.getListLevelProperties().start = start;
+                const numberingFormat = this.importer.importers.numbering.oldListLevelInfo.listLevelProperties.format;
+                if (numberingFormat != NumberingFormat.Decimal)
+                    level.getListLevelProperties().format = numberingFormat;
+            }
+            this.isOldNumberingListCreated = true;
+            documentModel.numberingLists.push(new NumberingList(documentModel, documentModel.abstractNumberingLists.length - 1));
+            this.importer.importers.numbering.numberingListToOldListLevelInfoMap[documentModel.numberingLists.length - 1] = this.importer.importers.numbering.oldListLevelInfo.clone();
+        }
+        else {
+            const abstractNumberingListIndex = documentModel.numberingLists[existingNumberingListIndex].abstractNumberingListIndex;
+            const prevNumberingList = utils_list.ListUtils.last(documentModel.numberingLists);
+            const newList = new NumberingList(documentModel, abstractNumberingListIndex);
+            const level = newList.levels[0];
+            const start = this.importer.importers.numbering.oldListLevelInfo.listLevelProperties.start;
+            if (start >= 0)
+                level.getListLevelProperties().start = start;
+            const numberingFormat = this.importer.importers.numbering.oldListLevelInfo.listLevelProperties.format;
+            if (numberingFormat != NumberingFormat.Decimal)
+                level.getListLevelProperties().format = numberingFormat;
+            if (prevNumberingList != null && prevNumberingList.levels[0].getListLevelProperties().format != level.getListLevelProperties().format)
+                level.overrideStart = true;
+            level.getCharacterProperties().copyFrom(this.importer.importers.character.characterFormatting.coreProperties);
+            const firstLineIndent = this.importer.importers.paragraph.paragraphFormatting.coreProperties.firstLineIndent;
+            this.setFirstLineIndent(level, firstLineIndent);
+            this.setDisplayFormatString(level, `${this.importer.importers.numbering.oldListLevelInfo.textBefore}{${0}}${this.importer.importers.numbering.oldListLevelInfo.textAfter}`);
+            this.setTemplateCode(level, NumberingHelper.generateNewTemplateCode(documentModel));
+            this.setLegacyProperties(level, 0, 0);
+            documentModel.numberingLists.push(newList);
+            this.importer.importers.numbering.numberingListToOldListLevelInfoMap[documentModel.numberingLists.length - 1] = this.importer.importers.numbering.oldListLevelInfo.clone();
+        }
+    }
+    shouldCreateNewAbstractSimpleList() {
+        let existingNumberingListIndex;
+        if (this.importer.importers.numbering.currentOldSimpleList &&
+            this.importer.importers.numbering.currentOldSimpleListIndex >= NumberingListIndexConstants.minValue) {
+            existingNumberingListIndex = this.importer.importers.numbering.currentOldSimpleListIndex;
+            let oldListLevelInfo = this.importer.importers.numbering.numberingListToOldListLevelInfoMap[existingNumberingListIndex];
+            if (!oldListLevelInfo)
+                return { isSecceed: true, existingNumberingListIndex: existingNumberingListIndex };
+            return { isSecceed: !this.areSameInfo(oldListLevelInfo, this.importer.importers.numbering.oldListLevelInfo), existingNumberingListIndex: existingNumberingListIndex };
+        }
+        existingNumberingListIndex = NumberingListIndexConstants.listIndexNotSetted;
+        let prevParagraphIndex = this.importer.subDocument.paragraphs.length - 1 - 1;
+        for (; prevParagraphIndex >= 0; prevParagraphIndex--) {
+            const prevParagraph = this.importer.subDocument.paragraphs[prevParagraphIndex];
+            if (!prevParagraph.isInList()) {
+                if (prevParagraph.numberingListIndex == NumberingListIndexConstants.noNumberingList)
+                    continue;
+                return { isSecceed: true, existingNumberingListIndex: existingNumberingListIndex };
+            }
+            const numberingListIndex = prevParagraph.numberingListIndex;
+            const prevOldListLevelInfo = this.importer.importers.numbering.numberingListToOldListLevelInfoMap[numberingListIndex];
+            if (!prevOldListLevelInfo)
+                return { isSecceed: true, existingNumberingListIndex: existingNumberingListIndex };
+            if (!this.areSameInfo(prevOldListLevelInfo, this.importer.importers.numbering.oldListLevelInfo))
+                return { isSecceed: true, existingNumberingListIndex: existingNumberingListIndex };
+            existingNumberingListIndex = numberingListIndex;
+            return { isSecceed: false, existingNumberingListIndex: existingNumberingListIndex };
+        }
+        return { isSecceed: true, existingNumberingListIndex: existingNumberingListIndex };
+    }
+    setLegacyProperties(level, legacyIndent, legacySpace) {
+        level.getListLevelProperties().legacy = true;
+        level.getListLevelProperties().legacySpace = legacyIndent;
+        level.getListLevelProperties().legacyIndent = legacySpace;
+    }
+    setDisplayFormatString(level, displayFormatString) {
+        level.getListLevelProperties().displayFormatString = displayFormatString;
+    }
+    setFirstLineIndent(level, lineIndent) {
+        level.getParagraphProperties().leftIndent = lineIndent;
+    }
+    setTemplateCode(level, templateCode) {
+        level.getListLevelProperties().templateCode = templateCode;
+    }
+    shouldCreateNewList() {
+        if (this.isNewListLevelInfoPresent())
+            return false;
+        if (this.isMultilevelList())
+            return (!this.sectionMultiLevelListCreated());
+        if (this.isSimpleList())
+            return true;
+        if (this.isSkipNumbering())
+            return false;
+        return true;
+    }
+    isNewListLevelInfoPresent() {
+        if (this.explicitListLevelIndex && this.explicitNumberingListIndex)
+            return true;
+        if (this.isSimpleList()) {
+            if (this.simpleListIndex < NumberingListIndexConstants.minValue)
+                return false;
+            const existingListLevelInfo = this.importer.importers.numbering.numberingListToOldListLevelInfoMap[this.simpleListIndex];
+            if (!existingListLevelInfo)
+                return false;
+            return this.areSameInfo(existingListLevelInfo, this.importer.importers.numbering.oldListLevelInfo);
+        }
+        else
+            return this.multiLevelListIndex >= NumberingListIndexConstants.minValue;
+    }
+    areSameInfo(existingListLevelInfo, rtfOldListLevelInfo) {
+        return existingListLevelInfo.textAfter === rtfOldListLevelInfo.textAfter
+            && existingListLevelInfo.textBefore === rtfOldListLevelInfo.textBefore
+            && existingListLevelInfo.listLevelProperties.format === rtfOldListLevelInfo.listLevelProperties.format;
+    }
+    isSimpleList() {
+        return this.simpleList;
+    }
+    isMultilevelList() {
+        return (this.oldLevelNumber >= 0) && !this.simpleList;
+    }
+    sectionMultiLevelListCreated() {
+        return this.importer.importers.numbering.currentOldMultiLevelListIndex >= NumberingListIndexConstants.minValue;
+    }
+    isSkipNumbering() {
+        return this.importer.importers.numbering.oldListLevelInfo.skipNumbering;
+    }
+}
+
 ;// CONCATENATED MODULE: ./src/common/formats/rtf/import/keyword-tables/paragraph-numbering-desc-keywords.ts
 
 
 
+
 const paragraphNumberingDescKeywords = new MapCreator()
     .add("pncard", DestinationOldParagraphNumberingBase.onCardinalKeyword)
     .add("pndec", DestinationOldParagraphNumberingBase.onDecimalKeyword)
@@ -64800,6 +65137,8 @@ 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();
 
 ;// CONCATENATED MODULE: ./src/common/formats/rtf/import/keyword-tables/paragraph-properties.ts
@@ -65073,283 +65412,6 @@ class DocumentVariableDestination extends StringValueDestination {
     }
 }
 
-;// CONCATENATED MODULE: ./src/common/formats/rtf/import/destination/numbering-list/destination-old-paragraph-numbering.ts
-
-
-
-
-
-
-
-
-
-class DestinationOldParagraphNumbering extends DestinationOldParagraphNumberingBase {
-    constructor(importer) {
-        super(importer);
-        this.oldLevelNumber = -1;
-        if (importer.importers.numbering.oldListLevelInfo == null)
-            importer.importers.numbering.oldListLevelInfo = new RtfOldListLevelInfo();
-        importer.importers.character.characterFormatting.coreProperties.setAllUse();
-        this.multiLevelListIndex = NumberingListIndexConstants.listIndexNotSetted;
-        this.simpleListIndex = NumberingListIndexConstants.listIndexNotSetted;
-    }
-    get destinationType() { return DestinationType.DestinationOldParagraphNumbering; }
-    static onParagraphLevelKeyword(importer, parameterValue, hasParameter) {
-        if (hasParameter && parameterValue == 10) {
-            DestinationOldParagraphNumbering.onSimpleNumberingKeyword(importer, 0, false);
-            return;
-        }
-        importer.destination.oldLevelNumber = parameterValue;
-        importer.destination.simpleList = false;
-    }
-    static onBulletedParagraphKeyword(importer, _parameterValue, _hasParameter) {
-        importer.importers.numbering.oldListLevelInfo.listLevelProperties.format = NumberingFormat.Bullet;
-    }
-    static onSimpleNumberingKeyword(importer, _parameterValue, _hasParameter) {
-        importer.destination.simpleList = true;
-    }
-    static onSkipNumberingKeyword(importer, _parameterValue, _hasParameter) {
-        importer.importers.numbering.oldListLevelInfo.skipNumbering = true;
-    }
-    static onListOverrideKeyword(importer, parameterValue, _hasParameter) {
-        const index = importer.importers.numbering.listOverrideIndexToNumberingListIndexMap[parameterValue];
-        if (index !== undefined)
-            importer.importers.paragraph.paragraphFormatting.paragraphListInfo.numberingListIndex = index;
-        importer.destination.explicitNumberingListIndex = true;
-    }
-    static onListLevelKeyword(importer, parameterValue, _hasParameter) {
-        importer.importers.paragraph.paragraphFormatting.paragraphListInfo.listLevelIndex = parameterValue;
-        importer.destination.explicitListLevelIndex = true;
-    }
-    createClone() {
-        const result = new DestinationOldParagraphNumbering(this.importer);
-        return result;
-    }
-    beforePopRtfState() {
-        super.beforePopRtfState();
-        if (this.shouldCreateNewList()) {
-            this.createNewList();
-        }
-        else {
-            this.skipNumbering = this.isSkipNumbering();
-            this.simpleListIndex = this.importer.importers.numbering.currentOldSimpleListIndex;
-            this.multiLevelListIndex = this.importer.importers.numbering.currentOldMultiLevelListIndex;
-        }
-        if (this.explicitNumberingListIndex && this.explicitListLevelIndex) {
-            this.listLevelIndex = this.importer.importers.paragraph.paragraphFormatting.listLevelIndex;
-            this.numberingListIndex = this.importer.importers.paragraph.paragraphFormatting.numberingListIndex;
-        }
-        else
-            this.listLevelIndex = this.oldLevelNumber >= 0 ? this.oldLevelNumber - 1 : 0;
-    }
-    afterPopRtfState() {
-        super.afterPopRtfState();
-        this.importer.importers.paragraph.paragraphFormatting.paragraphListInfo.listLevelIndex = this.listLevelIndex;
-        const actualNumberingListIndex = this.isSimpleList() ? this.simpleListIndex : this.multiLevelListIndex;
-        this.importer.importers.numbering.currentOldListSkipNumbering = this.skipNumbering;
-        if (this.isOldNumberingListCreated) {
-            this.importer.importers.numbering.currentOldMultiLevelListIndex = this.multiLevelListIndex;
-            this.importer.importers.numbering.currentOldSimpleListIndex = this.simpleListIndex;
-            this.importer.importers.numbering.currentOldSimpleList = this.simpleList;
-        }
-        if (this.explicitListLevelIndex && this.explicitNumberingListIndex) {
-            this.importer.importers.paragraph.paragraphFormatting.paragraphListInfo.numberingListIndex = this.numberingListIndex;
-            this.importer.importers.paragraph.paragraphFormatting.paragraphListInfo.listLevelIndex = this.listLevelIndex;
-        }
-        else
-            this.importer.importers.paragraph.paragraphFormatting.paragraphListInfo.numberingListIndex = !this.skipNumbering ?
-                actualNumberingListIndex : NumberingListIndexConstants.noNumberingList;
-    }
-    createNewList() {
-        const oldListLevelInfo = this.importer.importers.numbering.oldListLevelInfo;
-        if (this.simpleList) {
-            this.createSimpleNumberingListLevels();
-            this.simpleListIndex = this.importer.documentModel.numberingLists.length - 1;
-            this.multiLevelListIndex = this.importer.importers.numbering.currentOldMultiLevelListIndex;
-        }
-        else if (oldListLevelInfo.listLevelProperties.format == NumberingFormat.Bullet) {
-            this.createBulletedListLevels();
-            this.multiLevelListIndex = this.importer.documentModel.numberingLists.length - 1;
-            this.simpleListIndex = this.importer.importers.numbering.currentOldSimpleListIndex;
-        }
-        else {
-            this.createMultilevelListLevels();
-            this.multiLevelListIndex = this.importer.documentModel.numberingLists.length - 1;
-            this.simpleListIndex = this.importer.importers.numbering.currentOldSimpleListIndex;
-        }
-    }
-    createMultilevelListLevels() {
-        const documentModel = this.importer.documentModel;
-        const abstractNumberingList = new AbstractNumberingList(documentModel);
-        documentModel.abstractNumberingLists.push(abstractNumberingList);
-        for (let i = 0; i < abstractNumberingList.levels.length; i++) {
-            const levelInfo = this.importer.importers.numbering.oldListLevelInfoCollection.getByIndex(i + 1);
-            const level = abstractNumberingList.levels[i];
-            const firstLineIndent = levelInfo.indent;
-            this.setFirstLineIndent(abstractNumberingList.levels[i], firstLineIndent);
-            level.getCharacterProperties().copyFrom(this.importer.importers.character.characterFormatting.coreProperties);
-            let formatString = `${levelInfo.textBefore}{${i}}${levelInfo.textAfter}`;
-            if (i > 0 && levelInfo.includeInformationFromPreviousLevel)
-                formatString = abstractNumberingList.levels[i - 1].getListLevelProperties().displayFormatString + formatString;
-            this.setDisplayFormatString(level, formatString);
-            this.setLegacyProperties(level, 0, 0);
-        }
-        this.isOldNumberingListCreated = true;
-        documentModel.numberingLists.push(new NumberingList(documentModel, documentModel.abstractNumberingLists.length - 1));
-    }
-    createBulletedListLevels() {
-        const documentModel = this.importer.documentModel;
-        const levelOffset = unit_converter/* UnitConverter */.u.documentsToTwips(150);
-        const abstractNumberingList = new AbstractNumberingList(documentModel);
-        documentModel.abstractNumberingLists.push(abstractNumberingList);
-        for (let i = 0; i < abstractNumberingList.levels.length; i++) {
-            const level = abstractNumberingList.levels[i];
-            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;
-            this.setFirstLineIndent(level, firstLineIndent);
-            this.setDisplayFormatString(level, this.importer.importers.numbering.oldListLevelInfo.textBefore + this.importer.importers.numbering.oldListLevelInfo.textAfter);
-            this.setTemplateCode(level, NumberingHelper.generateNewTemplateCode(documentModel));
-            this.setLegacyProperties(level, 0, 0);
-        }
-        this.isOldNumberingListCreated = true;
-        documentModel.numberingLists.push(new NumberingList(documentModel, documentModel.abstractNumberingLists.length - 1));
-    }
-    createSimpleNumberingListLevels() {
-        const documentModel = this.importer.documentModel;
-        const addResult = this.shouldCreateNewAbstractSimpleList();
-        const existingNumberingListIndex = addResult.existingNumberingListIndex;
-        if (addResult.isSecceed) {
-            const abstractNumberingList = new AbstractNumberingList(documentModel);
-            documentModel.abstractNumberingLists.push(abstractNumberingList);
-            for (let i = 0; i < abstractNumberingList.levels.length; i++) {
-                const level = abstractNumberingList.levels[i];
-                level.getCharacterProperties().copyFrom(this.importer.importers.character.characterFormatting.coreProperties);
-                const firstLineIndent = this.importer.importers.paragraph.paragraphFormatting.coreProperties.firstLineIndent + 150 * i;
-                this.setFirstLineIndent(level, firstLineIndent);
-                this.setDisplayFormatString(level, `${this.importer.importers.numbering.oldListLevelInfo.textBefore}{${i}}${this.importer.importers.numbering.oldListLevelInfo.textAfter}`);
-                this.setTemplateCode(level, NumberingHelper.generateNewTemplateCode(documentModel));
-                this.setLegacyProperties(level, 0, 0);
-                const start = this.importer.importers.numbering.oldListLevelInfo.listLevelProperties.start;
-                if (start > 0)
-                    level.getListLevelProperties().start = start;
-                const numberingFormat = this.importer.importers.numbering.oldListLevelInfo.listLevelProperties.format;
-                if (numberingFormat != NumberingFormat.Decimal)
-                    level.getListLevelProperties().format = numberingFormat;
-            }
-            this.isOldNumberingListCreated = true;
-            documentModel.numberingLists.push(new NumberingList(documentModel, documentModel.abstractNumberingLists.length - 1));
-            this.importer.importers.numbering.numberingListToOldListLevelInfoMap[documentModel.numberingLists.length - 1] = this.importer.importers.numbering.oldListLevelInfo.clone();
-        }
-        else {
-            const abstractNumberingListIndex = documentModel.numberingLists[existingNumberingListIndex].abstractNumberingListIndex;
-            const prevNumberingList = utils_list.ListUtils.last(documentModel.numberingLists);
-            const newList = new NumberingList(documentModel, abstractNumberingListIndex);
-            const level = newList.levels[0];
-            const start = this.importer.importers.numbering.oldListLevelInfo.listLevelProperties.start;
-            if (start >= 0)
-                level.getListLevelProperties().start = start;
-            const numberingFormat = this.importer.importers.numbering.oldListLevelInfo.listLevelProperties.format;
-            if (numberingFormat != NumberingFormat.Decimal)
-                level.getListLevelProperties().format = numberingFormat;
-            if (prevNumberingList != null && prevNumberingList.levels[0].getListLevelProperties().format != level.getListLevelProperties().format)
-                level.overrideStart = true;
-            level.getCharacterProperties().copyFrom(this.importer.importers.character.characterFormatting.coreProperties);
-            const firstLineIndent = this.importer.importers.paragraph.paragraphFormatting.coreProperties.firstLineIndent;
-            this.setFirstLineIndent(level, firstLineIndent);
-            this.setDisplayFormatString(level, `${this.importer.importers.numbering.oldListLevelInfo.textBefore}{${0}}${this.importer.importers.numbering.oldListLevelInfo.textAfter}`);
-            this.setTemplateCode(level, NumberingHelper.generateNewTemplateCode(documentModel));
-            this.setLegacyProperties(level, 0, 0);
-            documentModel.numberingLists.push(newList);
-            this.importer.importers.numbering.numberingListToOldListLevelInfoMap[documentModel.numberingLists.length - 1] = this.importer.importers.numbering.oldListLevelInfo.clone();
-        }
-    }
-    shouldCreateNewAbstractSimpleList() {
-        let existingNumberingListIndex;
-        if (this.importer.importers.numbering.currentOldSimpleList &&
-            this.importer.importers.numbering.currentOldSimpleListIndex >= NumberingListIndexConstants.minValue) {
-            existingNumberingListIndex = this.importer.importers.numbering.currentOldSimpleListIndex;
-            let oldListLevelInfo = this.importer.importers.numbering.numberingListToOldListLevelInfoMap[existingNumberingListIndex];
-            if (!oldListLevelInfo)
-                return { isSecceed: true, existingNumberingListIndex: existingNumberingListIndex };
-            return { isSecceed: !this.areSameInfo(oldListLevelInfo, this.importer.importers.numbering.oldListLevelInfo), existingNumberingListIndex: existingNumberingListIndex };
-        }
-        existingNumberingListIndex = NumberingListIndexConstants.listIndexNotSetted;
-        let prevParagraphIndex = this.importer.subDocument.paragraphs.length - 1 - 1;
-        for (; prevParagraphIndex >= 0; prevParagraphIndex--) {
-            const prevParagraph = this.importer.subDocument.paragraphs[prevParagraphIndex];
-            if (!prevParagraph.isInList()) {
-                if (prevParagraph.numberingListIndex == NumberingListIndexConstants.noNumberingList)
-                    continue;
-                return { isSecceed: true, existingNumberingListIndex: existingNumberingListIndex };
-            }
-            const numberingListIndex = prevParagraph.numberingListIndex;
-            const prevOldListLevelInfo = this.importer.importers.numbering.numberingListToOldListLevelInfoMap[numberingListIndex];
-            if (!prevOldListLevelInfo)
-                return { isSecceed: true, existingNumberingListIndex: existingNumberingListIndex };
-            if (!this.areSameInfo(prevOldListLevelInfo, this.importer.importers.numbering.oldListLevelInfo))
-                return { isSecceed: true, existingNumberingListIndex: existingNumberingListIndex };
-            existingNumberingListIndex = numberingListIndex;
-            return { isSecceed: false, existingNumberingListIndex: existingNumberingListIndex };
-        }
-        return { isSecceed: true, existingNumberingListIndex: existingNumberingListIndex };
-    }
-    setLegacyProperties(level, legacyIndent, legacySpace) {
-        level.getListLevelProperties().legacy = true;
-        level.getListLevelProperties().legacySpace = legacyIndent;
-        level.getListLevelProperties().legacyIndent = legacySpace;
-    }
-    setDisplayFormatString(level, displayFormatString) {
-        level.getListLevelProperties().displayFormatString = displayFormatString;
-    }
-    setFirstLineIndent(level, lineIndent) {
-        level.getParagraphProperties().leftIndent = lineIndent;
-    }
-    setTemplateCode(level, templateCode) {
-        level.getListLevelProperties().templateCode = templateCode;
-    }
-    shouldCreateNewList() {
-        if (this.isNewListLevelInfoPresent())
-            return false;
-        if (this.isMultilevelList())
-            return (!this.sectionMultiLevelListCreated());
-        if (this.isSimpleList())
-            return true;
-        if (this.isSkipNumbering())
-            return false;
-        return true;
-    }
-    isNewListLevelInfoPresent() {
-        if (this.explicitListLevelIndex && this.explicitNumberingListIndex)
-            return true;
-        if (this.isSimpleList()) {
-            if (this.simpleListIndex < NumberingListIndexConstants.minValue)
-                return false;
-            const existingListLevelInfo = this.importer.importers.numbering.numberingListToOldListLevelInfoMap[this.simpleListIndex];
-            if (!existingListLevelInfo)
-                return false;
-            return this.areSameInfo(existingListLevelInfo, this.importer.importers.numbering.oldListLevelInfo);
-        }
-        else
-            return this.multiLevelListIndex >= NumberingListIndexConstants.minValue;
-    }
-    areSameInfo(existingListLevelInfo, rtfOldListLevelInfo) {
-        return existingListLevelInfo.textAfter == rtfOldListLevelInfo.textAfter && existingListLevelInfo.textBefore == rtfOldListLevelInfo.textBefore;
-    }
-    isSimpleList() {
-        return this.simpleList;
-    }
-    isMultilevelList() {
-        return (this.oldLevelNumber >= 0) && !this.simpleList;
-    }
-    sectionMultiLevelListCreated() {
-        return this.importer.importers.numbering.currentOldMultiLevelListIndex >= NumberingListIndexConstants.minValue;
-    }
-    isSkipNumbering() {
-        return this.importer.importers.numbering.oldListLevelInfo.skipNumbering;
-    }
-}
-
 ;// CONCATENATED MODULE: ./src/common/formats/rtf/import/destination/numbering-list/destination-old-section-numbering-level.ts
 
 
@@ -66314,6 +66376,7 @@ 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)
@@ -68259,6 +68322,9 @@ class HtmlLiTagImporter extends HtmlTagImporterBase {
 
 
 
+
+
+
 class HtmlImportUtils {
     static getTableWidthUnit(stringValue) {
         if (!stringValue)
@@ -68270,7 +68336,7 @@ 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(unit_converter/* UnitConverter */.u.pixelsToTwips(numberValue), TableWidthUnitType.ModelUnits);
             case "in":
@@ -68326,8 +68392,54 @@ 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/* Errors */.D.InternalException);
+        }
+    }
+    static getLineSpacingAsMultiple(multipleValue) {
+        if (!multipleValue || isNaN(multipleValue))
+            return LineSpacingUnit.createSingle();
+        if (math.MathUtils.numberCloseTo(multipleValue, 1))
+            return LineSpacingUnit.createSingle();
+        else if (math.MathUtils.numberCloseTo(multipleValue, 1.5))
+            return LineSpacingUnit.createSesquialteral();
+        else if (math.MathUtils.numberCloseTo(multipleValue, 2))
+            return LineSpacingUnit.createDouble();
+        else
+            return LineSpacingUnit.createMultiple(multipleValue);
     }
 }
 HtmlImportUtils.MapBorderStyleToType = new MapCreator()
@@ -68786,7 +68898,7 @@ class HtmlTableTagImporter extends HtmlTagImporterBase {
         if (!(tbl.width.type == TableWidthUnitType.ModelUnits && tbl.width.value > 0))
             if (!utils_list.ListUtils.unsafeAnyOf(this.rows, (row) => utils_list.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);
     }
@@ -69358,11 +69470,8 @@ class HtmlImporterMaskedCharacterProperties {
 
 
 
-
-
-
 class HtmlImporterMaskedParagraphProperties {
-    import(colorProvider, element, isTableCellTag) {
+    import(colorProvider, element, isTableCellTag = false) {
         this.result = new MaskedParagraphProperties();
         this.element = element;
         this.elementStyle = element.style;
@@ -69443,36 +69552,10 @@ 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/* Errors */.D.InternalException);
-        }
-    }
-    setSpacingAsMultiple(multipleValue) {
-        if (!multipleValue || isNaN(multipleValue))
-            return;
-        this.result.lineSpacing = multipleValue;
-        this.result.lineSpacingType =
-            math.MathUtils.numberCloseTo(multipleValue, 1.5) ? ParagraphLineSpacingType.Sesquialteral :
-                (math.MathUtils.numberCloseTo(multipleValue, 2) ? ParagraphLineSpacingType.Double :
-                    (math.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);
@@ -143634,7 +143717,6 @@ class FullScreenHelper {
 
 ;// CONCATENATED MODULE: external "DevExpress.config"
 var external_DevExpress_config_namespaceObject = DevExpress.config;
-var external_DevExpress_config_default = /*#__PURE__*/__webpack_require__.n(external_DevExpress_config_namespaceObject);
 ;// CONCATENATED MODULE: ./src/client/client-rich-edit.ts
 
 
@@ -143691,8 +143773,8 @@ class ClientRichEdit {
         this.rawDataSource = settings.rawDataSource;
         this.contextMenuSettings = settings.contextMenuSettings;
         this.fullScreenHelper = new FullScreenHelper(element);
-        if (true)
-            external_DevExpress_config_default()(JSON.parse(atob('eyJsaWNlbnNlS2V5IjoiZXdvZ0lDSm1iM0p0WVhRaU9pQXhMQW9nSUNKcGJuUmxjbTVoYkZWellXZGxTV1FpT2lBaWFYWkdXQzFTVkdFeU1IbFVPRGh0YzAxNmRsQTJaeUlLZlE9PS5GYjZ4U0JwU3BSVHBWajZ0dWtlQTJZaU1WVW5tb0ZoSDJKV3Ryak5iN3p6VlNrNzhKa294RVFKOW9rVlErYnh0SzM1WWlFZkpEWGJnNktrYVA1ZEljcnp0ZHlsOFlGL2ltc3BIWkY5aWlaeGtVK0FXbFVrV1RUb2c0ZnZDbWlxMTl2MWhIdz09In0=')));
+        if (false)
+            {}
         this.prepareElement(element, settings);
         this.initDefaultFontsAndStyles();
         this.initBars(settings.ribbon, settings.fonts);