devexpress-richedit 23.2.5 → 24.1.1-alpha-24085-0102

package/lib/html/import/utils/character-properties-utils.d.ts

@@ -1,34 +0,0 @@
-import { FontInfoCache } from '../../../core/model/caches/hashed-caches/font-info-cache';
-import { MaskedCharacterProperties } from '../../../core/model/character/character-properties';
-import { MaskedCharacterPropertiesBundle } from '../../../core/rich-utils/properties-bundle';
-import { FixedInterval } from '@devexpress/utils/lib/intervals/fixed';
-import { HtmlImporter } from '../html-importer';
-import { LoadFontInfo } from '../load-font-info';
-export declare class HtmlImporterMaskedCharacterProperties {
-    private loadFontInfos;
-    private tempFontInfoCache;
-    private result;
-    private styledElement;
-    private currentStyle;
-    private initialCharacterProperties;
-    private get model();
-    private get controlOptions();
-    private importer;
-    private allowCreateNewFonts;
-    constructor(importer: HtmlImporter, loadFontInfos: LoadFontInfo[], tempFontInfoCache: FontInfoCache, allowCreateNewFonts: boolean);
-    getBundleFrom(element: HTMLElement, interval: FixedInterval): MaskedCharacterPropertiesBundle;
-    import(element: HTMLElement, interval: FixedInterval, initialCharacterProperties: MaskedCharacterProperties): MaskedCharacterProperties;
-    private importFontBold;
-    private importFontItalic;
-    private importAllCaps;
-    private importStrikeoutType;
-    private importUnderlineType;
-    private importForeColor;
-    private importBackColor;
-    private importFontInfo;
-    private importFontSize;
-    private importHidden;
-    private importSuperscript;
-    private importSubscript;
-}
-//# sourceMappingURL=character-properties-utils.d.ts.map

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

