devexpress-richedit 24.1.12-build-25107-0103 → 24.1.13-build-25142-0103

package/dist/dx.richedit.js

@@ -1,6 +1,6 @@
 /**
 * DevExpress WebRichEdit (dx.richedit.js)
-* Version: 24.1.12
+* Version: 24.1.13
 * Copyright (c) 2012 - 2025 Developer Express Inc. ALL RIGHTS RESERVED
 * License: https://www.devexpress.com/Support/EULAs
 */
@@ -9438,6 +9438,219 @@ class ShadingInfo {
     }
 }
 
+// EXTERNAL MODULE: ./node_modules/@devexpress/utils/lib/utils/comparers.js
+var comparers = __webpack_require__(4170);
+;// CONCATENATED MODULE: ./src/common/model/history/base/history-item.ts
+
+class history_item_HistoryItem {
+    constructor(modelManipulator) {
+        this.uniqueId = -1;
+        this.modelManipulator = modelManipulator;
+    }
+    canBeMerged() {
+        return false;
+    }
+    changeModified() {
+        return true;
+    }
+}
+class CompositionHistoryItem extends history_item_HistoryItem {
+    constructor() {
+        super(null);
+        this.historyItems = [];
+    }
+    canBeMerged() {
+        return true;
+    }
+    changeModified() {
+        var item;
+        for (var i = 0; item = this.historyItems[i]; i++) {
+            if (item.changeModified())
+                return true;
+        }
+        return false;
+    }
+    redo() {
+        var item;
+        for (var i = 0; item = this.historyItems[i]; i++)
+            item.redo();
+    }
+    undo() {
+        var item;
+        for (var i = this.historyItems.length - 1; item = this.historyItems[i]; i--)
+            item.undo();
+    }
+    add(historyItem) {
+        if (historyItem == null)
+            throw new Error(errors/* Errors */.D.ValueCannotBeNull);
+        this.historyItems.push(historyItem);
+    }
+}
+
+;// CONCATENATED MODULE: ./src/common/model/history/base/interval-based-history-item.ts
+
+class interval_based_history_item_IntervalBasedHistoryItem extends history_item_HistoryItem {
+    constructor(modelManipulator, subDocInterval) {
+        super(modelManipulator);
+        this.subDocInterval = subDocInterval;
+    }
+    get boundSubDocument() { return this.subDocInterval.subDocument; }
+    get interval() { return this.subDocInterval.interval; }
+}
+
+;// CONCATENATED MODULE: ./src/common/model/history/items/character-properties-history-items.ts
+
+
+class FontUseValueHistoryItem extends interval_based_history_item_IntervalBasedHistoryItem {
+    constructor(modelManipulator, subDocInterval, newValue, keepCustomFormatting = false) {
+        super(modelManipulator, subDocInterval);
+        this.newValue = newValue;
+        this.keepCustomFormatting = keepCustomFormatting;
+    }
+    redo() {
+        this.oldState = this.modelManipulator.characterProperties.useValue.setValue(this.boundSubDocument, this.interval, this.newValue, this.keepCustomFormatting);
+    }
+    undo() {
+        this.modelManipulator.characterProperties.useValue.restoreValue(this.boundSubDocument, this.oldState);
+    }
+}
+class CharacterPropertiesHistoryItem extends interval_based_history_item_IntervalBasedHistoryItem {
+    constructor(modelManipulator, subDocInterval, newValue) {
+        super(modelManipulator, subDocInterval);
+        this.newValue = newValue;
+    }
+    redo() {
+        this.oldState = this.modelManipulator.characterProperties.setValue(this.boundSubDocument, this.interval, this.newValue);
+    }
+    undo() {
+        this.modelManipulator.characterProperties.restoreValue(this.boundSubDocument, this.oldState);
+    }
+}
+class CharacterPropertiesHistoryItemBase extends interval_based_history_item_IntervalBasedHistoryItem {
+    constructor(modelManipulator, subDocInterval, newValue, newUse) {
+        super(modelManipulator, subDocInterval);
+        this.newValue = newValue;
+        this.newUse = newUse;
+    }
+    redo() {
+        this.oldState = this.getPropertiesManipulator().setValue(this.boundSubDocument, this.interval, this.newValue, this.newUse);
+    }
+    undo() {
+        this.getPropertiesManipulator().restoreValue(this.boundSubDocument, this.oldState);
+    }
+    getPropertiesManipulator() {
+        throw new Error(errors/* Errors */.D.NotImplemented);
+    }
+}
+class FontBoldHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontBold;
+    }
+}
+class FontCapsHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontCaps;
+    }
+}
+class FontSmallCapsHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontSmallCaps;
+    }
+}
+class FontUnderlineTypeHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontUnderlineType;
+    }
+}
+class FontTextColorHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.textColor;
+    }
+}
+class FontShadingInfoHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.shadingInfo;
+    }
+}
+class FontHiddenHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontHidden;
+    }
+}
+class FontItalicHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontItalic;
+    }
+}
+class FontNameHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontName;
+    }
+}
+class FontScriptHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.script;
+    }
+}
+class FontSizeHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontSize;
+    }
+}
+class FontStrikeoutTypeHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontStrikeoutType;
+    }
+}
+class FontStrikeoutWordsOnlyHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontStrikeoutWordsOnly;
+    }
+}
+class FontStrikeoutColorHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontStrikeoutColor;
+    }
+}
+class FontUnderlineColorHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontUnderlineColor;
+    }
+}
+class FontHighlightColorHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontHighlightColor;
+    }
+}
+class FontUnderlineWordsOnlyHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontUnderlineWordsOnly;
+    }
+}
+class FontNoProofHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.fontNoProof;
+    }
+}
+class FontLangInfoHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.langInfo;
+    }
+}
+class FontCompositeFontInfoHistoryItem extends CharacterPropertiesHistoryItemBase {
+    getPropertiesManipulator() {
+        return this.modelManipulator.characterProperties.compositeFontInfo;
+    }
+}
+class ResetCharacterPropertiesUseValuesHistoryItem extends (/* unused pure expression or super */ null && (IntervalBasedHistoryItem)) {
+    redo() {
+        this.state = this.modelManipulator.characterProperties.useValue.setValue(this.boundSubDocument, this.interval, 0);
+    }
+    undo() {
+        this.modelManipulator.characterProperties.useValue.restoreValue(this.boundSubDocument, this.state);
+    }
+}
+
 ;// CONCATENATED MODULE: ./src/common/model/character/enums.ts
 var CharacterPropertiesMask;
 (function (CharacterPropertiesMask) {
@@ -9595,6 +9808,498 @@ class LangInfo {
     }
 }
 
+;// CONCATENATED MODULE: ./src/common/model/character/character-property-descriptor.ts
+
+
+
+
+
+
+
+
+class CharacterPropertiesAllCapsDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = false;
+    }
+    setProp(props, newValue) {
+        props.allCaps = newValue;
+    }
+    getProp(props) {
+        return props.allCaps;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseAllCaps;
+    }
+    getHistoryItemConstructor() {
+        return FontCapsHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.AllCaps;
+    }
+}
+class CharacterPropertiesSmallCapsDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = false;
+    }
+    setProp(props, newValue) {
+        props.smallCaps = newValue;
+    }
+    getProp(props) {
+        return props.smallCaps;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseSmallCaps;
+    }
+    getHistoryItemConstructor() {
+        return FontSmallCapsHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.SmallCaps;
+    }
+}
+class CharacterPropertiesFontSizeDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = 11;
+    }
+    setProp(props, newValue) {
+        props.fontSize = newValue;
+    }
+    getProp(props) {
+        return props.fontSize;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseDoubleFontSize;
+    }
+    getHistoryItemConstructor() {
+        return FontSizeHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.Size;
+    }
+}
+class CharacterPropertiesFontBoldDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = false;
+    }
+    setProp(props, newValue) {
+        props.fontBold = newValue;
+    }
+    getProp(props) {
+        return props.fontBold;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseFontBold;
+    }
+    getHistoryItemConstructor() {
+        return FontBoldHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.Bold;
+    }
+}
+class CharacterPropertiesFontItalicDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = false;
+    }
+    setProp(props, newValue) {
+        props.fontItalic = newValue;
+    }
+    getProp(props) {
+        return props.fontItalic;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseFontItalic;
+    }
+    getHistoryItemConstructor() {
+        return FontItalicHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.Italic;
+    }
+}
+class CharacterPropertiesFontInfoDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.object;
+        this.defaultValue = undefined;
+    }
+    setProp(props, newValue) {
+        props.fontInfo = newValue;
+    }
+    getProp(props) {
+        return props.fontInfo;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseFontName;
+    }
+    getHistoryItemConstructor() {
+        return FontNameHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.FontName;
+    }
+}
+class CharacterPropertiesScriptDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = CharacterFormattingScript.Normal;
+    }
+    setProp(props, newValue) {
+        props.script = newValue;
+    }
+    getProp(props) {
+        return props.script;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseScript;
+    }
+    getHistoryItemConstructor() {
+        return FontScriptHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.Script;
+    }
+}
+class CharacterPropertiesStrikeoutTypeDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = StrikeoutType.None;
+    }
+    setProp(props, newValue) {
+        props.fontStrikeoutType = newValue;
+    }
+    getProp(props) {
+        return props.fontStrikeoutType;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseFontStrikeoutType;
+    }
+    getHistoryItemConstructor() {
+        return FontStrikeoutTypeHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.StrikeoutType;
+    }
+}
+class CharacterPropertiesUnderlineTypeDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = UnderlineType.None;
+    }
+    setProp(props, newValue) {
+        props.fontUnderlineType = newValue;
+    }
+    getProp(props) {
+        return props.fontUnderlineType;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseFontUnderlineType;
+    }
+    getHistoryItemConstructor() {
+        return FontUnderlineTypeHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.UnderlineType;
+    }
+}
+class CharacterPropertiesUnderlineWordsOnlyDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = false;
+    }
+    setProp(props, newValue) {
+        props.underlineWordsOnly = newValue;
+    }
+    getProp(props) {
+        return props.underlineWordsOnly;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseUnderlineWordsOnly;
+    }
+    getHistoryItemConstructor() {
+        return FontUnderlineWordsOnlyHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.UnderlineWordsOnly;
+    }
+}
+class CharacterPropertiesStrikeoutWordsOnlyDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = false;
+    }
+    setProp(props, newValue) {
+        props.strikeoutWordsOnly = newValue;
+    }
+    getProp(props) {
+        return props.strikeoutWordsOnly;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseStrikeoutWordsOnly;
+    }
+    getHistoryItemConstructor() {
+        return FontStrikeoutWordsOnlyHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.StrikeoutWordsOnly;
+    }
+}
+class CharacterPropertiesNoProofDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = false;
+    }
+    setProp(props, newValue) {
+        props.noProof = newValue;
+    }
+    getProp(props) {
+        return props.noProof;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseNoProof;
+    }
+    getHistoryItemConstructor() {
+        return FontNoProofHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.NoProof;
+    }
+}
+class CharacterPropertiesHiddenDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.simpleType;
+        this.defaultValue = false;
+    }
+    setProp(props, newValue) {
+        props.hidden = newValue;
+    }
+    getProp(props) {
+        return props.hidden;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseHidden;
+    }
+    getHistoryItemConstructor() {
+        return FontHiddenHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.Hidden;
+    }
+}
+class CharacterPropertiesTextColorDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.object;
+        this.defaultValue = color_model_info_ColorModelInfo.autoColor;
+    }
+    setProp(props, newValue) {
+        props.textColor = newValue;
+    }
+    getProp(props) {
+        return props.textColor;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseForeColorIndex;
+    }
+    getHistoryItemConstructor() {
+        return FontTextColorHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.TextColor;
+    }
+}
+class CharacterPropertiesShadingInfoColorDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.object;
+        this.defaultValue = ShadingInfo.noColor;
+    }
+    setProp(props, newValue) {
+        props.shadingInfo = newValue;
+    }
+    getProp(props) {
+        return props.shadingInfo;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseShadingInfoIndex;
+    }
+    getHistoryItemConstructor() {
+        return FontShadingInfoHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.ShadingInfo;
+    }
+}
+class CharacterPropertiesStrikeoutColorDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.object;
+        this.defaultValue = color_model_info_ColorModelInfo.noColor;
+    }
+    setProp(props, newValue) {
+        props.strikeoutColor = newValue;
+    }
+    getProp(props) {
+        return props.strikeoutColor;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseStrikeoutColorIndex;
+    }
+    getHistoryItemConstructor() {
+        return FontStrikeoutColorHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.StrikeoutColor;
+    }
+}
+class CharacterPropertiesUnderlineColorDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.object;
+        this.defaultValue = color_model_info_ColorModelInfo.noColor;
+    }
+    setProp(props, newValue) {
+        props.underlineColor = newValue;
+    }
+    getProp(props) {
+        return props.underlineColor;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseUnderlineColorIndex;
+    }
+    getHistoryItemConstructor() {
+        return FontUnderlineColorHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.UnderlineColor;
+    }
+}
+class CharacterPropertiesHighlightColorDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.object;
+        this.defaultValue = color_model_info_ColorModelInfo.noColor;
+    }
+    setProp(props, newValue) {
+        props.highlightColor = newValue;
+    }
+    getProp(props) {
+        return props.highlightColor;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseHighlightColorIndex;
+    }
+    getHistoryItemConstructor() {
+        return FontHighlightColorHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.HighlightColor;
+    }
+}
+class CharacterPropertiesLangInfoDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.object;
+        this.defaultValue = new LangInfo();
+    }
+    setProp(props, newValue) {
+        props.langInfo = newValue;
+    }
+    getProp(props) {
+        return props.langInfo;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseLangInfo;
+    }
+    getHistoryItemConstructor() {
+        return FontLangInfoHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.LangInfo;
+    }
+}
+class CharacterPropertiesCompositeFontInfoDescriptor {
+    constructor() {
+        this.binaryEquals = comparers.Equals.object;
+        this.defaultValue = new CompositeFontInfo();
+    }
+    setProp(props, newValue) {
+        props.compositeFontInfo = newValue;
+    }
+    getProp(props) {
+        return props.compositeFontInfo;
+    }
+    maskValue() {
+        return CharacterPropertiesMask.UseCompositeFontInfo;
+    }
+    getHistoryItemConstructor() {
+        return FontCompositeFontInfoHistoryItem;
+    }
+    getJSONProperty() {
+        return JSONCharacterFormattingProperty.CompositeFontInfo;
+    }
+}
+class character_property_descriptor_CharacterPropertyDescriptor {
+}
+character_property_descriptor_CharacterPropertyDescriptor.allCaps = new CharacterPropertiesAllCapsDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.size = new CharacterPropertiesFontSizeDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.bold = new CharacterPropertiesFontBoldDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.italic = new CharacterPropertiesFontItalicDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.fontInfo = new CharacterPropertiesFontInfoDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.script = new CharacterPropertiesScriptDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.strikeoutType = new CharacterPropertiesStrikeoutTypeDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.underlineType = new CharacterPropertiesUnderlineTypeDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.underlineWordsOnly = new CharacterPropertiesUnderlineWordsOnlyDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.strikeoutWordsOnly = new CharacterPropertiesStrikeoutWordsOnlyDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.noProof = new CharacterPropertiesNoProofDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.hidden = new CharacterPropertiesHiddenDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.langInfo = new CharacterPropertiesLangInfoDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.compositeFontInfo = new CharacterPropertiesCompositeFontInfoDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.textColor = new CharacterPropertiesTextColorDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.shadingInfo = new CharacterPropertiesShadingInfoColorDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.highlightColor = new CharacterPropertiesHighlightColorDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.strikeoutColor = new CharacterPropertiesStrikeoutColorDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.underlineColor = new CharacterPropertiesUnderlineColorDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.smallCaps = new CharacterPropertiesSmallCapsDescriptor();
+character_property_descriptor_CharacterPropertyDescriptor.ALL_FIELDS = [
+    character_property_descriptor_CharacterPropertyDescriptor.allCaps,
+    character_property_descriptor_CharacterPropertyDescriptor.size,
+    character_property_descriptor_CharacterPropertyDescriptor.bold,
+    character_property_descriptor_CharacterPropertyDescriptor.italic,
+    character_property_descriptor_CharacterPropertyDescriptor.fontInfo,
+    character_property_descriptor_CharacterPropertyDescriptor.script,
+    character_property_descriptor_CharacterPropertyDescriptor.strikeoutType,
+    character_property_descriptor_CharacterPropertyDescriptor.underlineType,
+    character_property_descriptor_CharacterPropertyDescriptor.underlineWordsOnly,
+    character_property_descriptor_CharacterPropertyDescriptor.strikeoutWordsOnly,
+    character_property_descriptor_CharacterPropertyDescriptor.noProof,
+    character_property_descriptor_CharacterPropertyDescriptor.hidden,
+    character_property_descriptor_CharacterPropertyDescriptor.langInfo,
+    character_property_descriptor_CharacterPropertyDescriptor.compositeFontInfo,
+    character_property_descriptor_CharacterPropertyDescriptor.textColor,
+    character_property_descriptor_CharacterPropertyDescriptor.shadingInfo,
+    character_property_descriptor_CharacterPropertyDescriptor.highlightColor,
+    character_property_descriptor_CharacterPropertyDescriptor.strikeoutColor,
+    character_property_descriptor_CharacterPropertyDescriptor.underlineColor,
+    character_property_descriptor_CharacterPropertyDescriptor.smallCaps
+];
+character_property_descriptor_CharacterPropertyDescriptor.whatNeedSetWhenCreateHyperlinkField = [
+    character_property_descriptor_CharacterPropertyDescriptor.size,
+    character_property_descriptor_CharacterPropertyDescriptor.bold,
+    character_property_descriptor_CharacterPropertyDescriptor.italic,
+    character_property_descriptor_CharacterPropertyDescriptor.fontInfo,
+    character_property_descriptor_CharacterPropertyDescriptor.script,
+    character_property_descriptor_CharacterPropertyDescriptor.strikeoutType,
+    character_property_descriptor_CharacterPropertyDescriptor.allCaps,
+    character_property_descriptor_CharacterPropertyDescriptor.underlineWordsOnly,
+    character_property_descriptor_CharacterPropertyDescriptor.strikeoutWordsOnly,
+    character_property_descriptor_CharacterPropertyDescriptor.noProof,
+    character_property_descriptor_CharacterPropertyDescriptor.hidden,
+    character_property_descriptor_CharacterPropertyDescriptor.shadingInfo,
+    character_property_descriptor_CharacterPropertyDescriptor.strikeoutColor,
+    character_property_descriptor_CharacterPropertyDescriptor.underlineColor,
+    character_property_descriptor_CharacterPropertyDescriptor.langInfo,
+    character_property_descriptor_CharacterPropertyDescriptor.smallCaps
+];
+
 ;// CONCATENATED MODULE: ./src/common/model/character/layout-character-properties-color-info.ts
 class LayoutCharacterPropertiesColorInfo {
     constructor(textColor, foregroundColor, strikeoutColor, underlineColor) {
@@ -9627,6 +10332,7 @@ class LayoutCharacterPropertiesColorInfo {
 
 
 
+
 class CharacterProperties {
     constructor() {
         this.measurerSizes = Object.create(null);
@@ -9761,8 +10467,19 @@ class MaskedCharacterProperties extends CharacterProperties {
             this.useValueExt &= ~this.getHighPartUseValue(mask);
         }
     }
-    setUseValueFull(value) {
-        this.useValue = this.getLowPartUseValue(value);
+    setUseValueFull(value, onlyForDefault = false) {
+        const lowPartUseValue = this.getLowPartUseValue(value);
+        if (onlyForDefault) {
+            character_property_descriptor_CharacterPropertyDescriptor.ALL_FIELDS.forEach((desc) => {
+                const prop = desc.getProp(this);
+                const mask = desc.maskValue();
+                if (desc.binaryEquals(prop, desc.defaultValue))
+                    this.setUseValue(mask, !!(mask & lowPartUseValue));
+            });
+        }
+        else {
+            this.useValue = lowPartUseValue;
+        }
         this.useValueExt = this.getHighPartUseValue(value);
     }
     getLowPartUseValue(value) {
@@ -10176,7 +10893,7 @@ class LayoutBorder extends BorderBase {
 
 class BorderInfo {
     constructor() {
-        this.style = BorderLineStyle.None;
+        this.style = BorderLineStyle.Nil;
         this.color = ColorModelInfoCache.defaultItem;
         this.width = 0;
         this.offset = 0;
@@ -10226,66 +10943,6 @@ class BorderInfo {
     }
 }
 
-// EXTERNAL MODULE: ./node_modules/@devexpress/utils/lib/utils/comparers.js
-var comparers = __webpack_require__(4170);
-;// CONCATENATED MODULE: ./src/common/model/history/base/history-item.ts
-
-class history_item_HistoryItem {
-    constructor(modelManipulator) {
-        this.uniqueId = -1;
-        this.modelManipulator = modelManipulator;
-    }
-    canBeMerged() {
-        return false;
-    }
-    changeModified() {
-        return true;
-    }
-}
-class CompositionHistoryItem extends history_item_HistoryItem {
-    constructor() {
-        super(null);
-        this.historyItems = [];
-    }
-    canBeMerged() {
-        return true;
-    }
-    changeModified() {
-        var item;
-        for (var i = 0; item = this.historyItems[i]; i++) {
-            if (item.changeModified())
-                return true;
-        }
-        return false;
-    }
-    redo() {
-        var item;
-        for (var i = 0; item = this.historyItems[i]; i++)
-            item.redo();
-    }
-    undo() {
-        var item;
-        for (var i = this.historyItems.length - 1; item = this.historyItems[i]; i--)
-            item.undo();
-    }
-    add(historyItem) {
-        if (historyItem == null)
-            throw new Error(errors/* Errors */.D.ValueCannotBeNull);
-        this.historyItems.push(historyItem);
-    }
-}
-
-;// CONCATENATED MODULE: ./src/common/model/history/base/interval-based-history-item.ts
-
-class interval_based_history_item_IntervalBasedHistoryItem extends history_item_HistoryItem {
-    constructor(modelManipulator, subDocInterval) {
-        super(modelManipulator);
-        this.subDocInterval = subDocInterval;
-    }
-    get boundSubDocument() { return this.subDocInterval.subDocument; }
-    get interval() { return this.subDocInterval.interval; }
-}
-
 ;// CONCATENATED MODULE: ./src/common/model/history/items/paragraph-properties-history-items.ts
 
 
@@ -11455,650 +12112,6 @@ class LineSpacingUnit {
     }
 }
 
-;// CONCATENATED MODULE: ./src/common/model/history/items/character-properties-history-items.ts
-
-
-class FontUseValueHistoryItem extends interval_based_history_item_IntervalBasedHistoryItem {
-    constructor(modelManipulator, subDocInterval, newValue) {
-        super(modelManipulator, subDocInterval);
-        this.newValue = newValue;
-    }
-    redo() {
-        this.oldState = this.modelManipulator.characterProperties.useValue.setValue(this.boundSubDocument, this.interval, this.newValue);
-    }
-    undo() {
-        this.modelManipulator.characterProperties.useValue.restoreValue(this.boundSubDocument, this.oldState);
-    }
-}
-class CharacterPropertiesHistoryItem extends interval_based_history_item_IntervalBasedHistoryItem {
-    constructor(modelManipulator, subDocInterval, newValue) {
-        super(modelManipulator, subDocInterval);
-        this.newValue = newValue;
-    }
-    redo() {
-        this.oldState = this.modelManipulator.characterProperties.setValue(this.boundSubDocument, this.interval, this.newValue);
-    }
-    undo() {
-        this.modelManipulator.characterProperties.restoreValue(this.boundSubDocument, this.oldState);
-    }
-}
-class CharacterPropertiesHistoryItemBase extends interval_based_history_item_IntervalBasedHistoryItem {
-    constructor(modelManipulator, subDocInterval, newValue, newUse) {
-        super(modelManipulator, subDocInterval);
-        this.newValue = newValue;
-        this.newUse = newUse;
-    }
-    redo() {
-        this.oldState = this.getPropertiesManipulator().setValue(this.boundSubDocument, this.interval, this.newValue, this.newUse);
-    }
-    undo() {
-        this.getPropertiesManipulator().restoreValue(this.boundSubDocument, this.oldState);
-    }
-    getPropertiesManipulator() {
-        throw new Error(errors/* Errors */.D.NotImplemented);
-    }
-}
-class FontBoldHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontBold;
-    }
-}
-class FontCapsHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontCaps;
-    }
-}
-class FontSmallCapsHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontSmallCaps;
-    }
-}
-class FontUnderlineTypeHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontUnderlineType;
-    }
-}
-class FontTextColorHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.textColor;
-    }
-}
-class FontShadingInfoHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.shadingInfo;
-    }
-}
-class FontHiddenHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontHidden;
-    }
-}
-class FontItalicHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontItalic;
-    }
-}
-class FontNameHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontName;
-    }
-}
-class FontScriptHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.script;
-    }
-}
-class FontSizeHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontSize;
-    }
-}
-class FontStrikeoutTypeHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontStrikeoutType;
-    }
-}
-class FontStrikeoutWordsOnlyHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontStrikeoutWordsOnly;
-    }
-}
-class FontStrikeoutColorHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontStrikeoutColor;
-    }
-}
-class FontUnderlineColorHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontUnderlineColor;
-    }
-}
-class FontHighlightColorHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontHighlightColor;
-    }
-}
-class FontUnderlineWordsOnlyHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontUnderlineWordsOnly;
-    }
-}
-class FontNoProofHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.fontNoProof;
-    }
-}
-class FontLangInfoHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.langInfo;
-    }
-}
-class FontCompositeFontInfoHistoryItem extends CharacterPropertiesHistoryItemBase {
-    getPropertiesManipulator() {
-        return this.modelManipulator.characterProperties.compositeFontInfo;
-    }
-}
-class ResetCharacterPropertiesUseValuesHistoryItem extends (/* unused pure expression or super */ null && (IntervalBasedHistoryItem)) {
-    redo() {
-        this.state = this.modelManipulator.characterProperties.useValue.setValue(this.boundSubDocument, this.interval, 0);
-    }
-    undo() {
-        this.modelManipulator.characterProperties.useValue.restoreValue(this.boundSubDocument, this.state);
-    }
-}
-
-;// CONCATENATED MODULE: ./src/common/model/character/character-property-descriptor.ts
-
-
-
-
-
-
-
-
-class CharacterPropertiesAllCapsDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = false;
-    }
-    setProp(props, newValue) {
-        props.allCaps = newValue;
-    }
-    getProp(props) {
-        return props.allCaps;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseAllCaps;
-    }
-    getHistoryItemConstructor() {
-        return FontCapsHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.AllCaps;
-    }
-}
-class CharacterPropertiesSmallCapsDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = false;
-    }
-    setProp(props, newValue) {
-        props.smallCaps = newValue;
-    }
-    getProp(props) {
-        return props.smallCaps;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseSmallCaps;
-    }
-    getHistoryItemConstructor() {
-        return FontSmallCapsHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.SmallCaps;
-    }
-}
-class CharacterPropertiesFontSizeDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = 11;
-    }
-    setProp(props, newValue) {
-        props.fontSize = newValue;
-    }
-    getProp(props) {
-        return props.fontSize;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseDoubleFontSize;
-    }
-    getHistoryItemConstructor() {
-        return FontSizeHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.Size;
-    }
-}
-class CharacterPropertiesFontBoldDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = false;
-    }
-    setProp(props, newValue) {
-        props.fontBold = newValue;
-    }
-    getProp(props) {
-        return props.fontBold;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseFontBold;
-    }
-    getHistoryItemConstructor() {
-        return FontBoldHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.Bold;
-    }
-}
-class CharacterPropertiesFontItalicDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = false;
-    }
-    setProp(props, newValue) {
-        props.fontItalic = newValue;
-    }
-    getProp(props) {
-        return props.fontItalic;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseFontItalic;
-    }
-    getHistoryItemConstructor() {
-        return FontItalicHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.Italic;
-    }
-}
-class CharacterPropertiesFontInfoDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.object;
-        this.defaultValue = undefined;
-    }
-    setProp(props, newValue) {
-        props.fontInfo = newValue;
-    }
-    getProp(props) {
-        return props.fontInfo;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseFontName;
-    }
-    getHistoryItemConstructor() {
-        return FontNameHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.FontName;
-    }
-}
-class CharacterPropertiesScriptDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = CharacterFormattingScript.Normal;
-    }
-    setProp(props, newValue) {
-        props.script = newValue;
-    }
-    getProp(props) {
-        return props.script;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseScript;
-    }
-    getHistoryItemConstructor() {
-        return FontScriptHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.Script;
-    }
-}
-class CharacterPropertiesStrikeoutTypeDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = StrikeoutType.None;
-    }
-    setProp(props, newValue) {
-        props.fontStrikeoutType = newValue;
-    }
-    getProp(props) {
-        return props.fontStrikeoutType;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseFontStrikeoutType;
-    }
-    getHistoryItemConstructor() {
-        return FontStrikeoutTypeHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.StrikeoutType;
-    }
-}
-class CharacterPropertiesUnderlineTypeDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = UnderlineType.None;
-    }
-    setProp(props, newValue) {
-        props.fontUnderlineType = newValue;
-    }
-    getProp(props) {
-        return props.fontUnderlineType;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseFontUnderlineType;
-    }
-    getHistoryItemConstructor() {
-        return FontUnderlineTypeHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.UnderlineType;
-    }
-}
-class CharacterPropertiesUnderlineWordsOnlyDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = false;
-    }
-    setProp(props, newValue) {
-        props.underlineWordsOnly = newValue;
-    }
-    getProp(props) {
-        return props.underlineWordsOnly;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseUnderlineWordsOnly;
-    }
-    getHistoryItemConstructor() {
-        return FontUnderlineWordsOnlyHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.UnderlineWordsOnly;
-    }
-}
-class CharacterPropertiesStrikeoutWordsOnlyDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = false;
-    }
-    setProp(props, newValue) {
-        props.strikeoutWordsOnly = newValue;
-    }
-    getProp(props) {
-        return props.strikeoutWordsOnly;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseStrikeoutWordsOnly;
-    }
-    getHistoryItemConstructor() {
-        return FontStrikeoutWordsOnlyHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.StrikeoutWordsOnly;
-    }
-}
-class CharacterPropertiesNoProofDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = false;
-    }
-    setProp(props, newValue) {
-        props.noProof = newValue;
-    }
-    getProp(props) {
-        return props.noProof;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseNoProof;
-    }
-    getHistoryItemConstructor() {
-        return FontNoProofHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.NoProof;
-    }
-}
-class CharacterPropertiesHiddenDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.simpleType;
-        this.defaultValue = false;
-    }
-    setProp(props, newValue) {
-        props.hidden = newValue;
-    }
-    getProp(props) {
-        return props.hidden;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseHidden;
-    }
-    getHistoryItemConstructor() {
-        return FontHiddenHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.Hidden;
-    }
-}
-class CharacterPropertiesTextColorDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.object;
-        this.defaultValue = color_model_info_ColorModelInfo.autoColor;
-    }
-    setProp(props, newValue) {
-        props.textColor = newValue;
-    }
-    getProp(props) {
-        return props.textColor;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseForeColorIndex;
-    }
-    getHistoryItemConstructor() {
-        return FontTextColorHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.TextColor;
-    }
-}
-class CharacterPropertiesShadingInfoColorDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.object;
-        this.defaultValue = ShadingInfo.noColor;
-    }
-    setProp(props, newValue) {
-        props.shadingInfo = newValue;
-    }
-    getProp(props) {
-        return props.shadingInfo;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseShadingInfoIndex;
-    }
-    getHistoryItemConstructor() {
-        return FontShadingInfoHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.ShadingInfo;
-    }
-}
-class CharacterPropertiesStrikeoutColorDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.object;
-        this.defaultValue = color_model_info_ColorModelInfo.noColor;
-    }
-    setProp(props, newValue) {
-        props.strikeoutColor = newValue;
-    }
-    getProp(props) {
-        return props.strikeoutColor;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseStrikeoutColorIndex;
-    }
-    getHistoryItemConstructor() {
-        return FontStrikeoutColorHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.StrikeoutColor;
-    }
-}
-class CharacterPropertiesUnderlineColorDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.object;
-        this.defaultValue = color_model_info_ColorModelInfo.noColor;
-    }
-    setProp(props, newValue) {
-        props.underlineColor = newValue;
-    }
-    getProp(props) {
-        return props.underlineColor;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseUnderlineColorIndex;
-    }
-    getHistoryItemConstructor() {
-        return FontUnderlineColorHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.UnderlineColor;
-    }
-}
-class CharacterPropertiesHighlightColorDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.object;
-        this.defaultValue = color_model_info_ColorModelInfo.noColor;
-    }
-    setProp(props, newValue) {
-        props.highlightColor = newValue;
-    }
-    getProp(props) {
-        return props.highlightColor;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseHighlightColorIndex;
-    }
-    getHistoryItemConstructor() {
-        return FontHighlightColorHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.HighlightColor;
-    }
-}
-class CharacterPropertiesLangInfoDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.object;
-        this.defaultValue = new LangInfo();
-    }
-    setProp(props, newValue) {
-        props.langInfo = newValue;
-    }
-    getProp(props) {
-        return props.langInfo;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseLangInfo;
-    }
-    getHistoryItemConstructor() {
-        return FontLangInfoHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.LangInfo;
-    }
-}
-class CharacterPropertiesCompositeFontInfoDescriptor {
-    constructor() {
-        this.binaryEquals = comparers.Equals.object;
-        this.defaultValue = new CompositeFontInfo();
-    }
-    setProp(props, newValue) {
-        props.compositeFontInfo = newValue;
-    }
-    getProp(props) {
-        return props.compositeFontInfo;
-    }
-    maskValue() {
-        return CharacterPropertiesMask.UseCompositeFontInfo;
-    }
-    getHistoryItemConstructor() {
-        return FontCompositeFontInfoHistoryItem;
-    }
-    getJSONProperty() {
-        return JSONCharacterFormattingProperty.CompositeFontInfo;
-    }
-}
-class character_property_descriptor_CharacterPropertyDescriptor {
-}
-character_property_descriptor_CharacterPropertyDescriptor.allCaps = new CharacterPropertiesAllCapsDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.size = new CharacterPropertiesFontSizeDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.bold = new CharacterPropertiesFontBoldDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.italic = new CharacterPropertiesFontItalicDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.fontInfo = new CharacterPropertiesFontInfoDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.script = new CharacterPropertiesScriptDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.strikeoutType = new CharacterPropertiesStrikeoutTypeDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.underlineType = new CharacterPropertiesUnderlineTypeDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.underlineWordsOnly = new CharacterPropertiesUnderlineWordsOnlyDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.strikeoutWordsOnly = new CharacterPropertiesStrikeoutWordsOnlyDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.noProof = new CharacterPropertiesNoProofDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.hidden = new CharacterPropertiesHiddenDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.langInfo = new CharacterPropertiesLangInfoDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.compositeFontInfo = new CharacterPropertiesCompositeFontInfoDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.textColor = new CharacterPropertiesTextColorDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.shadingInfo = new CharacterPropertiesShadingInfoColorDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.highlightColor = new CharacterPropertiesHighlightColorDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.strikeoutColor = new CharacterPropertiesStrikeoutColorDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.underlineColor = new CharacterPropertiesUnderlineColorDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.smallCaps = new CharacterPropertiesSmallCapsDescriptor();
-character_property_descriptor_CharacterPropertyDescriptor.ALL_FIELDS = [
-    character_property_descriptor_CharacterPropertyDescriptor.allCaps,
-    character_property_descriptor_CharacterPropertyDescriptor.size,
-    character_property_descriptor_CharacterPropertyDescriptor.bold,
-    character_property_descriptor_CharacterPropertyDescriptor.italic,
-    character_property_descriptor_CharacterPropertyDescriptor.fontInfo,
-    character_property_descriptor_CharacterPropertyDescriptor.script,
-    character_property_descriptor_CharacterPropertyDescriptor.strikeoutType,
-    character_property_descriptor_CharacterPropertyDescriptor.underlineType,
-    character_property_descriptor_CharacterPropertyDescriptor.underlineWordsOnly,
-    character_property_descriptor_CharacterPropertyDescriptor.strikeoutWordsOnly,
-    character_property_descriptor_CharacterPropertyDescriptor.noProof,
-    character_property_descriptor_CharacterPropertyDescriptor.hidden,
-    character_property_descriptor_CharacterPropertyDescriptor.langInfo,
-    character_property_descriptor_CharacterPropertyDescriptor.compositeFontInfo,
-    character_property_descriptor_CharacterPropertyDescriptor.textColor,
-    character_property_descriptor_CharacterPropertyDescriptor.shadingInfo,
-    character_property_descriptor_CharacterPropertyDescriptor.highlightColor,
-    character_property_descriptor_CharacterPropertyDescriptor.strikeoutColor,
-    character_property_descriptor_CharacterPropertyDescriptor.underlineColor,
-    character_property_descriptor_CharacterPropertyDescriptor.smallCaps
-];
-character_property_descriptor_CharacterPropertyDescriptor.whatNeedSetWhenCreateHyperlinkField = [
-    character_property_descriptor_CharacterPropertyDescriptor.size,
-    character_property_descriptor_CharacterPropertyDescriptor.bold,
-    character_property_descriptor_CharacterPropertyDescriptor.italic,
-    character_property_descriptor_CharacterPropertyDescriptor.fontInfo,
-    character_property_descriptor_CharacterPropertyDescriptor.script,
-    character_property_descriptor_CharacterPropertyDescriptor.strikeoutType,
-    character_property_descriptor_CharacterPropertyDescriptor.allCaps,
-    character_property_descriptor_CharacterPropertyDescriptor.underlineWordsOnly,
-    character_property_descriptor_CharacterPropertyDescriptor.strikeoutWordsOnly,
-    character_property_descriptor_CharacterPropertyDescriptor.noProof,
-    character_property_descriptor_CharacterPropertyDescriptor.hidden,
-    character_property_descriptor_CharacterPropertyDescriptor.shadingInfo,
-    character_property_descriptor_CharacterPropertyDescriptor.strikeoutColor,
-    character_property_descriptor_CharacterPropertyDescriptor.underlineColor,
-    character_property_descriptor_CharacterPropertyDescriptor.langInfo,
-    character_property_descriptor_CharacterPropertyDescriptor.smallCaps
-];
-
 ;// CONCATENATED MODULE: ./src/common/model/borders/table-border-base.ts
 
 class TableBordersBase {
@@ -12281,6 +12294,7 @@ var ConditionalTableStyleFormatting;
     ConditionalTableStyleFormatting[ConditionalTableStyleFormatting["TopLeftCell"] = 4] = "TopLeftCell";
     ConditionalTableStyleFormatting[ConditionalTableStyleFormatting["BottomRightCell"] = 2] = "BottomRightCell";
     ConditionalTableStyleFormatting[ConditionalTableStyleFormatting["BottomLeftCell"] = 1] = "BottomLeftCell";
+    ConditionalTableStyleFormatting[ConditionalTableStyleFormatting["None"] = 0] = "None";
 })(ConditionalTableStyleFormatting || (ConditionalTableStyleFormatting = {}));
 
 ;// CONCATENATED MODULE: ./src/common/model/tables/secondary-structures/table-units.ts