@@ -1,151 +0,0 @@
-import { CharacterFormattingScript, CharacterPropertiesMask, StrikeoutType, UnderlineType } from '../../../core/model/character/enums';
-import { ColorModelInfo } from '../../../core/model/color/color-model-info';
-import { FontChooser } from '../../../core/model/fonts/font-chooser';
-import { ControlOptions } from '../../../core/model/options/control';
-import { ShadingInfo } from '../../../core/model/shadings/shading-info';
-import { MaskedCharacterPropertiesBundle } from '../../../core/rich-utils/properties-bundle';
-import { ColorUtils } from '@devexpress/utils/lib/utils/color';
-import { DomUtils } from '@devexpress/utils/lib/utils/dom';
-import { LoadFontInfo } from '../load-font-info';
-import { HtmlImporterFontUtils } from './font-utils';
-export class HtmlImporterMaskedCharacterProperties {
-    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);
-    }
-    import(element, interval, initialCharacterProperties) {
-        this.initialCharacterProperties = initialCharacterProperties;
-        this.result = initialCharacterProperties.clone();
-        this.styledElement = DomUtils.isHTMLElementNode(element) ? element : (element.parentElement || element.parentNode);
-        if (this.styledElement !== element && this.styledElement.tagName.toUpperCase() == 'TD')
-            return this.result;
-        this.currentStyle = DomUtils.getCurrentStyle(this.styledElement);
-        if (!this.currentStyle)
-            return this.result;
-        this.importFontBold();
-        this.importFontItalic();
-        this.importAllCaps();
-        this.importStrikeoutType();
-        this.importUnderlineType();
-        this.importForeColor();
-        this.importBackColor();
-        this.importFontInfo(interval);
-        this.importFontSize();
-        this.importHidden();
-        this.importSuperscript();
-        this.importSubscript();
-        return this.result;
-    }
-    importFontBold() {
-        switch (this.currentStyle.fontWeight) {
-            case "bold":
-            case "700":
-                this.result.fontBold = true;
-                this.result.setUseValue(CharacterPropertiesMask.UseFontBold, true);
-        }
-    }
-    importFontItalic() {
-        if (this.currentStyle.fontStyle == "italic") {
-            this.result.fontItalic = true;
-            this.result.setUseValue(CharacterPropertiesMask.UseFontItalic, true);
-        }
-    }
-    importAllCaps() {
-        if (this.currentStyle.textTransform == "uppercase") {
-            this.result.allCaps = true;
-            this.result.setUseValue(CharacterPropertiesMask.UseAllCaps, true);
-        }
-    }
-    importStrikeoutType() {
-        if (/.*line-through.*/gi.test(this.currentStyle.textDecoration)) {
-            this.result.fontStrikeoutType = StrikeoutType.Single;
-            this.result.setUseValue(CharacterPropertiesMask.UseFontStrikeoutType, true);
-        }
-    }
-    importUnderlineType() {
-        if (/.*underline.*/gi.test(this.currentStyle.textDecoration)) {
-            this.result.fontUnderlineType = UnderlineType.Single;
-            this.result.setUseValue(CharacterPropertiesMask.UseFontUnderlineType, true);
-        }
-    }
-    importForeColor() {
-        if (this.styledElement.style.color !== "") {
-            const foreColor = ColorUtils.fromString(this.currentStyle.color);
-            if (foreColor != null) {
-                this.result.textColor = ColorModelInfo.makeByColor(foreColor);
-                this.result.setUseValue(CharacterPropertiesMask.UseForeColorIndex, true);
-            }
-        }
-    }
-    importBackColor() {
-        if (this.styledElement.style.backgroundColor !== "") {
-            const backColor = ColorUtils.fromString(this.currentStyle.backgroundColor);
-            if (backColor) {
-                this.result.shadingInfo = ShadingInfo.createByColor(ColorModelInfo.makeByColor(backColor));
-                this.result.setUseValue(CharacterPropertiesMask.UseShadingInfoIndex, true);
-                this.result.setUseValue(CharacterPropertiesMask.UseHighlightColorIndex, false);
-            }
-        }
-    }
-    importFontInfo(interval) {
-        if (this.styledElement.style.fontFamily) {
-            const cssFontFamily = this.currentStyle.fontFamily;
-            let fontInfo = new FontChooser(this.model.cache.fontInfoCache).chooseByCssString(cssFontFamily);
-            if (!fontInfo) {
-                if (ControlOptions.isEnabled(this.controlOptions.characterFormatting) && this.allowCreateNewFonts) {
-                    const fontName = DomUtils.getFontFamiliesFromCssString(cssFontFamily)[0];
-                    fontInfo = this.tempFontInfoCache.getItemByName(fontName);
-                    if (!fontInfo) {
-                        const sourceFont = this.initialCharacterProperties.fontInfo || this.model.defaultCharacterProperties.fontInfo;
-                        fontInfo = sourceFont.clone();
-                        fontInfo.name = fontName;
-                        fontInfo.cssString = cssFontFamily;
-                        this.tempFontInfoCache.getItem(fontInfo);
-                    }
-                    this.loadFontInfos.push(new LoadFontInfo(fontInfo, this.importer.subDocument, interval));
-                }
-                else
-                    fontInfo = this.model.defaultCharacterProperties.fontInfo;
-            }
-            this.result.fontInfo = fontInfo;
-            this.result.setUseValue(CharacterPropertiesMask.UseFontName, true);
-        }
-    }
-    importFontSize() {
-        if (this.styledElement.style.fontSize) {
-            const parentCurrentStyle = DomUtils.getCurrentStyle(this.styledElement.parentElement || this.styledElement.parentNode);
-            const fontSize = HtmlImporterFontUtils.getFontSize(this.currentStyle.fontSize, parentCurrentStyle ? parentCurrentStyle.fontSize : null);
-            if (fontSize != null && fontSize > 0) {
-                this.result.fontSize = fontSize;
-                this.result.setUseValue(CharacterPropertiesMask.UseDoubleFontSize, true);
-            }
-        }
-    }
-    importHidden() {
-        if (this.currentStyle.display == "none") {
-            this.result.hidden = true;
-            this.result.setUseValue(CharacterPropertiesMask.UseHidden, true);
-        }
-    }
-    importSuperscript() {
-        if (this.currentStyle.verticalAlign == "super") {
-            this.result.script = CharacterFormattingScript.Superscript;
-            this.result.setUseValue(CharacterPropertiesMask.UseScript, true);
-        }
-    }
-    importSubscript() {
-        if (this.currentStyle.verticalAlign == "sub") {
-            this.result.script = CharacterFormattingScript.Subscript;
-            this.result.setUseValue(CharacterPropertiesMask.UseScript, true);
-        }
-    }
-}

package/lib/html/import/utils/font-utils.d.ts

@@ -1,5 +0,0 @@
-export declare class HtmlImporterFontUtils {
-    static getFontSize(font: string, parentFont: string): number;
-    private static getFontSizeCore;
-}
-//# sourceMappingURL=font-utils.d.ts.map

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

@@ -1,29 +0,0 @@
-import { NumberingFormat } from '../../../core/model/numbering-lists/list-level-properties';
-import { FixedInterval } from '@devexpress/utils/lib/intervals/fixed';
-import { ImportedParagraphListInfo } from '../containers/runs';
-import { HtmlImporter } from '../html-importer';
-import { HtmlImporterMaskedCharacterProperties } from './character-properties-utils';
-export declare class ParagraphListPropertiesUtils {
-    private htmlImporterMaskedCharacterProperties;
-    private listItemElement;
-    private msoListAttr;
-    private parentListElement;
-    private importer;
-    constructor(importer: HtmlImporter, htmlImporterMaskedCharacterProperties: HtmlImporterMaskedCharacterProperties);
-    import(element: HTMLElement, interval: FixedInterval): ImportedParagraphListInfo;
-    private importListIndex;
-    private importListLevelIndex;
-    private importListFormatByListItemElement;
-    private static importListFormatByReserveWay;
-    private importDisplayFormatStringByParentListElement;
-    static importDisplayFormatStringByParentListFormat(listFormat: NumberingFormat, parentListFormat: NumberingFormat, listLevelIndex: number): string;
-    private static importDisplayFormatStringByReserveWay;
-    private getMainParentListElement;
-    static getListType(listElement: HTMLElement): NumberingFormat;
-    private static getListTextElement;
-    private static getListText;
-    private static getParentListElement;
-    private static removeSomeHtml;
-    private static MapListTypeToType;
-}
-//# sourceMappingURL=paragraph-list-properties-utils.d.ts.map

package/lib/html/import/utils/paragraph-list-properties-utils.js