@@ -19160,8 +19174,6 @@ class TableAlignmentApplier {
                 offset = 0;
                 break;
         }
-        if (offset <= 0)
-            return;
         TableAlignmentApplier.moveAllTable(currTableColumnInfo, (rect) => rect.x += offset);
     }
     static applyCellsVerticalAlignment(defaultTableCellProps, grid, currTableColumnInfo, rowInfo) {
@@ -19655,15 +19667,16 @@ class TabProperties {
     }
 }
 class TabInfo {
-    constructor(position, alignment, leader, deleted, isDefault) {
+    constructor(position, alignment, leader, deleted, isDefault, isParagraphIndent = false) {
         this.position = position;
         this.alignment = alignment;
         this.leader = leader;
         this.isDefault = isDefault;
         this.deleted = deleted;
+        this.isParagraphIndent = isParagraphIndent;
     }
     clone() {
-        return new TabInfo(this.position, this.alignment, this.leader, this.deleted, this.isDefault);
+        return new TabInfo(this.position, this.alignment, this.leader, this.deleted, this.isDefault, this.isParagraphIndent);
     }
     equals(obj) {
         if (!obj)
@@ -19672,7 +19685,8 @@ class TabInfo {
             this.leader == obj.leader &&
             this.position == obj.position &&
             this.deleted == obj.deleted &&
-            this.isDefault == obj.isDefault;
+            this.isDefault == obj.isDefault &&
+            this.isParagraphIndent == obj.isParagraphIndent;
     }
 }
 
@@ -32115,6 +32129,14 @@ class LayoutPage extends rectangle.Rectangle {
         this.anchoredObjectHolder = new PageAnchoredObjectHolder(this);
         this.tableAnchoredObjectsHolder = new TableAnchoredObjectsHolder();
     }
+    get grids() {
+        const result = new Map();
+        for (let pageArea of this.mainSubDocumentPageAreas)
+            pageArea.grids.forEach((grid, table) => result.set(table, grid));
+        for (let pageArea of Object.values(this.otherPageAreas))
+            pageArea.grids.forEach((grid, table) => result.set(table, grid));
+        return result;
+    }
     setRenderLevelCalculator(anchorObjectsPositionInfo, compatibilityMode) {
         this.renderLevelCalculator = new RenderLevelCalculator();
         this.renderLevelCalculator.calcLevels(this.anchoredObjectHolder, anchorObjectsPositionInfo, compatibilityMode);
@@ -40300,7 +40322,7 @@ class CharacterPropertiesUseValueManipulator {
     constructor(manipulator) {
         this.manipulator = manipulator;
     }
-    setValue(subDocument, interval, newValue) {
+    setValue(subDocument, interval, newValue, keepCustomFormatting = false) {
         var oldState = new HistoryItemIntervalState();
         if (!ControlOptions.isEnabled(subDocument.documentModel.options.characterFormatting))
             return oldState;
@@ -40310,7 +40332,7 @@ class CharacterPropertiesUseValueManipulator {
             var run = iterator.currentRun;
             oldState.register(new HistoryItemIntervalStateObject(iterator.currentInterval(), run.maskedCharacterProperties.getUseValueFull()));
             var properties = run.maskedCharacterProperties.clone();
-            properties.setUseValueFull(newValue);
+            properties.setUseValueFull(newValue, keepCustomFormatting);
             run.setCharacterProperties(properties);
             run.onCharacterPropertiesChanged();
         }
@@ -49839,11 +49861,13 @@ class RtfStyleExporter {
 
 
 
+
 class RtfTableExporterStateBase {
-    constructor(rtfExporter, table, nestingLevel) {
+    constructor(rtfExporter, table, grid, nestingLevel) {
         this.rtfExporter = rtfExporter;
         this._nestingLevel = nestingLevel;
         this.table = table;
+        this.grid = grid;
         this.tableRowPropertiesExporter = new RtfTableRowPropertiesExporter(rtfExporter.documentModel, rtfExporter.rtfExportHelper, rtfExporter.rtfBuilder);
         this.tableCellPropertiesExporter = new RtfTableCellPropertiesExporter(rtfExporter.documentModel, rtfExporter.rtfExportHelper, rtfExporter.rtfBuilder);
         this.tablePropertiesExporter = new RtfTablePropertiesExporter(rtfExporter.documentModel, rtfExporter.rtfExportHelper, rtfExporter.rtfBuilder);
@@ -49918,7 +49942,7 @@ class RtfTableExporterStateBase {
         while (parentCell !== nestedTable.parentCell) {
             nestedTable = nestedTable.parentCell.parentRow.parentTable;
         }
-        return RtfTableExporter.exportNestedTable(this.rtfExporter, nestedTable, this.nestingLevel + 1);
+        return RtfTableExporter.exportNestedTable(this.rtfExporter, nestedTable, this.grid, this.nestingLevel + 1);
     }
     exportRowProperties(row, rowIndex) {
         const rowLeft = this.calculateRowLeft(row, row.parentTable.getActualTableIndent(this.documentModel.defaultTableProperties));
@@ -49926,20 +49950,25 @@ class RtfTableExporterStateBase {
         let cellRightVirtualColInd = row.gridBefore;
         for (const cell of row.cells) {
             cellRightVirtualColInd += cell.columnSpan;
-            const cellRight = rowLeft + this.getCellWidth(cellRightVirtualColInd);
+            const cellWidth = this.getCellWidth(row.gridBefore, cellRightVirtualColInd);
+            const cellRight = unit_converter/* UnitConverter */.u.pixelsToTwips(rowLeft + cellWidth);
             this.exportCellProperties(cell, cellRight);
         }
     }
-    getCellWidth(virtualColumnIndex) {
-        if (virtualColumnIndex < 0)
+    getCellWidth(leftSideIndex, columnSpan) {
+        if (leftSideIndex < 0 || columnSpan < 0)
             throw new Error(errors/* Errors */.D.InternalException);
-        const minVirtualColumnWidth = 10;
-        return virtualColumnIndex * minVirtualColumnWidth;
+        let result = 0;
+        for (let i = 0; i < columnSpan; i++)
+            result += Math.max(this.grid.columns.width[i + leftSideIndex], 1);
+        return result;
     }
     calculateRowLeft(row, indent) {
-        const widthBefore = row.gridBefore > 0 ? this.getCellWidth(row.gridBefore) : 0;
+        var _a;
+        const widthBefore = row.gridBefore > 0 ? this.getCellWidth(0, row.gridBefore) : 0;
         const offset = this.getActualWidth(indent) + widthBefore;
-        return offset - (this.rowLeftOffset != null ? this.rowLeftOffset : this.calculateRowLeftOffset(row));
+        const rowLeftOffset = (_a = this.rowLeftOffset) !== null && _a !== void 0 ? _a : this.calculateRowLeftOffset(row);
+        return offset - rowLeftOffset;
     }
     calculateRowLeftOffset(row) {
         const borderWidth = row.cells[0].properties.borders.left.width;
@@ -50049,8 +50078,8 @@ class RtfTableExporterStateBase {
 
 
 class RtfNestedTableExporterState extends RtfTableExporterStateBase {
-    constructor(rtfExporter, table, nestingLevel) {
-        super(rtfExporter, table, nestingLevel);
+    constructor(rtfExporter, table, grid, nestingLevel) {
+        super(rtfExporter, table, grid, nestingLevel);
     }
     export() {
         super.exportBase();
@@ -50079,8 +50108,8 @@ class RtfNestedTableExporterState extends RtfTableExporterStateBase {
 
 
 class RtfTableExporterState extends RtfTableExporterStateBase {
-    constructor(rtfExporter, table) {
-        super(rtfExporter, table, 1);
+    constructor(rtfExporter, table, grid) {
+        super(rtfExporter, table, grid, 1);
     }
     export() {
         super.exportBase();
@@ -50099,13 +50128,13 @@ class RtfTableExporterState extends RtfTableExporterStateBase {
 
 
 class RtfTableExporter {
-    static exportTable(rtfContentExporter, table) {
-        new RtfTableExporterState(rtfContentExporter, table).export();
+    static exportTable(rtfContentExporter, table, grid) {
+        new RtfTableExporterState(rtfContentExporter, table, grid).export();
         rtfContentExporter.tableIterator.update(table.getEndPosition());
         return rtfContentExporter.subDocument.getParagraphIndexByPosition(table.getEndPosition() - 1);
     }
-    static exportNestedTable(rtfContentExporter, table, nestingLevel) {
-        new RtfNestedTableExporterState(rtfContentExporter, table, nestingLevel).export();
+    static exportNestedTable(rtfContentExporter, table, grid, nestingLevel) {
+        new RtfNestedTableExporterState(rtfContentExporter, table, grid, nestingLevel).export();
         rtfContentExporter.tableIterator.update(table.getEndPosition());
         return rtfContentExporter.subDocument.getParagraphIndexByPosition(table.getEndPosition() - 1);
     }
@@ -50149,17 +50178,17 @@ class RtfTableExporter {
 
 
 class RtfContentExporter {
-    constructor(documentModel, options, rtfExportHelper) {
+    constructor(exportModelOptions, options, rtfExportHelper) {
         this.shouldFourceUpdateIterators = false;
-        this.documentModel = documentModel;
+        this.exportModelOptions = exportModelOptions;
         this.subDocument = this.documentModel.mainSubDocument;
         this.pieceTableNumberingListCounters = new PieceTableNumberingListCountersManager();
         this.rtfExportHelper = rtfExportHelper;
         this.options = options;
         this.rtfBuilder = this.createRtfBuilder();
-        this.paragraphPropertiesExporter = new RtfParagraphPropertiesExporter(documentModel, rtfExportHelper, this.rtfBuilder);
-        this.characterPropertiesExporter = new RtfCharacterPropertiesExporter(documentModel, rtfExportHelper, this.rtfBuilder, options);
-        this.sectionPropertiesExporter = new RtfSectionPropertiesExporter(documentModel, rtfExportHelper, this.rtfBuilder);
+        this.paragraphPropertiesExporter = new RtfParagraphPropertiesExporter(this.documentModel, rtfExportHelper, this.rtfBuilder);
+        this.characterPropertiesExporter = new RtfCharacterPropertiesExporter(this.documentModel, rtfExportHelper, this.rtfBuilder, options);
+        this.sectionPropertiesExporter = new RtfSectionPropertiesExporter(this.documentModel, rtfExportHelper, this.rtfBuilder);
         this.runHandlerMap = new MapCreator()
             .add(RunType.TextRun, this.exportTextRun)
             .add(RunType.FieldCodeStartRun, this.fieldCodeStartRunHandler)
@@ -50173,6 +50202,7 @@ class RtfContentExporter {
     }
     get shouldExportHiddenText() { return true; }
     ;
+    get documentModel() { return this.exportModelOptions.modelManager.modelManipulator.model; }
     createRtfBuilder() {
         return new RtfBuilder();
     }
@@ -50371,7 +50401,7 @@ class RtfContentExporter {
             value = "00000000";
         }
         else {
-            const view = new DataView(hash, 0);
+            const view = new DataView(hash.buffer, 0);
             const hashValue = view.getInt32(0);
             value = this.documentModel.simpleFormattersManager.formatString("{0:x8}", hashValue);
         }
@@ -50547,11 +50577,14 @@ class RtfContentExporter {
             this.exportSingleParagraph(paragraph);
             return paragraphIndex;
         }
-        else
-            return RtfTableExporter.exportTable(this, tablesInfo[0].table.getTopLevelParent()) - this.startSectionParagraphIndex;
+        else {
+            const table = tablesInfo[0].table.getTopLevelParent();
+            const grid = this.exportModelOptions.grids.get(table);
+            return RtfTableExporter.exportTable(this, table, grid) - this.startSectionParagraphIndex;
+        }
     }
     exportSingleParagraph(paragraph) {
-        this.exportParagraphCore(paragraph, 0, 0, -1);
+        this.exportParagraphCore(paragraph, 0, ConditionalTableStyleFormatting.None, -1);
         this.finishParagraph(paragraph);
     }
     finishParagraph(paragraph) {
@@ -51080,11 +51113,11 @@ class RtfExportHelper {
 
 
 class RtfExporter {
-    constructor(modelManipulator, options) {
-        this.modelManipulator = modelManipulator;
+    constructor(exportModelOptions, options) {
+        this.modelManipulator = exportModelOptions.modelManager.modelManipulator;
         this.options = options;
         this.rtfExportHelper = new RtfExportHelper();
-        this.contentExporter = new RtfContentExporter(this.documentModel, options, this.rtfExportHelper);
+        this.contentExporter = new RtfContentExporter(exportModelOptions, options, this.rtfExportHelper);
         this.rtfBuilder = this.contentExporter.createRtfBuilder();
     }
     get documentModel() { return this.modelManipulator.model; }
@@ -65204,10 +65237,11 @@ function getAfterInsertReject(callback) {
 
 
 
-function getRtfFromSubDocumentPublic(richOptions, subDocument, coreInterval) {
+function getRtfFromSubDocumentPublic(processor, subDocument, coreInterval) {
     const rangeCopy = RangeCopy.create(new SubDocumentIntervals(subDocument, [coreInterval]));
-    const newModelManager = new ClientModelManager(rangeCopy.model, richOptions, new batch_updatable/* EmptyBatchUpdatableObject */.m1());
-    return new RtfExporter(newModelManager.modelManipulator, new RtfDocumentExporterOptions()).exportAsString();
+    const newModelManager = new ClientModelManager(rangeCopy.model, processor.modelManager.richOptions, new batch_updatable/* EmptyBatchUpdatableObject */.m1());
+    const exportModelOptions = processor.getExportModelOptions({ modelManager: newModelManager });
+    return new RtfExporter(exportModelOptions, new RtfDocumentExporterOptions()).exportAsString();
 }
 function insertRtfInSubDocumentPublic(processor, subDocument, position, rtf, callback) {
     const options = new RtfImporterOptions(() => { });
@@ -70460,6 +70494,12 @@ class DocumentLayout {
         this.anchorObjectsPositionInfo = anchorObjectsPositionInfo;
         this.setEmptyLayout(ColorHelper.NO_COLOR);
     }
+    get grids() {
+        return this.pages.reduce((res, page) => {
+            page.grids.forEach((grid, table) => res.set(table, grid));
+            return res;
+        }, new Map());
+    }
     setEmptyLayout(pageColor) {
         this.pages = [];
         this.validPageCount = 0;
@@ -81456,10 +81496,12 @@ class ParagraphSpacingDestination extends ParagraphFormattingLeafElementDestinat
             const spacingBefore = this.data.readerHelper.getWpSTIntegerValue(reader, 'before', constants.Constants.MIN_SAFE_INTEGER);
             if (spacingBefore >= 0)
                 this.paragraphProperties.setValue(ParagraphPropertyDescriptor.spacingBefore, spacingBefore);
-            this.paragraphProperties.setValue(ParagraphPropertyDescriptor.beforeAutoSpacing, spacingBefore == -1 ||
-                this.data.readerHelper.getWpSTOnOffValue(reader, new WordProcessingMLValue('beforeAutospacing', 'before-autospacing').openXmlValue, false));
-            this.paragraphProperties.setValue(ParagraphPropertyDescriptor.afterAutoSpacing, spacingAfter == -1 ||
-                this.data.readerHelper.getWpSTOnOffValue(reader, new WordProcessingMLValue('afterAutospacing', 'after-autospacing').openXmlValue, false));
+            const beforeAutoSpacing = this.data.readerHelper.getWpSTOnOffValue(reader, 'beforeAutospacing', null);
+            if (spacingBefore == -1 || beforeAutoSpacing != null)
+                this.paragraphProperties.setValue(ParagraphPropertyDescriptor.beforeAutoSpacing, spacingBefore == -1 || beforeAutoSpacing);
+            const afterAutoSpacing = this.data.readerHelper.getWpSTOnOffValue(reader, 'afterAutospacing', null);
+            if (spacingAfter == -1 || afterAutoSpacing != null)
+                this.paragraphProperties.setValue(ParagraphPropertyDescriptor.afterAutoSpacing, spacingAfter == -1 || afterAutoSpacing);
             const lineSpacing = this.data.readerHelper.getWpSTIntegerValue(reader, 'line', constants.Constants.MIN_SAFE_INTEGER);
             if (lineSpacing != constants.Constants.MIN_SAFE_INTEGER && lineSpacing > 0) {
                 const attribute = new WordProcessingMLValue('lineRule', 'line-rule');
@@ -85071,7 +85113,7 @@ class SubDocumentApi {
     }
     getRtf(interval) {
         const coreInterval = this._checkInterval(interval);
-        return getRtfFromSubDocumentPublic(this._processor.modelManager.richOptions, this._subDocument, coreInterval);
+        return getRtfFromSubDocumentPublic(this._processor, this._subDocument, coreInterval);
     }
     insertContent(position, content, documentFormat, callback) {
         position = ApiParametersChecker.check(position, 1, false, [
@@ -88498,21 +88540,13 @@ class SectionExporter extends BaseExporter {
         this.exportSectionGeneralSettings(props);
     }
     exportSectionPage(props) {
-        if (!this.shouldExportSectionPage(props))
-            return;
         this.writer.writeWpStartElement('pgSz');
-        if (props.pageSize.width != SectionExporter.defaultProps.pageSize.width)
-            this.writer.writeWpIntAttr('w', props.pageSize.width);
-        if (props.pageSize.height != SectionExporter.defaultProps.pageSize.height)
-            this.writer.writeWpIntAttr('h', props.pageSize.height);
+        this.writer.writeWpIntAttr('w', props.pageSize.width);
+        this.writer.writeWpIntAttr('h', props.pageSize.height);
         if (props.landscape)
             this.writer.writeWpStringAttr('orient', props.landscape ? 'landscape' : 'portrait');
         this.writer.endElement();
     }
-    shouldExportSectionPage(props) {
-        return !props.pageSize.equals(SectionExporter.defaultProps.pageSize) ||
-            props.landscape != SectionExporter.defaultProps.landscape;
-    }
     exportSectionMargins(props) {
         this.writer.writeWpStartElement('pgMar');
         this.writer.writeWpIntAttr('left', props.marginLeft);
@@ -90299,6 +90333,7 @@ class EffectExtent {
 
 
 
+
 class TableExporter extends BaseExporter {
     constructor() {
         super(...arguments);
@@ -90328,10 +90363,9 @@ class TableExporter extends BaseExporter {
         }
     }
     getTableGrid(table) {
-        if (table.rows[0].logicColumnCount < 64)
-            return [];
-        const colGrid = [];
-        return colGrid;
+        var _a, _b;
+        const grid = this.data.grids.get(table);
+        return ((_b = (_a = grid === null || grid === void 0 ? void 0 : grid.columns) === null || _a === void 0 ? void 0 : _a.width) === null || _b === void 0 ? void 0 : _b.map(unit_converter/* UnitConverter */.u.pixelsToTwips)) || [];
     }
     initNewTables(newIndexes, allowInitNextTable) {
         for (let levelIndex = this.tableIndexes.length; levelIndex < newIndexes.length; levelIndex++) {
@@ -90836,11 +90870,12 @@ class IdGenerator {
 
 
 class data_Data {
-    constructor(model, options) {
+    constructor(exportModelOptions, options) {
         this.drawingElementId = 1;
         this.exportSubDocumentsList = [];
         this.relationExporters = [];
-        this.model = model;
+        this.model = exportModelOptions.modelManager.model;
+        this.grids = exportModelOptions.grids;
         this.options = options;
         this.constants = new DocxConstants();
         this.writerStack = new stack/* Stack */.K();
@@ -91629,10 +91664,10 @@ class EndNoteExporter extends NoteExporter {
 
 
 class DocxExporter {
-    constructor(modelManipulator, options) {
-        this.modelManipulator = modelManipulator;
+    constructor(exportModelOptions, options) {
+        this.modelManipulator = exportModelOptions.modelManager.modelManipulator;
         this.options = options;
-        this.data = new data_Data(modelManipulator.model, options);
+        this.data = new data_Data(exportModelOptions, options);
     }
     exportToBlob(callback) {
         this.modelManipulator.picture.loader.ensureAllPicturesLoaded(this.options.ensurePictureLoadedTimeout, (_loaded) => {
@@ -91739,8 +91774,8 @@ function exportModelToBlob(exportModelOptions, callback) {
 function getExporter(exportModelOptions) {
     const { modelManipulator } = exportModelOptions.modelManager;
     switch (exportModelOptions.documentFormat) {
-        case DocumentFormat.OpenXml: return new DocxExporter(modelManipulator, new DocxExportOptions());
-        case DocumentFormat.Rtf: return new RtfExporter(modelManipulator, new RtfDocumentExporterOptions());
+        case DocumentFormat.OpenXml: return new DocxExporter(exportModelOptions, new DocxExportOptions());
+        case DocumentFormat.Rtf: return new RtfExporter(exportModelOptions, new RtfDocumentExporterOptions());
         case DocumentFormat.PlainText: return new TxtExporter(modelManipulator, new DocumentExporterOptions());
         case DocumentFormat.Html: return new HtmlDocumentExporter(exportModelOptions, new DocumentExporterOptions());
         default:
@@ -92251,7 +92286,7 @@ class AnchorObjectHorizontalPositionCalculator extends AnchorObjectPositionCalcu
     alignment(type, alignment) {
         switch (type) {
             case AnchorObjectHorizontalPositionType.Character:
-                return this.getAlignPosition(alignment, 0);
+                return this.getAnchorXPosition() + this.getAlignPosition(alignment, 0);
             case AnchorObjectHorizontalPositionType.Column:
                 return this.isRelativeCell ?
                     this.relativeColumnPos() + this.lp.row.tableCellInfo.x +
@@ -92300,17 +92335,8 @@ class AnchorObjectHorizontalPositionCalculator extends AnchorObjectPositionCalcu
                 return this.isRelativeCell ? this.relativeColumnPos() + this.lp.row.tableCellInfo.x : 0;
             case AnchorObjectHorizontalPositionType.Column:
                 return this.isRelativeCell ? this.relativeColumnPos() + this.lp.row.tableCellInfo.x + this.leftCellMargin : this.relativeColumnPos();
-            case AnchorObjectHorizontalPositionType.Character: {
-                const rowAbsPos = this.lp.getLogPosition(DocumentLayoutDetailsLevel.Row);
-                const ancBoxAbsPos = this.obj.rowOffset;
-                const boxIndex = search.SearchUtils.normedInterpolationIndexOf(this.lp.row.boxes, (box) => rowAbsPos + box.rowOffset, ancBoxAbsPos);
-                const box = this.lp.row.boxes[boxIndex];
-                if (!box)
-                    return this.lp.getLayoutX(null, DocumentLayoutDetailsLevel.Row);
-                const symbolCount = Math.max(0, ancBoxAbsPos - rowAbsPos - box.rowOffset);
-                return this.lp.getLayoutX(null, DocumentLayoutDetailsLevel.Row) + box.x +
-                    box.getCharOffsetXInPixels(this.manager.measurer, symbolCount);
-            }
+            case AnchorObjectHorizontalPositionType.Character:
+                return this.getAnchorXPosition();
             case AnchorObjectHorizontalPositionType.Margin:
                 return this.isRelativeCell ? this.relativeColumnPos() + this.lp.row.tableCellInfo.x + this.leftCellMargin :
                     this.manager.boundsCalculator.marginLeft;
@@ -92327,6 +92353,19 @@ class AnchorObjectHorizontalPositionCalculator extends AnchorObjectPositionCalcu
                 throw new Error(errors/* Errors */.D.InternalException);
         }
     }
+    getAnchorXPosition() {
+        const rowAbsPos = this.lp.getLogPosition(DocumentLayoutDetailsLevel.Row);
+        const ancBoxAbsPos = this.obj.rowOffset;
+        let boxIndex = search.SearchUtils.normedInterpolationIndexOf(this.lp.row.boxes, (box) => rowAbsPos + box.rowOffset, ancBoxAbsPos);
+        if (boxIndex < 0)
+            boxIndex = 0;
+        const box = this.lp.row.boxes[boxIndex];
+        if (!box)
+            return this.lp.getLayoutX(null, DocumentLayoutDetailsLevel.Row);
+        const symbolCount = Math.max(0, ancBoxAbsPos - rowAbsPos - box.rowOffset);
+        return this.lp.getLayoutX(null, DocumentLayoutDetailsLevel.Row) + box.x +
+            box.getCharOffsetXInPixels(this.manager.measurer, symbolCount);
+    }
     bookLayout() {
         return this.alignment(this.anchorInfo.horizontalPositionType, AnchorObjectHorizontalPositionCalculator.mapBookLayoutALignmentType[this.anchorInfo.horizontalPositionAlignment]);
     }
@@ -92557,6 +92596,12 @@ class LayoutPageArea extends rectangle.Rectangle {
         this.columns = [];
         this.subDocument = subDocument;
     }
+    get grids() {
+        return this.columns.reduce((res, column) => {
+            column.tablesInfo.forEach(tableInfo => res.set(tableInfo.logicInfo.grid.table, tableInfo.logicInfo.grid));
+            return res;
+        }, new Map());
+    }
     getEndPosition() {
         return this.pageOffset + utils_list.ListUtils.last(this.columns).getEndPosition();
     }
@@ -92577,7 +92622,6 @@ class LayoutPageArea extends rectangle.Rectangle {
 
 
 
-
 var LayoutRowStateFlags;
 (function (LayoutRowStateFlags) {
     LayoutRowStateFlags[LayoutRowStateFlags["NormallyEnd"] = 0] = "NormallyEnd";
@@ -92704,7 +92748,7 @@ class layout_row_LayoutRow extends rectangle.Rectangle {
         return lastBoxIndexWhatCanStrikeoutAndUnderline;
     }
     containsSpacesOnly() {
-        return this.boxes.length > 0 && utils_list.ListUtils.allOf(this.boxes, val => val.isWhitespace() || val.getType() === LayoutBoxType.ParagraphMark);
+        return this.boxes.length > 0 && utils_list.ListUtils.allOf(this.boxes, val => val.isWhitespace());
     }
 }
 class LayoutRowWithIndex extends (/* unused pure expression or super */ null && (layout_row_LayoutRow)) {
@@ -94799,10 +94843,10 @@ class RowFormattingInfo {
         const ind = utils_list.ListUtils.indexBy(this.intervals, (curr) => curr.start > pos || pos < curr.end, this.currIndex + 1);
         return ind < 0 ? this.intervals.length - 1 : ind;
     }
-    calculate() {
+    calculate(outerHorizontalRowContentBounds) {
         this.setIntersectObjects();
         this.busyIntervals = algorithms.IntervalAlgorithms.getMergedIntervals(utils_list.ListUtils.map(this.intersectsObjects, (objBnds) => new fixed.FixedInterval(objBnds.x, objBnds.width)), true);
-        const freeIntervals = algorithms.IntervalAlgorithms.reflectIntervals(this.busyIntervals, this.outerHorizontalRowContentBounds);
+        const freeIntervals = this.calculateFreeIntervals(this.busyIntervals, outerHorizontalRowContentBounds !== null && outerHorizontalRowContentBounds !== void 0 ? outerHorizontalRowContentBounds : this.outerHorizontalRowContentBounds);
         if (freeIntervals.length) {
             this.intervals = utils_list.ListUtils.map(freeIntervals, (curr) => new RowIntervalInfo(curr.start, curr.length));
             return;
@@ -94810,6 +94854,40 @@ class RowFormattingInfo {
         this.resetMinY(utils_list.ListUtils.min);
         Log.print(LogSource.RowFormatter, "RowFormattingInfo.calculate ", `minY:${this.minY}, height:${this.height}, currIndex: ${this.currIndex} intervals:\n${Log.join("\n", utils_list.ListUtils.map(this.intervals, (curr) => LogObjToStr.fixedInterval(curr)))}`);
     }
+    calculateFreeIntervals(busyIntervals, outerHorizontalRowContentBounds) {
+        const intervals = utils_list.ListUtils.reducedMap(busyIntervals, val => algorithms.IntervalAlgorithms.getIntersectionNonNullLength(val, outerHorizontalRowContentBounds));
+        if (!intervals.length)
+            return [outerHorizontalRowContentBounds.clone()];
+        const lastIntervalEnd = utils_list.ListUtils.last(intervals).end;
+        const result = utils_list.ListUtils.reducedMap(intervals, (curr, i) => fixed.FixedInterval.fromPositions(busyIntervals[i - 1].end, curr.start), 1);
+        if (outerHorizontalRowContentBounds.start < busyIntervals[0].start)
+            result.unshift(fixed.FixedInterval.fromPositions(outerHorizontalRowContentBounds.start, busyIntervals[0].start));
+        if (outerHorizontalRowContentBounds.end > lastIntervalEnd)
+            result.push(fixed.FixedInterval.fromPositions(lastIntervalEnd, outerHorizontalRowContentBounds.end));
+        return result;
+    }
+    recalculate(outerHorizontalRowContentBounds) {
+        const currInterval = this.currInterval;
+        this.calculate(outerHorizontalRowContentBounds);
+        const pos = currInterval.start + currInterval.busyWidth;
+        const index = this.findIntervalIndexByPosition(pos);
+        const interval = this.intervals[index];
+        if (interval && interval.start < pos) {
+            const avaliableWidth = interval.length - (pos - interval.start);
+            interval.avaliableWidth = avaliableWidth;
+        }
+        this.currIndex = index;
+    }
+    findIntervalIndexByPosition(position) {
+        let index = 0;
+        while (index < this.intervals.length) {
+            const interval = this.intervals[index];
+            if (interval.start <= position && position < interval.end || position < interval.start)
+                break;
+            index++;
+        }
+        return index;
+    }
     canIncrementHeightTo(newHeight) {
         const contentBounds = utils_list.ListUtils.map(this.intervals, (c) => new rectangle.Rectangle(c.start, this.minY, c.busyWidth, newHeight));
         const intersectedObjects = this.calcIntersectObjects(newHeight);
@@ -95400,8 +95478,6 @@ class RowBaseFormatterState {
             this.rowFormatter.finishRow();
     }
     addAnchorObject() {
-        if (!this.rowFormatter.wordHolder.pushBoxes())
-            return;
         this.rowFormatter.addAnchorObject();
     }
     addTextBox() {
@@ -95525,7 +95601,7 @@ class RowTabInfo {
             const tab = this.tabPositions[ind];
             const oldTabPos = tab ? tab.position : Number.MAX_VALUE;
             if (oldTabPos != pos)
-                this.tabPositions.splice(pos > oldTabPos ? ind + 1 : ind, 0, new TabInfo(pos, TabAlign.Left, TabLeaderType.None, false, false));
+                this.tabPositions.splice(pos > oldTabPos ? ind + 1 : ind, 0, new TabInfo(pos, TabAlign.Left, TabLeaderType.None, false, false, true));
         }
         for (let pos of this.tabPositions)
             pos.position += this.paragraphHorizontalBoundsStart;
@@ -95579,9 +95655,10 @@ class RowTabInfo {
         const lastInterval = utils_list.ListUtils.last(this.rowFormatter.rowSizesManager.rowFormattingInfo.intervals);
         if (tabXPosRelativePage > lastInterval.end) {
             if (lastInterval.end < this.rowFormatter.paragraphHorizontalBounds.end) {
-                if (this.rowFormatter.manager.model.compatibilitySettings.compatibilityMode < CompatibilityMode.Word2013 && tabPosition !== null) {
-                    this.currInterval.avaliableWidth = Number.MAX_SAFE_INTEGER - this.currInterval.busyWidth;
-                    this.currInterval.length = Number.MAX_SAFE_INTEGER;
+                if (this.rowFormatter.manager.model.compatibilitySettings.compatibilityMode < CompatibilityMode.Word2013 && tabPosition && !tabPosition.isParagraphIndent) {
+                    const interval = this.rowFormatter.rowSizesManager.rowFormattingInfo.outerHorizontalRowContentBounds;
+                    interval.length = Number.MAX_SAFE_INTEGER - interval.start;
+                    this.rowFormatter.rowSizesManager.rowFormattingInfo.recalculate(interval);
                     this.row.width = Number.MAX_SAFE_INTEGER;
                     this.row.flags.set(LayoutRowStateFlags.InfinityWidth, true);
                     return this.addTabBox();
@@ -97943,25 +98020,9 @@ class table_info_TableInfo {
             tableIndent.value = 0;
         }
         const tableIndentInPixels = tableIndent.asNumberNoPercentType(unit_converter/* UnitConverter */.u.twipsToPixels);
-        this.xPositionStart = xPosition + tableIndentInPixels + (diff.xDiff ? diff.xDiff : -firstCellLeftMargin) +
-            this.getShiftHorizontalPosition(xPosition);
+        this.xPositionStart = xPosition + tableIndentInPixels + (diff.xDiff ? diff.xDiff : -firstCellLeftMargin);
         this.yPositionStart = yOffset + diff.yDiff;
     }
-    getShiftHorizontalPosition(xPosition) {
-        const freeSpaceFromTable = this.columnWidth - this.grid.commonWidth;
-        if (freeSpaceFromTable >= 0)
-            return 0;
-        const tableAlignment = this.table.getActualTableAlignment();
-        if (tableAlignment == TableRowAlignment.Center) {
-            let result = freeSpaceFromTable / 2 - xPosition;
-            if (result < 0 && this.isSimpleView)
-                result = 0;
-            return result;
-        }
-        else if (tableAlignment == TableRowAlignment.Right)
-            return freeSpaceFromTable - xPosition;
-        return 0;
-    }
     static getEstimatedTableWidth(table, maxWidth) {
         const preferredWidth = table.preferredWidth;
         const minWidth = 3 * table.rows[0].getTotalCellsInRowConsiderGrid();
@@ -98044,6 +98105,12 @@ class LayoutTableSizeCompressor {
             LayoutTableSizeCompressor.cellCompress(cell, cell.createRectangle());
     }
     static tableCompress(tableInfo, boundsRelativeColumn) {
+        const intersection = rectangle.Rectangle.getIntersection(tableInfo, boundsRelativeColumn);
+        const headOffset = intersection.x - tableInfo.x;
+        if (headOffset > 0) {
+            tableInfo.verticalBorders.forEach(b => b.xPos -= headOffset);
+            tableInfo.verticalCursorBorders.forEach(b => b.xPos -= headOffset);
+        }
         LayoutTableSizeCompressor.compress(tableInfo, boundsRelativeColumn, true, false);
         const boundsRelativeTable = tableInfo.clone().moveRectangle(-tableInfo.x, -tableInfo.y);
         for (let row of tableInfo.tableRows)
@@ -98112,8 +98179,9 @@ class LayoutTableSizeCompressor {
         }
         border.length = Math.min(border.yPos + border.length, bounds.bottom) - border.yPos;
         if (border.xPos < bounds.x)
-            return true;
-        border.xPos = bounds.right;
+            border.xPos = bounds.x;
+        else
+            border.xPos = bounds.right;
         border.borderInfo.width = 0;
         return false;
     }
@@ -113285,13 +113353,9 @@ class RulerControl extends RulerBase {
     }
     adjust() {
         const viewWidth = this.controls.canvas.clientWidth;
-        if (viewWidth > this.controls.ruler.pageWidth)
-            this.initialMarginLeftElement = (viewWidth - this.pageWidth - RULLER_NUMBER_CORRECTION * 2) / 2;
-        else {
-            const paddingLeft = dom.DomUtils.pxToInt(dom.DomUtils.getCurrentStyle(this.controls.canvas).paddingLeft);
-            const pageAreaBorderWidth = (this.controls.canvas.scrollWidth - paddingLeft - this.pageWidth) / 2;
-            this.initialMarginLeftElement = paddingLeft + pageAreaBorderWidth - RULLER_NUMBER_CORRECTION;
-        }
+        const paddingLeft = dom.DomUtils.pxToInt(dom.DomUtils.getCurrentStyle(this.controls.canvas).paddingLeft);
+        const minValue = paddingLeft - RULLER_NUMBER_CORRECTION;
+        this.initialMarginLeftElement = Math.max((viewWidth - this.pageWidth - RULLER_NUMBER_CORRECTION * 2) / 2, minValue);
         this.rootElement.style.left = this.calculateLeftOffset();
         this.setPaddings();
         this.canHandleScroll = this.controls.canvas.scrollWidth > this.controls.canvas.offsetWidth;
@@ -115559,6 +115623,7 @@ class RichEditCore {
             pictureRenderer: this.viewManager.renderer,
             uiUnitConverter: this.uiUnitConverter,
             lastMaxNumPages: this.layout.lastMaxNumPages,
+            grids: this.layout.grids,
             pageIndex: this.selection.pageIndex,
             sessionGuid: this.sessionGuid,
             clientGuid: this.clientGuid,
@@ -122303,6 +122368,7 @@ function createInnerItems(items) {
 }
 
 ;// CONCATENATED MODULE: ./src/client/utils/focus-helper.ts
+var focus_helper_a;
 class FocusHelper {
     static preventFocusOnClick(element) {
         return new FocusBlocker(element);
@@ -122315,23 +122381,24 @@ class FocusBlocker {
         this.addEventListeners(target);
     }
     addEventListeners(element) {
-        element.addEventListener("pointerdown", this.onPointerDownBinded);
+        element.addEventListener("mousedown", this.onPointerDownBinded);
     }
     removeEventListeners(element) {
-        element.removeEventListener("pointerdown", this.onPointerDownBinded);
+        element.removeEventListener("mousedown", this.onPointerDownBinded);
     }
     onPointerDown(event) {
         for (const element of event.composedPath()) {
-            if (!(element instanceof HTMLElement))
-                continue;
             if (element === this.target) {
                 event.preventDefault();
                 break;
             }
-            if (!this.target.contains(element) || element.tabIndex > -1)
+            if (element instanceof Element && this.isFocusableElement(element))
                 break;
         }
     }
+    isFocusableElement(element) {
+        return element.matches(FocusBlocker.focusableSelector);
+    }
     dispose() {
         if (this.target) {
             this.removeEventListeners(this.target);
@@ -122339,6 +122406,21 @@ class FocusBlocker {
         }
     }
 }
+focus_helper_a = FocusBlocker;
+FocusBlocker.focusableSelectors = [
+    'a[href]',
+    'area[href]',
+    'input',
+    'select',
+    'textarea',
+    'button',
+    'iframe',
+    'object',
+    'embed',
+    '[tabindex]:not([tabindex="-1"])',
+    '[contenteditable]:not([contenteditable="false"])'
+];
+FocusBlocker.focusableSelector = focus_helper_a.focusableSelectors.join(',');
 
 ;// CONCATENATED MODULE: ./src/client/bars/ribbon.ts
 
@@ -129396,7 +129478,7 @@ class ApplyStyleCommand extends CommandBase {
                 paragraphStyle = StylesManager.getPresetParagraphStyleByName(styleName).clone();
                 isPresetStyle = true;
             }
-            this.applyParagraphStyle(subDocumentInterval, paragraphStyle, isPresetStyle, parameter.keepDirectFormatting);
+            this.applyParagraphStyle(subDocumentInterval, paragraphStyle, isPresetStyle, parameter.keepCustomFormatting);
         }
         else if (!StylesManager.isParagraphStyle(parameter.styleName) && state.characterStyleChangeEnabled) {
             const styleName = StylesManager.getStyleNameWithoutPrefix(parameter.styleName);
@@ -129431,7 +129513,7 @@ class ApplyStyleCommand extends CommandBase {
             this.modelManipulator.style.applyCharacterStyle(subDocumentInterval, characterStyle, false);
         }
     }
-    applyParagraphStyle(subDocumentInterval, style, isPresetStyle, keepDirectFormatting = false) {
+    applyParagraphStyle(subDocumentInterval, style, isPresetStyle, keepCustomFormatting = false) {
         const count = this.calculateAffectedParagraphCount(subDocumentInterval);
         if (count > 0 && ControlOptions.isEnabled(this.control.modelManager.richOptions.control.paragraphStyle)) {
             const { interval, subDocument } = subDocumentInterval;
@@ -129444,8 +129526,7 @@ class ApplyStyleCommand extends CommandBase {
                 style = isPresetStyle ? modelManipulator.model.stylesManager.addParagraphStyle(style) : style;
                 this.history.addAndRedo(new ApplyParagraphStyleHistoryItem(modelManipulator, paragraphSubDocumentInterval, style));
                 this.history.addAndRedo(new ParagraphUseValueHistoryItem(modelManipulator, paragraphSubDocumentInterval, 0));
-                if (!keepDirectFormatting)
-                    this.history.addAndRedo(new FontUseValueHistoryItem(modelManipulator, paragraphSubDocumentInterval, 0));
+                this.history.addAndRedo(new FontUseValueHistoryItem(modelManipulator, paragraphSubDocumentInterval, 0, keepCustomFormatting));
                 this.history.addAndRedo(new AddParagraphToListHistoryItem(modelManipulator, subDocument, paragraphIndex, NumberingList.NumberingListNotSettedIndex, -1));
             }
         }
@@ -135980,7 +136061,7 @@ class SetParagraphLevelCommandBase extends CommandBase {
         if (!paragraphStyle)
             paragraphStyle = StylesManager.getPresetParagraphStyleByName(styleName);
         if (paragraphStyle) {
-            const commandOptions = new CommandSimpleOptions(this.control, { styleName: StylesManager.paragraphPrefix + styleName, keepDirectFormatting: true });
+            const commandOptions = new CommandSimpleOptions(this.control, { styleName: StylesManager.paragraphPrefix + styleName, keepCustomFormatting: true });
             this.commandManager.getCommand(RichEditClientCommand.ChangeStyle).execute(this.commandManager.isPublicApiCall, commandOptions);
         }
         else {
@@ -136904,7 +136985,8 @@ class MailMergeCommand extends CommandBase {
         return true;
     }
     executeCore(_state, options) {
-        const docxExporter = new DocxExporter(this.control.modelManager.modelManipulator, new DocxExportOptions());
+        const exportModelOptions = this.control.getExportModelOptions();
+        const docxExporter = new DocxExporter(exportModelOptions, new DocxExportOptions());
         docxExporter.exportToBlob((blob) => {
             const docxImporter = new Importer(new ImporterOptions());
             docxImporter.importFromFile(blob, this.control.modelManager.richOptions, (documentModel, formatImagesImporter) => {
@@ -141673,7 +141755,7 @@ class ClientRichEdit {
         this.contextMenuSettings = settings.contextMenuSettings;
         this.fullScreenHelper = new FullScreenHelper(element);
         if (true)
-            external_DevExpress_config_default()(JSON.parse(atob('eyJsaWNlbnNlS2V5IjoiZXdvZ0lDSm1iM0p0WVhRaU9pQXhMQW9nSUNKcGJuUmxjbTVoYkZWellXZGxTV1FpT2lBaVRXOVZka0ZEZWsxcVRsTmFiMjEyTmpsYVRGbHBlQ0lLZlE9PS5WN0NsMFNmUGxxMmpzWklzVVRDYSt3bUJ5VTRwazl1OFk1OVNMUEJWdWVRL2lrZWRHd3ljZDMrakpRejZ1cG9Sa3lPTGNuOEJJSitqa3MycGkyaHhyZjBRNkJoUW5zbjdZMDF5OXY5MWpWeDVVTW5XZWZaUlR6bWllK1M4TGl5OTVoUjJIQT09In0=')));
+            external_DevExpress_config_default()(JSON.parse(atob('eyJsaWNlbnNlS2V5IjoiZXdvZ0lDSm1iM0p0WVhRaU9pQXhMQW9nSUNKcGJuUmxjbTVoYkZWellXZGxTV1FpT2lBaVREZzBkbWxZYUZOS1MyWnRRams0U0VOTVkxTTRNaUlLZlE9PS53SkN1UVJhY3dIaU9DMEdWZFBPVlNacDJsRThrcTdTbUZTTWpIMXgvamxEMnowbzQvYWFkVm9zK1g2ZzlwSDZaYjdUUXdOdlZvQkduRUNwblB2M0ZaOUV4eWlkK3pybUxITE8yZnIyVzFTOEJOWE1YaE1mSlNPdjJ3aCs5SDBSd2lMejJxUT09In0=')));
         this.prepareElement(element, settings);
         this.initDefaultFontsAndStyles();
         this.initBars(settings.ribbon, settings.fonts);