@@ -1,158 +0,0 @@
-import { MapCreator } from '../../../base-utils/map-creator';
-import { NumberingFormat } from '../../../core/model/numbering-lists/list-level-properties';
-import { NumberingType } from '../../../core/model/numbering-lists/numbering-list';
-import { DomUtils } from '@devexpress/utils/lib/utils/dom';
-import { ListUtils } from '@devexpress/utils/lib/utils/list';
-import { StringUtils } from '@devexpress/utils/lib/utils/string';
-import { ImportedParagraphListInfo } from '../containers/runs';
-import { HtmlImportUtils } from './utils';
-export class ParagraphListPropertiesUtils {
-    constructor(importer, htmlImporterMaskedCharacterProperties) {
-        this.htmlImporterMaskedCharacterProperties = htmlImporterMaskedCharacterProperties;
-        this.importer = importer;
-    }
-    import(element, interval) {
-        this.listItemElement = DomUtils.getParentByTagName(element, "LI");
-        this.msoListAttr = element.outerHTML.match(/mso-list:\s*\w*\s*level[^ ]/gi);
-        if (!this.listItemElement && !this.msoListAttr)
-            return null;
-        this.parentListElement = this.listItemElement ? ParagraphListPropertiesUtils.getParentListElement(this.listItemElement) : null;
-        if (!this.parentListElement)
-            return null;
-        const listIndex = this.importListIndex();
-        const listLevelIndex = this.importListLevelIndex();
-        let listFormat;
-        let displayFormatString;
-        let maskedCharacterProperties;
-        if (this.listItemElement) {
-            listFormat = this.importListFormatByListItemElement();
-            displayFormatString = this.importDisplayFormatStringByParentListElement(listFormat, listLevelIndex);
-            maskedCharacterProperties = null;
-        }
-        else {
-            const listTextElement = ParagraphListPropertiesUtils.getListTextElement(element);
-            const listText = ParagraphListPropertiesUtils.getListText(listTextElement);
-            listFormat = ParagraphListPropertiesUtils.importListFormatByReserveWay(listText);
-            displayFormatString = ParagraphListPropertiesUtils.importDisplayFormatStringByReserveWay(listFormat, listLevelIndex, listText);
-            maskedCharacterProperties = this.htmlImporterMaskedCharacterProperties.import(listTextElement, interval, this.importer.charPropsBundle.props);
-            ParagraphListPropertiesUtils.removeSomeHtml(element, listTextElement, listText);
-        }
-        return new ImportedParagraphListInfo(listIndex, listLevelIndex, listFormat, listFormat == NumberingFormat.Bullet ? NumberingType.Bullet : NumberingType.MultiLevel, displayFormatString, maskedCharacterProperties);
-    }
-    importListIndex() {
-        if (this.msoListAttr && this.msoListAttr.length)
-            return parseInt(this.msoListAttr[0].replace(/mso-list:\s*[A-Za-z]*(\d*)[\s\S]*/gi, '$1'));
-        const mainParentListElement = this.getMainParentListElement();
-        if (!mainParentListElement)
-            return 0;
-        const lists = DomUtils.getChildNodes(mainParentListElement.parentNode, (e) => {
-            return e.tagName == "UL" || e.tagName == "OL";
-        });
-        return ListUtils.accumulate(lists, 0, (acc, list, index) => acc + (list == mainParentListElement ? index : 0));
-    }
-    importListLevelIndex() {
-        if (this.msoListAttr && this.msoListAttr.length)
-            return parseInt(this.msoListAttr[0].replace(/mso-list:\s*\w*\s*level/gi, '')) - 1;
-        let listLevelIndex = 0;
-        let parentListItemElement = this.parentListElement ? DomUtils.getParentByTagName(this.parentListElement, "LI") : null;
-        while (parentListItemElement) {
-            listLevelIndex++;
-            parentListItemElement = DomUtils.getParentByTagName(parentListItemElement.parentNode, "LI");
-        }
-        return listLevelIndex;
-    }
-    importListFormatByListItemElement() {
-        return ParagraphListPropertiesUtils.getListType(this.parentListElement);
-    }
-    static importListFormatByReserveWay(listText) {
-        if (!listText)
-            return NumberingFormat.None;
-        const encodedIndexText = encodeURI(listText);
-        if (listText == "o" || encodedIndexText.indexOf("%B7") > -1 || encodedIndexText.indexOf("%A7") > -1)
-            return NumberingFormat.Bullet;
-        if (/^(IX|IV|V?I{1,3})/.test(listText))
-            return NumberingFormat.UpperRoman;
-        if (/^(ix|iv|v?i{1,3})/.test(listText))
-            return NumberingFormat.LowerRoman;
-        if (/[0-9]/.test(listText))
-            return NumberingFormat.Decimal;
-        if (/[a-z]/.test(listText))
-            return NumberingFormat.LowerLetter;
-        if (/[A-Z]/.test(listText))
-            return NumberingFormat.UpperLetter;
-        return NumberingFormat.None;
-    }
-    importDisplayFormatStringByParentListElement(listFormat, listLevelIndex) {
-        const listElementParentList = ParagraphListPropertiesUtils.getParentListElement(this.parentListElement.parentNode);
-        if (listElementParentList) {
-            const parentListFormat = ParagraphListPropertiesUtils.getListType(listElementParentList);
-            return ParagraphListPropertiesUtils.importDisplayFormatStringByParentListFormat(listFormat, parentListFormat, listLevelIndex);
-        }
-        return "";
-    }
-    static importDisplayFormatStringByParentListFormat(listFormat, parentListFormat, listLevelIndex) {
-        if (parentListFormat && listFormat != parentListFormat)
-            return "{" + listLevelIndex + "}";
-        return "";
-    }
-    static importDisplayFormatStringByReserveWay(listFormat, listLevelIndex, listText) {
-        if (listFormat == NumberingFormat.Bullet)
-            return "";
-        if (listText.indexOf(".") > -1)
-            return ListUtils.accumulate(listText.split("."), "", (acc, listItem, listIndex) => listItem ? acc + "{" + listIndex + "}." : acc);
-        const matches = listText.match(/^(\W?)(\w+)(\W?)/);
-        return matches && matches.length > 2 ? matches[1] + "{" + listLevelIndex + "}" + matches[3] : listText.charAt(0);
-    }
-    getMainParentListElement() {
-        let listElement = this.parentListElement ? this.parentListElement : null;
-        let mainParentListElement = null;
-        while (listElement) {
-            mainParentListElement = listElement;
-            listElement = ParagraphListPropertiesUtils.getParentListElement(listElement.parentNode);
-        }
-        return mainParentListElement;
-    }
-    static getListType(listElement) {
-        return HtmlImportUtils.getPropertyByMap(ParagraphListPropertiesUtils.MapListTypeToType, DomUtils.getCurrentStyle(listElement).listStyleType, NumberingFormat.None);
-    }
-    static getListTextElement(element) {
-        const ignoreElements = DomUtils.getNodes(element, (e) => { return e.outerHTML.match(/mso-list:Ignore/gi) != null; });
-        let listTextElement = ignoreElements.length ? ignoreElements[0] : null;
-        if (!listTextElement) {
-            const whiteSpacesOnlyTextElements = DomUtils.getNodes(element, (e) => DomUtils.isTextNode(e) && e.nodeValue && !StringUtils.trim(e.nodeValue) ||
-                e.textContent && !StringUtils.trim(e.textContent) ||
-                e.innerText && !StringUtils.trim(e.innerText));
-            listTextElement = whiteSpacesOnlyTextElements.length ? whiteSpacesOnlyTextElements[0].previousSibling : (element.firstChild);
-        }
-        return listTextElement;
-    }
-    static getListText(listTextElement) {
-        return listTextElement ? StringUtils.trim((listTextElement.nodeValue || DomUtils.getInnerText(listTextElement)).split(" ")[0]) : "";
-    }
-    static getParentListElement(childElement) {
-        return DomUtils.getParentByTagName(childElement, "UL") || DomUtils.getParentByTagName(childElement, "OL");
-    }
-    static removeSomeHtml(element, listTextElement, listText) {
-        if (element.childNodes.length == 1)
-            element.innerHTML = StringUtils.trimStart(element.innerHTML.replace(listText, ''));
-        else {
-            const listTextElementParent = listTextElement.parentNode;
-            listTextElementParent.removeChild(listTextElement);
-            listTextElementParent.innerHTML = listTextElementParent.innerHTML.replace(/^<([^\s>]+)(\s[^>]*)?>(\s|&nbsp;){2,}<\/\1>/g, '');
-            if (listTextElement.parentNode != element)
-                element.innerHTML = element.innerHTML.replace(/<([^\s>]+)(\s[^>]*)?><\/\1>/g, '');
-        }
-    }
-}
-ParagraphListPropertiesUtils.MapListTypeToType = new MapCreator()
-    .add("decimal", NumberingFormat.Decimal)
-    .add("circle", NumberingFormat.Bullet)
-    .add("disc", NumberingFormat.Bullet)
-    .add("square", NumberingFormat.Bullet)
-    .add("lower-alpha", NumberingFormat.LowerLetter)
-    .add("lower-latin", NumberingFormat.LowerLetter)
-    .add("upper-alpha", NumberingFormat.UpperLetter)
-    .add("upper-latin", NumberingFormat.UpperLetter)
-    .add("lower-roman", NumberingFormat.LowerRoman)
-    .add("upper-roman", NumberingFormat.UpperRoman)
-    .get();

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

@@ -1,22 +0,0 @@
-import { ColorProvider } from '../../../core/model/color/color-provider';
-import { MaskedParagraphProperties } from '../../../core/model/paragraph/paragraph-properties';
-export declare class HtmlImporterMaskedParagraphProperties {
-    private result;
-    private elementStyle;
-    private element;
-    import(colorProvider: ColorProvider, element: HTMLElement, isTableCellTag: boolean): MaskedParagraphProperties;
-    private importAlignment;
-    private importFirstLineIndent;
-    private importLeftIndent;
-    private importRightIndent;
-    private importSpacingBefore;
-    private importSpacingAfter;
-    private importLineSpacing;
-    private setSpacingAsMultiple;
-    private importTopBorder;
-    private importRightBorder;
-    private importBottomBorder;
-    private importLeftBorder;
-    private static MapAlignmentToType;
-}
-//# sourceMappingURL=paragraph-properties-utils.d.ts.map

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

@@ -1,146 +0,0 @@
-import { MapCreator } from '../../../base-utils/map-creator';
-import { BorderLineStyle } from '../../../core/model/borders/enums';
-import { MaskedParagraphProperties, ParagraphAlignment, ParagraphFirstLineIndent, ParagraphLineSpacingType, ParagraphPropertiesMask } from '../../../core/model/paragraph/paragraph-properties';
-import { TableWidthUnit, TableWidthUnitType } from '../../../core/model/tables/secondary-structures/table-units';
-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 { HtmlImportUtils } from './utils';
-export class HtmlImporterMaskedParagraphProperties {
-    import(colorProvider, element, isTableCellTag) {
-        this.result = new MaskedParagraphProperties();
-        this.element = element;
-        this.elementStyle = element.style;
-        const calculatedStyle = DomUtils.getCurrentStyle(element);
-        this.importAlignment();
-        this.importFirstLineIndent();
-        this.importLeftIndent();
-        this.importRightIndent();
-        this.importLineSpacing();
-        this.importSpacingBefore();
-        this.importSpacingAfter();
-        if (!isTableCellTag) {
-            this.importTopBorder(colorProvider, calculatedStyle);
-            this.importRightBorder(colorProvider, calculatedStyle);
-            this.importBottomBorder(colorProvider, calculatedStyle);
-            this.importLeftBorder(colorProvider, calculatedStyle);
-        }
-        return this.result;
-    }
-    importAlignment() {
-        let textAlign = this.elementStyle.textAlign;
-        if (!textAlign || !textAlign.length) {
-            const parentCell = DomUtils.getParentByTagName(this.element, "TD");
-            if (parentCell)
-                textAlign = AttrUtils.getElementAttribute(parentCell, "align");
-        }
-        this.result.alignment = HtmlImportUtils.getPropertyByMap(HtmlImporterMaskedParagraphProperties.MapAlignmentToType, textAlign, ParagraphAlignment.Left);
-        this.result.setUseValue(ParagraphPropertiesMask.UseAlignment, this.result.alignment != ParagraphAlignment.Left);
-    }
-    importFirstLineIndent() {
-        const firstLineIndent = HtmlImportUtils.getValueInTwips(this.elementStyle.textIndent);
-        if (firstLineIndent != null && firstLineIndent != 0) {
-            this.result.firstLineIndentType = firstLineIndent > 0 ? ParagraphFirstLineIndent.Indented : ParagraphFirstLineIndent.Hanging;
-            this.result.firstLineIndent = Math.abs(firstLineIndent);
-            this.result.setUseValue(ParagraphPropertiesMask.UseFirstLineIndent, true);
-        }
-    }
-    importLeftIndent() {
-        const leftIndent = HtmlImportUtils.getValueInTwips(this.elementStyle.marginLeft);
-        if (leftIndent != null && leftIndent >= 0) {
-            this.result.leftIndent = leftIndent;
-            this.result.setUseValue(ParagraphPropertiesMask.UseLeftIndent, true);
-        }
-    }
-    importRightIndent() {
-        const rightIndent = HtmlImportUtils.getValueInTwips(this.elementStyle.marginRight);
-        if (rightIndent != null && rightIndent >= 0) {
-            this.result.rightIndent = rightIndent;
-            this.result.setUseValue(ParagraphPropertiesMask.UseRightIndent, true);
-        }
-    }
-    importSpacingBefore() {
-        const spacingBefore = HtmlImportUtils.getValueInTwips(this.elementStyle.marginTop);
-        if (spacingBefore != null && spacingBefore >= 0) {
-            this.result.spacingBefore = spacingBefore;
-            this.result.setUseValue(ParagraphPropertiesMask.UseSpacingBefore, true);
-        }
-    }
-    importSpacingAfter() {
-        const spacingAfter = HtmlImportUtils.getValueInTwips(this.elementStyle.marginBottom);
-        if (spacingAfter != null && spacingAfter >= 0) {
-            this.result.spacingAfter = spacingAfter;
-            this.result.setUseValue(ParagraphPropertiesMask.UseSpacingAfter, true);
-        }
-    }
-    importLineSpacing() {
-        this.result.setUseValue(ParagraphPropertiesMask.UseLineSpacing, true);
-        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));
-    }
-    importTopBorder(colorProvider, calculatedStyle) {
-        const borderTopInfo = HtmlImportUtils.getBorderInfo(colorProvider, calculatedStyle.borderTopWidth, calculatedStyle.borderTopStyle, calculatedStyle.borderTopColor);
-        if (borderTopInfo) {
-            this.result.topBorder.copyFrom(borderTopInfo);
-            this.result.setUseValue(ParagraphPropertiesMask.UseTopBorder, borderTopInfo.style != BorderLineStyle.None);
-        }
-    }
-    importRightBorder(colorProvider, calculatedStyle) {
-        const borderRightInfo = HtmlImportUtils.getBorderInfo(colorProvider, calculatedStyle.borderRightWidth, calculatedStyle.borderRightStyle, calculatedStyle.borderRightColor);
-        if (borderRightInfo) {
-            this.result.rightBorder.copyFrom(borderRightInfo);
-            this.result.setUseValue(ParagraphPropertiesMask.UseRightBorder, borderRightInfo.style != BorderLineStyle.None);
-        }
-    }
-    importBottomBorder(colorProvider, calculatedStyle) {
-        const borderBottomInfo = HtmlImportUtils.getBorderInfo(colorProvider, calculatedStyle.borderBottomWidth, calculatedStyle.borderBottomStyle, calculatedStyle.borderBottomColor);
-        if (borderBottomInfo) {
-            this.result.bottomBorder.copyFrom(borderBottomInfo);
-            this.result.setUseValue(ParagraphPropertiesMask.UseBottomBorder, borderBottomInfo.style != BorderLineStyle.None);
-        }
-    }
-    importLeftBorder(colorProvider, calculatedStyle) {
-        const borderLeftInfo = HtmlImportUtils.getBorderInfo(colorProvider, calculatedStyle.borderLeftWidth, calculatedStyle.borderLeftStyle, calculatedStyle.borderLeftColor);
-        if (borderLeftInfo) {
-            this.result.leftBorder.copyFrom(borderLeftInfo);
-            this.result.setUseValue(ParagraphPropertiesMask.UseLeftBorder, borderLeftInfo.style != BorderLineStyle.None);
-        }
-    }
-}
-HtmlImporterMaskedParagraphProperties.MapAlignmentToType = new MapCreator()
-    .add("right", ParagraphAlignment.Right)
-    .add("justify", ParagraphAlignment.Justify)
-    .add("center", ParagraphAlignment.Center)
-    .get();

package/lib/html/import/utils/tab-stops-utils.d.ts

@@ -1,5 +0,0 @@
-import { TabProperties } from '../../../core/model/paragraph/paragraph-style';
-export declare class HtmlImporterTabStops {
-    static import(element: HTMLElement): TabProperties;
-}
-//# sourceMappingURL=tab-stops-utils.d.ts.map

package/lib/html/import/utils/tab-stops-utils.js

@@ -1,71 +0,0 @@
-import { TabProperties, TabInfo } from '../../../core/model/paragraph/paragraph-style';
-import { TabAlign } from '../../../core/model/paragraph/paragraph';
-import { TabLeaderType } from '../../../core/layout/main-structures/layout-boxes/layout-tab-space-box';
-import { UnitConverter } from '@devexpress/utils/lib/class/unit-converter';
-export class HtmlImporterTabStops {
-    static import(element) {
-        var _a, _b;
-        const result = new TabProperties();
-        const tabStops = (_b = (_a = element.getAttribute('style')) === null || _a === void 0 ? void 0 : _a.split(';').find(e => e.startsWith('tab-stops:'))) === null || _b === void 0 ? void 0 : _b.replace('tab-stops:', '');
-        if (tabStops) {
-            const tabStopsArr = tabStops.split(' ');
-            for (let i = 0; i < tabStopsArr.length; i++) {
-                let align = TabAlign.Left;
-                let leaderType = TabLeaderType.None;
-                let parseResult = parseFloat(tabStopsArr[i]);
-                while (isNaN(parseResult)) {
-                    switch (tabStopsArr[i]) {
-                        case 'right':
-                            align = TabAlign.Right;
-                            break;
-                        case 'center':
-                            align = TabAlign.Center;
-                            break;
-                        case 'decimal':
-                            align = TabAlign.Decimal;
-                            break;
-                        case 'dotted':
-                            leaderType = TabLeaderType.Dots;
-                            break;
-                        case 'dashed':
-                            leaderType = TabLeaderType.Hyphens;
-                            break;
-                        case 'middot':
-                            leaderType = TabLeaderType.MiddleDots;
-                            break;
-                        case 'heavy':
-                            leaderType = TabLeaderType.ThickLine;
-                            break;
-                        case 'lined':
-                            leaderType = TabLeaderType.Underline;
-                            break;
-                    }
-                    i++;
-                    parseResult = parseFloat(tabStopsArr[i]);
-                }
-                const unitStr = tabStopsArr[i].substring(tabStopsArr[i].length - 2);
-                let value;
-                switch (unitStr) {
-                    case 'pt':
-                        value = UnitConverter.pointsToTwipsF(parseResult);
-                        break;
-                    case 'cm':
-                        value = UnitConverter.centimetersToTwipsF(parseResult);
-                        break;
-                    case 'in':
-                        value = UnitConverter.inchesToTwipsF(parseResult);
-                        break;
-                    case 'pc':
-                        value = UnitConverter.picasToTwips(parseResult);
-                        break;
-                    default:
-                        console.warn(`Unknown unit: ${unitStr}. Tab stop skipped`);
-                        continue;
-                }
-                const tab = new TabInfo(value, align, leaderType, false, false);
-                result.add(tab);
-            }
-        }
-        return result;
-    }
-}

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

@@ -1,17 +0,0 @@
-import { BorderInfo } from '../../../core/model/borders/border-info';
-import { TableBordersBase } from '../../../core/model/borders/table-border-base';
-import { ColorProvider } from '../../../core/model/color/color-provider';
-import { IMaskedProperties } from '../../../core/model/interfaces';
-import { TableWidthUnit } from '../../../core/model/tables/secondary-structures/table-units';
-export declare class HtmlImportUtils {
-    static getTableWidthUnit(stringValue: string): TableWidthUnit;
-    static getValueInTwips(stringValue: string): number;
-    static getBorderInfo(colorProvider: ColorProvider, borderWidth: string, borderStyle: string, borderColor: string): BorderInfo;
-    static importBorder<TMask, TProps extends IMaskedProperties<TMask>>(colorProvider: ColorProvider, props: TProps, borders: TableBordersBase, mask: TMask, setBorder: (brds: TableBordersBase, brd: BorderInfo) => void, borderWidth: string, borderStyle: string, borderColor: string): void;
-    static setBorders<TMask, TProps extends IMaskedProperties<TMask>>(colorProvider: ColorProvider, props: TProps, borders: TableBordersBase, style: CSSStyleDeclaration, topMask: TMask, rightMask: TMask, bottomMask: TMask, leftMask: TMask): void;
-    private static MapBorderStyleToType;
-    static getPropertyByMap<T>(map: {
-        [key: string]: T;
-    }, elementBy: string, defaultValue: T): T;
-}
-//# sourceMappingURL=utils.d.ts.map